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

LibSQL+SQLServer: Introduce and use ResultOr<ValueType>

Browse source 
The result of a SQL statement execution is either:
    1. An error.
    2. The list of rows inserted, deleted, selected, etc.

(2) is currently represented by a combination of the Result class and
the ResultSet list it holds. This worked okay, but issues start to
arise when trying to use Result in non-statement contexts (for example,
when introducing Result to SQL expression execution).

What we really need is for Result to be a thin wrapper that represents
both (1) and (2), and to not have any explicit members like a ResultSet.
So this commit removes ResultSet from Result, and introduces ResultOr,
which is just an alias for AK::ErrorOrr. Statement execution now returns
ResultOr<ResultSet> instead of Result. This further opens the door for
expression execution to return ResultOr<Value> in the future.

Lastly, this moves some other context held by Result over to ResultSet.
This includes the row count (which is really just the size of ResultSet)
and the command for which the result is for.
This commit is contained in:
Timothy Flynn 2022-02-10 14:43:00 -05:00 • committed by Andreas Kling
parent 6409618413
commit 2397836f8e
15 changed files with 259 additions and 330 deletions
Download patch file Download diff file Expand all files Collapse all files

357
Tests/LibSQL/TestSqlStatementExecution.cpp
View file

@ -11,6 +11,7 @@
#include <LibSQL/AST/Parser.h> #include <LibSQL/AST/Parser.h>
#include <LibSQL/Database.h> #include <LibSQL/Database.h>
#include <LibSQL/Result.h> #include <LibSQL/Result.h>
#include <LibSQL/ResultSet.h>
#include <LibSQL/Row.h> #include <LibSQL/Row.h>
#include <LibSQL/Value.h> #include <LibSQL/Value.h>
#include <LibTest/TestCase.h> #include <LibTest/TestCase.h>
@ -19,43 +20,46 @@ namespace {
constexpr const char* db_name = "/tmp/test.db"; constexpr const char* db_name = "/tmp/test.db";
SQL::Result execute(NonnullRefPtr<SQL::Database> database, String const& sql) SQL::ResultOr<SQL::ResultSet> try_execute(NonnullRefPtr<SQL::Database> database, String const& sql)
{ {
auto parser = SQL::AST::Parser(SQL::AST::Lexer(sql)); auto parser = SQL::AST::Parser(SQL::AST::Lexer(sql));
auto statement = parser.next_statement(); auto statement = parser.next_statement();
EXPECT(!parser.has_errors()); EXPECT(!parser.has_errors());
if (parser.has_errors()) if (parser.has_errors())
outln("{}", parser.errors()[0].to_string()); outln("{}", parser.errors()[0].to_string());
auto result = statement->execute(move(database)); return statement->execute(move(database));
if (result.is_error()) }
outln("{}", result.error_string());
return result; SQL::ResultSet execute(NonnullRefPtr<SQL::Database> database, String const& sql)
{
auto result = try_execute(move(database), sql);
if (result.is_error()) {
outln("{}", result.release_error().error_string());
VERIFY_NOT_REACHED();
}
return result.release_value();
} }
void create_schema(NonnullRefPtr<SQL::Database> database) void create_schema(NonnullRefPtr<SQL::Database> database)
{ {
auto result = execute(database, "CREATE SCHEMA TestSchema;"); auto result = execute(database, "CREATE SCHEMA TestSchema;");
EXPECT(!result.is_error()); EXPECT_EQ(result.command(), SQL::SQLCommand::Create);
EXPECT(result.inserted() == 1);
} }
void create_table(NonnullRefPtr<SQL::Database> database) void create_table(NonnullRefPtr<SQL::Database> database)
{ {
create_schema(database); create_schema(database);
auto result = execute(database, "CREATE TABLE TestSchema.TestTable ( TextColumn text, IntColumn integer );"); auto result = execute(database, "CREATE TABLE TestSchema.TestTable ( TextColumn text, IntColumn integer );");
EXPECT(!result.is_error()); EXPECT_EQ(result.command(), SQL::SQLCommand::Create);
EXPECT(result.inserted() == 1);
} }
void create_two_tables(NonnullRefPtr<SQL::Database> database) void create_two_tables(NonnullRefPtr<SQL::Database> database)
{ {
create_schema(database); create_schema(database);
auto result = execute(database, "CREATE TABLE TestSchema.TestTable1 ( TextColumn1 text, IntColumn integer );"); auto result = execute(database, "CREATE TABLE TestSchema.TestTable1 ( TextColumn1 text, IntColumn integer );");
EXPECT(!result.is_error()); EXPECT_EQ(result.command(), SQL::SQLCommand::Create);
EXPECT(result.inserted() == 1);
result = execute(database, "CREATE TABLE TestSchema.TestTable2 ( TextColumn2 text, IntColumn integer );"); result = execute(database, "CREATE TABLE TestSchema.TestTable2 ( TextColumn2 text, IntColumn integer );");
EXPECT(!result.is_error()); EXPECT_EQ(result.command(), SQL::SQLCommand::Create);
EXPECT(result.inserted() == 1);
} }
TEST_CASE(create_schema) TEST_CASE(create_schema)
@ -87,8 +91,7 @@ TEST_CASE(insert_into_table)
EXPECT(!database->open().is_error()); EXPECT(!database->open().is_error());
create_table(database); create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test', 42 );"); auto result = execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test', 42 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 1);
EXPECT(result.inserted() == 1);
auto table_or_error = database->get_table("TESTSCHEMA", "TESTTABLE"); auto table_or_error = database->get_table("TESTSCHEMA", "TESTTABLE");
EXPECT(!table_or_error.is_error()); EXPECT(!table_or_error.is_error());
@ -111,9 +114,9 @@ TEST_CASE(insert_into_table_wrong_data_types)
auto database = SQL::Database::construct(db_name); auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error()); EXPECT(!database->open().is_error());
create_table(database); create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES (43, 'Test_2');"); auto result = try_execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES (43, 'Test_2');");
EXPECT(result.inserted() == 0); EXPECT(result.is_error());
EXPECT(result.error() == SQL::SQLErrorCode::InvalidValueType); EXPECT(result.release_error().error() == SQL::SQLErrorCode::InvalidValueType);
} }
TEST_CASE(insert_into_table_multiple_tuples_wrong_data_types) TEST_CASE(insert_into_table_multiple_tuples_wrong_data_types)
@ -122,9 +125,9 @@ TEST_CASE(insert_into_table_multiple_tuples_wrong_data_types)
auto database = SQL::Database::construct(db_name); auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error()); EXPECT(!database->open().is_error());
create_table(database); create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ('Test_1', 42), (43, 'Test_2');"); auto result = try_execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ('Test_1', 42), (43, 'Test_2');");
EXPECT(result.inserted() == 0); EXPECT(result.is_error());
EXPECT(result.error() == SQL::SQLErrorCode::InvalidValueType); EXPECT(result.release_error().error() == SQL::SQLErrorCode::InvalidValueType);
} }
TEST_CASE(insert_wrong_number_of_values) TEST_CASE(insert_wrong_number_of_values)
@ -133,9 +136,9 @@ TEST_CASE(insert_wrong_number_of_values)
auto database = SQL::Database::construct(db_name); auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error()); EXPECT(!database->open().is_error());
create_table(database); create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ( 42 );"); auto result = try_execute(database, "INSERT INTO TestSchema.TestTable VALUES ( 42 );");
EXPECT(result.error() == SQL::SQLErrorCode::InvalidNumberOfValues); EXPECT(result.is_error());
EXPECT(result.inserted() == 0); EXPECT(result.release_error().error() == SQL::SQLErrorCode::InvalidNumberOfValues);
} }
TEST_CASE(insert_identifier_as_value) TEST_CASE(insert_identifier_as_value)
@ -144,9 +147,9 @@ TEST_CASE(insert_identifier_as_value)
auto database = SQL::Database::construct(db_name); auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error()); EXPECT(!database->open().is_error());
create_table(database); create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ( identifier, 42 );"); auto result = try_execute(database, "INSERT INTO TestSchema.TestTable VALUES ( identifier, 42 );");
EXPECT(result.error() == SQL::SQLErrorCode::SyntaxError); EXPECT(result.is_error());
EXPECT(result.inserted() == 0); EXPECT(result.release_error().error() == SQL::SQLErrorCode::SyntaxError);
} }
TEST_CASE(insert_quoted_identifier_as_value) TEST_CASE(insert_quoted_identifier_as_value)
@ -155,9 +158,9 @@ TEST_CASE(insert_quoted_identifier_as_value)
auto database = SQL::Database::construct(db_name); auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error()); EXPECT(!database->open().is_error());
create_table(database); create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ( \"QuotedIdentifier\", 42 );"); auto result = try_execute(database, "INSERT INTO TestSchema.TestTable VALUES ( \"QuotedIdentifier\", 42 );");
EXPECT(result.error() == SQL::SQLErrorCode::SyntaxError); EXPECT(result.is_error());
EXPECT(result.inserted() == 0); EXPECT(result.release_error().error() == SQL::SQLErrorCode::SyntaxError);
} }
TEST_CASE(insert_without_column_names) TEST_CASE(insert_without_column_names)
@ -167,8 +170,7 @@ TEST_CASE(insert_without_column_names)
EXPECT(!database->open().is_error()); EXPECT(!database->open().is_error());
create_table(database); create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ('Test_1', 42), ('Test_2', 43);"); auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ('Test_1', 42), ('Test_2', 43);");
EXPECT(!result.is_error()); EXPECT(result.size() == 2);
EXPECT(result.inserted() == 2);
auto table_or_error = database->get_table("TESTSCHEMA", "TESTTABLE"); auto table_or_error = database->get_table("TESTSCHEMA", "TESTTABLE");
EXPECT(!table_or_error.is_error()); EXPECT(!table_or_error.is_error());
@ -184,8 +186,7 @@ TEST_CASE(select_from_empty_table)
EXPECT(!database->open().is_error()); EXPECT(!database->open().is_error());
create_table(database); create_table(database);
auto result = execute(database, "SELECT * FROM TestSchema.TestTable;"); auto result = execute(database, "SELECT * FROM TestSchema.TestTable;");
EXPECT(!result.is_error()); EXPECT(result.is_empty());
EXPECT(!result.has_results());
} }
TEST_CASE(select_from_table) TEST_CASE(select_from_table)
@ -201,12 +202,9 @@ TEST_CASE(select_from_table)
"( 'Test_3', 44 ), " "( 'Test_3', 44 ), "
"( 'Test_4', 45 ), " "( 'Test_4', 45 ), "
"( 'Test_5', 46 );"); "( 'Test_5', 46 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, "SELECT * FROM TestSchema.TestTable;"); result = execute(database, "SELECT * FROM TestSchema.TestTable;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 5u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 5u);
} }
TEST_CASE(select_with_column_names) TEST_CASE(select_with_column_names)
@ -222,13 +220,10 @@ TEST_CASE(select_with_column_names)
"( 'Test_3', 44 ), " "( 'Test_3', 44 ), "
"( 'Test_4', 45 ), " "( 'Test_4', 45 ), "
"( 'Test_5', 46 );"); "( 'Test_5', 46 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable;"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 5u);
EXPECT(result.has_results()); EXPECT_EQ(result[0].row.size(), 1u);
EXPECT_EQ(result.results().size(), 5u);
EXPECT_EQ(result.results()[0].row.size(), 1u);
} }
TEST_CASE(select_with_nonexisting_column_name) TEST_CASE(select_with_nonexisting_column_name)
@ -244,10 +239,11 @@ TEST_CASE(select_with_nonexisting_column_name)
"( 'Test_3', 44 ), " "( 'Test_3', 44 ), "
"( 'Test_4', 45 ), " "( 'Test_4', 45 ), "
"( 'Test_5', 46 );"); "( 'Test_5', 46 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, "SELECT Bogus FROM TestSchema.TestTable;"); auto insert_result = try_execute(database, "SELECT Bogus FROM TestSchema.TestTable;");
EXPECT(result.error() == SQL::SQLErrorCode::ColumnDoesNotExist); EXPECT(insert_result.is_error());
EXPECT(insert_result.release_error().error() == SQL::SQLErrorCode::ColumnDoesNotExist);
} }
TEST_CASE(select_with_where) TEST_CASE(select_with_where)
@ -263,13 +259,10 @@ TEST_CASE(select_with_where)
"( 'Test_3', 44 ), " "( 'Test_3', 44 ), "
"( 'Test_4', 45 ), " "( 'Test_4', 45 ), "
"( 'Test_5', 46 );"); "( 'Test_5', 46 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable WHERE IntColumn > 44;"); result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable WHERE IntColumn > 44;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 2u);
EXPECT(result.has_results()); for (auto& row : result) {
EXPECT_EQ(result.results().size(), 2u);
for (auto& row : result.results()) {
EXPECT(row.row[1].to_int().value() > 44); EXPECT(row.row[1].to_int().value() > 44);
} }
} }
@ -287,8 +280,7 @@ TEST_CASE(select_cross_join)
"( 'Test_3', 44 ), " "( 'Test_3', 44 ), "
"( 'Test_4', 45 ), " "( 'Test_4', 45 ), "
"( 'Test_5', 46 );"); "( 'Test_5', 46 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, result = execute(database,
"INSERT INTO TestSchema.TestTable2 ( TextColumn2, IntColumn ) VALUES " "INSERT INTO TestSchema.TestTable2 ( TextColumn2, IntColumn ) VALUES "
"( 'Test_10', 40 ), " "( 'Test_10', 40 ), "
@ -296,13 +288,10 @@ TEST_CASE(select_cross_join)
"( 'Test_12', 42 ), " "( 'Test_12', 42 ), "
"( 'Test_13', 47 ), " "( 'Test_13', 47 ), "
"( 'Test_14', 48 );"); "( 'Test_14', 48 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, "SELECT * FROM TestSchema.TestTable1, TestSchema.TestTable2;"); result = execute(database, "SELECT * FROM TestSchema.TestTable1, TestSchema.TestTable2;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 25u);
EXPECT(result.has_results()); for (auto& row : result) {
EXPECT_EQ(result.results().size(), 25u);
for (auto& row : result.results()) {
EXPECT(row.row.size() == 4); EXPECT(row.row.size() == 4);
EXPECT(row.row[1].to_int().value() >= 42); EXPECT(row.row[1].to_int().value() >= 42);
EXPECT(row.row[1].to_int().value() <= 46); EXPECT(row.row[1].to_int().value() <= 46);
@ -324,8 +313,7 @@ TEST_CASE(select_inner_join)
"( 'Test_3', 44 ), " "( 'Test_3', 44 ), "
"( 'Test_4', 45 ), " "( 'Test_4', 45 ), "
"( 'Test_5', 46 );"); "( 'Test_5', 46 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, result = execute(database,
"INSERT INTO TestSchema.TestTable2 ( TextColumn2, IntColumn ) VALUES " "INSERT INTO TestSchema.TestTable2 ( TextColumn2, IntColumn ) VALUES "
"( 'Test_10', 40 ), " "( 'Test_10', 40 ), "
@ -333,20 +321,16 @@ TEST_CASE(select_inner_join)
"( 'Test_12', 42 ), " "( 'Test_12', 42 ), "
"( 'Test_13', 47 ), " "( 'Test_13', 47 ), "
"( 'Test_14', 48 );"); "( 'Test_14', 48 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, result = execute(database,
"SELECT TestTable1.IntColumn, TextColumn1, TextColumn2 " "SELECT TestTable1.IntColumn, TextColumn1, TextColumn2 "
"FROM TestSchema.TestTable1, TestSchema.TestTable2 " "FROM TestSchema.TestTable1, TestSchema.TestTable2 "
"WHERE TestTable1.IntColumn = TestTable2.IntColumn;"); "WHERE TestTable1.IntColumn = TestTable2.IntColumn;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 1u);
EXPECT(result.has_results()); EXPECT_EQ(result[0].row.size(), 3u);
EXPECT_EQ(result.results().size(), 1u); EXPECT_EQ(result[0].row[0].to_int().value(), 42);
auto& row = result.results()[0]; EXPECT_EQ(result[0].row[1].to_string(), "Test_1");
EXPECT_EQ(row.row.size(), 3u); EXPECT_EQ(result[0].row[2].to_string(), "Test_12");
EXPECT_EQ(row.row[0].to_int().value(), 42);
EXPECT_EQ(row.row[1].to_string(), "Test_1");
EXPECT_EQ(row.row[2].to_string(), "Test_12");
} }
TEST_CASE(select_with_like) TEST_CASE(select_with_like)
@ -363,63 +347,48 @@ TEST_CASE(select_with_like)
"( 'Test+4', 45 ), " "( 'Test+4', 45 ), "
"( 'Test+5', 46 ), " "( 'Test+5', 46 ), "
"( 'Another+Test_6', 47 );"); "( 'Another+Test_6', 47 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 6);
EXPECT(result.inserted() == 6);
// Simple match // Simple match
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE 'Test+1';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE 'Test+1';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 1u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 1u);
// Use % to match most rows // Use % to match most rows
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE 'T%';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE 'T%';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 5u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 5u);
// Same as above but invert the match // Same as above but invert the match
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn NOT LIKE 'T%';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn NOT LIKE 'T%';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 1u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 1u);
// Use _ and % to match all rows // Use _ and % to match all rows
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%e_t%';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%e_t%';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 6u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 6u);
// Use escape to match a single row. The escape character happens to be a // Use escape to match a single row. The escape character happens to be a
// Regex metacharacter, let's make sure we don't get confused by that. // Regex metacharacter, let's make sure we don't get confused by that.
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%Test^_%' ESCAPE '^';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%Test^_%' ESCAPE '^';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 1u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 1u);
// Same as above but escape the escape character happens to be a SQL // Same as above but escape the escape character happens to be a SQL
// metacharacter - we want to make sure it's treated as an escape. // metacharacter - we want to make sure it's treated as an escape.
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%Test__%' ESCAPE '_';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%Test__%' ESCAPE '_';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 1u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 1u);
// (Unnecessarily) escaping a character that happens to be a Regex // (Unnecessarily) escaping a character that happens to be a Regex
// metacharacter should have no effect. // metacharacter should have no effect.
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE 'Test:+_' ESCAPE ':';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE 'Test:+_' ESCAPE ':';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 5u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 5u);
// Make sure we error out if the ESCAPE is empty // Make sure we error out if the ESCAPE is empty
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%' ESCAPE '';"); auto select_result = try_execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%' ESCAPE '';");
EXPECT(result.error() == SQL::SQLErrorCode::SyntaxError); EXPECT(select_result.is_error());
EXPECT(!result.has_results()); EXPECT(select_result.release_error().error() == SQL::SQLErrorCode::SyntaxError);
// Make sure we error out if the ESCAPE has more than a single character // Make sure we error out if the ESCAPE has more than a single character
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%' ESCAPE 'whf';"); select_result = try_execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%' ESCAPE 'whf';");
EXPECT(result.error() == SQL::SQLErrorCode::SyntaxError); EXPECT(select_result.is_error());
EXPECT(!result.has_results()); EXPECT(select_result.release_error().error() == SQL::SQLErrorCode::SyntaxError);
} }
TEST_CASE(select_with_order) TEST_CASE(select_with_order)
@ -435,30 +404,23 @@ TEST_CASE(select_with_order)
"( 'Test_1', 47 ), " "( 'Test_1', 47 ), "
"( 'Test_3', 40 ), " "( 'Test_3', 40 ), "
"( 'Test_4', 41 );"); "( 'Test_4', 41 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;"); result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 5u);
EXPECT(result.has_results()); EXPECT_EQ(result[0].row[1].to_int().value(), 40);
auto rows = result.results(); EXPECT_EQ(result[1].row[1].to_int().value(), 41);
EXPECT_EQ(rows.size(), 5u); EXPECT_EQ(result[2].row[1].to_int().value(), 42);
EXPECT_EQ(rows[0].row[1].to_int().value(), 40); EXPECT_EQ(result[3].row[1].to_int().value(), 44);
EXPECT_EQ(rows[1].row[1].to_int().value(), 41); EXPECT_EQ(result[4].row[1].to_int().value(), 47);
EXPECT_EQ(rows[2].row[1].to_int().value(), 42);
EXPECT_EQ(rows[3].row[1].to_int().value(), 44);
EXPECT_EQ(rows[4].row[1].to_int().value(), 47);
result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY TextColumn;"); result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY TextColumn;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 5u);
EXPECT(result.has_results()); EXPECT_EQ(result[0].row[0].to_string(), "Test_1");
rows = result.results(); EXPECT_EQ(result[1].row[0].to_string(), "Test_2");
EXPECT_EQ(rows.size(), 5u); EXPECT_EQ(result[2].row[0].to_string(), "Test_3");
EXPECT_EQ(rows[0].row[0].to_string(), "Test_1"); EXPECT_EQ(result[3].row[0].to_string(), "Test_4");
EXPECT_EQ(rows[1].row[0].to_string(), "Test_2"); EXPECT_EQ(result[4].row[0].to_string(), "Test_5");
EXPECT_EQ(rows[2].row[0].to_string(), "Test_3");
EXPECT_EQ(rows[3].row[0].to_string(), "Test_4");
EXPECT_EQ(rows[4].row[0].to_string(), "Test_5");
} }
TEST_CASE(select_with_regexp) TEST_CASE(select_with_regexp)
@ -475,34 +437,25 @@ TEST_CASE(select_with_regexp)
"( 'Test[4]', 45 ), " "( 'Test[4]', 45 ), "
"( 'Test+5', 46 ), " "( 'Test+5', 46 ), "
"( 'Another-Test_6', 47 );"); "( 'Another-Test_6', 47 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 6);
EXPECT(result.inserted() == 6);
// Simple match // Simple match
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP 'Test\\+1';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP 'Test\\+1';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 1u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 1u);
// Match all // Match all
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP '.*';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP '.*';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 6u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 6u);
// Match with wildcards // Match with wildcards
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP '^Test.+';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP '^Test.+';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 4u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 4u);
// Match with case insensitive basic Latin and case sensitive Swedish ö // Match with case insensitive basic Latin and case sensitive Swedish ö
// FIXME: If LibRegex is changed to support case insensitive matches of Unicode characters // FIXME: If LibRegex is changed to support case insensitive matches of Unicode characters
// This test should be updated and changed to match 'PRÖV'. // This test should be updated and changed to match 'PRÖV'.
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP 'PRöV.*';"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP 'PRöV.*';");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 1u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 1u);
} }
TEST_CASE(handle_regexp_errors) TEST_CASE(handle_regexp_errors)
@ -514,13 +467,11 @@ TEST_CASE(handle_regexp_errors)
auto result = execute(database, auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES " "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
"( 'Test', 0 );"); "( 'Test', 0 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 1);
EXPECT(result.inserted() == 1);
// Malformed regex, unmatched square bracket // Malformed regex, unmatched square bracket
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP 'Test\\+[0-9.*';"); auto select_result = try_execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP 'Test\\+[0-9.*';");
EXPECT(result.is_error()); EXPECT(select_result.is_error());
EXPECT(!result.has_results());
} }
TEST_CASE(select_with_order_two_columns) TEST_CASE(select_with_order_two_columns)
@ -536,24 +487,20 @@ TEST_CASE(select_with_order_two_columns)
"( 'Test_1', 47 ), " "( 'Test_1', 47 ), "
"( 'Test_2', 40 ), " "( 'Test_2', 40 ), "
"( 'Test_4', 41 );"); "( 'Test_4', 41 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY TextColumn, IntColumn;"); result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY TextColumn, IntColumn;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 5u);
EXPECT(result.has_results()); EXPECT_EQ(result[0].row[0].to_string(), "Test_1");
auto rows = result.results(); EXPECT_EQ(result[0].row[1].to_int().value(), 47);
EXPECT_EQ(rows.size(), 5u); EXPECT_EQ(result[1].row[0].to_string(), "Test_2");
EXPECT_EQ(rows[0].row[0].to_string(), "Test_1"); EXPECT_EQ(result[1].row[1].to_int().value(), 40);
EXPECT_EQ(rows[0].row[1].to_int().value(), 47); EXPECT_EQ(result[2].row[0].to_string(), "Test_2");
EXPECT_EQ(rows[1].row[0].to_string(), "Test_2"); EXPECT_EQ(result[2].row[1].to_int().value(), 42);
EXPECT_EQ(rows[1].row[1].to_int().value(), 40); EXPECT_EQ(result[3].row[0].to_string(), "Test_4");
EXPECT_EQ(rows[2].row[0].to_string(), "Test_2"); EXPECT_EQ(result[3].row[1].to_int().value(), 41);
EXPECT_EQ(rows[2].row[1].to_int().value(), 42); EXPECT_EQ(result[4].row[0].to_string(), "Test_5");
EXPECT_EQ(rows[3].row[0].to_string(), "Test_4"); EXPECT_EQ(result[4].row[1].to_int().value(), 44);
EXPECT_EQ(rows[3].row[1].to_int().value(), 41);
EXPECT_EQ(rows[4].row[0].to_string(), "Test_5");
EXPECT_EQ(rows[4].row[1].to_int().value(), 44);
} }
TEST_CASE(select_with_order_by_column_not_in_result) TEST_CASE(select_with_order_by_column_not_in_result)
@ -569,19 +516,15 @@ TEST_CASE(select_with_order_by_column_not_in_result)
"( 'Test_1', 47 ), " "( 'Test_1', 47 ), "
"( 'Test_3', 40 ), " "( 'Test_3', 40 ), "
"( 'Test_4', 41 );"); "( 'Test_4', 41 );");
EXPECT(!result.is_error()); EXPECT(result.size() == 5);
EXPECT(result.inserted() == 5);
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable ORDER BY IntColumn;"); result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 5u);
EXPECT(result.has_results()); EXPECT_EQ(result[0].row[0].to_string(), "Test_3");
auto rows = result.results(); EXPECT_EQ(result[1].row[0].to_string(), "Test_4");
EXPECT_EQ(rows.size(), 5u); EXPECT_EQ(result[2].row[0].to_string(), "Test_2");
EXPECT_EQ(rows[0].row[0].to_string(), "Test_3"); EXPECT_EQ(result[3].row[0].to_string(), "Test_5");
EXPECT_EQ(rows[1].row[0].to_string(), "Test_4"); EXPECT_EQ(result[4].row[0].to_string(), "Test_1");
EXPECT_EQ(rows[2].row[0].to_string(), "Test_2");
EXPECT_EQ(rows[3].row[0].to_string(), "Test_5");
EXPECT_EQ(rows[4].row[0].to_string(), "Test_1");
} }
TEST_CASE(select_with_limit) TEST_CASE(select_with_limit)
@ -593,13 +536,10 @@ TEST_CASE(select_with_limit)
for (auto count = 0; count < 100; count++) { for (auto count = 0; count < 100; count++) {
auto result = execute(database, auto result = execute(database,
String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count)); String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count));
EXPECT(!result.is_error()); EXPECT(result.size() == 1);
EXPECT(result.inserted() == 1);
} }
auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 10;"); auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 10;");
EXPECT(!result.is_error()); auto rows = result;
EXPECT(result.has_results());
auto rows = result.results();
EXPECT_EQ(rows.size(), 10u); EXPECT_EQ(rows.size(), 10u);
} }
@ -612,14 +552,10 @@ TEST_CASE(select_with_limit_and_offset)
for (auto count = 0; count < 100; count++) { for (auto count = 0; count < 100; count++) {
auto result = execute(database, auto result = execute(database,
String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count)); String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count));
EXPECT(!result.is_error()); EXPECT(result.size() == 1);
EXPECT(result.inserted() == 1);
} }
auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 10 OFFSET 10;"); auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 10 OFFSET 10;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 10u);
EXPECT(result.has_results());
auto rows = result.results();
EXPECT_EQ(rows.size(), 10u);
} }
TEST_CASE(select_with_order_limit_and_offset) TEST_CASE(select_with_order_limit_and_offset)
@ -631,24 +567,20 @@ TEST_CASE(select_with_order_limit_and_offset)
for (auto count = 0; count < 100; count++) { for (auto count = 0; count < 100; count++) {
auto result = execute(database, auto result = execute(database,
String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count)); String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count));
EXPECT(!result.is_error()); EXPECT(result.size() == 1);
EXPECT(result.inserted() == 1);
} }
auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY IntColumn LIMIT 10 OFFSET 10;"); auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY IntColumn LIMIT 10 OFFSET 10;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 10u);
EXPECT(result.has_results()); EXPECT_EQ(result[0].row[1].to_int().value(), 10);
auto rows = result.results(); EXPECT_EQ(result[1].row[1].to_int().value(), 11);
EXPECT_EQ(rows.size(), 10u); EXPECT_EQ(result[2].row[1].to_int().value(), 12);
EXPECT_EQ(rows[0].row[1].to_int().value(), 10); EXPECT_EQ(result[3].row[1].to_int().value(), 13);
EXPECT_EQ(rows[1].row[1].to_int().value(), 11); EXPECT_EQ(result[4].row[1].to_int().value(), 14);
EXPECT_EQ(rows[2].row[1].to_int().value(), 12); EXPECT_EQ(result[5].row[1].to_int().value(), 15);
EXPECT_EQ(rows[3].row[1].to_int().value(), 13); EXPECT_EQ(result[6].row[1].to_int().value(), 16);
EXPECT_EQ(rows[4].row[1].to_int().value(), 14); EXPECT_EQ(result[7].row[1].to_int().value(), 17);
EXPECT_EQ(rows[5].row[1].to_int().value(), 15); EXPECT_EQ(result[8].row[1].to_int().value(), 18);
EXPECT_EQ(rows[6].row[1].to_int().value(), 16); EXPECT_EQ(result[9].row[1].to_int().value(), 19);
EXPECT_EQ(rows[7].row[1].to_int().value(), 17);
EXPECT_EQ(rows[8].row[1].to_int().value(), 18);
EXPECT_EQ(rows[9].row[1].to_int().value(), 19);
} }
TEST_CASE(select_with_limit_out_of_bounds) TEST_CASE(select_with_limit_out_of_bounds)
@ -660,14 +592,10 @@ TEST_CASE(select_with_limit_out_of_bounds)
for (auto count = 0; count < 100; count++) { for (auto count = 0; count < 100; count++) {
auto result = execute(database, auto result = execute(database,
String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count)); String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count));
EXPECT(!result.is_error()); EXPECT(result.size() == 1);
EXPECT(result.inserted() == 1);
} }
auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 500;"); auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 500;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 100u);
EXPECT(result.has_results());
auto rows = result.results();
EXPECT_EQ(rows.size(), 100u);
} }
TEST_CASE(select_with_offset_out_of_bounds) TEST_CASE(select_with_offset_out_of_bounds)
@ -679,14 +607,10 @@ TEST_CASE(select_with_offset_out_of_bounds)
for (auto count = 0; count < 100; count++) { for (auto count = 0; count < 100; count++) {
auto result = execute(database, auto result = execute(database,
String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count)); String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count));
EXPECT(!result.is_error()); EXPECT(result.size() == 1);
EXPECT(result.inserted() == 1);
} }
auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 10 OFFSET 200;"); auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 10 OFFSET 200;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 0u);
EXPECT(result.has_results());
auto rows = result.results();
EXPECT_EQ(rows.size(), 0u);
} }
TEST_CASE(describe_table) TEST_CASE(describe_table)
@ -696,18 +620,13 @@ TEST_CASE(describe_table)
EXPECT(!database->open().is_error()); EXPECT(!database->open().is_error());
create_table(database); create_table(database);
auto result = execute(database, "DESCRIBE TABLE TestSchema.TestTable;"); auto result = execute(database, "DESCRIBE TABLE TestSchema.TestTable;");
EXPECT(!result.is_error()); EXPECT_EQ(result.size(), 2u);
EXPECT(result.has_results());
EXPECT_EQ(result.results().size(), 2u);
auto rows = result.results(); EXPECT_EQ(result[0].row[0].to_string(), "TEXTCOLUMN");
auto& row1 = rows[0]; EXPECT_EQ(result[0].row[1].to_string(), "text");
EXPECT_EQ(row1.row[0].to_string(), "TEXTCOLUMN");
EXPECT_EQ(row1.row[1].to_string(), "text");
auto& row2 = rows[1]; EXPECT_EQ(result[1].row[0].to_string(), "INTCOLUMN");
EXPECT_EQ(row2.row[0].to_string(), "INTCOLUMN"); EXPECT_EQ(result[1].row[1].to_string(), "int");
EXPECT_EQ(row2.row[1].to_string(), "int");
} }
} }

