ZsqlDatabase.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * ZsqlDatabase.cpp
 *
 *  Created on: 06-Aug, 2014
 *  Author: Bob Dinitto   bob@ninzo.com
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include "ZsqlDatabase.h"
#include "zglobal.h"
#include "ZsqlQuery.h"
#include "ZsqlRecord.h"
#include "ZsqlError.h"
#include <QQmlEngine>



namespace Zbl
{

QReadWriteLock ZsqlDatabase::m_lock(QReadWriteLock::Recursive);

ZsqlDatabase::ZsqlDbMap ZsqlDatabase::m_databaseObjects;

QVariant ZsqlDatabase::m_tags;

ZsqlDatabase::ZsqlDatabase(QObject *parent)
    : QObject(parent), m_db(NULL)
{
    qDebug("ZsqlDatabase::ZsqlDatabase");

    QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);

    createTags();

}

ZsqlDatabase::~ZsqlDatabase()
{
    release();
}

void ZsqlDatabase::createTags()
{
    if(!m_tags.isNull())
        return;

    QVariantMap map;

    map.insert("tabletypeTables", Tables);
    map.insert("tabletypeSystemTables", SystemTables);
    map.insert("tabletypeViews", Views);
    map.insert("tabletypeAllTables", AllTables);

    map.insert("numbersLowPrecisionInt32", LowPrecisionInt32);
    map.insert("numbersLowPrecisionInt64", LowPrecisionInt64);
    map.insert("numbersLowPrecisionDouble", LowPrecisionDouble);
    map.insert("numbersHighPrecision", HighPrecision);

    m_tags = QVariant::fromValue(map);
}

/*********************************
**********************************
** Property Access Methods
**********************************
*********************************/

bool ZsqlDatabase::isValid() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    ZBL_SLOT_END_RETURN(m_db->isValid(),  false,
    Z_FAC_JS, ZsqlDatabase::isValid, isValid failed)
}

bool ZsqlDatabase::isOpen() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    ZBL_SLOT_END_RETURN(m_db->isOpen(),  false,
    Z_FAC_JS, ZsqlDatabase::isOpen, isOpen failed)
}

bool ZsqlDatabase::isOpenError() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    ZBL_SLOT_END_RETURN(m_db->isOpenError(),  false,
    Z_FAC_JS, ZsqlDatabase::isOpenError, isOpenError failed)
}

QString ZsqlDatabase::getHostname() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    ZBL_SLOT_END_RETURN(m_db->hostName(),  QString(),
    Z_FAC_JS, ZsqlDatabase::getHostname, getHostname failed)}

void ZsqlDatabase::setHostname(const QString& hostname)
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    m_db->setHostName(hostname);
    ZBL_SLOT_END_VOID( Z_FAC_JS,
    ZsqlDatabase::setHostName, setHostName failed)
}

QString ZsqlDatabase::getDbName() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    ZBL_SLOT_END_RETURN(m_db->databaseName(), QString(),
    Z_FAC_JS, ZsqlDatabase::getDbName, getDbName failed)}

void ZsqlDatabase::setDbName(const QString& dbName)
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    m_db->setDatabaseName(dbName);
    ZBL_SLOT_END_VOID( Z_FAC_JS,
    ZsqlDatabase::setDbName, setDbName failed)
}

int ZsqlDatabase::getPortNumber() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    ZBL_SLOT_END_RETURN(m_db->port(),  false,
    Z_FAC_JS, ZsqlDatabase::getPortNumber, getPortNumber failed)}

void ZsqlDatabase::setPortNumber(int portNumber)
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    m_db->setPort(portNumber);
    ZBL_SLOT_END_VOID( Z_FAC_JS,
    ZsqlDatabase::setPortNumber, setPortNumber failed)
}


void ZsqlDatabase::setConnectOptions(const QString& options)
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    m_db->setConnectOptions(options);
    ZBL_SLOT_END_VOID( Z_FAC_JS,
    ZsqlDatabase::setConnectOptions, setConnectOptions failed)
}

