oracledb 6.0.3 → 6.2.0

package/lib/thin/statement.js

@@ -28,29 +28,6 @@
 
 const { Buffer } = require('buffer');
 const constants = require('../constants');
-const thinUtil = require("./util.js");
-
-/* eslint-disable no-useless-escape */
-// Rules for named binds:
-// 1. Quoted and non-quoted bind names are allowed.
-// 2. Quoted binds can contain any characters.
-// 3. Non-quoted binds must begin with an alphabet character.
-// 4. Non-quoted binds can only contain alphanumeric characters, the underscore,
-//    the dollar sign and the pound sign.
-// 5. Non-quoted binds cannot be Oracle Database Reserved Names
-//    (Server handles this case and returns an appropriate error)
-const BIND_PATTERN = /(?<=:)\s*((?:".*?")|(?:[\p{L}][\p{L}\p{Nd}_\$#]*)|\p{Nd}+)/gu;
-
-// pattern used for detecting a DML returning clause; bind variables in the
-// first group are input variables; bind variables in the second group are
-// output only variables
-// assumes expressions/variables are seperated by delimiters space and comma
-const DML_RETURNING_KEY = /(?<=\bRETURN(?:ING)?\b)/si;
-const DML_RETURNING_INTO_KEY = /(?<=\bINTO\b)/gsi;
-
-const SINGLE_LINE_COMMENT_PATTERN = /--.*/g;
-const MULTI_LINE_COMMENT_PATTERN = /\/\*.*?\*\//sg;
-const CONSTANT_STRING_PATTERN = /'.*?'/sg;
 
 /**
  * It is used to cache the metadata about bind information
@@ -77,6 +54,286 @@ class BindInfo {
  */
 module.exports.BindInfo = BindInfo;
 
+class Parser {
+  constructor() {
+    this.returningKeywordFound = false;
+    this.pos = 0;
+    this.maxPos = 0;
+    this.sqlData = "";
+  }
+
+  /**
+   * Bind variables are identified as follows:
+   *  - Quoted and non-quoted bind names are allowed.
+   *  - Quoted bind names can contain any characters.
+   *  - Non-quoted bind names must begin with an alphabetic character.
+   *  - Non-quoted bind names can only contain alphanumeric characters, the
+   *    underscore, the dollar sign and the pound sign.
+   *  - Non-quoted bind names cannot be Oracle Database Reserved Names (this
+   *    is left to the server to detect and return an appropriate error).
+   */
+  _parseBindName(stmt) {
+    let quotedName = false;
+    let inBind = false;
+    let digitsOnly = false;
+    let startPos = 0;
+    let pos = this.pos + 1;
+    let bindName;
+    let ch;
+
+    while (pos <= this.maxPos) {
+      ch = this.sqlData[pos];
+      if (!inBind) {
+        if (/\p{space}/u.test(ch)) {
+          pos += 1;
+          continue;
+        } else if (ch === '"') {
+          quotedName = true;
+        } else if (/\p{N}/u.test(ch)) {
+          digitsOnly = true;
+        } else if (!/\p{Alpha}/u.test(ch)) {
+          break;
+        }
+        inBind = true;
+        startPos = pos;
+      } else if (digitsOnly && !(/\p{N}/u.test(ch))) {
+        this.pos = pos - 1;
+        break;
+      } else if (quotedName && ch === '"') {
+        this.pos = pos;
+        break;
+      } else if (!digitsOnly && !quotedName
+          && !(/[\p{L}\p{N}]/u.test(ch))
+          && !['$', '_', '#'].includes(ch)) {
+        this.pos = pos - 1;
+        break;
+      }
+      pos += 1;
+    }
+
+    if (inBind) {
+      if (quotedName) {
+        bindName = stmt.sql.substring(startPos + 1, pos);
+      } else if (digitsOnly) {
+        bindName = stmt.sql.substring(startPos, pos);
+      } else {
+        bindName = stmt.sql.substring(startPos, pos).toUpperCase();
+      }
+      stmt._addBind(bindName);
+    }
+  }
+
+  /**
+   * Multiple line comments consist of the characters /* followed by all
+   * characters up until * followed by /. This method is called when the first
+   * slash is detected and checks for the subsequent asterisk. If found,
+   * the comment is traversed and the current position is updated; otherwise,
+   * the current position is left untouched.
+   */
+  _parseMultiLineComment() {
+    let inComment = false;
+    let exitingComment = false;
+    let pos = this.pos + 1;
+    let ch;
+    while (pos <= this.maxPos) {
+      ch = this.sqlData[pos];
+      if (!inComment) {
+        if (ch !== '*') {
+          break;
+        }
+        inComment = true;
+      } else if (!exitingComment && ch === '*') {
+        exitingComment = true;
+      } else if (exitingComment) {
+        if (ch === '/') {
+          this.pos = pos;
+          break;
+        }
+        exitingComment = false;
+      }
+      pos += 1;
+    }
+  }
+
+  /** Parses a q-string which consists of the characters "q" and a single
+   * quote followed by a start separator, any text that does not contain the
+   * end seprator and the end separator and ending quote. The following are
+   * examples that demonstrate this:
+   *   - q'[...]'
+   *   - q'{...}'
+   *   - q'<...>'
+   *   - q'(...)'
+   *   - q'?...?' (where ? is any character)
+   */
+  _parseQstring() {
+    let exitingQstring = false;
+    let inQstring = false;
+    let sep;
+    let ch;
+
+    this.pos += 1;
+
+    while (this.pos <= this.maxPos) {
+      ch = this.sqlData[this.pos];
+      if (!inQstring) {
+        if (ch === '[') {
+          sep = ']';
+        } else if (ch === '{') {
+          sep = '}';
+        } else if (ch === '(') {
+          sep = ')';
+        } else if (ch === '<') {
+          sep = '>';
+        } else {
+          sep = ch;
+        }
+        inQstring = true;
+      } else if (!exitingQstring && ch === sep) {
+        exitingQstring = true;
+      } else if (exitingQstring) {
+        if (ch === "'") {
+          break;
+        } else if (ch !== sep) {
+          exitingQstring = false;
+        }
+      }
+      this.pos += 1;
+    }
+  }
+
+  /**
+   * Parses a quoted string with the given separator. All characters until
+   * the separate is detected are discarded.
+   */
+  _parseQuotedString(sep) {
+    let ch;
+    this.pos += 1;
+    while (this.pos <= this.maxPos) {
+      ch = this.sqlData[this.pos];
+      if (ch === sep) {
+        break;
+      }
+      this.pos += 1;
+    }
+  }
+
+  /**
+   * Single line comments consist of two dashes and all characters up to the
+   * next line break. This method is called when the first dash is detected
+   * and checks for the subsequent dash. If found, the single line comment
+   * is traversed and the current position is updated; otherwise, the
+   * current position is left untouched.
+   */
+  _parseSingleLineComment() {
+    let inComment = false;
+    let pos = this.pos + 1;
+    let ch;
+
+    while (pos <= this.maxPos) {
+      ch = this.sqlData[pos];
+      if (!inComment) {
+        if (ch !== '-') {
+          break;
+        }
+        inComment = true;
+      } else if (ch === '\n') {
+        this.pos = pos;
+        break;
+      }
+      pos += 1;
+    }
+  }
+
+  /**
+   * Parses the SQL stored in the statement in order to determine the
+   * keyword that identifies the type of SQL being executed as well as a
+   * list of bind variable names. A check is also made for DML returning
+   * statements since the bind variables following the "INTO" keyword are
+   * treated differently from other bind variables.
+   */
+  parse(stmt) {
+    let initialKeywordFound = false;
+    let lastWasString = false;
+    let ch, lastCh = '', alphaStartCh = '';
+    let alphaStartPos = 0, alphaLen;
+    let isAlpha, lastWasAlpha = false;
+    let keyword;
+
+    // initialization
+    this.pos = 0;
+    this.maxPos = stmt.sql.length - 1;
+    this.sqlData = stmt.sql;
+
+    // scan all the characters in the string
+    while (this.pos <= this.maxPos) {
+      ch = this.sqlData[this.pos];
+      // look for certain keywords (initial keyword and the ones for
+      // detecting DML returning statements
+      isAlpha = /\p{L}/u.test(ch);
+      if (isAlpha && !lastWasAlpha) {
+        alphaStartPos = this.pos;
+        alphaStartCh = ch;
+      } else if (!isAlpha && lastWasAlpha) {
+        alphaLen = this.pos - alphaStartPos;
+        if (!initialKeywordFound) {
+          keyword = stmt.sql.substring(alphaStartPos, this.pos).toUpperCase();
+          stmt._determineStatementType(keyword);
+          initialKeywordFound = true;
+          if (stmt.isDdl) {
+            break;
+          }
+        } else if (stmt.isDml && !this.returningKeywordFound
+            && (alphaLen === 9 || alphaLen === 6)
+            && ['r', 'R'].includes(alphaStartCh)) {
+          keyword = stmt.sql.substring(alphaStartPos, this.pos).toUpperCase();
+          if (['RETURNING', 'RETURN'].includes(keyword)) {
+            this.returningKeywordFound = true;
+          }
+        } else if (this.returningKeywordFound && alphaLen === 4
+            && ['i', 'I'].includes(alphaStartCh)) {
+          keyword = stmt.sql.substring(alphaStartPos, this.pos).toUpperCase();
+          if (keyword === 'INTO') {
+            stmt.isReturning = true;
+          }
+        }
+      }
+
+      // need to keep track of whether the last token parsed was a string
+      // (excluding whitespace) as if the last token parsed was a string
+      // a following colon is not a bind variable but a part of the JSON
+      // constant syntax
+      if (ch === "'") {
+        lastWasString = true;
+        if (['q', 'Q'].includes(lastCh)) {
+          this._parseQstring();
+        } else {
+          this._parseQuotedString(ch);
+        }
+      } else if (!(/\p{space}/u.test(ch))) {
+        if (ch === '-') {
+          this._parseSingleLineComment();
+        } else if (ch === '/') {
+          this._parseMultiLineComment();
+        } else if (ch === '"') {
+          this._parseQuotedString(ch);
+        } else if (ch === ':' && !lastWasString) {
+          this._parseBindName(stmt);
+        }
+        lastWasString = false;
+      }
+
+      this.pos += 1;
+      lastWasAlpha = isAlpha;
+      lastCh = ch;
+    }
+
+    // if only a single word is found in sql, e.g. in case of commit/rollback
+    if (!initialKeywordFound) {
+      stmt._determineStatementType(stmt.sql.toUpperCase());
+    }
+  }
+}
+
 class Statement {
   constructor() {
     this.sql = "";
@@ -143,54 +400,72 @@ class Statement {
   // Determine the type of the SQL statement by examining the first keyword
   // found in the statement
   //---------------------------------------------------------------------------
-  _determineStatementType(sql) {
-    sql = thinUtil.cleanSql(sql);
-    let tokens = sql.trim().trimStart('(').substring(0, 10).split(" ");
-    if (tokens.length > 0) {
-      const sqlKeyword = tokens[0].toUpperCase();
-      if (["DECLARE", "BEGIN", "CALL"].includes(sqlKeyword)) {
+  _determineStatementType(sqlKeyword) {
+    switch (sqlKeyword) {
+      case 'DECLARE':
         this.isPlSql = true;
-        if (sqlKeyword === 'DECLARE') {
-          this.statementType = constants.STMT_TYPE_DECLARE;
-        } else if (sqlKeyword === 'BEGIN') {
-          this.statementType = constants.STMT_TYPE_BEGIN;
-        } else if (sqlKeyword === 'CALL') {
-          this.statementType = constants.STMT_TYPE_CALL;
-        }
-      } else if (["SELECT", "WITH"].includes(sqlKeyword)) {
+        this.statementType = constants.STMT_TYPE_DECLARE;
+        break;
+      case 'CALL':
+        this.isPlSql = true;
+        this.statementType = constants.STMT_TYPE_CALL;
+        break;
+      case 'BEGIN':
+        this.isPlSql = true;
+        this.statementType = constants.STMT_TYPE_BEGIN;
+        break;
+      case 'SELECT':
         this.isQuery = true;
-        if (sqlKeyword === "SELECT") {
-          this.statementType = constants.STMT_TYPE_SELECT;
-        }
-      } else if (["INSERT", "UPDATE", "DELETE", "MERGE"].includes(sqlKeyword)) {
+        this.statementType = constants.STMT_TYPE_SELECT;
+        break;
+      case 'WITH':
+        this.isQuery = true;
+        break;
+      case 'INSERT':
         this.isDml = true;
-        if (sqlKeyword === 'INSERT') {
-          this.statementType = constants.STMT_TYPE_INSERT;
-        } else if (sqlKeyword === 'UPDATE') {
-          this.statementType = constants.STMT_TYPE_UPDATE;
-        } else if (sqlKeyword === 'DELETE') {
-          this.statementType = constants.STMT_TYPE_DELETE;
-        } else if (sqlKeyword === 'MERGE') {
-          this.statementType = constants.STMT_TYPE_MERGE;
-        }
-      } else if (["CREATE", "ALTER", "DROP", "TRUNCATE"].includes(sqlKeyword)) {
+        this.statementType = constants.STMT_TYPE_INSERT;
+        break;
+      case 'UPDATE':
+        this.isDml = true;
+        this.statementType = constants.STMT_TYPE_UPDATE;
+        break;
+      case 'DELETE':
+        this.isDml = true;
+        this.statementType = constants.STMT_TYPE_DELETE;
+        break;
+      case 'MERGE':
+        this.isDml = true;
+        this.statementType = constants.STMT_TYPE_MERGE;
+        break;
+      case 'ALTER':
         this.isDdl = true;
-        if (sqlKeyword === 'CREATE') {
-          this.statementType = constants.STMT_TYPE_CREATE;
-        } else if (sqlKeyword === 'ALTER') {
-          this.statementType = constants.STMT_TYPE_ALTER;
-        } else if (sqlKeyword === 'DROP') {
-          this.statementType = constants.STMT_TYPE_DROP;
-        }
-      } else if (sqlKeyword === 'COMMIT') {
+        this.statementType = constants.STMT_TYPE_ALTER;
+        break;
+      case 'CREATE':
+        this.isDdl = true;
+        this.statementType = constants.STMT_TYPE_CREATE;
+        break;
+      case 'DROP':
+        this.isDdl = true;
+        this.statementType = constants.STMT_TYPE_DROP;
+        break;
+      case 'ANALYZE':
+      case 'AUDIT':
+      case 'COMMENT':
+      case 'GRANT':
+      case 'REVOKE':
+      case 'TRUNCATE':
+        this.isDdl = true;
+        break;
+      case 'COMMIT':
         this.statementType = constants.STMT_TYPE_COMMIT;
-      } else if (sqlKeyword === 'ROLLBACK') {
+        break;
+      case 'ROLLBACK':
         this.statementType = constants.STMT_TYPE_ROLLBACK;
-      } else if (sqlKeyword === 'MERGE') {
-        this.statementType = constants.STMT_TYPE_MERGE;
-      } else {
+        break;
+      default:
         this.statementType = constants.STMT_TYPE_UNKNOWN;
-      }
+        break;
     }
   }
 
@@ -205,40 +480,8 @@ class Statement {
     this.sql = sql;
     this.sqlBytes = Buffer.from(this.sql, 'utf8');
     this.sqlLength = this.sqlBytes.length;
-    // replace literals with a specific literal
-    sql = sql.replace(CONSTANT_STRING_PATTERN, "'S'");
-    sql = sql.replace(SINGLE_LINE_COMMENT_PATTERN, "");
-    sql = sql.replace(MULTI_LINE_COMMENT_PATTERN, "");
-    this._determineStatementType(sql);
-    let returningSql;
-    if (this.isQuery || this.isDml || this.isPlSql) {
-      let inputSql = sql;
-      if (this.isDml) {
-        /*
-         * get starting index after DML_RETURNING_KEY from begining of sql and starting index
-         * after DML_RETURNING_INTO_KEY from the end of sql
-         */
-        let result;
-        let intoKey = -1;
-        const retKey = sql.search(DML_RETURNING_KEY);
-        let intoRegex = DML_RETURNING_INTO_KEY;
-        // simulate lastInfdexOf with intoRegex input
-        while ((result = intoRegex.exec(sql.slice(retKey))) != null) {
-          intoKey = result.index;
-          intoRegex.lastIndex = result.index + 1;
-        }
-        if (retKey > -1 && intoKey > -1) {
-          intoKey = retKey + intoKey;
-          inputSql = sql.slice(0, intoKey);
-          returningSql = sql.slice(intoKey);
-        }
-      }
-      this._addBinds(inputSql, false);
-      if (returningSql) {
-        this.isReturning = true;
-        this._addBinds(returningSql, true);
-      }
-    }
+    const parser = new Parser();
+    parser.parse(this);
   }
 
   //---------------------------------------------------------------------------
@@ -247,27 +490,16 @@ class Statement {
   // Add bind information to the statement by examining the passed SQL for
   // bind variable names.
   //---------------------------------------------------------------------------
-  _addBinds(sql, isReturnBind) {
-    const regexMatchArray = [...sql.matchAll(BIND_PATTERN)];
-    let name;
-    regexMatchArray.forEach(element => {
-      if (element[0].startsWith('"') && element[0].endsWith('"')) {
-        name = element[0].substring(1, element[0].length - 1);
-      } else {
-        name = element[0].trim().toUpperCase();
-      }
-      if (this.isPlSql && this.bindInfoDict.has(name)) {
-        return;
-      }
-      let info = new BindInfo(name, isReturnBind);
+  _addBind(name) {
+    if (!this.isPlSql || !this.bindInfoDict.has(name)) {
+      const info = new BindInfo(name, this.isReturning);
       this.bindInfoList.push(info);
-
       if (this.bindInfoDict.has(info.bindName)) {
         this.bindInfoDict.get(info.bindName).push(info);
       } else {
         this.bindInfoDict.set(info.bindName, [info]);
       }
-    });
+    }
   }
 
   //---------------------------------------------------------------------------

package/lib/thin/util.js

@@ -63,99 +63,41 @@ function getMetadataMany(vars) {
 }
 
 //---------------------------------------------------------------------------
-// getOutBinds(sql)
+// getOutBindValues(sql)
 //
-// Get the outBinds for the sql
+// Return the values for the out binds at the given position (row).
 //---------------------------------------------------------------------------
-function getOutBinds(bindVars, pos) {
-  let bindByPos = (bindVars[0].name === undefined);
-  let outBinds;
-  if (bindByPos) {
-    outBinds = [];
-  } else {
-    outBinds = {};
-  }
+function getOutBindValues(bindVars, pos) {
+  const bindByPos = (bindVars[0].name === undefined);
+  const outBindValues = (bindByPos) ? [] : {};
   for (let i = 0; i < bindVars.length; i++) {
-    if (bindVars[i].dir === constants.BIND_IN)
-      continue;
     if (bindByPos) {
-      outBinds.push(bindVars[i].values[pos]);
+      outBindValues.push(bindVars[i].values[pos]);
     } else {
-      outBinds[bindVars[i].name] = bindVars[i].values[pos];
+      outBindValues[bindVars[i].name] = bindVars[i].values[pos];
     }
   }
-  return outBinds;
-}
-
-//---------------------------------------------------------------------------
-// getExecuteManyOutBinds(sql)
-//
-// Get the outBinds for the sql when doing an executeMany call
-//---------------------------------------------------------------------------
-function getExecuteManyOutBinds(bindVars, numIters) {
-  let numOutBinds = getNumOutBinds(bindVars);
-  if (numOutBinds === 0) {
-    return;
-  }
-  let outBinds = new Array(numIters).fill(null);
-  for (let i = 0; i < numIters; i++) {
-    outBinds[i] = getOutBinds(bindVars, i);
-  }
-  return outBinds;
+  return outBindValues;
 }
 
 //---------------------------------------------------------------------------
-// getNumOutBinds(sql)
+// getOutBinds()
 //
-// Get the number of outBinds for the sql
+// Return the out binds for the given statement.
 //---------------------------------------------------------------------------
-function getNumOutBinds(bindVars) {
-  let numOutBinds = 0;
-  for (let i = 0; i < bindVars.length; i++) {
-    if (bindVars[i].dir !== constants.BIND_IN) {
-      numOutBinds++;
+function getOutBinds(statement, numIters, executeManyFlag) {
+  const bindVars = statement.bindInfoList.map(i => i.bindVar);
+  const outBinds = bindVars.filter(v => v.dir !== constants.BIND_IN);
+  if (outBinds.length > 0) {
+    if (executeManyFlag) {
+      const outBindValues = new Array(numIters);
+      for (let i = 0; i < numIters; i++) {
+        outBindValues[i] = getOutBindValues(outBinds, i);
+      }
+      return outBindValues;
     }
+    return getOutBindValues(outBinds, 0);
   }
-  return numOutBinds;
-}
-
-//---------------------------------------------------------------------------
-// getExecuteOutBinds(sql)
-//
-// Get the outBinds for the sql when doing an execute call
-//---------------------------------------------------------------------------
-function getExecuteOutBinds(bindVars) {
-  let numOutBinds = getNumOutBinds(bindVars);
-  if (numOutBinds === 0) {
-    return;
-  }
-  return getOutBinds(bindVars, 0);
-}
-
-//---------------------------------------------------------------------------
-// cleanSql(sql)
-//
-// Sanitize the sql to remove comment and redundant information
-//---------------------------------------------------------------------------
-function cleanSql(sql) {
-  sql = sql.trim();
-  sql = sql.replace(/\--.*(\n|$)/g, ""); // eslint-disable-line
-  sql = sql.replace(/\/\\*[\S\n ]+\\*\//g, "");
-  sql = sql.replace(/\s+/g, " ");
-  return sql;
-}
-
-//---------------------------------------------------------------------------
-// getOutBinds(sql)
-//
-// Get the bind variables from the bindInfoList of the statement object
-//---------------------------------------------------------------------------
-function getBindVars(statement) {
-  let bindVars = [];
-  for (const bindInfo of statement.bindInfoList) {
-    bindVars.push(bindInfo.bindVar);
-  }
-  return bindVars;
 }
 
 //---------------------------------------------------------------------------
@@ -167,8 +109,7 @@ function checkProxyUserValidity(userName) {
   let schemaUser = '', proxyUser = '';
   let quoteFound = false, openSquareBracketFound = false;
   let lastQuoteFoundIndex = 0;
-  let schemaUserStartIndex;
-  let result = {
+  const result = {
     status       : -1,
     proxyUser    : '',
     schemaUser   : ''
@@ -219,7 +160,7 @@ function checkProxyUserValidity(userName) {
   // extract schema user
   index = index + 1;
   quoteFound = false;
-  schemaUserStartIndex = index;
+  const schemaUserStartIndex = index;
   lastQuoteFoundIndex = 0;
   while (index < userNameLength) {
     // check for double quotes
@@ -299,12 +240,8 @@ function checkCredentials(params) {
 
 module.exports = {
   getMetadataMany,
-  cleanSql,
   CLIENT_INFO,
-  getExecuteOutBinds,
-  getExecuteManyOutBinds,
   getOutBinds,
-  getBindVars,
   checkProxyUserValidity,
   checkCredentials
 };

package/lib/transformer.js

@@ -248,5 +248,7 @@ function transformValueIn(info, value, options) {
 
 // define exports
 module.exports = {
-  transformValueIn,
+  transformJsonValue,
+  transformValueIn
+
 };