/*
* __curindex_search_near --
* WT_CURSOR->search_near method for index cursors.
*/
static int
__curindex_search_near(WT_CURSOR *cursor, int *exact)
{
WT_CURSOR *child;
WT_CURSOR_INDEX *cindex;
WT_DECL_RET;
WT_ITEM found_key;
WT_SESSION_IMPL *session;
int cmp;
cindex = (WT_CURSOR_INDEX *)cursor;
child = cindex->child;
JOINABLE_CURSOR_API_CALL(cursor, session, search, NULL);
/*
* We are searching using the application-specified key, which
* (usually) doesn't contain the primary key, so it is just a prefix of
* any matching index key. That said, if there is an exact match, we
* want to find the first matching index entry and set exact equal to
* zero.
*
* Do a search_near, and if we find an entry that is too small, step to
* the next one. In the unlikely event of a search past the end of the
* tree, go back to the last key.
*/
__wt_cursor_set_raw_key(child, &cursor->key);
WT_ERR(child->search_near(child, &cmp));
if (cmp < 0) {
if ((ret = child->next(child)) == WT_NOTFOUND)
ret = child->prev(child);
WT_ERR(ret);
}
/*
* We expect partial matches, and want the smallest record with a key
* greater than or equal to the search key.
*
* If the found key starts with the search key, we indicate a match by
* setting exact equal to zero.
*
* The compare function expects application-supplied keys to come first
* so we flip the sign of the result to match what callers expect.
*/
found_key = child->key;
if (found_key.size > cursor->key.size)
found_key.size = cursor->key.size;
WT_ERR(__wt_compare(
session, cindex->index->collator, &cursor->key, &found_key, exact));
*exact = -*exact;
WT_ERR(__curindex_move(cindex));
if (0) {
err: F_CLR(cursor, WT_CURSTD_KEY_INT | WT_CURSTD_VALUE_INT);
}
API_END_RET(session, ret);
}
/*
* __curindex_search --
* WT_CURSOR->search method for index cursors.
*/
static int
__curindex_search(WT_CURSOR *cursor)
{
WT_CURSOR *child;
WT_CURSOR_INDEX *cindex;
WT_DECL_RET;
WT_ITEM found_key;
WT_SESSION_IMPL *session;
int cmp;
cindex = (WT_CURSOR_INDEX *)cursor;
child = cindex->child;
JOINABLE_CURSOR_API_CALL(cursor, session, search, NULL);
/*
* We are searching using the application-specified key, which
* (usually) doesn't contain the primary key, so it is just a prefix of
* any matching index key. Do a search_near, step to the next entry if
* we land on one that is too small, then check that the prefix
* matches.
*/
__wt_cursor_set_raw_key(child, &cursor->key);
WT_ERR(child->search_near(child, &cmp));
if (cmp < 0)
WT_ERR(child->next(child));
/*
* We expect partial matches, and want the smallest record with a key
* greater than or equal to the search key.
*
* If the key we find is shorter than the search key, it can't possibly
* match.
*
* The only way for the key to be exactly equal is if there is an index
* on the primary key, because otherwise the primary key columns will
* be appended to the index key, but we don't disallow that (odd) case.
*/
found_key = child->key;
if (found_key.size < cursor->key.size)
WT_ERR(WT_NOTFOUND);
found_key.size = cursor->key.size;
WT_ERR(__wt_compare(
session, cindex->index->collator, &cursor->key, &found_key, &cmp));
if (cmp != 0) {
ret = WT_NOTFOUND;
goto err;
}
WT_ERR(__curindex_move(cindex));
if (0) {
err: F_CLR(cursor, WT_CURSTD_KEY_INT | WT_CURSTD_VALUE_INT);
}
API_END_RET(session, ret);
}
/*
* __curindex_search_near --
* WT_CURSOR->search_near method for index cursors.
*/
static int
__curindex_search_near(WT_CURSOR *cursor, int *exact)
{
WT_CURSOR_INDEX *cindex;
WT_DECL_RET;
WT_SESSION_IMPL *session;
cindex = (WT_CURSOR_INDEX *)cursor;
JOINABLE_CURSOR_API_CALL(cursor, session, search_near, NULL);
__wt_cursor_set_raw_key(cindex->child, &cursor->key);
if ((ret = cindex->child->search_near(cindex->child, exact)) == 0)
ret = __curindex_move(cindex);
else
F_CLR(cursor, WT_CURSTD_KEY_INT | WT_CURSTD_VALUE_INT);
err: API_END_RET(session, ret);
}
/*
* __curindex_move --
* When an index cursor changes position, set the primary key in the
* associated column groups and update their positions to match.
*/
static int
__curindex_move(WT_CURSOR_INDEX *cindex)
{
WT_CURSOR **cp, *first;
WT_SESSION_IMPL *session;
u_int i;
session = (WT_SESSION_IMPL *)cindex->iface.session;
first = NULL;
/* Point the public cursor to the key in the child. */
__wt_cursor_set_raw_key(&cindex->iface, &cindex->child->key);
F_CLR(&cindex->iface, WT_CURSTD_KEY_SET | WT_CURSTD_VALUE_SET);
for (i = 0, cp = cindex->cg_cursors;
i < WT_COLGROUPS(cindex->table);
i++, cp++) {
if (*cp == NULL)
continue;
if (first == NULL) {
/*
* Set the primary key -- note that we need the primary
* key columns, so we have to use the full key format,
* not just the public columns.
*/
WT_RET(__wt_schema_project_slice(session,
cp, cindex->index->key_plan,
1, cindex->index->key_format,
&cindex->iface.key));
first = *cp;
} else {
(*cp)->key.data = first->key.data;
(*cp)->key.size = first->key.size;
(*cp)->recno = first->recno;
}
F_SET(*cp, WT_CURSTD_KEY_EXT);
if (cindex->cg_needvalue[i])
WT_RET((*cp)->search(*cp));
}
F_SET(&cindex->iface, WT_CURSTD_KEY_INT | WT_CURSTD_VALUE_INT);
return (0);
}
/*
* __txn_op_apply --
* Apply a transactional operation during recovery.
*/
static int
__txn_op_apply(
WT_RECOVERY *r, WT_LSN *lsnp, const uint8_t **pp, const uint8_t *end)
{
WT_CURSOR *cursor, *start, *stop;
WT_DECL_RET;
WT_ITEM key, start_key, stop_key, value;
WT_SESSION_IMPL *session;
uint64_t recno, start_recno, stop_recno;
uint32_t fileid, mode, optype, opsize;
session = r->session;
cursor = NULL;
/* Peek at the size and the type. */
WT_ERR(__wt_logop_read(session, pp, end, &optype, &opsize));
end = *pp + opsize;
switch (optype) {
case WT_LOGOP_COL_PUT:
WT_ERR(__wt_logop_col_put_unpack(session, pp, end,
&fileid, &recno, &value));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
cursor->set_key(cursor, recno);
__wt_cursor_set_raw_value(cursor, &value);
WT_ERR(cursor->insert(cursor));
break;
case WT_LOGOP_COL_REMOVE:
WT_ERR(__wt_logop_col_remove_unpack(session, pp, end,
&fileid, &recno));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
cursor->set_key(cursor, recno);
WT_ERR(cursor->remove(cursor));
break;
case WT_LOGOP_COL_TRUNCATE:
WT_ERR(__wt_logop_col_truncate_unpack(session, pp, end,
&fileid, &start_recno, &stop_recno));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
/* Set up the cursors. */
if (start_recno == WT_RECNO_OOB) {
start = NULL;
stop = cursor;
} else if (stop_recno == WT_RECNO_OOB) {
start = cursor;
stop = NULL;
} else {
start = cursor;
WT_ERR(__recovery_cursor(
session, r, lsnp, fileid, true, &stop));
}
/* Set the keys. */
if (start != NULL)
start->set_key(start, start_recno);
if (stop != NULL)
stop->set_key(stop, stop_recno);
WT_TRET(session->iface.truncate(&session->iface, NULL,
start, stop, NULL));
/* If we opened a duplicate cursor, close it now. */
if (stop != NULL && stop != cursor)
WT_TRET(stop->close(stop));
WT_ERR(ret);
break;
case WT_LOGOP_ROW_PUT:
WT_ERR(__wt_logop_row_put_unpack(session, pp, end,
&fileid, &key, &value));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
__wt_cursor_set_raw_key(cursor, &key);
__wt_cursor_set_raw_value(cursor, &value);
WT_ERR(cursor->insert(cursor));
break;
case WT_LOGOP_ROW_REMOVE:
WT_ERR(__wt_logop_row_remove_unpack(session, pp, end,
&fileid, &key));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
__wt_cursor_set_raw_key(cursor, &key);
WT_ERR(cursor->remove(cursor));
break;
case WT_LOGOP_ROW_TRUNCATE:
WT_ERR(__wt_logop_row_truncate_unpack(session, pp, end,
&fileid, &start_key, &stop_key, &mode));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
/* Set up the cursors. */
start = stop = NULL;
switch (mode) {
case WT_TXN_TRUNC_ALL:
/* Both cursors stay NULL. */
break;
case WT_TXN_TRUNC_BOTH:
start = cursor;
WT_ERR(__recovery_cursor(
session, r, lsnp, fileid, true, &stop));
break;
case WT_TXN_TRUNC_START:
start = cursor;
break;
case WT_TXN_TRUNC_STOP:
stop = cursor;
break;
WT_ILLEGAL_VALUE_ERR(session);
}
/* Set the keys. */
if (start != NULL)
__wt_cursor_set_raw_key(start, &start_key);
if (stop != NULL)
__wt_cursor_set_raw_key(stop, &stop_key);
WT_TRET(session->iface.truncate(&session->iface, NULL,
start, stop, NULL));
/* If we opened a duplicate cursor, close it now. */
if (stop != NULL && stop != cursor)
WT_TRET(stop->close(stop));
WT_ERR(ret);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
/* Reset the cursor so it doesn't block eviction. */
if (cursor != NULL)
WT_ERR(cursor->reset(cursor));
err: if (ret != 0)
__wt_err(session, ret, "Operation failed during recovery");
return (ret);
}
/*
* __wt_las_sweep --
* Sweep the lookaside table.
*/
int
__wt_las_sweep(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR *cursor;
WT_DECL_ITEM(las_addr);
WT_DECL_ITEM(las_key);
WT_DECL_RET;
WT_ITEM *key;
uint64_t cnt, las_counter, las_txnid;
int64_t remove_cnt;
uint32_t las_id, session_flags;
int notused;
conn = S2C(session);
cursor = NULL;
key = &conn->las_sweep_key;
remove_cnt = 0;
session_flags = 0; /* [-Werror=maybe-uninitialized] */
WT_ERR(__wt_scr_alloc(session, 0, &las_addr));
WT_ERR(__wt_scr_alloc(session, 0, &las_key));
WT_ERR(__wt_las_cursor(session, &cursor, &session_flags));
/*
* If we're not starting a new sweep, position the cursor using the key
* from the last call (we don't care if we're before or after the key,
* just roughly in the same spot is fine).
*/
if (key->size != 0) {
__wt_cursor_set_raw_key(cursor, key);
ret = cursor->search_near(cursor, ¬used);
/*
* Don't search for the same key twice; if we don't set a new
* key below, it's because we've reached the end of the table
* and we want the next pass to start at the beginning of the
* table. Searching for the same key could leave us stuck at
* the end of the table, repeatedly checking the same rows.
*/
key->size = 0;
if (ret != 0)
goto srch_notfound;
}
/*
* The sweep server wakes up every 10 seconds (by default), it's a slow
* moving thread. Try to review the entire lookaside table once every 5
* minutes, or every 30 calls.
*
* The reason is because the lookaside table exists because we're seeing
* cache/eviction pressure (it allows us to trade performance and disk
* space for cache space), and it's likely lookaside blocks are being
* evicted, and reading them back in doesn't help things. A trickier,
* but possibly better, alternative might be to review all lookaside
* blocks in the cache in order to get rid of them, and slowly review
* lookaside blocks that have already been evicted.
*/
cnt = (uint64_t)WT_MAX(100, conn->las_record_cnt / 30);
/* Discard pages we read as soon as we're done with them. */
F_SET(session, WT_SESSION_NO_CACHE);
/* Walk the file. */
for (; cnt > 0 && (ret = cursor->next(cursor)) == 0; --cnt) {
/*
* If the loop terminates after completing a work unit, we will
* continue the table sweep next time. Get a local copy of the
* sweep key, we're going to reset the cursor; do so before
* calling cursor.remove, cursor.remove can discard our hazard
* pointer and the page could be evicted from underneath us.
*/
if (cnt == 1) {
WT_ERR(__wt_cursor_get_raw_key(cursor, key));
if (!WT_DATA_IN_ITEM(key))
WT_ERR(__wt_buf_set(
session, key, key->data, key->size));
}
WT_ERR(cursor->get_key(cursor,
&las_id, las_addr, &las_counter, &las_txnid, las_key));
/*
* If the on-page record transaction ID associated with the
* record is globally visible, the record can be discarded.
*
* Cursor opened overwrite=true: won't return WT_NOTFOUND should
* another thread remove the record before we do, and the cursor
* remains positioned in that case.
*/
if (__wt_txn_visible_all(session, las_txnid)) {
WT_ERR(cursor->remove(cursor));
++remove_cnt;
}
}
srch_notfound:
WT_ERR_NOTFOUND_OK(ret);
if (0) {
err: __wt_buf_free(session, key);
}
WT_TRET(__wt_las_cursor_close(session, &cursor, session_flags));
/*
* If there were races to remove records, we can over-count. All
* arithmetic is signed, so underflow isn't fatal, but check anyway so
* we don't skew low over time.
*/
if (remove_cnt > S2C(session)->las_record_cnt)
S2C(session)->las_record_cnt = 0;
else if (remove_cnt > 0)
(void)__wt_atomic_subi64(&conn->las_record_cnt, remove_cnt);
F_CLR(session, WT_SESSION_NO_CACHE);
__wt_scr_free(session, &las_addr);
__wt_scr_free(session, &las_key);
return (ret);
}
/*
* __curjoin_next --
* WT_CURSOR::next for join cursors.
*/
static int
__curjoin_next(WT_CURSOR *cursor)
{
WT_CURSOR *c;
WT_CURSOR_JOIN *cjoin;
WT_CURSOR_JOIN_ITER *iter;
WT_DECL_RET;
WT_SESSION_IMPL *session;
int tret;
cjoin = (WT_CURSOR_JOIN *)cursor;
JOINABLE_CURSOR_API_CALL(cursor, session, next, NULL);
if (F_ISSET(cjoin, WT_CURJOIN_ERROR))
WT_ERR_MSG(session, WT_ERROR,
"join cursor encountered previous error");
if (!F_ISSET(cjoin, WT_CURJOIN_INITIALIZED))
WT_ERR(__curjoin_init_next(session, cjoin, true));
if (cjoin->iter == NULL)
WT_ERR(__curjoin_iter_init(session, cjoin, &cjoin->iter));
iter = cjoin->iter;
F_CLR(cursor, WT_CURSTD_KEY_SET | WT_CURSTD_VALUE_SET);
while ((ret = __curjoin_iter_next(iter, cursor)) == 0) {
if ((ret = __curjoin_entries_in_range(session, cjoin,
iter->curkey, iter)) != WT_NOTFOUND)
break;
}
iter->positioned = (ret == 0);
if (ret != 0 && ret != WT_NOTFOUND)
WT_ERR(ret);
if (ret == 0) {
/*
* Position the 'main' cursor, this will be used to retrieve
* values from the cursor join. The key we have is raw, but
* the main cursor may not be raw.
*/
c = cjoin->main;
__wt_cursor_set_raw_key(c, iter->curkey);
/*
* A failed search is not expected, convert WT_NOTFOUND into a
* generic error.
*/
iter->entry->stats.main_access++;
if ((ret = c->search(c)) != 0) {
if (ret == WT_NOTFOUND)
ret = WT_ERROR;
WT_ERR_MSG(session, ret, "join cursor failed search");
}
F_SET(cursor, WT_CURSTD_KEY_INT | WT_CURSTD_VALUE_INT);
} else if (ret == WT_NOTFOUND &&
(tret = __curjoin_iter_close_all(iter)) != 0)
WT_ERR(tret);
if (0) {
err: F_SET(cjoin, WT_CURJOIN_ERROR);
}
API_END_RET(session, ret);
}
/*
* __wt_las_sweep --
* Sweep the lookaside table.
*/
int
__wt_las_sweep(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_CURSOR *cursor;
WT_DECL_ITEM(las_addr);
WT_DECL_ITEM(las_key);
WT_DECL_RET;
WT_ITEM *key;
uint64_t cnt, las_counter, las_txnid;
uint32_t las_id, session_flags;
int notused;
conn = S2C(session);
cursor = NULL;
key = &conn->las_sweep_key;
session_flags = 0; /* [-Werror=maybe-uninitialized] */
WT_ERR(__wt_scr_alloc(session, 0, &las_addr));
WT_ERR(__wt_scr_alloc(session, 0, &las_key));
WT_ERR(__wt_las_cursor(session, &cursor, &session_flags));
/*
* If we're not starting a new sweep, position the cursor using the key
* from the last call (we don't care if we're before or after the key,
* just roughly in the same spot is fine).
*/
if (conn->las_sweep_call != 0 && key->data != NULL) {
__wt_cursor_set_raw_key(cursor, key);
if ((ret = cursor->search_near(cursor, ¬used)) != 0)
goto srch_notfound;
}
/*
* The sweep server wakes up every 10 seconds (by default), it's a slow
* moving thread. Try to review the entire lookaside table once every 5
* minutes, or every 30 calls.
*
* The reason is because the lookaside table exists because we're seeing
* cache/eviction pressure (it allows us to trade performance and disk
* space for cache space), and it's likely lookaside blocks are being
* evicted, and reading them back in doesn't help things. A trickier,
* but possibly better, alternative might be to review all lookaside
* blocks in the cache in order to get rid of them, and slowly review
* lookaside blocks that have already been evicted.
*
* We can't know for sure how many records are in the lookaside table,
* the cursor insert and remove statistics aren't updated atomically.
* Start with reviewing 100 rows, and if it takes more than the target
* number of calls to finish, increase the number of rows checked on
* each call; if it takes less than the target calls to finish, then
* decrease the number of rows reviewed on each call (but never less
* than 100).
*/
#define WT_SWEEP_LOOKASIDE_MIN_CNT 100
#define WT_SWEEP_LOOKASIDE_PASS_TARGET 30
++conn->las_sweep_call;
if ((cnt = conn->las_sweep_cnt) < WT_SWEEP_LOOKASIDE_MIN_CNT)
cnt = conn->las_sweep_cnt = WT_SWEEP_LOOKASIDE_MIN_CNT;
/* Walk the file. */
for (; cnt > 0 && (ret = cursor->next(cursor)) == 0; --cnt) {
/*
* If the loop terminates after completing a work unit, we will
* continue the table sweep next time. Get a local copy of the
* sweep key, we're going to reset the cursor; do so before
* calling cursor.remove, cursor.remove can discard our hazard
* pointer and the page could be evicted from underneath us.
*/
if (cnt == 1) {
WT_ERR(__wt_cursor_get_raw_key(cursor, key));
if (!WT_DATA_IN_ITEM(key))
WT_ERR(__wt_buf_set(
session, key, key->data, key->size));
}
WT_ERR(cursor->get_key(cursor,
&las_id, las_addr, &las_counter, &las_txnid, las_key));
/*
* If the on-page record transaction ID associated with the
* record is globally visible, the record can be discarded.
*
* Cursor opened overwrite=true: won't return WT_NOTFOUND should
* another thread remove the record before we do, and the cursor
* remains positioned in that case.
*/
if (__wt_txn_visible_all(session, las_txnid))
WT_ERR(cursor->remove(cursor));
}
/*
* When reaching the lookaside table end or the target number of calls,
* adjust the row count. Decrease/increase the row count depending on
* if the number of calls is less/more than the target.
*/
if (ret == WT_NOTFOUND ||
conn->las_sweep_call > WT_SWEEP_LOOKASIDE_PASS_TARGET) {
if (conn->las_sweep_call < WT_SWEEP_LOOKASIDE_PASS_TARGET &&
conn->las_sweep_cnt > WT_SWEEP_LOOKASIDE_MIN_CNT)
conn->las_sweep_cnt -= WT_SWEEP_LOOKASIDE_MIN_CNT;
if (conn->las_sweep_call > WT_SWEEP_LOOKASIDE_PASS_TARGET)
conn->las_sweep_cnt += WT_SWEEP_LOOKASIDE_MIN_CNT;
}
srch_notfound:
if (ret == WT_NOTFOUND)
conn->las_sweep_call = 0;
WT_ERR_NOTFOUND_OK(ret);
if (0) {
err: __wt_buf_free(session, key);
}
WT_TRET(__wt_las_cursor_close(session, &cursor, session_flags));
__wt_scr_free(session, &las_addr);
__wt_scr_free(session, &las_key);
return (ret);
}
/*
* __txn_op_apply --
* Apply a transactional operation during recovery.
*/
static int
__txn_op_apply(
WT_RECOVERY *r, WT_LSN *lsnp, const uint8_t **pp, const uint8_t *end)
{
WT_CURSOR *cursor, *start, *stop;
WT_DECL_RET;
WT_ITEM key, start_key, stop_key, value;
WT_SESSION_IMPL *session;
uint64_t recno, start_recno, stop_recno;
uint32_t fileid, mode, optype, opsize;
session = r->session;
cursor = NULL;
/* Peek at the size and the type. */
WT_ERR(__wt_logop_read(session, pp, end, &optype, &opsize));
end = *pp + opsize;
switch (optype) {
case WT_LOGOP_COL_MODIFY:
WT_ERR(__wt_logop_col_modify_unpack(session, pp, end,
&fileid, &recno, &value));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
cursor->set_key(cursor, recno);
if ((ret = cursor->search(cursor)) != 0)
WT_ERR_NOTFOUND_OK(ret);
else {
/*
* Build/insert a complete value during recovery rather
* than using cursor modify to create a partial update
* (for no particular reason than simplicity).
*/
WT_ERR(__wt_modify_apply(session, cursor, value.data));
WT_ERR(cursor->insert(cursor));
}
break;
case WT_LOGOP_COL_PUT:
WT_ERR(__wt_logop_col_put_unpack(session, pp, end,
&fileid, &recno, &value));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
cursor->set_key(cursor, recno);
__wt_cursor_set_raw_value(cursor, &value);
WT_ERR(cursor->insert(cursor));
break;
case WT_LOGOP_COL_REMOVE:
WT_ERR(__wt_logop_col_remove_unpack(session, pp, end,
&fileid, &recno));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
cursor->set_key(cursor, recno);
WT_ERR(cursor->remove(cursor));
break;
case WT_LOGOP_COL_TRUNCATE:
WT_ERR(__wt_logop_col_truncate_unpack(session, pp, end,
&fileid, &start_recno, &stop_recno));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
/* Set up the cursors. */
if (start_recno == WT_RECNO_OOB) {
start = NULL;
stop = cursor;
} else if (stop_recno == WT_RECNO_OOB) {
start = cursor;
stop = NULL;
} else {
start = cursor;
WT_ERR(__recovery_cursor(
session, r, lsnp, fileid, true, &stop));
}
/* Set the keys. */
if (start != NULL)
start->set_key(start, start_recno);
if (stop != NULL)
stop->set_key(stop, stop_recno);
WT_TRET(session->iface.truncate(&session->iface, NULL,
start, stop, NULL));
/* If we opened a duplicate cursor, close it now. */
if (stop != NULL && stop != cursor)
WT_TRET(stop->close(stop));
WT_ERR(ret);
break;
case WT_LOGOP_ROW_MODIFY:
WT_ERR(__wt_logop_row_modify_unpack(session, pp, end,
&fileid, &key, &value));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
__wt_cursor_set_raw_key(cursor, &key);
if ((ret = cursor->search(cursor)) != 0)
WT_ERR_NOTFOUND_OK(ret);
else {
/*
* Build/insert a complete value during recovery rather
* than using cursor modify to create a partial update
* (for no particular reason than simplicity).
*/
WT_ERR(__wt_modify_apply(session, cursor, value.data));
WT_ERR(cursor->insert(cursor));
}
break;
case WT_LOGOP_ROW_PUT:
WT_ERR(__wt_logop_row_put_unpack(session, pp, end,
&fileid, &key, &value));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
__wt_cursor_set_raw_key(cursor, &key);
__wt_cursor_set_raw_value(cursor, &value);
WT_ERR(cursor->insert(cursor));
break;
case WT_LOGOP_ROW_REMOVE:
WT_ERR(__wt_logop_row_remove_unpack(session, pp, end,
&fileid, &key));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
__wt_cursor_set_raw_key(cursor, &key);
WT_ERR(cursor->remove(cursor));
break;
case WT_LOGOP_ROW_TRUNCATE:
WT_ERR(__wt_logop_row_truncate_unpack(session, pp, end,
&fileid, &start_key, &stop_key, &mode));
GET_RECOVERY_CURSOR(session, r, lsnp, fileid, &cursor);
/* Set up the cursors. */
start = stop = NULL;
switch (mode) {
case WT_TXN_TRUNC_ALL:
/* Both cursors stay NULL. */
break;
case WT_TXN_TRUNC_BOTH:
start = cursor;
WT_ERR(__recovery_cursor(
session, r, lsnp, fileid, true, &stop));
break;
case WT_TXN_TRUNC_START:
start = cursor;
break;
case WT_TXN_TRUNC_STOP:
stop = cursor;
break;
WT_ILLEGAL_VALUE_ERR(session, mode);
}
/* Set the keys. */
if (start != NULL)
__wt_cursor_set_raw_key(start, &start_key);
if (stop != NULL)
__wt_cursor_set_raw_key(stop, &stop_key);
WT_TRET(session->iface.truncate(&session->iface, NULL,
start, stop, NULL));
/* If we opened a duplicate cursor, close it now. */
if (stop != NULL && stop != cursor)
WT_TRET(stop->close(stop));
WT_ERR(ret);
break;
WT_ILLEGAL_VALUE_ERR(session, optype);
}
/* Reset the cursor so it doesn't block eviction. */
if (cursor != NULL)
WT_ERR(cursor->reset(cursor));
return (0);
err: __wt_err(session, ret,
"operation apply failed during recovery: operation type %"
PRIu32 " at LSN %" PRIu32 "/%" PRIu32,
optype, lsnp->l.file, lsnp->l.offset);
return (ret);
}
