int
svn_fs_bdb__open_strings_table(DB **strings_p,
DB_ENV *env,
svn_boolean_t create)
{
const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0);
DB *strings;
BDB_ERR(svn_fs_bdb__check_version());
BDB_ERR(db_create(&strings, env, 0));
/* Enable duplicate keys. This allows the data to be spread out across
multiple records. Note: this must occur before ->open(). */
BDB_ERR(strings->set_flags(strings, DB_DUP));
BDB_ERR((strings->open)(SVN_BDB_OPEN_PARAMS(strings, NULL),
"strings", 0, DB_BTREE,
open_flags, 0666));
if (create)
{
DBT key, value;
/* Create the `next-key' table entry. */
BDB_ERR(strings->put
(strings, 0,
svn_fs_base__str_to_dbt(&key, NEXT_KEY_KEY),
svn_fs_base__str_to_dbt(&value, "0"), 0));
}
*strings_p = strings;
return 0;
}
int
svn_fs_bdb__open_reps_table(DB **reps_p,
DB_ENV *env,
svn_boolean_t create)
{
const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0);
DB *reps;
BDB_ERR(svn_fs_bdb__check_version());
BDB_ERR(db_create(&reps, env, 0));
BDB_ERR((reps->open)(SVN_BDB_OPEN_PARAMS(reps, NULL),
"representations", 0, DB_BTREE,
open_flags, 0666));
/* Create the `next-key' table entry. */
if (create)
{
DBT key, value;
BDB_ERR(reps->put
(reps, 0,
svn_fs_base__str_to_dbt(&key, NEXT_KEY_KEY),
svn_fs_base__str_to_dbt(&value, "0"), 0));
}
*reps_p = reps;
return 0;
}
int svn_fs_bdb__open_checksum_reps_table(DB **checksum_reps_p,
DB_ENV *env,
svn_boolean_t create)
{
const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0);
DB *checksum_reps;
int error;
BDB_ERR(svn_fs_bdb__check_version());
BDB_ERR(db_create(&checksum_reps, env, 0));
error = (checksum_reps->open)(SVN_BDB_OPEN_PARAMS(checksum_reps, NULL),
"checksum-reps", 0, DB_BTREE,
open_flags, 0666);
/* Create the checksum-reps table if it doesn't exist. */
if (error == ENOENT && (! create))
{
BDB_ERR(checksum_reps->close(checksum_reps, 0));
return svn_fs_bdb__open_checksum_reps_table(checksum_reps_p, env, TRUE);
}
/* Create the initial `next-key' table entry. */
if (create)
{
DBT key, value;
BDB_ERR(checksum_reps->put(checksum_reps, 0,
svn_fs_base__str_to_dbt(&key, NEXT_KEY_KEY),
svn_fs_base__str_to_dbt(&value, "0"), 0));
}
BDB_ERR(error);
*checksum_reps_p = checksum_reps;
return 0;
}
int svn_fs_bdb__open_node_origins_table(DB **node_origins_p,
DB_ENV *env,
svn_boolean_t create)
{
const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0);
DB *node_origins;
int error;
BDB_ERR(svn_fs_bdb__check_version());
BDB_ERR(db_create(&node_origins, env, 0));
error = (node_origins->open)(SVN_BDB_OPEN_PARAMS(node_origins, NULL),
"node-origins", 0, DB_BTREE,
open_flags, 0666);
/* Create the node-origins table if it doesn't exist. */
if (error == ENOENT && (! create))
{
BDB_ERR(node_origins->close(node_origins, 0));
return svn_fs_bdb__open_node_origins_table(node_origins_p, env, TRUE);
}
BDB_ERR(error);
*node_origins_p = node_origins;
return 0;
}
int
svn_fs_bdb__open_locks_table(DB **locks_p,
DB_ENV *env,
svn_boolean_t create)
{
const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0);
DB *locks;
int error;
BDB_ERR(svn_fs_bdb__check_version());
BDB_ERR(db_create(&locks, env, 0));
error = (locks->open)(SVN_BDB_OPEN_PARAMS(locks, NULL),
"locks", 0, DB_BTREE,
open_flags, 0666);
/* Create the table if it doesn't yet exist. This is a form of
automagical repository upgrading. */
if (error == ENOENT && (! create))
{
BDB_ERR(locks->close(locks, 0));
return svn_fs_bdb__open_locks_table(locks_p, env, TRUE);
}
BDB_ERR(error);
*locks_p = locks;
return 0;
}
int
svn_fs_bdb__open_nodes_table(DB **nodes_p,
DB_ENV *env,
svn_boolean_t create)
{
const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0);
DB *nodes;
BDB_ERR(svn_fs_bdb__check_version());
BDB_ERR(db_create(&nodes, env, 0));
BDB_ERR((nodes->open)(SVN_BDB_OPEN_PARAMS(nodes, NULL),
"nodes", 0, DB_BTREE,
open_flags, 0666));
/* Create the `next-key' table entry (use '1' because '0' is
reserved for the root directory to use). */
if (create)
{
DBT key, value;
BDB_ERR(nodes->put(nodes, 0,
svn_fs_base__str_to_dbt(&key, NEXT_KEY_KEY),
svn_fs_base__str_to_dbt(&value, "1"), 0));
}
*nodes_p = nodes;
return 0;
}
int
svn_fs_bdb__open_miscellaneous_table(DB **miscellaneous_p,
DB_ENV *env,
svn_boolean_t create)
{
const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0);
DB *miscellaneous;
int error;
BDB_ERR(svn_fs_bdb__check_version());
BDB_ERR(db_create(&miscellaneous, env, 0));
error = (miscellaneous->open)(SVN_BDB_OPEN_PARAMS(miscellaneous, NULL),
"miscellaneous", 0, DB_BTREE,
open_flags, 0666);
/* Create the table if it doesn't yet exist. This is a form of
automagical repository upgrading. */
if (error == ENOENT && (! create))
{
BDB_ERR(miscellaneous->close(miscellaneous, 0));
return svn_fs_bdb__open_miscellaneous_table(miscellaneous_p, env, TRUE);
}
BDB_ERR(error);
/* If we're creating the table from scratch (not upgrading), record the
upgrade rev as 0. */
if (create)
{
DBT key, value;
BDB_ERR(miscellaneous->put
(miscellaneous, 0,
svn_fs_base__str_to_dbt
(&key, SVN_FS_BASE__MISC_FORWARD_DELTA_UPGRADE),
svn_fs_base__str_to_dbt(&value, "0"), 0));
}
*miscellaneous_p = miscellaneous;
return 0;
}
int
svn_fs_bdb__open_changes_table(DB **changes_p,
DB_ENV *env,
svn_boolean_t create)
{
const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0);
DB *changes;
BDB_ERR(svn_fs_bdb__check_version());
BDB_ERR(db_create(&changes, env, 0));
/* Enable duplicate keys. This allows us to store the changes
one-per-row. Note: this must occur before ->open(). */
BDB_ERR(changes->set_flags(changes, DB_DUP));
BDB_ERR((changes->open)(SVN_BDB_OPEN_PARAMS(changes, NULL),
"changes", 0, DB_BTREE,
open_flags, 0666));
*changes_p = changes;
return 0;
}