17
Userland/Libraries/LibSQL/AST/AST.h
View file

@ -15,6 +15,7 @@
#include <LibSQL/AST/Token.h> #include <LibSQL/AST/Token.h>
#include <LibSQL/Forward.h> #include <LibSQL/Forward.h>
#include <LibSQL/Result.h> #include <LibSQL/Result.h>
#include <LibSQL/ResultSet.h>
#include <LibSQL/Type.h> #include <LibSQL/Type.h>
namespace SQL::AST { namespace SQL::AST {
@ -725,11 +726,11 @@ private:
class Statement : public ASTNode { class Statement : public ASTNode {
public: public:
Result execute(AK::NonnullRefPtr<Database> database) const; ResultOr<ResultSet> execute(AK::NonnullRefPtr<Database> database) const;
virtual Result execute(ExecutionContext&) const virtual ResultOr<ResultSet> execute(ExecutionContext&) const
{ {
return { SQLCommand::Unknown, SQLErrorCode::NotYetImplemented }; return Result { SQLCommand::Unknown, SQLErrorCode::NotYetImplemented };
} }
}; };
@ -747,7 +748,7 @@ public:
const String& schema_name() const { return m_schema_name; } const String& schema_name() const { return m_schema_name; }
bool is_error_if_schema_exists() const { return m_is_error_if_schema_exists; } bool is_error_if_schema_exists() const { return m_is_error_if_schema_exists; }
Result execute(ExecutionContext&) const override; ResultOr<ResultSet> execute(ExecutionContext&) const override;
private: private:
String m_schema_name; String m_schema_name;
@ -786,7 +787,7 @@ public:
bool is_temporary() const { return m_is_temporary; } bool is_temporary() const { return m_is_temporary; }
bool is_error_if_table_exists() const { return m_is_error_if_table_exists; } bool is_error_if_table_exists() const { return m_is_error_if_table_exists; }
Result execute(ExecutionContext&) const override; ResultOr<ResultSet> execute(ExecutionContext&) const override;
private: private:
String m_schema_name; String m_schema_name;
@ -949,7 +950,7 @@ public:
bool has_selection() const { return !m_select_statement.is_null(); } bool has_selection() const { return !m_select_statement.is_null(); }
const RefPtr<Select>& select_statement() const { return m_select_statement; } const RefPtr<Select>& select_statement() const { return m_select_statement; }
virtual Result execute(ExecutionContext&) const override; virtual ResultOr<ResultSet> execute(ExecutionContext&) const override;
private: private:
RefPtr<CommonTableExpressionList> m_common_table_expression_list; RefPtr<CommonTableExpressionList> m_common_table_expression_list;
@ -1042,7 +1043,7 @@ public:
const RefPtr<GroupByClause>& group_by_clause() const { return m_group_by_clause; } const RefPtr<GroupByClause>& group_by_clause() const { return m_group_by_clause; }
const NonnullRefPtrVector<OrderingTerm>& ordering_term_list() const { return m_ordering_term_list; } const NonnullRefPtrVector<OrderingTerm>& ordering_term_list() const { return m_ordering_term_list; }
const RefPtr<LimitClause>& limit_clause() const { return m_limit_clause; } const RefPtr<LimitClause>& limit_clause() const { return m_limit_clause; }
Result execute(ExecutionContext&) const override; ResultOr<ResultSet> execute(ExecutionContext&) const override;
private: private:
RefPtr<CommonTableExpressionList> m_common_table_expression_list; RefPtr<CommonTableExpressionList> m_common_table_expression_list;
@ -1063,7 +1064,7 @@ public:
} }
NonnullRefPtr<QualifiedTableName> qualified_table_name() const { return m_qualified_table_name; } NonnullRefPtr<QualifiedTableName> qualified_table_name() const { return m_qualified_table_name; }
Result execute(ExecutionContext&) const override; ResultOr<ResultSet> execute(ExecutionContext&) const override;
private: private:
NonnullRefPtr<QualifiedTableName> m_qualified_table_name; NonnullRefPtr<QualifiedTableName> m_qualified_table_name;