QString ZsqlDatabase::getConnectOptions()
{
    return m_db->connectOptions();
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    ZBL_SLOT_END_RETURN(m_db->connectOptions(),  QString(),
    Z_FAC_JS, ZsqlDatabase::getConnectOptions, getConnectOptions failed)
}

QObject* ZsqlDatabase::getLastError()
{
    ZsqlError* error = NULL;
    bool ok = false;
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    error = new ZsqlError();
    *error = m_db->lastError();
    ok = true;
    ZBL_SLOT_END_VOID(
    Z_FAC_JS, ZsqlDatabase::getLastError, getLastError failed)

    if(!ok)
    {
        if(error)
            error->deleteLater();

        return NULL;
    }

    return error;
}


/*********************************
**********************************
** Property Access Methods
**********************************
*********************************/

bool ZsqlDatabase::open(const QString & user, const QString & password)
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    ZBL_SLOT_END_RETURN(m_db->open(user, password),  false,
    Z_FAC_JS, ZsqlDatabase::open, open failed)
}

void ZsqlDatabase::close()
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    m_db->close();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlDatabase::close, close failed)
}

void ZsqlDatabase::release()
{
    if(!m_db)
        return; // done!

    // release() must be thread-safe so a connection can be removed
    // by any thread, not just the one that created it

    if(!inObjectThread(this))
    {
        // not in this object's thread so perform a recursive
        // blocking invocation on the object's owner thread

        QMetaObject::invokeMethod(this, "release",
                                  Qt::BlockingQueuedConnection
                                  );
        return;
    }

    ZBL_SLOT_BEGIN_TRY

    // child QSqlQuery objects must be deleted before deleting QSqlDatabase
    // objects or a SQL resource leak will occur and warning messages
    // printed. calling QSqlQuery::close() is apparently not good enough.

    const QObjectList& childList(children());
    const int childCount = childList.count();
    for(int i=0; i < childCount; i++)
    {
        ZsqlQuery* query = qobject_cast<ZsqlQuery*>(childList.at(i));

        if(query)
            query->release();
    }

    m_db->close();
    delete m_db;
    m_db = NULL;
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlDatabase::release, release failed)
}


QStringList ZsqlDatabase::getTableNames(int tableType) const
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    switch(tableType)
    {

    case Tables:
    case SystemTables:
    case Views:
    case AllTables:

        return m_db->tables(QSql::TableType(tableType));
    }
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlDatabase::getTableNames, getTableNames failed)

    return QStringList();
 }

QVariant ZsqlDatabase::getTags()
{
    return m_tags;
}

QObject* ZsqlDatabase::newQuery()
{
    ZsqlQuery* query = NULL;

    ZBL_SLOT_BEGIN_TRY
    validateDb();

    validateThread();

    query = ZsqlQuery::newQuery(*this);

    //m_queryObjects.add(query);

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlDatabase::newQuery, newQuery failed)

    if(zThreadErr.isError())
    {
        if(query)
            query->deleteLater();
        return NULL;
    }
    return query;
}

#if 0
void ZsqlDatabase::removeQuery(QObject* query)
{

    ZBL_SLOT_BEGIN_TRY
            validateDb();

    ZsqlQuery* q = qobject_cast<ZsqlQuery*>(query);

    if(!q)
        throw ZblException("Specified query object isn't a ZsqlQuery object.")

    validateThread();

    query = ZsqlQuery::newQuery(*this);

    //m_queryObjects.add(query);

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlDatabase::removeQuery, removeQuery failed)

    if(zThreadErr.isError())
    {
        if(query)
            query->deleteLater();
        return NULL;
    }
    return query;
}
#endif


