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