oracledb 2.1.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>
@@ -71,7 +72,7 @@ Nan::Persistent<FunctionTemplate> njsConnection::connectionTemplate_s;
 //   Initialization function of Connection class. Maps functions and properties
 // from JS to C++.
 //-----------------------------------------------------------------------------
-void njsConnection::Init(Handle<Object> target)
+void njsConnection::Init(Local<Object> target)
 {
     Nan::HandleScope scope;
     Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
@@ -80,11 +81,17 @@ void njsConnection::Init(Handle<Object> target)
     tpl->SetClassName(Nan::New<v8::String>("Connection").ToLocalChecked());
 
     Nan::SetPrototypeMethod(tpl, "execute", Execute);
-    Nan::SetPrototypeMethod(tpl, "release", Release);
+    Nan::SetPrototypeMethod(tpl, "executeMany", ExecuteMany);
+    Nan::SetPrototypeMethod(tpl, "getStatementInfo", GetStatementInfo);
+    Nan::SetPrototypeMethod(tpl, "close", Close);
     Nan::SetPrototypeMethod(tpl, "commit", Commit);
     Nan::SetPrototypeMethod(tpl, "rollback", Rollback);
     Nan::SetPrototypeMethod(tpl, "break", Break);
     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(),
@@ -102,6 +109,10 @@ void njsConnection::Init(Handle<Object> target)
             Nan::New<v8::String>("oracleServerVersion").ToLocalChecked(),
             njsConnection::GetOracleServerVersion,
             njsConnection::SetOracleServerVersion);
