RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 16:57:35 +00:00
Code Issues Activity Actions

LibSQL: Move Lexer and Parser machinery to AST directory

Browse source 
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
Download patch file Download diff file Expand all files Collapse all files

202
Tests/LibSQL/TestSqlExpressionParser.cpp
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());
}