ZsqlQuery.h

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * ZsqlQuery.h
 *
 * 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
 *
 */

#ifndef ZSQLQUERY_H
#define ZSQLQUERY_H

#include <QObject>
#include <QSqlQuery>
#include <QMap>
#include <QVariant>
#include "zblcore_global.h"
#include "ZblException.h"
//#include "ZblScriptOb.h"

namespace Zbl
{

class ZsqlDatabase;
class ZTableModel;


class ZBLCORESHARED_EXPORT ZsqlQuery : public QObject
{
    Q_OBJECT
public:
    typedef QList<QString> zMetaRow;

    Q_ENUMS(BatchExecutionMode)

    enum BatchExecutionMode
    {
        ValuesAsRows = QSqlQuery::ValuesAsRows,
        ValuesAsColumns = QSqlQuery::ValuesAsColumns
    };

    Q_ENUMS(ParamType)

    enum ParamType
    {
        In = QSql::In,
        Out = QSql::Out,
        InOut = QSql::InOut,
        Binary = QSql::Binary
    };

    Q_ENUMS(ResultType)

    enum ResultType
    {
        StringSequence = 0,
        TableModel

    };


    explicit ZsqlQuery(QSqlQuery* query, QObject *parent = 0);

    virtual ~ZsqlQuery();


    QSqlQuery& queryObject() const;

    bool getTableModel(ZTableModel* model);

    QVariant getTags();

     Q_PROPERTY(QVariant tags READ getTags)

    
     Q_PROPERTY(bool isValid READ isValid)

     Q_PROPERTY(bool isActive READ isActive)

     Q_PROPERTY(bool forewardOnly READ isForwardOnly WRITE setForwardOnly)

     Q_PROPERTY(int position READ getPosition)

     Q_PROPERTY(QString lastQuery READ lastQuery)

     Q_PROPERTY(int numRowsAffected READ numRowsAffected)

     Q_PROPERTY(QObject* lastError READ getLastError)

     Q_PROPERTY(bool isSelect READ isSelect)

     Q_PROPERTY(int size READ size)

     Q_PROPERTY(int numericalPrecisionPolicy READ getNumericalPrecisionPolicy
                WRITE setNumericalPrecisionPolicy)

     Q_PROPERTY(QVariant boundValues READ getBoundValues)

     Q_PROPERTY(QString executedQuery READ getExecutedQuery)

     Q_PROPERTY(QVariant lastInsertId READ getLastInsertId)

     Q_PROPERTY(QVariant metaRow READ getJsMetaRow)


    // property methods

    bool isValid() const;
    bool isActive() const;
    bool isForwardOnly() const;
    void setForwardOnly(bool forward);
    int getPosition() const;
    QString lastQuery() const;
    int numRowsAffected() const;
    QObject* getLastError();
    bool isSelect() const;
    int size() const;
    void setNumericalPrecisionPolicy(int policy);
    int getNumericalPrecisionPolicy() const;
    QVariant getBoundValues() const;
    QString getExecutedQuery() const;
    QVariant getLastInsertId() const;
    zMetaRow getMetaRow() const;
    QVariant getJsMetaRow() const;


    static ZsqlQuery* newQuery(ZsqlDatabase& database);

    Q_INVOKABLE void release();


    Q_INVOKABLE void bindValue(
            const QString& placeholder,
            const QVariant& value,
            int paramType);

    Q_INVOKABLE QVariant boundValue(const QString& placeholder) const;

    Q_INVOKABLE QVariant value(const QString& name) const;

    Q_INVOKABLE bool isNull(int field) const;

    Q_INVOKABLE bool exec();

    Q_INVOKABLE bool prepare(const QString& query);

    //Q_INVOKABLE bool exec(
    //      const QString& query,
    //      ZsqlQuery::ResultType resultType = ZsqlQuery::StringSequence,
    //      QObject* tableModel = NULL);
    Q_INVOKABLE bool exec(
          const QString& query,
          int resultType,
          QObject* tableModel);

    Q_INVOKABLE QVariant value(int i) const;

    Q_INVOKABLE bool seek(int i, bool relative = false);

    Q_INVOKABLE bool next();

    Q_INVOKABLE bool previous();

    Q_INVOKABLE bool first();

    Q_INVOKABLE bool last();

    Q_INVOKABLE void clear();

    Q_INVOKABLE void finish();

    Q_INVOKABLE bool nextResult();



    Q_INVOKABLE QObject* record();


    Q_INVOKABLE bool populateTableModel(QObject* model);


    // Begin - Binding and prepared queries methods
    // WARNING: untested!


    Q_INVOKABLE QVariant boundValue(int pos) const;


    Q_INVOKABLE bool execBatch(int mode = ValuesAsRows);


    Q_INVOKABLE void bindValue(int pos, const QVariant& val, ParamType type = In);

    Q_INVOKABLE void addBindValue(const QVariant& val, ZsqlQuery::ParamType = In);


    // End - Binding and prepared queries




/****** Not wrapped ***********
* const QSqlDriver* driver() const;
* const QSqlResult* result() const;
* //QSqlRecord record() const;
******************************/

signals:

    void queryResult(QObject* qResult); // experiment!


public slots:

protected:

    void initGetTableModel();

    inline void validateQuery() const;

    void createTags();

    void ensureParamType(int paramType);

    QSqlQuery* m_q;
    //ZqSqlQueryPtr m_q;

    //ZPlaceMap m_values;

    static QVariant m_tags;


};

inline void ZsqlQuery::validateQuery() const
{
    if(!m_q)
        throw ZblException(
         "Error: ZsqlQuery's embedded QSqlQuery object has already "
                "been released.");
}

inline QSqlQuery& ZsqlQuery::queryObject() const
{
    validateQuery();
    return *m_q;
}


} // Zbl

Q_DECLARE_METATYPE(Zbl::ZsqlQuery::ResultType)


#endif // ZSQLQUERY_H