+    Nan::SetAccessor(tpl->InstanceTemplate(),
+            Nan::New<v8::String>("oracleServerVersionString").ToLocalChecked(),
+            njsConnection::GetOracleServerVersionString,
+            njsConnection::SetOracleServerVersionString);
 
     connectionTemplate_s.Reset(tpl);
     Nan::Set(target, Nan::New<v8::String>("Connection").ToLocalChecked(),
@@ -189,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:
@@ -239,77 +253,97 @@ bool njsConnection::ProcessQueryVars(njsBaton *baton, dpiStmt *dpiStmtHandle,
 // round trips.
 //-----------------------------------------------------------------------------
 bool njsConnection::ProcessVars(njsBaton *baton, njsVariable *vars,
-        uint32_t numVars, uint32_t baseNumElements)
+        uint32_t numVars, uint32_t numRows)
 {
-    uint32_t numElements;
-    dpiStmt *stmt;
-
     for (uint32_t col = 0; col < numVars; col++) {
         njsVariable *var = &vars[col];
+        var->buffer.numElements = numRows;
         if (var->bindDir == NJS_BIND_IN)
             continue;
-        njsDataType dataType;
-        switch (var->varTypeNum) {
-            case DPI_ORACLE_TYPE_CLOB:
-            case DPI_ORACLE_TYPE_NCLOB:
-                dataType = NJS_DATATYPE_CLOB;
-                break;
-            case DPI_ORACLE_TYPE_BLOB:
-                dataType = NJS_DATATYPE_BLOB;
-                break;
-            case DPI_ORACLE_TYPE_STMT:
-                stmt = var->dpiVarData->value.asStmt;
-                if (dpiStmt_getNumQueryColumns(stmt, &var->numQueryVars) < 0) {
+        if (var->dmlReturningBuffers) {
+            delete [] var->dmlReturningBuffers;
+            var->dmlReturningBuffers = NULL;
+        }
+
+        // for arrays, determine the number of elements in the array
+        if (var->isArray) {
+            if (dpiVar_getNumElementsInArray(var->dpiVarHandle,
+                    &var->buffer.numElements) < 0) {
+                baton->GetDPIError();
+                return false;
+            }
+
+        // for DML returning statements, each row has its own set of rows, so
+        // acquire those from ODPI-C and store them in variable buffers for
+        // later processing
+        } else if (baton->isReturning && var->bindDir == NJS_BIND_OUT) {
+            var->dmlReturningBuffers = new njsVariableBuffer[numRows];
+            for (uint32_t row = 0; row < numRows; row++) {
+                njsVariableBuffer *buffer = &var->dmlReturningBuffers[row];
+                if (dpiVar_getReturnedData(var->dpiVarHandle, row,
+                        &buffer->numElements, &buffer->dpiVarData) < 0) {
                     baton->GetDPIError();
                     return false;
                 }
-                var->queryVars = new njsVariable[var->numQueryVars];
-                if (!ProcessQueryVars(baton, stmt, var->queryVars,
-                        var->numQueryVars))
+                if (!ProcessVarBuffer(baton, var, buffer))
                     return false;
-                continue;
-            default:
-                continue;
+            }
         }
 
-        // for DML returning statements, the number of rows returned may have
-        // exceeded the maxArraySize of the variable, requiring ODPI-C to
-        // free the original buffers and allocate new ones; this call gets the
-        // buffers and maxArraySize value for the variable just in case that
-        // has taken place
-        if (baton->isReturning && var->bindDir == NJS_BIND_OUT) {
-            if (dpiVar_getData(var->dpiVarHandle, &var->maxArraySize,
-                    &var->dpiVarData) < 0) {
-                baton->GetDPIError();
-                return false;
-            }
-            numElements = (uint32_t) baton->rowsAffected;
+        // process the main buffer if DML returning is not in effect
+        if (!var->dmlReturningBuffers &&
+                !ProcessVarBuffer(baton, var, &var->buffer))
+            return false;
 
-        } else if (!var->isArray) {
-            numElements = baseNumElements;
-        } else {
-            if (dpiVar_getNumElementsInArray(var->dpiVarHandle,
-                    &numElements) < 0) {
+    }
+
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::ProcessVarBuffer()
+//   Process a variable buffer. REF cursors must have their query variables
+// defined and LOBs must be initially processed in order to have as much work
+// as possible done in the worker thread and avoid any round trips.
+//-----------------------------------------------------------------------------
+bool njsConnection::ProcessVarBuffer(njsBaton *baton, njsVariable *var,
+        njsVariableBuffer *buffer)
+{
+    dpiStmt *stmt;
+
+    switch (var->varTypeNum) {
+        case DPI_ORACLE_TYPE_CLOB:
+        case DPI_ORACLE_TYPE_NCLOB:
+        case DPI_ORACLE_TYPE_BLOB:
+            buffer->lobs = new njsProtoILob[buffer->numElements];
+            for (uint32_t i = 0; i < buffer->numElements; i++) {
+                njsProtoILob *lob = &buffer->lobs[i];
+                lob->dataType = (var->varTypeNum == DPI_ORACLE_TYPE_BLOB) ?
+                        NJS_DATATYPE_BLOB : NJS_DATATYPE_CLOB;
+                lob->isAutoClose = true;
+                uint32_t elementIndex = baton->bufferRowIndex + i;
+                dpiData *data = &buffer->dpiVarData[elementIndex];
+                if (data->isNull)
+                    continue;
+                if (!lob->PopulateFromDPI(baton, data->value.asLOB, true))
+                    return false;
+            }
+            break;
+        case DPI_ORACLE_TYPE_STMT:
+            stmt = buffer->dpiVarData->value.asStmt;
+            if (dpiStmt_getNumQueryColumns(stmt, &var->numQueryVars) < 0) {
                 baton->GetDPIError();
                 return false;
             }
-        }
-        if (var->lobs)
-            delete [] var->lobs;
-        var->lobs = new njsProtoILob[numElements];
-        for (uint32_t row = 0; row < numElements; row++) {
-            njsProtoILob *lob = &var->lobs[row];
-            lob->dataType = dataType;
-            lob->isAutoClose = true;
-            uint32_t elementIndex = baton->bufferRowIndex + row;
-            dpiData *data = &var->dpiVarData[elementIndex];
-            if (data->isNull)
-                continue;
-            if (!lob->PopulateFromDPI(baton, data->value.asLOB, true))
+            var->queryVars = new njsVariable[var->numQueryVars];
+            if (!ProcessQueryVars(baton, stmt, var->queryVars,
+                    var->numQueryVars))
                 return false;
-        }
+            break;
+        default:
+            break;
     }
-
     return true;
 }
 
@@ -348,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;
 }
 
@@ -431,12 +470,6 @@ bool njsConnection::PrepareAndBind(njsBaton *baton)
     for (uint32_t i = 0; i < baton->numBindVars; i++) {
         int status;
         njsVariable *var = &baton->bindVars[i];
-        if (stmtInfo.isReturning && var->bindDir == NJS_BIND_OUT &&
-                var->varTypeNum == DPI_ORACLE_TYPE_RAW) {
-            baton->error = njsMessages::Get(errBufferReturningInvalid);
-            baton->ClearAsyncData();
-            return false;
-        }
         if (var->name.empty())
             status = dpiStmt_bindByPos(baton->dpiStmtHandle, var->pos,
                     var->dpiVarHandle);
@@ -515,166 +548,24 @@ Local<Value> njsConnection::GetMetaData(njsVariable *vars, uint32_t numVars,
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::ProcessBinds()
-//   Process binds passed through to execute call. A variable is created for
-// each one and added to the binds array for processing during the actual
-// execution.
-//-----------------------------------------------------------------------------
-bool njsConnection::ProcessBinds(Nan::NAN_METHOD_ARGS_TYPE args,
-        unsigned int index, njsBaton *baton)
-{
-    Nan::HandleScope scope;
-    if (args[static_cast<int>(index)]->IsArray()) {
-      Local<Array> bindsArray = Local<Array>::Cast(
-                                       args[static_cast<int>(index)]);
-        return ProcessBindsByPos(bindsArray, baton);
-    }
-    if (args[static_cast<int>(index)]->IsObject() &&
-        !args[static_cast<int>(index)]->IsFunction()) {
-        Local<Object> bindsObject = args[static_cast<int>(index)]->ToObject();
-        return ProcessBindsByName(bindsObject, baton);
-    }
-    baton->error = njsMessages::Get(errInvalidParameterType, index);
-    return false;
-}
-
-
-//-----------------------------------------------------------------------------
-// njsConnection::ProcessBindsByName()
-//   Get bind variables from JS (by name).
-//-----------------------------------------------------------------------------
-bool njsConnection::ProcessBindsByName(Handle<Object> bindObj, njsBaton *baton)
-{
-    Nan::HandleScope scope;
-    Local<Array> array = bindObj->GetOwnPropertyNames();
-
-    baton->numBindVars = array->Length();
-    baton->bindVars = new njsVariable[baton->numBindVars];
-    for (uint32_t i = 0; i < baton->numBindVars; i++) {
-        njsVariable *var = &baton->bindVars[i];
-        Local<Value> temp = Nan::Get(array, i).ToLocalChecked();
-        v8::String::Utf8Value v8str(temp->ToString());
-        std::string str = std::string(*v8str,
-                                      static_cast<size_t>(v8str.length()));
-        var->name = ":" + str;
-        var->pos = i + 1;
-        MaybeLocal<Value> mval = Nan::Get (bindObj,
-                                           Nan::New(str).ToLocalChecked());
-        Local<Value> val;
-        if (!mval.ToLocal (&val))
-            return false;
-
-        if (!ProcessBind(val, var, false, baton))
-            return false;
-    }
-
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-// njsConnection::ProcessBindsByPos()
-//   Get bind variables from JS (by position).
-//-----------------------------------------------------------------------------
-bool njsConnection::ProcessBindsByPos(Handle<Array> binds, njsBaton *baton)
-{
-    Nan::HandleScope scope;
-
-    baton->numBindVars = binds->Length();
-    baton->bindVars = new njsVariable[baton->numBindVars];
-    for (uint32_t i = 0; i < baton->numBindVars; i++) {
-        njsVariable *var = &baton->bindVars[i];
-        var->pos = i + 1;
-        Local<Value> val = Nan::Get(binds,i).ToLocalChecked ();
-        if (!ProcessBind(val, var, true, baton))
-            return false;
-    }
-
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-// njsConnection::ProcessBind()
-//   Process bind variable from JS.
+// njsConnection::CreateVarBuffer()
+//   Create ODPI-C variables used to hold the bind data.
 //-----------------------------------------------------------------------------
-bool njsConnection::ProcessBind(Local<Value> val, njsVariable *var,
-        bool byPosition, njsBaton *baton)
+bool njsConnection::CreateVarBuffer(njsVariable *var, njsBaton *baton)
 {
-    Nan::HandleScope scope;
-    Local<Value> bindValue;
-    uint32_t bindType;
-
-    // default values
-    var->bindDir = NJS_BIND_IN;
-    var->maxSize = 0;
-    var->maxArraySize = 0;
-    var->isArray = false;
-    bindType = 0;
-
-    // value is an object, get information on the bind variable from it
-    if (val->IsObject() && !val->IsDate() && !Buffer::HasInstance(val) &&
-            !njsILob::HasInstance(val)) {
-        Local<Object> bindUnit = val->ToObject();
-
-        // In case of bind-by-position, JSON objects are expected to be
-        // unnamed. If JSON object is provided, we look for "dir", "type",
-        // "maxSize" and "val" key names. If not found, an error is reported.
-        // Array (positional) binds syntax
-        //    [ id, name, {type : oracledb.STRING, dir : oracledb.BIND_OUT}]
-        // the 3rd parameter is unnamed JSON object.
-        // [ id, n, { a: { type : oracledb.STRING, dir : oracledb.BIND_OUT} }]
-        // will fail now. In this example the third parameter JSON object has
-        // a key name "a" and value as another JSON. This is incorrect syntax.
-        if (byPosition) {
-            Local<Array> keys = bindUnit->GetOwnPropertyNames();
-            bool valid = false;
-            for (uint32_t i = 0; i < keys->Length(); i++) {
-                Local<String> temp = Nan::Get(keys,
-                                              i).ToLocalChecked().As<String>();
-
-                v8::String::Utf8Value utf8str(temp->ToString());
-                std::string key = std::string(*utf8str,
-                                     static_cast<size_t>(utf8str.length()));
-                if (key.compare("dir") == 0 ||
-                        key.compare("type") == 0 ||
-                        key.compare("maxSize") == 0 ||
-                        key.compare("val") == 0) {
-                    valid = true;
-                    break;
-                }
-            }
-            if (!valid) {
-                baton->error = njsMessages::Get(errNamedJSON);
-                return false;
-            }
-        }
-
-        if (!baton->GetUnsignedIntFromJSON(bindUnit, "dir", 1, &var->bindDir))
-            return false;
-        if (!baton->GetUnsignedIntFromJSON(bindUnit, "type", 1, &bindType))
-            return false;
-        if (var->bindDir != NJS_BIND_IN) {
-            var->maxSize = NJS_MAX_OUT_BIND_SIZE;
-            if (!baton->GetUnsignedIntFromJSON(bindUnit, "maxSize", 1,
-                    &var->maxSize))
-                return false;
-        }
-        if (!baton->GetUnsignedIntFromJSON(bindUnit, "maxArraySize", 1,
-                &var->maxArraySize))
-            return false;
-        if (var->maxArraySize > 0)
-            var->isArray = true;
-        bindValue = Nan::Get(bindUnit,
-              Nan::New<v8::String>("val").ToLocalChecked()).ToLocalChecked ();
+    // if the variable is not an array use the bind array size
+    if (!var->isArray)
+        var->maxArraySize = baton->bindArraySize;
 
-    // otherwise, bind value is directly passed and other values are defaults
-    } else {
-        bindValue = val;
+    // if the variable has no data type assume string of size 1
+    if (var->bindDataType == NJS_DATATYPE_DEFAULT) {
+        var->bindDataType = NJS_DATATYPE_STR;
+        var->maxSize = 1;
     }
 
     // REF cursors are only supported as out binds currently
-    if (bindType == NJS_DATATYPE_CURSOR && var->bindDir != NJS_BIND_OUT) {
+    if (var->bindDataType == NJS_DATATYPE_CURSOR &&
+            var->bindDir != NJS_BIND_OUT) {
         baton->error = njsMessages::Get(errInvalidPropertyValueInParam,
                 "type", 1);
         return false;
@@ -687,42 +578,8 @@ bool njsConnection::ProcessBind(Local<Value> val, njsVariable *var,
         return false;
     }
 
-    // validate bind type
-    if (!bindType || !var->maxSize || var->maxSize == NJS_MAX_OUT_BIND_SIZE) {
-        uint32_t defaultMaxSize = 0, defaultBindType = 0;
-        if (!GetBindTypeAndSizeFromValue(var, bindValue, &defaultBindType,
-                &defaultMaxSize, baton))
-            return false;
-        if (!bindType)
-            bindType = defaultBindType;
-        if (defaultMaxSize > var->maxSize)
-            var->maxSize = defaultMaxSize;
-    }
-
-    // for IN binds, maxArraySize is ignored and obtained from the actual
-    // array size; for INOUT binds, maxArraySize does need to be specified
-    // by the application; for OUT binds, the value from the application
-    // must be accepted as is as there is no way to validate it
-    if (bindValue->IsArray()) {
-        var->isArray = true;
-        Local<Array> arrayVal = Local<Array>::Cast(bindValue);
-        if (var->bindDir == NJS_BIND_IN) {
-            var->maxArraySize = arrayVal->Length();
-            if (var->maxArraySize == 0)
-                var->maxArraySize = 1;
-        } else if (!var->maxArraySize) {
-            baton->error = njsMessages::Get(errReqdMaxArraySize);
-            return false;
-        }
-        if (var->bindDir == NJS_BIND_INOUT &&
-                arrayVal->Length() > var->maxArraySize) {
-            baton->error = njsMessages::Get(errInvalidArraySize);
-            return false;
-        }
-    }
-
-    // validate bind type and determine variable type
-    switch (bindType) {
+    // determine ODPI-C Oracle type and native type to use
+    switch (var->bindDataType) {
         case NJS_DATATYPE_STR:
             var->varTypeNum = DPI_ORACLE_TYPE_VARCHAR;
             var->nativeTypeNum = DPI_NATIVE_TYPE_BYTES;
@@ -760,28 +617,130 @@ bool njsConnection::ProcessBind(Local<Value> val, njsVariable *var,
             return false;
     }
 
-    // create DPI variable to hold data
-    if (!var->isArray)
-        var->maxArraySize = 1;
+    // create ODPI-C variable
     if (dpiConn_newVar(baton->dpiConnHandle, var->varTypeNum,
             var->nativeTypeNum, var->maxArraySize, var->maxSize, 1,
-            var->isArray, NULL, &var->dpiVarHandle, &var->dpiVarData) < 0) {
+            var->isArray, NULL, &var->dpiVarHandle,
+            &var->buffer.dpiVarData) < 0) {
         baton->GetDPIError();
         return false;
     }
 
-    // for in and in/out binds, copy value into buffers
-    switch (var->bindDir) {
-        case NJS_BIND_OUT:
-            break;
-        case NJS_BIND_IN:
-        case NJS_BIND_INOUT:
-            if (!ProcessBindValue(bindValue, var, baton))
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::ProcessExecuteBinds()
+//   Process binds passed through to Execute() call.
+//-----------------------------------------------------------------------------
+bool njsConnection::ProcessExecuteBinds(Local<Object> binds, njsBaton *baton)
+{
+    Nan::HandleScope scope;
+    Local<Array> bindNames;
+
+    // determine bind names (if binding by name)
+    baton->bindArraySize = 1;
+    if (!binds->IsUndefined() && !binds->IsArray())
+        bindNames = binds->GetOwnPropertyNames();
+
+    // initialize variables; if there are no variables, nothing further to do!
+    if (!InitBindVars(binds, bindNames, baton))
+        return false;
+    if (baton->numBindVars == 0)
+        return true;
+
+    // scan the execute binds and populate the bind variables
+    return ScanExecuteBinds(binds, bindNames, baton);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::ScanExecuteBinds()
+//   Scan the binds passed through to Execute() and determine the bind
+// type and maximum size (for strings/buffers).
+//-----------------------------------------------------------------------------
+bool njsConnection::ScanExecuteBinds(Local<Object> binds,
+        Local<Array> bindNames, njsBaton *baton)
+{
+    Nan::HandleScope scope;
+    Local<Value> bindName, bindUnit, bindValue;
+    Local<Array> byPositionValues;
+    njsVariable *var;
+    bool byPosition;
+
+    // determine if binding is by position or by name
+    byPosition = (baton->bindVars[0].pos > 0);
+    if (byPosition)
+        byPositionValues = binds.As<Array>();
+
+    // scan each column
+    for (uint32_t i = 0; i < baton->numBindVars; i++) {
+        var = &baton->bindVars[i];
+
+        // determine bind information and value
+        if (byPosition)
+            bindUnit = Nan::Get(byPositionValues, i).ToLocalChecked();
+        else {
+            bindName = Nan::Get(bindNames, i).ToLocalChecked();
+            if (!Nan::Get(binds, bindName).ToLocal(&bindUnit))
                 return false;
-            break;
-        default:
-            baton->error = njsMessages::Get(errInvalidBindDirection);
+        }
+        if (bindUnit->IsObject() && !bindUnit->IsDate() &&
+                !Buffer::HasInstance(bindUnit) &&
+                !njsILob::HasInstance(bindUnit)) {
+            if (!ScanExecuteBindUnit(bindUnit.As<Object>(), var, false, baton))
+                return false;
+            Local<String> key = Nan::New<String>("val").ToLocalChecked();
+            bindValue = Nan::Get(bindUnit.As<Object>(), key).ToLocalChecked();
+        } else bindValue = bindUnit;
+
+        // get bind information from value if it has not already been specified
+        if (var->bindDataType == NJS_DATATYPE_DEFAULT || !var->maxSize ||
+                var->maxSize == NJS_MAX_OUT_BIND_SIZE) {
+            njsDataType defaultBindType = NJS_DATATYPE_DEFAULT;
+            uint32_t defaultMaxSize = 0;
+            if (!GetBindTypeAndSizeFromValue(var, bindValue, &defaultBindType,
+                    &defaultMaxSize, baton))
+                return false;
+            if (var->bindDataType == NJS_DATATYPE_DEFAULT)
+                var->bindDataType = defaultBindType;
+            if (defaultMaxSize > var->maxSize)
+                var->maxSize = defaultMaxSize;
+        }
+
+        // for IN binds, maxArraySize is ignored and obtained from the actual
+        // array size; for INOUT binds, maxArraySize does need to be specified
+        // by the application; for OUT binds, the value from the application
+        // must be accepted as is as there is no way to validate it
+        if (bindValue->IsArray()) {
+            var->isArray = true;
+            Local<Array> arrayVal = Local<Array>::Cast(bindValue);
+            if (var->bindDir == NJS_BIND_IN) {
+                var->maxArraySize = arrayVal->Length();
+                if (var->maxArraySize == 0)
+                    var->maxArraySize = 1;
+            } else if (var->maxArraySize == 0) {
+                baton->error = njsMessages::Get(errReqdMaxArraySize);
+                return false;
+            }
+            if (var->bindDir == NJS_BIND_INOUT &&
+                    arrayVal->Length() > var->maxArraySize) {
+                baton->error = njsMessages::Get(errInvalidArraySize);
+                return false;
+            }
+        }
+
+        // create buffer for variable
+        if (!CreateVarBuffer(var, baton))
             return false;
+
+        // process bind value (for all except OUT)
+        if (var->bindDir != NJS_BIND_OUT) {
+            if (!ProcessBindValue(bindValue, var, baton))
+                return false;
+        }
+
     }
 
     return true;
@@ -789,44 +748,90 @@ bool njsConnection::ProcessBind(Local<Value> val, njsVariable *var,
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::ProcessBindValue()
-//   Process bind value from JS and copy it to the variable that was created.
+// njsConnection::ScanExecuteBindUnit()
+//   Scan the execute bind unit for bind information.
 //-----------------------------------------------------------------------------
-bool njsConnection::ProcessBindValue(Local<Value> value, njsVariable *var,
-        njsBaton *baton)
+bool njsConnection::ScanExecuteBindUnit(Local<Object> bindUnit,
+        njsVariable *var, bool inExecuteMany, njsBaton *baton)
 {
-    // scalar values can be handled directly
-    if (!var->isArray)
-        return ProcessScalarBindValue(value, var, 0, baton);
+    Nan::HandleScope scope;
 
-    // only strings and numbers are currently allowed
-    if (var->varTypeNum != DPI_ORACLE_TYPE_VARCHAR &&
-            var->varTypeNum != DPI_ORACLE_TYPE_NUMBER &&
-            var->varTypeNum != DPI_ORACLE_TYPE_NATIVE_INT) {
-        baton->error = njsMessages::Get(errInvalidTypeForArrayBind);
+    // scan all keys and verify that one of "dir", "type", "maxSize" or "val"
+    // is found; if not, the bind information is considered invalid
+    Local<Array> keys = bindUnit->GetOwnPropertyNames();
+    bool valid = false;
+    for (uint32_t i = 0; i < keys->Length(); i++) {
+        Local<String> temp =
+                Nan::Get(keys, i).ToLocalChecked().As<String>();
+        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 ||
+                key.compare("maxSize") == 0 || key.compare("val") == 0) {
+            valid = true;
+            break;
+        }
+    }
+    if (!valid) {
+        baton->error = njsMessages::Get(errNamedJSON);
         return false;
     }
 
-    /* Expecting an array value here */
-    if ( !value->IsArray ()) {
-        baton->error = njsMessages::Get ( errNonArrayProvided ) ;
+    // get and validate bind direction
+    uint32_t temp = (uint32_t) var->bindDir;
+    if (!baton->GetUnsignedIntFromJSON(bindUnit, "dir", 1, &temp))
         return false;
+    var->bindDir = (njsBindDir) temp;
+    switch (var->bindDir) {
+        case NJS_BIND_OUT:
+        case NJS_BIND_IN:
+        case NJS_BIND_INOUT:
+            break;
+        default:
+            baton->error = njsMessages::Get(errInvalidBindDirection);
+            return false;
     }
 
-    // set the number of actual elements in the variable
-    Nan::HandleScope scope;
-    Local<Array> arrayVal = Local<Array>::Cast(value);
-    if (dpiVar_setNumElementsInArray(var->dpiVarHandle,
-            arrayVal->Length()) < 0) {
-        baton->GetDPIError();
+    // get data type
+    temp = (uint32_t) var->bindDataType;
+    if (!baton->GetUnsignedIntFromJSON(bindUnit, "type", 1, &temp))
         return false;
+    if (!temp && inExecuteMany) {
+        if (var->pos > 0)
+            baton->error = njsMessages::Get(errMissingTypeByPos, var->pos);
+        else baton->error = njsMessages::Get(errMissingTypeByName,
+                var->name.c_str());
     }
+    var->bindDataType = (njsDataType) temp;
 
-    // process each element in the array
-    for (uint32_t i = 0; i < arrayVal->Length(); i++) {
-        Local<Value> elementValue = Nan::Get (arrayVal, i).ToLocalChecked ();
-        if (!ProcessScalarBindValue(elementValue, var, i, baton))
+    // get maximum size for strings/buffers; this value is only used for
+    // IN/OUT and OUT binds in execute() and at all times for executeMany()
+    if (var->bindDir != NJS_BIND_IN || inExecuteMany) {
+        if (var->bindDir != NJS_BIND_IN)
+            var->maxSize = NJS_MAX_OUT_BIND_SIZE;
+        if (!baton->GetUnsignedIntFromJSON(bindUnit, "maxSize", 1,
+                &var->maxSize))
+            return false;
+        if (inExecuteMany && var->maxSize == 0) {
+            if (var->bindDataType == NJS_DATATYPE_STR ||
+                    var->bindDataType == NJS_DATATYPE_BUFFER) {
+                if (var->pos > 0)
+                    baton->error = njsMessages::Get(errMissingMaxSizeByPos,
+                            var->pos);
+                else baton->error = njsMessages::Get(errMissingMaxSizeByName,
+                        var->name.c_str());
+                return false;
+            }
+        }
+    }
+
+    // get max array size (for array binds)
+    if (!inExecuteMany) {
+        if (!baton->GetUnsignedIntFromJSON(bindUnit, "maxArraySize", 1,
+                &var->maxArraySize))
             return false;
+        if (var->maxArraySize > 0)
+            var->isArray = true;
     }
 
     return true;
@@ -834,45 +839,316 @@ bool njsConnection::ProcessBindValue(Local<Value> value, njsVariable *var,
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::ProcessScalarBindValue()
-//   Process scalar bind value from JS and copy it to the variable at the given
-// position.
+// njsConnection::ProcessExecuteManyBinds()
+//   Process binds passed through to ExecuteMany() call.
 //-----------------------------------------------------------------------------
-bool njsConnection::ProcessScalarBindValue(Local<Value> value,
-        njsVariable *var, uint32_t pos, njsBaton *baton)
+bool njsConnection::ProcessExecuteManyBinds(Local<Array> binds,
+        Local<Object> options, njsBaton *baton)
 {
     Nan::HandleScope scope;
-    bool bindOk = false;
-    dpiData *data;
+    Local<Value> bindDefs, bindName, bindUnit;
+    Local<Array> bindNames;
+    bool scanRequired;
 
-    // initialization
-    data = &var->dpiVarData[pos];
-    data->isNull = 0;
+    // all rows are bound at one time
+    baton->bindArraySize = binds->Length();
 
-    // nulls and undefined in JS are mapped to NULL in Oracle; no checks needed
-    if (value->IsUndefined() || value->IsNull()) {
-        data->isNull = 1;
-        bindOk = true;
+    // determine if bind definitions have been specified
+    Local<String> key = Nan::New<v8::String>("bindDefs").ToLocalChecked();
+    if (!Nan::Get(options, key).ToLocal(&bindDefs))
+        return false;
+    scanRequired = bindDefs->IsUndefined();
 
-    // value is a string, variable type should be a string
-    } else if (value->IsString()) {
-        bindOk = (var->varTypeNum == DPI_ORACLE_TYPE_VARCHAR ||
-                var->varTypeNum == DPI_ORACLE_TYPE_CLOB);
-        if (bindOk) {
-            v8::String::Utf8Value utf8str(value);
-            if (utf8str.length() == 0)
-                data->isNull = 1;
-            else if (dpiVar_setFromBytes(var->dpiVarHandle, pos, *utf8str,
-                             static_cast<uint32_t>( utf8str.length())) < 0) {
-                baton->GetDPIError();
-                return false;
-            }
-        }
+    // if no bind definitions are specified, the first row is used to determine
+    // the number of bind variables and types
+    if (scanRequired)
+        bindDefs = Nan::Get(binds, 0).ToLocalChecked();
+    if (!bindDefs->IsUndefined() && !bindDefs->IsArray())
+        bindNames = bindDefs.As<Object>()->GetOwnPropertyNames();
 
-    // value is an integer
-    } else if (value->IsInt32() || value->IsUint32()) {
-        bindOk = (var->varTypeNum == DPI_ORACLE_TYPE_NUMBER);
-        if (bindOk) {
+    // initialize variables; if there are no variables, nothing further to do!
+    if (!InitBindVars(bindDefs.As<Object>(), bindNames, baton))
+        return false;
+    if (baton->numBindVars == 0)
+        return true;
+
+    // if no bind definitions are specified, scan the binds to determine type
+    // and size
+    if (scanRequired) {
+        if (!ScanExecuteManyBinds(binds, bindNames, baton))
+            return false;
+
+    // otherwise, use the bind definitions to determine type and size
+    } else {
+        bool byPosition = (baton->bindVars[0].pos > 0);
+        Local<Array> byPositionValues;
+        if (byPosition)
+            byPositionValues = bindDefs.As<Array>();
+        for (uint32_t i = 0; i < baton->numBindVars; i++) {
+            njsVariable *var = &baton->bindVars[i];
+            if (byPosition)
+                bindUnit = Nan::Get(byPositionValues, i).ToLocalChecked();
+            else {
+                bindName = Nan::Get(bindNames, i).ToLocalChecked();
+                if (!Nan::Get(bindDefs.As<Object>(),
+                        bindName).ToLocal(&bindUnit))
+                    return false;
+            }
+            if (!ScanExecuteBindUnit(bindUnit.As<Object>(), var, true, baton))
+                return false;
+        }
+    }
+
+    // create the ODPI-C variables used to hold the data
+    for (uint32_t i = 0; i < baton->numBindVars; i++) {
+        if (!CreateVarBuffer(&baton->bindVars[i], baton))
+            return false;
+    }
+
+    // populate the ODPI-C variables with the data from JavaScript binds
+    if (!TransferExecuteManyBinds(binds, bindNames, baton))
+        return false;
+
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::ScanExecuteManyBinds()
+//   Scan the binds passed through to ExecuteMany() and determine the bind
+// type and maximum size (for strings/buffers).
+//-----------------------------------------------------------------------------
+bool njsConnection::ScanExecuteManyBinds(Local<Array> binds,
+        Local<Array> bindNames, njsBaton *baton)
+{
+    njsDataType defaultBindType;
+    uint32_t defaultMaxSize;
+    bool byPosition;
+    Nan::HandleScope scope;
+    Local<Array> byPositionValues;
+    Local<Value> bindName, val;
+    Local<Object> row;
+    njsVariable *var;
+
+    byPosition = (baton->bindVars[0].pos > 0);
+    for (uint32_t i = 0; i < baton->bindArraySize; i++) {
+        row = Nan::Get(binds, i).ToLocalChecked().As<Object>();
+
+        // verify that all rows are by position (array) or by name (object)
+        if ((byPosition && !row->IsArray()) ||
+                (!byPosition && row->IsArray())) {
+            baton->error = njsMessages::Get(errMixedBind);
+            return false;
+        }
+
+        // scan each of the columns in the row and determine the bind type and
+        // maximum size of the input data
+        if (byPosition)
+            byPositionValues = row.As<Array>();
+        for (uint32_t j = 0; j < baton->numBindVars; j++) {
+            var = &baton->bindVars[j];
+            if (byPosition)
+                val = Nan::Get(byPositionValues, j).ToLocalChecked();
+            else {
+                bindName = Nan::Get(bindNames, j).ToLocalChecked();
+                if (!Nan::Get(row, bindName).ToLocal(&val))
+                    return false;
+            }
+            if (val->IsUndefined() || val->IsNull())
+                continue;
+            if (!GetBindTypeAndSizeFromValue(var, val, &defaultBindType,
+                    &defaultMaxSize, baton, true))
+                return false;
+            if (var->bindDataType == 0)
+                var->bindDataType = defaultBindType;
+            if (defaultMaxSize > var->maxSize)
+                var->maxSize = defaultMaxSize;
+        }
+
+    }
+
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::TransferExecuteManyBinds()
+//   Transfer the binds from JavaScript to the ODPI-C variable buffers already
+// created.
+//-----------------------------------------------------------------------------
+bool njsConnection::TransferExecuteManyBinds(Local<Array> binds,
+        Local<Array> bindNames, njsBaton *baton)
+{
+    bool byPosition;
+    Nan::HandleScope scope;
+    Local<Array> byPositionValues;
+    Local<Value> bindName, val;
+    Local<Object> row;
+    njsVariable *var;
+
+    // determine if we are binding by position or by name
+    byPosition = (baton->bindVars[0].pos > 0);
+
+    // process each row
+    for (uint32_t i = 0; i < baton->bindArraySize; i++) {
+        row = Nan::Get(binds, i).ToLocalChecked().As<Object>();
+
+        // verify that all rows are by position (array) or by name (object)
+        if ((byPosition && !row->IsArray()) ||
+                (!byPosition && row->IsArray())) {
+            baton->error = njsMessages::Get(errMixedBind);
+            return false;
+        }
+
+        // process each column
+        if (byPosition)
+            byPositionValues = row.As<Array>();
+        for (uint32_t j = 0; j < baton->numBindVars; j++) {
+            var = &baton->bindVars[j];
+            if (byPosition)
+                val = Nan::Get(byPositionValues, j).ToLocalChecked();
+            else {
+                bindName = Nan::Get(bindNames, j).ToLocalChecked();
+                if (!Nan::Get(row, bindName).ToLocal(&val))
+                    return false;
+            }
+            if (!ProcessScalarBindValue(val, var, i, true, baton))
+                return false;
+        }
+
+    }
+
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::InitBindVars()
+//   Initialize bind variables using the given bind objectd/array as a
+// template. For binds performed by name, return the bind names as an array.
+//-----------------------------------------------------------------------------
+bool njsConnection::InitBindVars(Local<Object> bindObj,
+        Local<Array> bindNames, njsBaton *baton)
+{
+    bool byPosition = bindObj->IsArray();
+
+    // create bind variables (one for each element of the bind array or each
+    // property of the bind object)
+    if (bindObj->IsUndefined())
+        baton->numBindVars = 0;
+    else if (byPosition)
+        baton->numBindVars = bindObj.As<Array>()->Length();
+    else baton->numBindVars = bindNames->Length();
+    baton->bindVars = new njsVariable[baton->numBindVars];
+
+    // initialize bind variables (set position or name)
+    for (uint32_t i = 0; i < baton->numBindVars; i++) {
+        njsVariable *var = &baton->bindVars[i];
+        if (byPosition)
+            var->pos = i + 1;
+        else {
+            Local<Value> temp = Nan::Get(bindNames, i).ToLocalChecked();
+            Nan::Utf8String v8str(temp->ToString());
+            std::string str = std::string(*v8str,
+                    static_cast<size_t>(v8str.length()));
+            var->name = ":" + str;
+        }
+    }
+
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::ProcessBindValue()
+//   Process bind value from JS and copy it to the variable that was created.
+//-----------------------------------------------------------------------------
+bool njsConnection::ProcessBindValue(Local<Value> value, njsVariable *var,
+        njsBaton *baton)
+{
+    // scalar values can be handled directly
+    if (!var->isArray)
+        return ProcessScalarBindValue(value, var, 0, false, baton);
+
+    // only strings and numbers are currently allowed
+    if (var->varTypeNum != DPI_ORACLE_TYPE_VARCHAR &&
+            var->varTypeNum != DPI_ORACLE_TYPE_NUMBER &&
+            var->varTypeNum != DPI_ORACLE_TYPE_NATIVE_INT) {
+        baton->error = njsMessages::Get(errInvalidTypeForArrayBind);
+        return false;
+    }
+
+    /* Expecting an array value here */
+    if ( !value->IsArray ()) {
+        baton->error = njsMessages::Get ( errNonArrayProvided ) ;
+        return false;
+    }
+
+    // set the number of actual elements in the variable
+    Nan::HandleScope scope;
+    Local<Array> arrayVal = Local<Array>::Cast(value);
+    if (dpiVar_setNumElementsInArray(var->dpiVarHandle,
+            arrayVal->Length()) < 0) {
+        baton->GetDPIError();
+        return false;
+    }
+
+    // process each element in the array
+    for (uint32_t i = 0; i < arrayVal->Length(); i++) {
+        Local<Value> elementValue = Nan::Get (arrayVal, i).ToLocalChecked ();
+        if (!ProcessScalarBindValue(elementValue, var, i, false, baton))
+            return false;
+    }
+
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::ProcessScalarBindValue()
+//   Process scalar bind value from JS and copy it to the variable at the given
+// position.
+//-----------------------------------------------------------------------------
+bool njsConnection::ProcessScalarBindValue(Local<Value> value,
+        njsVariable *var, uint32_t pos, bool inExecuteMany, njsBaton *baton)
+{
+    Nan::HandleScope scope;
+    bool bindOk = false;
+    dpiData *data;
+
+    // initialization
+    data = &var->buffer.dpiVarData[pos];
+    data->isNull = 0;
+
+    // nulls and undefined in JS are mapped to NULL in Oracle; no checks needed
+    if (value->IsUndefined() || value->IsNull()) {
+        data->isNull = 1;
+        bindOk = true;
+
+    // value is a string, variable type should be a string
+    } else if (value->IsString()) {
+        bindOk = (var->varTypeNum == DPI_ORACLE_TYPE_VARCHAR ||
+                var->varTypeNum == DPI_ORACLE_TYPE_CLOB);
+        if (bindOk) {
+            Nan::Utf8String utf8str(value);
+            if (utf8str.length() == 0)
+                data->isNull = 1;
+            else if (inExecuteMany &&
+                    (uint32_t) utf8str.length() > var->maxSize) {
+                baton->error = njsMessages::Get(errMaxSizeTooSmall,
+                        var->maxSize, utf8str.length(), pos);
+                return false;
+            } else if (dpiVar_setFromBytes(var->dpiVarHandle, pos, *utf8str,
+                             static_cast<uint32_t>( utf8str.length())) < 0) {
+                baton->GetDPIError();
+                return false;
+            }
+        }
+
+    // value is an integer
+    } else if (value->IsInt32() || value->IsUint32()) {
+        bindOk = (var->varTypeNum == DPI_ORACLE_TYPE_NUMBER);
+        if (bindOk) {
             if (var->nativeTypeNum == DPI_NATIVE_TYPE_INT64) {
                 if (value->IsInt32())
                     data->value.asInt64 = Nan::To<int32_t>(value).FromJust();
@@ -905,8 +1181,12 @@ bool njsConnection::ProcessScalarBindValue(Local<Value> value,
                 var->varTypeNum == DPI_ORACLE_TYPE_BLOB);
         if (bindOk) {
             Local<Object> obj = value->ToObject();
-            if (dpiVar_setFromBytes(var->dpiVarHandle, pos, Buffer::Data(obj),
-                    (uint32_t) Buffer::Length(obj)) < 0) {
+            if (inExecuteMany && Buffer::Length(obj) > var->maxSize) {
+                baton->error = njsMessages::Get(errMaxSizeTooSmall,
+                        var->maxSize, Buffer::Length(obj), pos);
+                return false;
+            } else if (dpiVar_setFromBytes(var->dpiVarHandle, pos,
+                    Buffer::Data(obj), (uint32_t) Buffer::Length(obj)) < 0) {
                 baton->GetDPIError();
                 return false;
             }
@@ -967,7 +1247,7 @@ bool njsConnection::ProcessScalarBindValue(Local<Value> value,
 // is supported at this point, 0 is returned.
 //-----------------------------------------------------------------------------
 bool njsConnection::GetBindTypeAndSizeFromValue(njsVariable *var,
-        Local<Value> value, uint32_t *bindType, uint32_t *maxSize,
+        Local<Value> value, njsDataType *bindType, uint32_t *maxSize,
         njsBaton *baton, bool scalarOnly)
 {
     if (value->IsUndefined() || value->IsNull()) {
@@ -975,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;
@@ -987,7 +1267,8 @@ bool njsConnection::GetBindTypeAndSizeFromValue(njsVariable *var,
         Nan::HandleScope scope;
         Local<Array> arrayVal = Local<Array>::Cast(value);
         Local<Value> element;
-        uint32_t elementBindType, elementMaxSize;
+        njsDataType elementBindType;
+        uint32_t elementMaxSize;
         for (uint32_t i = 0; i < arrayVal->Length(); i++) {
             element = Nan::Get (arrayVal, i).ToLocalChecked ();
             if (element->IsUndefined() || element->IsNull())
@@ -1007,7 +1288,7 @@ bool njsConnection::GetBindTypeAndSizeFromValue(njsVariable *var,
                                       Buffer::Length(value->ToObject()));
         } else if (njsILob::HasInstance(value)) {
             njsILob *lob = njsILob::GetInstance(value);
-            *bindType = static_cast<uint32_t>(lob->GetDataType());
+            *bindType = lob->GetDataType();
         }
     } else {
         baton->error= njsMessages::Get(errInvalidBindDataType, 2);
@@ -1018,24 +1299,16 @@ bool njsConnection::GetBindTypeAndSizeFromValue(njsVariable *var,
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::ProcessOptions()
-//   Processing of options. If an error is detected, the baton error is
-// populated and false is returned.
+// njsConnection::ProcessExecuteOptions()
+//   Processing of options for connection.execute(). If an error is detected,
+// the baton error is populated and false is returned.
 //-----------------------------------------------------------------------------
-bool njsConnection::ProcessOptions(Nan::NAN_METHOD_ARGS_TYPE args,
-        unsigned int index, njsBaton *baton)
+bool njsConnection::ProcessExecuteOptions(Local<Object> options,
+        njsBaton *baton)
 {
     Nan::HandleScope scope;
 
-    // an object is expected, not an array
-    if (!args[static_cast<int>(index)]->IsObject() ||
-        args[static_cast<int>(index)]->IsArray()) {
-        baton->error = njsMessages::Get(errInvalidParameterType, index);
-        return false;
-    }
-
     // process the basic options
-    Local<Object> options = args[static_cast<int>(index)]->ToObject();
     if (!baton->GetUnsignedIntFromJSON(options, "maxRows", 2, &baton->maxRows))
         return false;
     if (!baton->GetPositiveIntFromJSON(options, "fetchArraySize", 2,
@@ -1059,33 +1332,22 @@ bool njsConnection::ProcessOptions(Nan::NAN_METHOD_ARGS_TYPE args,
 
     // process the fetchAs specifications, if applicable
     Local<Value> key = Nan::New<v8::String>("fetchInfo").ToLocalChecked();
-    MaybeLocal<Value> mval = Nan::Get(options, key);
     Local<Value> val;
-
-    if (!mval.ToLocal(&val))
+    if (!Nan::Get(options, key).ToLocal(&val))
         return false;
-
     if (!val->IsUndefined() && !val->IsNull()) {
         Local<Object> jsFetchInfo = val->ToObject();
         Local<Array> keys = jsFetchInfo->GetOwnPropertyNames();
-        if (keys->Length() == 0) {
-            baton->error = njsMessages::Get(errEmptyArrayForFetchAs, index);
-            return false;
-        }
         baton->numFetchInfo = keys->Length();
-        baton->fetchInfo = new njsFetchInfo[baton->numFetchInfo];
+        if (baton->numFetchInfo > 0)
+            baton->fetchInfo = new njsFetchInfo[baton->numFetchInfo];
         for (uint32_t i = 0; i < baton->numFetchInfo; i++) {
-          Local<String> temp = Nan::Get (keys,
-                                         i).ToLocalChecked ().As<String>();
-
-            v8::String::Utf8Value utf8str(temp->ToString());
+            Local<Value> temp = Nan::Get(keys, i).ToLocalChecked();
+            Nan::Utf8String utf8str(temp->ToString());
             baton->fetchInfo[i].name = std::string(*utf8str,
-                                    static_cast<size_t>(utf8str.length()));
-            v8::String::Utf8Value v8str(temp->ToString());
-            std::string str = std::string(*v8str,
-                             static_cast<size_t>(v8str.length()));
-            Local<Object> colInfo = Nan::Get(jsFetchInfo,
-                 Nan::New(str).ToLocalChecked()).ToLocalChecked()->ToObject();
+                    static_cast<size_t>(utf8str.length()));
+            Local<Object> colInfo =
+                    Nan::Get(jsFetchInfo, temp).ToLocalChecked()->ToObject();
             uint32_t tempType = static_cast<uint32_t>(NJS_DATATYPE_UNKNOWN);
             if (!baton->GetUnsignedIntFromJSON(colInfo, "type", 2, &tempType))
                 return false;
@@ -1106,6 +1368,96 @@ bool njsConnection::ProcessOptions(Nan::NAN_METHOD_ARGS_TYPE args,
 }
 
 
+//-----------------------------------------------------------------------------
+// njsConnection::ProcessExecuteManyOptions()
+//   Processing of options for connection.executeMany(). If an error is
+// detected, the baton error is populated and false is returned.
+//-----------------------------------------------------------------------------
+bool njsConnection::ProcessExecuteManyOptions(Local<Object> options,
+        njsBaton *baton)
+{
+    if (!baton->GetBoolFromJSON(options, "autoCommit", 2, &baton->autoCommit))
+        return false;
+    if (!baton->GetBoolFromJSON(options, "batchErrors", 2,
+            &baton->batchErrors))
+        return false;
+    if (!baton->GetBoolFromJSON(options, "dmlRowCounts", 2,
+            &baton->dmlRowCounts))
+        return false;
+
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// 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
@@ -1113,14 +1465,14 @@ bool njsConnection::ProcessOptions(Nan::NAN_METHOD_ARGS_TYPE args,
 // baton error has been populated with the error that was received from DPI.
 //-----------------------------------------------------------------------------
 bool njsConnection::GetScalarValueFromVar(njsBaton *baton, njsVariable *var,
-        uint32_t pos, Local<Value> &value)
+        njsVariableBuffer *buffer, uint32_t pos, Local<Value> &value)
 {
     Nan::EscapableHandleScope scope;
     Local<Value> temp;
 
     // LOBs make use of the njsProtoILob objects created in the worker thread
-    if (var->lobs) {
-        njsProtoILob *protoLob = &var->lobs[pos];
+    if (buffer->lobs) {
+        njsProtoILob *protoLob = &buffer->lobs[pos];
         if (!protoLob->dpiLobHandle)
             temp = Nan::Null();
         else {
@@ -1136,9 +1488,9 @@ bool njsConnection::GetScalarValueFromVar(njsBaton *baton, njsVariable *var,
         return true;
     }
 
-    // get the value from DPI
+    // get the value from ODPI-C
     uint32_t bufferRowIndex = baton->bufferRowIndex + pos;
-    dpiData *data = &var->dpiVarData[bufferRowIndex];
+    dpiData *data = &buffer->dpiVarData[bufferRowIndex];
 
     // transform it to a JS value
     if (data->isNull) {
@@ -1147,7 +1499,7 @@ bool njsConnection::GetScalarValueFromVar(njsBaton *baton, njsVariable *var,
     }
     switch (var->nativeTypeNum) {
         case DPI_NATIVE_TYPE_INT64:
-            temp = Nan::New<Number>(data->value.asInt64);
+            temp = Nan::New<Number>((double) data->value.asInt64);
             break;
         case DPI_NATIVE_TYPE_FLOAT:
             temp = Nan::New<Number>(data->value.asFloat);
@@ -1198,39 +1550,21 @@ bool njsConnection::GetScalarValueFromVar(njsBaton *baton, njsVariable *var,
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::GetValueFromVar()
-//   Get the value from the DPI variable of the specified type.
+// njsConnection::GetArrayValueFromVar()
+//   Get the value from the DPI variable of the specified type as an array.
 //-----------------------------------------------------------------------------
-bool njsConnection::GetValueFromVar(njsBaton *baton, njsVariable *var,
-        Local<Value> &value)
+bool njsConnection::GetArrayValueFromVar(njsBaton *baton, njsVariable *var,
+        uint32_t pos, Local<Value> &value)
 {
-    // scalar values can be handled directly
-    if (!var->isArray && !baton->isReturning)
-        return GetScalarValueFromVar(baton, var, 0, value);
-
-    // determine number of elements in output array
-    uint32_t numElements;
-    if (baton->isReturning) {
-        if (dpiVar_getData(var->dpiVarHandle, &var->maxArraySize,
-                &var->dpiVarData) < 0) {
-            baton->GetDPIError();
-            return false;
-        }
-        numElements = (uint32_t) baton->rowsAffected;
-    } else {
-        if (dpiVar_getNumElementsInArray(var->dpiVarHandle,
-                &numElements) < 0) {
-            baton->GetDPIError();
-            return false;
-        }
-    }
+    njsVariableBuffer *buffer = &var->buffer;
 
-    // process each element in the array
+    if (var->dmlReturningBuffers)
+        buffer = &var->dmlReturningBuffers[pos];
     Nan::EscapableHandleScope scope;
-    Local<Array> arrayVal = Nan::New<Array>(numElements);
-    for (uint32_t i = 0; i < numElements; i++) {
+    Local<Array> arrayVal = Nan::New<Array>(buffer->numElements);
+    for (uint32_t i = 0; i < buffer->numElements; i++) {
         Local<Value> elementValue;
-        if (!GetScalarValueFromVar(baton, var, i, elementValue))
+        if (!GetScalarValueFromVar(baton, var, buffer, i, elementValue))
             return false;
         Nan::Set(arrayVal, i, elementValue);
     }
@@ -1240,54 +1574,81 @@ bool njsConnection::GetValueFromVar(njsBaton *baton, njsVariable *var,
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::GetOutBinds()
+// njsConnection::GetExecuteOutBinds()
+//   Get the out binds as an object/array.
+//-----------------------------------------------------------------------------
+bool njsConnection::GetExecuteOutBinds(Local<Value> &outBinds, njsBaton *baton)
+{
+    uint32_t numOutBinds = baton->GetNumOutBinds();
+
+    if (numOutBinds > 0)
+        return GetOutBinds(outBinds, numOutBinds, 0, baton);
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::GetExecuteManyOutBinds()
 //   Get the out binds as an object/array.
 //-----------------------------------------------------------------------------
-Local<Value> njsConnection::GetOutBinds(njsBaton *baton)
+bool njsConnection::GetExecuteManyOutBinds(Local<Value> &outBinds,
+        uint32_t numOutBinds, njsBaton *baton)
 {
     Nan::EscapableHandleScope scope;
-    uint32_t numOutBinds;
+    Local<Array> rows = Nan::New<Array>(baton->bindArraySize);
+    Local<Value> row;
 
-    // determine the number of out bind variables
-    numOutBinds = 0;
-    for (uint32_t i = 0; i < baton->numBindVars; i++) {
-        if (baton->bindVars[i].bindDir != NJS_BIND_IN)
-            numOutBinds++;
+    for (uint32_t i = 0; i < baton->bindArraySize; i++) {
+        if (!GetOutBinds(row, numOutBinds, i, baton))
+            return false;
+        Nan::Set(rows, i, row);
     }
+    outBinds = scope.Escape(rows);
+    return true;
+}
 
-    // for 0 we return undefined
-    if (numOutBinds == 0)
-        return scope.Escape(Nan::Undefined());
 
-    // process each of the out bind variables
-    bool bindByPos = baton->bindVars[0].name.empty();
+//-----------------------------------------------------------------------------
+// njsConnection::GetOutBinds()
+//   Get the out binds as an object/array.
+//-----------------------------------------------------------------------------
+bool njsConnection::GetOutBinds(Local<Value> &outBinds, uint32_t numOutBinds,
+        uint32_t pos, njsBaton *baton)
+{
+    Nan::EscapableHandleScope scope;
     Local<Array> bindArray;
     Local<Object> bindObj;
     Local<Value> val;
+    bool bindByPos, ok;
+    njsVariable *var;
+
+    bindByPos = baton->bindVars[0].name.empty();
     if (bindByPos)
         bindArray = Nan::New<Array>(numOutBinds);
     else bindObj = Nan::New<Object>();
-    njsVariable *var;
     uint32_t arrayPos = 0;
     for (uint32_t i = 0; i < baton->numBindVars; i++) {
         var = &baton->bindVars[i];
         if (var->bindDir == NJS_BIND_IN)
             continue;
-        if (!GetValueFromVar(baton, var, val))
-            return scope.Escape(Nan::Undefined());
+        if (var->isArray || baton->isReturning)
+            ok = GetArrayValueFromVar(baton, var, pos, val);
+        else ok = GetScalarValueFromVar(baton, var, &var->buffer, pos, val);
+        if (!ok)
+            return false;
         if (bindByPos)
-            Nan::Set(bindArray, arrayPos, val);
+            Nan::Set(bindArray, arrayPos++, val);
         else {
             Local<String> key = Nan::New<String>(var->name.c_str() + 1,
                     (int) var->name.length() - 1).ToLocalChecked();
             Nan::Set(bindObj, key, val);
         }
-        arrayPos++;
     }
-
     if (bindByPos)
-        return scope.Escape(bindArray);
-    return scope.Escape(bindObj);
+        outBinds = scope.Escape(bindArray);
+    else outBinds = scope.Escape(bindObj);
+
+    return true;
 }
 
 
@@ -1309,9 +1670,9 @@ void njsConnection::SetTextAttribute(Nan::NAN_SETTER_ARGS_TYPE args,
         Nan::ThrowError(errMsg.c_str());
         return;
     }
-    v8::String::Utf8Value utfstr(value->ToString());
-    if ((*setter)(connection->dpiConnHandle, *utfstr,
-                  static_cast<int32_t> (utfstr.length()) < 0))
+    Nan::Utf8String utfstr(value->ToString());
+    uint32_t valueLength = static_cast<uint32_t>(utfstr.length());
+    if ((*setter)(connection->dpiConnHandle, *utfstr, valueLength) < 0)
         njsOracledb::ThrowDPIError();
 }
 
@@ -1370,9 +1731,9 @@ NAN_METHOD(njsConnection::Execute)
         baton->extendedMetaData = oracledb->getExtendedMetaData();
     }
     if (ok)
-        ok = ProcessBinds(info, 1, baton);
+        ok = ProcessExecuteBinds(info[1].As<Object>(), baton);
     if (ok)
-        ProcessOptions(info, 2, baton);
+        ProcessExecuteOptions(info[2].As<Object>(), baton);
     baton->CheckJSException(&tryCatch);
     baton->QueueWork("Execute", Async_Execute, Async_AfterExecute, 2);
 }
@@ -1454,9 +1815,10 @@ void njsConnection::Async_AfterExecute(njsBaton *baton, Local<Value> argv[])
                 resultSet);
 
     } else {
-        Nan::DefineOwnProperty (result,
-                Nan::New<v8::String>("outBinds").ToLocalChecked(),
-                GetOutBinds(baton), v8::ReadOnly);
+        Local<Value> outBinds = Nan::Undefined();
+        GetExecuteOutBinds(outBinds, baton);
+        Local<String> key = Nan::New<v8::String>("outBinds").ToLocalChecked();
+        Nan::DefineOwnProperty(result, key, outBinds);
         if (baton->isPLSQL)
             Nan::Set(result,
                     Nan::New<v8::String>("rowsAffected").ToLocalChecked(),
@@ -1476,9 +1838,319 @@ void njsConnection::Async_AfterExecute(njsBaton *baton, Local<Value> argv[])
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::Release()
-//   Releases the connection from use by JS. This releases the connection back
-// to the pool or closes the standalone connection so further use is not
+// njsConnection::ExecuteMany()
+//   Executes a statement on the connection multiple times, once for each row
+// of data that is passed.
+//
+// PARAMETERS
+//   - SQL Statement
+//   - Array of Binds
+//   - Options Object (Optional)
+//   - JS callback which will receive (error, result)
+//-----------------------------------------------------------------------------
+NAN_METHOD(njsConnection::ExecuteMany)
+{
+    njsConnection *connection;
+    njsOracledb *oracledb;
+    std::string sql;
+    njsBaton *baton;
+
+    connection = (njsConnection*) ValidateArgs(info, 4, 4);
+    if (!connection)
+        return;
+    if (!connection->GetStringArg(info, 0, sql))
+        return;
+    baton = connection->CreateBaton(info);
+    if (!baton)
+        return;
+    Nan::TryCatch tryCatch;
+    bool ok = baton->error.empty();
+    if (ok) {
+        baton->sql = sql;
+        baton->SetDPIConnHandle(connection->dpiConnHandle);
+        baton->jsOracledb.Reset(connection->jsOracledb);
+        oracledb = baton->GetOracledb();
+        baton->autoCommit = oracledb->getAutoCommit();
+    }
+    if (ok)
+        ok = ProcessExecuteManyOptions(info[2].As<Object>(), baton);
+    if (ok)
+        ProcessExecuteManyBinds(info[1].As<Array>(), info[2].As<Object>(),
+                baton);
+    baton->CheckJSException(&tryCatch);
+    baton->QueueWork("ExecuteMany", Async_ExecuteMany,
+            Async_AfterExecuteMany, 2);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Async_ExecuteMany()
+//   Worker function for njsConnection::ExecuteMany() method.
+//-----------------------------------------------------------------------------
+void njsConnection::Async_ExecuteMany(njsBaton *baton)
+{
+    uint32_t mode;
+
+    // prepare statement and perform any binds that are needed
+    if (!PrepareAndBind(baton))
+        return;
+
+    // execute statement
+    mode = (baton->autoCommit) ? DPI_MODE_EXEC_COMMIT_ON_SUCCESS :
+            DPI_MODE_EXEC_DEFAULT;
+    if (baton->batchErrors)
+        mode |= DPI_MODE_EXEC_BATCH_ERRORS;
+    if (baton->dmlRowCounts)
+        mode |= DPI_MODE_EXEC_ARRAY_DML_ROWCOUNTS;
+    if (dpiStmt_executeMany(baton->dpiStmtHandle, (dpiExecMode) mode,
+            baton->bindArraySize) < 0) {
+        baton->GetDPIError();
+        return;
+    }
+
+    // process any LOBS for out binds, as needed
+    if (dpiStmt_getRowCount(baton->dpiStmtHandle,
+            &baton->rowsAffected) < 0) {
+        baton->GetDPIError();
+        return;
+    }
+    baton->bufferRowIndex = 0;
+    if (!ProcessVars(baton, baton->bindVars, baton->numBindVars,
+            baton->bindArraySize))
+        return;
+
+    // get DML row counts if option was enabled
+    if (baton->dmlRowCounts) {
+        if (dpiStmt_getRowCounts(baton->dpiStmtHandle, &baton->numRowCounts,
+                &baton->rowCounts) < 0) {
+            baton->GetDPIError();
+            return;
+        }
+    }
+
+    // get batch errors, if option was enabled
+    if (baton->batchErrors) {
+        if (dpiStmt_getBatchErrorCount(baton->dpiStmtHandle,
+                &baton->numBatchErrorInfos) < 0) {
+            baton->GetDPIError();
+            return;
+        }
+        if (baton->numBatchErrorInfos > 0) {
+            baton->batchErrorInfos =
+                    new dpiErrorInfo[baton->numBatchErrorInfos];
+            if (dpiStmt_getBatchErrors(baton->dpiStmtHandle,
+                    baton->numBatchErrorInfos, baton->batchErrorInfos) < 0) {
+                baton->GetDPIError();
+                return;
+            }
+        }
+    }
+
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Async_AfterExecuteMany()
+//   Returns result to JS by invoking JS callback.
+//-----------------------------------------------------------------------------
+void njsConnection::Async_AfterExecuteMany(njsBaton *baton,
+        Local<Value> argv[])
+{
+    Nan::EscapableHandleScope scope;
+    Local<Object> result = Nan::New<v8::Object>();
+
+    // get out binds
+    uint32_t numOutBinds = baton->GetNumOutBinds();
+    Local<Value> outBinds;
+    if (numOutBinds > 0) {
+        if (GetExecuteManyOutBinds(outBinds, numOutBinds, baton)) {
+            Local<String> key = Nan::New<String>("outBinds").ToLocalChecked();
+            Nan::DefineOwnProperty(result, key, outBinds, v8::ReadOnly);
+        }
+    }
+
+    // get total number of rows affected
+    if (!baton->isPLSQL)
+        Nan::DefineOwnProperty(result,
+                Nan::New<v8::String>("rowsAffected").ToLocalChecked(),
+                Nan::New<v8::Integer>( (unsigned int) baton->rowsAffected),
+                v8::ReadOnly);
+
+    // get DML row counts if option was enabled
+    if (baton->dmlRowCounts && baton->numRowCounts > 0) {
+        Local<Array> rowCountsObj = Nan::New<Array>(baton->numRowCounts);
+        for (uint32_t i = 0; i < baton->numRowCounts; i++) {
+            Local<Value> rowCountObj =
+                    Nan::New<Integer>((unsigned int) baton->rowCounts[i]);
+            Nan::Set(rowCountsObj, i, rowCountObj);
+        }
+        Nan::DefineOwnProperty(result,
+                Nan::New<v8::String>("dmlRowCounts").ToLocalChecked(),
+                rowCountsObj, v8::ReadOnly);
+    }
+
+    // get batch errors, if option was enabled
+    if (baton->batchErrors && baton->numBatchErrorInfos > 0) {
+        Local<Array> batchErrorsObj =
+                Nan::New<Array>(baton->numBatchErrorInfos);
+        for (uint32_t i = 0; i < baton->numBatchErrorInfos; i++) {
+            dpiErrorInfo *info = &baton->batchErrorInfos[i];
+            std::string errorStr =
+                    std::string(info->message, info->messageLength);
+            Local<String> errorStrObj =
+                    Nan::New<String>(errorStr).ToLocalChecked();
+            Local<Object> errorObj =
+                    v8::Exception::Error(errorStrObj).As<Object>();
+            Nan::Set(errorObj,
+                    Nan::New<v8::String>("errorNum").ToLocalChecked(),
+                    Nan::New<v8::Number>(info->code));
+            Nan::Set(errorObj,
+                    Nan::New<v8::String>("offset").ToLocalChecked(),
+                    Nan::New<v8::Number>(info->offset));
+            Nan::Set(batchErrorsObj, i, errorObj);
+        }
+        Nan::DefineOwnProperty(result,
+                Nan::New<v8::String>("batchErrors").ToLocalChecked(),
+                batchErrorsObj, v8::ReadOnly);
+    }
+
+    argv[1] = scope.Escape(result);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::GetStatementInfo()
+//   Parses a statement on the connection and returns information about the
+// statement.
+//
+// PARAMETERS
+//   - SQL Statement
+//   - JS callback which will receive (error, result)
+//-----------------------------------------------------------------------------
+NAN_METHOD(njsConnection::GetStatementInfo)
+{
+    njsConnection *connection;
+    std::string sql;
+    njsBaton *baton;
+
+    connection = (njsConnection*) ValidateArgs(info, 2, 2);
+    if (!connection)
+        return;
+    if (!connection->GetStringArg(info, 0, sql))
+        return;
+    baton = connection->CreateBaton(info);
+    if (!baton)
+        return;
+    if (baton->error.empty()) {
+        baton->sql = sql;
+        baton->extendedMetaData = true;
+        baton->SetDPIConnHandle(connection->dpiConnHandle);
+        baton->jsOracledb.Reset(connection->jsOracledb);
+    }
+    baton->QueueWork("GetStatementInfo", Async_GetStatementInfo,
+            Async_AfterGetStatementInfo, 2);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Async_GetStatementInfo()
+//   Worker function for njsConnection::GetStatementInfo() method.
+//-----------------------------------------------------------------------------
+void njsConnection::Async_GetStatementInfo(njsBaton *baton)
+{
+    dpiExecMode mode;
+
+    // prepare DPI statement for use
+    if (dpiConn_prepareStmt(baton->dpiConnHandle, 0, baton->sql.c_str(),
+            (uint32_t) baton->sql.length(), NULL, 0,
+            &baton->dpiStmtHandle) < 0) {
+        baton->GetDPIError();
+        return;
+    }
+
+    // parse the statement
+    if (dpiStmt_getInfo(baton->dpiStmtHandle, &baton->stmtInfo) < 0) {
+        baton->GetDPIError();
+        return;
+    }
+    if (!baton->stmtInfo.isDDL) {
+        if (baton->stmtInfo.isQuery)
+            mode = DPI_MODE_EXEC_DESCRIBE_ONLY;
+        else mode = DPI_MODE_EXEC_PARSE_ONLY;
+        if (dpiStmt_execute(baton->dpiStmtHandle, mode,
+                &baton->numQueryVars) < 0) {
+            baton->GetDPIError();
+            return;
+        }
+    }
+
+    // for queries, process query variables to get metadata
+    if (baton->numQueryVars > 0) {
+        baton->queryVars = new njsVariable[baton->numQueryVars];
+        if (!ProcessQueryVars(baton, baton->dpiStmtHandle, baton->queryVars,
+                baton->numQueryVars))
+            return;
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Async_AfterGetStatementInfo()
+//   Returns result to JS by invoking JS callback.
+//-----------------------------------------------------------------------------
+void njsConnection::Async_AfterGetStatementInfo(njsBaton *baton,
+        Local<Value> argv[])
+{
+    Nan::EscapableHandleScope scope;
+    Local<Object> result = Nan::New<v8::Object>();
+    Local<Object> callingObj, rows;
+    Local<Function> callback;
+    uint32_t numBinds;
+
+    // add metadata (queries only)
+    if (baton->queryVars) {
+        Nan::Set(result, Nan::New<v8::String>("metaData").ToLocalChecked(),
+                GetMetaData(baton->queryVars, baton->numQueryVars,
+                        baton->extendedMetaData));
+    }
+
+    // add list of bind variable names
+    if (dpiStmt_getBindCount(baton->dpiStmtHandle, &numBinds) < 0) {
+        baton->GetDPIError();
+        return;
+    }
+    uint32_t *bindNameLengths = new uint32_t[numBinds];
+    const char **bindNames = new const char *[numBinds];
+    if (dpiStmt_getBindNames(baton->dpiStmtHandle, &numBinds, bindNames,
+            bindNameLengths) < 0) {
+        baton->GetDPIError();
+        delete [] bindNames;
+        delete [] bindNameLengths;
+        return;
+    }
+    Local<Array> bindNamesArray = Nan::New<Array>(numBinds);
+    for (uint32_t i = 0; i < numBinds; i++) {
+        Local<String> bindName = Nan::New<String>(bindNames[i],
+                (int) bindNameLengths[i]).ToLocalChecked();
+        Nan::Set(bindNamesArray, i, bindName);
+    }
+    delete [] bindNames;
+    delete [] bindNameLengths;
+    Nan::Set(result, Nan::New<v8::String>("bindNames").ToLocalChecked(),
+            bindNamesArray);
+
+    // add statement type
+    Nan::Set(result, Nan::New<v8::String>("statementType").ToLocalChecked(),
+            Nan::New(static_cast<int>(baton->stmtInfo.statementType)));
+
+    argv[1] = scope.Escape(result);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Close()
+//   Releases the connection from use by JS. This releases the connection back
+// to the pool or closes the standalone connection so further use is not
 // possible. The reference to the DPI handle is transferred to the baton so
 // that it will be cleared automatically upon success and so that the
 // connection is marked as invalid immediately.
@@ -1486,7 +2158,7 @@ void njsConnection::Async_AfterExecute(njsBaton *baton, Local<Value> argv[])
 // PARAMETERS
 //   - JS callback which will receive (error)
 //-----------------------------------------------------------------------------
-NAN_METHOD(njsConnection::Release)
+NAN_METHOD(njsConnection::Close)
 {
     njsConnection *connection;
     njsBaton *baton;
@@ -1499,17 +2171,17 @@ NAN_METHOD(njsConnection::Release)
         return;
     baton->dpiConnHandle = connection->dpiConnHandle;
     connection->dpiConnHandle = NULL;
-    baton->QueueWork("Release", Async_Release, NULL, 1);
+    baton->QueueWork("Close", Async_Close, NULL, 1);
 }
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::Async_Release()
-//   Worker function for njsConnection::Release() method. If the attempt to
+// njsConnection::Async_Close()
+//   Worker function for njsConnection::Close() method. If the attempt to
 // close fails, the reference to the DPI handle is transferred back from the
 // baton to the connection.
 //-----------------------------------------------------------------------------
-void njsConnection::Async_Release(njsBaton *baton)
+void njsConnection::Async_Close(njsBaton *baton)
 {
     if (dpiConn_close(baton->dpiConnHandle, DPI_MODE_CONN_CLOSE_DEFAULT, NULL,
             0) < 0) {
@@ -1522,10 +2194,10 @@ void njsConnection::Async_Release(njsBaton *baton)
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::Async_AfterRelease()
-//   Finishes release by cleaning up references.
+// njsConnection::Async_AfterClose()
+//   Finishes close by cleaning up references.
 //-----------------------------------------------------------------------------
-void njsConnection::Async_AfterRelease(njsBaton *baton, Local<Value> argv[])
+void njsConnection::Async_AfterClose(njsBaton *baton, Local<Value> argv[])
 {
     njsConnection *connection = (njsConnection*) baton->callingObj;
     connection->jsOracledb.Reset();
@@ -1568,7 +2240,7 @@ void njsConnection::Async_Commit(njsBaton *baton)
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::Commit()
+// njsConnection::Rollback()
 //   Rolls back the active transaction.
 //
 // PARAMETERS
@@ -1710,6 +2382,261 @@ void njsConnection::Async_AfterCreateLob(njsBaton *baton, Local<Value> argv[])
 }
 
 
+//-----------------------------------------------------------------------------
+// njsConnection::ChangePassword()
+//   Change the password on the connection.
+//
+// PARAMETERS
+//   - JS callback which will receive (error)
+//-----------------------------------------------------------------------------
+NAN_METHOD(njsConnection::ChangePassword)
+{
+    std::string user, password, newPassword;
+    njsConnection *connection;
+    njsBaton *baton;
+
+    connection = (njsConnection*) ValidateArgs(info, 4, 4);
+    if (!connection)
+        return;
+    if (!connection->GetStringArg(info, 0, user))
+        return;
+    if (!connection->GetStringArg(info, 1, password))
+        return;
+    if (!connection->GetStringArg(info, 2, newPassword))
+        return;
+    baton = connection->CreateBaton(info);
+    if (!baton)
+        return;
+    if (baton->error.empty()) {
+        baton->SetDPIConnHandle(connection->dpiConnHandle);
+        baton->user = user;
+        baton->password = password;
+        baton->newPassword = newPassword;
+    }
+    baton->QueueWork("ChangePassword", Async_ChangePassword, NULL, 1);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Async_ChangePassword()
+//   Worker function for njsConnection::ChangePassword() method.
+//-----------------------------------------------------------------------------
+void njsConnection::Async_ChangePassword(njsBaton *baton)
+{
+    if (dpiConn_changePassword(baton->dpiConnHandle, baton->user.c_str(),
+            (uint32_t) baton->user.length(), baton->password.c_str(),
+            (uint32_t) baton->password.length(), baton->newPassword.c_str(),
+            (uint32_t) baton->newPassword.length()) < 0)
+        baton->GetDPIError();
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Ping()
+//   Ping the database to see if it is "alive".
+//
+// PARAMETERS
+//   - JS callback which will receive (error)
+//-----------------------------------------------------------------------------
+NAN_METHOD(njsConnection::Ping)
+{
+    njsConnection *connection;
+    njsBaton *baton;
+
+    connection = (njsConnection*) ValidateArgs(info, 1, 1);
+    if (!connection)
+        return;
+    baton = connection->CreateBaton(info);
+    if (!baton)
+        return;
+    if (baton->error.empty())
+        baton->SetDPIConnHandle(connection->dpiConnHandle);
+    baton->QueueWork("Ping", Async_Ping, NULL, 1);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::Async_Ping()
+//   Worker function for njsConnection::Ping() method.
+//-----------------------------------------------------------------------------
+void njsConnection::Async_Ping(njsBaton *baton)
+{
+    if (dpiConn_ping(baton->dpiConnHandle) < 0)
+        baton->GetDPIError();
+}
+
+
+//-----------------------------------------------------------------------------
+// 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.
@@ -1843,3 +2770,43 @@ NAN_SETTER(njsConnection::SetOracleServerVersion)
     PropertyIsReadOnly("oracleServerVersion");
 }
 
+
+//-----------------------------------------------------------------------------
+// njsConnection::GetOracleServerVersionString()
+//   Get accessor of "oracleServerVersionString" property.
+//-----------------------------------------------------------------------------
+NAN_GETTER(njsConnection::GetOracleServerVersionString)
+{
+    njsConnection *connection = (njsConnection*) ValidateGetter(info);
+    if (!connection)
+        return;
+    if (!connection->IsValid()) {
+        info.GetReturnValue().Set(Nan::Undefined());
+        return;
+    }
+    dpiVersionInfo versionInfo;
+    uint32_t releaseStringLength;
+    const char *releaseString;
+    if (dpiConn_getServerVersion(connection->dpiConnHandle, &releaseString,
+            &releaseStringLength, &versionInfo) < 0) {
+        njsOracledb::ThrowDPIError();
+        return;
+    }
+    char versionString[40];
+    (void) sprintf(versionString, "%d.%d.%d.%d.%d", versionInfo.versionNum,
+            versionInfo.releaseNum, versionInfo.updateNum,
+            versionInfo.portReleaseNum, versionInfo.portUpdateNum);
+    Local<String> value = Nan::New<v8::String>(versionString).ToLocalChecked();
+    info.GetReturnValue().Set(value);
+}
+
+
+//-----------------------------------------------------------------------------
+// njsConnection::SetOracleServerVersionString()
+//   Set accessor of "oracleServerVersionString" property.
+//-----------------------------------------------------------------------------
+NAN_SETTER(njsConnection::SetOracleServerVersionString)
+{
+    PropertyIsReadOnly("oracleServerVersionString");
+}
+