tedious 11.5.0 → 11.8.0

package/benchmarks/bulk-load/iterable.js

@@ -0,0 +1,61 @@
+// @ts-check
+
+const { createBenchmark, createConnection } = require('../common');
+
+const { Request, TYPES } = require('../../src/tedious');
+
+const bench = createBenchmark(main, {
+  n: [10, 100],
+  size: [
+    10,
+    100,
+    1000,
+    10000
+  ]
+});
+
+function main({ n, size }) {
+  createConnection((connection) => {
+    const request = new Request(`
+      CREATE TABLE "#tmpTestTable" (
+        "id" int NOT NULL
+      )
+    `, (err) => {
+      if (err) {
+        throw err;
+      }
+
+      let i = 0;
+
+      bench.start();
+
+      (function cb() {
+        const bulkLoad = connection.newBulkLoad('#tmpTestTable', (err) => {
+          if (err) {
+            throw err;
+          }
+
+          if (i++ === n) {
+            bench.end(n);
+
+            connection.close();
+
+            return;
+          }
+
+          cb();
+        });
+
+        bulkLoad.addColumn('id', TYPES.Int, { nullable: false });
+
+        const rows = [];
+        for (let j = 0; j < size; j++) {
+          rows.push([ j ]);
+        }
+        connection.execBulkLoad(bulkLoad, rows);
+      })();
+    });
+
+    connection.execSqlBatch(request);
+  });
+}

package/lib/bulk-load.js

