forked from lix-project/lix
6644b6099b
This exploits the hermetic nature of flake evaluation to speed up
repeated evaluations of a flake output attribute.
For example (doing 'nix build' on an already present package):
$ time nix build nixpkgs:firefox
real 0m1.497s
user 0m1.160s
sys 0m0.139s
$ time nix build nixpkgs:firefox
real 0m0.052s
user 0m0.038s
sys 0m0.007s
The cache is ~/.cache/nix/eval-cache-v1.sqlite, which has entries like
INSERT INTO Attributes VALUES(
X'92a907d4efe933af2a46959b082cdff176aa5bfeb47a98fabd234809a67ab195',
'packages.firefox',
1,
'/nix/store/pbalzf8x19hckr8cwdv62rd6g0lqgc38-firefox-67.0.drv /nix/store/g6q0gx0v6xvdnizp8lrcw7c4gdkzana0-firefox-67.0 out');
where the hash 92a9... is a fingerprint over the flake store path and
the contents of the lockfile. Because flakes are evaluated in pure
mode, this uniquely identifies the evaluation result.
119 lines
2.6 KiB
C++
119 lines
2.6 KiB
C++
#pragma once
|
|
|
|
#include <functional>
|
|
#include <string>
|
|
|
|
#include "types.hh"
|
|
|
|
class sqlite3;
|
|
class 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);
|
|
};
|
|
|
|
/* 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 () (const std::string & 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();
|
|
};
|
|
|
|
|
|
MakeError(SQLiteError, Error);
|
|
MakeError(SQLiteBusy, SQLiteError);
|
|
|
|
[[noreturn]] void throwSQLiteError(sqlite3 * db, const FormatOrString & fs);
|
|
|
|
void handleSQLiteBusy(const SQLiteBusy & e);
|
|
|
|
/* Convenience function for retrying a SQLite transaction when the
|
|
database is busy. */
|
|
template<typename T>
|
|
T retrySQLite(std::function<T()> fun)
|
|
{
|
|
while (true) {
|
|
try {
|
|
return fun();
|
|
} catch (SQLiteBusy & e) {
|
|
handleSQLiteBusy(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|