自学教程：C++ F_ISSET函数代码示例

/* * __wt_btcur_insert -- *	Insert a record into the tree. */int__wt_btcur_insert(WT_CURSOR_BTREE *cbt){	WT_BTREE *btree;	WT_CURSOR *cursor;	WT_DECL_RET;	WT_SESSION_IMPL *session;	btree = cbt->btree;	cursor = &cbt->iface;	session = (WT_SESSION_IMPL *)cursor->session;	WT_STAT_CONN_INCR(session, cursor_insert);	WT_STAT_DATA_INCR(session, cursor_insert);	WT_STAT_DATA_INCRV(session,	    cursor_insert_bytes, cursor->key.size + cursor->value.size);	if (btree->type == BTREE_ROW)		WT_RET(__cursor_size_chk(session, &cursor->key));	WT_RET(__cursor_size_chk(session, &cursor->value));	/*	 * The tree is no longer empty: eviction should pay attention to it,	 * and it's no longer possible to bulk-load into it.	 */	if (btree->bulk_load_ok) {		btree->bulk_load_ok = false;		__wt_btree_evictable(session, true);	}retry:	WT_RET(__cursor_func_init(cbt, true));	switch (btree->type) {	case BTREE_COL_FIX:	case BTREE_COL_VAR:		/*		 * If WT_CURSTD_APPEND is set, insert a new record (ignoring		 * the application's record number). The real record number		 * is assigned by the serialized append operation.		 */		if (F_ISSET(cursor, WT_CURSTD_APPEND))			cbt->iface.recno = WT_RECNO_OOB;		WT_ERR(__cursor_col_search(session, cbt, NULL));		/*		 * If not overwriting, fail if the key exists.  Creating a		 * record past the end of the tree in a fixed-length		 * column-store implicitly fills the gap with empty records.		 * Fail in that case, the record exists.		 */		if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE) &&		    ((cbt->compare == 0 && __cursor_valid(cbt, NULL)) ||		    (cbt->compare != 0 && __cursor_fix_implicit(btree, cbt))))			WT_ERR(WT_DUPLICATE_KEY);		WT_ERR(__cursor_col_modify(session, cbt, false));		if (F_ISSET(cursor, WT_CURSTD_APPEND))			cbt->iface.recno = cbt->recno;		break;	case BTREE_ROW:		WT_ERR(__cursor_row_search(session, cbt, NULL, true));		/*		 * If not overwriting, fail if the key exists, else insert the		 * key/value pair.		 */		if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE) &&		    cbt->compare == 0 && __cursor_valid(cbt, NULL))			WT_ERR(WT_DUPLICATE_KEY);		ret = __cursor_row_modify(session, cbt, false);		break;	}err:	if (ret == WT_RESTART) {		WT_STAT_CONN_INCR(session, cursor_restart);		WT_STAT_DATA_INCR(session, cursor_restart);		goto retry;	}	/* Insert doesn't maintain a position across calls, clear resources. */	if (ret == 0)		WT_TRET(__curfile_leave(cbt));	if (ret != 0)		WT_TRET(__cursor_reset(cbt));	return (ret);}

/* * __wt_btcur_prev -- *	Move to the previous record in the tree. */int__wt_btcur_prev(WT_CURSOR_BTREE *cbt, bool truncating){	WT_CURSOR *cursor;	WT_DECL_RET;	WT_PAGE *page;	WT_SESSION_IMPL *session;	uint32_t flags;	bool newpage;	cursor = &cbt->iface;	session = (WT_SESSION_IMPL *)cbt->iface.session;	WT_STAT_CONN_INCR(session, cursor_prev);	WT_STAT_DATA_INCR(session, cursor_prev);	F_CLR(cursor, WT_CURSTD_KEY_SET | WT_CURSTD_VALUE_SET);	WT_RET(__cursor_func_init(cbt, false));	/*	 * If we aren't already iterating in the right direction, there's	 * some setup to do.	 */	if (!F_ISSET(cbt, WT_CBT_ITERATE_PREV))		__wt_btcur_iterate_setup(cbt);	/*	 * Walk any page we're holding until the underlying call returns not-	 * found.  Then, move to the previous page, until we reach the start	 * of the file.	 */	flags = WT_READ_PREV | WT_READ_SKIP_INTL;	/* tree walk flags */	LF_SET(WT_READ_NO_SPLIT);			/* don't try to split */	if (truncating)		LF_SET(WT_READ_TRUNCATE);	for (newpage = false;; newpage = true) {		page = cbt->ref == NULL ? NULL : cbt->ref->page;		/*		 * Column-store pages may have appended entries. Handle it		 * separately from the usual cursor code, it's in a simple		 * format.		 */		if (newpage && page != NULL && page->type != WT_PAGE_ROW_LEAF &&		    (cbt->ins_head = WT_COL_APPEND(page)) != NULL)			F_SET(cbt, WT_CBT_ITERATE_APPEND);		if (F_ISSET(cbt, WT_CBT_ITERATE_APPEND)) {			switch (page->type) {			case WT_PAGE_COL_FIX:				ret = __cursor_fix_append_prev(cbt, newpage);				break;			case WT_PAGE_COL_VAR:				ret = __cursor_var_append_prev(cbt, newpage);				break;			WT_ILLEGAL_VALUE_ERR(session);			}			if (ret == 0)				break;			F_CLR(cbt, WT_CBT_ITERATE_APPEND);			if (ret != WT_NOTFOUND)				break;			newpage = true;		}		if (page != NULL) {			switch (page->type) {			case WT_PAGE_COL_FIX:				ret = __cursor_fix_prev(cbt, newpage);				break;			case WT_PAGE_COL_VAR:				ret = __cursor_var_prev(cbt, newpage);				break;			case WT_PAGE_ROW_LEAF:				ret = __cursor_row_prev(cbt, newpage);				break;			WT_ILLEGAL_VALUE_ERR(session);			}			if (ret != WT_NOTFOUND)				break;		}		/*		 * If we saw a lot of deleted records on this page, or we went		 * all the way through a page and only saw deleted records, try		 * to evict the page when we release it.  Otherwise repeatedly		 * deleting from the beginning of a tree can have quadratic		 * performance.  Take care not to force eviction of pages that		 * are genuinely empty, in new trees.		 */		if (page != NULL &&		    (cbt->page_deleted_count > WT_BTREE_DELETE_THRESHOLD ||		    (newpage && cbt->page_deleted_count > 0)))			__wt_page_evict_soon(session, cbt->ref);		cbt->page_deleted_count = 0;//.........这里部分代码省略.........

/* * __wt_txn_rollback -- *	Roll back the current transaction. */int__wt_txn_rollback(WT_SESSION_IMPL *session, const char *cfg[]){	WT_DECL_RET;	WT_TXN *txn;	WT_TXN_OP *op;	u_int i;	bool readonly;	WT_UNUSED(cfg);	txn = &session->txn;	readonly = txn->mod_count == 0;	WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING));	/* Rollback notification. */	if (txn->notify != NULL)		WT_TRET(txn->notify->notify(txn->notify, (WT_SESSION *)session,		    txn->id, 0));	/* Rollback updates. */	for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++) {		/* Metadata updates are never rolled back. */		if (op->fileid == WT_METAFILE_ID)			continue;		switch (op->type) {		case WT_TXN_OP_BASIC:		case WT_TXN_OP_BASIC_TS:		case WT_TXN_OP_INMEM:			WT_ASSERT(session, op->u.upd->txnid == txn->id);			WT_ASSERT(session,			    S2C(session)->cache->las_fileid == 0 ||			    op->fileid != S2C(session)->cache->las_fileid);			op->u.upd->txnid = WT_TXN_ABORTED;			break;		case WT_TXN_OP_REF:			__wt_delete_page_rollback(session, op->u.ref);			break;		case WT_TXN_OP_TRUNCATE_COL:		case WT_TXN_OP_TRUNCATE_ROW:			/*			 * Nothing to do: these operations are only logged for			 * recovery.  The in-memory changes will be rolled back			 * with a combination of WT_TXN_OP_REF and			 * WT_TXN_OP_INMEM operations.			 */			break;		}		/* Free any memory allocated for the operation. */		__wt_txn_op_free(session, op);	}	txn->mod_count = 0;	__wt_txn_release(session);	/*	 * We're between transactions, if we need to block for eviction, it's	 * a good time to do so.  Note that we must ignore any error return	 * because the user's data is committed.	 */	if (!readonly)		(void)__wt_cache_eviction_check(session, false, false, NULL);	return (ret);}

