Added support for RAW data type by @bjouhier

Author: cjbj

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## node-oracledb v1.2.0 (DD Mon YYYY)
 
+- Added support for RAW data type.
+
 - Fixed intermittent crash while setting `fetchAsString`, and incorrect output while reading the value.
 
 - Changed write-only attributes to allow console.log() on Connection objects. Note the attribute values will show as null; refer to the documentation.

doc/api.md

@@ -27,6 +27,7 @@ limitations under the License.
      - BIND_INOUT
      - BIND_OUT
      - BLOB
+     - BUFFER
      - CLOB
      - CURSOR
      - DATE
@@ -259,6 +260,8 @@ Oracledb.OBJECT                    // Fetch each row as an object
 ```
 Oracledb.BLOB                      // Bind a BLOB to return a Node.js buffer
 
+Oracledb.BUFFER                    // Bind a RAW to return  a Node.js Buffer
+
 Oracledb.CLOB                      // Bind a CLOB to return a Node.js string
 
 Oracledb.CURSOR                    // Bind a REF CURSOR to a node-oracledb ResultSet class
@@ -1137,8 +1140,14 @@ Bind Property | Description
 ---------------|------------
 `val` | The input value or variable to be used for an IN or IN OUT bind variable.
 `dir` | The direction of the bind.  One of the [Oracledb Constants](#oracledbconstants) `BIND_IN`, `BIND_INOUT`, or `BIND_OUT`.
-`type` | The datatype to be bound. One of the [Oracledb Constants](#oracledbconstants) `STRING`, `NUMBER`, `DATE` or `CURSOR`.
-`maxSize` | The maximum number of bytes that an OUT or IN OUT bind variable of type STRING can use. The default value is 200. The maximum limit is 32767.
+`type` | The datatype to be bound. One of the [Oracledb Constants](#oracledbconstants) `STRING`, `NUMBER`, `DATE`, `CURSOR` or `BUFFER`.
+`maxSize` | The maximum number of bytes that an OUT or IN OUT bind variable of type STRING or BUFFER can use. The default value is 200. The maximum limit is 32767.
+
+In case of BUFFER type, when using Oracle Database 12c, in the init.ora file
+if MAX_STRING_SIZE parameter has a value of STANDARD, then the maximum size of
+BUFFER type is 4000.  If MAX_STRING_SIZE parameter has a value of EXTENDED then
+the maximum size of BUFFER type is 32767.  In earlier versions of Oracle
+Database, the maximum size of BUFFER type is 4000.
 
 With OUT binds, where the type cannot be inferred by node-oracledb
 because there is no input data value, the type defaults to `STRING`
@@ -2893,7 +2902,7 @@ connection.execute("INSERT INTO countries VALUES (:country_id, :country_name)",
 ```
 
 For IN binds the direction must be `BIND_IN`.  The type can be
-`STRING`, `NUMBER` or `DATE`, matching the data.  The type `CURSOR`
+`STRING`, `NUMBER`, `DATE` or `BUFFER`, matching the data.  The type `CURSOR`
 cannot be used with IN binds.
 
 ### <a name="outbind"></a> 12.2 OUT and IN OUT Bind Parameters
@@ -2906,10 +2915,10 @@ properties is used.
 The `dir` attribute should be `BIND_OUT` or `BIND_INOUT`.
 
 For `BIND_INOUT` parameters, the `type` attribute should be `STRING`,
-`NUMBER` or `DATE`.
+`NUMBER`, `DATE` or `BUFFER`.
 
 For `BIND_OUT` parameters the `type` attribute should be `STRING`,
-`NUMBER`, `DATE`, `CURSOR`, `BLOB` or `CLOB`.
+`NUMBER`, `DATE`, `CURSOR`, `BLOB`, `CLOB` or `BUFFER`.
 
 If `type` is not specified then `STRING` is assumed.
 

src/njs/src/njsConnection.cpp

