Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 15:43:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibDatabase/Database.cpp

168 lines
6.2 KiB
C++
Raw Normal View History

Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
/*
LibDatabase+LibWebView: Extract our SQLite wrapper to its own library It currently lives in LibWebView as it was only used for cookies and local storage, both of which are managed in the UI process. Let's move it to its own library now to allow other processes to use it, without having to depend on LibWebView (and therefore LibWeb).
2025-10-07 14:35:22 -04:00
* Copyright (c) 2022-2025, Tim Flynn <trflynn89@ladybird.org>
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
#include <AK/ByteString.h>
#include <AK/String.h>
#include <AK/Time.h>
#include <LibCore/Directory.h>
LibDatabase+LibWebView: Extract our SQLite wrapper to its own library It currently lives in LibWebView as it was only used for cookies and local storage, both of which are managed in the UI process. Let's move it to its own library now to allow other processes to use it, without having to depend on LibWebView (and therefore LibWeb).
2025-10-07 14:35:22 -04:00
#include <LibDatabase/Database.h>
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
#include <sqlite3.h>
LibDatabase+LibWebView: Extract our SQLite wrapper to its own library It currently lives in LibWebView as it was only used for cookies and local storage, both of which are managed in the UI process. Let's move it to its own library now to allow other processes to use it, without having to depend on LibWebView (and therefore LibWeb).
2025-10-07 14:35:22 -04:00
namespace Database {
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
static constexpr StringView sql_error(int error_code)
{
char const* _sql_error = sqlite3_errstr(error_code);
return { _sql_error, __builtin_strlen(_sql_error) };
}
#define SQL_TRY(expression) \
({ \
/* Ignore -Wshadow to allow nesting the macro. */ \
AK_IGNORE_DIAGNOSTIC("-Wshadow", auto _sql_result = (expression)); \
if (_sql_result != SQLITE_OK) [[unlikely]] \
return Error::from_string_view(sql_error(_sql_result)); \
})
#define SQL_MUST(expression) \
({ \
/* Ignore -Wshadow to allow nesting the macro. */ \
AK_IGNORE_DIAGNOSTIC("-Wshadow", auto _sql_result = (expression)); \
if (_sql_result != SQLITE_OK) [[unlikely]] { \
warnln("\033[31;1mDatabase error\033[0m: {}: {}", sql_error(_sql_result), sqlite3_errmsg(m_database)); \
VERIFY_NOT_REACHED(); \
} \
})
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
LibDatabase: Support all C++ integral types in SQL storage
2025-10-07 15:39:00 -04:00
#define ENUMERATE_SQL_TYPES \
__ENUMERATE_TYPE(String) \
__ENUMERATE_TYPE(UnixDateTime) \
__ENUMERATE_TYPE(i8) \
__ENUMERATE_TYPE(i16) \
__ENUMERATE_TYPE(i32) \
__ENUMERATE_TYPE(long) \
__ENUMERATE_TYPE(long long) \
__ENUMERATE_TYPE(u8) \
__ENUMERATE_TYPE(u16) \
__ENUMERATE_TYPE(u32) \
__ENUMERATE_TYPE(unsigned long) \
__ENUMERATE_TYPE(unsigned long long) \
__ENUMERATE_TYPE(bool)
LibDatabase+LibWebView: Extract our SQLite wrapper to its own library It currently lives in LibWebView as it was only used for cookies and local storage, both of which are managed in the UI process. Let's move it to its own library now to allow other processes to use it, without having to depend on LibWebView (and therefore LibWeb).
2025-10-07 14:35:22 -04:00
ErrorOr<NonnullRefPtr<Database>> Database::create(ByteString const& directory, StringView name)
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
{
LibDatabase+LibWebView: Extract our SQLite wrapper to its own library It currently lives in LibWebView as it was only used for cookies and local storage, both of which are managed in the UI process. Let's move it to its own library now to allow other processes to use it, without having to depend on LibWebView (and therefore LibWeb).
2025-10-07 14:35:22 -04:00
TRY(Core::Directory::create(directory, Core::Directory::CreateDirectories::Yes));
auto database_file = ByteString::formatted("{}/{}.db", directory, name);
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
sqlite3* m_database { nullptr };
SQL_TRY(sqlite3_open(database_file.characters(), &m_database));
return adopt_nonnull_ref_or_enomem(new (nothrow) Database(m_database));
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
}
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
Database::Database(sqlite3* database)
: m_database(database)
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
{
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
VERIFY(m_database);
}
Database::~Database()
{
for (auto* prepared_statement : m_prepared_statements)
sqlite3_finalize(prepared_statement);
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
sqlite3_close(m_database);
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
}
LibDatabase+LibWebView: Extract our SQLite wrapper to its own library It currently lives in LibWebView as it was only used for cookies and local storage, both of which are managed in the UI process. Let's move it to its own library now to allow other processes to use it, without having to depend on LibWebView (and therefore LibWeb).
2025-10-07 14:35:22 -04:00
ErrorOr<StatementID> Database::prepare_statement(StringView statement)
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
{
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
sqlite3_stmt* prepared_statement { nullptr };
SQL_TRY(sqlite3_prepare_v2(m_database, statement.characters_without_null_termination(), static_cast<int>(statement.length()), &prepared_statement, nullptr));
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
auto statement_id = m_prepared_statements.size();
m_prepared_statements.append(prepared_statement);
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
return statement_id;
}
Browser: Prevent moving a Database callback while it is executing All SQL callbacks here were already moving the to-be-executed callback out of its storage before executing it, except for on_next_result(). This makes on_next_result() do the same move to ensure we do not later attempt to move it while the callback is executing.
2023-08-29 07:42:09 -04:00
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
void Database::execute_statement(StatementID statement_id, OnResult on_result)
{
auto* statement = prepared_statement(statement_id);
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
while (true) {
auto result = sqlite3_step(statement);
switch (result) {
case SQLITE_DONE:
SQL_MUST(sqlite3_reset(statement));
return;
case SQLITE_ROW:
if (on_result)
on_result(statement_id);
continue;
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
default:
SQL_MUST(result);
return;
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
}
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
}
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
}
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
template<typename ValueType>
void Database::apply_placeholder(StatementID statement_id, int index, ValueType const& value)
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
{
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
auto* statement = prepared_statement(statement_id);
if constexpr (IsSame<ValueType, String>) {
StringView string { value };
SQL_MUST(sqlite3_bind_text(statement, index, string.characters_without_null_termination(), static_cast<int>(string.length()), SQLITE_TRANSIENT));
} else if constexpr (IsSame<ValueType, UnixDateTime>) {
LibDatabase: Support all C++ integral types in SQL storage
2025-10-07 15:39:00 -04:00
apply_placeholder(statement_id, index, value.offset_to_epoch().to_milliseconds());
} else if constexpr (IsIntegral<ValueType>) {
if constexpr (sizeof(ValueType) <= sizeof(int))
SQL_MUST(sqlite3_bind_int(statement, index, static_cast<int>(value)));
else
SQL_MUST(sqlite3_bind_int64(statement, index, static_cast<sqlite3_int64>(value)));
} else {
static_assert(DependentFalse<ValueType>);
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
}
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
}
LibDatabase: Support all C++ integral types in SQL storage
2025-10-07 15:39:00 -04:00
#define __ENUMERATE_TYPE(type) \
template DATABASE_API void Database::apply_placeholder(StatementID, int, type const&);
ENUMERATE_SQL_TYPES
#undef __ENUMERATE_TYPE
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
template<typename ValueType>
ValueType Database::result_column(StatementID statement_id, int column)
{
auto* statement = prepared_statement(statement_id);
if constexpr (IsSame<ValueType, String>) {
auto const* text = reinterpret_cast<char const*>(sqlite3_column_text(statement, column));
return MUST(String::from_utf8(StringView { text, strlen(text) }));
} else if constexpr (IsSame<ValueType, UnixDateTime>) {
LibDatabase: Support all C++ integral types in SQL storage
2025-10-07 15:39:00 -04:00
auto milliseconds = result_column<sqlite3_int64>(statement_id, column);
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
return UnixDateTime::from_milliseconds_since_epoch(milliseconds);
LibDatabase: Support all C++ integral types in SQL storage
2025-10-07 15:39:00 -04:00
} else if constexpr (IsIntegral<ValueType>) {
if constexpr (sizeof(ValueType) <= sizeof(int))
return static_cast<ValueType>(sqlite3_column_int(statement, column));
else
return static_cast<ValueType>(sqlite3_column_int64(statement, column));
} else {
static_assert(DependentFalse<ValueType>);
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
}
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
}
LibDatabase: Support all C++ integral types in SQL storage
2025-10-07 15:39:00 -04:00
#define __ENUMERATE_TYPE(type) \
template DATABASE_API type Database::result_column(StatementID, int);
ENUMERATE_SQL_TYPES
#undef __ENUMERATE_TYPE
LibWebView: Replace usage of LibSQL with sqlite3 This makes WebView::Database wrap around sqlite3 instead of LibSQL. The effect on outside callers is pretty minimal. The main consequences are: 1. We must ensure the Cookie table exists before preparing any SQL statements involving that table. 2. We can use an INSERT OR REPLACE statement instead of separate INSERT and UPDATE statements.
2024-06-04 16:34:32 -04:00
Browser: Store cookies in a LibSQL database :^) Currently, cookies are ephemeral and only survive for the lifetime of Browser instance. This will make Browser instead store cookies in a SQL database for persisted access.
2022-10-27 12:56:22 -04:00
}
Reference in a new issue Copy permalink