TestSqlExpressionParser.cpp 23 KB

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