{

if(lhs.size() != rhs.size())

return false;

return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), [](unsigned char a, unsigned char b) {

return std::tolower(a) == std::tolower(b);

});

{

auto it = map.find(key);

if(it != map.end())

return it;

return std::find_if(map.begin(), map.end(), [&key](const auto& entry) {

return equalsIgnoreCase(entry.first, key);

});

{

if(isTextOnly(literal))

return sqlb::escapeString(literal);

else

return QString("X'%1'").arg(QString(literal.toHex()));

{

if(sizeA == sizeB)

return memcmp(sA, sB, static_cast<size_t>(sizeA));

return sizeA - sizeB;

{

const QString string1 = QString::fromRawData(reinterpret_cast<const QChar*>(str1), static_cast<int>(static_cast<size_t>(size1) / sizeof(QChar)));

const QString string2 = QString::fromRawData(reinterpret_cast<const QChar*>(str2), static_cast<int>(static_cast<size_t>(size2) / sizeof(QChar)));

return QString::compare(string1, string2, Qt::CaseSensitive);

{

const QString string1 = QString::fromRawData(reinterpret_cast<const QChar*>(str1), static_cast<int>(static_cast<size_t>(size1) / sizeof(QChar)));

const QString string2 = QString::fromRawData(reinterpret_cast<const QChar*>(str2), static_cast<int>(static_cast<size_t>(size2) / sizeof(QChar)));

return QString::compare(string1, string2, Qt::CaseInsensitive);

{

QByteArray output;

for(int i=0;i<num_arguments;i++)

output += QByteArray::number(sqlite3_value_bytes(arguments[i])) + ":" + reinterpret_cast<const char*>(sqlite3_value_text(arguments[i]));

char* output_str = new char[static_cast<size_t>(output.size()) + 1];

std::strcpy(output_str, output);

sqlite3_result_text(ctx, output_str, output.size(), [](void* ptr) {

char* cptr = static_cast<char*>(ptr);

delete cptr;

});

_db(nullptr),

db_used(false),

isEncrypted(false),

isReadOnly(false),

disableStructureUpdateChecks(false)

{

// Register error log callback. This needs to be done before SQLite is first used

Callback<void(void*, int, const char*)>::func = std::bind(&DBBrowserDB::errorLogCallback, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);

void (*log_callback)(void*, int, const char*) = static_cast<decltype(log_callback)>(Callback<void(void*, int, const char*)>::callback);

sqlite3_config(SQLITE_CONFIG_LOG, log_callback, nullptr);

// Enable URI filenames

sqlite3_config(SQLITE_CONFIG_URI, 1);

{

QString name(sCollationName);

// Don't request built-in collations. SQLite requests these collations even though they are built into

// the library. Since we have no need for overriding them, we just silently ignore these requests.

if(name.compare("BINARY", Qt::CaseInsensitive) &&

name.compare("NOCASE", Qt::CaseInsensitive) &&

name.compare("RTRIM", Qt::CaseInsensitive))

{

emit requestCollation(name, eTextRep);

}

{

QString msg = QString("(%1) %2").arg(error_code).arg(message);

logSQL(msg, kLogMsg_ErrorLog);

{

// This is a cache for the last 50 regular expressions. Compiling them takes some time, so we want to cache the compiled

// regular expressions for performance purposes.

static std::array<std::pair<QString, QRegularExpression>, 50> regex_cache;

// Check if pattern is in cache

QString pattern{reinterpret_cast<const char*>(sqlite3_value_text(argv[0]))};

QRegularExpression regex;

const auto it = std::find_if(regex_cache.begin(), regex_cache.end(), [pattern](const std::pair<QString, QRegularExpression>& val) {

return val.first == pattern;

});

if(it == regex_cache.end())

{

// Pattern is not in cache. Create a new regular expressions object, compile it, and insert it into the cache

regex.setPattern(pattern);

regex.setPatternOptions(QRegularExpression::UseUnicodePropertiesOption);

if(!regex.isValid())

return sqlite3_result_error(ctx, "invalid operand", -1);

regex.optimize();

static size_t regex_cache_size;

regex_cache_size = (regex_cache_size + 1) % regex_cache.size();

regex_cache[regex_cache_size] = {pattern, regex};

} else {

// Pattern is in the cache. Just retrieve it

regex = it->second;

}

// Get arguments and check their values

QString arg2{reinterpret_cast<const char*>(sqlite3_value_text(argv[1]))};

// Perform the actual matching and return the result.

// SQLite expects a 0 for not found and a 1 for found.

sqlite3_result_int(ctx, regex.match(arg2).hasMatch());

{

if (isOpen()) close();

isEncrypted = false;

disableStructureUpdateChecks = false;

// Get encryption settings for database file

CipherSettings cipherSettings;

if(tryEncryptionSettings(db, &isEncrypted, &cipherSettings) == false)

return false;

// Open database file

if(sqlite3_open_v2(db.toUtf8(), &_db, readOnly ? SQLITE_OPEN_READONLY : SQLITE_OPEN_READWRITE, nullptr) != SQLITE_OK)

{

lastErrorMessage = QString::fromUtf8(sqlite3_errmsg(_db));

return false;

}

// Set encryption details if database is encrypted

#ifdef ENABLE_SQLCIPHER

if(isEncrypted)

{

executeSQL("PRAGMA key = " + cipherSettings.getPassword(), false, false);

executeSQL("PRAGMA cipher_page_size = " + std::to_string(cipherSettings.getPageSize()), false, false);

executeSQL("PRAGMA kdf_iter = " + std::to_string(cipherSettings.getKdfIterations()), false, false);

executeSQL("PRAGMA cipher_hmac_algorithm = " + cipherSettings.getHmacAlgorithm(), false, false);

executeSQL("PRAGMA cipher_kdf_algorithm = " + cipherSettings.getKdfAlgorithm(), false, false);

executeSQL("PRAGMA cipher_plaintext_header_size = " + std::to_string(cipherSettings.getPlaintextHeaderSize()), false, false);

}

#endif

if (_db)

{

// add UTF16 collation (comparison is performed by QString functions)

sqlite3_create_collation(_db, "UTF16", SQLITE_UTF16, nullptr, sqlite_compare_utf16);

// add UTF16CI (case insensitive) collation (comparison is performed by QString functions)

sqlite3_create_collation(_db, "UTF16CI", SQLITE_UTF16, nullptr, sqlite_compare_utf16ci);

// register collation callback

Callback<void(void*, sqlite3*, int, const char*)>::func = std::bind(&DBBrowserDB::collationNeeded, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);

void (*c_callback)(void*, sqlite3*, int, const char*) = static_cast<decltype(c_callback)>(Callback<void(void*, sqlite3*, int, const char*)>::callback);

sqlite3_collation_needed(_db, nullptr, c_callback);

// Set foreign key settings as requested in the preferences

bool foreignkeys = Settings::getValue("db", "foreignkeys").toBool();

setPragma("foreign_keys", foreignkeys ? "1" : "0");

// Register REGEXP function

if(Settings::getValue("extensions", "disableregex").toBool() == false)

sqlite3_create_function(_db, "REGEXP", 2, SQLITE_UTF8, nullptr, regexp, nullptr, nullptr);

// Register our internal helper function for putting multiple values into a single column

sqlite3_create_function_v2(

_db,

"sqlb_make_single_value",

-1,

SQLITE_UTF8 | SQLITE_DETERMINISTIC,

nullptr,

sqlite_make_single_value,

nullptr,

nullptr,

nullptr

);

// Check if file is read only. In-memory databases are never read only

if(db == ":memory:")

{

isReadOnly = false;

} else {

QFileInfo fi(db);

QFileInfo fid(fi.absoluteDir().absolutePath());

isReadOnly = readOnly || !fi.isWritable() || !fid.isWritable();

}

// Load extensions

loadExtensionsFromSettings();

// Execute default SQL

if(!isReadOnly)

{

QByteArray default_sql = Settings::getValue("db", "defaultsqltext").toByteArray();

if(!default_sql.isEmpty())

executeMultiSQL(default_sql, false, true);

}

curDBFilename = db;

updateSchema();

return true;

} else {

return false;

}

{

if(!_db)

{

return false;

}

waitForDbRelease();

// detach database

if(!executeSQL("DETACH " + sqlb::escapeIdentifier(attached_as) + ";", false))

{

QMessageBox::warning(nullptr, qApp->applicationName(), lastErrorMessage);

return false;

}

// Update schema to load database schema of the newly attached database

updateSchema();

return true;

{

if(!_db)

return false;

waitForDbRelease();

// In shared cache mode, attempting to attach the same database file more than once results in an error.

// So no need for a check if this file has already been attached and abort if this is the case

// Ask for name to be given to the attached database if none was provided

if(attach_as.isEmpty())

{

attach_as = QInputDialog::getText(nullptr,

qApp->applicationName(),

tr("Please specify the database name under which you want to access the attached database"),

QLineEdit::Normal,

QFileInfo(filePath).baseName()

).trimmed();

}

if(attach_as.isNull())

return false;

#ifdef ENABLE_SQLCIPHER

// Try encryption settings

CipherSettings cipherSettings;

bool is_encrypted;

if(tryEncryptionSettings(filePath, &is_encrypted, &cipherSettings) == false)

return false;

// Attach database

std::string key;

if(is_encrypted)

key = "KEY " + cipherSettings.getPassword();

else

key = "KEY ''";

// Only apply cipher settings if the database is encrypted

if(is_encrypted)

{

if(!executeSQL("PRAGMA cipher_default_page_size = " + std::to_string(cipherSettings.getPageSize()), false))

{

QMessageBox::warning(nullptr, qApp->applicationName(), lastErrorMessage);

return false;

}

if(!executeSQL("PRAGMA cipher_default_kdf_iter = " + std::to_string(cipherSettings.getKdfIterations()), false))

{

QMessageBox::warning(nullptr, qApp->applicationName(), lastErrorMessage);

return false;

}

if(!executeSQL("PRAGMA cipher_hmac_algorithm = " + cipherSettings.getHmacAlgorithm(), false))

{

QMessageBox::warning(nullptr, qApp->applicationName(), lastErrorMessage);

return false;

}

if(!executeSQL("PRAGMA cipher_kdf_algorithm = " + cipherSettings.getKdfAlgorithm(), false))

{

QMessageBox::warning(nullptr, qApp->applicationName(), lastErrorMessage);

return false;

}

if(!executeSQL("PRAGMA cipher_plaintext_header_size = " + std::to_string(cipherSettings.getPlaintextHeaderSize()), false))

{

QMessageBox::warning(nullptr, qApp->applicationName(), lastErrorMessage);

return false;

}

}

if(!executeSQL("ATTACH " + sqlb::escapeString(filePath.toStdString()) + " AS " + sqlb::escapeIdentifier(attach_as.toStdString()) + " " + key, false))

{

QMessageBox::warning(nullptr, qApp->applicationName(), lastErrorMessage);

return false;

}

// Clean up cipher settings

#else

// Attach database

if(!executeSQL("ATTACH " + sqlb::escapeString(filePath.toStdString()) + " AS " + sqlb::escapeIdentifier(attach_as.toStdString()), false))

{

QMessageBox::warning(nullptr, qApp->applicationName(), lastErrorMessage);

return false;

}

#endif

// Update schema to load database schema of the newly attached database

updateSchema();

return true;

{

lastErrorMessage = tr("Invalid file format");

// Open database file

sqlite3* dbHandle;

if(sqlite3_open_v2(filePath.toUtf8(), &dbHandle, SQLITE_OPEN_READONLY, nullptr) != SQLITE_OK)

return false;

// Try reading from database

#ifdef ENABLE_SQLCIPHER

bool isDotenvChecked = false;

// Determine default encryption settings depending on the SQLCipher version we use

QString sqlite_version, sqlcipher_version;

getSqliteVersion(sqlite_version, sqlcipher_version);

int enc_default_page_size, enc_default_kdf_iter;

int enc_default_plaintext_header_size = 0;

std::string enc_default_hmac_algorithm, enc_default_kdf_algorithm;

if(sqlcipher_version.startsWith('4'))

{

enc_default_page_size = 4096;

enc_default_kdf_iter = 256000;

enc_default_hmac_algorithm = "SHA512";

enc_default_kdf_algorithm = "SHA512";

} else {

enc_default_page_size = 1024;

enc_default_kdf_iter = 64000;

enc_default_hmac_algorithm = "SHA1";

enc_default_kdf_algorithm = "SHA1";

}

#endif

*encrypted = false;

while(true)

{

const std::string statement = "SELECT COUNT(*) FROM sqlite_master;";

sqlite3_stmt* vm;

const char* tail;

int err = sqlite3_prepare_v2(dbHandle, statement.c_str(), static_cast<int>(statement.size()), &vm, &tail);

if(err == SQLITE_BUSY || err == SQLITE_PERM || err == SQLITE_NOMEM || err == SQLITE_IOERR || err == SQLITE_CORRUPT || err == SQLITE_CANTOPEN)

{

lastErrorMessage = QString::fromUtf8(sqlite3_errmsg(dbHandle));

sqlite3_close_v2(dbHandle);

return false;

}

if(sqlite3_step(vm) != SQLITE_ROW)

{

sqlite3_finalize(vm);

#ifdef ENABLE_SQLCIPHER

bool foundDotenvPassword = false;

// Being in a while loop, we don't want to check the same file multiple times

if (!isDotenvChecked) {

const QFileInfo databaseFileInfo(filePath);

const QDir databaseDirectory(databaseFileInfo.absoluteDir());

const QString databaseFileName(databaseFileInfo.fileName());

auto tryLoadDotenv = [&](const QString& dotenvFilePath) -> bool {

if (!QFile::exists(dotenvFilePath))

return false;

const QSettings dotenv(dotenvFilePath, QSettings::IniFormat);

const QVariant passwordValue = dotenv.value(databaseFileName);

if (passwordValue.isNull())

return false;

const std::string password = passwordValue.toString().toStdString();

const QVariant keyFormatValue = dotenv.value(databaseFileName + "_keyFormat", QVariant(CipherSettings::KeyFormats::Passphrase));

const CipherSettings::KeyFormats keyFormat = CipherSettings::getKeyFormat(keyFormatValue.toInt());

const int pageSize = dotenv.value(databaseFileName + "_pageSize", enc_default_page_size).toInt();

const int kdfIterations = dotenv.value(databaseFileName + "_kdfIter", enc_default_kdf_iter).toInt();

const int plaintextHeaderSize = dotenv.value(databaseFileName + "_plaintextHeaderSize", enc_default_plaintext_header_size).toInt();

const std::string hmacAlgorithm = dotenv.value(databaseFileName + "_hmacAlgorithm", QString::fromStdString(enc_default_hmac_algorithm)).toString().toStdString();

const std::string kdfAlgorithm = dotenv.value(databaseFileName + "_kdfAlgorithm", QString::fromStdString(enc_default_kdf_algorithm)).toString().toStdString();

cipherSettings->setKeyFormat(keyFormat);

cipherSettings->setPassword(password);

cipherSettings->setPageSize(pageSize);

cipherSettings->setKdfIterations(kdfIterations);

cipherSettings->setHmacAlgorithm("HMAC_" + hmacAlgorithm);

cipherSettings->setKdfAlgorithm("PBKDF2_HMAC_" + kdfAlgorithm);

cipherSettings->setPlaintextHeaderSize(plaintextHeaderSize);

return true;

};

const QString db4sEnvPath = databaseDirectory.filePath(".db4s.env");

const bool hasDB4SEnv = QFile::exists(db4sEnvPath);

if (hasDB4SEnv)

{

foundDotenvPassword = tryLoadDotenv(db4sEnvPath);

} else {

// Deprecated: legacy .env in the database directory only. Remove once .db4s.env is adopted.

foundDotenvPassword = tryLoadDotenv(databaseDirectory.filePath(".env"));

// Parent folder search is opt-in because it can slow down opening encrypted databases.

if (!foundDotenvPassword && Settings::getValue("db", "sqlcipherparentdotenvlookup").toBool())

{

QDir searchDirectory(databaseDirectory);

while (searchDirectory.cdUp())

{

if (tryLoadDotenv(searchDirectory.filePath(".db4s.env")))

{

foundDotenvPassword = true;

break;

}

}

}

}

isDotenvChecked = true;

}

if(foundDotenvPassword)

{

// Skip the CipherDialog prompt for now to test if the dotenv settings are correct

} else {

CipherDialog *cipherDialog = new CipherDialog(nullptr, false);

if(cipherDialog->exec())

{

*cipherSettings = cipherDialog->getCipherSettings();

} else {

sqlite3_close_v2(dbHandle);

*encrypted = false;

return false;

}

}

// Close and reopen database first to be in a clean state after the failed read attempt from above

sqlite3_close_v2(dbHandle);

if(sqlite3_open_v2(filePath.toUtf8(), &dbHandle, SQLITE_OPEN_READONLY, nullptr) != SQLITE_OK)

return false;

// Set the key

sqlite3_exec(dbHandle, ("PRAGMA key = " + cipherSettings->getPassword()).c_str(), nullptr, nullptr, nullptr);

// Set the settings if they differ from the default values

if(cipherSettings->getPageSize() != enc_default_page_size)

sqlite3_exec(dbHandle, ("PRAGMA cipher_page_size = " + std::to_string(cipherSettings->getPageSize())).c_str(), nullptr, nullptr, nullptr);

if(cipherSettings->getKdfIterations() != enc_default_kdf_iter)

sqlite3_exec(dbHandle, ("PRAGMA kdf_iter = " + std::to_string(cipherSettings->getKdfIterations())).c_str(), nullptr, nullptr, nullptr);

if(cipherSettings->getHmacAlgorithm() != enc_default_hmac_algorithm)

sqlite3_exec(dbHandle, ("PRAGMA cipher_hmac_algorithm = " + cipherSettings->getHmacAlgorithm()).c_str(), nullptr, nullptr, nullptr);

if(cipherSettings->getKdfAlgorithm() != enc_default_kdf_algorithm)

sqlite3_exec(dbHandle, ("PRAGMA cipher_kdf_algorithm = " + cipherSettings->getKdfAlgorithm()).c_str(), nullptr, nullptr, nullptr);

if(cipherSettings->getPlaintextHeaderSize() != enc_default_plaintext_header_size)

sqlite3_exec(dbHandle, ("PRAGMA cipher_plaintext_header_size = " + std::to_string(cipherSettings->getPlaintextHeaderSize())).c_str(), nullptr, nullptr, nullptr);

*encrypted = true;

#else

lastErrorMessage = QString::fromUtf8(sqlite3_errmsg(dbHandle));

sqlite3_close_v2(dbHandle);

return false;

#endif

} else {

sqlite3_finalize(vm);

sqlite3_close_v2(dbHandle);

return true;

}

}

{

sqlite = QString(SQLITE_VERSION);

// The SQLCipher version must be queried via a pragma and for a pragma we need a database connection.

// Because we want to be able to query the SQLCipher version without opening a database file first, we

// open a separate connection to an in-memory database here.

sqlcipher = QString();

#ifdef ENABLE_SQLCIPHER

sqlite3* dummy;

if(sqlite3_open(":memory:", &dummy) == SQLITE_OK)

{

sqlite3_stmt* stmt;

if(sqlite3_prepare_v2(dummy, "PRAGMA cipher_version", -1, &stmt, nullptr) == SQLITE_OK)

{

if(sqlite3_step(stmt) == SQLITE_ROW)

sqlcipher = QByteArray(static_cast<const char*>(sqlite3_column_blob(stmt, 0)), sqlite3_column_bytes(stmt, 0));

sqlite3_finalize(stmt);

}

sqlite3_close_v2(dummy);

}

#endif

{

if(!isOpen())

return false;

if(isReadOnly) {

qWarning() << "setSavepoint: not done. DB is read-only";

return false;

}

if(unique && contains(savepointList, pointname))

return true;

executeSQL("SAVEPOINT " + sqlb::escapeIdentifier(pointname) + ";", false, true);

savepointList.push_back(pointname);

emit dbChanged(getDirty());

return true;

{

if(!isOpen())

return false;

if(contains(savepointList, pointname) == false)

// If there is no such savepoint in the list,

// we have already released it, so in this case

// the operation should be successfull

return true;

if(!executeSQL("RELEASE " + sqlb::escapeIdentifier(pointname) + ";", false, true))

return false;

// SQLite releases all savepoints that were created between

// creation of given savepoint and releasing of it,

// so we should too

auto it = std::find(savepointList.rbegin(), savepointList.rend(), pointname).base() - 1;

savepointList.erase(it, savepointList.end());

emit dbChanged(getDirty());

return true;

{

if(!isOpen() || contains(savepointList, pointname) == false)

return false;

executeSQL("ROLLBACK TO SAVEPOINT " + sqlb::escapeIdentifier(pointname) + ";", false, true);

executeSQL("RELEASE " + sqlb::escapeIdentifier(pointname) + ";", false, true);

// SQLite releases all savepoints that were created between

// creation of given savepoint and releasing of it,

// so we should too

auto it = std::find(savepointList.rbegin(), savepointList.rend(), pointname).base() - 1;

savepointList.erase(it, savepointList.end());

emit dbChanged(getDirty());

return true;

{

if(!_db)

return false;

waitForDbRelease();

while(!savepointList.empty())

{

if(!releaseSavepoint(savepointList.front()))

return false;

}

// When still in a transaction, commit that too

if(sqlite3_get_autocommit(_db) == 0)

executeSQL("COMMIT;", false, true);

return true;

{

while(!savepointList.empty())

{

if(!revertToSavepoint(savepointList.front()))

return false;

}

return true;

{

if (isOpen())

close();

// read encoding from settings and open with sqlite3_open for utf8 and sqlite3_open16 for utf16

QString sEncoding = Settings::getValue("db", "defaultencoding").toString();

int openresult = SQLITE_OK;

if(sEncoding == "UTF-8" || sEncoding == "UTF8" || sEncoding == "Latin1")

openresult = sqlite3_open(db.toUtf8(), &_db);

else

openresult = sqlite3_open16(db.utf16(), &_db);

if( openresult != SQLITE_OK ){

lastErrorMessage = QString::fromUtf8(sqlite3_errmsg(_db));

sqlite3_close_v2(_db);

_db = nullptr;

return false;

}

if (_db)

{

// force sqlite3 do write proper file header

// if we don't create and drop the table we might end up

// with a 0 byte file, if the user cancels the create table dialog

{

NoStructureUpdateChecks nup(*this);

executeSQL("CREATE TABLE notempty (id integer primary key);", false, false);

executeSQL("DROP TABLE notempty;", false, false);

}

// Close database and open it through the code for opening existing database files. This is slightly less efficient but saves us some duplicate

// code.

sqlite3_close_v2(_db);

return open(db);

} else {

return false;

}

{

// Do nothing if no file is opened

if(!_db)

return true;

waitForDbRelease();

if (getDirty())

{

// In-memory databases can't be saved to disk. So the need another text than regular databases.

// Note that the QMessageBox::Yes option in the :memory: case and the QMessageBox::No option in the regular case are

// doing the same job: proceeding but not saving anything.

QMessageBox::StandardButton reply;

if(curDBFilename == ":memory:")

{

reply = QMessageBox::question(nullptr,

QApplication::applicationName(),

tr("Do you really want to close this temporary database? All data will be lost."),

QMessageBox::Yes | QMessageBox::Cancel);

} else {

reply = QMessageBox::question(nullptr,

QApplication::applicationName(),

tr("Do you want to save the changes made to the database file %1?").arg(curDBFilename),

QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);

}

// If the user clicked the cancel button stop here and return false

if(reply == QMessageBox::Cancel)

return false;

// If he didn't it was either yes or no

if(reply == QMessageBox::Save)

releaseAllSavepoints();

else

revertAll(); //not really necessary, I think... but will not hurt.

}

if(sqlite3_close_v2(_db) != SQLITE_OK)

qWarning() << tr("Database didn't close correctly, probably still busy");

_db = nullptr;

curDBFilename.clear();

schemata.clear();

savepointList.clear();

emit dbChanged(getDirty());

emit structureUpdated();

// Return true to tell the calling function that the closing wasn't cancelled by the user

return true;

if(!_db)

return false;

waitForDbRelease();

// Open the database file identified by filename. Exit early if this fails

// for any reason.

sqlite3* pTo;

int rc = sqlite3_open(filename.c_str(), &pTo);

if(rc!=SQLITE_OK) {

qWarning() << tr("Cannot open destination file: '%1'").arg(filename.c_str());

return false;

} else {

// Set up the backup procedure to copy from the "main" database of

// connection _db to the main database of connection pTo.

// If something goes wrong, pBackup will be set to nullptr and an error

// code and message left in connection pTo.

//

// If the backup object is successfully created, call backup_step()

// to copy data from _db to pTo. Then call backup_finish()

// to release resources associated with the pBackup object. If an

// error occurred, then an error code and message will be left in

// connection pTo. If no error occurred, then the error code belonging

// to pTo is set to SQLITE_OK.

//

sqlite3_backup* pBackup = sqlite3_backup_init(pTo, "main", _db, "main");

if(pBackup == nullptr) {

qWarning() << tr("Cannot backup to file: '%1'. Message: %2").arg(filename.c_str(), sqlite3_errmsg(pTo));

sqlite3_close_v2(pTo);

return false;

} else {

sqlite3_backup_step(pBackup, -1);

sqlite3_backup_finish(pBackup);

}

rc = sqlite3_errcode(pTo);

}

if(rc == SQLITE_OK) {

// Close current database and set backup as current

sqlite3_close_v2(_db);

_db = pTo;

curDBFilename = QString::fromStdString(filename);

return true;

} else {

qWarning() << tr("Cannot backup to file: '%1'. Message: %2").arg(filename.c_str(), sqlite3_errmsg(pTo));

// Close failed database connection.

sqlite3_close_v2(pTo);

return false;

}

{

if(!_db)

return nullptr;

waitForDbRelease(force_wait ? Wait : Ask);

db_user = user;

db_used = true;

emit databaseInUseChanged(true, user);

return db_pointer_type(_db, DatabaseReleaser(this));

{

if(!_db)

return;

// We can't show a message box from another thread than the main thread. So instead of crashing we

// just decide that we don't interrupt any running query in this case.

if(choice == Ask && QThread::currentThread() != QApplication::instance()->thread())

choice = Wait;

std::unique_lock<std::mutex> lk(m);

while(db_used) {

// notify user, give him the opportunity to cancel that

auto str = db_user;

lk.unlock();

bool cancel = choice == CancelOther;

if(choice == Ask) {

QMessageBox msgBox;

msgBox.setText(tr("The database is currently busy: ") + str);

msgBox.setInformativeText(tr("Do you want to abort that other operation?"));

msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);

msgBox.setDefaultButton(QMessageBox::No);

int ret = msgBox.exec();

cancel = ret == QMessageBox::Yes;

}

if(cancel)

sqlite3_interrupt(_db);

lk.lock();

cv.wait(lk, [this](){ return !db_used; });

}

const std::vector<std::string>& tablesToDump,

bool insertColNames,

bool insertNewSyntx,

bool keepOriginal,

bool exportSchema,

bool exportData,

bool keepOldSchema) const

{

waitForDbRelease();

// Open file

QFile file(filePath);

if(file.open(QIODevice::WriteOnly|QIODevice::Text))

{

QApplication::setOverrideCursor(Qt::WaitCursor);

// Count the total number of all records in all tables for the progress dialog

size_t numRecordsTotal = 0;

objectMap objMap = schemata.at("main"); // We only always export the main database, not the attached databases

std::vector<sqlb::TablePtr> tables;

for(const auto& it : objMap.tables)

{

QString tableName = QString::fromStdString(it.first);

// Never export the sqlite internal tables. Also only export any tables which are selected for export.

if(!it.second->isView()

&& !tableName.startsWith("sqlite_", Qt::CaseInsensitive)

&& contains(tablesToDump, it.first))

{

// Get the number of records in this table and remember to export it

tables.push_back(it.second);

numRecordsTotal += querySingleValueFromDb("SELECT COUNT(*) FROM " + sqlb::ObjectIdentifier("main", it.first).toString()).toUInt();

}

}

QProgressDialog progress(tr("Exporting database to SQL file..."),

tr("Cancel"), 0, static_cast<int>(numRecordsTotal));

// Disable context help button on Windows

progress.setWindowFlags(progress.windowFlags()

& ~Qt::WindowContextHelpButtonHint);

progress.setWindowModality(Qt::ApplicationModal);

progress.show();

qApp->processEvents();

// Open text stream to the file

QTextStream stream(&file);

// Put the SQL commands in a transaction block

stream << "BEGIN TRANSACTION;\n";

// First export the schema of all selected tables. We need to export the schema of all tables before we export the first INSERT statement to

// make sure foreign keys are working properly.

if(exportSchema)

{

for(const auto& it : tables)

{

// Write the SQL string used to create this table to the output file

if(!keepOldSchema)

stream << QString("DROP TABLE IF EXISTS %1;\n").arg(QString::fromStdString(sqlb::escapeIdentifier(it->name())));

if(it->fullyParsed() && !keepOriginal)

stream << QString::fromStdString(it->sql("main", keepOldSchema)) << "\n";

else {

QString statement = QString::fromStdString(it->originalSql());

if(keepOldSchema) {

if (statement.startsWith("CREATE VIRTUAL TABLE", Qt::CaseInsensitive)) {

const int createTableLength = 20;

statement.replace(0, createTableLength, "CREATE VIRTUAL TABLE IF NOT EXISTS");

} else {

// The statement is guaranteed by SQLite to start with "CREATE TABLE"

const int createTableLength = 12;

statement.replace(0, createTableLength, "CREATE TABLE IF NOT EXISTS");

}

}

stream << statement << ";\n";

}

}

}

// Now export the data as well

if(exportData)

{

for(const auto& it : tables)

{

// get columns

sqlb::StringVector cols = it->fieldNames();

// Generated columns cannot be inserted into, so leave them out of both the SELECT and the

// INSERT statements, like the sqlite3 shell's .dump does

std::string sQuery = "SELECT * FROM " + sqlb::escapeIdentifier(it->name());

if(std::any_of(it->fields.begin(), it->fields.end(), [](const sqlb::Field& f) { return f.generated() != nullptr; }))

{

cols.clear();

for(const sqlb::Field& f : it->fields)

{