Parser.cpp 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777
  1. /*
  2. * Copyright (c) 2021, Tim Flynn <trflynn89@pm.me>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include "Parser.h"
  7. #include <AK/TypeCasts.h>
  8. namespace SQL {
  9. Parser::Parser(Lexer lexer)
  10. : m_parser_state(move(lexer))
  11. {
  12. }
  13. NonnullRefPtr<Statement> Parser::next_statement()
  14. {
  15. switch (m_parser_state.m_token.type()) {
  16. case TokenType::Create:
  17. return parse_create_table_statement();
  18. case TokenType::Drop:
  19. return parse_drop_table_statement();
  20. case TokenType::Delete:
  21. case TokenType::With:
  22. return parse_delete_statement();
  23. default:
  24. expected("CREATE, DROP, or DELETE");
  25. return create_ast_node<ErrorStatement>();
  26. }
  27. }
  28. NonnullRefPtr<CreateTable> Parser::parse_create_table_statement()
  29. {
  30. // https://sqlite.org/lang_createtable.html
  31. consume(TokenType::Create);
  32. bool is_temporary = false;
  33. if (consume_if(TokenType::Temp) || consume_if(TokenType::Temporary))
  34. is_temporary = true;
  35. consume(TokenType::Table);
  36. bool is_error_if_table_exists = true;
  37. if (consume_if(TokenType::If)) {
  38. consume(TokenType::Not);
  39. consume(TokenType::Exists);
  40. is_error_if_table_exists = false;
  41. }
  42. String schema_or_table_name = consume(TokenType::Identifier).value();
  43. String schema_name;
  44. String table_name;
  45. if (consume_if(TokenType::Period)) {
  46. schema_name = move(schema_or_table_name);
  47. table_name = consume(TokenType::Identifier).value();
  48. } else {
  49. table_name = move(schema_or_table_name);
  50. }
  51. // FIXME: Parse "AS select-stmt".
  52. NonnullRefPtrVector<ColumnDefinition> column_definitions;
  53. consume(TokenType::ParenOpen);
  54. do {
  55. column_definitions.append(parse_column_definition());
  56. if (match(TokenType::ParenClose))
  57. break;
  58. consume(TokenType::Comma);
  59. } while (!match(TokenType::Eof));
  60. // FIXME: Parse "table-constraint".
  61. consume(TokenType::ParenClose);
  62. consume(TokenType::SemiColon);
  63. return create_ast_node<CreateTable>(move(schema_name), move(table_name), move(column_definitions), is_temporary, is_error_if_table_exists);
  64. }
  65. NonnullRefPtr<DropTable> Parser::parse_drop_table_statement()
  66. {
  67. // https://sqlite.org/lang_droptable.html
  68. consume(TokenType::Drop);
  69. consume(TokenType::Table);
  70. bool is_error_if_table_does_not_exist = true;
  71. if (consume_if(TokenType::If)) {
  72. consume(TokenType::Exists);
  73. is_error_if_table_does_not_exist = false;
  74. }
  75. String schema_or_table_name = consume(TokenType::Identifier).value();
  76. String schema_name;
  77. String table_name;
  78. if (consume_if(TokenType::Period)) {
  79. schema_name = move(schema_or_table_name);
  80. table_name = consume(TokenType::Identifier).value();
  81. } else {
  82. table_name = move(schema_or_table_name);
  83. }
  84. consume(TokenType::SemiColon);
  85. return create_ast_node<DropTable>(move(schema_name), move(table_name), is_error_if_table_does_not_exist);
  86. }
  87. NonnullRefPtr<Delete> Parser::parse_delete_statement()
  88. {
  89. // https://sqlite.org/lang_delete.html
  90. RefPtr<CommonTableExpressionList> common_table_expression_list;
  91. if (consume_if(TokenType::With)) {
  92. NonnullRefPtrVector<CommonTableExpression> common_table_expression;
  93. bool recursive = consume_if(TokenType::Recursive);
  94. do {
  95. common_table_expression.append(parse_common_table_expression());
  96. if (!match(TokenType::Comma))
  97. break;
  98. consume(TokenType::Comma);
  99. } while (!match(TokenType::Eof));
  100. common_table_expression_list = create_ast_node<CommonTableExpressionList>(recursive, move(common_table_expression));
  101. }
  102. consume(TokenType::Delete);
  103. consume(TokenType::From);
  104. auto qualified_table_name = parse_qualified_table_name();
  105. RefPtr<Expression> where_clause;
  106. if (consume_if(TokenType::Where))
  107. where_clause = parse_expression();
  108. RefPtr<ReturningClause> returning_clause;
  109. if (match(TokenType::Returning))
  110. returning_clause = parse_returning_clause();
  111. consume(TokenType::SemiColon);
  112. return create_ast_node<Delete>(move(common_table_expression_list), move(qualified_table_name), move(where_clause), move(returning_clause));
  113. }
  114. NonnullRefPtr<Expression> Parser::parse_expression()
  115. {
  116. // https://sqlite.org/lang_expr.html
  117. auto expression = parse_primary_expression();
  118. if (match_secondary_expression())
  119. expression = parse_secondary_expression(move(expression));
  120. // FIXME: Parse 'bind-parameter'.
  121. // FIXME: Parse 'function-name'.
  122. // FIXME: Parse 'exists'.
  123. // FIXME: Parse 'raise-function'.
  124. return expression;
  125. }
  126. NonnullRefPtr<Expression> Parser::parse_primary_expression()
  127. {
  128. if (auto expression = parse_literal_value_expression(); expression.has_value())
  129. return move(expression.value());
  130. if (auto expression = parse_column_name_expression(); expression.has_value())
  131. return move(expression.value());
  132. if (auto expression = parse_unary_operator_expression(); expression.has_value())
  133. return move(expression.value());
  134. if (auto expression = parse_chained_expression(); expression.has_value())
  135. return move(expression.value());
  136. if (auto expression = parse_cast_expression(); expression.has_value())
  137. return move(expression.value());
  138. if (auto expression = parse_case_expression(); expression.has_value())
  139. return move(expression.value());
  140. expected("Primary Expression");
  141. consume();
  142. return create_ast_node<ErrorExpression>();
  143. }
  144. NonnullRefPtr<Expression> Parser::parse_secondary_expression(NonnullRefPtr<Expression> primary)
  145. {
  146. if (auto expression = parse_binary_operator_expression(primary); expression.has_value())
  147. return move(expression.value());
  148. if (auto expression = parse_collate_expression(primary); expression.has_value())
  149. return move(expression.value());
  150. if (auto expression = parse_is_expression(primary); expression.has_value())
  151. return move(expression.value());
  152. bool invert_expression = false;
  153. if (consume_if(TokenType::Not))
  154. invert_expression = true;
  155. if (auto expression = parse_match_expression(primary, invert_expression); expression.has_value())
  156. return move(expression.value());
  157. if (auto expression = parse_null_expression(primary, invert_expression); expression.has_value())
  158. return move(expression.value());
  159. if (auto expression = parse_between_expression(primary, invert_expression); expression.has_value())
  160. return move(expression.value());
  161. if (auto expression = parse_in_expression(primary, invert_expression); expression.has_value())
  162. return move(expression.value());
  163. expected("Secondary Expression");
  164. consume();
  165. return create_ast_node<ErrorExpression>();
  166. }
  167. bool Parser::match_secondary_expression() const
  168. {
  169. return match(TokenType::Not)
  170. || match(TokenType::DoublePipe)
  171. || match(TokenType::Asterisk)
  172. || match(TokenType::Divide)
  173. || match(TokenType::Modulus)
  174. || match(TokenType::Plus)
  175. || match(TokenType::Minus)
  176. || match(TokenType::ShiftLeft)
  177. || match(TokenType::ShiftRight)
  178. || match(TokenType::Ampersand)
  179. || match(TokenType::Pipe)
  180. || match(TokenType::LessThan)
  181. || match(TokenType::LessThanEquals)
  182. || match(TokenType::GreaterThan)
  183. || match(TokenType::GreaterThanEquals)
  184. || match(TokenType::Equals)
  185. || match(TokenType::EqualsEquals)
  186. || match(TokenType::NotEquals1)
  187. || match(TokenType::NotEquals2)
  188. || match(TokenType::And)
  189. || match(TokenType::Or)
  190. || match(TokenType::Collate)
  191. || match(TokenType::Is)
  192. || match(TokenType::Like)
  193. || match(TokenType::Glob)
  194. || match(TokenType::Match)
  195. || match(TokenType::Regexp)
  196. || match(TokenType::Isnull)
  197. || match(TokenType::Notnull)
  198. || match(TokenType::Between)
  199. || match(TokenType::In);
  200. }
  201. Optional<NonnullRefPtr<Expression>> Parser::parse_literal_value_expression()
  202. {
  203. if (match(TokenType::NumericLiteral)) {
  204. auto value = consume().double_value();
  205. return create_ast_node<NumericLiteral>(value);
  206. }
  207. if (match(TokenType::StringLiteral)) {
  208. // TODO: Should the surrounding ' ' be removed here?
  209. auto value = consume().value();
  210. return create_ast_node<StringLiteral>(value);
  211. }
  212. if (match(TokenType::BlobLiteral)) {
  213. // TODO: Should the surrounding x' ' be removed here?
  214. auto value = consume().value();
  215. return create_ast_node<BlobLiteral>(value);
  216. }
  217. if (consume_if(TokenType::Null))
  218. return create_ast_node<NullLiteral>();
  219. return {};
  220. }
  221. Optional<NonnullRefPtr<Expression>> Parser::parse_column_name_expression()
  222. {
  223. if (!match(TokenType::Identifier))
  224. return {};
  225. String first_identifier = consume(TokenType::Identifier).value();
  226. String schema_name;
  227. String table_name;
  228. String column_name;
  229. if (consume_if(TokenType::Period)) {
  230. String second_identifier = consume(TokenType::Identifier).value();
  231. if (consume_if(TokenType::Period)) {
  232. schema_name = move(first_identifier);
  233. table_name = move(second_identifier);
  234. column_name = consume(TokenType::Identifier).value();
  235. } else {
  236. table_name = move(first_identifier);
  237. column_name = move(second_identifier);
  238. }
  239. } else {
  240. column_name = move(first_identifier);
  241. }
  242. return create_ast_node<ColumnNameExpression>(move(schema_name), move(table_name), move(column_name));
  243. }
  244. Optional<NonnullRefPtr<Expression>> Parser::parse_unary_operator_expression()
  245. {
  246. if (consume_if(TokenType::Minus))
  247. return create_ast_node<UnaryOperatorExpression>(UnaryOperator::Minus, parse_expression());
  248. if (consume_if(TokenType::Plus))
  249. return create_ast_node<UnaryOperatorExpression>(UnaryOperator::Plus, parse_expression());
  250. if (consume_if(TokenType::Tilde))
  251. return create_ast_node<UnaryOperatorExpression>(UnaryOperator::BitwiseNot, parse_expression());
  252. if (consume_if(TokenType::Not))
  253. return create_ast_node<UnaryOperatorExpression>(UnaryOperator::Not, parse_expression());
  254. return {};
  255. }
  256. Optional<NonnullRefPtr<Expression>> Parser::parse_binary_operator_expression(NonnullRefPtr<Expression> lhs)
  257. {
  258. if (consume_if(TokenType::DoublePipe))
  259. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::Concatenate, move(lhs), parse_expression());
  260. if (consume_if(TokenType::Asterisk))
  261. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::Multiplication, move(lhs), parse_expression());
  262. if (consume_if(TokenType::Divide))
  263. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::Division, move(lhs), parse_expression());
  264. if (consume_if(TokenType::Modulus))
  265. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::Modulo, move(lhs), parse_expression());
  266. if (consume_if(TokenType::Plus))
  267. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::Plus, move(lhs), parse_expression());
  268. if (consume_if(TokenType::Minus))
  269. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::Minus, move(lhs), parse_expression());
  270. if (consume_if(TokenType::ShiftLeft))
  271. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::ShiftLeft, move(lhs), parse_expression());
  272. if (consume_if(TokenType::ShiftRight))
  273. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::ShiftRight, move(lhs), parse_expression());
  274. if (consume_if(TokenType::Ampersand))
  275. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::BitwiseAnd, move(lhs), parse_expression());
  276. if (consume_if(TokenType::Pipe))
  277. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::BitwiseOr, move(lhs), parse_expression());
  278. if (consume_if(TokenType::LessThan))
  279. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::LessThan, move(lhs), parse_expression());
  280. if (consume_if(TokenType::LessThanEquals))
  281. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::LessThanEquals, move(lhs), parse_expression());
  282. if (consume_if(TokenType::GreaterThan))
  283. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::GreaterThan, move(lhs), parse_expression());
  284. if (consume_if(TokenType::GreaterThanEquals))
  285. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::GreaterThanEquals, move(lhs), parse_expression());
  286. if (consume_if(TokenType::Equals) || consume_if(TokenType::EqualsEquals))
  287. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::Equals, move(lhs), parse_expression());
  288. if (consume_if(TokenType::NotEquals1) || consume_if(TokenType::NotEquals2))
  289. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::NotEquals, move(lhs), parse_expression());
  290. if (consume_if(TokenType::And))
  291. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::And, move(lhs), parse_expression());
  292. if (consume_if(TokenType::Or))
  293. return create_ast_node<BinaryOperatorExpression>(BinaryOperator::Or, move(lhs), parse_expression());
  294. return {};
  295. }
  296. Optional<NonnullRefPtr<Expression>> Parser::parse_chained_expression()
  297. {
  298. if (!match(TokenType::ParenOpen))
  299. return {};
  300. NonnullRefPtrVector<Expression> expressions;
  301. consume(TokenType::ParenOpen);
  302. do {
  303. expressions.append(parse_expression());
  304. if (match(TokenType::ParenClose))
  305. break;
  306. consume(TokenType::Comma);
  307. } while (!match(TokenType::Eof));
  308. consume(TokenType::ParenClose);
  309. return create_ast_node<ChainedExpression>(move(expressions));
  310. }
  311. Optional<NonnullRefPtr<Expression>> Parser::parse_cast_expression()
  312. {
  313. if (!match(TokenType::Cast))
  314. return {};
  315. consume(TokenType::Cast);
  316. consume(TokenType::ParenOpen);
  317. auto expression = parse_expression();
  318. consume(TokenType::As);
  319. auto type_name = parse_type_name();
  320. consume(TokenType::ParenClose);
  321. return create_ast_node<CastExpression>(move(expression), move(type_name));
  322. }
  323. Optional<NonnullRefPtr<Expression>> Parser::parse_case_expression()
  324. {
  325. if (!match(TokenType::Case))
  326. return {};
  327. consume();
  328. RefPtr<Expression> case_expression;
  329. if (!match(TokenType::When)) {
  330. case_expression = parse_expression();
  331. }
  332. Vector<CaseExpression::WhenThenClause> when_then_clauses;
  333. do {
  334. consume(TokenType::When);
  335. auto when = parse_expression();
  336. consume(TokenType::Then);
  337. auto then = parse_expression();
  338. when_then_clauses.append({ move(when), move(then) });
  339. if (!match(TokenType::When))
  340. break;
  341. } while (!match(TokenType::Eof));
  342. RefPtr<Expression> else_expression;
  343. if (consume_if(TokenType::Else))
  344. else_expression = parse_expression();
  345. consume(TokenType::End);
  346. return create_ast_node<CaseExpression>(move(case_expression), move(when_then_clauses), move(else_expression));
  347. }
  348. Optional<NonnullRefPtr<Expression>> Parser::parse_collate_expression(NonnullRefPtr<Expression> expression)
  349. {
  350. if (!match(TokenType::Collate))
  351. return {};
  352. consume();
  353. String collation_name = consume(TokenType::Identifier).value();
  354. return create_ast_node<CollateExpression>(move(expression), move(collation_name));
  355. }
  356. Optional<NonnullRefPtr<Expression>> Parser::parse_is_expression(NonnullRefPtr<Expression> expression)
  357. {
  358. if (!match(TokenType::Is))
  359. return {};
  360. consume();
  361. bool invert_expression = false;
  362. if (match(TokenType::Not)) {
  363. consume();
  364. invert_expression = true;
  365. }
  366. auto rhs = parse_expression();
  367. return create_ast_node<IsExpression>(move(expression), move(rhs), invert_expression);
  368. }
  369. Optional<NonnullRefPtr<Expression>> Parser::parse_match_expression(NonnullRefPtr<Expression> lhs, bool invert_expression)
  370. {
  371. auto parse_escape = [this]() {
  372. RefPtr<Expression> escape;
  373. if (consume_if(TokenType::Escape))
  374. escape = parse_expression();
  375. return escape;
  376. };
  377. if (consume_if(TokenType::Like))
  378. return create_ast_node<MatchExpression>(MatchOperator::Like, move(lhs), parse_expression(), parse_escape(), invert_expression);
  379. if (consume_if(TokenType::Glob))
  380. return create_ast_node<MatchExpression>(MatchOperator::Glob, move(lhs), parse_expression(), parse_escape(), invert_expression);
  381. if (consume_if(TokenType::Match))
  382. return create_ast_node<MatchExpression>(MatchOperator::Match, move(lhs), parse_expression(), parse_escape(), invert_expression);
  383. if (consume_if(TokenType::Regexp))
  384. return create_ast_node<MatchExpression>(MatchOperator::Regexp, move(lhs), parse_expression(), parse_escape(), invert_expression);
  385. return {};
  386. }
  387. Optional<NonnullRefPtr<Expression>> Parser::parse_null_expression(NonnullRefPtr<Expression> expression, bool invert_expression)
  388. {
  389. if (!match(TokenType::Isnull) && !match(TokenType::Notnull) && !(invert_expression && match(TokenType::Null)))
  390. return {};
  391. auto type = consume().type();
  392. invert_expression |= (type == TokenType::Notnull);
  393. return create_ast_node<NullExpression>(move(expression), invert_expression);
  394. }
  395. Optional<NonnullRefPtr<Expression>> Parser::parse_between_expression(NonnullRefPtr<Expression> expression, bool invert_expression)
  396. {
  397. if (!match(TokenType::Between))
  398. return {};
  399. consume();
  400. auto nested = parse_expression();
  401. if (!is<BinaryOperatorExpression>(*nested)) {
  402. expected("Binary Expression");
  403. return create_ast_node<ErrorExpression>();
  404. }
  405. const auto& binary_expression = static_cast<const BinaryOperatorExpression&>(*nested);
  406. if (binary_expression.type() != BinaryOperator::And) {
  407. expected("AND Expression");
  408. return create_ast_node<ErrorExpression>();
  409. }
  410. return create_ast_node<BetweenExpression>(move(expression), binary_expression.lhs(), binary_expression.rhs(), invert_expression);
  411. }
  412. Optional<NonnullRefPtr<Expression>> Parser::parse_in_expression(NonnullRefPtr<Expression> expression, bool invert_expression)
  413. {
  414. if (!match(TokenType::In))
  415. return {};
  416. consume();
  417. if (consume_if(TokenType::ParenOpen)) {
  418. if (match(TokenType::Select)) {
  419. // FIXME: Parse "select-stmt".
  420. return {};
  421. }
  422. // FIXME: Consolidate this with parse_chained_expression(). That method consumes the opening paren as
  423. // well, and also requires at least one expression (whereas this allows for an empty chain).
  424. NonnullRefPtrVector<Expression> expressions;
  425. if (!match(TokenType::ParenClose)) {
  426. do {
  427. expressions.append(parse_expression());
  428. if (match(TokenType::ParenClose))
  429. break;
  430. consume(TokenType::Comma);
  431. } while (!match(TokenType::Eof));
  432. }
  433. consume(TokenType::ParenClose);
  434. auto chain = create_ast_node<ChainedExpression>(move(expressions));
  435. return create_ast_node<InChainedExpression>(move(expression), move(chain), invert_expression);
  436. }
  437. String schema_or_table_name = consume(TokenType::Identifier).value();
  438. String schema_name;
  439. String table_name;
  440. if (consume_if(TokenType::Period)) {
  441. schema_name = move(schema_or_table_name);
  442. table_name = consume(TokenType::Identifier).value();
  443. } else {
  444. table_name = move(schema_or_table_name);
  445. }
  446. if (match(TokenType::ParenOpen)) {
  447. // FIXME: Parse "table-function".
  448. return {};
  449. }
  450. return create_ast_node<InTableExpression>(move(expression), move(schema_name), move(table_name), invert_expression);
  451. }
  452. NonnullRefPtr<ColumnDefinition> Parser::parse_column_definition()
  453. {
  454. // https://sqlite.org/syntax/column-def.html
  455. auto name = consume(TokenType::Identifier).value();
  456. auto type_name = match(TokenType::Identifier)
  457. ? parse_type_name()
  458. // https://www.sqlite.org/datatype3.html: If no type is specified then the column has affinity BLOB.
  459. : create_ast_node<TypeName>("BLOB", NonnullRefPtrVector<SignedNumber> {});
  460. // FIXME: Parse "column-constraint".
  461. return create_ast_node<ColumnDefinition>(move(name), move(type_name));
  462. }
  463. NonnullRefPtr<TypeName> Parser::parse_type_name()
  464. {
  465. // https: //sqlite.org/syntax/type-name.html
  466. auto name = consume(TokenType::Identifier).value();
  467. NonnullRefPtrVector<SignedNumber> signed_numbers;
  468. if (consume_if(TokenType::ParenOpen)) {
  469. signed_numbers.append(parse_signed_number());
  470. if (consume_if(TokenType::Comma))
  471. signed_numbers.append(parse_signed_number());
  472. consume(TokenType::ParenClose);
  473. }
  474. return create_ast_node<TypeName>(move(name), move(signed_numbers));
  475. }
  476. NonnullRefPtr<SignedNumber> Parser::parse_signed_number()
  477. {
  478. // https://sqlite.org/syntax/signed-number.html
  479. bool is_positive = true;
  480. if (consume_if(TokenType::Plus))
  481. is_positive = true;
  482. else if (consume_if(TokenType::Minus))
  483. is_positive = false;
  484. if (match(TokenType::NumericLiteral)) {
  485. auto number = consume(TokenType::NumericLiteral).double_value();
  486. return create_ast_node<SignedNumber>(is_positive ? number : (number * -1));
  487. }
  488. expected("NumericLiteral");
  489. return create_ast_node<SignedNumber>(0);
  490. }
  491. NonnullRefPtr<CommonTableExpression> Parser::parse_common_table_expression()
  492. {
  493. // https://sqlite.org/syntax/common-table-expression.html
  494. auto table_name = consume(TokenType::Identifier).value();
  495. Vector<String> column_names;
  496. if (consume_if(TokenType::ParenOpen)) {
  497. do {
  498. column_names.append(consume(TokenType::Identifier).value());
  499. if (match(TokenType::ParenClose))
  500. break;
  501. consume(TokenType::Comma);
  502. } while (!match(TokenType::Eof));
  503. consume(TokenType::ParenClose);
  504. }
  505. consume(TokenType::As);
  506. consume(TokenType::ParenOpen);
  507. // FIXME: Parse "select-stmt".
  508. consume(TokenType::ParenClose);
  509. return create_ast_node<CommonTableExpression>(move(table_name), move(column_names));
  510. }
  511. NonnullRefPtr<QualifiedTableName> Parser::parse_qualified_table_name()
  512. {
  513. // https://sqlite.org/syntax/qualified-table-name.html
  514. String schema_or_table_name = consume(TokenType::Identifier).value();
  515. String schema_name;
  516. String table_name;
  517. if (consume_if(TokenType::Period)) {
  518. schema_name = move(schema_or_table_name);
  519. table_name = consume(TokenType::Identifier).value();
  520. } else {
  521. table_name = move(schema_or_table_name);
  522. }
  523. String alias;
  524. if (consume_if(TokenType::As))
  525. alias = consume(TokenType::Identifier).value();
  526. // Note: The qualified-table-name spec may include an "INDEXED BY index-name" or "NOT INDEXED" clause. This is a SQLite extension
  527. // "designed to help detect undesirable query plan changes during regression testing", and "application developers are admonished
  528. // to omit all use of INDEXED BY during application design, implementation, testing, and tuning". Our implementation purposefully
  529. // omits parsing INDEXED BY for now until there is good reason to add support.
  530. return create_ast_node<QualifiedTableName>(move(schema_name), move(table_name), move(alias));
  531. }
  532. NonnullRefPtr<ReturningClause> Parser::parse_returning_clause()
  533. {
  534. // https://sqlite.org/syntax/returning-clause.html
  535. consume(TokenType::Returning);
  536. if (consume_if(TokenType::Asterisk))
  537. return create_ast_node<ReturningClause>();
  538. Vector<ReturningClause::ColumnClause> columns;
  539. do {
  540. auto expression = parse_expression();
  541. consume_if(TokenType::As); // 'AS' is optional.
  542. String column_alias;
  543. if (match(TokenType::Identifier))
  544. column_alias = consume().value();
  545. columns.append({ move(expression), move(column_alias) });
  546. if (!match(TokenType::Comma))
  547. break;
  548. consume(TokenType::Comma);
  549. } while (!match(TokenType::Eof));
  550. return create_ast_node<ReturningClause>(move(columns));
  551. }
  552. Token Parser::consume()
  553. {
  554. auto old_token = m_parser_state.m_token;
  555. m_parser_state.m_token = m_parser_state.m_lexer.next();
  556. return old_token;
  557. }
  558. Token Parser::consume(TokenType expected_type)
  559. {
  560. if (!match(expected_type)) {
  561. expected(Token::name(expected_type));
  562. }
  563. return consume();
  564. }
  565. bool Parser::consume_if(TokenType expected_type)
  566. {
  567. if (!match(expected_type))
  568. return false;
  569. consume();
  570. return true;
  571. }
  572. bool Parser::match(TokenType type) const
  573. {
  574. return m_parser_state.m_token.type() == type;
  575. }
  576. void Parser::expected(StringView what)
  577. {
  578. syntax_error(String::formatted("Unexpected token {}, expected {}", m_parser_state.m_token.name(), what));
  579. }
  580. void Parser::syntax_error(String message)
  581. {
  582. m_parser_state.m_errors.append({ move(message), position() });
  583. }
  584. Parser::Position Parser::position() const
  585. {
  586. return {
  587. m_parser_state.m_token.line_number(),
  588. m_parser_state.m_token.line_column()
  589. };
  590. }
  591. Parser::ParserState::ParserState(Lexer lexer)
  592. : m_lexer(move(lexer))
  593. , m_token(m_lexer.next())
  594. {
  595. }
  596. }