ZsqlQuery.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * ZsqlQuery.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 "ZsqlQuery.h"
#include "ZsqlDatabase.h"
#include "ZsqlError.h"
#include "ZsqlRecord.h"
#include "ZTableModel.h"
#include "zglobal.h"
#include <QList>


namespace Zbl
{

QVariant ZsqlQuery::m_tags;

ZsqlQuery::ZsqlQuery(
        QSqlQuery* query,
        QObject *parent)
:  QObject(parent),m_q(query)
{
    createTags();
}

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


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

    QVariantMap map;

    map.insert("paramtypeIn", In);
    map.insert("paramtypeOut",  Out);
    map.insert("paramtypeInOut",  InOut);
    map.insert("paramtypeBinary",  Binary);

    map.insert("batchexemodeValuesAsRows",  ValuesAsRows);
    map.insert("batchexemodeValuesAsColumns",  ValuesAsColumns);

    m_tags = QVariant::fromValue(map);
}

void ZsqlQuery::ensureParamType(int paramType)
{
    if(paramType != QSql::In
        && paramType != QSql::Out
        && paramType != QSql::InOut
        && paramType != QSql::Binary
        )
    {
        throw ZblException(QString(
        "ERROR: paramType is an invalid QSql::ParamType value: %1")
        .arg(paramType));
    }
}

void ZsqlQuery::initGetTableModel()
{
    validateQuery();

    if(!m_q->isActive())
        throw ZblException("ZsqlQuery::validateGetTableModel - ERROR: inactive query");

    if(!m_q->isSelect())
        throw ZblException("ZsqlQuery::validateGetTableModel - ERROR: non-SELECT query");

    if(!m_q->first())
        throw ZblException("ZsqlQuery::validateGetTableModel - ERROR: no data in query");
}

bool ZsqlQuery::getTableModel(ZTableModel* model)
{
    if(!model)
        throw ZblException("ZsqlQuery::tableModel - Error: null model object");

    initGetTableModel();

        zMetaRow metaRow(getMetaRow());

        model->setColumnCount(1);

        const int colCount = metaRow.count();

        //QHash<int, QByteArray> roleNames;

        for(int i=0; i<colCount; i++)
        {
            model->addRole(i, metaRow.at(i));
            //roleNames.insert(i, metaRow.at(i).toUtf8());
        }

        //model->setRoleNames(roleNames);

        ZRoleRowList rowList;

        do
        {
            ZRoleRow row;

            for(int col=0; col < colCount; col++)
            {
                QList<QVariant> rowData;

                rowData.append(m_q->value(col));

                row.insert(col, rowData);
            }

            rowList.push_back(row);

        } while(m_q->next());

        QVariant vRows = QVariant::fromValue(rowList);

        model->appendRows(vRows); // debug

    return true;
}

ZsqlQuery* ZsqlQuery::newQuery(ZsqlDatabase& database)
{
    if(!database.isValid())
        return NULL;

    if(!database.isOpen())
        return NULL;

   ZsqlQuery* z = NULL;
   QSqlQuery* q = NULL;

   try
   {
       q = new QSqlQuery(*database.m_db);
   }
   catch(...)
   {
       if(q)
       {
           delete q;
           return NULL;
       }
   }

   try
   {
       z = new ZsqlQuery(q, &database);
   }
   catch(...)
   {
       if(z)
       {
           z->deleteLater();
           return NULL;
        }
   }

   return z;
}

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

void ZsqlQuery::release()
{
    if(!m_q)
        return; // done!

    ZBL_SLOT_BEGIN_TRY
    delete m_q;
    m_q = NULL;
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlQuery::release, release failed)
}

void ZsqlQuery::bindValue(const QString& placeholder, const QVariant &value, int paramType)
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ensureParamType(paramType);
    m_q->bindValue(placeholder, value, (QSql::ParamTypeFlag)paramType);
    ZBL_SLOT_END_VOID(
    Z_FAC_JS, ZsqlQuery::bindValue, bindValue failed)
}

QVariant ZsqlQuery::boundValue(const QString & placeholder) const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->boundValue(placeholder),  QVariant(),
    Z_FAC_JS, ZsqlQuery::boundValue, boundValue failed)
}

QVariant ZsqlQuery::value(const QString & name) const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->value(name),  QVariant(),
    Z_FAC_JS, ZsqlQuery::value, value failed)
}

bool ZsqlQuery::isNull(int field) const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->isNull(field),  true,
    Z_FAC_JS, ZsqlQuery::isNull, isNull failed)
}

bool ZsqlQuery::isValid() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->isValid(),  true,
    Z_FAC_JS, ZsqlQuery::isValid, isValid failed)
}
bool ZsqlQuery::isActive() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->isActive(),  true,
    Z_FAC_JS, ZsqlQuery::isActive, isActive failed)
}

bool ZsqlQuery::isForwardOnly() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->isForwardOnly(),  true,
    Z_FAC_JS, ZsqlQuery::isForwardOnly, isForwardOnly failed)
}


bool ZsqlQuery::exec()
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->exec(),  true,
    Z_FAC_JS, ZsqlQuery::exec, exec failed)
}

bool ZsqlQuery::prepare(const QString& query)
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->prepare(query),  true,
    Z_FAC_JS, ZsqlQuery::prepare, prepare failed)

}

void ZsqlQuery::setForwardOnly(bool forward)
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    m_q->setForwardOnly(forward);
    ZBL_SLOT_END_VOID(Z_FAC_JS,
    ZsqlQuery::setForwardOnly, setForwardOnly failed)
}

int ZsqlQuery::getPosition() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->at(),  -1,
    Z_FAC_JS, ZsqlQuery::getPosition, getPosition failed)

}
QString ZsqlQuery::lastQuery() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->lastQuery(),  QString(),
    Z_FAC_JS, ZsqlQuery::lastQuery, lastQuery failed)

}

int ZsqlQuery::numRowsAffected() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->numRowsAffected(),  -1,
    Z_FAC_JS, ZsqlQuery::numRowsAffected, numRowsAffected failed)
}

bool ZsqlQuery::exec(const QString& query, int
                     resultType, QObject* tableModel)
{
    bool ok = false;

    ZBL_SLOT_BEGIN_TRY

    if(resultType != ZsqlQuery::TableModel)
        throw ZblException(
            "QSqlQuery::exec - Error: only ZsqlQuery::TableModel "
            "result type is currently supported. Sorry.");

    if(!tableModel)
            throw ZblException(
                "QSqlQuery::exec - Error: you must pass a ZTableModel "
                "object as argument 3 to receive the query data.");

    validateQuery();

    ok = m_q->exec(query);

    if(!ok)
        throw ZblException("QSqlQuery::exec - query failed.");

#if 0

    ok = getTableModel(tableModel);

    if(resultType == ZsqlQuery::TableModel)
    {
        emit queryResult(tableModel());
    }
#endif

    ok = true;

    ZBL_SLOT_END_RETURN(ok,  ok,
    Z_FAC_JS, ZsqlQuery::exec, exec failed)
}

bool ZsqlQuery::populateTableModel(QObject* model)
{
    ZBL_SLOT_BEGIN_TRY

    ZTableModel* zModel = qobject_cast<ZTableModel*>(model);
    if(!zModel)
        ZblException("Error: ZTableModel object required!");

    ZBL_SLOT_END_RETURN(getTableModel(zModel),  false,
    Z_FAC_JS, ZsqlQuery::populateTableModel, populateTableModel failed)
}

ZsqlQuery::zMetaRow ZsqlQuery::getMetaRow() const
{
    validateQuery();

    zMetaRow metaRow;

    QSqlRecord rec(m_q->record());

    int fieldCount = rec.count();

    for(int i=0; i<fieldCount; i++)
        metaRow.append(rec.fieldName(i));

    return metaRow;
}

QVariant ZsqlQuery::getJsMetaRow() const
{
    //QJSValue jsRow;

    ZBL_SLOT_BEGIN_TRY
        #if 0
    zMetaRow metaRow = getMetaRow();

    const int colCount = metaRow.size();

    jsRow = m_zApp->engine().newArray(colCount);

    for(int i = 0; i<colCount; i++)
        jsRow.setProperty(i, QJSValue(metaRow[i]));

    ZBL_SLOT_END_RETURN(jsRow,  QJSValue(),
    Z_FAC_JS, ZsqlQuery::getJsMetaRow, getJsMetaRow failed)
        #else

    QVariantList jsRow;

    zMetaRow metaRow = getMetaRow();

    const int colCount = metaRow.size();

    for(int i = 0; i<colCount; i++)
        jsRow.append(QVariant(metaRow[i]));

            ZBL_SLOT_END_RETURN(QVariant::fromValue(jsRow),  QVariant(),
            Z_FAC_JS, ZsqlQuery::getJsMetaRow, getJsMetaRow failed)

        #endif
}


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

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

        return NULL;
    }

    return error;
}

bool ZsqlQuery::isSelect() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->isSelect(),  false,
    Z_FAC_JS, ZsqlQuery::isSelect, isSelect failed)
}

