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.

24 files changed, 281 insertions, 278 deletions

diff --git a/Meta/Lagom/CMakeLists.txt b/Meta/Lagom/CMakeLists.txt
index a11d692b43..47cbea7eb5 100644
--- a/Meta/Lagom/CMakeLists.txt
+++ b/Meta/Lagom/CMakeLists.txt
@@ -81,8 +81,8 @@ file(GLOB LIBTEXTCODEC_SOURCES CONFIGURE_DEPENDS "../../Userland/Libraries/LibTe
 file(GLOB SHELL_SOURCES CONFIGURE_DEPENDS "../../Userland/Shell/*.cpp")
 file(GLOB SHELL_TESTS CONFIGURE_DEPENDS "../../Userland/Shell/Tests/*.sh")
 list(FILTER SHELL_SOURCES EXCLUDE REGEX ".*main.cpp$")
-file(GLOB LIBSQL_SOURCES CONFIGURE_DEPENDS "../../Userland/Libraries/LibSQL/*.cpp")
-list(REMOVE_ITEM LIBSQL_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/../../Userland/Libraries/LibSQL/SyntaxHighlighter.cpp")
+file(GLOB_RECURSE LIBSQL_SOURCES CONFIGURE_DEPENDS "../../Userland/Libraries/LibSQL/*.cpp")
+list(REMOVE_ITEM LIBSQL_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/../../Userland/Libraries/LibSQL/AST/SyntaxHighlighter.cpp")
 file(GLOB LIBSQL_TEST_SOURCES CONFIGURE_DEPENDS "../../Tests/LibSQL/*.cpp")
 file(GLOB LIBWASM_SOURCES CONFIGURE_DEPENDS "../../Userland/Libraries/LibWasm/*/*.cpp")
 file(GLOB LIBIMAP_SOURCES CONFIGURE_DEPENDS "../../Userland/Libraries/LibIMAP/*.cpp")
diff --git a/Meta/Lagom/Fuzzers/FuzzSQLParser.cpp b/Meta/Lagom/Fuzzers/FuzzSQLParser.cpp
index 0532e83274..b60df45fff 100644
--- a/Meta/Lagom/Fuzzers/FuzzSQLParser.cpp
+++ b/Meta/Lagom/Fuzzers/FuzzSQLParser.cpp
@@ -4,13 +4,13 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibSQL/Lexer.h>
-#include <LibSQL/Parser.h>
+#include <LibSQL/AST/Lexer.h>
+#include <LibSQL/AST/Parser.h>
 #include <stdio.h>
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    auto parser = SQL::Parser(SQL::Lexer({ data, size }));
+    auto parser = SQL::AST::Parser(SQL::AST::Lexer({ data, size }));
     [[maybe_unused]] auto statement = parser.next_statement();
     return 0;
 }
diff --git a/Tests/LibSQL/TestSqlBtreeIndex.cpp b/Tests/LibSQL/TestSqlBtreeIndex.cpp
index edb3a6b722..726edfad94 100644
--- a/Tests/LibSQL/TestSqlBtreeIndex.cpp
+++ b/Tests/LibSQL/TestSqlBtreeIndex.cpp
@@ -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) {
diff --git a/Tests/LibSQL/TestSqlExpressionParser.cpp b/Tests/LibSQL/TestSqlExpressionParser.cpp
index 15bd8d8415..ec3685c028 100644
--- a/Tests/LibSQL/TestSqlExpressionParser.cpp
+++ b/Tests/LibSQL/TestSqlExpressionParser.cpp
@@ -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());
 }
diff --git a/Tests/LibSQL/TestSqlHashIndex.cpp b/Tests/LibSQL/TestSqlHashIndex.cpp
index c6f0b5badc..ca4cab3ee2 100644
--- a/Tests/LibSQL/TestSqlHashIndex.cpp
+++ b/Tests/LibSQL/TestSqlHashIndex.cpp
@@ -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) {
diff --git a/Tests/LibSQL/TestSqlStatementParser.cpp b/Tests/LibSQL/TestSqlStatementParser.cpp
index 259a9e091e..c5ad5f036b 100644
--- a/Tests/LibSQL/TestSqlStatementParser.cpp
+++ b/Tests/LibSQL/TestSqlStatementParser.cpp
@@ -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());
 }
