mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 08:18:11 +00:00
LibSQL+SQLServer: Return the new Result class from statement executions
We can now TRY anything that returns a SQL::Result or an AK::Error.
This commit is contained in:
Timothy Flynn
Linus Groh
parent
d9055de7ea
commit
6620f19979
11 changed files with 337 additions and 337 deletions
|
|
@ -19,7 +19,7 @@ namespace {
|
|||
|
||||
constexpr const char* db_name = "/tmp/test.db";
|
||||
|
||||
RefPtr<SQL::SQLResult> execute(NonnullRefPtr<SQL::Database> database, String const& sql)
|
||||
SQL::Result execute(NonnullRefPtr<SQL::Database> database, String const& sql)
|
||||
{
|
||||
auto parser = SQL::AST::Parser(SQL::AST::Lexer(sql));
|
||||
auto statement = parser.next_statement();
|
||||
|
|
@ -27,35 +27,35 @@ RefPtr<SQL::SQLResult> execute(NonnullRefPtr<SQL::Database> database, String con
|
|||
if (parser.has_errors())
|
||||
outln("{}", parser.errors()[0].to_string());
|
||||
auto result = statement->execute(move(database));
|
||||
if (result->error().code != SQL::SQLErrorCode::NoError)
|
||||
outln("{}", result->error().to_string());
|
||||
if (result.is_error())
|
||||
outln("{}", result.error_string());
|
||||
return result;
|
||||
}
|
||||
|
||||
void create_schema(NonnullRefPtr<SQL::Database> database)
|
||||
{
|
||||
auto result = execute(database, "CREATE SCHEMA TestSchema;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
}
|
||||
|
||||
void create_table(NonnullRefPtr<SQL::Database> database)
|
||||
{
|
||||
create_schema(database);
|
||||
auto result = execute(database, "CREATE TABLE TestSchema.TestTable ( TextColumn text, IntColumn integer );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
}
|
||||
|
||||
void create_two_tables(NonnullRefPtr<SQL::Database> database)
|
||||
{
|
||||
create_schema(database);
|
||||
auto result = execute(database, "CREATE TABLE TestSchema.TestTable1 ( TextColumn1 text, IntColumn integer );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
result = execute(database, "CREATE TABLE TestSchema.TestTable2 ( TextColumn2 text, IntColumn integer );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
}
|
||||
|
||||
TEST_CASE(create_schema)
|
||||
|
|
@ -87,8 +87,8 @@ TEST_CASE(insert_into_table)
|
|||
EXPECT(!database->open().is_error());
|
||||
create_table(database);
|
||||
auto result = execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test', 42 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
|
||||
auto table_or_error = database->get_table("TESTSCHEMA", "TESTTABLE");
|
||||
EXPECT(!table_or_error.is_error());
|
||||
|
|
@ -112,8 +112,8 @@ TEST_CASE(insert_into_table_wrong_data_types)
|
|||
EXPECT(!database->open().is_error());
|
||||
create_table(database);
|
||||
auto result = execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES (43, 'Test_2');");
|
||||
EXPECT(result->inserted() == 0);
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::InvalidValueType);
|
||||
EXPECT(result.inserted() == 0);
|
||||
EXPECT(result.error() == SQL::SQLErrorCode::InvalidValueType);
|
||||
}
|
||||
|
||||
TEST_CASE(insert_into_table_multiple_tuples_wrong_data_types)
|
||||
|
|
@ -123,8 +123,8 @@ TEST_CASE(insert_into_table_multiple_tuples_wrong_data_types)
|
|||
EXPECT(!database->open().is_error());
|
||||
create_table(database);
|
||||
auto result = execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ('Test_1', 42), (43, 'Test_2');");
|
||||
EXPECT(result->inserted() == 0);
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::InvalidValueType);
|
||||
EXPECT(result.inserted() == 0);
|
||||
EXPECT(result.error() == SQL::SQLErrorCode::InvalidValueType);
|
||||
}
|
||||
|
||||
TEST_CASE(insert_wrong_number_of_values)
|
||||
|
|
@ -134,8 +134,8 @@ TEST_CASE(insert_wrong_number_of_values)
|
|||
EXPECT(!database->open().is_error());
|
||||
create_table(database);
|
||||
auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ( 42 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::InvalidNumberOfValues);
|
||||
EXPECT(result->inserted() == 0);
|
||||
EXPECT(result.error() == SQL::SQLErrorCode::InvalidNumberOfValues);
|
||||
EXPECT(result.inserted() == 0);
|
||||
}
|
||||
|
||||
TEST_CASE(insert_identifier_as_value)
|
||||
|
|
@ -145,8 +145,8 @@ TEST_CASE(insert_identifier_as_value)
|
|||
EXPECT(!database->open().is_error());
|
||||
create_table(database);
|
||||
auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ( identifier, 42 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::SyntaxError);
|
||||
EXPECT(result->inserted() == 0);
|
||||
EXPECT(result.error() == SQL::SQLErrorCode::SyntaxError);
|
||||
EXPECT(result.inserted() == 0);
|
||||
}
|
||||
|
||||
TEST_CASE(insert_quoted_identifier_as_value)
|
||||
|
|
@ -156,8 +156,8 @@ TEST_CASE(insert_quoted_identifier_as_value)
|
|||
EXPECT(!database->open().is_error());
|
||||
create_table(database);
|
||||
auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ( \"QuotedIdentifier\", 42 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::SyntaxError);
|
||||
EXPECT(result->inserted() == 0);
|
||||
EXPECT(result.error() == SQL::SQLErrorCode::SyntaxError);
|
||||
EXPECT(result.inserted() == 0);
|
||||
}
|
||||
|
||||
TEST_CASE(insert_without_column_names)
|
||||
|
|
@ -167,8 +167,8 @@ TEST_CASE(insert_without_column_names)
|
|||
EXPECT(!database->open().is_error());
|
||||
create_table(database);
|
||||
auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ('Test_1', 42), ('Test_2', 43);");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 2);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 2);
|
||||
|
||||
auto table_or_error = database->get_table("TESTSCHEMA", "TESTTABLE");
|
||||
EXPECT(!table_or_error.is_error());
|
||||
|
|
@ -190,12 +190,12 @@ TEST_CASE(select_from_table)
|
|||
"( 'Test_3', 44 ), "
|
||||
"( 'Test_4', 45 ), "
|
||||
"( 'Test_5', 46 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
result = execute(database, "SELECT * FROM TestSchema.TestTable;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 5u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 5u);
|
||||
}
|
||||
|
||||
TEST_CASE(select_with_column_names)
|
||||
|
|
@ -211,13 +211,13 @@ TEST_CASE(select_with_column_names)
|
|||
"( 'Test_3', 44 ), "
|
||||
"( 'Test_4', 45 ), "
|
||||
"( 'Test_5', 46 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 5u);
|
||||
EXPECT_EQ(result->results()[0].row.size(), 1u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 5u);
|
||||
EXPECT_EQ(result.results()[0].row.size(), 1u);
|
||||
}
|
||||
|
||||
TEST_CASE(select_with_nonexisting_column_name)
|
||||
|
|
@ -233,10 +233,10 @@ TEST_CASE(select_with_nonexisting_column_name)
|
|||
"( 'Test_3', 44 ), "
|
||||
"( 'Test_4', 45 ), "
|
||||
"( 'Test_5', 46 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
result = execute(database, "SELECT Bogus FROM TestSchema.TestTable;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::ColumnDoesNotExist);
|
||||
EXPECT(result.error() == SQL::SQLErrorCode::ColumnDoesNotExist);
|
||||
}
|
||||
|
||||
TEST_CASE(select_with_where)
|
||||
|
|
@ -252,13 +252,13 @@ TEST_CASE(select_with_where)
|
|||
"( 'Test_3', 44 ), "
|
||||
"( 'Test_4', 45 ), "
|
||||
"( 'Test_5', 46 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable WHERE IntColumn > 44;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 2u);
|
||||
for (auto& row : result->results()) {
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 2u);
|
||||
for (auto& row : result.results()) {
|
||||
EXPECT(row.row[1].to_int().value() > 44);
|
||||
}
|
||||
}
|
||||
|
|
@ -276,8 +276,8 @@ TEST_CASE(select_cross_join)
|
|||
"( 'Test_3', 44 ), "
|
||||
"( 'Test_4', 45 ), "
|
||||
"( 'Test_5', 46 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
result = execute(database,
|
||||
"INSERT INTO TestSchema.TestTable2 ( TextColumn2, IntColumn ) VALUES "
|
||||
"( 'Test_10', 40 ), "
|
||||
|
|
@ -285,13 +285,13 @@ TEST_CASE(select_cross_join)
|
|||
"( 'Test_12', 42 ), "
|
||||
"( 'Test_13', 47 ), "
|
||||
"( 'Test_14', 48 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
result = execute(database, "SELECT * FROM TestSchema.TestTable1, TestSchema.TestTable2;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 25u);
|
||||
for (auto& row : result->results()) {
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 25u);
|
||||
for (auto& row : result.results()) {
|
||||
EXPECT(row.row.size() == 4);
|
||||
EXPECT(row.row[1].to_int().value() >= 42);
|
||||
EXPECT(row.row[1].to_int().value() <= 46);
|
||||
|
|
@ -313,8 +313,8 @@ TEST_CASE(select_inner_join)
|
|||
"( 'Test_3', 44 ), "
|
||||
"( 'Test_4', 45 ), "
|
||||
"( 'Test_5', 46 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
result = execute(database,
|
||||
"INSERT INTO TestSchema.TestTable2 ( TextColumn2, IntColumn ) VALUES "
|
||||
"( 'Test_10', 40 ), "
|
||||
|
|
@ -322,16 +322,16 @@ TEST_CASE(select_inner_join)
|
|||
"( 'Test_12', 42 ), "
|
||||
"( 'Test_13', 47 ), "
|
||||
"( 'Test_14', 48 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
result = execute(database,
|
||||
"SELECT TestTable1.IntColumn, TextColumn1, TextColumn2 "
|
||||
"FROM TestSchema.TestTable1, TestSchema.TestTable2 "
|
||||
"WHERE TestTable1.IntColumn = TestTable2.IntColumn;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 1u);
|
||||
auto& row = result->results()[0];
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 1u);
|
||||
auto& row = result.results()[0];
|
||||
EXPECT_EQ(row.row.size(), 3u);
|
||||
EXPECT_EQ(row.row[0].to_int().value(), 42);
|
||||
EXPECT_EQ(row.row[1].to_string(), "Test_1");
|
||||
|
|
@ -352,63 +352,63 @@ TEST_CASE(select_with_like)
|
|||
"( 'Test+4', 45 ), "
|
||||
"( 'Test+5', 46 ), "
|
||||
"( 'Another+Test_6', 47 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 6);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 6);
|
||||
|
||||
// Simple match
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE 'Test+1';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 1u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 1u);
|
||||
|
||||
// Use % to match most rows
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE 'T%';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 5u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 5u);
|
||||
|
||||
// Same as above but invert the match
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn NOT LIKE 'T%';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 1u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 1u);
|
||||
|
||||
// Use _ and % to match all rows
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%e_t%';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 6u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 6u);
|
||||
|
||||
// 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.
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%Test^_%' ESCAPE '^';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 1u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 1u);
|
||||
|
||||
// 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.
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%Test__%' ESCAPE '_';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 1u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 1u);
|
||||
|
||||
// (Unnecessarily) escaping a character that happens to be a Regex
|
||||
// metacharacter should have no effect.
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE 'Test:+_' ESCAPE ':';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 5u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 5u);
|
||||
|
||||
// Make sure we error out if the ESCAPE is empty
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn LIKE '%' ESCAPE '';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::SyntaxError);
|
||||
EXPECT(!result->has_results());
|
||||
EXPECT(result.error() == SQL::SQLErrorCode::SyntaxError);
|
||||
EXPECT(!result.has_results());
|
||||
|
||||
// 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';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::SyntaxError);
|
||||
EXPECT(!result->has_results());
|
||||
EXPECT(result.error() == SQL::SQLErrorCode::SyntaxError);
|
||||
EXPECT(!result.has_results());
|
||||
}
|
||||
|
||||
TEST_CASE(select_with_order)
|
||||
|
|
@ -424,13 +424,13 @@ TEST_CASE(select_with_order)
|
|||
"( 'Test_1', 47 ), "
|
||||
"( 'Test_3', 40 ), "
|
||||
"( 'Test_4', 41 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
|
||||
result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
auto rows = result->results();
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
auto rows = result.results();
|
||||
EXPECT_EQ(rows.size(), 5u);
|
||||
EXPECT_EQ(rows[0].row[1].to_int().value(), 40);
|
||||
EXPECT_EQ(rows[1].row[1].to_int().value(), 41);
|
||||
|
|
@ -439,9 +439,9 @@ TEST_CASE(select_with_order)
|
|||
EXPECT_EQ(rows[4].row[1].to_int().value(), 47);
|
||||
|
||||
result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY TextColumn;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
rows = result->results();
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
rows = result.results();
|
||||
EXPECT_EQ(rows.size(), 5u);
|
||||
EXPECT_EQ(rows[0].row[0].to_string(), "Test_1");
|
||||
EXPECT_EQ(rows[1].row[0].to_string(), "Test_2");
|
||||
|
|
@ -464,34 +464,34 @@ TEST_CASE(select_with_regexp)
|
|||
"( 'Test[4]', 45 ), "
|
||||
"( 'Test+5', 46 ), "
|
||||
"( 'Another-Test_6', 47 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 6);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 6);
|
||||
|
||||
// Simple match
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP 'Test\\+1';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 1u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 1u);
|
||||
|
||||
// Match all
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP '.*';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 6u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 6u);
|
||||
|
||||
// Match with wildcards
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP '^Test.+';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 4u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 4u);
|
||||
|
||||
// Match with case insensitive basic Latin and case sensitive Swedish ö
|
||||
// FIXME: If LibRegex is changed to support case insensitive matches of Unicode characters
|
||||
// This test should be updated and changed to match 'PRÖV'.
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP 'PRöV.*';");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 1u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 1u);
|
||||
}
|
||||
|
||||
TEST_CASE(handle_regexp_errors)
|
||||
|
|
@ -503,13 +503,13 @@ TEST_CASE(handle_regexp_errors)
|
|||
auto result = execute(database,
|
||||
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
|
||||
"( 'Test', 0 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
|
||||
// Malformed regex, unmatched square bracket
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable WHERE TextColumn REGEXP 'Test\\+[0-9.*';");
|
||||
EXPECT(result->error().code != SQL::SQLErrorCode::NoError);
|
||||
EXPECT(!result->has_results());
|
||||
EXPECT(result.is_error());
|
||||
EXPECT(!result.has_results());
|
||||
}
|
||||
|
||||
TEST_CASE(select_with_order_two_columns)
|
||||
|
|
@ -525,13 +525,13 @@ TEST_CASE(select_with_order_two_columns)
|
|||
"( 'Test_1', 47 ), "
|
||||
"( 'Test_2', 40 ), "
|
||||
"( 'Test_4', 41 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
|
||||
result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY TextColumn, IntColumn;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
auto rows = result->results();
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
auto rows = result.results();
|
||||
EXPECT_EQ(rows.size(), 5u);
|
||||
EXPECT_EQ(rows[0].row[0].to_string(), "Test_1");
|
||||
EXPECT_EQ(rows[0].row[1].to_int().value(), 47);
|
||||
|
|
@ -558,13 +558,13 @@ TEST_CASE(select_with_order_by_column_not_in_result)
|
|||
"( 'Test_1', 47 ), "
|
||||
"( 'Test_3', 40 ), "
|
||||
"( 'Test_4', 41 );");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 5);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 5);
|
||||
|
||||
result = execute(database, "SELECT TextColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
auto rows = result->results();
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
auto rows = result.results();
|
||||
EXPECT_EQ(rows.size(), 5u);
|
||||
EXPECT_EQ(rows[0].row[0].to_string(), "Test_3");
|
||||
EXPECT_EQ(rows[1].row[0].to_string(), "Test_4");
|
||||
|
|
@ -582,13 +582,13 @@ TEST_CASE(select_with_limit)
|
|||
for (auto count = 0; count < 100; count++) {
|
||||
auto result = execute(database,
|
||||
String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count));
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
}
|
||||
auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 10;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
auto rows = result->results();
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
auto rows = result.results();
|
||||
EXPECT_EQ(rows.size(), 10u);
|
||||
}
|
||||
|
||||
|
|
@ -601,13 +601,13 @@ TEST_CASE(select_with_limit_and_offset)
|
|||
for (auto count = 0; count < 100; count++) {
|
||||
auto result = execute(database,
|
||||
String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count));
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
}
|
||||
auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 10 OFFSET 10;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
auto rows = result->results();
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
auto rows = result.results();
|
||||
EXPECT_EQ(rows.size(), 10u);
|
||||
}
|
||||
|
||||
|
|
@ -620,13 +620,13 @@ TEST_CASE(select_with_order_limit_and_offset)
|
|||
for (auto count = 0; count < 100; count++) {
|
||||
auto result = execute(database,
|
||||
String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count));
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
}
|
||||
auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable ORDER BY IntColumn LIMIT 10 OFFSET 10;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
auto rows = result->results();
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
auto rows = result.results();
|
||||
EXPECT_EQ(rows.size(), 10u);
|
||||
EXPECT_EQ(rows[0].row[1].to_int().value(), 10);
|
||||
EXPECT_EQ(rows[1].row[1].to_int().value(), 11);
|
||||
|
|
@ -649,13 +649,13 @@ TEST_CASE(select_with_limit_out_of_bounds)
|
|||
for (auto count = 0; count < 100; count++) {
|
||||
auto result = execute(database,
|
||||
String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count));
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
}
|
||||
auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 500;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
auto rows = result->results();
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
auto rows = result.results();
|
||||
EXPECT_EQ(rows.size(), 100u);
|
||||
}
|
||||
|
||||
|
|
@ -668,13 +668,13 @@ TEST_CASE(select_with_offset_out_of_bounds)
|
|||
for (auto count = 0; count < 100; count++) {
|
||||
auto result = execute(database,
|
||||
String::formatted("INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test_{}', {} );", count, count));
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->inserted() == 1);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.inserted() == 1);
|
||||
}
|
||||
auto result = execute(database, "SELECT TextColumn, IntColumn FROM TestSchema.TestTable LIMIT 10 OFFSET 200;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
auto rows = result->results();
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
auto rows = result.results();
|
||||
EXPECT_EQ(rows.size(), 0u);
|
||||
}
|
||||
|
||||
|
|
@ -685,11 +685,11 @@ TEST_CASE(describe_table)
|
|||
EXPECT(!database->open().is_error());
|
||||
create_table(database);
|
||||
auto result = execute(database, "DESCRIBE TABLE TestSchema.TestTable;");
|
||||
EXPECT(result->error().code == SQL::SQLErrorCode::NoError);
|
||||
EXPECT(result->has_results());
|
||||
EXPECT_EQ(result->results().size(), 2u);
|
||||
EXPECT(!result.is_error());
|
||||
EXPECT(result.has_results());
|
||||
EXPECT_EQ(result.results().size(), 2u);
|
||||
|
||||
auto rows = result->results();
|
||||
auto rows = result.results();
|
||||
auto& row1 = rows[0];
|
||||
EXPECT_EQ(row1.row[0].to_string(), "TEXTCOLUMN");
|
||||
EXPECT_EQ(row1.row[1].to_string(), "text");
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue