lix/src/libstore/sqlite.hh

172 lines
3.7 KiB
C++
Raw Normal View History

2016-03-30 11:27:25 +00:00
#pragma once
///@file
2016-03-30 11:27:25 +00:00
#include <functional>
#include <string>
2020-05-11 21:52:15 +00:00
#include "error.hh"
2016-03-30 11:27:25 +00:00
2019-09-24 15:28:18 +00:00
struct sqlite3;
struct sqlite3_stmt;
2016-03-30 11:27:25 +00:00
namespace nix {
/**
* RAII wrapper to close a SQLite database automatically.
*/
2016-03-30 11:27:25 +00:00
struct SQLite
{
2016-08-09 12:27:30 +00:00
sqlite3 * db = 0;
SQLite() { }
SQLite(const Path & path, bool create = true);
2016-08-09 12:27:30 +00:00
SQLite(const SQLite & from) = delete;
SQLite& operator = (const SQLite & from) = delete;
SQLite& operator = (SQLite && from) { db = from.db; from.db = 0; return *this; }
2016-03-30 11:27:25 +00:00
~SQLite();
operator sqlite3 * () { return db; }
2016-08-09 12:27:30 +00:00
/**
* Disable synchronous mode, set truncate journal mode.
*/
void isCache();
2016-08-09 12:27:30 +00:00
void exec(const std::string & stmt);
uint64_t getLastInsertedRowId();
2016-03-30 11:27:25 +00:00
};
/**
* RAII wrapper to create and destroy SQLite prepared statements.
*/
2016-03-30 11:27:25 +00:00
struct SQLiteStmt
{
sqlite3 * db = 0;
sqlite3_stmt * stmt = 0;
2017-02-28 12:59:11 +00:00
std::string sql;
SQLiteStmt() { }
2017-02-28 12:59:11 +00:00
SQLiteStmt(sqlite3 * db, const std::string & sql) { create(db, sql); }
2016-03-30 11:27:25 +00:00
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:
2016-04-05 13:29:56 +00:00
~Use();
/**
* Bind the next parameter.
*/
2020-04-16 23:00:56 +00:00
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);
}
2016-03-30 11:27:25 +00:00
};
/**
* RAII helper that ensures transactions are aborted unless explicitly
* committed.
*/
2016-03-30 11:27:25 +00:00
struct SQLiteTxn
{
bool active = false;
sqlite3 * db;
SQLiteTxn(sqlite3 * db);
void commit();
~SQLiteTxn();
};
struct SQLiteError : Error
{
std::string path;
std::string errMsg;
int errNo, extendedErrNo, offset;
template<typename... Args>
[[noreturn]] static void throw_(sqlite3 * db, const std::string & fs, const Args & ... args) {
throw_(db, hintfmt(fs, args...));
}
2016-03-30 11:27:25 +00:00
SQLiteError(const char *path, const char *errMsg, int errNo, int extendedErrNo, int offset, hintformat && 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, errNo, extendedErrNo, offset, hintfmt(fs, args...))
{ }
[[noreturn]] static void throw_(sqlite3 * db, hintformat && hf);
};
MakeError(SQLiteBusy, SQLiteError);
2016-03-30 11:27:25 +00:00
void handleSQLiteBusy(const SQLiteBusy & e, bool shouldWarn);
2017-02-28 12:59:11 +00:00
/**
* Convenience function for retrying a SQLite transaction when the
* database is busy.
*/
template<typename T, typename F>
T retrySQLite(F && fun)
2016-03-30 11:27:25 +00:00
{
time_t nextWarning = time(0) + 1;
2016-03-30 11:27:25 +00:00
while (true) {
try {
return fun();
2016-03-30 11:27:25 +00:00
} catch (SQLiteBusy & e) {
time_t now = time(0);
bool shouldWarn = false;
if (now > nextWarning) {
nextWarning = now + 10;
shouldWarn = true;
}
handleSQLiteBusy(e, shouldWarn);
2016-03-30 11:27:25 +00:00
}
}
}
}