8
Userland/Libraries/LibSQL/AST/CreateSchema.cpp
View file

@ -10,20 +10,20 @@
namespace SQL::AST { namespace SQL::AST {
Result CreateSchema::execute(ExecutionContext& context) const ResultOr<ResultSet> CreateSchema::execute(ExecutionContext& context) const
{ {
auto schema_def = TRY(context.database->get_schema(m_schema_name)); auto schema_def = TRY(context.database->get_schema(m_schema_name));
if (schema_def) { if (schema_def) {
if (m_is_error_if_schema_exists) if (m_is_error_if_schema_exists)
return { SQLCommand::Create, SQLErrorCode::SchemaExists, m_schema_name }; return Result { SQLCommand::Create, SQLErrorCode::SchemaExists, m_schema_name };
return { SQLCommand::Create }; return ResultSet { SQLCommand::Create };
} }
schema_def = SchemaDef::construct(m_schema_name); schema_def = SchemaDef::construct(m_schema_name);
TRY(context.database->add_schema(*schema_def)); TRY(context.database->add_schema(*schema_def));
return { SQLCommand::Create, 0, 1 }; return ResultSet { SQLCommand::Create };
} }
} }

12
Userland/Libraries/LibSQL/AST/CreateTable.cpp
View file

@ -9,19 +9,19 @@
namespace SQL::AST { namespace SQL::AST {
Result CreateTable::execute(ExecutionContext& context) const ResultOr<ResultSet> CreateTable::execute(ExecutionContext& context) const
{ {
auto schema_name = m_schema_name.is_empty() ? String { "default"sv } : m_schema_name; auto schema_name = m_schema_name.is_empty() ? String { "default"sv } : m_schema_name;
auto schema_def = TRY(context.database->get_schema(schema_name)); auto schema_def = TRY(context.database->get_schema(schema_name));
if (!schema_def) if (!schema_def)
return { SQLCommand::Create, SQLErrorCode::SchemaDoesNotExist, schema_name }; return Result { SQLCommand::Create, SQLErrorCode::SchemaDoesNotExist, schema_name };
auto table_def = TRY(context.database->get_table(schema_name, m_table_name)); auto table_def = TRY(context.database->get_table(schema_name, m_table_name));
if (table_def) { if (table_def) {
if (m_is_error_if_table_exists) if (m_is_error_if_table_exists)
return { SQLCommand::Create, SQLErrorCode::TableExists, m_table_name }; return Result { SQLCommand::Create, SQLErrorCode::TableExists, m_table_name };
return { SQLCommand::Create }; return ResultSet { SQLCommand::Create };
} }
table_def = TableDef::construct(schema_def, m_table_name); table_def = TableDef::construct(schema_def, m_table_name);
@ -36,13 +36,13 @@ Result CreateTable::execute(ExecutionContext& context) const
else if (column.type_name()->name().is_one_of("FLOAT"sv, "NUMBER"sv)) else if (column.type_name()->name().is_one_of("FLOAT"sv, "NUMBER"sv))
type = SQLType::Float; type = SQLType::Float;
else else
return { SQLCommand::Create, SQLErrorCode::InvalidType, column.type_name()->name() }; return Result { SQLCommand::Create, SQLErrorCode::InvalidType, column.type_name()->name() };
table_def->append_column(column.name(), type); table_def->append_column(column.name(), type);
} }
TRY(context.database->add_table(*table_def)); TRY(context.database->add_table(*table_def));
return { SQLCommand::Create, 0, 1 }; return ResultSet { SQLCommand::Create };
} }
} }

