Import wiredtiger: 298609418d45b9821c06d588d28b710b7b36c195 from branch mongodb-3.6

ref: dc91a569c8..298609418d
for: 3.6.14

WT-4352       Resolve birthmarks during eviction in more cases
WT-4421       Add a way to calculate modify operations
WT-4693       WT_CONNECTION::reconfigure should not require quiescence when downgraded
WT-4706       Add a statistic to track the lookaside table size
WT-4750       Sweep can remove active lookaside records when files are closed and re-opened
WT-4759       Save a copy when an old overflow value is discarded
WT-4768       Inconsistent data with lookaside eviction followed by sweep
WT-4769       Don't discard active history for empty pages
WT-4776       Modify operations should be equivalent to updates
WT-4794       Mark lookaside history resolved in all paths
WT-4803       Implement file_max configuration for Cache Overflow mechanism
WT-4823       Add check for uninitialised lookaside resources
WT-4848       Fix perf regression when calculating differences

42 files changed, 1569 insertions, 507 deletions

diff --git a/src/third_party/wiredtiger/build_win/wiredtiger.def b/src/third_party/wiredtiger/build_win/wiredtiger.def
index 79fa84a11e0..71c52bd81af 100644
--- a/src/third_party/wiredtiger/build_win/wiredtiger.def
+++ b/src/third_party/wiredtiger/build_win/wiredtiger.def
@@ -1,5 +1,6 @@
 LIBRARY WIREDTIGER
 EXPORTS
+    wiredtiger_calc_modify
     wiredtiger_config_parser_open
     wiredtiger_config_validate
     wiredtiger_crc32c_func
diff --git a/src/third_party/wiredtiger/dist/api_data.py b/src/third_party/wiredtiger/dist/api_data.py
index 08a322a66e7..9db4799026d 100644
--- a/src/third_party/wiredtiger/dist/api_data.py
+++ b/src/third_party/wiredtiger/dist/api_data.py
@@ -430,6 +430,18 @@ connection_runtime_config = [
         for space to be available in cache before giving up. Default will
         wait forever''',
         min=0),
+    Config('cache_overflow', '', r'''
+        cache overflow configuration options''',
+        type='category', subconfig=[
+        Config('file_max', '0', r'''
+            The maximum number of bytes that WiredTiger is allowed to use for
+            its cache overflow mechanism. If the cache overflow file exceeds
+            this size, a panic will be triggered. The default value means that
+            the cache overflow file is unbounded and may use as much space as
+            the filesystem will accommodate. The minimum non-zero setting is
+            100MB.''',    # !!! Must match WT_LAS_FILE_MIN
+            min='0')
+        ]),
     Config('cache_overhead', '8', r'''
         assume the heap allocator overhead is the specified percentage, and
         adjust the cache usage by that amount (for example, if there is 10GB
diff --git a/src/third_party/wiredtiger/dist/filelist b/src/third_party/wiredtiger/dist/filelist
index 79590313b89..1bbeeb3c7a3 100644
--- a/src/third_party/wiredtiger/dist/filelist
+++ b/src/third_party/wiredtiger/dist/filelist
@@ -62,6 +62,7 @@ src/config/config_collapse.c
 src/config/config_def.c
 src/config/config_ext.c
 src/config/config_upgrade.c
+src/conn/api_calc_modify.c
 src/conn/api_strerror.c
 src/conn/api_version.c
 src/conn/conn_api.c
diff --git a/src/third_party/wiredtiger/dist/s_export.list b/src/third_party/wiredtiger/dist/s_export.list
index e49fa113d96..e85bf62517d 100644
--- a/src/third_party/wiredtiger/dist/s_export.list
+++ b/src/third_party/wiredtiger/dist/s_export.list
@@ -1,4 +1,5 @@
 # List of OK external symbols.
+wiredtiger_calc_modify
 wiredtiger_config_parser_open
 wiredtiger_config_validate
 wiredtiger_crc32c_func
diff --git a/src/third_party/wiredtiger/dist/s_funcs.list b/src/third_party/wiredtiger/dist/s_funcs.list
index 95c568a19ff..bcedc19a459 100644
--- a/src/third_party/wiredtiger/dist/s_funcs.list
+++ b/src/third_party/wiredtiger/dist/s_funcs.list
@@ -33,6 +33,7 @@ __wt_stat_join_aggregate
 __wt_stat_join_clear_all
 __wt_stream_set_no_buffer
 __wt_try_readlock
+wiredtiger_calc_modify
 wiredtiger_config_parser_open
 wiredtiger_config_validate
 wiredtiger_pack_int
diff --git a/src/third_party/wiredtiger/dist/s_string.ok b/src/third_party/wiredtiger/dist/s_string.ok
index ed5f27cdf11..8b3110e87c8 100644
--- a/src/third_party/wiredtiger/dist/s_string.ok
+++ b/src/third_party/wiredtiger/dist/s_string.ok
@@ -527,6 +527,7 @@ bzDecompressInit
 bzalloc
 bzfree
 bzip
+calc
 call's
 calloc
 cas
@@ -951,6 +952,7 @@ marshalled
 maxCLevel
 maxcpu
 maxdbs
+maxdiff
 mbll
 mbss
 mem
@@ -998,9 +1000,11 @@ needkey
 needvalue
 negint
 nentries
+nentriesp
 newbar
 newfile
 newuri
+newv
 nextprev
 nfilename
 nhex
@@ -1029,6 +1033,7 @@ numSymbols
 numbare
 offpage
 ok
+oldv
 ondisk
 onint
 online
@@ -1216,6 +1221,7 @@ subgets
 subinit
 sublicense
 subone
+suboptimal
 subtest
 subtree
 sunique
diff --git a/src/third_party/wiredtiger/dist/s_void b/src/third_party/wiredtiger/dist/s_void
index 8798893597d..aa20270ad27 100755
--- a/src/third_party/wiredtiger/dist/s_void
+++ b/src/third_party/wiredtiger/dist/s_void
@@ -118,6 +118,7 @@ func_ok()
 	    -e '/int snappy_pre_size$/d' \
 	    -e '/int snappy_terminate$/d' \
 	    -e '/int subtest_error_handler$/d' \
+	    -e '/int test_las_workload$/d' \
 	    -e '/int uri2name$/d' \
 	    -e '/int usage$/d' \
 	    -e '/int util_err$/d' \
diff --git a/src/third_party/wiredtiger/dist/stat_data.py b/src/third_party/wiredtiger/dist/stat_data.py
index 2bf788085b1..cad3735a8d1 100644
--- a/src/third_party/wiredtiger/dist/stat_data.py
+++ b/src/third_party/wiredtiger/dist/stat_data.py
@@ -264,6 +264,8 @@ connection_stats = [
     CacheStat('cache_lookaside_cursor_wait_internal', 'cache overflow cursor internal thread wait time (usecs)'),
     CacheStat('cache_lookaside_entries', 'cache overflow table entries', 'no_clear,no_scale'),
     CacheStat('cache_lookaside_insert', 'cache overflow table insert calls'),
+    CacheStat('cache_lookaside_ondisk', 'cache overflow table on-disk size', 'no_clear,no_scale,size'),
+    CacheStat('cache_lookaside_ondisk_max', 'cache overflow table max on-disk size', 'no_clear,no_scale,size'),
     CacheStat('cache_lookaside_remove', 'cache overflow table remove calls'),
     CacheStat('cache_lookaside_score', 'cache overflow score', 'no_clear,no_scale'),
     CacheStat('cache_overhead', 'percentage overhead', 'no_clear,no_scale'),
diff --git a/src/third_party/wiredtiger/examples/c/ex_all.c b/src/third_party/wiredtiger/examples/c/ex_all.c
index 190c2c421d3..cc9df3f03c3 100644
--- a/src/third_party/wiredtiger/examples/c/ex_all.c
+++ b/src/third_party/wiredtiger/examples/c/ex_all.c
@@ -1353,6 +1353,26 @@ main(int argc, char *argv[])
 	}
 
 	{
+	/*! [Calculate a modify operation] */
+	WT_MODIFY mod[3];
+	int nmod = 3;
+	WT_ITEM prev, newv;
+	prev.data = "the quick brown fox jumped over the lazy dog. " \
+		"THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG. " \
+		"the quick brown fox jumped over the lazy dog. " \
+		"THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG. ";
+	prev.size = strlen(prev.data);
+	newv.data = "A quick brown fox jumped over the lazy dog. " \
+		"THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG. " \
+		"then a quick brown fox jumped over the lazy dog. " \
+		"THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG. " \
+		"then what?";
+	newv.size = strlen(newv.data);
+	error_check(wiredtiger_calc_modify(NULL, &prev, &newv, 20, mod, &nmod));
+	/*! [Calculate a modify operation] */
+	}
+
+	{
 	const char *buffer = "some string";
 	size_t len = strlen(buffer);
 	/*! [Checksum a buffer] */
diff --git a/src/third_party/wiredtiger/import.data b/src/third_party/wiredtiger/import.data
index 0aaf4175e25..d0379dd479e 100644
--- a/src/third_party/wiredtiger/import.data
+++ b/src/third_party/wiredtiger/import.data
@@ -1,5 +1,5 @@
 {
-    "commit": "dc91a569c824b133fde67be22f0e5a20dbb9db74", 
+    "commit": "298609418d45b9821c06d588d28b710b7b36c195", 
     "github": "wiredtiger/wiredtiger.git", 
     "vendor": "wiredtiger", 
     "branch": "mongodb-3.6"
diff --git a/src/third_party/wiredtiger/lang/java/wiredtiger.i b/src/third_party/wiredtiger/lang/java/wiredtiger.i
index dfac0e9ec8d..5ef1658a322 100644
--- a/src/third_party/wiredtiger/lang/java/wiredtiger.i
+++ b/src/third_party/wiredtiger/lang/java/wiredtiger.i
@@ -357,6 +357,7 @@ WT_CLASS(struct __wt_async_op, WT_ASYNC_OP, op)
 %ignore __wt_modify::position;
 %ignore __wt_modify::size;
 %ignore __wt_cursor::modify;
+%ignore wiredtiger_calc_modify;
 
 %ignore __wt_cursor::compare(WT_CURSOR *, WT_CURSOR *, int *);
 %rename (compare_wrap) __wt_cursor::compare;
diff --git a/src/third_party/wiredtiger/lang/python/wiredtiger.i b/src/third_party/wiredtiger/lang/python/wiredtiger.i
index 0c95be87c1b..d3eb79cfd63 100644
--- a/src/third_party/wiredtiger/lang/python/wiredtiger.i
+++ b/src/third_party/wiredtiger/lang/python/wiredtiger.i
@@ -151,6 +151,41 @@ from packing import pack, unpack
 	}
 }
 
+%typemap(in,numinputs=1) (WT_MODIFY *entries, int *nentriesp) (WT_MODIFY *mod, int nentries) {
+	nentries = (int) PyLong_AsLong($input);
+	if (__wt_calloc_def(NULL, (size_t)nentries, &mod) != 0)
+		SWIG_exception_fail(SWIG_MemoryError, "WT calloc failed");
+	$1 = mod;
+	$2 = &nentries;
+}
+
+%typemap(argout) (WT_MODIFY *entries, int *nentriesp) {
+	int i;
+	$result = PyList_New(*$2);
+	for (i = 0; i < *$2; i++) {
+		PyObject *o = SWIG_NewPointerObj(Py_None, SWIGTYPE_p___wt_modify, 0);
+		PyObject_SetAttrString(o, "data", PyString_FromStringAndSize(
+		    $1[i].data.data, $1[i].data.size));
+		PyObject_SetAttrString(o, "offset",
+		    PyInt_FromLong($1[i].offset));
+		PyObject_SetAttrString(o, "size",
+		    PyInt_FromLong($1[i].size));
+		PyList_SetItem($result, i, o);
+	}
+}
+
+%typemap(in) const WT_ITEM * (WT_ITEM val, long sz) {
+	if (PyString_AsStringAndSize($input, &val.data, &sz) < 0)
+		SWIG_exception_fail(SWIG_AttributeError,
+		    "bad string value for WT_ITEM");
+	val.size = (size_t)sz;
+	$1 = &val;
+}
+
+%typemap(freearg) (WT_MODIFY *entries, int *nentriesp) {
+	__wt_free(NULL, $1);
+}
+
 %typemap(in) WT_MODIFY * (int len, WT_MODIFY *modarray, int i) {
 	len = PyList_Size($input);
 	/*
@@ -209,7 +244,7 @@ from packing import pack, unpack
 }
 
 %typemap(freearg) WT_MODIFY * {
-	/* The WT_MODIFY arg is in position 2.  Is there a better way? */
+	/* The WT_MODIFY arg is in position 2.	Is there a better way? */
 	WT_MODIFY *modarray = modarray2;
 	size_t i, len;
 
@@ -981,6 +1016,9 @@ typedef int int_void;
 		self.data = data
 		self.offset = offset
 		self.size = size
+
+	def __repr__(self):
+		return 'Modify(\'%s\', %d, %d)' % (self.data, self.offset, self.size)
 %}
 };
 
@@ -1013,6 +1051,7 @@ int timestamp_build() {
 	return WT_TIMESTAMP_SIZE > 0;
 }
 %}
+
 int diagnostic_build();
 int timestamp_build();
 
diff --git a/src/third_party/wiredtiger/src/btree/bt_cursor.c b/src/third_party/wiredtiger/src/btree/bt_cursor.c
index 199c57972d7..8f4f7982e3d 100644
--- a/src/third_party/wiredtiger/src/btree/bt_cursor.c
+++ b/src/third_party/wiredtiger/src/btree/bt_cursor.c
@@ -1393,12 +1393,13 @@ __cursor_chain_exceeded(WT_CURSOR_BTREE *cbt)
 	    upd != NULL && upd->type == WT_UPDATE_MODIFY;
 	    ++i, upd = upd->next) {
 		upd_size += WT_UPDATE_MEMSIZE(upd);
-		if (upd_size >= WT_MODIFY_MEM_FACTOR * cursor->value.size)
+		if (i >= WT_MAX_MODIFY_UPDATE &&
+		    upd_size * WT_MODIFY_MEM_FRACTION >= cursor->value.size)
 			return (true);
 	}
-	if (upd != NULL && upd->type == WT_UPDATE_STANDARD &&
-	    __wt_txn_upd_visible_all(session, upd) &&
-	    i >= WT_MAX_MODIFY_UPDATE)
+	if (i >= WT_MAX_MODIFY_UPDATE && upd != NULL &&
+	    upd->type == WT_UPDATE_STANDARD &&
+	    __wt_txn_upd_visible_all(session, upd))
 		return (true);
 	return (false);
 }
diff --git a/src/third_party/wiredtiger/src/btree/bt_delete.c b/src/third_party/wiredtiger/src/btree/bt_delete.c
index 6f2b28d296a..8e9d937991a 100644
--- a/src/third_party/wiredtiger/src/btree/bt_delete.c
+++ b/src/third_party/wiredtiger/src/btree/bt_delete.c
@@ -279,13 +279,14 @@ __wt_delete_page_skip(WT_SESSION_IMPL *session, WT_REF *ref, bool visible_all)
 	 * the page could switch to an in-memory state at any time.  Lock down
 	 * the structure, just to be safe.
 	 */
-	if (ref->page_del == NULL)
+	if (ref->page_del == NULL && ref->page_las == NULL)
 		return (true);
 
 	if (!__wt_atomic_casv32(&ref->state, WT_REF_DELETED, WT_REF_LOCKED))
 		return (false);
 
-	skip = !__wt_page_del_active(session, ref, visible_all);
+	skip = !__wt_page_del_active(session, ref, visible_all) &&
+	    !__wt_page_las_active(session, ref);
 
 	/*
 	 * The page_del structure can be freed as soon as the delete is stable:
diff --git a/src/third_party/wiredtiger/src/btree/bt_handle.c b/src/third_party/wiredtiger/src/btree/bt_handle.c
index 5d9609c3a52..610dd971e34 100644
--- a/src/third_party/wiredtiger/src/btree/bt_handle.c
+++ b/src/third_party/wiredtiger/src/btree/bt_handle.c
@@ -115,6 +115,12 @@ __wt_btree_open(WT_SESSION_IMPL *session, const char *op_cfg[])
 	/* Initialize and configure the WT_BTREE structure. */
 	WT_ERR(__btree_conf(session, &ckpt));
 
+	/*
+	 * We could be a re-open of a table that was put in the lookaside
+	 * dropped list. Remove our id from that list.
+	 */
+	__wt_las_remove_dropped(session);
+
 	/* Connect to the underlying block manager. */
 	filename = dhandle->name;
 	if (!WT_PREFIX_SKIP(filename, "file:"))
@@ -236,6 +242,16 @@ __wt_btree_close(WT_SESSION_IMPL *session)
 	F_SET(btree, WT_BTREE_CLOSED);
 
 	/*
+	 * If closing a tree let sweep drop lookaside entries for it.
+	 */
+	if (F_ISSET(S2C(session), WT_CONN_LOOKASIDE_OPEN) &&
+	    btree->lookaside_entries) {
+		WT_ASSERT(session, !WT_IS_METADATA(btree->dhandle) &&
+		    !F_ISSET(btree, WT_BTREE_LOOKASIDE));
+		WT_TRET(__wt_las_save_dropped(session));
+	}
+
+	/*
 	 * If we turned eviction off and never turned it back on, do that now,
 	 * otherwise the counter will be off.
 	 */
diff --git a/src/third_party/wiredtiger/src/btree/bt_read.c b/src/third_party/wiredtiger/src/btree/bt_read.c
index 1254b86c6ea..bbf60aabc20 100644
--- a/src/third_party/wiredtiger/src/btree/bt_read.c
+++ b/src/third_party/wiredtiger/src/btree/bt_read.c
@@ -291,6 +291,13 @@ __las_page_instantiate(WT_SESSION_IMPL *session, WT_REF *ref)
 		}
 	}
 
+	/*
+	 * Now the lookaside history has been read into cache there is no
+	 * further need to maintain a reference to it.
+	 */
+	ref->page_las->eviction_to_lookaside = false;
+	ref->page_las->resolved = true;
+
 err:	if (locked)
 		__wt_readunlock(session, &cache->las_sweepwalk_lock);
 	WT_TRET(__wt_las_cursor_close(session, &cursor, session_flags));
@@ -414,7 +421,6 @@ __page_read_lookaside(WT_SESSION_IMPL *session,
 	}
 
 	WT_RET(__las_page_instantiate(session, ref));
-	ref->page_las->eviction_to_lookaside = false;
 	return (0);
 }
 
@@ -538,10 +544,8 @@ skip_read:
 		 * information), first update based on the lookaside table and
 		 * then apply the delete.
 		 */
-		if (ref->page_las != NULL) {
+		if (ref->page_las != NULL)
 			WT_ERR(__las_page_instantiate(session, ref));
-			ref->page_las->eviction_to_lookaside = false;
-		}
 
 		/* Move all records to a deleted state. */
 		WT_ERR(__wt_delete_page_instantiate(session, ref));
diff --git a/src/third_party/wiredtiger/src/btree/bt_ret.c b/src/third_party/wiredtiger/src/btree/bt_ret.c
index 95ba4114345..60cb3d53699 100644
--- a/src/third_party/wiredtiger/src/btree/bt_ret.c
+++ b/src/third_party/wiredtiger/src/btree/bt_ret.c
@@ -201,6 +201,13 @@ __wt_value_return_upd(WT_SESSION_IMPL *session,
 					memcpy(listp, list, sizeof(list));
 			}
 			listp[i++] = upd;
+
+			/*
+			 * Once a modify is found, all previously committed
+			 * modifications should be applied regardless of
+			 * visibility.
+			 */
+			ignore_visibility = true;
 		}
 	}
 
diff --git a/src/third_party/wiredtiger/src/btree/bt_split.c b/src/third_party/wiredtiger/src/btree/bt_split.c
index 42d232fc7b4..0ea367fa360 100644
--- a/src/third_party/wiredtiger/src/btree/bt_split.c
+++ b/src/third_party/wiredtiger/src/btree/bt_split.c
@@ -855,6 +855,9 @@ __split_parent(WT_SESSION_IMPL *session, WT_REF *ref, WT_REF **ref_new,
 			}
 		}
 
+		/* Check that we are not discarding active history. */
+		WT_ASSERT(session, !__wt_page_las_active(session, next_ref));
+
 		/*
 		 * The page-delete and lookaside memory weren't added to the
 		 * parent's footprint, ignore it here.
diff --git a/src/third_party/wiredtiger/src/cache/cache_las.c b/src/third_party/wiredtiger/src/cache/cache_las.c
index cf28027d8b7..b38da22fc4a 100644
--- a/src/third_party/wiredtiger/src/cache/cache_las.c
+++ b/src/third_party/wiredtiger/src/cache/cache_las.c
@@ -57,6 +57,46 @@ __las_entry_count(WT_CACHE *cache)
 }
 
 /*
+ * __wt_las_config --
+ *	Configure the lookaside table.
+ */
+int
+__wt_las_config(WT_SESSION_IMPL *session, const char **cfg)
+{
+	WT_CONFIG_ITEM cval;
+	WT_CURSOR_BTREE *las_cursor;
+	WT_SESSION_IMPL *las_session;
+
+	WT_RET(__wt_config_gets(
+	    session, cfg, "cache_overflow.file_max", &cval));
+
+	if (cval.val != 0 && cval.val < WT_LAS_FILE_MIN)
+		WT_RET_MSG(session, EINVAL,
+		    "max cache overflow size %" PRId64 " below minimum %d",
+		    cval.val, WT_LAS_FILE_MIN);
+
+	/* This is expected for in-memory configurations. */
+	las_session = S2C(session)->cache->las_session[0];
+	WT_ASSERT(session,
+	    las_session != NULL || F_ISSET(S2C(session), WT_CONN_IN_MEMORY));
+
+	if (las_session == NULL)
+		return (0);
+
+	/*
+	 * We need to set file_max on the btree associated with one of the
+	 * lookaside sessions.
+	 */
+	las_cursor = (WT_CURSOR_BTREE *)las_session->las_cursor;
+	las_cursor->btree->file_max = (uint64_t)cval.val;
+
+	WT_STAT_CONN_SET(
+	    session, cache_lookaside_ondisk_max, las_cursor->btree->file_max);
+
+	return (0);
+}
+
+/*
  * __wt_las_empty --
  *	Return when there are entries in the lookaside table.
  */
@@ -126,7 +166,7 @@ __wt_las_stats_update(WT_SESSION_IMPL *session)
  *	Initialize the database's lookaside store.
  */
 int
-__wt_las_create(WT_SESSION_IMPL *session)
+__wt_las_create(WT_SESSION_IMPL *session, const char **cfg)
 {
 	WT_CACHE *cache;
 	WT_CONNECTION_IMPL *conn;
@@ -166,6 +206,8 @@ __wt_las_create(WT_SESSION_IMPL *session)
 		WT_RET(__wt_las_cursor_open(cache->las_session[i]));
 	}
 
+	WT_RET(__wt_las_config(session, cfg));
+
 	/* The statistics server is already running, make sure we don't race. */
 	WT_WRITE_BARRIER();
 	F_SET(conn, WT_CONN_LOOKASIDE_OPEN);
@@ -622,8 +664,9 @@ __wt_las_insert_block(WT_CURSOR *cursor,
 	WT_SESSION_IMPL *session;
 	WT_TXN_ISOLATION saved_isolation;
 	WT_UPDATE *upd;
+	wt_off_t las_size;
 	uint64_t insert_cnt;
-	uint64_t las_counter, las_pageid;
+	uint64_t las_counter, las_pageid, max_las_size;
 	uint32_t btree_id, i, slot;
 	uint8_t *p;
 	bool local_txn;
@@ -766,6 +809,14 @@ __wt_las_insert_block(WT_CURSOR *cursor,
 		} while ((upd = upd->next) != NULL);
 	}
 
+	WT_ERR(__wt_block_manager_named_size(session, WT_LAS_FILE, &las_size));
+	WT_STAT_CONN_SET(session, cache_lookaside_ondisk, las_size);
+	max_las_size = ((WT_CURSOR_BTREE *)cursor)->btree->file_max;
+	if (max_las_size != 0 && (uint64_t)las_size > max_las_size)
+		WT_PANIC_MSG(session, WT_PANIC,
+		    "WiredTigerLAS: file size of %" PRIu64 " exceeds maximum "
+		    "size %" PRIu64, (uint64_t)las_size, max_las_size);
+
 err:	/* Resolve the transaction. */
 	if (local_txn) {
 		if (ret == 0)
@@ -882,6 +933,33 @@ __wt_las_remove_block(
 }
 
 /*
+ * __wt_las_remove_dropped --
+ *	Remove an opened btree ID if it is in the dropped table.
+ */
+void
+__wt_las_remove_dropped(WT_SESSION_IMPL *session)
+{
+	WT_BTREE *btree;
+	WT_CACHE *cache;
+	u_int i, j;
+
+	btree = S2BT(session);
+	cache = S2C(session)->cache;
+
+	__wt_spin_lock(session, &cache->las_sweep_lock);
+	for (i = 0; i < cache->las_dropped_next &&
+	    cache->las_dropped[i] != btree->id; i++)
+		;
+
+	if (i < cache->las_dropped_next) {
+		cache->las_dropped_next--;
+		for (j = i; j < cache->las_dropped_next; j++)
+			cache->las_dropped[j] = cache->las_dropped[j + 1];
+	}
+	__wt_spin_unlock(session, &cache->las_sweep_lock);
+}
+
+/*
  * __wt_las_save_dropped --
  *	Save a dropped btree ID to be swept from the lookaside table.
  */
@@ -958,6 +1036,19 @@ __las_sweep_init(WT_SESSION_IMPL *session)
 		goto err;
 	}
 
+	/*
+	 * Record the current page ID: sweep will stop after this point.
+	 *
+	 * Since the btree IDs we're scanning are closed, any eviction must
+	 * have already completed, so we won't miss anything with this
+	 * approach.
+	 *
+	 * Also, if a tree is reopened and there is lookaside activity before
+	 * this sweep completes, it will have a higher page ID and should not
+	 * be removed.
+	 */
+	cache->las_sweep_max_pageid = cache->las_pageid;
+
 	/* Scan the btree IDs to find min/max. */
 	cache->las_sweep_dropmin = UINT32_MAX;
 	cache->las_sweep_dropmax = 0;
@@ -1058,7 +1149,7 @@ __wt_las_sweep(WT_SESSION_IMPL *session)
 		 * table. Searching for the same key could leave us stuck at
 		 * the end of the table, repeatedly checking the same rows.
 		 */
-		sweep_key->size = 0;
+		__wt_buf_free(session, sweep_key);
 	} else
 		ret = __las_sweep_init(session);
 	if (ret != 0)
@@ -1088,6 +1179,17 @@ __wt_las_sweep(WT_SESSION_IMPL *session)
 			cnt = 0;
 
 		/*
+		 * Don't go past the end of lookaside from when sweep started.
+		 * If a file is reopened, its ID may be reused past this point
+		 * so the bitmap we're using is not valid.
+		 */
+		if (las_pageid > cache->las_sweep_max_pageid) {
+			__wt_buf_free(session, sweep_key);
+			ret = WT_NOTFOUND;
+			break;
+		}
+
+		/*
 		 * We only want to break between key blocks. Stop if we've
 		 * processed enough entries either all we wanted or enough
 		 * and there is a reader waiting and we're on a key boundary.
diff --git a/src/third_party/wiredtiger/src/config/config_def.c b/src/third_party/wiredtiger/src/config/config_def.c
index 1bda9a62e25..1e6c6775ba5 100644
--- a/src/third_party/wiredtiger/src/config/config_def.c
+++ b/src/third_party/wiredtiger/src/config/config_def.c
@@ -61,6 +61,12 @@ static const WT_CONFIG_CHECK
 };
 
 static const WT_CONFIG_CHECK
+    confchk_wiredtiger_open_cache_overflow_subconfigs[] = {
+	{ "file_max", "int", NULL, "min=0", NULL, 0 },
+	{ NULL, NULL, NULL, NULL, NULL, 0 }
+};
+
+static const WT_CONFIG_CHECK
     confchk_wiredtiger_open_checkpoint_subconfigs[] = {
 	{ "log_size", "int", NULL, "min=0,max=2GB", NULL, 0 },
 	{ "wait", "int", NULL, "min=0,max=100000", NULL, 0 },
@@ -139,6 +145,9 @@ static const WT_CONFIG_CHECK confchk_WT_CONNECTION_reconfigure[] = {
 	    NULL, NULL,
 	    confchk_wiredtiger_open_async_subconfigs, 3 },
 	{ "cache_max_wait_ms", "int", NULL, "min=0", NULL, 0 },
+	{ "cache_overflow", "category",
+	    NULL, NULL,
+	    confchk_wiredtiger_open_cache_overflow_subconfigs, 1 },
 	{ "cache_overhead", "int", NULL, "min=0,max=30", NULL, 0 },
 	{ "cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0 },
 	{ "checkpoint", "category",
@@ -822,6 +831,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open[] = {
 	{ "builtin_extension_config", "string", NULL, NULL, NULL, 0 },
 	{ "cache_cursors", "boolean", NULL, NULL, NULL, 0 },
 	{ "cache_max_wait_ms", "int", NULL, "min=0", NULL, 0 },
+	{ "cache_overflow", "category",
+	    NULL, NULL,
+	    confchk_wiredtiger_open_cache_overflow_subconfigs, 1 },
 	{ "cache_overhead", "int", NULL, "min=0,max=30", NULL, 0 },
 	{ "cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0 },
 	{ "checkpoint", "category",
@@ -928,6 +940,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_all[] = {
 	{ "builtin_extension_config", "string", NULL, NULL, NULL, 0 },
 	{ "cache_cursors", "boolean", NULL, NULL, NULL, 0 },
 	{ "cache_max_wait_ms", "int", NULL, "min=0", NULL, 0 },
+	{ "cache_overflow", "category",
+	    NULL, NULL,
+	    confchk_wiredtiger_open_cache_overflow_subconfigs, 1 },
 	{ "cache_overhead", "int", NULL, "min=0,max=30", NULL, 0 },
 	{ "cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0 },
 	{ "checkpoint", "category",
@@ -1035,6 +1050,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_basecfg[] = {
 	{ "builtin_extension_config", "string", NULL, NULL, NULL, 0 },
 	{ "cache_cursors", "boolean", NULL, NULL, NULL, 0 },
 	{ "cache_max_wait_ms", "int", NULL, "min=0", NULL, 0 },
+	{ "cache_overflow", "category",
+	    NULL, NULL,
+	    confchk_wiredtiger_open_cache_overflow_subconfigs, 1 },
 	{ "cache_overhead", "int", NULL, "min=0,max=30", NULL, 0 },
 	{ "cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0 },
 	{ "checkpoint", "category",
@@ -1136,6 +1154,9 @@ static const WT_CONFIG_CHECK confchk_wiredtiger_open_usercfg[] = {
 	{ "builtin_extension_config", "string", NULL, NULL, NULL, 0 },
 	{ "cache_cursors", "boolean", NULL, NULL, NULL, 0 },
 	{ "cache_max_wait_ms", "int", NULL, "min=0", NULL, 0 },
+	{ "cache_overflow", "category",
+	    NULL, NULL,
+	    confchk_wiredtiger_open_cache_overflow_subconfigs, 1 },
 	{ "cache_overhead", "int", NULL, "min=0,max=30", NULL, 0 },
 	{ "cache_size", "int", NULL, "min=1MB,max=10TB", NULL, 0 },
 	{ "checkpoint", "category",
@@ -1278,9 +1299,9 @@ static const WT_CONFIG_ENTRY config_entries[] = {
 	},
 	{ "WT_CONNECTION.reconfigure",
 	  "async=(enabled=false,ops_max=1024,threads=2),cache_max_wait_ms=0"
-	  ",cache_overhead=8,cache_size=100MB,checkpoint=(log_size=0,"
-	  "wait=0),compatibility=(release=),error_prefix=,"
-	  "eviction=(threads_max=8,threads_min=1),"
+	  ",cache_overflow=(file_max=0),cache_overhead=8,cache_size=100MB,"
+	  "checkpoint=(log_size=0,wait=0),compatibility=(release=),"
+	  "error_prefix=,eviction=(threads_max=8,threads_min=1),"
 	  "eviction_checkpoint_target=1,eviction_dirty_target=5,"
 	  "eviction_dirty_trigger=20,eviction_target=80,eviction_trigger=95"
 	  ",file_manager=(close_handle_minimum=250,close_idle_time=30,"
@@ -1291,7 +1312,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {
 	  "statistics=none,statistics_log=(json=false,on_close=false,"
 	  "sources=,timestamp=\"%b %d %H:%M:%S\",wait=0),"
 	  "timing_stress_for_test=,verbose=",
-	  confchk_WT_CONNECTION_reconfigure, 23
+	  confchk_WT_CONNECTION_reconfigure, 24
 	},
 	{ "WT_CONNECTION.rollback_to_stable",
 	  "",
@@ -1525,65 +1546,67 @@ static const WT_CONFIG_ENTRY config_entries[] = {
 	{ "wiredtiger_open",
 	  "async=(enabled=false,ops_max=1024,threads=2),buffer_alignment=-1"
 	  ",builtin_extension_config=,cache_cursors=true,"
-	  "cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB,"
-	  "checkpoint=(log_size=0,wait=0),checkpoint_sync=true,"
-	  "compatibility=(release=,require_max=,require_min=),"
-	  "config_base=true,create=false,direct_io=,encryption=(keyid=,"
-	  "name=,secretkey=),error_prefix=,eviction=(threads_max=8,"
-	  "threads_min=1),eviction_checkpoint_target=1,"
-	  "eviction_dirty_target=5,eviction_dirty_trigger=20,"
-	  "eviction_target=80,eviction_trigger=95,exclusive=false,"
-	  "extensions=,file_extend=,file_manager=(close_handle_minimum=250,"
-	  "close_idle_time=30,close_scan_interval=10),hazard_max=1000,"
-	  "in_memory=false,log=(archive=true,compressor=,enabled=false,"
-	  "file_max=100MB,path=\".\",prealloc=true,recover=on,"
-	  "zero_fill=false),lsm_manager=(merge=true,worker_thread_max=4),"
-	  "lsm_merge=true,mmap=true,multiprocess=false,"
-	  "operation_tracking=(enabled=false,path=\".\"),readonly=false,"
-	  "salvage=false,session_max=100,session_scratch_max=2MB,"
-	  "session_table_cache=true,shared_cache=(chunk=10MB,name=,quota=0,"
-	  "reserve=0,size=500MB),statistics=none,statistics_log=(json=false"
-	  ",on_close=false,path=\".\",sources=,timestamp=\"%b %d %H:%M:%S\""
-	  ",wait=0),timing_stress_for_test=,transaction_sync=(enabled=false"
-	  ",method=fsync),use_environment=true,use_environment_priv=false,"
+	  "cache_max_wait_ms=0,cache_overflow=(file_max=0),cache_overhead=8"
+	  ",cache_size=100MB,checkpoint=(log_size=0,wait=0),"
+	  "checkpoint_sync=true,compatibility=(release=,require_max=,"
+	  "require_min=),config_base=true,create=false,direct_io=,"
+	  "encryption=(keyid=,name=,secretkey=),error_prefix=,"
+	  "eviction=(threads_max=8,threads_min=1),"
+	  "eviction_checkpoint_target=1,eviction_dirty_target=5,"
+	  "eviction_dirty_trigger=20,eviction_target=80,eviction_trigger=95"
+	  ",exclusive=false,extensions=,file_extend=,"
+	  "file_manager=(close_handle_minimum=250,close_idle_time=30,"
+	  "close_scan_interval=10),hazard_max=1000,in_memory=false,"
+	  "log=(archive=true,compressor=,enabled=false,file_max=100MB,"
+	  "path=\".\",prealloc=true,recover=on,zero_fill=false),"
+	  "lsm_manager=(merge=true,worker_thread_max=4),lsm_merge=true,"
+	  "mmap=true,multiprocess=false,operation_tracking=(enabled=false,"
+	  "path=\".\"),readonly=false,salvage=false,session_max=100,"
+	  "session_scratch_max=2MB,session_table_cache=true,"
+	  "shared_cache=(chunk=10MB,name=,quota=0,reserve=0,size=500MB),"
+	  "statistics=none,statistics_log=(json=false,on_close=false,"
+	  "path=\".\",sources=,timestamp=\"%b %d %H:%M:%S\",wait=0),"
+	  "timing_stress_for_test=,transaction_sync=(enabled=false,"
+	  "method=fsync),use_environment=true,use_environment_priv=false,"
 	  "verbose=,write_through=",
-	  confchk_wiredtiger_open, 47
+	  confchk_wiredtiger_open, 48
 	},
 	{ "wiredtiger_open_all",
 	  "async=(enabled=false,ops_max=1024,threads=2),buffer_alignment=-1"
 	  ",builtin_extension_config=,cache_cursors=true,"
-	  "cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB,"
-	  "checkpoint=(log_size=0,wait=0),checkpoint_sync=true,"
-	  "compatibility=(release=,require_max=,require_min=),"
-	  "config_base=true,create=false,direct_io=,encryption=(keyid=,"
-	  "name=,secretkey=),error_prefix=,eviction=(threads_max=8,"
-	  "threads_min=1),eviction_checkpoint_target=1,"
-	  "eviction_dirty_target=5,eviction_dirty_trigger=20,"
-	  "eviction_target=80,eviction_trigger=95,exclusive=false,"
-	  "extensions=,file_extend=,file_manager=(close_handle_minimum=250,"
-	  "close_idle_time=30,close_scan_interval=10),hazard_max=1000,"
-	  "in_memory=false,log=(archive=true,compressor=,enabled=false,"
-	  "file_max=100MB,path=\".\",prealloc=true,recover=on,"
-	  "zero_fill=false),lsm_manager=(merge=true,worker_thread_max=4),"
-	  "lsm_merge=true,mmap=true,multiprocess=false,"
-	  "operation_tracking=(enabled=false,path=\".\"),readonly=false,"
-	  "salvage=false,session_max=100,session_scratch_max=2MB,"
-	  "session_table_cache=true,shared_cache=(chunk=10MB,name=,quota=0,"
-	  "reserve=0,size=500MB),statistics=none,statistics_log=(json=false"
-	  ",on_close=false,path=\".\",sources=,timestamp=\"%b %d %H:%M:%S\""
-	  ",wait=0),timing_stress_for_test=,transaction_sync=(enabled=false"
-	  ",method=fsync),use_environment=true,use_environment_priv=false,"
+	  "cache_max_wait_ms=0,cache_overflow=(file_max=0),cache_overhead=8"
+	  ",cache_size=100MB,checkpoint=(log_size=0,wait=0),"
+	  "checkpoint_sync=true,compatibility=(release=,require_max=,"
+	  "require_min=),config_base=true,create=false,direct_io=,"
+	  "encryption=(keyid=,name=,secretkey=),error_prefix=,"
+	  "eviction=(threads_max=8,threads_min=1),"
+	  "eviction_checkpoint_target=1,eviction_dirty_target=5,"
+	  "eviction_dirty_trigger=20,eviction_target=80,eviction_trigger=95"
+	  ",exclusive=false,extensions=,file_extend=,"
+	  "file_manager=(close_handle_minimum=250,close_idle_time=30,"
+	  "close_scan_interval=10),hazard_max=1000,in_memory=false,"
+	  "log=(archive=true,compressor=,enabled=false,file_max=100MB,"
+	  "path=\".\",prealloc=true,recover=on,zero_fill=false),"
+	  "lsm_manager=(merge=true,worker_thread_max=4),lsm_merge=true,"
+	  "mmap=true,multiprocess=false,operation_tracking=(enabled=false,"
+	  "path=\".\"),readonly=false,salvage=false,session_max=100,"
+	  "session_scratch_max=2MB,session_table_cache=true,"
+	  "shared_cache=(chunk=10MB,name=,quota=0,reserve=0,size=500MB),"
+	  "statistics=none,statistics_log=(json=false,on_close=false,"
+	  "path=\".\",sources=,timestamp=\"%b %d %H:%M:%S\",wait=0),"
+	  "timing_stress_for_test=,transaction_sync=(enabled=false,"
+	  "method=fsync),use_environment=true,use_environment_priv=false,"
 	  "verbose=,version=(major=0,minor=0),write_through=",
-	  confchk_wiredtiger_open_all, 48
+	  confchk_wiredtiger_open_all, 49
 	},
 	{ "wiredtiger_open_basecfg",
 	  "async=(enabled=false,ops_max=1024,threads=2),buffer_alignment=-1"
 	  ",builtin_extension_config=,cache_cursors=true,"
-	  "cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB,"
-	  "checkpoint=(log_size=0,wait=0),checkpoint_sync=true,"
-	  "compatibility=(release=,require_max=,require_min=),direct_io=,"
-	  "encryption=(keyid=,name=,secretkey=),error_prefix=,"
-	  "eviction=(threads_max=8,threads_min=1),"
+	  "cache_max_wait_ms=0,cache_overflow=(file_max=0),cache_overhead=8"
+	  ",cache_size=100MB,checkpoint=(log_size=0,wait=0),"
+	  "checkpoint_sync=true,compatibility=(release=,require_max=,"
+	  "require_min=),direct_io=,encryption=(keyid=,name=,secretkey=),"
+	  "error_prefix=,eviction=(threads_max=8,threads_min=1),"
 	  "eviction_checkpoint_target=1,eviction_dirty_target=5,"
 	  "eviction_dirty_trigger=20,eviction_target=80,eviction_trigger=95"
 	  ",extensions=,file_extend=,file_manager=(close_handle_minimum=250"
@@ -1599,16 +1622,16 @@ static const WT_CONFIG_ENTRY config_entries[] = {
 	  "path=\".\",sources=,timestamp=\"%b %d %H:%M:%S\",wait=0),"
 	  "timing_stress_for_test=,transaction_sync=(enabled=false,"
 	  "method=fsync),verbose=,version=(major=0,minor=0),write_through=",
-	  confchk_wiredtiger_open_basecfg, 42
+	  confchk_wiredtiger_open_basecfg, 43
 	},
 	{ "wiredtiger_open_usercfg",
 	  "async=(enabled=false,ops_max=1024,threads=2),buffer_alignment=-1"
 	  ",builtin_extension_config=,cache_cursors=true,"
-	  "cache_max_wait_ms=0,cache_overhead=8,cache_size=100MB,"
-	  "checkpoint=(log_size=0,wait=0),checkpoint_sync=true,"
-	  "compatibility=(release=,require_max=,require_min=),direct_io=,"
-	  "encryption=(keyid=,name=,secretkey=),error_prefix=,"
-	  "eviction=(threads_max=8,threads_min=1),"
+	  "cache_max_wait_ms=0,cache_overflow=(file_max=0),cache_overhead=8"
+	  ",cache_size=100MB,checkpoint=(log_size=0,wait=0),"
+	  "checkpoint_sync=true,compatibility=(release=,require_max=,"
+	  "require_min=),direct_io=,encryption=(keyid=,name=,secretkey=),"
+	  "error_prefix=,eviction=(threads_max=8,threads_min=1),"
 	  "eviction_checkpoint_target=1,eviction_dirty_target=5,"
 	  "eviction_dirty_trigger=20,eviction_target=80,eviction_trigger=95"
 	  ",extensions=,file_extend=,file_manager=(close_handle_minimum=250"
@@ -1624,7 +1647,7 @@ static const WT_CONFIG_ENTRY config_entries[] = {
 	  "path=\".\",sources=,timestamp=\"%b %d %H:%M:%S\",wait=0),"
 	  "timing_stress_for_test=,transaction_sync=(enabled=false,"
 	  "method=fsync),verbose=,write_through=",
-	  confchk_wiredtiger_open_usercfg, 41
+	  confchk_wiredtiger_open_usercfg, 42
 	},
 	{ NULL, NULL, NULL, 0 }
 };
diff --git a/src/third_party/wiredtiger/src/conn/api_calc_modify.c b/src/third_party/wiredtiger/src/conn/api_calc_modify.c
new file mode 100644
index 00000000000..0888ce7b706
--- /dev/null
+++ b/src/third_party/wiredtiger/src/conn/api_calc_modify.c
@@ -0,0 +1,208 @@
+/*-
+ * Copyright (c) 2014-2018 MongoDB, Inc.
+ * Copyright (c) 2008-2014 WiredTiger, Inc.
+ *	All rights reserved.
+ *
+ * See the file LICENSE for redistribution information.
+ */
+
+#include "wt_internal.h"
+
+#define	WT_CM_BLOCKSIZE 8
+#define	WT_CM_MINMATCH 64
+#define	WT_CM_STARTGAP (WT_CM_BLOCKSIZE / 2)
+
+typedef struct {
+	WT_SESSION_IMPL *session;
+
+	const uint8_t *s1, *e1; /* Start / end of pre-image. */
+	const uint8_t *s2, *e2; /* Start / end of after-image. */
+
+	const uint8_t *used1, *used2; /* Used up to here. */
+
+	size_t maxdiff;
+	int maxentries;
+} WT_CM_STATE;
+
+typedef struct {
+	const uint8_t *m1, *m2;
+	size_t len;
+} WT_CM_MATCH;
+
+/*
+ * __cm_add_modify --
+ *	Add a modify operation to the list of entries.
+ *
+ *	Fails if all entries are used or the maximum bytes of difference is
+ *	exceeded.
+ */
+static int
+__cm_add_modify(WT_CM_STATE *cms, const uint8_t *p2,
+    const uint8_t *m1, const uint8_t *m2, WT_MODIFY *entries, int *nentriesp)
+{
+	WT_MODIFY *mod;
+	size_t len1, len2;
+
+	WT_ASSERT(cms->session, m1 >= cms->used1 && m2 >= cms->used2);
+
+	len1 = (size_t)(m1 - cms->used1);
+	len2 = (size_t)(m2 - cms->used2);
+
+	if (*nentriesp >= cms->maxentries || len2 > cms->maxdiff)
+		return (WT_NOTFOUND);
+
+	mod = entries + (*nentriesp)++;
+	mod->offset = (size_t)(p2 - cms->s2);
+	mod->size = len1;
+	mod->data.data = p2;
+	mod->data.size = len2;
+	cms->maxdiff -= len2;
+
+	return (0);
+}
+
+/*
+ * __cm_extend --
+ *	Given a potential match size, extend to find the complete match.
+ */
+static void
+__cm_extend(WT_CM_STATE *cms,
+    const uint8_t *m1, const uint8_t *m2, WT_CM_MATCH *match)
+{
+	ptrdiff_t n;
+	const uint8_t *p1, *p2;
+
+	p1 = m1;
+	p2 = m2;
+
+	/*
+	 * Keep skipping half of the remaining bytes while they compare equal.
+	 * This is significantly faster than our byte-at-a-time loop below.
+	 */
+	for (p1 = m1, p2 = m2;
+	    (n = WT_MIN(cms->e1 - p1, cms->e2 - p2) / 2) > 8 &&
+	    memcmp(p1, p2, (size_t)n) == 0;
+	    p1 += n, p2 += n)
+		;
+
+	/* Step past the end and before the beginning of the matching block. */
+	for (n = WT_MIN(cms->e1 - p1, cms->e2 - p2);
+	    n > 0 && *p1 == *p2;
+	    n--, p1++, p2++)
+		;
+
+	for (n = WT_MIN(m1 - cms->used1, m2 - cms->used2);
+	    n > 0 && *m1 == *m2;
+	    n--, m1--, m2--)
+		;
+
+	match->m1 = m1 + 1;
+	match->m2 = m2 + 1;
+	match->len = p1 > m1 ? (size_t)((p1 - m1) - 1) : 0;
+}
+
+/*
+ * __cm_fingerprint --
+ *	Calculate an integral "fingerprint" of a block of bytes.
+ */
+static inline uint64_t
+__cm_fingerprint(const uint8_t *p)
+{
+	uint64_t h;
+
+	WT_STATIC_ASSERT(sizeof(h) <= WT_CM_BLOCKSIZE);
+	memcpy(&h, p, WT_CM_BLOCKSIZE);
+	return (h);
+}
+
+/*
+ * wiredtiger_calc_modify --
+ *	Calculate a set of WT_MODIFY operations to represent an update.
+ */
+int
+wiredtiger_calc_modify(WT_SESSION *wt_session,
+    const WT_ITEM *oldv, const WT_ITEM *newv,
+    size_t maxdiff, WT_MODIFY *entries, int *nentriesp)
+{
+	WT_CM_MATCH match;
+	WT_CM_STATE cms;
+	size_t gap, i;
+	uint64_t h, hend, hstart;
+	const uint8_t *p1, *p2;
+	bool start;
+
+	if (oldv->size < WT_CM_MINMATCH || newv->size < WT_CM_MINMATCH)
+		return (WT_NOTFOUND);
+
+	cms.session = (WT_SESSION_IMPL *)wt_session;
+
+	cms.s1 = cms.used1 = oldv->data;
+	cms.e1 = cms.s1 + oldv->size;
+	cms.s2 = cms.used2 = newv->data;
+	cms.e2 = cms.s2 + newv->size;
+	cms.maxdiff = maxdiff;
+	cms.maxentries = *nentriesp;
+	*nentriesp = 0;
+
+	/* Ignore matches at the beginning / end. */
+	__cm_extend(&cms, cms.s1, cms.s2, &match);
+	cms.used1 += match.len;
+	cms.used2 += match.len;
+	if (cms.used1 < cms.e1 && cms.used2 < cms.e2) {
+		__cm_extend(&cms, cms.e1 - 1, cms.e2 - 1, &match);
+		cms.e1 -= match.len;
+		cms.e2 -= match.len;
+	}
+
+	if (cms.used1 + WT_CM_BLOCKSIZE >= cms.e1 ||
+	    cms.used2 + WT_CM_BLOCKSIZE >= cms.e2)
+		goto end;
+
+	/*
+	 * Walk through the post-image, maintaining start / end markers
+	 * separated by a gap in the pre-image.  If the current point in the
+	 * post-image matches either marker, try to extend the match to find a
+	 * (large) range of matching bytes.  If the end of the range is reached
+	 * in the post-image without finding a good match, double the size of
+	 * the gap, update the markers and keep trying.
+	 */
+	h = hstart = hend = 0;
+	i = gap = 0;
+	for (p1 = cms.used1, p2 = cms.used2, start = true;
+	    p1 + WT_CM_BLOCKSIZE <= cms.e1 && p2 + WT_CM_BLOCKSIZE <= cms.e2;
+	    p2++, i++) {
+		if (start || i == gap) {
+			p1 += gap;
+			gap = start ? WT_CM_STARTGAP : gap * 2;
+			if (p1 + gap + WT_CM_BLOCKSIZE >= cms.e1)
+				break;
+			if (gap > maxdiff)
+				return (WT_NOTFOUND);
+			hstart = start ? __cm_fingerprint(p1) : hend;
+			hend = __cm_fingerprint(p1 + gap);
+			start = false;
+			i = 0;
+		}
+		h = __cm_fingerprint(p2);
+		match.len = 0;
+		if (h == hstart)
+			__cm_extend(&cms, p1, p2, &match);
+		else if (h == hend)
+			__cm_extend(&cms, p1 + gap, p2, &match);
+
+		if (match.len < WT_CM_MINMATCH)
+			continue;
+
+		WT_RET(__cm_add_modify(&cms, cms.used2, match.m1, match.m2,
+		    entries, nentriesp));
+		cms.used1 = p1 = match.m1 + match.len;
+		cms.used2 = p2 = match.m2 + match.len;
+		start = true;
+	}
+
+end:	if (cms.used1 < cms.e1 || cms.used2 < cms.e2)
+		WT_RET(__cm_add_modify(&cms, cms.used2, cms.e1, cms.e2,
+		    entries, nentriesp));
+
+	return (0);
+}
diff --git a/src/third_party/wiredtiger/src/conn/conn_open.c b/src/third_party/wiredtiger/src/conn/conn_open.c
index 6fa87d47a91..446e8701250 100644
--- a/src/third_party/wiredtiger/src/conn/conn_open.c
+++ b/src/third_party/wiredtiger/src/conn/conn_open.c
@@ -237,7 +237,7 @@ __wt_connection_workers(WT_SESSION_IMPL *session, const char *cfg[])
 	WT_RET(__wt_meta_track_init(session));
 
 	/* Create the lookaside table. */