int ZsqlQuery::size() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->size(),  -1,
    Z_FAC_JS, ZsqlQuery::size, size failed)
}

void ZsqlQuery::setNumericalPrecisionPolicy(int policy)
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    switch(policy)
    {

    case ZsqlDatabase::LowPrecisionInt32:
    case ZsqlDatabase::LowPrecisionInt64:
    case ZsqlDatabase::LowPrecisionDouble:
    case ZsqlDatabase::HighPrecision:

        m_q->setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy(policy));
        break;

        default:

            throw ZblException(QString("Invalid NumericalPrecisionPolicy value: %1")
                               .arg(policy));
    }
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlDatabase::setNumericalPrecisionPolicy,
                      setNumericalPrecisionPolicy failed)


}

int ZsqlQuery::getNumericalPrecisionPolicy() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->numericalPrecisionPolicy(),  -1,
    Z_FAC_JS, ZsqlQuery::getNumericalPrecisionPolicy, getNumericalPrecisionPolicy failed)
}

QVariant ZsqlQuery::getBoundValues() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(QVariant::fromValue(m_q->boundValues()),  QVariant(),
    Z_FAC_JS, ZsqlQuery::getBoundValues, getBoundValues failed)
}

QString ZsqlQuery::getExecutedQuery() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->executedQuery(),  QString(),
    Z_FAC_JS, ZsqlQuery::getExecutedQuery, getExecutedQuery failed)
}

QVariant ZsqlQuery::getLastInsertId() const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->lastInsertId(),  QVariant(),
    Z_FAC_JS, ZsqlQuery::getLastInsertId, getLastInsertId failed)
}

QVariant ZsqlQuery::value(int i) const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->value(i),  QVariant(),
    Z_FAC_JS, ZsqlQuery::value, value failed)
}


bool ZsqlQuery::seek(int i, bool relative)
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->seek(i, relative),  false,
    Z_FAC_JS, ZsqlQuery::seek, seek failed)
}

bool ZsqlQuery::next()
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->next(),  false,
    Z_FAC_JS, ZsqlQuery::next, next failed)
}

bool ZsqlQuery::previous()
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->previous(),  false,
    Z_FAC_JS, ZsqlQuery::previous, previous failed)
}

bool ZsqlQuery::first()
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->first(),  false,
    Z_FAC_JS, ZsqlQuery::first, first failed)
}

bool ZsqlQuery::last()
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->last(),  false,
    Z_FAC_JS, ZsqlQuery::last, last failed)
}

void ZsqlQuery::clear()
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    if(m_q)
        m_q->clear();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlQuery::clear, clear failed)
}

void ZsqlQuery::finish()
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    m_q->finish();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlQuery::finish, finish failed)

}

bool ZsqlQuery::nextResult()
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->nextResult(),  false,
    Z_FAC_JS, ZsqlQuery::nextResult, nextResult failed)
}

QVariant ZsqlQuery::boundValue(int pos) const
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ZBL_SLOT_END_RETURN(m_q->boundValue(pos),  QVariant(),
    Z_FAC_JS, ZsqlQuery::boundValue, boundValue failed)
}

bool ZsqlQuery::execBatch(int mode)
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    if(mode != QSqlQuery::ValuesAsRows
        && mode != QSqlQuery::ValuesAsColumns
        )
    {
        throw ZblException(QString("ERROR: invalid mode: %1 is not a "
       "QSqlQuery::BatchExecutionMode value!").arg(mode));
    }
    ZBL_SLOT_END_RETURN(m_q->execBatch(QSqlQuery::BatchExecutionMode(mode)),  false,
    Z_FAC_JS, ZsqlQuery::execBatch, execBatch failed)
}

void ZsqlQuery::bindValue(int pos, const QVariant& val, ZsqlQuery::ParamType type)
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ensureParamType(type);
    m_q->bindValue(pos, val, QSql::ParamType(type));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlQuery::bindValue, bindValue failed)
}

void ZsqlQuery::addBindValue(const QVariant& val, ZsqlQuery::ParamType type)
{
    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    ensureParamType(type);
    m_q->addBindValue(val, QSql::ParamType(type));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlQuery::addBindValue, addBindValue failed)
}

QObject* ZsqlQuery::record()
{

    ZsqlRecord* r = NULL;

    ZBL_SLOT_BEGIN_TRY
    validateQuery();
    r = new ZsqlRecord();
    r->m_r = m_q->record();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZsqlQuery::record, record failed)

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

    return r;
}



} // Zbl