src/flbase/aqsobjects/AQObjects.h

Ir a la documentación de este archivo.

/***************************************************************************
 AQObjects.h
 -------------------
 begin                : 09/02/2011
 copyright            : (C) 2003-2011 by InfoSiAL S.L.
 email                : mail@infosial.com
 ***************************************************************************/
/***************************************************************************
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; version 2 of the License.               *
 ***************************************************************************/
/***************************************************************************
 Este  programa es software libre. Puede redistribuirlo y/o modificarlo
 bajo  los  términos  de  la  Licencia  Pública General de GNU   en  su
 versión 2, publicada  por  la  Free  Software Foundation.
 ***************************************************************************/

#ifndef AQOBJECTS_H_
#define AQOBJECTS_H_

#include "AQS_p.h"
#include "AQPackager.h"
#include "AQCompilerQSA.h"
#include "AQZipReader.h"
#include "AQZipWriter.h"
#include "AQOds.h"

#include "FLSqlDatabase.h"
#include "FLManager.h"
#include "FLManagerModules.h"
#include "FLRelationMetaData.h"
#include "FLFieldMetaData.h"
#include "FLTableMetaData.h"
#include "FLAction.h"
#include "FLSqlCursor.h"
#include "FLSqlQuery.h"
#include "FLSettings.h"
#include "FLVar.h"
#include "FLReportEngine.h"
#include "FLReportViewer.h"
#include "FLJasperEngine.h"
#include "FLSqlConnections.h"

class AQJasperEngine : public FLJasperEngine
{
  Q_OBJECT

public:
  AQJasperEngine(QObject *parent = 0) : FLJasperEngine(parent) {}
};

class AQReportViewer : public FLReportViewer
{
  Q_OBJECT

public:
  AQReportViewer(QWidget *parent = 0,
                 const char *name = 0,
                 bool embedInParent = false,
                 FLReportEngine *rptEngine = 0) :
    FLReportViewer(parent, name, embedInParent, rptEngine) {}
};

class AQReportEngine : public FLReportEngine
{
  Q_OBJECT

public:
  AQReportEngine(QObject *parent = 0) : FLReportEngine(parent) {}
};

class AQVar : public FLVar
{
public:
  AQVar() : FLVar() {}
};

class AQSettings : public FLSettings
{
public:
  AQSettings() : FLSettings() {}
};

class AQSqlDatabase : public FLSqlDatabase
{
public:
  AQSqlDatabase() : FLSqlDatabase() {}
};

class AQManager : public FLManager
{
public:
  AQManager() : FLManager() {}
};

class AQManagerModules : public FLManagerModules
{
public:
  AQManagerModules() : FLManagerModules() {}
};

class AQActionMD: public FLAction
{
public:
  AQActionMD() : FLAction() {}
};

class AQRelationMD : public FLRelationMetaData
{
public:
  AQRelationMD(const QString &fT, const QString &fF, int rC,
               bool dC = false, bool uC = false, bool cI = true) :
    FLRelationMetaData(fT, fF, rC, dC, uC, cI) {}
};

class AQFieldMD : public FLFieldMetaData
{
public:
  AQFieldMD(const QString &n, const QString &a, bool aN, bool iPK, int t,
            int l = 0, bool c = false, bool v = true, bool ed = false,
            int pI = 4, int pD = 0, bool iNX = false, bool uNI = false,
            bool coun = false, const QVariant &defValue = QVariant(), bool oT = false,
            const QString &rX = QString::null, bool vG = true, bool gen = true, bool iCK = false) :
    FLFieldMetaData(n, a, aN, iPK, t,
                    l, c, v, ed,
                    pI, pD, iNX, uNI,
                    coun, defValue, oT,
                    rX, vG, gen, iCK) {}
};

class AQTableMD : public FLTableMetaData
{
public:
  AQTableMD(const QString &n, const QString &a, const QString &q = QString::null) :
    FLTableMetaData(n, a, q) {}
};

class AQSqlCursor : public FLSqlCursor
{
public:
  AQSqlCursor(const QString &name = QString::null, bool autopopulate = true,
              const QString &connectionName = "default", FLSqlCursor *cR = 0,
              FLRelationMetaData *r = 0, QObject *parent = 0) :
    FLSqlCursor(name, autopopulate, connectionName, cR, r, parent) {}

  AQSqlCursor(const QString &name, bool autopopulate, QSqlDatabase *db, FLSqlCursor *cR = 0,
              FLRelationMetaData *r = 0, QObject *parent = 0) :
    FLSqlCursor(name, autopopulate, db, cR, r, parent) {}

  AQSqlCursor(const QString &name, QObject *parent,
              const QString &connectionName = "default") :
    FLSqlCursor(name, true, connectionName, 0, 0, parent) {}

  AQSqlCursor(const QString &name, const QString &connectionName) :
    FLSqlCursor(name, true, connectionName) {}
};

class AQSqlQuery : public FLSqlQuery
{
public:
  AQSqlQuery(QObject *parent = 0, const QString &connectionName = "default") :
    FLSqlQuery(parent, connectionName) {}
};

