@sap/async-xsjs 1.0.2

package/lib/xsjs/db/common/parse-time.js

@@ -0,0 +1,139 @@
+'use strict';
+
+var util = require('util');
+var moment = require('moment');
+
+// This is a workaround for the output that moment js produces when you try to instantiate a Javascript specific date via the moment constructor.
+moment.createFromInputFallback = function(config) {
+  config._d = new Date(NaN);
+};
+
+exports.formatDate = function(date) {
+  // see node_modules/hdb/lib/protocol/Writer.js for the expected format
+  return zpad(date.getFullYear(), 4) + '-' + zpad(date.getMonth() + 1, 2) + '-' + zpad(date.getDate(), 2);
+};
+
+exports.formatTime = function(date) {
+  // see node_modules/hdb/lib/protocol/Writer.js for the expected format
+  return zpad(date.getHours(), 2) + ':' + zpad(date.getMinutes(), 2) + ':' +
+    zpad(date.getSeconds(), 2);
+};
+
+exports.formatDateTime = function(date) {
+  // see node_modules/hdb/lib/protocol/Writer.js for the expected format
+  return exports.formatDate(date) + 'T' + exports.formatTime(date) + '.' + zpad(date.getMilliseconds(), 3);
+};
+
+exports.parseDateTime = function(value, format) {
+  if (!format && isAbabFormat(value)) {
+    format = 'YYYYMMDD';
+  }
+
+  if (format) {
+    // Change the format if it is HANA Specific so that moment understands it.
+    var HANA_TO_MOMENTJS_MAPPING = {
+      // RM not supported !!! W and WW are not supported !!!
+      MM: 'M',
+      DD: 'D',
+      MONTH: 'MMMM',
+      MON: 'MMM',
+      HH24: 'H',
+      HH12: 'h',
+      MI: 'm',
+      SS: 's',
+      AM: 'A',
+      PM: 'A'
+    };
+
+    Object.keys(HANA_TO_MOMENTJS_MAPPING).forEach(function(hanaFormat) {
+      var momentFormat = HANA_TO_MOMENTJS_MAPPING[hanaFormat];
+      format = format.replace(hanaFormat, momentFormat);
+    });
+
+    // Fractional seconds. Example: HH:MI:SS.FFX, where X e {1, 2, ..., 7}. NOTE: In XS1 X represented the digits of fractional second. In XS Advanced they are always 3 digit.
+    format = format.replace(/FF\d/, 'SSS');
+
+    var momentDate = moment(value, format);
+    if (!momentDate.isValid()) {
+      throw new TypeError(util.format('Provided timestamp value: %s does not match the given format: %s or invalid format.', value, format));
+    }
+
+    return momentDate.toDate();
+  }
+
+  // Do not allow hours like '14:00:00 PM'. Note: third part of expression produces moment js output.
+  if (isNaN(Date.parse(value)) && value.indexOf('T') < 0 && !moment(value).isValid()) {
+    throw new TypeError(util.format('Provided timestamp value: %s is not valid.', value));
+  }
+
+  var separators = findDateSeparators(value);
+  // If date is DD MM YYYY, which is moment js specific, switch it to YYYY MM DD
+  value = exchangeYearAndDate(separators, value);
+
+  // If timestamp is not moment specific we can't just pass it to the moment constructor, so we need format.
+  if (!timestampIsMomentSpecific(value)) {
+    format = 'Y' + separators[0] + 'M' + separators[1] + 'D h:m:s.SSS A';
+  }
+
+  return moment(value, format).toDate();
+};
+
+
+// ABAP Data Type, DATS format is in form YYYYMMDD
+var ABAP_TIMESTAMP_LENGTH = 8;
+
+function isAbabFormat(value) {
+  var eightDigits = new RegExp('\\d{' + ABAP_TIMESTAMP_LENGTH + '}');
+
+  return (value.length === ABAP_TIMESTAMP_LENGTH && eightDigits.test(value));
+}
+
+function findDateSeparators(timestamp) {
+  var index = 0;
+  var separators = [];
+
+  while (separators.length < 2) {
+    var currentChar = timestamp[index];
+    // If the char at this position is separator
+    if (currentChar === '-' || currentChar === '/') {
+      separators.push(currentChar);
+    }
+    index++;
+  }
+  return separators;
+}
+
+function exchangeYearAndDate(separators, timestamp) {
+  var separatorIndexes = [timestamp.indexOf(separators[0]), timestamp.lastIndexOf(separators[1]) + 1];
+  var dateLastIndex = timestamp.split(' ')[0].split('T')[0].length;
+  var newTimestamp = timestamp;
+
+  var year = timestamp.slice(separatorIndexes[1], dateLastIndex);
+  if (year.length > 2) {
+    var month = timestamp.slice(separatorIndexes[0], separatorIndexes[1]);
+    var day = timestamp.slice(0, separatorIndexes[0]);
+    var restOfTheTimestamp = timestamp.slice(dateLastIndex);
+
+    newTimestamp = year + month + day + restOfTheTimestamp;
+  }
+  return newTimestamp;
+}
+
+function timestampIsMomentSpecific(timestamp) {
+  var momentSpecificCharacters = ['+', 'W', 'Z'];
+  var isMomentSpecific = false;
+  momentSpecificCharacters.forEach(function(character) {
+    if (timestamp.indexOf(character) > -1) {
+      isMomentSpecific = true;
+    }
+  });
+  return isMomentSpecific;
+}
+
+function zpad(n, digits) {
+  var s = n + '';
+  while (s.length < digits) {
+    s = '0' + s;
+  }
+  return s;
+}

