oracledb 6.2.0 → 6.4.0

package/lib/errors.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -107,7 +107,6 @@ const ERR_POOL_HAS_BUSY_CONNECTIONS = 104;
 const ERR_NAN_VALUE = 105;
 const ERR_INTERNAL = 106;
 const ERR_INVALID_REF_CURSOR = 107;
-const ERR_LOB_CLOSED = 108;
 const ERR_INVALID_TYPE_NUM = 109;
 const ERR_INVALID_ORACLE_TYPE_NUM = 110;
 const ERR_UNEXPECTED_NEGATIVE_INTEGER = 111;
@@ -136,6 +135,14 @@ const ERR_WRONG_VALUE_FOR_DBOBJECT_ELEM = 135;
 const ERR_WRONG_CRED_FOR_EXTAUTH = 136;
 const ERR_MISSING_BIND_VALUE = 137;
 const ERR_SERVER_VERSION_NOT_SUPPORTED = 138;
+const ERR_UNEXPECTED_XML_TYPE = 139;
+const ERR_WRONG_USER_FORMAT_EXTAUTH_PROXY = 140;
+const ERR_TOO_MANY_BATCH_ERRORS = 141;
+const ERR_WRONG_LENGTH_FOR_DBOBJECT_ATTR = 142;
+const ERR_WRONG_LENGTH_FOR_DBOBJECT_ELEM = 143;
+const ERR_VECTOR_FORMAT_NOT_SUPPORTED = 144;
+const ERR_VECTOR_VERSION_NOT_SUPPORTED = 145;
+const ERR_OBJECT_IS_NOT_A_COLLECTION = 146;
 
 // Oracle Net layer errors start from 500
 const ERR_CONNECTION_CLOSED = 500;
@@ -160,12 +167,14 @@ const ERR_INVALID_SID = 519;
 const ERR_TNS_NAMES_FILE_MISSING = 520;
 const ERR_CONNECTION_EOF = 521;
 
+// Oracle SUCCESS_WITH_INFO warning start from 700
+const WRN_COMPILATION_CREATE = 700;
+
 // define mapping for ODPI-C, OCI & ORA errors that need to be wrapped
 // with NJS errors
 const adjustErrorXref = new Map();
-adjustErrorXref.set("DPI-1010", ERR_CONNECTION_CLOSED);
+adjustErrorXref.set("DPI-1010", ERR_INVALID_CONNECTION);
 adjustErrorXref.set("DPI-1024", [ERR_INVALID_COLL_INDEX_GET, 'at index ([0-9]+) does']);
-adjustErrorXref.set("DPI-1040", ERR_LOB_CLOSED);
 adjustErrorXref.set("DPI-1044", ERR_ORACLE_NUMBER_NO_REPR);
 adjustErrorXref.set("DPI-1055", ERR_NAN_VALUE);
 adjustErrorXref.set("DPI-1063", ERR_EXEC_MODE_ONLY_FOR_DML);
@@ -178,13 +187,14 @@ adjustErrorXref.set("ORA-00028", ERR_CONNECTION_CLOSED);
 adjustErrorXref.set("ORA-00600", ERR_CONNECTION_CLOSED);
 adjustErrorXref.set("ORA-24338", ERR_INVALID_REF_CURSOR);
 adjustErrorXref.set("ORA-25708", ERR_TOKEN_HAS_EXPIRED);
