mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-09-30 00:31:14 +00:00
001949d77a
The handling of filesystem level errors was basically non-existing or consisting of `VERIFY_NOT_REACHED` assertions. Addressed this by * Adding `open` methods to `Heap` and `Database` which return errors. * Changing the interface of methods of these classes and clients downstream to propagate these errors. The constructors of `Heap` and `Database` don't open the underlying filesystem file anymore. The SQL statement handlers return an `SQLErrorCode::InternalError` error code if an error comes back from the lower levels. Note that some of these errors are things like duplicate index entry errors that should be caught before the SQL layer attempts to actually update the database. Added tests to catch attempts to open weird or non-existent files as databases. Finally, in between me writing this patch and submitting the PR the AK::Result<Foo, Bar> template got deprecated in favour of ErrorOr<Foo>. This resulted in more busywork.
338 lines
6.8 KiB
C++
338 lines
6.8 KiB
C++
/*
|
|
* Copyright (c) 2021, Jan de Visser <jan@de-visser.net>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <LibSQL/HashIndex.h>
|
|
#include <LibSQL/Heap.h>
|
|
#include <LibSQL/Meta.h>
|
|
#include <LibSQL/Tuple.h>
|
|
#include <LibSQL/Value.h>
|
|
#include <LibTest/TestCase.h>
|
|
#include <unistd.h>
|
|
|
|
constexpr static int keys[] = {
|
|
39,
|
|
87,
|
|
77,
|
|
42,
|
|
98,
|
|
40,
|
|
53,
|
|
8,
|
|
37,
|
|
12,
|
|
90,
|
|
72,
|
|
73,
|
|
11,
|
|
88,
|
|
22,
|
|
10,
|
|
82,
|
|
25,
|
|
61,
|
|
97,
|
|
18,
|
|
60,
|
|
68,
|
|
21,
|
|
3,
|
|
58,
|
|
29,
|
|
13,
|
|
17,
|
|
89,
|
|
81,
|
|
16,
|
|
64,
|
|
5,
|
|
41,
|
|
36,
|
|
91,
|
|
38,
|
|
24,
|
|
32,
|
|
50,
|
|
34,
|
|
94,
|
|
49,
|
|
47,
|
|
1,
|
|
6,
|
|
44,
|
|
76,
|
|
};
|
|
constexpr static u32 pointers[] = {
|
|
92,
|
|
4,
|
|
50,
|
|
47,
|
|
68,
|
|
73,
|
|
24,
|
|
28,
|
|
50,
|
|
93,
|
|
60,
|
|
36,
|
|
92,
|
|
72,
|
|
53,
|
|
26,
|
|
91,
|
|
84,
|
|
25,
|
|
43,
|
|
88,
|
|
12,
|
|
62,
|
|
35,
|
|
96,
|
|
27,
|
|
96,
|
|
27,
|
|
99,
|
|
30,
|
|
21,
|
|
89,
|
|
54,
|
|
60,
|
|
37,
|
|
68,
|
|
35,
|
|
55,
|
|
80,
|
|
2,
|
|
33,
|
|
26,
|
|
93,
|
|
70,
|
|
45,
|
|
44,
|
|
3,
|
|
66,
|
|
75,
|
|
4,
|
|
};
|
|
|
|
NonnullRefPtr<SQL::HashIndex> setup_hash_index(SQL::Serializer&);
|
|
void insert_and_get_to_and_from_hash_index(int);
|
|
void insert_into_and_scan_hash_index(int);
|
|
|
|
NonnullRefPtr<SQL::HashIndex> setup_hash_index(SQL::Serializer& serializer)
|
|
{
|
|
NonnullRefPtr<SQL::TupleDescriptor> tuple_descriptor = adopt_ref(*new SQL::TupleDescriptor);
|
|
tuple_descriptor->append({ "schema", "table", "key_value", SQL::SQLType::Integer, SQL::Order::Ascending });
|
|
tuple_descriptor->append({ "schema", "table", "text_value", SQL::SQLType::Text, SQL::Order::Ascending });
|
|
|
|
auto directory_pointer = serializer.heap().user_value(0);
|
|
if (!directory_pointer) {
|
|
directory_pointer = serializer.heap().new_record_pointer();
|
|
serializer.heap().set_user_value(0, directory_pointer);
|
|
}
|
|
auto hash_index = SQL::HashIndex::construct(serializer, tuple_descriptor, directory_pointer);
|
|
return hash_index;
|
|
}
|
|
|
|
void insert_and_get_to_and_from_hash_index(int num_keys)
|
|
{
|
|
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
|
|
{
|
|
auto heap = SQL::Heap::construct("/tmp/test.db");
|
|
EXPECT(!heap->open().is_error());
|
|
SQL::Serializer serializer(heap);
|
|
auto hash_index = setup_hash_index(serializer);
|
|
|
|
for (auto ix = 0; ix < num_keys; ix++) {
|
|
SQL::Key k(hash_index->descriptor());
|
|
k[0] = keys[ix];
|
|
k[1] = String::formatted("The key value is {} and the pointer is {}", keys[ix], pointers[ix]);
|
|
k.set_pointer(pointers[ix]);
|
|
hash_index->insert(k);
|
|
}
|
|
#ifdef LIST_HASH_INDEX
|
|
hash_index->list_hash();
|
|
#endif
|
|
}
|
|
|
|
{
|
|
auto heap = SQL::Heap::construct("/tmp/test.db");
|
|
EXPECT(!heap->open().is_error());
|
|
SQL::Serializer serializer(heap);
|
|
auto hash_index = setup_hash_index(serializer);
|
|
|
|
for (auto ix = 0; ix < num_keys; ix++) {
|
|
SQL::Key k(hash_index->descriptor());
|
|
k[0] = keys[ix];
|
|
k[1] = String::formatted("The key value is {} and the pointer is {}", keys[ix], pointers[ix]);
|
|
auto pointer_opt = hash_index->get(k);
|
|
VERIFY(pointer_opt.has_value());
|
|
EXPECT_EQ(pointer_opt.value(), pointers[ix]);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE(hash_index_one_key)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(1);
|
|
}
|
|
|
|
TEST_CASE(hash_index_four_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(4);
|
|
}
|
|
|
|
TEST_CASE(hash_index_five_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(5);
|
|
}
|
|
|
|
TEST_CASE(hash_index_10_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(10);
|
|
}
|
|
|
|
TEST_CASE(hash_index_13_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(13);
|
|
}
|
|
|
|
TEST_CASE(hash_index_20_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(20);
|
|
}
|
|
|
|
TEST_CASE(hash_index_25_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(25);
|
|
}
|
|
|
|
TEST_CASE(hash_index_30_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(30);
|
|
}
|
|
|
|
TEST_CASE(hash_index_35_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(35);
|
|
}
|
|
|
|
TEST_CASE(hash_index_40_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(40);
|
|
}
|
|
|
|
TEST_CASE(hash_index_45_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(45);
|
|
}
|
|
|
|
TEST_CASE(hash_index_50_keys)
|
|
{
|
|
insert_and_get_to_and_from_hash_index(50);
|
|
}
|
|
|
|
void insert_into_and_scan_hash_index(int num_keys)
|
|
{
|
|
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
|
|
{
|
|
auto heap = SQL::Heap::construct("/tmp/test.db");
|
|
EXPECT(!heap->open().is_error());
|
|
SQL::Serializer serializer(heap);
|
|
auto hash_index = setup_hash_index(serializer);
|
|
|
|
for (auto ix = 0; ix < num_keys; ix++) {
|
|
SQL::Key k(hash_index->descriptor());
|
|
k[0] = keys[ix];
|
|
k[1] = String::formatted("The key value is {} and the pointer is {}", keys[ix], pointers[ix]);
|
|
k.set_pointer(pointers[ix]);
|
|
hash_index->insert(k);
|
|
}
|
|
#ifdef LIST_HASH_INDEX
|
|
hash_index->list_hash();
|
|
#endif
|
|
}
|
|
|
|
{
|
|
auto heap = SQL::Heap::construct("/tmp/test.db");
|
|
EXPECT(!heap->open().is_error());
|
|
SQL::Serializer serializer(heap);
|
|
auto hash_index = setup_hash_index(serializer);
|
|
Vector<bool> found;
|
|
for (auto ix = 0; ix < num_keys; ix++) {
|
|
found.append(false);
|
|
}
|
|
|
|
int count = 0;
|
|
for (auto iter = hash_index->begin(); !iter.is_end(); iter++, count++) {
|
|
auto key = (*iter);
|
|
auto key_value = (int)key[0];
|
|
for (auto ix = 0; ix < num_keys; ix++) {
|
|
if (keys[ix] == key_value) {
|
|
EXPECT_EQ(key.pointer(), pointers[ix]);
|
|
if (found[ix])
|
|
FAIL(String::formatted("Key {}, index {} already found previously", key_value, ix));
|
|
found[ix] = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef LIST_HASH_INDEX
|
|
hash_index->list_hash();
|
|
#endif
|
|
EXPECT_EQ(count, num_keys);
|
|
for (auto ix = 0; ix < num_keys; ix++) {
|
|
if (!found[ix])
|
|
FAIL(String::formatted("Key {}, index {} not found", keys[ix], ix));
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE(hash_index_scan_one_key)
|
|
{
|
|
insert_into_and_scan_hash_index(1);
|
|
}
|
|
|
|
TEST_CASE(hash_index_scan_four_keys)
|
|
{
|
|
insert_into_and_scan_hash_index(4);
|
|
}
|
|
|
|
TEST_CASE(hash_index_scan_five_keys)
|
|
{
|
|
insert_into_and_scan_hash_index(5);
|
|
}
|
|
|
|
TEST_CASE(hash_index_scan_10_keys)
|
|
{
|
|
insert_into_and_scan_hash_index(10);
|
|
}
|
|
|
|
TEST_CASE(hash_index_scan_15_keys)
|
|
{
|
|
insert_into_and_scan_hash_index(15);
|
|
}
|
|
|
|
TEST_CASE(hash_index_scan_20_keys)
|
|
{
|
|
insert_into_and_scan_hash_index(20);
|
|
}
|
|
|
|
TEST_CASE(hash_index_scan_30_keys)
|
|
{
|
|
insert_into_and_scan_hash_index(30);
|
|
}
|
|
|
|
TEST_CASE(hash_index_scan_40_keys)
|
|
{
|
|
insert_into_and_scan_hash_index(40);
|
|
}
|
|
|
|
TEST_CASE(hash_index_scan_50_keys)
|
|
{
|
|
insert_into_and_scan_hash_index(50);
|
|
}
|