package/lib/xsjs/db/dbapi/CallableStatement.js

@@ -0,0 +1,192 @@
+'use strict';
+
+var _ = require('lodash');
+var util = require('util');
+var Statement = require('./Statement');
+var conversions = require('./conversions');
+
+module.exports = CallableStatement;
+
+util.inherits(CallableStatement, Statement);
+
+function CallableStatement(statement) {
+  Statement.call(this, statement);
+}
+
+/**
+ * Returns an integer value of a TINYINT, SMALLINT, INT or BIGINT parameter types
+ * An exception will be thrown if the value is bigger than 9007199254740992 (2^53) or smaller than -9007199254740992 (-2^53).
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {integer} Integer representation
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getInteger = function (columnIndex) {
+  return conversions.getInteger(getValue.call(this, columnIndex));
+};
+
+CallableStatement.prototype.getInt = CallableStatement.prototype.getInteger;
+
+/**
+ * Returns an Int64 value of a BIGINT parameter
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {ctypes.Int64} ctypes.Int64
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getBigInt = function (columnIndex) {
+  return conversions.getBigInt(getValue.call(this, columnIndex));
+};
+
+/**
+ * Returns a string value of a CHAR or VARCHAR parameter; ASCII only, not suitable for strings containing unicode characters.
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {string} String representation
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getString = function (columnIndex) {
+  return conversions.getString(getValue.call(this, columnIndex),
+  this._parameterInfo[columnIndex - 1].nativeType);
+};
+
+/**
+ * Returns the string value of an NCHAR, an NVARCHAR, or a SHORTTEXT parameter
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {string} String representation
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getNString = CallableStatement.prototype.getString;
+
+/**
+ * Returns a number value of a DECIMAL parameter
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {number} Number representation
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getDecimal = function (columnIndex) {
+  return conversions.getDecimal(getValue.call(this, columnIndex));
+};
+
+/**
+ * Returns a number value of the specified column. getReal is used for REAL column types.
+ * @param {integer} columnIndex The target column <b>starting from 1</b>
+ * @returns {number} Number representation
+ * @throws Throws an error if the index parameter is not valid.
+ */
+CallableStatement.prototype.getReal = CallableStatement.prototype.getDecimal;
+
+/**
+ * Returns a number value of the specified column. getFloat is used for FLOAT column types.
+ * @param {integer} columnIndex The target column <b>starting from 1</b>
+ * @returns {number} Number representation
+ * @throws Throws an error if the index parameter is not valid.
+ */
+CallableStatement.prototype.getFloat = CallableStatement.prototype.getDecimal;
+
+/**
+ * Returns a number value of a DOUBLE, FLOAT or REAL parameter
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {number} Number representation
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getDouble = CallableStatement.prototype.getDecimal;
+
+/**
+ * Returns the ArrayBuffer value of a BLOB specified parameter
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {ArrayBuffer} Blob representation
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getBlob = function (columnIndex) {
+  return conversions.getBlob(getValue.call(this, columnIndex),
+    this._parameterInfo[columnIndex - 1].nativeType);
+};
+
+/**
+ * Returns an ArrayBuffer object of the specified column. getBString is used for BINARY and VARBINARY column types.
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {ArrayBuffer} value ArrayBuffer object
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getBString = CallableStatement.prototype.getBlob;
+
+/**
+ * Returns the string value of a CLOB parameter
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {string} String representation
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getClob = function (columnIndex) {
+  return conversions.getClob(getValue.call(this, columnIndex),
+    this._parameterInfo[columnIndex - 1].nativeType);
+};
+
+
+/**
+ * Returns the string value of a NCLOB or TEXT parameter
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {string} String representation
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getNClob = CallableStatement.prototype.getClob;
+
+/**
+ * Returns the string value of a TEXT parameter
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {string} String representation
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getText = CallableStatement.prototype.getClob;
+
+/**
+ * Used to retrieve the value of a DATE parameter
+ * @param {integer} index The index of the parameter, <b>starting from 1</b>
+ * @returns {Date} A JavaScript date object representing the value
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getDate = function (columnIndex) {
+  return conversions.getDate(getValue.call(this, columnIndex));
+};
+
+
+/**
+ * Used to retrieve the value of a TIME parameter
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {Date} A JavaScript date object representing the value
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getTime = function (columnIndex) {
+  return conversions.getTime(getValue.call(this, columnIndex));
+};
+
+/**
+ * Used to retrieve the value of a SECONDDATE parameter
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {Date} A JavaScript date object representing the value
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getSeconddate = CallableStatement.prototype.getDate;
+
+/**
+ * Used to retrieve the value of a TIMESTAMP parameter. <br>
+ * As this type contains only time information and no date, the JavaScript's date object will always be 1 Jan 1970 plus the time offset.<br>
+ * For example: if the stored value is 10:00:00, the JavaScript date object will specify: 1 Jan 1970 10:00:00
+ *
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {Date} A JavaScript date object representing the value
+ * @throws Throws an error if the index parameter is not valid or the SQL type of the queried parameter does not match.
+ */
+CallableStatement.prototype.getTimestamp = CallableStatement.prototype.getDate;
+
+function getValue(columnIndex) {
+  if (!this._results) {
+    throw new Error('Callable statement not executed');
+  }
+  if (!_.isNumber(columnIndex)) {
+    throw new Error('Index should be a number');
+  }
+  const paramLength = this._results.parameters.length;
+  if (columnIndex < 1 || columnIndex > paramLength) {
+    throw new Error(`Index should be within 1 - ${paramLength}`);
+  }
+  return this._results.parameters[columnIndex - 1];
+}
+

package/lib/xsjs/db/dbapi/Connection.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var assert            = require('assert');
+var PreparedStatement = require('./PreparedStatement');
+var CallableStatement = require('./CallableStatement');
+
+exports = module.exports = Connection;
+
+function Connection(client) {
+  assert(typeof client === 'object', 'Valid hdb.client should be provided to create $.db.Connection');
+  this._client = client;
+}
+
+/**
+ * Prepares a statement for execution
+ * @param {string} statement The SQL statement to be prepared
+ * @returns {PreparedStatement} PreparedStatement object that represents the prepared statement
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.`
+ */
+Connection.prototype.prepareStatement = async function (statement) {
+  return new PreparedStatement(await this._client.prepare(statement));
+};
+
+/**
+ * Prepares a stored procedure for execution
+ *
+ * @example
+ * var myCallableStatement = myconnection.prepareCall("{call myprocedure(?)}");
+ *
+ * @param {string} statement The SQL statement to be prepared
+ * @returns {CallableStatement} CallableStatement The object used to represent the callable statement
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ */
+Connection.prototype.prepareCall = async function (statement) {
+  return new CallableStatement(await this._client.prepare(statement));
+};
+
+/**
+ * Changes the auto-commit flag of the connection
+ * @param {integer} enable An integer value, which can be either 0 (false) or 1 (true)
+ * @throws Throws an error if the object the method is being called on is not valid.
+ */
+Connection.prototype.setAutoCommit = function (enable) {
+  this._client.setAutoCommit(enable);
+};
+
+/**
+ * Commits the changes.
+ * @throws Throws an error if the object the method is being called on is not valid.
+ */
+Connection.prototype.commit = async function () {
+  await this._client.commit();
+};
+
+/**
+ * Rolls back the changes.
+ * @throws Throws an error if the object the method is being called on is not valid.
+ */
+Connection.prototype.rollback = async function () {
+  await this._client.rollback();
+};
+
+/**
+ * Closes the connection.
+ * @throws Throws an error if the object the method is being called on is not valid.
+ */
+Connection.prototype.close = async function () {
+  await this._client.close();
+};
+
+/**
+ * Checks if the connection is closed.
+ * @returns {boolean} Returns true if the connection is already closed, false if not
+ * @throws Throws an error if the object the method is being called on is not valid.
+ */
+Connection.prototype.isClosed = function () {
+  return this._client.state() === 'disconnected';
+};

