mirror of
https://github.com/RGBCube/serenity
synced 2025-07-27 16:07:46 +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
Andreas Kling
parent
e0f1c237d2
commit
4198f7e1af
24 changed files with 281 additions and 278 deletions
|
|
@ -127,7 +127,7 @@ void insert_into_and_scan_btree(int num_keys);
|
|||
NonnullRefPtr<SQL::BTree> setup_btree(SQL::Heap& heap)
|
||||
{
|
||||
SQL::TupleDescriptor tuple_descriptor;
|
||||
tuple_descriptor.append({ "key_value", SQL::SQLType::Integer, SQL::Order::Ascending });
|
||||
tuple_descriptor.append({ "key_value", SQL::SQLType::Integer, SQL::AST::Order::Ascending });
|
||||
|
||||
auto root_pointer = heap.user_value(0);
|
||||
if (!root_pointer) {
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -124,8 +124,8 @@ void insert_into_and_scan_hash_index(int num_keys);
|
|||
NonnullRefPtr<SQL::HashIndex> setup_hash_index(SQL::Heap& heap)
|
||||
{
|
||||
SQL::TupleDescriptor tuple_descriptor;
|
||||
tuple_descriptor.append({ "key_value", SQL::SQLType::Integer, SQL::Order::Ascending });
|
||||
tuple_descriptor.append({ "text_value", SQL::SQLType::Text, SQL::Order::Ascending });
|
||||
tuple_descriptor.append({ "key_value", SQL::SQLType::Integer, SQL::AST::Order::Ascending });
|
||||
tuple_descriptor.append({ "text_value", SQL::SQLType::Text, SQL::AST::Order::Ascending });
|
||||
|
||||
auto directory_pointer = heap.user_value(0);
|
||||
if (!directory_pointer) {
|
||||
|
|
|
|||
|
|
@ -12,16 +12,16 @@
|
|||
#include <AK/StringView.h>
|
||||
#include <AK/TypeCasts.h>
|
||||
#include <AK/Vector.h>
|
||||
#include <LibSQL/Lexer.h>
|
||||
#include <LibSQL/Parser.h>
|
||||
#include <LibSQL/AST/Lexer.h>
|
||||
#include <LibSQL/AST/Parser.h>
|
||||
|
||||
namespace {
|
||||
|
||||
using ParseResult = AK::Result<NonnullRefPtr<SQL::Statement>, String>;
|
||||
using ParseResult = AK::Result<NonnullRefPtr<SQL::AST::Statement>, String>;
|
||||
|
||||
ParseResult parse(StringView sql)
|
||||
{
|
||||
auto parser = SQL::Parser(SQL::Lexer(sql));
|
||||
auto parser = SQL::AST::Parser(SQL::AST::Lexer(sql));
|
||||
auto statement = parser.next_statement();
|
||||
|
||||
if (parser.has_errors()) {
|
||||
|
|
@ -70,9 +70,9 @@ TEST_CASE(create_table)
|
|||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::CreateTable>(*statement));
|
||||
EXPECT(is<SQL::AST::CreateTable>(*statement));
|
||||
|
||||
const auto& table = static_cast<const SQL::CreateTable&>(*statement);
|
||||
const auto& table = static_cast<const SQL::AST::CreateTable&>(*statement);
|
||||
EXPECT_EQ(table.schema_name(), expected_schema);
|
||||
EXPECT_EQ(table.table_name(), expected_table);
|
||||
EXPECT_EQ(table.is_temporary(), expected_is_temporary);
|
||||
|
|
@ -145,9 +145,9 @@ TEST_CASE(alter_table_rename_table)
|
|||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::RenameTable>(*statement));
|
||||
EXPECT(is<SQL::AST::RenameTable>(*statement));
|
||||
|
||||
const auto& alter = static_cast<const SQL::RenameTable&>(*statement);
|
||||
const auto& alter = static_cast<const SQL::AST::RenameTable&>(*statement);
|
||||
EXPECT_EQ(alter.schema_name(), expected_schema);
|
||||
EXPECT_EQ(alter.table_name(), expected_table);
|
||||
EXPECT_EQ(alter.new_table_name(), expected_new_table);
|
||||
|
|
@ -173,9 +173,9 @@ TEST_CASE(alter_table_rename_column)
|
|||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::RenameColumn>(*statement));
|
||||
EXPECT(is<SQL::AST::RenameColumn>(*statement));
|
||||
|
||||
const auto& alter = static_cast<const SQL::RenameColumn&>(*statement);
|
||||
const auto& alter = static_cast<const SQL::AST::RenameColumn&>(*statement);
|
||||
EXPECT_EQ(alter.schema_name(), expected_schema);
|
||||
EXPECT_EQ(alter.table_name(), expected_table);
|
||||
EXPECT_EQ(alter.column_name(), expected_column);
|
||||
|
|
@ -205,9 +205,9 @@ TEST_CASE(alter_table_add_column)
|
|||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::AddColumn>(*statement));
|
||||
EXPECT(is<SQL::AST::AddColumn>(*statement));
|
||||
|
||||
const auto& alter = static_cast<const SQL::AddColumn&>(*statement);
|
||||
const auto& alter = static_cast<const SQL::AST::AddColumn&>(*statement);
|
||||
EXPECT_EQ(alter.schema_name(), expected_schema);
|
||||
EXPECT_EQ(alter.table_name(), expected_table);
|
||||
|
||||
|
|
@ -252,9 +252,9 @@ TEST_CASE(alter_table_drop_column)
|
|||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::DropColumn>(*statement));
|
||||
EXPECT(is<SQL::AST::DropColumn>(*statement));
|
||||
|
||||
const auto& alter = static_cast<const SQL::DropColumn&>(*statement);
|
||||
const auto& alter = static_cast<const SQL::AST::DropColumn&>(*statement);
|
||||
EXPECT_EQ(alter.schema_name(), expected_schema);
|
||||
EXPECT_EQ(alter.table_name(), expected_table);
|
||||
EXPECT_EQ(alter.column_name(), expected_column);
|
||||
|
|
@ -278,9 +278,9 @@ TEST_CASE(drop_table)
|
|||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::DropTable>(*statement));
|
||||
EXPECT(is<SQL::AST::DropTable>(*statement));
|
||||
|
||||
const auto& table = static_cast<const SQL::DropTable&>(*statement);
|
||||
const auto& table = static_cast<const SQL::AST::DropTable&>(*statement);
|
||||
EXPECT_EQ(table.schema_name(), expected_schema);
|
||||
EXPECT_EQ(table.table_name(), expected_table);
|
||||
EXPECT_EQ(table.is_error_if_table_does_not_exist(), expected_is_error_if_table_does_not_exist);
|
||||
|
|
@ -306,14 +306,14 @@ TEST_CASE(insert)
|
|||
EXPECT(parse("INSERT OR INTO table DEFAULT VALUES;").is_error());
|
||||
EXPECT(parse("INSERT OR foo INTO table DEFAULT VALUES;").is_error());
|
||||
|
||||
auto validate = [](StringView sql, SQL::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<StringView> expected_column_names, Vector<size_t> expected_chain_sizes, bool expect_select_statement) {
|
||||
auto validate = [](StringView sql, SQL::AST::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<StringView> expected_column_names, Vector<size_t> expected_chain_sizes, bool expect_select_statement) {
|
||||
auto result = parse(sql);
|
||||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::Insert>(*statement));
|
||||
EXPECT(is<SQL::AST::Insert>(*statement));
|
||||
|
||||
const auto& insert = static_cast<const SQL::Insert&>(*statement);
|
||||
const auto& insert = static_cast<const SQL::AST::Insert&>(*statement);
|
||||
EXPECT_EQ(insert.conflict_resolution(), expected_conflict_resolution);
|
||||
EXPECT_EQ(insert.schema_name(), expected_schema);
|
||||
EXPECT_EQ(insert.table_name(), expected_table);
|
||||
|
|
@ -335,7 +335,7 @@ TEST_CASE(insert)
|
|||
EXPECT_EQ(expressions.size(), expected_chain_sizes[i]);
|
||||
|
||||
for (const auto& expression : expressions)
|
||||
EXPECT(!is<SQL::ErrorExpression>(expression));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(expression));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -343,13 +343,13 @@ TEST_CASE(insert)
|
|||
EXPECT_EQ(insert.default_values(), expected_chain_sizes.is_empty() && !expect_select_statement);
|
||||
};
|
||||
|
||||
validate("INSERT OR ABORT INTO table DEFAULT VALUES;", SQL::ConflictResolution::Abort, {}, "table", {}, {}, {}, false);
|
||||
validate("INSERT OR FAIL INTO table DEFAULT VALUES;", SQL::ConflictResolution::Fail, {}, "table", {}, {}, {}, false);
|
||||
validate("INSERT OR IGNORE INTO table DEFAULT VALUES;", SQL::ConflictResolution::Ignore, {}, "table", {}, {}, {}, false);
|
||||
validate("INSERT OR REPLACE INTO table DEFAULT VALUES;", SQL::ConflictResolution::Replace, {}, "table", {}, {}, {}, false);
|
||||
validate("INSERT OR ROLLBACK INTO table DEFAULT VALUES;", SQL::ConflictResolution::Rollback, {}, "table", {}, {}, {}, false);
|
||||
validate("INSERT OR ABORT INTO table DEFAULT VALUES;", SQL::AST::ConflictResolution::Abort, {}, "table", {}, {}, {}, false);
|
||||
validate("INSERT OR FAIL INTO table DEFAULT VALUES;", SQL::AST::ConflictResolution::Fail, {}, "table", {}, {}, {}, false);
|
||||
validate("INSERT OR IGNORE INTO table DEFAULT VALUES;", SQL::AST::ConflictResolution::Ignore, {}, "table", {}, {}, {}, false);
|
||||
validate("INSERT OR REPLACE INTO table DEFAULT VALUES;", SQL::AST::ConflictResolution::Replace, {}, "table", {}, {}, {}, false);
|
||||
validate("INSERT OR ROLLBACK INTO table DEFAULT VALUES;", SQL::AST::ConflictResolution::Rollback, {}, "table", {}, {}, {}, false);
|
||||
|
||||
auto resolution = SQL::ConflictResolution::Abort;
|
||||
auto resolution = SQL::AST::ConflictResolution::Abort;
|
||||
validate("INSERT INTO table DEFAULT VALUES;", resolution, {}, "table", {}, {}, {}, false);
|
||||
validate("INSERT INTO schema.table DEFAULT VALUES;", resolution, "schema", "table", {}, {}, {}, false);
|
||||
validate("INSERT INTO table AS foo DEFAULT VALUES;", resolution, {}, "table", "foo", {}, {}, false);
|
||||
|
|
@ -386,14 +386,14 @@ TEST_CASE(update)
|
|||
EXPECT(parse("UPDATE OR table SET column=4;").is_error());
|
||||
EXPECT(parse("UPDATE OR foo table SET column=4;").is_error());
|
||||
|
||||
auto validate = [](StringView sql, SQL::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<Vector<String>> expected_update_columns, bool expect_where_clause, bool expect_returning_clause, Vector<StringView> expected_returned_column_aliases) {
|
||||
auto validate = [](StringView sql, SQL::AST::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<Vector<String>> expected_update_columns, bool expect_where_clause, bool expect_returning_clause, Vector<StringView> expected_returned_column_aliases) {
|
||||
auto result = parse(sql);
|
||||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::Update>(*statement));
|
||||
EXPECT(is<SQL::AST::Update>(*statement));
|
||||
|
||||
const auto& update = static_cast<const SQL::Update&>(*statement);
|
||||
const auto& update = static_cast<const SQL::AST::Update&>(*statement);
|
||||
EXPECT_EQ(update.conflict_resolution(), expected_conflict_resolution);
|
||||
|
||||
const auto& qualified_table_name = update.qualified_table_name();
|
||||
|
|
@ -407,7 +407,7 @@ TEST_CASE(update)
|
|||
const auto& update_column = update_columns[i];
|
||||
const auto& expected_update_column = expected_update_columns[i];
|
||||
EXPECT_EQ(update_column.column_names.size(), expected_update_column.size());
|
||||
EXPECT(!is<SQL::ErrorExpression>(*update_column.expression));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(*update_column.expression));
|
||||
|
||||
for (size_t j = 0; j < update_column.column_names.size(); ++j)
|
||||
EXPECT_EQ(update_column.column_names[j], expected_update_column[j]);
|
||||
|
|
@ -416,7 +416,7 @@ TEST_CASE(update)
|
|||
const auto& where_clause = update.where_clause();
|
||||
EXPECT_EQ(where_clause.is_null(), !expect_where_clause);
|
||||
if (where_clause)
|
||||
EXPECT(!is<SQL::ErrorExpression>(*where_clause));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(*where_clause));
|
||||
|
||||
const auto& returning_clause = update.returning_clause();
|
||||
EXPECT_EQ(returning_clause.is_null(), !expect_returning_clause);
|
||||
|
|
@ -427,20 +427,20 @@ TEST_CASE(update)
|
|||
const auto& column = returning_clause->columns()[i];
|
||||
const auto& expected_column_alias = expected_returned_column_aliases[i];
|
||||
|
||||
EXPECT(!is<SQL::ErrorExpression>(*column.expression));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(*column.expression));
|
||||
EXPECT_EQ(column.column_alias, expected_column_alias);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Vector<Vector<String>> update_columns { { "column" } };
|
||||
validate("UPDATE OR ABORT table SET column=1;", SQL::ConflictResolution::Abort, {}, "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE OR FAIL table SET column=1;", SQL::ConflictResolution::Fail, {}, "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE OR IGNORE table SET column=1;", SQL::ConflictResolution::Ignore, {}, "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE OR REPLACE table SET column=1;", SQL::ConflictResolution::Replace, {}, "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE OR ROLLBACK table SET column=1;", SQL::ConflictResolution::Rollback, {}, "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE OR ABORT table SET column=1;", SQL::AST::ConflictResolution::Abort, {}, "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE OR FAIL table SET column=1;", SQL::AST::ConflictResolution::Fail, {}, "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE OR IGNORE table SET column=1;", SQL::AST::ConflictResolution::Ignore, {}, "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE OR REPLACE table SET column=1;", SQL::AST::ConflictResolution::Replace, {}, "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE OR ROLLBACK table SET column=1;", SQL::AST::ConflictResolution::Rollback, {}, "table", {}, update_columns, false, false, {});
|
||||
|
||||
auto resolution = SQL::ConflictResolution::Abort;
|
||||
auto resolution = SQL::AST::ConflictResolution::Abort;
|
||||
validate("UPDATE table SET column=1;", resolution, {}, "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE schema.table SET column=1;", resolution, "schema", "table", {}, update_columns, false, false, {});
|
||||
validate("UPDATE table AS foo SET column=1;", resolution, {}, "table", "foo", update_columns, false, false, {});
|
||||
|
|
@ -475,9 +475,9 @@ TEST_CASE(delete_)
|
|||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::Delete>(*statement));
|
||||
EXPECT(is<SQL::AST::Delete>(*statement));
|
||||
|
||||
const auto& delete_ = static_cast<const SQL::Delete&>(*statement);
|
||||
const auto& delete_ = static_cast<const SQL::AST::Delete&>(*statement);
|
||||
|
||||
const auto& qualified_table_name = delete_.qualified_table_name();
|
||||
EXPECT_EQ(qualified_table_name->schema_name(), expected_schema);
|
||||
|
|
@ -487,7 +487,7 @@ TEST_CASE(delete_)
|
|||
const auto& where_clause = delete_.where_clause();
|
||||
EXPECT_EQ(where_clause.is_null(), !expect_where_clause);
|
||||
if (where_clause)
|
||||
EXPECT(!is<SQL::ErrorExpression>(*where_clause));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(*where_clause));
|
||||
|
||||
const auto& returning_clause = delete_.returning_clause();
|
||||
EXPECT_EQ(returning_clause.is_null(), !expect_returning_clause);
|
||||
|
|
@ -498,7 +498,7 @@ TEST_CASE(delete_)
|
|||
const auto& column = returning_clause->columns()[i];
|
||||
const auto& expected_column_alias = expected_returned_column_aliases[i];
|
||||
|
||||
EXPECT(!is<SQL::ErrorExpression>(*column.expression));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(*column.expression));
|
||||
EXPECT_EQ(column.column_alias, expected_column_alias);
|
||||
}
|
||||
}
|
||||
|
|
@ -550,7 +550,7 @@ TEST_CASE(select)
|
|||
EXPECT(parse("SELECT * FROM table LIMIT 15, 16;").is_error());
|
||||
|
||||
struct Type {
|
||||
SQL::ResultType type;
|
||||
SQL::AST::ResultType type;
|
||||
StringView table_name_or_column_alias {};
|
||||
};
|
||||
|
||||
|
|
@ -562,8 +562,8 @@ TEST_CASE(select)
|
|||
|
||||
struct Ordering {
|
||||
String collation_name;
|
||||
SQL::Order order;
|
||||
SQL::Nulls nulls;
|
||||
SQL::AST::Order order;
|
||||
SQL::AST::Nulls nulls;
|
||||
};
|
||||
|
||||
auto validate = [](StringView sql, Vector<Type> expected_columns, Vector<From> expected_from_list, bool expect_where_clause, size_t expected_group_by_size, bool expect_having_clause, Vector<Ordering> expected_ordering, bool expect_limit_clause, bool expect_offset_clause) {
|
||||
|
|
@ -571,9 +571,9 @@ TEST_CASE(select)
|
|||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::Select>(*statement));
|
||||
EXPECT(is<SQL::AST::Select>(*statement));
|
||||
|
||||
const auto& select = static_cast<const SQL::Select&>(*statement);
|
||||
const auto& select = static_cast<const SQL::AST::Select&>(*statement);
|
||||
|
||||
const auto& result_column_list = select.result_column_list();
|
||||
EXPECT_EQ(result_column_list.size(), expected_columns.size());
|
||||
|
|
@ -583,13 +583,13 @@ TEST_CASE(select)
|
|||
EXPECT_EQ(result_column.type(), expected_column.type);
|
||||
|
||||
switch (result_column.type()) {
|
||||
case SQL::ResultType::All:
|
||||
case SQL::AST::ResultType::All:
|
||||
EXPECT(expected_column.table_name_or_column_alias.is_null());
|
||||
break;
|
||||
case SQL::ResultType::Table:
|
||||
case SQL::AST::ResultType::Table:
|
||||
EXPECT_EQ(result_column.table_name(), expected_column.table_name_or_column_alias);
|
||||
break;
|
||||
case SQL::ResultType::Expression:
|
||||
case SQL::AST::ResultType::Expression:
|
||||
EXPECT_EQ(result_column.column_alias(), expected_column.table_name_or_column_alias);
|
||||
break;
|
||||
}
|
||||
|
|
@ -608,7 +608,7 @@ TEST_CASE(select)
|
|||
const auto& where_clause = select.where_clause();
|
||||
EXPECT_EQ(where_clause.is_null(), !expect_where_clause);
|
||||
if (where_clause)
|
||||
EXPECT(!is<SQL::ErrorExpression>(*where_clause));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(*where_clause));
|
||||
|
||||
const auto& group_by_clause = select.group_by_clause();
|
||||
EXPECT_EQ(group_by_clause.is_null(), (expected_group_by_size == 0));
|
||||
|
|
@ -616,12 +616,12 @@ TEST_CASE(select)
|
|||
const auto& group_by_list = group_by_clause->group_by_list();
|
||||
EXPECT_EQ(group_by_list.size(), expected_group_by_size);
|
||||
for (size_t i = 0; i < group_by_list.size(); ++i)
|
||||
EXPECT(!is<SQL::ErrorExpression>(group_by_list[i]));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(group_by_list[i]));
|
||||
|
||||
const auto& having_clause = group_by_clause->having_clause();
|
||||
EXPECT_EQ(having_clause.is_null(), !expect_having_clause);
|
||||
if (having_clause)
|
||||
EXPECT(!is<SQL::ErrorExpression>(*having_clause));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(*having_clause));
|
||||
}
|
||||
|
||||
const auto& ordering_term_list = select.ordering_term_list();
|
||||
|
|
@ -629,7 +629,7 @@ TEST_CASE(select)
|
|||
for (size_t i = 0; i < ordering_term_list.size(); ++i) {
|
||||
const auto& result_order = ordering_term_list[i];
|
||||
const auto& expected_order = expected_ordering[i];
|
||||
EXPECT(!is<SQL::ErrorExpression>(*result_order.expression()));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(*result_order.expression()));
|
||||
EXPECT_EQ(result_order.collation_name(), expected_order.collation_name);
|
||||
EXPECT_EQ(result_order.order(), expected_order.order);
|
||||
EXPECT_EQ(result_order.nulls(), expected_order.nulls);
|
||||
|
|
@ -639,24 +639,24 @@ TEST_CASE(select)
|
|||
EXPECT_EQ(limit_clause.is_null(), !expect_limit_clause);
|
||||
if (limit_clause) {
|
||||
const auto& limit_expression = limit_clause->limit_expression();
|
||||
EXPECT(!is<SQL::ErrorExpression>(*limit_expression));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(*limit_expression));
|
||||
|
||||
const auto& offset_expression = limit_clause->offset_expression();
|
||||
EXPECT_EQ(offset_expression.is_null(), !expect_offset_clause);
|
||||
if (offset_expression)
|
||||
EXPECT(!is<SQL::ErrorExpression>(*offset_expression));
|
||||
EXPECT(!is<SQL::AST::ErrorExpression>(*offset_expression));
|
||||
}
|
||||
};
|
||||
|
||||
Vector<Type> all { { SQL::ResultType::All } };
|
||||
Vector<Type> all { { SQL::AST::ResultType::All } };
|
||||
Vector<From> from { { {}, "table", {} } };
|
||||
|
||||
validate("SELECT * FROM table;", { { SQL::ResultType::All } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT table.* FROM table;", { { SQL::ResultType::Table, "table" } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT column AS alias FROM table;", { { SQL::ResultType::Expression, "alias" } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT table.column AS alias FROM table;", { { SQL::ResultType::Expression, "alias" } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT schema.table.column AS alias FROM table;", { { SQL::ResultType::Expression, "alias" } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT column AS alias, *, table.* FROM table;", { { SQL::ResultType::Expression, "alias" }, { SQL::ResultType::All }, { SQL::ResultType::Table, "table" } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT * FROM table;", { { SQL::AST::ResultType::All } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT table.* FROM table;", { { SQL::AST::ResultType::Table, "table" } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT column AS alias FROM table;", { { SQL::AST::ResultType::Expression, "alias" } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT table.column AS alias FROM table;", { { SQL::AST::ResultType::Expression, "alias" } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT schema.table.column AS alias FROM table;", { { SQL::AST::ResultType::Expression, "alias" } }, from, false, 0, false, {}, false, false);
|
||||
validate("SELECT column AS alias, *, table.* FROM table;", { { SQL::AST::ResultType::Expression, "alias" }, { SQL::AST::ResultType::All }, { SQL::AST::ResultType::Table, "table" } }, from, false, 0, false, {}, false, false);
|
||||
|
||||
validate("SELECT * FROM table;", all, { { {}, "table", {} } }, false, 0, false, {}, false, false);
|
||||
validate("SELECT * FROM schema.table;", all, { { "schema", "table", {} } }, false, 0, false, {}, false, false);
|
||||
|
|
@ -669,13 +669,13 @@ TEST_CASE(select)
|
|||
validate("SELECT * FROM table GROUP BY column1, column2, column3;", all, from, false, 3, false, {}, false, false);
|
||||
validate("SELECT * FROM table GROUP BY column HAVING 'abc';", all, from, false, 1, true, {}, false, false);
|
||||
|
||||
validate("SELECT * FROM table ORDER BY column;", all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column COLLATE collation;", all, from, false, 0, false, { { "collation", SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column ASC;", all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column DESC;", all, from, false, 0, false, { { {}, SQL::Order::Descending, SQL::Nulls::Last } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column ASC NULLS LAST;", all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::Last } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column DESC NULLS FIRST;", all, from, false, 0, false, { { {}, SQL::Order::Descending, SQL::Nulls::First } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column1, column2 DESC, column3 NULLS LAST;", all, from, false, 0, false, { { {}, SQL::Order::Ascending, SQL::Nulls::First }, { {}, SQL::Order::Descending, SQL::Nulls::Last }, { {}, SQL::Order::Ascending, SQL::Nulls::Last } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column;", all, from, false, 0, false, { { {}, SQL::AST::Order::Ascending, SQL::AST::Nulls::First } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column COLLATE collation;", all, from, false, 0, false, { { "collation", SQL::AST::Order::Ascending, SQL::AST::Nulls::First } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column ASC;", all, from, false, 0, false, { { {}, SQL::AST::Order::Ascending, SQL::AST::Nulls::First } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column DESC;", all, from, false, 0, false, { { {}, SQL::AST::Order::Descending, SQL::AST::Nulls::Last } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column ASC NULLS LAST;", all, from, false, 0, false, { { {}, SQL::AST::Order::Ascending, SQL::AST::Nulls::Last } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column DESC NULLS FIRST;", all, from, false, 0, false, { { {}, SQL::AST::Order::Descending, SQL::AST::Nulls::First } }, false, false);
|
||||
validate("SELECT * FROM table ORDER BY column1, column2 DESC, column3 NULLS LAST;", all, from, false, 0, false, { { {}, SQL::AST::Order::Ascending, SQL::AST::Nulls::First }, { {}, SQL::AST::Order::Descending, SQL::AST::Nulls::Last }, { {}, SQL::AST::Order::Ascending, SQL::AST::Nulls::Last } }, false, false);
|
||||
|
||||
validate("SELECT * FROM table LIMIT 15;", all, from, false, 0, false, {}, true, false);
|
||||
validate("SELECT * FROM table LIMIT 15 OFFSET 16;", all, from, false, 0, false, {}, true, true);
|
||||
|
|
@ -710,9 +710,9 @@ TEST_CASE(common_table_expression)
|
|||
EXPECT(!result.is_error());
|
||||
|
||||
auto statement = result.release_value();
|
||||
EXPECT(is<SQL::Delete>(*statement));
|
||||
EXPECT(is<SQL::AST::Delete>(*statement));
|
||||
|
||||
const auto& delete_ = static_cast<const SQL::Delete&>(*statement);
|
||||
const auto& delete_ = static_cast<const SQL::AST::Delete&>(*statement);
|
||||
|
||||
const auto& common_table_expression_list = delete_.common_table_expression_list();
|
||||
EXPECT(!common_table_expression_list.is_null());
|
||||
|
|
@ -741,7 +741,7 @@ TEST_CASE(common_table_expression)
|
|||
|
||||
TEST_CASE(nested_subquery_limit)
|
||||
{
|
||||
auto subquery = String::formatted("{:(^{}}table{:)^{}}", "", SQL::Limits::maximum_subquery_depth - 1, "", SQL::Limits::maximum_subquery_depth - 1);
|
||||
auto subquery = String::formatted("{:(^{}}table{:)^{}}", "", SQL::AST::Limits::maximum_subquery_depth - 1, "", SQL::AST::Limits::maximum_subquery_depth - 1);
|
||||
EXPECT(!parse(String::formatted("SELECT * FROM {};", subquery)).is_error());
|
||||
EXPECT(parse(String::formatted("SELECT * FROM ({});", subquery)).is_error());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -136,8 +136,8 @@ TEST_CASE(order_int_values)
|
|||
TEST_CASE(tuple)
|
||||
{
|
||||
SQL::TupleDescriptor descriptor;
|
||||
descriptor.append({ "col1", SQL::SQLType::Text, SQL::Order::Ascending });
|
||||
descriptor.append({ "col2", SQL::SQLType::Integer, SQL::Order::Descending });
|
||||
descriptor.append({ "col1", SQL::SQLType::Text, SQL::AST::Order::Ascending });
|
||||
descriptor.append({ "col2", SQL::SQLType::Integer, SQL::AST::Order::Descending });
|
||||
SQL::Tuple tuple(descriptor);
|
||||
|
||||
tuple["col1"] = "Test";
|
||||
|
|
@ -149,8 +149,8 @@ TEST_CASE(tuple)
|
|||
TEST_CASE(serialize_tuple)
|
||||
{
|
||||
SQL::TupleDescriptor descriptor;
|
||||
descriptor.append({ "col1", SQL::SQLType::Text, SQL::Order::Ascending });
|
||||
descriptor.append({ "col2", SQL::SQLType::Integer, SQL::Order::Descending });
|
||||
descriptor.append({ "col1", SQL::SQLType::Text, SQL::AST::Order::Ascending });
|
||||
descriptor.append({ "col2", SQL::SQLType::Integer, SQL::AST::Order::Descending });
|
||||
SQL::Tuple tuple(descriptor);
|
||||
|
||||
tuple["col1"] = "Test";
|
||||
|
|
@ -170,8 +170,8 @@ TEST_CASE(serialize_tuple)
|
|||
TEST_CASE(copy_tuple)
|
||||
{
|
||||
SQL::TupleDescriptor descriptor;
|
||||
descriptor.append({ "col1", SQL::SQLType::Text, SQL::Order::Ascending });
|
||||
descriptor.append({ "col2", SQL::SQLType::Integer, SQL::Order::Descending });
|
||||
descriptor.append({ "col1", SQL::SQLType::Text, SQL::AST::Order::Ascending });
|
||||
descriptor.append({ "col2", SQL::SQLType::Integer, SQL::AST::Order::Descending });
|
||||
SQL::Tuple tuple(descriptor);
|
||||
|
||||
tuple["col1"] = "Test";
|
||||
|
|
@ -188,8 +188,8 @@ TEST_CASE(copy_tuple)
|
|||
TEST_CASE(compare_tuples)
|
||||
{
|
||||
SQL::TupleDescriptor descriptor;
|
||||
descriptor.append({ "col1", SQL::SQLType::Text, SQL::Order::Ascending });
|
||||
descriptor.append({ "col2", SQL::SQLType::Integer, SQL::Order::Descending });
|
||||
descriptor.append({ "col1", SQL::SQLType::Text, SQL::AST::Order::Ascending });
|
||||
descriptor.append({ "col2", SQL::SQLType::Integer, SQL::AST::Order::Descending });
|
||||
|
||||
SQL::Tuple tuple1(descriptor);
|
||||
tuple1["col1"] = "Test";
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue