@ohos-ports/lmdb 2.5.3 → 2.8.5-beta.0

package/write.js

@@ -1,9 +1,9 @@
-import { getAddress, write, compress } from './native.js';
+import { getAddress, getBufferAddress, write, compress, lmdbError } from './native.js';
 import { when } from './util/when.js';
 var backpressureArray;
 
 const WAITING_OPERATION = 0x2000000;
-const BACKPRESSURE_THRESHOLD = 100000;
+const BACKPRESSURE_THRESHOLD = 300000;
 const TXN_DELIMITER = 0x8000000;
 const TXN_COMMITTED = 0x10000000;
 const TXN_FLUSHED = 0x20000000;
@@ -13,13 +13,15 @@ const REUSE_BUFFER_MODE = 512;
 const RESET_BUFFER_MODE = 1024;
 const NO_RESOLVE = 16;
 const HAS_TXN = 8;
+const CONDITIONAL_VERSION_LESS_THAN = 0x800;
+const CONDITIONAL_ALLOW_NOTFOUND = 0x800;
 
 const SYNC_PROMISE_SUCCESS = Promise.resolve(true);
 const SYNC_PROMISE_FAIL = Promise.resolve(false);
 SYNC_PROMISE_SUCCESS.isSync = true;
 SYNC_PROMISE_FAIL.isSync = true;
 const PROMISE_SUCCESS = Promise.resolve(true);
-export const ABORT = {};
+export const ABORT = 4.452694326329068e-106; // random/unguessable numbers, which work across module/versions and native
 export const IF_EXISTS = 3.542694326329068e-103;
 const CALLBACK_THREW = {};
 const LocalSharedArrayBuffer = typeof Deno != 'undefined' ? ArrayBuffer : SharedArrayBuffer; // Deno can't handle SharedArrayBuffer as an FFI argument due to https://github.com/denoland/deno/issues/12678
