diff --git a/Tests/LibSQL/TestSqlStatementExecution.cpp b/Tests/LibSQL/TestSqlStatementExecution.cpp index caf97a9ec2..ef049b8ae7 100644 --- a/Tests/LibSQL/TestSqlStatementExecution.cpp +++ b/Tests/LibSQL/TestSqlStatementExecution.cpp @@ -216,7 +216,7 @@ TEST_CASE(select_with_column_names) EXPECT(result->error().code == SQL::SQLErrorCode::NoError); EXPECT(result->has_results()); EXPECT_EQ(result->results().size(), 5u); - EXPECT_EQ(result->results()[0].size(), 1u); + EXPECT_EQ(result->results()[0].row.size(), 1u); } TEST_CASE(select_with_nonexisting_column_name) @@ -258,7 +258,7 @@ TEST_CASE(select_with_where) EXPECT(result->has_results()); EXPECT_EQ(result->results().size(), 2u); for (auto& row : result->results()) { - EXPECT(row[1].to_int().value() > 44); + EXPECT(row.row[1].to_int().value() > 44); } } @@ -291,11 +291,11 @@ TEST_CASE(select_cross_join) EXPECT(result->has_results()); EXPECT_EQ(result->results().size(), 25u); for (auto& row : result->results()) { - EXPECT(row.size() == 4); - EXPECT(row[1].to_int().value() >= 42); - EXPECT(row[1].to_int().value() <= 46); - EXPECT(row[3].to_int().value() >= 40); - EXPECT(row[3].to_int().value() <= 48); + EXPECT(row.row.size() == 4); + EXPECT(row.row[1].to_int().value() >= 42); + EXPECT(row.row[1].to_int().value() <= 46); + EXPECT(row.row[3].to_int().value() >= 40); + EXPECT(row.row[3].to_int().value() <= 48); } } @@ -331,10 +331,10 @@ TEST_CASE(select_inner_join) EXPECT(result->has_results()); EXPECT_EQ(result->results().size(), 1u); auto& row = result->results()[0]; - EXPECT_EQ(row.size(), 3u); - EXPECT_EQ(row[0].to_int().value(), 42); - EXPECT_EQ(row[1].to_string(), "Test_1"); - EXPECT_EQ(row[2].to_string(), "Test_12"); + EXPECT_EQ(row.row.size(), 3u); + 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) @@ -410,4 +410,104 @@ TEST_CASE(select_with_like) EXPECT(!result->has_results()); } +TEST_CASE(select_with_order) +{ + ScopeGuard guard([]() { unlink(db_name); }); + auto database = SQL::Database::construct(db_name); + EXPECT(!database->open().is_error()); + create_table(database); + auto result = execute(database, + "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES " + "( 'Test_5', 44 ), " + "( 'Test_2', 42 ), " + "( 'Test_1', 47 ), " + "( 'Test_3', 40 ), " + "( 'Test_4', 41 );"); + EXPECT(result->error().code == SQL::SQLErrorCode::NoError); + 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_EQ(rows.size(), 5u); + EXPECT_EQ(rows[0].row[1].to_int().value(), 40); + EXPECT_EQ(rows[1].row[1].to_int().value(), 41); + 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;"); + EXPECT(result->error().code == SQL::SQLErrorCode::NoError); + 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"); + 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_order_two_columns) +{ + ScopeGuard guard([]() { unlink(db_name); }); + auto database = SQL::Database::construct(db_name); + EXPECT(!database->open().is_error()); + create_table(database); + auto result = execute(database, + "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES " + "( 'Test_5', 44 ), " + "( 'Test_2', 42 ), " + "( 'Test_1', 47 ), " + "( 'Test_2', 40 ), " + "( 'Test_4', 41 );"); + EXPECT(result->error().code == SQL::SQLErrorCode::NoError); + 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_EQ(rows.size(), 5u); + EXPECT_EQ(rows[0].row[0].to_string(), "Test_1"); + EXPECT_EQ(rows[0].row[1].to_int().value(), 47); + EXPECT_EQ(rows[1].row[0].to_string(), "Test_2"); + EXPECT_EQ(rows[1].row[1].to_int().value(), 40); + EXPECT_EQ(rows[2].row[0].to_string(), "Test_2"); + EXPECT_EQ(rows[2].row[1].to_int().value(), 42); + EXPECT_EQ(rows[3].row[0].to_string(), "Test_4"); + 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) +{ + ScopeGuard guard([]() { unlink(db_name); }); + auto database = SQL::Database::construct(db_name); + EXPECT(!database->open().is_error()); + create_table(database); + auto result = execute(database, + "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES " + "( 'Test_5', 44 ), " + "( 'Test_2', 42 ), " + "( 'Test_1', 47 ), " + "( 'Test_3', 40 ), " + "( 'Test_4', 41 );"); + EXPECT(result->error().code == SQL::SQLErrorCode::NoError); + 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_EQ(rows.size(), 5u); + EXPECT_EQ(rows[0].row[0].to_string(), "Test_3"); + EXPECT_EQ(rows[1].row[0].to_string(), "Test_4"); + 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"); +} + } diff --git a/Userland/Libraries/LibSQL/AST/Select.cpp b/Userland/Libraries/LibSQL/AST/Select.cpp index d890f1c7e9..9db06f02ab 100644 --- a/Userland/Libraries/LibSQL/AST/Select.cpp +++ b/Userland/Libraries/LibSQL/AST/Select.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include namespace SQL::AST { @@ -77,6 +78,14 @@ RefPtr Select::execute(ExecutionContext& context) const } } + bool has_ordering { false }; + AK::NonnullRefPtr sort_descriptor = AK::adopt_ref(*new TupleDescriptor); + for (auto& term : m_ordering_term_list) { + sort_descriptor->append(TupleElementDescriptor { .order = term.order() }); + has_ordering = true; + } + Tuple sort_key(sort_descriptor); + for (auto& row : rows) { context.current_row = &row; if (where_clause()) { @@ -93,7 +102,17 @@ RefPtr Select::execute(ExecutionContext& context) const return context.result; tuple.append(value); } - context.result->append(tuple); + + if (has_ordering) { + sort_key.clear(); + for (auto& term : m_ordering_term_list) { + auto value = term.expression()->evaluate(context); + if (context.result->has_error()) + return context.result; + sort_key.append(value); + } + } + context.result->insert(tuple, sort_key); } return context.result; } diff --git a/Userland/Libraries/LibSQL/CMakeLists.txt b/Userland/Libraries/LibSQL/CMakeLists.txt index 395890f602..5bc6b4dc47 100644 --- a/Userland/Libraries/LibSQL/CMakeLists.txt +++ b/Userland/Libraries/LibSQL/CMakeLists.txt @@ -17,6 +17,7 @@ set(SOURCES Index.cpp Key.cpp Meta.cpp + ResultSet.cpp Row.cpp Serializer.cpp SQLClient.cpp diff --git a/Userland/Libraries/LibSQL/ResultSet.cpp b/Userland/Libraries/LibSQL/ResultSet.cpp new file mode 100644 index 0000000000..ee793bfbb2 --- /dev/null +++ b/Userland/Libraries/LibSQL/ResultSet.cpp @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2022, Jan de Visser + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include + +namespace SQL { + +size_t ResultSet::binary_search(Tuple const& sort_key, size_t low, size_t high) +{ + if (high <= low) { + auto compare = sort_key.compare(at(low).sort_key); + return (compare > 0) ? low + 1 : low; + } + + auto mid = (low + high) / 2; + auto compare = sort_key.compare(at(mid).sort_key); + if (compare == 0) + return mid + 1; + + if (compare > 0) + return binary_search(sort_key, mid + 1, high); + return binary_search(sort_key, low, mid); +} + +void ResultSet::insert_row(Tuple const& row, Tuple const& sort_key) +{ + if ((sort_key.size() == 0) || is_empty()) { + empend(row, sort_key); + return; + } + auto ix = binary_search(sort_key, 0, size() - 1); + insert(ix, ResultRow { row, sort_key }); +} + +} diff --git a/Userland/Libraries/LibSQL/ResultSet.h b/Userland/Libraries/LibSQL/ResultSet.h new file mode 100644 index 0000000000..8a9e60399c --- /dev/null +++ b/Userland/Libraries/LibSQL/ResultSet.h @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2022, Jan de Visser + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#pragma once + +#include +#include +#include + +namespace SQL { + +struct ResultRow { + Tuple row; + Tuple sort_key; +}; + +class ResultSet : public Vector { +public: + ResultSet() = default; + void insert_row(Tuple const& row, Tuple const& sort_key); + +private: + size_t binary_search(Tuple const& sort_key, size_t low, size_t high); +}; + +} diff --git a/Userland/Libraries/LibSQL/SQLResult.h b/Userland/Libraries/LibSQL/SQLResult.h index 8072f67b0a..6847da8a62 100644 --- a/Userland/Libraries/LibSQL/SQLResult.h +++ b/Userland/Libraries/LibSQL/SQLResult.h @@ -10,6 +10,7 @@ #include #include #include +#include #include #include @@ -110,10 +111,10 @@ class SQLResult : public Core::Object { C_OBJECT(SQLResult) public: - void append(Tuple const& tuple) + void insert(Tuple const& row, Tuple const& sort_key) { m_has_results = true; - m_result_set.append(tuple); + m_result_set.insert_row(row, sort_key); } SQLCommand command() const { return m_command; } @@ -129,7 +130,7 @@ public: bool has_error() const { return m_error.code != SQLErrorCode::NoError; } SQLError const& error() const { return m_error; } bool has_results() const { return m_has_results; } - Vector const& results() const { return m_result_set; } + ResultSet const& results() const { return m_result_set; } private: SQLResult() = default; @@ -161,7 +162,7 @@ private: int m_insert_count { 0 }; int m_delete_count { 0 }; bool m_has_results { false }; - Vector m_result_set; + ResultSet m_result_set; }; } diff --git a/Userland/Services/SQLServer/SQLStatement.cpp b/Userland/Services/SQLServer/SQLStatement.cpp index 5c62b7a9a7..c556757318 100644 --- a/Userland/Services/SQLServer/SQLStatement.cpp +++ b/Userland/Services/SQLServer/SQLStatement.cpp @@ -104,7 +104,7 @@ void SQLStatement::next() return; } if (m_index < m_result->results().size()) { - auto& tuple = m_result->results()[m_index++]; + auto& tuple = m_result->results()[m_index++].row; client_connection->async_next_result(statement_id(), tuple.to_string_vector()); deferred_invoke([this]() { next();