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