{

Nan::HandleScope scope;

Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);

tpl->InstanceTemplate()->SetInternalFieldCount(1);

tpl->SetClassName(Nan::New<v8::String>("Connection").ToLocalChecked());

Nan::SetPrototypeMethod(tpl, "execute", Execute);

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::SetPrototypeMethod(tpl, "getSodaDatabase", GetSodaDatabase);

Nan::SetAccessor(tpl->InstanceTemplate(),

Nan::New<v8::String>("stmtCacheSize").ToLocalChecked(),

njsConnection::GetStmtCacheSize, njsConnection::SetStmtCacheSize);

Nan::SetAccessor(tpl->InstanceTemplate(),

Nan::New<v8::String>("clientId").ToLocalChecked(),

njsConnection::GetClientId, njsConnection::SetClientId);

Nan::SetAccessor(tpl->InstanceTemplate(),

Nan::New<v8::String>("module").ToLocalChecked(),

njsConnection::GetModule, njsConnection::SetModule);

Nan::SetAccessor(tpl->InstanceTemplate(),

Nan::New<v8::String>("action").ToLocalChecked(),

njsConnection::GetAction, njsConnection::SetAction);

Nan::SetAccessor(tpl->InstanceTemplate(),

Nan::New<v8::String>("oracleServerVersion").ToLocalChecked(),

njsConnection::GetOracleServerVersion,

njsConnection::SetOracleServerVersion);

Nan::SetAccessor(tpl->InstanceTemplate(),

Nan::New<v8::String>("oracleServerVersionString").ToLocalChecked(),

njsConnection::GetOracleServerVersionString,

njsConnection::SetOracleServerVersionString);

Nan::SetAccessor(tpl->InstanceTemplate(),

Nan::New<v8::String>("callTimeout").ToLocalChecked(),

njsConnection::GetCallTimeout, njsConnection::SetCallTimeout);

Nan::SetAccessor(tpl->InstanceTemplate(),

Nan::New<v8::String>("tag").ToLocalChecked(),

njsConnection::GetTag, njsConnection::SetTag);

connectionTemplate_s.Reset(tpl);

Nan::Set(target, Nan::New<v8::String>("Connection").ToLocalChecked(),

Nan::GetFunction(tpl).ToLocalChecked());

{

Nan::EscapableHandleScope scope;

njsConnection *connection;

Local<Function> func;

Local<Object> obj;

func = Nan::GetFunction(

Nan::New<FunctionTemplate>(connectionTemplate_s)).ToLocalChecked();

obj = Nan::NewInstance(func).ToLocalChecked();

connection = Nan::ObjectWrap::Unwrap<njsConnection>(obj);

connection->dpiConnHandle = baton->dpiConnHandle;

baton->dpiConnHandle = NULL;

connection->jsOracledb.Reset(baton->jsOracledb);

if (!baton->tag.empty()) {

connection->tag = baton->tag;

connection->retag = true;

}

return scope.Escape(obj);

njsVariable *vars, uint32_t numVars)

