oracledb 3.1.2 → 4.2.0

package/lib/dbObject.js

@@ -0,0 +1,144 @@
+// Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
+//
+//----------------------------------------------------------------------------
+//
+// You may not use the identified files except in compliance with the Apache
+// License, Version 2.0 (the "License.")
+//
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0.
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-----------------------------------------------------------------------------
+
+'use strict';
+
+const util = require('util');
+
+// define base database object class; instances of this class are never
+// instantiated; instead, classes subclassed from this one will be
+// instantiated; a cache of these classes are maintained on each connection
+class BaseDbObject {
+
+  // extend class with promisified functions
+  _extend(oracledb) {
+    this._oracledb = oracledb;
+  }
+
+  // initialize object with value
+  _initialize(initialValue) {
+    if (this.isCollection) {
+      for (let i = 0; i < initialValue.length; i++) {
+        this.append(initialValue[i]);
+      }
+    } else {
+      Object.assign(this, initialValue);
+    }
+  }
+
+  // return as a plain object
+  _toPojo() {
+    if (this.isCollection) {
+      return this.getValues();
+    }
+    const result = {};
+    for (let name in this.attributes) {
+      let value = this[name];
+      if (value instanceof BaseDbObject) {
+        value = value._toPojo();
+      }
+      result[name] = value;
+    }
+    return result;
+  }
+
+  // custom inspection routine
+  [util.inspect.custom](depth, options) {
+    return '[' + this.fqn + '] ' + util.inspect(this._toPojo(), options);
+  }
+
+  [Symbol.iterator]() {
+    if (this.isCollection) {
+      const values = this.getValues();
+      return values[Symbol.iterator]();
+    }
+    throw TypeError("obj is not iterable");
+  }
+
+  [Symbol.toPrimitive](hint) {
+    switch (hint) {
+      case 'number':
+        return NaN;
+      default:
+        return '[' + this.fqn + '] ' + util.inspect(this._toPojo(), {});
+    }
+  }
+
+  get [Symbol.toStringTag]() {
+    return this.fqn;
+  }
+
+  toJSON() {
+    return this._toPojo();
+  }
+
+}
+
+
+// define proxy handler used for collections
+BaseDbObject._collectionProxyHandler = {
+
+  deleteProperty(target, prop) {
+    if (typeof prop === 'string') {
+      const index = +prop;
+      if (!isNaN(index)) {
+        return target.deleteElement(index);
+      }
+    }
+    return delete target[prop];
+  },
+
+  get(target, prop) {
+    if (typeof prop === 'string') {
+
+      // when binding collections, we must be consistent in getting the target
+      // of the proxy, since napi_wrap() called on the proxy will not be
+      // available when calling napi_unwrap() on the target; this property
+      // forces the target to get returned
+      if (prop === '_target') {
+        return target;
+      }
+      const index = +prop;
+      if (!isNaN(index)) {
+        return target.getElement(index);
+      }
+    }
+    const value = target[prop];
+    if (typeof value === 'function') {
+      return value.bind(target);
+    }
+    return value;
+  },
+
+  set(target, prop, value) {
+    if (typeof prop === 'string') {
+      const index = +prop;
+      if (!isNaN(index)) {
+        target.setElement(index, value);
+        return true;
+      }
+    }
+    target[prop] = value;
+    return true;
+  }
+
+};
+
+
+module.exports = BaseDbObject;

package/lib/lob.js

@@ -1,153 +1,146 @@
-/* Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. */
-
-/******************************************************************************
- *
- * You may not use the identified files except in compliance with the Apache
- * License, Version 2.0 (the "License.")
- *
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- *****************************************************************************/
+// Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved
+
+//-----------------------------------------------------------------------------
+//
+// You may not use the identified files except in compliance with the Apache
+// License, Version 2.0 (the "License.")
+//
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0.
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-----------------------------------------------------------------------------
 
 'use strict';
 
-var Duplex = require('stream').Duplex;
-var util = require('util');
-var nodbUtil = require('./util.js');
-var closePromisified;
+const Duplex = require('stream').Duplex;
+const nodbUtil = require('./util.js');
+const util = require('util');
 
