oracledb 6.3.0 → 6.5.0

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2024, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -32,9 +32,11 @@ 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
+ * Class used for decoding
  */
 class OsonDecoder extends BaseBuffer {
 
@@ -50,6 +52,7 @@ class OsonDecoder extends BaseBuffer {
     // significant bits of the node type; determine the offsets in the tree
     // segment to the field ids array and the value offsets array
     let container, offsetsPos, fieldIdsPos;
+    const containerOffset = this.pos - this.treeSegPos - 1;
     let numChildren = this._getNumChildren(nodeType);
     const isObject = ((nodeType & 0x40) === 0);
     if (numChildren === undefined) {
@@ -84,7 +87,10 @@ class OsonDecoder extends BaseBuffer {
         fieldIdsPos += this.fieldIdLength;
       }
       this.pos = offsetsPos;
-      const offset = this._getOffset(nodeType);
+      let offset = this._getOffset(nodeType);
+      if (this.relativeOffsets) {
+        offset += containerOffset;
+      }
       offsetsPos = this.pos;
       this.pos = this.treeSegPos + offset;
       if (isObject) {
@@ -106,7 +112,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);
     }
@@ -141,10 +147,22 @@ class OsonDecoder extends BaseBuffer {
       return this.readBytes(this.readUInt32BE()).toString();
     } else if (nodeType === constants.TNS_JSON_TYPE_NUMBER_LENGTH_UINT8) {
       return parseFloat(this.readOracleNumber());
+    } else if (nodeType === constants.TNS_JSON_TYPE_ID) {
+      const buf = this.readBytes(this.readUInt8());
+      const jsonId = new types.JsonId(buf.length);
+      buf.copy(jsonId);
+      return jsonId;
     } else if (nodeType === constants.TNS_JSON_TYPE_BINARY_LENGTH_UINT16) {
       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
@@ -207,6 +225,46 @@ class OsonDecoder extends BaseBuffer {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // _getFieldNames
+  //
+  // Reads the field names from the buffer.
+  //---------------------------------------------------------------------------
+  _getFieldNames(arrStartPos, numFields, offsetsSize, fieldNamesSegSize, fieldNamesSize) {
+
+    // skip the hash id array (1 byte * fieldNamesSize for each field)
+    this.skipBytes(numFields * fieldNamesSize);
+
+    // skip the field name offsets array for now
+    const offsetsPos = this.pos;
+    this.skipBytes(numFields * offsetsSize);
+    const ptr = this.readBytes(fieldNamesSegSize);
+    const finalPos = this.pos;
+
+    // determine the names of the fields
+    this.pos = offsetsPos;
+    let offset;
+    for (let i = arrStartPos; i < arrStartPos + numFields; i++) {
+      if (offsetsSize === 2) {
+        offset = this.readUInt16BE();
+      } else {
+        offset = this.readUInt32BE();
+      }
+
+      // get the field name object
+      let temp;
+      if (fieldNamesSize === 1) {
+        // Short Field Name
+        temp = ptr.readUInt8(offset);
+      } else {
+        // Long Field Name
+        temp = ptr.readUInt16BE(offset);
+      }
+      this.fieldNames[i] = ptr.subarray(offset + fieldNamesSize, offset + temp + fieldNamesSize).toString();
+    }
+    this.pos = finalPos;
+  }
+
   //---------------------------------------------------------------------------
   // decode()
   //
@@ -223,14 +281,16 @@ class OsonDecoder extends BaseBuffer {
       errors.throwErr(errors.ERR_UNEXPECTED_DATA, magic.toString('hex'));
     }
     const version = this.readUInt8();
-    if (version !== constants.TNS_JSON_VERSION) {
+    if (version !== constants.TNS_JSON_VERSION_MAX_FNAME_255 &&
+        version !== constants.TNS_JSON_VERSION_MAX_FNAME_65535) {
       errors.throwErr(errors.ERR_OSON_VERSION_NOT_SUPPORTED, version);
     }
-    const flags = this.readUInt16BE();
+    const primaryFlags = this.readUInt16BE();
+    this.relativeOffsets = primaryFlags & constants.TNS_JSON_FLAG_REL_OFFSET_MODE;
 
     // scalar values are much simpler
-    if (flags & constants.TNS_JSON_FLAG_IS_SCALAR) {
-      if (flags & constants.TNS_JSON_FLAG_TREE_SEG_UINT32) {
+    if (primaryFlags & constants.TNS_JSON_FLAG_IS_SCALAR) {
+      if (primaryFlags & constants.TNS_JSON_FLAG_TREE_SEG_UINT32) {
         this.skipBytes(4);
       } else {
         this.skipBytes(2);
@@ -238,31 +298,46 @@ class OsonDecoder extends BaseBuffer {
       return this._decodeNode();
     }
 
-    // determine the number of field names
-    let numFieldNames;
-    if (flags & constants.TNS_JSON_FLAG_NUM_FNAMES_UINT32) {
-      numFieldNames = this.readUInt32BE();
+    // determine the number of short field names
+    let numShortFieldNames;
+    if (primaryFlags & constants.TNS_JSON_FLAG_NUM_FNAMES_UINT32) {
+      numShortFieldNames = this.readUInt32BE();
       this.fieldIdLength = 4;
-    } else if (flags & constants.TNS_JSON_FLAG_NUM_FNAMES_UINT16) {
-      numFieldNames = this.readUInt16BE();
+    } else if (primaryFlags & constants.TNS_JSON_FLAG_NUM_FNAMES_UINT16) {
+      numShortFieldNames = this.readUInt16BE();
       this.fieldIdLength = 2;
     } else {
-      numFieldNames = this.readUInt8();
+      numShortFieldNames = this.readUInt8();
       this.fieldIdLength = 1;
     }
 
-    // determine the size of the field names segment
-    let fieldNameOffsetsSize, fieldNamesSegSize;
-    if (flags & constants.TNS_JSON_FLAG_FNAMES_SEG_UINT32) {
-      fieldNameOffsetsSize = 4;
-      fieldNamesSegSize = this.readUInt32BE();
+    // determine the size of the short field names segment
+    let shortFieldNameOffsetsSize, shortFieldNamesSegSize;
+    if (primaryFlags & constants.TNS_JSON_FLAG_FNAMES_SEG_UINT32) {
+      shortFieldNameOffsetsSize = 4;
+      shortFieldNamesSegSize = this.readUInt32BE();
     } else {
-      fieldNameOffsetsSize = 2;
-      fieldNamesSegSize = this.readUInt16BE();
+      shortFieldNameOffsetsSize = 2;
+      shortFieldNamesSegSize = this.readUInt16BE();
+    }
+
+    // if the version indicates that field names > 255 bytes exist, parse
+    // the information about that segment
+    let longFieldNameOffsetsSize, longFieldNamesSegSize;
+    let numLongFieldNames = 0;
+    if (version === constants.TNS_JSON_VERSION_MAX_FNAME_65535) {
+      const secondaryFlags = this.readUInt16BE();
+      if (secondaryFlags & constants.TNS_JSON_FLAG_SEC_FNAMES_SEG_UINT16) {
+        longFieldNameOffsetsSize = 2;
+      } else {
+        longFieldNameOffsetsSize = 4;
+      }
+      numLongFieldNames = this.readUInt32BE();
+      longFieldNamesSegSize = this.readUInt32BE();
     }
 
     // skip the size of the tree segment
-    if (flags & constants.TNS_JSON_FLAG_TREE_SEG_UINT32) {
+    if (primaryFlags & constants.TNS_JSON_FLAG_TREE_SEG_UINT32) {
       this.skipBytes(4);
     } else {
       this.skipBytes(2);
@@ -271,37 +346,18 @@ class OsonDecoder extends BaseBuffer {
     // skip the number of "tiny" nodes
     this.skipBytes(2);
 
-    // skip the hash id array
-    let hashIdSize;
-    if (flags & constants.TNS_JSON_FLAG_HASH_ID_UINT8) {
-      hashIdSize = 1;
-    } else if (flags & constants.TNS_JSON_FLAG_HASH_ID_UINT16) {
-      hashIdSize = 2;
-    } else {
-      hashIdSize = 4;
-    }
-    this.skipBytes(numFieldNames * hashIdSize);
+    this.fieldNames = new Array(numShortFieldNames + numLongFieldNames);
 
-    // skip over the field name offsets and field names
-    let fieldNameOffsetsPos = this.pos;
-    this.skipBytes(numFieldNames * fieldNameOffsetsSize);
-    const fieldNamesPos = this.pos;
-    this.skipBytes(fieldNamesSegSize);
+    // if there are any short names, read them now
+    if (numShortFieldNames > 0) {
+      this._getFieldNames(0, numShortFieldNames,
+        shortFieldNameOffsetsSize, shortFieldNamesSegSize, 1);
+    }
 
-    // determine the names of the fields
-    this.fieldNames = new Array(numFieldNames);
-    for (let i = 0; i < numFieldNames; i++) {
-      let offset = fieldNamesPos;
-      if (flags & constants.TNS_JSON_FLAG_FNAMES_SEG_UINT32) {
-        offset += this.buf.readUInt32BE(fieldNameOffsetsPos);
-        fieldNameOffsetsPos += 4;
-      } else {
-        offset += this.buf.readUInt16BE(fieldNameOffsetsPos);
-        fieldNameOffsetsPos += 2;
-      }
-      const len = this.buf[offset];
-      const name = this.buf.subarray(offset + 1, offset + len + 1).toString();
-      this.fieldNames[i] = name;
+    // if there are any long names, read them now
+    if (numLongFieldNames > 0) {
+      this._getFieldNames(numShortFieldNames, numLongFieldNames,
+        longFieldNameOffsetsSize, longFieldNamesSegSize, 2);
     }
 
     // determine tree segment position in the buffer
@@ -315,18 +371,22 @@ class OsonDecoder extends BaseBuffer {
 
 class OsonFieldName {
 
-  constructor(name) {
+  constructor(name, maxFieldNameSize) {
     this.name = name;
     this.nameBytes = Buffer.from(name);
-    if (this.nameBytes.length > 255) {
-      errors.throwErr(errors.ERR_OSON_FIELD_NAME_LIMITATION);
+    if (this.nameBytes.length > maxFieldNameSize) {
+      errors.throwErr(errors.ERR_OSON_FIELD_NAME_LIMITATION, maxFieldNameSize);
     }
-    this.hashId = BigInt(0x811C9DC5);
-    const multiplier = BigInt(16777619);
-    const mask = BigInt(0xffffffff);
+
+    // BigInt constants for calculating Hash ID for the OSON Field Name
+    const INITIAL_HASHID = 0x811C9DC5n;
+    const HASH_MULTIPLIER = 16777619n;
+    const HASH_MASK = 0xffffffffn;
+
+    this.hashId = INITIAL_HASHID;
     for (let i = 0; i < this.nameBytes.length; i++) {
       const c = BigInt(this.nameBytes[i]);
-      this.hashId = ((this.hashId ^ c) * multiplier) & mask;
+      this.hashId = ((this.hashId ^ c) * HASH_MULTIPLIER) & HASH_MASK;
     }
     this.hashId = Number(this.hashId) & 0xff;
   }
@@ -335,41 +395,25 @@ class OsonFieldName {
 
 class OsonFieldNamesSegment extends GrowableBuffer {
 
-  constructor(value) {
+  constructor() {
     super();
-    this.fieldNamesMap = new Map();
     this.fieldNames = [];
-    this._examineNode(value);
-    this._processFieldNames();
   }
 
   //---------------------------------------------------------------------------
-  // _exmaineNode()
+  // addName()
   //
-  // Examines the value. If it contains fields, unique names are retained. The
-  // values are then examined to see if they also contain fields. Arrays are
-  // examined to determine they contain elements that contain fields.
+  // Adds a name to the field names segment.
   //---------------------------------------------------------------------------
-  _examineNode(value) {
-    if (Array.isArray(value)) {
-      for (const element of value) {
-        this._examineNode(element);
-      }
-    } else if (value && Array.isArray(value.fields)) {
-      for (let i = 0; i < value.fields.length; i++) {
-        const name = value.fields[i];
-        const element = value.values[i];
-        if (!this.fieldNamesMap.has(name)) {
-          const fieldName = new OsonFieldName(name);
-          this.fieldNamesMap.set(name, fieldName);
-          this.fieldNames.push(fieldName);
-          fieldName.offset = this.pos;
-          this.writeUInt8(fieldName.nameBytes.length);
-          this.writeBytes(fieldName.nameBytes);
-        }
-        this._examineNode(element);
-      }
+  addName(fieldName) {
+    fieldName.offset = this.pos;
+    if (fieldName.nameBytes.length <= 255) {
+      this.writeUInt8(fieldName.nameBytes.length);
+    } else {
+      this.writeUInt16BE(fieldName.nameBytes.length);
     }
+    this.writeBytes(fieldName.nameBytes);
+    this.fieldNames.push(fieldName);
   }
 
   //---------------------------------------------------------------------------
@@ -377,7 +421,7 @@ class OsonFieldNamesSegment extends GrowableBuffer {
   //
   // Processes the field names in preparation for encoding within OSON.
   //---------------------------------------------------------------------------
-  _processFieldNames() {
+  _processFieldNames(fieldIdOffset) {
     this.fieldNames.sort((a, b) => {
       if (a.hashId < b.hashId)
         return -1;
@@ -394,7 +438,7 @@ class OsonFieldNamesSegment extends GrowableBuffer {
       return 0;
     });
     for (let i = 0; i < this.fieldNames.length; i++) {
-      this.fieldNames[i].fieldId = i + 1;
+      this.fieldNames[i].fieldId = fieldIdOffset + i + 1;
     }
     if (this.fieldNames.length < 256) {
       this.fieldIdSize = 1;
@@ -414,7 +458,7 @@ class OsonTreeSegment extends GrowableBuffer {
   //
   // Encodes an array in the OSON tree segment.
   //---------------------------------------------------------------------------
-  _encodeArray(value, fnamesSeg) {
+  _encodeArray(value, encoder) {
     this._encodeContainer(constants.TNS_JSON_TYPE_ARRAY, value.length);
     const len = value.length * 4;
     const pos = this.reserveBytes(len);
@@ -422,7 +466,7 @@ class OsonTreeSegment extends GrowableBuffer {
     for (const element of value) {
       this.buf.writeUInt32BE(this.pos, offsetsBufPos);
       offsetsBufPos += 4;
-      this.encodeNode(element, fnamesSeg);
+      this.encodeNode(element, encoder);
     }
   }
 
@@ -454,27 +498,27 @@ class OsonTreeSegment extends GrowableBuffer {
   //
   // Encodes an object in the OSON tree segment.
   //---------------------------------------------------------------------------
-  _encodeObject(value, fnamesSeg) {
+  _encodeObject(value, encoder) {
     const numChildren = value.values.length;
     this._encodeContainer(constants.TNS_JSON_TYPE_OBJECT, numChildren);
-    const len = numChildren * (fnamesSeg.fieldIdSize + 4);
-    const pos = this.reserveBytes(len);
-    let fieldIdOffset = pos;
-    let valueOffset = pos + (numChildren * fnamesSeg.fieldIdSize);
+    let fieldIdOffset = this.pos;
+    let valueOffset = this.pos + (numChildren * encoder.fieldIdSize);
+    const finalOffset = valueOffset + numChildren * 4;
+    this.reserveBytes(finalOffset - this.pos);
 
     for (let i = 0; i < value.fields.length; i++) {
-      const fieldName = fnamesSeg.fieldNamesMap.get(value.fields[i]);
-      if (fnamesSeg.fieldIdSize == 1) {
+      const fieldName = encoder.fieldNamesMap.get(value.fields[i]);
+      if (encoder.fieldIdSize == 1) {
         this.buf[fieldIdOffset] = fieldName.fieldId;
-      } else if (fnamesSeg.fieldIdSize == 2) {
+      } else if (encoder.fieldIdSize == 2) {
         this.buf.writeUInt16BE(fieldName.fieldId, fieldIdOffset);
       } else {
         this.buf.writeUInt32BE(fieldName.fieldId, fieldIdOffset);
       }
       this.buf.writeUInt32BE(this.pos, valueOffset);
-      fieldIdOffset += fnamesSeg.fieldIdSize;
+      fieldIdOffset += encoder.fieldIdSize;
       valueOffset += 4;
-      this.encodeNode(value.values[i], fnamesSeg);
+      this.encodeNode(value.values[i], encoder);
     }
   }
 
@@ -483,7 +527,7 @@ class OsonTreeSegment extends GrowableBuffer {
   //
   // Encodes a value (node) in the OSON tree segment.
   //---------------------------------------------------------------------------
-  encodeNode(value, fnamesSeg) {
+  encodeNode(value, encoder) {
 
     // handle null
     if (value === undefined || value === null) {
@@ -520,7 +564,7 @@ class OsonTreeSegment extends GrowableBuffer {
       }
 
     // handle dates
-    } else if (util.isDate(value)) {
+    } else if (util.types.isDate(value)) {
       if (value.getUTCMilliseconds() === 0) {
         this.writeUInt8(constants.TNS_JSON_TYPE_TIMESTAMP7);
         this.writeOracleDate(value, types.DB_TYPE_DATE, false);
@@ -542,48 +586,199 @@ class OsonTreeSegment extends GrowableBuffer {
 
     // handle arrays
     } else if (Array.isArray(value)) {
-      this._encodeArray(value, fnamesSeg);
+      this._encodeArray(value, encoder);
+
+    // 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);
+
+    } else if (value instanceof types.JsonId) {
+      this.writeUInt8(constants.TNS_JSON_TYPE_ID);
+      this.writeUInt8(value.length);
+      this.writeBytes(Buffer.from(value.buffer));
 
     // handle objects
     } else {
-      this._encodeObject(value, fnamesSeg);
+      this._encodeObject(value, encoder);
     }
 
   }
 
 }
 
+/**
+ * Class used for encoding
+ */
+
 class OsonEncoder extends GrowableBuffer {
 
+  //---------------------------------------------------------------------------
+  // _addFieldName()
+  //
+  // Add a field with the given name.
+  //---------------------------------------------------------------------------
+  _addFieldName(name) {
+    const fieldName = new OsonFieldName(name, this.maxFieldNameSize);
+    this.fieldNamesMap.set(name, fieldName);
+    if (fieldName.nameBytes.length <= 255) {
+      this.shortFieldNamesSeg.addName(fieldName);
+    } else {
+      if (!this.longFieldNamesSeg) {
+        this.longFieldNamesSeg = new OsonFieldNamesSegment();
+      }
+      this.longFieldNamesSeg.addName(fieldName);
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // _examineNode()
+  //
+  // Examines the value. If it contains fields, unique names are retained. The
+  // values are then examined to see if they also contain fields. Arrays are
+  // examined to determine they contain elements that contain fields.
+  //---------------------------------------------------------------------------
+  _examineNode(value) {
+    if (Array.isArray(value)) {
+      for (const element of value) {
+        this._examineNode(element);
+      }
+    } else if (value && Array.isArray(value.fields)) {
+      for (let i = 0; i < value.fields.length; i++) {
+        const name = value.fields[i];
+        const element = value.values[i];
+        if (!this.fieldNamesMap.has(name)) {
+          this._addFieldName(name);
+        }
+        this._examineNode(element);
+      }
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // _writeExtendedHeader()
+  //
+  // Write the extended header containing information about the short and long
+  // field name segments.
+  //---------------------------------------------------------------------------
+  _writeExtendedHeader() {
+    // write number of short field names
+    if (this.fieldIdSize === 1) {
+      this.writeUInt8(this.shortFieldNamesSeg.fieldNames.length);
+    } else if (this.fieldIdSize === 2) {
+      this.writeUInt16BE(this.shortFieldNamesSeg.fieldNames.length);
+    } else {
+      this.writeUInt32BE(this.shortFieldNamesSeg.fieldNames.length);
+    }
+
+    // write size of short field names segment
+    if (this.shortFieldNamesSeg.pos < 65536) {
+      this.writeUInt16BE(this.shortFieldNamesSeg.pos);
+    } else {
+      this.writeUInt32BE(this.shortFieldNamesSeg.pos);
+    }
+
+    // write fields for long field names segment, if applicable
+    if (this.longFieldNamesSeg) {
+      let secondaryFlags = 0;
+      if (this.longFieldNamesSeg.pos < 65536) {
+        secondaryFlags = constants.TNS_JSON_FLAG_SEC_FNAMES_SEG_UINT16;
+      }
+      this.writeUInt16BE(secondaryFlags);
+      this.writeUInt32BE(this.longFieldNamesSeg.fieldNames.length);
+      this.writeUInt32BE(this.longFieldNamesSeg.pos);
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // _writeFieldNamesSeg()
+  //
+  // Write the contents of the field names segment to the buffer.
+  //---------------------------------------------------------------------------
+  _writeFieldNamesSeg(fieldNamesSeg) {
+    // write array of hash ids
+    for (const fieldName of fieldNamesSeg.fieldNames) {
+      if (fieldName.nameBytes.length <= 255) {
+        this.writeUInt8(fieldName.hashId);
+      } else {
+        this.writeUInt16BE(fieldName.hashId);
+      }
+    }
+
+    // write array of field name offsets for the short field names
+    for (const fieldName of fieldNamesSeg.fieldNames) {
+      if (fieldNamesSeg.pos < 65536) {
+        this.writeUInt16BE(fieldName.offset);
+      } else {
+        this.writeUInt32BE(fieldName.offset);
+      }
+    }
+
+    // write field names
+    if (fieldNamesSeg.pos > 0) {
+      this.writeBytes(fieldNamesSeg.buf.subarray(0, fieldNamesSeg.pos));
+    }
+
+  }
+
   //---------------------------------------------------------------------------
   // encode()
   //
   // Encodes the value as OSON and returns a buffer containing the OSON bytes.
   //---------------------------------------------------------------------------
-  encode(value) {
+  encode(value, maxFieldNameSize) {
 
-    // determine flags to use
-    let fnamesSeg;
+    this.maxFieldNameSize = maxFieldNameSize;
+
+    // determine the flags to use
     let flags = constants.TNS_JSON_FLAG_INLINE_LEAF;
     if (Array.isArray(value) || (value && Array.isArray(value.fields))) {
+      // examine all values recursively to determine the unique set of field
+      // names and whether they need to be added to the long field names
+      // segment (> 255 bytes) or short field names segment (<= 255 bytes)
+      this.fieldNamesMap = new Map();
+      this.shortFieldNamesSeg = new OsonFieldNamesSegment();
+      this._examineNode(value);
+
+      // perform processing of field names segments and determine the total
+      // number of unique field names in the value
+      let totalNumFieldNames = 0;
+      if (this.shortFieldNamesSeg) {
+        this.shortFieldNamesSeg._processFieldNames(0);
+        totalNumFieldNames += this.shortFieldNamesSeg.fieldNames.length;
+      }
+      if (this.longFieldNamesSeg) {
+        this.longFieldNamesSeg._processFieldNames(totalNumFieldNames);
+        totalNumFieldNames += this.longFieldNamesSeg.fieldNames.length;
+      }
+
+      // determine remaining flags and field id size
       flags |= constants.TNS_JSON_FLAG_HASH_ID_UINT8 |
         constants.TNS_JSON_FLAG_TINY_NODES_STAT;
-      fnamesSeg = new OsonFieldNamesSegment(value);
-      if (fnamesSeg.fieldNames.length > 65535) {
+      if (totalNumFieldNames > 65535) {
         flags |= constants.TNS_JSON_FLAG_NUM_FNAMES_UINT32;
-      } else if (fnamesSeg.fieldNames.length > 255) {
+        this.fieldIdSize = 4;
+      } else if (totalNumFieldNames > 255) {
         flags |= constants.TNS_JSON_FLAG_NUM_FNAMES_UINT16;
+        this.fieldIdSize = 2;
+      } else {
+        this.fieldIdSize = 1;
       }
-      if (fnamesSeg.pos > 65535) {
+      if (this.shortFieldNamesSeg.pos > 65535) {
         flags |= constants.TNS_JSON_FLAG_FNAMES_SEG_UINT32;
       }
     } else {
+      // if the value is a simple scalar
       flags |= constants.TNS_JSON_FLAG_IS_SCALAR;
     }
 
-    // encode values into the tree segment
+    // encode values into the OSON tree segment
     const treeSeg = new OsonTreeSegment();
-    treeSeg.encodeNode(value, fnamesSeg);
+    treeSeg.encodeNode(value, this);
     if (treeSeg.pos > 65535) {
       flags |= constants.TNS_JSON_FLAG_TREE_SEG_UINT32;
     }
@@ -592,28 +787,16 @@ class OsonEncoder extends GrowableBuffer {
     this.writeUInt8(constants.TNS_JSON_MAGIC_BYTE_1);
     this.writeUInt8(constants.TNS_JSON_MAGIC_BYTE_2);
     this.writeUInt8(constants.TNS_JSON_MAGIC_BYTE_3);
-    this.writeUInt8(constants.TNS_JSON_VERSION);
+    if (this.longFieldNamesSeg) {
+      this.writeUInt8(constants.TNS_JSON_VERSION_MAX_FNAME_65535);
+    } else {
+      this.writeUInt8(constants.TNS_JSON_VERSION_MAX_FNAME_255);
+    }
     this.writeUInt16BE(flags);
 
     // write extended header (when value is not scalar)
-    if (fnamesSeg) {
-
-      // write number of field names
-      if (fnamesSeg.fieldNames.length < 256) {
-        this.writeUInt8(fnamesSeg.fieldNames.length);
-      } else if (fnamesSeg.fieldNames.length < 65536) {
-        this.writeUInt16BE(fnamesSeg.fieldNames.length);
-      } else {
-        this.writeUInt32BE(fnamesSeg.fieldNames.length);
-      }
-
-      // write size of field names segment
-      if (fnamesSeg.pos < 65536) {
-        this.writeUInt16BE(fnamesSeg.pos);
-      } else {
-        this.writeUInt32BE(fnamesSeg.pos);
-      }
-
+    if (this.shortFieldNamesSeg) {
+      this._writeExtendedHeader();
     }
 
     // write size of tree segment
@@ -624,30 +807,16 @@ class OsonEncoder extends GrowableBuffer {
     }
 
     // write remainder of header and any data (when value is not scalar)
-    if (fnamesSeg) {
+    if (this.shortFieldNamesSeg) {
 
       // write number of "tiny" nodes (always zero)
       this.writeUInt16BE(0);
 
-      // write array of hash ids
-      for (const fieldName of fnamesSeg.fieldNames) {
-        this.writeUInt8(fieldName.hashId);
-      }
-
-      // write array of field name offsets
-      for (const fieldName of fnamesSeg.fieldNames) {
-        if (fnamesSeg.pos < 65536) {
-          this.writeUInt16BE(fieldName.offset);
-        } else {
-          this.writeUInt32BE(fieldName.offset);
-        }
-      }
-
-      // write field names
-      if (fnamesSeg.pos > 0) {
-        this.writeBytes(fnamesSeg.buf.subarray(0, fnamesSeg.pos));
+      // write the field names segments
+      this._writeFieldNamesSeg(this.shortFieldNamesSeg);
+      if (this.longFieldNamesSeg) {
+        this._writeFieldNamesSeg(this.longFieldNamesSeg);
       }
-
     }
 
     // write tree segment data