/*
* __wt_curbackup_open --
* WT_SESSION->open_cursor method for the backup cursor type.
*/
int
__wt_curbackup_open(WT_SESSION_IMPL *session,
const char *uri, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value_notsup, /* get-value */
__wt_cursor_set_key_notsup, /* set-key */
__wt_cursor_set_value_notsup, /* set-value */
__wt_cursor_compare_notsup, /* compare */
__wt_cursor_equals_notsup, /* equals */
__curbackup_next, /* next */
__wt_cursor_notsup, /* prev */
__curbackup_reset, /* reset */
__wt_cursor_notsup, /* search */
__wt_cursor_search_near_notsup, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_modify_notsup, /* modify */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_notsup, /* reserve */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__curbackup_close); /* close */
WT_CURSOR *cursor;
WT_CURSOR_BACKUP *cb;
WT_DECL_RET;
WT_STATIC_ASSERT(offsetof(WT_CURSOR_BACKUP, iface) == 0);
cb = NULL;
WT_RET(__wt_calloc_one(session, &cb));
cursor = &cb->iface;
*cursor = iface;
cursor->session = &session->iface;
session->bkp_cursor = cb;
cursor->key_format = "S"; /* Return the file names as the key. */
cursor->value_format = ""; /* No value. */
/*
* Start the backup and fill in the cursor's list. Acquire the schema
* lock, we need a consistent view when creating a copy.
*/
WT_WITH_CHECKPOINT_LOCK(session,
WT_WITH_SCHEMA_LOCK(session,
ret = __backup_start(session, cb, cfg)));
WT_ERR(ret);
WT_ERR(__wt_cursor_init(cursor, uri, NULL, cfg, cursorp));
if (0) {
err: WT_TRET(__curbackup_close(cursor));
*cursorp = NULL;
}
return (ret);
}
/*
* __wt_apply_single_idx --
* Apply an operation to a single index of a table.
*/
int
__wt_apply_single_idx(WT_SESSION_IMPL *session, WT_INDEX *idx,
WT_CURSOR *cur, WT_CURSOR_TABLE *ctable, int (*f)(WT_CURSOR *))
{
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__wt_cursor_notsup, /* compare */
__wt_cursor_notsup, /* equals */
__wt_cursor_notsup, /* next */
__wt_cursor_notsup, /* prev */
__wt_cursor_notsup, /* reset */
__wt_cursor_notsup, /* search */
__wt_cursor_notsup, /* search-near */
__curextract_insert, /* insert */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* reconfigure */
__wt_cursor_notsup, /* remove */
__wt_cursor_notsup); /* close */
WT_CURSOR_EXTRACTOR extract_cursor;
WT_DECL_RET;
WT_ITEM key, value;
if (idx->extractor) {
extract_cursor.iface = iface;
extract_cursor.iface.session = &session->iface;
extract_cursor.iface.key_format = idx->exkey_format;
extract_cursor.ctable = ctable;
extract_cursor.idxc = cur;
extract_cursor.f = f;
WT_RET(__wt_cursor_get_raw_key(&ctable->iface, &key));
WT_RET(__wt_cursor_get_raw_value(&ctable->iface, &value));
ret = idx->extractor->extract(idx->extractor,
&session->iface, &key, &value,
&extract_cursor.iface);
__wt_buf_free(session, &extract_cursor.iface.key);
WT_RET(ret);
} else {
WT_RET(__wt_schema_project_merge(session,
ctable->cg_cursors,
idx->key_plan, idx->key_format, &cur->key));
/*
* The index key is now set and the value is empty
* (it starts clear and is never set).
*/
F_SET(cur, WT_CURSTD_KEY_EXT | WT_CURSTD_VALUE_EXT);
WT_RET(f(cur));
}
return (0);
}
/*
* __wt_curbackup_open --
* WT_SESSION->open_cursor method for the backup cursor type.
*/
int
__wt_curbackup_open(WT_SESSION_IMPL *session,
const char *uri, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
NULL, /* get-key */
__wt_cursor_notsup, /* get-value */
__wt_cursor_notsup, /* set-key */
__wt_cursor_notsup, /* set-value */
NULL, /* compare */
__curbackup_next, /* next */
__wt_cursor_notsup, /* prev */
__curbackup_reset, /* reset */
__wt_cursor_notsup, /* search */
__wt_cursor_notsup, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__curbackup_close); /* close */
WT_CURSOR *cursor;
WT_CURSOR_BACKUP *cb;
WT_DECL_RET;
STATIC_ASSERT(offsetof(WT_CURSOR_BACKUP, iface) == 0);
cb = NULL;
WT_RET(__wt_calloc_def(session, 1, &cb));
cursor = &cb->iface;
*cursor = iface;
cursor->session = &session->iface;
session->bkp_cursor = cb;
cursor->key_format = "S"; /* Return the file names as the key. */
cursor->value_format = ""; /* No value. */
/*
* Start the backup and fill in the cursor's list. Acquire the schema
* lock, we need a consistent view when creating a copy.
*/
WT_WITH_SCHEMA_LOCK(session, ret = __backup_start(session, cb, cfg));
WT_ERR(ret);
/* __wt_cursor_init is last so we don't have to clean up on error. */
WT_ERR(__wt_cursor_init(cursor, uri, NULL, cfg, cursorp));
if (0) {
err: __wt_free(session, cb);
}
return (ret);
}
/*
* __wt_curmetadata_open --
* WT_SESSION->open_cursor method for metadata cursors.
*
* Metadata cursors are a similar to a file cursor on the special metadata
* table, except that the metadata for the metadata table (which is stored
* in the turtle file) can also be queried.
*
* Metadata cursors are read-only default.
*/
int
__wt_curmetadata_open(WT_SESSION_IMPL *session,
const char *uri, WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
NULL, /* get-key */
NULL, /* get-value */
NULL, /* set-key */
NULL, /* set-value */
__curmetadata_compare, /* compare */
__curmetadata_next, /* next */
__curmetadata_prev, /* prev */
__curmetadata_reset, /* reset */
__curmetadata_search, /* search */
__curmetadata_search_near, /* search-near */
__curmetadata_insert, /* insert */
__curmetadata_update, /* update */
__curmetadata_remove, /* remove */
__curmetadata_close); /* close */
WT_CURSOR *cursor;
WT_CURSOR_METADATA *mdc;
WT_DECL_RET;
WT_RET(__wt_calloc(session, 1, sizeof(WT_CURSOR_METADATA), &mdc));
cursor = &mdc->iface;
*cursor = iface;
cursor->session = &session->iface;
cursor->key_format = "S";
cursor->value_format = "S";
/* Open the file cursor for operations on the regular metadata */
WT_ERR(__wt_metadata_cursor(session, cfg[1], &mdc->file_cursor));
WT_ERR(__wt_cursor_init(cursor, uri, owner, cfg, cursorp));
/* Metadata cursors default to read only. */
WT_ERR(__wt_cursor_config_readonly(cursor, cfg, 1));
if (0) {
err: __wt_free(session, mdc);
}
return (ret);
}
/*
* __wt_curconfig_open --
* WT_SESSION->open_cursor method for config cursors.
*/
int
__wt_curconfig_open(WT_SESSION_IMPL *session,
const char *uri, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__wt_cursor_compare_notsup, /* compare */
__wt_cursor_equals_notsup, /* equals */
__wt_cursor_notsup, /* next */
__wt_cursor_notsup, /* prev */
__wt_cursor_noop, /* reset */
__wt_cursor_notsup, /* search */
__wt_cursor_search_near_notsup, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__curconfig_close);
WT_CURSOR_CONFIG *cconfig;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_STATIC_ASSERT(offsetof(WT_CURSOR_CONFIG, iface) == 0);
WT_UNUSED(uri);
WT_RET(__wt_calloc_one(session, &cconfig));
cursor = &cconfig->iface;
*cursor = iface;
cursor->session = &session->iface;
cursor->key_format = cursor->value_format = "S";
/* __wt_cursor_init is last so we don't have to clean up on error. */
WT_ERR(__wt_cursor_init(cursor, uri, NULL, cfg, cursorp));
if (0) {
err: __wt_free(session, cconfig);
}
return (ret);
}
/*
* __apply_idx --
* Apply an operation to all indices of a table.
*/
static int
__apply_idx(WT_CURSOR_TABLE *ctable, size_t func_off, int skip_immutable) {
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__wt_cursor_notsup, /* compare */
__wt_cursor_notsup, /* next */
__wt_cursor_notsup, /* prev */
__wt_cursor_notsup, /* reset */
__wt_cursor_notsup, /* search */
__wt_cursor_notsup, /* search-near */
__curextract_insert, /* insert */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_notsup); /* close */
WT_CURSOR **cp;
WT_CURSOR_EXTRACTOR extract_cursor;
WT_DECL_RET;
WT_INDEX *idx;
WT_ITEM key, value;
WT_SESSION_IMPL *session;
int (*f)(WT_CURSOR *);
u_int i;
cp = ctable->idx_cursors;
session = (WT_SESSION_IMPL *)ctable->iface.session;
for (i = 0; i < ctable->table->nindices; i++, cp++) {
idx = ctable->table->indices[i];
if (skip_immutable && F_ISSET(idx, WT_INDEX_IMMUTABLE))
continue;
f = *(int (**)(WT_CURSOR *))((uint8_t *)*cp + func_off);
if (idx->extractor) {
extract_cursor.iface = iface;
extract_cursor.iface.session = &session->iface;
extract_cursor.iface.key_format = idx->exkey_format;
extract_cursor.ctable = ctable;
extract_cursor.idxc = *cp;
extract_cursor.f = f;
WT_RET(__wt_cursor_get_raw_key(&ctable->iface, &key));
WT_RET(
__wt_cursor_get_raw_value(&ctable->iface, &value));
ret = idx->extractor->extract(idx->extractor,
&session->iface, &key, &value,
&extract_cursor.iface);
__wt_buf_free(session, &extract_cursor.iface.key);
WT_RET(ret);
} else {
WT_RET(__wt_schema_project_merge(session,
ctable->cg_cursors,
idx->key_plan, idx->key_format, &(*cp)->key));
/*
* The index key is now set and the value is empty
* (it starts clear and is never set).
*/
F_SET(*cp, WT_CURSTD_KEY_EXT | WT_CURSTD_VALUE_EXT);
WT_RET(f(*cp));
}
WT_RET((*cp)->reset(*cp));
}
return (0);
}
/*
* __curjoin_entry_member --
* Do a membership check for a particular index that was joined,
* if not a member, returns WT_NOTFOUND.
*/
static int
__curjoin_entry_member(WT_SESSION_IMPL *session, WT_CURSOR_JOIN_ENTRY *entry,
WT_ITEM *key, WT_CURSOR_JOIN_ITER *iter)
{
WT_CURJOIN_EXTRACTOR extract_cursor;
WT_CURSOR *c;
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__wt_cursor_compare_notsup, /* compare */
__wt_cursor_equals_notsup, /* equals */
__wt_cursor_notsup, /* next */
__wt_cursor_notsup, /* prev */
__wt_cursor_notsup, /* reset */
__wt_cursor_notsup, /* search */
__wt_cursor_search_near_notsup, /* search-near */
__curjoin_extract_insert, /* insert */
__wt_cursor_modify_notsup, /* modify */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_notsup, /* reserve */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__wt_cursor_notsup, /* cache */
__wt_cursor_reopen_notsup, /* reopen */
__wt_cursor_notsup); /* close */
WT_DECL_RET;
WT_INDEX *idx;
WT_ITEM v;
bool bloom_found;
if (entry->subjoin == NULL && iter != NULL &&
(iter->end_pos + iter->end_skip >= entry->ends_next ||
(iter->end_skip > 0 &&
F_ISSET(entry, WT_CURJOIN_ENTRY_DISJUNCTION))))
return (0); /* no checks to make */
entry->stats.membership_check++;
bloom_found = false;
if (entry->bloom != NULL) {
/*
* If the item is not in the Bloom filter, we return
* immediately, otherwise, we still may need to check the
* long way, since it may be a false positive.
*
* If we don't own the Bloom filter, we must be sharing one
* in a previous entry. So the shared filter has already
* been checked and passed, we don't need to check it again.
* We'll still need to check the long way.
*/
if (F_ISSET(entry, WT_CURJOIN_ENTRY_OWN_BLOOM))
WT_ERR(__wt_bloom_inmem_get(entry->bloom, key));
if (F_ISSET(entry, WT_CURJOIN_ENTRY_FALSE_POSITIVES))
return (0);
bloom_found = true;
}
if (entry->subjoin != NULL) {
WT_ASSERT(session,
iter == NULL || entry->subjoin == iter->child->cjoin);
ret = __curjoin_entries_in_range(session, entry->subjoin,
key, iter == NULL ? NULL : iter->child);
if (iter != NULL &&
WT_CURJOIN_ITER_CONSUMED(iter->child)) {
WT_ERR(__curjoin_iter_bump(iter));
ret = WT_NOTFOUND;
}
return (ret);
}
if (entry->index != NULL) {
/*
* If this entry is used by the iterator, then we already
* have the index key, and we won't have to do any
* extraction either.
*/
if (iter != NULL && entry == iter->entry)
WT_ITEM_SET(v, iter->idxkey);
else {
memset(&v, 0, sizeof(v)); /* Keep lint quiet. */
c = entry->main;
c->set_key(c, key);
entry->stats.main_access++;
if ((ret = c->search(c)) == 0)
ret = c->get_value(c, &v);
else if (ret == WT_NOTFOUND) {
__wt_err(session, ret,
"main table for join is missing entry");
ret = WT_ERROR;
}
WT_TRET(c->reset(c));
WT_ERR(ret);
}
} else
WT_ITEM_SET(v, *key);
if ((idx = entry->index) != NULL && idx->extractor != NULL &&
(iter == NULL || entry != iter->entry)) {
WT_CLEAR(extract_cursor);
extract_cursor.iface = iface;
extract_cursor.iface.session = &session->iface;
extract_cursor.iface.key_format = idx->exkey_format;
extract_cursor.ismember = false;
extract_cursor.entry = entry;
WT_ERR(idx->extractor->extract(idx->extractor,
&session->iface, key, &v, &extract_cursor.iface));
__wt_buf_free(session, &extract_cursor.iface.key);
__wt_buf_free(session, &extract_cursor.iface.value);
if (!extract_cursor.ismember)
WT_ERR(WT_NOTFOUND);
} else
WT_ERR(__curjoin_entry_in_range(session, entry, &v, iter));
if (0) {
err: if (ret == WT_NOTFOUND && bloom_found)
entry->stats.bloom_false_positive++;
}
return (ret);
}
/*
* __wt_curjoin_open --
* Initialize a join cursor.
*
* Join cursors are read-only.
*/
int
__wt_curjoin_open(WT_SESSION_IMPL *session,
const char *uri, WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
__curjoin_get_key, /* get-key */
__curjoin_get_value, /* get-value */
__wt_cursor_set_key_notsup, /* set-key */
__wt_cursor_set_value_notsup, /* set-value */
__wt_cursor_compare_notsup, /* compare */
__wt_cursor_equals_notsup, /* equals */
__curjoin_next, /* next */
__wt_cursor_notsup, /* prev */
__curjoin_reset, /* reset */
__wt_cursor_notsup, /* search */
__wt_cursor_search_near_notsup, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_modify_notsup, /* modify */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_notsup, /* reserve */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__wt_cursor_notsup, /* cache */
__wt_cursor_reopen_notsup, /* reopen */
__curjoin_close); /* close */
WT_CURSOR *cursor;
WT_CURSOR_JOIN *cjoin;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
WT_TABLE *table;
size_t size;
const char *tablename, *columns;
WT_STATIC_ASSERT(offsetof(WT_CURSOR_JOIN, iface) == 0);
if (owner != NULL)
WT_RET_MSG(session, EINVAL,
"unable to initialize a join cursor with existing owner");
tablename = uri;
if (!WT_PREFIX_SKIP(tablename, "join:table:"))
return (
__wt_unexpected_object_type(session, uri, "join:table:"));
columns = strchr(tablename, '(');
if (columns == NULL)
size = strlen(tablename);
else
size = WT_PTRDIFF(columns, tablename);
WT_RET(__wt_schema_get_table(
session, tablename, size, false, 0, &table));
WT_RET(__wt_calloc_one(session, &cjoin));
cursor = (WT_CURSOR *)cjoin;
*cursor = iface;
cursor->session = (WT_SESSION *)session;
cursor->key_format = table->key_format;
cursor->value_format = table->value_format;
cjoin->table = table;
/* Handle projections. */
WT_ERR(__wt_scr_alloc(session, 0, &tmp));
if (columns != NULL) {
WT_ERR(__wt_struct_reformat(session, table,
columns, strlen(columns), NULL, false, tmp));
WT_ERR(__wt_strndup(
session, tmp->data, tmp->size, &cursor->value_format));
WT_ERR(__wt_strdup(session, columns, &cjoin->projection));
}
WT_ERR(__wt_cursor_init(cursor, uri, owner, cfg, cursorp));
if (0) {
err: WT_TRET(__curjoin_close(cursor));
*cursorp = NULL;
}
__wt_scr_free(session, &tmp);
return (ret);
}
/*
* __wt_curindex_open --
* WT_SESSION->open_cursor method for index cursors.
*/
int
__wt_curindex_open(WT_SESSION_IMPL *session,
const char *uri, WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__curindex_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__curindex_set_value, /* set-value */
__curindex_compare, /* compare */
__wt_cursor_equals, /* equals */
__curindex_next, /* next */
__curindex_prev, /* prev */
__curindex_reset, /* reset */
__curindex_search, /* search */
__curindex_search_near, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__curindex_close); /* close */
WT_CURSOR_INDEX *cindex;
WT_CURSOR *cursor;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
WT_INDEX *idx;
WT_TABLE *table;
const char *columns, *idxname, *tablename;
size_t namesize;
tablename = uri;
if (!WT_PREFIX_SKIP(tablename, "index:") ||
(idxname = strchr(tablename, ':')) == NULL)
WT_RET_MSG(session, EINVAL, "Invalid cursor URI: '%s'", uri);
namesize = (size_t)(idxname - tablename);
++idxname;
if ((ret = __wt_schema_get_table(session,
tablename, namesize, false, &table)) != 0) {
if (ret == WT_NOTFOUND)
WT_RET_MSG(session, EINVAL,
"Cannot open cursor '%s' on unknown table", uri);
return (ret);
}
columns = strchr(idxname, '(');
if (columns == NULL)
namesize = strlen(idxname);
else
namesize = (size_t)(columns - idxname);
if ((ret = __wt_schema_open_index(
session, table, idxname, namesize, &idx)) != 0) {
__wt_schema_release_table(session, table);
return (ret);
}
WT_RET(__wt_calloc_one(session, &cindex));
cursor = &cindex->iface;
*cursor = iface;
cursor->session = &session->iface;
cindex->table = table;
cindex->index = idx;
cindex->key_plan = idx->key_plan;
cindex->value_plan = idx->value_plan;
cursor->internal_uri = idx->name;
cursor->key_format = idx->idxkey_format;
cursor->value_format = table->value_format;
/*
* XXX
* A very odd corner case is an index with a recno key.
* The only way to get here is by creating an index on a column store
* using only the primary's recno as the index key. Disallow that for
* now.
*/
if (WT_CURSOR_RECNO(cursor))
WT_ERR_MSG(session, WT_ERROR,
"Column store indexes based on a record number primary "
"key are not supported");
/* Handle projections. */
if (columns != NULL) {
WT_ERR(__wt_scr_alloc(session, 0, &tmp));
WT_ERR(__wt_struct_reformat(session, table,
columns, strlen(columns), NULL, false, tmp));
WT_ERR(__wt_strndup(
session, tmp->data, tmp->size, &cursor->value_format));
WT_ERR(__wt_buf_init(session, tmp, 0));
WT_ERR(__wt_struct_plan(session, table,
columns, strlen(columns), false, tmp));
WT_ERR(__wt_strndup(
session, tmp->data, tmp->size, &cindex->value_plan));
}
WT_ERR(__wt_cursor_init(
cursor, cursor->internal_uri, owner, cfg, cursorp));
WT_ERR(__wt_open_cursor(
session, idx->source, cursor, cfg, &cindex->child));
/* Open the column groups needed for this index cursor. */
WT_ERR(__curindex_open_colgroups(session, cindex, cfg));
if (F_ISSET(cursor, WT_CURSTD_DUMP_JSON))
__wt_json_column_init(
cursor, table->key_format, &idx->colconf, &table->colconf);
if (0) {
err: WT_TRET(__curindex_close(cursor));
*cursorp = NULL;
}
__wt_scr_free(session, &tmp);
return (ret);
}
/*
* __curfile_create --
* Open a cursor for a given btree handle.
*/
static int
__curfile_create(WT_SESSION_IMPL *session,
WT_CURSOR *owner, const char *cfg[], bool bulk, bool bitmap,
WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__curfile_compare, /* compare */
__curfile_equals, /* equals */
__curfile_next, /* next */
__curfile_prev, /* prev */
__curfile_reset, /* reset */
__curfile_search, /* search */
__curfile_search_near, /* search-near */
__curfile_insert, /* insert */
__wt_cursor_modify_notsup, /* modify */
__curfile_update, /* update */
__curfile_remove, /* remove */
__curfile_reserve, /* reserve */
__wt_cursor_reconfigure, /* reconfigure */
__curfile_close); /* close */
WT_BTREE *btree;
WT_CONFIG_ITEM cval;
WT_CURSOR *cursor;
WT_CURSOR_BTREE *cbt;
WT_CURSOR_BULK *cbulk;
WT_DECL_RET;
size_t csize;
WT_STATIC_ASSERT(offsetof(WT_CURSOR_BTREE, iface) == 0);
cbt = NULL;
btree = S2BT(session);
WT_ASSERT(session, btree != NULL);
csize = bulk ? sizeof(WT_CURSOR_BULK) : sizeof(WT_CURSOR_BTREE);
WT_RET(__wt_calloc(session, 1, csize, &cbt));
cursor = &cbt->iface;
*cursor = iface;
cursor->session = &session->iface;
cursor->internal_uri = btree->dhandle->name;
cursor->key_format = btree->key_format;
cursor->value_format = btree->value_format;
cbt->btree = btree;
/*
* Increment the data-source's in-use counter; done now because closing
* the cursor will decrement it, and all failure paths from here close
* the cursor.
*/
__wt_cursor_dhandle_incr_use(session);
if (session->dhandle->checkpoint != NULL)
F_SET(cbt, WT_CBT_NO_TXN);
if (bulk) {
F_SET(cursor, WT_CURSTD_BULK);
cbulk = (WT_CURSOR_BULK *)cbt;
/* Optionally skip the validation of each bulk-loaded key. */
WT_ERR(__wt_config_gets_def(
session, cfg, "skip_sort_check", 0, &cval));
WT_ERR(__wt_curbulk_init(
session, cbulk, bitmap, cval.val == 0 ? 0 : 1));
}
/*
* Random retrieval, row-store only.
* Random retrieval cursors support a limited set of methods.
*/
WT_ERR(__wt_config_gets_def(session, cfg, "next_random", 0, &cval));
if (cval.val != 0) {
if (WT_CURSOR_RECNO(cursor))
WT_ERR_MSG(session, ENOTSUP,
"next_random configuration not supported for "
"column-store objects");
__wt_cursor_set_notsup(cursor);
cursor->next = __wt_curfile_next_random;
cursor->reset = __curfile_reset;
WT_ERR(__wt_config_gets_def(
session, cfg, "next_random_sample_size", 0, &cval));
if (cval.val != 0)
cbt->next_random_sample_size = (u_int)cval.val;
}
/* Underlying btree initialization. */
__wt_btcur_open(cbt);
/*
* WT_CURSOR.modify supported on 'u' value formats, but the fast-path
* through the btree code requires log file format changes, it's not
* available in all versions.
*/
if (WT_STREQ(cursor->value_format, "u") &&
S2C(session)->compat_major >= WT_LOG_V2)
cursor->modify = __curfile_modify;
WT_ERR(__wt_cursor_init(
cursor, cursor->internal_uri, owner, cfg, cursorp));
WT_STAT_CONN_INCR(session, cursor_create);
WT_STAT_DATA_INCR(session, cursor_create);
if (0) {
err: /*
* Our caller expects to release the data handle if we fail.
* Disconnect it from the cursor before closing.
*/
if (session->dhandle != NULL)
__wt_cursor_dhandle_decr_use(session);
cbt->btree = NULL;
WT_TRET(__curfile_close(cursor));
*cursorp = NULL;
}
return (ret);
}
/*
* __wt_curds_open --
* Initialize a data-source cursor.
*/
int
__wt_curds_open(
WT_SESSION_IMPL *session, const char *uri, WT_CURSOR *owner,
const char *cfg[], WT_DATA_SOURCE *dsrc, WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
NULL, /* get-key */
NULL, /* get-value */
NULL, /* set-key */
NULL, /* set-value */
__curds_compare, /* compare */
__curds_next, /* next */
__curds_prev, /* prev */
__curds_reset, /* reset */
__curds_search, /* search */
__curds_search_near, /* search-near */
__curds_insert, /* insert */
__curds_update, /* update */
__curds_remove, /* remove */
__curds_close); /* close */
WT_CONFIG_ITEM cval;
WT_CURSOR *cursor, *source;
WT_CURSOR_DATA_SOURCE *data_source;
WT_DECL_RET;
const char *metaconf;
STATIC_ASSERT(offsetof(WT_CURSOR_DATA_SOURCE, iface) == 0);
data_source = NULL;
metaconf = NULL;
WT_RET(__wt_calloc_def(session, 1, &data_source));
cursor = &data_source->iface;
*cursor = iface;
cursor->session = &session->iface;
F_SET(cursor, WT_CURSTD_DATA_SOURCE);
/*
* XXX
* The underlying data-source may require the object's key and value
* formats. This isn't a particularly elegant way of getting that
* information to the data-source, this feels like a layering problem
* to me.
*/
WT_ERR(__wt_metadata_search(session, uri, &metaconf));
WT_ERR(__wt_config_getones(session, metaconf, "key_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len, &cursor->key_format));
WT_ERR(__wt_config_getones(session, metaconf, "value_format", &cval));
WT_ERR(
__wt_strndup(session, cval.str, cval.len, &cursor->value_format));
WT_ERR(__wt_cursor_init(cursor, uri, owner, cfg, cursorp));
/* Data-source cursors have a collator reference. */
WT_ERR(__wt_collator_config(session, cfg, &data_source->collator));
WT_ERR(dsrc->open_cursor(dsrc,
&session->iface, uri, (WT_CONFIG_ARG *)cfg, &data_source->source));
source = data_source->source;
source->session = (WT_SESSION *)session;
memset(&source->q, 0, sizeof(source->q));
source->recno = 0;
memset(source->raw_recno_buf, 0, sizeof(source->raw_recno_buf));
memset(&source->key, 0, sizeof(source->key));
memset(&source->value, 0, sizeof(source->value));
source->saved_err = 0;
source->flags = 0;
if (0) {
err: if (F_ISSET(cursor, WT_CURSTD_OPEN))
WT_TRET(cursor->close(cursor));
else
__wt_free(session, data_source);
*cursorp = NULL;
}
__wt_free(session, metaconf);
return (ret);
}
/*
* __wt_curds_create --
* Initialize a data-source cursor.
*/
int
__wt_curds_create(WT_SESSION_IMPL *session, const char *uri,
const char *cfg[], WT_DATA_SOURCE *dsrc, WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
NULL, /* get-key */
NULL, /* get-value */
NULL, /* set-key */
NULL, /* set-value */
NULL, /* compare */
__curds_next, /* next */
__curds_prev, /* prev */
__curds_reset, /* reset */
__curds_search, /* search */
__curds_search_near, /* search-near */
__curds_insert, /* insert */
__curds_update, /* update */
__curds_remove, /* remove */
__curds_close); /* close */
WT_CONFIG_ITEM cval;
WT_CURSOR *cursor, *dsc;
WT_DECL_RET;
const char *metaconf;
metaconf = NULL;
/* Open the WiredTiger cursor. */
WT_RET(__wt_calloc_def(session, 1, &cursor));
*cursor = iface;
cursor->session = (WT_SESSION *)session;
/*
* XXX
* We'll need the object's key and value formats.
*/
WT_ERR(__wt_metadata_search(session, uri, &metaconf));
WT_ERR(__wt_config_getones(session, metaconf, "key_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len, &cursor->key_format));
WT_ERR(__wt_config_getones(session, metaconf, "value_format", &cval));
WT_ERR(
__wt_strndup(session, cval.str, cval.len, &cursor->value_format));
WT_ERR(__wt_cursor_init(cursor, uri, NULL, cfg, cursorp));
WT_ERR(dsrc->open_cursor(dsrc,
&session->iface, uri, (WT_CONFIG_ARG *)cfg, &dsc));
dsc->session = (WT_SESSION *)session;
memset(&dsc->q, 0, sizeof(dsc->q));
dsc->recno = 0;
memset(dsc->raw_recno_buf, 0, sizeof(dsc->raw_recno_buf));
memset(&dsc->key, 0, sizeof(dsc->key));
memset(&dsc->value, 0, sizeof(dsc->value));
memset(&dsc->saved_err, 0, sizeof(dsc->saved_err));
dsc->data_source = NULL;
memset(&dsc->flags, 0, sizeof(dsc->flags));
/* Reference the underlying application cursor. */
cursor->data_source = dsc;
if (0) {
err: if (F_ISSET(cursor, WT_CURSTD_OPEN))
WT_TRET(cursor->close(cursor));
else
__wt_free(session, cursor);
}
__wt_free(session, metaconf);
return (ret);
}
/*
* __curjoin_entry_member --
* Do a membership check for a particular index that was joined,
* if not a member, returns WT_NOTFOUND.
*/
static int
__curjoin_entry_member(WT_SESSION_IMPL *session, WT_CURSOR_JOIN *cjoin,
WT_CURSOR_JOIN_ENTRY *entry, bool skip_left)
{
WT_CURJOIN_EXTRACTOR extract_cursor;
WT_CURSOR *c;
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__wt_cursor_notsup, /* compare */
__wt_cursor_notsup, /* equals */
__wt_cursor_notsup, /* next */
__wt_cursor_notsup, /* prev */
__wt_cursor_notsup, /* reset */
__wt_cursor_notsup, /* search */
__wt_cursor_notsup, /* search-near */
__curjoin_extract_insert, /* insert */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* reconfigure */
__wt_cursor_notsup, /* remove */
__wt_cursor_notsup); /* close */
WT_DECL_RET;
WT_INDEX *idx;
WT_ITEM *key, v;
bool bloom_found;
key = cjoin->iter->curkey;
entry->stats.accesses++;
bloom_found = false;
if (entry->bloom != NULL) {
/*
* If we don't own the Bloom filter, we must be sharing one
* in a previous entry. So the shared filter has already
* been checked and passed.
*/
if (!F_ISSET(entry, WT_CURJOIN_ENTRY_OWN_BLOOM))
return (0);
/*
* If the item is not in the Bloom filter, we return
* immediately, otherwise, we still need to check the
* long way.
*/
WT_ERR(__wt_bloom_inmem_get(entry->bloom, key));
bloom_found = true;
}
if (entry->index != NULL) {
memset(&v, 0, sizeof(v)); /* Keep lint quiet. */
c = entry->main;
c->set_key(c, key);
if ((ret = c->search(c)) == 0)
ret = c->get_value(c, &v);
else if (ret == WT_NOTFOUND)
WT_ERR_MSG(session, WT_ERROR,
"main table for join is missing entry.");
WT_TRET(c->reset(c));
WT_ERR(ret);
} else
v = *key;
if ((idx = entry->index) != NULL && idx->extractor != NULL) {
extract_cursor.iface = iface;
extract_cursor.iface.session = &session->iface;
extract_cursor.iface.key_format = idx->exkey_format;
extract_cursor.ismember = 0;
extract_cursor.entry = entry;
WT_ERR(idx->extractor->extract(idx->extractor,
&session->iface, key, &v, &extract_cursor.iface));
if (!extract_cursor.ismember)
WT_ERR(WT_NOTFOUND);
} else
WT_ERR(__curjoin_entry_in_range(session, entry, &v, skip_left));
if (0) {
err: if (ret == WT_NOTFOUND && bloom_found)
entry->stats.bloom_false_positive++;
}
return (ret);
}
/*
* __wt_curfile_create --
* Open a cursor for a given btree handle.
*/
int
__wt_curfile_create(WT_SESSION_IMPL *session,
WT_CURSOR *owner, const char *cfg[], int bulk, int bitmap,
WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
NULL, /* get-key */
NULL, /* get-value */
NULL, /* set-key */
NULL, /* set-value */
__curfile_compare, /* compare */
__curfile_next, /* next */
__curfile_prev, /* prev */
__curfile_reset, /* reset */
__curfile_search, /* search */
__curfile_search_near, /* search-near */
__curfile_insert, /* insert */
__curfile_update, /* update */
__curfile_remove, /* remove */
__curfile_close); /* close */
WT_BTREE *btree;
WT_CONFIG_ITEM cval;
WT_CURSOR *cursor;
WT_CURSOR_BTREE *cbt;
WT_DECL_RET;
size_t csize;
cbt = NULL;
btree = session->btree;
WT_ASSERT(session, btree != NULL);
csize = bulk ? sizeof(WT_CURSOR_BULK) : sizeof(WT_CURSOR_BTREE);
WT_RET(__wt_calloc(session, 1, csize, &cbt));
cursor = &cbt->iface;
*cursor = iface;
cursor->session = &session->iface;
cursor->uri = btree->name;
cursor->key_format = btree->key_format;
cursor->value_format = btree->value_format;
cbt->btree = session->btree;
if (bulk)
WT_ERR(__wt_curbulk_init((WT_CURSOR_BULK *)cbt, bitmap));
/*
* random_retrieval
* Random retrieval cursors only support next, reset and close.
*/
WT_ERR(__wt_config_gets_defno(session, cfg, "next_random", &cval));
if (cval.val != 0) {
__wt_cursor_set_notsup(cursor);
cursor->next = __curfile_next_random;
cursor->reset = __curfile_reset;
}
/* __wt_cursor_init is last so we don't have to clean up on error. */
STATIC_ASSERT(offsetof(WT_CURSOR_BTREE, iface) == 0);
WT_ERR(__wt_cursor_init(cursor, cursor->uri, owner, cfg, cursorp));
if (0) {
err: __wt_free(session, cbt);
}
return (ret);
}
/*
* __wt_curlog_open --
* Initialize a log cursor.
*/
int
__wt_curlog_open(WT_SESSION_IMPL *session,
const char *uri, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__curlog_compare, /* compare */
__wt_cursor_equals, /* equals */
__curlog_next, /* next */
__wt_cursor_notsup, /* prev */
__curlog_reset, /* reset */
__curlog_search, /* search */
__wt_cursor_search_near_notsup, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__curlog_close); /* close */
WT_CURSOR *cursor;
WT_CURSOR_LOG *cl;
WT_DECL_RET;
WT_LOG *log;
WT_STATIC_ASSERT(offsetof(WT_CURSOR_LOG, iface) == 0);
conn = S2C(session);
if (!FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED))
WT_RET_MSG(session, EINVAL,
"Cannot open a log cursor without logging enabled");
log = conn->log;
cl = NULL;
WT_RET(__wt_calloc_one(session, &cl));
cursor = &cl->iface;
*cursor = iface;
cursor->session = &session->iface;
WT_ERR(__wt_calloc_one(session, &cl->cur_lsn));
WT_ERR(__wt_calloc_one(session, &cl->next_lsn));
WT_ERR(__wt_scr_alloc(session, 0, &cl->logrec));
WT_ERR(__wt_scr_alloc(session, 0, &cl->opkey));
WT_ERR(__wt_scr_alloc(session, 0, &cl->opvalue));
cursor->key_format = WT_LOGC_KEY_FORMAT;
cursor->value_format = WT_LOGC_VALUE_FORMAT;
WT_INIT_LSN(cl->cur_lsn);
WT_INIT_LSN(cl->next_lsn);
WT_ERR(__wt_cursor_init(cursor, uri, NULL, cfg, cursorp));
/*
* The user may be trying to read a log record they just wrote.
* Log records may be buffered, so force out any now.
*/
WT_ERR(__wt_log_force_write(session, 1));
/* Log cursors block archiving. */
WT_ERR(__wt_readlock(session, log->log_archive_lock));
if (0) {
err: if (F_ISSET(cursor, WT_CURSTD_OPEN))
WT_TRET(cursor->close(cursor));
else {
__wt_free(session, cl->cur_lsn);
__wt_free(session, cl->next_lsn);
__wt_scr_free(session, &cl->logrec);
__wt_scr_free(session, &cl->opkey);
__wt_scr_free(session, &cl->opvalue);
/*
* NOTE: We cannot get on the error path with the
* readlock held. No need to unlock it unless that
* changes above.
*/
__wt_free(session, cl);
}
*cursorp = NULL;
}
return (ret);
}
/*
* __wt_curlog_open --
* Initialize a log cursor.
*/
int
__wt_curlog_open(WT_SESSION_IMPL *session,
const char *uri, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__curlog_compare, /* compare */
__wt_cursor_equals, /* equals */
__curlog_next, /* next */
__wt_cursor_notsup, /* prev */
__curlog_reset, /* reset */
__curlog_search, /* search */
__wt_cursor_search_near_notsup, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_modify_notsup, /* modify */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_notsup, /* reserve */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__wt_cursor_notsup, /* cache */
__wt_cursor_reopen_notsup, /* reopen */
__curlog_close); /* close */
WT_CURSOR *cursor;
WT_CURSOR_LOG *cl;
WT_DECL_RET;
WT_LOG *log;
WT_STATIC_ASSERT(offsetof(WT_CURSOR_LOG, iface) == 0);
conn = S2C(session);
log = conn->log;
WT_RET(__wt_calloc_one(session, &cl));
cursor = (WT_CURSOR *)cl;
*cursor = iface;
cursor->session = (WT_SESSION *)session;
cursor->key_format = WT_LOGC_KEY_FORMAT;
cursor->value_format = WT_LOGC_VALUE_FORMAT;
WT_ERR(__wt_calloc_one(session, &cl->cur_lsn));
WT_ERR(__wt_calloc_one(session, &cl->next_lsn));
WT_ERR(__wt_scr_alloc(session, 0, &cl->logrec));
WT_ERR(__wt_scr_alloc(session, 0, &cl->opkey));
WT_ERR(__wt_scr_alloc(session, 0, &cl->opvalue));
WT_INIT_LSN(cl->cur_lsn);
WT_INIT_LSN(cl->next_lsn);
WT_ERR(__wt_cursor_init(cursor, uri, NULL, cfg, cursorp));
if (log != NULL) {
/*
* The user may be trying to read a log record they just wrote.
* Log records may be buffered, so force out any now.
*/
WT_ERR(__wt_log_force_write(session, 1, NULL));
/* Log cursors block archiving. */
__wt_readlock(session, &log->log_archive_lock);
F_SET(cl, WT_CURLOG_ARCHIVE_LOCK);
(void)__wt_atomic_add32(&conn->log_cursors, 1);
}
if (0) {
err: WT_TRET(__curlog_close(cursor));
*cursorp = NULL;
}
return (ret);
}
/*
* __wt_curlog_open --
* Initialize a log cursor.
*/
int
__wt_curlog_open(WT_SESSION_IMPL *session,
const char *uri, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR_STATIC_INIT(iface,
NULL, /* get-key */
NULL, /* get-value */
NULL, /* set-key */
NULL, /* set-value */
__curlog_compare, /* compare */
__curlog_next, /* next */
__wt_cursor_notsup, /* prev */
__curlog_reset, /* reset */
__curlog_search, /* search */
__wt_cursor_notsup, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__curlog_close); /* close */
WT_CURSOR *cursor;
WT_CURSOR_LOG *cl;
WT_DECL_RET;
STATIC_ASSERT(offsetof(WT_CURSOR_LOG, iface) == 0);
conn = S2C(session);
if (!conn->logging)
WT_RET_MSG(session, EINVAL,
"Cannot open a log cursor without logging enabled");
cl = NULL;
WT_RET(__wt_calloc_def(session, 1, &cl));
cursor = &cl->iface;
*cursor = iface;
cursor->session = &session->iface;
WT_ERR(__wt_calloc_def(session, 1, &cl->cur_lsn));
WT_ERR(__wt_calloc_def(session, 1, &cl->next_lsn));
WT_ERR(__wt_scr_alloc(session, 0, &cl->logrec));
WT_ERR(__wt_scr_alloc(session, 0, &cl->opkey));
WT_ERR(__wt_scr_alloc(session, 0, &cl->opvalue));
cursor->key_format = LOGC_KEY_FORMAT;
cursor->value_format = LOGC_VALUE_FORMAT;
INIT_LSN(cl->cur_lsn);
INIT_LSN(cl->next_lsn);
WT_ERR(__wt_cursor_init(cursor, uri, NULL, cfg, cursorp));
/* Log cursors default to read only. */
WT_ERR(__wt_cursor_config_readonly(cursor, cfg, 1));
if (0) {
err: if (F_ISSET(cursor, WT_CURSTD_OPEN))
WT_TRET(cursor->close(cursor));
else {
__wt_free(session, cl->cur_lsn);
__wt_free(session, cl->next_lsn);
__wt_scr_free(&cl->logrec);
__wt_scr_free(&cl->opkey);
__wt_scr_free(&cl->opvalue);
__wt_free(session, cl);
}
*cursorp = NULL;
}
return (ret);
}
/*
* __wt_curds_open --
* Initialize a data-source cursor.
*/
int
__wt_curds_open(
WT_SESSION_IMPL *session, const char *uri, WT_CURSOR *owner,
const char *cfg[], WT_DATA_SOURCE *dsrc, WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__curds_compare, /* compare */
__wt_cursor_equals, /* equals */
__curds_next, /* next */
__curds_prev, /* prev */
__curds_reset, /* reset */
__curds_search, /* search */
__curds_search_near, /* search-near */
__curds_insert, /* insert */
__wt_cursor_modify_notsup, /* modify */
__curds_update, /* update */
__curds_remove, /* remove */
__curds_reserve, /* reserve */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__curds_close); /* close */
WT_CONFIG_ITEM cval, metadata;
WT_CURSOR *cursor, *source;
WT_CURSOR_DATA_SOURCE *data_source;
WT_DECL_RET;
char *metaconf;
WT_STATIC_ASSERT(offsetof(WT_CURSOR_DATA_SOURCE, iface) == 0);
data_source = NULL;
metaconf = NULL;
WT_RET(__wt_calloc_one(session, &data_source));
cursor = &data_source->iface;
*cursor = iface;
cursor->session = &session->iface;
/*
* XXX
* The underlying data-source may require the object's key and value
* formats. This isn't a particularly elegant way of getting that
* information to the data-source, this feels like a layering problem
* to me.
*/
WT_ERR(__wt_metadata_search(session, uri, &metaconf));
WT_ERR(__wt_config_getones(session, metaconf, "key_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len, &cursor->key_format));
WT_ERR(__wt_config_getones(session, metaconf, "value_format", &cval));
WT_ERR(
__wt_strndup(session, cval.str, cval.len, &cursor->value_format));
WT_ERR(__wt_cursor_init(cursor, uri, owner, cfg, cursorp));
/* Data-source cursors may have a custom collator. */
ret = __wt_config_getones(session, metaconf, "collator", &cval);
if (ret == 0 && cval.len != 0) {
WT_CLEAR(metadata);
WT_ERR_NOTFOUND_OK(__wt_config_getones(
session, metaconf, "app_metadata", &metadata));
WT_ERR(__wt_collator_config(session, uri, &cval, &metadata,
&data_source->collator, &data_source->collator_owned));
}
WT_ERR_NOTFOUND_OK(ret);
WT_ERR(dsrc->open_cursor(dsrc,
&session->iface, uri, (WT_CONFIG_ARG *)cfg, &data_source->source));
source = data_source->source;
source->session = (WT_SESSION *)session;
memset(&source->q, 0, sizeof(source->q));
source->recno = WT_RECNO_OOB;
memset(source->raw_recno_buf, 0, sizeof(source->raw_recno_buf));
memset(&source->key, 0, sizeof(source->key));
memset(&source->value, 0, sizeof(source->value));
source->saved_err = 0;
source->flags = 0;
if (0) {
err: WT_TRET(__curds_close(cursor));
*cursorp = NULL;
}
__wt_free(session, metaconf);
return (ret);
}
/*
* __wt_curfile_create --
* Open a cursor for a given btree handle.
*/
int
__wt_curfile_create(WT_SESSION_IMPL *session,
WT_CURSOR *owner, const char *cfg[], int bulk, int bitmap,
WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__curfile_compare, /* compare */
__curfile_equals, /* equals */
__curfile_next, /* next */
__curfile_prev, /* prev */
__curfile_reset, /* reset */
__curfile_search, /* search */
__curfile_search_near, /* search-near */
__curfile_insert, /* insert */
__curfile_update, /* update */
__curfile_remove, /* remove */
__wt_cursor_reconfigure, /* reconfigure */
__curfile_close); /* close */
WT_BTREE *btree;
WT_CONFIG_ITEM cval;
WT_CURSOR *cursor;
WT_CURSOR_BTREE *cbt;
WT_CURSOR_BULK *cbulk;
WT_DECL_RET;
size_t csize;
WT_STATIC_ASSERT(offsetof(WT_CURSOR_BTREE, iface) == 0);
cbt = NULL;
btree = S2BT(session);
WT_ASSERT(session, btree != NULL);
csize = bulk ? sizeof(WT_CURSOR_BULK) : sizeof(WT_CURSOR_BTREE);
WT_RET(__wt_calloc(session, 1, csize, &cbt));
cursor = &cbt->iface;
*cursor = iface;
cursor->session = &session->iface;
cursor->internal_uri = btree->dhandle->name;
cursor->key_format = btree->key_format;
cursor->value_format = btree->value_format;
cbt->btree = btree;
if (bulk) {
F_SET(cursor, WT_CURSTD_BULK);
cbulk = (WT_CURSOR_BULK *)cbt;
/* Optionally skip the validation of each bulk-loaded key. */
WT_ERR(__wt_config_gets_def(
session, cfg, "skip_sort_check", 0, &cval));
WT_ERR(__wt_curbulk_init(
session, cbulk, bitmap, cval.val == 0 ? 0 : 1));
}
/*
* random_retrieval
* Random retrieval cursors only support next, reset and close.
*/
WT_ERR(__wt_config_gets_def(session, cfg, "next_random", 0, &cval));
if (cval.val != 0) {
__wt_cursor_set_notsup(cursor);
cursor->next = __curfile_next_random;
cursor->reset = __curfile_reset;
}
/* Underlying btree initialization. */
__wt_btcur_open(cbt);
/* __wt_cursor_init is last so we don't have to clean up on error. */
WT_ERR(__wt_cursor_init(
cursor, cursor->internal_uri, owner, cfg, cursorp));
WT_STAT_FAST_CONN_INCR(session, cursor_create);
WT_STAT_FAST_DATA_INCR(session, cursor_create);
if (0) {
err: __wt_free(session, cbt);
}
return (ret);
}
/*
* __wt_curmetadata_open --
* WT_SESSION->open_cursor method for metadata cursors.
*
* Metadata cursors are a similar to a file cursor on the special metadata
* table, except that the metadata for the metadata table (which is stored
* in the turtle file) can also be queried.
*
* Metadata cursors are read-only by default.
*/
int
__wt_curmetadata_open(WT_SESSION_IMPL *session,
const char *uri, WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__wt_cursor_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__wt_cursor_set_value, /* set-value */
__curmetadata_compare, /* compare */
__wt_cursor_equals, /* equals */
__curmetadata_next, /* next */
__curmetadata_prev, /* prev */
__curmetadata_reset, /* reset */
__curmetadata_search, /* search */
__curmetadata_search_near, /* search-near */
__curmetadata_insert, /* insert */
__curmetadata_update, /* update */
__curmetadata_remove, /* remove */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__curmetadata_close); /* close */
WT_CURSOR *cursor;
WT_CURSOR_METADATA *mdc;
WT_DECL_RET;
WT_CONFIG_ITEM cval;
WT_RET(__wt_calloc_one(session, &mdc));
cursor = &mdc->iface;
*cursor = iface;
cursor->session = &session->iface;
cursor->key_format = "S";
cursor->value_format = "S";
/*
* Open the file cursor for operations on the regular metadata; don't
* use the existing, cached session metadata cursor, the configuration
* may not be the same.
*/
WT_ERR(__wt_metadata_cursor_open(session, cfg[1], &mdc->file_cursor));
WT_ERR(__wt_cursor_init(cursor, uri, owner, cfg, cursorp));
/* If we are only returning create config, strip internal metadata. */
if (WT_STREQ(uri, "metadata:create"))
F_SET(mdc, WT_MDC_CREATEONLY);
/*
* Metadata cursors default to readonly; if not set to not-readonly,
* they are permanently readonly and cannot be reconfigured.
*/
WT_ERR(__wt_config_gets_def(session, cfg, "readonly", 1, &cval));
if (cval.val != 0) {
cursor->insert = __wt_cursor_notsup;
cursor->update = __wt_cursor_notsup;
cursor->remove = __wt_cursor_notsup;
}
if (0) {
err: WT_TRET(__curmetadata_close(cursor));
*cursorp = NULL;
}
return (ret);
}