+adjustErrorXref.set("ORA-24344", WRN_COMPILATION_CREATE);
 
 // define mapping for error messages
 const messages = new Map();
 messages.set(ERR_INVALID_POOL,                          // NJS-002
   'invalid pool');
 messages.set(ERR_INVALID_CONNECTION,                    // NJS-003
-  'invalid connection');
+  'invalid or closed connection');
 messages.set(ERR_INVALID_PROPERTY_VALUE,                // NJS-004
   'invalid value for property "%s"');
 messages.set(ERR_INVALID_PARAMETER_VALUE,               // NJS-005
@@ -335,8 +345,6 @@ messages.set(ERR_INTERNAL,                              // NJS-106
   'internal error: %s');
 messages.set(ERR_INVALID_REF_CURSOR,                    // NJS-107
   'invalid cursor');
-messages.set(ERR_LOB_CLOSED,                            // NJS-108
-  'LOB was already closed');
 messages.set(ERR_INVALID_TYPE_NUM,                      // NJS-109
   'invalid type number %d');
 messages.set(ERR_INVALID_ORACLE_TYPE_NUM,               // NJS-110
@@ -393,6 +401,22 @@ messages.set(ERR_MISSING_BIND_VALUE,                    // NJS-137
   'a bind variable replacement value for placeholder ":%s" was not provided');
 messages.set(ERR_SERVER_VERSION_NOT_SUPPORTED,          // NJS-138
   'connections to this database server version are not supported by node-oracledb in Thin mode');
+messages.set(ERR_UNEXPECTED_XML_TYPE,                   // NJS-139
+  'unexpected XML type with flag %d');
+messages.set(ERR_WRONG_USER_FORMAT_EXTAUTH_PROXY,       // NJS-140
+  'user name must be enclosed in [] when using external authentication with a proxy user');
+messages.set(ERR_TOO_MANY_BATCH_ERRORS,                 // NJS-141
+  'the number of batch errors from executemany() exceeds 65535');
+messages.set(ERR_WRONG_LENGTH_FOR_DBOBJECT_ATTR,        // NJS-142
+  'value too large for attribute %s of object %s (actual: %d, maximum: %d)');
+messages.set(ERR_WRONG_LENGTH_FOR_DBOBJECT_ELEM,        // NJS-143
+  'value too large for element %d of object %s (actual: %d, maximum: %d)');
+messages.set(ERR_VECTOR_FORMAT_NOT_SUPPORTED,           // NJS-144
+  'VECTOR format %d is not supported');
+messages.set(ERR_VECTOR_VERSION_NOT_SUPPORTED,          // NJS-145
+  'VECTOR version %d is not supported');
+messages.set(ERR_OBJECT_IS_NOT_A_COLLECTION,            // NJS-146
+  'object %s is not a collection');
 
 // Oracle Net layer errors
 
@@ -439,6 +463,11 @@ messages.set(ERR_TNS_NAMES_FILE_MISSING,                // NJS-520
 messages.set(ERR_CONNECTION_EOF,                        // NJS-521
   'connection to host %s port %d received end-of-file on communication channel. (CONNECTION_ID=%s)');
 
+// Oracle SUCCESS_WITH_INFO warning
+
+messages.set(WRN_COMPILATION_CREATE,                           // NJS-700
+  'creation succeeded with compilation errors');
+
 //-----------------------------------------------------------------------------
 // assert()
 //
@@ -741,7 +770,6 @@ module.exports = {
   ERR_INVALID_REF_CURSOR,
   ERR_UNSUPPORTED_VERIFIER_TYPE,
   ERR_NAN_VALUE,
-  ERR_LOB_CLOSED,
   ERR_ORACLE_NUMBER_NO_REPR,
   ERR_INVALID_SERVICE_NAME,
   ERR_INVALID_SID,
@@ -772,7 +800,16 @@ module.exports = {
   ERR_WRONG_CRED_FOR_EXTAUTH,
   ERR_MISSING_BIND_VALUE,
   ERR_SERVER_VERSION_NOT_SUPPORTED,
+  ERR_UNEXPECTED_XML_TYPE,
+  ERR_WRONG_USER_FORMAT_EXTAUTH_PROXY,
+  ERR_TOO_MANY_BATCH_ERRORS,
+  ERR_WRONG_LENGTH_FOR_DBOBJECT_ATTR,
+  ERR_WRONG_LENGTH_FOR_DBOBJECT_ELEM,
+  ERR_VECTOR_FORMAT_NOT_SUPPORTED,
+  ERR_VECTOR_VERSION_NOT_SUPPORTED,
+  ERR_OBJECT_IS_NOT_A_COLLECTION,
   ERR_CONNECTION_CLOSED_CODE: `${ERR_PREFIX}-${ERR_CONNECTION_CLOSED}`,
+  WRN_COMPILATION_CREATE,
   assert,
   assertArgCount,
   assertParamPropBool,

package/lib/future.js

@@ -0,0 +1,53 @@
+// Copyright (c) 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 errors = require('./errors.js');
+
+// future object used for managing backwards incompatible changes.
+class Future {
+
+  constructor() {
+    this._featureFlags = {};
+    this._featureFlags.oldJsonColumnAsObj = false;
+  }
+
+  get oldJsonColumnAsObj() {
+    return this._featureFlags.oldJsonColumnAsObj;
+  }
+
+  // fetch VARCHAR2 and LOB columns that contain JSON data (and have
+  // the "IS JSON" constraint enabled) in the same way that columns
+  // of type JSON (which requires Oracle Database 21 and higher) are fetched.
+  set oldJsonColumnAsObj(value) {
+    errors.assertPropValue(typeof value === 'boolean', "oldJsonColumnAsObj");
+    this._featureFlags.oldJsonColumnAsObj = value;
+  }
+
+}
+
+module.exports = new Future;

package/lib/impl/connection.js

@@ -208,6 +208,24 @@ class ConnectionImpl {
     errors.throwNotImplemented("getting current schema");
   }
 
+  //---------------------------------------------------------------------------
+  // getDbDomain()
+  //
+  // Returns the Oracle Database domain name associated with the connection.
+  //---------------------------------------------------------------------------
+  getDbDomain() {
+    errors.throwNotImplemented("getting db domain");
+  }
+
+  //---------------------------------------------------------------------------
+  // getDbName()
+  //
+  // Returns the Oracle Database name associated with the connection.
+  //---------------------------------------------------------------------------
+  getDbName() {
+    errors.throwNotImplemented("getting db name");
+  }
+
   //---------------------------------------------------------------------------
   // getDbObjectClass()
   //
@@ -244,6 +262,15 @@ class ConnectionImpl {
     errors.throwNotImplemented("getting the internal name");
   }
 
+  //---------------------------------------------------------------------------
+  // getMaxOpenCursors()
+  //
+  // Returns maximum number of cursors that can be opened in one session.
+  //---------------------------------------------------------------------------
+  getMaxOpenCursors() {
+    errors.throwNotImplemented("getting max open cursors");
+  }
+
   //---------------------------------------------------------------------------
   // getOracleServerVersion()
   //
@@ -271,6 +298,15 @@ class ConnectionImpl {
     errors.throwNotImplemented("getting a queue");
   }
 
+  //---------------------------------------------------------------------------
+  // getServiceName()
+  //
+  // Returns the Oracle Database service name associated with the connection.
+  //---------------------------------------------------------------------------
+  getServiceName() {
+    errors.throwNotImplemented("getting service name");
+  }
+
   //---------------------------------------------------------------------------
   // getSodaDatabase()
   //
@@ -307,6 +343,26 @@ class ConnectionImpl {
     errors.throwNotImplemented("getting the tag for the connection");
   }
 
+  //---------------------------------------------------------------------------
+  // getTransactionInProgress()
+  //
+  // Returns boolean based on the presence of an active transaction on the
+  // connection
+  //---------------------------------------------------------------------------
+  getTransactionInProgress() {
+    errors.throwNotImplemented("getting the status of an active transaction" +
+      " on the connection");
+  }
+
+  //---------------------------------------------------------------------------
+  // getWarning()
+  //
+  // Returns a warning on a connection
+  //---------------------------------------------------------------------------
+  getWarning() {
+    errors.throwNotImplemented("getting information about warning");
+  }
+
   //---------------------------------------------------------------------------
   // isHealthy()
   //

package/lib/{thin/protocol → impl/datahandlers}/buffer.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -29,8 +29,8 @@
 const { Buffer } = require('buffer');
 const constants = require("./constants.js");
 const errors = require("../../errors.js");
-const settings = require("../../settings.js");
 const types = require("../../types.js");
+const nodbUtil = require("../../util.js");
 
 /**
  * Base buffer class used for managing buffered data without unnecessary
@@ -184,7 +184,7 @@ class BaseBuffer {
       fseconds = Math.floor(buf.readUInt32BE(7) / (1000 * 1000));
     }
     const year = (buf[0] - 100) * 100 + buf[1] - 100;
-    return settings._makeDate(useLocalTime, year, buf[2], buf[3], buf[4] - 1,
+    return nodbUtil.makeDate(useLocalTime, year, buf[2], buf[3], buf[4] - 1,
       buf[5] - 1, buf[6] - 1, fseconds, 0);
   }
 
@@ -321,6 +321,22 @@ class BaseBuffer {
     return this.parseBinaryFloat(buf);
   }
 
+  //---------------------------------------------------------------------------
+  // readBinaryInteger()
+  //
+  // Reads a binary integer value from the buffer and returns a Number
+  //---------------------------------------------------------------------------
+  readBinaryInteger() {
+    const buf = this.readBytesWithLength();
+    if (!buf) {
+      return 0;
+    }
+    if (buf.length > 4) {
+      errors.throwErr(errors.ERR_INTEGER_TOO_LARGE, buf.length, 4, this.pos, this.packetNum);
+    }
+    return (buf.readIntBE(0, buf.length));
+  }
+
   //---------------------------------------------------------------------------
   // readBool()
   //
@@ -617,9 +633,10 @@ class BaseBuffer {
   //
   // Writes the number in binary double format to the buffer.
   //---------------------------------------------------------------------------
-  writeBinaryDouble(n) {
-    this.writeUInt8(8);
-    const pos = this.reserveBytes(8);
+  writeBinaryDouble(n, pos) {
+    if (!pos) {
+      pos = this.reserveBytes(8);
+    }
     this.buf.writeDoubleBE(n, pos);
     if ((this.buf[pos] & 0x80) === 0) {
       this.buf[pos] |= 0x80;
@@ -641,9 +658,10 @@ class BaseBuffer {
   //
   // Writes the number in binary float format to the buffer.
   //---------------------------------------------------------------------------
-  writeBinaryFloat(n) {
-    this.writeUInt8(4);
-    const pos = this.reserveBytes(4);
+  writeBinaryFloat(n, pos) {
+    if (!pos) {
+      pos = this.reserveBytes(4);
+    }
     this.buf.writeFloatBE(n, pos);
     if ((this.buf[pos] & 0x80) === 0) {
       this.buf[pos] |= 0x80;
@@ -677,15 +695,12 @@ class BaseBuffer {
     }
   }
 
-  //---------------------------------------------------------------------------
-  // writeBytesWithLength()
+  // _writeRawBytesAndLength()
   //
-  // Writes the bytes in the supplied buffer to the buffer, but first writes
-  // the length. If the length exceeds a fixed value, the value is written in
-  // chunks instead.
+  // Writes the length in the format required before
+  // writing the bytes.
   //---------------------------------------------------------------------------
-  writeBytesWithLength(value) {
-    let numBytes = value.length;
+  _writeRawBytesAndLength(value, numBytes) {
     if (numBytes <= constants.TNS_MAX_SHORT_LENGTH) {
       this.writeUInt8(numBytes);
       if (numBytes > 0) {
@@ -704,6 +719,17 @@ class BaseBuffer {
       this.writeUB4(0);
     }
   }
+  //---------------------------------------------------------------------------
+  // writeBytesWithLength()
+  //
+  // Writes the bytes in the supplied buffer to the buffer, but first writes
+  // the length. If the length exceeds a fixed value, the value is written in
+  // chunks instead.
+  //---------------------------------------------------------------------------
+  writeBytesWithLength(value) {
+    const numBytes = value.length;
+    this._writeRawBytesAndLength(value, numBytes);
+  }
 
   //---------------------------------------------------------------------------
   // writeDbObject()
@@ -861,29 +887,6 @@ class BaseBuffer {
 
   }
 
-  //---------------------------------------------------------------------------
-  // writeQLocator()
-  //
-  // Writes a QLocator. QLocators are always 40 bytes in length.
-  //---------------------------------------------------------------------------
-  writeQLocator(numBytes) {
-    this.writeUB4(40);                  // QLocator length
-    this.writeUInt8(40);                // repeated length
-    this.writeUInt16BE(38);             // internal length
-    this.writeUInt16BE(constants.TNS_LOB_QLOCATOR_VERSION);
-    this.writeUInt8(constants.TNS_LOB_LOC_FLAGS_VALUE_BASED |
-      constants.TNS_LOB_LOC_FLAGS_BLOB | constants.TNS_LOB_LOC_FLAGS_ABSTRACT);
-    this.writeUInt8(constants.TNS_LOB_LOC_FLAGS_INIT);
-    this.writeUInt16BE(0);              // additional flags
-    this.writeUInt16BE(1);              // byt1
-    this.writeUInt64BE(numBytes);
-    this.writeUInt16BE(0);              // unused
-    this.writeUInt16BE(0);              // csid
-    this.writeUInt16BE(0);              // unused
-    this.writeUInt64BE(0);              // unused
-    this.writeUInt64BE(0);              // unused
-  }
-
   //---------------------------------------------------------------------------
   // writeStr()
   //
@@ -976,6 +979,15 @@ class BaseBuffer {
     this.buf[pos] = n;
   }
 
+  // writeSB1()
+  //
+  // Writes an signed 8-bit integer to the buffer.
+  //---------------------------------------------------------------------------
+  writeSB1(n) {
+    const pos = this.reserveBytes(1);
+    this.buf[pos] = n;
+  }
+
   //---------------------------------------------------------------------------
   // writeUInt16BE()
   //

package/lib/impl/datahandlers/constants.js

@@ -0,0 +1,105 @@
+// Copyright (c) 2024, 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');
+
+module.exports = {
+
+  // vector constants
+  TNS_VECTOR_MAGIC_BYTE: 0xDB,
+  TNS_VECTOR_VERSION: 0,
+
+  // vector flags
+  TNS_VECTOR_FLAG_DIM_UINT8: 0x0001,
+  TNS_VECTOR_FLAG_DIM_UINT32: 0x0002,
+  TNS_VECTOR_FLAG_NORMSRC: 0x0040,
+  TNS_VECTOR_FLAG_NORM: 0x0008,
+
+  // base JSON constants
+  TNS_JSON_MAGIC_BYTE_1: 0xff,
+  TNS_JSON_MAGIC_BYTE_2: 0x4a,       // 'J'
+  TNS_JSON_MAGIC_BYTE_3: 0x5a,       // 'Z'
+  TNS_JSON_VERSION: 1,
+  TNS_JSON_FLAG_HASH_ID_UINT8: 0x0100,
+  TNS_JSON_FLAG_HASH_ID_UINT16: 0x0200,
+  TNS_JSON_FLAG_NUM_FNAMES_UINT16: 0x0400,
+  TNS_JSON_FLAG_FNAMES_SEG_UINT32: 0x0800,
+  TNS_JSON_FLAG_TINY_NODES_STAT: 0x2000,
+  TNS_JSON_FLAG_TREE_SEG_UINT32: 0x1000,
+  TNS_JSON_FLAG_REL_OFFSET_MODE: 0x01,
+  TNS_JSON_FLAG_INLINE_LEAF: 0x02,
+  TNS_JSON_FLAG_LEN_IN_PCODE: 0x04,
+  TNS_JSON_FLAG_NUM_FNAMES_UINT32: 0x08,
+  TNS_JSON_FLAG_IS_SCALAR: 0x10,
+
+  // JSON data types
+  TNS_JSON_TYPE_NULL: 0x30,
+  TNS_JSON_TYPE_TRUE: 0x31,
+  TNS_JSON_TYPE_FALSE: 0x32,
+  TNS_JSON_TYPE_STRING_LENGTH_UINT8: 0x33,
+  TNS_JSON_TYPE_NUMBER_LENGTH_UINT8: 0x34,
+  TNS_JSON_TYPE_BINARY_DOUBLE: 0x36,
+  TNS_JSON_TYPE_STRING_LENGTH_UINT16: 0x37,
+  TNS_JSON_TYPE_STRING_LENGTH_UINT32: 0x38,
+  TNS_JSON_TYPE_TIMESTAMP: 0x39,
+  TNS_JSON_TYPE_BINARY_LENGTH_UINT16: 0x3a,
+  TNS_JSON_TYPE_BINARY_LENGTH_UINT32: 0x3b,
+  TNS_JSON_TYPE_DATE: 0x3c,
+  TNS_JSON_TYPE_INTERVAL_YM: 0x3d,
+  TNS_JSON_TYPE_INTERVAL_DS: 0x3e,
+  TNS_JSON_TYPE_TIMESTAMP_TZ: 0x7c,
+  TNS_JSON_TYPE_TIMESTAMP7: 0x7d,
+  TNS_JSON_TYPE_BINARY_FLOAT: 0x7f,
+  TNS_JSON_TYPE_OBJECT: 0x84,
+  TNS_JSON_TYPE_ARRAY: 0xc0,
+  TNS_JSON_TYPE_EXTENDED: 0x7b,
+  TNS_JSON_TYPE_VECTOR: 0x01,
+
+  // timezone offsets
+  TZ_HOUR_OFFSET: 20,
+  TZ_MINUTE_OFFSET: 60,
+
+  // general constants
+  TNS_MAX_SHORT_LENGTH: 252,
+  TNS_DURATION_MID: 0x80000000,
+  TNS_DURATION_OFFSET: 60,
+  TNS_CHUNK_SIZE: 32767,
+  TNS_HAS_REGION_ID: 0x80,
+  NUMBER_MAX_DIGITS: 40,
+  BUFFER_CHUNK_SIZE: 65536,
+  CSFRM_IMPLICIT: constants.CSFRM_IMPLICIT,
+
+  // vector generic constants
+  VECTOR_FORMAT_FLOAT32: constants.VECTOR_FORMAT_FLOAT32,
+  VECTOR_FORMAT_FLOAT64: constants.VECTOR_FORMAT_FLOAT64,
+  VECTOR_FORMAT_INT8: constants.VECTOR_FORMAT_INT8,
+
+  TNS_NULL_LENGTH_INDICATOR: 255,
+  TNS_LONG_LENGTH_INDICATOR: 254,
+
+};

package/lib/{thin/protocol → impl/datahandlers}/oson.js

@@ -32,6 +32,8 @@ const constants = require("./constants.js");
 const errors = require("../../errors.js");
 const types = require("../../types.js");
 const util = require("util");
+const vector = require("./vector.js");
+const nodbUtil = require("../../util.js");
 
 /**
  * Class used for decodeing
@@ -106,7 +108,7 @@ class OsonDecoder extends BaseBuffer {
   _decodeNode() {
 
     // if the most significant bit is set the node refers to a container
-    const nodeType = this.readUInt8();
+    let nodeType = this.readUInt8();
     if (nodeType & 0x80) {
       return this._decodeContainerNode(nodeType);
     }
@@ -145,6 +147,13 @@ class OsonDecoder extends BaseBuffer {
       return Buffer.from(this.readBytes(this.readUInt16BE()));
     } else if (nodeType === constants.TNS_JSON_TYPE_BINARY_LENGTH_UINT32) {
       return Buffer.from(this.readBytes(this.readUInt32BE()));
+    } else if (nodeType === constants.TNS_JSON_TYPE_EXTENDED) {
+      nodeType = this.readUInt8();
+      if (nodeType === constants.TNS_JSON_TYPE_VECTOR) {
+        const vecImage = this.readBytes(this.readUInt32BE());
+        const decoder = new vector.VectorDecoder(vecImage);
+        return decoder.decode();
+      }
     }
 
     // handle number/decimal with length stored inside the node itself
@@ -544,6 +553,15 @@ class OsonTreeSegment extends GrowableBuffer {
     } else if (Array.isArray(value)) {
       this._encodeArray(value, fnamesSeg);
 
+    // handle vectors
+    } else if (nodbUtil.isVectorValue(value)) {
+      this.writeUInt8(constants.TNS_JSON_TYPE_EXTENDED);
+      this.writeUInt8(constants.TNS_JSON_TYPE_VECTOR);
+      const encoder = new vector.VectorEncoder();
+      const buf = encoder.encode(value);
+      this.writeUInt32BE(buf.length);
+      this.writeBytes(buf);
+
     // handle objects
     } else {
       this._encodeObject(value, fnamesSeg);