package/lib/xsjs/db/dbapi/DB.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var util              = require('util');
+var ResultSet         = require('./ResultSet');
+var Connection        = require('./Connection');
+var ResultSetMetaData = require('./ResultSetMetaData');
+var DbBase            = require('../common/DbBase');
+
+module.exports = DB;
+
+function DB(dbReqOptions) {
+
+  DbBase.call(this, dbReqOptions);
+
+  this.ResultSet = ResultSet.prototype;
+  this.ResultSetMetaData = ResultSetMetaData.prototype;
+  this.getConnection = async function (arg, isolationLevel) {
+    var userOptions;
+    switch (typeof arg) {
+    case 'undefined':
+      userOptions = { isolationLevel: isolationLevel };
+      break;
+    case 'number':
+      userOptions = { isolationLevel: arg };
+      break;
+    case 'string':
+      userOptions = { sqlcc: arg, isolationLevel: isolationLevel };
+      break;
+    case 'object':
+      userOptions = arg || {};
+      break;
+    default:
+      throw new TypeError('Invalid parameters for "$.db.getConnection", check function signature in the documentation');
+    }
+    return new Connection(await this._getClient(userOptions));
+  };
+}
+
+util.inherits(DB, DbBase);

package/lib/xsjs/db/dbapi/ParameterMetaData.js

@@ -0,0 +1,118 @@
+'use strict';
+
+var enums = require('../common/enums');
+var TypeCode = require('@sap/hana-client/extension/TypeCode');
+var isString = require('lodash').isString;
+
+module.exports = ParameterMetaData;
+
+function ParameterMetaData(parameters) {
+  this._parameters = parameters;
+}
+
+/**
+ * Returns the number of the parameters in the prepared statement
+ * @returns {integer} The number of the parameters in the prepared statement
+ * @throws Throws an error if the object the method is being called on is not valid.
+ */
+ParameterMetaData.prototype.getParameterCount = function () {
+  return this._parameters.length;
+};
+
+/**
+ * Returns the name of the specified parameter
+ * @param {integer} columnIndex The index of the parameter in the prepared statement <b>starting from 1</b>
+ * @returns {string} The name of the specified parameter
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ */
+ParameterMetaData.prototype.getParameterName = function (columnIndex) {
+  return this._parameters[columnIndex - 1].name;
+};
+
+/**
+ * Returns the mode of the specified parameter
+ * @todo provide an enumeration
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {integer} The mode of the specified parameter
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ */
+ParameterMetaData.prototype.getParameterMode = function (columnIndex) {
+  return enums.convert.toXscParameterMode(this._parameters[columnIndex - 1].direction);
+};
+
+/**
+ * Returns the type (db.types) of the specified parameter
+ * @param {integer} columnIndex The index of the parameter in the prepared statement <b>starting from 1</b>
+ * @returns {db.types} The type
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ * @see types
+ */
+ParameterMetaData.prototype.getParameterType = function (columnIndex) {
+  return enums.convert.toXscType(this._parameters[columnIndex - 1].nativeType);
+};
+
+/**
+ * Returns the typename of the specified parameter
+ * @param {integer} columnIndex is the index of the parameter in the prepared statement <b>starting from 1</b>
+ * @returns {string} The typename of the specified parameter
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ */
+ParameterMetaData.prototype.getParameterTypeName = function (columnIndex) {
+  var nativeTypeName = this._parameters[columnIndex - 1].nativeTypeName;
+
+  if (!isString(nativeTypeName)) {
+    nativeTypeName = Object.keys(TypeCode).find(key => TypeCode[key] === nativeTypeName);
+  }
+
+  return enums.convert.toXscTypeName(nativeTypeName);
+};
+
+/**
+ * Returns the designated parameter's number of decimal digits
+ * @param {integer} columnIndex The index of the parameter in the prepared statement <b>starting from 1</b>
+ * @returns {string} The designated parameter's number of decimal digits
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ */
+ParameterMetaData.prototype.getPrecision = function (columnIndex) {
+  return this._parameters[columnIndex - 1].precision;
+};
+
+/**
+ * Returns the designated parameter's scale
+ * @param {integer} columnIndex The index of the parameter in the prepared statement <b>starting from 1</b>
+ * @returns {string} The designated parameter's scale
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ */
+ParameterMetaData.prototype.getScale = function (columnIndex) {
+  return this._parameters[columnIndex - 1].scale;
+};
+
+/**
+ * Checks if the specified parameter is nullable
+ * @param {integer} index The index of the parameter, <b>starting from 1</b>
+ * @returns {integer} 1: true, 0: false
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ */
+ParameterMetaData.prototype.isNullable = function (index) { // eslint-disable-line no-unused-vars
+  throw new Error('Not implemented yet');
+};
+
+/**
+ * Checks if the specified parameter is signed
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {integer} 1: true, 0: false
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ */
+ParameterMetaData.prototype.isSigned = function (index) { // eslint-disable-line no-unused-vars
+  throw new Error('Not implemented yet');
+};
+
+/**
+ * Checks if the specified parameter has a default value
+ * @param {integer} index The index of the parameter <b>starting from 1</b>
+ * @returns {integer} 1: true, 0: false
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ */
+ParameterMetaData.prototype.hasDefault = function (index) { // eslint-disable-line no-unused-vars
+  throw new Error('Not implemented yet');
+};

