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

package/read.js

@@ -1,44 +1,60 @@
 import { RangeIterable }  from './util/RangeIterable.js';
-import { getAddress, Cursor, Txn, orderedBinary, lmdbError, getByBinary, detachBuffer, setGlobalBuffer, prefetch, iterate, position as doPosition, resetTxn, getCurrentValue, getCurrentShared, getStringByBinary, getSharedByBinary } from './native.js';
+import { getAddress, Cursor, Txn, orderedBinary, lmdbError, getByBinary, setGlobalBuffer, prefetch, iterate, position as doPosition, resetTxn, getCurrentValue, getCurrentShared, getStringByBinary, globalBuffer, getSharedBuffer, startRead, setReadCallback } from './native.js';
 import { saveKey }  from './keys.js';
+const IF_EXISTS = 3.542694326329068e-103;
 const ITERATOR_DONE = { done: true, value: undefined };
 const Uint8ArraySlice = Uint8Array.prototype.slice;
-const Uint8A = typeof Buffer != 'undefined' ? Buffer.allocUnsafeSlow : Uint8Array
-let getValueBytes = makeReusableBuffer(0);
+let getValueBytes = globalBuffer;
+if (!getValueBytes.maxLength) {
+	getValueBytes.maxLength = getValueBytes.length;
+	getValueBytes.isGlobal = true;
+	Object.defineProperty(getValueBytes, 'length', { value: getValueBytes.length, writable: true, configurable: true });
+}
 const START_ADDRESS_POSITION = 4064;
 const NEW_BUFFER_THRESHOLD = 0x8000;
+const SOURCE_SYMBOL = Symbol.for('source');
+export const UNMODIFIED = {};
+let mmaps = [];
 
 export function addReadMethods(LMDBStore, {
-	maxKeySize, env, keyBytes, keyBytesView, getLastVersion
+	maxKeySize, env, keyBytes, keyBytesView, getLastVersion, getLastTxnId
 }) {
 	let readTxn, readTxnRenewed, asSafeBuffer = false;
 	let renewId = 1;
+	let outstandingReads = 0;
 	Object.assign(LMDBStore.prototype, {
-		getString(id) {
-			(env.writeTxn || (readTxnRenewed ? readTxn : renewReadTxn(this)));
-			let string = getStringByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0));
+		getString(id, options) {
+			let txn = env.writeTxn || (options && options.transaction) || (readTxnRenewed ? readTxn : renewReadTxn(this));
+			let string = getStringByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0), txn.address || 0);
 			if (typeof string === 'number') { // indicates the buffer wasn't large enough
 				this._allocateGetBuffer(string);
 				// and then try again
-				string = getStringByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0));
+				string = getStringByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0), txn.address || 0);
 			}
 			if (string)
 				this.lastSize = string.length;
 			return string;
 		},
-		getBinaryFast(id) {
-			(env.writeTxn || (readTxnRenewed ? readTxn : renewReadTxn(this)));
-			let rc = this.lastSize = getByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0));
+		getBinaryFast(id, options) {
+			let rc;
+			let txn = env.writeTxn || (options && options.transaction) || (readTxnRenewed ? readTxn : renewReadTxn(this));
+			rc = this.lastSize = getByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0), (options && options.ifNotTxnId) || 0, txn.address || 0);
 			if (rc < 0) {
 				if (rc == -30798) // MDB_NOTFOUND
 					return; // undefined
+				if (rc == -30004) // txn id matched
+					return UNMODIFIED;
 				if (rc == -30781 /*MDB_BAD_VALSIZE*/ && this.writeKey(id, keyBytes, 0) == 0)
 					throw new Error(id === undefined ?
 					'A key is required for get, but is undefined' :
 					'Zero length key is not allowed in LMDB');
 				if (rc == -30000) // int32 overflow, read uint32
 					rc = this.lastSize = keyBytesView.getUint32(0, true);
-				else
+				else if (rc == -30001) {// shared buffer
+					this.lastSize = keyBytesView.getUint32(0, true);
+					let bufferId = keyBytesView.getUint32(4, true);
+					return getMMapBuffer(bufferId, this.lastSize);
+				} else
 					throw lmdbError(rc);
 			}
 			let compression = this.compression;
