SQLConn.h

// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include <filesystem>
#include <optional>
#include <string>
#include <variant>
#include <vector>
 
#include "../helpers/Enum.h"
#include "../helpers/LastError.h"
#include "SQLiteSmart.h"
 
namespace SlSqlite {

enum class OpenFlags : unsigned {
    NONE                = 0,
    CREATE              = 1 << 0,
    NO_FOREIGN_KEY          = 1 << 1,
    ERROR_ON_UNIQUE_CONSTRAINT  = 1 << 2,
    READ_ONLY           = 1 << 3,
};
 
} // namespace
 
ENABLE_BITMASK_OPERATORS(SlSqlite::OpenFlags);
 
namespace SlSqlite {

enum struct TransactionType {
    DEFERRED,
    IMMEDIATE,
    EXCLUSIVE,
};
 
class Select;
class SQLConn;

class AutoTransaction {
public:
    AutoTransaction() = delete;
    AutoTransaction(const SQLConn &conn,
            TransactionType type = TransactionType::DEFERRED);
    ~AutoTransaction() { end(); }
 
    AutoTransaction(const AutoTransaction &) = delete;
    AutoTransaction &operator=(const AutoTransaction &) = delete;

    AutoTransaction(AutoTransaction &&other) noexcept : m_conn(other.m_conn) {
        other.m_conn = nullptr;
    }

    AutoTransaction &operator=(AutoTransaction &&other) noexcept {
        if (this != &other) {
            end();
            m_conn = other.m_conn;
            other.m_conn = nullptr;
        }
 
        return *this;
    }

    void end();

    bool operator!() const { return !m_conn; }
    operator bool() const { return m_conn; }
private:
    const SQLConn *m_conn;
};

class SQLConn {
    friend class Select;
public:
    virtual ~SQLConn() = default;

    SQLConn(SQLConn &&) = default;
    SQLConn &operator=(SQLConn &&) = default;

    bool open(const std::filesystem::path &dbFile, OpenFlags flags = OpenFlags::NONE)
    {
        return openDB(dbFile, flags) && createDB() && prepDB();
    }

    bool openDB(const std::filesystem::path &dbFile,
            OpenFlags flags = OpenFlags::NONE) noexcept;

    virtual bool createDB() { return true; }

    virtual bool prepDB() { return true; }

    bool exec(const std::string &sql) const noexcept { return exec(sql, "exec failed"); }

    bool attach(const std::filesystem::path &dbFile,
            std::string_view dbName) const noexcept;

    bool begin(TransactionType type = TransactionType::DEFERRED) const noexcept;

    bool end() const noexcept { return exec("END;", "db END failed"); }

    AutoTransaction beginAuto(TransactionType type = TransactionType::DEFERRED) const noexcept {
        return AutoTransaction(*this, type);
    }

    std::string lastError() const { return m_lastError.lastError(); }
    int lastErrorCode() const { return m_lastError.get<0>(); }
    int lastErrorCodeExt() const { return m_lastError.get<1>(); }
 
protected:
    SQLConn() : m_flags(OpenFlags::NONE) {}

    using BindVal = std::variant<std::monostate, int, unsigned, std::string, std::string_view>;
    using Binding = std::vector<std::pair<std::string, BindVal>>;
    using Column = std::variant<std::monostate, int, std::string>;
    using Row = std::vector<Column>;
    using SelectResult = std::vector<Row>;

    enum TableFlags : unsigned {
        TABLE_TEMPORARY = 1u << 0,
    };

    struct TableEntry {
        std::string name;
        std::vector<std::string> columns;
        unsigned flags = 0u;
    };

    using Tables = std::vector<TableEntry>;
    using Indices = std::vector<std::pair<std::string, std::string>>;
    using Triggers = Indices;
    using Views = Indices;
    using Statements = std::vector<std::pair<std::reference_wrapper<SQLStmtHolder>, std::string>>;

    bool createTables(const Tables &tables) const noexcept;
    bool createIndices(const Indices &indices) const noexcept;
    bool createTriggers(const Triggers &triggers) const noexcept;
    bool createViews(const Views &views) const noexcept;

    bool prepareStatement(std::string_view sql, SQLStmtHolder &stmt) const noexcept;
    bool prepareStatements(const Statements &stmts) const noexcept;

    bool bind(const SQLStmtHolder &ins, const std::string &key,
          const BindVal &val, bool transient = false) const noexcept;
    bool bind(const SQLStmtHolder &ins, const Binding &binding,
          bool transient = false) const noexcept;
    bool step(const SQLStmtHolder &ins, uint64_t *affected = nullptr,
          bool *uniqueError = nullptr) const noexcept;
    bool insert(const SQLStmtHolder &ins, const Binding &binding = {},
            uint64_t *affected = nullptr) const noexcept;

    std::optional<SQLConn::SelectResult>
    select(const SQLStmtHolder &sel, const Binding &binding) const noexcept;

    static BindVal valueOrNull(bool cond, BindVal val) {
        return cond ? std::move(val) : std::monostate();
    }

    using LastError = SlHelpers::LastErrorStream<int, int>;

    LastError &setError(int ret, std::string_view error, bool errmsg = false) const;

    SQLHolder sqlHolder;
    OpenFlags m_flags;
    mutable LastError m_lastError;
private:
    bool exec(const std::string &SQL, std::string_view errorMsg,
          bool includeSQL = false) const noexcept;
 
    static constexpr bool isUniqueConstraint(int sqlExtError) noexcept;
    static int busyHandler(void *, int count);
    void dumpBinding(const Binding &binding) const noexcept;
};
 
inline AutoTransaction::AutoTransaction(const SQLConn &conn, TransactionType type)
    : m_conn(conn.begin(type) ? &conn : nullptr)
{
}
 
inline void AutoTransaction::end()
{
    if (m_conn) {
        m_conn->end();
        m_conn = nullptr;
    }
}
 
}