add initial support for vectors

Author: ValYouW

lib/oracle.js

@@ -34,6 +34,7 @@ exports.OCCIDATE = 6;
 exports.OCCITIMESTAMP = 7;
 exports.OCCINUMBER = 8;
 exports.OCCIBLOB = 9;
+exports.OCCIVECTOR = 10;
 
 // Reader is implemented in JS around a C++ handle
 // This is easier and also more efficient because we don't cross the JS/C++ boundary 

src/outParam.cpp

@@ -60,6 +60,93 @@ uni::CallbackType OutParam::New(const uni::FunctionCallbackInfo& args) {
         OBJ_GET_STRING(opts, "in", outParam->_inOut.stringVal);
         break;
       }
+      case OutParam::OCCIVECTOR: {
+        // Get the vector's elements type
+        Local<Value> valType = opts->Get(String::New("type"));
+        if(valType->IsUndefined() || valType->IsNull())
+          UNI_THROW(Exception::Error(String::New("OutParam::OCCIVECTOR missing `type` property")));
+
+        // Create the collection according to the elem type.
+        int type = valType->ToInt32()->Value();
+        switch(type) {
+        // Here we create the array buffer that will be used later as the value for the param on the sp statement (Connection::SetValuesOnStatement)
+        case OutParam::OCCISTRING: {
+          outParam->_inOut.elemetnsType = oracle::occi::OCCI_SQLT_STR;
+
+          // Get the array
+          Local<Array> arr = Local<Array>::Cast(opts->Get(String::New("in")));
+							
+          // Find the longest string, this is necessary in order to create a buffer later.
+		  // If "size" was provided by the user we use it as the size of the "longest string", otherwise we would look for it.
+          int longestString = 0;
+		  if (opts->Has(String::New("in"))) {
+		    longestString = outParam->_size;
+		  } else {
+            for(unsigned int i = 0; i < arr->Length(); i++) {
+              Local<Value> val = arr->Get(i);
+              if (val->ToString()->Utf8Length() > longestString)
+                longestString = val->ToString()->Utf8Length();
+            }
+		  }
+
+		  // Add 1 for '\0'
+          ++longestString;
+
+		  // Create a long char* that will hold the entire array, it is important to create a FIXED SIZE array,
+          // meaning all strings have the same allocated length.
+          char* strArr = new char[arr->Length() * longestString];
+          outParam->_inOut.elementLength = new ub2[arr->Length()];
+
+          // loop thru the arr and copy the strings into the strArr
+          int bytesWritten = 0;
+          for(unsigned int i = 0; i < arr->Length(); i++) {
+            Local<Value> val = arr->Get(i);
+            if(!val->IsString()) {
+              UNI_THROW(Exception::Error(String::New("OutParam::OCCIVECTOR of type OCCISTRING must include string types only")));
+			}
+            
+			String::Utf8Value utfStr(val);
+									
+            // Copy this string onto the strArr (we put \0 in the beginning as this is what strcat expects).
+            strArr[bytesWritten] = '\0';
+            strncat(strArr + bytesWritten, *utfStr, longestString);
+            bytesWritten += longestString;
+									
+            // Set the length of this element, add +1 for the '\0'
+            outParam->_inOut.elementLength[i] = utfStr.length() + 1;
+          }
+
+          outParam->_inOut.collectionValues = strArr;
+          outParam->_inOut.collectionLength = arr->Length();
+          outParam->_inOut.elementsSize = longestString;
+          break;
+        }
+        case OutParam::OCCIINT: {
+          Local<Array> arr = Local<Array>::Cast( opts->Get(String::New("in")));
+
+          // Allocate memory and copy the ints.
+          int* intArr = new int[arr->Length()];
+          for(unsigned int i = 0; i < arr->Length(); i++) {
+            Local<Value> val = arr->Get(i);
+            if(!val->IsInt32()) {
+              UNI_THROW(Exception::Error(String::New("OutParam::OCCIVECTOR of type OCCIINT must include integer types only")));
+			}
+
+			intArr[i] = val->ToInt32()->Value();
+          }
+
+          outParam->_inOut.collectionValues = intArr;
+          outParam->_inOut.collectionLength = arr->Length();
+          outParam->_inOut.elementsSize = sizeof(int);
+          outParam->_inOut.elemetnsType = oracle::occi::OCCIINT;
+          break;
+        }
+        default: 
+          UNI_THROW(Exception::Error(String::New("OutParam::OCCIVECTOR unsupported `type`, only supports OCCIINT and OCCISTRING")));
+        }
+		// End case:OCCIVECTOR
+        break;
+      }
       default:
         UNI_THROW(Exception::Error(String::New("Unhandled OutPram type!")));
       }
@@ -76,6 +163,19 @@ OutParam::OutParam() {
 }
 
 OutParam::~OutParam() {
+  if (_inOut.collectionValues != NULL) {
+    // This can be either a char* or int*
+    if (_inOut.elemetnsType == oracle::occi::OCCIINT)
+      delete (int*)(_inOut.collectionValues);
+    else if (_inOut.elemetnsType == oracle::occi::OCCI_SQLT_STR)
+      delete (char*)(_inOut.collectionValues);
+  }
+
+  if (_inOut.elementLength != 0)
+    delete _inOut.elementLength;
+
+  if (_inOut.stringVal != NULL)
+    delete _inOut.stringVal;
 }
 
 int OutParam::type() {

src/outParam.h

@@ -22,6 +22,13 @@ struct inout_t {
   oracle::occi::Date dateVal;
   oracle::occi::Timestamp timestampVal;
   oracle::occi::Number numberVal;
+
+  // This will hold the info needed for binding vectors values
+  void* collectionValues;
+  ub4 collectionLength;
+  sb4 elementsSize; // The size of each element in the array
+  ub2* elementLength; //  An array that holds the actual length of each element in the array (in case of strings)
+  oracle::occi::Type elemetnsType;
 };
 
 class OutParam : public ObjectWrap {
@@ -47,6 +54,7 @@ class OutParam : public ObjectWrap {
   static const int OCCITIMESTAMP = 7;
   static const int OCCINUMBER = 8;
   static const int OCCIBLOB = 9;
+  static const int OCCIVECTOR = 10;
 
 private:
 };

tests-settings.json

@@ -1,5 +1,5 @@
 {
-  "hostname": "localhost",
-  "user": "test",
-  "password": "test"
+  "hostname": "yubuntu",
+  "user": "yuvalw",
+  "password": "123457"
 }