oracledb 5.5.0 → 6.0.1

package/lib/impl/index.js

@@ -0,0 +1,59 @@
+// Copyright (c) 2022, Oracle and/or its affiliates.
+
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://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 AqDeqOptionsImpl = require('./aqDeqOptions.js');
+const AqEnqOptionsImpl = require('./aqEnqOptions.js');
+const AqMessageImpl = require('./aqMessage.js');
+const AqQueueImpl = require('./aqQueue.js');
+const DbObjectImpl = require('./dbObject.js');
+const ConnectionImpl = require('./connection.js');
+const LobImpl = require('./lob.js');
+const PoolImpl = require('./pool.js');
+const ResultSetImpl = require('./resultset.js');
+const SodaCollectionImpl = require('./sodaCollection.js');
+const SodaDatabaseImpl = require('./sodaDatabase.js');
+const SodaDocCursorImpl = require('./sodaDocCursor.js');
+const SodaDocumentImpl = require('./sodaDocument.js');
+const SodaOperationImpl = require('./sodaOperation.js');
+
+module.exports = {
+  AqDeqOptionsImpl,
+  AqEnqOptionsImpl,
+  AqMessageImpl,
+  AqQueueImpl,
+  DbObjectImpl,
+  ConnectionImpl,
+  LobImpl,
+  PoolImpl,
+  ResultSetImpl,
+  SodaCollectionImpl,
+  SodaDatabaseImpl,
+  SodaDocCursorImpl,
+  SodaDocumentImpl,
+  SodaOperationImpl
+};

package/lib/impl/lob.js

@@ -0,0 +1,85 @@
+// Copyright (c) 2022, Oracle and/or its affiliates.
+
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://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 ConnectionImpl = require('./connection.js');
+const errors = require('../errors.js');
+
+class LobImpl {
+
+  //---------------------------------------------------------------------------
+  // _getConnImpl()
+  //
+  // Common method on all classes that make use of a connection -- used to
+  // ensure serialization of all use of the connection.
+  //---------------------------------------------------------------------------
+  _getConnImpl() {
+    let parentObj = this._parentObj;
+    while (!(parentObj instanceof ConnectionImpl))
+      parentObj = parentObj._parentObj;
+    return parentObj;
+  }
+
+  //---------------------------------------------------------------------------
+  // close()
+  //
+  // Close the LOB.
+  //---------------------------------------------------------------------------
+  close() {
+    errors.throwNotImplemented("closing a LOB");
+  }
+
+  //---------------------------------------------------------------------------
+  // getData()
+  //
+  // Returns all of the data in the LOB.
+  //---------------------------------------------------------------------------
+  getData() {
+    errors.throwNotImplemented("getting all of the data from a LOB");
+  }
+
+  //---------------------------------------------------------------------------
+  // read()
+  //
+  // Reads data from the LOB at the specified offset.
+  //---------------------------------------------------------------------------
+  read() {
+    errors.throwNotImplemented("reading from a LOB");
+  }
+
+  //---------------------------------------------------------------------------
+  // write()
+  //
+  // Writes data to the LOB at the specified offset.
+  //---------------------------------------------------------------------------
+  write() {
+    errors.throwNotImplemented("writing to a LOB");
+  }
+
+}
+
+module.exports = LobImpl;

package/lib/impl/pool.js