-util.inherits(Lob, Duplex);
-
-// the Lob class is used to support the streaming of LOB data to/from the
-// database; the iLob refers to the C++ implementation of the Lob class
-function Lob(iLob, opt, oracledb) {
-  Duplex.call(this, opt);
-
-  this.iLob = iLob;
-
-  Object.defineProperties(
-    this,
-    {
-      _oracledb: { // _oracledb property used by promisify () in util.js
-        value: oracledb
-      },
-      _autoCloseLob: { // Tells whether to close at the end of stream or not
-        value: iLob.autoCloseLob,
-        writable: false
-      },
-      chunkSize: {
-        value: iLob.chunkSize,
-        writable: false
-      },
-      length: {
-        get: function() {
-          return iLob.length;
-        }
-      },
-      pieceSize: {
-        get: function() {
-          return iLob.pieceSize;
-        },
-        set: function(newPieceSize) {
-          iLob.pieceSize = newPieceSize;
-        }
-      },
-      type: {
-        get: function() {
-          return iLob.type;
-        }
-      },
-      close: {
-        value: closePromisified,
-        enumerable: true,
-        writable: true
-      }
-    });
+function close(closeCb) {
+  nodbUtil.checkAsyncArgs(arguments, 1, 1);
 
-  if (this._autoCloseLob) {
-    this.once('finish', function() {
-      this.close(function() {});
-    });
+  // Return if LOB already closed to support multiple close() calls should be
+  // no-op
+  if (!this.valid) {
+    closeCb(null);
+    return;
   }
+
+  this._close(function(err) {
+    if (err) {
+      this.emit('error', err);
+    } else  {
+      this.emit('close');
+    }
+
+    closeCb(err);
+  });
 }
 
-// implementation of streaming read; if lob is set to auto-close, the lob is
-// automatically closed within the C++ code when an error occurs or when there
-// are no more bytes to transfer; all that needs to be done in the JS layer is
-// to emit the close and/or error events
-Lob.prototype._read = function() {
-  var self = this;
-
-  self.iLob.read(
-    function(err, str) {
-      if (err) {
-        self.emit('error', err);
-        if (self._autoCloseLob) {
-          self.emit('close');
-        }
-        return;
-      }
 
-      self.push(str);
+function getData(getDataCb) {
+  nodbUtil.checkAsyncArgs(arguments, 1, 1);
+  this._getData(getDataCb);
+}
+
 
-      if (self._autoCloseLob && !str) {
-        process.nextTick(function() {
-          self.emit('close');
-        });
+class Lob {
+
+  constructor() {
+    Duplex.call(this, {decodeStrings: false});
+    this.offset = 1;
+    this.once('finish', function() {
+      if (this._autoCloseLob) {
+        this.close(function() {});
       }
-    }
-  );
-};
-
-// implementation of streaming write; if lob is set to auto-close, the lob is
-// automatically closed in the "finish" event; all that needs to be done here
-// is to emit the close event in the event of an error
-Lob.prototype._write = function(data, encoding, cb) {
-  var self = this;
-
-  self.iLob.write(
-    data,
-    function(err) {
-      if (err && self._autoCloseLob) {
-        self.emit('close');
+    });
+  }
+
+  _extend(oracledb) {
+    this._oracledb = oracledb;
+    this.close = nodbUtil.promisify(oracledb, close);
+    this.getData = nodbUtil.promisify(oracledb, getData);
+  }
+
+  // called by stream.destroy() and ensures that the LOB is closed if it has
+  // not already been closed (never called directly)
+  _destroy(err, cb) {
+    this._close(function(closeErr) {
+      if (closeErr) {
+        cb(closeErr);
+      } else {
+        cb(err);
       }
-      cb(err);
-    }
-  );
-};
+    });
+  }
 
-Lob.prototype.close = function(closeCb) {
-  var self = this;
+  // implementation of streaming read; if lob is set to auto-close, the lob is
+  // automatically closed within the C++ code when an error occurs or when
+  // there are no more bytes to transfer; all that needs to be done in the JS
+  // layer is to emit the close and/or error events
+  _read() {
+    const self = this;
+
+    self.__read(self.offset,
+      function(err, data) {
+        if (err) {
+          self.emit('error', err);
+          if (self._autoCloseLob) {
+            self.emit('close');
+          }
+          return;
+        }
 
-  nodbUtil.assert(arguments.length === 1, 'NJS-009');
-  nodbUtil.assert(typeof closeCb === 'function', 'NJS-006', 1);
+        if (data) {
+          self.offset += data.length;
+        }
 
-  // Return if LOB already closed to support multiple close() calls should be
-  // no-op
-  if (!self.iLob.valid) {
-    closeCb(null);
-    return;
+        self.push(data);
+
+        if (self._autoCloseLob && !data) {
+          process.nextTick(function() {
+            self.emit('close');
+          });
+        }
+      }
+    );
   }
 
-  self.iLob.close(function(err) {
-    if (err) {
-      self.emit('error', err);
-    } else  {
-      self.emit('close');
+  // implementation of streaming write; if lob is set to auto-close, the lob is
+  // automatically closed in the "finish" event; all that needs to be done here
+  // is to emit the close event in the event of an error
+  _write(data, encoding, cb) {
+    const self = this;
+
+    if (self.type == self._oracledb.BLOB && !Buffer.isBuffer(data)) {
+      data = Buffer.from(data);
+    } else if (self.type == self._oracledb.CLOB && Buffer.isBuffer(data)) {
+      data = data.toString();
     }
+    self.__write(
+      self.offset,
+      data,
+      function(err) {
+        if (err && self._autoCloseLob) {
+          self.emit('close');
+        }
+        if (!err) {
+          self.offset += data.length;
+        }
+        cb(err);
+      }
+    );
+  }
 
-    closeCb(err);
-  });
-};
+}
 
-closePromisified = nodbUtil.promisify(Lob.prototype.close);
+util.inherits(Lob, Duplex);
 
-module.exports.Lob = Lob;
+module.exports = Lob;