{

dpiQueryInfo queryInfo;

// populate variables with query metadata

for (uint32_t i = 0; i < numVars; i++) {

// get query information for the specified column

vars[i].pos = i + 1;

vars[i].isArray = false;

vars[i].bindDir = NJS_BIND_OUT;

if (dpiStmt_getQueryInfo(dpiStmtHandle, vars[i].pos, &queryInfo) < 0) {

baton->GetDPIError();

return false;

}

vars[i].name = std::string(queryInfo.name, queryInfo.nameLength);

vars[i].maxArraySize = baton->fetchArraySize;

vars[i].dbSizeInBytes = queryInfo.typeInfo.dbSizeInBytes;

vars[i].precision = queryInfo.typeInfo.precision +

queryInfo.typeInfo.fsPrecision;

vars[i].scale = queryInfo.typeInfo.scale;

vars[i].isNullable = queryInfo.nullOk;

// determine the type of data

vars[i].dbTypeNum = queryInfo.typeInfo.oracleTypeNum;

vars[i].varTypeNum = queryInfo.typeInfo.oracleTypeNum;

vars[i].nativeTypeNum = queryInfo.typeInfo.defaultNativeTypeNum;

if (queryInfo.typeInfo.oracleTypeNum != DPI_ORACLE_TYPE_VARCHAR &&

queryInfo.typeInfo.oracleTypeNum != DPI_ORACLE_TYPE_NVARCHAR &&

queryInfo.typeInfo.oracleTypeNum != DPI_ORACLE_TYPE_CHAR &&

queryInfo.typeInfo.oracleTypeNum != DPI_ORACLE_TYPE_NCHAR &&

queryInfo.typeInfo.oracleTypeNum != DPI_ORACLE_TYPE_ROWID) {

if (!njsConnection::MapByName(baton, &queryInfo,

vars[i].varTypeNum))

njsConnection::MapByType(baton, &queryInfo,

vars[i].varTypeNum);

}

// validate data type and determine size

if (vars[i].varTypeNum == DPI_ORACLE_TYPE_VARCHAR ||

vars[i].varTypeNum == DPI_ORACLE_TYPE_RAW) {

vars[i].maxSize = NJS_MAX_FETCH_AS_STRING_SIZE;

vars[i].nativeTypeNum = DPI_NATIVE_TYPE_BYTES;

} else {

vars[i].maxSize = 0;

}

switch (queryInfo.typeInfo.oracleTypeNum) {

case DPI_ORACLE_TYPE_VARCHAR:

case DPI_ORACLE_TYPE_NVARCHAR:

case DPI_ORACLE_TYPE_CHAR:

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:

case DPI_ORACLE_TYPE_TIMESTAMP_TZ:

case DPI_ORACLE_TYPE_TIMESTAMP_LTZ:

if (vars[i].varTypeNum != DPI_ORACLE_TYPE_VARCHAR) {

vars[i].varTypeNum = DPI_ORACLE_TYPE_TIMESTAMP_LTZ;

vars[i].nativeTypeNum = DPI_NATIVE_TYPE_DOUBLE;

}

break;

case DPI_ORACLE_TYPE_CLOB:

case DPI_ORACLE_TYPE_NCLOB:

if (vars[i].varTypeNum == DPI_ORACLE_TYPE_VARCHAR)

vars[i].maxSize = (uint32_t) -1;

break;

case DPI_ORACLE_TYPE_BLOB:

if (vars[i].varTypeNum == DPI_ORACLE_TYPE_RAW)

vars[i].maxSize = (uint32_t) -1;

break;

case DPI_ORACLE_TYPE_LONG_VARCHAR:

case DPI_ORACLE_TYPE_LONG_RAW:

vars[i].maxSize = (uint32_t) -1;

break;

case DPI_ORACLE_TYPE_NUMBER:

case DPI_ORACLE_TYPE_NATIVE_INT:

case DPI_ORACLE_TYPE_NATIVE_FLOAT:

case DPI_ORACLE_TYPE_NATIVE_DOUBLE:

case DPI_ORACLE_TYPE_ROWID:

break;

default:

baton->error = njsMessages::Get(errUnsupportedDataType,

queryInfo.typeInfo.oracleTypeNum, i + 1);

baton->ClearAsyncData();

return false;

}

}

return true;

uint32_t numVars, uint32_t numRows)

{

for (uint32_t col = 0; col < numVars; col++) {

njsVariable *var = &vars[col];

var->buffer.numElements = numRows;

if (var->bindDir == NJS_BIND_IN)

continue;

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;

}

if (!ProcessVarBuffer(baton, var, buffer))

return false;

}

}

// process the main buffer if DML returning is not in effect

if (!var->dmlReturningBuffers &&

!ProcessVarBuffer(baton, var, &var->buffer))

return false;

}

return true;

njsVariableBuffer *buffer)

{

dpiStmt *stmt;

switch (var->varTypeNum) {

case DPI_ORACLE_TYPE_CLOB:

case DPI_ORACLE_TYPE_NCLOB:

case DPI_ORACLE_TYPE_BLOB:

if (buffer->lobs)

delete [] buffer->lobs;

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;

}

var->queryVars = new njsVariable[var->numQueryVars];

if (!ProcessQueryVars(baton, stmt, var->queryVars,

var->numQueryVars))

return false;

break;

default:

break;

}

return true;

dpiOracleTypeNum &targetType)

