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>
 
#if __cplusplus >= 202002L
#include <Pt/Slot.h>
#include <Pt/Coroutine.h>
#endif
 
namespace Pt {
 
namespace Db {
 
#if __cplusplus >= 202002L
class AsyncBegin;
class AsyncCommit;
class AsyncRollback;
#endif

class Transaction : private NonCopyable
{
    private:
        Connection&  _connection;
        bool         _active;
        Pt::Signal<> _startFinished;
        Pt::Signal<> _commitFinished;
        Pt::Signal<> _rollbackFinished;
 
#if __cplusplus >= 202002L
        ConnectionAwaiter* _awaiter = nullptr;
#endif
 
    public:
        Transaction(Connection& conn, bool starttransaction = true)
        : _connection(conn)
        , _active(false)
        {
            if (starttransaction)
            {
                begin();
            }
        }

        ~Transaction()
        {
#if __cplusplus >= 202002L
            if(_awaiter)
            {
                _awaiter->cancel();
                _awaiter->onDetach();
                _awaiter = nullptr;
            }
#endif
 
            if (_active)
            {
                try
                {
                    rollback();
                }
                catch (const std::exception&)
                {
                }
            }
        }

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

        Connection& getConnection()
        { 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; }
 
#if __cplusplus >= 202002L
        AsyncBegin beginAsync();

        AsyncCommit commitAsync();

        AsyncRollback rollbackAsync();
#endif
 
    protected:
        virtual const char* onGetBeginSql()
        { return nullptr; }

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

        virtual const char* onGetRollbackSql()
        { return nullptr; }
 
#if __cplusplus >= 202002L
    private:
        friend class AsyncBegin;
        friend class AsyncCommit;
        friend class AsyncRollback;
 
        void attachAwaiter(ConnectionAwaiter& awaiter)
        {
            _awaiter = &awaiter;
        }
 
        void detachAwaiter(ConnectionAwaiter& awaiter)
        {
            if(_awaiter == &awaiter)
                _awaiter = nullptr;
        }
#endif
};
 
 
#if __cplusplus >= 202002L

class AsyncBegin : public ConnectionAwaiter
{
    public:
        explicit AsyncBegin(Transaction& txn)
        : ConnectionAwaiter(txn.getConnection())
        , _txn(&txn)
        {
            txn.attachAwaiter(*this);
        }
 
        ~AsyncBegin()
        {
            if(_txn)
                _txn->detachAwaiter(*this);
        }
 
        void onDetach() override
        {
            if(_txn)
            {
                _txn->detachAwaiter(*this);
                _txn = nullptr;
            }
 
            ConnectionAwaiter::onDetach();
        }
 
        void await_resume()
        {
            transaction().endStart();
        }
 
    private:
        Transaction& transaction()
        {
            if( ! _txn )
                throw std::logic_error("invalid transaction");
 
            return *_txn;
        }
 
        void onBegin() override
        {
            Transaction& txn = transaction();
            txn.startFinished() += slot(*this, &AsyncBegin::setReady);
            txn.beginStart();
        }
 
        Transaction* _txn;
};
 

class AsyncCommit : public ConnectionAwaiter
{
    public:
        explicit AsyncCommit(Transaction& txn)
        : ConnectionAwaiter(txn.getConnection())
        , _txn(&txn)
        {
            txn.attachAwaiter(*this);
        }
 
        ~AsyncCommit()
        {
            if(_txn)
                _txn->detachAwaiter(*this);
        }
 
        void onDetach() override
        {
            if(_txn)
            {
                _txn->detachAwaiter(*this);
                _txn = nullptr;
            }
 
            ConnectionAwaiter::onDetach();
        }
 
        void await_resume()
        {
            transaction().endCommit();
        }
 
    private:
        Transaction& transaction()
        {
            if( ! _txn )
                throw std::logic_error("invalid transaction");
 
            return *_txn;
        }
 
        void onBegin() override
        {
            Transaction& txn = transaction();
            txn.commitFinished() += slot(*this, &AsyncCommit::setReady);
            txn.beginCommit();
        }
 
        Transaction* _txn;
};
 

class AsyncRollback : public ConnectionAwaiter
{
    public:
        explicit AsyncRollback(Transaction& txn)
        : ConnectionAwaiter(txn.getConnection())
        , _txn(&txn)
        {
            txn.attachAwaiter(*this);
        }
 
        ~AsyncRollback()
        {
            if(_txn)
                _txn->detachAwaiter(*this);
        }
 
        void onDetach() override
        {
            if(_txn)
            {
                _txn->detachAwaiter(*this);
                _txn = nullptr;
            }
 
            ConnectionAwaiter::onDetach();
        }
 
        void await_resume()
        {
            transaction().endRollback();
        }
 
    private:
        Transaction& transaction()
        {
            if( ! _txn )
                throw std::logic_error("invalid transaction");
 
            return *_txn;
        }
 
        void onBegin() override
        {
            Transaction& txn = transaction();
            txn.rollbackFinished() += slot(*this, &AsyncRollback::setReady);
            txn.beginRollback();
        }
 
        Transaction* _txn;
};
 
 
inline AsyncBegin Transaction::beginAsync()
{
    return AsyncBegin(*this);
}
 
 
inline AsyncCommit Transaction::commitAsync()
{
    return AsyncCommit(*this);
}
 
 
inline AsyncRollback Transaction::rollbackAsync()
{
    return AsyncRollback(*this);
}
 
#endif // __cplusplus >= 202002L
 

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