diff --git a/Tests/LibSQL/TestSqlValueAndTuple.cpp b/Tests/LibSQL/TestSqlValueAndTuple.cpp
index 7740e5ce48..8eeeb2723f 100644
--- a/Tests/LibSQL/TestSqlValueAndTuple.cpp
+++ b/Tests/LibSQL/TestSqlValueAndTuple.cpp
@@ -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";
diff --git a/Userland/Applications/TextEditor/MainWidget.cpp b/Userland/Applications/TextEditor/MainWidget.cpp
index 3bc77d7492..807d3ed9c9 100644
--- a/Userland/Applications/TextEditor/MainWidget.cpp
+++ b/Userland/Applications/TextEditor/MainWidget.cpp
@@ -36,7 +36,7 @@
 #include <LibGfx/Painter.h>
 #include <LibJS/SyntaxHighlighter.h>
 #include <LibMarkdown/Document.h>
-#include <LibSQL/SyntaxHighlighter.h>
+#include <LibSQL/AST/SyntaxHighlighter.h>
 #include <LibWeb/HTML/SyntaxHighlighter/SyntaxHighlighter.h>
 #include <LibWeb/OutOfProcessWebView.h>
 #include <Shell/SyntaxHighlighter.h>
@@ -582,7 +582,7 @@ void MainWidget::initialize_menubar(GUI::Menubar& menubar)
     syntax_menu.add_action(*m_shell_highlight);
 
     m_sql_highlight = GUI::Action::create_checkable("S&QL File", [&](auto&) {
-        m_editor->set_syntax_highlighter(make<SQL::SyntaxHighlighter>());
+        m_editor->set_syntax_highlighter(make<SQL::AST::SyntaxHighlighter>());
         m_editor->update();
     });
     syntax_actions.add_action(*m_sql_highlight);
diff --git a/Userland/Libraries/LibSQL/AST.h b/Userland/Libraries/LibSQL/AST/AST.h
index 8f71d26e17..8f22bbab65 100644
--- a/Userland/Libraries/LibSQL/AST.h
+++ b/Userland/Libraries/LibSQL/AST/AST.h
@@ -11,10 +11,10 @@
 #include <AK/RefCounted.h>
 #include <AK/RefPtr.h>
 #include <AK/String.h>
+#include <LibSQL/AST/Token.h>
 #include <LibSQL/Forward.h>
-#include <LibSQL/Token.h>
 
