/*
* __wt_clsm_open_bulk --
* WT_SESSION->open_cursor method for LSM bulk cursors.
*/
int
__wt_clsm_open_bulk(WT_CURSOR_LSM *clsm, const char *cfg[])
{
WT_CURSOR *cursor, *bulk_cursor;
WT_LSM_TREE *lsm_tree;
WT_SESSION_IMPL *session;
bulk_cursor = NULL;
cursor = &clsm->iface;
lsm_tree = clsm->lsm_tree;
session = (WT_SESSION_IMPL *)clsm->iface.session;
F_SET(clsm, WT_CLSM_BULK);
/* Bulk cursors are limited to insert and close. */
__wt_cursor_set_notsup(cursor);
cursor->insert = __clsm_insert_bulk;
cursor->close = __clsm_close_bulk;
/* Setup the first chunk in the tree. */
WT_RET(__wt_clsm_request_switch(clsm));
WT_RET(__wt_clsm_await_switch(clsm));
/*
* Grab and release the LSM tree lock to ensure that the first chunk
* has been fully created before proceeding. We have the LSM tree
* open exclusive, so that saves us from needing the lock generally.
*/
WT_RET(__wt_lsm_tree_readlock(session, lsm_tree));
WT_RET(__wt_lsm_tree_readunlock(session, lsm_tree));
/*
* Open a bulk cursor on the first chunk, it's not a regular LSM chunk
* cursor, but use the standard storage locations. Allocate the space
* for a bloom filter - it makes cleanup simpler. Cleaned up by
* cursor close on error.
*/
WT_RET(__wt_calloc_one(session, &clsm->blooms));
clsm->bloom_alloc = 1;
WT_RET(__wt_calloc_one(session, &clsm->cursors));
clsm->cursor_alloc = 1;
clsm->nchunks = 1;
/*
* Open a bulk cursor on the first chunk in the tree - take a read
* lock on the LSM tree while we are opening the chunk, to ensure
* that the first chunk has been fully created before we succeed.
* Pass through the application config to ensure the tree is open
* for bulk access.
*/
WT_RET(__wt_open_cursor(session,
lsm_tree->chunk[0]->uri, &clsm->iface, cfg, &bulk_cursor));
clsm->cursors[0] = bulk_cursor;
/* LSM cursors are always raw */
F_SET(bulk_cursor, WT_CURSTD_RAW);
return (0);
}
/*
* __clsm_enter_update --
* Make sure an LSM cursor is ready to perform an update.
*/
static int
__clsm_enter_update(WT_CURSOR_LSM *clsm)
{
WT_CURSOR *primary;
WT_LSM_CHUNK *primary_chunk;
WT_LSM_TREE *lsm_tree;
WT_SESSION_IMPL *session;
bool hard_limit, have_primary, ovfl;
lsm_tree = clsm->lsm_tree;
ovfl = false;
session = (WT_SESSION_IMPL *)clsm->iface.session;
if (clsm->nchunks == 0) {
primary = NULL;
have_primary = false;
} else {
primary = clsm->cursors[clsm->nchunks - 1];
primary_chunk = clsm->primary_chunk;
WT_ASSERT(session, F_ISSET(&session->txn, WT_TXN_HAS_ID));
have_primary = (primary != NULL && primary_chunk != NULL &&
(primary_chunk->switch_txn == WT_TXN_NONE ||
WT_TXNID_LT(session->txn.id, primary_chunk->switch_txn)));
}
/*
* In LSM there are multiple btrees active at one time. The tree
* switch code needs to use btree API methods, and it wants to
* operate on the btree for the primary chunk. Set that up now.
*
* If the primary chunk has grown too large, set a flag so the worker
* thread will switch when it gets a chance to avoid introducing high
* latency into application threads. Don't do this indefinitely: if a
* chunk grows twice as large as the configured size, block until it
* can be switched.
*/
hard_limit = F_ISSET(lsm_tree, WT_LSM_TREE_NEED_SWITCH);
if (have_primary) {
WT_ENTER_PAGE_INDEX(session);
WT_WITH_BTREE(session, ((WT_CURSOR_BTREE *)primary)->btree,
ovfl = __wt_btree_lsm_over_size(session, hard_limit ?
2 * lsm_tree->chunk_size : lsm_tree->chunk_size));
WT_LEAVE_PAGE_INDEX(session);
/* If there was no overflow, we're done. */
if (!ovfl)
return (0);
}
/* Request a switch. */
WT_RET(__wt_clsm_request_switch(clsm));
/* If we only overflowed the soft limit, we're done. */
if (have_primary && !hard_limit)
return (0);
WT_RET(__wt_clsm_await_switch(clsm));
return (0);
}