{

if (baton->fetchInfo) {

std::string name = std::string(queryInfo->name, queryInfo->nameLength);

for (uint32_t i = 0; i < baton->numFetchInfo; i++) {

if (baton->fetchInfo[i].name.compare(name) == 0) {

if (baton->fetchInfo[i].type == NJS_DATATYPE_STR) {

targetType = DPI_ORACLE_TYPE_VARCHAR;

} else if (baton->fetchInfo[i].type == NJS_DATATYPE_BUFFER) {

targetType = DPI_ORACLE_TYPE_RAW;

} else if (baton->fetchInfo[i].type == NJS_DATATYPE_DEFAULT) {

targetType = queryInfo->typeInfo.oracleTypeNum;

}

return true;

}

}

}

return false;

dpiOracleTypeNum &targetType)

{

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:

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:

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:

if (baton->fetchAsStringTypes[i] == NJS_DATATYPE_CLOB) {

targetType = DPI_ORACLE_TYPE_VARCHAR;

return true;

}

break;

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;

{

// 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 false;

}

// determine statement information

dpiStmtInfo stmtInfo;

if (dpiStmt_getInfo(baton->dpiStmtHandle, &stmtInfo) < 0) {

baton->GetDPIError();

return false;

}

baton->isPLSQL = (stmtInfo.isPLSQL) ? true : false;

baton->isReturning = (stmtInfo.isReturning) ? true : false;

// result sets are incompatible with non-queries

if (!stmtInfo.isQuery && baton->getRS) {

baton->error = njsMessages::Get(errInvalidNonQueryExecution);

baton->ClearAsyncData();

return false;

}

// 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 false;

}

}

return true;

bool extendedMetaData)

{

Nan::EscapableHandleScope scope;

Local<Array> metaArray = Nan::New<Array>((int)numVars);

for (uint32_t i = 0; i < numVars; i++) {

njsVariable *var = &vars[i];

Local<Object> column = Nan::New<Object>();

Nan::Set(column, Nan::New<v8::String>("name").ToLocalChecked(),

Nan::New<v8::String>(var->name).ToLocalChecked());

if (extendedMetaData) {

njsDBType dbType = var->DBType();

Nan::Set(column,

Nan::New<v8::String>("fetchType").ToLocalChecked(),

Nan::New<v8::Number>(var->DataType()));

Nan::Set(column,

Nan::New<v8::String>("dbType").ToLocalChecked(),

Nan::New<v8::Number>(dbType));

Nan::Set(column,

Nan::New<v8::String>("nullable").ToLocalChecked(),

Nan::New<v8::Boolean>(var->isNullable));

switch (dbType) {

case NJS_DB_TYPE_VARCHAR:

case NJS_DB_TYPE_NVARCHAR:

case NJS_DB_TYPE_CHAR:

case NJS_DB_TYPE_NCHAR:

case NJS_DB_TYPE_RAW:

Nan::Set(column,

Nan::New<v8::String>("byteSize").ToLocalChecked(),

Nan::New<v8::Number>(var->dbSizeInBytes));

break;

case NJS_DB_TYPE_NUMBER:

Nan::Set(column,

Nan::New<v8::String>("precision").ToLocalChecked(),

Nan::New<v8::Number>(var->precision));

Nan::Set(column,

Nan::New<v8::String>("scale").ToLocalChecked(),

Nan::New<v8::Number>(var->scale) );

break;

case NJS_DB_TYPE_TIMESTAMP:

case NJS_DB_TYPE_TIMESTAMP_TZ:

case NJS_DB_TYPE_TIMESTAMP_LTZ:

Nan::Set(column,

Nan::New<v8::String>("precision").ToLocalChecked(),

Nan::New<v8::Number>(var->precision));

break;

default:

break;

}

}

Nan::Set(metaArray, i, column);

}

return scope.Escape(metaArray);

{

// if the variable is not an array use the bind array size

if (!var->isArray)

var->maxArraySize = baton->bindArraySize;

// 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 (var->bindDataType == NJS_DATATYPE_CURSOR &&

var->bindDir != NJS_BIND_OUT) {

baton->error = njsMessages::Get(errInvalidPropertyValueInParam,

"type", 1);

return false;

}

// max size must be specified for in/out and out binds

if (!var->maxSize && var->bindDir != NJS_BIND_IN) {

baton->error = njsMessages::Get(errInvalidPropertyValueInParam,

"maxSize", 1);

return false;

}

// 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;

break;

case NJS_DATATYPE_NUM:

var->varTypeNum = DPI_ORACLE_TYPE_NUMBER;

var->nativeTypeNum = DPI_NATIVE_TYPE_DOUBLE;

break;

case NJS_DATATYPE_INT:

var->varTypeNum = DPI_ORACLE_TYPE_NUMBER;

var->nativeTypeNum = DPI_NATIVE_TYPE_INT64;

break;

case NJS_DATATYPE_DATE:

var->varTypeNum = DPI_ORACLE_TYPE_TIMESTAMP_LTZ;

var->nativeTypeNum = DPI_NATIVE_TYPE_DOUBLE;

break;

case NJS_DATATYPE_CURSOR:

var->varTypeNum = DPI_ORACLE_TYPE_STMT;

var->nativeTypeNum = DPI_NATIVE_TYPE_STMT;

break;

case NJS_DATATYPE_BUFFER:

var->varTypeNum = DPI_ORACLE_TYPE_RAW;

var->nativeTypeNum = DPI_NATIVE_TYPE_BYTES;

break;

case NJS_DATATYPE_CLOB:

var->varTypeNum = DPI_ORACLE_TYPE_CLOB;

var->nativeTypeNum = DPI_NATIVE_TYPE_LOB;

break;

case NJS_DATATYPE_BLOB:

var->varTypeNum = DPI_ORACLE_TYPE_BLOB;

var->nativeTypeNum = DPI_NATIVE_TYPE_LOB;

break;

default:

baton->error= njsMessages::Get(errInvalidBindDataType, 2);

return false;

}