-namespace SQL {
+namespace SQL::AST {
 
 template<class T, class... Args>
 static inline NonnullRefPtr<T>
diff --git a/Userland/Libraries/LibSQL/Lexer.cpp b/Userland/Libraries/LibSQL/AST/Lexer.cpp
index 50598b3159..49c1602243 100644
--- a/Userland/Libraries/LibSQL/Lexer.cpp
+++ b/Userland/Libraries/LibSQL/AST/Lexer.cpp
@@ -8,7 +8,7 @@
 #include <AK/Debug.h>
 #include <ctype.h>
 
-namespace SQL {
+namespace SQL::AST {
 
 HashMap<String, TokenType> Lexer::s_keywords;
 HashMap<char, TokenType> Lexer::s_one_char_tokens;
diff --git a/Userland/Libraries/LibSQL/Lexer.h b/Userland/Libraries/LibSQL/AST/Lexer.h
index 2ec93a2e80..77abcdec45 100644
--- a/Userland/Libraries/LibSQL/Lexer.h
+++ b/Userland/Libraries/LibSQL/AST/Lexer.h
@@ -11,7 +11,7 @@
 #include <AK/String.h>
 #include <AK/StringView.h>
 
-namespace SQL {
+namespace SQL::AST {
 
 class Lexer {
 public:
diff --git a/Userland/Libraries/LibSQL/Parser.cpp b/Userland/Libraries/LibSQL/AST/Parser.cpp
index 5ee5d2538d..ae771c9ae0 100644
--- a/Userland/Libraries/LibSQL/Parser.cpp
+++ b/Userland/Libraries/LibSQL/AST/Parser.cpp
@@ -8,7 +8,7 @@
 #include <AK/ScopeGuard.h>
 #include <AK/TypeCasts.h>
 
-namespace SQL {
+namespace SQL::AST {
 
 Parser::Parser(Lexer lexer)
     : m_parser_state(move(lexer))
diff --git a/Userland/Libraries/LibSQL/Parser.h b/Userland/Libraries/LibSQL/AST/Parser.h
index 94fb0e6a04..466c2f4150 100644
--- a/Userland/Libraries/LibSQL/Parser.h
+++ b/Userland/Libraries/LibSQL/AST/Parser.h
@@ -8,11 +8,11 @@
 
 #include <AK/String.h>
 #include <AK/StringView.h>
-#include <LibSQL/AST.h>
-#include <LibSQL/Lexer.h>
-#include <LibSQL/Token.h>
+#include <LibSQL/AST/AST.h>
+#include <LibSQL/AST/Lexer.h>
+#include <LibSQL/AST/Token.h>
 
-namespace SQL {
+namespace SQL::AST {
 
 namespace Limits {
 // https://www.sqlite.org/limits.html
diff --git a/Userland/Libraries/LibSQL/SyntaxHighlighter.cpp b/Userland/Libraries/LibSQL/AST/SyntaxHighlighter.cpp
index db0b308763..da5de16a67 100644
--- a/Userland/Libraries/LibSQL/SyntaxHighlighter.cpp
+++ b/Userland/Libraries/LibSQL/AST/SyntaxHighlighter.cpp
@@ -6,10 +6,10 @@
 
 #include <AK/Debug.h>
 #include <LibGfx/Palette.h>
-#include <LibSQL/Lexer.h>
-#include <LibSQL/SyntaxHighlighter.h>
+#include <LibSQL/AST/Lexer.h>
+#include <LibSQL/AST/SyntaxHighlighter.h>
 
-namespace SQL {
+namespace SQL::AST {
 
 static Syntax::TextStyle style_for_token_type(Gfx::Palette const& palette, TokenType type)
 {
@@ -35,19 +35,19 @@ static Syntax::TextStyle style_for_token_type(Gfx::Palette const& palette, Token
 
 bool SyntaxHighlighter::is_identifier(u64 token) const
 {
-    auto sql_token = static_cast<SQL::TokenType>(static_cast<size_t>(token));
-    return sql_token == SQL::TokenType::Identifier;
+    auto sql_token = static_cast<TokenType>(static_cast<size_t>(token));
+    return sql_token == TokenType::Identifier;
 }
 
 void SyntaxHighlighter::rehighlight(Palette const& palette)
 {
     auto text = m_client->get_text();
 
-    SQL::Lexer lexer(text);
+    Lexer lexer(text);
 
     Vector<GUI::TextDocumentSpan> spans;
 
-    auto append_token = [&](StringView str, SQL::Token const& token) {
+    auto append_token = [&](StringView str, Token const& token) {
         if (str.is_empty())
             return;
 
@@ -79,7 +79,7 @@ void SyntaxHighlighter::rehighlight(Palette const& palette)
     for (;;) {
         auto token = lexer.next();
         append_token(token.value(), token);
-        if (token.type() == SQL::TokenType::Eof)
+        if (token.type() == TokenType::Eof)
             break;
     }
 
diff --git a/Userland/Libraries/LibSQL/SyntaxHighlighter.h b/Userland/Libraries/LibSQL/AST/SyntaxHighlighter.h
index b8f17b8527..981b5b8091 100644
--- a/Userland/Libraries/LibSQL/SyntaxHighlighter.h
+++ b/Userland/Libraries/LibSQL/AST/SyntaxHighlighter.h
@@ -8,7 +8,7 @@
 
 #include <LibSyntax/Highlighter.h>
 
-namespace SQL {
+namespace SQL::AST {
 
 class SyntaxHighlighter final : public Syntax::Highlighter {
 public:
diff --git a/Userland/Libraries/LibSQL/Token.cpp b/Userland/Libraries/LibSQL/AST/Token.cpp
index 7ec61f0574..2780b39a1d 100644
--- a/Userland/Libraries/LibSQL/Token.cpp
+++ b/Userland/Libraries/LibSQL/AST/Token.cpp
@@ -9,7 +9,7 @@
 #include <AK/String.h>
 #include <stdlib.h>
 
-namespace SQL {
+namespace SQL::AST {
 
 StringView Token::name(TokenType type)
 {
diff --git a/Userland/Libraries/LibSQL/Token.h b/Userland/Libraries/LibSQL/AST/Token.h
index 66ac5dea5a..e8dc8ff5cb 100644
--- a/Userland/Libraries/LibSQL/Token.h
+++ b/Userland/Libraries/LibSQL/AST/Token.h
@@ -9,7 +9,7 @@
 #include <AK/HashMap.h>
 #include <AK/StringView.h>
 
-namespace SQL {
+namespace SQL::AST {
 
 // https://sqlite.org/lang_keywords.html
 #define ENUMERATE_SQL_TOKENS                                              \
diff --git a/Userland/Libraries/LibSQL/CMakeLists.txt b/Userland/Libraries/LibSQL/CMakeLists.txt
index 0e979d69f8..23bbd35b5e 100644
--- a/Userland/Libraries/LibSQL/CMakeLists.txt
+++ b/Userland/Libraries/LibSQL/CMakeLists.txt
@@ -1,4 +1,8 @@
 set(SOURCES
+        AST/Lexer.cpp
+        AST/Parser.cpp
+        AST/SyntaxHighlighter.cpp
+        AST/Token.cpp
         BTree.cpp
         BTreeIterator.cpp
         Database.cpp
@@ -6,12 +10,8 @@ set(SOURCES
         Heap.cpp
         Index.cpp
         Key.cpp
-        Lexer.cpp
         Meta.cpp
-        Parser.cpp
         Row.cpp
-        SyntaxHighlighter.cpp
-        Token.cpp
         TreeNode.cpp
         Tuple.cpp
         Value.cpp
diff --git a/Userland/Libraries/LibSQL/Forward.h b/Userland/Libraries/LibSQL/Forward.h
index 224404d189..e844a1e782 100644
--- a/Userland/Libraries/LibSQL/Forward.h
+++ b/Userland/Libraries/LibSQL/Forward.h
@@ -7,27 +7,45 @@
 #pragma once
 
 namespace SQL {
+class BTree;
+class BTreeIterator;
+class ColumnDef;
+class Database;
+class HashBucket;
+class HashDirectoryNode;
+class HashIndex;
+class HashIndexIterator;
+class Heap;
+class Index;
+class IndexNode;
+class IndexDef;
+class Key;
+class KeyPartDef;
+class Row;
+class TableDef;
+class TreeNode;
+class Tuple;
+class TupleDescriptor;
+struct TupleElement;
+class Value;
+}
+
+namespace SQL::AST {
 class AddColumn;
 class AlterTable;
 class ASTNode;
 class BetweenExpression;
 class BinaryOperatorExpression;
 class BlobLiteral;
-class BTree;
-class BTreeIterator;
 class CaseExpression;
 class CastExpression;
 class ChainedExpression;
 class CollateExpression;
-class ColumnDef;
 class ColumnDefinition;
 class ColumnNameExpression;
 class CommonTableExpression;
 class CommonTableExpressionList;
 class CreateTable;
-class Database;
-class TupleDescriptor;
-struct TupleElement;
 class Delete;
 class DropColumn;
 class DropTable;
@@ -36,23 +54,13 @@ class ErrorStatement;
 class ExistsExpression;
 class Expression;
 class GroupByClause;
-class HashBucket;
-class HashDirectoryNode;
-class HashIndex;
-class HashIndexIterator;
-class Heap;
 class InChainedExpression;
-class Index;
-class IndexNode;
-class IndexDef;
 class InSelectionExpression;
 class Insert;
 class InTableExpression;
 class InvertibleNestedDoubleExpression;
 class InvertibleNestedExpression;
 class IsExpression;
-class Key;
-class KeyPartDef;
 class Lexer;
 class LimitClause;
 class MatchExpression;
@@ -68,18 +76,13 @@ class RenameColumn;
 class RenameTable;
 class ResultColumn;
 class ReturningClause;
-class Row;
 class Select;
 class SignedNumber;
 class Statement;
 class StringLiteral;
-class TableDef;
 class TableOrSubquery;
 class Token;
-class TreeNode;
-class Tuple;
 class TypeName;
 class UnaryOperatorExpression;
 class Update;
-class Value;
 }
diff --git a/Userland/Libraries/LibSQL/Meta.cpp b/Userland/Libraries/LibSQL/Meta.cpp
index 43a240f9af..ce8dc12bd2 100644
--- a/Userland/Libraries/LibSQL/Meta.cpp
+++ b/Userland/Libraries/LibSQL/Meta.cpp
@@ -37,7 +37,7 @@ NonnullRefPtr<IndexDef> SchemaDef::index_def()
 {
     NonnullRefPtr<IndexDef> s_index_def = IndexDef::construct("$schema", true, 0);
     if (!s_index_def->size()) {
-        s_index_def->append_column("schema_name", SQLType::Text, Order::Ascending);
+        s_index_def->append_column("schema_name", SQLType::Text, AST::Order::Ascending);
     }
     return s_index_def;
 }
@@ -70,15 +70,15 @@ NonnullRefPtr<IndexDef> ColumnDef::index_def()
 {
     NonnullRefPtr<IndexDef> s_index_def = IndexDef::construct("$column", true, 0);
     if (!s_index_def->size()) {
-        s_index_def->append_column("table_hash", SQLType::Integer, Order::Ascending);
-        s_index_def->append_column("column_number", SQLType::Integer, Order::Ascending);
-        s_index_def->append_column("column_name", SQLType::Text, Order::Ascending);
-        s_index_def->append_column("column_type", SQLType::Integer, Order::Ascending);
+        s_index_def->append_column("table_hash", SQLType::Integer, AST::Order::Ascending);
+        s_index_def->append_column("column_number", SQLType::Integer, AST::Order::Ascending);
+        s_index_def->append_column("column_name", SQLType::Text, AST::Order::Ascending);
+        s_index_def->append_column("column_type", SQLType::Integer, AST::Order::Ascending);
     }
     return s_index_def;
 }
 
-KeyPartDef::KeyPartDef(IndexDef* index, String name, SQLType sql_type, Order sort_order)
+KeyPartDef::KeyPartDef(IndexDef* index, String name, SQLType sql_type, AST::Order sort_order)
     : ColumnDef(index, index->size(), move(name), sql_type)
     , m_sort_order(sort_order)
 {
@@ -96,7 +96,7 @@ IndexDef::IndexDef(String name, bool unique, u32 pointer)
 {
 }
 
-void IndexDef::append_column(String name, SQLType sql_type, Order sort_order)
+void IndexDef::append_column(String name, SQLType sql_type, AST::Order sort_order)
 {
     auto part = KeyPartDef::construct(this, move(name), sql_type, sort_order);
     m_key_definition.append(part);
@@ -131,9 +131,9 @@ NonnullRefPtr<IndexDef> IndexDef::index_def()
 {
     NonnullRefPtr<IndexDef> s_index_def = IndexDef::construct("$index", true, 0);
     if (!s_index_def->size()) {
-        s_index_def->append_column("table_hash", SQLType::Integer, Order::Ascending);
-        s_index_def->append_column("index_name", SQLType::Text, Order::Ascending);
-        s_index_def->append_column("unique", SQLType::Integer, Order::Ascending);
+        s_index_def->append_column("table_hash", SQLType::Integer, AST::Order::Ascending);
+        s_index_def->append_column("index_name", SQLType::Text, AST::Order::Ascending);
+        s_index_def->append_column("unique", SQLType::Integer, AST::Order::Ascending);
     }
     return s_index_def;
 }
@@ -149,7 +149,7 @@ TupleDescriptor TableDef::to_tuple_descriptor() const
 {
     TupleDescriptor ret;
     for (auto& part : m_columns) {
-        ret.append({ part.name(), part.type(), Order::Ascending });
+        ret.append({ part.name(), part.type(), AST::Order::Ascending });
     }
     return ret;
 }
@@ -192,8 +192,8 @@ NonnullRefPtr<IndexDef> TableDef::index_def()
 {
     NonnullRefPtr<IndexDef> s_index_def = IndexDef::construct("$table", true, 0);
     if (!s_index_def->size()) {
-        s_index_def->append_column("schema_hash", SQLType::Integer, Order::Ascending);
-        s_index_def->append_column("table_name", SQLType::Text, Order::Ascending);
+        s_index_def->append_column("schema_hash", SQLType::Integer, AST::Order::Ascending);
+        s_index_def->append_column("table_name", SQLType::Text, AST::Order::Ascending);
     }
     return s_index_def;
 }
diff --git a/Userland/Libraries/LibSQL/Meta.h b/Userland/Libraries/LibSQL/Meta.h
index 06a01b18db..468e34cb95 100644
--- a/Userland/Libraries/LibSQL/Meta.h
+++ b/Userland/Libraries/LibSQL/Meta.h
@@ -13,7 +13,7 @@
 #include <AK/String.h>
 #include <AK/Vector.h>
 #include <LibCore/Object.h>
-#include <LibSQL/AST.h>
+#include <LibSQL/AST/AST.h>
 #include <LibSQL/Forward.h>
 #include <LibSQL/Key.h>
 #include <LibSQL/Type.h>
@@ -90,11 +90,11 @@ class KeyPartDef : public ColumnDef {
     C_OBJECT(KeyPartDef);
 
 public:
-    KeyPartDef(IndexDef*, String, SQLType, Order = Order::Ascending);
-    Order sort_order() const { return m_sort_order; }
+    KeyPartDef(IndexDef*, String, SQLType, AST::Order = AST::Order::Ascending);
+    AST::Order sort_order() const { return m_sort_order; }
 
 private:
-    Order m_sort_order { Order::Ascending };
+    AST::Order m_sort_order { AST::Order::Ascending };
 };
 
 class IndexDef : public Relation {
@@ -106,7 +106,7 @@ public:
     NonnullRefPtrVector<KeyPartDef> key_definition() const { return m_key_definition; }
     bool unique() const { return m_unique; }
     [[nodiscard]] size_t size() const { return m_key_definition.size(); }
-    void append_column(String, SQLType, Order = Order::Ascending);
+    void append_column(String, SQLType, AST::Order = AST::Order::Ascending);
     Key key() const override;
     [[nodiscard]] TupleDescriptor to_tuple_descriptor() const;
     static NonnullRefPtr<IndexDef> index_def();
diff --git a/Userland/Libraries/LibSQL/Tuple.cpp b/Userland/Libraries/LibSQL/Tuple.cpp
index 406484e924..c9d5da5c1f 100644
--- a/Userland/Libraries/LibSQL/Tuple.cpp
+++ b/Userland/Libraries/LibSQL/Tuple.cpp
@@ -203,7 +203,7 @@ int Tuple::compare(const Tuple& other) const
     for (auto ix = 0u; ix < num_values; ix++) {
         auto ret = m_data[ix].compare(other.m_data[ix]);
         if (ret != 0) {
-            if ((ix < m_descriptor.size()) && m_descriptor[ix].order == Order::Descending)
+            if ((ix < m_descriptor.size()) && m_descriptor[ix].order == AST::Order::Descending)
                 ret = -ret;
             return ret;
         }
@@ -223,7 +223,7 @@ int Tuple::match(const Tuple& other) const
             return -1;
         auto ret = m_data[my_index.value()].compare(other_value);
         if (ret != 0)
-            return (m_descriptor[my_index.value()].order == Order::Descending) ? -ret : ret;
+            return (m_descriptor[my_index.value()].order == AST::Order::Descending) ? -ret : ret;
         other_index++;
     }
     return 0;
diff --git a/Userland/Libraries/LibSQL/TupleDescriptor.h b/Userland/Libraries/LibSQL/TupleDescriptor.h
index 2fc34172f8..c95dcfcb07 100644
--- a/Userland/Libraries/LibSQL/TupleDescriptor.h
+++ b/Userland/Libraries/LibSQL/TupleDescriptor.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/Vector.h>
-#include <LibSQL/AST.h>
+#include <LibSQL/AST/AST.h>
 #include <LibSQL/Type.h>
 
 namespace SQL {
@@ -15,7 +15,7 @@ namespace SQL {
 struct TupleElement {
     String name { "" };
     SQLType type { SQLType::Text };
-    Order order { Order::Ascending };
+    AST::Order order { AST::Order::Ascending };
 
     bool operator==(TupleElement const&) const = default;
 };
diff --git a/Userland/Utilities/sql.cpp b/Userland/Utilities/sql.cpp
index b763e846a8..936f20976e 100644
--- a/Userland/Utilities/sql.cpp
+++ b/Userland/Utilities/sql.cpp
@@ -9,9 +9,9 @@
 #include <AK/StringBuilder.h>
 #include <LibCore/StandardPaths.h>
 #include <LibLine/Editor.h>
-#include <LibSQL/Lexer.h>
-#include <LibSQL/Parser.h>
-#include <LibSQL/Token.h>
+#include <LibSQL/AST/Lexer.h>
+#include <LibSQL/AST/Parser.h>
+#include <LibSQL/AST/Token.h>
 
 namespace {
 
@@ -48,7 +48,7 @@ String read_next_piece()
         }
 
         auto& line = line_result.value();
-        auto lexer = SQL::Lexer(line);
+        auto lexer = SQL::AST::Lexer(line);
 
         s_editor->add_to_history(line);
         piece.append(line);
@@ -57,18 +57,18 @@ String read_next_piece()
         bool is_command = false;
         bool last_token_ended_statement = false;
 
-        for (SQL::Token token = lexer.next(); token.type() != SQL::TokenType::Eof; token = lexer.next()) {
+        for (SQL::AST::Token token = lexer.next(); token.type() != SQL::AST::TokenType::Eof; token = lexer.next()) {
             switch (token.type()) {
-            case SQL::TokenType::ParenOpen:
+            case SQL::AST::TokenType::ParenOpen:
                 ++s_repl_line_level;
                 break;
-            case SQL::TokenType::ParenClose:
+            case SQL::AST::TokenType::ParenClose:
                 --s_repl_line_level;
                 break;
-            case SQL::TokenType::SemiColon:
+            case SQL::AST::TokenType::SemiColon:
                 last_token_ended_statement = true;
                 break;
-            case SQL::TokenType::Period:
+            case SQL::AST::TokenType::Period:
                 if (is_first_token)
                     is_command = true;
                 break;
@@ -96,7 +96,7 @@ void handle_command(StringView command)
 
 void handle_statement(StringView statement_string)
 {
-    auto parser = SQL::Parser(SQL::Lexer(statement_string));
+    auto parser = SQL::AST::Parser(SQL::AST::Lexer(statement_string));
     [[maybe_unused]] auto statement = parser.next_statement();
 
     if (parser.has_errors()) {
@@ -132,38 +132,38 @@ int main()
         size_t open_indents = s_repl_line_level;
 
         auto line = editor.line();
-        SQL::Lexer lexer(line);
+        SQL::AST::Lexer lexer(line);
 
         bool indenters_starting_line = true;
-        for (SQL::Token token = lexer.next(); token.type() != SQL::TokenType::Eof; token = lexer.next()) {
+        for (SQL::AST::Token token = lexer.next(); token.type() != SQL::AST::TokenType::Eof; token = lexer.next()) {
             auto length = token.value().length();
             auto start = token.line_column() - 1;
             auto end = start + length;
 
             if (indenters_starting_line) {
-                if (token.type() != SQL::TokenType::ParenClose)
+                if (token.type() != SQL::AST::TokenType::ParenClose)
                     indenters_starting_line = false;
                 else
                     --open_indents;
             }
 
             switch (token.category()) {
-            case SQL::TokenCategory::Invalid:
+            case SQL::AST::TokenCategory::Invalid:
                 editor.stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Red), Line::Style::Underline });
                 break;
-            case SQL::TokenCategory::Number:
+            case SQL::AST::TokenCategory::Number:
                 editor.stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Magenta) });
                 break;
-            case SQL::TokenCategory::String:
+            case SQL::AST::TokenCategory::String:
                 editor.stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Green), Line::Style::Bold });
                 break;
-            case SQL::TokenCategory::Blob:
+            case SQL::AST::TokenCategory::Blob:
                 editor.stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Magenta), Line::Style::Bold });
                 break;
-            case SQL::TokenCategory::Keyword:
+            case SQL::AST::TokenCategory::Keyword:
                 editor.stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Blue), Line::Style::Bold });
                 break;
-            case SQL::TokenCategory::Identifier:
+            case SQL::AST::TokenCategory::Identifier:
                 editor.stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::White), Line::Style::Bold });
             default:
                 break;