package/lib/xsjs/db/dbapi/PreparedStatement.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var util = require('util');
+var Statement = require('./Statement');
+var ResultSetMetaData = require('./ResultSetMetaData');
+var executeBatchPromise = require('../common/execute-batch').executeBatchPromise;
+
+module.exports = PreparedStatement;
+
+util.inherits(PreparedStatement, Statement);
+
+function PreparedStatement(statement) {
+  Statement.call(this, statement);
+  this._batchParameters = [];
+}
+
+/**
+ * Executes an SQL statement
+ * @returns {db.ResultSet} ResultSet Holds the result of the executed SQL statement
+ * @throws Throws an error if the object the method is being called on is not valid.
+ */
+PreparedStatement.prototype.executeQuery = async function () {
+  await this.execute();
+  return this.getResultSet();
+};
+
+/**
+ * Executes an update statement
+ * @returns {integer} The number of changed rows resulting from the update statement
+ * @throws Throws an error if the object the method is being called on is not valid.
+ */
+PreparedStatement.prototype.executeUpdate = async function () {
+  await this.execute();
+  return this._results.rowsAffected;
+};
+
+
+/**
+ * Reserves space for batch insertion
+ * @param {integer} size The number (count) of batch insertions that will be performed
+ * @throws Throws an error on invalid parameters or if the object the method is being called on is not valid.
+ */
+PreparedStatement.prototype.setBatchSize = function (size) { // eslint-disable-line no-unused-vars
+
+};
+
+
+/**
+ * Adds last parameter values and iterates to the next batch slot
+ * @throws Throws an error if the statement if setBatchSize has not been called successfully or if the object the method is being called on is not valid.
+ */
+PreparedStatement.prototype.addBatch = function () {
+  this._batchParameters.push(this._parameters);
+  this._parameters = [];
+};
+
+
+/**
+ * Executes a batch insertion. Use setBatchSize and addBatch to prepare for batch execution.
+ * @returns {array} Array with integers representing the number of updated rows per batch
+ * @throws Throws an error if the object the method is being called on is not valid.
+ */
+PreparedStatement.prototype.executeBatch = async function () {
+  var result = await executeBatchPromise.call(null, this._statement, this._batchParameters);
+  this._batchParameters = [];
+  return result;
+};
+
+
+/**
+ * Returns the metadata of the ResultSet
+ * @returns {db.ResultSetMetaData} ResultSetMetaData object
+ * @deprecated Use getMetaData on ResultSet.
+ * @see ResultSet#getMetaData
+ */
+PreparedStatement.prototype.getMetaData = function () {
+  return new ResultSetMetaData(this._statement.getColumnInfo());
+};