class AQSql : public QObject
{
  Q_OBJECT

  Q_ENUMS(ModeAccess)
  Q_ENUMS(ConnOptions)
  Q_ENUMS(SpecialType)
  Q_ENUMS(Cardinality)
  Q_ENUMS(TableType)
  Q_ENUMS(SqlErrorType)

public:
  enum ModeAccess {
    Insert = 0,
    Edit = 1,
    Del = 2,
    Browse = 3
  };

  enum ConnOptions {
    User = 0,
    Password = 1,
    Port = 2,
    Host = 3
  };

  enum SpecialType {
    Serial = 100,
    Unlock = 200,
    Check = 300
  };

  enum Cardinality {
    RELATION_1M = 0,
    RELATION_M1 = 1
  };

  enum TableType {
    Tables = 0x01,
    SystemTables = 0x02,
    Views = 0x04,
    AllTables = 0xff
  };

  enum SqlErrorType {
    SqlErrorNone,
    SqlErrorConnection,
    SqlErrorStatement,
    SqlErrorTransaction,
    SqlErrorUnknown
  };

  AQSql() : QObject(0, "aqs_aqsql") {}

public slots:
  bool addDatabase(const QString &driverAlias, const QString &nameDB, const QString &user,
                   const QString &password, const QString &host, int port,
                   const QString &connectionName) {
    return FLSqlConnections::addDatabase(driverAlias, nameDB, user, password, host, port, connectionName);
  }

  bool addDatabase(FLSqlDatabase *db, const QString &connectionName = "default") {
    return FLSqlConnections::addDatabase(db, connectionName);
  }

  bool addDatabase(const QString &newConnName, const QString &sourceConnName = "default") {
    FLSqlDatabase *srcDb = FLSqlConnections::database(sourceConnName);
    if (!srcDb)
      return false;
    return FLSqlConnections::addDatabase(srcDb->driverName(), srcDb->database(),
                                         srcDb->user(), srcDb->password(), srcDb->host(),
                                         srcDb->port(), newConnName);
  }

  bool removeDatabase(const QString &connectionName) {
    return FLSqlConnections::removeDatabase(connectionName);
  }

  FLSqlDatabase *database(const QString &connectionName = "default") {
    return FLSqlConnections::database(connectionName);
  }

  void finish() {
    FLSqlConnections::finish();
  }

  bool insert(FLSqlCursor *cur, const QStringList &fields,
              const QValueList<QVariant> &values) {
    if (!cur) {
      if (cur->lastError().type() != QSqlError::None) {
        globalAQSInterpreter->throwError(cur->lastError().driverText() + ":" +
                                         cur->lastError().databaseText());
      }
      return false;
    }

    int fieldsCount = fields.size();
    int valuesCount = values.size();

    cur->setModeAccess(Insert);
    cur->refreshBuffer();
    for (int i = 0; i < fieldsCount; ++i)
      cur->setValueBuffer(fields[i], (i < valuesCount ? values[i] : QVariant()));

    bool ok = cur->commitBuffer();
    if (!ok && cur->lastError().type() != QSqlError::None) {
      globalAQSInterpreter->throwError(cur->lastError().driverText() + ":" +
                                       cur->lastError().databaseText());
    }
    return ok;
  }

  bool insert(const QString &table, const QStringList &fields,
              const QValueList<QVariant> &values, const QString &connName = "default") {
    AQSqlCursor cur(table, true, connName);
    return insert(&cur, fields, values);
  }

  bool update(FLSqlCursor *cur, const QStringList &fields,
              const QValueList<QVariant> &values, const QString &where = "") {
    if (!cur || !cur->select(where)) {
      if (cur->lastError().type() != QSqlError::None) {
        globalAQSInterpreter->throwError(cur->lastError().driverText() + ":" +
                                         cur->lastError().databaseText());
      }
      return false;
    }

    int fieldsCount = fields.size();
    int valuesCount = values.size();

    while (cur->next()) {
      cur->setModeAccess(Edit);
      cur->refreshBuffer();
      for (int i = 0; i < fieldsCount; ++i)
        cur->setValueBuffer(fields[i], (i < valuesCount ? values[i] : QVariant()));
      if (!cur->commitBuffer()) {
        if (cur->lastError().type() != QSqlError::None) {
          globalAQSInterpreter->throwError(cur->lastError().driverText() + ":" +
                                           cur->lastError().databaseText());
        }
        return false;
      }
    }
    return true;
  }

  bool update(const QString &table, const QStringList &fields,
              const QValueList<QVariant> &values, const QString &where = "",
              const QString &connName = "default") {
    AQSqlCursor cur(table, true, connName);
    cur.setForwardOnly(true);
    return update(&cur, fields, values, where);
  }

