Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-04 07:10:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWebView/Database.cpp

153 lines
5.8 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
/*
LibCore+LibSQL+LibWebView: Move launching a singleton process to LibCore This just moves the code to launch a single process such as SQLServer to LibCore. This will allow re-using this feature for other processes, and will allow moving the launching of SQLServer to Ladybird.
2024-04-17 11:17:46 -04:00
* Copyright (c) 2022-2024, Tim Flynn <trflynn89@serenityos.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>
#include <LibCore/StandardPaths.h>
Ladybird+LibWebView: Move CookieJar, Database, and History to LibWebView These classes are used as-is in all chromes. Move them to LibWebView so that non-Serenity chromes don't have to awkwardly reach into its headers and sources.
2023-08-31 07:07:07 -04:00
#include <LibWebView/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>
Ladybird+LibWebView: Move CookieJar, Database, and History to LibWebView These classes are used as-is in all chromes. Move them to LibWebView so that non-Serenity chromes don't have to awkwardly reach into its headers and sources.
2023-08-31 07:07:07 -04:00
namespace WebView {
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
ErrorOr<NonnullRefPtr<Database>> Database::create()
{
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
// FIXME: Move this to a generic "Ladybird data directory" helper.
LibCore: Clarify StandardPaths::data_directory() name Let's make it clear that this is for user data.
2024-09-30 10:36:11 +01:00
auto database_path = ByteString::formatted("{}/Ladybird", Core::StandardPaths::user_data_directory());
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
TRY(Core::Directory::create(database_path, Core::Directory::CreateDirectories::Yes));
auto database_file = ByteString::formatted("{}/Ladybird.db", database_path);
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
}
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
ErrorOr<Database::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>) {
SQL_MUST(sqlite3_bind_int64(statement, index, value.offset_to_epoch().to_milliseconds()));
} else if constexpr (IsSame<ValueType, int>) {
SQL_MUST(sqlite3_bind_int(statement, index, value));
} else if constexpr (IsSame<ValueType, bool>) {
SQL_MUST(sqlite3_bind_int(statement, index, static_cast<int>(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
template void Database::apply_placeholder(StatementID, int, String const&);
template void Database::apply_placeholder(StatementID, int, UnixDateTime const&);
template void Database::apply_placeholder(StatementID, int, int const&);
template void Database::apply_placeholder(StatementID, int, bool const&);
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>) {
auto milliseconds = sqlite3_column_int64(statement, column);
return UnixDateTime::from_milliseconds_since_epoch(milliseconds);
} else if constexpr (IsSame<ValueType, int>) {
return sqlite3_column_int(statement, column);
} else if constexpr (IsSame<ValueType, bool>) {
return static_cast<bool>(sqlite3_column_int(statement, column));
}
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
}
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 String Database::result_column(StatementID, int);
template UnixDateTime Database::result_column(StatementID, int);
template int Database::result_column(StatementID, int);
template bool Database::result_column(StatementID, int);
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