@ohos-ports/lmdb 2.8.6-beta.0

package/src/txn.cpp

@@ -0,0 +1,210 @@
+#include "lmdb-js.h"
+
+using namespace Napi;
+
+TxnTracked::TxnTracked(MDB_txn *txn, unsigned int flags) {
+	this->txn = txn;
+	this->flags = flags;
+	parent = nullptr;
+}
+
+TxnTracked::~TxnTracked() {
+	this->txn = nullptr;
+}
+
+TxnWrap::TxnWrap(const Napi::CallbackInfo& info) : ObjectWrap<TxnWrap>(info) {
+	EnvWrap *ew;
+	napi_unwrap(info.Env(), info[0], (void**)&ew);
+	if (ew->env == nullptr) throwError(info.Env(), "Attempt to start a transaction on a database environment that is closed");
+	int flags = 0;
+	TxnWrap *parentTw;
+	if (info[1].IsBoolean() && ew->writeWorker) { // this is from a transaction callback
+		txn = ew->writeWorker->AcquireTxn(&flags);
+		parentTw = nullptr;
+	} else {
+		if (info[1].IsObject()) {
+			Object options = info[1].As<Object>();
+
+			// Get flags from options
+
+			setFlagFromValue(&flags, MDB_RDONLY, "readOnly", false, options);
+		} else if (info[1].IsNumber()) {
+			flags = info[1].As<Number>();
+		}
+		MDB_txn *parentTxn;
+		if (info[2].IsObject()) {
+			napi_unwrap(info.Env(), info[2], (void**) &parentTw);
+			parentTxn = parentTw->txn;
+		} else {
+			parentTxn = nullptr;
+			parentTw = nullptr;
+			// Check existence of current write transaction
+			if (0 == (flags & MDB_RDONLY)) {
+				if (ew->currentWriteTxn != nullptr) {
+					throwError(info.Env(), "You have already opened a write transaction in the current process, can't open a second one.");
+					return;
+				}
+				//fprintf(stderr, "begin sync txn");
+				auto writeWorker = ew->writeWorker;
+				if (writeWorker) {
+					parentTxn = writeWorker->AcquireTxn(&flags); // see if we have a paused transaction
+					// else we create a child transaction from the current batch transaction. TODO: Except in WRITEMAP mode, where we need to indicate that the transaction should not be committed
+				}
+			}
+		}
+		//fprintf(stderr, "txn_begin from txn.cpp %u %p\n", flags, parentTxn);
+		if ((flags & MDB_RDONLY) && parentTxn) {
+			// if a txn is passed in, we check to see if it is up-to-date and can be reused
+			MDB_envinfo stat;
+			mdb_env_info(ew->env, &stat);
+			if (mdb_txn_id(parentTxn) == stat.me_last_txnid) {
+				txn = nullptr;
+				info.This().As<Object>().Set("address", Number::New(info.Env(), 0));
+				return;
+			}
+			parentTxn = nullptr;
+		}
+		int rc = mdb_txn_begin(ew->env, parentTxn, flags, &txn);
+		if (rc == MDB_READERS_FULL) { // try again after reader check, in case a dead process frees a slot
+			int dead;
+			mdb_reader_check(ew->env, &dead);
+			ew->consolidateTxns();
+			rc = mdb_txn_begin(ew->env, parentTxn, flags, &txn);
+		}
+		if (rc != 0) {
+			txn = nullptr;
+			throwLmdbError(info.Env(), rc);
+			return;
+		}
+	}
+
+	// Set the current write transaction
+	if (0 == (flags & MDB_RDONLY)) {
+		ew->currentWriteTxn = this;
+	}
+	else {
+		ew->readTxns.push_back(this);
+		ew->currentReadTxn = txn;
+	}
+	this->parentTw = parentTw;
+	this->flags = flags;
+	this->ew = ew;
+	this->env = ew->env;
+	info.This().As<Object>().Set("address", Number::New(info.Env(), (size_t) this));
+}
+
+TxnWrap::~TxnWrap() {
+	// Close if not closed already
+	if (this->txn) {
+		mdb_txn_abort(txn);
+		this->removeFromEnvWrap();
+	}
+}
+
+void TxnWrap::removeFromEnvWrap() {
+	if (this->ew) {
+		if (this->ew->currentWriteTxn == this) {
+			this->ew->currentWriteTxn = this->parentTw;
+		}
+		else {
+			auto it = std::find(ew->readTxns.begin(), ew->readTxns.end(), this);
+			if (it != ew->readTxns.end()) {
+				ew->readTxns.erase(it);
+			}
+		}
+		this->ew = nullptr;
+	}
+	this->txn = nullptr;
+}
+
+Value TxnWrap::commit(const Napi::CallbackInfo& info) {
+	// this should only be used for committing read-only txns
+	if (!this->txn) {
+		return throwError(info.Env(), "The transaction is already closed.");
+	}
+	int rc = mdb_txn_commit(this->txn);
+	this->removeFromEnvWrap();
+	if (rc != 0) {
+		return throwLmdbError(info.Env(), rc);
+	}
+	return info.Env().Undefined();
+}
+
+Value TxnWrap::abort(const Napi::CallbackInfo& info) {
+	if (!this->txn) {
+		return throwError(info.Env(), "The transaction is already closed.");
+	}
+
+	mdb_txn_abort(this->txn);
+	this->removeFromEnvWrap();
+	return info.Env().Undefined();
+}
+NAPI_FUNCTION(resetTxn) {
+	ARGS(1)
+	GET_INT64_ARG(0);
+	TxnWrap* tw = (TxnWrap*) i64;
+	if (!tw->txn || !tw->getEnv()) {
+		THROW_ERROR("The transaction is already closed.");
+	} else {
+		tw->reset();
+		RETURN_UNDEFINED;
+	}
+}
+void resetTxnFFI(double twPointer) {
+	TxnWrap* tw = (TxnWrap*) (size_t) twPointer;
+	if (tw->txn && tw->getEnv()) tw->reset();
+}
+
+void TxnWrap::reset() {
+	ew->readTxnRenewed = false;
+	mdb_txn_reset(txn);
+}
+Value TxnWrap::renew(const Napi::CallbackInfo& info) {
+	if (!this->txn || !this->ew->env) {
+		return throwError(info.Env(), "The transaction is already closed.");
+	}
+
+	int rc = mdb_txn_renew(this->txn);
+	if (rc != 0) {
+		return throwLmdbError(info.Env(), rc);
+	}
+	return info.Env().Undefined();
+}
+MDB_env* TxnWrap::getEnv() {
+	return this->ew->env;
+}
+void TxnWrap::setupExports(Napi::Env env, Object exports) {
+		// TxnWrap: Prepare constructor template
+	Function TxnClass = DefineClass(env, "Txn", {
+		// TxnWrap: Add functions to the prototype
+		TxnWrap::InstanceMethod("commit", &TxnWrap::commit),
+		TxnWrap::InstanceMethod("abort", &TxnWrap::abort),
+		TxnWrap::InstanceMethod("renew", &TxnWrap::renew),
+	});
+	exports.Set("Txn", TxnClass);
+	EXPORT_NAPI_FUNCTION("resetTxn", resetTxn);
+	EXPORT_FUNCTION_ADDRESS("resetTxnPtr", resetTxnFFI);
+	//txnTpl->InstanceTemplate()->SetInternalFieldCount(1);
+}
+// This file contains code from the node-lmdb project
+// Copyright (c) 2013-2017 Timur Kristóf
+// Copyright (c) 2021 Kristopher Tate
+// Licensed to you under the terms of the MIT license
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+
+// 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 OR COPYRIGHT HOLDERS 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.

