harperdb 3.2.0 → 3.3.0

package/node_modules/lmdb-store/src/misc.cpp

@@ -1,528 +1,528 @@
-
-// This file is part of node-lmdb, the Node.js binding for lmdb
-// 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.
-
-#include "node-lmdb.h"
-#include <string.h>
-#include <stdio.h>
-
-static thread_local char* globalUnsafePtr;
-static thread_local size_t globalUnsafeSize;
-static thread_local Persistent<Object>* globalUnsafeBuffer;
-
-void setupExportMisc(Local<Object> exports) {
-    Local<Object> versionObj = Nan::New<Object>();
-
-    int major, minor, patch;
-    char *str = mdb_version(&major, &minor, &patch);
-    Local<Context> context = Nan::GetCurrentContext();
-    (void)versionObj->Set(context, Nan::New<String>("versionString").ToLocalChecked(), Nan::New<String>(str).ToLocalChecked());
-    (void)versionObj->Set(context, Nan::New<String>("major").ToLocalChecked(), Nan::New<Integer>(major));
-    (void)versionObj->Set(context, Nan::New<String>("minor").ToLocalChecked(), Nan::New<Integer>(minor));
-    (void)versionObj->Set(context, Nan::New<String>("patch").ToLocalChecked(), Nan::New<Integer>(patch));
-
-    (void)exports->Set(context, Nan::New<String>("version").ToLocalChecked(), versionObj);
-    Nan::SetMethod(exports, "getLastVersion", getLastVersion);
-    Nan::SetMethod(exports, "setLastVersion", setLastVersion);
-    Nan::SetMethod(exports, "bufferToKeyValue", bufferToKeyValue);
-    Nan::SetMethod(exports, "keyValueToBuffer", keyValueToBuffer);
-    Nan::SetMethod(exports, "setWinMemoryLimit", setWinMemoryLimit);
-    Nan::SetMethod(exports, "setWinMemoryPriority", setWinMemoryPriority);
-    globalUnsafeBuffer = new Persistent<Object>();
-    makeGlobalUnsafeBuffer(8);
-    fixedKeySpace = new KeySpace(true);
-}
-
-KeySpace* getFixedKeySpace() {
-    return fixedKeySpace;
-}
-
-void setFlagFromValue(int *flags, int flag, const char *name, bool defaultValue, Local<Object> options) {
-    Local<Context> context = Nan::GetCurrentContext();
-    Local<Value> opt = options->Get(context, Nan::New<String>(name).ToLocalChecked()).ToLocalChecked();
-    #if NODE_VERSION_AT_LEAST(12,0,0)
-    if (opt->IsBoolean() ? opt->BooleanValue(Isolate::GetCurrent()) : defaultValue) {
-    #else
-    if (opt->IsBoolean() ? opt->BooleanValue(context).FromJust() : defaultValue) {
-    #endif
-        *flags |= flag;
-    }
-}
-
-NodeLmdbKeyType keyTypeFromOptions(const Local<Value> &val, NodeLmdbKeyType defaultKeyType) {
-    if (!val->IsObject()) {
-        return defaultKeyType;
-    }
-    auto obj = Local<Object>::Cast(val);
-
-    NodeLmdbKeyType keyType = defaultKeyType;
-    int keyIsUint32 = 0;
-    int keyIsBuffer = 0;
-    int keyIsString = 0;
-    
-    setFlagFromValue(&keyIsUint32, 1, "keyIsUint32", false, obj);
-    setFlagFromValue(&keyIsString, 1, "keyIsString", false, obj);
-    setFlagFromValue(&keyIsBuffer, 1, "keyIsBuffer", false, obj);
-    
-    const char *keySpecificationErrorText = "You can't specify multiple key types at once. Either set keyIsUint32, or keyIsBuffer or keyIsString (default).";
-    
-    if (keyIsUint32) {
-        keyType = NodeLmdbKeyType::Uint32Key;
-        if (keyIsBuffer || keyIsString) {
-            Nan::ThrowError(keySpecificationErrorText);
-            return NodeLmdbKeyType::InvalidKey;
-        }
-    }
-    else if (keyIsBuffer) {
-        keyType = NodeLmdbKeyType::BinaryKey;
-        
-        if (keyIsUint32 || keyIsString) {
-            Nan::ThrowError(keySpecificationErrorText);
-            return NodeLmdbKeyType::InvalidKey;
-        }
-    }
-    else if (keyIsString) {
-        keyType = NodeLmdbKeyType::StringKey;
-    }
-    
-    return keyType;
-}
-
-NodeLmdbKeyType inferKeyType(const Local<Value> &val) {
-    if (val->IsString()) {
-        return NodeLmdbKeyType::StringKey;
-    }
-    if (val->IsUint32()) {
-        return NodeLmdbKeyType::Uint32Key;
-    }
-    if (node::Buffer::HasInstance(val)) {
-        return NodeLmdbKeyType::BinaryKey;
-    }
-    
-    return NodeLmdbKeyType::InvalidKey;
-}
-
-NodeLmdbKeyType inferAndValidateKeyType(const Local<Value> &key, const Local<Value> &options, NodeLmdbKeyType dbiKeyType, bool &isValid) {
-    auto keyType = keyTypeFromOptions(options, NodeLmdbKeyType::DefaultKey);
-    auto inferredKeyType = inferKeyType(key);
-    isValid = false;
-    
-    if (keyType != NodeLmdbKeyType::DefaultKey && inferredKeyType != keyType) {
-        Nan::ThrowError("Specified key type doesn't match the key you gave.");
-        return NodeLmdbKeyType::InvalidKey;
-    }
-    else {
-        keyType = inferredKeyType;
-    }
-    if (dbiKeyType == NodeLmdbKeyType::Uint32Key && keyType != NodeLmdbKeyType::Uint32Key) {
-        Nan::ThrowError("You specified keyIsUint32 on the Dbi, so you can't use other key types with it.");
-        return NodeLmdbKeyType::InvalidKey;
-    }
-    
-    isValid = true;
-    return keyType;
-}
-
-argtokey_callback_t argToKey(const Local<Value> &val, MDB_val &key, NodeLmdbKeyType keyType, bool &isValid) {
-    isValid = false;
-
-    if (keyType == NodeLmdbKeyType::DefaultKey) {
-        isValid = valueToMDBKey(val, key, *fixedKeySpace);
-    } else if (keyType == NodeLmdbKeyType::StringKey) {
-        if (!val->IsString()) {
-            Nan::ThrowError("Invalid key. Should be a string. (Specified with env.openDbi)");
-            return nullptr;
-        }
-        
-        isValid = true;
-        CustomExternalStringResource::writeTo(Local<String>::Cast(val), &key);
-        return ([](MDB_val &key) -> void {
-            delete[] (uint16_t*)key.mv_data;
-        });
-    }
-    else if (keyType == NodeLmdbKeyType::Uint32Key) {
-        if (!val->IsUint32()) {
-            Nan::ThrowError("Invalid key. Should be an unsigned 32-bit integer. (Specified with env.openDbi)");
-            return nullptr;
-        }
-        
-        isValid = true;
-        uint32_t* uint32Key = new uint32_t;
-        *uint32Key = val->Uint32Value(Nan::GetCurrentContext()).FromJust();
-        key.mv_size = sizeof(uint32_t);
-        key.mv_data = uint32Key;
-
-        return ([](MDB_val &key) -> void {
-            delete (uint32_t*)key.mv_data;
-        });
-    }
-    else if (keyType == NodeLmdbKeyType::BinaryKey) {
-        if (!node::Buffer::HasInstance(val)) {
-            Nan::ThrowError("Invalid key. Should be a Buffer. (Specified with env.openDbi)");
-            return nullptr;
-        }
-        
-        isValid = true;
-        key.mv_size = node::Buffer::Length(val);
-        key.mv_data = node::Buffer::Data(val);
-        
-        return nullptr;
-    }
-    else if (keyType == NodeLmdbKeyType::InvalidKey) {
-        Nan::ThrowError("Invalid key type. This might be a bug in node-lmdb.");
-    }
-    else {
-        Nan::ThrowError("Unknown key type. This is a bug in node-lmdb.");
-    }
-
-    return nullptr;
-}
-
-Local<Value> keyToHandle(MDB_val &key, NodeLmdbKeyType keyType) {
-    switch (keyType) {
-    case NodeLmdbKeyType::DefaultKey:
-        return MDBKeyToValue(key);
-    case NodeLmdbKeyType::Uint32Key:
-        return Nan::New<Integer>(*((uint32_t*)key.mv_data));
-    case NodeLmdbKeyType::BinaryKey:
-        return valToBinary(key);
-    case NodeLmdbKeyType::StringKey:
-        return valToString(key);
-    default:
-        Nan::ThrowError("Unknown key type. This is a bug in node-lmdb.");
-        return Nan::Undefined();
-    }
-}
-
-Local<Value> valToStringUnsafe(MDB_val &data) {
-    auto resource = new CustomExternalOneByteStringResource(&data);
-    auto str = Nan::New<v8::String>(resource);
-
-    return str.ToLocalChecked();
-}
-
-Local<Value> valToUtf8(MDB_val &data) {
-    //const uint8_t *buffer = (const uint8_t*)(data.mv_data);
-    //Isolate *isolate = Isolate::GetCurrent();
-    //auto str = v8::String::NewFromOneByte(isolate, buffer, v8::NewStringType::kNormal, data.mv_size);
-    const char *buffer = (const char*)(data.mv_data);
-    auto str = Nan::New<v8::String>(buffer, data.mv_size);
-
-    return str.ToLocalChecked();
-}
-
-Local<Value> valToString(MDB_val &data) {
-    // UTF-16 buffer
-    const uint16_t *buffer = reinterpret_cast<const uint16_t*>(data.mv_data);
-    // Number of UTF-16 code points
-    size_t n = data.mv_size / sizeof(uint16_t);
-    
-    // Check zero termination
-    if (n < 1 || buffer[n - 1] != 0) {
-        Nan::ThrowError("Invalid zero-terminated UTF-16 string");
-        return Nan::Undefined();
-    }
-    
-    size_t length = n - 1;
-    auto str = Nan::New<v8::String>(buffer, length);
-
-    return str.ToLocalChecked();
-}
-
-Local<Value> valToBinary(MDB_val &data) {
-    return Nan::CopyBuffer(
-        (char*)data.mv_data,
-        data.mv_size
-    ).ToLocalChecked();
-}
-
-void makeGlobalUnsafeBuffer(size_t size) {
-    globalUnsafeSize = size;
-    Local<Object> newBuffer = Nan::NewBuffer(size).ToLocalChecked();
-    globalUnsafePtr = node::Buffer::Data(newBuffer);
-    globalUnsafeBuffer->Reset(Isolate::GetCurrent(), newBuffer);
-}
-
-Local<Value> valToBinaryUnsafe(MDB_val &data) {
-    DbiWrap* dw = currentDb;
-    Compression* compression = dw->compression;
-    if (compression) {
-        if (data.mv_data == compression->decompressTarget) {
-            // already decompressed to the target, nothing more to do
-        } else {
-            if (data.mv_size > compression->decompressSize) {
-                compression->expand(data.mv_size);
-            }
-            // copy into the buffer target
-            memcpy(compression->decompressTarget, data.mv_data, data.mv_size);
-        }
-        dw->setUnsafeBuffer(compression->decompressTarget, compression->unsafeBuffer);
-    } else {
-        if (data.mv_size > globalUnsafeSize) {
-            // TODO: Provide a direct reference if for really large blocks, but we do that we need to detach that in the next turn
-            /* if(data.mv_size > 64000) {
-                dw->SetUnsafeBuffer(data.mv_data, data.mv_size);
-                return Nan::New<Number>(data.mv_size);
-            }*/
-            makeGlobalUnsafeBuffer(data.mv_size * 2);
-        }
-        memcpy(globalUnsafePtr, data.mv_data, data.mv_size);
-        dw->setUnsafeBuffer(globalUnsafePtr, *globalUnsafeBuffer);
-    }
-    return Nan::New<Number>(data.mv_size);
-}
-
-Local<Value> valToNumber(MDB_val &data) {
-    return Nan::New<Number>(*((double*)data.mv_data));
-}
-
-Local<Value> valToBoolean(MDB_val &data) {
-    return Nan::New<Boolean>(*((bool*)data.mv_data));
-}
-
-Local<Value> getVersionAndUncompress(MDB_val &data, DbiWrap* dw, Local<Value> (*successFunc)(MDB_val&)) {
-    //fprintf(stdout, "uncompressing %u\n", compressionThreshold);
-    unsigned char* charData = (unsigned char*) data.mv_data;
-    if (dw->hasVersions) {
-        lastVersion = *((double*) charData);
-//        fprintf(stderr, "getVersion %u\n", lastVersion);
-        charData = charData + 8;
-        data.mv_data = charData;
-        data.mv_size -= 8;
-    }
-    if (data.mv_size == 0) {
-        currentDb = dw;
-        return successFunc(data);
-    }
-    unsigned char statusByte = dw->compression ? charData[0] : 0;
-        //fprintf(stdout, "uncompressing status %X\n", statusByte);
-    if (statusByte >= 250) {
-        bool isValid;
-        dw->compression->decompress(data, isValid);
-        if (!isValid)
-            return Nan::Null();
-    }
-    currentDb = dw;
-    return successFunc(data);
-}
-
-NAN_METHOD(getLastVersion) {
-    if (lastVersion == NO_EXIST_VERSION)
-        return info.GetReturnValue().Set(Nan::Null());
-    return info.GetReturnValue().Set(Nan::New<Number>(lastVersion));
-}
-void setLastVersion(double version) {
-    lastVersion = version;
-}
-NAN_METHOD(setLastVersion) {
-    lastVersion = Nan::To<v8::Number>(info[0]).ToLocalChecked()->Value();
-}
-
-NAN_METHOD(setWinMemoryLimit) {
-    #if defined(_WIN32)
-    SIZE_T  dwMin = 204800, dwMax = Nan::To<v8::Number>(info[0]).ToLocalChecked()->Value();
-    if (!SetProcessWorkingSetSize(GetCurrentProcess(), dwMin, dwMax)) {
-        return throwLmdbError(GetLastError());
-    }
-    #endif
-}
-NAN_METHOD(setWinMemoryPriority) {
-    #if defined(_WIN32)
-    setProcessMemoryPriority(Nan::To<v8::Number>(info[0]).ToLocalChecked()->Value());
-    SIZE_T  dwMin = 204800, dwMax = Nan::To<v8::Number>(info[0]).ToLocalChecked()->Value();
-    if (!SetProcessWorkingSetSize(GetCurrentProcess(), dwMin, dwMax)) {
-        return throwLmdbError(GetLastError());
-    }
-    #endif
-}
-
-/*NAN_METHOD(getBufferForAddress) {
-    char* address = (char*) (size_t) Nan::To<v8::Number>(info[0]).ToLocalChecked()->Value();
-    std::unique_ptr<v8::BackingStore> backing = v8::ArrayBuffer::NewBackingStore(
-    address, 0x100000000, [](void*, size_t, void*){}, nullptr);
-    auto array_buffer = v8::ArrayBuffer::New(Isolate::GetCurrent(), std::move(backing));
-    info.GetReturnValue().Set(array_buffer);/*Nan::NewBuffer(
-        (char*)address,
-        0x3f000000, // max 1GB buffer size
-        [](char *, void *) {
-            // Data belongs to LMDB, we shouldn't free it here
-        },
-        nullptr
-    ).ToLocalChecked());*/
-//}
-
-void throwLmdbError(int rc) {
-    auto err = Nan::Error(mdb_strerror(rc));
-    (void)err.As<Object>()->Set(Nan::GetCurrentContext(), Nan::New("code").ToLocalChecked(), Nan::New(rc));
-    return Nan::ThrowError(err);
-}
-
-void consoleLog(const char *msg) {
-    Local<String> str = Nan::New("console.log('").ToLocalChecked();
-    //str = String::Concat(str, Nan::New<String>(msg).ToLocalChecked());
-    //str = String::Concat(str, Nan::New("');").ToLocalChecked());
-
-    Local<Script> script = Nan::CompileScript(str).ToLocalChecked();
-    Nan::RunScript(script);
-}
-
-void consoleLog(Local<Value> val) {
-    Local<String> str = Nan::New<String>("console.log('").ToLocalChecked();
-    //str = String::Concat(str, Local<String>::Cast(val));
-    //str = String::Concat(str, Nan::New<String>("');").ToLocalChecked());
-
-    Local<Script> script = Nan::CompileScript(str).ToLocalChecked();
-    Nan::RunScript(script);
-}
-
-void consoleLogN(int n) {
-    char c[20];
-    memset(c, 0, 20 * sizeof(char));
-    sprintf(c, "%d", n);
-    consoleLog(c);
-}
-
-void writeValueToEntry(const Local<Value> &value, MDB_val *val) {
-    if (value->IsString()) {
-        Local<String> str = Local<String>::Cast(value);
-        int strLength = str->Length();
-        // an optimized guess at buffer length that works >99% of time and has good byte alignment
-        int byteLength = str->IsOneByte() ? strLength :
-            (((strLength >> 3) + ((strLength + 116) >> 6)) << 3);
-        char *data = new char[byteLength];
-        int utfWritten = 0;
-#if NODE_VERSION_AT_LEAST(11,0,0)
-        int bytes = str->WriteUtf8(Isolate::GetCurrent(), data, byteLength, &utfWritten, v8::String::WriteOptions::NO_NULL_TERMINATION);
-#else
-        int bytes = str->WriteUtf8(data, byteLength, &utfWritten, v8::String::WriteOptions::NO_NULL_TERMINATION);
-#endif        
-        if (utfWritten < strLength) {
-            // we didn't allocate enough memory, need to expand
-            delete[] data;
-            byteLength = strLength * 3;
-            data = new char[byteLength];
-#if NODE_VERSION_AT_LEAST(11,0,0)
-            bytes = str->WriteUtf8(Isolate::GetCurrent(), data, byteLength, &utfWritten, v8::String::WriteOptions::NO_NULL_TERMINATION);
-#else
-            bytes = str->WriteUtf8(data, byteLength, &utfWritten, v8::String::WriteOptions::NO_NULL_TERMINATION);
-#endif        
-        }
-        val->mv_data = data;
-        val->mv_size = bytes;
-        //fprintf(stdout, "size of data with string %u header size %u\n", val->mv_size, headerSize);
-    } else {
-        Nan::ThrowError("Unknown value type");
-    }
-}
-
-int putWithVersion(MDB_txn *   txn,
-        MDB_dbi     dbi,
-        MDB_val *   key,
-        MDB_val *   data,
-        unsigned int    flags, double version) {
-    // leave 8 header bytes available for version and copy in with reserved memory
-    char* sourceData = (char*) data->mv_data;
-    int size = data->mv_size;
-    data->mv_size = size + 8;
-    int rc = mdb_put(txn, dbi, key, data, flags | MDB_RESERVE);
-    if (rc == 0) {
-        // if put is successful, data->mv_data will point into the database where we copy the data to
-        memcpy((char*) data->mv_data + 8, sourceData, size);
-        *((double*) data->mv_data) = version;
-    }
-    data->mv_data = sourceData; // restore this so that if it points to data that needs to be freed, it points to the right place
-    return rc;
-}
-
-
-void CustomExternalStringResource::writeTo(Local<String> str, MDB_val *val) {
-    unsigned int l = str->Length() + 1;
-    uint16_t *d = new uint16_t[l];
-    #if NODE_VERSION_AT_LEAST(12,0,0)
-    str->Write(Isolate::GetCurrent(), d);
-    #else
-    str->Write(d);
-    #endif
-    d[l - 1] = 0;
-
-    val->mv_data = d;
-    val->mv_size = l * sizeof(uint16_t);
-}
-
-CustomExternalStringResource::CustomExternalStringResource(MDB_val *val) {
-    // The UTF-16 data
-    this->d = (uint16_t*)(val->mv_data);
-    // Number of UTF-16 characters in the string
-    size_t n = val->mv_size / sizeof(uint16_t);
-    // Silently generate a 0 length if length invalid
-    this->l = n ? (n - 1) : 0;
-}
-
-CustomExternalStringResource::~CustomExternalStringResource() { }
-
-void CustomExternalStringResource::Dispose() {
-    // No need to do anything, the data is owned by LMDB, not us
-    
-    // But actually need to delete the string resource itself:
-    // the docs say that "The default implementation will use the delete operator."
-    // while initially I thought this means using delete on the string,
-    // apparently they meant just calling the destructor of this class.
-    delete this;
-}
-
-const uint16_t *CustomExternalStringResource::data() const {
-    return this->d;
-}
-
-size_t CustomExternalStringResource::length() const {
-    return this->l;
-}
-
-CustomExternalOneByteStringResource::CustomExternalOneByteStringResource(MDB_val *val) {
-    // The Latin data
-    this->d = (char*)(val->mv_data);
-    // Number of Latin characters in the string
-    this->l = val->mv_size;
-}
-
-CustomExternalOneByteStringResource::~CustomExternalOneByteStringResource() { }
-
-void CustomExternalOneByteStringResource::Dispose() {
-    // No need to do anything, the data is owned by LMDB, not us
-    
-    // But actually need to delete the string resource itself:
-    // the docs say that "The default implementation will use the delete operator."
-    // while initially I thought this means using delete on the string,
-    // apparently they meant just calling the destructor of this class.
-    delete this;
-}
-
-const char *CustomExternalOneByteStringResource::data() const {
-    return this->d;
-}
-
-size_t CustomExternalOneByteStringResource::length() const {
-    return this->l;
-}
-
-
+
+// This file is part of node-lmdb, the Node.js binding for lmdb
+// 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.
+
+#include "node-lmdb.h"
+#include <string.h>
+#include <stdio.h>
+
+static thread_local char* globalUnsafePtr;
+static thread_local size_t globalUnsafeSize;
+static thread_local Persistent<Object>* globalUnsafeBuffer;
+
+void setupExportMisc(Local<Object> exports) {
+    Local<Object> versionObj = Nan::New<Object>();
+
+    int major, minor, patch;
+    char *str = mdb_version(&major, &minor, &patch);
+    Local<Context> context = Nan::GetCurrentContext();
+    (void)versionObj->Set(context, Nan::New<String>("versionString").ToLocalChecked(), Nan::New<String>(str).ToLocalChecked());
+    (void)versionObj->Set(context, Nan::New<String>("major").ToLocalChecked(), Nan::New<Integer>(major));
+    (void)versionObj->Set(context, Nan::New<String>("minor").ToLocalChecked(), Nan::New<Integer>(minor));
+    (void)versionObj->Set(context, Nan::New<String>("patch").ToLocalChecked(), Nan::New<Integer>(patch));
+
+    (void)exports->Set(context, Nan::New<String>("version").ToLocalChecked(), versionObj);
+    Nan::SetMethod(exports, "getLastVersion", getLastVersion);
+    Nan::SetMethod(exports, "setLastVersion", setLastVersion);
+    Nan::SetMethod(exports, "bufferToKeyValue", bufferToKeyValue);
+    Nan::SetMethod(exports, "keyValueToBuffer", keyValueToBuffer);
+    Nan::SetMethod(exports, "setWinMemoryLimit", setWinMemoryLimit);
+    Nan::SetMethod(exports, "setWinMemoryPriority", setWinMemoryPriority);
+    globalUnsafeBuffer = new Persistent<Object>();
+    makeGlobalUnsafeBuffer(8);
+    fixedKeySpace = new KeySpace(true);
+}
+
+KeySpace* getFixedKeySpace() {
+    return fixedKeySpace;
+}
+
+void setFlagFromValue(int *flags, int flag, const char *name, bool defaultValue, Local<Object> options) {
+    Local<Context> context = Nan::GetCurrentContext();
+    Local<Value> opt = options->Get(context, Nan::New<String>(name).ToLocalChecked()).ToLocalChecked();
+    #if NODE_VERSION_AT_LEAST(12,0,0)
+    if (opt->IsBoolean() ? opt->BooleanValue(Isolate::GetCurrent()) : defaultValue) {
+    #else
+    if (opt->IsBoolean() ? opt->BooleanValue(context).FromJust() : defaultValue) {
+    #endif
+        *flags |= flag;
+    }
+}
+
+NodeLmdbKeyType keyTypeFromOptions(const Local<Value> &val, NodeLmdbKeyType defaultKeyType) {
+    if (!val->IsObject()) {
+        return defaultKeyType;
+    }
+    auto obj = Local<Object>::Cast(val);
+
+    NodeLmdbKeyType keyType = defaultKeyType;
+    int keyIsUint32 = 0;
+    int keyIsBuffer = 0;
+    int keyIsString = 0;
+    
+    setFlagFromValue(&keyIsUint32, 1, "keyIsUint32", false, obj);
+    setFlagFromValue(&keyIsString, 1, "keyIsString", false, obj);
+    setFlagFromValue(&keyIsBuffer, 1, "keyIsBuffer", false, obj);
+    
+    const char *keySpecificationErrorText = "You can't specify multiple key types at once. Either set keyIsUint32, or keyIsBuffer or keyIsString (default).";
+    
+    if (keyIsUint32) {
+        keyType = NodeLmdbKeyType::Uint32Key;
+        if (keyIsBuffer || keyIsString) {
+            Nan::ThrowError(keySpecificationErrorText);
+            return NodeLmdbKeyType::InvalidKey;
+        }
+    }
+    else if (keyIsBuffer) {
+        keyType = NodeLmdbKeyType::BinaryKey;
+        
+        if (keyIsUint32 || keyIsString) {
+            Nan::ThrowError(keySpecificationErrorText);
+            return NodeLmdbKeyType::InvalidKey;
+        }
+    }
+    else if (keyIsString) {
+        keyType = NodeLmdbKeyType::StringKey;
+    }
+    
+    return keyType;
+}
+
+NodeLmdbKeyType inferKeyType(const Local<Value> &val) {
+    if (val->IsString()) {
+        return NodeLmdbKeyType::StringKey;
+    }
+    if (val->IsUint32()) {
+        return NodeLmdbKeyType::Uint32Key;
+    }
+    if (node::Buffer::HasInstance(val)) {
+        return NodeLmdbKeyType::BinaryKey;
+    }
+    
+    return NodeLmdbKeyType::InvalidKey;
+}
+
+NodeLmdbKeyType inferAndValidateKeyType(const Local<Value> &key, const Local<Value> &options, NodeLmdbKeyType dbiKeyType, bool &isValid) {
+    auto keyType = keyTypeFromOptions(options, NodeLmdbKeyType::DefaultKey);
+    auto inferredKeyType = inferKeyType(key);
+    isValid = false;
+    
+    if (keyType != NodeLmdbKeyType::DefaultKey && inferredKeyType != keyType) {
+        Nan::ThrowError("Specified key type doesn't match the key you gave.");
+        return NodeLmdbKeyType::InvalidKey;
+    }
+    else {
+        keyType = inferredKeyType;
+    }
+    if (dbiKeyType == NodeLmdbKeyType::Uint32Key && keyType != NodeLmdbKeyType::Uint32Key) {
+        Nan::ThrowError("You specified keyIsUint32 on the Dbi, so you can't use other key types with it.");
+        return NodeLmdbKeyType::InvalidKey;
+    }
+    
+    isValid = true;
+    return keyType;
+}
+
+argtokey_callback_t argToKey(const Local<Value> &val, MDB_val &key, NodeLmdbKeyType keyType, bool &isValid) {
+    isValid = false;
+
+    if (keyType == NodeLmdbKeyType::DefaultKey) {
+        isValid = valueToMDBKey(val, key, *fixedKeySpace);
+    } else if (keyType == NodeLmdbKeyType::StringKey) {
+        if (!val->IsString()) {
+            Nan::ThrowError("Invalid key. Should be a string. (Specified with env.openDbi)");
+            return nullptr;
+        }
+        
+        isValid = true;
+        CustomExternalStringResource::writeTo(Local<String>::Cast(val), &key);
+        return ([](MDB_val &key) -> void {
+            delete[] (uint16_t*)key.mv_data;
+        });
+    }
+    else if (keyType == NodeLmdbKeyType::Uint32Key) {
+        if (!val->IsUint32()) {
+            Nan::ThrowError("Invalid key. Should be an unsigned 32-bit integer. (Specified with env.openDbi)");
+            return nullptr;
+        }
+        
+        isValid = true;
+        uint32_t* uint32Key = new uint32_t;
+        *uint32Key = val->Uint32Value(Nan::GetCurrentContext()).FromJust();
+        key.mv_size = sizeof(uint32_t);
+        key.mv_data = uint32Key;
+
+        return ([](MDB_val &key) -> void {
+            delete (uint32_t*)key.mv_data;
+        });
+    }
+    else if (keyType == NodeLmdbKeyType::BinaryKey) {
+        if (!node::Buffer::HasInstance(val)) {
+            Nan::ThrowError("Invalid key. Should be a Buffer. (Specified with env.openDbi)");
+            return nullptr;
+        }
+        
+        isValid = true;
+        key.mv_size = node::Buffer::Length(val);
+        key.mv_data = node::Buffer::Data(val);
+        
+        return nullptr;
+    }
+    else if (keyType == NodeLmdbKeyType::InvalidKey) {
+        Nan::ThrowError("Invalid key type. This might be a bug in node-lmdb.");
+    }
+    else {
+        Nan::ThrowError("Unknown key type. This is a bug in node-lmdb.");
+    }
+
+    return nullptr;
+}
+
+Local<Value> keyToHandle(MDB_val &key, NodeLmdbKeyType keyType) {
+    switch (keyType) {
+    case NodeLmdbKeyType::DefaultKey:
+        return MDBKeyToValue(key);
+    case NodeLmdbKeyType::Uint32Key:
+        return Nan::New<Integer>(*((uint32_t*)key.mv_data));
+    case NodeLmdbKeyType::BinaryKey:
+        return valToBinary(key);
+    case NodeLmdbKeyType::StringKey:
+        return valToString(key);
+    default:
+        Nan::ThrowError("Unknown key type. This is a bug in node-lmdb.");
+        return Nan::Undefined();
+    }
+}
+
+Local<Value> valToStringUnsafe(MDB_val &data) {
+    auto resource = new CustomExternalOneByteStringResource(&data);
+    auto str = Nan::New<v8::String>(resource);
+
+    return str.ToLocalChecked();
+}
+
+Local<Value> valToUtf8(MDB_val &data) {
+    //const uint8_t *buffer = (const uint8_t*)(data.mv_data);
+    //Isolate *isolate = Isolate::GetCurrent();
+    //auto str = v8::String::NewFromOneByte(isolate, buffer, v8::NewStringType::kNormal, data.mv_size);
+    const char *buffer = (const char*)(data.mv_data);
+    auto str = Nan::New<v8::String>(buffer, data.mv_size);
+
+    return str.ToLocalChecked();
+}
+
+Local<Value> valToString(MDB_val &data) {
+    // UTF-16 buffer
+    const uint16_t *buffer = reinterpret_cast<const uint16_t*>(data.mv_data);
+    // Number of UTF-16 code points
+    size_t n = data.mv_size / sizeof(uint16_t);
+    
+    // Check zero termination
+    if (n < 1 || buffer[n - 1] != 0) {
+        Nan::ThrowError("Invalid zero-terminated UTF-16 string");
+        return Nan::Undefined();
+    }
+    
+    size_t length = n - 1;
+    auto str = Nan::New<v8::String>(buffer, length);
+
+    return str.ToLocalChecked();
+}
+
+Local<Value> valToBinary(MDB_val &data) {
+    return Nan::CopyBuffer(
+        (char*)data.mv_data,
+        data.mv_size
+    ).ToLocalChecked();
+}
+
+void makeGlobalUnsafeBuffer(size_t size) {
+    globalUnsafeSize = size;
+    Local<Object> newBuffer = Nan::NewBuffer(size).ToLocalChecked();
+    globalUnsafePtr = node::Buffer::Data(newBuffer);
+    globalUnsafeBuffer->Reset(Isolate::GetCurrent(), newBuffer);
+}
+
+Local<Value> valToBinaryUnsafe(MDB_val &data) {
+    DbiWrap* dw = currentDb;
+    Compression* compression = dw->compression;
+    if (compression) {
+        if (data.mv_data == compression->decompressTarget) {
+            // already decompressed to the target, nothing more to do
+        } else {
+            if (data.mv_size > compression->decompressSize) {
+                compression->expand(data.mv_size);
+            }
+            // copy into the buffer target
+            memcpy(compression->decompressTarget, data.mv_data, data.mv_size);
+        }
+        dw->setUnsafeBuffer(compression->decompressTarget, compression->unsafeBuffer);
+    } else {
+        if (data.mv_size > globalUnsafeSize) {
+            // TODO: Provide a direct reference if for really large blocks, but we do that we need to detach that in the next turn
+            /* if(data.mv_size > 64000) {
+                dw->SetUnsafeBuffer(data.mv_data, data.mv_size);
+                return Nan::New<Number>(data.mv_size);
+            }*/
+            makeGlobalUnsafeBuffer(data.mv_size * 2);
+        }
+        memcpy(globalUnsafePtr, data.mv_data, data.mv_size);
+        dw->setUnsafeBuffer(globalUnsafePtr, *globalUnsafeBuffer);
+    }
+    return Nan::New<Number>(data.mv_size);
+}
+
+Local<Value> valToNumber(MDB_val &data) {
+    return Nan::New<Number>(*((double*)data.mv_data));
+}
+
+Local<Value> valToBoolean(MDB_val &data) {
+    return Nan::New<Boolean>(*((bool*)data.mv_data));
+}
+
+Local<Value> getVersionAndUncompress(MDB_val &data, DbiWrap* dw, Local<Value> (*successFunc)(MDB_val&)) {
+    //fprintf(stdout, "uncompressing %u\n", compressionThreshold);
+    unsigned char* charData = (unsigned char*) data.mv_data;
+    if (dw->hasVersions) {
+        lastVersion = *((double*) charData);
+//        fprintf(stderr, "getVersion %u\n", lastVersion);
+        charData = charData + 8;
+        data.mv_data = charData;
+        data.mv_size -= 8;
+    }
+    if (data.mv_size == 0) {
+        currentDb = dw;
+        return successFunc(data);
+    }
+    unsigned char statusByte = dw->compression ? charData[0] : 0;
+        //fprintf(stdout, "uncompressing status %X\n", statusByte);
+    if (statusByte >= 250) {
+        bool isValid;
+        dw->compression->decompress(data, isValid);
+        if (!isValid)
+            return Nan::Null();
+    }
+    currentDb = dw;
+    return successFunc(data);
+}
+
+NAN_METHOD(getLastVersion) {
+    if (lastVersion == NO_EXIST_VERSION)
+        return info.GetReturnValue().Set(Nan::Null());
+    return info.GetReturnValue().Set(Nan::New<Number>(lastVersion));
+}
+void setLastVersion(double version) {
+    lastVersion = version;
+}
+NAN_METHOD(setLastVersion) {
+    lastVersion = Nan::To<v8::Number>(info[0]).ToLocalChecked()->Value();
+}
+
+NAN_METHOD(setWinMemoryLimit) {
+    #if defined(_WIN32)
+    SIZE_T  dwMin = 204800, dwMax = Nan::To<v8::Number>(info[0]).ToLocalChecked()->Value();
+    if (!SetProcessWorkingSetSize(GetCurrentProcess(), dwMin, dwMax)) {
+        return throwLmdbError(GetLastError());
+    }
+    #endif
+}
+NAN_METHOD(setWinMemoryPriority) {
+    #if defined(_WIN32)
+    setProcessMemoryPriority(Nan::To<v8::Number>(info[0]).ToLocalChecked()->Value());
+    SIZE_T  dwMin = 204800, dwMax = Nan::To<v8::Number>(info[0]).ToLocalChecked()->Value();
+    if (!SetProcessWorkingSetSize(GetCurrentProcess(), dwMin, dwMax)) {
+        return throwLmdbError(GetLastError());
+    }
+    #endif
+}
+
+/*NAN_METHOD(getBufferForAddress) {
+    char* address = (char*) (size_t) Nan::To<v8::Number>(info[0]).ToLocalChecked()->Value();
+    std::unique_ptr<v8::BackingStore> backing = v8::ArrayBuffer::NewBackingStore(
+    address, 0x100000000, [](void*, size_t, void*){}, nullptr);
+    auto array_buffer = v8::ArrayBuffer::New(Isolate::GetCurrent(), std::move(backing));
+    info.GetReturnValue().Set(array_buffer);/*Nan::NewBuffer(
+        (char*)address,
+        0x3f000000, // max 1GB buffer size
+        [](char *, void *) {
+            // Data belongs to LMDB, we shouldn't free it here
+        },
+        nullptr
+    ).ToLocalChecked());*/
+//}
+
+void throwLmdbError(int rc) {
+    auto err = Nan::Error(mdb_strerror(rc));
+    (void)err.As<Object>()->Set(Nan::GetCurrentContext(), Nan::New("code").ToLocalChecked(), Nan::New(rc));
+    return Nan::ThrowError(err);
+}
+
+void consoleLog(const char *msg) {
+    Local<String> str = Nan::New("console.log('").ToLocalChecked();
+    //str = String::Concat(str, Nan::New<String>(msg).ToLocalChecked());
+    //str = String::Concat(str, Nan::New("');").ToLocalChecked());
+
+    Local<Script> script = Nan::CompileScript(str).ToLocalChecked();
+    Nan::RunScript(script);
+}
+
+void consoleLog(Local<Value> val) {
+    Local<String> str = Nan::New<String>("console.log('").ToLocalChecked();
+    //str = String::Concat(str, Local<String>::Cast(val));
+    //str = String::Concat(str, Nan::New<String>("');").ToLocalChecked());
+
+    Local<Script> script = Nan::CompileScript(str).ToLocalChecked();
+    Nan::RunScript(script);
+}
+
+void consoleLogN(int n) {
+    char c[20];
+    memset(c, 0, 20 * sizeof(char));
+    sprintf(c, "%d", n);
+    consoleLog(c);
+}
+
+void writeValueToEntry(const Local<Value> &value, MDB_val *val) {
+    if (value->IsString()) {
+        Local<String> str = Local<String>::Cast(value);
+        int strLength = str->Length();
+        // an optimized guess at buffer length that works >99% of time and has good byte alignment
+        int byteLength = str->IsOneByte() ? strLength :
+            (((strLength >> 3) + ((strLength + 116) >> 6)) << 3);
+        char *data = new char[byteLength];
+        int utfWritten = 0;
+#if NODE_VERSION_AT_LEAST(11,0,0)
+        int bytes = str->WriteUtf8(Isolate::GetCurrent(), data, byteLength, &utfWritten, v8::String::WriteOptions::NO_NULL_TERMINATION);
+#else
+        int bytes = str->WriteUtf8(data, byteLength, &utfWritten, v8::String::WriteOptions::NO_NULL_TERMINATION);
+#endif        
+        if (utfWritten < strLength) {
+            // we didn't allocate enough memory, need to expand
+            delete[] data;
+            byteLength = strLength * 3;
+            data = new char[byteLength];
+#if NODE_VERSION_AT_LEAST(11,0,0)
+            bytes = str->WriteUtf8(Isolate::GetCurrent(), data, byteLength, &utfWritten, v8::String::WriteOptions::NO_NULL_TERMINATION);
+#else
+            bytes = str->WriteUtf8(data, byteLength, &utfWritten, v8::String::WriteOptions::NO_NULL_TERMINATION);
+#endif        
+        }
+        val->mv_data = data;
+        val->mv_size = bytes;
+        //fprintf(stdout, "size of data with string %u header size %u\n", val->mv_size, headerSize);
+    } else {
+        Nan::ThrowError("Unknown value type");
+    }
+}
+
+int putWithVersion(MDB_txn *   txn,
+        MDB_dbi     dbi,
+        MDB_val *   key,
+        MDB_val *   data,
+        unsigned int    flags, double version) {
+    // leave 8 header bytes available for version and copy in with reserved memory
+    char* sourceData = (char*) data->mv_data;
+    int size = data->mv_size;
+    data->mv_size = size + 8;
+    int rc = mdb_put(txn, dbi, key, data, flags | MDB_RESERVE);
+    if (rc == 0) {
+        // if put is successful, data->mv_data will point into the database where we copy the data to
+        memcpy((char*) data->mv_data + 8, sourceData, size);
+        *((double*) data->mv_data) = version;
+    }
+    data->mv_data = sourceData; // restore this so that if it points to data that needs to be freed, it points to the right place
+    return rc;
+}
+
+
+void CustomExternalStringResource::writeTo(Local<String> str, MDB_val *val) {
+    unsigned int l = str->Length() + 1;
+    uint16_t *d = new uint16_t[l];
+    #if NODE_VERSION_AT_LEAST(12,0,0)
+    str->Write(Isolate::GetCurrent(), d);
+    #else
+    str->Write(d);
+    #endif
+    d[l - 1] = 0;
+
+    val->mv_data = d;
+    val->mv_size = l * sizeof(uint16_t);
+}
+
+CustomExternalStringResource::CustomExternalStringResource(MDB_val *val) {
+    // The UTF-16 data
+    this->d = (uint16_t*)(val->mv_data);
+    // Number of UTF-16 characters in the string
+    size_t n = val->mv_size / sizeof(uint16_t);
+    // Silently generate a 0 length if length invalid
+    this->l = n ? (n - 1) : 0;
+}
+
+CustomExternalStringResource::~CustomExternalStringResource() { }
+
+void CustomExternalStringResource::Dispose() {
+    // No need to do anything, the data is owned by LMDB, not us
+    
+    // But actually need to delete the string resource itself:
+    // the docs say that "The default implementation will use the delete operator."
+    // while initially I thought this means using delete on the string,
+    // apparently they meant just calling the destructor of this class.
+    delete this;
+}
+
+const uint16_t *CustomExternalStringResource::data() const {
+    return this->d;
+}
+
+size_t CustomExternalStringResource::length() const {
+    return this->l;
+}
+
+CustomExternalOneByteStringResource::CustomExternalOneByteStringResource(MDB_val *val) {
+    // The Latin data
+    this->d = (char*)(val->mv_data);
+    // Number of Latin characters in the string
+    this->l = val->mv_size;
+}
+
+CustomExternalOneByteStringResource::~CustomExternalOneByteStringResource() { }
+
+void CustomExternalOneByteStringResource::Dispose() {
+    // No need to do anything, the data is owned by LMDB, not us
+    
+    // But actually need to delete the string resource itself:
+    // the docs say that "The default implementation will use the delete operator."
+    // while initially I thought this means using delete on the string,
+    // apparently they meant just calling the destructor of this class.
+    delete this;
+}
+
+const char *CustomExternalOneByteStringResource::data() const {
+    return this->d;
+}
+
+size_t CustomExternalOneByteStringResource::length() const {
+    return this->l;
+}
+
+