Transaction.h

/* Copyright (C) 2006-2026 by Tommi Maekitalo
   Copyright (C) 2006-2026 by Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_DB_TRANSACTION_H
#define PT_DB_TRANSACTION_H
 
#include <Pt/Db/Api.h>
#include <Pt/Db/Connection.h>
#include <Pt/NonCopyable.h>
#include <Pt/Signal.h>
 
namespace Pt {
 
namespace Db {

class Transaction : private NonCopyable
{
    private:
        Connection&  _connection;
        bool         _active;
        Pt::Signal<> _startFinished;
        Pt::Signal<> _commitFinished;
        Pt::Signal<> _rollbackFinished;
 
    public:
        Transaction(Connection& conn, bool starttransaction = true)
        : _connection(conn)
        , _active(false)
        {
            if (starttransaction)
            {
                begin();
            }
        }

        ~Transaction()
        {
            if (_active)
            {
                try
                {
                    rollback();
                }
                catch (const std::exception&)
                {
                }
            }
        }

        const Connection& getConnection() const
        { return _connection; }

        void begin()
        {
            if (_active)
                rollback();
            _connection.startTransaction(onGetBeginSql());
            _active = true;
        }

        void commit()
        {
            if (_active)
            {
                _connection.commitTransaction(onGetCommitSql());
                _active = false;
            }
        }

        void rollback()
        {
            if (_active)
            {
                _connection.rollbackTransaction(onGetRollbackSql());
                _active = false;
            }
        }

        void beginStart()
        {
            if(_active)
                rollback();
            _connection.beginStartTransaction(*this, onGetBeginSql());
        }

        void endStart()
        {
            _connection.endStartTransaction();
            _active = true;
        }

        Pt::Signal<>& startFinished()
        { return _startFinished; }

        void beginCommit()
        {
            _active = false;
            _connection.beginCommitTransaction(*this, onGetCommitSql());
        }

        void endCommit()
        {
            _connection.endCommitTransaction();
        }

        Pt::Signal<>& commitFinished()
        { return _commitFinished; }
 

        void beginRollback()
        {
            _active = false;
            _connection.beginRollbackTransaction(*this, onGetRollbackSql());
        }

        void endRollback()
        {
            _connection.endRollbackTransaction();
        }

        Pt::Signal<>& rollbackFinished()
        { return _rollbackFinished; }
 
    protected:
        virtual const char* onGetBeginSql()
        { return nullptr; }

        virtual const char* onGetCommitSql()
        { return nullptr; }

        virtual const char* onGetRollbackSql()
        { return nullptr; }
};
 

class SqliteTransaction : public Transaction
{
    public:
        SqliteTransaction(Connection& conn, bool start = true, bool immediate = false)
        : Transaction(conn, false)
        , _immediate(immediate)
        {
            if(start)
                begin();
        }
 
    protected:
        const char* onGetBeginSql() override
        {
            return _immediate ? "BEGIN IMMEDIATE TRANSACTION" : nullptr;
        }
 
    private:
        bool _immediate;
};
 
} // namespace Db
 
} // namespace Pt
 
#endif // PT_DB_TRANSACTION_H