@@ -46,13 +62,89 @@ export function addReadMethods(LMDBStore, {
 			if (rc > bytes.maxLength) {
 				// this means the target buffer wasn't big enough, so the get failed to copy all the data from the database, need to either grow or use special buffer
 				return this._returnLargeBuffer(
-					() => getByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0)),
-					() => getSharedByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0)));
+					() => getByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0), 0, txn.address || 0));
 			}
 			bytes.length = this.lastSize;
 			return bytes;
 		},
-		_returnLargeBuffer(getFast, getShared) {
+		getBFAsync(id, options, callback) {
+			let txn = env.writeTxn || (options && options.transaction) || (readTxnRenewed ? readTxn : renewReadTxn(this));
+			txn.refCount = (txn.refCount || 0) + 1;
+			outstandingReads++;
+			let address = recordReadInstruction(txn.address, this.db.dbi, id, this.writeKey, maxKeySize, ( rc, bufferId, offset, size ) => {
+				if (rc && rc !== 1)
+					callback(lmdbError(rc));
+				outstandingReads--;
+				let buffer = mmaps[bufferId];
+				if (!buffer) {
+					buffer = mmaps[bufferId] = getSharedBuffer(bufferId, env.address);
+				}
+				//console.log({bufferId, offset, size})
+				if (buffer.isSharedMap) {
+					// using LMDB shared memory
+					// TODO: We may want explicit support for clearing aborting the transaction on the next event turn,
+					// but for now we are relying on the GC to cleanup transaction for larger blocks of memory
+					let bytes = new Uint8Array(buffer, offset, size);
+					bytes.txn = txn;
+					callback(bytes, 0, size);
+				} else {
+					// using copied memory
+					txn.done(); // decrement and possibly abort
+					callback(buffer, offset, size);
+				}
+			});
+			if (address) {
+				startRead(address, () => {
+					resolveReads();
+				});
+			}
+		},
+		getAsync(id, options, callback) {
+			let promise;
+			if (!callback)
+				promise = new Promise(resolve => callback = resolve);
+			this.getBFAsync(id, options, (buffer, offset, size) => {
+				if (this.useVersions) {
+					// TODO: And get the version
+					offset += 8;
+					size -= 8;
+				}
+				let bytes = new Uint8Array(buffer, offset, size);
+				let value;
+				if (this.decoder) {
+					// the decoder potentially uses the data from the buffer in the future and needs a stable buffer
+					value = bytes && this.decoder.decode(bytes);
+				} else if (this.encoding == 'binary') {
+					value = bytes;
+				} else {
+					value = Buffer.prototype.utf8Slice.call(bytes, 0, size);
+					if (this.encoding == 'json' && value)
+						value = JSON.parse(value);
+				}
+				callback(value);
+			});
+			return promise;
+		},
+		retain(data, options) {
+			if (!data)
+				return
+			let source = data[SOURCE_SYMBOL];
+			let buffer = source ? source.bytes : data;
+			if (!buffer.isGlobal && !env.writeTxn) {
+				let txn = options?.transaction || (readTxnRenewed ? readTxn : renewReadTxn(this));
+				buffer.txn = txn;
+				txn.refCount = (txn.refCount || 0) + 1;
+				return data;
+			} else {
+				buffer = Uint8ArraySlice.call(buffer, 0, this.lastSize);
+				if (source) {
+					source.bytes = buffer;
+					return data;
+				} else
+					return buffer;
+			}
+		},
+		_returnLargeBuffer(getFast) {
 			let bytes;
 			let compression = this.compression;
 			if (asSafeBuffer && this.lastSize > NEW_BUFFER_THRESHOLD) {
@@ -64,7 +156,7 @@ export function addReadMethods(LMDBStore, {
 						let dictionary = compression.dictionary || [];
 						let dictLength = (dictionary.length >> 3) << 3;// make sure it is word-aligned
 						bytes = makeReusableBuffer(this.lastSize);
-						compression.setBuffer(bytes, this.lastSize, dictionary, dictLength);
+						compression.setBuffer(bytes.buffer, bytes.byteOffset, this.lastSize, dictionary, dictLength);
 						compression.getValueBytes = bytes;
 					} else {
 						bytesToRestore = getValueBytes;
@@ -74,7 +166,7 @@ export function addReadMethods(LMDBStore, {
 				} finally {
 					if (compression) {
 						let dictLength = (compression.dictionary.length >> 3) << 3;
-						compression.setBuffer(bytesToRestore, bytesToRestore.maxLength, compression.dictionary, dictLength);
+						compression.setBuffer(bytesToRestore.buffer, bytesToRestore.byteOffset, bytesToRestore.maxLength, compression.dictionary, dictLength);
 						compression.getValueBytes = bytesToRestore;
 					} else {
 						setGlobalBuffer(bytesToRestore);
@@ -83,12 +175,6 @@ export function addReadMethods(LMDBStore, {
 				}
 				return bytes;
 			}
-			if (this.lastSize > NEW_BUFFER_THRESHOLD && !compression) {
-				// for large binary objects, cheaper to make a buffer that directly points at the shared LMDB memory to avoid copying a large amount of memory, but only for large data since there is significant overhead to instantiating the buffer
-				if (globalThis.__lmdb_last_shared__ && detachBuffer) // we have to detach the last one, or else could crash due to two buffers pointing at same location
-					detachBuffer(globalThis.__lmdb_last_shared__.buffer);
-				return globalThis.__lmdb_last_shared__ = getShared();
-			}
 			// grow our shared/static buffer to accomodate the size of the data
 			bytes = this._allocateGetBuffer(this.lastSize);
 			// and try again
@@ -100,13 +186,13 @@ export function addReadMethods(LMDBStore, {
 			let newLength = Math.min(Math.max(lastSize * 2, 0x1000), 0xfffffff8);
 			let bytes;
 			if (this.compression) {
-				let dictionary = this.compression.dictionary || new Uint8A(0);
+				let dictionary = this.compression.dictionary || Buffer.allocUnsafeSlow(0);
 				let dictLength = (dictionary.length >> 3) << 3;// make sure it is word-aligned
-				bytes = new Uint8A(newLength + dictLength);
+				bytes = Buffer.allocUnsafeSlow(newLength + dictLength);
 				bytes.set(dictionary) // copy dictionary into start
 				// the section after the dictionary is the target area for get values
 				bytes = bytes.subarray(dictLength);
-				this.compression.setBuffer(bytes, newLength, dictionary, dictLength);
+				this.compression.setBuffer(bytes.buffer, bytes.byteOffset, newLength, dictionary, dictLength);
 				bytes.maxLength = newLength;
 				Object.defineProperty(bytes, 'length', { value: newLength, writable: true, configurable: true });
 				this.compression.getValueBytes = bytes;
@@ -114,41 +200,51 @@ export function addReadMethods(LMDBStore, {
 				bytes = makeReusableBuffer(newLength);
 				setGlobalBuffer(getValueBytes = bytes);
 			}
-			bytes.isShared = true;
+			bytes.isGlobal = true;
 			return bytes;
 		},
-		getBinary(id) {
+		getBinary(id, options) {
 			try {
 				asSafeBuffer = true;
-				let fastBuffer = this.getBinaryFast(id);
-				return fastBuffer && (fastBuffer.isShared ? Uint8ArraySlice.call(fastBuffer, 0, this.lastSize) : fastBuffer);
+				let fastBuffer = this.getBinaryFast(id, options);
+				return fastBuffer && (fastBuffer.isGlobal ? Uint8ArraySlice.call(fastBuffer, 0, this.lastSize) : fastBuffer);
 			} finally {
 				asSafeBuffer = false;
 			}
 		},
-		get(id) {
+		getSharedBinary(id, options) {
+			let fastBuffer = this.getBinaryFast(id, options);
+			if (fastBuffer) {
+				if (fastBuffer.isGlobal || writeTxn)
+					return Uint8ArraySlice.call(fastBuffer, 0, this.lastSize)
+				fastBuffer.txn = (options && options.transaction);
+				options.transaction.refCount = (options.transaction.refCount || 0) + 1;
+				return fastBuffer;
+			}
+		},
+		get(id, options) {
 			if (this.decoderCopies) {
 				// the decoder copies any data, so we can use the fast binary retrieval that overwrites the same buffer space
-				let bytes = this.getBinaryFast(id);
-				return bytes && this.decoder.decode(bytes);
+				let bytes = this.getBinaryFast(id, options);
+				return bytes && (bytes == UNMODIFIED ? UNMODIFIED : this.decoder.decode(bytes, options));
 			}
 			if (this.encoding == 'binary')
-				return this.getBinary(id);
+				return this.getBinary(id, options);
 			if (this.decoder) {
 				// the decoder potentially uses the data from the buffer in the future and needs a stable buffer
-				let bytes = this.getBinary(id);
-				return bytes && this.decoder.decode(bytes);
+				let bytes = this.getBinary(id, options);
+				return bytes && (bytes == UNMODIFIED ? UNMODIFIED : this.decoder.decode(bytes));
 			}
 
-			let result = this.getString(id);
+			let result = this.getString(id, options);
 			if (result) {
 				if (this.encoding == 'json')
 					return JSON.parse(result);
 			}
 			return result;
 		},
-		getEntry(id) {
-			let value = this.get(id);
+		getEntry(id, options) {
+			let value = this.get(id, options);
 			if (value !== undefined) {
 				if (this.useVersions)
 					return {
@@ -167,8 +263,11 @@ export function addReadMethods(LMDBStore, {
 			resetReadTxn();
 		},
 		_commitReadTxn() {
-			if (readTxn)
+			if (readTxn) {
+				readTxn.isCommitted = true
 				readTxn.commit();
+			}
+			lastReadTxnRef = null;
 			readTxnRenewed = null;
 			readTxn = null;
 		},
@@ -177,15 +276,12 @@ export function addReadMethods(LMDBStore, {
 				renewReadTxn(this);
 		},
 		doesExist(key, versionOrValue) {
-			if (!env.writeTxn)
-				readTxnRenewed ? readTxn : renewReadTxn(this);
 			if (versionOrValue == null) {
 				// undefined means the entry exists, null is used specifically to check for the entry *not* existing
 				return (this.getBinaryFast(key) === undefined) == (versionOrValue === null);
 			}
 			else if (this.useVersions) {
-				this.getBinaryFast(key);
-				return this.getBinaryFast(key) !== undefined && getLastVersion() === versionOrValue;
+				return this.getBinaryFast(key) !== undefined && (versionOrValue === IF_EXISTS || getLastVersion() === versionOrValue);
 			}
 			else {
 				if (versionOrValue && versionOrValue['\x10binary-data\x02'])
@@ -251,28 +347,39 @@ export function addReadMethods(LMDBStore, {
 				let cursor, cursorRenewId, cursorAddress;
 				let txn;
 				let flags = (includeValues ? 0x100 : 0) | (reverse ? 0x400 : 0) |
-					(valuesForKey ? 0x800 : 0) | (options.exactMatch ? 0x4000 : 0);
+					(valuesForKey ? 0x800 : 0) | (options.exactMatch ? 0x4000 : 0) |
+					(options.inclusiveEnd ? 0x8000 : 0) |
+					(options.exclusiveStart ? 0x10000 : 0);
 				let store = this;
 				function resetCursor() {
 					try {
 						if (cursor)
 							finishCursor();
-						let writeTxn = env.writeTxn;
-						if (writeTxn)
-							snapshot = false;
-						txn = writeTxn || (readTxnRenewed ? readTxn : renewReadTxn(store));
-						cursor = !writeTxn && db.availableCursor;
+						let txnAddress;
+						txn = options.transaction
+						if (txn) {
+							if (txn.isDone) throw new Error('Can not iterate on range with transaction that is already' +
+								' done');
+							txnAddress = txn.address;
+							cursor = null;
+						} else {
+							let writeTxn = env.writeTxn;
+							if (writeTxn)
+								snapshot = false;
+							txn = env.writeTxn || options.transaction || (readTxnRenewed ? readTxn : renewReadTxn(store));
+							cursor = !writeTxn && db.availableCursor;
+						}
 						if (cursor) {
 							db.availableCursor = null;
 							flags |= 0x2000;
 						} else {
-							cursor = new Cursor(db);
+							cursor = new Cursor(db, txnAddress || 0);
 						}
 						cursorAddress = cursor.address;
-						txn.cursorCount = (txn.cursorCount || 0) + 1; // track transaction so we always use the same one
+						txn.refCount = (txn.refCount || 0) + 1; // track transaction so we always use the same one
 						if (snapshot === false) {
 							cursorRenewId = renewId; // use shared read transaction
-							txn.renewingCursorCount = (txn.renewingCursorCount || 0) + 1; // need to know how many are renewing cursors
+							txn.renewingRefCount = (txn.renewingRefCount || 0) + 1; // need to know how many are renewing cursors
 						}
 					} catch(error) {
 						if (cursor) {
@@ -293,6 +400,9 @@ export function addReadMethods(LMDBStore, {
 					return count;
 				}
 				function position(offset) {
+					if (!env.address) {
+						throw new Error('Can not iterate on a closed database');
+					}
 					let keySize = currentKey === undefined ? 0 : store.writeKey(currentKey, keyBytes, 0);
 					let endAddress;
 					if (valuesForKey) {
@@ -311,7 +421,7 @@ export function addReadMethods(LMDBStore, {
 							} else {
 								throw new Error('Only key-based encoding is supported for start/end values');
 								let encoded = store.encoder.encode(options.start);
-								let bufferAddress = encoded.buffer.address || (encoded.buffer.address = getAddress(encoded) - encoded.byteOffset);
+								let bufferAddress = encoded.buffer.address || (encoded.buffer.address = getAddress(encoded.buffer) - encoded.byteOffset);
 								startAddress = bufferAddress + encoded.byteOffset;
 							}
 						}
@@ -323,9 +433,11 @@ export function addReadMethods(LMDBStore, {
 				function finishCursor() {
 					if (txn.isDone)
 						return;
+					if (iterable.onDone)
+						iterable.onDone()
 					if (cursorRenewId)
-						txn.renewingCursorCount--;
-					if (--txn.cursorCount <= 0 && txn.onlyCursor) {
+						txn.renewingRefCount--;
+					if (--txn.refCount <= 0 && txn.notCurrent) {
 						cursor.close();
 						txn.abort(); // this is no longer main read txn, abort it now that we are done
 						txn.isDone = true;
@@ -352,7 +464,7 @@ export function addReadMethods(LMDBStore, {
 						if (keySize <= 0 ||
 								(count++ >= limit)) {
 							if (count < 0)
-								lmdbError(count);				
+								lmdbError(count);
 							finishCursor();
 							return ITERATOR_DONE;
 						}
@@ -367,24 +479,27 @@ export function addReadMethods(LMDBStore, {
 						if (includeValues) {
 							let value;
 							lastSize = keyBytesView.getUint32(0, true);
-							let bytes = compression ? compression.getValueBytes : getValueBytes;
-							if (lastSize > bytes.maxLength) {
-								store.lastSize = lastSize;
-								asSafeBuffer = store.encoding == 'binary';
-								try {
-									bytes = store._returnLargeBuffer(
-										() => getCurrentValue(cursorAddress),
-										() => getCurrentShared(cursorAddress)
-									);
-								} finally {
-									asSafeBuffer = false;
-								}
-							} else
-								bytes.length = lastSize;
+							let bufferId = keyBytesView.getUint32(4, true);
+							let bytes;
+							if (bufferId) {
+								bytes = getMMapBuffer(bufferId, lastSize);
+							} else {
+								bytes = compression ? compression.getValueBytes : getValueBytes;
+								if (lastSize > bytes.maxLength) {
+									store.lastSize = lastSize;
+									asSafeBuffer = store.encoding == 'binary';
+									try {
+										bytes = store._returnLargeBuffer(() => getCurrentValue(cursorAddress));
+									} finally {
+										asSafeBuffer = false;
+									}
+								} else
+									bytes.length = lastSize;
+							}
 							if (store.decoder) {
 								value = store.decoder.decode(bytes, lastSize);
 							} else if (store.encoding == 'binary')
-								value = bytes.isShared ? Uint8ArraySlice.call(bytes, 0, lastSize) : bytes;
+								value = bytes.isGlobal ? Uint8ArraySlice.call(bytes, 0, lastSize) : bytes;
 							else {
 								value = bytes.toString('utf8', 0, lastSize);
 								if (store.encoding == 'json' && value)
@@ -450,8 +565,8 @@ export function addReadMethods(LMDBStore, {
 			});
 			return promise;
 		},
-		getSharedBufferForGet(id) {
-			let txn = (env.writeTxn || (readTxnRenewed ? readTxn : renewReadTxn(this)));
+		getSharedBufferForGet(id, options) {
+			let txn = env.writeTxn || (options && options.transaction) || (readTxnRenewed ? readTxn : renewReadTxn(this));
 			this.lastSize = this.keyIsCompatibility ? txn.getBinaryShared(id) : this.db.get(this.writeKey(id, keyBytes, 0));
 			if (this.lastSize === -30798) { // not found code
 				return; //undefined
@@ -489,7 +604,13 @@ export function addReadMethods(LMDBStore, {
 			let bufferHolder = {};
 			let lastBuffer;
 			for (let key of keys) {
-				let position = saveKey(key, this.writeKey, bufferHolder, maxKeySize);
+				let position
+				if (key && key.key !== undefined && key.value !== undefined) {
+					position = saveKey(key.value, this.writeKey, bufferHolder, maxKeySize, 0x80000000);
+					saveKey(key.key, this.writeKey, bufferHolder, maxKeySize);
+				} else {
+					position = saveKey(key, this.writeKey, bufferHolder, maxKeySize);
+				}
 				if (!startPosition)
 					startPosition = position;
 				if (bufferHolder.saveBuffer != lastBuffer) {
@@ -499,7 +620,9 @@ export function addReadMethods(LMDBStore, {
 				}
 			}
 			saveKey(undefined, this.writeKey, bufferHolder, maxKeySize);
+			outstandingReads++;
 			prefetch(this.dbAddress, startPosition, (error) => {
+				outstandingReads--;
 				if (error)
 					console.error('Error with prefetch', buffers, bufferHolder); // partly exists to keep the buffers pinned in memory
 				else
@@ -508,27 +631,44 @@ export function addReadMethods(LMDBStore, {
 			if (!callback)
 				return new Promise(resolve => callback = resolve);
 		},
+		useReadTransaction() {
+			let txn = readTxnRenewed ? readTxn : renewReadTxn(this);
+			if (!txn.use) {
+				throw new Error('Can not use read transaction from a closed database');
+			}
+			txn.use();
+			return txn;
+		},
 		close(callback) {
 			this.status = 'closing';
+			let txnPromise;
 			if (this.isRoot) {
-				if (readTxn) {
-					try {
-						readTxn.abort();
-					} catch(error) {}
-				}
-				readTxn = {
-					renew() {
+				// if it is root, we need to abort and/or wait for transactions to finish
+				if (readTxn) readTxn.abort();
+				else readTxn = {};
+				readTxn.isDone = true;
+				Object.defineProperty(readTxn,'renew', {
+					value: () => {
 						throw new Error('Can not read from a closed database');
-					}
-				};
+					}, configurable: true
+				});
+				Object.defineProperty(readTxn,'use', {
+					value: () => {
+						throw new Error('Can not read from a closed database');
+					}, configurable: true
+				});
 				readTxnRenewed = null;
+				txnPromise = this._endWrites && this._endWrites();
 			}
-			let txnPromise = this._endWrites();
 			const doClose = () => {
-				this.db.close();
 				if (this.isRoot) {
+					if (outstandingReads > 0) {
+						return new Promise(resolve => setTimeout(() => resolve(doClose()), 1));
+					}
+					env.address = 0;
 					env.close();
-				}
+				} else
+					this.db.close();
 				this.status = 'closed';
 				if (callback)
 					callback();
@@ -541,18 +681,40 @@ export function addReadMethods(LMDBStore, {
 			}
 		},
 		getStats() {
-			readTxnRenewed ? readTxn : renewReadTxn(this);
-			return this.db.stat();
-		}
+			let txn = env.writeTxn || (readTxnRenewed ? readTxn : renewReadTxn(this));
+			let dbStats = this.db.stat();
+			dbStats.root = env.stat();
+			Object.assign(dbStats, env.info());
+			dbStats.free = env.freeStat();
+			return dbStats;
+		},
 	});
 	let get = LMDBStore.prototype.get;
+	let lastReadTxnRef;
+	function getMMapBuffer(bufferId, size) {
+		let buffer = mmaps[bufferId];
+		if (!buffer) {
+			buffer = mmaps[bufferId] = getSharedBuffer(bufferId, env.address);
+		}
+		let offset = keyBytesView.getUint32(8, true);
+		return new Uint8Array(buffer, offset, size);
+	}
 	function renewReadTxn(store) {
+		if (!env.address) {
+			throw new Error('Can not renew a transaction from a closed database');
+		}
 		if (!readTxn) {
 			let retries = 0;
 			let waitArray;
 			do {
 				try {
-					readTxn = new Txn(env, 0x20000);
+					let lastReadTxn = lastReadTxnRef && lastReadTxnRef.deref();
+					readTxn = new Txn(env, 0x20000, lastReadTxn && !lastReadTxn.isDone && lastReadTxn);
+					if (readTxn.address == 0) {
+						readTxn = lastReadTxn;
+						if (readTxn.notCurrent)
+							readTxn.notCurrent = false;
+					}
 					break;
 				} catch (error) {
 					if (error.message.includes('temporarily')) {
@@ -570,15 +732,20 @@ export function addReadMethods(LMDBStore, {
 		store.emit('begin-transaction');
 		return readTxn;
 	}
-	function resetReadTxn(hardReset) {
+	function resetReadTxn() {
 		renewId++;
 		if (readTxnRenewed) {
 			readTxnRenewed = null;
-			if (readTxn.cursorCount - (readTxn.renewingCursorCount || 0) > 0) {
-				readTxn.onlyCursor = true;
+			if (readTxn.refCount - (readTxn.renewingRefCount || 0) > 0) {
+				readTxn.notCurrent = true;
+				lastReadTxnRef = new WeakRef(readTxn);
 				readTxn = null;
-			} else
+			} else if (readTxn.address && !readTxn.isDone) {
 				resetTxn(readTxn.address);
+			} else {
+				console.warn('Attempt to reset an invalid read txn', readTxn);
+				throw new Error('Attempt to reset an invalid read txn');
+			}
 		}
 	}
 }
@@ -588,3 +755,79 @@ export function makeReusableBuffer(size) {
 	Object.defineProperty(bytes, 'length', { value: size, writable: true, configurable: true });
 	return bytes;
 }
+
+Txn.prototype.done = function() {
+	this.refCount--;
+	if (this.refCount === 0 && this.notCurrent) {
+		this.abort();
+		this.isDone = true;
+	}
+}
+Txn.prototype.use = function() {
+	this.refCount = (this.refCount || 0) + 1;
+}
+
+
+let readInstructions, readCallbacks = new Map(), uint32Instructions, instructionsDataView = { setFloat64() {}, setUint32() {} }, instructionsAddress;
+let savePosition = 8000;
+let DYNAMIC_KEY_BUFFER_SIZE = 8192;
+function allocateInstructionsBuffer() {
+	readInstructions = typeof Buffer != 'undefined' ? Buffer.alloc(DYNAMIC_KEY_BUFFER_SIZE) : new Uint8Array(DYNAMIC_KEY_BUFFER_SIZE);
+	uint32Instructions = new Int32Array(readInstructions.buffer, 0, readInstructions.buffer.byteLength >> 2);
+	uint32Instructions[2] = 0xf0000000; // indicates a new read task must be started
+	instructionsAddress = readInstructions.buffer.address = getAddress(readInstructions.buffer);
+	readInstructions.dataView = instructionsDataView = new DataView(readInstructions.buffer, readInstructions.byteOffset, readInstructions.byteLength);
+	savePosition = 0;
+}
+export function recordReadInstruction(txnAddress, dbi, key, writeKey, maxKeySize, callback) {
+	if (savePosition > 7800) {
+		allocateInstructionsBuffer();
+	}
+	let start = savePosition;
+	let keyPosition = savePosition + 16;
+	try {
+		savePosition = key === undefined ? keyPosition :
+			writeKey(key, readInstructions, keyPosition);
+	} catch (error) {
+		if (error.name == 'RangeError') {
+			if (8180 - start < maxKeySize) {
+				allocateInstructionsBuffer(); // try again:
+				return recordReadInstruction(txnAddress, dbi, key, writeKey, maxKeySize, callback);
+			}
+			throw new Error('Key was too large, max key size is ' + maxKeySize);
+		} else
+			throw error;
+	}
+	let length = savePosition - keyPosition;
+	if (length > maxKeySize) {
+		savePosition = start;
+		throw new Error('Key of size ' + length + ' was too large, max key size is ' + maxKeySize);
+	}
+	uint32Instructions[(start >> 2) + 3] = length; // save the length
+	uint32Instructions[(start >> 2) + 2] = dbi;
+	savePosition = (savePosition + 12) & 0xfffffc;
+	instructionsDataView.setFloat64(start, txnAddress, true);
+	let callbackId = addReadCallback(() => {
+		let position = start >> 2;
+		let rc = thisInstructions[position];
+		callback(rc, thisInstructions[position + 1], thisInstructions[position + 2], thisInstructions[position + 3]);
+	});
+	let thisInstructions = uint32Instructions;
+	//if (start === 0)
+		return startRead(instructionsAddress + start, callbackId, {}, 'read');
+	//else
+		//nextRead(start);
+}
+let nextCallbackId = 0;
+let addReadCallback = globalThis.__lmdb_read_callback;
+if (!addReadCallback) {
+	addReadCallback = globalThis.__lmdb_read_callback = function(callback) {
+		let callbackId = nextCallbackId++;
+		readCallbacks.set(callbackId, callback);
+		return callbackId;
+	};
+	setReadCallback(function(callbackId) {
+		readCallbacks.get(callbackId)();
+		readCallbacks.delete(callbackId);
+	})
+}