Branch data Line data Source code
1 : : // Copyright (c) 2020-present The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <bitcoin-build-config.h> // IWYU pragma: keep
6 : :
7 : : #include <wallet/sqlite.h>
8 : :
9 : : #include <chainparams.h>
10 : : #include <crypto/common.h>
11 : : #include <logging.h>
12 : : #include <sync.h>
13 : : #include <util/check.h>
14 : : #include <util/fs_helpers.h>
15 : : #include <util/strencodings.h>
16 : : #include <util/translation.h>
17 : : #include <wallet/db.h>
18 : :
19 : : #include <sqlite3.h>
20 : :
21 : : #include <cstdint>
22 : : #include <optional>
23 : : #include <utility>
24 : : #include <vector>
25 : :
26 : : namespace wallet {
27 : : static constexpr int32_t WALLET_SCHEMA_VERSION = 0;
28 : :
29 : 542 : static std::span<const std::byte> SpanFromBlob(sqlite3_stmt* stmt, int col)
30 : : {
31 : 542 : return {reinterpret_cast<const std::byte*>(sqlite3_column_blob(stmt, col)),
32 : 542 : static_cast<size_t>(sqlite3_column_bytes(stmt, col))};
33 : : }
34 : :
35 : 2 : static void ErrorLogCallback(void* arg, int code, const char* msg)
36 : : {
37 : : // From sqlite3_config() documentation for the SQLITE_CONFIG_LOG option:
38 : : // "The void pointer that is the second argument to SQLITE_CONFIG_LOG is passed through as
39 : : // the first parameter to the application-defined logger function whenever that function is
40 : : // invoked."
41 : : // Assert that this is the case:
42 [ - + ]: 2 : assert(arg == nullptr);
43 : 2 : LogWarning("SQLite Error. Code: %d. Message: %s", code, msg);
44 : 2 : }
45 : :
46 : 43305 : static int TraceSqlCallback(unsigned code, void* context, void* param1, void* param2)
47 : : {
48 : 43305 : auto* db = static_cast<SQLiteDatabase*>(context);
49 [ + - ]: 43305 : if (code == SQLITE_TRACE_STMT) {
50 : 43305 : auto* stmt = static_cast<sqlite3_stmt*>(param1);
51 : : // To be conservative and avoid leaking potentially secret information
52 : : // in the log file, only expand statements that query the database, not
53 : : // statements that update the database.
54 [ + + ]: 43305 : char* expanded{sqlite3_stmt_readonly(stmt) ? sqlite3_expanded_sql(stmt) : nullptr};
55 [ + - + + : 86610 : LogTrace(BCLog::WALLETDB, "[%s] SQLite Statement: %s\n", db->Filename(), expanded ? expanded : sqlite3_sql(stmt));
+ - ]
56 [ + + ]: 43305 : if (expanded) sqlite3_free(expanded);
57 : : }
58 : 43305 : return SQLITE_OK;
59 : : }
60 : :
61 : 58453 : static bool BindBlobToStatement(sqlite3_stmt* stmt,
62 : : int index,
63 : : std::span<const std::byte> blob,
64 : : const std::string& description)
65 : : {
66 : : // Pass a pointer to the empty string "" below instead of passing the
67 : : // blob.data() pointer if the blob.data() pointer is null. Passing a null
68 : : // data pointer to bind_blob would cause sqlite to bind the SQL NULL value
69 : : // instead of the empty blob value X'', which would mess up SQL comparisons.
70 [ + + ]: 58453 : int res = sqlite3_bind_blob(stmt, index, blob.data() ? static_cast<const void*>(blob.data()) : "", blob.size(), SQLITE_STATIC);
71 [ - + ]: 58453 : if (res != SQLITE_OK) {
72 : 0 : LogWarning("Unable to bind %s to statement: %s", description, sqlite3_errstr(res));
73 : 0 : sqlite3_clear_bindings(stmt);
74 : 0 : sqlite3_reset(stmt);
75 : 0 : return false;
76 : : }
77 : :
78 : : return true;
79 : : }
80 : :
81 : 28 : static std::optional<int> ReadPragmaInteger(sqlite3* db, const std::string& key, const std::string& description, bilingual_str& error)
82 : : {
83 : 28 : std::string stmt_text = strprintf("PRAGMA %s", key);
84 : 28 : sqlite3_stmt* pragma_read_stmt{nullptr};
85 [ + - ]: 28 : int ret = sqlite3_prepare_v2(db, stmt_text.c_str(), -1, &pragma_read_stmt, nullptr);
86 [ - + ]: 28 : if (ret != SQLITE_OK) {
87 [ # # ]: 0 : sqlite3_finalize(pragma_read_stmt);
88 [ # # # # : 0 : error = Untranslated(strprintf("SQLiteDatabase: Failed to prepare the statement to fetch %s: %s", description, sqlite3_errstr(ret)));
# # ]
89 : 0 : return std::nullopt;
90 : : }
91 [ + - ]: 28 : ret = sqlite3_step(pragma_read_stmt);
92 [ - + ]: 28 : if (ret != SQLITE_ROW) {
93 [ # # ]: 0 : sqlite3_finalize(pragma_read_stmt);
94 [ # # # # : 0 : error = Untranslated(strprintf("SQLiteDatabase: Failed to fetch %s: %s", description, sqlite3_errstr(ret)));
# # ]
95 : 0 : return std::nullopt;
96 : : }
97 [ + - ]: 28 : int result = sqlite3_column_int(pragma_read_stmt, 0);
98 [ + - ]: 28 : sqlite3_finalize(pragma_read_stmt);
99 : 28 : return result;
100 : 28 : }
101 : :
102 : 350 : static void SetPragma(sqlite3* db, const std::string& key, const std::string& value, const std::string& err_msg)
103 : : {
104 : 350 : std::string stmt_text = strprintf("PRAGMA %s = %s", key, value);
105 [ + - ]: 350 : int ret = sqlite3_exec(db, stmt_text.c_str(), nullptr, nullptr, nullptr);
106 [ - + ]: 350 : if (ret != SQLITE_OK) {
107 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: %s: %s\n", err_msg, sqlite3_errstr(ret)));
# # ]
108 : : }
109 : 350 : }
110 : :
111 : : Mutex SQLiteDatabase::g_sqlite_mutex;
112 : : int SQLiteDatabase::g_sqlite_count = 0;
113 : :
114 : 14 : SQLiteDatabase::SQLiteDatabase(const fs::path& dir_path, const fs::path& file_path, const DatabaseOptions& options)
115 : 14 : : SQLiteDatabase(dir_path, file_path, options, /*additional_flags=*/0)
116 : 14 : {}
117 : :
118 : 89 : SQLiteDatabase::SQLiteDatabase(const fs::path& dir_path, const fs::path& file_path, const DatabaseOptions& options, int additional_flags)
119 [ + - - + : 178 : : WalletDatabase(), m_dir_path(dir_path), m_file_path(fs::PathToString(file_path)), m_write_semaphore(1), m_use_unsafe_sync(options.use_unsafe_sync)
+ - ]
120 : : {
121 : 89 : {
122 [ + - ]: 89 : LOCK(g_sqlite_mutex);
123 [ + + ]: 89 : if (++g_sqlite_count == 1) {
124 : : // Setup logging
125 [ + - ]: 63 : int ret = sqlite3_config(SQLITE_CONFIG_LOG, ErrorLogCallback, nullptr);
126 [ - + ]: 63 : if (ret != SQLITE_OK) {
127 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to setup error log: %s\n", sqlite3_errstr(ret)));
# # ]
128 : : }
129 : : // Force serialized threading mode
130 [ + - ]: 63 : ret = sqlite3_config(SQLITE_CONFIG_SERIALIZED);
131 [ - + ]: 63 : if (ret != SQLITE_OK) {
132 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to configure serialized threading mode: %s\n", sqlite3_errstr(ret)));
# # ]
133 : : }
134 : : }
135 [ + - ]: 89 : int ret = sqlite3_initialize(); // This is a no-op if sqlite3 is already initialized
136 [ - + ]: 89 : if (ret != SQLITE_OK) {
137 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to initialize SQLite: %s\n", sqlite3_errstr(ret)));
# # ]
138 : : }
139 : 0 : }
140 : :
141 : 89 : try {
142 [ + - ]: 89 : Open(additional_flags);
143 [ - - ]: 0 : } catch (const std::runtime_error&) {
144 : : // If open fails, cleanup this object and rethrow the exception
145 : 0 : Cleanup();
146 : 0 : throw;
147 : 0 : }
148 : 89 : }
149 : :
150 : 19542 : void SQLiteBatch::SetupSQLStatements()
151 : : {
152 : 19542 : const std::vector<std::pair<sqlite3_stmt**, const char*>> statements{
153 : 19542 : {&m_read_stmt, "SELECT value FROM main WHERE key = ?"},
154 : 19542 : {&m_insert_stmt, "INSERT INTO main VALUES(?, ?)"},
155 : 19542 : {&m_overwrite_stmt, "INSERT or REPLACE into main values(?, ?)"},
156 : 19542 : {&m_delete_stmt, "DELETE FROM main WHERE key = ?"},
157 : 19542 : {&m_delete_prefix_stmt, "DELETE FROM main WHERE instr(key, ?) = 1"},
158 : 19542 : };
159 : :
160 [ + - + + ]: 117252 : for (const auto& [stmt_prepared, stmt_text] : statements) {
161 [ + - ]: 97710 : if (*stmt_prepared == nullptr) {
162 [ + - ]: 97710 : int res = sqlite3_prepare_v2(m_database.m_db, stmt_text, -1, stmt_prepared, nullptr);
163 [ - + ]: 97710 : if (res != SQLITE_OK) {
164 : 0 : throw std::runtime_error(strprintf(
165 [ # # # # : 0 : "SQLiteDatabase: Failed to setup SQL statements: %s\n", sqlite3_errstr(res)));
# # ]
166 : : }
167 : : }
168 : : }
169 : 19542 : }
170 : :
171 : 103 : SQLiteDatabase::~SQLiteDatabase()
172 : : {
173 : 89 : Cleanup();
174 : 103 : }
175 : :
176 : 89 : void SQLiteDatabase::Cleanup() noexcept
177 : : {
178 : 89 : AssertLockNotHeld(g_sqlite_mutex);
179 : :
180 : 89 : Close();
181 : :
182 : 89 : LOCK(g_sqlite_mutex);
183 [ + + ]: 89 : if (--g_sqlite_count == 0) {
184 : 63 : int ret = sqlite3_shutdown();
185 [ - + ]: 63 : if (ret != SQLITE_OK) {
186 : 0 : LogWarning("SQLiteDatabase: Failed to shutdown SQLite: %s", sqlite3_errstr(ret));
187 : : }
188 : : }
189 : 89 : }
190 : :
191 : 14 : bool SQLiteDatabase::Verify(bilingual_str& error)
192 : : {
193 [ - + ]: 14 : assert(m_db);
194 : :
195 : : // Check the application ID matches our network magic
196 [ + - + - ]: 28 : auto read_result = ReadPragmaInteger(m_db, "application_id", "the application id", error);
197 [ + - ]: 14 : if (!read_result.has_value()) return false;
198 : 14 : uint32_t app_id = static_cast<uint32_t>(read_result.value());
199 [ - + ]: 14 : uint32_t net_magic = ReadBE32(Params().MessageStart().data());
200 [ - + ]: 14 : if (app_id != net_magic) {
201 : 0 : error = strprintf(_("SQLiteDatabase: Unexpected application id. Expected %u, got %u"), net_magic, app_id);
202 : 0 : return false;
203 : : }
204 : :
205 : : // Check our schema version
206 [ + - + - ]: 28 : read_result = ReadPragmaInteger(m_db, "user_version", "sqlite wallet schema version", error);
207 [ + - ]: 14 : if (!read_result.has_value()) return false;
208 [ - + ]: 14 : int32_t user_ver = read_result.value();
209 [ - + ]: 14 : if (user_ver != WALLET_SCHEMA_VERSION) {
210 : 0 : error = strprintf(_("SQLiteDatabase: Unknown sqlite wallet schema version %d. Only version %d is supported"), user_ver, WALLET_SCHEMA_VERSION);
211 : 0 : return false;
212 : : }
213 : :
214 : 14 : sqlite3_stmt* stmt{nullptr};
215 : 14 : int ret = sqlite3_prepare_v2(m_db, "PRAGMA integrity_check", -1, &stmt, nullptr);
216 [ - + ]: 14 : if (ret != SQLITE_OK) {
217 : 0 : sqlite3_finalize(stmt);
218 : 0 : error = strprintf(_("SQLiteDatabase: Failed to prepare statement to verify database: %s"), sqlite3_errstr(ret));
219 : 0 : return false;
220 : : }
221 : 28 : while (true) {
222 : 28 : ret = sqlite3_step(stmt);
223 [ + + ]: 28 : if (ret == SQLITE_DONE) {
224 : : break;
225 : : }
226 [ - + ]: 14 : if (ret != SQLITE_ROW) {
227 : 0 : error = strprintf(_("SQLiteDatabase: Failed to execute statement to verify database: %s"), sqlite3_errstr(ret));
228 : 0 : break;
229 : : }
230 : 14 : const char* msg = (const char*)sqlite3_column_text(stmt, 0);
231 [ - + ]: 14 : if (!msg) {
232 : 0 : error = strprintf(_("SQLiteDatabase: Failed to read database verification error: %s"), sqlite3_errstr(ret));
233 : 0 : break;
234 : : }
235 : 14 : std::string str_msg(msg);
236 [ + - ]: 14 : if (str_msg == "ok") {
237 : 14 : continue;
238 : : }
239 [ # # ]: 0 : if (error.empty()) {
240 [ # # # # : 0 : error = _("Failed to verify database") + Untranslated("\n");
# # ]
241 : : }
242 [ # # # # : 0 : error += Untranslated(strprintf("%s\n", str_msg));
# # ]
243 : 14 : }
244 : 14 : sqlite3_finalize(stmt);
245 : 14 : return error.empty();
246 : : }
247 : :
248 : 1 : void SQLiteDatabase::Open()
249 : : {
250 : 1 : Open(/*additional_flags*/0);
251 : 1 : }
252 : :
253 : 90 : void SQLiteDatabase::Open(int additional_flags)
254 : : {
255 : 90 : int flags = SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | additional_flags;
256 : :
257 [ + - ]: 90 : if (m_db == nullptr) {
258 [ + + ]: 90 : if (!(flags & SQLITE_OPEN_MEMORY)) {
259 : 15 : TryCreateDirectories(m_dir_path);
260 [ - + ]: 15 : if (!IsDirWritable(m_dir_path)) {
261 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to open database in directory '%s': directory is not writable", fs::PathToString(m_dir_path)));
# # ]
262 : : }
263 : : }
264 : :
265 : 90 : int ret = sqlite3_open_v2(m_file_path.c_str(), &m_db, flags, nullptr);
266 [ - + ]: 90 : if (ret != SQLITE_OK) {
267 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to open database: %s\n", sqlite3_errstr(ret)));
# # ]
268 : : }
269 : 90 : ret = sqlite3_extended_result_codes(m_db, 1);
270 [ - + ]: 90 : if (ret != SQLITE_OK) {
271 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to enable extended result codes: %s\n", sqlite3_errstr(ret)));
# # ]
272 : : }
273 : : // Trace SQL statements if tracing is enabled with -debug=walletdb -loglevel=walletdb:trace
274 [ + - ]: 90 : if (LogAcceptCategory(BCLog::WALLETDB, BCLog::Level::Trace)) {
275 : 90 : ret = sqlite3_trace_v2(m_db, SQLITE_TRACE_STMT, TraceSqlCallback, this);
276 [ - + ]: 90 : if (ret != SQLITE_OK) {
277 [ # # ]: 0 : LogWarning("Failed to enable SQL tracing for %s", Filename());
278 : : }
279 : : }
280 : : }
281 : :
282 [ - + ]: 90 : if (sqlite3_db_readonly(m_db, "main") != 0) {
283 [ # # ]: 0 : throw std::runtime_error("SQLiteDatabase: Database opened in readonly mode but read-write permissions are needed");
284 : : }
285 : :
286 : : // Acquire an exclusive lock on the database
287 : : // First change the locking mode to exclusive
288 [ + - + - : 180 : SetPragma(m_db, "locking_mode", "exclusive", "Unable to change database locking mode to exclusive");
+ - ]
289 : : // Now begin a transaction to acquire the exclusive lock. This lock won't be released until we close because of the exclusive locking mode.
290 : 90 : int ret = sqlite3_exec(m_db, "BEGIN EXCLUSIVE TRANSACTION", nullptr, nullptr, nullptr);
291 [ - + ]: 90 : if (ret != SQLITE_OK) {
292 [ # # ]: 0 : throw std::runtime_error("SQLiteDatabase: Unable to obtain an exclusive lock on the database, is it being used by another instance of " CLIENT_NAME "?\n");
293 : : }
294 : 90 : ret = sqlite3_exec(m_db, "COMMIT", nullptr, nullptr, nullptr);
295 [ - + ]: 90 : if (ret != SQLITE_OK) {
296 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Unable to end exclusive lock transaction: %s\n", sqlite3_errstr(ret)));
# # ]
297 : : }
298 : :
299 : : // Enable fullfsync for the platforms that use it
300 [ + - + - : 180 : SetPragma(m_db, "fullfsync", "true", "Failed to enable fullfsync");
+ - ]
301 : :
302 [ - + ]: 90 : if (m_use_unsafe_sync) {
303 : : // Use normal synchronous mode for the journal
304 : 0 : LogWarning("SQLite is configured to not wait for data to be flushed to disk. Data loss and corruption may occur.");
305 [ # # # # : 0 : SetPragma(m_db, "synchronous", "OFF", "Failed to set synchronous mode to OFF");
# # ]
306 : : }
307 : :
308 : : // Make the table for our key-value pairs
309 : : // First check that the main table exists
310 : 90 : sqlite3_stmt* check_main_stmt{nullptr};
311 : 90 : ret = sqlite3_prepare_v2(m_db, "SELECT name FROM sqlite_master WHERE type='table' AND name='main'", -1, &check_main_stmt, nullptr);
312 [ - + ]: 90 : if (ret != SQLITE_OK) {
313 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to prepare statement to check table existence: %s\n", sqlite3_errstr(ret)));
# # ]
314 : : }
315 : 90 : ret = sqlite3_step(check_main_stmt);
316 [ - + ]: 90 : if (sqlite3_finalize(check_main_stmt) != SQLITE_OK) {
317 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to finalize statement checking table existence: %s\n", sqlite3_errstr(ret)));
# # ]
318 : : }
319 : 90 : bool table_exists;
320 [ + + ]: 90 : if (ret == SQLITE_DONE) {
321 : : table_exists = false;
322 [ - + ]: 5 : } else if (ret == SQLITE_ROW) {
323 : : table_exists = true;
324 : : } else {
325 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to execute statement to check table existence: %s\n", sqlite3_errstr(ret)));
# # ]
326 : : }
327 : :
328 : : // Do the db setup things because the table doesn't exist only when we are creating a new wallet
329 : 85 : if (!table_exists) {
330 : 85 : ret = sqlite3_exec(m_db, "CREATE TABLE main(key BLOB PRIMARY KEY NOT NULL, value BLOB NOT NULL)", nullptr, nullptr, nullptr);
331 [ - + ]: 85 : if (ret != SQLITE_OK) {
332 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to create new database: %s\n", sqlite3_errstr(ret)));
# # ]
333 : : }
334 : :
335 : : // Set the application id
336 : 85 : uint32_t app_id = ReadBE32(Params().MessageStart().data());
337 [ + - + - : 170 : SetPragma(m_db, "application_id", strprintf("%d", static_cast<int32_t>(app_id)),
+ - ]
338 : 85 : "Failed to set the application id");
339 : :
340 : : // Set the user version
341 [ + - + - : 170 : SetPragma(m_db, "user_version", strprintf("%d", WALLET_SCHEMA_VERSION),
+ - ]
342 : 170 : "Failed to set the wallet schema version");
343 : : }
344 : 90 : }
345 : :
346 : 0 : bool SQLiteDatabase::Rewrite()
347 : : {
348 : : // Rewrite the database using the VACUUM command: https://sqlite.org/lang_vacuum.html
349 : 0 : int ret = sqlite3_exec(m_db, "VACUUM", nullptr, nullptr, nullptr);
350 : 0 : return ret == SQLITE_OK;
351 : : }
352 : :
353 : 0 : bool SQLiteDatabase::Backup(const std::string& dest) const
354 : : {
355 : 0 : sqlite3* db_copy;
356 : 0 : int res = sqlite3_open(dest.c_str(), &db_copy);
357 [ # # ]: 0 : if (res != SQLITE_OK) {
358 : 0 : sqlite3_close(db_copy);
359 : 0 : return false;
360 : : }
361 : 0 : sqlite3_backup* backup = sqlite3_backup_init(db_copy, "main", m_db, "main");
362 [ # # ]: 0 : if (!backup) {
363 : 0 : LogWarning("Unable to begin sqlite backup: %s", sqlite3_errmsg(m_db));
364 : 0 : sqlite3_close(db_copy);
365 : 0 : return false;
366 : : }
367 : : // Specifying -1 will copy all of the pages
368 : 0 : res = sqlite3_backup_step(backup, -1);
369 [ # # ]: 0 : if (res != SQLITE_DONE) {
370 : 0 : LogWarning("Unable to continue sqlite backup: %s", sqlite3_errstr(res));
371 : 0 : sqlite3_backup_finish(backup);
372 : 0 : sqlite3_close(db_copy);
373 : 0 : return false;
374 : : }
375 : 0 : res = sqlite3_backup_finish(backup);
376 : 0 : sqlite3_close(db_copy);
377 : 0 : return res == SQLITE_OK;
378 : : }
379 : :
380 : 94 : void SQLiteDatabase::Close()
381 : : {
382 : 94 : int res = sqlite3_close(m_db);
383 [ - + ]: 94 : if (res != SQLITE_OK) {
384 [ # # # # : 0 : throw std::runtime_error(strprintf("SQLiteDatabase: Failed to close database: %s\n", sqlite3_errstr(res)));
# # ]
385 : : }
386 : 94 : m_db = nullptr;
387 : 94 : }
388 : :
389 : 13303 : bool SQLiteDatabase::HasActiveTxn()
390 : : {
391 : : // 'sqlite3_get_autocommit' returns true by default, and false if a transaction has begun and not been committed or rolled back.
392 [ + - + + ]: 13303 : return m_db && sqlite3_get_autocommit(m_db) == 0;
393 : : }
394 : :
395 : 13301 : int SQliteExecHandler::Exec(SQLiteDatabase& database, const std::string& statement)
396 : : {
397 : 13301 : return sqlite3_exec(database.m_db, statement.data(), nullptr, nullptr, nullptr);
398 : : }
399 : :
400 : 109 : std::unique_ptr<DatabaseBatch> SQLiteDatabase::MakeBatch()
401 : : {
402 : : // We ignore flush_on_close because we don't do manual flushing for SQLite
403 : 109 : return std::make_unique<SQLiteBatch>(*this);
404 : : }
405 : :
406 : 19542 : SQLiteBatch::SQLiteBatch(SQLiteDatabase& database)
407 [ + - ]: 19542 : : m_database(database)
408 : : {
409 : : // Make sure we have a db handle
410 [ - + ]: 19542 : assert(m_database.m_db);
411 : :
412 [ + - ]: 19542 : SetupSQLStatements();
413 : 19542 : }
414 : :
415 : 19542 : void SQLiteBatch::Close()
416 : : {
417 : 19542 : bool force_conn_refresh = false;
418 : :
419 : : // If we began a transaction, and it wasn't committed, abort the transaction in progress
420 [ + + ]: 19542 : if (m_txn) {
421 [ - + ]: 1 : if (TxnAbort()) {
422 : 0 : LogWarning("SQLiteBatch: Batch closed unexpectedly without the transaction being explicitly committed or aborted");
423 : : } else {
424 : : // If transaction cannot be aborted, it means there is a bug or there has been data corruption. Try to recover in this case
425 : : // by closing and reopening the database. Closing the database should also ensure that any changes made since the transaction
426 : : // was opened will be rolled back and future transactions can succeed without committing old data.
427 : 1 : force_conn_refresh = true;
428 : 1 : LogWarning("SQLiteBatch: Batch closed and failed to abort transaction, resetting db connection..");
429 : : }
430 : : }
431 : :
432 : : // Free all of the prepared statements
433 : 19542 : const std::vector<std::pair<sqlite3_stmt**, const char*>> statements{
434 : 19542 : {&m_read_stmt, "read"},
435 : 19542 : {&m_insert_stmt, "insert"},
436 : 19542 : {&m_overwrite_stmt, "overwrite"},
437 : 19542 : {&m_delete_stmt, "delete"},
438 : 19542 : {&m_delete_prefix_stmt, "delete prefix"},
439 : 19542 : };
440 : :
441 [ + - + + ]: 117252 : for (const auto& [stmt_prepared, stmt_description] : statements) {
442 [ + - ]: 97710 : int res = sqlite3_finalize(*stmt_prepared);
443 [ - + ]: 97710 : if (res != SQLITE_OK) {
444 [ # # # # ]: 0 : LogWarning("SQLiteBatch: Batch closed but could not finalize %s statement: %s",
445 : : stmt_description, sqlite3_errstr(res));
446 : : }
447 : 97710 : *stmt_prepared = nullptr;
448 : : }
449 : :
450 [ + + ]: 19542 : if (force_conn_refresh) {
451 [ + - ]: 1 : m_database.Close();
452 : 1 : try {
453 [ + - ]: 1 : m_database.Open();
454 : : // If TxnAbort failed and we refreshed the connection, the semaphore was not released, so release it here to avoid deadlocks on future writes.
455 : 1 : m_database.m_write_semaphore.release();
456 [ - - ]: 0 : } catch (const std::runtime_error&) {
457 : : // If open fails, cleanup this object and rethrow the exception
458 [ - - ]: 0 : m_database.Close();
459 : 0 : throw;
460 : 0 : }
461 : : }
462 : 19542 : }
463 : :
464 : 38 : bool SQLiteBatch::ReadKey(DataStream&& key, DataStream& value)
465 : : {
466 [ + - ]: 38 : if (!m_database.m_db) return false;
467 [ - + ]: 38 : assert(m_read_stmt);
468 : :
469 : : // Bind: leftmost parameter in statement is index 1
470 [ + - + - ]: 76 : if (!BindBlobToStatement(m_read_stmt, 1, key, "key")) return false;
471 : 38 : int res = sqlite3_step(m_read_stmt);
472 [ + + ]: 38 : if (res != SQLITE_ROW) {
473 [ - + ]: 8 : if (res != SQLITE_DONE) {
474 : : // SQLITE_DONE means "not found", don't log an error in that case.
475 : 0 : LogWarning("Unable to execute read statement: %s", sqlite3_errstr(res));
476 : : }
477 : 8 : sqlite3_clear_bindings(m_read_stmt);
478 : 8 : sqlite3_reset(m_read_stmt);
479 : 8 : return false;
480 : : }
481 : : // Leftmost column in result is index 0
482 [ - + ]: 30 : value.clear();
483 : 30 : value.write(SpanFromBlob(m_read_stmt, 0));
484 : :
485 : 30 : sqlite3_clear_bindings(m_read_stmt);
486 : 30 : sqlite3_reset(m_read_stmt);
487 : 30 : return true;
488 : : }
489 : :
490 : 28984 : bool SQLiteBatch::WriteKey(DataStream&& key, DataStream&& value, bool overwrite)
491 : : {
492 [ + - ]: 28984 : if (!m_database.m_db) return false;
493 [ + - - + ]: 28984 : assert(m_insert_stmt && m_overwrite_stmt);
494 : :
495 : 28984 : sqlite3_stmt* stmt;
496 [ + + ]: 28984 : if (overwrite) {
497 : : stmt = m_overwrite_stmt;
498 : : } else {
499 : 281 : stmt = m_insert_stmt;
500 : : }
501 : :
502 : : // Bind: leftmost parameter in statement is index 1
503 : : // Insert index 1 is key, 2 is value
504 [ + - + - ]: 57968 : if (!BindBlobToStatement(stmt, 1, key, "key")) return false;
505 [ + - + - ]: 57968 : if (!BindBlobToStatement(stmt, 2, value, "value")) return false;
506 : :
507 : : // Acquire semaphore if not previously acquired when creating a transaction.
508 [ + + ]: 28984 : if (!m_txn) m_database.m_write_semaphore.acquire();
509 : :
510 : : // Execute
511 : 28984 : int res = sqlite3_step(stmt);
512 : 28984 : sqlite3_clear_bindings(stmt);
513 : 28984 : sqlite3_reset(stmt);
514 [ + + ]: 28984 : if (res != SQLITE_DONE) {
515 : 2 : LogWarning("Unable to execute write statement: %s", sqlite3_errstr(res));
516 : : }
517 : :
518 [ + + ]: 28984 : if (!m_txn) m_database.m_write_semaphore.release();
519 : :
520 : 28984 : return res == SQLITE_DONE;
521 : : }
522 : :
523 : 6 : bool SQLiteBatch::ExecStatement(sqlite3_stmt* stmt, std::span<const std::byte> blob)
524 : : {
525 [ + - ]: 6 : if (!m_database.m_db) return false;
526 [ - + ]: 6 : assert(stmt);
527 : :
528 : : // Bind: leftmost parameter in statement is index 1
529 [ + - + - ]: 6 : if (!BindBlobToStatement(stmt, 1, blob, "key")) return false;
530 : :
531 : : // Acquire semaphore if not previously acquired when creating a transaction.
532 [ + + ]: 6 : if (!m_txn) m_database.m_write_semaphore.acquire();
533 : :
534 : : // Execute
535 : 6 : int res = sqlite3_step(stmt);
536 : 6 : sqlite3_clear_bindings(stmt);
537 : 6 : sqlite3_reset(stmt);
538 [ - + ]: 6 : if (res != SQLITE_DONE) {
539 : 0 : LogWarning("Unable to execute exec statement: %s", sqlite3_errstr(res));
540 : : }
541 : :
542 [ + + ]: 6 : if (!m_txn) m_database.m_write_semaphore.release();
543 : :
544 : 6 : return res == SQLITE_DONE;
545 : : }
546 : :
547 : 3 : bool SQLiteBatch::EraseKey(DataStream&& key)
548 : : {
549 [ - + ]: 3 : return ExecStatement(m_delete_stmt, key);
550 : : }
551 : :
552 : 3 : bool SQLiteBatch::ErasePrefix(std::span<const std::byte> prefix)
553 : : {
554 : 3 : return ExecStatement(m_delete_prefix_stmt, prefix);
555 : : }
556 : :
557 : 11 : bool SQLiteBatch::HasKey(DataStream&& key)
558 : : {
559 [ + - ]: 11 : if (!m_database.m_db) return false;
560 [ - + ]: 11 : assert(m_read_stmt);
561 : :
562 : : // Bind: leftmost parameter in statement is index 1
563 [ + - + - ]: 22 : if (!BindBlobToStatement(m_read_stmt, 1, key, "key")) return false;
564 : 11 : int res = sqlite3_step(m_read_stmt);
565 : 11 : sqlite3_clear_bindings(m_read_stmt);
566 : 11 : sqlite3_reset(m_read_stmt);
567 : 11 : return res == SQLITE_ROW;
568 : : }
569 : :
570 : 474 : DatabaseCursor::Status SQLiteCursor::Next(DataStream& key, DataStream& value)
571 : : {
572 : 474 : int res = sqlite3_step(m_cursor_stmt);
573 [ + + ]: 474 : if (res == SQLITE_DONE) {
574 : : return Status::DONE;
575 : : }
576 [ - + ]: 256 : if (res != SQLITE_ROW) {
577 : 0 : LogWarning("Unable to execute cursor step: %s", sqlite3_errstr(res));
578 : 0 : return Status::FAIL;
579 : : }
580 : :
581 [ - + ]: 256 : key.clear();
582 [ - + ]: 256 : value.clear();
583 : :
584 : : // Leftmost column in result is index 0
585 : 256 : key.write(SpanFromBlob(m_cursor_stmt, 0));
586 : 256 : value.write(SpanFromBlob(m_cursor_stmt, 1));
587 : 256 : return Status::MORE;
588 : : }
589 : :
590 : 436 : SQLiteCursor::~SQLiteCursor()
591 : : {
592 : 218 : sqlite3_clear_bindings(m_cursor_stmt);
593 : 218 : sqlite3_reset(m_cursor_stmt);
594 : 218 : int res = sqlite3_finalize(m_cursor_stmt);
595 [ - + ]: 218 : if (res != SQLITE_OK) {
596 : 0 : LogWarning("Cursor closed but could not finalize cursor statement: %s",
597 : : sqlite3_errstr(res));
598 : : }
599 : 436 : }
600 : :
601 : 0 : std::unique_ptr<DatabaseCursor> SQLiteBatch::GetNewCursor()
602 : : {
603 [ # # ]: 0 : if (!m_database.m_db) return nullptr;
604 : 0 : auto cursor = std::make_unique<SQLiteCursor>();
605 : :
606 : 0 : const char* stmt_text = "SELECT key, value FROM main";
607 [ # # ]: 0 : int res = sqlite3_prepare_v2(m_database.m_db, stmt_text, -1, &cursor->m_cursor_stmt, nullptr);
608 [ # # ]: 0 : if (res != SQLITE_OK) {
609 : 0 : throw std::runtime_error(strprintf(
610 [ # # # # : 0 : "%s: Failed to setup cursor SQL statement: %s\n", __func__, sqlite3_errstr(res)));
# # ]
611 : : }
612 : :
613 : 0 : return cursor;
614 : 0 : }
615 : :
616 : 218 : std::unique_ptr<DatabaseCursor> SQLiteBatch::GetNewPrefixCursor(std::span<const std::byte> prefix)
617 : : {
618 [ - + ]: 218 : if (!m_database.m_db) return nullptr;
619 : :
620 : : // To get just the records we want, the SQL statement does a comparison of the binary data
621 : : // where the data must be greater than or equal to the prefix, and less than
622 : : // the prefix incremented by one (when interpreted as an integer)
623 : 218 : std::vector<std::byte> start_range(prefix.begin(), prefix.end());
624 [ + - ]: 218 : std::vector<std::byte> end_range(prefix.begin(), prefix.end());
625 : 218 : auto it = end_range.rbegin();
626 [ + + ]: 230 : for (; it != end_range.rend(); ++it) {
627 [ + + ]: 224 : if (*it == std::byte(std::numeric_limits<unsigned char>::max())) {
628 : 12 : *it = std::byte(0);
629 : 12 : continue;
630 : : }
631 : 212 : *it = std::byte(std::to_integer<unsigned char>(*it) + 1);
632 : 212 : break;
633 : : }
634 [ + + ]: 218 : if (it == end_range.rend()) {
635 : : // If the prefix is all 0xff bytes, clear end_range as we won't need it
636 [ + + ]: 6 : end_range.clear();
637 : : }
638 : :
639 [ + - ]: 218 : auto cursor = std::make_unique<SQLiteCursor>(start_range, end_range);
640 [ - + ]: 218 : if (!cursor) return nullptr;
641 : :
642 [ + + ]: 218 : const char* stmt_text = end_range.empty() ? "SELECT key, value FROM main WHERE key >= ?" :
643 : 212 : "SELECT key, value FROM main WHERE key >= ? AND key < ?";
644 [ + - ]: 218 : int res = sqlite3_prepare_v2(m_database.m_db, stmt_text, -1, &cursor->m_cursor_stmt, nullptr);
645 [ - + ]: 218 : if (res != SQLITE_OK) {
646 : 0 : throw std::runtime_error(strprintf(
647 [ # # # # : 0 : "SQLiteDatabase: Failed to setup cursor SQL statement: %s\n", sqlite3_errstr(res)));
# # ]
648 : : }
649 : :
650 [ + - - + : 218 : if (!BindBlobToStatement(cursor->m_cursor_stmt, 1, cursor->m_prefix_range_start, "prefix_start")) return nullptr;
+ - - + ]
651 [ + + ]: 218 : if (!end_range.empty()) {
652 [ + - - + : 212 : if (!BindBlobToStatement(cursor->m_cursor_stmt, 2, cursor->m_prefix_range_end, "prefix_end")) return nullptr;
+ - - + ]
653 : : }
654 : :
655 : 218 : return cursor;
656 : 218 : }
657 : :
658 : 6651 : bool SQLiteBatch::TxnBegin()
659 : : {
660 [ + - + - ]: 6651 : if (!m_database.m_db || m_txn) return false;
661 : 6651 : m_database.m_write_semaphore.acquire();
662 [ - + ]: 6651 : Assert(!m_database.HasActiveTxn());
663 [ - + + - ]: 6651 : int res = Assert(m_exec_handler)->Exec(m_database, "BEGIN TRANSACTION");
664 [ - + ]: 6651 : if (res != SQLITE_OK) {
665 : 0 : LogWarning("SQLiteBatch: Failed to begin the transaction");
666 : 0 : m_database.m_write_semaphore.release();
667 : : } else {
668 : 6651 : m_txn = true;
669 : : }
670 : 6651 : return res == SQLITE_OK;
671 : : }
672 : :
673 : 6651 : bool SQLiteBatch::TxnCommit()
674 : : {
675 [ + - + + ]: 6651 : if (!m_database.m_db || !m_txn) return false;
676 [ - + ]: 6650 : Assert(m_database.HasActiveTxn());
677 [ - + + - ]: 6650 : int res = Assert(m_exec_handler)->Exec(m_database, "COMMIT TRANSACTION");
678 [ - + ]: 6650 : if (res != SQLITE_OK) {
679 : 0 : LogWarning("SQLiteBatch: Failed to commit the transaction");
680 : : } else {
681 : 6650 : m_txn = false;
682 : 6650 : m_database.m_write_semaphore.release();
683 : : }
684 : 6650 : return res == SQLITE_OK;
685 : : }
686 : :
687 : 2 : bool SQLiteBatch::TxnAbort()
688 : : {
689 [ + - + + ]: 2 : if (!m_database.m_db || !m_txn) return false;
690 [ - + ]: 1 : Assert(m_database.HasActiveTxn());
691 [ - + + - ]: 1 : int res = Assert(m_exec_handler)->Exec(m_database, "ROLLBACK TRANSACTION");
692 [ + - ]: 1 : if (res != SQLITE_OK) {
693 : 1 : LogWarning("SQLiteBatch: Failed to abort the transaction");
694 : : } else {
695 : 0 : m_txn = false;
696 : 0 : m_database.m_write_semaphore.release();
697 : : }
698 : 1 : return res == SQLITE_OK;
699 : : }
700 : :
701 : 14 : std::unique_ptr<SQLiteDatabase> MakeSQLiteDatabase(const fs::path& path, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error)
702 : : {
703 : 14 : try {
704 [ + - ]: 14 : fs::path data_file = SQLiteDataFile(path);
705 [ + - + - ]: 14 : auto db = std::make_unique<SQLiteDatabase>(data_file.parent_path(), data_file, options);
706 [ + - + - : 14 : if (options.verify && !db->Verify(error)) {
- + ]
707 : 0 : status = DatabaseStatus::FAILED_VERIFY;
708 : 0 : return nullptr;
709 : : }
710 : 14 : status = DatabaseStatus::SUCCESS;
711 : 14 : return db;
712 [ - - ]: 28 : } catch (const std::runtime_error& e) {
713 : 0 : status = DatabaseStatus::FAILED_LOAD;
714 [ - - - - ]: 0 : error = Untranslated(e.what());
715 : 0 : return nullptr;
716 : 0 : }
717 : : }
718 : :
719 : 5 : std::string SQLiteDatabaseVersion()
720 : : {
721 : 5 : return std::string(sqlite3_libversion());
722 : : }
723 : : } // namespace wallet
|