package/src/v8-functions.cpp

@@ -0,0 +1,170 @@
+#include "lmdb-js.h"
+#if ENABLE_V8_API
+#include <string.h>
+#include <stdio.h>
+#include <v8.h>
+#include <node.h>
+
+#if NODE_VERSION_AT_LEAST(16,6,0)
+#if NODE_VERSION_AT_LEAST(17,0,0)
+#include "../dependencies/v8/v8-fast-api-calls.h"
+#else
+#include "../dependencies/v8/v8-fast-api-calls-v16.h"
+#endif
+#endif
+
+using namespace v8;
+int32_t getByBinaryFast(Local<v8::Object> instance, double dwPointer, uint32_t keySize, uint32_t ifNotTxnId, int64_t txnAddress) {
+	DbiWrap* dw = (DbiWrap*) (size_t) dwPointer;
+	return dw->doGetByBinary(keySize, ifNotTxnId, txnAddress);
+}
+
+//class NanWrap : public Nan::ObjectWrap {};
+void getByBinaryV8(const FunctionCallbackInfo<v8::Value>& info) {
+	Isolate* isolate = Isolate::GetCurrent();
+	auto context = isolate->GetCurrentContext();
+	DbiWrap* dw = (DbiWrap*) (size_t) info[0]->NumberValue(context).FromJust();
+	info.GetReturnValue().Set(v8::Number::New(isolate, dw->doGetByBinary(
+		info[1]->Uint32Value(context).FromJust(),
+		info[2]->Uint32Value(context).FromJust(),
+		info[3]->NumberValue(context).FromJust())));
+}
+int32_t positionFast(Local<v8::Object> instance, double cwPointer, uint32_t flags, uint32_t offset, uint32_t keySize, uint64_t endKeyAddress) {
+	CursorWrap* cw = (CursorWrap*) (size_t) cwPointer;
+	DbiWrap* dw = cw->dw;
+	dw->getFast = true;
+	cw->flags = flags;
+	return cw->doPosition(offset, keySize, endKeyAddress);
+}
+void positionV8(const FunctionCallbackInfo<v8::Value>& info) {
+	Isolate* isolate = Isolate::GetCurrent();
+	CursorWrap* cw = (CursorWrap*) (size_t) info[0]->NumberValue(isolate->GetCurrentContext()).FromJust();
+	cw->flags = info[1]->Uint32Value(isolate->GetCurrentContext()).FromJust();
+	uint32_t offset = info[2]->Uint32Value(isolate->GetCurrentContext()).FromJust();
+	uint32_t keySize = info[3]->Uint32Value(isolate->GetCurrentContext()).FromJust();
+	uint64_t endKeyAddress = info[4]->IntegerValue(isolate->GetCurrentContext()).FromJust();
+	info.GetReturnValue().Set(v8::Number::New(isolate, cw->doPosition(offset, keySize, endKeyAddress)));
+}
+
+int32_t iterateFast(Local<v8::Object> instance, double cwPointer) {
+	CursorWrap* cw = (CursorWrap*) (size_t) cwPointer;
+	DbiWrap* dw = cw->dw;
+	dw->getFast = true;
+	MDB_val key, data;
+	int rc = mdb_cursor_get(cw->cursor, &key, &data, cw->iteratingOp);
+	return cw->returnEntry(rc, key, data);
+}
+void iterateV8(const FunctionCallbackInfo<v8::Value>& info) {
+	Isolate* isolate = Isolate::GetCurrent();
+	CursorWrap* cw = (CursorWrap*) (size_t) info[0]->NumberValue(isolate->GetCurrentContext()).FromJust();
+	DbiWrap* dw = cw->dw;
+	dw->getFast = true;
+	MDB_val key, data;
+	int rc = mdb_cursor_get(cw->cursor, &key, &data, cw->iteratingOp);
+	info.GetReturnValue().Set(v8::Number::New(isolate, cw->returnEntry(rc, key, data)));
+}
+
+int32_t writeFast(Local<v8::Object> instance, double ewPointer, uint64_t instructionAddress) {
+	EnvWrap* ew = (EnvWrap*) (size_t) ewPointer;
+	int rc;
+	if (instructionAddress)
+		rc = WriteWorker::DoWrites(ew->writeTxn->txn, ew, (uint32_t*)instructionAddress, nullptr);
+	else {
+		pthread_cond_signal(ew->writingCond);
+		rc = 0;
+	}
+	return rc;
+//	if (rc && !(rc == MDB_KEYEXIST || rc == MDB_NOTFOUND))
+	//	options.fallback = true;
+}
+void writeV8(const v8::FunctionCallbackInfo<v8::Value>& info) {
+	Isolate* isolate = Isolate::GetCurrent();
+	EnvWrap* ew = (EnvWrap*) (size_t) info[0]->NumberValue(isolate->GetCurrentContext()).FromJust();
+	uint64_t instructionAddress = info[1]->IntegerValue(isolate->GetCurrentContext()).FromJust();
+	int rc;
+	if (instructionAddress)
+		rc = WriteWorker::DoWrites(ew->writeTxn->txn, ew, (uint32_t*)instructionAddress, nullptr);
+	else {
+		pthread_cond_signal(ew->writingCond);
+		rc = 0;
+	}
+	info.GetReturnValue().Set(v8::Number::New(isolate, rc));
+}
+
+void resetTxnFast(Local<v8::Object> instance, double twPointer) {
+	TxnWrap* tw = (TxnWrap*) (size_t) twPointer;
+	tw->reset();
+}
+
+void resetTxnV8(const FunctionCallbackInfo<v8::Value>& info) {
+	Isolate* isolate = Isolate::GetCurrent();
+	TxnWrap* tw = (TxnWrap*) (size_t) info[0]->NumberValue(isolate->GetCurrentContext()).FromJust();
+	tw->reset();
+}
+
+void noopFast(Local<v8::Object> instance) {
+}
+
+void noopV8(const FunctionCallbackInfo<v8::Value>& info) {
+}
+
+
+void clearKeptObjects(const FunctionCallbackInfo<v8::Value>& info) {
+	#if NODE_VERSION_AT_LEAST(14,0,0)
+	v8::Isolate::GetCurrent()->ClearKeptObjects();
+	#endif
+}
+void detachBuffer(const FunctionCallbackInfo<v8::Value>& info) {
+	#if NODE_VERSION_AT_LEAST(12,0,0)
+	v8::Local<v8::ArrayBuffer> v8Buffer = Local<v8::ArrayBuffer>::Cast(info[0]);
+	v8Buffer->Detach();
+	#endif
+}
+
+#endif
+
+
+#define EXPORT_FAST(exportName, slowName, fastName) {\
+	auto fast = CFunction::Make(fastName);\
+	exports->Set(isolate->GetCurrentContext(), v8::String::NewFromUtf8(isolate, exportName, NewStringType::kInternalized).ToLocalChecked(), FunctionTemplate::New(\
+			isolate, slowName, Local<v8::Value>(),\
+			Local<Signature>(), 0, ConstructorBehavior::kThrow,\
+			SideEffectType::kHasNoSideEffect, &fast)->GetFunction(isolate->GetCurrentContext()).ToLocalChecked());\
+}
+#define EXPORT_FUNCTION(exportName, funcName) \
+	exports->Set(isolate->GetCurrentContext(), v8::String::NewFromUtf8(isolate, exportName, NewStringType::kInternalized).ToLocalChecked(), FunctionTemplate::New(\
+			isolate, funcName, Local<v8::Value>(),\
+			Local<Signature>(), 0, ConstructorBehavior::kThrow,\
+			SideEffectType::kHasNoSideEffect)->GetFunction(isolate->GetCurrentContext()).ToLocalChecked());
+NAPI_FUNCTION(enableDirectV8) {
+	ARGS(2)
+	#if ENABLE_V8_API
+	Isolate* isolate = Isolate::GetCurrent();
+	napi_value exportsValue = args[0];
+	Local<v8::Object> exports;
+	memcpy((void*) &exports, (void*) &exportsValue, sizeof(exportsValue));
+	#if NODE_VERSION_AT_LEAST(16,6,1)
+	bool useFastApi;
+	napi_get_value_bool(env, args[1], &useFastApi);
+	if (useFastApi) {
+		EXPORT_FAST("getByBinary", getByBinaryV8, getByBinaryFast);
+		EXPORT_FAST("position", positionV8, positionFast);
+		EXPORT_FAST("iterate", iterateV8, iterateFast);
+		EXPORT_FAST("write", writeV8, writeFast);
+		EXPORT_FAST("resetTxn", resetTxnV8, resetTxnFast);
+		EXPORT_FAST("noop", noopV8, noopFast);
+	} else {
+	#endif
+	EXPORT_FUNCTION("getByBinary", getByBinaryV8);
+	EXPORT_FUNCTION("position", positionV8);
+	EXPORT_FUNCTION("iterate", iterateV8);
+	EXPORT_FUNCTION("write", writeV8);
+	EXPORT_FUNCTION("noop", noopV8);
+	#if NODE_VERSION_AT_LEAST(16,6,1)
+	}
+	#endif
+	EXPORT_FUNCTION("clearKeptObjects", clearKeptObjects);
+	EXPORT_FUNCTION("detachBuffer", detachBuffer);
+	#endif
+	RETURN_UNDEFINED
+}