11
Userland/Libraries/LibSQL/AST/Describe.cpp
View file

@ -7,11 +7,12 @@
#include <LibSQL/AST/AST.h> #include <LibSQL/AST/AST.h>
#include <LibSQL/Database.h> #include <LibSQL/Database.h>
#include <LibSQL/Meta.h> #include <LibSQL/Meta.h>
#include <LibSQL/ResultSet.h>
#include <LibSQL/Row.h> #include <LibSQL/Row.h>
namespace SQL::AST { namespace SQL::AST {
Result DescribeTable::execute(ExecutionContext& context) const ResultOr<ResultSet> DescribeTable::execute(ExecutionContext& context) const
{ {
auto schema_name = m_qualified_table_name->schema_name(); auto schema_name = m_qualified_table_name->schema_name();
auto table_name = m_qualified_table_name->table_name(); auto table_name = m_qualified_table_name->table_name();
@ -20,19 +21,21 @@ Result DescribeTable::execute(ExecutionContext& context) const
if (!table_def) { if (!table_def) {
if (schema_name.is_empty()) if (schema_name.is_empty())
schema_name = "default"sv; schema_name = "default"sv;
return { SQLCommand::Describe, SQLErrorCode::TableDoesNotExist, String::formatted("{}.{}", schema_name, table_name) }; return Result { SQLCommand::Describe, SQLErrorCode::TableDoesNotExist, String::formatted("{}.{}", schema_name, table_name) };
} }
auto describe_table_def = MUST(context.database->get_table("master"sv, "internal_describe_table"sv)); auto describe_table_def = MUST(context.database->get_table("master"sv, "internal_describe_table"sv));
auto descriptor = describe_table_def->to_tuple_descriptor(); auto descriptor = describe_table_def->to_tuple_descriptor();
Result result { SQLCommand::Describe }; ResultSet result { SQLCommand::Describe };
TRY(result.try_ensure_capacity(table_def->columns().size()));
for (auto& column : table_def->columns()) { for (auto& column : table_def->columns()) {
Tuple tuple(descriptor); Tuple tuple(descriptor);
tuple[0] = column.name(); tuple[0] = column.name();
tuple[1] = SQLType_name(column.type()); tuple[1] = SQLType_name(column.type());
result.insert(tuple, Tuple {});
result.insert_row(tuple, Tuple {});
} }
return result; return result;

22
Userland/Libraries/LibSQL/AST/Insert.cpp
View file

@ -21,23 +21,23 @@ static bool does_value_data_type_match(SQLType expected, SQLType actual)
return expected == actual; return expected == actual;
} }
Result Insert::execute(ExecutionContext& context) const ResultOr<ResultSet> Insert::execute(ExecutionContext& context) const
{ {
auto table_def = TRY(context.database->get_table(m_schema_name, m_table_name)); auto table_def = TRY(context.database->get_table(m_schema_name, m_table_name));
if (!table_def) { if (!table_def) {
auto schema_name = m_schema_name.is_empty() ? String("default"sv) : m_schema_name; auto schema_name = m_schema_name.is_empty() ? String("default"sv) : m_schema_name;
return { SQLCommand::Insert, SQLErrorCode::TableDoesNotExist, String::formatted("{}.{}", schema_name, m_table_name) }; return Result { SQLCommand::Insert, SQLErrorCode::TableDoesNotExist, String::formatted("{}.{}", schema_name, m_table_name) };
} }
Row row(table_def); Row row(table_def);
for (auto& column : m_column_names) { for (auto& column : m_column_names) {
if (!row.has(column)) if (!row.has(column))
return { SQLCommand::Insert, SQLErrorCode::ColumnDoesNotExist, column }; return Result { SQLCommand::Insert, SQLErrorCode::ColumnDoesNotExist, column };
} }
Vector<Row> inserted_rows; ResultSet result { SQLCommand::Insert };
TRY(inserted_rows.try_ensure_capacity(m_chained_expressions.size())); TRY(result.try_ensure_capacity(m_chained_expressions.size()));
context.result = Result { SQLCommand::Insert }; context.result = Result { SQLCommand::Insert };
@ -55,7 +55,7 @@ Result Insert::execute(ExecutionContext& context) const
auto values = row_value.to_vector().value(); auto values = row_value.to_vector().value();
if (m_column_names.is_empty() && values.size() != row.size()) if (m_column_names.is_empty() && values.size() != row.size())
return { SQLCommand::Insert, SQLErrorCode::InvalidNumberOfValues, String::empty() }; return Result { SQLCommand::Insert, SQLErrorCode::InvalidNumberOfValues, String::empty() };
for (auto ix = 0u; ix < values.size(); ix++) { for (auto ix = 0u; ix < values.size(); ix++) {
auto input_value_type = values[ix].type(); auto input_value_type = values[ix].type();
@ -65,18 +65,16 @@ Result Insert::execute(ExecutionContext& context) const
auto element_type = tuple_descriptor[element_index].type; auto element_type = tuple_descriptor[element_index].type;
if (!does_value_data_type_match(element_type, input_value_type)) if (!does_value_data_type_match(element_type, input_value_type))
return { SQLCommand::Insert, SQLErrorCode::InvalidValueType, table_def->columns()[element_index].name() }; return Result { SQLCommand::Insert, SQLErrorCode::InvalidValueType, table_def->columns()[element_index].name() };
row[element_index] = values[ix]; row[element_index] = values[ix];
} }
inserted_rows.append(row); TRY(context.database->insert(row));
result.insert_row(row, {});
} }
for (auto& inserted_row : inserted_rows) return result;
TRY(context.database->insert(inserted_row));
return { SQLCommand::Insert, 0, m_chained_expressions.size() };
} }
} }

