plugin-data-source-mssql 2.0.0 → 2.0.1

package/dist/node_modules/tedious/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010-2018 Mike D Pilsbury
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/node_modules/tedious/appveyor.yml

@@ -0,0 +1,67 @@
+version: "{build}"
+
+environment:
+  matrix:
+    - nodejs_version: "18"
+    - nodejs_version: "20"
+    - nodejs_version: "21"
+
+branches:
+  only:
+    - master
+    - /^maint\/.+/
+    - /v\d+\.\d+\.\d+/
+
+install:
+  - ps: Update-NodeJsInstallation (Get-NodeJsLatestBuild $env:nodejs_version)
+  - npm install
+
+services:
+  - mssql2017
+
+cache:
+  - node_modules
+
+build: off
+
+before_test:
+  - npm prune
+
+  - sc config sqlbrowser start= auto
+  - net start sqlbrowser
+
+test_script:
+  - node --version
+  - npm --version
+
+  - pwsh: |-
+      $ErrorActionPreference = "Stop"
+
+      npm run-script test
+      if ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }
+
+      Copy-Item -Force test/config.appveyor.ts test/config.ts
+
+      $env:NTLM_USERNAME = $env:USERNAME
+      $env:NTLM_PASSWORD = [Microsoft.Win32.Registry]::GetValue("HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Winlogon", "DefaultPassword", '')
+      $env:NTLM_DOMAIN = $env:COMPUTERNAME
+
+      $env:TEDIOUS_TDS_VERSION = '7_4'
+      npm run-script test-integration
+      if ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }
+
+      $env:TEDIOUS_TDS_VERSION = '7_3_B'
+      npm run-script test-integration
+      if ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }
+
+      $env:TEDIOUS_TDS_VERSION = '7_3_A'
+      npm run-script test-integration
+      if ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }
+
+      $env:TEDIOUS_TDS_VERSION = '7_2'
+      npm run-script test-integration
+      if ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }
+
+      $env:TEDIOUS_TDS_VERSION = '7_1'
+      npm run-script test-integration
+      if ($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode) }

package/dist/node_modules/tedious/benchmarks/bulk-load/iterable.js

