oracledb 2.2.0 → 2.3.0

package/src/njsConnection.cpp

@@ -51,6 +51,7 @@
 
 #include "njsConnection.h"
 #include "njsResultSet.h"
+#include "njsSubscription.h"
 #include "njsIntLob.h"
 #include <stdlib.h>
 #include <limits>
@@ -89,6 +90,8 @@ void njsConnection::Init(Local<Object> target)
     Nan::SetPrototypeMethod(tpl, "createLob", CreateLob);
     Nan::SetPrototypeMethod(tpl, "changePassword", ChangePassword);
     Nan::SetPrototypeMethod(tpl, "ping", Ping);
+    Nan::SetPrototypeMethod(tpl, "subscribe", Subscribe);
+    Nan::SetPrototypeMethod(tpl, "unsubscribe", Unsubscribe);
 
     Nan::SetAccessor(tpl->InstanceTemplate(),
             Nan::New<v8::String>("stmtCacheSize").ToLocalChecked(),
@@ -197,6 +200,9 @@ bool njsConnection::ProcessQueryVars(njsBaton *baton, dpiStmt *dpiStmtHandle,
             case DPI_ORACLE_TYPE_NCHAR:
             case DPI_ORACLE_TYPE_RAW:
                 vars[i].maxSize = queryInfo.typeInfo.clientSizeInBytes;
+                if (queryInfo.typeInfo.oracleTypeNum == DPI_ORACLE_TYPE_RAW &&
+                        vars[i].varTypeNum == DPI_ORACLE_TYPE_VARCHAR)
+                    vars[i].maxSize *= 2;
                 break;
             case DPI_ORACLE_TYPE_DATE:
             case DPI_ORACLE_TYPE_TIMESTAMP:
@@ -376,51 +382,56 @@ bool njsConnection::MapByName(njsBaton *baton, dpiQueryInfo *queryInfo,
 bool njsConnection::MapByType(njsBaton *baton, dpiQueryInfo *queryInfo,
         dpiOracleTypeNum &targetType)
 {
-    if (baton->fetchAsStringTypes || baton->fetchAsBufferTypes) {
+    uint32_t i;
+
+    // handle fetchAsString
+    for (i = 0; i < baton->numFetchAsStringTypes; i++) {
         switch (queryInfo->typeInfo.oracleTypeNum) {
             case DPI_ORACLE_TYPE_NUMBER:
             case DPI_ORACLE_TYPE_NATIVE_FLOAT:
             case DPI_ORACLE_TYPE_NATIVE_DOUBLE:
             case DPI_ORACLE_TYPE_NATIVE_INT:
-                for (uint32_t i = 0; i < baton->numFetchAsStringTypes; i++) {
-                    if (baton->fetchAsStringTypes[i] == NJS_DATATYPE_NUM) {
-                        targetType = DPI_ORACLE_TYPE_VARCHAR;
-                        return true;
-                    }
+                if (baton->fetchAsStringTypes[i] == NJS_DATATYPE_NUM) {
+                    targetType = DPI_ORACLE_TYPE_VARCHAR;
+                    return true;
                 }
                 break;
             case DPI_ORACLE_TYPE_DATE:
             case DPI_ORACLE_TYPE_TIMESTAMP:
             case DPI_ORACLE_TYPE_TIMESTAMP_TZ:
             case DPI_ORACLE_TYPE_TIMESTAMP_LTZ:
-                for (uint32_t i = 0; i < baton->numFetchAsStringTypes; i++) {
-                    if (baton->fetchAsStringTypes[i] == NJS_DATATYPE_DATE) {
-                        targetType = DPI_ORACLE_TYPE_VARCHAR;
-                        return true;
-                    }
+                if (baton->fetchAsStringTypes[i] == NJS_DATATYPE_DATE) {
+                    targetType = DPI_ORACLE_TYPE_VARCHAR;
+                    return true;
                 }
                 break;
             case DPI_ORACLE_TYPE_CLOB:
             case DPI_ORACLE_TYPE_NCLOB:
-                for (uint32_t i = 0; i < baton->numFetchAsStringTypes; i++) {
-                    if (baton->fetchAsStringTypes[i] == NJS_DATATYPE_CLOB) {
-                        targetType = DPI_ORACLE_TYPE_VARCHAR;
-                        return true;
-                    }
+                if (baton->fetchAsStringTypes[i] == NJS_DATATYPE_CLOB) {
+                    targetType = DPI_ORACLE_TYPE_VARCHAR;
+                    return true;
                 }
                 break;
-            case DPI_ORACLE_TYPE_BLOB:
-                for (uint32_t i = 0; i < baton->numFetchAsBufferTypes; i++) {
-                    if (baton->fetchAsBufferTypes[i] == NJS_DATATYPE_BLOB) {
-                        targetType = DPI_ORACLE_TYPE_RAW;
-                        return true;
-                    }
+            case DPI_ORACLE_TYPE_RAW:
+                if (baton->fetchAsStringTypes[i] == NJS_DATATYPE_BUFFER) {
+                    targetType = DPI_ORACLE_TYPE_VARCHAR;
+                    return true;
                 }
                 break;
             default:
                 break;
         }
     }
+
+    // handle fetchAsBuffer
+    for (i = 0; i < baton->numFetchAsBufferTypes; i++) {
+        if (queryInfo->typeInfo.oracleTypeNum == DPI_ORACLE_TYPE_BLOB &&
+                baton->fetchAsBufferTypes[i] == NJS_DATATYPE_BLOB) {
+            targetType = DPI_ORACLE_TYPE_RAW;
+            return true;
+        }
+    }
+
     return false;
 }
 
@@ -630,7 +641,7 @@ bool njsConnection::ProcessExecuteBinds(Local<Object> binds, njsBaton *baton)
 
     // determine bind names (if binding by name)
     baton->bindArraySize = 1;
-    if (!binds->IsArray())
+    if (!binds->IsUndefined() && !binds->IsArray())
         bindNames = binds->GetOwnPropertyNames();
 
     // initialize variables; if there are no variables, nothing further to do!
@@ -752,7 +763,7 @@ bool njsConnection::ScanExecuteBindUnit(Local<Object> bindUnit,
     for (uint32_t i = 0; i < keys->Length(); i++) {
         Local<String> temp =
                 Nan::Get(keys, i).ToLocalChecked().As<String>();
-        v8::String::Utf8Value utf8str(temp);
+        Nan::Utf8String utf8str(temp);
         std::string key =
                 std::string(*utf8str, static_cast<size_t>(utf8str.length()));
         if (key.compare("dir") == 0 || key.compare("type") == 0 ||
@@ -852,7 +863,7 @@ bool njsConnection::ProcessExecuteManyBinds(Local<Array> binds,
     // the number of bind variables and types
     if (scanRequired)
         bindDefs = Nan::Get(binds, 0).ToLocalChecked();
-    if (!bindDefs->IsArray())
+    if (!bindDefs->IsUndefined() && !bindDefs->IsArray())
         bindNames = bindDefs.As<Object>()->GetOwnPropertyNames();
 
     // initialize variables; if there are no variables, nothing further to do!
@@ -1023,12 +1034,11 @@ bool njsConnection::InitBindVars(Local<Object> bindObj,
 
     // create bind variables (one for each element of the bind array or each
     // property of the bind object)
-    if (byPosition)
+    if (bindObj->IsUndefined())
+        baton->numBindVars = 0;
+    else if (byPosition)
         baton->numBindVars = bindObj.As<Array>()->Length();
-    else {
-        bindNames = bindObj->GetOwnPropertyNames();
-        baton->numBindVars = bindNames->Length();
-    }
+    else baton->numBindVars = bindNames->Length();
     baton->bindVars = new njsVariable[baton->numBindVars];
 
     // initialize bind variables (set position or name)
@@ -1038,7 +1048,7 @@ bool njsConnection::InitBindVars(Local<Object> bindObj,
             var->pos = i + 1;
         else {
             Local<Value> temp = Nan::Get(bindNames, i).ToLocalChecked();
-            v8::String::Utf8Value v8str(temp->ToString());
+            Nan::Utf8String v8str(temp->ToString());
             std::string str = std::string(*v8str,
                     static_cast<size_t>(v8str.length()));
             var->name = ":" + str;
@@ -1120,7 +1130,7 @@ bool njsConnection::ProcessScalarBindValue(Local<Value> value,
         bindOk = (var->varTypeNum == DPI_ORACLE_TYPE_VARCHAR ||
                 var->varTypeNum == DPI_ORACLE_TYPE_CLOB);
         if (bindOk) {
-            v8::String::Utf8Value utf8str(value);
+            Nan::Utf8String utf8str(value);
             if (utf8str.length() == 0)
                 data->isNull = 1;
             else if (inExecuteMany &&
@@ -1245,7 +1255,7 @@ bool njsConnection::GetBindTypeAndSizeFromValue(njsVariable *var,
         *maxSize = 1;
     } else if (value->IsString()) {
         *bindType = NJS_DATATYPE_STR;
-        v8::String::Utf8Value utf8str(value->ToString());
+        Nan::Utf8String utf8str(value->ToString());
         *maxSize = static_cast<uint32_t>(utf8str.length());
     } else if (value->IsInt32() || value->IsUint32()) {
         *bindType = NJS_DATATYPE_INT;
@@ -1333,7 +1343,7 @@ bool njsConnection::ProcessExecuteOptions(Local<Object> options,
             baton->fetchInfo = new njsFetchInfo[baton->numFetchInfo];
         for (uint32_t i = 0; i < baton->numFetchInfo; i++) {
             Local<Value> temp = Nan::Get(keys, i).ToLocalChecked();
-            v8::String::Utf8Value utf8str(temp->ToString());
+            Nan::Utf8String utf8str(temp->ToString());
             baton->fetchInfo[i].name = std::string(*utf8str,
                     static_cast<size_t>(utf8str.length()));
             Local<Object> colInfo =
@@ -1379,6 +1389,75 @@ bool njsConnection::ProcessExecuteManyOptions(Local<Object> options,
 }
 
 
+//-----------------------------------------------------------------------------
+// njsConnection::ProcessSubscriptionOptions()
+//   Processing of options for connection.subscribe(). If an error is detected,
+// the baton error is populated and false is returned.
+//-----------------------------------------------------------------------------
+bool njsConnection::ProcessSubscriptionOptions(Local<Object> options,
+        njsBaton *baton)
+{
+    Nan::HandleScope scope;
+    uint32_t temp;
+
+    // if subscription doesn't exist, get options for creating subscription
+    if (!baton->dpiSubscrHandle) {
+        temp = DPI_SUBSCR_NAMESPACE_DBCHANGE;
+        if (!baton->GetUnsignedIntFromJSON(options, "namespace", 1,
+                &temp))
+            return false;
+        baton->subscription->SetNamespace((dpiSubscrNamespace) temp);
+        if (!baton->GetStringFromJSON(options, "ipAddress", 1,
+                baton->ipAddress))
+            return false;
+        if (!baton->GetUnsignedIntFromJSON(options, "port", 1,
+                &baton->portNumber))
+            return false;
+        if (!baton->GetUnsignedIntFromJSON(options, "timeout", 1,
+                &baton->timeout))
+            return false;
+        if (!baton->GetUnsignedIntFromJSON(options, "operations", 1,
+                &baton->operations))
+            return false;
+        if (!baton->GetUnsignedIntFromJSON(options, "qos", 1, &baton->qos))
+            return false;
+        if (!baton->GetUnsignedIntFromJSON(options, "groupingClass", 1,
+                &baton->subscrGroupingClass))
+            return false;
+        if (!baton->GetUnsignedIntFromJSON(options, "groupingValue", 1,
+                &baton->subscrGroupingValue))
+            return false;
+        if (!baton->GetUnsignedIntFromJSON(options, "groupingType", 1,
+                &baton->subscrGroupingType))
+            return false;
+        Local<Function> callback;
+        if (!baton->GetFunctionFromJSON(options, "callback", 1, &callback))
+            return false;
+        if (callback.IsEmpty())
+            baton->error = njsMessages::Get(errMissingSubscrCallback);
+        else baton->subscription->SetCallback(callback);
+    }
+
+    // get options that are used for registering queries
+    if (baton->subscription->GetNamespace() == DPI_SUBSCR_NAMESPACE_DBCHANGE) {
+        if (!baton->GetStringFromJSON(options, "sql", 1, baton->sql))
+            return false;
+        if (baton->sql.empty()) {
+            baton->error = njsMessages::Get(errMissingSubscrSql);
+            return false;
+        }
+        Local<Value> binds;
+        Local<String> key = Nan::New("binds").ToLocalChecked();
+        if (!Nan::Get(options, key).ToLocal(&binds))
+            return false;
+        if (!ProcessExecuteBinds(binds.As<Object>(), baton))
+            return false;
+    }
+
+    return true;
+}
+
+
 //-----------------------------------------------------------------------------
 // njsConnection::GetScalarValueFromVar()
 //   Get the value from the DPI variable of the specified type at the specified
@@ -1591,7 +1670,7 @@ void njsConnection::SetTextAttribute(Nan::NAN_SETTER_ARGS_TYPE args,
         Nan::ThrowError(errMsg.c_str());
         return;
     }
-    v8::String::Utf8Value utfstr(value->ToString());
+    Nan::Utf8String utfstr(value->ToString());
     uint32_t valueLength = static_cast<uint32_t>(utfstr.length());
     if ((*setter)(connection->dpiConnHandle, *utfstr, valueLength) < 0)
         njsOracledb::ThrowDPIError();
@@ -2387,6 +2466,177 @@ void njsConnection::Async_Ping(njsBaton *baton)
 }
 
 
+//-----------------------------------------------------------------------------
+// njsConnection::Subscribe()
+//   Subscribe to events from the database. The provided callback will be
+// invoked each time a notification is received. The name is used to uniquely
+// identify a subscription and a reference is stored on the oracledb instance
+// for use by subsequent calls to subscribe() or unsubscribe().
+//
+// PARAMETERS
+//   - JS callback which will receive (error)
+//-----------------------------------------------------------------------------
+NAN_METHOD(njsConnection::Subscribe)
+{
+    njsConnection *connection;
+    std::string name;
+    njsBaton *baton;
+
+    connection = (njsConnection*) ValidateArgs(info, 3, 3);
+    if (!connection)
+        return;
+    if (!connection->GetStringArg(info, 0, name))
+        return;
+    baton = connection->CreateBaton(info);
+    if (!baton)
+        return;
+    baton->name = name;
+    baton->SetDPIConnHandle(connection->dpiConnHandle);
+    baton->subscription = njsOracledb::GetSubscription(name);
+    if (baton->subscription)
+        baton->subscription->SetDPISubscrHandle(baton);
+    else {
+        Local<Object> obj = njsSubscription::Create();
+        baton->subscription = Nan::ObjectWrap::Unwrap<njsSubscription>(obj);
+        baton->jsSubscription.Reset(obj);
+    }
+    Local<Object> options = info[1].As<Object>();
+    ProcessSubscriptionOptions(options, baton);
+    baton->QueueWork("Subscribe", Async_Subscribe, Async_AfterSubscribe, 1);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Async_Subscribe()
+//   Worker function for njsConnection::Subscribe() method.
+//-----------------------------------------------------------------------------
+void njsConnection::Async_Subscribe(njsBaton *baton)
+{
+    // create subscription, if necessary
+    if (!baton->dpiSubscrHandle) {
+        dpiSubscrCreateParams params;
+        dpiContext *context = njsOracledb::GetDPIContext();
+        if (dpiContext_initSubscrCreateParams(context, &params) < 0) {
+            baton->GetDPIError();
+            return;
+        }
+        params.subscrNamespace = baton->subscription->GetNamespace();
+        params.name = baton->name.c_str();
+        params.nameLength = baton->name.length();
+        params.protocol = DPI_SUBSCR_PROTO_CALLBACK;
+        params.callback = (dpiSubscrCallback) njsSubscription::EventHandler;
+        params.callbackContext = baton->subscription;
+        params.ipAddress = baton->ipAddress.c_str();
+        params.ipAddressLength = baton->ipAddress.length();
+        params.portNumber = baton->portNumber;
+        params.timeout = baton->timeout;
+        params.qos = (dpiSubscrQOS) baton->qos;
+        params.operations = (dpiOpCode) baton->operations;
+        params.groupingClass = (uint8_t) baton->subscrGroupingClass;
+        params.groupingValue = baton->subscrGroupingValue;
+        params.groupingType = (uint8_t) baton->subscrGroupingType;
+        if (dpiConn_subscribe(baton->dpiConnHandle, &params,
+                &baton->dpiSubscrHandle) < 0) {
+            baton->GetDPIError();
+            return;
+        }
+    }
+
+    // register query if applicable
+    if (!baton->sql.empty()) {
+
+        // prepare statement for registration
+        if (dpiSubscr_prepareStmt(baton->dpiSubscrHandle, baton->sql.c_str(),
+                (uint32_t) baton->sql.length(), &baton->dpiStmtHandle) < 0) {
+            baton->GetDPIError();
+            return;
+        }
+
+        // perform any binds necessary
+        for (uint32_t i = 0; i < baton->numBindVars; i++) {
+            int status;
+            njsVariable *var = &baton->bindVars[i];
+            if (var->name.empty())
+                status = dpiStmt_bindByPos(baton->dpiStmtHandle, var->pos,
+                        var->dpiVarHandle);
+            else status = dpiStmt_bindByName(baton->dpiStmtHandle,
+                    var->name.c_str(), (uint32_t) var->name.length(),
+                    var->dpiVarHandle);
+            if (status < 0) {
+                baton->GetDPIError();
+                return;
+            }
+        }
+
+        // perform execute (which registers the query)
+        if (dpiStmt_execute(baton->dpiStmtHandle, DPI_MODE_EXEC_DEFAULT,
+                NULL) < 0)
+            baton->GetDPIError();
+
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Async_AfterSubscribe()
+//   Returns result to JS by invoking JS callback.
+//-----------------------------------------------------------------------------
+void njsConnection::Async_AfterSubscribe(njsBaton *baton, Local<Value> argv[])
+{
+    baton->subscription->StartNotifications(baton);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Unsubscribe()
+//   Unsubscribe from events in the database that were originally subscribed
+// with a call to connection.subscribe().
+//
+// PARAMETERS
+//   - JS callback which will receive (error)
+//-----------------------------------------------------------------------------
+NAN_METHOD(njsConnection::Unsubscribe)
+{
+    njsConnection *connection;
+    std::string name;
+    njsBaton *baton;
+
+    connection = (njsConnection*) ValidateArgs(info, 2, 2);
+    if (!connection)
+        return;
+    if (!connection->GetStringArg(info, 0, name))
+        return;
+    baton = connection->CreateBaton(info);
+    if (!baton)
+        return;
+    baton->name = name;
+    baton->subscription = njsOracledb::GetSubscription(name);
+    if (baton->subscription) {
+        baton->subscription->SetDPISubscrHandle(baton);
+        baton->SetDPIConnHandle(connection->dpiConnHandle);
+    } else {
+        baton->error = njsMessages::Get(errInvalidSubscription);
+    }
+    baton->QueueWork("Unsubscribe", Async_Unsubscribe, NULL, 1);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Async_Unsubscribe()
+//   Worker function for njsConnection::Unsubscribe() method.
+//-----------------------------------------------------------------------------
+void njsConnection::Async_Unsubscribe(njsBaton *baton)
+{
+    if (dpiConn_unsubscribe(baton->dpiConnHandle, baton->dpiSubscrHandle) < 0)
+        baton->GetDPIError();
+    else {
+        baton->dpiSubscrHandle = NULL;
+        baton->subscription->StopNotifications();
+    }
+    baton->subscription = NULL;
+}
+
+
 //-----------------------------------------------------------------------------
 // njsConnection::GetStmtCacheSize()
 //   Get accessor of "stmtCacheSize" property.

package/src/njsConnection.h

@@ -73,6 +73,7 @@ public:
             bool extendedMetaData);
     static bool GetScalarValueFromVar(njsBaton *baton, njsVariable *var,
             njsVariableBuffer *buffer, uint32_t pos, Local<Value> &value);
+    static bool ProcessExecuteBinds(Local<Object> binds, njsBaton *baton);
     static bool ProcessQueryVars(njsBaton* baton, dpiStmt *dpiStmtHandle,
             njsVariable *vars, uint32_t numVars);
     static bool ProcessVars(njsBaton *baton, njsVariable *vars,
@@ -139,6 +140,15 @@ private:
     static NAN_METHOD(Ping);
     static void Async_Ping(njsBaton *baton);
 
+    // Subscribe Method on Connection class
+    static NAN_METHOD(Subscribe);
+    static void Async_Subscribe(njsBaton *baton);
+    static void Async_AfterSubscribe(njsBaton *baton, Local<Value> argv[]);
+
+    // Unsubscribe Method on Connection class
+    static NAN_METHOD(Unsubscribe);
+    static void Async_Unsubscribe(njsBaton *baton);
+
     // Define Getter Accessors to properties
     static NAN_GETTER(GetStmtCacheSize);
     static NAN_GETTER(GetClientId);
@@ -176,7 +186,6 @@ private:
     static bool PrepareAndBind(njsBaton* baton);
     static bool ProcessBindValue(Local<Value> bindValue, njsVariable *var,
             njsBaton *baton);
-    static bool ProcessExecuteBinds(Local<Object> binds, njsBaton *baton);
     static bool ProcessExecuteManyBinds(Local<Array> binds,
             Local<Object> options, njsBaton *baton);
     static bool ProcessExecuteOptions(Local<Object> options, njsBaton *baton);
@@ -185,6 +194,8 @@ private:
     static bool ProcessScalarBindValue(Local<Value> bindValue,
             njsVariable *var, uint32_t pos, bool inExecuteMany,
             njsBaton *baton);
+    static bool ProcessSubscriptionOptions(Local<Object> options,
+            njsBaton *baton);
     static bool ProcessVarBuffer(njsBaton *baton, njsVariable *var,
             njsVariableBuffer *buffer);
     static bool ScanExecuteBinds(Local<Object> binds, Local<Array> bindNames,

package/src/njsIntLob.cpp

@@ -189,6 +189,10 @@ bool njsILob::ClearDPILobHandle(njsBaton *baton)
         baton->GetDPIError();
         return false;
     }
+    if (dpiLob_release(dpiLobHandle) < 0) {
+        baton->GetDPIError();
+        return false;
+    }
     dpiLobHandle = NULL;
     return true;
 }

package/src/njsMessages.cpp

@@ -89,6 +89,9 @@ static const char *errMsg[] = {
     "NJS-058: maxSize of %u is too small for value of length %u in row %u", // errMaxSizeTooSmall
     "NJS-059: type must be specified for bind position %u", // errMissingTypeByPos
     "NJS-060: type must be specified for bind \"%s\"", // errMissingTypeByName
+    "NJS-061: invalid subscription", // errInvalidSubscription
+    "NJS-062: subscription notification callback missing", // errMissingSubscrCallback
+    "NJS-063: subscription notification SQL missing", // errMissingSubscrSql
 };
 
 

package/src/njsMessages.h

@@ -92,6 +92,9 @@ typedef enum {
     errMaxSizeTooSmall,
     errMissingTypeByPos,
     errMissingTypeByName,
+    errInvalidSubscription,
+    errMissingSubscrCallback,
+    errMissingSubscrSql,
 
     // New ones should be added here
 

package/src/njsOracle.cpp

@@ -56,11 +56,15 @@
 #include "njsResultSet.h"
 #include "njsMessages.h"
 #include "njsIntLob.h"
+#include "njsSubscription.h"
 #include <sstream>
 
 // peristent Oracledb class handle
 Nan::Persistent<FunctionTemplate> njsOracledb::oracledbTemplate_s;
 
+// persistent handle for subscriptions
+Nan::Persistent<Object> njsOracledb::subscriptions;
+
 // DPI context
 dpiContext *njsOracledb::globalDPIContext = NULL;
 
@@ -191,6 +195,9 @@ void njsOracledb::Init(Local<Object> target)
     oracledbTemplate_s.Reset(temp);
     Nan::Set(target, Nan::New<v8::String>("Oracledb").ToLocalChecked(),
             temp->GetFunction());
+
+    Local<Object> obj = Nan::New<v8::Object>();
+    subscriptions.Reset(obj);
 }
 
 
@@ -729,6 +736,7 @@ NAN_SETTER(njsOracledb::SetFetchAsString)
         switch (type) {
             case NJS_DATATYPE_NUM:
             case NJS_DATATYPE_DATE:
+            case NJS_DATATYPE_BUFFER:
             case NJS_DATATYPE_CLOB:
                 break;
             default:
@@ -1052,6 +1060,7 @@ NAN_METHOD(njsOracledb::CreatePool)
     baton->GetIntFromJSON(poolProps, "poolPingInterval", 0,
             &baton->poolPingInterval);
     baton->GetBoolFromJSON(poolProps, "externalAuth", 0, &baton->externalAuth);
+    baton->GetBoolFromJSON(poolProps, "homogeneous", 0, &baton->homogeneous);
     baton->GetBoolFromJSON(poolProps, "events", 0, &baton->events);
     baton->GetStringFromJSON(poolProps, "edition", 0, baton->edition);
     baton->lobPrefetchSize = oracledb->lobPrefetchSize;
@@ -1079,6 +1088,8 @@ void njsOracledb::Async_CreatePool(njsBaton *baton)
     params.maxSessions = baton->poolMax;
     params.sessionIncrement = baton->poolIncrement;
     params.externalAuth = baton->externalAuth;
+    params.homogeneous = baton->homogeneous;
+
     if (params.externalAuth)
         params.homogeneous = 0;
     params.pingInterval = baton->poolPingInterval;
@@ -1183,6 +1194,50 @@ void njsOracledb::ThrowDPIError(void)
 }
 
 
+//-----------------------------------------------------------------------------
+// njsOracledb::GetSubscription()
+//   Gets the subscription with the give name if it exists, or returns NULL if
+// it does not exist in the subscriptions object.
+//-----------------------------------------------------------------------------
+njsSubscription *njsOracledb::GetSubscription(std::string &name)
+{
+    Nan::HandleScope scope;
+    Local<String> nameObj = Nan::New<String>(name).ToLocalChecked();
+    Local<Object> allSubscriptions = Nan::New(subscriptions);
+    Local<Value> value = Nan::Get(allSubscriptions, nameObj).ToLocalChecked();
+    if (value->IsUndefined())
+        return NULL;
+    return Nan::ObjectWrap::Unwrap<njsSubscription>(value.As<Object>());
+}
+
+
+//-----------------------------------------------------------------------------
+// njsOracledb::SetSubscription()
+//   Sets the subscription in the subscriptions object for later recovery,
+// either to subscribe another query or to unsubscribe.
+//-----------------------------------------------------------------------------
+void njsOracledb::SetSubscription(std::string &name, Local<Value> subscription)
+{
+    Nan::HandleScope scope;
+    Local<String> nameObj = Nan::New<String>(name).ToLocalChecked();
+    Local<Object> allSubscriptions = Nan::New(subscriptions);
+    Nan::Set(allSubscriptions, nameObj, subscription);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsOracledb::ClearSubscription()
+//   Clears the subscription from the subscriptions object.
+//-----------------------------------------------------------------------------
+void njsOracledb::ClearSubscription(std::string &name)
+{
+    Nan::HandleScope scope;
+    Local<String> nameObj = Nan::New<String>(name).ToLocalChecked();
+    Local<Object> allSubscriptions = Nan::New(subscriptions);
+    Nan::Delete(allSubscriptions, nameObj);
+}
+
+
 //-----------------------------------------------------------------------------
 // init()
 //   Invoked when require on oracledb is called.
@@ -1196,6 +1251,7 @@ extern "C"
         njsPool::Init(target);
         njsResultSet::Init(target);
         njsILob::Init(target);
+        njsSubscription::Init(target);
     }
 
     NODE_MODULE(oracledb, init)

package/src/njsOracle.h

@@ -70,7 +70,7 @@ using namespace v8;
 // The suffix should be something like "-dev" or "-beta.1".
 // For production, leave NJS_NODE_ORACLEDB_SUFFIX undefined (not "")
 #define NJS_NODE_ORACLEDB_MAJOR       2
-#define NJS_NODE_ORACLEDB_MINOR       2
+#define NJS_NODE_ORACLEDB_MINOR       3
 #define NJS_NODE_ORACLEDB_PATCH       0
 #define NJS_NODE_ORACLEDB_SUFFIX
 
@@ -104,6 +104,7 @@ using namespace v8;
 // njsOracledb
 //   Class exposed to JS for the main module.
 //-----------------------------------------------------------------------------
+class njsSubscription;
 class njsOracledb: public njsCommon
 {
 public:
@@ -127,6 +128,9 @@ public:
     void SetFetchAsBufferTypesOnBaton(njsBaton *baton) const;
     static dpiContext *GetDPIContext()             { return globalDPIContext; }
     static void ThrowDPIError(void);
+    static njsSubscription *GetSubscription(std::string &name);
+    static void SetSubscription(std::string &name, Local<Value> subscription);
+    static void ClearSubscription(std::string &name);
 
 private:
 
@@ -224,6 +228,7 @@ private:
     int32_t poolPingInterval;
 
     static Nan::Persistent<FunctionTemplate> oracledbTemplate_s;
+    static Nan::Persistent<Object> subscriptions;
     static dpiContext *globalDPIContext;
 
 };