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