EasyQtSql_Transaction.h

Go to the documentation of this file.

#ifndef EASYQTSQL_TRANSACTION_H
#define EASYQTSQL_TRANSACTION_H

/*
 * The MIT License (MIT)
 * Copyright 2018 Alexey Kramin
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
*/

#ifndef EASY_QT_SQL_MAIN

#include <QtSql>
#include "EasyQtSql_DBException.h"
#include "EasyQtSql_NonQueryResult.h"
#include "EasyQtSql_InsertQuery.h"
#include "EasyQtSql_DeleteQuery.h"
#include "EasyQtSql_UpdateQuery.h"
#include "EasyQtSql_PreparedQuery.h"

#endif

#include "EasyQtSql_Util.h"

class Database
{
   Q_DISABLE_COPY(Database)

public:

   explicit Database (const QSqlDatabase &db = QSqlDatabase())
   {
      m_db = db.isValid() ? db : QSqlDatabase::database();

      if (!m_db.isOpen())
      {
         if (!m_db.open())
         {
            #ifdef DB_EXCEPTIONS_ENABLED
            throw DBException(m_db);
            #endif
         }
      }
   }

   Database(Database&& other)
   {
      m_db = other.m_db;
      other.m_db = QSqlDatabase();
   }

   Database& operator=(Database&& other)
   {
      if (this == &other) return *this;

      m_db = other.m_db;
      other.m_db = QSqlDatabase();

      return *this;
   }

   QSqlError lastError() const
   {
      return m_db.lastError();
   }

   NonQueryResult execNonQuery(const QString &sql) const
   {
      QSqlQuery q = m_db.exec(sql);

#ifdef DB_EXCEPTIONS_ENABLED

      QSqlError lastError = q.lastError();

      if (lastError.isValid())
         throw DBException(q);

#endif

      return NonQueryResult(q);
   }

   QueryResult execQuery(const QString &sql) const
   {
      QSqlQuery q = m_db.exec(sql);

#ifdef DB_EXCEPTIONS_ENABLED

      QSqlError lastError = q.lastError();

      if (lastError.isValid())
         throw DBException(q);

#endif

      return QueryResult(q);
   }

   InsertQuery insertInto(const QString &table) const
   {
      InsertQuery query(table, m_db);

      return query;
   }

   DeleteQuery deleteFrom(const QString &table) const
   {
      DeleteQuery query(table, m_db);

      return query;
   }

   UpdateQuery update(const QString &table) const
   {
      UpdateQuery query(table, m_db);

      return query;
   }

   PreparedQuery prepare(const QString &sql, bool forwardOnly = true) const
   {
      PreparedQuery query(sql, m_db, forwardOnly);

      return query;
   }

   QSqlDatabase &qSqlDatabase()
   {
      return m_db;
   }

   template<typename Func>
   int each (const QString &query, Func&& f) const
   {
      QueryResult res = execQuery(query);

      return Util::each(res, f);
   }

   template<typename Func>
   int first (const QString &query, Func&& f) const
   {
      QueryResult res = execQuery(query);

      return Util::first(res, f);
   }

   template<typename Func>
   int range(const QString &query, int start, int count, Func&& f) const
   {
      QueryResult res = execQuery(query);

      return Util::range(res, start, count, f);
   }

   template<typename Func>
   int top(const QString &query, int topCount, Func&& f) const
   {
      QueryResult res = execQuery(query);

      return Util::top(res, topCount, f);
   }

   template<typename T>
   T scalar(const QString &query) const
   {
      QueryResult res = execQuery(query);

      res.next();

      return res.scalar<T>();
   }

   QVariant scalar(const QString &query) const
   {
      QueryResult res = execQuery(query);

      res.next();

      return res.scalar();
   }

protected:
   QSqlDatabase m_db;
};


class  Transaction : public Database
{
   Q_DISABLE_COPY(Transaction)

public:

   explicit Transaction (const QSqlDatabase &db = QSqlDatabase())
     : Database(db)
     , m_commited(false)
     , m_started(false)
   {      
      m_started = m_db.transaction();

      #ifdef DB_EXCEPTIONS_ENABLED
      if (!m_started)
      {
         throw DBException(m_db);
      }
      #endif
   }

   Transaction (Transaction&& other)
      : Database(std::move(other))
   {
      m_commited = other.m_commited;
      m_started  = other.m_started;

      other.m_commited = false;
      other.m_started  = false;
   }

   Transaction& operator=(Transaction&& other)
   {
      m_started  = other.m_started;
      m_commited = other.m_commited;

      other.m_commited = false;
      other.m_started  = false;

      return static_cast<Transaction&>(Database::operator=(std::move(other)));
   }

   ~Transaction()
   {
      if (m_db.isValid() && !m_commited)
      {
         m_db.rollback();
      }
   }

   bool commit()
   {
      if (m_db.isValid() && !m_commited)
      {
         m_commited = m_db.commit();

#ifdef DB_EXCEPTIONS_ENABLED

         if (!m_commited)
            throw DBException(m_db);

#endif

      }

      return m_commited;
   }

   bool rollback()
   {
      bool res = false;

      if (m_db.isValid() && !m_commited)
      {
         res = m_db.rollback();

         m_commited = false;
      }

      return res;
   }

   bool started() const
   {
      return m_started;
   }

   bool commited() const
   {
      return m_commited;
   }

private:   
   bool m_commited = false;
   bool m_started = false;   
};

#endif // EASYQTSQL_TRANSACTION_H