RADDatabase.h

Go to the documentation of this file.

#ifndef RADDATABASE_H
#define RADDATABASE_H
 
#pragma once
 
#include <RADCore/RADCore.h>
 
#include <map>
#include <string>
#include <vector>
 
namespace RADDatabase {
 
    using RADSqlRow = std::map<std::string, RADCore::RADVariant>;
 
    class RADSqlStatement;
    class RADSqlTransaction;
 
    class RADSqlResult {
    public:
        RADSqlResult() = default;
        explicit RADSqlResult(std::vector<RADSqlRow> rows);
 
        size_t rowCount() const;
        bool empty() const;
        const RADSqlRow& row(size_t index) const;
        const std::vector<RADSqlRow>& rows() const;
 
    private:
        std::vector<RADSqlRow> rows_;
    };
 
    class RADSqlDatabase : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(errorOccurred, (std::string));
 
        RADSqlDatabase();
        explicit RADSqlDatabase(std::string fileName);
        ~RADSqlDatabase() override;
 
        void setFileName(std::string fileName);
        const std::string& fileName() const;
 
        bool open();
        void close();
        bool isOpen() const;
        std::string lastError() const;
 
        bool execute(const std::string& sql);
        RADSqlResult query(const std::string& sql);
        RADSqlStatement prepare(const std::string& sql);
        RADCore::RADFutureT<RADSqlResult> queryAsync(
            RADCore::RADThreadPool& pool,
            RADCore::EventLoop& completionLoop,
            const std::string& sql);
 
        bool beginTransaction();
        bool commit();
        bool rollback();
        int schemaVersion();
        bool migrateTo(int targetVersion, const std::vector<std::pair<int, std::string>>& migrations);
 
    private:
        friend class RADSqlStatement;
        friend class RADSqlTransaction;
        struct Impl;
        std::shared_ptr<Impl> pImpl_;
    };
 
    class RADSqlStatement {
    public:
        RADSqlStatement();
        ~RADSqlStatement();
 
        RADSqlStatement(const RADSqlStatement&) = delete;
        RADSqlStatement& operator=(const RADSqlStatement&) = delete;
        RADSqlStatement(RADSqlStatement&& other) noexcept;
        RADSqlStatement& operator=(RADSqlStatement&& other) noexcept;
 
        bool isValid() const;
        std::string lastError() const;
        void clearBindings();
        void reset();
 
        bool bindNull(int index);
        bool bind(int index, int64_t value);
        bool bind(int index, double value);
        bool bind(int index, const std::string& value);
        bool bind(int index, const std::vector<uint8_t>& value);
        bool bind(int index, const RADCore::RADVariant& value);
 
        bool step();
        bool execute();
        int columnCount() const;
        std::string columnName(int column) const;
        RADCore::RADVariant columnValue(int column) const;
 
    private:
        friend class RADSqlDatabase;
        struct Impl;
        explicit RADSqlStatement(std::shared_ptr<Impl> impl);
        std::shared_ptr<Impl> pImpl_;
    };
 
    class RADSqlTransaction {
    public:
        explicit RADSqlTransaction(RADSqlDatabase& database);
        ~RADSqlTransaction();
 
        RADSqlTransaction(const RADSqlTransaction&) = delete;
        RADSqlTransaction& operator=(const RADSqlTransaction&) = delete;
 
        bool isActive() const;
        bool commit();
        bool rollback();
 
    private:
        RADSqlDatabase* database_ = nullptr;
        bool active_ = false;
    };
 
} // namespace RADDatabase
 
#endif