server-sdk/src/serversdk/databasemanager.cpp

#include "databasemanager.h"
#include "logger.h"




namespace serversdk {

DatabaseManager::DatabaseManager()
{
}



DatabaseManager::~DatabaseManager()
{
    if (mDatabase.isValid()) {
        mDatabase.close();
        mDatabase = QSqlDatabase(); // invalidate database
        qDebug(sdkdb) << "removing database connection:" << mConnectionName;
        QSqlDatabase::removeDatabase(mConnectionName);
    }
}

/**
 * @brief Creates new SQLite connection
 * @param path to database ( will be created when none )
 * @param connectionName
 * @return
 */
bool DatabaseManager::openSQLite(const QString &path, const QString &connectionName)
{
    mConnectionName = connectionName;
    mDatabase = QSqlDatabase::addDatabase("QSQLITE", mConnectionName);
    mDatabase.setDatabaseName(path);

    int res = mDatabase.open();

    if (!res) {
        qInfo(sdkdb) << "Not possible to open database from path:" << path;
    }
    return res;
}

bool DatabaseManager::openPostgres(const QString &host, const QString &dbName, const QString &user, const QString &password, const QString &connectionName)
{
    Q_ASSERT_X(mConnectionName.isEmpty(), "open postgres", "Expecting only one database per DatabaseManager");
    mConnectionName = connectionName;
    mDatabase = QSqlDatabase::addDatabase("QPSQL", mConnectionName);

    mDatabase.setDatabaseName(dbName);
    mDatabase.setHostName(host);
    mDatabase.setUserName(user); // home-office stuff -->> db.setPort(80);
    mDatabase.setPassword(password);

    int res = mDatabase.open();

    if (!res) {
        qInfo(sdkdb) << "Not possible to open database from url:" << host;
    }
    return res;
}


bool DatabaseManager::isValid() const
{
    return mDatabase.isValid();
}

bool DatabaseManager::isOpen() const
{
    return mDatabase.isOpen();
}

void DatabaseManager::close()
{
    mDatabase.close();
}

QSqlQuery DatabaseManager::execPlainSql(const QString &sqlText)
{
    QSqlQuery query(mDatabase);
    return executeQuery(query, sqlText);
}

QSqlQuery DatabaseManager::executeQuery(QSqlQuery &query, const QString &sqlText)
{

    // Get correct SQL statement and correct isSelect
    // Need for output correct SQL command
    // isSelect is needed for correct bahaviour of 'dryMode' only select should be executed
    QString sqlStatement = sqlText;
    bool isSelect = false;
    if ( sqlText.isEmpty()) {
        sqlStatement = getLastQuery(query);
    }
    if (sqlText.startsWith("SELECT", Qt::CaseInsensitive)) {
        isSelect = true;
    }

    if (mDryMode) {
        qCInfo(sdkdb) << "SQL statement: " << sqlStatement;
    }

    // Execute only SELECT statement or when not drymode
    if ( isSelect || !mDryMode ) {
        int res = false;
        if ( ! sqlText.isEmpty()) { // prepared statement.
            res = query.exec(sqlText);
            return processResult(res, query);
        } else {
            res = query.exec();
            return processResult(res, query);
        }
    }
    return query;
}

QSqlQuery DatabaseManager::createQuery()
{
    QSqlQuery query(mDatabase);
    return query;
}

QSqlQuery DatabaseManager::processResult(int res, const QSqlQuery &query) const
{
    if ( !res ) {
        QString msg = QString("Source: Database Manager \nError --------\n%1\nSQL-------\n%2\n--------")
                .arg(query.lastError().text(), query.lastQuery());
        qCDebug(sdkdb).noquote() << msg;
        emit sqlError(query);
        log(msg);
    }
    return query;
}

QString DatabaseManager::getLastQuery(const QSqlQuery& query) const
{
    QString str = query.lastQuery();
    QMapIterator<QString, QVariant> it(query.boundValues());
    while (it.hasNext())
    {
        it.next();
        str.replace(it.key(),it.value().toString());
    }
    return str;
}

void DatabaseManager::log(const QString &msg) const
{
    qDebug() << "database logger implement logger";
    qDebug() << msg;
}

bool DatabaseManager::dryMode() const
{
    return mDryMode;
}

void DatabaseManager::setDryMode(bool dryMode)
{
    mDryMode = dryMode;
}

QSqlDatabase DatabaseManager::database() const
{
    Q_ASSERT(mDatabase.isValid());
    Q_ASSERT(mDatabase.isOpen());
    return mDatabase;
}

} // core