/* LBS: An LFS-inspired filesystem backup system
- * Copyright (C) 2007 Michael Vrable
+ * Copyright (C) 2007-2008 Michael Vrable
*
* When creating backup snapshots, maintain a local database of data blocks and
* checksums, in addition to the data contents (which may be stored remotely).
rc = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, &tail);
if (rc != SQLITE_OK) {
+ ReportError(rc);
throw IOException(string("Error preparing statement: ") + sql);
}
}
void LocalDb::Open(const char *path, const char *snapshot_name,
- const char *snapshot_scheme)
+ const char *snapshot_scheme, double intent)
{
int rc;
/* Insert this snapshot into the database, and determine the integer key
* which will be used to identify it. */
sqlite3_stmt *stmt = Prepare("insert into "
- "snapshots(name, scheme, timestamp) "
- "values (?, ?, julianday('now'))");
+ "snapshots(name, scheme, timestamp, intent) "
+ "values (?, ?, julianday('now'), ?)");
sqlite3_bind_text(stmt, 1, snapshot_name, strlen(snapshot_name),
SQLITE_TRANSIENT);
if (snapshot_scheme == NULL)
else
sqlite3_bind_text(stmt, 2, snapshot_scheme, strlen(snapshot_scheme),
SQLITE_TRANSIENT);
+ sqlite3_bind_double(stmt, 3, intent);
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE) {
sqlite3_close(db);
throw IOException("Find snapshot id");
}
+
+ /* Create a temporary table which will be used to keep track of the objects
+ * used by this snapshot. When the database is closed, we will summarize
+ * the results of this table into segments_used. */
+ rc = sqlite3_exec(db,
+ "create temporary table snapshot_refs ("
+ " segmentid integer not null,"
+ " object text not null,"
+ " size integer not null"
+ ")", NULL, NULL, NULL);
+ if (rc != SQLITE_OK) {
+ ReportError(rc);
+ sqlite3_close(db);
+ throw IOException("Database initialization");
+ }
+ rc = sqlite3_exec(db,
+ "create unique index snapshot_refs_index "
+ "on snapshot_refs(segmentid, object)",
+ NULL, NULL, NULL);
+ if (rc != SQLITE_OK) {
+ ReportError(rc);
+ sqlite3_close(db);
+ throw IOException("Database initialization");
+ }
}
void LocalDb::Close()
{
int rc;
+
+ /* Summarize the snapshot_refs table into segments_used. */
+ sqlite3_stmt *stmt = Prepare(
+ "insert or replace into segments_used "
+ "select ? as snapshotid, segmentid, max(utilization) from ("
+ " select segmentid, cast(used as real) / size as utilization "
+ " from "
+ " (select segmentid, sum(size) as used from snapshot_refs "
+ " group by segmentid) "
+ " join segments using (segmentid) "
+ " union "
+ " select segmentid, utilization from segments_used "
+ " where snapshotid = ? "
+ ") group by segmentid"
+ );
+ sqlite3_bind_int64(stmt, 1, snapshotid);
+ sqlite3_bind_int64(stmt, 2, snapshotid);
+ rc = sqlite3_step(stmt);
+ if (rc != SQLITE_OK && rc != SQLITE_DONE) {
+ ReportError(rc);
+ sqlite3_close(db);
+ fprintf(stderr, "DATABASE ERROR: Unable to create segment summary!\n");
+ }
+ sqlite3_finalize(stmt);
+
+ /* Commit changes to the database and close. */
rc = sqlite3_exec(db, "commit", NULL, NULL, NULL);
if (rc != SQLITE_OK) {
fprintf(stderr, "DATABASE ERROR: Can't commit database!\n");
}
sqlite3_finalize(stmt);
+
+ if (age != 0.0) {
+ stmt = Prepare("update segments "
+ "set mtime = coalesce(max(mtime, ?), ?) "
+ "where segmentid = ?");
+ sqlite3_bind_double(stmt, 1, age);
+ sqlite3_bind_double(stmt, 2, age);
+ sqlite3_bind_int64(stmt, 3, SegmentToId(ref.get_segment()));
+ rc = sqlite3_step(stmt);
+ sqlite3_finalize(stmt);
+ }
}
ObjectReference LocalDb::FindObject(const string &checksum, int64_t size)
} else if (rc == SQLITE_ROW) {
ref = ObjectReference(IdToSegment(sqlite3_column_int64(stmt, 0)),
(const char *)sqlite3_column_text(stmt, 1));
+ ref.set_range(0, size);
} else {
fprintf(stderr, "Could not execute SELECT statement!\n");
ReportError(rc);
return ref;
}
-bool LocalDb::IsOldObject(const string &checksum, int64_t size, double *age)
+bool LocalDb::IsOldObject(const string &checksum, int64_t size, double *age,
+ int *group)
{
int rc;
sqlite3_stmt *stmt;
bool found = false;
- stmt = Prepare("select segmentid, object, timestamp from block_index "
- "where checksum = ? and size = ?");
+ stmt = Prepare("select segmentid, object, timestamp, expired "
+ "from block_index where checksum = ? and size = ?");
sqlite3_bind_text(stmt, 1, checksum.c_str(), checksum.size(),
SQLITE_TRANSIENT);
sqlite3_bind_int64(stmt, 2, size);
} else if (rc == SQLITE_ROW) {
found = true;
*age = sqlite3_column_double(stmt, 2);
+ *group = sqlite3_column_int(stmt, 3);
} else {
fprintf(stderr, "Could not execute SELECT statement!\n");
ReportError(rc);
sqlite3_stmt *stmt;
bool found = false;
+ // Special objects (such as the zero object) aren't stored in segments, and
+ // so are always available.
+ if (!ref.is_normal())
+ return true;
+
stmt = Prepare("select count(*) from block_index "
"where segmentid = ? and object = ? and expired is null");
sqlite3_bind_int64(stmt, 1, SegmentToId(ref.get_segment()));
int rc;
sqlite3_stmt *stmt;
- stmt = Prepare("insert or ignore into snapshot_contents "
- "select blockid, ? as snapshotid from block_index "
+ if (!ref.is_normal())
+ return;
+
+ stmt = Prepare("insert or ignore into snapshot_refs "
+ "select segmentid, object, size from block_index "
"where segmentid = ? and object = ?");
- sqlite3_bind_int64(stmt, 1, snapshotid);
- sqlite3_bind_int64(stmt, 2, SegmentToId(ref.get_segment()));
+ sqlite3_bind_int64(stmt, 1, SegmentToId(ref.get_segment()));
string obj = ref.get_sequence();
- sqlite3_bind_text(stmt, 3, obj.c_str(), obj.size(), SQLITE_TRANSIENT);
+ sqlite3_bind_text(stmt, 2, obj.c_str(), obj.size(), SQLITE_TRANSIENT);
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE) {
sqlite3_finalize(stmt);
}
+void LocalDb::UseSegment(const std::string &segment, double utilization)
+{
+ int rc;
+ sqlite3_stmt *stmt;
+
+ stmt = Prepare("insert or replace "
+ "into segments_used(snapshotid, segmentid, utilization) "
+ "values (?, ?, ?)");
+ sqlite3_bind_int64(stmt, 1, snapshotid);
+ sqlite3_bind_int64(stmt, 2, SegmentToId(segment));
+ sqlite3_bind_double(stmt, 3, utilization);
+
+ rc = sqlite3_step(stmt);
+ if (rc != SQLITE_DONE) {
+ fprintf(stderr, "Could not insert segment use record!\n");
+ ReportError(rc);
+ }
+
+ sqlite3_finalize(stmt);
+}
+
void LocalDb::SetSegmentChecksum(const std::string &segment,
const std::string &path,
- const std::string &checksum)
+ const std::string &checksum,
+ int size)
{
int rc;
sqlite3_stmt *stmt;
- stmt = Prepare("update segments set path = ?, checksum = ? "
+ stmt = Prepare("update segments set path = ?, checksum = ?, size = ?, "
+ "mtime = coalesce(mtime, julianday('now')) "
"where segmentid = ?");
sqlite3_bind_text(stmt, 1, path.c_str(), path.size(),
SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 2, checksum.c_str(), checksum.size(),
SQLITE_TRANSIENT);
- sqlite3_bind_int64(stmt, 3, SegmentToId(segment));
+ sqlite3_bind_int64(stmt, 3, size);
+ sqlite3_bind_int64(stmt, 4, SegmentToId(segment));
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE) {