package/src/windows.c

@@ -0,0 +1,35 @@
+#ifdef _WIN32
+#include <windows.h>
+#include <synchapi.h>
+static int initializeMemoryPriority = 1;
+static MEMORY_PRIORITY_INFORMATION lowMemPriority;
+static MEMORY_PRIORITY_INFORMATION normalMemPriority;
+int lowerMemoryPriority(int priority) {
+    if (initializeMemoryPriority) {
+        GetThreadInformation(GetCurrentThread(), ThreadMemoryPriority, &normalMemPriority, sizeof(normalMemPriority));
+//      fprintf(stderr, "initialized memory %u setting to %u\n", normalMemPriority.MemoryPriority, priority);
+        ZeroMemory(&lowMemPriority, sizeof(lowMemPriority));
+        lowMemPriority.MemoryPriority = priority;
+        initializeMemoryPriority = 0;
+    }
+    void* instruction;
+    void* pointer;
+    WaitOnAddress(instruction, pointer, 8, INFINITE);
+
+    return SetThreadInformation(GetCurrentThread(), ThreadMemoryPriority, &lowMemPriority, sizeof(lowMemPriority));
+}
+int setProcessMemoryPriority(int priority) {
+    if (initializeMemoryPriority) {
+        GetThreadInformation(GetCurrentThread(), ThreadMemoryPriority, &normalMemPriority, sizeof(normalMemPriority));
+//      fprintf(stderr, "initialized memory %u setting to %u\n", normalMemPriority.MemoryPriority, priority);
+        ZeroMemory(&lowMemPriority, sizeof(lowMemPriority));
+        lowMemPriority.MemoryPriority = priority;
+        initializeMemoryPriority = 0;
+    }
+    return SetProcessInformation(GetCurrentProcess(), ProcessMemoryPriority, &lowMemPriority, sizeof(lowMemPriority));
+}
+
+int restoreMemoryPriority() {
+    return SetThreadInformation(GetCurrentThread(), ThreadMemoryPriority, &normalMemPriority, sizeof(normalMemPriority));
+}
+#endif