-	WT_RET(__wt_las_create(session));
+	WT_RET(__wt_las_create(session, cfg));
 
 	/*
 	 * Start eviction threads.
diff --git a/src/third_party/wiredtiger/src/conn/conn_reconfig.c b/src/third_party/wiredtiger/src/conn/conn_reconfig.c
index 8bf2a53e49b..e557d0d3472 100644
--- a/src/third_party/wiredtiger/src/conn/conn_reconfig.c
+++ b/src/third_party/wiredtiger/src/conn/conn_reconfig.c
@@ -55,7 +55,7 @@ __wt_conn_compat_config(
 	uint16_t max_major, max_minor, min_major, min_minor;
 	uint16_t rel_major, rel_minor;
 	char *value;
-	bool txn_active;
+	bool txn_active, unchg;
 
 	conn = S2C(session);
 	value = NULL;
@@ -63,6 +63,7 @@ __wt_conn_compat_config(
 	max_minor = WT_CONN_COMPAT_NONE;
 	min_major = WT_CONN_COMPAT_NONE;
 	min_minor = WT_CONN_COMPAT_NONE;
+	unchg = false;
 
 	WT_RET(__wt_config_gets(session, cfg, "compatibility.release", &cval));
 	if (cval.len == 0) {
@@ -74,21 +75,31 @@ __wt_conn_compat_config(
 		    session, &cval, &rel_major, &rel_minor));
 
 		/*
-		 * We're doing an upgrade or downgrade, check whether
-		 * transactions are active.
+		 * If the user is running downgraded, then the compatibility
+		 * string is part of the configuration string. Determine if
+		 * the user is actually changing the compatibility.
 		 */
-		WT_RET(__wt_txn_activity_check(session, &txn_active));
-		if (txn_active)
-			WT_RET_MSG(session, ENOTSUP,
-			    "system must be quiescent"
-			    " for upgrade or downgrade");
+		if (reconfig && rel_major == conn->compat_major &&
+		    rel_minor == conn->compat_minor)
+			unchg = true;
+		else {
+			/*
+			 * We're doing an upgrade or downgrade, check whether
+			 * transactions are active.
+			 */
+			WT_RET(__wt_txn_activity_check(session, &txn_active));
+			if (txn_active)
+				WT_RET_MSG(session, ENOTSUP,
+				    "system must be quiescent"
+				    " for upgrade or downgrade");
+		}
 		F_SET(conn, WT_CONN_COMPATIBILITY);
 	}
 	/*
-	 * If we're a reconfigure and the user did not set any compatibility,
-	 * we're done.
+	 * If we're a reconfigure and the user did not set any compatibility
+	 * or did not change the setting, we're done.
 	 */
-	if (reconfig && !F_ISSET(conn, WT_CONN_COMPATIBILITY))
+	if (reconfig && (!F_ISSET(conn, WT_CONN_COMPATIBILITY) || unchg))
 		goto done;
 
 	/*
@@ -476,12 +487,13 @@ __wt_conn_reconfig(WT_SESSION_IMPL *session, const char **cfg)
 	WT_ERR(__wt_async_reconfig(session, cfg));
 	WT_ERR(__wt_cache_config(session, true, cfg));
 	WT_ERR(__wt_checkpoint_server_create(session, cfg));
+	WT_ERR(__wt_las_config(session, cfg));
 	WT_ERR(__wt_logmgr_reconfig(session, cfg));
 	WT_ERR(__wt_lsm_manager_reconfig(session, cfg));
 	WT_ERR(__wt_statlog_create(session, cfg));
 	WT_ERR(__wt_sweep_config(session, cfg));
-	WT_ERR(__wt_verbose_config(session, cfg));
 	WT_ERR(__wt_timing_stress_config(session, cfg));
+	WT_ERR(__wt_verbose_config(session, cfg));
 
 	/* Third, merge everything together, creating a new connection state. */
 	WT_ERR(__wt_config_merge(session, cfg, NULL, &p));
diff --git a/src/third_party/wiredtiger/src/docs/Doxyfile b/src/third_party/wiredtiger/src/docs/Doxyfile
index 60b6c4690b0..567a8cb92fb 100644
--- a/src/third_party/wiredtiger/src/docs/Doxyfile
+++ b/src/third_party/wiredtiger/src/docs/Doxyfile
@@ -210,7 +210,7 @@ ALIASES                = \
                          configempty{2}="@param config configuration string, see @ref config_strings.  No values currently permitted." \
                          configend="  </table>" \
                          configstart{2}="@param config configuration string, see @ref config_strings. Permitted values:\n  <table>@hrow{Name,Effect,Values}" \
-"ebusy_errors=@returns zero on success, EBUSY if the object is not available for exclusive access, and a non-zero error code on failure.  See @ref error_handling \"Error handling\" for details." \
+                         ebusy_errors="@returns zero on success, EBUSY if the object is not available for exclusive access, and a non-zero error code on failure.  See @ref error_handling \"Error handling\" for details." \
                          errors="@returns zero on success and a non-zero error code on failure.  See @ref error_handling \"Error handling\" for details." \
                          exclusive="This method requires exclusive access to the specified data source(s).  If any cursors are open with the specified name(s) or a data source is otherwise in use, the call will fail and return \c EBUSY.\n\n" \
                          ex_ref{1}="@ref \1 \"\1\"" \
