/* This function's caller ignores most errors it returns.
If you extend this function, check the callsite to see if you have
to make it not-ignore additional error codes. */
svn_error_t *
svn_fs_fs__get_rep_reference(representation_t **rep,
svn_fs_t *fs,
svn_checksum_t *checksum,
apr_pool_t *pool)
{
fs_fs_data_t *ffd = fs->fsap_data;
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
SVN_ERR_ASSERT(ffd->rep_sharing_allowed);
if (! ffd->rep_cache_db)
SVN_ERR(svn_fs_fs__open_rep_cache(fs, pool));
/* We only allow SHA1 checksums in this table. */
if (checksum->kind != svn_checksum_sha1)
return svn_error_create(SVN_ERR_BAD_CHECKSUM_KIND, NULL,
_("Only SHA1 checksums can be used as keys in the "
"rep_cache table.\n"));
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db, STMT_GET_REP));
SVN_ERR(svn_sqlite__bindf(stmt, "s",
svn_checksum_to_cstring(checksum, pool)));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
if (have_row)
{
*rep = apr_pcalloc(pool, sizeof(**rep));
svn_fs_fs__id_txn_reset(&(*rep)->txn_id);
memcpy((*rep)->sha1_digest, checksum->digest,
sizeof((*rep)->sha1_digest));
(*rep)->has_sha1 = TRUE;
(*rep)->revision = svn_sqlite__column_revnum(stmt, 0);
(*rep)->item_index = svn_sqlite__column_int64(stmt, 1);
(*rep)->size = svn_sqlite__column_int64(stmt, 2);
(*rep)->expanded_size = svn_sqlite__column_int64(stmt, 3);
}
else
*rep = NULL;
SVN_ERR(svn_sqlite__reset(stmt));
if (*rep)
{
/* Check that REP refers to a revision that exists in FS. */
svn_error_t *err = svn_fs_fs__ensure_revision_exists((*rep)->revision,
fs, pool);
if (err)
return svn_error_createf(SVN_ERR_FS_CORRUPT, err,
"Checksum '%s' in rep-cache is beyond HEAD",
svn_checksum_to_cstring_display(checksum,
pool));
}
return SVN_NO_ERROR;
}
/* This function's caller ignores most errors it returns.
If you extend this function, check the callsite to see if you have
to make it not-ignore additional error codes. */
svn_error_t *
svn_fs_fs__get_rep_reference(representation_t **rep,
svn_fs_t *fs,
svn_checksum_t *checksum,
apr_pool_t *pool)
{
fs_fs_data_t *ffd = fs->fsap_data;
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
SVN_ERR_ASSERT(ffd->rep_sharing_allowed);
if (! ffd->rep_cache_db)
SVN_ERR(svn_fs_fs__open_rep_cache(fs, pool));
/* We only allow SHA1 checksums in this table. */
if (checksum->kind != svn_checksum_sha1)
return svn_error_create(SVN_ERR_BAD_CHECKSUM_KIND, NULL,
_("Only SHA1 checksums can be used as keys in the "
"rep_cache table.\n"));
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db, STMT_GET_REP));
SVN_ERR(svn_sqlite__bindf(stmt, "s",
svn_checksum_to_cstring(checksum, pool)));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
if (have_row)
{
*rep = apr_pcalloc(pool, sizeof(**rep));
(*rep)->sha1_checksum = svn_checksum_dup(checksum, pool);
(*rep)->revision = svn_sqlite__column_revnum(stmt, 0);
(*rep)->offset = svn_sqlite__column_int64(stmt, 1);
(*rep)->size = svn_sqlite__column_int64(stmt, 2);
(*rep)->expanded_size = svn_sqlite__column_int64(stmt, 3);
}
else
*rep = NULL;
if (*rep)
SVN_ERR(rep_has_been_born(*rep, fs, pool));
return svn_sqlite__reset(stmt);
}
/* Transaction implementation of svn_wc__db_pristine_transfer().
We have a lock on DST_WCROOT.
*/
static svn_error_t *
pristine_transfer_txn(svn_wc__db_wcroot_t *src_wcroot,
svn_wc__db_wcroot_t *dst_wcroot,
const char *src_relpath,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *scratch_pool)
{
svn_sqlite__stmt_t *stmt;
svn_boolean_t got_row;
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
SVN_ERR(svn_sqlite__get_statement(&stmt, src_wcroot->sdb,
STMT_SELECT_COPY_PRISTINES));
SVN_ERR(svn_sqlite__bindf(stmt, "is", src_wcroot->wc_id, src_relpath));
/* This obtains an sqlite read lock on src_wcroot */
SVN_ERR(svn_sqlite__step(&got_row, stmt));
while (got_row)
{
const svn_checksum_t *checksum;
const svn_checksum_t *md5_checksum;
apr_int64_t size;
svn_error_t *err;
svn_pool_clear(iterpool);
SVN_ERR(svn_sqlite__column_checksum(&checksum, stmt, 0, iterpool));
SVN_ERR(svn_sqlite__column_checksum(&md5_checksum, stmt, 1, iterpool));
size = svn_sqlite__column_int64(stmt, 2);
err = maybe_transfer_one_pristine(src_wcroot, dst_wcroot,
checksum, md5_checksum, size,
cancel_func, cancel_baton,
iterpool);
if (err)
return svn_error_trace(svn_error_compose_create(
err,
svn_sqlite__reset(stmt)));
SVN_ERR(svn_sqlite__step(&got_row, stmt));
}
SVN_ERR(svn_sqlite__reset(stmt));
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
/* Set *CONTENTS to a readable stream from which the pristine text
* identified by SHA1_CHECKSUM and PRISTINE_ABSPATH can be read from the
* pristine store of WCROOT. If SIZE is not null, set *SIZE to the size
* in bytes of that text. If that text is not in the pristine store,
* return an error.
*
* Even if the pristine text is removed from the store while it is being
* read, the stream will remain valid and readable until it is closed.
*
* Allocate the stream in RESULT_POOL.
*
* This function expects to be executed inside a SQLite txn.
*
* Implements 'notes/wc-ng/pristine-store' section A-3(d).
*/
static svn_error_t *
pristine_read_txn(svn_stream_t **contents,
svn_filesize_t *size,
svn_wc__db_wcroot_t *wcroot,
const svn_checksum_t *sha1_checksum,
const char *pristine_abspath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
/* Check that this pristine text is present in the store. (The presence
* of the file is not sufficient.) */
SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
STMT_SELECT_PRISTINE_SIZE));
SVN_ERR(svn_sqlite__bind_checksum(stmt, 1, sha1_checksum, scratch_pool));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
if (size)
*size = svn_sqlite__column_int64(stmt, 0);
SVN_ERR(svn_sqlite__reset(stmt));
if (! have_row)
{
return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL,
_("Pristine text '%s' not present"),
svn_checksum_to_cstring_display(
sha1_checksum, scratch_pool));
}
/* Open the file as a readable stream. It will remain readable even when
* deleted from disk; APR guarantees that on Windows as well as Unix.
*
* We also don't enable APR_BUFFERED on this file to maximize throughput
* e.g. for fulltext comparison. As we use SVN__STREAM_CHUNK_SIZE buffers
* where needed in streams, there is no point in having another layer of
* buffers. */
if (contents)
{
apr_file_t *file;
SVN_ERR(svn_io_file_open(&file, pristine_abspath, APR_READ,
APR_OS_DEFAULT, result_pool));
*contents = svn_stream_from_aprfile2(file, FALSE, result_pool);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__db_util_fetch_wc_id(apr_int64_t *wc_id,
svn_sqlite__db_t *sdb,
apr_pool_t *scratch_pool)
{
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
/* ### cheat. we know there is just one WORKING_COPY row, and it has a
### NULL value for local_abspath. */
SVN_ERR(svn_sqlite__get_statement(&stmt, sdb, STMT_SELECT_WCROOT_NULL));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
if (!have_row)
return svn_error_createf(SVN_ERR_WC_CORRUPT, svn_sqlite__reset(stmt),
_("Missing a row in WCROOT."));
SVN_ERR_ASSERT(!svn_sqlite__column_is_null(stmt, 0));
*wc_id = svn_sqlite__column_int64(stmt, 0);
return svn_error_trace(svn_sqlite__reset(stmt));
}
svn_error_t *
svn_fs_fs__walk_rep_reference(svn_fs_t *fs,
svn_error_t *(*walker)(representation_t *,
void *,
svn_fs_t *,
apr_pool_t *),
void *walker_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
fs_fs_data_t *ffd = fs->fsap_data;
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
int iterations = 0;
apr_pool_t *iterpool = svn_pool_create(pool);
/* Don't check ffd->rep_sharing_allowed. */
SVN_ERR_ASSERT(ffd->format >= SVN_FS_FS__MIN_REP_SHARING_FORMAT);
if (! ffd->rep_cache_db)
SVN_ERR(svn_fs_fs__open_rep_cache(fs, pool));
/* Get the statement. (There are no arguments to bind.) */
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db,
STMT_GET_ALL_REPS));
/* Walk the cache entries. */
SVN_ERR(svn_sqlite__step(&have_row, stmt));
while (have_row)
{
representation_t *rep;
const char *sha1_digest;
/* Clear ITERPOOL occasionally. */
if (iterations++ % 16 == 0)
svn_pool_clear(iterpool);
/* Check for cancellation. */
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
/* Construct a representation_t. */
rep = apr_pcalloc(iterpool, sizeof(*rep));
sha1_digest = svn_sqlite__column_text(stmt, 0, iterpool);
SVN_ERR(svn_checksum_parse_hex(&rep->sha1_checksum,
svn_checksum_sha1, sha1_digest,
iterpool));
rep->revision = svn_sqlite__column_revnum(stmt, 1);
rep->offset = svn_sqlite__column_int64(stmt, 2);
rep->size = svn_sqlite__column_int64(stmt, 3);
rep->expanded_size = svn_sqlite__column_int64(stmt, 4);
/* Sanity check. */
if (rep)
SVN_ERR(rep_has_been_born(rep, fs, iterpool));
/* Walk. */
SVN_ERR(walker(rep, walker_baton, fs, iterpool));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
}
SVN_ERR(svn_sqlite__reset(stmt));
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_fs__walk_rep_reference(svn_fs_t *fs,
svn_revnum_t start,
svn_revnum_t end,
svn_error_t *(*walker)(representation_t *,
void *,
svn_fs_t *,
apr_pool_t *),
void *walker_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
fs_fs_data_t *ffd = fs->fsap_data;
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
int iterations = 0;
apr_pool_t *iterpool = svn_pool_create(pool);
/* Don't check ffd->rep_sharing_allowed. */
SVN_ERR_ASSERT(ffd->format >= SVN_FS_FS__MIN_REP_SHARING_FORMAT);
if (! ffd->rep_cache_db)
SVN_ERR(svn_fs_fs__open_rep_cache(fs, pool));
/* Check global invariants. */
if (start == 0)
{
svn_revnum_t max;
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db,
STMT_GET_MAX_REV));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
max = svn_sqlite__column_revnum(stmt, 0);
SVN_ERR(svn_sqlite__reset(stmt));
if (SVN_IS_VALID_REVNUM(max)) /* The rep-cache could be empty. */
SVN_ERR(svn_fs_fs__ensure_revision_exists(max, fs, iterpool));
}
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db,
STMT_GET_REPS_FOR_RANGE));
SVN_ERR(svn_sqlite__bindf(stmt, "rr",
start, end));
/* Walk the cache entries. */
SVN_ERR(svn_sqlite__step(&have_row, stmt));
while (have_row)
{
representation_t *rep;
const char *sha1_digest;
svn_error_t *err;
svn_checksum_t *checksum;
/* Clear ITERPOOL occasionally. */
if (iterations++ % 16 == 0)
svn_pool_clear(iterpool);
/* Check for cancellation. */
if (cancel_func)
{
err = cancel_func(cancel_baton);
if (err)
return svn_error_compose_create(err, svn_sqlite__reset(stmt));
}
/* Construct a representation_t. */
rep = apr_pcalloc(iterpool, sizeof(*rep));
svn_fs_fs__id_txn_reset(&rep->txn_id);
sha1_digest = svn_sqlite__column_text(stmt, 0, iterpool);
err = svn_checksum_parse_hex(&checksum, svn_checksum_sha1,
sha1_digest, iterpool);
if (err)
return svn_error_compose_create(err, svn_sqlite__reset(stmt));
rep->has_sha1 = TRUE;
memcpy(rep->sha1_digest, checksum->digest, sizeof(rep->sha1_digest));
rep->revision = svn_sqlite__column_revnum(stmt, 1);
rep->item_index = svn_sqlite__column_int64(stmt, 2);
rep->size = svn_sqlite__column_int64(stmt, 3);
rep->expanded_size = svn_sqlite__column_int64(stmt, 4);
/* Walk. */
err = walker(rep, walker_baton, fs, iterpool);
if (err)
return svn_error_compose_create(err, svn_sqlite__reset(stmt));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
}
SVN_ERR(svn_sqlite__reset(stmt));
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