/* * ex_aci -- *	Append, change, insert in ex. */static intex_aci(SCR *sp, EXCMD *cmdp, enum which cmd){	CHAR_T *p, *t;	GS *gp;	TEXT *tp;	TEXTH tiq[] = {{ 0 }};	recno_t cnt = 0, lno;	size_t len;	u_int32_t flags;	int need_newline;	gp = sp->gp;	NEEDFILE(sp, cmdp);	/*	 * If doing a change, replace lines for as long as possible.  Then,	 * append more lines or delete remaining lines.  Changes to an empty	 * file are appends, inserts are the same as appends to the previous	 * line.	 *	 * !!!	 * Set the address to which we'll append.  We set sp->lno to this	 * address as well so that autoindent works correctly when get text	 * from the user.	 */	lno = cmdp->addr1.lno;	sp->lno = lno;	if ((cmd == CHANGE || cmd == INSERT) && lno != 0)		--lno;	/*	 * !!!	 * If the file isn't empty, cut changes into the unnamed buffer.	 */	if (cmd == CHANGE && cmdp->addr1.lno != 0 &&	    (cut(sp, NULL, &cmdp->addr1, &cmdp->addr2, CUT_LINEMODE) ||	    del(sp, &cmdp->addr1, &cmdp->addr2, 1)))		return (1);	/*	 * !!!	 * Anything that was left after the command separator becomes part	 * of the inserted text.  Apparently, it was common usage to enter:	 *	 *	:g/pattern/append|stuff1	 *	 * and append the line of text "stuff1" to the lines containing the	 * pattern.  It was also historically legal to enter:	 *	 *	:append|stuff1	 *	stuff2	 *	.	 *	 * and the text on the ex command line would be appended as well as	 * the text inserted after it.  There was an historic bug however,	 * that the user had to enter *two* terminating lines (the '.' lines)	 * to terminate text input mode, in this case.  This whole thing	 * could be taken too far, however.  Entering:	 *	 *	:append|stuff1/	 *	stuff2	 *	stuff3	 *	.	 *	 * i.e. mixing and matching the forms confused the historic vi, and,	 * not only did it take two terminating lines to terminate text input	 * mode, but the trailing backslashes were retained on the input.  We	 * match historic practice except that we discard the backslashes.	 *	 * Input lines specified on the ex command line lines are separated by	 * <newline>s.  If there is a trailing delimiter an empty line was	 * inserted.  There may also be a leading delimiter, which is ignored	 * unless it's also a trailing delimiter.  It is possible to encounter	 * a termination line, i.e. a single '.', in a global command, but not	 * necessary if the text insert command was the last of the global	 * commands.	 */	if (cmdp->save_cmdlen != 0) {		for (p = cmdp->save_cmd,		    len = cmdp->save_cmdlen; len > 0; p = t) {			for (t = p; len > 0 && t[0] != '/n'; ++t, --len);			if (t != p || len == 0) {				if (F_ISSET(sp, SC_EX_GLOBAL) &&				    t - p == 1 && p[0] == '.') {					++t;					if (len > 0)						--len;					break;				}				if (db_append(sp, 1, lno++, p, t - p))					return (1);			}			if (len != 0) {				++t;				if (--len == 0 &&//.........这里部分代码省略.........

/* * cl_event -- *	Return a single event. * * PUBLIC: int cl_event __P((SCR *, EVENT *, u_int32_t, int)); */intcl_event(SCR *sp, EVENT *evp, u_int32_t flags, int ms){	struct timeval t, *tp;	CL_PRIVATE *clp;	size_t lines, columns;	int changed, nr = 0;	CHAR_T *wp;	size_t wlen;	int rc;	/*	 * Queue signal based events.  We never clear SIGHUP or SIGTERM events,	 * so that we just keep returning them until the editor dies.	 */	clp = CLP(sp);retest:	if (LF_ISSET(EC_INTERRUPT) || F_ISSET(clp, CL_SIGINT)) {		if (F_ISSET(clp, CL_SIGINT)) {			F_CLR(clp, CL_SIGINT);			evp->e_event = E_INTERRUPT;		} else			evp->e_event = E_TIMEOUT;		return (0);	}	if (F_ISSET(clp, CL_SIGHUP | CL_SIGTERM | CL_SIGWINCH)) {		if (F_ISSET(clp, CL_SIGHUP)) {			evp->e_event = E_SIGHUP;			return (0);		}		if (F_ISSET(clp, CL_SIGTERM)) {			evp->e_event = E_SIGTERM;			return (0);		}		if (F_ISSET(clp, CL_SIGWINCH)) {			F_CLR(clp, CL_SIGWINCH);			if (cl_ssize(sp, 1, &lines, &columns, &changed))				return (1);			if (changed) {				(void)cl_resize(sp, lines, columns);				evp->e_event = E_WRESIZE;				return (0);			}			/* No real change, ignore the signal. */		}	}	/* Set timer. */	if (ms == 0)		tp = NULL;	else {		t.tv_sec = ms / 1000;		t.tv_usec = (ms % 1000) * 1000;		tp = &t;	}	/* Read input characters. */read:	switch (cl_read(sp, LF_ISSET(EC_QUOTED | EC_RAW),	    clp->ibuf + clp->skip, SIZE(clp->ibuf) - clp->skip, &nr, tp)) {	case INP_OK:		rc = INPUT2INT5(sp, clp->cw, clp->ibuf, nr + clp->skip,				wp, wlen);		evp->e_csp = wp;		evp->e_len = wlen;		evp->e_event = E_STRING;		if (rc < 0) {		    int n = -rc;		    memmove(clp->ibuf, clp->ibuf + nr + clp->skip - n, n);		    clp->skip = n;		    if (wlen == 0)			goto read;		} else if (rc == 0)		    clp->skip = 0;		else		    msgq(sp, M_ERR, "323|Invalid input. Truncated.");		break;	case INP_EOF:		evp->e_event = E_EOF;		break;	case INP_ERR:		evp->e_event = E_ERR;		break;	case INP_INTR:		goto retest;	case INP_TIMEOUT:		evp->e_event = E_TIMEOUT;		break;	default:		abort();	}	return (0);}

/* * __rec_review -- *	Get exclusive access to the page and review the page and its subtree *	for conditions that would block its eviction. * *	The ref and page arguments may appear to be redundant, because usually *	ref->page == page and page->ref == ref.  However, we need both because *	(a) there are cases where ref == NULL (e.g., for root page or during *	salvage), and (b) we can't safely look at page->ref until we have a *	hazard reference. */static int__rec_review(WT_SESSION_IMPL *session,    WT_REF *ref, WT_PAGE *page, uint32_t flags, int top){	WT_DECL_RET;	WT_PAGE_MODIFY *mod;	WT_TXN *txn;	uint32_t i;	txn = &session->txn;	/*	 * Get exclusive access to the page if our caller doesn't have the tree	 * locked down.	 */	if (!LF_ISSET(WT_REC_SINGLE))		WT_RET(__hazard_exclusive(session, ref, top));	/*	 * Recurse through the page's subtree: this happens first because we	 * have to write pages in depth-first order, otherwise we'll dirty	 * pages after we've written them.	 */	if (page->type == WT_PAGE_COL_INT || page->type == WT_PAGE_ROW_INT)		WT_REF_FOREACH(page, ref, i)			switch (ref->state) {			case WT_REF_DISK:		/* On-disk */			case WT_REF_DELETED:		/* On-disk, deleted */				break;			case WT_REF_MEM:		/* In-memory */				WT_RET(__rec_review(				    session, ref, ref->page, flags, 0));				break;			case WT_REF_EVICT_WALK:		/* Walk point */			case WT_REF_LOCKED:		/* Being evicted */			case WT_REF_READING:		/* Being read */				return (EBUSY);			}	/*	 * Check if this page can be evicted:	 *	 * Fail if the top-level page is a page expected to be removed from the	 * tree as part of eviction (an empty page or a split-merge page).  Note	 * "split" pages are NOT included in this test, because a split page can	 * be separately evicted, at which point it's replaced in its parent by	 * a reference to a split-merge page.  That's a normal part of the leaf	 * page life-cycle if it grows too large and must be pushed out of the	 * cache.  There is also an exception for empty pages, the root page may	 * be empty when evicted, but that only happens when the tree is closed.	 *	 * Fail if any page in the top-level page's subtree can't be merged into	 * its parent.  You can't evict a page that references such in-memory	 * pages, they must be evicted first.  The test is necessary but should	 * not fire much: the LRU-based eviction code is biased for leaf pages,	 * an internal page shouldn't be selected for LRU-based eviction until	 * its children have been evicted.  Empty, split and split-merge pages	 * are all included in this test, they can all be merged into a parent.	 *	 * We have to write dirty pages to know their final state, a page marked	 * empty may have had records added since reconciliation, a page marked	 * split may have had records deleted and no longer need to split.	 * Split-merge pages are the exception: they can never be change into	 * anything other than a split-merge page and are merged regardless of	 * being clean or dirty.	 *	 * Writing the page is expensive, do a cheap test first: if it doesn't	 * appear a subtree page can be merged, quit.  It's possible the page	 * has been emptied since it was last reconciled, and writing it before	 * testing might be worthwhile, but it's more probable we're attempting	 * to evict an internal page with live children, and that's a waste of	 * time.	 *	 * We don't do a cheap test for the top-level page: we're not called	 * to evict split-merge pages, which means the only interesting case	 * is an empty page.  If the eviction thread picked an "empty" page	 * for eviction, it must have had reason, probably the empty page got	 * really, really full.	 */	mod = page->modify;	if (!top && (mod == NULL || !F_ISSET(mod,	    WT_PM_REC_EMPTY | WT_PM_REC_SPLIT | WT_PM_REC_SPLIT_MERGE)))		return (EBUSY);	/* If the page is dirty, write it so we know the final state. */	if (__wt_page_is_modified(page) &&	    !F_ISSET(mod, WT_PM_REC_SPLIT_MERGE)) {		ret = __wt_rec_write(session, page, NULL, flags);//.........这里部分代码省略.........

/* * __wt_page_in_func -- *	Acquire a hazard pointer to a page; if the page is not in-memory, *	read it from the disk and build an in-memory version. */int__wt_page_in_func(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags#ifdef HAVE_DIAGNOSTIC    , const char *file, int line#endif    ){	WT_DECL_RET;	WT_PAGE *page;	int busy, force_attempts, oldgen;	for (force_attempts = oldgen = 0;;) {		switch (ref->state) {		case WT_REF_DISK:		case WT_REF_DELETED:			if (LF_ISSET(WT_READ_CACHE))				return (WT_NOTFOUND);			/*			 * The page isn't in memory, attempt to read it.			 * Make sure there is space in the cache.			 */			WT_RET(__wt_cache_full_check(session));			WT_RET(__wt_cache_read(session, ref));			oldgen = LF_ISSET(WT_READ_WONT_NEED) ||			    F_ISSET(session, WT_SESSION_NO_CACHE);			continue;		case WT_REF_READING:			if (LF_ISSET(WT_READ_CACHE))				return (WT_NOTFOUND);			/* FALLTHROUGH */		case WT_REF_LOCKED:			if (LF_ISSET(WT_READ_NO_WAIT))				return (WT_NOTFOUND);			/* The page is busy -- wait. */			break;		case WT_REF_SPLIT:			return (WT_RESTART);		case WT_REF_MEM:			/*			 * The page is in memory: get a hazard pointer, update			 * the page's LRU and return.  The expected reason we			 * can't get a hazard pointer is because the page is			 * being evicted; yield and try again.			 */#ifdef HAVE_DIAGNOSTIC			WT_RET(			    __wt_hazard_set(session, ref, &busy, file, line));#else			WT_RET(__wt_hazard_set(session, ref, &busy));#endif			if (busy)				break;			page = ref->page;			WT_ASSERT(session, page != NULL);			/* Forcibly evict pages that are too big. */			if (!LF_ISSET(WT_READ_NO_EVICT) &&			    force_attempts < 10 &&			    __evict_force_check(session, page)) {				++force_attempts;				WT_RET(__wt_page_release(session, ref, flags));				break;			}			/* Check if we need an autocommit transaction. */			if ((ret = __wt_txn_autocommit_check(session)) != 0) {				WT_TRET(__wt_hazard_clear(session, page));				return (ret);			}			/*			 * If we read the page and we are configured to not			 * trash the cache, set the oldest read generation so			 * the page is forcibly evicted as soon as possible.			 *			 * Otherwise, update the page's read generation.			 */			if (oldgen && page->read_gen == WT_READGEN_NOTSET)				__wt_page_evict_soon(page);			else if (!LF_ISSET(WT_READ_NO_GEN) &&			    page->read_gen < __wt_cache_read_gen(session))				page->read_gen =				    __wt_cache_read_gen_set(session);			return (0);		WT_ILLEGAL_VALUE(session);		}		/* We failed to get the page -- yield before retrying. */		__wt_yield();	}}

DB *__rec_open(const char *fname, int flags, mode_t mode, const RECNOINFO *openinfo,    int dflags){	BTREE *t;	BTREEINFO btopeninfo;	DB *dbp;	PAGE *h;	struct stat sb;	int rfd = -1;	/* pacify gcc */	int sverrno;	dbp = NULL;	/* Open the user's file -- if this fails, we're done. */	if (fname != NULL) {		if ((rfd = open(fname, flags | O_CLOEXEC, mode)) == -1)			return NULL;	}	/* Create a btree in memory (backed by disk). */	if (openinfo) {		if (openinfo->flags & ~(R_FIXEDLEN | R_NOKEY | R_SNAPSHOT))			goto einval;		btopeninfo.flags = 0;		btopeninfo.cachesize = openinfo->cachesize;		btopeninfo.maxkeypage = 0;		btopeninfo.minkeypage = 0;		btopeninfo.psize = openinfo->psize;		btopeninfo.compare = NULL;		btopeninfo.prefix = NULL;		btopeninfo.lorder = openinfo->lorder;		dbp = __bt_open(openinfo->bfname,		    O_RDWR, S_IRUSR | S_IWUSR, &btopeninfo, dflags);	} else		dbp = __bt_open(NULL, O_RDWR, S_IRUSR | S_IWUSR, NULL, dflags);	if (dbp == NULL)		goto err;	/*	 * Some fields in the tree structure are recno specific.  Fill them	 * in and make the btree structure look like a recno structure.  We	 * don't change the bt_ovflsize value, it's close enough and slightly	 * bigger.	 */	t = dbp->internal;	if (openinfo) {		if (openinfo->flags & R_FIXEDLEN) {			F_SET(t, R_FIXLEN);			t->bt_reclen = openinfo->reclen;			if (t->bt_reclen == 0)				goto einval;		}		t->bt_bval = openinfo->bval;	} else		t->bt_bval = '/n';	F_SET(t, R_RECNO);	if (fname == NULL)		F_SET(t, R_EOF | R_INMEM);	else		t->bt_rfd = rfd;	if (fname != NULL) {		/*		 * In 4.4BSD, stat(2) returns true for ISSOCK on pipes.		 * Unfortunately, that's not portable, so we use lseek		 * and check the errno values.		 */		errno = 0;		if (lseek(rfd, (off_t)0, SEEK_CUR) == -1 && errno == ESPIPE) {			switch (flags & O_ACCMODE) {			case O_RDONLY:				F_SET(t, R_RDONLY);				break;			default:				goto einval;			}slow:			if ((t->bt_rfp = fdopen(rfd, "r")) == NULL)				goto err;			F_SET(t, R_CLOSEFP);			t->bt_irec =			    F_ISSET(t, R_FIXLEN) ? __rec_fpipe : __rec_vpipe;		} else {			switch (flags & O_ACCMODE) {			case O_RDONLY:				F_SET(t, R_RDONLY);				break;			case O_RDWR:				break;			default:				goto einval;			}			if (fstat(rfd, &sb))				goto err;			/*			 * Kluge -- we'd like to test to see if the file is too			 * big to mmap.  Since, we don't know what size or type			 * off_t's or size_t's are, what the largest unsigned			 * integral type is, or what random insanity the local//.........这里部分代码省略.........

/* * __wt_page_out -- *	Discard an in-memory page, freeing all memory associated with it. */void__wt_page_out(WT_SESSION_IMPL *session, WT_PAGE **pagep){	WT_PAGE *page;	WT_PAGE_HEADER *dsk;	WT_PAGE_MODIFY *mod;	/*	 * Kill our caller's reference, do our best to catch races.	 */	page = *pagep;	*pagep = NULL;	if (F_ISSET(session->dhandle, WT_DHANDLE_DEAD))		__wt_page_modify_clear(session, page);	/*	 * We should never discard:	 * - a dirty page,	 * - a page queued for eviction, or	 * - a locked page.	 */	WT_ASSERT(session, !__wt_page_is_modified(page));	WT_ASSERT(session, !F_ISSET_ATOMIC(page, WT_PAGE_EVICT_LRU));	WT_ASSERT(session, !__wt_rwlock_islocked(session, &page->page_lock));	/*	 * If a root page split, there may be one or more pages linked from the	 * page; walk the list, discarding pages.	 */	switch (page->type) {	case WT_PAGE_COL_INT:	case WT_PAGE_ROW_INT:		mod = page->modify;		if (mod != NULL && mod->mod_root_split != NULL)			__wt_page_out(session, &mod->mod_root_split);		break;	}	/* Update the cache's information. */	__wt_cache_page_evict(session, page);	dsk = (WT_PAGE_HEADER *)page->dsk;	if (F_ISSET_ATOMIC(page, WT_PAGE_DISK_ALLOC))		__wt_cache_page_image_decr(session, dsk->mem_size);	/* Discard any mapped image. */	if (F_ISSET_ATOMIC(page, WT_PAGE_DISK_MAPPED))		(void)S2BT(session)->bm->map_discard(		    S2BT(session)->bm, session, dsk, (size_t)dsk->mem_size);	/*	 * If discarding the page as part of process exit, the application may	 * configure to leak the memory rather than do the work.	 */	if (F_ISSET(S2C(session), WT_CONN_LEAK_MEMORY))		return;	/* Free the page modification information. */	if (page->modify != NULL)		__free_page_modify(session, page);	switch (page->type) {	case WT_PAGE_COL_FIX:		break;	case WT_PAGE_COL_INT:	case WT_PAGE_ROW_INT:		__free_page_int(session, page);		break;	case WT_PAGE_COL_VAR:		__free_page_col_var(session, page);		break;	case WT_PAGE_ROW_LEAF:		__free_page_row_leaf(session, page);		break;	}	/* Discard any allocated disk image. */	if (F_ISSET_ATOMIC(page, WT_PAGE_DISK_ALLOC))		__wt_overwrite_and_free_len(session, dsk, dsk->mem_size);	__wt_overwrite_and_free(session, page);}

//.........这里部分代码省略.........	 * 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);}

/* * __wt_btcur_update -- *	Update a record in the tree. */int__wt_btcur_update(WT_CURSOR_BTREE *cbt){	WT_BTREE *btree;	WT_CURSOR *cursor;	WT_DECL_RET;	WT_SESSION_IMPL *session;	btree = cbt->btree;	cursor = &cbt->iface;	session = (WT_SESSION_IMPL *)cursor->session;	WT_STAT_CONN_INCR(session, cursor_update);	WT_STAT_DATA_INCR(session, cursor_update);	WT_STAT_DATA_INCRV(session, cursor_update_bytes, cursor->value.size);	if (btree->type == BTREE_ROW)		WT_RET(__cursor_size_chk(session, &cursor->key));	WT_RET(__cursor_size_chk(session, &cursor->value));	/*	 * The tree is no longer empty: eviction should pay attention to it,	 * and it's no longer possible to bulk-load into it.	 */	if (btree->bulk_load_ok) {		btree->bulk_load_ok = false;		__wt_btree_evictable(session, true);	}retry:	WT_RET(__cursor_func_init(cbt, true));	switch (btree->type) {	case BTREE_COL_FIX:	case BTREE_COL_VAR:		WT_ERR(__cursor_col_search(session, cbt, NULL));		/*		 * If not overwriting, fail if the key doesn't exist.  If we		 * find an update for the key, check for conflicts.  Update the		 * record if it exists.  Creating a record past the end of the		 * tree in a fixed-length column-store implicitly fills the gap		 * with empty records.  Update the record in that case, the		 * record exists.		 */		if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE)) {			WT_ERR(__curfile_update_check(cbt));			if ((cbt->compare != 0 || !__cursor_valid(cbt, NULL)) &&			    !__cursor_fix_implicit(btree, cbt))				WT_ERR(WT_NOTFOUND);		}		ret = __cursor_col_modify(session, cbt, false);		break;	case BTREE_ROW:		WT_ERR(__cursor_row_search(session, cbt, NULL, true));		/*		 * If not overwriting, check for conflicts and fail if the key		 * does not exist.		 */		if (!F_ISSET(cursor, WT_CURSTD_OVERWRITE)) {			WT_ERR(__curfile_update_check(cbt));			if (cbt->compare != 0 || !__cursor_valid(cbt, NULL))				WT_ERR(WT_NOTFOUND);		}		ret = __cursor_row_modify(session, cbt, false);		break;	}err:	if (ret == WT_RESTART) {		WT_STAT_CONN_INCR(session, cursor_restart);		WT_STAT_DATA_INCR(session, cursor_restart);		goto retry;	}	/*	 * If successful, point the cursor at internal copies of the data.  We	 * could shuffle memory in the cursor so the key/value pair are in local	 * buffer memory, but that's a data copy.  We don't want to do another	 * search (and we might get a different update structure if we race).	 * To make this work, we add a field to the btree cursor to pass back a	 * pointer to the modify function's allocated update structure.	 */	if (ret == 0)		WT_TRET(__wt_kv_return(session, cbt, cbt->modify_update));	if (ret != 0)		WT_TRET(__cursor_reset(cbt));	return (ret);}

/* * __wt_btcur_remove -- *	Remove a record from the tree. */int__wt_btcur_remove(WT_CURSOR_BTREE *cbt){	WT_BTREE *btree;	WT_CURSOR *cursor;	WT_DECL_RET;	WT_SESSION_IMPL *session;	btree = cbt->btree;	cursor = &cbt->iface;	session = (WT_SESSION_IMPL *)cursor->session;	WT_STAT_CONN_INCR(session, cursor_remove);	WT_STAT_DATA_INCR(session, cursor_remove);	WT_STAT_DATA_INCRV(session, cursor_remove_bytes, cursor->key.size);retry:	WT_RET(__cursor_func_init(cbt, true));	switch (btree->type) {	case BTREE_COL_FIX:	case BTREE_COL_VAR:		WT_ERR(__cursor_col_search(session, cbt, NULL));		/*		 * If we find a matching record, check whether an update would		 * conflict.  Do this before checking if the update is visible		 * in __cursor_valid, or we can miss conflict.		 */		WT_ERR(__curfile_update_check(cbt));		/* Remove the record if it exists. */		if (cbt->compare != 0 || !__cursor_valid(cbt, NULL)) {			if (!__cursor_fix_implicit(btree, cbt))				WT_ERR(WT_NOTFOUND);			/*			 * Creating a record past the end of the tree in a			 * fixed-length column-store implicitly fills the			 * gap with empty records.  Return success in that			 * case, the record was deleted successfully.			 *			 * Correct the btree cursor's location: the search			 * will have pointed us at the previous/next item,			 * and that's not correct.			 */			cbt->recno = cursor->recno;		} else			ret = __cursor_col_modify(session, cbt, true);		break;	case BTREE_ROW:		/* Remove the record if it exists. */		WT_ERR(__cursor_row_search(session, cbt, NULL, false));		/* Check whether an update would conflict. */		WT_ERR(__curfile_update_check(cbt));		if (cbt->compare != 0 || !__cursor_valid(cbt, NULL))			WT_ERR(WT_NOTFOUND);		ret = __cursor_row_modify(session, cbt, true);		break;	}err:	if (ret == WT_RESTART) {		WT_STAT_CONN_INCR(session, cursor_restart);		WT_STAT_DATA_INCR(session, cursor_restart);		goto retry;	}	/*	 * If the cursor is configured to overwrite and the record is not	 * found, that is exactly what we want.	 */	if (F_ISSET(cursor, WT_CURSTD_OVERWRITE) && ret == WT_NOTFOUND)		ret = 0;	if (ret != 0)		WT_TRET(__cursor_reset(cbt));	return (ret);}

/* * __wt_verify -- *	Verify a file. */int__wt_verify(WT_SESSION_IMPL *session, const char *cfg[]){	WT_BM *bm;	WT_BTREE *btree;	WT_CKPT *ckptbase, *ckpt;	WT_DECL_RET;	WT_VSTUFF *vs, _vstuff;	uint32_t root_addr_size;	uint8_t root_addr[WT_BTREE_MAX_ADDR_COOKIE];	btree = S2BT(session);	bm = btree->bm;	ckptbase = NULL;	WT_CLEAR(_vstuff);	vs = &_vstuff;	WT_ERR(__wt_scr_alloc(session, 0, &vs->max_key));	WT_ERR(__wt_scr_alloc(session, 0, &vs->max_addr));	WT_ERR(__wt_scr_alloc(session, 0, &vs->tmp1));	WT_ERR(__wt_scr_alloc(session, 0, &vs->tmp2));	/* Check configuration strings. */	WT_ERR(__verify_config(session, cfg, vs));	/* Get a list of the checkpoints for this file. */	WT_ERR(	    __wt_meta_ckptlist_get(session, btree->dhandle->name, &ckptbase));	/* Inform the underlying block manager we're verifying. */	WT_ERR(bm->verify_start(bm, session, ckptbase));	/* Loop through the file's checkpoints, verifying each one. */	WT_CKPT_FOREACH(ckptbase, ckpt) {		WT_VERBOSE_ERR(session, verify,		    "%s: checkpoint %s", btree->dhandle->name, ckpt->name);#ifdef HAVE_DIAGNOSTIC		if (vs->dump_address || vs->dump_blocks || vs->dump_pages)			WT_ERR(__wt_msg(session, "%s: checkpoint %s",			    btree->dhandle->name, ckpt->name));#endif		/* Fake checkpoints require no work. */		if (F_ISSET(ckpt, WT_CKPT_FAKE))			continue;		/* House-keeping between checkpoints. */		__verify_checkpoint_reset(vs);		/* Load the checkpoint, ignore trees with no root page. */		WT_ERR(bm->checkpoint_load(bm, session,		    ckpt->raw.data, ckpt->raw.size,		    root_addr, &root_addr_size, 1));		if (root_addr_size != 0) {			/* Verify then discard the checkpoint from the cache. */			if ((ret = __wt_btree_tree_open(			    session, root_addr, root_addr_size)) == 0) {				ret = __verify_tree(				    session, btree->root_page, vs);				WT_TRET(__wt_bt_cache_op(				    session, NULL, WT_SYNC_DISCARD_NOWRITE));			}		}		/* Unload the checkpoint. */		WT_TRET(bm->checkpoint_unload(bm, session));		WT_ERR(ret);	}

/* * __wt_rec_evict -- *	Reconciliation plus eviction. */int__wt_rec_evict(WT_SESSION_IMPL *session, WT_PAGE *page, uint32_t flags){	WT_CONNECTION_IMPL *conn;	WT_DECL_RET;	int single;	conn = S2C(session);	WT_VERBOSE_RET(session, evict,	    "page %p (%s)", page, __wt_page_type_string(page->type));	WT_ASSERT(session, session->excl_next == 0);	single = LF_ISSET(WT_REC_SINGLE) ? 1 : 0;	/*	 * Get exclusive access to the page and review the page and its subtree	 * for conditions that would block our eviction of the page.  If the	 * check fails (for example, we find a child page that can't be merged),	 * we're done.  We have to make this check for clean pages, too: while	 * unlikely eviction would choose an internal page with children, it's	 * not disallowed anywhere.	 *	 * Note that page->ref may be NULL in some cases (e.g., for root pages	 * or during salvage).  That's OK if WT_REC_SINGLE is set: we won't	 * check hazard references in that case.	 */	WT_ERR(__rec_review(session, page->ref, page, flags, 1));	/* Count evictions of internal pages during normal operation. */	if (!single &&	    (page->type == WT_PAGE_COL_INT || page->type == WT_PAGE_ROW_INT))		WT_STAT_INCR(conn->stats, cache_evict_internal);	/* Update the parent and discard the page. */	if (page->modify == NULL || !F_ISSET(page->modify, WT_PM_REC_MASK)) {		WT_STAT_INCR(conn->stats, cache_evict_unmodified);		WT_ASSERT(session, single || page->ref->state == WT_REF_LOCKED);		if (WT_PAGE_IS_ROOT(page))			__rec_root_update(session);		else			__rec_page_clean_update(session, page);		/* Discard the page. */		__rec_discard_page(session, page, single);	} else {		WT_STAT_INCR(conn->stats, cache_evict_modified);		if (WT_PAGE_IS_ROOT(page))			__rec_root_update(session);		else			WT_ERR(__rec_page_dirty_update(session, page));		/* Discard the tree rooted in this page. */		__rec_discard_tree(session, page, single);	}	if (0) {err:		/*		 * If unable to evict this page, release exclusive reference(s)		 * we've acquired.		 */		__rec_excl_clear(session);	}	session->excl_next = 0;	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);}

/* * __wt_page_inmem -- *	Build in-memory page information. */int__wt_page_inmem(WT_SESSION_IMPL *session,    WT_REF *ref, const void *image, uint32_t flags, WT_PAGE **pagep){	WT_DECL_RET;	WT_PAGE *page;	const WT_PAGE_HEADER *dsk;	uint32_t alloc_entries;	size_t size;	*pagep = NULL;	dsk = image;	alloc_entries = 0;	/*	 * Figure out how many underlying objects the page references so we can	 * allocate them along with the page.	 */	switch (dsk->type) {	case WT_PAGE_COL_FIX:	case WT_PAGE_COL_INT:	case WT_PAGE_COL_VAR:		/*		 * Column-store leaf page entries map one-to-one to the number		 * of physical entries on the page (each physical entry is a		 * value item).		 *		 * Column-store internal page entries map one-to-one to the		 * number of physical entries on the page (each entry is a		 * location cookie).		 */		alloc_entries = dsk->u.entries;		break;	case WT_PAGE_ROW_INT:		/*		 * Row-store internal page entries map one-to-two to the number		 * of physical entries on the page (each entry is a key and		 * location cookie pair).		 */		alloc_entries = dsk->u.entries / 2;		break;	case WT_PAGE_ROW_LEAF:		/*		 * If the "no empty values" flag is set, row-store leaf page		 * entries map one-to-one to the number of physical entries		 * on the page (each physical entry is a key or value item).		 * If that flag is not set, there are more keys than values,		 * we have to walk the page to figure it out.		 */		if (F_ISSET(dsk, WT_PAGE_EMPTY_V_ALL))			alloc_entries = dsk->u.entries;		else if (F_ISSET(dsk, WT_PAGE_EMPTY_V_NONE))			alloc_entries = dsk->u.entries / 2;		else			WT_RET(__inmem_row_leaf_entries(			    session, dsk, &alloc_entries));		break;	WT_ILLEGAL_VALUE(session);	}	/* Allocate and initialize a new WT_PAGE. */	WT_RET(__wt_page_alloc(	    session, dsk->type, dsk->recno, alloc_entries, 1, &page));	page->dsk = dsk;	F_SET_ATOMIC(page, flags);	/*	 * Track the memory allocated to build this page so we can update the	 * cache statistics in a single call.	 */	size = LF_ISSET(WT_PAGE_DISK_ALLOC) ? dsk->mem_size : 0;	switch (page->type) {	case WT_PAGE_COL_FIX:		__inmem_col_fix(session, page);		break;	case WT_PAGE_COL_INT:		__inmem_col_int(session, page);		break;	case WT_PAGE_COL_VAR:		WT_ERR(__inmem_col_var(session, page, &size));		break;	case WT_PAGE_ROW_INT:		WT_ERR(__inmem_row_int(session, page, &size));		break;	case WT_PAGE_ROW_LEAF:		WT_ERR(__inmem_row_leaf(session, page));		break;	WT_ILLEGAL_VALUE_ERR(session);	}	/* Update the page's in-memory size and the cache statistics. */	__wt_cache_page_inmem_incr(session, page, size);	/* Link the new internal page to the parent. *///.........这里部分代码省略.........

int__wt_page_in_func(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags#ifdef HAVE_DIAGNOSTIC    , const char *file, int line#endif    ){	WT_DECL_RET;	WT_PAGE *page;	u_int sleep_cnt, wait_cnt;	int busy, force_attempts, oldgen;	for (force_attempts = oldgen = 0, wait_cnt = 0;;) {		switch (ref->state) {		case WT_REF_DISK:		case WT_REF_DELETED:			if (LF_ISSET(WT_READ_CACHE))				return (WT_NOTFOUND);			/*			 * The page isn't in memory, attempt to read it.			 * Make sure there is space in the cache.			 */			WT_RET(__wt_cache_full_check(session));			WT_RET(__wt_cache_read(session, ref));			oldgen = LF_ISSET(WT_READ_WONT_NEED) ||			    F_ISSET(session, WT_SESSION_NO_CACHE);			continue;		case WT_REF_READING:			if (LF_ISSET(WT_READ_CACHE))				return (WT_NOTFOUND);			if (LF_ISSET(WT_READ_NO_WAIT))				return (WT_NOTFOUND);			WT_STAT_FAST_CONN_INCR(session, page_read_blocked);			break;		case WT_REF_LOCKED:			if (LF_ISSET(WT_READ_NO_WAIT))				return (WT_NOTFOUND);			WT_STAT_FAST_CONN_INCR(session, page_locked_blocked);			break;		case WT_REF_SPLIT:			return (WT_RESTART);		case WT_REF_MEM:			/*			 * The page is in memory.			 *			 * Get a hazard pointer if one is required. We cannot			 * be evicting if no hazard pointer is required, we're			 * done.			 */			if (F_ISSET(S2BT(session), WT_BTREE_IN_MEMORY))				goto skip_evict;			/*			 * The expected reason we can't get a hazard pointer is			 * because the page is being evicted, yield, try again.			 */#ifdef HAVE_DIAGNOSTIC			WT_RET(			    __wt_hazard_set(session, ref, &busy, file, line));#else			WT_RET(__wt_hazard_set(session, ref, &busy));#endif			if (busy) {				WT_STAT_FAST_CONN_INCR(				    session, page_busy_blocked);				break;			}			/*			 * If eviction is configured for this file, check to see			 * if the page qualifies for forced eviction and update			 * the page's generation number. If eviction isn't being			 * done on this file, we're done.			 */			if (F_ISSET(S2BT(session), WT_BTREE_NO_EVICTION))				goto skip_evict;			/*			 * Forcibly evict pages that are too big.			 */			page = ref->page;			if (force_attempts < 10 &&			    __evict_force_check(session, page, flags)) {				++force_attempts;				ret = __wt_page_release_evict(session, ref);				/* If forced eviction fails, stall. */				if (ret == EBUSY) {					ret = 0;					wait_cnt += 1000;					WT_STAT_FAST_CONN_INCR(session,					    page_forcible_evict_blocked);					break;				} else					WT_RET(ret);				/*				 * The result of a successful forced eviction				 * is a page-state transition (potentially to				 * an in-memory page we can use, or a restart//.........这里部分代码省略.........

/* * __bt_search -- *	Search a btree for a key. * * Parameters: *	t:	tree to search *	key:	key to find *	exactp:	pointer to exact match flag * * Returns: *	The EPG for matching record, if any, or the EPG for the location *	of the key, if it were inserted into the tree, is entered into *	the bt_cur field of the tree.  A pointer to the field is returned. */EPG *__bt_search(BTREE *t, const DBT *key, int *exactp){	PAGE *h;	indx_t base, idx, lim;	pgno_t pg;	int cmp;	BT_CLR(t);	for (pg = P_ROOT;;) {		if ((h = mpool_get(t->bt_mp, pg, 0)) == NULL)			return (NULL);		/* Do a binary search on the current page. */		t->bt_cur.page = h;		for (base = 0, lim = NEXTINDEX(h); lim; lim >>= 1) {			t->bt_cur.index = idx = base + (lim >> 1);			if ((cmp = __bt_cmp(t, key, &t->bt_cur)) == 0) {				if (h->flags & P_BLEAF) {					*exactp = 1;					return (&t->bt_cur);				}				goto next;			}			if (cmp > 0) {				base = idx + 1;				--lim;			}		}		/*		 * If it's a leaf page, we're almost done.  If no duplicates		 * are allowed, or we have an exact match, we're done.  Else,		 * it's possible that there were matching keys on this page,		 * which later deleted, and we're on a page with no matches		 * while there are matches on other pages.  If at the start or		 * end of a page, check the adjacent page.		 */		if (h->flags & P_BLEAF) {			if (!F_ISSET(t, B_NODUPS)) {				if (base == 0 &&				    h->prevpg != P_INVALID &&				    __bt_sprev(t, h, key, exactp))					return (&t->bt_cur);				if (base == NEXTINDEX(h) &&				    h->nextpg != P_INVALID &&				    __bt_snext(t, h, key, exactp))					return (&t->bt_cur);			}			*exactp = 0;			t->bt_cur.index = base;			return (&t->bt_cur);		}		/*		 * No match found.  Base is the smallest index greater than		 * key and may be zero or a last + 1 index.  If it's non-zero,		 * decrement by one, and record the internal page which should		 * be a parent page for the key.  If a split later occurs, the		 * inserted page will be to the right of the saved page.		 */		idx = base ? base - 1 : base;next:		BT_PUSH(t, h->pgno, idx);		pg = GETBINTERNAL(h, idx)->pgno;		mpool_put(t->bt_mp, h, 0);	}}

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

/* * cl_read -- *	Read characters from the input. */static input_tcl_read(SCR *sp, u_int32_t flags, char *bp, size_t blen, int *nrp, struct timeval *tp){	struct termios term1, term2;	CL_PRIVATE *clp;	GS *gp;	fd_set rdfd;	input_t rval;	int maxfd, nr, term_reset;	gp = sp->gp;	clp = CLP(sp);	term_reset = 0;	/*	 * 1: A read from a file or a pipe.  In this case, the reads	 *    never timeout regardless.  This means that we can hang	 *    when trying to complete a map, but we're going to hang	 *    on the next read anyway.	 */	if (!F_ISSET(clp, CL_STDIN_TTY)) {		nr = extpread(STDIN_FILENO, bp, blen, O_FBLOCKING, -1);		switch (nr) {		case 0:			return (INP_EOF);		case -1:			goto err;		default:			*nrp = nr;			return (INP_OK);		}		/* NOTREACHED */	}	/*	 * 2: A read with an associated timeout, e.g., trying to complete	 *    a map sequence.  If input exists, we fall into #3.	 */	if (tp != NULL) {		FD_ZERO(&rdfd);		FD_SET(STDIN_FILENO, &rdfd);		switch (select(STDIN_FILENO + 1, &rdfd, NULL, NULL, tp)) {		case 0:			return (INP_TIMEOUT);		case -1:			goto err;		default:			break;		}	}		/*	 * The user can enter a key in the editor to quote a character.  If we	 * get here and the next key is supposed to be quoted, do what we can.	 * Reset the tty so that the user can enter a ^C, ^Q, ^S.  There's an	 * obvious race here, when the key has already been entered, but there's	 * nothing that we can do to fix that problem.	 *	 * The editor can ask for the next literal character even thought it's	 * generally running in line-at-a-time mode.  Do what we can.	 */	if (LF_ISSET(EC_QUOTED | EC_RAW) && !tcgetattr(STDIN_FILENO, &term1)) {		term_reset = 1;		if (LF_ISSET(EC_QUOTED)) {			term2 = term1;			term2.c_lflag &= ~ISIG;			term2.c_iflag &= ~(IXON | IXOFF);			(void)tcsetattr(STDIN_FILENO,			    TCSASOFT | TCSADRAIN, &term2);		} else			(void)tcsetattr(STDIN_FILENO,			    TCSASOFT | TCSADRAIN, &clp->vi_enter);	}	/*	 * 3: Wait for input.	 *	 * Select on the command input and scripting window file descriptors.	 * It's ugly that we wait on scripting file descriptors here, but it's	 * the only way to keep from locking out scripting windows.	 */	if (F_ISSET(gp, G_SCRWIN)) {loop:		FD_ZERO(&rdfd);		FD_SET(STDIN_FILENO, &rdfd);		maxfd = STDIN_FILENO;		if (F_ISSET(sp, SC_SCRIPT)) {			FD_SET(sp->script->sh_master, &rdfd);			if (sp->script->sh_master > maxfd)				maxfd = sp->script->sh_master;		}		switch (select(maxfd + 1, &rdfd, NULL, NULL, NULL)) {		case 0:			abort();		case -1:			goto err;		default://.........这里部分代码省略.........

/* * __clsm_enter -- *	Start an operation on an LSM cursor, update if the tree has changed. */static inline int__clsm_enter(WT_CURSOR_LSM *clsm, bool reset, bool update){	WT_DECL_RET;	WT_LSM_TREE *lsm_tree;	WT_SESSION_IMPL *session;	WT_TXN *txn;	uint64_t *switch_txnp;	uint64_t snap_min;	lsm_tree = clsm->lsm_tree;	session = (WT_SESSION_IMPL *)clsm->iface.session;	txn = &session->txn;	/* Merge cursors never update. */	if (F_ISSET(clsm, WT_CLSM_MERGE))		return (0);	if (reset) {		WT_ASSERT(session, !F_ISSET(&clsm->iface,		   WT_CURSTD_KEY_INT | WT_CURSTD_VALUE_INT));		WT_RET(__clsm_reset_cursors(clsm, NULL));	}	for (;;) {		/*		 * If the cursor looks up-to-date, check if the cache is full.		 * In case this call blocks, the check will be repeated before		 * proceeding.		 */		if (clsm->dsk_gen != lsm_tree->dsk_gen &&		    lsm_tree->nchunks != 0)			goto open;		if (clsm->dsk_gen != lsm_tree->dsk_gen &&		    lsm_tree->nchunks != 0)			goto open;		/* Update the maximum transaction ID in the primary chunk. */		if (update) {			/*			 * Ensure that there is a transaction snapshot active.			 */			WT_RET(__wt_txn_autocommit_check(session));			WT_RET(__wt_txn_id_check(session));			WT_RET(__clsm_enter_update(clsm));			if (clsm->dsk_gen != clsm->lsm_tree->dsk_gen)				goto open;			if (txn->isolation == WT_ISO_SNAPSHOT)				__wt_txn_cursor_op(session);			/*			 * Figure out how many updates are required for			 * snapshot isolation.			 *			 * This is not a normal visibility check on the maximum			 * transaction ID in each chunk: any transaction ID			 * that overlaps with our snapshot is a potential			 * conflict.			 */			clsm->nupdates = 1;			if (txn->isolation == WT_ISO_SNAPSHOT &&			    F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT)) {				WT_ASSERT(session,				    F_ISSET(txn, WT_TXN_HAS_SNAPSHOT));				snap_min = txn->snap_min;				for (switch_txnp =				    &clsm->switch_txn[clsm->nchunks - 2];				    clsm->nupdates < clsm->nchunks;				    clsm->nupdates++, switch_txnp--) {					if (WT_TXNID_LT(*switch_txnp, snap_min))						break;					WT_ASSERT(session,					    !__wt_txn_visible_all(					    session, *switch_txnp));				}			}		}		/*		 * Stop when we are up-to-date, as long as this is:		 *   - a snapshot isolation update and the cursor is set up for		 *     that;		 *   - an update operation with a primary chunk, or		 *   - a read operation and the cursor is open for reading.		 */		if ((!update ||		    txn->isolation != WT_ISO_SNAPSHOT ||		    F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT)) &&		    ((update && clsm->primary_chunk != NULL) ||		    (!update && F_ISSET(clsm, WT_CLSM_OPEN_READ))))			break;open:		WT_WITH_SCHEMA_LOCK(session,//.........这里部分代码省略.........

/* * __clsm_open_cursors -- *	Open cursors for the current set of files. */static int__clsm_open_cursors(    WT_CURSOR_LSM *clsm, bool update, u_int start_chunk, uint32_t start_id){	WT_BTREE *btree;	WT_CURSOR *c, **cp, *primary;	WT_DECL_RET;	WT_LSM_CHUNK *chunk;	WT_LSM_TREE *lsm_tree;	WT_SESSION_IMPL *session;	WT_TXN *txn;	const char *checkpoint, *ckpt_cfg[3];	uint64_t saved_gen;	u_int i, nchunks, ngood, nupdates;	u_int close_range_end, close_range_start;	bool locked;	c = &clsm->iface;	session = (WT_SESSION_IMPL *)c->session;	txn = &session->txn;	chunk = NULL;	locked = false;	lsm_tree = clsm->lsm_tree;	/*	 * Ensure that any snapshot update has cursors on the right set of	 * chunks to guarantee visibility is correct.	 */	if (update && txn->isolation == WT_ISO_SNAPSHOT)		F_SET(clsm, WT_CLSM_OPEN_SNAPSHOT);	/*	 * Query operations need a full set of cursors. Overwrite cursors	 * do queries in service of updates.	 */	if (!update || !F_ISSET(c, WT_CURSTD_OVERWRITE))		F_SET(clsm, WT_CLSM_OPEN_READ);	if (lsm_tree->nchunks == 0)		return (0);	ckpt_cfg[0] = WT_CONFIG_BASE(session, WT_SESSION_open_cursor);	ckpt_cfg[1] = "checkpoint=" WT_CHECKPOINT ",raw";	ckpt_cfg[2] = NULL;	/*	 * If the key is pointing to memory that is pinned by a chunk	 * cursor, take a copy before closing cursors.	 */	if (F_ISSET(c, WT_CURSTD_KEY_INT))		WT_CURSOR_NEEDKEY(c);	F_CLR(clsm, WT_CLSM_ITERATE_NEXT | WT_CLSM_ITERATE_PREV);	WT_RET(__wt_lsm_tree_readlock(session, lsm_tree));	locked = true;	/* Merge cursors have already figured out how many chunks they need. */retry:	if (F_ISSET(clsm, WT_CLSM_MERGE)) {		nchunks = clsm->nchunks;		ngood = 0;		/*		 * We may have raced with another merge completing.  Check that		 * we're starting at the right offset in the chunk array.		 */		if (start_chunk >= lsm_tree->nchunks ||		    lsm_tree->chunk[start_chunk]->id != start_id) {			for (start_chunk = 0;			    start_chunk < lsm_tree->nchunks;			    start_chunk++) {				chunk = lsm_tree->chunk[start_chunk];				if (chunk->id == start_id)					break;			}			/* We have to find the start chunk: merge locked it. */			WT_ASSERT(session, start_chunk < lsm_tree->nchunks);		}		WT_ASSERT(session, start_chunk + nchunks <= lsm_tree->nchunks);	} else {		nchunks = lsm_tree->nchunks;		/*		 * If we are only opening the cursor for updates, only open the		 * primary chunk, plus any other chunks that might be required		 * to detect snapshot isolation conflicts.		 */		if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT))			WT_ERR(__wt_realloc_def(session,			    &clsm->txnid_alloc, nchunks,			    &clsm->switch_txn));		if (F_ISSET(clsm, WT_CLSM_OPEN_READ))			ngood = nupdates = 0;		else if (F_ISSET(clsm, WT_CLSM_OPEN_SNAPSHOT)) {			/*//.........这里部分代码省略.........

/* * __wt_txn_commit -- *	Commit the current transaction. */int__wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[]){	WT_CONFIG_ITEM cval;	WT_CONNECTION_IMPL *conn;	WT_DECL_RET;	WT_TXN *txn;	WT_TXN_GLOBAL *txn_global;	WT_TXN_OP *op;	u_int i;	bool locked, readonly;#ifdef HAVE_TIMESTAMPS	wt_timestamp_t prev_commit_timestamp, ts;	bool update_timestamp;#endif	txn = &session->txn;	conn = S2C(session);	txn_global = &conn->txn_global;	locked = false;	WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING));	WT_ASSERT(session, !F_ISSET(txn, WT_TXN_ERROR) ||	    txn->mod_count == 0);	readonly = txn->mod_count == 0;	/*	 * Look for a commit timestamp.	 */	WT_ERR(	    __wt_config_gets_def(session, cfg, "commit_timestamp", 0, &cval));	if (cval.len != 0) {#ifdef HAVE_TIMESTAMPS		WT_ERR(__wt_txn_parse_timestamp(session, "commit", &ts, &cval));		WT_ERR(__wt_timestamp_validate(session,		    "commit", &ts, &cval, true, true, true));		__wt_timestamp_set(&txn->commit_timestamp, &ts);		__wt_txn_set_commit_timestamp(session);#else		WT_ERR_MSG(session, EINVAL, "commit_timestamp requires a "		    "version of WiredTiger built with timestamp support");#endif	}#ifdef HAVE_TIMESTAMPS	/*	 * Debugging checks on timestamps, if user requested them.	 */	if (F_ISSET(txn, WT_TXN_TS_COMMIT_ALWAYS) &&	    !F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&	    txn->mod_count != 0)		WT_ERR_MSG(session, EINVAL, "commit_timestamp required and "		    "none set on this transaction");	if (F_ISSET(txn, WT_TXN_TS_COMMIT_NEVER) &&	    F_ISSET(txn, WT_TXN_HAS_TS_COMMIT) &&	    txn->mod_count != 0)		WT_ERR_MSG(session, EINVAL, "no commit_timestamp required and "		    "timestamp set on this transaction");#endif	/*	 * The default sync setting is inherited from the connection, but can	 * be overridden by an explicit "sync" setting for this transaction.	 */	WT_ERR(__wt_config_gets_def(session, cfg, "sync", 0, &cval));	/*	 * If the user chose the default setting, check whether sync is enabled	 * for this transaction (either inherited or via begin_transaction).	 * If sync is disabled, clear the field to avoid the log write being	 * flushed.	 *	 * Otherwise check for specific settings.  We don't need to check for	 * "on" because that is the default inherited from the connection.  If	 * the user set anything in begin_transaction, we only override with an	 * explicit setting.	 */	if (cval.len == 0) {		if (!FLD_ISSET(txn->txn_logsync, WT_LOG_SYNC_ENABLED) &&		    !F_ISSET(txn, WT_TXN_SYNC_SET))			txn->txn_logsync = 0;	} else {		/*		 * If the caller already set sync on begin_transaction then		 * they should not be using sync on commit_transaction.		 * Flag that as an error.		 */		if (F_ISSET(txn, WT_TXN_SYNC_SET))			WT_ERR_MSG(session, EINVAL,			    "Sync already set during begin_transaction");		if (WT_STRING_MATCH("background", cval.str, cval.len))			txn->txn_logsync = WT_LOG_BACKGROUND;		else if (WT_STRING_MATCH("off", cval.str, cval.len))			txn->txn_logsync = 0;		/*		 * We don't need to check for "on" here because that is the		 * default to inherit from the connection setting.//.........这里部分代码省略.........

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

/* * cl_attr -- *	Toggle a screen attribute on/off. * * PUBLIC: int cl_attr __P((SCR *, scr_attr_t, int)); */intcl_attr(SCR *sp, scr_attr_t attribute, int on){	CL_PRIVATE *clp;	WINDOW *win;	clp = CLP(sp);	win = CLSP(sp) ? CLSP(sp) : stdscr;	switch (attribute) {	case SA_ALTERNATE:	/*	 * !!!	 * There's a major layering violation here.  The problem is that the	 * X11 xterm screen has what's known as an "alternate" screen.  Some	 * xterm termcap/terminfo entries include sequences to switch to/from	 * that alternate screen as part of the ti/te (smcup/rmcup) strings.	 * Vi runs in the alternate screen, so that you are returned to the	 * same screen contents on exit from vi that you had when you entered	 * vi.  Further, when you run :shell, or :!date or similar ex commands,	 * you also see the original screen contents.  This wasn't deliberate	 * on vi's part, it's just that it historically sent terminal init/end	 * sequences at those times, and the addition of the alternate screen	 * sequences to the strings changed the behavior of vi.  The problem	 * caused by this is that we don't want to switch back to the alternate	 * screen while getting a new command from the user, when the user is	 * continuing to enter ex commands, e.g.:	 *	 *	:!date				<<< switch to original screen	 *	[Hit return to continue]	<<< prompt user to continue	 *	:command			<<< get command from user	 *	 * Note that the :command input is a true vi input mode, e.g., input	 * maps and abbreviations are being done.  So, we need to be able to	 * switch back into the vi screen mode, without flashing the screen. 	 *	 * To make matters worse, the curses initscr() and endwin() calls will	 * do this automatically -- so, this attribute isn't as controlled by	 * the higher level screen as closely as one might like.	 */	if (on) {		if (clp->ti_te != TI_SENT) {			clp->ti_te = TI_SENT;			if (clp->smcup == NULL)				(void)cl_getcap(sp, "smcup", &clp->smcup);			if (clp->smcup != NULL)				(void)tputs(clp->smcup, 1, cl_putchar);		}	} else		if (clp->ti_te != TE_SENT) {			clp->ti_te = TE_SENT;			if (clp->rmcup == NULL)				(void)cl_getcap(sp, "rmcup", &clp->rmcup);			if (clp->rmcup != NULL)				(void)tputs(clp->rmcup, 1, cl_putchar);			(void)fflush(stdout);		}		(void)fflush(stdout);		break;	case SA_INVERSE:		if (F_ISSET(sp, SC_EX | SC_SCR_EXWROTE)) {			if (clp->smso == NULL)				return (1);			if (on)				(void)tputs(clp->smso, 1, cl_putchar);			else				(void)tputs(clp->rmso, 1, cl_putchar);			(void)fflush(stdout);		} else {			if (on)				(void)wstandout(win);			else				(void)wstandend(win);		}		break;	default:		abort();	}	return (0);}

/* * __wt_btcur_search_near -- *	Search for a record in the tree. */int__wt_btcur_search_near(WT_CURSOR_BTREE *cbt, int *exactp){	WT_BTREE *btree;	WT_CURSOR *cursor;	WT_DECL_RET;	WT_SESSION_IMPL *session;	WT_UPDATE *upd;	int exact;	bool valid;	btree = cbt->btree;	cursor = &cbt->iface;	session = (WT_SESSION_IMPL *)cursor->session;	upd = NULL;					/* -Wuninitialized */	exact = 0;	WT_STAT_CONN_INCR(session, cursor_search_near);	WT_STAT_DATA_INCR(session, cursor_search_near);	/*	 * If we have a row-store page pinned, search it; if we don't have a	 * page pinned, or the search of the pinned page doesn't find an exact	 * match, search from the root. Unlike WT_CURSOR.search, ignore pinned	 * pages in the case of column-store, search-near isn't an interesting	 * enough case for column-store to add the complexity needed to avoid	 * the tree search.	 *	 * Set the "insert" flag for the btree row-store search; we may intend	 * to position the cursor at the end of the tree, rather than match an	 * existing record.	 */	valid = false;	if (btree->type == BTREE_ROW &&	    F_ISSET(cbt, WT_CBT_ACTIVE) &&	    cbt->ref->page->read_gen != WT_READGEN_OLDEST) {		WT_ERR(__wt_txn_cursor_op(session));		WT_ERR(__cursor_row_search(session, cbt, cbt->ref, true));		/*		 * Search-near is trickier than search when searching an already		 * pinned page. If search returns the first or last page slots,		 * discard the results and search the full tree as the neighbor		 * pages might offer better matches. This test is simplistic as		 * we're ignoring append lists (there may be no page slots or we		 * might be legitimately positioned after the last page slot).		 * Ignore those cases, it makes things too complicated.		 */		if (cbt->slot != 0 &&		    cbt->slot != cbt->ref->page->pg_row_entries - 1)			valid = __cursor_valid(cbt, &upd);	}	if (!valid) {		WT_ERR(__cursor_func_init(cbt, true));		WT_ERR(btree->type == BTREE_ROW ?		    __cursor_row_search(session, cbt, NULL, true) :		    __cursor_col_search(session, cbt, NULL));		valid = __cursor_valid(cbt, &upd);	}	/*	 * If we find a valid key, return it.	 *	 * Else, creating a record past the end of the tree in a fixed-length	 * column-store implicitly fills the gap with empty records.  In this	 * case, we instantiate the empty record, it's an exact match.	 *	 * Else, move to the next key in the tree (bias for prefix searches).	 * Cursor next skips invalid rows, so we don't have to test for them	 * again.	 *	 * Else, redo the search and move to the previous key in the tree.	 * Cursor previous skips invalid rows, so we don't have to test for	 * them again.	 *	 * If that fails, quit, there's no record to return.	 */	if (valid) {		exact = cbt->compare;		ret = __wt_kv_return(session, cbt, upd);	} else if (__cursor_fix_implicit(btree, cbt)) {		cbt->recno = cursor->recno;		cbt->v = 0;		cursor->value.data = &cbt->v;		cursor->value.size = 1;		exact = 0;	} else if ((ret = __wt_btcur_next(cbt, false)) != WT_NOTFOUND)		exact = 1;	else {		WT_ERR(__cursor_func_init(cbt, true));		WT_ERR(btree->type == BTREE_ROW ?		    __cursor_row_search(session, cbt, NULL, true) :		    __cursor_col_search(session, cbt, NULL));		if (__cursor_valid(cbt, &upd)) {			exact = cbt->compare;//.........这里部分代码省略.........