// create ODPI-C variable

if (dpiConn_newVar(baton->dpiConnHandle, var->varTypeNum,

var->nativeTypeNum, var->maxArraySize, var->maxSize, 1,

var->isArray, NULL, &var->dpiVarHandle,

&var->buffer.dpiVarData) < 0) {

baton->GetDPIError();

return false;

}

return true;

{

Nan::HandleScope scope;

Local<Array> bindNames;

// determine bind names (if binding by name)

baton->bindArraySize = 1;

if (!binds->IsUndefined() && !binds->IsArray())

bindNames = Nan::GetOwnPropertyNames(binds).ToLocalChecked();

// 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);

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) {

MaybeLocal<Value> mval = Nan::Get(byPositionValues, i);

if (!mval.ToLocal(&bindUnit))

return false;

} else {

MaybeLocal<Value> mval = Nan::Get(bindNames, i);

if (!mval.ToLocal(&bindName))

return false;

mval = Nan::Get(binds, bindName);

if(!mval.ToLocal(&bindUnit))

return false;

}

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();

MaybeLocal<Value> mval = Nan::Get(bindUnit.As<Object>(), key);

if (!mval.ToLocal(&bindValue))

return false;

} 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;

njsVariable *var, bool inExecuteMany, njsBaton *baton)

{

Nan::HandleScope scope;

// 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 = Nan::GetOwnPropertyNames(bindUnit).ToLocalChecked();

bool valid = false;

for (uint32_t i = 0; i < keys->Length(); i++) {

MaybeLocal<Value> mval = Nan::Get(keys, i );

Local<Value> tempVal;

if (!mval.ToLocal(&tempVal))

return false;

Local<String> temp = tempVal.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;

}

// 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;

}

// 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;

// 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;

Local<Object> options, njsBaton *baton)

{

Nan::HandleScope scope;

Local<Value> bindDefs, bindName, bindUnit;

Local<Array> bindNames;

bool scanRequired;

// 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();

// if no bind definitions are specified, the first row is used to determine

// the number of bind variables and types

if (scanRequired && !binds.IsEmpty()) {

MaybeLocal<Value> mval = Nan::Get(binds, 0);

if (!mval.ToLocal (&bindDefs))

return false;

}

// bindDefs must be an array or object

if (!bindDefs->IsUndefined() && !bindDefs->IsArray()) {

if (!bindDefs->IsObject()) {

baton->error = njsMessages::Get(errInvalidParameterValue, 2);

return false;

}

bindNames = Nan::GetOwnPropertyNames(bindDefs.As<Object>()).

ToLocalChecked();

}

// 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) {

MaybeLocal<Value> mval = Nan::Get(byPositionValues, i);

if(!mval.ToLocal(&bindUnit))

return false;

} else {

MaybeLocal<Value> mval = Nan::Get(bindNames, i);

if(!mval.ToLocal(&bindName))

return false;

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 (!binds.IsEmpty() && !TransferExecuteManyBinds(binds, bindNames, baton))

return false;

return true;

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;