QSqlDatabase QrSqlDatabase::createDatabase(QSqlError &dbError)
{
QString connectionName_ = connectionName();
dbError = QSqlError();
dbFileIsCreated = false;
qDebug() << "create database:" << getDatabasePath () << "," << connectionName_;
if (! QrFiler::fileExists (getDatabasePath ())) {
// qDebug() << "database path is not exist:" << getDatabasePath ();
// dbError = QSqlError("'database file is not exist!'", "", QSqlError::ConnectionError);
// Q_ASSERT(false);
// return QrSqlDatabase::null;
dbFileIsCreated = true;
qDebug() << "database file is not exist, ready to creating...";
}
const QrSqlDatabaseParams ¶ms = getParams ();
Q_ASSERT(!params.driverName.isEmpty () && !params.databaseName.isEmpty ());
QSqlDatabase db = QSqlDatabase::addDatabase (params.driverName, connectionName_);
db.setConnectOptions (params.connectOptions);
db.setDatabaseName (getDatabasePath ());
db.setUserName (params.username);
db.setPassword (params.password);
db.setHostName (params.hostname);
if (-1 != params.port){
db.setPort (params.port);
}
if (! db.open ()) {
qDebug() << "fail to open database";
QrSqlDatabaseError::displayLastError (db, "unable to open connection to database");
dbError = db.lastError ();
if (!dbError.isValid ()) {
dbError = QSqlError("'unable to open connection to database'", "", QSqlError::UnknownError);
}
QSqlDatabase::removeDatabase (connectionName_);
return QrSqlDatabase::null;
}
Qt::HANDLE curThreadIdHandle = QThread::currentThreadId ();
listDbByThread.insert (curThreadIdHandle, connectionName_);
QString curThreadId = QrStringCvter<Qt::HANDLE, QrIsPointer<Qt::HANDLE>::value>::toString (curThreadIdHandle);
qDebug() << "create new database connection of " << params.databaseName
<< "in thread " << curThreadId << " with key " << connectionName_;
return QSqlDatabase::database(connectionName_);
}
//----------------------------------------------------------------------------
QSqlDatabase ctkPluginStorageSQL::getConnection(bool create) const
{
if (m_connectionNames.hasLocalData() && QSqlDatabase::contains(m_connectionNames.localData()))
{
return QSqlDatabase::database(m_connectionNames.localData());
}
if (!create)
{
throw ctkPluginDatabaseException(QString("No database connection."),
ctkPluginDatabaseException::DB_NOT_OPEN_ERROR);
}
m_connectionNames.setLocalData(getConnectionName());
QSqlDatabase database = QSqlDatabase::addDatabase("QSQLITE", m_connectionNames.localData());
database.setDatabaseName(getDatabasePath());
if (!database.isValid())
{
close();
throw ctkPluginDatabaseException(QString("Invalid database connection: %1").arg(m_connectionNames.localData()),
ctkPluginDatabaseException::DB_CONNECTION_INVALID);
}
if (!database.open())
{
close();
throw ctkPluginDatabaseException(QString("Could not open database connection: %1 (%2)").arg(m_connectionNames.localData()).arg(database.lastError().text()),
ctkPluginDatabaseException::DB_SQL_ERROR);
}
return database;
}
bool Resource::Id::verifyPaths() const
{
if (getResourcePath().empty()) {
// DS_LOG_ERROR_M("resource_id (" << *this << ") missing resource path", ds::GENERAL_LOG);
return false;
}
if (getDatabasePath().empty()) {
// DS_LOG_ERROR_M("resource_id (" << *this << ") missing database path", ds::GENERAL_LOG);
return false;
}
return true;
}
//----------------------------------------------------------------------------
void ctkPluginStorageSQL::createDatabaseDirectory() const
{
QString path = getDatabasePath();
QFileInfo fileInfo(path);
if (!fileInfo.dir().exists())
{
if (!QDir::root().mkpath(fileInfo.path()))
{
close();
throw ctkPluginDatabaseException(QString("Could not create database directory: %1").arg(fileInfo.path()),
ctkPluginDatabaseException::DB_CREATE_DIR_ERROR);
}
}
}
int setupWebView(RuskWindow *rusk)
{
WebKitCookieManager *cookieManager;
WebKitWebContext *context;
context = webkit_web_context_get_default();
cookieManager = webkit_web_context_get_cookie_manager(context);
if(cookieManager == NULL)
{
return -1;
}
gchar *dbpath = getDatabasePath();
webkit_cookie_manager_set_persistent_storage(cookieManager, dbpath, WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE);
g_free(dbpath);
gchar *favdir = getFaviconDir();
webkit_web_context_set_favicon_database_directory(context, favdir);
g_free(favdir);
webkit_settings_set_user_agent_with_application_details(webkit_web_view_get_settings(rusk->webview), "rusk", VERSION);
g_signal_connect(G_OBJECT(rusk->webview), "notify::title", G_CALLBACK(onTitleChange), rusk);
g_signal_connect(G_OBJECT(rusk->webview), "notify::estimated-load-progress", G_CALLBACK(onProgressChange), rusk);
g_signal_connect(G_OBJECT(rusk->webview), "load-changed", G_CALLBACK(onLoadChange), rusk);
g_signal_connect(G_OBJECT(rusk->webview), "notify::favicon", G_CALLBACK(onFaviconChange), rusk);
g_signal_connect(G_OBJECT(rusk->webview), "mouse-target-changed", G_CALLBACK(onMouseTargetChange), rusk);
g_signal_connect(G_OBJECT(rusk->webview), "create", G_CALLBACK(onRequestNewWindow), rusk);
g_signal_connect(G_OBJECT(context), "download-started", G_CALLBACK(onDownloadStarted), rusk);
WebKitUserContentManager *manager = webkit_web_view_get_user_content_manager(rusk->webview);
if(addScriptByFileName(manager, SCRIPT_DOCUMENT_START, WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START) < 0)
{
return -1;
}
if(addScriptByFileName(manager, SCRIPT_DOCUMENT_END, WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_END) < 0)
{
return -1;
}
return 0;
}
int connectDataBase(RuskWindow *rusk)
{
gchar *dbpath = getDatabasePath();
if(sqlite3_open(dbpath, &rusk->database.connection) != SQLITE_OK)
{
return -1;
}
g_free(dbpath);
char *error = NULL;
if(sqlite3_exec(rusk->database.connection, "create table if not exists rusk_history (date integer not null check(date > 0), uri text not null unique);", NULL, NULL, &error) != SQLITE_OK)
{
sqlite3_free(error);
return -1;
}
const char *insert = "insert or replace into rusk_history values(:date, :uri);";
sqlite3_prepare(rusk->database.connection, insert, strlen(insert), &rusk->database.insertStmt, NULL);
return 0;
}
/**
* Get the path to the database file in the host file system.
* This is the database file used by LMS to store metadata
* @param output: Path to database file in host file system
* @deprecated This is only used for testing purposes and will be removed
*/
void IndexerStubDefault::getDatabasePath(const std::shared_ptr<CommonAPI::ClientId> clientId, std::string& output, Indexer::IndexerError& e) {
// Call old style methods in default
getDatabasePath(output, e);
}
//----------------------------------------------------------------------------
QString ctkPluginStorageSQL::getConnectionName() const
{
QString connectionName = QFileInfo(getDatabasePath()).completeBaseName();
connectionName += QString("_0x%1").arg(reinterpret_cast<quintptr>(QThread::currentThread()), 2 * QT_POINTER_SIZE, 16, QLatin1Char('0'));
return connectionName;
}
//----------------------------------------------------------------------------
void ctkPluginStorageSQL::open()
{
if (m_isDatabaseOpen)
return;
QString path;
//Create full path to database
if(m_databasePath.isEmpty ())
m_databasePath = getDatabasePath();
path = m_databasePath;
QFileInfo dbFileInfo(path);
if (!dbFileInfo.dir().exists())
{
if(!QDir::root().mkpath(dbFileInfo.path()))
{
close();
QString errorText("Could not create database directory: %1");
throw ctkPluginDatabaseException(errorText.arg(dbFileInfo.path()), ctkPluginDatabaseException::DB_CREATE_DIR_ERROR);
}
}
m_connectionName = dbFileInfo.completeBaseName();
QSqlDatabase database;
if (QSqlDatabase::contains(m_connectionName))
{
database = QSqlDatabase::database(m_connectionName);
}
else
{
database = QSqlDatabase::addDatabase("QSQLITE", m_connectionName);
database.setDatabaseName(path);
}
if (!database.isValid())
{
close();
throw ctkPluginDatabaseException(QString("Invalid database connection: %1").arg(m_connectionName),
ctkPluginDatabaseException::DB_CONNECTION_INVALID);
}
//Create or open database
if (!database.isOpen())
{
if (!database.open())
{
close();
throw ctkPluginDatabaseException(QString("Could not open database. ") + database.lastError().text(),
ctkPluginDatabaseException::DB_SQL_ERROR);
}
}
m_isDatabaseOpen = true;
//Check if the sqlite version supports foreign key constraints
QSqlQuery query(database);
if (!query.exec("PRAGMA foreign_keys"))
{
close();
throw ctkPluginDatabaseException(QString("Check for foreign key support failed."),
ctkPluginDatabaseException::DB_SQL_ERROR);
}
if (!query.next())
{
close();
throw ctkPluginDatabaseException(QString("SQLite db does not support foreign keys. It is either older than 3.6.19 or was compiled with SQLITE_OMIT_FOREIGN_KEY or SQLITE_OMIT_TRIGGER"),
ctkPluginDatabaseException::DB_SQL_ERROR);
}
query.finish();
query.clear();
//Enable foreign key support
if (!query.exec("PRAGMA foreign_keys = ON"))
{
close();
throw ctkPluginDatabaseException(QString("Enabling foreign key support failed."),
ctkPluginDatabaseException::DB_SQL_ERROR);
}
query.finish();
//Check database structure (tables) and recreate tables if neccessary
//If one of the tables is missing remove all tables and recreate them
//This operation is required in order to avoid data coruption
if (!checkTables())
{
if (dropTables())
{
createTables();
}
else
{
//dropTables() should've handled error message
//and warning
close();
}
}
// silently remove any plugin marked as uninstalled
cleanupDB();
//Update database based on the recorded timestamps
updateDB();
initNextFreeIds();
}