QObject* ZsqlDatabase::addDatabase(const QString& driverType,
                                   const QString& connectionName )
{
    QWriteLocker lock(&m_lock);
    ZsqlDatabase* db = NULL;

    ZBL_SLOT_BEGIN_TRY

    // "default" connections are bad practice - they break
    // modularity so we don't allow them

    if(connectionName.isEmpty())
        throw ZblException("Invalid connection name");

    if(m_databaseObjects.contains(connectionName))
    {
        qDebug("ZsqlDatabase::addDatabase - "
               "Warning: replacing existing database connection: %s",
               cStr(connectionName));

        qDebug("ZsqlDatabase::addDatabase - "
               "Warning: current references on connection: %s will dangle",
               cStr(connectionName));

        removeDatabase(connectionName);  // which thread created it?
    }

    db = new ZsqlDatabase(NULL);

    db->m_db = new QSqlDatabase(
                QSqlDatabase::addDatabase(driverType, connectionName));

    m_databaseObjects.insert(connectionName, db);

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlDatabase::addDatabase, addDatabase failed)

    if(zThreadErr.isError())
    {
        if(db)
            db->deleteLater();
        return NULL;
    }
    return db;
}

void ZsqlDatabase::removeDatabase(const QString& connectionName)
{

    ZBL_SLOT_BEGIN_TRY

    if(connectionName.isEmpty())
        throw ZblException("Invalid connection name");

    QWriteLocker lock(&m_lock);

    if(m_databaseObjects.contains(connectionName))
    {
        ZsqlDatabase* db = m_databaseObjects.value(connectionName);

        m_databaseObjects.remove(connectionName);

        db->release();

        QSqlDatabase::removeDatabase(connectionName);

        db->deleteLater();
    }
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlDatabase::removeDatabase, removeDatabase failed)
}


QObject* ZsqlDatabase::database(const QString& connectionName )
{
    ZsqlDatabase* db = NULL;

    ZBL_SLOT_BEGIN_TRY

    if(connectionName.isEmpty())
        throw ZblException("Invalid connection name");

    QReadLocker lock(&m_lock);

    if(m_databaseObjects.contains(connectionName))
    {
        db = m_databaseObjects.value(connectionName);

        if(!inObjectThread(db))
            throw ZblException(
            "Database can only be accessed by same thread that created it.");
    }

    ZBL_SLOT_END_RETURN(db,  NULL,
    Z_FAC_JS, ZsqlDatabase::database, database failed)
}

void ZsqlDatabase::removeThreadDatabases()
{
    const QThread* currentThread = QThread::currentThread();

    ZBL_SLOT_BEGIN_TRY

    QWriteLocker lock(&m_lock);

    ZsqlDbMap::iterator i = m_databaseObjects.begin();

    while(i != m_databaseObjects.end())
    {
        ZsqlDatabase* db = *i;

        if(currentThread == db->thread())
        {
            db->release();

            db->deleteLater();

            QSqlDatabase::removeDatabase(i.key());

            i = m_databaseObjects.erase(i);
        }
        else
        {
            i++;
        }
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlDatabase::removeThreadDatabases,
                      removeThreadDatabases failed)

}




bool ZsqlDatabase::transaction()
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    ZBL_SLOT_END_RETURN(m_db->transaction(),  false,
    Z_FAC_JS, ZsqlDatabase::transaction, transaction failed)
}

bool ZsqlDatabase::commit()
{
    ZBL_SLOT_BEGIN_TRY
    validateDb();
    ZBL_SLOT_END_RETURN(m_db->commit(),  false,
    Z_FAC_JS, ZsqlDatabase::commit, commit failed)
}

bool ZsqlDatabase::rollback()
{
    ZBL_SLOT_BEGIN_TRY
     validateDb();
    ZBL_SLOT_END_RETURN(m_db->rollback(),  false,
    Z_FAC_JS, ZsqlDatabase::rollback, rollback failed)
}

QObject* ZsqlDatabase::record(const QString& tablename)
{

    ZsqlRecord* r = NULL;

    ZBL_SLOT_BEGIN_TRY
    validateDb();
    r = new ZsqlRecord();
    r->m_r = m_db->record(tablename);
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlQuery::record, record failed)

    if(zThreadErr.isError())
    {
        if(r)
        {
            r->deleteLater();
            r = NULL;
        }
    }

    return r;
}



} // Zbl