work on support for NdbRecord-backed ValueObjects which contain

TEXT or BLOB columns.

Author: jdduncan

Adapter/impl/ndb/NdbOperation.js

@@ -567,7 +567,7 @@ function buildValueObject(op) {
 
   if(VOC) {
     /* Turn the buffer into a Value Object */
-    op.result.value = new VOC(op.buffers.row);
+    op.result.value = new VOC(op.buffers.row, op.blobs);
 
     /* TODO: Apply type converters here, rather than in Column Handler??? */
 
@@ -732,11 +732,11 @@ function buildOperationResult(transactionHandler, op, op_ndb_error, execMode) {
     }
 
     if(op.result.success && op.opcode === opcodes.OP_READ) {
-      if(op.tableHandler.numberOfLobColumns) {
-        readResultRow(op);    // Objects with BLOBs get plain JS Objects
-      } else {
+//      if(op.tableHandler.numberOfLobColumns) {
+//        readResultRow(op);    // Objects with BLOBs get plain JS Objects
+//      } else {
         buildValueObject(op); // Objects without BLOBS get ValueObjects
-      }
+//      }
     } 
   }
   if(udebug.is_detail()) udebug.log("buildOperationResult finished:", op.result);

Adapter/impl/ndb/include/ColumnHandler.h

@@ -26,13 +26,16 @@ using v8::Handle;
 using v8::Value;
 using v8::Object;
 
+class BlobWriteHandler;
+
 class ColumnHandler {
 public:
   ColumnHandler();
   ~ColumnHandler();
   void init(const NdbDictionary::Column *, size_t, Handle<Value>);
-  Handle<Value> read(char *) const;
+  Handle<Value> read(char *, Handle<Object>) const;
   Handle<Value> write(Handle<Value>, char *) const;
+  BlobWriteHandler * createBlobWriteHandle(Handle<Value>, int fieldNo) const;
 
 public:
   const NdbDictionary::Column *column;
@@ -43,6 +46,7 @@ class ColumnHandler {
   Persistent<Object> converterReader;
   Persistent<Object> converterWriter;
   bool hasConverterReader, hasConverterWriter;
+  bool isLob, isText;
 };
 
 

Adapter/impl/ndb/include/ColumnProxy.h

@@ -27,15 +27,22 @@ class ColumnProxy {
   ColumnProxy();
   ~ColumnProxy();
   void setHandler(const ColumnHandler *);
+  void setBlobBuffer(Handle<Value>);
+  bool valueIsNull();
+  BlobWriteHandler * createBlobWriteHandle(int);
 
   Handle<Value> get(char *);
   void          set(Handle<Value>);
   Handle<Value> write(char *);
-  bool          isNull;  // value has been set to null
+
+protected:
+  void Dispose();
 
 private:
   const ColumnHandler *handler;
   Persistent<Value> jsValue;
+  Persistent<Object> blobBuffer;
+  bool isNull;           // value has been set to null
   bool isLoaded;         // value has been read from buffer
   bool isDirty;          // value should be rewritten in buffer
 };
@@ -49,4 +56,10 @@ inline void ColumnProxy::setHandler(const ColumnHandler *h) {
   handler = h;
 }
 
+inline bool ColumnProxy::valueIsNull() {
+  return isNull;
+}
 
+inline void ColumnProxy::setBlobBuffer(Handle<Value> buffer) {
+  blobBuffer = Persistent<Object>(buffer->ToObject());
+}

Adapter/impl/ndb/include/KeyOperation.h

@@ -55,6 +55,7 @@ class KeyOperation {
   void setRowMask(uint32_t);
 
   // Prepare operation
+  void setBlobHandler(BlobHandler *);
   bool isBlobReadOperation();
   const NdbOperation *prepare(NdbTransaction *);
 

Adapter/impl/ndb/include/NdbRecordObject.h

@@ -20,10 +20,11 @@
 
 #include "Record.h"
 #include "ColumnProxy.h"
+#include "KeyOperation.h"
 
 class NdbRecordObject {
 public:
-  NdbRecordObject(const Record *, ColumnHandlerSet *, Handle<Value>);
+  NdbRecordObject(const Record *, ColumnHandlerSet *, Handle<Value>, Handle<Value>);
   ~NdbRecordObject();
 
   Handle<Value> getField(int);
@@ -35,6 +36,7 @@ class NdbRecordObject {
   char * getBuffer() const;
   uint32_t getMaskValue() const;
   unsigned short getWriteCount() const;
+  void createBlobWriteHandles(KeyOperation &);
 
 private:
   const Record * record;

Adapter/impl/ndb/include/NdbTypeEncoders.h

@@ -21,12 +21,13 @@
 #include <node.h>
 #include <NdbApi.hpp>
 
-typedef v8::Handle<v8::Value> EncoderReader(const NdbDictionary::Column *, 
-                                            char *, size_t);
+using namespace v8;
 
-typedef v8::Handle<v8::Value> EncoderWriter(const NdbDictionary::Column *, 
-                                            v8::Handle<v8::Value>, 
-                                            char *, size_t);
+typedef Handle<Value> EncoderReader(const NdbDictionary::Column *, 
+                                    char *, size_t);
+
+typedef Handle<Value> EncoderWriter(const NdbDictionary::Column *, 
+                                    Handle<Value>, char *, size_t);
 
 typedef struct {
   EncoderReader * read;
@@ -36,4 +37,5 @@ typedef struct {
 
 const NdbTypeEncoder * getEncoderForColumn(const NdbDictionary::Column *);
 
-
+Handle<Object> getBufferForText(const NdbDictionary::Column *, Handle<String>);
+Handle<String> getTextFromBuffer(const NdbDictionary::Column *, Handle<Object>);

Adapter/impl/ndb/src/ColumnHandler.cpp

@@ -19,8 +19,8 @@
  */
 
 #include "adapter_global.h"
-
 #include "ColumnHandler.h"
+#include "BlobHandler.h"
 
 using namespace v8;
 
@@ -40,7 +40,8 @@ Keys keys;
 ColumnHandler::ColumnHandler() :
   column(0), offset(0), 
   converterClass(), converterReader(), converterWriter(),
-  hasConverterReader(false), hasConverterWriter(false) 
+  hasConverterReader(false), hasConverterWriter(false),
+  isLob(false), isText(false)
 {
 }
 
@@ -60,6 +61,16 @@ void ColumnHandler::init(const NdbDictionary::Column *_column,
   offset = _offset;
   Local<Object> t;
 
+  switch(column->getType()) {
+    case NDB_TYPE_TEXT: 
+      isText = true;   // fall through to also set isLob
+    case NDB_TYPE_BLOB:
+      isLob = true;
+      break;
+    default:
+      break;
+  }
+
   if(typeConverter->IsObject()) {
     converterClass = Persistent<Object>::New(typeConverter->ToObject());
 
@@ -82,9 +93,20 @@ void ColumnHandler::init(const NdbDictionary::Column *_column,
 }
 
 
-Handle<Value> ColumnHandler::read(char * buffer) const {
+Handle<Value> ColumnHandler::read(char * rowBuffer, Handle<Object> blobBuffer) const {
   HandleScope scope;
-  Handle<Value> val = encoder->read(column, buffer, offset);
+  Handle<Value> val;
+
+  if(isText) {
+    DEBUG_PRINT("text read");
+    val = getTextFromBuffer(column, blobBuffer);
+  } else if(isLob) {
+    DEBUG_PRINT("blob read");
+    val = Handle<Value>(blobBuffer);
+  } else {
+    val = encoder->read(column, rowBuffer, offset);
+  }
+
   if(hasConverterReader) {
     TryCatch tc;
     Handle<Value> arguments[1];
@@ -114,3 +136,18 @@ Handle<Value> ColumnHandler::write(Handle<Value> val, char *buffer) const {
   return scope.Close(writeStatus);
 }
 
+
+BlobWriteHandler * ColumnHandler::createBlobWriteHandle(Handle<Value> val, 
+                                                        int fieldNo) const {
+  HandleScope scope;
+  BlobWriteHandler * b = 0;
+  Handle<Object> obj = val->ToObject();
+  if(isLob) {
+    if(isText && val->IsString()) {
+      obj = getBufferForText(column, val->ToString());
+    }
+    b = new BlobWriteHandler(column->getColumnNo(), fieldNo, obj);
+  }
+  return b;
+}
+

Adapter/impl/ndb/src/ColumnProxy.cpp

@@ -25,29 +25,28 @@
 using namespace v8;
 
 ColumnProxy::~ColumnProxy() {
-  if(! jsValue.IsEmpty())
-    jsValue.Dispose();
+  Dispose();
+}
+
+/* Drop our claim on the old value */
+void ColumnProxy::Dispose() {
+  if(! jsValue.IsEmpty()) jsValue.Dispose();
+  if(! blobBuffer.IsEmpty()) blobBuffer.Dispose();
 }
 
 Handle<Value> ColumnProxy::get(char *buffer) {
   HandleScope scope;
-  Handle<Value> val;
 
-  if(! isLoaded) {    
-    val = handler->read(buffer);
+  if(! isLoaded) {
+    Handle<Value> val = handler->read(buffer, blobBuffer);
     jsValue = Persistent<Value>::New(val);
     isLoaded = true;
   }
   return scope.Close(jsValue);
 }
 
-
 void ColumnProxy::set(Handle<Value> newValue) {
-  HandleScope scope;
-    
-  /* Drop our claim on the old value */
-  if(! jsValue.IsEmpty()) jsValue.Dispose();
-  
+  Dispose();
   isNull = (newValue->IsNull());
   isLoaded = isDirty = true;
   jsValue = Persistent<Value>::New(newValue);
@@ -59,11 +58,19 @@ Handle<Value> ColumnProxy::write(char *buffer) {
   HandleScope scope;
   Handle<Value> rval;
 
-  if(isDirty || (jsValue->IsObject() && jsValue->ToObject()->IsDirty())) {
+  if(isDirty) {
     rval = handler->write(jsValue, buffer);
   }
   isDirty = false;
   DEBUG_PRINT("write %s", handler->column->getName());
   return scope.Close(rval);
 }
 
+
+BlobWriteHandler * ColumnProxy::createBlobWriteHandle(int i) {
+  BlobWriteHandler * b = 0;
+  if(isDirty && ! isNull) {
+    b = handler->createBlobWriteHandle(blobBuffer, i);
+  }
+  return b;
+}

Adapter/impl/ndb/src/DBOperationHelper.cpp

@@ -120,10 +120,9 @@ void createBlobReadHandles(Handle<Object> blobsArray, const Record * rowRecord,
   for(int i = 0 ; i < ncol ; i++) {
     const NdbDictionary::Column * col = rowRecord->getColumn(i);
     if((col->getType() ==  NdbDictionary::Column::Blob) ||
-       (col->getType() ==  NdbDictionary::Column::Text)) {
-      BlobHandler * next = op.blobHandler;
-      op.blobHandler = new BlobReadHandler(i, col->getColumnNo());
-      op.blobHandler->setNext(next);
+       (col->getType() ==  NdbDictionary::Column::Text)) 
+    {
+      op.setBlobHandler(new BlobReadHandler(i, col->getColumnNo()));
     }
   }
 }
@@ -139,9 +138,7 @@ void createBlobWriteHandles(Handle<Object> blobsArray, const Record * rowRecord,
       const NdbDictionary::Column * col = rowRecord->getColumn(i);
       assert( (col->getType() ==  NdbDictionary::Column::Blob) ||
               (col->getType() ==  NdbDictionary::Column::Text));
-      BlobHandler * next = op.blobHandler;
-      op.blobHandler = new BlobWriteHandler(i, col->getColumnNo(), blobValue);
-      op.blobHandler->setNext(next);
+      op.setBlobHandler(new BlobWriteHandler(i, col->getColumnNo(), blobValue));
     }
   }
 }

Adapter/impl/ndb/src/KeyOperation.cpp

@@ -103,4 +103,7 @@ const NdbOperation * KeyOperation::prepare(NdbTransaction *tx) {
   }
 }
 
-
+void KeyOperation::setBlobHandler(BlobHandler *b) {
+  b->setNext(blobHandler);
+  blobHandler = b;
+}