@@ -0,0 +1,195 @@
+// Copyright (c) 2022, Oracle and/or its affiliates.
+
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://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 errors = require('../errors.js');
+const nodbUtil = require('../util.js');
+
+class PoolImpl {
+
+  //---------------------------------------------------------------------------
+  // _accessTokenHandler()
+  //
+  // Access token handler callback function which wraps the user callback and
+  // returns the token to the implementation.
+  //---------------------------------------------------------------------------
+  async _accessTokenHandler(userFn, externalObj, refresh) {
+    let accessToken;
+    try {
+      let result = userFn(refresh);
+      if (result instanceof Promise) {
+        result = await result;
+      }
+
+      if (!nodbUtil.isTokenValid(result)) {
+        errors.throwErr(errors.ERR_TOKEN_HAS_EXPIRED);
+      }
+
+      accessToken = result;
+    } finally {
+      this.returnAccessToken(externalObj, accessToken);
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // close()
+  //
+  // Close the pool.
+  //---------------------------------------------------------------------------
+  close() {
+    errors.throwNotImplemented("closing the pool");
+  }
+
+  //---------------------------------------------------------------------------
+  // create()
+  //
+  // Creates the pool and makes it available for use.
+  //---------------------------------------------------------------------------
+  create() {
+    errors.throwNotImplemented("creating the pool");
+  }
+
+  //---------------------------------------------------------------------------
+  // getConnection()
+  //
+  // Returns a connection from the pool.
+  //---------------------------------------------------------------------------
+  getConnection() {
+    errors.throwNotImplemented("getting a connection from the pool");
+  }
+
+  //---------------------------------------------------------------------------
+  // getConnectionsInUse()
+  //
+  // Returns the number of connections in use in the pool.
+  //---------------------------------------------------------------------------
+  getConnectionsInUse() {
+    errors.throwNotImplemented("getting num connection in use");
+  }
+
+  //---------------------------------------------------------------------------
+  // getConnectionsOpen()
+  //
+  // Returns the number of connections opened by the pool.
+  //---------------------------------------------------------------------------
+  getConnectionsOpen() {
+    errors.throwNotImplemented("getting num connection open");
+  }
+
+  //---------------------------------------------------------------------------
+  // getPoolIncrement()
+  //
+  // Returns the number of connections to create when the pool needs to grow.
+  //---------------------------------------------------------------------------
+  getPoolIncrement() {
+    errors.throwNotImplemented("getting the pool increment");
+  }
+
+  //---------------------------------------------------------------------------
+  // getPoolMax()
+  //
+  // Returns the maximum number of connections allowed in the pool.
+  //---------------------------------------------------------------------------
+  getPoolMax() {
+    errors.throwNotImplemented("getting the pool max");
+  }
+
+  //---------------------------------------------------------------------------
+  // getPoolMaxPerShard()
+  //
+  // Returns the maximum number of connections allowed per shard in the pool.
+  //---------------------------------------------------------------------------
+  getPoolMaxPerShard() {
+    errors.throwNotImplemented("getting the pool max per shard");
+  }
+
+  //---------------------------------------------------------------------------
+  // getPoolMin()
+  //
+  // Returns the minimum number of connections allowed in the pool.
+  //---------------------------------------------------------------------------
+  getPoolMin() {
+    errors.throwNotImplemented("getting the pool min");
+  }
+
+  //---------------------------------------------------------------------------
+  // getPoolPingInterval()
+  //
+  // Returns the pool ping interval (seconds).
+  //---------------------------------------------------------------------------
+  getPoolPingInterval() {
+    errors.throwNotImplemented("getting the pool ping interval");
+  }
+
+  //---------------------------------------------------------------------------
+  // getPoolTimeout()
+  //
+  // Returns the pool timeout.
+  //---------------------------------------------------------------------------
+  getPoolTimeout() {
+    errors.throwNotImplemented("getting the pool timeout");
+  }
+
+  //---------------------------------------------------------------------------
+  // getStmtCacheSize()
+  //
+  // Returns the statement cache size associate with the pool.
+  //---------------------------------------------------------------------------
+  getStmtCacheSize() {
+    errors.throwNotImplemented("getting the pool statement cache size");
+  }
+
+  //---------------------------------------------------------------------------
+  // getSodaMetaDataCache()
+  //
+  // Returns whether the SODA metadata cache is enabled or not.
+  //---------------------------------------------------------------------------
+  getSodaMetaDataCache() {
+    errors.throwNotImplemented("getting the SODA metadata cache flag");
+  }
+
+  //---------------------------------------------------------------------------
+  // reconfigure()
+  //
+  // Reconfigures the pool with new parameters.
+  //---------------------------------------------------------------------------
+  reconfigure() {
+    errors.throwNotImplemented("reconfiguring the pool");
+  }
+
+  //---------------------------------------------------------------------------
+  // setAccessToken()
+  //
+  // Sets the access token to use with the pool.
+  //---------------------------------------------------------------------------
+  setAccessToken() {
+    errors.throwNotImplemented("sets the access token");
+  }
+
+}
+
+module.exports = PoolImpl;

package/lib/impl/resultset.js

@@ -0,0 +1,223 @@
+// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://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 constants = require('../constants.js');
+const errors = require('../errors.js');
+const nodbUtil = require('../util.js');
+const settings = require('../settings.js');
+const types = require('../types.js');
+
+// define implementation class
+class ResultSetImpl {
+
+  //---------------------------------------------------------------------------
+  // _determineFetchType()
+  //
+  // Determine the fetch type to use for the specified metadata.
+  //---------------------------------------------------------------------------
+  _determineFetchType(metadata, options) {
+
+    // clear any previous fetch type and converter functions that may have been
+    // retained
+    delete metadata.fetchType;
+    delete metadata.converter;
+
+    // if a fetch type handler is specified, call it; if no value (undefined)
+    // is returned, the normal processing takes place
+    if (options.fetchTypeHandler) {
+      const result = options.fetchTypeHandler(metadata);
+      if (result !== undefined) {
+        errors.assert(typeof result === 'object',
+          errors.ERR_FETCH_TYPE_HANDLER_RETURN_VALUE);
+        if (result.type !== undefined) {
+          errors.assert(result.type instanceof types.DbType,
+            errors.ERR_FETCH_TYPE_HANDLER_TYPE);
+        }
+        if (result.converter !== undefined) {
+          errors.assert(typeof result.converter === 'function',
+            errors.ERR_FETCH_TYPE_HANDLER_CONVERTER);
+        }
+        metadata.fetchType = result.type;
+        metadata.converter = result.converter;
+      }
+    }
+
+    // continue processing if no fetch type was specified or no fetch type
+    // handler was supplied
+    if (!metadata.fetchType) {
+
+      // if the fetchTypeMap exists (calculated from the fetchInfo argument),
+      // use it to determine the fetch type
+      if (options.fetchTypeMap && options.fetchTypeMap.has(metadata.name)) {
+        metadata.fetchType = options.fetchTypeMap.get(metadata.name);
+        if (metadata.fetchType === constants.DEFAULT) {
+          metadata.fetchType =
+            types.DB_TYPE_FETCH_TYPE_MAP.get(metadata.dbType);
+        }
+
+      // otherwise, use the default fetch type map (calculated from the
+      // fetchAsString and fetchAsBuffer settings
+      } else {
+        metadata.fetchType = settings.fetchTypeMap.get(metadata.dbType);
+      }
+
+    }
+
+    // if the types do not match, verify that the conversion is supported and
+    // adjust the final fetch type to match what the database expects
+    if (metadata.fetchType !== metadata.dbType) {
+      const map = types.DB_TYPE_CONVERSION_MAP.get(metadata.dbType);
+      const actualFetchType = map && map.get(metadata.fetchType);
+      if (!actualFetchType) {
+        errors.throwErr(errors.ERR_UNSUPPORTED_CONVERSION,
+          metadata.dbType.name, metadata.fetchType.name);
+      }
+      metadata.fetchType = actualFetchType;
+    }
+
+    // in thin mode, Oracle NUMBER values are internally fetched as string in
+    // order to preserve precision so must be converted to JavaScript Number
+    // when needed; other numeric and date types are fetched natively as
+    // JavaScript Number and Date values and are converted to string using
+    // toString() when desired
+    if (settings.thin) {
+      let converter;
+      const userConverter = metadata.converter;
+      if (metadata.dbType === types.DB_TYPE_NUMBER &&
+          metadata.fetchType === types.DB_TYPE_NUMBER) {
+        converter = (v) => (v === null) ? null : parseFloat(v);
+      } else if (metadata.fetchType === types.DB_TYPE_VARCHAR &&
+          (metadata.dbType === types.DB_TYPE_BINARY_DOUBLE ||
+           metadata.dbType === types.DB_TYPE_BINARY_FLOAT ||
+           metadata.dbType === types.DB_TYPE_DATE ||
+           metadata.dbType === types.DB_TYPE_TIMESTAMP ||
+           metadata.dbType === types.DB_TYPE_TIMESTAMP_LTZ ||
+           metadata.dbType === types.DB_TYPE_TIMESTAMP_TZ)) {
+        converter = (v) => (v === null) ? null : v.toString();
+      }
+      if (userConverter && converter) {
+        const internalConverter = converter;
+        converter = (v) => userConverter(internalConverter(v));
+      }
+      if (converter) {
+        metadata.converter = converter;
+      }
+    }
+
+  }
+
+  //---------------------------------------------------------------------------
+  // _getConnImpl()
+  //
+  // Common method on all classes that make use of a connection -- used to
+  // ensure serialization of all use of the connection.
+  //---------------------------------------------------------------------------
+  _getConnImpl() {
+    return this._parentObj;
+  }
+
+  //---------------------------------------------------------------------------
+  // _setup()
+  //
+  // Setup a result set. The metadata is examined to to determine if any
+  // columns need to be manipulated before being returned to the caller. If the
+  // rows fetched from the result set are expected to be objects, a unique set
+  // of attribute names are also determined.
+  //---------------------------------------------------------------------------
+  _setup(options, metaData) {
+    this._parentObj = options.connection._impl;
+    this.metaData = metaData;
+    this.lobIndices = [];
+    this.dbObjectIndices = [];
+    this.nestedCursorIndices = [];
+    this.converterIndices = [];
+    this.outFormat = options.outFormat;
+    this.fetchArraySize = options.fetchArraySize;
+    this.dbObjectAsPojo = options.dbObjectAsPojo;
+    this.maxRows = options.maxRows;
+    const names = new Map();
+    for (let i = 0; i < metaData.length; i++) {
+      const name = metaData[i].name;
+      if (!names.has(name)) {
+        names.set(name, i);
+      }
+    }
+    for (let i = 0; i < metaData.length; i++) {
+      const info = metaData[i];
+      if (info.dbTypeClass) {
+        const cls = options.connection._getDbObjectClass(info.dbTypeClass);
+        info.dbTypeClass = cls;
+      }
+      nodbUtil.addTypeProperties(info, "dbType");
+      this._determineFetchType(info, options);
+      if (info.fetchType === types.DB_TYPE_CURSOR) {
+        this.nestedCursorIndices.push(i);
+      } else if (info.fetchType === types.DB_TYPE_CLOB ||
+          info.fetchType === types.DB_TYPE_NCLOB ||
+          info.fetchType === types.DB_TYPE_BLOB) {
+        this.lobIndices.push(i);
+      } else if (info.fetchType === types.DB_TYPE_OBJECT) {
+        this.dbObjectIndices.push(i);
+      }
+      if (info.converter) {
+        this.converterIndices.push(i);
+      }
+      let name = info.name;
+      if (names.get(name) !== i) {
+        let seqNum = 0;
+        while (names.has(name)) {
+          seqNum = seqNum + 1;
+          name = `${info.name}_${seqNum}`;
+        }
+        names.set(name, i);
+        info.name = name;
+      }
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // close()
+  //
+  // Closes the result set.
+  //---------------------------------------------------------------------------
+  close() {
+    errors.throwNotImplemented("closing a result set");
+  }
+
+  //---------------------------------------------------------------------------
+  // getRows()
+  //
+  // Returns rows from a result set.
+  //---------------------------------------------------------------------------
+  getRows() {
+    errors.throwNotImplemented("getting rows");
+  }
+
+}
+
+module.exports = ResultSetImpl;