forked from lix-project/lix
e7d79c7861
Otherwise the clang builds fail because the constructor of `SQLiteBusy` inherits it, `SQLiteError::_throw` tries to call it, which fails. Strangely, gcc works fine with it. Not sure what the correct behavior is and who is buggy here, but either way, making it public is at the worst a reasonable workaround
141 lines
3.2 KiB
C++
141 lines
3.2 KiB
C++
#pragma once
|
|
|
|
#include <functional>
|
|
#include <string>
|
|
|
|
#include "error.hh"
|
|
|
|
struct sqlite3;
|
|
struct sqlite3_stmt;
|
|
|
|
namespace nix {
|
|
|
|
/* RAII wrapper to close a SQLite database automatically. */
|
|
struct SQLite
|
|
{
|
|
sqlite3 * db = 0;
|
|
SQLite() { }
|
|
SQLite(const Path & path, bool create = true);
|
|
SQLite(const SQLite & from) = delete;
|
|
SQLite& operator = (const SQLite & from) = delete;
|
|
SQLite& operator = (SQLite && from) { db = from.db; from.db = 0; return *this; }
|
|
~SQLite();
|
|
operator sqlite3 * () { return db; }
|
|
|
|
/* Disable synchronous mode, set truncate journal mode. */
|
|
void isCache();
|
|
|
|
void exec(const std::string & stmt);
|
|
|
|
uint64_t getLastInsertedRowId();
|
|
};
|
|
|
|
/* RAII wrapper to create and destroy SQLite prepared statements. */
|
|
struct SQLiteStmt
|
|
{
|
|
sqlite3 * db = 0;
|
|
sqlite3_stmt * stmt = 0;
|
|
std::string sql;
|
|
SQLiteStmt() { }
|
|
SQLiteStmt(sqlite3 * db, const std::string & sql) { create(db, sql); }
|
|
void create(sqlite3 * db, const std::string & s);
|
|
~SQLiteStmt();
|
|
operator sqlite3_stmt * () { return stmt; }
|
|
|
|
/* Helper for binding / executing statements. */
|
|
class Use
|
|
{
|
|
friend struct SQLiteStmt;
|
|
private:
|
|
SQLiteStmt & stmt;
|
|
unsigned int curArg = 1;
|
|
Use(SQLiteStmt & stmt);
|
|
|
|
public:
|
|
|
|
~Use();
|
|
|
|
/* Bind the next parameter. */
|
|
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
|
|
|
|
int step();
|
|
|
|
/* Execute a statement that does not return rows. */
|
|
void exec();
|
|
|
|
/* For statements that return 0 or more rows. Returns true iff
|
|
a row is available. */
|
|
bool next();
|
|
|
|
std::string getStr(int col);
|
|
int64_t getInt(int col);
|
|
bool isNull(int col);
|
|
};
|
|
|
|
Use use()
|
|
{
|
|
return Use(*this);
|
|
}
|
|
};
|
|
|
|
/* RAII helper that ensures transactions are aborted unless explicitly
|
|
committed. */
|
|
struct SQLiteTxn
|
|
{
|
|
bool active = false;
|
|
sqlite3 * db;
|
|
|
|
SQLiteTxn(sqlite3 * db);
|
|
|
|
void commit();
|
|
|
|
~SQLiteTxn();
|
|
};
|
|
|
|
|
|
struct SQLiteError : Error
|
|
{
|
|
const char *path;
|
|
int errNo, extendedErrNo;
|
|
|
|
template<typename... Args>
|
|
[[noreturn]] static void throw_(sqlite3 * db, const std::string & fs, const Args & ... args) {
|
|
throw_(db, hintfmt(fs, args...));
|
|
}
|
|
|
|
SQLiteError(const char *path, int errNo, int extendedErrNo, hintformat && hf);
|
|
|
|
protected:
|
|
|
|
template<typename... Args>
|
|
SQLiteError(const char *path, int errNo, int extendedErrNo, const std::string & fs, const Args & ... args)
|
|
: SQLiteError(path, errNo, extendedErrNo, hintfmt(fs, args...))
|
|
{ }
|
|
|
|
[[noreturn]] static void throw_(sqlite3 * db, hintformat && hf);
|
|
|
|
};
|
|
|
|
MakeError(SQLiteBusy, SQLiteError);
|
|
|
|
void handleSQLiteBusy(const SQLiteBusy & e);
|
|
|
|
/* Convenience function for retrying a SQLite transaction when the
|
|
database is busy. */
|
|
template<typename T, typename F>
|
|
T retrySQLite(F && fun)
|
|
{
|
|
while (true) {
|
|
try {
|
|
return fun();
|
|
} catch (SQLiteBusy & e) {
|
|
handleSQLiteBusy(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|