@@ -32,18 +34,23 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 	eventTurnBatching, txnStartThreshold, batchStartThreshold, overlappingSync, commitDelay, separateFlushed, maxFlushDelay }) {
 	//  stands for write instructions
 	var dynamicBytes;
-	function allocateInstructionBuffer() {
+	function allocateInstructionBuffer(lastPosition) {
 		// Must use a shared buffer on older node in order to use Atomics, and it is also more correct since we are 
 		// indeed accessing and modifying it from another thread (in C). However, Deno can't handle it for
 		// FFI so aliased above
 		let buffer = new LocalSharedArrayBuffer(WRITE_BUFFER_SIZE);
+		let lastBytes = dynamicBytes;
 		dynamicBytes = new ByteArray(buffer);
 		let uint32 = dynamicBytes.uint32 = new Uint32Array(buffer, 0, WRITE_BUFFER_SIZE >> 2);
-		uint32[0] = 0;
+		uint32[2] = 0;
 		dynamicBytes.float64 = new Float64Array(buffer, 0, WRITE_BUFFER_SIZE >> 3);
-		buffer.address = getAddress(dynamicBytes);
+		buffer.address = getBufferAddress(dynamicBytes);
 		uint32.address = buffer.address + uint32.byteOffset;
-		dynamicBytes.position = 0;
+		dynamicBytes.position = 1; // we start at position 1 to save space for writing the txn id before the txn delimiter
+		if (lastPosition) {
+			lastBytes.float64[lastPosition + 1] = dynamicBytes.uint32.address + (dynamicBytes.position << 3);
+			lastBytes.uint32[lastPosition << 1] = 3; // pointer instruction
+		}
 		return dynamicBytes;
 	}
 	var newBufferThreshold = (WRITE_BUFFER_SIZE - maxKeySize - 64) >> 3; // need to reserve more room if we do inline values
@@ -53,7 +60,7 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 	var committed;
 	var abortedNonChildTransactionWarn;
 	var nextTxnCallbacks = [];
-	var commitPromise, flushPromise, flushResolvers = [];
+	var commitPromise, flushPromise, flushResolvers = [], batchFlushResolvers = [];
 	commitDelay = commitDelay || 0;
 	eventTurnBatching = eventTurnBatching === false ? false : true;
 	var enqueuedCommit;
@@ -63,22 +70,24 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 	var batchDepth = 0;
 	var lastWritePromise;
 	var writeBatchStart, outstandingBatchCount, lastSyncTxnFlush, lastFlushTimeout, lastFlushCallback;
+	var hasUnresolvedTxns;
 	txnStartThreshold = txnStartThreshold || 5;
 	batchStartThreshold = batchStartThreshold || 1000;
 	maxFlushDelay = maxFlushDelay || 500;
 
 	allocateInstructionBuffer();
-	dynamicBytes.uint32[0] = TXN_DELIMITER | TXN_COMMITTED | TXN_FLUSHED;
-	var txnResolution, lastQueuedResolution, nextResolution = {
-		uint32: dynamicBytes.uint32, flagPosition: 0, flag: 0, valueBuffer: null, next: null, meta: null };
+	dynamicBytes.uint32[2] = TXN_DELIMITER | TXN_COMMITTED | TXN_FLUSHED;
+	var txnResolution, nextResolution = {
+		uint32: dynamicBytes.uint32, flagPosition: 2, flag: 0, valueBuffer: null, next: null, meta: null };
 	var uncommittedResolution = {
-		uint32: null, flagPosition: 0, flag: 0, valueBuffer: null, next: nextResolution, meta: null };
+		uint32: null, flagPosition: 2, flag: 0, valueBuffer: null, next: nextResolution, meta: null };
 	var unwrittenResolution = nextResolution;
 	var lastPromisedResolution = uncommittedResolution;
+	var lastQueuedResolution = uncommittedResolution;
 	function writeInstructions(flags, store, key, value, version, ifVersion) {
 		let writeStatus;
 		let targetBytes, position, encoder;
-		let valueBuffer, valueSize, valueBufferStart;
+		let valueSize, valueBuffer, valueBufferStart;
 		if (flags & 2) {
 			// encode first in case we have to write a shared structure
 			encoder = store.encoder;
@@ -115,7 +124,11 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 				enqueuedEventTurnBatch = queueTask(() => {
 					try {
 						for (let i = 0, l = beforeCommitCallbacks.length; i < l; i++) {
-							beforeCommitCallbacks[i]();
+							try {
+								beforeCommitCallbacks[i]();
+							} catch(error) {
+								console.error('In beforecommit callback', error);
+							}
 						}
 					} catch(error) {
 						console.error(error);
@@ -149,7 +162,7 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 			try {
 				endPosition = store.writeKey(key, targetBytes, keyStartPosition);
 				if (!(keyStartPosition < endPosition) && (flags & 0xf) != 12)
-					throw new Error('Invalid key or zero length key is not allowed in LMDB')
+					throw new Error('Invalid key or zero length key is not allowed in LMDB ' + key)
 			} catch(error) {
 				targetBytes.fill(0, keyStartPosition);
 				if (error.name == 'RangeError')
@@ -168,14 +181,14 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 				if (valueBufferStart > -1) { // if we have buffers with start/end position
 					// record pointer to value buffer
 					float64[position] = (valueBuffer.address ||
-						(valueBuffer.address = getAddress(valueBuffer))) + valueBufferStart;
+						(valueBuffer.address = getAddress(valueBuffer.buffer))) + valueBufferStart;
 					mustCompress = valueBuffer[valueBufferStart] >= 250; // this is the compression indicator, so we must compress
 				} else {
 					let valueArrayBuffer = valueBuffer.buffer;
 					// record pointer to value buffer
 					let address = (valueArrayBuffer.address ||
 						(valueBuffer.length === 0 ? 0 : // externally allocated buffers of zero-length with the same non-null-pointer can crash node, #161
-						(valueArrayBuffer.address = (getAddress(valueBuffer) - valueBuffer.byteOffset))))
+						valueArrayBuffer.address = getAddress(valueArrayBuffer)))
 							+ valueBuffer.byteOffset;
 					if (address <= 0 && valueBuffer.length > 0)
 						console.error('Supplied buffer had an invalid address', address);
@@ -222,10 +235,8 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 		if (position > newBufferThreshold) {
 			// make new buffer and make pointer to it
 			let lastPosition = position;
-			targetBytes = allocateInstructionBuffer();
+			targetBytes = allocateInstructionBuffer(position);
 			position = targetBytes.position;
-			float64[lastPosition + 1] = targetBytes.uint32.address + position;
-			uint32[lastPosition << 1] = 3; // pointer instruction
 			nextUint32 = targetBytes.uint32;
 		} else
 			nextUint32 = uint32;
@@ -239,6 +250,8 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 			next: null,
 			meta: null,
 		};
+		lastQueuedResolution = resolution;
+
 		let writtenBatchDepth = batchDepth;
 
 		return (callback) => {
@@ -266,13 +279,25 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 			if (writeStatus & TXN_DELIMITER) {
 				commitPromise = null; // TODO: Don't reset these if this comes from the batch start operation on an event turn batch
 				flushPromise = null;
+				flushResolvers = [];
 				queueCommitResolution(resolution);
 				if (!startAddress) {
 					startAddress = uint32.address + (flagPosition << 2);
 				}
 			}
-			if (!flushPromise && overlappingSync)
-				flushPromise = new Promise(resolve => flushResolvers.push(resolve));
+			if (!writtenBatchDepth && batchFlushResolvers.length > 0) {
+				flushResolvers.push(...batchFlushResolvers);
+				batchFlushResolvers = [];
+			}
+			if (!flushPromise && overlappingSync) {
+				flushPromise = new Promise(resolve => {
+					if (writtenBatchDepth) {
+						batchFlushResolvers.push(resolve);
+					} else {
+						flushResolvers.push(resolve);
+					}
+				});
+			}
 			if (writeStatus & WAITING_OPERATION) { // write thread is waiting
 				write(env.address, 0);
 			}
@@ -301,7 +326,6 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 				};
 			}
 			resolution.valueBuffer = valueBuffer;
-			lastQueuedResolution = resolution;
 
 			if (callback) {
 				if (callback === IF_EXISTS)
@@ -351,7 +375,6 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 			enqueuedCommit = null;
 		}
 		let resolvers = flushResolvers;
-		flushResolvers = [];
 		let start = Date.now();
 		env.startWriting(startAddress, (status) => {
 			if (dynamicBytes.uint32[dynamicBytes.position << 1] & TXN_DELIMITER)
@@ -360,52 +383,31 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 			resolveWrites(true);
 			switch (status) {
 				case 0:
-					if (resolvers.length > 0) {
-						let delay = Date.now() - start
-						scheduleFlush(resolvers, Math.min((flushPromise && flushPromise.hasCallbacks ? delay >> 1 : delay) + 1, maxFlushDelay))
+					for (let resolver of resolvers) {
+						resolver();
 					}
+					break;
 				case 1:
-				break;
+					break;
 				case 2:
+					hasUnresolvedTxns = false;
 					executeTxnCallbacks();
-				break;
+					return hasUnresolvedTxns;
+					break;
 				default:
-				console.error(status);
-				if (commitRejectPromise) {
-					commitRejectPromise.reject(status);
-					commitRejectPromise = null;
-				}
+					try {
+						lmdbError(status);
+					} catch(error) {
+						console.error(error);
+						if (commitRejectPromise) {
+							commitRejectPromise.reject(error);
+							commitRejectPromise = null;
+						}
+					}
 			}
 		});
 		startAddress = 0;
 	}
-	function scheduleFlush(resolvers, delay) {
-		if (committedFlushResolvers)
-			committedFlushResolvers.push(...resolvers)
-		else {
-			committedFlushResolvers = resolvers
-			lastFlushTimeout = setTimeout(lastFlushCallback = () => {
-				lastFlushTimeout = null;
-				lastSync.then(() => {
-					let resolvers = committedFlushResolvers || [];
-					committedFlushResolvers = null;
-					lastSync = new Promise((resolve) => {
-						env.sync(() => {
-							for (let i = 0; i < resolvers.length; i++)
-								resolvers[i]();
-							resolve();
-						});
-					});
-				});
-			}, delay || 0);
-		}
-	}
-	function expediteFlush() {
-		if (lastFlushTimeout) {
-			clearTimeout(lastFlushTimeout);
-			lastFlushCallback();
-		}
-	}
 
 	function queueCommitResolution(resolution) {
 		if (!(resolution.flag & HAS_TXN)) {
@@ -430,7 +432,7 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 			}
 			outstandingWriteCount--;
 			if (unwrittenResolution.flag !== HAS_TXN) {
-				if (unwrittenResolution.flag === NO_RESOLVE && !unwrittenResolution.store) {
+				if (unwrittenResolution.flag === NO_RESOLVE && !unwrittenResolution.meta) {
 					// in this case we can completely remove from the linked list, clearing more memory
 					lastPromisedResolution.next = unwrittenResolution = unwrittenResolution.next;
 					continue;
@@ -452,7 +454,7 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 	}
 
 	function resolveCommit(async) {
-		afterCommit();
+		afterCommit(txnResolution.uint32[txnResolution.flagPosition - 1]);
 		if (async)
 			resetReadTxn();
 		else
@@ -498,35 +500,38 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 		} else // otherwise the transaction could end at any time and we need to know the
 			// deterministically if it is ending, so we can reset the commit promise
 			// so we use the slower atomic operation
-			return Atomics.or(uint32, flagPosition, newStatus);
+			try {
+				return Atomics.or(uint32, flagPosition, newStatus);
+			} catch(error) {
+			console.error(error);
+			return;
+			}
 	}
-	function afterCommit() {
+	function afterCommit(txnId) {
 		for (let i = 0, l = afterCommitCallbacks.length; i < l; i++) {
-			afterCommitCallbacks[i]({ next: uncommittedResolution, last: unwrittenResolution});
+			try {
+				afterCommitCallbacks[i]({next: uncommittedResolution, last: txnResolution, txnId});
+			} catch(error) {
+				console.error('In aftercommit callback', error);
+			}
 		}
 	}
 	async function executeTxnCallbacks() {
 		env.writeTxn = writeTxn = { write: true };
-		//this.emit('begin-transaction');
-		let promises;
-		let txnCallbacks;
-		for (let i = 0, l = nextTxnCallbacks.length; i < l; i++) {
-			txnCallbacks = nextTxnCallbacks[i];
-			for (let i = 0, l = txnCallbacks.length; i < l; i++) {
-				let userTxnCallback = txnCallbacks[i];
+		nextTxnCallbacks.isExecuting = true;
+		for (let i = 0; i < nextTxnCallbacks.length; i++) {
+			let txnCallbacks = nextTxnCallbacks[i];
+			for (let j = 0, l = txnCallbacks.length; j < l; j++) {
+				let userTxnCallback = txnCallbacks[j];
 				let asChild = userTxnCallback.asChild;
 				if (asChild) {
-					if (promises) {
-						// must complete any outstanding transactions before proceeding
-						await Promise.all(promises);
-						promises = null;
-					}
 					env.beginTxn(1); // abortable
 					let parentTxn = writeTxn;
 					env.writeTxn = writeTxn = { write: true };
 					try {
 						let result = userTxnCallback.callback();
 						if (result && result.then) {
+							hasUnresolvedTxns = true;
 							await result;
 						}
 						if (result === ABORT)
@@ -534,33 +539,32 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 						else
 							env.commitTxn();
 						clearWriteTxn(parentTxn);
-						txnCallbacks[i] = result;
+						txnCallbacks[j] = result;
 					} catch(error) {
 						clearWriteTxn(parentTxn);
 						env.abortTxn();
-						txnError(error, i);
+						txnError(error, txnCallbacks, j);
 					}
 				} else {
 					try {
 						let result = userTxnCallback();
-						txnCallbacks[i] = result;
+						txnCallbacks[j] = result;
 						if (result && result.then) {
-							if (!promises)
-								promises = [];
-							promises.push(result.catch(() => {}));
+							hasUnresolvedTxns = true;
+							await result;
 						}
 					} catch(error) {
-						txnError(error, i);
+						txnError(error, txnCallbacks, j);
 					}
 				}
 			}
 		}
 		nextTxnCallbacks = [];
-		if (promises) { // finish any outstanding commit functions
-			await Promise.all(promises);
-		}
 		clearWriteTxn(null);
-		function txnError(error, i) {
+		if (hasUnresolvedTxns) {
+			env.resumeWriting();
+		}
+		function txnError(error, txnCallbacks, i) {
 			(txnCallbacks.errors || (txnCallbacks.errors = []))[i] = error;
 			txnCallbacks[i] = CALLBACK_THREW;
 		}
@@ -572,18 +576,23 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 		if (writeStatus & WAITING_OPERATION) {
 			write(env.address, 0);
 		}
+		if (dynamicBytes.position > newBufferThreshold) {
+			allocateInstructionBuffer(dynamicBytes.position);
+			nextResolution.flagPosition = dynamicBytes.position << 1;
+			nextResolution.uint32 = dynamicBytes.uint32;
+		}
 	}
 	function clearWriteTxn(parentTxn) {
 		// TODO: We might actually want to track cursors in a write txn and manually
 		// close them.
-		if (writeTxn.cursorCount > 0)
+		if (writeTxn && writeTxn.refCount > 0)
 			writeTxn.isDone = true;
 		env.writeTxn = writeTxn = parentTxn || null;
 	}
 	Object.assign(LMDBStore.prototype, {
 		put(key, value, versionOrOptions, ifVersion) {
 			let callback, flags = 15, type = typeof versionOrOptions;
-			if (type == 'object') {
+			if (type == 'object' && versionOrOptions) {
 				if (versionOrOptions.noOverwrite)
 					flags |= 0x10;
 				if (versionOrOptions.noDupData)
@@ -591,7 +600,7 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 				if (versionOrOptions.append)
 					flags |= 0x20000;
 				if (versionOrOptions.ifVersion != undefined)
-					ifVersion = versionsOrOptions.ifVersion;
+					ifVersion = versionOrOptions.ifVersion;
 				versionOrOptions = versionOrOptions.version;
 				if (typeof ifVersion == 'function')
 					callback = ifVersion;
@@ -624,11 +633,10 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 		ifNoExists(key, callback) {
 			return this.ifVersion(key, null, callback);
 		},
-
-		ifVersion(key, version, callback) {
+		ifVersion(key, version, callback, options) {
 			if (!callback) {
 				return new Batch((operations, callback) => {
-					let promise = this.ifVersion(key, version, operations);
+					let promise = this.ifVersion(key, version, operations, options);
 					if (callback)
 						promise.then(callback);
 					return promise;
@@ -641,7 +649,12 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 				}
 				return SYNC_PROMISE_FAIL;
 			}
-			let finishStartWrite = writeInstructions(key === undefined || version === undefined ? 1 : 4, this, key, undefined, undefined, version);
+			let flags = key === undefined || version === undefined ? 1 : 4;
+			if (options?.ifLessThan)
+				flags |= CONDITIONAL_VERSION_LESS_THAN;
+			if (options?.allowNotFound)
+				flags |= CONDITIONAL_ALLOW_NOTFOUND;
+			let finishStartWrite = writeInstructions(flags, this, key, undefined, undefined, version);
 			let promise;
 			batchDepth += 2;
 			if (batchDepth > 2)
@@ -678,7 +691,7 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 			return this.ifVersion(undefined, undefined, callbackOrOperations);
 		},
 		drop(callback) {
-			return writeInstructions(1024 + 12, this, undefined, undefined, undefined, undefined)(callback);
+			return writeInstructions(1024 + 12, this, Buffer.from([]), undefined, undefined, undefined)(callback);
 		},
 		clearAsync(callback) {
 			if (this.encoder) {
@@ -687,7 +700,7 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 				else if (this.encoder.structures)
 					this.encoder.structures = []
 			}
-			return writeInstructions(12, this, undefined, undefined, undefined, undefined)(callback);
+			return writeInstructions(12, this, Buffer.from([]), undefined, undefined, undefined)(callback);
 		},
 		_triggerError() {
 			finishBatch();
@@ -695,20 +708,20 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 
 		putSync(key, value, versionOrOptions, ifVersion) {
 			if (writeTxn)
-				return this.put(key, value, versionOrOptions, ifVersion);
+				return this.put(key, value, versionOrOptions, ifVersion) === SYNC_PROMISE_SUCCESS;
 			else
 				return this.transactionSync(() =>
-					this.put(key, value, versionOrOptions, ifVersion) == SYNC_PROMISE_SUCCESS, overlappingSync? 0x10002 : 2); // non-abortable, async flush
+					this.put(key, value, versionOrOptions, ifVersion) === SYNC_PROMISE_SUCCESS, overlappingSync? 0x10002 : 2); // non-abortable, async flush
 		},
 		removeSync(key, ifVersionOrValue) {
 			if (writeTxn)
-				return this.remove(key, ifVersionOrValue);
+				return this.remove(key, ifVersionOrValue) === SYNC_PROMISE_SUCCESS;
 			else
 				return this.transactionSync(() =>
-					this.remove(key, ifVersionOrValue) == SYNC_PROMISE_SUCCESS, overlappingSync? 0x10002 : 2); // non-abortable, async flush
+					this.remove(key, ifVersionOrValue) === SYNC_PROMISE_SUCCESS, overlappingSync? 0x10002 : 2); // non-abortable, async flush
 		},
 		transaction(callback) {
-			if (writeTxn) {
+			if (writeTxn && !nextTxnCallbacks.isExecuting) {
 				// already nested in a transaction, just execute and return
 				return callback();
 			}
@@ -719,11 +732,13 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 				throw new Error('Child transactions are not supported in writemap mode');
 			if (writeTxn) {
 				let parentTxn = writeTxn;
-				env.writeTxn = writeTxn = { write: true };
+				let thisTxn = env.writeTxn = writeTxn = { write: true };
 				env.beginTxn(1); // abortable
-				let callbackDone;
+				let callbackDone, finishTxn;
 				try {
-					return when(callback(), (result) => {
+					return writeTxn.childResults = when(callback(), finishTxn = (result) => {
+						if (writeTxn !== thisTxn) // need to wait for child txn to finish asynchronously
+							return writeTxn.childResults.then(() => finishTxn(result));
 						callbackDone = true;
 						if (result === ABORT)
 							env.abortTxn();
@@ -748,14 +763,23 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 		transactionAsync(callback, asChild) {
 			let txnIndex;
 			let txnCallbacks;
-			if (!nextResolution.callbacks) {
+			if (lastQueuedResolution.callbacks) {
+				txnCallbacks = lastQueuedResolution.callbacks;
+				txnIndex = txnCallbacks.push(asChild ? { callback, asChild } : callback) - 1;
+			} else if (nextTxnCallbacks.isExecuting) {
 				txnCallbacks = [asChild ? { callback, asChild } : callback];
-				nextResolution.callbacks = txnCallbacks;
-				txnCallbacks.results = writeInstructions(8 | (this.strictAsyncOrder ? 0x100000 : 0), this)();
+				txnCallbacks.results = commitPromise;
+				nextTxnCallbacks.push(txnCallbacks);
 				txnIndex = 0;
 			} else {
-				txnCallbacks = lastQueuedResolution.callbacks;
-				txnIndex = txnCallbacks.push(asChild ? { callback, asChild } : callback) - 1;
+				if (writeTxn)
+					throw new Error('Can not enqueue transaction during write txn');
+				let finishWrite = writeInstructions(8 | (this.strictAsyncOrder ? 0x100000 : 0), this);
+				txnCallbacks = [asChild ? { callback, asChild } : callback];
+				lastQueuedResolution.callbacks = txnCallbacks;
+				lastQueuedResolution.id = Math.random();
+				txnCallbacks.results = finishWrite();
+				txnIndex = 0;
 			}
 			return txnCallbacks.results.then((results) => {
 				let result = txnCallbacks[txnIndex];
@@ -766,7 +790,7 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 		},
 		transactionSync(callback, flags) {
 			if (writeTxn) {
-				if (!useWritemap && !this.isCaching) // can't use child transactions in write maps or caching stores
+				if (!useWritemap && (flags == undefined || (flags & 1))) // can't use child transactions in write maps
 					// already nested in a transaction, execute as child transaction (if possible) and return
 					return this.childTransaction(callback);
 				let result = callback(); // else just run in current transaction
@@ -776,13 +800,17 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 				}
 				return result;
 			}
-			let callbackDone;
+			let callbackDone, finishTxn;
+			this.transactions++;
+			if (!env.address)
+				throw new Error('The database has been closed and you can not transact on it');
+			env.beginTxn(flags == undefined ? 3 : flags);
+			let thisTxn = writeTxn = env.writeTxn = { write: true };
 			try {
-				this.transactions++;
-				env.beginTxn(flags == undefined ? 3 : flags);
-				writeTxn = env.writeTxn = { write: true };
 				this.emit('begin-transaction');
-				return when(callback(), (result) => {
+				return writeTxn.childResults = when(callback(), finishTxn = (result) => {
+					if (writeTxn !== thisTxn) // need to wait for child txn to finish asynchronously
+						return writeTxn.childResults.then(() => finishTxn(result));
 					try {
 						callbackDone = true;
 						if (result === ABORT)
@@ -790,8 +818,6 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 						else {
 							env.commitTxn();
 							resetReadTxn();
-							if ((flags & 0x10000) && overlappingSync) // if it is no-sync in overlapping-sync mode, need to schedule flush for it to be marked as persisted
-								lastSyncTxnFlush = new Promise(resolve => scheduleFlush([resolve]))
 						}
 						return result;
 					} finally {
@@ -836,8 +862,6 @@ export function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, use
 			let finalPromise = flushPromise || commitPromise || lastWritePromise;
 			if (flushPromise)
 				flushPromise.hasCallbacks = true
-			if (lastFlushTimeout)
-				expediteFlush();
 			let finalSyncPromise = lastSyncTxnFlush;
 			if (finalPromise && resolvedPromise != finalPromise ||
 					finalSyncPromise && resolvedSyncPromise != finalSyncPromise) {