mythdbcon.h

Go to the documentation of this file.

#ifndef MYTHDBCON_H_
#define MYTHDBCON_H_
 
#include <QSqlDatabase>
#include <QSqlRecord>
#include <QSqlError>
#include <QVariant>
#include <QSqlQuery>
#include <QDateTime>
#include <QMutex>
#include <QList>
 
#include "mythbaseexp.h"
#include "mythdbparams.h"
 
#define REUSE_CONNECTION 1 // NOLINT(cppcoreguidelines-macro-usage)
 
MBASE_PUBLIC bool TestDatabase(const QString& dbHostName,
                               const QString& dbUserName,
                               QString dbPassword,
                               QString dbName = "mythconverg",
                               int     dbPort = 3306);
 
class MSqlDatabase
{
  friend class MDBManager;
  friend class MSqlQuery;
  public:
    explicit MSqlDatabase(QString name, QString driver = "QMYSQL");
   ~MSqlDatabase(void);
 
    bool OpenDatabase(bool skipdb = false);
    void SetDBParams(const DatabaseParams &params) { m_dbparms = params; };
 
  private:
    Q_DISABLE_COPY_MOVE(MSqlDatabase)
    bool isOpen(void);
    bool KickDatabase(void);
    QString GetConnectionName(void) const { return m_name; }
    QSqlDatabase db(void) const { return m_db; }
    bool Reconnect(void);
    void InitSessionVars(void);
 
  private:
    QString m_name;
    QString m_driver;
    QSqlDatabase m_db;
    QDateTime m_lastDBKick;
    DatabaseParams m_dbparms;
};
 
class MBASE_PUBLIC MDBManager
{
  friend class MSqlQuery;
  public:
    MDBManager(void) = default;
    ~MDBManager(void);
 
    void CloseDatabases(void);
    void PurgeIdleConnections(bool leaveOne = false);
 
  protected:
    MSqlDatabase *popConnection(bool reuse);
    void pushConnection(MSqlDatabase *db);
 
    MSqlDatabase *getSchedCon(void);
    MSqlDatabase *getChannelCon(void);
 
  private:
    Q_DISABLE_COPY_MOVE(MDBManager)
    MSqlDatabase *getStaticCon(MSqlDatabase **dbcon, const QString& name);
 
    QMutex m_lock;
    using DBList = QList<MSqlDatabase*>;
    QHash<QThread*, DBList> m_pool; // protected by m_lock
#if REUSE_CONNECTION
    QHash<QThread*, MSqlDatabase*> m_inuse; // protected by m_lock
    QHash<QThread*, int> m_inuseCount; // protected by m_lock
#endif
 
    int m_nextConnID         {0};
    int m_connCount          {0};
 
    MSqlDatabase *m_schedCon {nullptr};
    MSqlDatabase *m_channelCon {nullptr};
    QHash<QThread*, DBList> m_staticPool;
};
 
struct MSqlQueryInfo
{
    MSqlDatabase *db      {nullptr};
    QSqlDatabase qsqldb;
    bool returnConnection {false};
};
 
using MSqlBindings = QMap<QString, QVariant>;
 
 MBASE_PUBLIC  void MSqlAddMoreBindings(MSqlBindings &output, MSqlBindings &addfrom);
 
 MBASE_PUBLIC  void MSqlEscapeAsAQuery(QString &query, const MSqlBindings &bindings);
 
class MBASE_PUBLIC MSqlQuery : private QSqlQuery
{
    MBASE_PUBLIC friend void MSqlEscapeAsAQuery(QString& query, MSqlBindings& bindings);
  public:
    explicit MSqlQuery(const MSqlQueryInfo &qi);
    ~MSqlQuery();
 
    bool isConnected(void) const { return m_isConnected; }
 
    bool exec(void);
 
    bool next(void);
 
    bool previous(void);
 
    bool first(void);
 
    bool last(void);
 
    //         so we can display the query results
    bool seek(int where, bool relative = false);
 
    bool exec(const QString &query);
 
    bool prepare(const QString &query);
 
    void bindValue(const QString &placeholder, const QVariant &val);
 
    void bindValueNoNull(const QString &placeholder, const QVariant &val);
 
    void bindValues(const MSqlBindings &bindings);
 
    QVariant lastInsertId();
 
    bool Reconnect(void);
 
    bool lostConnectionCheck(void);
 
    // Thunks that allow us to make QSqlQuery private
    QVariant value(int i) const { return QSqlQuery::value(i); }
    QString executedQuery(void) const { return QSqlQuery::executedQuery(); }
 
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
    QMap<QString, QVariant> boundValues(void) const
        { return QSqlQuery::boundValues(); }
#else
    QVariantList boundValues(void) const { return QSqlQuery::boundValues(); }
#endif
    QSqlError lastError(void) const { return QSqlQuery::lastError(); }
    int size(void) const { return QSqlQuery::size();}
    bool isActive(void) const { return  QSqlQuery::isActive(); }
    QSqlRecord record(void) const { return QSqlQuery::record(); }
    int numRowsAffected() const { return QSqlQuery::numRowsAffected(); }
    void setForwardOnly(bool f) { QSqlQuery::setForwardOnly(f); }
    bool isNull(int field) const { return QSqlQuery::isNull(field); }
    const QSqlDriver *driver(void) const { return QSqlQuery::driver(); }
    int at(void) const { return QSqlQuery::at(); }
 
    static bool testDBConnection();
 
    enum ConnectionReuse : std::uint8_t
    {
        kDedicatedConnection,
        kNormalConnection,
    };
    static MSqlQueryInfo InitCon(ConnectionReuse _reuse = kNormalConnection);
 
    static MSqlQueryInfo SchedCon();
 
    static MSqlQueryInfo ChannelCon();
 
  private:
    Q_DISABLE_COPY_MOVE(MSqlQuery)
 
    // Only QSql::In is supported as a param type and only named params...
    void bindValue(const QString&, const QVariant&, QSql::ParamType);
    void bindValue(int, const QVariant&, QSql::ParamType);
    void addBindValue(const QVariant&, QSql::ParamType = QSql::In);
 
    bool seekDebug(const char *type, bool result,
                   int where, bool relative) const;
 
    MSqlDatabase *m_db               {nullptr};
    bool          m_isConnected      {false};
    bool          m_returnConnection {false};
    QString       m_lastPreparedQuery; // holds a copy of the last prepared query
};
 
#endif