diff --git a/src/third_party/wiredtiger/src/evict/evict_file.c b/src/third_party/wiredtiger/src/evict/evict_file.c
index df88a64daa9..5c0b6462b56 100644
--- a/src/third_party/wiredtiger/src/evict/evict_file.c
+++ b/src/third_party/wiredtiger/src/evict/evict_file.c
@@ -16,7 +16,6 @@ int
 __wt_evict_file(WT_SESSION_IMPL *session, WT_CACHE_OP syncop)
 {
 	WT_BTREE *btree;
-	WT_CONNECTION_IMPL *conn;
 	WT_DATA_HANDLE *dhandle;
 	WT_DECL_RET;
 	WT_PAGE *page;
@@ -25,7 +24,6 @@ __wt_evict_file(WT_SESSION_IMPL *session, WT_CACHE_OP syncop)
 
 	dhandle = session->dhandle;
 	btree = dhandle->handle;
-	conn = S2C(session);
 
 	/*
 	 * We need exclusive access to the file, we're about to discard the root
@@ -41,24 +39,6 @@ __wt_evict_file(WT_SESSION_IMPL *session, WT_CACHE_OP syncop)
 	if (btree->root.page == NULL)
 		return (0);
 
-	/*
-	 * If discarding a dead tree, remove any lookaside entries.  This deals
-	 * with the case where a tree is dropped with "force=true".  It happens
-	 * that we also force-drop the lookaside table itself: it can never
-	 * participate in lookaside eviction, and we can't open a cursor on it
-	 * as we are discarding it.
-	 *
-	 * We use the special page ID zero so that all lookaside entries for
-	 * the tree are removed.
-	 */
-	if (F_ISSET(dhandle, WT_DHANDLE_DEAD) &&
-	    F_ISSET(conn, WT_CONN_LOOKASIDE_OPEN) && btree->lookaside_entries) {
-		WT_ASSERT(session, !WT_IS_METADATA(dhandle) &&
-		    !F_ISSET(btree, WT_BTREE_LOOKASIDE));
-
-		WT_RET(__wt_las_save_dropped(session));
-	}
-
 	/* Make sure the oldest transaction ID is up-to-date. */
 	WT_RET(__wt_txn_update_oldest(
 	    session, WT_TXN_OLDEST_STRICT | WT_TXN_OLDEST_WAIT));
@@ -123,7 +103,7 @@ __wt_evict_file(WT_SESSION_IMPL *session, WT_CACHE_OP syncop)
 			 */
 			WT_ASSERT(session,
 			    F_ISSET(dhandle, WT_DHANDLE_DEAD) ||
-			    F_ISSET(conn, WT_CONN_CLOSING) ||
+			    F_ISSET(S2C(session), WT_CONN_CLOSING) ||
 			    __wt_page_can_evict(session, ref, NULL));
 			__wt_ref_out(session, ref);
 			break;
diff --git a/src/third_party/wiredtiger/src/include/btmem.h b/src/third_party/wiredtiger/src/include/btmem.h
index f4a6871e9a6..dcfb59d2ce9 100644
--- a/src/third_party/wiredtiger/src/include/btmem.h
+++ b/src/third_party/wiredtiger/src/include/btmem.h
@@ -239,6 +239,7 @@ struct __wt_page_lookaside {
 	WT_DECL_TIMESTAMP(max_timestamp)/* Maximum timestamp */
 	WT_DECL_TIMESTAMP(unstable_timestamp)/* First timestamp not on page */
 	bool eviction_to_lookaside;	/* Revert to lookaside on eviction */
+	bool resolved;			/* History has been read into cache */
 	bool skew_newest;		/* Page image has newest versions */
 };
 
@@ -1083,9 +1084,9 @@ struct __wt_update {
 
 /*
  * WT_MODIFY_MEM_FACTOR	--
- *	Limit update chains to a factor of the base document size.
+ *	Limit update chains to a fraction of the base document size.
  */
-#define	WT_MODIFY_MEM_FACTOR	1
+#define	WT_MODIFY_MEM_FRACTION	10
 
 /*
  * WT_INSERT --
diff --git a/src/third_party/wiredtiger/src/include/btree.h b/src/third_party/wiredtiger/src/include/btree.h
index 593745cc315..f4ed7c1a644 100644
--- a/src/third_party/wiredtiger/src/include/btree.h
+++ b/src/third_party/wiredtiger/src/include/btree.h
@@ -193,6 +193,12 @@ struct __wt_btree {
 	uint64_t    bytes_dirty_leaf;	/* Bytes in dirty leaf pages. */
 
 	/*
+	 * The maximum bytes allowed to be used for the table on disk.  This is
+	 * currently only used for the lookaside table.
+	 */
+	uint64_t    file_max;
+
+	/*
 	 * We flush pages from the tree (in order to make checkpoint faster),
 	 * without a high-level lock.  To avoid multiple threads flushing at
 	 * the same time, lock the tree.
diff --git a/src/third_party/wiredtiger/src/include/btree.i b/src/third_party/wiredtiger/src/include/btree.i
index 41d843790e8..4ca82e1ee9e 100644
--- a/src/third_party/wiredtiger/src/include/btree.i
+++ b/src/third_party/wiredtiger/src/include/btree.i
@@ -1189,6 +1189,8 @@ __wt_page_las_active(WT_SESSION_IMPL *session, WT_REF *ref)
 
 	if ((page_las = ref->page_las) == NULL)
 		return (false);
+	if (page_las->resolved)
+		return (false);
 	if (!page_las->skew_newest)
 		return (true);
 	if (__wt_txn_visible_all(session, page_las->max_txn,
diff --git a/src/third_party/wiredtiger/src/include/cache.h b/src/third_party/wiredtiger/src/include/cache.h
index 8afedb30832..9e849bf4d7f 100644
--- a/src/third_party/wiredtiger/src/include/cache.h
+++ b/src/third_party/wiredtiger/src/include/cache.h
@@ -54,6 +54,7 @@ typedef enum __wt_cache_op {
 	WT_SYNC_WRITE_LEAVES
 } WT_CACHE_OP;
 
+#define	WT_LAS_FILE_MIN		(100 * WT_MEGABYTE)
 #define	WT_LAS_NUM_SESSIONS	5
 #define	WT_LAS_SWEEP_ENTRIES	(20 * WT_THOUSAND)
 #define	WT_LAS_SWEEP_SEC	2
@@ -210,6 +211,7 @@ struct __wt_cache {
 	uint32_t las_sweep_dropmin;	/* Minimum btree ID in current set. */
 	uint8_t *las_sweep_dropmap;	/* Bitmap of dropped btree IDs. */
 	uint32_t las_sweep_dropmax;	/* Maximum btree ID in current set. */
+	uint64_t las_sweep_max_pageid;	/* Maximum page ID for sweep. */
 
 	uint32_t *las_dropped;		/* List of dropped btree IDs. */
 	size_t las_dropped_next;	/* Next index into drop list. */
diff --git a/src/third_party/wiredtiger/src/include/extern.h b/src/third_party/wiredtiger/src/include/extern.h
index 0e3bc68fcc6..afc89795500 100644
--- a/src/third_party/wiredtiger/src/include/extern.h
+++ b/src/third_party/wiredtiger/src/include/extern.h
@@ -201,9 +201,10 @@ extern int __wt_update_alloc(WT_SESSION_IMPL *session, const WT_ITEM *value, WT_
 extern WT_UPDATE *__wt_update_obsolete_check(WT_SESSION_IMPL *session, WT_PAGE *page, WT_UPDATE *upd);
 extern int __wt_search_insert(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt, WT_INSERT_HEAD *ins_head, WT_ITEM *srch_key) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_row_search(WT_SESSION_IMPL *session, WT_ITEM *srch_key, WT_REF *leaf, WT_CURSOR_BTREE *cbt, bool insert, bool restore) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __wt_las_config(WT_SESSION_IMPL *session, const char **cfg) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern bool __wt_las_empty(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern void __wt_las_stats_update(WT_SESSION_IMPL *session);
-extern int __wt_las_create(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __wt_las_create(WT_SESSION_IMPL *session, const char **cfg) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_las_destroy(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_las_cursor_open(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern void __wt_las_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session_flags);
@@ -213,6 +214,7 @@ extern bool __wt_las_page_skip(WT_SESSION_IMPL *session, WT_REF *ref) WT_GCC_FUN
 extern int __wt_las_insert_block(WT_CURSOR *cursor, WT_BTREE *btree, WT_PAGE *page, WT_MULTI *multi, WT_ITEM *key) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_las_cursor_position(WT_CURSOR *cursor, uint64_t pageid) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_las_remove_block(WT_SESSION_IMPL *session, uint64_t pageid, bool lock_wait) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern void __wt_las_remove_dropped(WT_SESSION_IMPL *session);
 extern int __wt_las_save_dropped(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_las_sweep(WT_SESSION_IMPL *session) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern uint32_t __wt_checksum_sw(const void *chunk, size_t len);
diff --git a/src/third_party/wiredtiger/src/include/meta.h b/src/third_party/wiredtiger/src/include/meta.h
index 3c028d1484b..4ae083d2885 100644
--- a/src/third_party/wiredtiger/src/include/meta.h
+++ b/src/third_party/wiredtiger/src/include/meta.h
@@ -27,6 +27,7 @@
 #define	WT_METAFILE_SLVG	"WiredTiger.wt.orig"	/* Metadata copy */
 #define	WT_METAFILE_URI		"file:WiredTiger.wt"	/* Metadata table URI */
 
+#define	WT_LAS_FILE		"WiredTigerLAS.wt"	/* Lookaside table */
 #define	WT_LAS_URI		"file:WiredTigerLAS.wt"	/* Lookaside table URI*/
 
 #define	WT_SYSTEM_PREFIX	"system:"		/* System URI prefix */
diff --git a/src/third_party/wiredtiger/src/include/stat.h b/src/third_party/wiredtiger/src/include/stat.h
index 38224cd2bc0..98064e547e1 100644
--- a/src/third_party/wiredtiger/src/include/stat.h
+++ b/src/third_party/wiredtiger/src/include/stat.h
@@ -359,6 +359,8 @@ struct __wt_connection_stats {
 	int64_t cache_lookaside_score;
 	int64_t cache_lookaside_entries;
 	int64_t cache_lookaside_insert;
+	int64_t cache_lookaside_ondisk_max;
+	int64_t cache_lookaside_ondisk;
 	int64_t cache_lookaside_remove;
 	int64_t cache_eviction_checkpoint;
 	int64_t cache_eviction_get_ref;
diff --git a/src/third_party/wiredtiger/src/include/wiredtiger.in b/src/third_party/wiredtiger/src/include/wiredtiger.in
index 73078f797b6..36f9ecff5c7 100644
--- a/src/third_party/wiredtiger/src/include/wiredtiger.in
+++ b/src/third_party/wiredtiger/src/include/wiredtiger.in
@@ -2187,6 +2187,16 @@ struct __wt_connection {
 	 * application thread will wait for space to be available in cache
 	 * before giving up.  Default will wait forever., an integer greater
 	 * than or equal to 0; default \c 0.}
+	 * @config{cache_overflow = (, cache overflow configuration options., a
+	 * set of related configuration options defined below.}
+	 * @config{&nbsp;&nbsp;&nbsp;&nbsp;file_max, The maximum number of bytes
+	 * that WiredTiger is allowed to use for its cache overflow mechanism.
+	 * If the cache overflow file exceeds this size\, a panic will be
+	 * triggered.  The default value means that the cache overflow file is
+	 * unbounded and may use as much space as the filesystem will
+	 * accommodate.  The minimum non-zero setting is 100MB., an integer
+	 * greater than or equal to 0; default \c 0.}
+	 * @config{ ),,}
 	 * @config{cache_overhead, assume the heap allocator overhead is the
 	 * specified percentage\, and adjust the cache usage by that amount (for
 	 * example\, if there is 10GB of data in cache\, a percentage of 10
@@ -2772,6 +2782,15 @@ struct __wt_connection {
  * thread will wait for space to be available in cache before giving up.
  * Default will wait forever., an integer greater than or equal to 0; default \c
  * 0.}
+ * @config{cache_overflow = (, cache overflow configuration options., a set of
+ * related configuration options defined below.}
+ * @config{&nbsp;&nbsp;&nbsp;&nbsp;file_max, The maximum number of bytes that
+ * WiredTiger is allowed to use for its cache overflow mechanism.  If the cache
+ * overflow file exceeds this size\, a panic will be triggered.  The default
+ * value means that the cache overflow file is unbounded and may use as much
+ * space as the filesystem will accommodate.  The minimum non-zero setting is
+ * 100MB., an integer greater than or equal to 0; default \c 0.}
+ * @config{ ),,}
  * @config{cache_overhead, assume the heap allocator overhead is the specified
  * percentage\, and adjust the cache usage by that amount (for example\, if
  * there is 10GB of data in cache\, a percentage of 10 means WiredTiger treats
@@ -3614,10 +3633,43 @@ struct __wt_config_parser {
 uint32_t (*wiredtiger_crc32c_func(void))(const void *, size_t)
     WT_ATTRIBUTE_LIBRARY_VISIBLE;
 
-/*! @} */
 #endif /* !defined(SWIG) */
 
 /*!
+ * Calculate a set of WT_MODIFY operations to represent an update.
+ * This call will calculate a set of modifications to an old value that produce
+ * the new value.  If more modifications are required than fit in the array
+ * passed in by the caller, or if more bytes have changed than the \c maxdiff
+ * parameter, the call will fail.  The matching algorithm is approximate, so it
+ * may fail and return WT_NOTFOUND if a matching set of WT_MODIFY operations
+ * is not found.
+ *
+ * The \c maxdiff parameter bounds how much work will be done searching for a
+ * match: to ensure a match is found, it may need to be set larger than actual
+ * number of bytes that differ between the old and new values.  In particular,
+ * repeated patterns of bytes in the values can lead to suboptimal matching,
+ * and matching ranges less than 64 bytes long will not be detected.
+ *
+ * If the call succeeds, the WT_MODIFY operations will point into \c newv,
+ * which must remain valid until WT_CURSOR::modify is called.
+ *
+ * @snippet ex_all.c Calculate a modify operation
+ *
+ * @param session the current WiredTiger session (may be NULL)
+ * @param oldv old value
+ * @param newv new value
+ * @param maxdiff maximum bytes difference
+ * @param[out] entries array of modifications producing the new value
+ * @param[in,out] nentriesp size of \c entries array passed in,
+ *	set to the number of entries used
+ * @errors
+ */
+int wiredtiger_calc_modify(WT_SESSION *session,
+    const WT_ITEM *oldv, const WT_ITEM *newv,
+    size_t maxdiff, WT_MODIFY *entries, int *nentriesp)
+    WT_ATTRIBUTE_LIBRARY_VISIBLE;
+
+/*!
  * Get version information.
  *
  * @snippet ex_all.c Get the WiredTiger library version #1
@@ -3631,6 +3683,8 @@ uint32_t (*wiredtiger_crc32c_func(void))(const void *, size_t)
 const char *wiredtiger_version(int *majorp, int *minorp, int *patchp)
     WT_ATTRIBUTE_LIBRARY_VISIBLE;
 
+/*! @} */
+
 /*******************************************
  * Error returns
  *******************************************/
@@ -5074,703 +5128,707 @@ extern int wiredtiger_extension_terminate(WT_CONNECTION *connection);
 #define	WT_STAT_CONN_CACHE_LOOKASIDE_ENTRIES		1044
 /*! cache: cache overflow table insert calls */
 #define	WT_STAT_CONN_CACHE_LOOKASIDE_INSERT		1045
+/*! cache: cache overflow table max on-disk size */
+#define	WT_STAT_CONN_CACHE_LOOKASIDE_ONDISK_MAX		1046
+/*! cache: cache overflow table on-disk size */
+#define	WT_STAT_CONN_CACHE_LOOKASIDE_ONDISK		1047
 /*! cache: cache overflow table remove calls */
-#define	WT_STAT_CONN_CACHE_LOOKASIDE_REMOVE		1046
+#define	WT_STAT_CONN_CACHE_LOOKASIDE_REMOVE		1048
 /*! cache: checkpoint blocked page eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_CHECKPOINT		1047
+#define	WT_STAT_CONN_CACHE_EVICTION_CHECKPOINT		1049
 /*! cache: eviction calls to get a page */
-#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF		1048
+#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF		1050
 /*! cache: eviction calls to get a page found queue empty */
-#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY	1049
+#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY	1051
 /*! cache: eviction calls to get a page found queue empty after locking */
-#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY2	1050
+#define	WT_STAT_CONN_CACHE_EVICTION_GET_REF_EMPTY2	1052
 /*! cache: eviction currently operating in aggressive mode */
-#define	WT_STAT_CONN_CACHE_EVICTION_AGGRESSIVE_SET	1051
+#define	WT_STAT_CONN_CACHE_EVICTION_AGGRESSIVE_SET	1053
 /*! cache: eviction empty score */
-#define	WT_STAT_CONN_CACHE_EVICTION_EMPTY_SCORE		1052
+#define	WT_STAT_CONN_CACHE_EVICTION_EMPTY_SCORE		1054
 /*! cache: eviction passes of a file */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK_PASSES		1053
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK_PASSES		1055
 /*! cache: eviction server candidate queue empty when topping up */
-#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_EMPTY		1054
+#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_EMPTY		1056
 /*! cache: eviction server candidate queue not empty when topping up */
-#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_NOT_EMPTY	1055
+#define	WT_STAT_CONN_CACHE_EVICTION_QUEUE_NOT_EMPTY	1057
 /*! cache: eviction server evicting pages */
-#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_EVICTING	1056
+#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_EVICTING	1058
 /*!
  * cache: eviction server slept, because we did not make progress with
  * eviction
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_SLEPT	1057
+#define	WT_STAT_CONN_CACHE_EVICTION_SERVER_SLEPT	1059
 /*! cache: eviction server unable to reach eviction goal */
-#define	WT_STAT_CONN_CACHE_EVICTION_SLOW		1058
+#define	WT_STAT_CONN_CACHE_EVICTION_SLOW		1060
 /*! cache: eviction state */
-#define	WT_STAT_CONN_CACHE_EVICTION_STATE		1059
+#define	WT_STAT_CONN_CACHE_EVICTION_STATE		1061
 /*! cache: eviction walk target pages histogram - 0-9 */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT10	1060
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT10	1062
 /*! cache: eviction walk target pages histogram - 10-31 */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT32	1061
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT32	1063
 /*! cache: eviction walk target pages histogram - 128 and higher */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_GE128	1062
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_GE128	1064
 /*! cache: eviction walk target pages histogram - 32-63 */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT64	1063
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT64	1065
 /*! cache: eviction walk target pages histogram - 64-128 */
-#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT128	1064
+#define	WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT128	1066
 /*! cache: eviction walks abandoned */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ABANDONED	1065
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ABANDONED	1067
 /*! cache: eviction walks gave up because they restarted their walk twice */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_STOPPED	1066
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_STOPPED	1068
 /*!
  * cache: eviction walks gave up because they saw too many pages and
  * found no candidates
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_NO_TARGETS	1067
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_NO_TARGETS	1069
 /*!
  * cache: eviction walks gave up because they saw too many pages and
  * found too few candidates
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_RATIO	1068
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_GAVE_UP_RATIO	1070
 /*! cache: eviction walks reached end of tree */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ENDED		1069
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ENDED		1071
 /*! cache: eviction walks started from root of tree */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK_FROM_ROOT	1070
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK_FROM_ROOT	1072
 /*! cache: eviction walks started from saved location in tree */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK_SAVED_POS	1071
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK_SAVED_POS	1073
 /*! cache: eviction worker thread active */
-#define	WT_STAT_CONN_CACHE_EVICTION_ACTIVE_WORKERS	1072
+#define	WT_STAT_CONN_CACHE_EVICTION_ACTIVE_WORKERS	1074
 /*! cache: eviction worker thread created */
-#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_CREATED	1073
+#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_CREATED	1075
 /*! cache: eviction worker thread evicting pages */
-#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_EVICTING	1074
+#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_EVICTING	1076
 /*! cache: eviction worker thread removed */
-#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_REMOVED	1075
+#define	WT_STAT_CONN_CACHE_EVICTION_WORKER_REMOVED	1077
 /*! cache: eviction worker thread stable number */
-#define	WT_STAT_CONN_CACHE_EVICTION_STABLE_STATE_WORKERS	1076
+#define	WT_STAT_CONN_CACHE_EVICTION_STABLE_STATE_WORKERS	1078
 /*!
  * cache: failed eviction of pages that exceeded the in-memory maximum
  * count
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL		1077
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL		1079
 /*!
  * cache: failed eviction of pages that exceeded the in-memory maximum
  * time (usecs)
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL_TIME	1078
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_FAIL_TIME	1080
 /*! cache: files with active eviction walks */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ACTIVE	1079
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_ACTIVE	1081
 /*! cache: files with new eviction walks started */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_STARTED	1080
+#define	WT_STAT_CONN_CACHE_EVICTION_WALKS_STARTED	1082
 /*! cache: force re-tuning of eviction workers once in a while */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_RETUNE	1081
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_RETUNE	1083
 /*! cache: hazard pointer blocked page eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_HAZARD		1082
+#define	WT_STAT_CONN_CACHE_EVICTION_HAZARD		1084
 /*! cache: hazard pointer check calls */
-#define	WT_STAT_CONN_CACHE_HAZARD_CHECKS		1083
+#define	WT_STAT_CONN_CACHE_HAZARD_CHECKS		1085
 /*! cache: hazard pointer check entries walked */
-#define	WT_STAT_CONN_CACHE_HAZARD_WALKS			1084
+#define	WT_STAT_CONN_CACHE_HAZARD_WALKS			1086
 /*! cache: hazard pointer maximum array length */
-#define	WT_STAT_CONN_CACHE_HAZARD_MAX			1085
+#define	WT_STAT_CONN_CACHE_HAZARD_MAX			1087
 /*! cache: in-memory page passed criteria to be split */
-#define	WT_STAT_CONN_CACHE_INMEM_SPLITTABLE		1086
+#define	WT_STAT_CONN_CACHE_INMEM_SPLITTABLE		1088
 /*! cache: in-memory page splits */
-#define	WT_STAT_CONN_CACHE_INMEM_SPLIT			1087
+#define	WT_STAT_CONN_CACHE_INMEM_SPLIT			1089
 /*! cache: internal pages evicted */
-#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL		1088
+#define	WT_STAT_CONN_CACHE_EVICTION_INTERNAL		1090
 /*! cache: internal pages split during eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL	1089
+#define	WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL	1091
 /*! cache: leaf pages split during eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF		1090
+#define	WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF		1092
 /*! cache: maximum bytes configured */
-#define	WT_STAT_CONN_CACHE_BYTES_MAX			1091
+#define	WT_STAT_CONN_CACHE_BYTES_MAX			1093
 /*! cache: maximum page size at eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE	1092
+#define	WT_STAT_CONN_CACHE_EVICTION_MAXIMUM_PAGE_SIZE	1094
 /*! cache: modified pages evicted */
-#define	WT_STAT_CONN_CACHE_EVICTION_DIRTY		1093
+#define	WT_STAT_CONN_CACHE_EVICTION_DIRTY		1095
 /*! cache: modified pages evicted by application threads */
-#define	WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY		1094
+#define	WT_STAT_CONN_CACHE_EVICTION_APP_DIRTY		1096
 /*! cache: operations timed out waiting for space in cache */
-#define	WT_STAT_CONN_CACHE_TIMED_OUT_OPS		1095
+#define	WT_STAT_CONN_CACHE_TIMED_OUT_OPS		1097
 /*! cache: overflow pages read into cache */
-#define	WT_STAT_CONN_CACHE_READ_OVERFLOW		1096
+#define	WT_STAT_CONN_CACHE_READ_OVERFLOW		1098
 /*! cache: page split during eviction deepened the tree */
-#define	WT_STAT_CONN_CACHE_EVICTION_DEEPEN		1097
+#define	WT_STAT_CONN_CACHE_EVICTION_DEEPEN		1099
 /*! cache: page written requiring cache overflow records */
-#define	WT_STAT_CONN_CACHE_WRITE_LOOKASIDE		1098
+#define	WT_STAT_CONN_CACHE_WRITE_LOOKASIDE		1100
 /*! cache: pages currently held in the cache */
-#define	WT_STAT_CONN_CACHE_PAGES_INUSE			1099
+#define	WT_STAT_CONN_CACHE_PAGES_INUSE			1101
 /*! cache: pages evicted because they exceeded the in-memory maximum count */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE		1100
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE		1102
 /*!
  * cache: pages evicted because they exceeded the in-memory maximum time
  * (usecs)
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_TIME		1101
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_TIME		1103
 /*! cache: pages evicted because they had chains of deleted items count */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE	1102
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE	1104
 /*!
  * cache: pages evicted because they had chains of deleted items time
  * (usecs)
  */
-#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE_TIME	1103
+#define	WT_STAT_CONN_CACHE_EVICTION_FORCE_DELETE_TIME	1105
 /*! cache: pages evicted by application threads */
-#define	WT_STAT_CONN_CACHE_EVICTION_APP			1104
+#define	WT_STAT_CONN_CACHE_EVICTION_APP			1106
 /*! cache: pages queued for eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED	1105
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED	1107
 /*! cache: pages queued for urgent eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT	1106
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_URGENT	1108
 /*! cache: pages queued for urgent eviction during walk */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST	1107
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_QUEUED_OLDEST	1109
 /*! cache: pages read into cache */
-#define	WT_STAT_CONN_CACHE_READ				1108
+#define	WT_STAT_CONN_CACHE_READ				1110
 /*! cache: pages read into cache after truncate */
-#define	WT_STAT_CONN_CACHE_READ_DELETED			1109
+#define	WT_STAT_CONN_CACHE_READ_DELETED			1111
 /*! cache: pages read into cache after truncate in prepare state */
-#define	WT_STAT_CONN_CACHE_READ_DELETED_PREPARED	1110
+#define	WT_STAT_CONN_CACHE_READ_DELETED_PREPARED	1112
 /*! cache: pages read into cache requiring cache overflow entries */
-#define	WT_STAT_CONN_CACHE_READ_LOOKASIDE		1111
+#define	WT_STAT_CONN_CACHE_READ_LOOKASIDE		1113
 /*! cache: pages read into cache requiring cache overflow for checkpoint */
-#define	WT_STAT_CONN_CACHE_READ_LOOKASIDE_CHECKPOINT	1112
+#define	WT_STAT_CONN_CACHE_READ_LOOKASIDE_CHECKPOINT	1114
 /*! cache: pages read into cache skipping older cache overflow entries */
-#define	WT_STAT_CONN_CACHE_READ_LOOKASIDE_SKIPPED	1113
+#define	WT_STAT_CONN_CACHE_READ_LOOKASIDE_SKIPPED	1115
 /*!
  * cache: pages read into cache with skipped cache overflow entries
  * needed later
  */
-#define	WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY		1114
+#define	WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY		1116
 /*!
  * cache: pages read into cache with skipped cache overflow entries
  * needed later by checkpoint
  */
-#define	WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY_CHECKPOINT	1115
+#define	WT_STAT_CONN_CACHE_READ_LOOKASIDE_DELAY_CHECKPOINT	1117
 /*! cache: pages requested from the cache */
-#define	WT_STAT_CONN_CACHE_PAGES_REQUESTED		1116
+#define	WT_STAT_CONN_CACHE_PAGES_REQUESTED		1118
 /*! cache: pages seen by eviction walk */
-#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN		1117
+#define	WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN		1119
 /*! cache: pages selected for eviction unable to be evicted */
-#define	WT_STAT_CONN_CACHE_EVICTION_FAIL		1118
+#define	WT_STAT_CONN_CACHE_EVICTION_FAIL		1120
 /*! cache: pages walked for eviction */
-#define	WT_STAT_CONN_CACHE_EVICTION_WALK		1119
+#define	WT_STAT_CONN_CACHE_EVICTION_WALK		1121
 /*! cache: pages written from cache */
-#define	WT_STAT_CONN_CACHE_WRITE			1120
+#define	WT_STAT_CONN_CACHE_WRITE			1122
 /*! cache: pages written requiring in-memory restoration */
-#define	WT_STAT_CONN_CACHE_WRITE_RESTORE		1121
+#define	WT_STAT_CONN_CACHE_WRITE_RESTORE		1123
 /*! cache: percentage overhead */
-#define	WT_STAT_CONN_CACHE_OVERHEAD			1122
+#define	WT_STAT_CONN_CACHE_OVERHEAD			1124
 /*! cache: tracked bytes belonging to internal pages in the cache */
-#define	WT_STAT_CONN_CACHE_BYTES_INTERNAL		1123
+#define	WT_STAT_CONN_CACHE_BYTES_INTERNAL		1125
 /*! cache: tracked bytes belonging to leaf pages in the cache */
-#define	WT_STAT_CONN_CACHE_BYTES_LEAF			1124
+#define	WT_STAT_CONN_CACHE_BYTES_LEAF			1126
 /*! cache: tracked dirty bytes in the cache */
-#define	WT_STAT_CONN_CACHE_BYTES_DIRTY			1125
+#define	WT_STAT_CONN_CACHE_BYTES_DIRTY			1127
 /*! cache: tracked dirty pages in the cache */
-#define	WT_STAT_CONN_CACHE_PAGES_DIRTY			1126
+#define	WT_STAT_CONN_CACHE_PAGES_DIRTY			1128
 /*! cache: unmodified pages evicted */
-#define	WT_STAT_CONN_CACHE_EVICTION_CLEAN		1127
+#define	WT_STAT_CONN_CACHE_EVICTION_CLEAN		1129
 /*! connection: auto adjusting condition resets */
-#define	WT_STAT_CONN_COND_AUTO_WAIT_RESET		1128
+#define	WT_STAT_CONN_COND_AUTO_WAIT_RESET		1130
 /*! connection: auto adjusting condition wait calls */
-#define	WT_STAT_CONN_COND_AUTO_WAIT			1129
+#define	WT_STAT_CONN_COND_AUTO_WAIT			1131
 /*! connection: detected system time went backwards */
-#define	WT_STAT_CONN_TIME_TRAVEL			1130
+#define	WT_STAT_CONN_TIME_TRAVEL			1132
 /*! connection: files currently open */
-#define	WT_STAT_CONN_FILE_OPEN				1131
+#define	WT_STAT_CONN_FILE_OPEN				1133
 /*! connection: memory allocations */
-#define	WT_STAT_CONN_MEMORY_ALLOCATION			1132
+#define	WT_STAT_CONN_MEMORY_ALLOCATION			1134
 /*! connection: memory frees */
-#define	WT_STAT_CONN_MEMORY_FREE			1133
+#define	WT_STAT_CONN_MEMORY_FREE			1135
 /*! connection: memory re-allocations */
-#define	WT_STAT_CONN_MEMORY_GROW			1134
+#define	WT_STAT_CONN_MEMORY_GROW			1136
 /*! connection: pthread mutex condition wait calls */
-#define	WT_STAT_CONN_COND_WAIT				1135
+#define	WT_STAT_CONN_COND_WAIT				1137
 /*! connection: pthread mutex shared lock read-lock calls */
-#define	WT_STAT_CONN_RWLOCK_READ			1136
+#define	WT_STAT_CONN_RWLOCK_READ			1138
 /*! connection: pthread mutex shared lock write-lock calls */
-#define	WT_STAT_CONN_RWLOCK_WRITE			1137
+#define	WT_STAT_CONN_RWLOCK_WRITE			1139
 /*! connection: total fsync I/Os */
-#define	WT_STAT_CONN_FSYNC_IO				1138
+#define	WT_STAT_CONN_FSYNC_IO				1140
 /*! connection: total read I/Os */
-#define	WT_STAT_CONN_READ_IO				1139
+#define	WT_STAT_CONN_READ_IO				1141
 /*! connection: total write I/Os */
-#define	WT_STAT_CONN_WRITE_IO				1140
+#define	WT_STAT_CONN_WRITE_IO				1142
 /*! cursor: cached cursor count */
-#define	WT_STAT_CONN_CURSOR_CACHED_COUNT		1141
+#define	WT_STAT_CONN_CURSOR_CACHED_COUNT		1143
 /*! cursor: cursor close calls that result in cache */
-#define	WT_STAT_CONN_CURSOR_CACHE			1142
+#define	WT_STAT_CONN_CURSOR_CACHE			1144
 /*! cursor: cursor create calls */
-#define	WT_STAT_CONN_CURSOR_CREATE			1143
+#define	WT_STAT_CONN_CURSOR_CREATE			1145
 /*! cursor: cursor insert calls */
-#define	WT_STAT_CONN_CURSOR_INSERT			1144
+#define	WT_STAT_CONN_CURSOR_INSERT			1146
 /*! cursor: cursor modify calls */
-#define	WT_STAT_CONN_CURSOR_MODIFY			1145
+#define	WT_STAT_CONN_CURSOR_MODIFY			1147
 /*! cursor: cursor next calls */
-#define	WT_STAT_CONN_CURSOR_NEXT			1146
+#define	WT_STAT_CONN_CURSOR_NEXT			1148
 /*! cursor: cursor operation restarted */
-#define	WT_STAT_CONN_CURSOR_RESTART			1147
+#define	WT_STAT_CONN_CURSOR_RESTART			1149
 /*! cursor: cursor prev calls */
-#define	WT_STAT_CONN_CURSOR_PREV			1148
+#define	WT_STAT_CONN_CURSOR_PREV			1150
 /*! cursor: cursor remove calls */
-#define	WT_STAT_CONN_CURSOR_REMOVE			1149
+#define	WT_STAT_CONN_CURSOR_REMOVE			1151
 /*! cursor: cursor reserve calls */
-#define	WT_STAT_CONN_CURSOR_RESERVE			1150
+#define	WT_STAT_CONN_CURSOR_RESERVE			1152
 /*! cursor: cursor reset calls */
-#define	WT_STAT_CONN_CURSOR_RESET			1151
+#define	WT_STAT_CONN_CURSOR_RESET			1153
 /*! cursor: cursor search calls */
-#define	WT_STAT_CONN_CURSOR_SEARCH			1152
+#define	WT_STAT_CONN_CURSOR_SEARCH			1154
 /*! cursor: cursor search near calls */
-#define	WT_STAT_CONN_CURSOR_SEARCH_NEAR			1153
+#define	WT_STAT_CONN_CURSOR_SEARCH_NEAR			1155
 /*! cursor: cursor sweep buckets */
-#define	WT_STAT_CONN_CURSOR_SWEEP_BUCKETS		1154
+#define	WT_STAT_CONN_CURSOR_SWEEP_BUCKETS		1156
 /*! cursor: cursor sweep cursors closed */
-#define	WT_STAT_CONN_CURSOR_SWEEP_CLOSED		1155
+#define	WT_STAT_CONN_CURSOR_SWEEP_CLOSED		1157
 /*! cursor: cursor sweep cursors examined */
-#define	WT_STAT_CONN_CURSOR_SWEEP_EXAMINED		1156
+#define	WT_STAT_CONN_CURSOR_SWEEP_EXAMINED		1158
 /*! cursor: cursor sweeps */
-#define	WT_STAT_CONN_CURSOR_SWEEP			1157
+#define	WT_STAT_CONN_CURSOR_SWEEP			1159
 /*! cursor: cursor update calls */
-#define	WT_STAT_CONN_CURSOR_UPDATE			1158
+#define	WT_STAT_CONN_CURSOR_UPDATE			1160
 /*! cursor: cursors reused from cache */
-#define	WT_STAT_CONN_CURSOR_REOPEN			1159
+#define	WT_STAT_CONN_CURSOR_REOPEN			1161
 /*! cursor: open cursor count */
-#define	WT_STAT_CONN_CURSOR_OPEN_COUNT			1160
+#define	WT_STAT_CONN_CURSOR_OPEN_COUNT			1162
 /*! cursor: truncate calls */
-#define	WT_STAT_CONN_CURSOR_TRUNCATE			1161
+#define	WT_STAT_CONN_CURSOR_TRUNCATE			1163
 /*! data-handle: connection data handles currently active */
-#define	WT_STAT_CONN_DH_CONN_HANDLE_COUNT		1162
+#define	WT_STAT_CONN_DH_CONN_HANDLE_COUNT		1164
 /*! data-handle: connection sweep candidate became referenced */
-#define	WT_STAT_CONN_DH_SWEEP_REF			1163
+#define	WT_STAT_CONN_DH_SWEEP_REF			1165
 /*! data-handle: connection sweep dhandles closed */
-#define	WT_STAT_CONN_DH_SWEEP_CLOSE			1164
+#define	WT_STAT_CONN_DH_SWEEP_CLOSE			1166
 /*! data-handle: connection sweep dhandles removed from hash list */
-#define	WT_STAT_CONN_DH_SWEEP_REMOVE			1165
+#define	WT_STAT_CONN_DH_SWEEP_REMOVE			1167
 /*! data-handle: connection sweep time-of-death sets */
-#define	WT_STAT_CONN_DH_SWEEP_TOD			1166
+#define	WT_STAT_CONN_DH_SWEEP_TOD			1168
 /*! data-handle: connection sweeps */
-#define	WT_STAT_CONN_DH_SWEEPS				1167
+#define	WT_STAT_CONN_DH_SWEEPS				1169
 /*! data-handle: session dhandles swept */
-#define	WT_STAT_CONN_DH_SESSION_HANDLES			1168
+#define	WT_STAT_CONN_DH_SESSION_HANDLES			1170
 /*! data-handle: session sweep attempts */
-#define	WT_STAT_CONN_DH_SESSION_SWEEPS			1169
+#define	WT_STAT_CONN_DH_SESSION_SWEEPS			1171
 /*! lock: checkpoint lock acquisitions */
-#define	WT_STAT_CONN_LOCK_CHECKPOINT_COUNT		1170
+#define	WT_STAT_CONN_LOCK_CHECKPOINT_COUNT		1172
 /*! lock: checkpoint lock application thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION	1171
+#define	WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION	1173
 /*! lock: checkpoint lock internal thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL	1172
+#define	WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL	1174
 /*!
  * lock: commit timestamp queue lock application thread time waiting
  * (usecs)
  */
-#define	WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_APPLICATION	1173
+#define	WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_APPLICATION	1175
 /*! lock: commit timestamp queue lock internal thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_INTERNAL	1174
+#define	WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WAIT_INTERNAL	1176
 /*! lock: commit timestamp queue read lock acquisitions */
-#define	WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_READ_COUNT	1175
+#define	WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_READ_COUNT	1177
 /*! lock: commit timestamp queue write lock acquisitions */
-#define	WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WRITE_COUNT	1176
+#define	WT_STAT_CONN_LOCK_COMMIT_TIMESTAMP_WRITE_COUNT	1178
 /*! lock: dhandle lock application thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION	1177
+#define	WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION	1179
 /*! lock: dhandle lock internal thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL		1178
+#define	WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL		1180
 /*! lock: dhandle read lock acquisitions */
-#define	WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT		1179
+#define	WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT		1181
 /*! lock: dhandle write lock acquisitions */
-#define	WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT		1180
+#define	WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT		1182
 /*! lock: metadata lock acquisitions */
-#define	WT_STAT_CONN_LOCK_METADATA_COUNT		1181
+#define	WT_STAT_CONN_LOCK_METADATA_COUNT		1183
 /*! lock: metadata lock application thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION	1182
+#define	WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION	1184
 /*! lock: metadata lock internal thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL	1183
+#define	WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL	1185
 /*!
  * lock: read timestamp queue lock application thread time waiting
  * (usecs)
  */
-#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION	1184
+#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_APPLICATION	1186
 /*! lock: read timestamp queue lock internal thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL	1185
+#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WAIT_INTERNAL	1187
 /*! lock: read timestamp queue read lock acquisitions */
-#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT	1186
+#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_READ_COUNT	1188
 /*! lock: read timestamp queue write lock acquisitions */
-#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT	1187
+#define	WT_STAT_CONN_LOCK_READ_TIMESTAMP_WRITE_COUNT	1189
 /*! lock: schema lock acquisitions */
-#define	WT_STAT_CONN_LOCK_SCHEMA_COUNT			1188
+#define	WT_STAT_CONN_LOCK_SCHEMA_COUNT			1190
 /*! lock: schema lock application thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION	1189
+#define	WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION	1191
 /*! lock: schema lock internal thread wait time (usecs) */
-#define	WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL		1190
+#define	WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL		1192
 /*!
  * lock: table lock application thread time waiting for the table lock
  * (usecs)
  */
-#define	WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION	1191
+#define	WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION	1193
 /*!
  * lock: table lock internal thread time waiting for the table lock
  * (usecs)
  */
-#define	WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL		1192
+#define	WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL		1194
 /*! lock: table read lock acquisitions */
-#define	WT_STAT_CONN_LOCK_TABLE_READ_COUNT		1193
+#define	WT_STAT_CONN_LOCK_TABLE_READ_COUNT		1195
 /*! lock: table write lock acquisitions */
-#define	WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT		1194
+#define	WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT		1196
 /*! lock: txn global lock application thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION	1195
+#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION	1197
 /*! lock: txn global lock internal thread time waiting (usecs) */
-#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL	1196
+#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL	1198
 /*! lock: txn global read lock acquisitions */
-#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT		1197
+#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT		1199
 /*! lock: txn global write lock acquisitions */
-#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT	1198
+#define	WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT	1200
 /*! log: busy returns attempting to switch slots */
-#define	WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY		1199
+#define	WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY		1201
 /*! log: force archive time sleeping (usecs) */
-#define	WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP		1200
+#define	WT_STAT_CONN_LOG_FORCE_ARCHIVE_SLEEP		1202
 /*! log: log bytes of payload data */
-#define	WT_STAT_CONN_LOG_BYTES_PAYLOAD			1201
+#define	WT_STAT_CONN_LOG_BYTES_PAYLOAD			1203
 /*! log: log bytes written */
-#define	WT_STAT_CONN_LOG_BYTES_WRITTEN			1202
+#define	WT_STAT_CONN_LOG_BYTES_WRITTEN			1204
 /*! log: log files manually zero-filled */
-#define	WT_STAT_CONN_LOG_ZERO_FILLS			1203
+#define	WT_STAT_CONN_LOG_ZERO_FILLS			1205
 /*! log: log flush operations */
-#define	WT_STAT_CONN_LOG_FLUSH				1204
+#define	WT_STAT_CONN_LOG_FLUSH				1206
 /*! log: log force write operations */
-#define	WT_STAT_CONN_LOG_FORCE_WRITE			1205
+#define	WT_STAT_CONN_LOG_FORCE_WRITE			1207
 /*! log: log force write operations skipped */
-#define	WT_STAT_CONN_LOG_FORCE_WRITE_SKIP		1206
+#define	WT_STAT_CONN_LOG_FORCE_WRITE_SKIP		1208
 /*! log: log records compressed */
-#define	WT_STAT_CONN_LOG_COMPRESS_WRITES		1207
+#define	WT_STAT_CONN_LOG_COMPRESS_WRITES		1209
 /*! log: log records not compressed */
-#define	WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS		1208
+#define	WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS		1210
 /*! log: log records too small to compress */
-#define	WT_STAT_CONN_LOG_COMPRESS_SMALL			1209
+#define	WT_STAT_CONN_LOG_COMPRESS_SMALL			1211
 /*! log: log release advances write LSN */
-#define	WT_STAT_CONN_LOG_RELEASE_WRITE_LSN		1210
+#define	WT_STAT_CONN_LOG_RELEASE_WRITE_LSN		1212
 /*! log: log scan operations */
-#define	WT_STAT_CONN_LOG_SCANS				1211
+#define	WT_STAT_CONN_LOG_SCANS				1213
 /*! log: log scan records requiring two reads */
-#define	WT_STAT_CONN_LOG_SCAN_REREADS			1212
+#define	WT_STAT_CONN_LOG_SCAN_REREADS			1214
 /*! log: log server thread advances write LSN */
-#define	WT_STAT_CONN_LOG_WRITE_LSN			1213
+#define	WT_STAT_CONN_LOG_WRITE_LSN			1215
 /*! log: log server thread write LSN walk skipped */
-#define	WT_STAT_CONN_LOG_WRITE_LSN_SKIP			1214
+#define	WT_STAT_CONN_LOG_WRITE_LSN_SKIP			1216
 /*! log: log sync operations */
-#define	WT_STAT_CONN_LOG_SYNC				1215
+#define	WT_STAT_CONN_LOG_SYNC				1217
 /*! log: log sync time duration (usecs) */
-#define	WT_STAT_CONN_LOG_SYNC_DURATION			1216
+#define	WT_STAT_CONN_LOG_SYNC_DURATION			1218
 /*! log: log sync_dir operations */
-#define	WT_STAT_CONN_LOG_SYNC_DIR			1217
+#define	WT_STAT_CONN_LOG_SYNC_DIR			1219
 /*! log: log sync_dir time duration (usecs) */
-#define	WT_STAT_CONN_LOG_SYNC_DIR_DURATION		1218
+#define	WT_STAT_CONN_LOG_SYNC_DIR_DURATION		1220
 /*! log: log write operations */
-#define	WT_STAT_CONN_LOG_WRITES				1219
+#define	WT_STAT_CONN_LOG_WRITES				1221
 /*! log: logging bytes consolidated */
-#define	WT_STAT_CONN_LOG_SLOT_CONSOLIDATED		1220
+#define	WT_STAT_CONN_LOG_SLOT_CONSOLIDATED		1222
 /*! log: maximum log file size */
-#define	WT_STAT_CONN_LOG_MAX_FILESIZE			1221
+#define	WT_STAT_CONN_LOG_MAX_FILESIZE			1223
 /*! log: number of pre-allocated log files to create */
-#define	WT_STAT_CONN_LOG_PREALLOC_MAX			1222
+#define	WT_STAT_CONN_LOG_PREALLOC_MAX			1224
 /*! log: pre-allocated log files not ready and missed */
-#define	WT_STAT_CONN_LOG_PREALLOC_MISSED		1223
+#define	WT_STAT_CONN_LOG_PREALLOC_MISSED		1225
 /*! log: pre-allocated log files prepared */
-#define	WT_STAT_CONN_LOG_PREALLOC_FILES			1224
+#define	WT_STAT_CONN_LOG_PREALLOC_FILES			1226
 /*! log: pre-allocated log files used */
-#define	WT_STAT_CONN_LOG_PREALLOC_USED			1225
+#define	WT_STAT_CONN_LOG_PREALLOC_USED			1227
 /*! log: records processed by log scan */
-#define	WT_STAT_CONN_LOG_SCAN_RECORDS			1226
+#define	WT_STAT_CONN_LOG_SCAN_RECORDS			1228
 /*! log: slot close lost race */
-#define	WT_STAT_CONN_LOG_SLOT_CLOSE_RACE		1227
+#define	WT_STAT_CONN_LOG_SLOT_CLOSE_RACE		1229
 /*! log: slot close unbuffered waits */
-#define	WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF		1228
+#define	WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF		1230
 /*! log: slot closures */
-#define	WT_STAT_CONN_LOG_SLOT_CLOSES			1229
+#define	WT_STAT_CONN_LOG_SLOT_CLOSES			1231
 /*! log: slot join atomic update races */
-#define	WT_STAT_CONN_LOG_SLOT_RACES			1230
+#define	WT_STAT_CONN_LOG_SLOT_RACES			1232
 /*! log: slot join calls atomic updates raced */
-#define	WT_STAT_CONN_LOG_SLOT_YIELD_RACE		1231
+#define	WT_STAT_CONN_LOG_SLOT_YIELD_RACE		1233
 /*! log: slot join calls did not yield */
-#define	WT_STAT_CONN_LOG_SLOT_IMMEDIATE			1232
+#define	WT_STAT_CONN_LOG_SLOT_IMMEDIATE			1234
 /*! log: slot join calls found active slot closed */
-#define	WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE		1233
+#define	WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE		1235
 /*! log: slot join calls slept */
-#define	WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP		1234
+#define	WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP		1236
 /*! log: slot join calls yielded */
-#define	WT_STAT_CONN_LOG_SLOT_YIELD			1235
+#define	WT_STAT_CONN_LOG_SLOT_YIELD			1237
 /*! log: slot join found active slot closed */
-#define	WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED		1236
+#define	WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED		1238
 /*! log: slot joins yield time (usecs) */
-#define	WT_STAT_CONN_LOG_SLOT_YIELD_DURATION		1237
+#define	WT_STAT_CONN_LOG_SLOT_YIELD_DURATION		1239
 /*! log: slot transitions unable to find free slot */
-#define	WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS		1238
+#define	WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS		1240
 /*! log: slot unbuffered writes */
-#define	WT_STAT_CONN_LOG_SLOT_UNBUFFERED		1239
+#define	WT_STAT_CONN_LOG_SLOT_UNBUFFERED		1241
 /*! log: total in-memory size of compressed records */
-#define	WT_STAT_CONN_LOG_COMPRESS_MEM			1240
+#define	WT_STAT_CONN_LOG_COMPRESS_MEM			1242
 /*! log: total log buffer size */
-#define	WT_STAT_CONN_LOG_BUFFER_SIZE			1241
+#define	WT_STAT_CONN_LOG_BUFFER_SIZE			1243
 /*! log: total size of compressed records */
-#define	WT_STAT_CONN_LOG_COMPRESS_LEN			1242
+#define	WT_STAT_CONN_LOG_COMPRESS_LEN			1244
 /*! log: written slots coalesced */
-#define	WT_STAT_CONN_LOG_SLOT_COALESCED			1243
+#define	WT_STAT_CONN_LOG_SLOT_COALESCED			1245
 /*! log: yields waiting for previous log file close */
-#define	WT_STAT_CONN_LOG_CLOSE_YIELDS			1244
+#define	WT_STAT_CONN_LOG_CLOSE_YIELDS			1246
 /*! perf: file system read latency histogram (bucket 1) - 10-49ms */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50	1245
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50	1247
 /*! perf: file system read latency histogram (bucket 2) - 50-99ms */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100	1246
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100	1248
 /*! perf: file system read latency histogram (bucket 3) - 100-249ms */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250	1247
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250	1249
 /*! perf: file system read latency histogram (bucket 4) - 250-499ms */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500	1248
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500	1250
 /*! perf: file system read latency histogram (bucket 5) - 500-999ms */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000	1249
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000	1251
 /*! perf: file system read latency histogram (bucket 6) - 1000ms+ */
-#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000	1250
+#define	WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000	1252
 /*! perf: file system write latency histogram (bucket 1) - 10-49ms */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50	1251
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50	1253
 /*! perf: file system write latency histogram (bucket 2) - 50-99ms */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100	1252
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100	1254
 /*! perf: file system write latency histogram (bucket 3) - 100-249ms */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250	1253
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250	1255
 /*! perf: file system write latency histogram (bucket 4) - 250-499ms */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500	1254
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500	1256
 /*! perf: file system write latency histogram (bucket 5) - 500-999ms */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000	1255
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000	1257
 /*! perf: file system write latency histogram (bucket 6) - 1000ms+ */
-#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000	1256
+#define	WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000	1258
 /*! perf: operation read latency histogram (bucket 1) - 100-249us */
-#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250	1257
+#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250	1259
 /*! perf: operation read latency histogram (bucket 2) - 250-499us */
-#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500	1258
+#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500	1260
 /*! perf: operation read latency histogram (bucket 3) - 500-999us */
-#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000	1259
+#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000	1261
 /*! perf: operation read latency histogram (bucket 4) - 1000-9999us */
-#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000	1260
+#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000	1262
 /*! perf: operation read latency histogram (bucket 5) - 10000us+ */
-#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000	1261
+#define	WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000	1263
 /*! perf: operation write latency histogram (bucket 1) - 100-249us */
-#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250	1262
+#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250	1264
 /*! perf: operation write latency histogram (bucket 2) - 250-499us */
-#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500	1263
+#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500	1265
 /*! perf: operation write latency histogram (bucket 3) - 500-999us */
-#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000	1264
+#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000	1266
 /*! perf: operation write latency histogram (bucket 4) - 1000-9999us */
-#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000	1265
+#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000	1267
 /*! perf: operation write latency histogram (bucket 5) - 10000us+ */
-#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000	1266
+#define	WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000	1268
 /*! reconciliation: fast-path pages deleted */
-#define	WT_STAT_CONN_REC_PAGE_DELETE_FAST		1267
+#define	WT_STAT_CONN_REC_PAGE_DELETE_FAST		1269
 /*! reconciliation: page reconciliation calls */
-#define	WT_STAT_CONN_REC_PAGES				1268
+#define	WT_STAT_CONN_REC_PAGES				1270
 /*! reconciliation: page reconciliation calls for eviction */
-#define	WT_STAT_CONN_REC_PAGES_EVICTION			1269
+#define	WT_STAT_CONN_REC_PAGES_EVICTION			1271
 /*! reconciliation: pages deleted */
-#define	WT_STAT_CONN_REC_PAGE_DELETE			1270
+#define	WT_STAT_CONN_REC_PAGE_DELETE			1272
 /*! reconciliation: split bytes currently awaiting free */
-#define	WT_STAT_CONN_REC_SPLIT_STASHED_BYTES		1271
+#define	WT_STAT_CONN_REC_SPLIT_STASHED_BYTES		1273
 /*! reconciliation: split objects currently awaiting free */
-#define	WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS		1272
+#define	WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS		1274
 /*! session: open session count */
-#define	WT_STAT_CONN_SESSION_OPEN			1273
+#define	WT_STAT_CONN_SESSION_OPEN			1275
 /*! session: session query timestamp calls */
-#define	WT_STAT_CONN_SESSION_QUERY_TS			1274
+#define	WT_STAT_CONN_SESSION_QUERY_TS			1276
 /*! session: table alter failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL		1275
+#define	WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL		1277
 /*! session: table alter successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS	1276
+#define	WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS	1278
 /*! session: table alter unchanged and skipped */
-#define	WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP		1277
+#define	WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP		1279
 /*! session: table compact failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL		1278
+#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL		1280
 /*! session: table compact successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS	1279
+#define	WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS	1281
 /*! session: table create failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL		1280
+#define	WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL		1282
 /*! session: table create successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS	1281
+#define	WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS	1283
 /*! session: table drop failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_DROP_FAIL		1282
+#define	WT_STAT_CONN_SESSION_TABLE_DROP_FAIL		1284
 /*! session: table drop successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS		1283
+#define	WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS		1285
 /*! session: table rebalance failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_REBALANCE_FAIL	1284
+#define	WT_STAT_CONN_SESSION_TABLE_REBALANCE_FAIL	1286
 /*! session: table rebalance successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_REBALANCE_SUCCESS	1285
+#define	WT_STAT_CONN_SESSION_TABLE_REBALANCE_SUCCESS	1287
 /*! session: table rename failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL		1286
+#define	WT_STAT_CONN_SESSION_TABLE_RENAME_FAIL		1288
 /*! session: table rename successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS	1287
+#define	WT_STAT_CONN_SESSION_TABLE_RENAME_SUCCESS	1289
 /*! session: table salvage failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL		1288
+#define	WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL		1290
 /*! session: table salvage successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS	1289
+#define	WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS	1291
 /*! session: table truncate failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL	1290
+#define	WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL	1292
 /*! session: table truncate successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS	1291
+#define	WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS	1293
 /*! session: table verify failed calls */
-#define	WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL		1292
+#define	WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL		1294
 /*! session: table verify successful calls */
-#define	WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS	1293
+#define	WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS	1295
 /*! thread-state: active filesystem fsync calls */
-#define	WT_STAT_CONN_THREAD_FSYNC_ACTIVE		1294
+#define	WT_STAT_CONN_THREAD_FSYNC_ACTIVE		1296
 /*! thread-state: active filesystem read calls */
-#define	WT_STAT_CONN_THREAD_READ_ACTIVE			1295
+#define	WT_STAT_CONN_THREAD_READ_ACTIVE			1297
 /*! thread-state: active filesystem write calls */
-#define	WT_STAT_CONN_THREAD_WRITE_ACTIVE		1296
+#define	WT_STAT_CONN_THREAD_WRITE_ACTIVE		1298
 /*! thread-yield: application thread time evicting (usecs) */
-#define	WT_STAT_CONN_APPLICATION_EVICT_TIME		1297
+#define	WT_STAT_CONN_APPLICATION_EVICT_TIME		1299
 /*! thread-yield: application thread time waiting for cache (usecs) */
-#define	WT_STAT_CONN_APPLICATION_CACHE_TIME		1298
+#define	WT_STAT_CONN_APPLICATION_CACHE_TIME		1300
 /*!
  * thread-yield: connection close blocked waiting for transaction state
  * stabilization
  */
-#define	WT_STAT_CONN_TXN_RELEASE_BLOCKED		1299
+#define	WT_STAT_CONN_TXN_RELEASE_BLOCKED		1301
 /*! thread-yield: connection close yielded for lsm manager shutdown */
-#define	WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM		1300
+#define	WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM		1302
 /*! thread-yield: data handle lock yielded */
-#define	WT_STAT_CONN_DHANDLE_LOCK_BLOCKED		1301
+#define	WT_STAT_CONN_DHANDLE_LOCK_BLOCKED		1303
 /*!
  * thread-yield: get reference for page index and slot time sleeping
  * (usecs)
  */
-#define	WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED	1302
+#define	WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED	1304
 /*! thread-yield: log server sync yielded for log write */
-#define	WT_STAT_CONN_LOG_SERVER_SYNC_BLOCKED		1303
+#define	WT_STAT_CONN_LOG_SERVER_SYNC_BLOCKED		1305
 /*! thread-yield: page access yielded due to prepare state change */
-#define	WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE	1304
+#define	WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE	1306
 /*! thread-yield: page acquire busy blocked */
-#define	WT_STAT_CONN_PAGE_BUSY_BLOCKED			1305
+#define	WT_STAT_CONN_PAGE_BUSY_BLOCKED			1307
 /*! thread-yield: page acquire eviction blocked */
-#define	WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED	1306
+#define	WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED	1308
 /*! thread-yield: page acquire locked blocked */
-#define	WT_STAT_CONN_PAGE_LOCKED_BLOCKED		1307
+#define	WT_STAT_CONN_PAGE_LOCKED_BLOCKED		1309
 /*! thread-yield: page acquire read blocked */
-#define	WT_STAT_CONN_PAGE_READ_BLOCKED			1308
+#define	WT_STAT_CONN_PAGE_READ_BLOCKED			1310
 /*! thread-yield: page acquire time sleeping (usecs) */
-#define	WT_STAT_CONN_PAGE_SLEEP				1309
+#define	WT_STAT_CONN_PAGE_SLEEP				1311
 /*!
  * thread-yield: page delete rollback time sleeping for state change
  * (usecs)
  */
-#define	WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED		1310
+#define	WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED		1312
 /*! thread-yield: page reconciliation yielded due to child modification */
-#define	WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE		1311
+#define	WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE		1313
 /*! transaction: commit timestamp queue entries walked */
-#define	WT_STAT_CONN_TXN_COMMIT_QUEUE_WALKED		1312
+#define	WT_STAT_CONN_TXN_COMMIT_QUEUE_WALKED		1314
 /*! transaction: commit timestamp queue insert to empty */
-#define	WT_STAT_CONN_TXN_COMMIT_QUEUE_EMPTY		1313
+#define	WT_STAT_CONN_TXN_COMMIT_QUEUE_EMPTY		1315
 /*! transaction: commit timestamp queue inserts to head */
-#define	WT_STAT_CONN_TXN_COMMIT_QUEUE_HEAD		1314
+#define	WT_STAT_CONN_TXN_COMMIT_QUEUE_HEAD		1316
 /*! transaction: commit timestamp queue inserts total */
-#define	WT_STAT_CONN_TXN_COMMIT_QUEUE_INSERTS		1315
+#define	WT_STAT_CONN_TXN_COMMIT_QUEUE_INSERTS		1317
 /*! transaction: commit timestamp queue length */
-#define	WT_STAT_CONN_TXN_COMMIT_QUEUE_LEN		1316
+#define	WT_STAT_CONN_TXN_COMMIT_QUEUE_LEN		1318
 /*! transaction: number of named snapshots created */
-#define	WT_STAT_CONN_TXN_SNAPSHOTS_CREATED		1317
+#define	WT_STAT_CONN_TXN_SNAPSHOTS_CREATED		1319
 /*! transaction: number of named snapshots dropped */
-#define	WT_STAT_CONN_TXN_SNAPSHOTS_DROPPED		1318
+#define	WT_STAT_CONN_TXN_SNAPSHOTS_DROPPED		1320
 /*! transaction: prepared transactions */
-#define	WT_STAT_CONN_TXN_PREPARE			1319
+#define	WT_STAT_CONN_TXN_PREPARE			1321
 /*! transaction: prepared transactions committed */
-#define	WT_STAT_CONN_TXN_PREPARE_COMMIT			1320
+#define	WT_STAT_CONN_TXN_PREPARE_COMMIT			1322
 /*! transaction: prepared transactions currently active */
-#define	WT_STAT_CONN_TXN_PREPARE_ACTIVE			1321
+#define	WT_STAT_CONN_TXN_PREPARE_ACTIVE			1323
 /*! transaction: prepared transactions rolled back */
-#define	WT_STAT_CONN_TXN_PREPARE_ROLLBACK		1322
+#define	WT_STAT_CONN_TXN_PREPARE_ROLLBACK		1324
 /*! transaction: query timestamp calls */
-#define	WT_STAT_CONN_TXN_QUERY_TS			1323
+#define	WT_STAT_CONN_TXN_QUERY_TS			1325
 /*! transaction: read timestamp queue entries walked */
-#define	WT_STAT_CONN_TXN_READ_QUEUE_WALKED		1324
+#define	WT_STAT_CONN_TXN_READ_QUEUE_WALKED		1326
 /*! transaction: read timestamp queue insert to empty */
-#define	WT_STAT_CONN_TXN_READ_QUEUE_EMPTY		1325
+#define	WT_STAT_CONN_TXN_READ_QUEUE_EMPTY		1327
 /*! transaction: read timestamp queue inserts to head */
-#define	WT_STAT_CONN_TXN_READ_QUEUE_HEAD		1326
+#define	WT_STAT_CONN_TXN_READ_QUEUE_HEAD		1328
 /*! transaction: read timestamp queue inserts total */
-#define	WT_STAT_CONN_TXN_READ_QUEUE_INSERTS		1327
+#define	WT_STAT_CONN_TXN_READ_QUEUE_INSERTS		1329
 /*! transaction: read timestamp queue length */
-#define	WT_STAT_CONN_TXN_READ_QUEUE_LEN			1328
+#define	WT_STAT_CONN_TXN_READ_QUEUE_LEN			1330
 /*! transaction: rollback to stable calls */
-#define	WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE		1329
+#define	WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE		1331
 /*! transaction: rollback to stable updates aborted */
-#define	WT_STAT_CONN_TXN_ROLLBACK_UPD_ABORTED		1330
+#define	WT_STAT_CONN_TXN_ROLLBACK_UPD_ABORTED		1332
 /*! transaction: rollback to stable updates removed from cache overflow */
-#define	WT_STAT_CONN_TXN_ROLLBACK_LAS_REMOVED		1331
+#define	WT_STAT_CONN_TXN_ROLLBACK_LAS_REMOVED		1333
 /*! transaction: set timestamp calls */
-#define	WT_STAT_CONN_TXN_SET_TS				1332
+#define	WT_STAT_CONN_TXN_SET_TS				1334
 /*! transaction: set timestamp commit calls */
-#define	WT_STAT_CONN_TXN_SET_TS_COMMIT			1333
+#define	WT_STAT_CONN_TXN_SET_TS_COMMIT			1335
 /*! transaction: set timestamp commit updates */
-#define	WT_STAT_CONN_TXN_SET_TS_COMMIT_UPD		1334
+#define	WT_STAT_CONN_TXN_SET_TS_COMMIT_UPD		1336
 /*! transaction: set timestamp oldest calls */
-#define	WT_STAT_CONN_TXN_SET_TS_OLDEST			1335
+#define	WT_STAT_CONN_TXN_SET_TS_OLDEST			1337
 /*! transaction: set timestamp oldest updates */
-#define	WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD		1336
+#define	WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD		1338
 /*! transaction: set timestamp stable calls */
-#define	WT_STAT_CONN_TXN_SET_TS_STABLE			1337
+#define	WT_STAT_CONN_TXN_SET_TS_STABLE			1339
 /*! transaction: set timestamp stable updates */
-#define	WT_STAT_CONN_TXN_SET_TS_STABLE_UPD		1338
+#define	WT_STAT_CONN_TXN_SET_TS_STABLE_UPD		1340
 /*! transaction: transaction begins */
-#define	WT_STAT_CONN_TXN_BEGIN				1339
+#define	WT_STAT_CONN_TXN_BEGIN				1341
 /*! transaction: transaction checkpoint currently running */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_RUNNING		1340
+#define	WT_STAT_CONN_TXN_CHECKPOINT_RUNNING		1342
 /*! transaction: transaction checkpoint generation */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_GENERATION		1341
+#define	WT_STAT_CONN_TXN_CHECKPOINT_GENERATION		1343
 /*! transaction: transaction checkpoint max time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX		1342
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MAX		1344
 /*! transaction: transaction checkpoint min time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN		1343
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_MIN		1345
 /*! transaction: transaction checkpoint most recent time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT		1344
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_RECENT		1346
 /*! transaction: transaction checkpoint scrub dirty target */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET	1345
+#define	WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TARGET	1347
 /*! transaction: transaction checkpoint scrub time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME		1346
+#define	WT_STAT_CONN_TXN_CHECKPOINT_SCRUB_TIME		1348
 /*! transaction: transaction checkpoint total time (msecs) */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL		1347
+#define	WT_STAT_CONN_TXN_CHECKPOINT_TIME_TOTAL		1349
 /*! transaction: transaction checkpoints */
-#define	WT_STAT_CONN_TXN_CHECKPOINT			1348
+#define	WT_STAT_CONN_TXN_CHECKPOINT			1350
 /*!
  * transaction: transaction checkpoints skipped because database was
  * clean
  */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED		1349
+#define	WT_STAT_CONN_TXN_CHECKPOINT_SKIPPED		1351
 /*! transaction: transaction failures due to cache overflow */
-#define	WT_STAT_CONN_TXN_FAIL_CACHE			1350
+#define	WT_STAT_CONN_TXN_FAIL_CACHE			1352
 /*!
  * transaction: transaction fsync calls for checkpoint after allocating
  * the transaction ID
  */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST		1351
+#define	WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST		1353
 /*!
  * transaction: transaction fsync duration for checkpoint after
  * allocating the transaction ID (usecs)
  */
-#define	WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION	1352
+#define	WT_STAT_CONN_TXN_CHECKPOINT_FSYNC_POST_DURATION	1354
 /*! transaction: transaction range of IDs currently pinned */
-#define	WT_STAT_CONN_TXN_PINNED_RANGE			1353
+#define	WT_STAT_CONN_TXN_PINNED_RANGE			1355
 /*! transaction: transaction range of IDs currently pinned by a checkpoint */
-#define	WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE	1354
+#define	WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE	1356
 /*!
  * transaction: transaction range of IDs currently pinned by named
  * snapshots
  */
-#define	WT_STAT_CONN_TXN_PINNED_SNAPSHOT_RANGE		1355
+#define	WT_STAT_CONN_TXN_PINNED_SNAPSHOT_RANGE		1357
 /*! transaction: transaction range of timestamps currently pinned */
-#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP		1356
+#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP		1358
 /*! transaction: transaction range of timestamps pinned by a checkpoint */
-#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT	1357
+#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT	1359
 /*!
  * transaction: transaction range of timestamps pinned by the oldest
  * timestamp
  */
-#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST	1358
+#define	WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST	1360
 /*! transaction: transaction sync calls */
-#define	WT_STAT_CONN_TXN_SYNC				1359
+#define	WT_STAT_CONN_TXN_SYNC				1361
 /*! transaction: transactions committed */
-#define	WT_STAT_CONN_TXN_COMMIT				1360
+#define	WT_STAT_CONN_TXN_COMMIT				1362
 /*! transaction: transactions rolled back */
-#define	WT_STAT_CONN_TXN_ROLLBACK			1361
+#define	WT_STAT_CONN_TXN_ROLLBACK			1363
 /*! transaction: update conflicts */
-#define	WT_STAT_CONN_TXN_UPDATE_CONFLICT		1362
+#define	WT_STAT_CONN_TXN_UPDATE_CONFLICT		1364
 
 /*!
  * @}
diff --git a/src/third_party/wiredtiger/src/reconcile/rec_write.c b/src/third_party/wiredtiger/src/reconcile/rec_write.c
index f67342720f3..37b0581af6b 100644
--- a/src/third_party/wiredtiger/src/reconcile/rec_write.c
+++ b/src/third_party/wiredtiger/src/reconcile/rec_write.c
@@ -1299,7 +1299,7 @@ __rec_txn_read(WT_SESSION_IMPL *session, WT_RECONCILE *r,
 	wt_timestamp_t *timestampp;
 	size_t upd_memsize;
 	uint64_t max_txn, txnid;
-	bool all_visible, prepared, skipped_birthmark, uncommitted;
+	bool all_visible, prepared, skipped_birthmark, uncommitted, upd_saved;
 
 #ifdef HAVE_TIMESTAMPS
 	WT_UPDATE *first_ts_upd;
@@ -1314,7 +1314,7 @@ __rec_txn_read(WT_SESSION_IMPL *session, WT_RECONCILE *r,
 	first_txn_upd = NULL;
 	upd_memsize = 0;
 	max_txn = WT_TXN_NONE;
-	prepared = skipped_birthmark = uncommitted = false;
+	prepared = skipped_birthmark = uncommitted = upd_saved = false;
 
 	/*
 	 * If called with a WT_INSERT item, use its WT_UPDATE list (which must
@@ -1557,6 +1557,7 @@ __rec_txn_read(WT_SESSION_IMPL *session, WT_RECONCILE *r,
 	 * unresolved updates, move the entire update list.
 	 */
 	WT_RET(__rec_update_save(session, r, ins, ripcip, *updp, upd_memsize));
+	upd_saved = true;
 	if (upd_savedp != NULL)
 		*upd_savedp = true;
 
@@ -1602,18 +1603,15 @@ check_original_value:
 
 	/*
 	 * Returning an update means the original on-page value might be lost,
-	 * and that's a problem if there's a reader that needs it. There are
-	 * several cases:
-	 * - any update from a modify operation (because the modify has to be
-	 *   applied to a stable update, not the new on-page update),
-	 * - any lookaside table eviction (because the backing disk image is
-	 *   rewritten),
-	 * - or any reconciliation of a backing overflow record that will be
-	 *   physically removed once it's no longer needed.
-	 */
-	if (*updp != NULL && (!WT_UPDATE_DATA_VALUE(*updp) ||
-	    F_ISSET(r, WT_REC_LOOKASIDE) || (vpack != NULL &&
-	    vpack->ovfl && vpack->raw != WT_CELL_VALUE_OVFL_RM)))
+	 * and that's a problem if there's a reader that needs it.  This call
+	 * makes a copy of the on-page value and if there is a birthmark in the
+	 * update list, replaces it.  We do that any time there are saved
+	 * updates and during reconciliation of a backing overflow record that
+	 * will be physically removed once it's no longer needed.
+	 */
+	if (*updp != NULL && (upd_saved ||
+	    (vpack != NULL && vpack->ovfl &&
+	    vpack->raw != WT_CELL_VALUE_OVFL_RM)))
 		WT_RET(
 		    __rec_append_orig_value(session, page, first_upd, vpack));
 
diff --git a/src/third_party/wiredtiger/src/support/stat.c b/src/third_party/wiredtiger/src/support/stat.c
index ebfa481eb3b..b04b9776f7f 100644
--- a/src/third_party/wiredtiger/src/support/stat.c
+++ b/src/third_party/wiredtiger/src/support/stat.c
@@ -788,6 +788,8 @@ static const char * const __stats_connection_desc[] = {
 	"cache: cache overflow score",
 	"cache: cache overflow table entries",
 	"cache: cache overflow table insert calls",
+	"cache: cache overflow table max on-disk size",
+	"cache: cache overflow table on-disk size",
 	"cache: cache overflow table remove calls",
 	"cache: checkpoint blocked page eviction",
 	"cache: eviction calls to get a page",
@@ -1193,6 +1195,8 @@ __wt_stat_connection_clear_single(WT_CONNECTION_STATS *stats)
 		/* not clearing cache_lookaside_score */
 		/* not clearing cache_lookaside_entries */
 	stats->cache_lookaside_insert = 0;
+		/* not clearing cache_lookaside_ondisk_max */
+		/* not clearing cache_lookaside_ondisk */
 	stats->cache_lookaside_remove = 0;
 	stats->cache_eviction_checkpoint = 0;
 	stats->cache_eviction_get_ref = 0;
@@ -1586,6 +1590,10 @@ __wt_stat_connection_aggregate(
 	    WT_STAT_READ(from, cache_lookaside_entries);
 	to->cache_lookaside_insert +=
 	    WT_STAT_READ(from, cache_lookaside_insert);
+	to->cache_lookaside_ondisk_max +=
+	    WT_STAT_READ(from, cache_lookaside_ondisk_max);
+	to->cache_lookaside_ondisk +=
+	    WT_STAT_READ(from, cache_lookaside_ondisk);
 	to->cache_lookaside_remove +=
 	    WT_STAT_READ(from, cache_lookaside_remove);
 	to->cache_eviction_checkpoint +=
diff --git a/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c b/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c
index 6baaffa532a..8f4f4de1573 100644
--- a/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c
+++ b/src/third_party/wiredtiger/src/txn/txn_rollback_to_stable.c
@@ -250,19 +250,47 @@ __txn_abort_newer_updates(
 	 * dirty.  Otherwise, the history we need could be swept from the
 	 * lookaside table before the page is read because the lookaside sweep
 	 * code has no way to tell that the page image is invalid.
+	 *
+	 * So, if there is lookaside history for a page, first check if the
+	 * history needs to be rolled back make sure that history is loaded
+	 * into cache.  That is, if skew_newest is true, so the disk image
+	 * potentially contained unstable updates, and the history is more
+	 * recent than the rollback timestamp.
+	 *
+	 * Also, we have separately discarded any lookaside history more recent
+	 * than the rollback timestamp.  For page_las structures in cache,
+	 * reset any future timestamps back to the rollback timestamp.  This
+	 * allows those structures to be discarded once the rollback timestamp
+	 * is stable (crucially for tests, they can be discarded if the
+	 * connection is closed right after a rollback_to_stable call).
 	 */
 	local_read = false;
 	read_flags = WT_READ_WONT_NEED;
-	if (ref->page_las != NULL && ref->page_las->skew_newest &&
-	    __wt_timestamp_cmp(rollback_timestamp,
-	    &ref->page_las->unstable_timestamp) < 0) {
-		/* Make sure get back a page with history, not limbo page */
-		WT_ASSERT(session,
-		    !F_ISSET(&session->txn, WT_TXN_HAS_SNAPSHOT));
-		WT_RET(__wt_page_in(session, ref, read_flags));
-		WT_ASSERT(session, ref->state != WT_REF_LIMBO &&
-		    ref->page != NULL && __wt_page_is_modified(ref->page));
-		local_read = true;
+	if (ref->page_las != NULL) {
+		if (ref->page_las->skew_newest &&
+		    __wt_timestamp_cmp(rollback_timestamp,
+		    &ref->page_las->unstable_timestamp) < 0) {
+			/*
+			 * Make sure we get back a page with history, not a
+			 * limbo page.
+			 */
+			WT_ASSERT(session,
+			    !F_ISSET(&session->txn, WT_TXN_HAS_SNAPSHOT));
+			WT_RET(__wt_page_in(session, ref, read_flags));
+			WT_ASSERT(session, ref->state != WT_REF_LIMBO &&
+			    ref->page != NULL &&
+			    __wt_page_is_modified(ref->page));
+			local_read = true;
+		}
+		if (__wt_timestamp_cmp(&ref->page_las->max_timestamp,
+		    rollback_timestamp) > 0)
+			ref->page_las->max_timestamp = *rollback_timestamp;
+		if (__wt_timestamp_cmp(&ref->page_las->unstable_timestamp,
+		    rollback_timestamp) > 0)
+			ref->page_las->unstable_timestamp = *rollback_timestamp;
+		if (__wt_timestamp_cmp(&ref->page_las->unstable_timestamp,
+		    rollback_timestamp) > 0)
+			ref->page_las->unstable_timestamp = *rollback_timestamp;
 	}
 
 	/* Review deleted page saved to the ref */
diff --git a/src/third_party/wiredtiger/test/csuite/Makefile.am b/src/third_party/wiredtiger/test/csuite/Makefile.am
index 7c13eb4e696..a041b564f64 100644
--- a/src/third_party/wiredtiger/test/csuite/Makefile.am
+++ b/src/third_party/wiredtiger/test/csuite/Makefile.am
@@ -127,6 +127,10 @@ test_wt4333_handle_locks_SOURCES = wt4333_handle_locks/main.c
 noinst_PROGRAMS += test_wt4333_handle_locks
 all_TESTS += test_wt4333_handle_locks
 
+test_wt4803_cache_overflow_abort_SOURCES = wt4803_cache_overflow_abort/main.c
+noinst_PROGRAMS += test_wt4803_cache_overflow_abort
+all_TESTS += test_wt4803_cache_overflow_abort
+
 # Run this during a "make check" smoke test.
 TESTS = $(all_TESTS)
 LOG_COMPILER = $(TEST_WRAPPER)
diff --git a/src/third_party/wiredtiger/test/csuite/wt3338_partial_update/main.c b/src/third_party/wiredtiger/test/csuite/wt3338_partial_update/main.c
index fb246f87da1..e73f63cdd8a 100644
--- a/src/third_party/wiredtiger/test/csuite/wt3338_partial_update/main.c
+++ b/src/third_party/wiredtiger/test/csuite/wt3338_partial_update/main.c
@@ -32,13 +32,13 @@
  * Test case description: Smoke-test the partial update construction.
  */
 
-#define	DEBUG		0
+#define	DEBUG			0
 
-#define	DATASIZE	1024
+#define	DATASIZE		1024
+#define	MAX_MODIFY_ENTRIES	37		/* Maximum modify vectors */
 
-#define	MAX_MODIFY_ENTRIES	37
-static WT_MODIFY entries[MAX_MODIFY_ENTRIES];		/* Entries vector */
-static int nentries;					/* Entries count */
+static WT_MODIFY entries[1000];			/* Entries vector */
+static int nentries;				/* Entries count */
 
 /*
  * The replacement bytes array is 2x the maximum replacement string so we can
@@ -213,11 +213,11 @@ slow_apply_api(WT_ITEM *orig)
 }
 
 /*
- * diff --
- *	Diff the two results.
+ * compare --
+ *	Compare two results.
  */
 static void
-diff(WT_ITEM *local, WT_ITEM *library)
+compare(WT_ITEM *local, WT_ITEM *library)
 {
 #if DEBUG
 	if (local->size != library->size ||
@@ -232,42 +232,92 @@ diff(WT_ITEM *local, WT_ITEM *library)
 	    local->data, library->data, local->size) == 0);
 }
 
+static int nruns = 10000;
+
 /*
- * modify_init --
- *	Initialize the buffers to a known state.
+ * modify_run
+ *	Run some tests:
+ *	1. Create an initial value, a copy and a fake cursor to use with the
+ *	WiredTiger routines. Generate a set of modify vectors and apply them to
+ *	the item stored in the cursor using the modify apply API. Also apply the
+ *	same modify vector to one of the copies using a helper routine written
+ *	to test the modify API. The final value generated with the modify API
+ *	and the helper routine should match.
+ *
+ *	2. Use the initial value and the modified value generated above as
+ *	inputs into the calculate-modify API to generate a set of modify
+ *	vectors. Apply this generated vector to the initial value using the
+ *	modify apply API to obtain a final value. The final value generated
+ *	should match the modified value that was used as input to the
+ *	calculate-modify API.
  */
 static void
-modify_init(WT_ITEM *local, WT_ITEM *library)
+modify_run(bool verbose)
 {
+	WT_CURSOR *cursor, _cursor;
+	WT_DECL_RET;
+	WT_ITEM *localA, _localA, *localB, _localB;
 	size_t len;
+	int i, j;
 
-	len = (size_t)(__wt_random(&rnd) % MAX_REPL_BYTES);
-	testutil_check(__wt_buf_set(NULL, local, modify_repl, len));
-	testutil_check(__wt_buf_set(NULL, library, modify_repl, len));
-}
+	/* Initialize the RNG. */
+	__wt_random_init_seed(NULL, &rnd);
 
-static int nruns = 1000;
+	/* Set up replacement information. */
+	modify_repl_init();
 
-/*
- * modify_run
- *	Run some tests.
- */
-static void
-modify_run(WT_CURSOR *cursor, WT_ITEM *local, bool verbose)
-{
-	int i, j;
+	/* We need three WT_ITEMs, one of them part of a fake cursor. */
+	localA = &_localA;
+	memset(&_localA, 0, sizeof(_localA));
+	localB = &_localB;
+	memset(&_localB, 0, sizeof(_localB));
+	cursor = &_cursor;
+	memset(&_cursor, 0, sizeof(_cursor));
+	cursor->value_format = "u";
 
 	for (i = 0; i < nruns; ++i) {
-		modify_init(local, &cursor->value);
+		/* Create an initial value. */
+		len = (size_t)(__wt_random(&rnd) % MAX_REPL_BYTES);
+		testutil_check(__wt_buf_set(NULL, localA, modify_repl, len));
 
 		for (j = 0; j < 1000; ++j) {
+			/* Copy the current value into the second item. */
+			testutil_check(__wt_buf_set(
+			    NULL, localB, localA->data, localA->size));
+
+			/*
+			 * Create a random set of modify vectors, run the
+			 * underlying library modification function, then
+			 * compare the result against our implementation
+			 * of modify.
+			 */
 			modify_build();
-
-			slow_apply_api(local);
+			testutil_check(__wt_buf_set(
+			    NULL, &cursor->value, localA->data, localA->size));
 			testutil_check(__wt_modify_apply_api(
 			    NULL, cursor, entries, nentries));
-
-			diff(local, &cursor->value);
+			slow_apply_api(localA);
+			compare(localA, &cursor->value);
+
+			/*
+			 * Call the WiredTiger function to build a modification
+			 * vector for the change, and repeat the test using the
+			 * WiredTiger modification vector, then compare results
+			 * against our implementation of modify.
+			 */
+			nentries = WT_ELEMENTS(entries);
+			ret = wiredtiger_calc_modify(NULL,
+			    localB, localA,
+			    WT_MAX(localB->size, localA->size) + 100,
+			    entries, &nentries);
+			if (ret == WT_NOTFOUND)
+				continue;
+			testutil_check(ret);
+			testutil_check(__wt_buf_set(
+			    NULL, &cursor->value, localB->data, localB->size));
+			testutil_check(__wt_modify_apply_api(
+			    NULL, cursor, entries, nentries));
+			compare(localA, &cursor->value);
 		}
 		if (verbose) {
 			printf("%d (%d%%)\r", i, (i * 100) / nruns);
@@ -275,18 +325,17 @@ modify_run(WT_CURSOR *cursor, WT_ITEM *local, bool verbose)
 		}
 	}
 	if (verbose)
-		printf("\n");
+		printf("%d (100%%)\n", i);
+
+	__wt_buf_free(NULL, localA);
+	__wt_buf_free(NULL, localB);
+	__wt_buf_free(NULL, &cursor->value);
 }
 
 int
 main(int argc, char *argv[])
 {
 	TEST_OPTS *opts, _opts;
-	WT_CURSOR *cursor, _cursor;
-	WT_ITEM *local, _local;
-
-	if (testutil_is_flag_set("TESTUTIL_ENABLE_LONG_TESTS"))
-		nruns = 10000;
 
 	opts = &_opts;
 	memset(opts, 0, sizeof(*opts));
@@ -295,24 +344,8 @@ main(int argc, char *argv[])
 	testutil_check(
 	    wiredtiger_open(opts->home, NULL, "create", &opts->conn));
 
-	/* Initialize the RNG. */
-	__wt_random_init_seed(NULL, &rnd);
-
-	/* Set up replacement information. */
-	modify_repl_init();
-
-	/* We need two items, one of them hooked into fake cursor. */
-	local = &_local;
-	memset(&_local, 0, sizeof(_local));
-	cursor = &_cursor;
-	memset(&_cursor, 0, sizeof(_cursor));
-	cursor->value_format = "u";
-
 	/* Run the test. */
-	modify_run(cursor, local, opts->verbose);
-
-	__wt_buf_free(NULL, local);
-	__wt_buf_free(NULL, &cursor->value);
+	modify_run(opts->verbose);
 
 	testutil_cleanup(opts);
 	return (EXIT_SUCCESS);
diff --git a/src/third_party/wiredtiger/test/csuite/wt4803_cache_overflow_abort/main.c b/src/third_party/wiredtiger/test/csuite/wt4803_cache_overflow_abort/main.c
new file mode 100644
index 00000000000..7d9b0baf132
--- /dev/null
+++ b/src/third_party/wiredtiger/test/csuite/wt4803_cache_overflow_abort/main.c
@@ -0,0 +1,239 @@
+/*-
+ * Public Domain 2014-2019 MongoDB, Inc.
+ * Public Domain 2008-2014 WiredTiger, Inc.
+ *
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "test_util.h"
+
+#include <signal.h>
+#include <sys/wait.h>
+
+/*
+ * JIRA ticket reference: WT-4803
+ * Test case description: This test is checking the functionality of the
+ * lookaside file_max configuration. When the size of the lookaside file exceeds
+ * this value, we expect to panic.
+ * Failure mode: If we receive a panic in the test cases we weren't expecting to
+ * and vice versa.
+ */
+
+#define	NUM_KEYS	2000
+
+/*
+ * This is a global flag that should be set before running test_las_workload.
+ * It lets the child process know whether it should be expecting a panic or not
+ * so that it can adjust its exit code as needed.
+ */
+static bool expect_panic;
+
+static int
+handle_message(WT_EVENT_HANDLER *handler,
+    WT_SESSION *session, int error, const char *message)
+{
+	WT_UNUSED(handler);
+	WT_UNUSED(session);
+
+	(void)fprintf(
+	    stderr, "%s: %s\n", message, session->strerror(session, error));
+
+	if (error == WT_PANIC &&
+	    strstr(message, "exceeds maximum size") != NULL) {
+		fprintf(stderr, "Got cache overflow error (expect_panic=%s)\n",
+		    expect_panic ? "true" : "false");
+
+		/*
+		 * If we're expecting a panic, exit with zero to indicate to the
+		 * parent that this test was successful.
+		 *
+		 * If not, don't intercept. We'll naturally exit with non-zero
+		 * if we're terminating due to panic.
+		 */
+		if (expect_panic)
+			exit(EXIT_SUCCESS);
+	}
+
+	return (0);
+}
+
+static WT_EVENT_HANDLER event_handler = {
+	handle_message,
+	NULL,
+	NULL,
+	NULL
+};
+
+static void
+las_workload(TEST_OPTS *opts, const char *las_file_max)
+{
+	WT_CURSOR *cursor;
+	WT_SESSION *other_session, *session;
+	int i;
+	char buf[WT_MEGABYTE], open_config[128];
+
+	testutil_check(__wt_snprintf(open_config, sizeof(open_config),
+	    "create,cache_size=50MB,cache_overflow=(file_max=%s)",
+	    las_file_max));
+
+	testutil_check(wiredtiger_open(
+	    opts->home, &event_handler, open_config, &opts->conn));
+	testutil_check(
+	    opts->conn->open_session(opts->conn, NULL, NULL, &session));
+	testutil_check(
+	    session->create(session, opts->uri, "key_format=i,value_format=S"));
+	testutil_check(
+	    session->open_cursor(session, opts->uri, NULL, NULL, &cursor));
+
+	memset(buf, 0xA, WT_MEGABYTE);
+	buf[WT_MEGABYTE - 1] = '\0';
+
+	/* Populate the table. */
+	for (i = 0; i < NUM_KEYS; ++i) {
+		cursor->set_key(cursor, i);
+		cursor->set_value(cursor, buf);
+		testutil_check(cursor->insert(cursor));
+	}
+
+	/*
+	 * Open a snapshot isolation transaction in another session. This forces
+	 * the cache to retain all previous values. Then update all keys with a
+	 * new value in the original session while keeping that snapshot
+	 * transaction open. With the large value buffer, small cache and lots
+	 * of keys, this will force a lot of lookaside usage.
+	 *
+	 * When the file_max setting is small, the maximum size should easily be
+	 * reached and we should panic. When the maximum size is large or not
+	 * set, then we should succeed.
+	 */
+	testutil_check(
+	    opts->conn->open_session(opts->conn, NULL, NULL, &other_session));
+	testutil_check(other_session->begin_transaction(
+	    other_session, "isolation=snapshot"));
+
+	memset(buf, 0xB, WT_MEGABYTE);
+	buf[WT_MEGABYTE - 1] = '\0';
+
+	for (i = 0; i < NUM_KEYS; ++i) {
+		cursor->set_key(cursor, i);
+		cursor->set_value(cursor, buf);
+		testutil_check(cursor->update(cursor));
+	}
+
+	/*
+	 * Cleanup.
+	 * We do not get here when the file_max size is small because we will
+	 * have already hit the maximum and exited. This code only executes on
+	 * the successful path.
+	 */
+	testutil_check(
+	    other_session->rollback_transaction(other_session, NULL));
+	testutil_check(other_session->close(other_session, NULL));
+
+	testutil_check(cursor->close(cursor));
+	testutil_check(session->close(session, NULL));
+}
+
+static int
+test_las_workload(TEST_OPTS *opts, const char *las_file_max)
+{
+	pid_t pid;
+	int status;
+
+	/*
+	 * We're going to run this workload for different configurations of
+	 * file_max. So clean out the work directory each time.
+	 */
+	testutil_make_work_dir(opts->home);
+
+	/*
+	 * Since it's possible that the workload will panic and abort, we will
+	 * fork the process and execute the workload in the child process.
+	 *
+	 * This way, we can safely check the exit code of the child process and
+	 * confirm that it is what we expected.
+	 */
+	pid = fork();
+	if (pid < 0)
+		/* Failed fork. */
+		testutil_die(errno, "fork");
+	else if (pid == 0) {
+		/* Child process from here. */
+		las_workload(opts, las_file_max);
+
+		/*
+		 * If we're expecting a panic during the workload, we shouldn't
+		 * get to this point. Exit with non-zero to indicate to parent
+		 * that we should fail this test.
+		 */
+		fprintf(stderr,
+		    "Successfully completed workload (expect_panic=%s)\n",
+		    expect_panic ? "true" : "false");
+
+		if (expect_panic)
+			exit(EXIT_FAILURE);
+		else
+			exit(EXIT_SUCCESS);
+	}
+
+	/* Parent process from here. */
+	if (waitpid(pid, &status, 0) == -1)
+		testutil_die(errno, "waitpid");
+
+	return (status);
+}
+
+int
+main(int argc, char **argv)
+{
+	TEST_OPTS opts;
+
+	memset(&opts, 0x0, sizeof(opts));
+	testutil_check(testutil_parse_opts(argc, argv, &opts));
+
+	/*
+	 * The lookaside is unbounded.
+	 * We don't expect any failure since we can use as much as needed.
+	 */
+	expect_panic = false;
+	testutil_check(test_las_workload(&opts, "0"));
+
+	/*
+	 * The lookaside is limited to 5GB.
+	 * This is more than enough for this workload so we don't expect any
+	 * failure.
+	 */
+	expect_panic = false;
+	testutil_check(test_las_workload(&opts, "5GB"));
+
+	/*
+	 * The lookaside is limited to 100MB.
+	 * This is insufficient for this workload so we're expecting a failure.
+	 */
+	expect_panic = true;
+	testutil_check(test_las_workload(&opts, "100MB"));
+
+	testutil_cleanup(&opts);
+
+	return (0);
+}
diff --git a/src/third_party/wiredtiger/test/suite/test_calc_modify.py b/src/third_party/wiredtiger/test/suite/test_calc_modify.py
new file mode 100644
index 00000000000..a52096a3125
--- /dev/null
+++ b/src/third_party/wiredtiger/test/suite/test_calc_modify.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+#
+# Public Domain 2014-2018 MongoDB, Inc.
+# Public Domain 2008-2014 WiredTiger, Inc.
+#
+# This is free and unencumbered software released into the public domain.
+#
+# Anyone is free to copy, modify, publish, use, compile, sell, or
+# distribute this software, either in source code form or as a compiled
+# binary, for any purpose, commercial or non-commercial, and by any
+# means.
+#
+# In jurisdictions that recognize copyright laws, the author or authors
+# of this software dedicate any and all copyright interest in the
+# software to the public domain. We make this dedication for the benefit
+# of the public at large and to the detriment of our heirs and
+# successors. We intend this dedication to be an overt act of
+# relinquishment in perpetuity of all present and future rights to this
+# software under copyright law.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+
+import random, string
+import wiredtiger, wttest
+
+r = random.Random(42) # Make things repeatable
+
+# test_calc_modify.py
+#   Test the wiredtiger_calc_modify API
+#
+# Try many combinations of:
+# - data size
+# - data randomness ('a' * N, repeated patterns, uniform random)
+# - number and type of modifications (add, remove, replace)
+# - space between the modifications
+#
+# Check that wiredtiger_calc_modify finds a set of modifies when the edit
+# difference is under the specified limits, and that applying those
+# modifications produces the expected result.  If the edit difference is
+# larger than the limits, it okay for the call to fail.
+class test_calc_modify(wttest.WiredTigerTestCase):
+    uri = 'table:test_calc_modify'
+
+    # operation types
+    ADD = 1
+    REMOVE = 2
+    REPLACE = 3
+
+    def mkstring(self, size, repeat_size=1):
+        pattern = ''.join(r.choice(string.ascii_letters + string.digits) for _ in xrange(repeat_size))
+        return (pattern * ((size + repeat_size - 1) / repeat_size))[:size]
+
+    def one_test(self, c, k, oldsz, repeatsz, nmod, maxdiff):
+        oldv = self.mkstring(oldsz, repeatsz)
+
+        offsets = sorted(r.sample(xrange(oldsz), nmod))
+        modsizes = sorted(r.sample(xrange(maxdiff), nmod + 1))
+        lengths = [modsizes[i+1] - modsizes[i] for i in xrange(nmod)]
+        modtypes = [r.choice((self.ADD, self.REMOVE, self.REPLACE)) for _ in xrange(nmod)]
+
+        self.pr("offsets: %s" % offsets)
+        self.pr("modsizes: %s" % modsizes)
+        self.pr("lengths: %s" % lengths)
+        self.pr("modtypes: %s" % modtypes)
+
+        orig = oldv
+        newv = ''
+        for i in xrange(nmod):
+            if i > 0 and offsets[i] - offsets[i - 1] < maxdiff:
+                continue
+            newv += orig[:offsets[i]]
+            orig = orig[offsets[i]:]
+            if modtypes[i] == self.ADD:
+                newv += self.mkstring(lengths[i], r.randint(1, lengths[i]))
+            elif modtypes[i] == self.REMOVE:
+                orig = orig[lengths[i]:]
+            elif modtypes[i] == self.REPLACE:
+                newv += self.mkstring(lengths[i], r.randint(1, lengths[i]))
+                orig = orig[lengths[i]:]
+        newv += orig
+
+        self.pr("oldv: %s" % oldv)
+        self.pr("newv: %s" % newv)
+        try:
+            mods = wiredtiger.wiredtiger_calc_modify(None, oldv, newv, max(maxdiff, nmod * 64), nmod)
+            self.pr("calculated mods: %s" % mods)
+        except wiredtiger.WiredTigerError:
+            # When the data repeats, the algorithm can register the "wrong" repeated sequence.  Retry...
+            mods = wiredtiger.wiredtiger_calc_modify(None, oldv, newv, nmod * (64 + repeatsz), nmod)
+            self.pr("calculated mods (round 2): %s" % mods)
+        self.assertIsNotNone(mods)
+
+        c[k] = oldv
+        self.session.begin_transaction('isolation=snapshot')
+        c.set_key(k)
+        c.modify(mods)
+        self.session.commit_transaction()
+        self.assertEqual(c[k], newv)
+
+    def test_calc_modify(self):
+        self.session.create(self.uri, 'key_format=i,value_format=u')
+        c = self.session.open_cursor(self.uri)
+        for k in xrange(1000):
+            size = r.randint(1000, 10000)
+            repeats = r.randint(1, size)
+            nmods = r.randint(1, 10)
+            maxdiff = r.randint(64, size / 10)
+            self.pr("size %s, repeats %s, nmods %s, maxdiff %s" % (size, repeats, nmods, maxdiff))
+            self.one_test(c, k, size, repeats, nmods, maxdiff)
+
+if __name__ == '__main__':
+    wttest.run()
diff --git a/src/third_party/wiredtiger/test/suite/test_compat01.py b/src/third_party/wiredtiger/test/suite/test_compat01.py
index f9131331640..e9bb23f00dd 100644
--- a/src/third_party/wiredtiger/test/suite/test_compat01.py
+++ b/src/third_party/wiredtiger/test/suite/test_compat01.py
@@ -189,12 +189,20 @@ class test_reconfig_fail(wttest.WiredTigerTestCase):
         ds = SimpleDataSet(self, uri, 100, key_format='S')
         ds.populate()
 
+        # Reconfigure to an older version.
+        compat_str = 'compatibility=(release="2.6")'
+        self.conn.reconfigure(compat_str)
+
         self.session.begin_transaction("isolation=snapshot")
         c = self.session.open_cursor(uri, None)
         c.set_key(ds.key(20))
         c.set_value("abcde")
         self.assertEquals(c.update(), 0)
 
+        # Make sure we can reconfigure unrelated things while downgraded
+        # and we have an active transaction.
+        self.conn.reconfigure("cache_size=100M")
+
         compat_str = 'compatibility=(release="3.0.0")'
         msg = '/system must be quiescent/'
         self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
diff --git a/src/third_party/wiredtiger/test/suite/test_las04.py b/src/third_party/wiredtiger/test/suite/test_las04.py
new file mode 100644
index 00000000000..9d35d3c17f3
--- /dev/null
+++ b/src/third_party/wiredtiger/test/suite/test_las04.py
@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+#
+# Public Domain 2014-2019 MongoDB, Inc.
+# Public Domain 2008-2014 WiredTiger, Inc.
+#
+# This is free and unencumbered software released into the public domain.
+#
+# Anyone is free to copy, modify, publish, use, compile, sell, or
+# distribute this software, either in source code form or as a compiled
+# binary, for any purpose, commercial or non-commercial, and by any
+# means.
+#
+# In jurisdictions that recognize copyright laws, the author or authors
+# of this software dedicate any and all copyright interest in the
+# software to the public domain. We make this dedication for the benefit
+# of the public at large and to the detriment of our heirs and
+# successors. We intend this dedication to be an overt act of
+# relinquishment in perpetuity of all present and future rights to this
+# software under copyright law.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+# test_las04.py
+#   Test file_max configuration and reconfiguration for the lookaside table.
+#
+
+import wiredtiger, wttest
+from wtscenario import make_scenarios
+
+# Taken from src/include/misc.h.
+WT_MB = 1048576
+
+class test_las04(wttest.WiredTigerTestCase):
+    uri = 'table:las_04'
+    in_memory_values = [
+        ('false', dict(in_memory=False)),
+        ('none', dict(in_memory=None)),
+        ('true', dict(in_memory=True))
+    ]
+    init_file_max_values = [
+        ('default', dict(init_file_max=None, init_stat_val=0)),
+        ('non-zero', dict(init_file_max='100MB', init_stat_val=(WT_MB * 100))),
+        ('zero', dict(init_file_max='0', init_stat_val=0))
+    ]
+    reconfig_file_max_values = [
+        ('non-zero', dict(reconfig_file_max='100MB',
+                          reconfig_stat_val=(WT_MB * 100))),
+        ('too-low', dict(reconfig_file_max='99MB', reconfig_stat_val=None)),
+        ('zero', dict(reconfig_file_max='0', reconfig_stat_val=0))
+    ]
+    scenarios = make_scenarios(init_file_max_values, reconfig_file_max_values,
+                               in_memory_values)
+
+    def conn_config(self):
+        config = 'statistics=(fast)'
+        if self.init_file_max is not None:
+            config += ',cache_overflow=(file_max={})'.format(self.init_file_max)
+        if self.in_memory is not None:
+            config += ',in_memory=' + ('true' if self.in_memory else 'false')
+        return config
+
+    def get_stat(self, stat):
+        stat_cursor = self.session.open_cursor('statistics:')
+        val = stat_cursor[stat][2]
+        stat_cursor.close()
+        return val
+
+    def test_las(self):
+        self.session.create(self.uri, 'key_format=S,value_format=S')
+
+        if self.in_memory:
+            # For in-memory configurations, we simply ignore any lookaside
+            # related configuration.
+            self.assertEqual(
+                self.get_stat(wiredtiger.stat.conn.cache_lookaside_ondisk_max),
+                0)
+        else:
+            self.assertEqual(
+                self.get_stat(wiredtiger.stat.conn.cache_lookaside_ondisk_max),
+                self.init_stat_val)
+
+        reconfigure = lambda: self.conn.reconfigure(
+            'cache_overflow=(file_max={})'.format(self.reconfig_file_max))
+
+        # We expect an error when the statistic value is None because the value
+        # is out of range.
+        if self.reconfig_stat_val is None:
+            self.assertRaisesWithMessage(
+                wiredtiger.WiredTigerError, reconfigure, '/below minimum/')
+            return
+
+        reconfigure()
+
+        if self.in_memory:
+            self.assertEqual(
+                self.get_stat(wiredtiger.stat.conn.cache_lookaside_ondisk_max),
+                0)
+        else:
+            self.assertEqual(
+                self.get_stat(wiredtiger.stat.conn.cache_lookaside_ondisk_max),
+                self.reconfig_stat_val)
+
+if __name__ == '__main__':
+    wttest.run()