oracledb 6.10.0 → 7.0.0

package/lib/thin/protocol/messages/base.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -29,6 +29,8 @@
 const { Buffer } = require('buffer');
 const constants = require("../constants.js");
 const errors = require("../../../errors.js");
+const types = require('../../../types.js');
+
 
 // List of recoverable errors
 const RECOVERABLE_ERRORS = new Set([
@@ -58,6 +60,9 @@ const RECOVERABLE_ERRORS = new Set([
   16456   // missing or invalid value
 ]);
 
+// App Context constants.
+const KeyValueSetContext = 0x01; // SET CONTEXT -send to server side
+const KeyValueClearContext = 0x02; // CLEAR CONTEXT -send to server side
 /**
  *
  * Base class for all the RPC messages to support encode/decode functions
@@ -74,6 +79,8 @@ class Message {
     this.endToEndSeqNum = 0;
     this.errorOccurred = false;
     this.warning = undefined;
+    this.tokenNum = 0;  // used for request-response correlation in pipelining
+    this.isPipeline = connection.pipelineMode !== 0;
   }
 
   preProcess() { }
@@ -85,10 +92,164 @@ class Message {
     buf.writeUInt8(this.functionCode);
     buf.writeSeqNum();
     if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_23_1_EXT_1) {
-      buf.writeUB8(0);                          // token number
+      buf.writeUB8(this.tokenNum);              // token number for pipelining
     }
   }
 
+  processColumnInfo(buf, columnNum) {
+    const dataType = buf.readUInt8();
+    buf.skipUB1();                              // flags
+    const precision = buf.readInt8();
+    const scale = buf.readInt8();
+    const maxSize = buf.readUB4();
+    buf.skipUB4();                              // max number of array elements
+    buf.skipUB8();                              // cont flags
+    let oid;
+    let numBytes = buf.readUB4();               // OID
+    if (numBytes > 0) {
+      oid = Buffer.from(buf.readBytesWithLength());
+    }
+    buf.skipUB2();                              // version
+    buf.skipUB2();                              // character set id
+    const csfrm = buf.readUInt8();              // character set form
+    let size = buf.readUB4();
+    if (dataType === constants.TNS_DATA_TYPE_RAW) {
+      size = maxSize;
+    }
+    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_12_2) {
+      buf.skipUB4();                            // oaccolid
+    }
+    const nullable = Boolean(buf.readUInt8());
+    buf.skipUB1();                              // v7 length of name
+    let name;
+    numBytes = buf.readUB4();
+    if (numBytes > 0) {
+      name = buf.readStr(constants.CSFRM_IMPLICIT);
+    }
+    let schema;
+    numBytes = buf.readUB4();
+    if (numBytes > 0) {
+      schema = buf.readStr(constants.CSFRM_IMPLICIT);
+    }
+    numBytes = buf.readUB4();
+    let typeName;
+    if (numBytes > 0) {
+      typeName = buf.readStr(constants.CSFRM_IMPLICIT);
+    }
+    buf.skipUB2();                              // column position
+    const udsFlags = buf.readUB4();             // uds flag
+
+    // build metadata
+    const fetchInfo = {
+      name: name,
+      dbColumnName: name,
+      nullable: nullable,
+    };
+
+    try {
+      fetchInfo.dbType = types.getTypeByOraTypeNum(dataType, csfrm);
+    } catch {
+      fetchInfo.dbType = types.getTypeByOraTypeNum(dataType, 0);
+    }
+
+    fetchInfo.isJson = Boolean(udsFlags & constants.TNS_UDS_FLAGS_IS_JSON);
+    fetchInfo.isOson = Boolean(udsFlags & constants.TNS_UDS_FLAGS_IS_OSON);
+    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_23_1) {
+      numBytes = buf.readUB4();
+      if (numBytes > 0) {
+        fetchInfo.domainSchema = buf.readStr(constants.CSFRM_IMPLICIT);
+      }
+      numBytes = buf.readUB4();
+      if (numBytes > 0) {
+        fetchInfo.domainName = buf.readStr(constants.CSFRM_IMPLICIT);
+      }
+    }
+    if (
+      buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_23_1_EXT_3
+    ) {
+      if (buf.readUB4() > 0) {
+        fetchInfo.annotations = {};
+        buf.skipUB1();
+        const numAnnotations = buf.readUB4();
+        buf.skipUB1();
+        let key, value;
+        for (let i = 0; i < numAnnotations; i++) {
+          buf.skipUB4();
+          value = "";
+          key = buf.readStr(constants.CSFRM_IMPLICIT);
+          numBytes = buf.readUB4();
+          if (numBytes > 0) {
+            value = buf.readStr(constants.CSFRM_IMPLICIT);
+          }
+          fetchInfo.annotations[key] = value;
+          buf.skipUB4();                        // flags
+        }
+        buf.skipUB4();                          // flags
+      }
+    }
+    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_23_4) {
+      const dimensions = buf.readUB4();
+      const vectorFormat = buf.readUInt8();
+      const vectorFlags = buf.readUInt8();
+      if (fetchInfo.dbType === types.DB_TYPE_VECTOR) {
+        if (!(vectorFlags & constants.VECTOR_META_FLAG_FLEXIBLE_DIM)) {
+          fetchInfo.vectorDimensions = dimensions;
+        }
+        fetchInfo.isSparseVector = Boolean(
+          vectorFlags & constants.VECTOR_META_FLAG_SPARSE
+        );
+        if (vectorFormat !== constants.VECTOR_FORMAT_FLEX) {
+          fetchInfo.vectorFormat = vectorFormat;
+        }
+      }
+    }
+
+    switch (fetchInfo.dbType) {
+      case types.DB_TYPE_VARCHAR:
+      case types.DB_TYPE_NVARCHAR:
+      case types.DB_TYPE_CHAR:
+      case types.DB_TYPE_NCHAR:
+      case types.DB_TYPE_RAW:
+        fetchInfo.byteSize = size;
+        break;
+      case types.DB_TYPE_NUMBER:
+        fetchInfo.precision = precision;
+        break;
+      case types.DB_TYPE_TIMESTAMP:
+      case types.DB_TYPE_TIMESTAMP_TZ:
+      case types.DB_TYPE_TIMESTAMP_LTZ:
+        fetchInfo.precision = scale;
+        break;
+      case types.DB_TYPE_OBJECT:
+        fetchInfo.dbTypeClass = this.connection._getDbObjectType(
+          schema,
+          typeName,
+          undefined,
+          oid
+        );
+        if (fetchInfo.dbTypeClass.partial) {
+          this.connection._partialDbObjectTypes.push(fetchInfo.dbTypeClass);
+        }
+        if (fetchInfo.dbTypeClass.isXmlType) {
+          fetchInfo.dbType = types.DB_TYPE_XMLTYPE;
+        }
+        break;
+      default:
+        break;
+    }
+    if (fetchInfo.dbType === types.DB_TYPE_NUMBER) {
+      fetchInfo.scale = scale;
+    }
+    const result = {
+      fetchInfo: fetchInfo,
+      type: fetchInfo.dbType,
+      maxSize: maxSize,
+      columnNum: columnNum,
+      values: new Array(this.options?.fetchArraySize)
+    };
+    return result;
+  }
+
   processErrorInfo(buf) {
     this.callStatus = buf.readUB4();            // end of call status
     buf.skipUB2();                              // end to end seq number
@@ -241,6 +402,12 @@ class Message {
       this.processServerSidePiggyBack(buf);
     } else if (messageType === constants.TNS_MSG_TYPE_END_OF_REQUEST) {
       this.endOfResponse = true;
+    } else if (messageType === constants.TNS_MSG_TYPE_TOKEN) {
+      const tokenNum = buf.readUB8();
+      if (tokenNum !== this.tokenNum) {
+        errors.throwErr(errors.ERR_PIPELINE_MISMATCHED_TOKEN, tokenNum,
+          this.tokenNum);
+      }
     } else {
       errors.throwErr(errors.ERR_UNEXPECTED_MESSAGE_TYPE, messageType, buf.pos, buf.packetNum);
     }
@@ -281,6 +448,10 @@ class Message {
           this.connection.currentSchema = keyTextValue;
         } else if (keywordNum === constants.TNS_KEYWORD_NUM_EDITION) {
           this.connection._edition = keyTextValue;
+        } else if (keywordNum === constants.TNS_KEYWORD_DBNAME) {
+          this.connection.dbName = keyTextValue;
+        } else if (keywordNum === constants.TNS_KEYWORD_PDBNAME) {
+          this.connection.pdbName = keyTextValue;
         }
       }
       buf.skipUB4();                            // skip overall flags
@@ -335,14 +506,30 @@ class Message {
     }
   }
 
+  _writeBeginPipelinePiggyback(buf) {
+    buf._dataFlags |= constants.TNS_DATA_FLAGS_BEGIN_PIPELINE;
+    this.writePiggybackHeader(buf, constants.TNS_FUNC_PIPELINE_BEGIN);
+    buf.writeUB2(0);                            // error set ID
+    buf.writeUInt8(0);                          // error set mode
+    buf.writeUInt8(this.connection.pipelineMode);
+  }
+
   writePiggybacks(buf) {
     // Don't write piggybacks if not authenticated yet
     if (this.connection._protocol.connInProgress)
       return;
 
+    if (this.connection.securityContext) {
+      this._writeEndUserSecurityContextPiggyback(buf);
+    }
+    if (this.connection.pipelineMode) {
+      this._writeBeginPipelinePiggyback(buf);
+      this.connection.pipelineMode = 0;
+    }
     if (this.connection._currentSchemaModified) {
       this._writeCurrentSchemaPiggyback(buf);
     }
+    this._writeApplicationContextPiggyback(buf);
     if (this.connection.statementCache._cursorsToClose.size > 0 && !this.connection._drcpEstablishSession) {
       // skip closing cursors when '_drcpEstablishSession = true' Since we don't know whether the same session
       // is in use. We can not send the information across until after the session information has been returned
@@ -372,8 +559,9 @@ class Message {
     buf.writeUInt8(constants.TNS_MSG_TYPE_PIGGYBACK);
     buf.writeUInt8(functionCode);
     buf.writeSeqNum();
-    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_23_1_EXT_1) {
-      buf.writeUB8(0);                          // token number
+    if (buf.caps.ttcFieldVersion >=
+      constants.TNS_CCAP_FIELD_VERSION_23_1_EXT_1) {
+      buf.writeUB8(buf.tokenNum);               // token number for pipelining
     }
   }
 
@@ -429,6 +617,17 @@ class Message {
     buf.writeBytesWithLength(Buffer.from(this.connection.currentSchema));
   }
 
+  // Writes the piggyback that informs the server of the EndUserSecurityContext.
+  _writeEndUserSecurityContextPiggyback(buf) {
+    const encoded = this.connection.securityContext.getDeobfuscatedValue();
+    this.writePiggybackHeader(buf, constants.TNS_FUNC_END_USER_SECURITY_CTX);
+    buf.writeUB4(constants.TNS_SECURITY_CONTEXT_ATTACH_FLAG);
+    buf.writeUInt8(1); // pointer(kpdkve)
+    buf.writeUB4(1);   // number of key values
+    buf.writeStrKeywordValuePair("ORCL_XS_AUTHZ_CONTEXT", encoded);
+    encoded.fill(0);
+  }
+
   _writeEndToEndPiggybacks(buf) {
     let flags = 0;
 
@@ -521,6 +720,48 @@ class Message {
     return writtenBytes;
   }
 
+  _writeApplicationContextPiggyback(buf) {
+    const nameSpaces = this.connection._nameSpaceMap;
+    if (!nameSpaces) {
+      return; // nothing to send
+    }
+
+    for (const [key, nameSpace] of nameSpaces) {
+      this.writePiggybackHeader(buf, constants.TNS_FUNC_APP_CONTEXT);
+
+      // send metadata first
+      const nsBytes = Buffer.from(nameSpace.nameSpaceName);
+      if (nsBytes.length > 0) {
+        buf.writeUInt8(1); // ptr
+        buf.writeUB4(nsBytes.length);
+      } else {
+        buf.writeUInt8(0); // null ptr
+      }
+      const keyValues = nameSpace.keyValues;
+      if (keyValues.length > 0) {
+        buf.writeUInt8(1); // ptr
+      } else {
+        buf.writeUInt8(0); // null ptr
+      }
+      buf.writeUB4(keyValues.length);
+
+      let flag = 0;
+      if (keyValues.length > 0) flag = KeyValueSetContext;
+      if (nameSpace.pendingClear) flag |= KeyValueClearContext;
+      buf.writeUB2(flag);
+      buf.writeUInt8(0);
+      // --- end of metadata
+
+      // --- now send the values
+      buf.writeBytesWithLength(nsBytes);
+      for (const obj of keyValues) {
+        const [entryKey, entryValue] = Object.entries(obj)[0];
+        buf.writeKeyValue(entryKey, entryValue);
+      }
+      nameSpaces.delete(key);
+    }
+  }
+
   // Called when an error is encountered during decode of RPC
   saveDeferredErr() {
     if (!this.deferredErr) {

package/lib/thin/protocol/messages/dataType.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -40,7 +40,7 @@ class DataTypeMessage extends Message {
 
   processMessage(buf, messageType) {
     if (messageType === constants.TNS_MSG_TYPE_DATA_TYPES) {
-      while (true) {        // eslint-disable-line
+      while (true) {
         const dataType = buf.readUInt16BE();
         if (dataType === 0)
           break;
@@ -395,7 +395,12 @@ const dataTypes = [
   [constants.TNS_DATA_TYPE_OER, constants.TNS_DATA_TYPE_OER, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_OAC, constants.TNS_DATA_TYPE_OAC, constants.TNS_TYPE_REP_UNIVERSAL],
   [constants.TNS_DATA_TYPE_SESSSIGN, constants.TNS_DATA_TYPE_SESSSIGN, constants.TNS_TYPE_REP_UNIVERSAL],
-  [constants.TNS_DATA_TYPE_VECTOR, constants.TNS_DATA_TYPE_VECTOR, constants.TNS_TYPE_REP_UNIVERSAL]
+  [constants.TNS_DATA_TYPE_VECTOR, constants.TNS_DATA_TYPE_VECTOR, constants.TNS_TYPE_REP_UNIVERSAL],
+  [constants.TNS_DATA_TYPE_PLEND, constants.TNS_DATA_TYPE_PLEND, constants.TNS_TYPE_REP_UNIVERSAL],
+  [constants.TNS_DATA_TYPE_PLBGN, constants.TNS_DATA_TYPE_PLBGN, constants.TNS_TYPE_REP_UNIVERSAL],
+  [constants.TNS_DATA_TYPE_PLOP, constants.TNS_DATA_TYPE_PLOP, constants.TNS_TYPE_REP_UNIVERSAL],
+  [constants.TNS_DATA_TYPE_KVE, constants.TNS_DATA_TYPE_KVE, constants.TNS_TYPE_REP_UNIVERSAL],
+  [constants.TNS_DATA_TYPE_EUSC, constants.TNS_DATA_TYPE_EUSC, constants.TNS_TYPE_REP_UNIVERSAL]
 ];
 
 module.exports = DataTypeMessage;