  bool del(FLSqlCursor *cur, const QString &where = "") {
    if (!cur || !cur->select(where)) {
      if (cur->lastError().type() != QSqlError::None) {
        globalAQSInterpreter->throwError(cur->lastError().driverText() + ":" +
                                         cur->lastError().databaseText());
      }
      return false;
    }

    while (cur->next()) {
      cur->setModeAccess(Del);
      cur->refreshBuffer();
      if (!cur->commitBuffer()) {
        if (cur->lastError().type() != QSqlError::None) {
          globalAQSInterpreter->throwError(cur->lastError().driverText() + ":" +
                                           cur->lastError().databaseText());
        }
        return false;
      }
    }
    return true;
  }

  bool del(const QString &table, const QString &where = "",
           const QString &connName = "default") {
    AQSqlCursor cur(table, true, connName);
    cur.setForwardOnly(true);
    return del(&cur, where);
  }

  QValueList<QVariant> select(const QString &select,
                              const QString &from,
                              const QString &where = QString::null,
                              const QString &orderBy = QString::null,
                              const QString &connName = "default") {
    AQSqlQuery qry(0, connName);
    qry.setTablesList(from);
    qry.setSelect(select);
    qry.setFrom(from);
    qry.setWhere(where);
    qry.setOrderBy(orderBy);
    qry.setForwardOnly(true);
    if (!qry.exec()) {
      if (qry.lastError().type() != QSqlError::None) {
        globalAQSInterpreter->throwError(qry.lastError().driverText() + ":" +
                                         qry.lastError().databaseText());
      }
      return QVariantList();
    }

    QVariantList ret;
    int countFields = qry.fieldList().count();

    ret.append(qry.size());
    ret.append(countFields);
    ret.append(qry.fieldList());

    while (qry.next()) {
      for (int i = 0; i < countFields; ++i)
        ret.append(qry.value(i));
    }

    return ret;
  }

  QValueList<QVariant> selectForUpdate(const QString &select,
                                       const QString &from,
                                       const QString &where = QString::null,
                                       bool nowait = false,
                                       const QString &connName = "default") {
    AQSqlQuery qry(0, connName);
    qry.setTablesList(from);
    qry.setSelect(select);
    qry.setFrom(from);
    QString w(where.isEmpty() ? "1=1" : w);
    qry.setWhere(nowait ?
                 w + QString::fromLatin1(" FOR UPDATE NOWAIT") :
                 w + QString::fromLatin1(" FOR UPDATE"));
    qry.setForwardOnly(true);
    if (!qry.exec()) {
      if (qry.lastError().type() != QSqlError::None) {
        globalAQSInterpreter->throwError(qry.lastError().driverText() + ":" +
                                         qry.lastError().databaseText());
      }
      return QVariantList();
    }

    QVariantList ret;
    int countFields = qry.fieldList().count();

    ret.append(qry.size());
    ret.append(countFields);
    ret.append(qry.fieldList());

    while (qry.next()) {
      for (int i = 0; i < countFields; ++i)
        ret.append(qry.value(i));
    }

    return ret;
  }
};

#include "FLFieldDB.h"
#include "FLTableDB.h"
#include "FLDataTable.h"

class AQFieldDB : public FLFieldDB
{
public:
  AQFieldDB(QWidget *parent = 0, const char *name = 0) :
    FLFieldDB(parent, name) {}
};

class AQTableDB : public FLTableDB
{
public:
  AQTableDB(QWidget *parent = 0, const char *name = 0) :
    FLTableDB(parent, name) {}
};

class AQDataTableDB : public FLDataTable
{
public:
  AQDataTableDB(QWidget *parent = 0, const char *name = 0, bool popup = false) :
    FLDataTable(parent, name, popup) {}
};

#include "FLDigiDoc.h"

class AQDigiDoc : public FLDigiDoc
{
public:
  AQDigiDoc(const QString &configfile = QString::null) :
    FLDigiDoc(configfile) {}
};

#include "FLFormDB.h"
#include "FLFormRecordDB.h"
#include "FLFormSearchDB.h"

class AQFormDB : public FLFormDB
{
public:
  explicit AQFormDB(QWidget *parent = 0, const char *name = 0, WFlags f = 0) :
    FLFormDB(parent, name, f) {}

  AQFormDB(const QString &actionName, QWidget *parent = 0, WFlags f = 0) :
    FLFormDB(actionName, parent, f) {}

  AQFormDB(FLSqlCursor *cursor, const QString &actionName = QString::null,
           QWidget *parent = 0, WFlags f = 0) :
    FLFormDB(cursor, actionName, parent, f) {}
};


class AQFormRecordDB : public FLFormRecordDB
{
public:
  AQFormRecordDB(FLSqlCursor *cursor, const QString &actionName = QString::null,
                 QWidget *parent = 0, bool showAcceptContinue = true):
    FLFormRecordDB(cursor, actionName, parent) {}
};

class AQFormSearchDB : public FLFormSearchDB
{
public:
  AQFormSearchDB(const QString &actionName, QWidget *parent = 0) :
    FLFormSearchDB(actionName, parent) {}

  AQFormSearchDB(FLSqlCursor *cursor, const QString &actionName = QString::null,
                 QWidget *parent = 0) :
    FLFormSearchDB(cursor, actionName, parent) {}
};

#endif /* AQOBJECTS_H_ */