@@ -0,0 +1,61 @@
+// @ts-check
+
+const { createBenchmark, createConnection } = require('../common');
+
+const { Request, TYPES } = require('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/dist/node_modules/tedious/benchmarks/common.js

@@ -0,0 +1,287 @@
+'use strict';
+
+const fs = require('fs');
+const child_process = require('child_process');
+
+const {
+  PerformanceObserver,
+  constants: {
+    NODE_PERFORMANCE_GC_INCREMENTAL,
+    NODE_PERFORMANCE_GC_MAJOR,
+    NODE_PERFORMANCE_GC_MINOR
+  }
+} = require('perf_hooks');
+
+const { Connection } = require('tedious');
+
+// The `Benchmark` class is taken from Node.js - see
+// https://github.com/nodejs/node/blob/0f96dc266fd0cd8c1baa82ce7eb951c11b29a331/benchmark/common.js
+// Copyright Node.js contributors. All rights reserved.
+function Benchmark(fn, configs, options) {
+  // Use the file name as the name of the benchmark
+  this.name = require.main.filename.slice(__dirname.length + 1);
+  // Parse job-specific configuration from the command line arguments
+  const parsed_args = this._parseArgs(process.argv.slice(2), configs);
+  this.options = parsed_args.cli;
+  this.extra_options = parsed_args.extra;
+  // The configuration list as a queue of jobs
+  this.queue = this._queue(this.options);
+  // The configuration of the current job, head of the queue
+  this.config = this.queue[0];
+  // Execution arguments i.e. flags used to run the jobs
+  this.flags = [];
+  if (options && options.flags) {
+    this.flags = this.flags.concat(options.flags);
+  }
+  if (process.env.NODE_BENCHMARK_FLAGS) {
+    const flags = process.env.NODE_BENCHMARK_FLAGS.split(/\s+/);
+    this.flags = this.flags.concat(flags);
+  }
+  // Holds process.hrtime value
+  this._time = [0, 0];
+  // Used to make sure a benchmark only start a timer once
+  this._started = false;
+
+  this._gcStats = {
+    [NODE_PERFORMANCE_GC_INCREMENTAL]: {
+      count: 0,
+      totalDuration: 0
+    },
+    [NODE_PERFORMANCE_GC_MINOR]: {
+      count: 0,
+      totalDuration: 0
+    },
+    [NODE_PERFORMANCE_GC_MAJOR]: {
+      count: 0,
+      totalDuration: 0
+    }
+  };
+
+  this._observer = new PerformanceObserver((list) => {
+    const entries = list.getEntries();
+    const length = entries.length;
+
+    for (let i = 0; i < length; i++) {
+      const entry = entries[i];
+      const stats = this._gcStats[entry.detail.kind];
+
+      if (stats) {
+        stats.count += 1;
+        stats.totalDuration += entry.duration;
+      }
+    }
+  });
+
+  // this._run will use fork() to create a new process for each configuration
+  // combination.
+  if (process.env.hasOwnProperty('NODE_RUN_BENCHMARK_FN')) {
+    process.nextTick(() => fn(this.config));
+  } else {
+    process.nextTick(() => this._run());
+  }
+}
+
+Benchmark.prototype._parseArgs = function(argv, configs) {
+  const cliOptions = {};
+  const extraOptions = {};
+  const validArgRE = /^(.+?)=([\s\S]*)$/;
+  // Parse configuration arguments
+  for (const arg of argv) {
+    const match = arg.match(validArgRE);
+    if (!match) {
+      console.error(`bad argument: ${arg}`);
+      process.exit(1);
+    }
+    const config = match[1];
+
+    if (configs[config]) {
+      // Infer the type from the config object and parse accordingly
+      const isNumber = typeof configs[config][0] === 'number';
+      const value = isNumber ? +match[2] : match[2];
+      if (!cliOptions[config])
+        cliOptions[config] = [];
+      cliOptions[config].push(value);
+    } else {
+      extraOptions[config] = match[2];
+    }
+  }
+  return { cli: Object.assign({}, configs, cliOptions), extra: extraOptions };
+};
+
+Benchmark.prototype._queue = function(options) {
+  const queue = [];
+  const keys = Object.keys(options);
+
+  // Perform a depth-first walk though all options to generate a
+  // configuration list that contains all combinations.
+  function recursive(keyIndex, prevConfig) {
+    const key = keys[keyIndex];
+    const values = options[key];
+    const type = typeof values[0];
+
+    for (const value of values) {
+      if (typeof value !== 'number' && typeof value !== 'string') {
+        throw new TypeError(`configuration "${key}" had type ${typeof value}`);
+      }
+      if (typeof value !== type) {
+        // This is a requirement for being able to consistently and predictably
+        // parse CLI provided configuration values.
+        throw new TypeError(`configuration "${key}" has mixed types`);
+      }
+
+      const currConfig = Object.assign({ [key]: value }, prevConfig);
+
+      if (keyIndex + 1 < keys.length) {
+        recursive(keyIndex + 1, currConfig);
+      } else {
+        queue.push(currConfig);
+      }
+    }
+  }
+
+  if (keys.length > 0) {
+    recursive(0, {});
+  } else {
+    queue.push({});
+  }
+
+  return queue;
+};
+
+Benchmark.prototype._run = function() {
+  const self = this;
+  // If forked, report to the parent.
+  if (process.send) {
+    process.send({
+      type: 'config',
+      name: this.name,
+      queueLength: this.queue.length,
+    });
+  }
+
+  (function recursive(queueIndex) {
+    const config = self.queue[queueIndex];
+
+    // Set NODE_RUN_BENCHMARK_FN to indicate that the child shouldn't construct
+    // a configuration queue, but just execute the benchmark function.
+    const childEnv = Object.assign({}, process.env);
+    childEnv.NODE_RUN_BENCHMARK_FN = '';
+
+    // Create configuration arguments
+    const childArgs = [];
+    for (const key of Object.keys(config)) {
+      childArgs.push(`${key}=${config[key]}`);
+    }
+    for (const key of Object.keys(self.extra_options)) {
+      childArgs.push(`${key}=${self.extra_options[key]}`);
+    }
+
+    const child = child_process.fork(require.main.filename, childArgs, {
+      env: childEnv,
+      execArgv: self.flags.concat(process.execArgv),
+    });
+    child.on('message', sendResult);
+    child.on('close', (code) => {
+      if (code) {
+        process.exit(code);
+      }
+
+      if (queueIndex + 1 < self.queue.length) {
+        recursive(queueIndex + 1);
+      }
+    });
+  })(0);
+};
+
+Benchmark.prototype.start = function() {
+  if (this._started) {
+    throw new Error('Called start more than once in a single benchmark');
+  }
+  this._started = true;
+  this._observer.observe({ entryTypes: ['gc'], buffered: false });
+
+  this._time = process.hrtime();
+};
+
+Benchmark.prototype.end = function(operations) {
+  // Get elapsed time now and do error checking later for accuracy.
+  const elapsed = process.hrtime(this._time);
+
+  if (!this._started) {
+    throw new Error('called end without start');
+  }
+  if (typeof operations !== 'number') {
+    throw new Error('called end() without specifying operation count');
+  }
+  if (!process.env.NODEJS_BENCHMARK_ZERO_ALLOWED && operations <= 0) {
+    throw new Error('called end() with operation count <= 0');
+  }
+  if (elapsed[0] === 0 && elapsed[1] === 0) {
+    if (!process.env.NODEJS_BENCHMARK_ZERO_ALLOWED)
+      throw new Error('insufficient clock precision for short benchmark');
+    // Avoid dividing by zero
+    elapsed[1] = 1;
+  }
+
+  this._observer.disconnect();
+
+  const time = elapsed[0] + elapsed[1] / 1e9;
+  const rate = operations / time;
+  this.report(rate, elapsed);
+};
+
+function formatResult(data) {
+  // Construct configuration string, " A=a, B=b, ..."
+  let conf = '';
+  for (const key of Object.keys(data.conf)) {
+    conf += ` ${key}=${JSON.stringify(data.conf[key])}`;
+  }
+
+  var rate = data.rate.toString().split('.');
+  rate[0] = rate[0].replace(/(\d)(?=(?:\d\d\d)+(?!\d))/g, '$1,');
+  rate = (rate[1] ? rate.join('.') : rate[0]);
+
+  var gcInfo;
+  gcInfo = `(minor: ${data.gcStats[NODE_PERFORMANCE_GC_MINOR].count} - ${data.gcStats[NODE_PERFORMANCE_GC_MINOR].totalDuration}ms,`;
+  gcInfo += ` major: ${data.gcStats[NODE_PERFORMANCE_GC_MAJOR].count} - ${data.gcStats[NODE_PERFORMANCE_GC_MAJOR].totalDuration}ms,`;
+  gcInfo += ` incremental: ${data.gcStats[NODE_PERFORMANCE_GC_INCREMENTAL].count} - ${data.gcStats[NODE_PERFORMANCE_GC_INCREMENTAL].totalDuration}ms)`;
+
+  return `${data.name}${conf}: ${rate} ${gcInfo}`;
+}
+
+function sendResult(data) {
+  if (process.send) {
+    // If forked, report by process send
+    process.send(data);
+  } else {
+    // Otherwise report by stdout
+    console.log(formatResult(data));
+  }
+}
+
+Benchmark.prototype.report = function(rate, elapsed) {
+  sendResult({
+    name: this.name,
+    conf: this.config,
+    rate: rate,
+    time: elapsed[0] + elapsed[1] / 1e9,
+    type: 'report',
+    gcStats: this._gcStats
+  });
+};
+
+function createBenchmark(fn, configs, options) {
+  return new Benchmark(fn, configs, options);
+}
+
+function createConnection(cb) {
+  var config = JSON.parse(fs.readFileSync(require('os').homedir() + '/.tedious/test-connection.json', 'utf8')).config;
+
+  var connection = new Connection(config);
+  connection.connect(function() {
+    cb(connection);
+  });
+}
+
+module.exports.createBenchmark = createBenchmark;
+module.exports.createConnection = createConnection;

package/dist/node_modules/tedious/benchmarks/connection/open.js

@@ -0,0 +1,26 @@
+const { createBenchmark, createConnection } = require('../common');
+
+const bench = createBenchmark(main, {
+  n: [10, 100]
+});
+
+function main({ n }) {
+  let i = 0;
+  bench.start();
+
+  (function cb() {
+    createConnection(function(connection) {
+      connection.close();
+
+      if (i++ === n) {
+        bench.end(n);
+
+        connection.close();
+
+        return;
+      }
+
+      cb();
+    });
+  })();
+}