@@ -54,7 +54,12 @@ const DONE_STATUS = {
  * @private
  */
 
-const rowTokenBuffer = Buffer.from([_token.TYPE.ROW]); // A transform that converts rows to packets.
+const rowTokenBuffer = Buffer.from([_token.TYPE.ROW]);
+const textPointerAndTimestampBuffer = Buffer.from([// TextPointer length
+0x10, // TextPointer
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Timestamp
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+const textPointerNullBuffer = Buffer.from([0x00]); // A transform that converts rows to packets.
 
 class RowTransform extends _stream.Transform {
   /**
@@ -120,6 +125,16 @@ class RowTransform extends _stream.Transform {
         precision: c.precision,
         value: value
       };
+
+      if (c.type.name === 'Text' || c.type.name === 'Image' || c.type.name === 'NText') {
+        if (value == null) {
+          this.push(textPointerNullBuffer);
+          continue;
+        }
+
+        this.push(textPointerAndTimestampBuffer);
+      }
+
       this.push(c.type.generateParameterLength(parameter, this.mainOptions));
 
       for (const chunk of c.type.generateParameterData(parameter, this.mainOptions)) {
@@ -160,12 +175,11 @@ class RowTransform extends _stream.Transform {
  * bulkLoad.addColumn('myInt', TYPES.Int, { nullable: false });
  * bulkLoad.addColumn('myString', TYPES.NVarChar, { length: 50, nullable: true });
  *
- * // add rows
- * bulkLoad.addRow({ myInt: 7, myString: 'hello' });
- * bulkLoad.addRow({ myInt: 23, myString: 'world' });
- *
  * // execute
- * connection.execBulkLoad(bulkLoad);
+ * connection.execBulkLoad(bulkLoad, [
+ *   { myInt: 7, myString: 'hello' },
+ *   { myInt: 23, myString: 'world' }
+ * ]);
  * ```
  */
 
@@ -325,10 +339,10 @@ class BulkLoad extends _events.EventEmitter {
    *
    * @param name The name of the column.
    * @param type One of the supported `data types`.
-   * @param __namedParameters Type [[ColumnOptions]]<p> Additional column type information. At a minimum, `nullable` must be set to true or false.
+   * @param __namedParameters Additional column type information. At a minimum, `nullable` must be set to true or false.
    * @param length For VarChar, NVarChar, VarBinary. Use length as `Infinity` for VarChar(max), NVarChar(max) and VarBinary(max).
    * @param nullable Indicates whether the column accepts NULL values.
-   * @param objName  If the name of the column is different from the name of the property found on `rowObj` arguments passed to [[addRow]], then you can use this option to specify the property name.
+   * @param objName If the name of the column is different from the name of the property found on `rowObj` arguments passed to [[addRow]] or [[Connection.execBulkLoad]], then you can use this option to specify the property name.
    * @param precision For Numeric, Decimal.
    * @param scale For Numeric, Decimal, Time, DateTime2, DateTimeOffset.
   */
@@ -380,27 +394,16 @@ class BulkLoad extends _events.EventEmitter {
     this.columnsByName[name] = column;
   }
   /**
-   * Adds a row to the bulk insert. This method accepts arguments in three different formats:
+   * Adds a row to the bulk insert.
    *
    * ```js
-   * bulkLoad.addRow( rowObj )
-   * bulkLoad.addRow( columnArray )
-   * bulkLoad.addRow( col0, col1, ... colN )`
+   * bulkLoad.addRow({ first_name: 'Bill', last_name: 'Gates' });
    * ```
-   * * `rowObj`
-   *
-   *    An object of key/value pairs representing column name (or objName) and value.
    *
-   * * `columnArray`
+   * @param row An object of key/value pairs representing column name (or objName) and value.
    *
-   *    An array representing the values of each column in the same order which they were added to the bulkLoad object.
-   *
-   * * `col0, col1, ... colN`
-   *
-   *    If there are at least two columns, values can be passed as multiple arguments instead of an array. They
-   *    must be in the same order the columns were added in.
-   *
-   * @param input
+   * @deprecated This method is deprecated. Instead of adding rows individually, you should pass
+   *   all row objects when calling [[Connection.execBulkLoad]]. This method will be removed in the future.
    */
 
 
@@ -566,7 +569,12 @@ class BulkLoad extends _events.EventEmitter {
 
       tBuf.writeUInt16LE(flags); // TYPE_INFO
 
-      tBuf.writeBuffer(c.type.generateTypeInfo(c, this.options)); // ColName
+      tBuf.writeBuffer(c.type.generateTypeInfo(c, this.options)); // TableName
+
+      if (c.type.hasTableName) {
+        tBuf.writeUsVarchar(this.table, 'ucs2');
+      } // ColName
+
 
       tBuf.writeBVarchar(c.name, 'ucs2');
     }
@@ -629,6 +637,11 @@ class BulkLoad extends _events.EventEmitter {
    *
    * After that, the stream emits a ['drain' event](https://nodejs.org/dist/latest-v10.x/docs/api/stream.html#stream_event_drain)
    * when it is ready to resume data transfer.
+   *
+   * @deprecated
+   *   This method is deprecated. Instead of writing rows to the stream returned by this method,
+   *   you can pass any object that implements the `Iterable` or `AsyncIterable` interface (e.g. a `Readable`
+   *   stream or an `AsyncGenerator`) when calling [[Connection.execBulkLoad]]. This method will be removed in the future.
    */
 
 

package/lib/collation.js

@@ -6,10 +6,157 @@ Object.defineProperty(exports, "__esModule", {
 exports.codepageBySortId = exports.codepageByLcid = void 0;
 // http://technet.microsoft.com/en-us/library/aa176553(v=sql.80).aspx
 const codepageByLcid = {
-  [0x436]: 'CP1252',
-  [0x401]: 'CP1256',
-  [0x801]: 'CP1256',
-  [0xC01]: 'CP1256',
+  // Arabic_*
+  [0x0401]: 'CP1256',
+  // Chinese_Taiwan_Stroke_*
+  // Chinese_Traditional_Stroke_Count_*
+  [0x0404]: 'CP950',
+  // Czech_*
+  [0x0405]: 'CP1250',
+  // Danish_Greenlandic_*
+  // Danish_Norwegian_*
+  [0x0406]: 'CP1252',
+  // Greek_*
+  [0x0408]: 'CP1253',
+  // Latin1_General_*
+  [0x0409]: 'CP1252',
+  // Traditional_Spanish_*
+  [0x040A]: 'CP1252',
+  // Finnish_Swedish_*
+  [0x040B]: 'CP1252',
+  // French_*
+  [0x040C]: 'CP1252',
+  // Hebrew_*
+  [0x040D]: 'CP1255',
+  // Hungarian_*
+  [0x040E]: 'CP1250',
+  // Icelandic_*
+  [0x040F]: 'CP1252',
+  // Japanese_*
+  // Japanese_XJIS_*
+  [0x0411]: 'CP932',
+  // Korean_*
+  // Korean_Wansung_*
+  [0x0412]: 'CP949',
+  // Norwegian_*
+  [0x0414]: 'CP1252',
+  // Polish_*
+  [0x0415]: 'CP1250',
+  // Romansh_*
+  [0x0417]: 'CP1252',
+  // Romanian_*
+  [0x0418]: 'CP1250',
+  // Cyrillic_*
+  [0x0419]: 'CP1251',
+  // Croatian_*
+  [0x041A]: 'CP1250',
+  // Slovak_*
+  [0x041B]: 'CP1250',
+  // Albanian_*
+  [0x041C]: 'CP1250',
+  // Thai_*
+  [0x041E]: 'CP874',
+  // Turkish_*
+  [0x041F]: 'CP1254',
+  // Urdu_*
+  [0x0420]: 'CP1256',
+  // Ukrainian_*
+  [0x0422]: 'CP1251',
+  // Slovenian_*
+  [0x0424]: 'CP1250',
+  // Estonian_*
+  [0x0425]: 'CP1257',
+  // Latvian_BIN
+  [0x0426]: 'CP1257',
+  // Lithuanian_BIN
+  [0x0427]: 'CP1257',
+  // Persian_100_BIN
+  [0x0429]: 'CP1256',
+  // Vietnamese_BIN
+  [0x042A]: 'CP1258',
+  // Azeri_Latin_100_BIN
+  [0x042C]: 'CP1254',
+  // Upper_Sorbian_100_BIN
+  [0x042E]: 'CP1252',
+  // Macedonian_FYROM_90_BIN
+  [0x042F]: 'CP1251',
+  // Sami_Norway_100_BIN
+  [0x043B]: 'CP1252',
+  // Kazakh_90_BIN
+  [0x043F]: 'CP1251',
+  // Turkmen_100_BIN
+  [0x0442]: 'CP1250',
+  // Uzbek_Latin_90_BIN
+  [0x0443]: 'CP1254',
+  // Tatar_90_BIN
+  [0x0444]: 'CP1251',
+  // Welsh_100_BIN
+  [0x0452]: 'CP1252',
+  // Frisian_100_BIN
+  [0x0462]: 'CP1252',
+  // Bashkir_100_BIN
+  [0x046D]: 'CP1251',
+  // Mapudungan_100_BIN
+  [0x047A]: 'CP1252',
+  // Mohawk_100_BIN
+  [0x047C]: 'CP1252',
+  // Breton_100_BIN
+  [0x047E]: 'CP1252',
+  // Uighur_100_BIN
+  [0x0480]: 'CP1256',
+  // Corsican_100_BIN
+  [0x0483]: 'CP1252',
+  // Yakut_100_BIN
+  [0x0485]: 'CP1251',
+  // Dari_100_BIN
+  [0x048C]: 'CP1256',
+  // Chinese_PRC_BIN
+  // Chinese_Simplified_Pinyin_100_BIN
+  [0x0804]: 'CP936',
+  // Serbian_Latin_100_BIN
+  [0x081A]: 'CP1250',
+  // Azeri_Cyrillic_100_BIN
+  [0x082C]: 'CP1251',
+  // Sami_Sweden_Finland_100_BIN
+  [0x083B]: 'CP1252',
+  // Tamazight_100_BIN
+  [0x085F]: 'CP1252',
+  // Chinese_Hong_Kong_Stroke_90_BIN
+  [0x0C04]: 'CP950',
+  // Modern_Spanish_BIN
+  [0x0C0A]: 'CP1252',
+  // Serbian_Cyrillic_100_BIN
+  [0x0C1A]: 'CP1251',
+  // Chinese_Traditional_Pinyin_100_BIN
+  [0x1404]: 'CP950',
+  // Bosnian_Latin_100_BIN
+  [0x141A]: 'CP1250',
+  // Bosnian_Cyrillic_100_BIN
+  [0x201A]: 'CP1251',
+  // German
+  [0x0407]: 'CP1252',
+  // German_PhoneBook_BIN
+  [0x10407]: 'CP1252',
+  // Hungarian_Technical_BIN
+  [0x1040E]: 'CP1250',
+  // Japanese_Unicode_BIN
+  [0x10411]: 'CP932',
+  // Georgian_Modern_Sort_BIN
+  [0x10437]: 'CP1252',
+  // Chinese_PRC_Stroke_BIN
+  // Chinese_Simplified_Stroke_Order_100_BIN
+  [0x20804]: 'CP936',
+  // Chinese_Traditional_Stroke_Order_100_BIN
+  [0x21404]: 'CP950',
+  // Chinese_Taiwan_Bopomofo_BIN
+  // Chinese_Traditional_Bopomofo_100_BIN
+  [0x30404]: 'CP950',
+  // Japanese_Bushu_Kakusu_100_BIN
+  [0x40411]: 'CP932',
+  // These LCIDs might not actually be supported by SQL Server
+  [0x0436]: 'CP1252',
+  [0x0801]: 'CP1256',
+  [0x0C01]: 'CP1256',
   [0x1001]: 'CP1256',
   [0x1401]: 'CP1256',
   [0x1801]: 'CP1256',
@@ -27,17 +174,9 @@ const codepageByLcid = {
   [0x423]: 'CP1251',
   [0x402]: 'CP1251',
   [0x403]: 'CP1252',
-  [0x30404]: 'CP950',
-  [0x404]: 'CP950',
-  [0x804]: 'CP936',
-  [0x20804]: 'CP936',
   [0x1004]: 'CP936',
-  [0x41a]: 'CP1250',
-  [0x405]: 'CP1250',
-  [0x406]: 'CP1252',
   [0x413]: 'CP1252',
   [0x813]: 'CP1252',
-  [0x409]: 'CP1252',
   [0x809]: 'CP1252',
   [0x1009]: 'CP1252',
   [0x1409]: 'CP1252',
@@ -46,52 +185,25 @@ const codepageByLcid = {
   [0x1C09]: 'CP1252',
   [0x2409]: 'CP1252',
   [0x2009]: 'CP1252',
-  [0x425]: 'CP1257',
   [0x0438]: 'CP1252',
-  [0x429]: 'CP1256',
-  [0x40B]: 'CP1252',
-  [0x40C]: 'CP1252',
   [0x80C]: 'CP1252',
   [0x100C]: 'CP1252',
   [0xC0C]: 'CP1252',
   [0x140C]: 'CP1252',
-  [0x10437]: 'CP1252',
-  [0x10407]: 'CP1252',
-  [0x407]: 'CP1252',
   [0x807]: 'CP1252',
   [0xC07]: 'CP1252',
   [0x1007]: 'CP1252',
   [0x1407]: 'CP1252',
-  [0x408]: 'CP1253',
-  [0x40D]: 'CP1255',
   [0x439]: 'CPUTF8',
-  [0x40E]: 'CP1250',
   [0x104E]: 'CP1250',
-  [0x40F]: 'CP1252',
   [0x421]: 'CP1252',
   [0x410]: 'CP1252',
   [0x810]: 'CP1252',
-  [0x411]: 'CP932',
-  [0x10411]: 'CP932',
-  [0x412]: 'CP949',
-  [0x426]: 'CP1257',
-  [0x427]: 'CP1257',
   [0x827]: 'CP1257',
-  [0x41C]: 'CP1251',
-  [0x414]: 'CP1252',
   [0x814]: 'CP1252',
-  [0x415]: 'CP1250',
   [0x816]: 'CP1252',
   [0x416]: 'CP1252',
-  [0x418]: 'CP1250',
-  [0x419]: 'CP1251',
-  [0x81A]: 'CP1251',
-  [0xC1A]: 'CP1251',
-  [0x41B]: 'CP1250',
-  [0x424]: 'CP1250',
   [0x80A]: 'CP1252',
-  [0x40A]: 'CP1252',
-  [0xC0A]: 'CP1252',
   [0x100A]: 'CP1252',
   [0x140A]: 'CP1252',
   [0x180A]: 'CP1252',
@@ -105,12 +217,7 @@ const codepageByLcid = {
   [0x380A]: 'CP1252',
   [0x3C0A]: 'CP1252',
   [0x400A]: 'CP1252',
-  [0x41D]: 'CP1252',
-  [0x41E]: 'CP874',
-  [0x41F]: 'CP1254',
-  [0x422]: 'CP1251',
-  [0x420]: 'CP1256',
-  [0x42A]: 'CP1258'
+  [0x41D]: 'CP1252'
 };
 exports.codepageByLcid = codepageByLcid;
 const codepageBySortId = {

package/lib/connection.js

@@ -109,7 +109,7 @@ const DEFAULT_PACKET_SIZE = 4 * 1024;
  * @private
  */
 
-const DEFAULT_TEXTSIZE = '2147483647';
+const DEFAULT_TEXTSIZE = 2147483647;
 /**
  * @private
  */
@@ -930,7 +930,13 @@ class Connection extends _events.EventEmitter {
           throw new TypeError('The "config.options.textsize" property must be of type number or null.');
         }
 
-        this.config.options.textsize = config.options.textsize;
+        if (config.options.textsize > 2147483647) {
+          throw new TypeError('The "config.options.textsize" can\'t be greater than 2147483647.');
+        } else if (config.options.textsize < -1) {
+          throw new TypeError('The "config.options.textsize" can\'t be smaller than -1.');
+        }
+
+        this.config.options.textsize = config.options.textsize | 0;
       }
 
       if (config.options.trustServerCertificate !== undefined) {
@@ -2053,16 +2059,69 @@ class Connection extends _events.EventEmitter {
     return new _bulkLoad.default(table, this.config.options, options, callback);
   }
   /**
-   * Executes a [[BulkLoad]].
+   * Execute a [[BulkLoad]].
+   *
+   * ```js
+   * // We want to perform a bulk load into a table with the following format:
+   * // CREATE TABLE employees (first_name nvarchar(255), last_name nvarchar(255), day_of_birth date);
+   *
+   * const bulkLoad = connection.newBulkLoad('employees', (err, rowCount) => {
+   *   // ...
+   * });
+   *
+   * // First, we need to specify the columns that we want to write to,
+   * // and their definitions. These definitions must match the actual table,
+   * // otherwise the bulk load will fail.
+   * bulkLoad.addColumn('first_name', TYPES.NVarchar, { nullable: false });
+   * bulkLoad.addColumn('last_name', TYPES.NVarchar, { nullable: false });
+   * bulkLoad.addColumn('date_of_birth', TYPES.Date, { nullable: false });
+   *
+   * // Now, we can specify each row to be written.
+   * //
+   * // Note that these rows are held in memory until the
+   * // bulk load was performed, so if you need to write a large
+   * // number of rows (e.g. by reading from a CSV file),
+   * // using a streaming bulk load is advisable to keep memory usage low.
+   * bulkLoad.addRow({ 'first_name': 'Steve', 'last_name': 'Jobs', 'day_of_birth': new Date('02-24-1955') });
+   * bulkLoad.addRow({ 'first_name': 'Bill', 'last_name': 'Gates', 'day_of_birth': new Date('10-28-1955') });
+   *
+   * connection.execBulkLoad(bulkLoad);
+   * ```
    *
-   * @param bulkLoad
+   * @param bulkLoad A previously created [[BulkLoad]].
+   *
+   * @deprecated Adding rows to a [[BulkLoad]] via [[BulkLoad.addRow]] or [[BulkLoad.getRowStream]]
+   *   is deprecated and will be removed in the future. You should migrate to calling [[Connection.execBulkLoad]]
+   *   with a `Iterable` or `AsyncIterable` as the second argument instead.
    */
 
 
-  execBulkLoad(bulkLoad) {
+  execBulkLoad(bulkLoad, rows) {
     bulkLoad.executionStarted = true;
 
-    if (!bulkLoad.streamingMode) {
+    if (rows) {
+      if (bulkLoad.streamingMode) {
+        throw new Error("Connection.execBulkLoad can't be called with a BulkLoad that was put in streaming mode.");
+      }
+
+      if (bulkLoad.firstRowWritten) {
+        throw new Error("Connection.execBulkLoad can't be called with a BulkLoad that already has rows written to it.");
+      }
+
+      const rowStream = _stream.Readable.from(rows); // Destroy the packet transform if an error happens in the row stream,
+      // e.g. if an error is thrown from within a generator or stream.
+
+
+      rowStream.on('error', err => {
+        bulkLoad.rowToPacketTransform.destroy(err);
+      }); // Destroy the row stream if an error happens in the packet transform,
+      // e.g. if the bulk load is cancelled.
+
+      bulkLoad.rowToPacketTransform.on('error', err => {
+        rowStream.destroy(err);
+      });
+      rowStream.pipe(bulkLoad.rowToPacketTransform);
+    } else if (!bulkLoad.streamingMode) {
       // If the bulkload was not put into streaming mode by the user,
       // we end the rowToPacketTransform here for them.
       //
@@ -2501,6 +2560,7 @@ class Connection extends _events.EventEmitter {
         payloadStream.unpipe(message); // Only set a request error if no error was set yet.
 
         (_request$error = request.error) !== null && _request$error !== void 0 ? _request$error : request.error = error;
+        payloadStream.unpipe(message);
         message.ignore = true;
         message.end();
       });

package/lib/data-types/image.js

@@ -36,7 +36,7 @@ const Image = {
     }
 
     const buffer = Buffer.alloc(4);
-    buffer.writeInt32LE(parameter.length, 0);
+    buffer.writeInt32LE(parameter.value.length, 0);
     return buffer;
   },
 

package/lib/data-types/ntext.js

@@ -4,32 +4,65 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+const NULL_LENGTH = Buffer.from([0xFF, 0xFF, 0xFF, 0xFF]);
 const NText = {
   id: 0x63,
   type: 'NTEXT',
   name: 'NText',
   hasTableName: true,
+  declaration: function () {
+    return 'ntext';
+  },
+  resolveLength: function (parameter) {
+    const value = parameter.value; // Temporary solution. Remove 'any' later.
 
-  declaration() {
-    throw new Error('not implemented');
+    if (value != null) {
+      return value.length;
+    } else {
+      return -1;
+    }
   },
 
-  generateTypeInfo() {
-    throw new Error('not implemented');
+  generateTypeInfo(parameter, _options) {
+    const buffer = Buffer.alloc(10);
+    buffer.writeUInt8(this.id, 0);
+    buffer.writeInt32LE(parameter.length, 1); // TODO: Collation handling
+
+    return buffer;
   },
 
-  generateParameterLength() {
-    throw new Error('not implemented');
+  generateParameterLength(parameter, options) {
+    if (parameter.value == null) {
+      return NULL_LENGTH;
+    }
+
+    const buffer = Buffer.alloc(4);
+    buffer.writeInt32LE(Buffer.byteLength(parameter.value, 'ucs2'), 0);
+    return buffer;
   },
 
-  generateParameterData() {
-    throw new Error('not implemented');
+  generateParameterData: function* (parameter, options) {
+    if (parameter.value == null) {
+      return;
+    }
+
+    yield Buffer.from(parameter.value.toString(), 'ucs2');
   },
+  validate: function (value) {
+    if (value == null) {
+      return null;
+    }
 
-  validate() {
-    throw new Error('not implemented');
-  }
+    if (typeof value !== 'string') {
+      if (typeof value.toString !== 'function') {
+        throw new TypeError('Invalid string.');
+      }
+
+      value = value.toString();
+    }
 
+    return value;
+  }
 };
 var _default = NText;
 exports.default = _default;

package/lib/data-types/text.js

@@ -37,7 +37,7 @@ const Text = {
     }
 
     const buffer = Buffer.alloc(4);
-    buffer.writeInt32LE(parameter.length, 0);
+    buffer.writeInt32LE(parameter.value.length, 0);
     return buffer;
   },
 

package/package.json

@@ -27,7 +27,7 @@
   "homepage": "https://github.com/tediousjs/tedious",
   "bugs": "https://github.com/tediousjs/tedious/issues",
   "license": "MIT",
-  "version": "11.5.0",
+  "version": "11.8.0",
   "main": "./lib/tedious.js",
   "repository": {
     "type": "git",