/*
* __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_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);
}
/*
* __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_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_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_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_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);
}
/*
* __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);
}