sqlite.hh

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <kj/async.h>
#include <string>
#include <type_traits>
 
#include "lix/libutil/async.hh"
#include "lix/libutil/result.hh"
#include "lix/libutil/types.hh"
#include "lix/libutil/error.hh"
 
struct sqlite3;
struct sqlite3_stmt;
 
namespace nix {
 
enum class SQLiteOpenMode {
    Normal,
    NoCreate,
    Immutable,
};
 
enum class SQLiteTxnType {
    Deferred,
    Immediate,
    Exclusive,
};
 
struct SQLiteError;
class SQLiteStmt;
class SQLiteTxn;

class SQLite
{
    friend SQLiteError;
 
    struct Close {
        void operator()(sqlite3 * db);
    };
    std::unique_ptr<sqlite3, Close> db;
 
public:
    SQLite() = default;
    SQLite(const Path & path, SQLiteOpenMode mode = SQLiteOpenMode::Normal);

    void isCache();
 
    void exec(const std::string & stmt, NeverAsync = {});
 
    SQLiteStmt create(const std::string & stmt);
 
    SQLiteTxn beginTransaction(SQLiteTxnType type = SQLiteTxnType::Deferred);
 
    void setPersistWAL(bool persist);
 
    uint64_t getLastInsertedRowId();
    uint64_t getRowsChanged();
};

class SQLiteStmt
{
    friend SQLite;
 
    struct Finalize {
        SQLiteStmt * parent;
        void operator()(sqlite3_stmt * stmt);
    };
 
    sqlite3 * db = 0;
    std::unique_ptr<sqlite3_stmt, Finalize> stmt;
    std::string sql;
 
    SQLiteStmt(sqlite3 * db, const std::string & sql);
 
public:
    SQLiteStmt() = default;

    class Use
    {
        friend class SQLiteStmt;
    private:
        SQLiteStmt & stmt;
        unsigned int curArg = 1;
        Use(SQLiteStmt & stmt);
 
    public:
 
        ~Use();

        Use & operator () (std::string_view value, bool notNull = true);
        Use & operator () (const unsigned char * data, size_t len, bool notNull = true);
        Use & operator () (int64_t value, bool notNull = true);
        Use & bind(); // null

        void exec();

        bool next();
 
        std::string getStr(int col);
        std::optional<std::string> getStrNullable(int col);
        int64_t getInt(int col);
        bool isNull(int col);
    };
 
    Use use()
    {
        return Use(*this);
    }
};

class SQLiteTxn
{
    friend SQLite;
 
    struct Rollback {
        void operator()(sqlite3 * db);
    };
    std::unique_ptr<sqlite3, Rollback> db;
 
    explicit SQLiteTxn(sqlite3 * db, SQLiteTxnType type);
 
public:
    void commit();
};
 
 
struct SQLiteError : Error
{
    friend SQLite;
    friend SQLiteStmt;
    friend SQLiteTxn;
 
    std::string path;
    std::string errMsg;
    int errNo, extendedErrNo, offset;
 
    SQLiteError(const char *path, const char *errMsg, int errNo, int extendedErrNo, int offset, HintFmt && hf);
 
protected:
 
    template<typename... Args>
    SQLiteError(const char *path, const char *errMsg, int errNo, int extendedErrNo, int offset, const std::string & fs, const Args & ... args)
      : SQLiteError(path, errMsg, errNo, extendedErrNo, offset, HintFmt(fs, args...))
    { }
 
    template<typename... Args>
    [[noreturn]] static void throw_(sqlite3 * db, const std::string & fs, const Args & ... args) {
        throw_(db, HintFmt(fs, args...));
    }
 
    [[noreturn]] static void throw_(sqlite3 * db, HintFmt && hf);
 
};
 
MakeError(SQLiteBusy, SQLiteError);
 
void handleSQLiteBusy(const SQLiteBusy & e, std::chrono::time_point<std::chrono::steady_clock> & nextWarning);
kj::Promise<Result<void>> handleSQLiteBusyAsync(const SQLiteBusy & e, std::chrono::time_point<std::chrono::steady_clock> & nextWarning);

template<typename F>
    requires(!requires(F f) { []<typename T>(kj::Promise<T>) {}(f()); })
auto retrySQLite(F fun, NeverAsync = {})
{
    auto nextWarning = std::chrono::steady_clock::now() + std::chrono::seconds(1);
 
    while (true) {
        try {
            return fun();
        } catch (SQLiteBusy & e) {
            handleSQLiteBusy(e, nextWarning);
        }
    }
}
 
template<typename F>
    requires requires(F f) { []<typename T>(kj::Promise<Result<T>>) {}(f()); }
auto retrySQLite(F fun)
{
    return [](F fun) -> decltype(fun()) {
        auto nextWarning = std::chrono::steady_clock::now() + std::chrono::seconds(1);
 
        while (true) {
            kj::Promise<Result<void>> handleBusy{nullptr};
            try {
                if constexpr (std::is_same_v<decltype(fun()), kj::Promise<Result<void>>>) {
                    LIX_TRY_AWAIT(fun());
                    co_return result::success();
                } else {
                    co_return LIX_TRY_AWAIT(fun());
                }
            } catch (SQLiteBusy & e) {
                handleBusy = handleSQLiteBusyAsync(e, nextWarning);
            } catch (...) {
                co_return result::current_exception();
            }
            LIX_TRY_AWAIT(handleBusy);
        }
    }(std::move(fun));
}
}