jcs.org
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 *
5 * SPDX-License-Identifier: BSD-2-Clause
6 */
7
8#include <LibTest/TestCase.h>
9
10#include <AK/DeprecatedString.h>
11#include <AK/HashMap.h>
12#include <AK/Result.h>
13#include <AK/StringBuilder.h>
14#include <AK/StringView.h>
15#include <AK/TypeCasts.h>
16#include <LibSQL/AST/Lexer.h>
17#include <LibSQL/AST/Parser.h>
18
19namespace {
20
21class ExpressionParser : public SQL::AST::Parser {
22public:
23 explicit ExpressionParser(SQL::AST::Lexer lexer)
24 : SQL::AST::Parser(move(lexer))
25 {
26 }
27
28 NonnullRefPtr<SQL::AST::Expression> parse()
29 {
30 return SQL::AST::Parser::parse_expression();
31 }
32};
33
34using ParseResult = AK::Result<NonnullRefPtr<SQL::AST::Expression>, DeprecatedString>;
35
36ParseResult parse(StringView sql)
37{
38 auto parser = ExpressionParser(SQL::AST::Lexer(sql));
39 auto expression = parser.parse();
40
41 if (parser.has_errors()) {
42 return parser.errors()[0].to_deprecated_string();
43 }
44
45 return expression;
46}
47
48}
49
50TEST_CASE(numeric_literal)
51{
52 // FIXME Right now the "1a" test fails (meaning the parse succeeds).
53 // This is obviously inconsistent.
54 // See the FIXME in lexer.cpp, method consume_exponent() about
55 // solutions.
56 // EXPECT(parse("1e"sv).is_error());
57 // EXPECT(parse("1a"sv).is_error());
58 // EXPECT(parse("0x"sv).is_error());
59
60 auto validate = [](StringView sql, double expected_value) {
61 auto result = parse(sql);
62 EXPECT(!result.is_error());
63
64 auto expression = result.release_value();
65 EXPECT(is<SQL::AST::NumericLiteral>(*expression));
66
67 const auto& literal = static_cast<const SQL::AST::NumericLiteral&>(*expression);
68 EXPECT_EQ(literal.value(), expected_value);
69 };
70
71 validate("123"sv, 123);
72 validate("3.14"sv, 3.14);
73 validate("0xA"sv, 10);
74 validate("0xff"sv, 255);
75 validate("0x100"sv, 256);
76 validate("1e3"sv, 1000);
77}
78
79TEST_CASE(string_literal)
80{
81 EXPECT(parse("'"sv).is_error());
82 EXPECT(parse("'unterminated"sv).is_error());
83
84 auto validate = [](StringView sql, StringView expected_value) {
85 auto result = parse(sql);
86 EXPECT(!result.is_error());
87
88 auto expression = result.release_value();
89 EXPECT(is<SQL::AST::StringLiteral>(*expression));
90
91 const auto& literal = static_cast<const SQL::AST::StringLiteral&>(*expression);
92 EXPECT_EQ(literal.value(), expected_value);
93 };
94
95 validate("''"sv, ""sv);
96 validate("'hello friends'"sv, "hello friends"sv);
97 validate("'hello ''friends'''"sv, "hello 'friends'"sv);
98}
99
100TEST_CASE(blob_literal)
101{
102 EXPECT(parse("x'"sv).is_error());
103 EXPECT(parse("x'unterminated"sv).is_error());
104 EXPECT(parse("x'NOTHEX'"sv).is_error());
105
106 auto validate = [](StringView sql, StringView expected_value) {
107 auto result = parse(sql);
108 EXPECT(!result.is_error());
109
110 auto expression = result.release_value();
111 EXPECT(is<SQL::AST::BlobLiteral>(*expression));
112
113 const auto& literal = static_cast<const SQL::AST::BlobLiteral&>(*expression);
114 EXPECT_EQ(literal.value(), expected_value);
115 };
116
117 validate("x''"sv, ""sv);
118 validate("x'DEADC0DE'"sv, "DEADC0DE"sv);
119}
120
121TEST_CASE(boolean_literal)
122{
123 auto validate = [](StringView sql, bool expected_value) {
124 auto result = parse(sql);
125 EXPECT(!result.is_error());
126
127 auto expression = result.release_value();
128 EXPECT(is<SQL::AST::BooleanLiteral>(*expression));
129
130 auto const& literal = static_cast<SQL::AST::BooleanLiteral const&>(*expression);
131 EXPECT_EQ(literal.value(), expected_value);
132 };
133
134 validate("TRUE"sv, true);
135 validate("FALSE"sv, false);
136}
137
138TEST_CASE(null_literal)
139{
140 auto validate = [](StringView sql) {
141 auto result = parse(sql);
142 EXPECT(!result.is_error());
143
144 auto expression = result.release_value();
145 EXPECT(is<SQL::AST::NullLiteral>(*expression));
146 };
147
148 validate("NULL"sv);
149}
150
151TEST_CASE(bind_parameter)
152{
153 auto validate = [](StringView sql) {
154 auto result = parse(sql);
155 EXPECT(!result.is_error());
156
157 auto expression = result.release_value();
158 EXPECT(is<SQL::AST::Placeholder>(*expression));
159 };
160
161 validate("?"sv);
162}
163
164TEST_CASE(column_name)
165{
166 EXPECT(parse(".column_name"sv).is_error());
167 EXPECT(parse("table_name."sv).is_error());
168 EXPECT(parse("schema_name.table_name."sv).is_error());
169 EXPECT(parse("\"unterminated"sv).is_error());
170
171 auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column) {
172 auto result = parse(sql);
173 EXPECT(!result.is_error());
174
175 auto expression = result.release_value();
176 EXPECT(is<SQL::AST::ColumnNameExpression>(*expression));
177
178 const auto& column = static_cast<const SQL::AST::ColumnNameExpression&>(*expression);
179 EXPECT_EQ(column.schema_name(), expected_schema);
180 EXPECT_EQ(column.table_name(), expected_table);
181 EXPECT_EQ(column.column_name(), expected_column);
182 };
183
184 validate("column_name"sv, {}, {}, "COLUMN_NAME"sv);
185 validate("table_name.column_name"sv, {}, "TABLE_NAME"sv, "COLUMN_NAME"sv);
186 validate("schema_name.table_name.column_name"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, "COLUMN_NAME"sv);
187 validate("\"Column_Name\""sv, {}, {}, "Column_Name"sv);
188 validate("\"Column\n_Name\""sv, {}, {}, "Column\n_Name"sv);
189}
190
191TEST_CASE(unary_operator)
192{
193 EXPECT(parse("-"sv).is_error());
194 EXPECT(parse("--"sv).is_error());
195 EXPECT(parse("+"sv).is_error());
196 EXPECT(parse("++"sv).is_error());
197 EXPECT(parse("~"sv).is_error());
198 EXPECT(parse("~~"sv).is_error());
199 EXPECT(parse("NOT"sv).is_error());
200
201 auto validate = [](StringView sql, SQL::AST::UnaryOperator expected_operator) {
202 auto result = parse(sql);
203 EXPECT(!result.is_error());
204
205 auto expression = result.release_value();
206 EXPECT(is<SQL::AST::UnaryOperatorExpression>(*expression));
207
208 const auto& unary = static_cast<const SQL::AST::UnaryOperatorExpression&>(*expression);
209 EXPECT_EQ(unary.type(), expected_operator);
210
211 const auto& secondary_expression = unary.expression();
212 EXPECT(!is<SQL::AST::ErrorExpression>(*secondary_expression));
213 };
214
215 validate("-15"sv, SQL::AST::UnaryOperator::Minus);
216 validate("+15"sv, SQL::AST::UnaryOperator::Plus);
217 validate("~15"sv, SQL::AST::UnaryOperator::BitwiseNot);
218 validate("NOT 15"sv, SQL::AST::UnaryOperator::Not);
219}
220
221TEST_CASE(binary_operator)
222{
223 HashMap<StringView, SQL::AST::BinaryOperator> operators {
224 { "||"sv, SQL::AST::BinaryOperator::Concatenate },
225 { "*"sv, SQL::AST::BinaryOperator::Multiplication },
226 { "/"sv, SQL::AST::BinaryOperator::Division },
227 { "%"sv, SQL::AST::BinaryOperator::Modulo },
228 { "+"sv, SQL::AST::BinaryOperator::Plus },
229 { "-"sv, SQL::AST::BinaryOperator::Minus },
230 { "<<"sv, SQL::AST::BinaryOperator::ShiftLeft },
231 { ">>"sv, SQL::AST::BinaryOperator::ShiftRight },
232 { "&"sv, SQL::AST::BinaryOperator::BitwiseAnd },
233 { "|"sv, SQL::AST::BinaryOperator::BitwiseOr },
234 { "<"sv, SQL::AST::BinaryOperator::LessThan },
235 { "<="sv, SQL::AST::BinaryOperator::LessThanEquals },
236 { ">"sv, SQL::AST::BinaryOperator::GreaterThan },
237 { ">="sv, SQL::AST::BinaryOperator::GreaterThanEquals },
238 { "="sv, SQL::AST::BinaryOperator::Equals },
239 { "=="sv, SQL::AST::BinaryOperator::Equals },
240 { "!="sv, SQL::AST::BinaryOperator::NotEquals },
241 { "<>"sv, SQL::AST::BinaryOperator::NotEquals },
242 { "AND"sv, SQL::AST::BinaryOperator::And },
243 { "OR"sv, SQL::AST::BinaryOperator::Or },
244 };
245
246 for (auto op : operators) {
247 EXPECT(parse(op.key).is_error());
248
249 StringBuilder builder;
250 builder.append("1 "sv);
251 builder.append(op.key);
252 EXPECT(parse(builder.to_deprecated_string()).is_error());
253
254 builder.clear();
255
256 if (op.key != "+" && op.key != "-") { // "+1" and "-1" are fine (unary operator).
257 builder.append(op.key);
258 builder.append(" 1"sv);
259 EXPECT(parse(builder.to_deprecated_string()).is_error());
260 }
261 }
262
263 auto validate = [](StringView sql, SQL::AST::BinaryOperator expected_operator) {
264 auto result = parse(sql);
265 EXPECT(!result.is_error());
266
267 auto expression = result.release_value();
268 EXPECT(is<SQL::AST::BinaryOperatorExpression>(*expression));
269
270 const auto& binary = static_cast<const SQL::AST::BinaryOperatorExpression&>(*expression);
271 EXPECT(!is<SQL::AST::ErrorExpression>(*binary.lhs()));
272 EXPECT(!is<SQL::AST::ErrorExpression>(*binary.rhs()));
273 EXPECT_EQ(binary.type(), expected_operator);
274 };
275
276 for (auto op : operators) {
277 StringBuilder builder;
278 builder.append("1 "sv);
279 builder.append(op.key);
280 builder.append(" 1"sv);
281 validate(builder.to_deprecated_string(), op.value);
282 }
283}
284
285TEST_CASE(chained_expression)
286{
287 EXPECT(parse("()"sv).is_error());
288 EXPECT(parse("(,)"sv).is_error());
289 EXPECT(parse("(15,)"sv).is_error());
290
291 auto validate = [](StringView sql, size_t expected_chain_size) {
292 auto result = parse(sql);
293 EXPECT(!result.is_error());
294
295 auto expression = result.release_value();
296 EXPECT(is<SQL::AST::ChainedExpression>(*expression));
297
298 const auto& chain = static_cast<const SQL::AST::ChainedExpression&>(*expression).expressions();
299 EXPECT_EQ(chain.size(), expected_chain_size);
300
301 for (const auto& chained_expression : chain)
302 EXPECT(!is<SQL::AST::ErrorExpression>(chained_expression));
303 };
304
305 validate("(15)"sv, 1);
306 validate("(15, 16)"sv, 2);
307 validate("(15, 16, column_name)"sv, 3);
308}
309
310TEST_CASE(cast_expression)
311{
312 EXPECT(parse("CAST"sv).is_error());
313 EXPECT(parse("CAST ("sv).is_error());
314 EXPECT(parse("CAST ()"sv).is_error());
315 EXPECT(parse("CAST (15)"sv).is_error());
316 EXPECT(parse("CAST (15 AS"sv).is_error());
317 EXPECT(parse("CAST (15 AS)"sv).is_error());
318 EXPECT(parse("CAST (15 AS int"sv).is_error());
319
320 auto validate = [](StringView sql, StringView expected_type_name) {
321 auto result = parse(sql);
322 if (result.is_error())
323 outln("{}: {}", sql, result.error());
324 EXPECT(!result.is_error());
325
326 auto expression = result.release_value();
327 EXPECT(is<SQL::AST::CastExpression>(*expression));
328
329 const auto& cast = static_cast<const SQL::AST::CastExpression&>(*expression);
330 EXPECT(!is<SQL::AST::ErrorExpression>(*cast.expression()));
331
332 const auto& type_name = cast.type_name();
333 EXPECT_EQ(type_name->name(), expected_type_name);
334 };
335
336 validate("CAST (15 AS int)"sv, "INT"sv);
337 // FIXME The syntax in the test below fails on both sqlite3 and psql (PostgreSQL).
338 // Also fails here because null is interpreted as the NULL keyword and not the
339 // identifier null (which is not a type)
340 // validate("CAST ('NULL' AS null)"sv, "null"sv);
341 validate("CAST (15 AS varchar(255))"sv, "VARCHAR"sv);
342}
343
344TEST_CASE(case_expression)
345{
346 EXPECT(parse("CASE"sv).is_error());
347 EXPECT(parse("CASE END"sv).is_error());
348 EXPECT(parse("CASE 15"sv).is_error());
349 EXPECT(parse("CASE 15 END"sv).is_error());
350 EXPECT(parse("CASE WHEN"sv).is_error());
351 EXPECT(parse("CASE WHEN THEN"sv).is_error());
352 EXPECT(parse("CASE WHEN 15 THEN 16"sv).is_error());
353 EXPECT(parse("CASE WHEN 15 THEN 16 ELSE"sv).is_error());
354 EXPECT(parse("CASE WHEN 15 THEN 16 ELSE END"sv).is_error());
355
356 auto validate = [](StringView sql, bool expect_case_expression, size_t expected_when_then_size, bool expect_else_expression) {
357 auto result = parse(sql);
358 EXPECT(!result.is_error());
359
360 auto expression = result.release_value();
361 EXPECT(is<SQL::AST::CaseExpression>(*expression));
362
363 const auto& case_ = static_cast<const SQL::AST::CaseExpression&>(*expression);
364
365 const auto& case_expression = case_.case_expression();
366 EXPECT_EQ(case_expression.is_null(), !expect_case_expression);
367 if (case_expression)
368 EXPECT(!is<SQL::AST::ErrorExpression>(*case_expression));
369
370 const auto& when_then_clauses = case_.when_then_clauses();
371 EXPECT_EQ(when_then_clauses.size(), expected_when_then_size);
372 for (const auto& when_then_clause : when_then_clauses) {
373 EXPECT(!is<SQL::AST::ErrorExpression>(*when_then_clause.when));
374 EXPECT(!is<SQL::AST::ErrorExpression>(*when_then_clause.then));
375 }
376
377 const auto& else_expression = case_.else_expression();
378 EXPECT_EQ(else_expression.is_null(), !expect_else_expression);
379 if (else_expression)
380 EXPECT(!is<SQL::AST::ErrorExpression>(*else_expression));
381 };
382
383 validate("CASE WHEN 16 THEN 17 END"sv, false, 1, false);
384 validate("CASE WHEN 16 THEN 17 WHEN 18 THEN 19 END"sv, false, 2, false);
385 validate("CASE WHEN 16 THEN 17 WHEN 18 THEN 19 ELSE 20 END"sv, false, 2, true);
386
387 validate("CASE 15 WHEN 16 THEN 17 END"sv, true, 1, false);
388 validate("CASE 15 WHEN 16 THEN 17 WHEN 18 THEN 19 END"sv, true, 2, false);
389 validate("CASE 15 WHEN 16 THEN 17 WHEN 18 THEN 19 ELSE 20 END"sv, true, 2, true);
390}
391
392TEST_CASE(exists_expression)
393{
394 EXPECT(parse("EXISTS"sv).is_error());
395 EXPECT(parse("EXISTS ("sv).is_error());
396 EXPECT(parse("EXISTS (SELECT"sv).is_error());
397 EXPECT(parse("EXISTS (SELECT)"sv).is_error());
398 EXPECT(parse("EXISTS (SELECT * FROM table_name"sv).is_error());
399 EXPECT(parse("NOT EXISTS"sv).is_error());
400 EXPECT(parse("NOT EXISTS ("sv).is_error());
401 EXPECT(parse("NOT EXISTS (SELECT"sv).is_error());
402 EXPECT(parse("NOT EXISTS (SELECT)"sv).is_error());
403 EXPECT(parse("NOT EXISTS (SELECT * FROM table_name"sv).is_error());
404 EXPECT(parse("("sv).is_error());
405 EXPECT(parse("(SELECT"sv).is_error());
406 EXPECT(parse("(SELECT)"sv).is_error());
407 EXPECT(parse("(SELECT * FROM table_name"sv).is_error());
408
409 auto validate = [](StringView sql, bool expected_invert_expression) {
410 auto result = parse(sql);
411 EXPECT(!result.is_error());
412
413 auto expression = result.release_value();
414 EXPECT(is<SQL::AST::ExistsExpression>(*expression));
415
416 const auto& exists = static_cast<const SQL::AST::ExistsExpression&>(*expression);
417 EXPECT_EQ(exists.invert_expression(), expected_invert_expression);
418 };
419
420 validate("EXISTS (SELECT * FROM table_name)"sv, false);
421 validate("NOT EXISTS (SELECT * FROM table_name)"sv, true);
422 validate("(SELECT * FROM table_name)"sv, false);
423}
424
425TEST_CASE(collate_expression)
426{
427 EXPECT(parse("COLLATE"sv).is_error());
428 EXPECT(parse("COLLATE name"sv).is_error());
429 EXPECT(parse("15 COLLATE"sv).is_error());
430
431 auto validate = [](StringView sql, StringView expected_collation_name) {
432 auto result = parse(sql);
433 EXPECT(!result.is_error());
434
435 auto expression = result.release_value();
436 EXPECT(is<SQL::AST::CollateExpression>(*expression));
437
438 const auto& collate = static_cast<const SQL::AST::CollateExpression&>(*expression);
439 EXPECT(!is<SQL::AST::ErrorExpression>(*collate.expression()));
440 EXPECT_EQ(collate.collation_name(), expected_collation_name);
441 };
442
443 validate("15 COLLATE fifteen"sv, "FIFTEEN"sv);
444 validate("(15, 16) COLLATE \"chain\""sv, "chain"sv);
445}
446
447TEST_CASE(is_expression)
448{
449 EXPECT(parse("IS"sv).is_error());
450 EXPECT(parse("IS 1"sv).is_error());
451 EXPECT(parse("1 IS"sv).is_error());
452 EXPECT(parse("IS NOT"sv).is_error());
453 EXPECT(parse("IS NOT 1"sv).is_error());
454 EXPECT(parse("1 IS NOT"sv).is_error());
455
456 auto validate = [](StringView sql, bool expected_invert_expression) {
457 auto result = parse(sql);
458 EXPECT(!result.is_error());
459
460 auto expression = result.release_value();
461 EXPECT(is<SQL::AST::IsExpression>(*expression));
462
463 const auto& is_ = static_cast<const SQL::AST::IsExpression&>(*expression);
464 EXPECT(!is<SQL::AST::ErrorExpression>(*is_.lhs()));
465 EXPECT(!is<SQL::AST::ErrorExpression>(*is_.rhs()));
466 EXPECT_EQ(is_.invert_expression(), expected_invert_expression);
467 };
468
469 validate("1 IS NULL"sv, false);
470 validate("1 IS NOT NULL"sv, true);
471}
472
473TEST_CASE(match_expression)
474{
475 HashMap<StringView, SQL::AST::MatchOperator> operators {
476 { "LIKE"sv, SQL::AST::MatchOperator::Like },
477 { "GLOB"sv, SQL::AST::MatchOperator::Glob },
478 { "MATCH"sv, SQL::AST::MatchOperator::Match },
479 { "REGEXP"sv, SQL::AST::MatchOperator::Regexp },
480 };
481
482 for (auto op : operators) {
483 EXPECT(parse(op.key).is_error());
484
485 StringBuilder builder;
486 builder.append("1 "sv);
487 builder.append(op.key);
488 EXPECT(parse(builder.to_deprecated_string()).is_error());
489
490 builder.clear();
491 builder.append(op.key);
492 builder.append(" 1"sv);
493 EXPECT(parse(builder.to_deprecated_string()).is_error());
494 }
495
496 auto validate = [](StringView sql, SQL::AST::MatchOperator expected_operator, bool expected_invert_expression, bool expect_escape) {
497 auto result = parse(sql);
498 EXPECT(!result.is_error());
499
500 auto expression = result.release_value();
501 EXPECT(is<SQL::AST::MatchExpression>(*expression));
502
503 const auto& match = static_cast<const SQL::AST::MatchExpression&>(*expression);
504 EXPECT(!is<SQL::AST::ErrorExpression>(*match.lhs()));
505 EXPECT(!is<SQL::AST::ErrorExpression>(*match.rhs()));
506 EXPECT_EQ(match.type(), expected_operator);
507 EXPECT_EQ(match.invert_expression(), expected_invert_expression);
508 EXPECT(match.escape() || !expect_escape);
509 };
510
511 for (auto op : operators) {
512 StringBuilder builder;
513 builder.append("1 "sv);
514 builder.append(op.key);
515 builder.append(" 1"sv);
516 validate(builder.to_deprecated_string(), op.value, false, false);
517
518 builder.clear();
519 builder.append("1 NOT "sv);
520 builder.append(op.key);
521 builder.append(" 1"sv);
522 validate(builder.to_deprecated_string(), op.value, true, false);
523
524 builder.clear();
525 builder.append("1 NOT "sv);
526 builder.append(op.key);
527 builder.append(" 1 ESCAPE '+'"sv);
528 validate(builder.to_deprecated_string(), op.value, true, true);
529 }
530}
531
532TEST_CASE(null_expression)
533{
534 EXPECT(parse("ISNULL"sv).is_error());
535 EXPECT(parse("NOTNULL"sv).is_error());
536 EXPECT(parse("15 NOT"sv).is_error());
537
538 auto validate = [](StringView sql, bool expected_invert_expression) {
539 auto result = parse(sql);
540 EXPECT(!result.is_error());
541
542 auto expression = result.release_value();
543 EXPECT(is<SQL::AST::NullExpression>(*expression));
544
545 const auto& null = static_cast<const SQL::AST::NullExpression&>(*expression);
546 EXPECT_EQ(null.invert_expression(), expected_invert_expression);
547 };
548
549 validate("15 ISNULL"sv, false);
550 validate("15 NOTNULL"sv, true);
551 validate("15 NOT NULL"sv, true);
552}
553
554TEST_CASE(between_expression)
555{
556 EXPECT(parse("BETWEEN"sv).is_error());
557 EXPECT(parse("NOT BETWEEN"sv).is_error());
558 EXPECT(parse("BETWEEN 10 AND 20"sv).is_error());
559 EXPECT(parse("NOT BETWEEN 10 AND 20"sv).is_error());
560 EXPECT(parse("15 BETWEEN 10"sv).is_error());
561 EXPECT(parse("15 BETWEEN 10 AND"sv).is_error());
562 EXPECT(parse("15 BETWEEN AND 20"sv).is_error());
563 EXPECT(parse("15 BETWEEN 10 OR 20"sv).is_error());
564
565 auto validate = [](StringView sql, bool expected_invert_expression) {
566 auto result = parse(sql);
567 EXPECT(!result.is_error());
568
569 auto expression = result.release_value();
570 EXPECT(is<SQL::AST::BetweenExpression>(*expression));
571
572 const auto& between = static_cast<const SQL::AST::BetweenExpression&>(*expression);
573 EXPECT(!is<SQL::AST::ErrorExpression>(*between.expression()));
574 EXPECT(!is<SQL::AST::ErrorExpression>(*between.lhs()));
575 EXPECT(!is<SQL::AST::ErrorExpression>(*between.rhs()));
576 EXPECT_EQ(between.invert_expression(), expected_invert_expression);
577 };
578
579 validate("15 BETWEEN 10 AND 20"sv, false);
580 validate("15 NOT BETWEEN 10 AND 20"sv, true);
581}
582
583TEST_CASE(in_table_expression)
584{
585 EXPECT(parse("IN"sv).is_error());
586 EXPECT(parse("IN table_name"sv).is_error());
587 EXPECT(parse("NOT IN"sv).is_error());
588 EXPECT(parse("NOT IN table_name"sv).is_error());
589
590 auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, bool expected_invert_expression) {
591 auto result = parse(sql);
592 EXPECT(!result.is_error());
593
594 auto expression = result.release_value();
595 EXPECT(is<SQL::AST::InTableExpression>(*expression));
596
597 const auto& in = static_cast<const SQL::AST::InTableExpression&>(*expression);
598 EXPECT(!is<SQL::AST::ErrorExpression>(*in.expression()));
599 EXPECT_EQ(in.schema_name(), expected_schema);
600 EXPECT_EQ(in.table_name(), expected_table);
601 EXPECT_EQ(in.invert_expression(), expected_invert_expression);
602 };
603
604 validate("15 IN table_name"sv, {}, "TABLE_NAME"sv, false);
605 validate("15 IN schema_name.table_name"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, false);
606
607 validate("15 NOT IN table_name"sv, {}, "TABLE_NAME"sv, true);
608 validate("15 NOT IN schema_name.table_name"sv, "SCHEMA_NAME"sv, "TABLE_NAME"sv, true);
609}
610
611TEST_CASE(in_chained_expression)
612{
613 EXPECT(parse("IN ()"sv).is_error());
614 EXPECT(parse("NOT IN ()"sv).is_error());
615
616 auto validate = [](StringView sql, size_t expected_chain_size, bool expected_invert_expression) {
617 auto result = parse(sql);
618 EXPECT(!result.is_error());
619
620 auto expression = result.release_value();
621 EXPECT(is<SQL::AST::InChainedExpression>(*expression));
622
623 const auto& in = static_cast<const SQL::AST::InChainedExpression&>(*expression);
624 EXPECT(!is<SQL::AST::ErrorExpression>(*in.expression()));
625 EXPECT_EQ(in.expression_chain()->expressions().size(), expected_chain_size);
626 EXPECT_EQ(in.invert_expression(), expected_invert_expression);
627
628 for (const auto& chained_expression : in.expression_chain()->expressions())
629 EXPECT(!is<SQL::AST::ErrorExpression>(chained_expression));
630 };
631
632 validate("15 IN ()"sv, 0, false);
633 validate("15 IN (15)"sv, 1, false);
634 validate("15 IN (15, 16)"sv, 2, false);
635
636 validate("15 NOT IN ()"sv, 0, true);
637 validate("15 NOT IN (15)"sv, 1, true);
638 validate("15 NOT IN (15, 16)"sv, 2, true);
639}
640
641TEST_CASE(in_selection_expression)
642{
643 EXPECT(parse("IN (SELECT)"sv).is_error());
644 EXPECT(parse("IN (SELECT * FROM table_name, SELECT * FROM table_name);"sv).is_error());
645 EXPECT(parse("NOT IN (SELECT)"sv).is_error());
646 EXPECT(parse("NOT IN (SELECT * FROM table_name, SELECT * FROM table_name);"sv).is_error());
647
648 auto validate = [](StringView sql, bool expected_invert_expression) {
649 auto result = parse(sql);
650 EXPECT(!result.is_error());
651
652 auto expression = result.release_value();
653 EXPECT(is<SQL::AST::InSelectionExpression>(*expression));
654
655 const auto& in = static_cast<const SQL::AST::InSelectionExpression&>(*expression);
656 EXPECT(!is<SQL::AST::ErrorExpression>(*in.expression()));
657 EXPECT_EQ(in.invert_expression(), expected_invert_expression);
658 };
659
660 validate("15 IN (SELECT * FROM table_name)"sv, false);
661 validate("15 NOT IN (SELECT * FROM table_name)"sv, true);
662}
663
664TEST_CASE(expression_tree_depth_limit)
665{
666 auto too_deep_expression = DeprecatedString::formatted("{:+^{}}1", "", SQL::AST::Limits::maximum_expression_tree_depth);
667 EXPECT(!parse(too_deep_expression.substring_view(1)).is_error());
668 EXPECT(parse(too_deep_expression).is_error());
669}