Connection.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_CONNECTION_H
#define PT_DB_CONNECTION_H
 
#include <Pt/Db/Api.h>
#include <Pt/SmartPtr.h>
#include <Pt/Db/IConnection.h>
#include <Pt/Db/Statement.h>
#include <Pt/Db/Result.h>
#include <Pt/Db/Row.h>
#include <Pt/Db/Value.h>
#include <Pt/Signal.h>
#include <string>
 
#if __cplusplus >= 202002L
#include <Pt/Slot.h>
#include <Pt/Coroutine.h>
#endif
 
namespace Pt {
 
namespace System {
class EventLoop;
}
 
namespace Db {
 
class Result;
class Row;
class Value;
class Statement;
class Transaction;
 
#if __cplusplus >= 202002L
class AsyncOpen;
class AsyncClose;
class AsyncExecute;
class AsyncSelect;
class AsyncPing;
class ConnectionAwaiter;
#endif

class PT_DB_API Connection
{
    public:
        typedef std::size_t size_type;

        explicit Connection(const std::string& driver);

        explicit Connection(IConnection* conn);

        ~Connection();

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

        void cancel();

        bool ping();

        void beginPing();

        bool endPing();

        Pt::Signal<>& pingFinished();

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

        bool isIdle() const;

        bool hasTransaction() const;
 
    public:
        bool isOpen() const;

        bool operator!() const;

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

        void close();

        void beginClose();

        void endClose();

        Pt::Signal<>& closeFinished();

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

        void endOpen();

        Pt::Signal<>& openFinished();
 
    public:
        size_type execute(const std::string& query);

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

        size_type endExecute();

        Pt::Signal<>& executeFinished();
 
    public:
        Result select(const std::string& query);

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

        Result endSelect();

        Pt::Signal<>& selectFinished();
 
    public:
        Statement prepare(const std::string& query);

        Statement prepareCached(const std::string& query);

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

        Statement endPrepare();

        Pt::Signal<>& prepareFinished();

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

        Statement endPrepareCached();

        Pt::Signal<>& prepareCachedFinished();
 
    private:
        friend class Transaction;
 
#if __cplusplus >= 202002L
        friend class ConnectionAwaiter;
 
        void attachAwaiter(ConnectionAwaiter& awaiter);
 
        void detachAwaiter(ConnectionAwaiter& awaiter);
#endif
 
        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();
 
#if __cplusplus >= 202002L
    public:
        AsyncOpen openAsync(const std::string& connStr);

        AsyncClose closeAsync();

        AsyncExecute executeAsync(const std::string& sql);

        AsyncSelect selectAsync(const std::string& sql);

        AsyncPing pingAsync();
#endif
 
    public:
        IConnection* impl();

        const IConnection* impl() const;
 
    private:
        Connection(const Connection&) = delete;
 
        Connection& operator=(const Connection&) = delete;
 
        typedef SmartPtr<IConnection,
                         InternalRefCounted<IConnection> > ConnectionImplPtr;
 
        ConnectionImplPtr _connection;
 
#if __cplusplus >= 202002L
        ConnectionAwaiter* _awaiter = nullptr;
#endif
};
 
#if __cplusplus >= 202002L

class ConnectionAwaiter : public Pt::Awaiter
                        , public Pt::Connectable
{
    public:
        explicit ConnectionAwaiter(Connection& conn)
        : _conn(&conn)
        {
            _conn->attachAwaiter(*this); ;
        }
 
        ~ConnectionAwaiter()
        {
            if(_conn)
            {
                _conn->cancel();
                _conn->detachAwaiter(*this);
                _conn = nullptr;
            }
        }
 
        virtual void onDetach()
        {
            if(_conn)
                _conn->detachAwaiter(*this);
 
            _conn = nullptr;
            _handle = nullptr;
        }
 
    protected:
        Connection& connection()
        {
            if( ! _conn )
                throw std::logic_error("invalid connection");
 
            return *_conn;
        }
 
        void onCancel() override
        {
            if(_conn)
                _conn->cancel();
        }
 
    private:
        Connection* _conn;
};

class AsyncOpen : public ConnectionAwaiter
{
    public:
        AsyncOpen(Connection& conn, const std::string& connStr)
        : ConnectionAwaiter(conn)
        , _connStr(connStr)
        {}
 
        void await_resume()
        {
            connection().endOpen();
        }
 
    private:
        void onBegin() override
        {
            Connection& conn = connection();
            conn.openFinished() += slot(*this, &AsyncOpen::setReady);
            conn.beginOpen(_connStr);
        }
 
        std::string _connStr;
};

class AsyncClose : public ConnectionAwaiter
{
    public:
        AsyncClose(Connection& conn)
        : ConnectionAwaiter(conn)
        {}
 
        void await_resume()
        { connection().endClose(); }
 
    private:
        void onBegin() override
        {
            Connection& conn = connection();
            conn.closeFinished() += slot(*this, &AsyncClose::setReady);
            conn.beginClose();
        }
};
 

class AsyncExecute : public ConnectionAwaiter
{
    public:
        AsyncExecute(Connection& conn, const std::string& sql)
        : ConnectionAwaiter(conn)
        , _sql(sql)
        {}
 
        Connection::size_type await_resume()
        { return connection().endExecute(); }
 
    private:
        void onBegin() override
        {
            Connection& conn = connection();
            conn.executeFinished() += slot(*this, &AsyncExecute::setReady);
            conn.beginExecute(_sql);
        }
 
        std::string _sql;
};
 

class AsyncSelect : public ConnectionAwaiter
{
    public:
        AsyncSelect(Connection& conn, const std::string& sql)
        : ConnectionAwaiter(conn)
        , _sql(sql)
        {}
 
        Result await_resume()
        { return connection().endSelect(); }
 
    private:
        void onBegin() override
        {
            Connection& conn = connection();
            conn.selectFinished() += slot(*this, &AsyncSelect::setReady);
            conn.beginSelect(_sql);
        }
 
        std::string _sql;
};
 

class AsyncPing : public ConnectionAwaiter
{
    public:
        AsyncPing(Connection& conn)
        : ConnectionAwaiter(conn)
        {}
 
        bool await_resume()
        {
            return connection().endPing();
        }
 
    private:
        void onBegin() override
        {
            Connection& conn = connection();
            conn.pingFinished() += slot(*this, &AsyncPing::setReady);
            conn.beginPing();
        }
};
 
#endif // __cplusplus >= 202002L
 
} // namespace Db
 
} // namespace Pt
 
#endif // PT_DB_CONNECTION_H