22
Userland/Libraries/LibSQL/AST/Select.cpp
View file

@ -8,12 +8,11 @@
#include <LibSQL/AST/AST.h> #include <LibSQL/AST/AST.h>
#include <LibSQL/Database.h> #include <LibSQL/Database.h>
#include <LibSQL/Meta.h> #include <LibSQL/Meta.h>
#include <LibSQL/ResultSet.h>
#include <LibSQL/Row.h> #include <LibSQL/Row.h>
namespace SQL::AST { namespace SQL::AST {
Result Select::execute(ExecutionContext& context) const ResultOr<ResultSet> Select::execute(ExecutionContext& context) const
{ {
NonnullRefPtrVector<ResultColumn> columns; NonnullRefPtrVector<ResultColumn> columns;
@ -22,11 +21,11 @@ Result Select::execute(ExecutionContext& context) const
for (auto& table_descriptor : table_or_subquery_list()) { for (auto& table_descriptor : table_or_subquery_list()) {
if (!table_descriptor.is_table()) if (!table_descriptor.is_table())
return { SQLCommand::Select, SQLErrorCode::NotYetImplemented, "Sub-selects are not yet implemented"sv }; return Result { SQLCommand::Select, SQLErrorCode::NotYetImplemented, "Sub-selects are not yet implemented"sv };
auto table_def = TRY(context.database->get_table(table_descriptor.schema_name(), table_descriptor.table_name())); auto table_def = TRY(context.database->get_table(table_descriptor.schema_name(), table_descriptor.table_name()));
if (!table_def) if (!table_def)
return { SQLCommand::Select, SQLErrorCode::TableDoesNotExist, table_descriptor.table_name() }; return Result { SQLCommand::Select, SQLErrorCode::TableDoesNotExist, table_descriptor.table_name() };
if (result_column_list.size() == 1 && result_column_list[0].type() == ResultType::All) { if (result_column_list.size() == 1 && result_column_list[0].type() == ResultType::All) {
for (auto& col : table_def->columns()) { for (auto& col : table_def->columns()) {
@ -42,7 +41,7 @@ Result Select::execute(ExecutionContext& context) const
for (auto& col : result_column_list) { for (auto& col : result_column_list) {
if (col.type() == ResultType::All) { if (col.type() == ResultType::All) {
// FIXME can have '*' for example in conjunction with computed columns // FIXME can have '*' for example in conjunction with computed columns
return { SQLCommand::Select, SQLErrorCode::SyntaxError, "*"sv }; return Result { SQLCommand::Select, SQLErrorCode::SyntaxError, "*"sv };
} }
columns.append(col); columns.append(col);
@ -50,6 +49,7 @@ Result Select::execute(ExecutionContext& context) const
} }
context.result = Result { SQLCommand::Select }; context.result = Result { SQLCommand::Select };
ResultSet result { SQLCommand::Select };
auto descriptor = adopt_ref(*new TupleDescriptor); auto descriptor = adopt_ref(*new TupleDescriptor);
Tuple tuple(descriptor); Tuple tuple(descriptor);
@ -60,7 +60,7 @@ Result Select::execute(ExecutionContext& context) const
for (auto& table_descriptor : table_or_subquery_list()) { for (auto& table_descriptor : table_or_subquery_list()) {
if (!table_descriptor.is_table()) if (!table_descriptor.is_table())
return { SQLCommand::Select, SQLErrorCode::NotYetImplemented, "Sub-selects are not yet implemented"sv }; return Result { SQLCommand::Select, SQLErrorCode::NotYetImplemented, "Sub-selects are not yet implemented"sv };
auto table_def = TRY(context.database->get_table(table_descriptor.schema_name(), table_descriptor.table_name())); auto table_def = TRY(context.database->get_table(table_descriptor.schema_name(), table_descriptor.table_name()));
if (table_def->num_columns() == 0) if (table_def->num_columns() == 0)
@ -119,7 +119,7 @@ Result Select::execute(ExecutionContext& context) const
} }
} }
context.result->insert(tuple, sort_key); result.insert_row(tuple, sort_key);
} }
if (m_limit_clause != nullptr) { if (m_limit_clause != nullptr) {
@ -130,7 +130,7 @@ Result Select::execute(ExecutionContext& context) const
if (!limit.is_null()) { if (!limit.is_null()) {
auto limit_value_maybe = limit.to_u32(); auto limit_value_maybe = limit.to_u32();
if (!limit_value_maybe.has_value()) if (!limit_value_maybe.has_value())
return { SQLCommand::Select, SQLErrorCode::SyntaxError, "LIMIT clause must evaluate to an integer value"sv }; return Result { SQLCommand::Select, SQLErrorCode::SyntaxError, "LIMIT clause must evaluate to an integer value"sv };
limit_value = limit_value_maybe.value(); limit_value = limit_value_maybe.value();
} }
@ -140,16 +140,16 @@ Result Select::execute(ExecutionContext& context) const
if (!offset.is_null()) { if (!offset.is_null()) {
auto offset_value_maybe = offset.to_u32(); auto offset_value_maybe = offset.to_u32();
if (!offset_value_maybe.has_value()) if (!offset_value_maybe.has_value())
return { SQLCommand::Select, SQLErrorCode::SyntaxError, "OFFSET clause must evaluate to an integer value"sv }; return Result { SQLCommand::Select, SQLErrorCode::SyntaxError, "OFFSET clause must evaluate to an integer value"sv };
offset_value = offset_value_maybe.value(); offset_value = offset_value_maybe.value();
} }
} }
context.result->limit(offset_value, limit_value); result.limit(offset_value, limit_value);
} }
return context.result.release_value(); return result;
} }
} }