@@ -572,7 +572,7 @@ void Connection::GetBindUnit (Handle<Value> val, Bind* bind,
   NanScope();
   unsigned int dir   = BIND_IN;
 
-  if(val->IsObject() && !val->IsDate())
+  if(val->IsObject() && !val->IsDate() && !Buffer::HasInstance(val))
   {
     dir                     = BIND_UNKNOWN;
     Local<Object> bind_unit = val->ToObject();
@@ -674,6 +674,10 @@ void Connection::GetOutBindParams (unsigned short dataType, Bind* bind,
       bind->type     = dpi::DpiRSet;
       bind->maxSize  = 0;
       break;
+    case DATA_BUFFER :
+      bind->type     = dpi::DpiRaw;
+      bind->maxSize  = 0;
+      break;
     case DATA_CLOB : 
       bind->type    = dpi::DpiClob;
       bind->maxSize  = 0;
@@ -807,6 +811,33 @@ void Connection::GetInBindParams (Handle<Value> v8val, Bind* bind,
     /* Convert v8::Date value to long double */
     Connection::v8Date2OraDate ( v8val, bind);
   }
+  else if(v8val->IsObject ())
+  {
+    Local<Object> obj = v8val->ToObject();
+    if (Buffer::HasInstance(obj)) {
+      size_t bufLen = Buffer::Length(obj);
+      bind->type = dpi::DpiRaw;
+      if(type == BIND_INOUT)
+      {
+        *(bind->len) = bufLen;
+      }
+      else // IN
+      {
+        bind->maxSize = *(bind->len) = bufLen;
+      }
+      DPI_SZ_TYPE size = (bind->maxSize >= *(bind->len) ) ?
+                         bind->maxSize : *(bind->len);
+      if(size)
+      {
+        bind->value = (char*)malloc(size);
+        if(bufLen)
+          memcpy(bind->value, Buffer::Data(obj), bufLen);
+      }
+    } else {
+      executeBaton->error= NJSMessages::getErrorMsg(errInvalidBindDataType,2);
+      goto exitGetInBindParams;
+    }
+  }
   else
   {
     executeBaton->error= NJSMessages::getErrorMsg(errInvalidBindDataType,2);
@@ -839,6 +870,23 @@ void Connection::Async_Execute (uv_work_t *req)
 
     if ( !executeBaton->error.empty() )  goto exitAsyncExecute;
 
+    // In DML Returning statements, Buffer type is not allowed temporarily.
+    if ( executeBaton->stmtIsReturning )
+    {
+      for ( unsigned int b = 0; b < executeBaton->binds.size () ; b ++ )
+      {
+        if ( executeBaton->binds[b]->isOut && 
+             executeBaton->binds[b]->type == dpi::DpiRaw )
+        {
+          executeBaton->error = NJSMessages::getErrorMsg ( 
+                                                  errBufferReturningInvalid );
+          return;
+          
+        }
+      }
+    }
+      
+
     if (executeBaton->st == DpiStmtSelect)
     {
       // set prefetch
@@ -1523,6 +1571,26 @@ void Connection::DoDefines ( eBaton* executeBaton, const dpi::MetaData* meta,
 
         }
         break;
+      case dpi::DpiRaw :
+        defines[col].fetchType = DpiRaw;
+        defines[col].maxSize   = meta[col].dbSize;
+
+        if ( NJS_SIZE_T_OVERFLOW ( defines[col].maxSize,
+                                   executeBaton->maxRows ) )
+        {
+          executeBaton->error = NJSMessages::getErrorMsg (
+                                                     errResultsTooLarge ) ;
+          return;
+        }
+        defines[col].buf = (char *)malloc(defines[col].maxSize *
+                                          executeBaton->maxRows) ;
+        if ( !defines[col].buf )
+        {
+          executeBaton->error = NJSMessages::getErrorMsg ( 
+                                         errInsufficientMemory );
+          return;
+        }
+        break;
 
       case dpi::DpiClob:
       case dpi::DpiBlob:
@@ -2174,6 +2242,9 @@ Handle<Value> Connection::GetValueCommon ( eBaton *executeBaton,
          date = NanNew<v8::Date>( *(long double*)val );
          value = date;
         break;
+       case (dpi::DpiRaw) :
+         value = NanNewBufferHandle((char*)val, len);
+         break;
         // The LOB types are hit only by the define code path
         // The bind code path has its own Connection::GetValueLob method
        case (dpi::DpiClob):

src/njs/src/njsMessages.cpp

@@ -60,6 +60,7 @@ static const char *errMsg[] =
   "NJS-024: memory allocation failed",
   "NJS-025: overflow when calculating results area size",
   "NJS-026: maxRows must be greater than zero",
+  "NJS-027: raw database type is not supported with DML Returning statements",
 };
 
 string NJSMessages::getErrorMsg ( NJSErrorType err, ... )

src/njs/src/njsMessages.h

@@ -59,6 +59,7 @@ typedef enum
   errInsufficientMemory,
   errResultsTooLarge,
   errInvalidmaxRows,
+  errBufferReturningInvalid,
 
   // New ones should be added here
 

test/dataTypeAssist.js

@@ -60,7 +60,8 @@ assist.allDataTypeNames =
   "oracledb_timestamp6"   : "TIMESTAMP (9) WITH LOCAL TIME ZONE",
   "oracledb_rowid"        : "ROWID",
   "oracledb_myclobs"      : "CLOB",
-  "oracledb_myblobs"      : "BLOB"
+  "oracledb_myblobs"      : "BLOB",
+  "oracledb_raw"          : "RAW(2000)"
 };
 
 assist.data = {
@@ -368,6 +369,15 @@ assist.createCharString = function(size) {
   return buffer.toString();
 }
 
+assist.createBuffer = function(size) {
+  var array = [];
+  for(var i = 0; i < size; i++) {
+    var b = Math.floor(Math.random() * 256); // generate a random integer among 0-255
+    array.push(b);
+  }
+  return new Buffer(array);
+}
+
 assist.setUp = function(connection, tableName, array, done) 
 {
   async.series([
@@ -483,6 +493,8 @@ assist.dataTypeSupport = function(connection, tableName, array, done) {
           result.rows[i].CONTENT.trim().should.eql(array[result.rows[i].NUM]);
         else if( (typeof result.rows[i].CONTENT) === 'number' )
           result.rows[i].CONTENT.should.eql(array[result.rows[i].NUM]);
+        else if( Buffer.isBuffer(result.rows[i].CONTENT) )
+          result.rows[i].CONTENT.toString('hex').should.eql(array[result.rows[i].NUM].toString('hex'));
         else
           result.rows[i].CONTENT.toUTCString().should.eql(array[result.rows[i].NUM].toUTCString());
       }   
@@ -560,6 +572,8 @@ function fetchRowsFromRS(rs, array, cb)
           rows[i].CONTENT.trim().should.eql(array[rows[i].NUM]); 
         else if( (typeof rows[i].CONTENT) === 'number' )
           rows[i].CONTENT.should.eql(array[rows[i].NUM]);
+        else if( Buffer.isBuffer(rows[i].CONTENT) )
+          rows[i].CONTENT.toString('hex').should.eql(array[rows[i].NUM].toString('hex'));
         else 
           rows[i].CONTENT.toUTCString().should.eql(array[rows[i].NUM].toUTCString());     
       }