/*
* __cursor_var_append_prev --
* Return the previous variable-length entry on the append list.
*/
static inline int
__cursor_var_append_prev(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_ITEM *val;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
val = &cbt->iface.value;
if (newpage) {
cbt->ins = WT_SKIP_LAST(cbt->ins_head);
goto new_page;
}
for (;;) {
WT_RET(__cursor_skip_prev(cbt));
new_page: if (cbt->ins == NULL)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, WT_INSERT_RECNO(cbt->ins));
if ((upd = __wt_txn_read(session, cbt->ins->upd)) == NULL)
continue;
if (WT_UPDATE_DELETED_ISSET(upd)) {
if (__wt_txn_visible_all(session, upd->txnid))
++cbt->page_deleted_count;
continue;
}
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/* NOTREACHED */
}
/*
* __cursor_var_append_next --
* Return the next variable-length entry on the append list.
*/
static inline int
__cursor_var_append_next(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
if (newpage) {
cbt->ins = WT_SKIP_FIRST(cbt->ins_head);
goto new_page;
}
for (;;) {
cbt->ins = WT_SKIP_NEXT(cbt->ins);
new_page: if (cbt->ins == NULL)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, WT_INSERT_RECNO(cbt->ins));
if ((upd = __wt_txn_read(session, cbt->ins->upd)) == NULL)
continue;
if (upd->type == WT_UPDATE_DELETED) {
if (__wt_txn_upd_visible_all(session, upd))
++cbt->page_deleted_count;
continue;
}
return (__wt_value_return(session, cbt, upd));
}
/* NOTREACHED */
}
/*
* __cursor_var_append_prev --
* Return the previous variable-length entry on the append list.
*/
static inline int
__cursor_var_append_prev(WT_CURSOR_BTREE *cbt, int newpage)
{
WT_ITEM *val;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
val = &cbt->iface.value;
if (newpage) {
cbt->ins = WT_SKIP_LAST(cbt->ins_head);
goto new_page;
}
for (;;) {
WT_RET(__cursor_skip_prev(cbt));
new_page: if (cbt->ins == NULL)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, WT_INSERT_RECNO(cbt->ins));
if ((upd = __wt_txn_read(session, cbt->ins->upd)) == NULL ||
WT_UPDATE_DELETED_ISSET(upd))
continue;
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
break;
}
return (0);
}
/*
* __cursor_invalid --
* Return if the cursor references an invalid K/V pair (either the pair
* doesn't exist at all because the tree is empty, or the pair was deleted).
*/
static inline int
__cursor_invalid(WT_CURSOR_BTREE *cbt)
{
WT_BTREE *btree;
WT_CELL *cell;
WT_CELL_UNPACK unpack;
WT_COL *cip;
WT_INSERT *ins;
WT_PAGE *page;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
btree = cbt->btree;
ins = cbt->ins;
page = cbt->page;
session = (WT_SESSION_IMPL *)cbt->iface.session;
/* If we found an item on an insert list, check there. */
if (ins != NULL && (upd = __wt_txn_read(session, ins->upd)) != NULL)
return (WT_UPDATE_DELETED_ISSET(upd) ? 1 : 0);
/* The page may be empty, the search routine doesn't check. */
if (page->entries == 0)
return (1);
/* Otherwise, check for an update in the page's slots. */
switch (btree->type) {
case BTREE_COL_FIX:
break;
case BTREE_COL_VAR:
cip = &page->u.col_var.d[cbt->slot];
if ((cell = WT_COL_PTR(page, cip)) == NULL)
return (WT_NOTFOUND);
__wt_cell_unpack(cell, &unpack);
if (unpack.type == WT_CELL_DEL)
return (1);
break;
case BTREE_ROW:
if (page->u.row.upd != NULL && (upd = __wt_txn_read(session,
page->u.row.upd[cbt->slot])) != NULL &&
WT_UPDATE_DELETED_ISSET(upd))
return (1);
break;
}
return (0);
}
/*btree cursor移向下一个记录，仅仅在append list上移动*/
static inline int __cursor_fix_append_next(WT_CURSOR_BTREE* cbt, int newpage)
{
WT_ITEM *val;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
val = &cbt->iface.value;
/*新载入的page,判断ins_head是否为空，如果为空表示没有append的记录*/
if (newpage){
if ((cbt->ins = WT_SKIP_FIRST(cbt->ins_head)) == NULL)
return (WT_NOTFOUND);
}
else{
/*已经到append list的最后一条记录了，后面没有记录*/
if (cbt->recno >= WT_INSERT_RECNO(cbt->ins) && (cbt->ins = WT_SKIP_NEXT(cbt->ins)) == NULL)
return (WT_NOTFOUND);
}
/*
* This code looks different from the cursor-previous code. The append
* list appears on the last page of the tree, but it may be preceded by
* other rows, which means the cursor's recno will be set to a value and
* we simply want to increment it. If the cursor's recno is NOT set,
* we're starting our iteration in a tree that has only appended items.
* In that case, recno will be 0 and happily enough the increment will
* set it to 1, which is correct.
*/
__cursor_set_recno(cbt, cbt->recno + 1);
/*
* Fixed-width column store appends are inherently non-transactional.
* Even a non-visible update by a concurrent or aborted transaction
* changes the effective end of the data. The effect is subtle because
* of the blurring between deleted and empty values, but ideally we
* would skip all uncommitted changes at the end of the data. This
* doesn't apply to variable-width column stores because the implicitly
* created records written by reconciliation are deleted and so can be
* never seen by a read.
*
* The problem is that we don't know at this point whether there may be
* multiple uncommitted changes at the end of the data, and it would be
* expensive to check every time we hit an aborted update. If an
* insert is aborted, we simply return zero (empty), regardless of
* whether we are at the end of the data.
*/
if (cbt->recno < WT_INSERT_RECNO(cbt->ins) || (upd = __wt_txn_read(session, cbt->ins->upd)) == NULL){ /*没有可见的记录值，直接返回0*/
cbt->v = 0;
val->data = &cbt->v;
}
else
val->data = WT_UPDATE_DATA(upd);
val->size = 1;
return 0;
}
/*
* __cursor_fix_prev --
* Move to the previous, fixed-length column-store item.
*/
static inline int
__cursor_fix_prev(WT_CURSOR_BTREE *cbt, int newpage)
{
WT_BTREE *btree;
WT_ITEM *val;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
btree = session->btree;
val = &cbt->iface.value;
/* Initialize for each new page. */
if (newpage) {
cbt->last_standard_recno = __col_last_recno(cbt->page);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, cbt->last_standard_recno);
goto new_page;
}
/* Move to the previous entry and return the item. */
for (;;) {
if (cbt->recno == cbt->page->u.col_fix.recno)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, cbt->recno - 1);
new_page: /* Check any insert list for a matching record. */
cbt->ins_head = WT_COL_UPDATE_SINGLE(cbt->page);
cbt->ins = __col_insert_search(
cbt->ins_head, cbt->ins_stack, cbt->next_stack, cbt->recno);
if (cbt->ins != NULL &&
cbt->recno != WT_INSERT_RECNO(cbt->ins))
cbt->ins = NULL;
upd = cbt->ins == NULL ?
NULL : __wt_txn_read(session, cbt->ins->upd);
if (upd != NULL) {
val->data = WT_UPDATE_DATA(upd);
val->size = 1;
return (0);
}
cbt->v = __bit_getv_recno(cbt->page, cbt->recno, btree->bitcnt);
val->data = &cbt->v;
val->size = 1;
return (0);
}
/* NOTREACHED */
}
/*
* __cursor_fix_prev --
* Move to the previous, fixed-length column-store item.
*/
static inline int
__cursor_fix_prev(WT_CURSOR_BTREE *cbt, int newpage)
{
WT_BTREE *btree;
WT_INSERT *ins;
WT_ITEM *val;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
uint64_t *recnop;
session = (WT_SESSION_IMPL *)cbt->iface.session;
btree = session->btree;
recnop = &cbt->iface.recno;
val = &cbt->iface.value;
/* Initialize for each new page. */
if (newpage) {
cbt->last_standard_recno = __col_last_recno(cbt->page);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
cbt->recno = cbt->last_standard_recno;
goto new_page;
}
/* Move to the previous entry and return the item. */
for (;;) {
if (cbt->recno == cbt->page->u.col_fix.recno)
return (WT_NOTFOUND);
--cbt->recno;
new_page: *recnop = cbt->recno;
/* Check any insert list for a matching record. */
if ((ins = cbt->ins = __col_insert_search_match(
WT_COL_UPDATE_SINGLE(cbt->page), cbt->recno)) != NULL &&
(upd = __wt_txn_read(session, ins->upd)) != NULL) {
val->data = WT_UPDATE_DATA(upd);
val->size = 1;
return (0);
}
cbt->v = __bit_getv_recno(cbt->page, cbt->recno, btree->bitcnt);
val->data = &cbt->v;
val->size = 1;
return (0);
}
/* NOTREACHED */
}
/*btree cursor移向下一个记录(fix col方式存储)，在btree树空间上移动*/
static inline int __cursor_fix_next(WT_CURSOR_BTREE* cbt, int newpage)
{
WT_BTREE *btree;
WT_ITEM *val;
WT_PAGE *page;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
btree = S2BT(session);
page = cbt->ref->page;
val = &cbt->iface.value;
/*切换到新的page上做next操作*/
if (newpage){
cbt->last_standard_recno = __col_fix_last_recno(page);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, page->pg_fix_recno);
goto new_page;
}
/*记录序号超出最后一个序号，到末尾了*/
if (cbt->recno >= cbt->last_standard_recno)
return WT_NOTFOUND;
__cursor_set_recno(cbt, cbt->recno + 1);
new_page:
/*获得第一个修改列表*/
cbt->ins_head = WT_COL_UPDATE_SINGLE(page);
/*定位recno所在的修改条目*/
cbt->ins = __col_insert_search(cbt->ins_head, cbt->ins_stack, cbt->next_stack, cbt->recno);
if (cbt->ins != NULL && cbt->recno != WT_INSERT_RECNO(cbt->ins)) /*不正确的修改定位，将ins设置为NULL表示定位失败*/
cbt->ins = NULL;
/*做事务隔离读取记录版本*/
upd = cbt->ins == NULL ? NULL : __wt_txn_read(session, cbt->ins->upd);
if (upd == NULL){
cbt->v = __bit_getv_recno(page, cbt->recno, btree->bitcnt); /*V赋值*/
val->data = &cbt->v;
}
else
val->data = WT_UPDATE_DATA(upd);
val->size = 1;
return 0;
}
/*
* __cursor_fix_next --
* Move to the next, fixed-length column-store item.
*/
static inline int
__cursor_fix_next(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_BTREE *btree;
WT_PAGE *page;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
btree = S2BT(session);
page = cbt->ref->page;
/* Initialize for each new page. */
if (newpage) {
cbt->last_standard_recno = __col_fix_last_recno(cbt->ref);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, cbt->ref->ref_recno);
goto new_page;
}
/* Move to the next entry and return the item. */
if (cbt->recno >= cbt->last_standard_recno)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, cbt->recno + 1);
new_page:
/* Check any insert list for a matching record. */
cbt->ins_head = WT_COL_UPDATE_SINGLE(page);
cbt->ins = __col_insert_search(
cbt->ins_head, cbt->ins_stack, cbt->next_stack, cbt->recno);
if (cbt->ins != NULL && cbt->recno != WT_INSERT_RECNO(cbt->ins))
cbt->ins = NULL;
upd = cbt->ins == NULL ? NULL : __wt_txn_read(session, cbt->ins->upd);
if (upd == NULL) {
cbt->v = __bit_getv_recno(cbt->ref, cbt->recno, btree->bitcnt);
cbt->iface.value.data = &cbt->v;
} else
cbt->iface.value.data = upd->data;
cbt->iface.value.size = 1;
return (0);
}
/*
* __cursor_fix_append_prev --
* Return the previous fixed-length entry on the append list.
*/
static inline int
__cursor_fix_append_prev(WT_CURSOR_BTREE *cbt, int newpage)
{
WT_ITEM *val;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
val = &cbt->iface.value;
if (newpage) {
if ((cbt->ins = WT_SKIP_LAST(cbt->ins_head)) == NULL)
return (WT_NOTFOUND);
cbt->recno = WT_INSERT_RECNO(cbt->ins);
} else {
if (cbt->recno == WT_INSERT_RECNO(cbt->ins)) {
__cursor_skip_prev(cbt);
if (cbt->ins == NULL)
return (WT_NOTFOUND);
}
--cbt->recno;
}
/*
* Column store appends are inherently non-transactional.
*
* Even a non-visible update by a concurrent or aborted transaction
* changes the effective end of the data. The effect is subtle because
* of the blurring between deleted and empty values, but ideally we
* would skip all uncommitted changes at the end of the data.
*/
cbt->iface.recno = cbt->recno;
if (cbt->recno > WT_INSERT_RECNO(cbt->ins) ||
(upd = __wt_txn_read(session, cbt->ins->upd)) == NULL) {
cbt->v = 0;
val->data = &cbt->v;
} else
val->data = WT_UPDATE_DATA(upd);
val->size = 1;
return (0);
}
/*在append list上移动variable-length类型的btree cursor*/
static inline int __cursor_var_append_next(WT_CURSOR_BTREE* cbt, int newpage)
{
WT_ITEM *val;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
val = &cbt->iface.value;
if (newpage){
cbt->ins = WT_SKIP_FIRST(cbt->ins_head);
goto new_page;
}
for (;;){
cbt->ins = WT_SKIP_NEXT(cbt->ins);
new_page:
if (cbt->ins == NULL)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, WT_INSERT_RECNO(cbt->ins));
/*事务隔离读，对本事务不可见，继续向前*/
if ((upd = __wt_txn_read(session, cbt->ins->upd)) == NULL)
continue;
/*删除集合，不做指向这条记录，继续向下移动*/
if (WT_UPDATE_DELETED_ISSET(upd)) {
++cbt->page_deleted_count;
continue;
}
/*赋值value*/
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return 0;
}
}
/*
* __cursor_row_next --
* Move to the next row-store item.
*/
static inline int
__cursor_row_next(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_INSERT *ins;
WT_ITEM *key;
WT_PAGE *page;
WT_ROW *rip;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
page = cbt->ref->page;
key = &cbt->iface.key;
/*
* For row-store pages, we need a single item that tells us the part
* of the page we're walking (otherwise switching from next to prev
* and vice-versa is just too complicated), so we map the WT_ROW and
* WT_INSERT_HEAD insert array slots into a single name space: slot 1
* is the "smallest key insert list", slot 2 is WT_ROW[0], slot 3 is
* WT_INSERT_HEAD[0], and so on. This means WT_INSERT lists are
* odd-numbered slots, and WT_ROW array slots are even-numbered slots.
*
* Initialize for each new page.
*/
if (newpage) {
cbt->ins_head = WT_ROW_INSERT_SMALLEST(page);
cbt->ins = WT_SKIP_FIRST(cbt->ins_head);
cbt->row_iteration_slot = 1;
cbt->rip_saved = NULL;
goto new_insert;
}
/* Move to the next entry and return the item. */
for (;;) {
/*
* Continue traversing any insert list; maintain the insert list
* head reference and entry count in case we switch to a cursor
* previous movement.
*/
if (cbt->ins != NULL)
cbt->ins = WT_SKIP_NEXT(cbt->ins);
new_insert: if ((ins = cbt->ins) != NULL) {
if ((upd = __wt_txn_read(session, ins->upd)) == NULL)
continue;
if (upd->type == WT_UPDATE_DELETED) {
if (__wt_txn_upd_visible_all(session, upd))
++cbt->page_deleted_count;
continue;
}
key->data = WT_INSERT_KEY(ins);
key->size = WT_INSERT_KEY_SIZE(ins);
return (__wt_value_return(session, cbt, upd));
}
/* Check for the end of the page. */
if (cbt->row_iteration_slot >= page->entries * 2 + 1)
return (WT_NOTFOUND);
++cbt->row_iteration_slot;
/*
* Odd-numbered slots configure as WT_INSERT_HEAD entries,
* even-numbered slots configure as WT_ROW entries.
*/
if (cbt->row_iteration_slot & 0x01) {
cbt->ins_head = WT_ROW_INSERT_SLOT(
page, cbt->row_iteration_slot / 2 - 1);
cbt->ins = WT_SKIP_FIRST(cbt->ins_head);
goto new_insert;
}
cbt->ins_head = NULL;
cbt->ins = NULL;
cbt->slot = cbt->row_iteration_slot / 2 - 1;
rip = &page->pg_row[cbt->slot];
upd = __wt_txn_read(session, WT_ROW_UPDATE(page, rip));
if (upd != NULL && upd->type == WT_UPDATE_DELETED) {
if (__wt_txn_upd_visible_all(session, upd))
++cbt->page_deleted_count;
continue;
}
return (__cursor_row_slot_return(cbt, rip, upd));
}
/* NOTREACHED */
}
/*
* __cursor_var_prev --
* Move to the previous, variable-length column-store item.
*/
static inline int
__cursor_var_prev(WT_CURSOR_BTREE *cbt, int newpage)
{
WT_CELL *cell;
WT_CELL_UNPACK unpack;
WT_COL *cip;
WT_INSERT *ins;
WT_ITEM *val;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
uint64_t *recnop;
session = (WT_SESSION_IMPL *)cbt->iface.session;
recnop = &cbt->iface.recno;
val = &cbt->iface.value;
/* Initialize for each new page. */
if (newpage) {
cbt->last_standard_recno = __col_last_recno(cbt->page);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
cbt->recno = cbt->last_standard_recno;
goto new_page;
}
/* Move to the previous entry and return the item. */
for (;;) {
--cbt->recno;
new_page: *recnop = cbt->recno;
if (cbt->recno < cbt->page->u.col_var.recno)
return (WT_NOTFOUND);
/* Find the matching WT_COL slot. */
if ((cip = __col_var_search(cbt->page, cbt->recno)) == NULL)
return (WT_NOTFOUND);
/* Check any insert list for a matching record. */
if ((ins = __col_insert_search_match(
WT_COL_UPDATE(cbt->page, cip), cbt->recno)) != NULL &&
(upd = __wt_txn_read(session, ins->upd)) != NULL) {
if (WT_UPDATE_DELETED_ISSET(upd))
continue;
cbt->ins = ins;
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/*
* If we're at the same slot as the last reference and there's
* no matching insert list item, re-use the return information
* (so encoded items with large repeat counts aren't repeatedly
* decoded). Otherwise, unpack the cell and build the return
* information.
*/
if (cbt->cip_saved != cip) {
if ((cell = WT_COL_PTR(cbt->page, cip)) == NULL)
continue;
__wt_cell_unpack(cell, &unpack);
switch (unpack.type) {
case WT_CELL_DEL:
continue;
case WT_CELL_VALUE:
if (session->btree->huffman_value == NULL) {
cbt->tmp.data = unpack.data;
cbt->tmp.size = unpack.size;
break;
}
/* FALLTHROUGH */
default:
WT_RET(__wt_cell_unpack_copy(
session, &unpack, &cbt->tmp));
}
cbt->cip_saved = cip;
}
val->data = cbt->tmp.data;
val->size = cbt->tmp.size;
return (0);
}
/* NOTREACHED */
}
/*
* __cursor_var_prev --
* Move to the previous, variable-length column-store item.
*/
static inline int
__cursor_var_prev(WT_CURSOR_BTREE *cbt, int newpage)
{
WT_CELL *cell;
WT_CELL_UNPACK unpack;
WT_COL *cip;
WT_ITEM *val;
WT_PAGE *page;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
page = cbt->ref->page;
val = &cbt->iface.value;
/* Initialize for each new page. */
if (newpage) {
cbt->last_standard_recno = __col_var_last_recno(page);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, cbt->last_standard_recno);
goto new_page;
}
/* Move to the previous entry and return the item. */
for (;;) {
__cursor_set_recno(cbt, cbt->recno - 1);
new_page: if (cbt->recno < page->pg_var_recno)
return (WT_NOTFOUND);
/* Find the matching WT_COL slot. */
if ((cip = __col_var_search(page, cbt->recno)) == NULL)
return (WT_NOTFOUND);
cbt->slot = WT_COL_SLOT(page, cip);
/* Check any insert list for a matching record. */
cbt->ins_head = WT_COL_UPDATE_SLOT(page, cbt->slot);
cbt->ins = __col_insert_search_match(cbt->ins_head, cbt->recno);
upd = cbt->ins == NULL ?
NULL : __wt_txn_read(session, cbt->ins->upd);
if (upd != NULL) {
if (WT_UPDATE_DELETED_ISSET(upd)) {
++cbt->page_deleted_count;
continue;
}
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/*
* If we're at the same slot as the last reference and there's
* no matching insert list item, re-use the return information
* (so encoded items with large repeat counts aren't repeatedly
* decoded). Otherwise, unpack the cell and build the return
* information.
*/
if (cbt->cip_saved != cip) {
if ((cell = WT_COL_PTR(page, cip)) == NULL)
continue;
__wt_cell_unpack(cell, &unpack);
if (unpack.type == WT_CELL_DEL)
continue;
WT_RET(__wt_page_cell_data_ref(
session, page, &unpack, &cbt->tmp));
cbt->cip_saved = cip;
}
val->data = cbt->tmp.data;
val->size = cbt->tmp.size;
return (0);
}
/* NOTREACHED */
}
/*
* __cursor_var_prev --
* Move to the previous, variable-length column-store item.
*/
static inline int
__cursor_var_prev(WT_CURSOR_BTREE *cbt, int newpage)
{
WT_CELL *cell;
WT_CELL_UNPACK unpack;
WT_COL *cip;
WT_DECL_RET;
WT_ITEM *val;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
val = &cbt->iface.value;
/* Initialize for each new page. */
if (newpage) {
cbt->last_standard_recno = __col_last_recno(cbt->page);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, cbt->last_standard_recno);
goto new_page;
}
/* Move to the previous entry and return the item. */
for (;;) {
__cursor_set_recno(cbt, cbt->recno - 1);
new_page: if (cbt->recno < cbt->page->u.col_var.recno)
return (WT_NOTFOUND);
/* Find the matching WT_COL slot. */
if ((cip = __col_var_search(cbt->page, cbt->recno)) == NULL)
return (WT_NOTFOUND);
cbt->slot = WT_COL_SLOT(cbt->page, cip);
/* Check any insert list for a matching record. */
cbt->ins_head = WT_COL_UPDATE_SLOT(cbt->page, cbt->slot);
cbt->ins = __col_insert_search_match(cbt->ins_head, cbt->recno);
upd = cbt->ins == NULL ?
NULL : __wt_txn_read(session, cbt->ins->upd);
if (upd != NULL) {
if (WT_UPDATE_DELETED_ISSET(upd))
continue;
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/*
* If we're at the same slot as the last reference and there's
* no matching insert list item, re-use the return information
* (so encoded items with large repeat counts aren't repeatedly
* decoded). Otherwise, unpack the cell and build the return
* information.
*/
if (cbt->cip_saved != cip) {
if ((cell = WT_COL_PTR(cbt->page, cip)) == NULL)
continue;
__wt_cell_unpack(cell, &unpack);
if (unpack.type == WT_CELL_DEL)
continue;
/*
* Restart for a variable-length column-store. We could
* catch restart higher up the call-stack but there's no
* point to it: unlike row-store (where a normal search
* path finds cached overflow values), we have to access
* the page's reconciliation structures, and that's as
* easy here as higher up the stack.
*/
if ((ret = __wt_cell_unpack_ref(
session, &unpack, &cbt->tmp)) == WT_RESTART)
ret = __wt_ovfl_cache_col_restart(
session, cbt->page, &unpack, &cbt->tmp);
WT_RET(ret);
cbt->cip_saved = cip;
}
val->data = cbt->tmp.data;
val->size = cbt->tmp.size;
return (0);
}
/* NOTREACHED */
}
/*
* __cursor_row_prev --
* Move to the previous row-store item.
*/
static inline int
__cursor_row_prev(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_INSERT *ins;
WT_ITEM *key, *val;
WT_PAGE *page;
WT_ROW *rip;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
page = cbt->ref->page;
key = &cbt->iface.key;
val = &cbt->iface.value;
/*
* For row-store pages, we need a single item that tells us the part
* of the page we're walking (otherwise switching from next to prev
* and vice-versa is just too complicated), so we map the WT_ROW and
* WT_INSERT_HEAD insert array slots into a single name space: slot 1
* is the "smallest key insert list", slot 2 is WT_ROW[0], slot 3 is
* WT_INSERT_HEAD[0], and so on. This means WT_INSERT lists are
* odd-numbered slots, and WT_ROW array slots are even-numbered slots.
*
* New page configuration.
*/
if (newpage) {
/*
* If we haven't instantiated keys on this page, do so, else it
* is a very, very slow traversal.
*/
if (!F_ISSET_ATOMIC(page, WT_PAGE_BUILD_KEYS))
WT_RET(__wt_row_leaf_keys(session, page));
if (page->pg_row_entries == 0)
cbt->ins_head = WT_ROW_INSERT_SMALLEST(page);
else
cbt->ins_head =
WT_ROW_INSERT_SLOT(page, page->pg_row_entries - 1);
cbt->ins = WT_SKIP_LAST(cbt->ins_head);
cbt->row_iteration_slot = page->pg_row_entries * 2 + 1;
goto new_insert;
}
/* Move to the previous entry and return the item. */
for (;;) {
/*
* Continue traversing any insert list. Maintain the reference
* to the current insert element in case we switch to a cursor
* next movement.
*/
if (cbt->ins != NULL)
WT_RET(__cursor_skip_prev(cbt));
new_insert: if ((ins = cbt->ins) != NULL) {
if ((upd = __wt_txn_read(session, ins->upd)) == NULL)
continue;
if (WT_UPDATE_DELETED_ISSET(upd)) {
if (__wt_txn_visible_all(session, upd->txnid))
++cbt->page_deleted_count;
continue;
}
key->data = WT_INSERT_KEY(ins);
key->size = WT_INSERT_KEY_SIZE(ins);
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/* Check for the beginning of the page. */
if (cbt->row_iteration_slot == 1)
return (WT_NOTFOUND);
--cbt->row_iteration_slot;
/*
* Odd-numbered slots configure as WT_INSERT_HEAD entries,
* even-numbered slots configure as WT_ROW entries.
*/
if (cbt->row_iteration_slot & 0x01) {
cbt->ins_head = cbt->row_iteration_slot == 1 ?
WT_ROW_INSERT_SMALLEST(page) :
WT_ROW_INSERT_SLOT(
page, cbt->row_iteration_slot / 2 - 1);
cbt->ins = WT_SKIP_LAST(cbt->ins_head);
goto new_insert;
}
cbt->ins_head = NULL;
cbt->ins = NULL;
cbt->slot = cbt->row_iteration_slot / 2 - 1;
rip = &page->pg_row_d[cbt->slot];
upd = __wt_txn_read(session, WT_ROW_UPDATE(page, rip));
if (upd != NULL && WT_UPDATE_DELETED_ISSET(upd)) {
if (__wt_txn_visible_all(session, upd->txnid))
++cbt->page_deleted_count;
continue;
}
return (__cursor_row_slot_return(cbt, rip, upd));
}
/* NOTREACHED */
}
/*
* __wt_kv_return --
* Return a page referenced key/value pair to the application.
*/
int
__wt_kv_return(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt)
{
WT_BTREE *btree;
WT_CELL *cell;
WT_CELL_UNPACK unpack;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_PAGE *page;
WT_ROW *rip;
WT_UPDATE *upd;
uint8_t v;
btree = S2BT(session);
page = cbt->page;
cursor = &cbt->iface;
switch (page->type) {
case WT_PAGE_COL_FIX:
/*
* The interface cursor's record has usually been set, but that
* isn't universally true, specifically, cursor.search_near may
* call here without first setting the interface cursor.
*/
cursor->recno = cbt->recno;
/*
* If the cursor references a WT_INSERT item, take the related
* WT_UPDATE item.
*/
if (cbt->ins != NULL &&
(upd = __wt_txn_read(session, cbt->ins->upd)) != NULL) {
cursor->value.data = WT_UPDATE_DATA(upd);
cursor->value.size = upd->size;
return (0);
}
v = __bit_getv_recno(page, cbt->iface.recno, btree->bitcnt);
return (__wt_buf_set(session, &cursor->value, &v, 1));
case WT_PAGE_COL_VAR:
/*
* The interface cursor's record has usually been set, but that
* isn't universally true, specifically, cursor.search_near may
* call here without first setting the interface cursor.
*/
cursor->recno = cbt->recno;
/*
* If the cursor references a WT_INSERT item, take the related
* WT_UPDATE item.
*/
if (cbt->ins != NULL &&
(upd = __wt_txn_read(session, cbt->ins->upd)) != NULL) {
cursor->value.data = WT_UPDATE_DATA(upd);
cursor->value.size = upd->size;
return (0);
}
cell = WT_COL_PTR(page, &page->u.col_var.d[cbt->slot]);
break;
case WT_PAGE_ROW_LEAF:
rip = &page->u.row.d[cbt->slot];
/*
* If the cursor references a WT_INSERT item, take the key and
* related WT_UPDATE item. Otherwise, take the key from the
* original page, and the value from any related WT_UPDATE item,
* or the page if the key was never updated.
*/
if (cbt->ins != NULL &&
(upd = __wt_txn_read(session, cbt->ins->upd)) != NULL) {
cursor->key.data = WT_INSERT_KEY(cbt->ins);
cursor->key.size = WT_INSERT_KEY_SIZE(cbt->ins);
} else {
WT_RET(
__wt_row_key(session, page, rip, &cursor->key, 0));
upd = __wt_txn_read(session, WT_ROW_UPDATE(page, rip));
}
if (upd != NULL) {
cursor->value.data = WT_UPDATE_DATA(upd);
cursor->value.size = upd->size;
return (0);
}
/* Take the original cell (which may be empty). */
if ((cell = __wt_row_value(page, rip)) == NULL) {
cursor->value.size = 0;
return (0);
}
break;
WT_ILLEGAL_VALUE(session);
}
/* The value is an on-page cell, unpack and expand it as necessary. */
__wt_cell_unpack(cell, &unpack);
ret = __wt_cell_unpack_ref(session, &unpack, &cursor->value);
/*
* Restart for a variable-length column-store. We could catch restart
* higher up the call-stack but there's no point to it: unlike row-store
* (where a normal search path finds cached overflow values), we have to
* access the page's reconciliation structures, and that's as easy here
* as higher up the stack.
*/
if (ret == WT_RESTART && page->type == WT_PAGE_COL_VAR)
ret = __wt_ovfl_cache_col_restart(
session, page, &unpack, &cursor->value);
return (ret);
}
/*
* __cursor_fix_append_prev --
* Return the previous fixed-length entry on the append list.
*/
static inline int
__cursor_fix_append_prev(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_ITEM *val;
WT_PAGE *page;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
page = cbt->ref->page;
val = &cbt->iface.value;
if (newpage) {
if ((cbt->ins = WT_SKIP_LAST(cbt->ins_head)) == NULL)
return (WT_NOTFOUND);
} else {
/*
* Handle the special case of leading implicit records, that is,
* there aren't any records in the tree not on the append list,
* and the first record on the append list isn't record 1.
*
* The "right" place to handle this is probably in our caller.
* The high-level cursor-previous routine would:
* -- call this routine to walk the append list
* -- call the routine to walk the standard page items
* -- call the tree walk routine looking for a previous page
* Each of them returns WT_NOTFOUND, at which point our caller
* checks the cursor record number, and if it's larger than 1,
* returns the implicit records. Instead, I'm trying to detect
* the case here, mostly because I don't want to put that code
* into our caller. Anyway, if this code breaks for any reason,
* that's the way I'd go.
*
* If we're not pointing to a WT_INSERT entry, or we can't find
* a WT_INSERT record that precedes our record name-space, check
* if there are any records on the page. If there aren't, then
* we're in the magic zone, keep going until we get to a record
* number of 1.
*/
if (cbt->ins != NULL &&
cbt->recno <= WT_INSERT_RECNO(cbt->ins))
WT_RET(__cursor_skip_prev(cbt));
if (cbt->ins == NULL &&
(cbt->recno == 1 || __col_fix_last_recno(page) != 0))
return (WT_NOTFOUND);
}
/*
* This code looks different from the cursor-next code. The append
* list appears on the last page of the tree and contains the last
* records in the tree. If we're iterating through the tree, starting
* at the last record in the tree, by definition we're starting a new
* iteration and we set the record number to the last record found in
* the tree. Otherwise, decrement the record.
*/
if (newpage)
__cursor_set_recno(cbt, WT_INSERT_RECNO(cbt->ins));
else
__cursor_set_recno(cbt, cbt->recno - 1);
/*
* Fixed-width column store appends are inherently non-transactional.
* Even a non-visible update by a concurrent or aborted transaction
* changes the effective end of the data. The effect is subtle because
* of the blurring between deleted and empty values, but ideally we
* would skip all uncommitted changes at the end of the data. This
* doesn't apply to variable-width column stores because the implicitly
* created records written by reconciliation are deleted and so can be
* never seen by a read.
*/
if (cbt->ins == NULL ||
cbt->recno > WT_INSERT_RECNO(cbt->ins) ||
(upd = __wt_txn_read(session, cbt->ins->upd)) == NULL) {
cbt->v = 0;
val->data = &cbt->v;
} else
val->data = WT_UPDATE_DATA(upd);
val->size = 1;
return (0);
}
/*移向下条variable-length column-store 记录*/
static inline int __cursor_var_next(WT_CURSOR_BTREE* cbt, int newpage)
{
WT_CELL *cell;
WT_CELL_UNPACK unpack;
WT_COL *cip;
WT_ITEM *val;
WT_INSERT *ins;
WT_PAGE *page;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
uint64_t rle, rle_start;
session = (WT_SESSION_IMPL *)cbt->iface.session;
page = cbt->ref->page;
val = &cbt->iface.value;
rle_start = 0; /* -Werror=maybe-uninitialized */
if (newpage){
cbt->last_standard_recno = __col_var_last_recno(page);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, page->pg_var_recno);
goto new_page;
}
for (;;){
if (cbt->recno >= cbt->last_standard_recno)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, cbt->recno + 1);
new_page:
/*定位到recno对应的WT_COL slot*/
if ((cip = __col_var_search(page, cbt->recno, &rle_start)) == NULL)
return (WT_NOTFOUND);
cbt->slot = WT_COL_SLOT(page, cip);
/*读取内容值*/
cbt->ins_head = WT_COL_UPDATE_SLOT(page, cbt->slot);
cbt->ins = __col_insert_search_match(cbt->ins_head, cbt->recno);
upd = cbt->ins == NULL ? NULL : __wt_txn_read(session, cbt->ins->upd);
if (upd != NULL) {
if (WT_UPDATE_DELETED_ISSET(upd)) {
++cbt->page_deleted_count;
continue;
}
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/*
* If we're at the same slot as the last reference and there's
* no matching insert list item, re-use the return information
* (so encoded items with large repeat counts aren't repeatedly
* decoded). Otherwise, unpack the cell and build the return
* information.
* upd == NULL, 记录可能被删除放入到了insert列表中，slot可能被重用了，那么需要进行cell unpack取值
*/
if (cbt->cip_saved != cip) {
if ((cell = WT_COL_PTR(page, cip)) == NULL)
continue;
__wt_cell_unpack(cell, &unpack);
if (unpack.type == WT_CELL_DEL) {
if ((rle = __wt_cell_rle(&unpack)) == 1)
continue;
/*定位到修改列表中的记录*/
ins = __col_insert_search_gt(cbt->ins_head, cbt->recno);
cbt->recno = rle_start + rle;
if (ins != NULL && WT_INSERT_RECNO(ins) < cbt->recno)
cbt->recno = WT_INSERT_RECNO(ins);
/* Adjust for the outer loop increment. */
--cbt->recno;
continue;
}
/*取出cell中的值到tmp中*/
WT_RET(__wt_page_cell_data_ref(session, page, &unpack, &cbt->tmp));
cbt->cip_saved = cip;
}
val->data = cbt->tmp.data;
val->size = cbt->tmp.size;
return 0;
}
}
/*
* __cursor_var_prev --
* Move to the previous, variable-length column-store item.
*/
static inline int
__cursor_var_prev(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_CELL *cell;
WT_CELL_UNPACK unpack;
WT_COL *cip;
WT_INSERT *ins;
WT_ITEM *val;
WT_PAGE *page;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
uint64_t rle_start;
session = (WT_SESSION_IMPL *)cbt->iface.session;
page = cbt->ref->page;
val = &cbt->iface.value;
rle_start = 0; /* -Werror=maybe-uninitialized */
/* Initialize for each new page. */
if (newpage) {
cbt->last_standard_recno = __col_var_last_recno(page);
if (cbt->last_standard_recno == 0)
return (WT_NOTFOUND);
__cursor_set_recno(cbt, cbt->last_standard_recno);
goto new_page;
}
/* Move to the previous entry and return the item. */
for (;;) {
__cursor_set_recno(cbt, cbt->recno - 1);
new_page: if (cbt->recno < page->pg_var_recno)
return (WT_NOTFOUND);
/* Find the matching WT_COL slot. */
if ((cip =
__col_var_search(page, cbt->recno, &rle_start)) == NULL)
return (WT_NOTFOUND);
cbt->slot = WT_COL_SLOT(page, cip);
/* Check any insert list for a matching record. */
cbt->ins_head = WT_COL_UPDATE_SLOT(page, cbt->slot);
cbt->ins = __col_insert_search_match(cbt->ins_head, cbt->recno);
upd = cbt->ins == NULL ?
NULL : __wt_txn_read(session, cbt->ins->upd);
if (upd != NULL) {
if (WT_UPDATE_DELETED_ISSET(upd)) {
if (__wt_txn_visible_all(session, upd->txnid))
++cbt->page_deleted_count;
continue;
}
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return (0);
}
/*
* If we're at the same slot as the last reference and there's
* no matching insert list item, re-use the return information
* (so encoded items with large repeat counts aren't repeatedly
* decoded). Otherwise, unpack the cell and build the return
* information.
*/
if (cbt->cip_saved != cip) {
if ((cell = WT_COL_PTR(page, cip)) == NULL)
continue;
__wt_cell_unpack(cell, &unpack);
if (unpack.type == WT_CELL_DEL) {
if (__wt_cell_rle(&unpack) == 1)
continue;
/*
* There can be huge gaps in the variable-length
* column-store name space appearing as deleted
* records. If more than one deleted record, do
* the work of finding the next record to return
* instead of looping through the records.
*
* First, find the largest record in the update
* list that's smaller than the current record.
*/
ins = __col_insert_search_lt(
cbt->ins_head, cbt->recno);
/*
* Second, for records with RLEs greater than 1,
* the above call to __col_var_search located
* this record in the page's list of repeating
* records, and returned the starting record.
* The starting record - 1 is the record to
* which we could skip, if there was no larger
* record in the update list.
*/
cbt->recno = rle_start - 1;
if (ins != NULL &&
WT_INSERT_RECNO(ins) > cbt->recno)
cbt->recno = WT_INSERT_RECNO(ins);
/* Adjust for the outer loop decrement. */
++cbt->recno;
continue;
}
WT_RET(__wt_page_cell_data_ref(
session, page, &unpack, cbt->tmp));
cbt->cip_saved = cip;
}
val->data = cbt->tmp->data;
val->size = cbt->tmp->size;
return (0);
}
/* NOTREACHED */
}
/*移向行存储的下一个行对象*/
static inline int __cursor_row_next(WT_CURSOR_BTREE* cbt, int newpage)
{
WT_INSERT *ins;
WT_ITEM *key, *val;
WT_PAGE *page;
WT_ROW *rip;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
page = cbt->ref->page;
key = &cbt->iface.key;
val = &cbt->iface.value;
/*假如是newpage，定位到insert修改队列的头位置*/
if (newpage){
cbt->ins_head = WT_ROW_INSERT_SMALLEST(page);
cbt->ins = WT_SKIP_FIRST(cbt->ins_head);
cbt->row_iteration_slot = 1;
goto new_insert;
}
for (;;){
if (cbt->ins != NULL)
cbt->ins = WT_SKIP_NEXT(cbt->ins);
new_insert:
if ((ins = cbt->ins) != NULL) {
/*事务可见数据读取*/
if ((upd = __wt_txn_read(session, ins->upd)) == NULL)
continue;
/*判断是否删除，如果删除，跳过被删除的对象*/
if (WT_UPDATE_DELETED_ISSET(upd)) {
++cbt->page_deleted_count;
continue;
}
key->data = WT_INSERT_KEY(ins);
key->size = WT_INSERT_KEY_SIZE(ins);
val->data = WT_UPDATE_DATA(upd);
val->size = upd->size;
return 0;
}
/*检索page row entires数组， 到了page的末尾*/
if (cbt->row_iteration_slot >= page->pg_row_entries * 2 + 1)
return (WT_NOTFOUND);
++cbt->row_iteration_slot;
/*
* Odd-numbered slots configure as WT_INSERT_HEAD entries,
* even-numbered slots configure as WT_ROW entries.
*/
if (cbt->row_iteration_slot & 0x01) {
cbt->ins_head = WT_ROW_INSERT_SLOT(page, cbt->row_iteration_slot / 2 - 1);
cbt->ins = WT_SKIP_FIRST(cbt->ins_head);
goto new_insert;
}
cbt->ins_head = NULL;
cbt->ins = NULL;
/*计算定位slot*/
cbt->slot = cbt->row_iteration_slot / 2 - 1;
rip = &page->pg_row_d[cbt->slot];
upd = __wt_txn_read(session, WT_ROW_UPDATE(page, rip));
if (upd != NULL && WT_UPDATE_DELETED_ISSET(upd)) {
++cbt->page_deleted_count;
continue;
}
return __cursor_row_slot_return(cbt, rip, upd);
}
}
/*
* __cursor_valid --
* Return if the cursor references an valid key/value pair.
*/
static inline bool
__cursor_valid(WT_CURSOR_BTREE *cbt, WT_UPDATE **updp)
{
WT_BTREE *btree;
WT_CELL *cell;
WT_COL *cip;
WT_PAGE *page;
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
btree = cbt->btree;
page = cbt->ref->page;
session = (WT_SESSION_IMPL *)cbt->iface.session;
if (updp != NULL)
*updp = NULL;
/*
* We may be pointing to an insert object, and we may have a page with
* existing entries. Insert objects always have associated update
* objects (the value). Any update object may be deleted, or invisible
* to us. In the case of an on-page entry, there is by definition a
* value that is visible to us, the original page cell.
*
* If we find a visible update structure, return our caller a reference
* to it because we don't want to repeatedly search for the update, it
* might suddenly become invisible (imagine a read-uncommitted session
* with another session's aborted insert), and we don't want to handle
* that potential error every time we look at the value.
*
* Unfortunately, the objects we might have and their relationships are
* different for the underlying page types.
*
* In the case of row-store, an insert object implies ignoring any page
* objects, no insert object can have the same key as an on-page object.
* For row-store:
* if there's an insert object:
* if there's a visible update:
* exact match
* else
* no exact match
* else
* use the on-page object (which may have an associated
* update object that may or may not be visible to us).
*
* Column-store is more complicated because an insert object can have
* the same key as an on-page object: updates to column-store rows
* are insert/object pairs, and an invisible update isn't the end as
* there may be an on-page object that is visible. This changes the
* logic to:
* if there's an insert object:
* if there's a visible update:
* exact match
* else if the on-page object's key matches the insert key
* use the on-page object
* else
* use the on-page object
*
* First, check for an insert object with a visible update (a visible
* update that's been deleted is not a valid key/value pair).
*/
if (cbt->ins != NULL &&
(upd = __wt_txn_read(session, cbt->ins->upd)) != NULL) {
if (WT_UPDATE_DELETED_ISSET(upd))
return (false);
if (updp != NULL)
*updp = upd;
return (true);
}
/*
* If we don't have an insert object, or in the case of column-store,
* there's an insert object but no update was visible to us and the key
* on the page is the same as the insert object's key, and the slot as
* set by the search function is valid, we can use the original page
* information.
*/
switch (btree->type) {
case BTREE_COL_FIX:
/*
* If search returned an insert object, there may or may not be
* a matching on-page object, we have to check. Fixed-length
* column-store pages don't have slots, but map one-to-one to
* keys, check for retrieval past the end of the page.
*/
if (cbt->recno >= cbt->ref->ref_recno + page->pg_fix_entries)
return (false);
/*
* An update would have appeared as an "insert" object; no
* further checks to do.
*/
break;
case BTREE_COL_VAR:
/* The search function doesn't check for empty pages. */
if (page->pg_var_entries == 0)
return (false);
WT_ASSERT(session, cbt->slot < page->pg_var_entries);
/*
* Column-store updates are stored as "insert" objects. If
* search returned an insert object we can't return, the
* returned on-page object must be checked for a match.
*/
if (cbt->ins != NULL && !F_ISSET(cbt, WT_CBT_VAR_ONPAGE_MATCH))
return (false);
/*
* Although updates would have appeared as an "insert" objects,
* variable-length column store deletes are written into the
* backing store; check the cell for a record already deleted
* when read.
*/
cip = &page->pg_var_d[cbt->slot];
if ((cell = WT_COL_PTR(page, cip)) == NULL ||
__wt_cell_type(cell) == WT_CELL_DEL)
return (false);
break;
case BTREE_ROW:
/* The search function doesn't check for empty pages. */
if (page->pg_row_entries == 0)
return (false);
WT_ASSERT(session, cbt->slot < page->pg_row_entries);
/*
* See above: for row-store, no insert object can have the same
* key as an on-page object, we're done.
*/
if (cbt->ins != NULL)
return (false);
/* Check for an update. */
if (page->modify != NULL &&
page->modify->mod_row_update != NULL &&
(upd = __wt_txn_read(session,
page->modify->mod_row_update[cbt->slot])) != NULL) {
if (WT_UPDATE_DELETED_ISSET(upd))
return (false);
if (updp != NULL)
*updp = upd;
}
break;
}
return (true);
}
/*
* __cursor_fix_append_prev --
* Return the previous fixed-length entry on the append list.
*/
static inline int
__cursor_fix_append_prev(WT_CURSOR_BTREE *cbt, bool newpage)
{
WT_SESSION_IMPL *session;
WT_UPDATE *upd;
session = (WT_SESSION_IMPL *)cbt->iface.session;
if (newpage) {
if ((cbt->ins = WT_SKIP_LAST(cbt->ins_head)) == NULL)
return (WT_NOTFOUND);
} else {
/* Move to the previous record in the append list, if any. */
if (cbt->ins != NULL &&
cbt->recno <= WT_INSERT_RECNO(cbt->ins))
WT_RET(__cursor_skip_prev(cbt));
/*
* Handle the special case of leading implicit records, that is,
* there aren't any records in the page not on the append list,
* and the append list's first record isn't the first record on
* the page. (Although implemented as a test of the page values,
* this is really a test for a tree where the first inserted
* record wasn't record 1, any other page with only an append
* list will have a first page record number matching the first
* record in the append list.)
*
* The "right" place to handle this is probably in our caller.
* The high-level cursor-previous routine would:
* -- call this routine to walk the append list
* -- call the routine to walk the standard page items
* -- call the tree walk routine looking for a previous page
* Each of them returns WT_NOTFOUND, at which point our caller
* checks the cursor record number, and if it's larger than 1,
* returns the implicit records. Instead, I'm trying to detect
* the case here, mostly because I don't want to put that code
* into our caller. Anyway, if this code breaks for any reason,
* that's the way I'd go.
*
* If we're not pointing to a WT_INSERT entry (we didn't find a
* WT_INSERT record preceding our record name-space), check if
* we've reached the beginning of this page, a possibility if a
* page had a large number of items appended, and then split.
* If not, check if there are any records on the page. If there
* aren't, then we're in the magic zone, keep going until we get
* to a record number matching the first record on the page.
*/
if (cbt->ins == NULL &&
(cbt->recno == cbt->ref->ref_recno ||
__col_fix_last_recno(cbt->ref) != 0))
return (WT_NOTFOUND);
}
/*
* This code looks different from the cursor-next code. The append list
* may be preceded by other rows. If we're iterating through the tree,
* starting at the last record in the tree, by definition we're starting
* a new iteration and we set the record number to the last record found
* on the page. Otherwise, decrement the record.
*/
if (newpage)
__cursor_set_recno(cbt, WT_INSERT_RECNO(cbt->ins));
else
__cursor_set_recno(cbt, cbt->recno - 1);
/*
* Fixed-width column store appends are inherently non-transactional.
* Even a non-visible update by a concurrent or aborted transaction
* changes the effective end of the data. The effect is subtle because
* of the blurring between deleted and empty values, but ideally we
* would skip all uncommitted changes at the end of the data. This
* doesn't apply to variable-width column stores because the implicitly
* created records written by reconciliation are deleted and so can be
* never seen by a read.
*/
if (cbt->ins == NULL ||
cbt->recno > WT_INSERT_RECNO(cbt->ins) ||
(upd = __wt_txn_read(session, cbt->ins->upd)) == NULL) {
cbt->v = 0;
cbt->iface.value.data = &cbt->v;
} else
cbt->iface.value.data = upd->data;
cbt->iface.value.size = 1;
return (0);
}