2
Userland/Libraries/LibSQL/AST/Statement.cpp
View file

@ -11,7 +11,7 @@
namespace SQL::AST { namespace SQL::AST {
Result Statement::execute(AK::NonnullRefPtr<Database> database) const ResultOr<ResultSet> Statement::execute(AK::NonnullRefPtr<Database> database) const
{ {
ExecutionContext context { move(database), {}, this, nullptr }; ExecutionContext context { move(database), {}, this, nullptr };
return execute(context); return execute(context);

1
Userland/Libraries/LibSQL/Forward.h
View file

@ -23,6 +23,7 @@ class Key;
class KeyPartDef; class KeyPartDef;
class Relation; class Relation;
class Result; class Result;
class ResultSet;
class Row; class Row;
class SchemaDef; class SchemaDef;
class Serializer; class Serializer;

24
Userland/Libraries/LibSQL/Result.cpp
View file

@ -9,30 +9,6 @@
namespace SQL { namespace SQL {
void Result::insert(Tuple const& row, Tuple const& sort_key)
{
if (!m_result_set.has_value())
m_result_set = ResultSet {};
m_result_set->insert_row(row, sort_key);
}
void Result::limit(size_t offset, size_t limit)
{
VERIFY(has_results());
if (offset > 0) {
if (offset > m_result_set->size()) {
m_result_set->clear();
return;
}
m_result_set->remove(0, offset);
}
if (m_result_set->size() > limit)
m_result_set->remove(limit, m_result_set->size() - limit);
}
String Result::error_string() const String Result::error_string() const
{ {
VERIFY(is_error()); VERIFY(is_error());

27
Userland/Libraries/LibSQL/Result.h
View file

@ -9,8 +9,6 @@
#include <AK/Error.h> #include <AK/Error.h>
#include <AK/Noncopyable.h> #include <AK/Noncopyable.h>
#include <LibSQL/ResultSet.h>
#include <LibSQL/Tuple.h>
#include <LibSQL/Type.h> #include <LibSQL/Type.h>
namespace SQL { namespace SQL {
@ -75,11 +73,8 @@ enum class SQLErrorCode {
class [[nodiscard]] Result { class [[nodiscard]] Result {
public: public:
ALWAYS_INLINE Result(SQLCommand command, size_t update_count = 0, size_t insert_count = 0, size_t delete_count = 0) ALWAYS_INLINE Result(SQLCommand command)
: m_command(command) : m_command(command)
, m_update_count(update_count)
, m_insert_count(insert_count)
, m_delete_count(delete_count)
{ {
} }
@ -109,19 +104,9 @@ public:
SQLErrorCode error() const { return m_error; } SQLErrorCode error() const { return m_error; }
String error_string() const; String error_string() const;
void insert(Tuple const& row, Tuple const& sort_key);
void limit(size_t offset, size_t limit);
bool has_results() const { return m_result_set.has_value(); }
ResultSet const& results() const { return m_result_set.value(); }
size_t updated() const { return m_update_count; }
size_t inserted() const { return m_insert_count; }
size_t deleted() const { return m_delete_count; }
// These are for compatibility with the TRY() macro in AK. // These are for compatibility with the TRY() macro in AK.
[[nodiscard]] bool is_error() const { return m_error != SQLErrorCode::NoError; } [[nodiscard]] bool is_error() const { return m_error != SQLErrorCode::NoError; }
[[nodiscard]] ResultSet release_value() { return m_result_set.release_value(); } [[nodiscard]] Result release_value() { return move(*this); }
Result release_error() Result release_error()
{ {
VERIFY(is_error()); VERIFY(is_error());
@ -138,11 +123,9 @@ private:
SQLErrorCode m_error { SQLErrorCode::NoError }; SQLErrorCode m_error { SQLErrorCode::NoError };
Optional<String> m_error_message {}; Optional<String> m_error_message {};
Optional<ResultSet> m_result_set {};
size_t m_update_count { 0 };
size_t m_insert_count { 0 };
size_t m_delete_count { 0 };
}; };
template<typename ValueType>
using ResultOr = ErrorOr<ValueType, Result>;
} }

15
Userland/Libraries/LibSQL/ResultSet.cpp
View file

@ -35,4 +35,19 @@ void ResultSet::insert_row(Tuple const& row, Tuple const& sort_key)
insert(ix, ResultRow { row, sort_key }); insert(ix, ResultRow { row, sort_key });
} }
void ResultSet::limit(size_t offset, size_t limit)
{
if (offset > 0) {
if (offset > size()) {
clear();
return;
}
remove(0, offset);
}
if (size() > limit)
remove(limit, size() - limit);
}
} }

12
Userland/Libraries/LibSQL/ResultSet.h
View file

@ -7,6 +7,7 @@
#pragma once #pragma once
#include <AK/Vector.h> #include <AK/Vector.h>
#include <LibSQL/Result.h>
#include <LibSQL/Tuple.h> #include <LibSQL/Tuple.h>
#include <LibSQL/Type.h> #include <LibSQL/Type.h>
@ -19,11 +20,20 @@ struct ResultRow {
class ResultSet : public Vector<ResultRow> { class ResultSet : public Vector<ResultRow> {
public: public:
ResultSet() = default; ALWAYS_INLINE ResultSet(SQLCommand command)
: m_command(command)
{
}
SQLCommand command() const { return m_command; }
void insert_row(Tuple const& row, Tuple const& sort_key); void insert_row(Tuple const& row, Tuple const& sort_key);
void limit(size_t offset, size_t limit);
private: private:
size_t binary_search(Tuple const& sort_key, size_t low, size_t high); size_t binary_search(Tuple const& sort_key, size_t low, size_t high);
SQLCommand m_command { SQLCommand::Unknown };
}; };
} }

51
Userland/Services/SQLServer/SQLStatement.cpp
View file

@ -33,9 +33,9 @@ SQLStatement::SQLStatement(DatabaseConnection& connection, String sql)
s_statements.set(m_statement_id, *this); s_statements.set(m_statement_id, *this);
} }
void SQLStatement::report_error() void SQLStatement::report_error(SQL::Result result)
{ {
dbgln_if(SQLSERVER_DEBUG, "SQLStatement::report_error(statement_id {}, error {}", statement_id(), m_result->error_string()); dbgln_if(SQLSERVER_DEBUG, "SQLStatement::report_error(statement_id {}, error {}", statement_id(), result.error_string());
auto client_connection = ClientConnection::client_connection_for(connection()->client_id()); auto client_connection = ClientConnection::client_connection_for(connection()->client_id());
@ -43,7 +43,7 @@ void SQLStatement::report_error()
remove_from_parent(); remove_from_parent();
if (client_connection) if (client_connection)
client_connection->async_execution_error(statement_id(), (int)m_result->error(), m_result->error_string()); client_connection->async_execution_error(statement_id(), (int)result.error(), result.error_string());
else else
warnln("Cannot return execution error. Client disconnected"); warnln("Cannot return execution error. Client disconnected");
@ -61,17 +61,17 @@ void SQLStatement::execute()
} }
deferred_invoke([this]() mutable { deferred_invoke([this]() mutable {
m_result = parse(); auto parse_result = parse();
if (m_result.has_value()) { if (parse_result.is_error()) {
report_error(); report_error(parse_result.release_error());
return; return;
} }
VERIFY(!connection()->database().is_null()); VERIFY(!connection()->database().is_null());
m_result = m_statement->execute(connection()->database().release_nonnull()); auto execution_result = m_statement->execute(connection()->database().release_nonnull());
if (m_result->is_error()) { if (execution_result.is_error()) {
report_error(); report_error(execution_result.release_error());
return; return;
} }
@ -80,15 +80,20 @@ void SQLStatement::execute()
warnln("Cannot return statement execution results. Client disconnected"); warnln("Cannot return statement execution results. Client disconnected");
return; return;
} }
client_connection->async_execution_success(statement_id(), m_result->has_results(), m_result->updated(), m_result->inserted(), m_result->deleted());
if (m_result->has_results()) { m_result = execution_result.release_value();
if (should_send_result_rows()) {
client_connection->async_execution_success(statement_id(), true, 0, 0, 0);
m_index = 0; m_index = 0;
next(); next();
} else {
client_connection->async_execution_success(statement_id(), false, 0, m_result->size(), 0);
} }
}); });
} }
Optional<SQL::Result> SQLStatement::parse() SQL::ResultOr<void> SQLStatement::parse()
{ {
auto parser = SQL::AST::Parser(SQL::AST::Lexer(m_sql)); auto parser = SQL::AST::Parser(SQL::AST::Lexer(m_sql));
m_statement = parser.next_statement(); m_statement = parser.next_statement();
@ -98,16 +103,32 @@ Optional<SQL::Result> SQLStatement::parse()
return {}; return {};
} }
bool SQLStatement::should_send_result_rows() const
{
VERIFY(m_result.has_value());
if (m_result->is_empty())
return false;
switch (m_result->command()) {
case SQL::SQLCommand::Describe:
case SQL::SQLCommand::Select:
return true;
default:
return false;
}
}
void SQLStatement::next() void SQLStatement::next()
{ {
VERIFY(m_result->has_results()); VERIFY(!m_result->is_empty());
auto client_connection = ClientConnection::client_connection_for(connection()->client_id()); auto client_connection = ClientConnection::client_connection_for(connection()->client_id());
if (!client_connection) { if (!client_connection) {
warnln("Cannot yield next result. Client disconnected"); warnln("Cannot yield next result. Client disconnected");
return; return;
} }
if (m_index < m_result->results().size()) { if (m_index < m_result->size()) {
auto& tuple = m_result->results()[m_index++].row; auto& tuple = m_result->at(m_index++).row;
client_connection->async_next_result(statement_id(), tuple.to_string_vector()); client_connection->async_next_result(statement_id(), tuple.to_string_vector());
deferred_invoke([this]() { deferred_invoke([this]() {
next(); next();

8
Userland/Services/SQLServer/SQLStatement.h
View file

@ -11,6 +11,7 @@
#include <LibCore/Object.h> #include <LibCore/Object.h>
#include <LibSQL/AST/AST.h> #include <LibSQL/AST/AST.h>
#include <LibSQL/Result.h> #include <LibSQL/Result.h>
#include <LibSQL/ResultSet.h>
#include <SQLServer/DatabaseConnection.h> #include <SQLServer/DatabaseConnection.h>
#include <SQLServer/Forward.h> #include <SQLServer/Forward.h>
@ -30,15 +31,16 @@ public:
private: private:
SQLStatement(DatabaseConnection&, String sql); SQLStatement(DatabaseConnection&, String sql);
Optional<SQL::Result> parse(); SQL::ResultOr<void> parse();
bool should_send_result_rows() const;
void next(); void next();
void report_error(); void report_error(SQL::Result);
int m_statement_id; int m_statement_id;
String m_sql; String m_sql;
size_t m_index { 0 }; size_t m_index { 0 };
RefPtr<SQL::AST::Statement> m_statement { nullptr }; RefPtr<SQL::AST::Statement> m_statement { nullptr };
Optional<SQL::Result> m_result {}; Optional<SQL::ResultSet> m_result {};
}; };
} }