1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 02:17:35 +00:00

LibSQL: Move Lexer and Parser machinery to AST directory

The SQL engine is expected to be a fairly sizeable piece of software.
Therefore we're starting to restructure the codebase for growth.
This commit is contained in:
Jan de Visser 2021-06-21 10:57:44 -04:00 committed by Andreas Kling
parent e0f1c237d2
commit 4198f7e1af
24 changed files with 281 additions and 278 deletions

View file

@ -12,29 +12,29 @@
#include <AK/StringBuilder.h>
#include <AK/StringView.h>
#include <AK/TypeCasts.h>
#include <LibSQL/Lexer.h>
#include <LibSQL/Parser.h>
#include <LibSQL/AST/Lexer.h>
#include <LibSQL/AST/Parser.h>
namespace {
class ExpressionParser : public SQL::Parser {
class ExpressionParser : public SQL::AST::Parser {
public:
explicit ExpressionParser(SQL::Lexer lexer)
: SQL::Parser(move(lexer))
explicit ExpressionParser(SQL::AST::Lexer lexer)
: SQL::AST::Parser(move(lexer))
{
}
NonnullRefPtr<SQL::Expression> parse()
NonnullRefPtr<SQL::AST::Expression> parse()
{
return SQL::Parser::parse_expression();
return SQL::AST::Parser::parse_expression();
}
};
using ParseResult = AK::Result<NonnullRefPtr<SQL::Expression>, String>;
using ParseResult = AK::Result<NonnullRefPtr<SQL::AST::Expression>, String>;
ParseResult parse(StringView sql)
{
auto parser = ExpressionParser(SQL::Lexer(sql));
auto parser = ExpressionParser(SQL::AST::Lexer(sql));
auto expression = parser.parse();
if (parser.has_errors()) {
@ -53,9 +53,9 @@ TEST_CASE(numeric_literal)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::NumericLiteral>(*expression));
EXPECT(is<SQL::AST::NumericLiteral>(*expression));
const auto& literal = static_cast<const SQL::NumericLiteral&>(*expression);
const auto& literal = static_cast<const SQL::AST::NumericLiteral&>(*expression);
EXPECT_EQ(literal.value(), expected_value);
};
@ -75,9 +75,9 @@ TEST_CASE(string_literal)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::StringLiteral>(*expression));
EXPECT(is<SQL::AST::StringLiteral>(*expression));
const auto& literal = static_cast<const SQL::StringLiteral&>(*expression);
const auto& literal = static_cast<const SQL::AST::StringLiteral&>(*expression);
EXPECT_EQ(literal.value(), expected_value);
};
@ -95,9 +95,9 @@ TEST_CASE(blob_literal)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::BlobLiteral>(*expression));
EXPECT(is<SQL::AST::BlobLiteral>(*expression));
const auto& literal = static_cast<const SQL::BlobLiteral&>(*expression);
const auto& literal = static_cast<const SQL::AST::BlobLiteral&>(*expression);
EXPECT_EQ(literal.value(), expected_value);
};
@ -112,7 +112,7 @@ TEST_CASE(null_literal)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::NullLiteral>(*expression));
EXPECT(is<SQL::AST::NullLiteral>(*expression));
};
validate("NULL");
@ -129,9 +129,9 @@ TEST_CASE(column_name)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::ColumnNameExpression>(*expression));
EXPECT(is<SQL::AST::ColumnNameExpression>(*expression));
const auto& column = static_cast<const SQL::ColumnNameExpression&>(*expression);
const auto& column = static_cast<const SQL::AST::ColumnNameExpression&>(*expression);
EXPECT_EQ(column.schema_name(), expected_schema);
EXPECT_EQ(column.table_name(), expected_table);
EXPECT_EQ(column.column_name(), expected_column);
@ -152,49 +152,49 @@ TEST_CASE(unary_operator)
EXPECT(parse("~~").is_error());
EXPECT(parse("NOT").is_error());
auto validate = [](StringView sql, SQL::UnaryOperator expected_operator) {
auto validate = [](StringView sql, SQL::AST::UnaryOperator expected_operator) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::UnaryOperatorExpression>(*expression));
EXPECT(is<SQL::AST::UnaryOperatorExpression>(*expression));
const auto& unary = static_cast<const SQL::UnaryOperatorExpression&>(*expression);
const auto& unary = static_cast<const SQL::AST::UnaryOperatorExpression&>(*expression);
EXPECT_EQ(unary.type(), expected_operator);
const auto& secondary_expression = unary.expression();
EXPECT(!is<SQL::ErrorExpression>(*secondary_expression));
EXPECT(!is<SQL::AST::ErrorExpression>(*secondary_expression));
};
validate("-15", SQL::UnaryOperator::Minus);
validate("+15", SQL::UnaryOperator::Plus);
validate("~15", SQL::UnaryOperator::BitwiseNot);
validate("NOT 15", SQL::UnaryOperator::Not);
validate("-15", SQL::AST::UnaryOperator::Minus);
validate("+15", SQL::AST::UnaryOperator::Plus);
validate("~15", SQL::AST::UnaryOperator::BitwiseNot);
validate("NOT 15", SQL::AST::UnaryOperator::Not);
}
TEST_CASE(binary_operator)
{
HashMap<StringView, SQL::BinaryOperator> operators {
{ "||", SQL::BinaryOperator::Concatenate },
{ "*", SQL::BinaryOperator::Multiplication },
{ "/", SQL::BinaryOperator::Division },
{ "%", SQL::BinaryOperator::Modulo },
{ "+", SQL::BinaryOperator::Plus },
{ "-", SQL::BinaryOperator::Minus },
{ "<<", SQL::BinaryOperator::ShiftLeft },
{ ">>", SQL::BinaryOperator::ShiftRight },
{ "&", SQL::BinaryOperator::BitwiseAnd },
{ "|", SQL::BinaryOperator::BitwiseOr },
{ "<", SQL::BinaryOperator::LessThan },
{ "<=", SQL::BinaryOperator::LessThanEquals },
{ ">", SQL::BinaryOperator::GreaterThan },
{ ">=", SQL::BinaryOperator::GreaterThanEquals },
{ "=", SQL::BinaryOperator::Equals },
{ "==", SQL::BinaryOperator::Equals },
{ "!=", SQL::BinaryOperator::NotEquals },
{ "<>", SQL::BinaryOperator::NotEquals },
{ "AND", SQL::BinaryOperator::And },
{ "OR", SQL::BinaryOperator::Or },
HashMap<StringView, SQL::AST::BinaryOperator> operators {
{ "||", SQL::AST::BinaryOperator::Concatenate },
{ "*", SQL::AST::BinaryOperator::Multiplication },
{ "/", SQL::AST::BinaryOperator::Division },
{ "%", SQL::AST::BinaryOperator::Modulo },
{ "+", SQL::AST::BinaryOperator::Plus },
{ "-", SQL::AST::BinaryOperator::Minus },
{ "<<", SQL::AST::BinaryOperator::ShiftLeft },
{ ">>", SQL::AST::BinaryOperator::ShiftRight },
{ "&", SQL::AST::BinaryOperator::BitwiseAnd },
{ "|", SQL::AST::BinaryOperator::BitwiseOr },
{ "<", SQL::AST::BinaryOperator::LessThan },
{ "<=", SQL::AST::BinaryOperator::LessThanEquals },
{ ">", SQL::AST::BinaryOperator::GreaterThan },
{ ">=", SQL::AST::BinaryOperator::GreaterThanEquals },
{ "=", SQL::AST::BinaryOperator::Equals },
{ "==", SQL::AST::BinaryOperator::Equals },
{ "!=", SQL::AST::BinaryOperator::NotEquals },
{ "<>", SQL::AST::BinaryOperator::NotEquals },
{ "AND", SQL::AST::BinaryOperator::And },
{ "OR", SQL::AST::BinaryOperator::Or },
};
for (auto op : operators) {
@ -214,16 +214,16 @@ TEST_CASE(binary_operator)
}
}
auto validate = [](StringView sql, SQL::BinaryOperator expected_operator) {
auto validate = [](StringView sql, SQL::AST::BinaryOperator expected_operator) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::BinaryOperatorExpression>(*expression));
EXPECT(is<SQL::AST::BinaryOperatorExpression>(*expression));
const auto& binary = static_cast<const SQL::BinaryOperatorExpression&>(*expression);
EXPECT(!is<SQL::ErrorExpression>(*binary.lhs()));
EXPECT(!is<SQL::ErrorExpression>(*binary.rhs()));
const auto& binary = static_cast<const SQL::AST::BinaryOperatorExpression&>(*expression);
EXPECT(!is<SQL::AST::ErrorExpression>(*binary.lhs()));
EXPECT(!is<SQL::AST::ErrorExpression>(*binary.rhs()));
EXPECT_EQ(binary.type(), expected_operator);
};
@ -247,13 +247,13 @@ TEST_CASE(chained_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::ChainedExpression>(*expression));
EXPECT(is<SQL::AST::ChainedExpression>(*expression));
const auto& chain = static_cast<const SQL::ChainedExpression&>(*expression).expressions();
const auto& chain = static_cast<const SQL::AST::ChainedExpression&>(*expression).expressions();
EXPECT_EQ(chain.size(), expected_chain_size);
for (const auto& chained_expression : chain)
EXPECT(!is<SQL::ErrorExpression>(chained_expression));
EXPECT(!is<SQL::AST::ErrorExpression>(chained_expression));
};
validate("(15)", 1);
@ -276,10 +276,10 @@ TEST_CASE(cast_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::CastExpression>(*expression));
EXPECT(is<SQL::AST::CastExpression>(*expression));
const auto& cast = static_cast<const SQL::CastExpression&>(*expression);
EXPECT(!is<SQL::ErrorExpression>(*cast.expression()));
const auto& cast = static_cast<const SQL::AST::CastExpression&>(*expression);
EXPECT(!is<SQL::AST::ErrorExpression>(*cast.expression()));
const auto& type_name = cast.type_name();
EXPECT_EQ(type_name->name(), expected_type_name);
@ -307,26 +307,26 @@ TEST_CASE(case_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::CaseExpression>(*expression));
EXPECT(is<SQL::AST::CaseExpression>(*expression));
const auto& case_ = static_cast<const SQL::CaseExpression&>(*expression);
const auto& case_ = static_cast<const SQL::AST::CaseExpression&>(*expression);
const auto& case_expression = case_.case_expression();
EXPECT_EQ(case_expression.is_null(), !expect_case_expression);
if (case_expression)
EXPECT(!is<SQL::ErrorExpression>(*case_expression));
EXPECT(!is<SQL::AST::ErrorExpression>(*case_expression));
const auto& when_then_clauses = case_.when_then_clauses();
EXPECT_EQ(when_then_clauses.size(), expected_when_then_size);
for (const auto& when_then_clause : when_then_clauses) {
EXPECT(!is<SQL::ErrorExpression>(*when_then_clause.when));
EXPECT(!is<SQL::ErrorExpression>(*when_then_clause.then));
EXPECT(!is<SQL::AST::ErrorExpression>(*when_then_clause.when));
EXPECT(!is<SQL::AST::ErrorExpression>(*when_then_clause.then));
}
const auto& else_expression = case_.else_expression();
EXPECT_EQ(else_expression.is_null(), !expect_else_expression);
if (else_expression)
EXPECT(!is<SQL::ErrorExpression>(*else_expression));
EXPECT(!is<SQL::AST::ErrorExpression>(*else_expression));
};
validate("CASE WHEN 16 THEN 17 END", false, 1, false);
@ -360,9 +360,9 @@ TEST_CASE(exists_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::ExistsExpression>(*expression));
EXPECT(is<SQL::AST::ExistsExpression>(*expression));
const auto& exists = static_cast<const SQL::ExistsExpression&>(*expression);
const auto& exists = static_cast<const SQL::AST::ExistsExpression&>(*expression);
EXPECT_EQ(exists.invert_expression(), expected_invert_expression);
};
@ -382,10 +382,10 @@ TEST_CASE(collate_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::CollateExpression>(*expression));
EXPECT(is<SQL::AST::CollateExpression>(*expression));
const auto& collate = static_cast<const SQL::CollateExpression&>(*expression);
EXPECT(!is<SQL::ErrorExpression>(*collate.expression()));
const auto& collate = static_cast<const SQL::AST::CollateExpression&>(*expression);
EXPECT(!is<SQL::AST::ErrorExpression>(*collate.expression()));
EXPECT_EQ(collate.collation_name(), expected_collation_name);
};
@ -407,11 +407,11 @@ TEST_CASE(is_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::IsExpression>(*expression));
EXPECT(is<SQL::AST::IsExpression>(*expression));
const auto& is_ = static_cast<const SQL::IsExpression&>(*expression);
EXPECT(!is<SQL::ErrorExpression>(*is_.lhs()));
EXPECT(!is<SQL::ErrorExpression>(*is_.rhs()));
const auto& is_ = static_cast<const SQL::AST::IsExpression&>(*expression);
EXPECT(!is<SQL::AST::ErrorExpression>(*is_.lhs()));
EXPECT(!is<SQL::AST::ErrorExpression>(*is_.rhs()));
EXPECT_EQ(is_.invert_expression(), expected_invert_expression);
};
@ -421,11 +421,11 @@ TEST_CASE(is_expression)
TEST_CASE(match_expression)
{
HashMap<StringView, SQL::MatchOperator> operators {
{ "LIKE", SQL::MatchOperator::Like },
{ "GLOB", SQL::MatchOperator::Glob },
{ "MATCH", SQL::MatchOperator::Match },
{ "REGEXP", SQL::MatchOperator::Regexp },
HashMap<StringView, SQL::AST::MatchOperator> operators {
{ "LIKE", SQL::AST::MatchOperator::Like },
{ "GLOB", SQL::AST::MatchOperator::Glob },
{ "MATCH", SQL::AST::MatchOperator::Match },
{ "REGEXP", SQL::AST::MatchOperator::Regexp },
};
for (auto op : operators) {
@ -442,16 +442,16 @@ TEST_CASE(match_expression)
EXPECT(parse(builder.build()).is_error());
}
auto validate = [](StringView sql, SQL::MatchOperator expected_operator, bool expected_invert_expression) {
auto validate = [](StringView sql, SQL::AST::MatchOperator expected_operator, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::MatchExpression>(*expression));
EXPECT(is<SQL::AST::MatchExpression>(*expression));
const auto& match = static_cast<const SQL::MatchExpression&>(*expression);
EXPECT(!is<SQL::ErrorExpression>(*match.lhs()));
EXPECT(!is<SQL::ErrorExpression>(*match.rhs()));
const auto& match = static_cast<const SQL::AST::MatchExpression&>(*expression);
EXPECT(!is<SQL::AST::ErrorExpression>(*match.lhs()));
EXPECT(!is<SQL::AST::ErrorExpression>(*match.rhs()));
EXPECT_EQ(match.type(), expected_operator);
EXPECT_EQ(match.invert_expression(), expected_invert_expression);
};
@ -482,9 +482,9 @@ TEST_CASE(null_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::NullExpression>(*expression));
EXPECT(is<SQL::AST::NullExpression>(*expression));
const auto& null = static_cast<const SQL::NullExpression&>(*expression);
const auto& null = static_cast<const SQL::AST::NullExpression&>(*expression);
EXPECT_EQ(null.invert_expression(), expected_invert_expression);
};
@ -509,12 +509,12 @@ TEST_CASE(between_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::BetweenExpression>(*expression));
EXPECT(is<SQL::AST::BetweenExpression>(*expression));
const auto& between = static_cast<const SQL::BetweenExpression&>(*expression);
EXPECT(!is<SQL::ErrorExpression>(*between.expression()));
EXPECT(!is<SQL::ErrorExpression>(*between.lhs()));
EXPECT(!is<SQL::ErrorExpression>(*between.rhs()));
const auto& between = static_cast<const SQL::AST::BetweenExpression&>(*expression);
EXPECT(!is<SQL::AST::ErrorExpression>(*between.expression()));
EXPECT(!is<SQL::AST::ErrorExpression>(*between.lhs()));
EXPECT(!is<SQL::AST::ErrorExpression>(*between.rhs()));
EXPECT_EQ(between.invert_expression(), expected_invert_expression);
};
@ -534,10 +534,10 @@ TEST_CASE(in_table_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::InTableExpression>(*expression));
EXPECT(is<SQL::AST::InTableExpression>(*expression));
const auto& in = static_cast<const SQL::InTableExpression&>(*expression);
EXPECT(!is<SQL::ErrorExpression>(*in.expression()));
const auto& in = static_cast<const SQL::AST::InTableExpression&>(*expression);
EXPECT(!is<SQL::AST::ErrorExpression>(*in.expression()));
EXPECT_EQ(in.schema_name(), expected_schema);
EXPECT_EQ(in.table_name(), expected_table);
EXPECT_EQ(in.invert_expression(), expected_invert_expression);
@ -560,15 +560,15 @@ TEST_CASE(in_chained_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::InChainedExpression>(*expression));
EXPECT(is<SQL::AST::InChainedExpression>(*expression));
const auto& in = static_cast<const SQL::InChainedExpression&>(*expression);
EXPECT(!is<SQL::ErrorExpression>(*in.expression()));
const auto& in = static_cast<const SQL::AST::InChainedExpression&>(*expression);
EXPECT(!is<SQL::AST::ErrorExpression>(*in.expression()));
EXPECT_EQ(in.expression_chain()->expressions().size(), expected_chain_size);
EXPECT_EQ(in.invert_expression(), expected_invert_expression);
for (const auto& chained_expression : in.expression_chain()->expressions())
EXPECT(!is<SQL::ErrorExpression>(chained_expression));
EXPECT(!is<SQL::AST::ErrorExpression>(chained_expression));
};
validate("15 IN ()", 0, false);
@ -592,10 +592,10 @@ TEST_CASE(in_selection_expression)
EXPECT(!result.is_error());
auto expression = result.release_value();
EXPECT(is<SQL::InSelectionExpression>(*expression));
EXPECT(is<SQL::AST::InSelectionExpression>(*expression));
const auto& in = static_cast<const SQL::InSelectionExpression&>(*expression);
EXPECT(!is<SQL::ErrorExpression>(*in.expression()));
const auto& in = static_cast<const SQL::AST::InSelectionExpression&>(*expression);
EXPECT(!is<SQL::AST::ErrorExpression>(*in.expression()));
EXPECT_EQ(in.invert_expression(), expected_invert_expression);
};
@ -605,7 +605,7 @@ TEST_CASE(in_selection_expression)
TEST_CASE(expression_tree_depth_limit)
{
auto too_deep_expression = String::formatted("{:+^{}}1", "", SQL::Limits::maximum_expression_tree_depth);
auto too_deep_expression = String::formatted("{:+^{}}1", "", SQL::AST::Limits::maximum_expression_tree_depth);
EXPECT(!parse(too_deep_expression.substring_view(1)).is_error());
EXPECT(parse(too_deep_expression).is_error());
}