Serenity Operating System
1/*
2 * Copyright (c) 2021, Tim Flynn <trflynn89@serenityos.org>
3 * Copyright (c) 2021, Jan de Visser <jan@de-visser.net>
4 * Copyright (c) 2021, Mahmoud Mandour <ma.mandourr@gmail.com>
5 *
6 * SPDX-License-Identifier: BSD-2-Clause
7 */
8
9#include <LibTest/TestCase.h>
10
11#include <AK/DeprecatedString.h>
12#include <AK/Optional.h>
13#include <AK/Result.h>
14#include <AK/StringView.h>
15#include <AK/TypeCasts.h>
16#include <AK/Vector.h>
17#include <LibSQL/AST/Lexer.h>
18#include <LibSQL/AST/Parser.h>
19
20namespace {
21
22using ParseResult = AK::Result<NonnullRefPtr<SQL::AST::Statement>, DeprecatedString>;
23
24ParseResult parse(StringView sql)
25{
26 auto parser = SQL::AST::Parser(SQL::AST::Lexer(sql));
27 auto statement = parser.next_statement();
28
29 if (parser.has_errors()) {
30 return parser.errors()[0].to_deprecated_string();
31 }
32
33 return statement;
34}
35
36}
37
38TEST_CASE(create_table)
39{
40 EXPECT(parse("CREATE TABLE"sv).is_error());
41 EXPECT(parse("CREATE TABLE test"sv).is_error());
42 EXPECT(parse("CREATE TABLE test ()"sv).is_error());
43 EXPECT(parse("CREATE TABLE test ();"sv).is_error());
44 EXPECT(parse("CREATE TABLE test ( column1 "sv).is_error());
45 EXPECT(parse("CREATE TABLE test ( column1 )"sv).is_error());
46 EXPECT(parse("CREATE TABLE IF test ( column1 );"sv).is_error());
47 EXPECT(parse("CREATE TABLE IF NOT test ( column1 );"sv).is_error());
48 EXPECT(parse("CREATE TABLE AS;"sv).is_error());
49 EXPECT(parse("CREATE TABLE AS SELECT;"sv).is_error());
50 EXPECT(parse("CREATE TABLE test ( column1 varchar()"sv).is_error());
51 EXPECT(parse("CREATE TABLE test ( column1 varchar(abc)"sv).is_error());
52 EXPECT(parse("CREATE TABLE test ( column1 varchar(123 )"sv).is_error());
53 EXPECT(parse("CREATE TABLE test ( column1 varchar(123, )"sv).is_error());
54 EXPECT(parse("CREATE TABLE test ( column1 varchar(123, ) )"sv).is_error());
55 EXPECT(parse("CREATE TABLE test ( column1 varchar(.) )"sv).is_error());
56 EXPECT(parse("CREATE TABLE test ( column1 varchar(.abc) )"sv).is_error());
57 EXPECT(parse("CREATE TABLE test ( column1 varchar(0x) )"sv).is_error());
58 EXPECT(parse("CREATE TABLE test ( column1 varchar(0xzzz) )"sv).is_error());
59 EXPECT(parse("CREATE TABLE test ( column1 int ) AS SELECT * FROM table_name;"sv).is_error());
60 EXPECT(parse("CREATE TABLE test AS SELECT * FROM table_name ( column1 int ) ;"sv).is_error());
61
62 struct Column {
63 StringView name;
64 StringView type;
65 Vector<double> signed_numbers {};
66 };
67
68 auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, Vector<Column> expected_columns, bool expected_is_temporary = false, bool expected_is_error_if_table_exists = true) {
69 auto result = parse(sql);
70 if (result.is_error())
71 outln("{}: {}", sql, result.error());
72 EXPECT(!result.is_error());
73
74 auto statement = result.release_value();
75 EXPECT(is<SQL::AST::CreateTable>(*statement));
76
77 const auto& table = static_cast<const SQL::AST::CreateTable&>(*statement);
78 EXPECT_EQ(table.schema_name(), expected_schema);
79 EXPECT_EQ(table.table_name(), expected_table);
80 EXPECT_EQ(table.is_temporary(), expected_is_temporary);
81 EXPECT_EQ(table.is_error_if_table_exists(), expected_is_error_if_table_exists);
82
83 bool expect_select_statement = expected_columns.is_empty();
84 EXPECT_EQ(table.has_selection(), expect_select_statement);
85 EXPECT_EQ(table.has_columns(), !expect_select_statement);
86
87 const auto& select_statement = table.select_statement();
88 EXPECT_EQ(select_statement.is_null(), !expect_select_statement);
89
90 const auto& columns = table.columns();
91 EXPECT_EQ(columns.size(), expected_columns.size());
92
93 for (size_t i = 0; i < columns.size(); ++i) {
94 const auto& column = columns[i];
95 const auto& expected_column = expected_columns[i];
96 EXPECT_EQ(column->name(), expected_column.name);
97
98 const auto& type_name = column->type_name();
99 EXPECT_EQ(type_name->name(), expected_column.type);
100
101 const auto& signed_numbers = type_name->signed_numbers();
102 EXPECT_EQ(signed_numbers.size(), expected_column.signed_numbers.size());
103
104 for (size_t j = 0; j < signed_numbers.size(); ++j) {
105 double signed_number = signed_numbers[j]->value();
106 double expected_signed_number = expected_column.signed_numbers[j];
107 EXPECT_EQ(signed_number, expected_signed_number);
108 }
109 }
110 };
111
112 validate("CREATE TABLE test ( column1 );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } });
113 validate("Create Table test ( column1 );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } });
114 validate(R"(CREATE TABLE "test" ( "column1" );)"sv, {}, "test"sv, { { "column1"sv, "BLOB"sv } });
115 validate(R"(CREATE TABLE "te""st" ( "co""lumn1" );)"sv, {}, "te\"st"sv, { { "co\"lumn1"sv, "BLOB"sv } });
116 validate("CREATE TABLE schema_name.test ( column1 );"sv, "SCHEMA_NAME"sv, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } });
117 validate("CREATE TABLE \"schema\".test ( column1 );"sv, "schema"sv, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } });
118 validate("CREATE TEMP TABLE test ( column1 );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } }, true, true);
119 validate("CREATE TEMPORARY TABLE test ( column1 );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } }, true, true);
120 validate("CREATE TABLE IF NOT EXISTS test ( column1 );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "BLOB"sv } }, false, false);
121
122 validate("CREATE TABLE test AS SELECT * FROM table_name;"sv, {}, "TEST"sv, {});
123
124 validate("CREATE TABLE test ( column1 int );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "INT"sv } });
125 validate("CREATE TABLE test ( column1 varchar );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv } });
126 validate("CREATE TABLE test ( column1 varchar(255) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 255 } } });
127 validate("CREATE TABLE test ( column1 varchar(255, 123) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 255, 123 } } });
128 validate("CREATE TABLE test ( column1 varchar(255, -123) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 255, -123 } } });
129 validate("CREATE TABLE test ( column1 varchar(0xff) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 255 } } });
130 validate("CREATE TABLE test ( column1 varchar(3.14) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 3.14 } } });
131 validate("CREATE TABLE test ( column1 varchar(1e3) );"sv, {}, "TEST"sv, { { "COLUMN1"sv, "VARCHAR"sv, { 1000 } } });
132}
133
134TEST_CASE(alter_table)
135{
136 // This test case only contains common error cases of the AlterTable subclasses.
137 EXPECT(parse("ALTER"sv).is_error());
138 EXPECT(parse("ALTER TABLE"sv).is_error());
139 EXPECT(parse("ALTER TABLE table_name"sv).is_error());
140 EXPECT(parse("ALTER TABLE table_name;"sv).is_error());
141}
142
143TEST_CASE(alter_table_rename_table)
144{
145 EXPECT(parse("ALTER TABLE table_name RENAME"sv).is_error());
146 EXPECT(parse("ALTER TABLE table_name RENAME TO"sv).is_error());
147 EXPECT(parse("ALTER TABLE table_name RENAME TO new_table"sv).is_error());
148
149 auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_new_table) {
150 auto result = parse(sql);
151 EXPECT(!result.is_error());
152
153 auto statement = result.release_value();
154 EXPECT(is<SQL::AST::RenameTable>(*statement));
155
156 const auto& alter = static_cast<const SQL::AST::RenameTable&>(*statement);
157 EXPECT_EQ(alter.schema_name(), expected_schema);
158 EXPECT_EQ(alter.table_name(), expected_table);
159 EXPECT_EQ(alter.new_table_name(), expected_new_table);
160 };
161
162 validate("ALTER TABLE table_name RENAME TO new_table;"sv, {}, "TABLE_NAME"sv, "NEW_TABLE"sv);
163 validate("ALTER TABLE schema_name.table_name RENAME TO new_table;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "NEW_TABLE"sv);
164}
165
166TEST_CASE(alter_table_rename_column)
167{
168 EXPECT(parse("ALTER TABLE table_name RENAME"sv).is_error());
169 EXPECT(parse("ALTER TABLE table_name RENAME COLUMN"sv).is_error());
170 EXPECT(parse("ALTER TABLE table_name RENAME COLUMN column_name"sv).is_error());
171 EXPECT(parse("ALTER TABLE table_name RENAME COLUMN column_name TO"sv).is_error());
172 EXPECT(parse("ALTER TABLE table_name RENAME COLUMN column_name TO new_column"sv).is_error());
173 EXPECT(parse("ALTER TABLE table_name RENAME column_name"sv).is_error());
174 EXPECT(parse("ALTER TABLE table_name RENAME column_name TO"sv).is_error());
175 EXPECT(parse("ALTER TABLE table_name RENAME column_name TO new_column"sv).is_error());
176
177 auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column, StringView expected_new_column) {
178 auto result = parse(sql);
179 EXPECT(!result.is_error());
180
181 auto statement = result.release_value();
182 EXPECT(is<SQL::AST::RenameColumn>(*statement));
183
184 const auto& alter = static_cast<const SQL::AST::RenameColumn&>(*statement);
185 EXPECT_EQ(alter.schema_name(), expected_schema);
186 EXPECT_EQ(alter.table_name(), expected_table);
187 EXPECT_EQ(alter.column_name(), expected_column);
188 EXPECT_EQ(alter.new_column_name(), expected_new_column);
189 };
190
191 validate("ALTER TABLE table_name RENAME column_name TO new_column;"sv, {}, "TABLE_NAME"sv, "COLUMN_NAME"sv, "NEW_COLUMN"sv);
192 validate("ALTER TABLE table_name RENAME COLUMN column_name TO new_column;"sv, {}, "TABLE_NAME"sv, "COLUMN_NAME"sv, "NEW_COLUMN"sv);
193 validate("ALTER TABLE schema_name.table_name RENAME column_name TO new_column;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "COLUMN_NAME"sv, "NEW_COLUMN"sv);
194 validate("ALTER TABLE schema_name.table_name RENAME COLUMN column_name TO new_column;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "COLUMN_NAME"sv, "NEW_COLUMN"sv);
195}
196
197TEST_CASE(alter_table_add_column)
198{
199 EXPECT(parse("ALTER TABLE table_name ADD"sv).is_error());
200 EXPECT(parse("ALTER TABLE table_name ADD COLUMN"sv).is_error());
201 EXPECT(parse("ALTER TABLE table_name ADD COLUMN column_name"sv).is_error());
202
203 struct Column {
204 StringView name;
205 StringView type;
206 Vector<double> signed_numbers {};
207 };
208
209 auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, Column expected_column) {
210 auto result = parse(sql);
211 EXPECT(!result.is_error());
212
213 auto statement = result.release_value();
214 EXPECT(is<SQL::AST::AddColumn>(*statement));
215
216 const auto& alter = static_cast<const SQL::AST::AddColumn&>(*statement);
217 EXPECT_EQ(alter.schema_name(), expected_schema);
218 EXPECT_EQ(alter.table_name(), expected_table);
219
220 const auto& column = alter.column();
221 EXPECT_EQ(column->name(), expected_column.name);
222
223 const auto& type_name = column->type_name();
224 EXPECT_EQ(type_name->name(), expected_column.type);
225
226 const auto& signed_numbers = type_name->signed_numbers();
227 EXPECT_EQ(signed_numbers.size(), expected_column.signed_numbers.size());
228
229 for (size_t j = 0; j < signed_numbers.size(); ++j) {
230 double signed_number = signed_numbers[j]->value();
231 double expected_signed_number = expected_column.signed_numbers[j];
232 EXPECT_EQ(signed_number, expected_signed_number);
233 }
234 };
235
236 validate("ALTER TABLE test ADD column1;"sv, {}, "TEST"sv, { "COLUMN1"sv, "BLOB"sv });
237 validate("ALTER TABLE test ADD column1 int;"sv, {}, "TEST"sv, { "COLUMN1"sv, "INT"sv });
238 validate("ALTER TABLE test ADD column1 varchar;"sv, {}, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv });
239 validate("ALTER TABLE test ADD column1 varchar(255);"sv, {}, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv, { 255 } });
240 validate("ALTER TABLE test ADD column1 varchar(255, 123);"sv, {}, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv, { 255, 123 } });
241
242 validate("ALTER TABLE schema_name.test ADD COLUMN column1;"sv, "SCHEMA_NAME"sv, "TEST"sv, { "COLUMN1"sv, "BLOB"sv });
243 validate("ALTER TABLE schema_name.test ADD COLUMN column1 int;"sv, "SCHEMA_NAME"sv, "TEST"sv, { "COLUMN1"sv, "INT"sv });
244 validate("ALTER TABLE schema_name.test ADD COLUMN column1 varchar;"sv, "SCHEMA_NAME"sv, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv });
245 validate("ALTER TABLE schema_name.test ADD COLUMN column1 varchar(255);"sv, "SCHEMA_NAME"sv, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv, { 255 } });
246 validate("ALTER TABLE schema_name.test ADD COLUMN column1 varchar(255, 123);"sv, "SCHEMA_NAME"sv, "TEST"sv, { "COLUMN1"sv, "VARCHAR"sv, { 255, 123 } });
247}
248
249TEST_CASE(alter_table_drop_column)
250{
251 EXPECT(parse("ALTER TABLE table_name DROP"sv).is_error());
252 EXPECT(parse("ALTER TABLE table_name DROP COLUMN"sv).is_error());
253 EXPECT(parse("ALTER TABLE table_name DROP column_name"sv).is_error());
254 EXPECT(parse("ALTER TABLE table_name DROP COLUMN column_name"sv).is_error());
255
256 auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column) {
257 auto result = parse(sql);
258 EXPECT(!result.is_error());
259
260 auto statement = result.release_value();
261 EXPECT(is<SQL::AST::DropColumn>(*statement));
262
263 const auto& alter = static_cast<const SQL::AST::DropColumn&>(*statement);
264 EXPECT_EQ(alter.schema_name(), expected_schema);
265 EXPECT_EQ(alter.table_name(), expected_table);
266 EXPECT_EQ(alter.column_name(), expected_column);
267 };
268
269 validate("ALTER TABLE table_name DROP column_name;"sv, {}, "TABLE_NAME"sv, "COLUMN_NAME"sv);
270 validate("ALTER TABLE table_name DROP COLUMN column_name;"sv, {}, "TABLE_NAME"sv, "COLUMN_NAME"sv);
271 validate("ALTER TABLE schema_name.table_name DROP column_name;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "COLUMN_NAME"sv);
272 validate("ALTER TABLE schema_name.table_name DROP COLUMN column_name;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "COLUMN_NAME"sv);
273}
274
275TEST_CASE(drop_table)
276{
277 EXPECT(parse("DROP"sv).is_error());
278 EXPECT(parse("DROP TABLE"sv).is_error());
279 EXPECT(parse("DROP TABLE test"sv).is_error());
280 EXPECT(parse("DROP TABLE IF test;"sv).is_error());
281
282 auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, bool expected_is_error_if_table_does_not_exist = true) {
283 auto result = parse(sql);
284 EXPECT(!result.is_error());
285
286 auto statement = result.release_value();
287 EXPECT(is<SQL::AST::DropTable>(*statement));
288
289 const auto& table = static_cast<const SQL::AST::DropTable&>(*statement);
290 EXPECT_EQ(table.schema_name(), expected_schema);
291 EXPECT_EQ(table.table_name(), expected_table);
292 EXPECT_EQ(table.is_error_if_table_does_not_exist(), expected_is_error_if_table_does_not_exist);
293 };
294
295 validate("DROP TABLE test;"sv, {}, "TEST"sv);
296 validate("DROP TABLE schema_name.test;"sv, "SCHEMA_NAME"sv, "TEST"sv);
297 validate("DROP TABLE IF EXISTS test;"sv, {}, "TEST"sv, false);
298}
299
300TEST_CASE(insert)
301{
302 EXPECT(parse("INSERT"sv).is_error());
303 EXPECT(parse("INSERT INTO"sv).is_error());
304 EXPECT(parse("INSERT INTO table_name"sv).is_error());
305 EXPECT(parse("INSERT INTO table_name (column_name)"sv).is_error());
306 EXPECT(parse("INSERT INTO table_name (column_name, ) DEFAULT VALUES;"sv).is_error());
307 EXPECT(parse("INSERT INTO table_name VALUES"sv).is_error());
308 EXPECT(parse("INSERT INTO table_name VALUES ();"sv).is_error());
309 EXPECT(parse("INSERT INTO table_name VALUES (1)"sv).is_error());
310 EXPECT(parse("INSERT INTO table_name SELECT"sv).is_error());
311 EXPECT(parse("INSERT INTO table_name SELECT * from table_name"sv).is_error());
312 EXPECT(parse("INSERT OR INTO table_name DEFAULT VALUES;"sv).is_error());
313 EXPECT(parse("INSERT OR foo INTO table_name DEFAULT VALUES;"sv).is_error());
314
315 auto validate = [](StringView sql, SQL::AST::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<StringView> expected_column_names, Vector<size_t> expected_chain_sizes, bool expect_select_statement) {
316 auto result = parse(sql);
317 EXPECT(!result.is_error());
318
319 auto statement = result.release_value();
320 EXPECT(is<SQL::AST::Insert>(*statement));
321
322 const auto& insert = static_cast<const SQL::AST::Insert&>(*statement);
323 EXPECT_EQ(insert.conflict_resolution(), expected_conflict_resolution);
324 EXPECT_EQ(insert.schema_name(), expected_schema);
325 EXPECT_EQ(insert.table_name(), expected_table);
326 EXPECT_EQ(insert.alias(), expected_alias);
327
328 const auto& column_names = insert.column_names();
329 EXPECT_EQ(column_names.size(), expected_column_names.size());
330 for (size_t i = 0; i < column_names.size(); ++i)
331 EXPECT_EQ(column_names[i], expected_column_names[i]);
332
333 EXPECT_EQ(insert.has_expressions(), !expected_chain_sizes.is_empty());
334 if (insert.has_expressions()) {
335 const auto& chained_expressions = insert.chained_expressions();
336 EXPECT_EQ(chained_expressions.size(), expected_chain_sizes.size());
337
338 for (size_t i = 0; i < chained_expressions.size(); ++i) {
339 const auto& chained_expression = chained_expressions[i];
340 const auto& expressions = chained_expression->expressions();
341 EXPECT_EQ(expressions.size(), expected_chain_sizes[i]);
342
343 for (const auto& expression : expressions)
344 EXPECT(!is<SQL::AST::ErrorExpression>(expression));
345 }
346 }
347
348 EXPECT_EQ(insert.has_selection(), expect_select_statement);
349 EXPECT_EQ(insert.default_values(), expected_chain_sizes.is_empty() && !expect_select_statement);
350 };
351
352 validate("INSERT OR ABORT INTO table_name DEFAULT VALUES;"sv, SQL::AST::ConflictResolution::Abort, {}, "TABLE_NAME"sv, {}, {}, {}, false);
353 validate("INSERT OR FAIL INTO table_name DEFAULT VALUES;"sv, SQL::AST::ConflictResolution::Fail, {}, "TABLE_NAME"sv, {}, {}, {}, false);
354 validate("INSERT OR IGNORE INTO table_name DEFAULT VALUES;"sv, SQL::AST::ConflictResolution::Ignore, {}, "TABLE_NAME"sv, {}, {}, {}, false);
355 validate("INSERT OR REPLACE INTO table_name DEFAULT VALUES;"sv, SQL::AST::ConflictResolution::Replace, {}, "TABLE_NAME"sv, {}, {}, {}, false);
356 validate("INSERT OR ROLLBACK INTO table_name DEFAULT VALUES;"sv, SQL::AST::ConflictResolution::Rollback, {}, "TABLE_NAME"sv, {}, {}, {}, false);
357
358 auto resolution = SQL::AST::ConflictResolution::Abort;
359 validate("INSERT INTO table_name DEFAULT VALUES;"sv, resolution, {}, "TABLE_NAME"sv, {}, {}, {}, false);
360 validate("INSERT INTO schema_name.table_name DEFAULT VALUES;"sv, resolution, "SCHEMA_NAME"sv, "TABLE_NAME"sv, {}, {}, {}, false);
361 validate("INSERT INTO table_name AS foo DEFAULT VALUES;"sv, resolution, {}, "TABLE_NAME"sv, "FOO"sv, {}, {}, false);
362
363 validate("INSERT INTO table_name (column_name) DEFAULT VALUES;"sv, resolution, {}, "TABLE_NAME"sv, {}, { "COLUMN_NAME"sv }, {}, false);
364 validate("INSERT INTO table_name (column1, column2) DEFAULT VALUES;"sv, resolution, {}, "TABLE_NAME"sv, {}, { "COLUMN1"sv, "COLUMN2"sv }, {}, false);
365
366 validate("INSERT INTO table_name VALUES (1);"sv, resolution, {}, "TABLE_NAME"sv, {}, {}, { 1 }, false);
367 validate("INSERT INTO table_name VALUES (1, 2);"sv, resolution, {}, "TABLE_NAME"sv, {}, {}, { 2 }, false);
368 validate("INSERT INTO table_name VALUES (1, 2), (3, 4, 5);"sv, resolution, {}, "TABLE_NAME"sv, {}, {}, { 2, 3 }, false);
369
370 validate("INSERT INTO table_name SELECT * FROM table_name;"sv, resolution, {}, "TABLE_NAME"sv, {}, {}, {}, true);
371}
372
373TEST_CASE(update)
374{
375 EXPECT(parse("UPDATE"sv).is_error());
376 EXPECT(parse("UPDATE table_name"sv).is_error());
377 EXPECT(parse("UPDATE table_name SET"sv).is_error());
378 EXPECT(parse("UPDATE table_name SET column_name"sv).is_error());
379 EXPECT(parse("UPDATE table_name SET column_name=4"sv).is_error());
380 EXPECT(parse("UPDATE table_name SET column_name=4, ;"sv).is_error());
381 EXPECT(parse("UPDATE table_name SET (column_name)=4"sv).is_error());
382 EXPECT(parse("UPDATE table_name SET (column_name)=4, ;"sv).is_error());
383 EXPECT(parse("UPDATE table_name SET (column_name, )=4;"sv).is_error());
384 EXPECT(parse("UPDATE table_name SET column_name=4 FROM"sv).is_error());
385 EXPECT(parse("UPDATE table_name SET column_name=4 FROM table_name"sv).is_error());
386 EXPECT(parse("UPDATE table_name SET column_name=4 WHERE"sv).is_error());
387 EXPECT(parse("UPDATE table_name SET column_name=4 WHERE 1==1"sv).is_error());
388 EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING"sv).is_error());
389 EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING *"sv).is_error());
390 EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING column_name"sv).is_error());
391 EXPECT(parse("UPDATE table_name SET column_name=4 RETURNING column_name AS"sv).is_error());
392 EXPECT(parse("UPDATE OR table_name SET column_name=4;"sv).is_error());
393 EXPECT(parse("UPDATE OR foo table_name SET column_name=4;"sv).is_error());
394
395 auto validate = [](StringView sql, SQL::AST::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<Vector<DeprecatedString>> expected_update_columns, bool expect_where_clause, bool expect_returning_clause, Vector<StringView> expected_returned_column_aliases) {
396 auto result = parse(sql);
397 EXPECT(!result.is_error());
398
399 auto statement = result.release_value();
400 EXPECT(is<SQL::AST::Update>(*statement));
401
402 const auto& update = static_cast<const SQL::AST::Update&>(*statement);
403 EXPECT_EQ(update.conflict_resolution(), expected_conflict_resolution);
404
405 const auto& qualified_table_name = update.qualified_table_name();
406 EXPECT_EQ(qualified_table_name->schema_name(), expected_schema);
407 EXPECT_EQ(qualified_table_name->table_name(), expected_table);
408 EXPECT_EQ(qualified_table_name->alias(), expected_alias);
409
410 const auto& update_columns = update.update_columns();
411 EXPECT_EQ(update_columns.size(), expected_update_columns.size());
412 for (size_t i = 0; i < update_columns.size(); ++i) {
413 const auto& update_column = update_columns[i];
414 const auto& expected_update_column = expected_update_columns[i];
415 EXPECT_EQ(update_column.column_names.size(), expected_update_column.size());
416 EXPECT(!is<SQL::AST::ErrorExpression>(*update_column.expression));
417
418 for (size_t j = 0; j < update_column.column_names.size(); ++j)
419 EXPECT_EQ(update_column.column_names[j], expected_update_column[j]);
420 }
421
422 const auto& where_clause = update.where_clause();
423 EXPECT_EQ(where_clause.is_null(), !expect_where_clause);
424 if (where_clause)
425 EXPECT(!is<SQL::AST::ErrorExpression>(*where_clause));
426
427 const auto& returning_clause = update.returning_clause();
428 EXPECT_EQ(returning_clause.is_null(), !expect_returning_clause);
429 if (returning_clause) {
430 EXPECT_EQ(returning_clause->columns().size(), expected_returned_column_aliases.size());
431
432 for (size_t i = 0; i < returning_clause->columns().size(); ++i) {
433 const auto& column = returning_clause->columns()[i];
434 const auto& expected_column_alias = expected_returned_column_aliases[i];
435
436 EXPECT(!is<SQL::AST::ErrorExpression>(*column.expression));
437 EXPECT_EQ(column.column_alias, expected_column_alias);
438 }
439 }
440 };
441
442 Vector<Vector<DeprecatedString>> update_columns { { "COLUMN_NAME" } };
443 validate("UPDATE OR ABORT table_name SET column_name=1;"sv, SQL::AST::ConflictResolution::Abort, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
444 validate("UPDATE OR FAIL table_name SET column_name=1;"sv, SQL::AST::ConflictResolution::Fail, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
445 validate("UPDATE OR IGNORE table_name SET column_name=1;"sv, SQL::AST::ConflictResolution::Ignore, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
446 validate("UPDATE OR REPLACE table_name SET column_name=1;"sv, SQL::AST::ConflictResolution::Replace, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
447 validate("UPDATE OR ROLLBACK table_name SET column_name=1;"sv, SQL::AST::ConflictResolution::Rollback, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
448
449 auto resolution = SQL::AST::ConflictResolution::Abort;
450 validate("UPDATE table_name SET column_name=1;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, false, false, {});
451 validate("UPDATE schema_name.table_name SET column_name=1;"sv, resolution, "SCHEMA_NAME"sv, "TABLE_NAME"sv, {}, update_columns, false, false, {});
452 validate("UPDATE table_name AS foo SET column_name=1;"sv, resolution, {}, "TABLE_NAME"sv, "FOO"sv, update_columns, false, false, {});
453
454 validate("UPDATE table_name SET column_name=1;"sv, resolution, {}, "TABLE_NAME"sv, {}, { { "COLUMN_NAME"sv } }, false, false, {});
455 validate("UPDATE table_name SET column1=1, column2=2;"sv, resolution, {}, "TABLE_NAME"sv, {}, { { "COLUMN1"sv }, { "COLUMN2"sv } }, false, false, {});
456 validate("UPDATE table_name SET (column1, column2)=1, column3=2;"sv, resolution, {}, "TABLE_NAME"sv, {}, { { "COLUMN1"sv, "COLUMN2"sv }, { "COLUMN3"sv } }, false, false, {});
457
458 validate("UPDATE table_name SET column_name=1 WHERE 1==1;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, true, false, {});
459
460 validate("UPDATE table_name SET column_name=1 RETURNING *;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, false, true, {});
461 validate("UPDATE table_name SET column_name=1 RETURNING column_name;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, false, true, { {} });
462 validate("UPDATE table_name SET column_name=1 RETURNING column_name AS alias;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, false, true, { "ALIAS"sv });
463 validate("UPDATE table_name SET column_name=1 RETURNING column1 AS alias1, column2 AS alias2;"sv, resolution, {}, "TABLE_NAME"sv, {}, update_columns, false, true, { "ALIAS1"sv, "ALIAS2"sv });
464}
465
466TEST_CASE(delete_)
467{
468 EXPECT(parse("DELETE"sv).is_error());
469 EXPECT(parse("DELETE FROM"sv).is_error());
470 EXPECT(parse("DELETE FROM table_name"sv).is_error());
471 EXPECT(parse("DELETE FROM table_name WHERE"sv).is_error());
472 EXPECT(parse("DELETE FROM table_name WHERE 15"sv).is_error());
473 EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING"sv).is_error());
474 EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING *"sv).is_error());
475 EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING column_name"sv).is_error());
476 EXPECT(parse("DELETE FROM table_name WHERE 15 RETURNING column_name AS;"sv).is_error());
477 EXPECT(parse("DELETE FROM table_name WHERE (');"sv).is_error());
478
479 auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_alias, bool expect_where_clause, bool expect_returning_clause, Vector<StringView> expected_returned_column_aliases) {
480 auto result = parse(sql);
481 EXPECT(!result.is_error());
482
483 auto statement = result.release_value();
484 EXPECT(is<SQL::AST::Delete>(*statement));
485
486 const auto& delete_ = static_cast<const SQL::AST::Delete&>(*statement);
487
488 const auto& qualified_table_name = delete_.qualified_table_name();
489 EXPECT_EQ(qualified_table_name->schema_name(), expected_schema);
490 EXPECT_EQ(qualified_table_name->table_name(), expected_table);
491 EXPECT_EQ(qualified_table_name->alias(), expected_alias);
492
493 const auto& where_clause = delete_.where_clause();
494 EXPECT_EQ(where_clause.is_null(), !expect_where_clause);
495 if (where_clause)
496 EXPECT(!is<SQL::AST::ErrorExpression>(*where_clause));
497
498 const auto& returning_clause = delete_.returning_clause();
499 EXPECT_EQ(returning_clause.is_null(), !expect_returning_clause);
500 if (returning_clause) {
501 EXPECT_EQ(returning_clause->columns().size(), expected_returned_column_aliases.size());
502
503 for (size_t i = 0; i < returning_clause->columns().size(); ++i) {
504 const auto& column = returning_clause->columns()[i];
505 const auto& expected_column_alias = expected_returned_column_aliases[i];
506
507 EXPECT(!is<SQL::AST::ErrorExpression>(*column.expression));
508 EXPECT_EQ(column.column_alias, expected_column_alias);
509 }
510 }
511 };
512
513 validate("DELETE FROM table_name;"sv, {}, "TABLE_NAME"sv, {}, false, false, {});
514 validate("DELETE FROM schema_name.table_name;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, {}, false, false, {});
515 validate("DELETE FROM schema_name.table_name AS alias;"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "ALIAS"sv, false, false, {});
516 validate("DELETE FROM table_name WHERE (1 == 1);"sv, {}, "TABLE_NAME"sv, {}, true, false, {});
517 validate("DELETE FROM table_name RETURNING *;"sv, {}, "TABLE_NAME"sv, {}, false, true, {});
518 validate("DELETE FROM table_name RETURNING column_name;"sv, {}, "TABLE_NAME"sv, {}, false, true, { {} });
519 validate("DELETE FROM table_name RETURNING column_name AS alias;"sv, {}, "TABLE_NAME"sv, {}, false, true, { "ALIAS"sv });
520 validate("DELETE FROM table_name RETURNING column1 AS alias1, column2 AS alias2;"sv, {}, "TABLE_NAME"sv, {}, false, true, { "ALIAS1"sv, "ALIAS2"sv });
521}
522
523TEST_CASE(select)
524{
525 EXPECT(parse("SELECT"sv).is_error());
526 EXPECT(parse("SELECT;"sv).is_error());
527 EXPECT(parse("SELECT DISTINCT;"sv).is_error());
528 EXPECT(parse("SELECT ALL;"sv).is_error());
529 EXPECT(parse("SELECT *"sv).is_error());
530 EXPECT(parse("SELECT * FROM;"sv).is_error());
531 EXPECT(parse("SELECT table_name. FROM table_name;"sv).is_error());
532 EXPECT(parse("SELECT column_name AS FROM table_name;"sv).is_error());
533 EXPECT(parse("SELECT * FROM ("sv).is_error());
534 EXPECT(parse("SELECT * FROM ()"sv).is_error());
535 EXPECT(parse("SELECT * FROM ();"sv).is_error());
536 EXPECT(parse("SELECT * FROM (table_name1)"sv).is_error());
537 EXPECT(parse("SELECT * FROM (table_name1, )"sv).is_error());
538 EXPECT(parse("SELECT * FROM (table_name1, table_name2)"sv).is_error());
539 EXPECT(parse("SELECT * FROM table_name"sv).is_error());
540 EXPECT(parse("SELECT * FROM table_name AS;"sv).is_error());
541 EXPECT(parse("SELECT * FROM table_name WHERE;"sv).is_error());
542 EXPECT(parse("SELECT * FROM table_name WHERE 1 ==1"sv).is_error());
543 EXPECT(parse("SELECT * FROM table_name GROUP;"sv).is_error());
544 EXPECT(parse("SELECT * FROM table_name GROUP BY;"sv).is_error());
545 EXPECT(parse("SELECT * FROM table_name GROUP BY column_name"sv).is_error());
546 EXPECT(parse("SELECT * FROM table_name ORDER:"sv).is_error());
547 EXPECT(parse("SELECT * FROM table_name ORDER BY column_name"sv).is_error());
548 EXPECT(parse("SELECT * FROM table_name ORDER BY column_name COLLATE:"sv).is_error());
549 EXPECT(parse("SELECT * FROM table_name ORDER BY column_name COLLATE collation"sv).is_error());
550 EXPECT(parse("SELECT * FROM table_name ORDER BY column_name NULLS;"sv).is_error());
551 EXPECT(parse("SELECT * FROM table_name ORDER BY column_name NULLS SECOND;"sv).is_error());
552 EXPECT(parse("SELECT * FROM table_name LIMIT;"sv).is_error());
553 EXPECT(parse("SELECT * FROM table_name LIMIT 12"sv).is_error());
554 EXPECT(parse("SELECT * FROM table_name LIMIT 12 OFFSET;"sv).is_error());
555 EXPECT(parse("SELECT * FROM table_name LIMIT 12 OFFSET 15"sv).is_error());
556 EXPECT(parse("SELECT * FROM table_name LIMIT 15, 16;"sv).is_error());
557
558 struct Type {
559 SQL::AST::ResultType type;
560 StringView table_name_or_column_alias {};
561 };
562
563 struct From {
564 StringView schema_name;
565 StringView table_name;
566 StringView table_alias;
567 };
568
569 struct Ordering {
570 DeprecatedString collation_name;
571 SQL::Order order;
572 SQL::Nulls nulls;
573 };
574
575 auto validate = [](StringView sql, Vector<Type> expected_columns, Vector<From> expected_from_list, bool expect_where_clause, size_t expected_group_by_size, bool expect_having_clause, Vector<Ordering> expected_ordering, bool expect_limit_clause, bool expect_offset_clause) {
576 auto result = parse(sql);
577 EXPECT(!result.is_error());
578
579 auto statement = result.release_value();
580 EXPECT(is<SQL::AST::Select>(*statement));
581
582 const auto& select = static_cast<const SQL::AST::Select&>(*statement);
583
584 const auto& result_column_list = select.result_column_list();
585 EXPECT_EQ(result_column_list.size(), expected_columns.size());
586 for (size_t i = 0; i < result_column_list.size(); ++i) {
587 const auto& result_column = result_column_list[i];
588 const auto& expected_column = expected_columns[i];
589 EXPECT_EQ(result_column->type(), expected_column.type);
590
591 switch (result_column->type()) {
592 case SQL::AST::ResultType::All:
593 EXPECT(expected_column.table_name_or_column_alias.is_null());
594 break;
595 case SQL::AST::ResultType::Table:
596 EXPECT_EQ(result_column->table_name(), expected_column.table_name_or_column_alias);
597 break;
598 case SQL::AST::ResultType::Expression:
599 EXPECT_EQ(result_column->column_alias(), expected_column.table_name_or_column_alias);
600 break;
601 }
602 }
603
604 const auto& table_or_subquery_list = select.table_or_subquery_list();
605 EXPECT_EQ(table_or_subquery_list.size(), expected_from_list.size());
606 for (size_t i = 0; i < table_or_subquery_list.size(); ++i) {
607 const auto& result_from = table_or_subquery_list[i];
608 const auto& expected_from = expected_from_list[i];
609 EXPECT_EQ(result_from->schema_name(), expected_from.schema_name);
610 EXPECT_EQ(result_from->table_name(), expected_from.table_name);
611 EXPECT_EQ(result_from->table_alias(), expected_from.table_alias);
612 }
613
614 const auto& where_clause = select.where_clause();
615 EXPECT_EQ(where_clause.is_null(), !expect_where_clause);
616 if (where_clause)
617 EXPECT(!is<SQL::AST::ErrorExpression>(*where_clause));
618
619 const auto& group_by_clause = select.group_by_clause();
620 EXPECT_EQ(group_by_clause.is_null(), (expected_group_by_size == 0));
621 if (group_by_clause) {
622 const auto& group_by_list = group_by_clause->group_by_list();
623 EXPECT_EQ(group_by_list.size(), expected_group_by_size);
624 for (size_t i = 0; i < group_by_list.size(); ++i)
625 EXPECT(!is<SQL::AST::ErrorExpression>(group_by_list[i]));
626
627 const auto& having_clause = group_by_clause->having_clause();
628 EXPECT_EQ(having_clause.is_null(), !expect_having_clause);
629 if (having_clause)
630 EXPECT(!is<SQL::AST::ErrorExpression>(*having_clause));
631 }
632
633 const auto& ordering_term_list = select.ordering_term_list();
634 EXPECT_EQ(ordering_term_list.size(), expected_ordering.size());
635 for (size_t i = 0; i < ordering_term_list.size(); ++i) {
636 const auto& result_order = ordering_term_list[i];
637 const auto& expected_order = expected_ordering[i];
638 EXPECT(!is<SQL::AST::ErrorExpression>(*result_order->expression()));
639 EXPECT_EQ(result_order->collation_name(), expected_order.collation_name);
640 EXPECT_EQ(result_order->order(), expected_order.order);
641 EXPECT_EQ(result_order->nulls(), expected_order.nulls);
642 }
643
644 const auto& limit_clause = select.limit_clause();
645 EXPECT_EQ(limit_clause.is_null(), !expect_limit_clause);
646 if (limit_clause) {
647 const auto& limit_expression = limit_clause->limit_expression();
648 EXPECT(!is<SQL::AST::ErrorExpression>(*limit_expression));
649
650 const auto& offset_expression = limit_clause->offset_expression();
651 EXPECT_EQ(offset_expression.is_null(), !expect_offset_clause);
652 if (offset_expression)
653 EXPECT(!is<SQL::AST::ErrorExpression>(*offset_expression));
654 }
655 };
656
657 Vector<Type> all { { SQL::AST::ResultType::All } };
658 Vector<From> from { { {}, "TABLE_NAME"sv, {} } };
659
660 validate("SELECT * FROM table_name;"sv, { { SQL::AST::ResultType::All } }, from, false, 0, false, {}, false, false);
661 validate("SELECT table_name.* FROM table_name;"sv, { { SQL::AST::ResultType::Table, "TABLE_NAME"sv } }, from, false, 0, false, {}, false, false);
662 validate("SELECT column_name AS alias FROM table_name;"sv, { { SQL::AST::ResultType::Expression, "ALIAS"sv } }, from, false, 0, false, {}, false, false);
663 validate("SELECT table_name.column_name AS alias FROM table_name;"sv, { { SQL::AST::ResultType::Expression, "ALIAS"sv } }, from, false, 0, false, {}, false, false);
664 validate("SELECT schema_name.table_name.column_name AS alias FROM table_name;"sv, { { SQL::AST::ResultType::Expression, "ALIAS"sv } }, from, false, 0, false, {}, false, false);
665 validate("SELECT column_name AS alias, *, table_name.* FROM table_name;"sv, { { SQL::AST::ResultType::Expression, "ALIAS"sv }, { SQL::AST::ResultType::All }, { SQL::AST::ResultType::Table, "TABLE_NAME"sv } }, from, false, 0, false, {}, false, false);
666
667 validate("SELECT * FROM table_name;"sv, all, { { {}, "TABLE_NAME"sv, {} } }, false, 0, false, {}, false, false);
668 validate("SELECT * FROM schema_name.table_name;"sv, all, { { "SCHEMA_NAME"sv, "TABLE_NAME"sv, {} } }, false, 0, false, {}, false, false);
669 validate("SELECT * FROM schema_name.table_name AS alias;"sv, all, { { "SCHEMA_NAME"sv, "TABLE_NAME"sv, "ALIAS"sv } }, false, 0, false, {}, false, false);
670 validate("SELECT * FROM schema_name.table_name AS alias, table_name2, table_name3 AS table_name4;"sv, all, { { "SCHEMA_NAME"sv, "TABLE_NAME"sv, "ALIAS"sv }, { {}, "TABLE_NAME2"sv, {} }, { {}, "TABLE_NAME3"sv, "TABLE_NAME4"sv } }, false, 0, false, {}, false, false);
671
672 validate("SELECT * FROM table_name WHERE column_name IS NOT NULL;"sv, all, from, true, 0, false, {}, false, false);
673
674 validate("SELECT * FROM table_name GROUP BY column_name;"sv, all, from, false, 1, false, {}, false, false);
675 validate("SELECT * FROM table_name GROUP BY column1, column2, column3;"sv, all, from, false, 3, false, {}, false, false);
676 validate("SELECT * FROM table_name GROUP BY column_name HAVING 'abc';"sv, all, from, false, 1, true, {}, false, false);
677
678 validate("SELECT * FROM table_name ORDER BY column_name;"sv, all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
679 validate("SELECT * FROM table_name ORDER BY column_name COLLATE collation;"sv, all, from, false, 0, false, { { "COLLATION"sv, SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
680 validate("SELECT * FROM table_name ORDER BY column_name ASC;"sv, all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
681 validate("SELECT * FROM table_name ORDER BY column_name DESC;"sv, all, from, false, 0, false, { { {}, SQL::Order::Descending, SQL::Nulls::Last } }, false, false);
682 validate("SELECT * FROM table_name ORDER BY column_name ASC NULLS LAST;"sv, all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::Last } }, false, false);
683 validate("SELECT * FROM table_name ORDER BY column_name DESC NULLS FIRST;"sv, all, from, false, 0, false, { { {}, SQL::Order::Descending, SQL::Nulls::First } }, false, false);
684 validate("SELECT * FROM table_name ORDER BY column1, column2 DESC, column3 NULLS LAST;"sv, all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First }, { {}, SQL::Order::Descending, SQL::Nulls::Last }, { {}, SQL::Order::Ascending, SQL::Nulls::Last } }, false, false);
685
686 validate("SELECT * FROM table_name LIMIT 15;"sv, all, from, false, 0, false, {}, true, false);
687 validate("SELECT * FROM table_name LIMIT 15 OFFSET 16;"sv, all, from, false, 0, false, {}, true, true);
688}
689
690TEST_CASE(common_table_expression)
691{
692 EXPECT(parse("WITH"sv).is_error());
693 EXPECT(parse("WITH;"sv).is_error());
694 EXPECT(parse("WITH DELETE FROM table_name;"sv).is_error());
695 EXPECT(parse("WITH table_name DELETE FROM table_name;"sv).is_error());
696 EXPECT(parse("WITH table_name AS DELETE FROM table_name;"sv).is_error());
697 EXPECT(parse("WITH RECURSIVE table_name DELETE FROM table_name;"sv).is_error());
698 EXPECT(parse("WITH RECURSIVE table_name AS DELETE FROM table_name;"sv).is_error());
699
700 // Below are otherwise valid common-table-expressions, but attached to statements which do not allow them.
701 EXPECT(parse("WITH table_name AS (SELECT * AS TABLE) CREATE TABLE test ( column1 );"sv).is_error());
702 EXPECT(parse("WITH table_name AS (SELECT * FROM table_name) DROP TABLE test;"sv).is_error());
703
704 struct SelectedTableList {
705 struct SelectedTable {
706 StringView table_name {};
707 Vector<StringView> column_names {};
708 };
709
710 bool recursive { false };
711 Vector<SelectedTable> selected_tables {};
712 };
713
714 auto validate = [](StringView sql, SelectedTableList expected_selected_tables) {
715 auto result = parse(sql);
716 EXPECT(!result.is_error());
717
718 auto statement = result.release_value();
719 EXPECT(is<SQL::AST::Delete>(*statement));
720
721 const auto& delete_ = static_cast<const SQL::AST::Delete&>(*statement);
722
723 const auto& common_table_expression_list = delete_.common_table_expression_list();
724 EXPECT(!common_table_expression_list.is_null());
725
726 EXPECT_EQ(common_table_expression_list->recursive(), expected_selected_tables.recursive);
727
728 const auto& common_table_expressions = common_table_expression_list->common_table_expressions();
729 EXPECT_EQ(common_table_expressions.size(), expected_selected_tables.selected_tables.size());
730
731 for (size_t i = 0; i < common_table_expressions.size(); ++i) {
732 const auto& common_table_expression = common_table_expressions[i];
733 const auto& expected_common_table_expression = expected_selected_tables.selected_tables[i];
734 EXPECT_EQ(common_table_expression->table_name(), expected_common_table_expression.table_name);
735 EXPECT_EQ(common_table_expression->column_names().size(), expected_common_table_expression.column_names.size());
736
737 for (size_t j = 0; j < common_table_expression->column_names().size(); ++j)
738 EXPECT_EQ(common_table_expression->column_names()[j], expected_common_table_expression.column_names[j]);
739 }
740 };
741
742 validate("WITH table_name AS (SELECT * FROM table_name) DELETE FROM table_name;"sv, { false, { { "TABLE_NAME"sv } } });
743 validate("WITH table_name (column_name) AS (SELECT * FROM table_name) DELETE FROM table_name;"sv, { false, { { "TABLE_NAME"sv, { "COLUMN_NAME"sv } } } });
744 validate("WITH table_name (column1, column2) AS (SELECT * FROM table_name) DELETE FROM table_name;"sv, { false, { { "TABLE_NAME"sv, { "COLUMN1"sv, "COLUMN2"sv } } } });
745 validate("WITH RECURSIVE table_name AS (SELECT * FROM table_name) DELETE FROM table_name;"sv, { true, { { "TABLE_NAME"sv, {} } } });
746}
747
748TEST_CASE(nested_subquery_limit)
749{
750 auto subquery = DeprecatedString::formatted("{:(^{}}table_name{:)^{}}", "", SQL::AST::Limits::maximum_subquery_depth - 1, "", SQL::AST::Limits::maximum_subquery_depth - 1);
751 EXPECT(!parse(DeprecatedString::formatted("SELECT * FROM {};"sv, subquery)).is_error());
752 EXPECT(parse(DeprecatedString::formatted("SELECT * FROM ({});"sv, subquery)).is_error());
753}
754
755TEST_CASE(bound_parameter_limit)
756{
757 auto subquery = DeprecatedString::repeated("?, "sv, SQL::AST::Limits::maximum_bound_parameters);
758 EXPECT(!parse(DeprecatedString::formatted("INSERT INTO table_name VALUES ({}42);"sv, subquery)).is_error());
759 EXPECT(parse(DeprecatedString::formatted("INSERT INTO table_name VALUES ({}?);"sv, subquery)).is_error());
760}
761
762TEST_CASE(describe_table)
763{
764 EXPECT(parse("DESCRIBE"sv).is_error());
765 EXPECT(parse("DESCRIBE;"sv).is_error());
766 EXPECT(parse("DESCRIBE TABLE;"sv).is_error());
767 EXPECT(parse("DESCRIBE table_name;"sv).is_error());
768
769 auto validate = [](StringView sql, StringView expected_schema, StringView expected_table) {
770 auto result = parse(sql);
771 if (result.is_error())
772 outln("{}: {}", sql, result.error());
773 EXPECT(!result.is_error());
774
775 auto statement = result.release_value();
776 EXPECT(is<SQL::AST::DescribeTable>(*statement));
777
778 const auto& describe_table_statement = static_cast<const SQL::AST::DescribeTable&>(*statement);
779 EXPECT_EQ(describe_table_statement.qualified_table_name()->schema_name(), expected_schema);
780 EXPECT_EQ(describe_table_statement.qualified_table_name()->table_name(), expected_table);
781 };
782
783 validate("DESCRIBE TABLE TableName;"sv, {}, "TABLENAME"sv);
784 validate("DESCRIBE TABLE SchemaName.TableName;"sv, "SCHEMANAME"sv, "TABLENAME"sv);
785}