/*
* __wt_curfile_open --
* WT_SESSION->open_cursor method for the btree cursor type.
*/
int
__wt_curfile_open(WT_SESSION_IMPL *session, const char *uri,
WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONFIG_ITEM cval;
WT_DECL_RET;
int bitmap, bulk;
uint32_t flags;
flags = 0;
WT_RET(__wt_config_gets_def(session, cfg, "bulk", 0, &cval));
if (cval.type == WT_CONFIG_ITEM_BOOL ||
(cval.type == WT_CONFIG_ITEM_NUM &&
(cval.val == 0 || cval.val == 1))) {
bitmap = 0;
bulk = (cval.val != 0);
} else if (WT_STRING_MATCH("bitmap", cval.str, cval.len))
bitmap = bulk = 1;
else
WT_RET_MSG(session, EINVAL,
"Value for 'bulk' must be a boolean or 'bitmap'");
/* Bulk handles require exclusive access. */
if (bulk)
LF_SET(WT_BTREE_BULK | WT_DHANDLE_EXCLUSIVE);
/* Get the handle and lock it while the cursor is using it. */
if (WT_PREFIX_MATCH(uri, "file:")) {
/*
* If we are opening a bulk cursor, get the handle while
* holding the checkpoint lock. This prevents a bulk cursor
* open failing with EBUSY due to a database-wide checkpoint.
*/
if (bulk)
WT_WITH_CHECKPOINT_LOCK(session, ret =
__wt_session_get_btree_ckpt(
session, uri, cfg, flags));
else
ret = __wt_session_get_btree_ckpt(
session, uri, cfg, flags);
WT_RET(ret);
} else
WT_RET(__wt_bad_object_type(session, uri));
WT_ERR(__wt_curfile_create(session, owner, cfg, bulk, bitmap, cursorp));
/* Increment the data-source's in-use counter. */
__wt_cursor_dhandle_incr_use(session);
return (0);
err: /* If the cursor could not be opened, release the handle. */
WT_TRET(__wt_session_release_btree(session));
return (ret);
}
/*
* __wt_exclusive_handle_operation --
* Get exclusive access to a file and apply a function.
*/
int
__wt_exclusive_handle_operation(WT_SESSION_IMPL *session,
const char *uri,
int (*file_func)(WT_SESSION_IMPL *, const char *[]),
const char *cfg[], uint32_t open_flags)
{
WT_DECL_RET;
/*
* If the operation requires exclusive access, close
* any open file handles, including checkpoints.
*/
if (FLD_ISSET(open_flags, WT_DHANDLE_EXCLUSIVE)) {
WT_WITH_HANDLE_LIST_WRITE_LOCK(session,
ret = __wt_conn_dhandle_close_all(
session, uri, false, false));
WT_RET(ret);
}
WT_RET(__wt_session_get_btree_ckpt(session, uri, cfg, open_flags));
WT_SAVE_DHANDLE(session, ret = file_func(session, cfg));
WT_TRET(__wt_session_release_dhandle(session));
return (ret);
}
/*
* __wt_curfile_open --
* WT_SESSION->open_cursor method for the btree cursor type.
*/
int
__wt_curfile_open(WT_SESSION_IMPL *session, const char *uri,
WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONFIG_ITEM cval;
WT_DECL_RET;
int bitmap, bulk;
uint32_t flags;
flags = 0;
WT_RET(__wt_config_gets_defno(session, cfg, "bulk", &cval));
if (cval.type == ITEM_NUM && (cval.val == 0 || cval.val == 1)) {
bitmap = 0;
bulk = (cval.val != 0);
} else if (WT_STRING_MATCH("bitmap", cval.str, cval.len))
bitmap = bulk = 1;
else
WT_RET_MSG(session, EINVAL,
"Value for 'bulk' must be a boolean or 'bitmap'");
/* Bulk handles require exclusive access. */
if (bulk)
LF_SET(WT_BTREE_BULK | WT_BTREE_EXCLUSIVE);
/* TODO: handle projections. */
/* Get the handle and lock it while the cursor is using it. */
if (WT_PREFIX_MATCH(uri, "file:"))
WT_RET(__wt_session_get_btree_ckpt(session, uri, cfg, flags));
else
WT_RET(__wt_bad_object_type(session, uri));
WT_ERR(__wt_curfile_create(session, owner, cfg, bulk, bitmap, cursorp));
return (0);
err: /* If the cursor could not be opened, release the handle. */
WT_TRET(__wt_session_release_btree(session));
return (ret);
}
/*
* __wt_curfile_open --
* WT_SESSION->open_cursor method for the btree cursor type.
*/
int
__wt_curfile_open(WT_SESSION_IMPL *session, const char *uri,
WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONFIG_ITEM cval;
WT_DECL_RET;
uint32_t flags;
/*
* Bulk and no cache handles are exclusive and may not be used by more
* than a single thread.
* Additionally set the discard flag on no cache handles so they are
* destroyed on close.
*/
flags = 0;
WT_RET(__wt_config_gets_defno(session, cfg, "bulk", &cval));
if (cval.val != 0)
LF_SET(WT_BTREE_EXCLUSIVE | WT_BTREE_BULK);
WT_RET(__wt_config_gets_defno(session, cfg, "no_cache", &cval));
if (cval.val != 0)
LF_SET(WT_BTREE_EXCLUSIVE | WT_BTREE_NO_CACHE);
/* TODO: handle projections. */
/* Get the handle and lock it while the cursor is using it. */
if (WT_PREFIX_MATCH(uri, "file:"))
WT_RET(__wt_session_get_btree_ckpt(session, uri, cfg, flags));
else
WT_RET(__wt_bad_object_type(session, uri));
WT_ERR(__wt_curfile_create(session, owner, cfg, cursorp));
return (0);
err: /* If the cursor could not be opened, release the handle. */
(void)__wt_session_release_btree(session);
return (ret);
}
/*
* __wt_curfile_open --
* WT_SESSION->open_cursor method for the btree cursor type.
*/
int
__wt_curfile_open(WT_SESSION_IMPL *session, const char *uri,
WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONFIG_ITEM cval;
WT_DECL_RET;
uint32_t flags;
bool bitmap, bulk, checkpoint_wait;
bitmap = bulk = false;
checkpoint_wait = true;
flags = 0;
/*
* Decode the bulk configuration settings. In memory databases
* ignore bulk load.
*/
if (!F_ISSET(S2C(session), WT_CONN_IN_MEMORY)) {
WT_RET(__wt_config_gets_def(session, cfg, "bulk", 0, &cval));
if (cval.type == WT_CONFIG_ITEM_BOOL ||
(cval.type == WT_CONFIG_ITEM_NUM &&
(cval.val == 0 || cval.val == 1))) {
bitmap = false;
bulk = cval.val != 0;
} else if (WT_STRING_MATCH("bitmap", cval.str, cval.len))
bitmap = bulk = true;
/*
* Unordered bulk insert is a special case used
* internally by index creation on existing tables. It
* doesn't enforce any special semantics at the file
* level. It primarily exists to avoid some locking
* problems between LSM and index creation.
*/
else if (!WT_STRING_MATCH("unordered", cval.str, cval.len))
WT_RET_MSG(session, EINVAL,
"Value for 'bulk' must be a boolean or 'bitmap'");
if (bulk) {
WT_RET(__wt_config_gets(session,
cfg, "checkpoint_wait", &cval));
checkpoint_wait = cval.val != 0;
}
}
/* Bulk handles require exclusive access. */
if (bulk)
LF_SET(WT_BTREE_BULK | WT_DHANDLE_EXCLUSIVE);
/* Get the handle and lock it while the cursor is using it. */
if (WT_PREFIX_MATCH(uri, "file:")) {
/*
* If we are opening exclusive and don't want a bulk cursor
* open to fail with EBUSY due to a database-wide checkpoint,
* get the handle while holding the checkpoint lock.
*/
if (LF_ISSET(WT_DHANDLE_EXCLUSIVE) && checkpoint_wait)
WT_WITH_CHECKPOINT_LOCK(session,
ret = __wt_session_get_btree_ckpt(
session, uri, cfg, flags));
else
ret = __wt_session_get_btree_ckpt(
session, uri, cfg, flags);
WT_RET(ret);
} else
WT_RET(__wt_bad_object_type(session, uri));
WT_ERR(__curfile_create(session, owner, cfg, bulk, bitmap, cursorp));
return (0);
err: /* If the cursor could not be opened, release the handle. */
WT_TRET(__wt_session_release_btree(session));
return (ret);
}
/*
* __wt_schema_worker --
* Get Btree handles for the object and cycle through calls to an
* underlying worker function with each handle.
*/
int
__wt_schema_worker(WT_SESSION_IMPL *session,
const char *uri,
int (*file_func)(WT_SESSION_IMPL *, const char *[]),
int (*name_func)(WT_SESSION_IMPL *, const char *),
const char *cfg[], uint32_t open_flags)
{
WT_COLGROUP *colgroup;
WT_DATA_SOURCE *dsrc;
WT_DECL_RET;
WT_INDEX *idx;
WT_SESSION *wt_session;
WT_TABLE *table;
const char *tablename;
u_int i;
table = NULL;
tablename = uri;
if (name_func != NULL)
WT_ERR(name_func(session, uri));
/* Get the btree handle(s) and call the underlying function. */
if (WT_PREFIX_MATCH(uri, "file:")) {
if (file_func != NULL) {
WT_ERR(__wt_session_get_btree_ckpt(
session, uri, cfg, open_flags));
ret = file_func(session, cfg);
WT_TRET(__wt_session_release_btree(session));
}
} else if (WT_PREFIX_MATCH(uri, "colgroup:")) {
WT_ERR(__wt_schema_get_colgroup(session, uri, NULL, &colgroup));
WT_ERR(__wt_schema_worker(session, colgroup->source,
file_func, name_func, cfg, open_flags));
} else if (WT_PREFIX_SKIP(tablename, "index:")) {
idx = NULL;
WT_ERR(__wt_schema_get_index(session, uri, NULL, &idx));
WT_ERR(__wt_schema_worker(session, idx->source,
file_func, name_func, cfg, open_flags));
} else if (WT_PREFIX_MATCH(uri, "lsm:")) {
WT_ERR(__wt_lsm_tree_worker(
session, uri, file_func, name_func, cfg, open_flags));
} else if (WT_PREFIX_SKIP(tablename, "table:")) {
WT_ERR(__wt_schema_get_table(session,
tablename, strlen(tablename), 0, &table));
WT_ASSERT(session, session->dhandle == NULL);
/*
* We could make a recursive call for each colgroup or index
* URI, but since we have already opened the table, we can take
* a short cut and skip straight to the sources. If we have a
* name function, it needs to know about the intermediate URIs.
*/
for (i = 0; i < WT_COLGROUPS(table); i++) {
colgroup = table->cgroups[i];
if (name_func != NULL)
WT_ERR(name_func(session, colgroup->name));
WT_ERR(__wt_schema_worker(session, colgroup->source,
file_func, name_func, cfg, open_flags));
}
WT_ERR(__wt_schema_open_indices(session, table));
for (i = 0; i < table->nindices; i++) {
idx = table->indices[i];
if (name_func != NULL)
WT_ERR(name_func(session, idx->name));
WT_ERR(__wt_schema_worker(session, idx->source,
file_func, name_func, cfg, open_flags));
}
} else if ((dsrc = __wt_schema_get_source(session, uri)) != NULL) {
wt_session = (WT_SESSION *)session;
if (file_func == __wt_compact && dsrc->compact != NULL)
WT_ERR(dsrc->compact(
dsrc, wt_session, uri, (WT_CONFIG_ARG *)cfg));
else if (file_func == __wt_salvage && dsrc->salvage != NULL)
WT_ERR(dsrc->salvage(
dsrc, wt_session, uri, (WT_CONFIG_ARG *)cfg));
else if (file_func == __wt_verify && dsrc->verify != NULL)
WT_ERR(dsrc->verify(
dsrc, wt_session, uri, (WT_CONFIG_ARG *)cfg));
else
WT_ERR(__wt_object_unsupported(session, uri));
} else
WT_ERR(__wt_bad_object_type(session, uri));
err: if (table != NULL)
__wt_schema_release_table(session, table);
return (ret);
}
