IConnection.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_ICONNECTION_H
#define PT_DB_ICONNECTION_H
 
#include <Pt/Db/Api.h>
#include <Pt/RefCounted.h>
#include <Pt/SmartPtr.h>
#include <Pt/Signal.h>
#include <Pt/Db/ICursor.h>
#include <Pt/Db/Cursor.h>
#include <Pt/Db/IStatement.h>
#include <Pt/Db/Result.h>
#include <Pt/Db/Row.h>
#include <Pt/Db/Value.h>
 
#include <string>
#include <map>
 
namespace Pt {
 
namespace System {
class EventLoop;
}
 
namespace Db {
 
class Result;
class Row;
class Value;
class Statement;
class Transaction;

class PT_DB_API IConnection : public RefCounted
{
    public:
        typedef std::size_t size_type;
 

        void setActive(Pt::System::EventLoop* loop);

        bool ping();

        void beginPing();

        bool endPing();

        Pt::Signal<>& pingFinished()
        { return _pingFinished; }

        long long lastInsertId(const std::string& name);

        bool isIdle() const
        { return _pendingOp == nullptr; }

        bool hasTransaction() const
        { return _inTransaction; }
 
    public:
        void open(const std::string& connStr);

        void close();

        void beginClose();

        void endClose();

        Pt::Signal<>& closeFinished()
        { return _closeFinished; }

        bool isOpen() const
        { return _isOpen; }

        void beginOpen(const std::string& connStr);

        void endOpen();

        Pt::Signal<>& openFinished()
        { return _openFinished; }
 
    public:
        void startTransaction(const char* sql = nullptr);

        void commitTransaction(const char* sql = nullptr);

        void rollbackTransaction(const char* sql = nullptr);

        void beginStartTransaction(Transaction& txn, const char* sql);

        void endStartTransaction();

        void beginCommitTransaction(Transaction& txn, const char* sql);

        void endCommitTransaction();

        void beginRollbackTransaction(Transaction& txn, const char* sql);

        void endRollbackTransaction();
 
    public:
        size_type execute(const std::string& query);

        void beginExecute(const std::string& sql);

        size_type endExecute();

        Pt::Signal<>& executeFinished()
        { return _executeFinished; }

        size_type execute(IStatement& stmt);

        void beginExecute(IStatement& stmt);

        size_type endExecute(IStatement& stmt);
 
    public:
        Statement prepare(const std::string& query);

        virtual Statement prepareCached(const std::string& query) = 0;

        virtual void clearStatementCache() = 0;

        virtual void beginPrepareCached(const std::string& query) = 0;

        virtual Statement endPrepareCached() = 0;

        Pt::Signal<>& prepareCachedFinished()
        { return _prepareCachedFinished; }

        void beginPrepare(const std::string& query);

        Statement endPrepare();

        Pt::Signal<>& prepareFinished()
        { return _prepareFinished; }
 
    public:
        Result select(const std::string& query);

        void beginSelect(const std::string& sql);

        Result endSelect();

        Pt::Signal<>& selectFinished()
        { return _selectFinished; }

        Result select(IStatement& stmt);

        Row selectRow(IStatement& stmt);

        Value selectValue(IStatement& stmt);

        void beginSelect(IStatement& stmt);

        Result endSelect(IStatement& stmt);
 
    public:
        Cursor getCursor(IStatement& stmt, size_type batchSize);

        Result fetchBatch(ICursor& cursor, size_type batchSize);

        void beginBatchFetch(ICursor& cursor, size_type batchSize);

        Result endBatchFetch(ICursor& cursor);

        void cancelCursor(ICursor& cursor);

        void cancelStatement(IStatement& stmt);
 
    protected:
        IConnection();

        void cancelPending() noexcept;

        void cancelConnection() noexcept;
 
        virtual void onSetActive(Pt::System::EventLoop* loop) = 0;
 
        virtual void onOpen(const std::string& connStr) = 0;
 
        virtual void onClose() = 0;
 
        virtual void onCancelPending() noexcept = 0;
 
        virtual void onBeginClose() = 0;
 
        virtual void onEndClose() = 0;
 
        virtual void onNotifyPreparedCached() = 0;
 
        virtual void onBeginOpen(const std::string& connStr) = 0;
 
        virtual void onEndOpen() = 0;
 
        virtual void onBeginExec(const std::string& sql) = 0;
 
        virtual size_type onEndExec() = 0;
 
        virtual void onBeginSelect(const std::string& sql) = 0;
 
        virtual Result onEndSelect() = 0;
 
        virtual void onBeginPrepare(const std::string& query) = 0;
 
        virtual Statement onEndPrepare() = 0;
 
        virtual void onBeginPrepareCachedMiss(const std::string& query) = 0;
 
        virtual Statement onEndPrepareCachedMiss() = 0;
 
        virtual void onBeginStartTransaction(Transaction& txn, const char* sql) = 0;
 
        virtual void onEndStartTransaction() = 0;
 
        virtual void onBeginCommitTransaction(Transaction& txn, const char* sql) = 0;
 
        virtual void onEndCommitTransaction() = 0;
 
        virtual void onBeginRollbackTransaction(Transaction& txn, const char* sql) = 0;
 
        virtual void onEndRollbackTransaction() = 0;
 
        virtual size_type onExecute(const std::string& query) = 0;
 
        virtual Result onSelect(const std::string& query) = 0;
 
        virtual Statement onPrepare(const std::string& query) = 0;
 
        virtual bool onPing() = 0;
 
        virtual void onBeginPing() = 0;
 
        virtual bool onEndPing() = 0;
 
        virtual long long onLastInsertId(const std::string& name) = 0;
 
        virtual void onStartTransaction(const char* sql) = 0;
 
        virtual void onCommitTransaction(const char* sql) = 0;
 
        virtual void onRollbackTransaction(const char* sql) = 0;
 
        Pt::Signal<>            _openFinished;
        Pt::Signal<>            _closeFinished;
        Pt::Signal<>            _executeFinished;
        Pt::Signal<>            _selectFinished;
        Pt::Signal<>            _prepareFinished;
        Pt::Signal<>            _prepareCachedFinished;
        Pt::Signal<>            _pingFinished;
        bool                    _prepareCachedHit;
        bool                    _isOpen;
        bool                    _inTransaction;
        Pt::System::EventLoop*  _loop;
        void*                   _pendingOp;
 
        friend class Connection;
};
 

class PT_DB_API IStmtCacheConnection : public IConnection
{
    public:
        virtual Statement prepareCached(const std::string& query);

        virtual void clearStatementCache();

        virtual void beginPrepareCached(const std::string& query);

        virtual Statement endPrepareCached();
 
    private:
        typedef SmartPtr<IStatement, InternalRefCounted<IStatement> > StatementPtr;
        typedef std::map<std::string, StatementPtr> StatementCache;
        StatementCache _stmtCache;
        IStatement*    _cachedHitStmt = nullptr;
        std::string    _pendingPrepareCachedQuery;
};
 
} // namespace Db
 
} // namespace Pt
 
#endif // PT_DB_ICONNECTION_H