mssql 7.1.3 → 8.0.0

package/lib/connectionstring.js

@@ -1,289 +0,0 @@
-'use strict'
-
-const URL = require('url').URL
-
-const IGNORE_KEYS = ['stream']
-const oror = function () {
-  for (let i = 0, l = arguments.length; i < l; i++) {
-    if (arguments[i] !== null && arguments[i] !== undefined) {
-      return arguments[i]
-    }
-  }
-}
-
-const parseConnectionURI = function (uri) {
-  const parsed = new URL(uri)
-  let instance
-  let user
-  let password
-
-  const path = parsed.pathname.substr(1).split('/')
-  if (path.length > 1) {
-    instance = path.shift()
-  }
-
-  if (parsed.username) {
-    const auth = [parsed.username, parsed.password]
-    user = decodeURIComponent(auth.shift())
-    password = decodeURIComponent(auth.join(':'))
-  }
-
-  const port = parsed.port ? `,${parsed.port}` : (instance ? `\\${instance}` : '')
-  const object = {
-    server: `${parsed.hostname}${port}`,
-    uid: user || '',
-    pwd: password || '',
-    database: path[0]
-  }
-
-  if (parsed.searchParams) {
-    parsed.searchParams.forEach((value, key) => {
-      if (key === 'domain') {
-        object.uid = `${value}\\${object.uid}`
-      } else {
-        object[key] = value
-      }
-    })
-  }
-
-  Object.defineProperty(object, 'toString', {
-    value () {
-      const out = []
-      for (const key in this) {
-        if (IGNORE_KEYS.indexOf(key) === -1) {
-          out.push(`${key}={${this[key]}}`)
-        }
-      }
-      return out.join(';')
-    }
-  })
-
-  return object
-}
-
-const parseConnectionString = function (string) {
-  let cursor = 0
-  let parsing = 'name'
-  let param = null
-  let buffer = ''
-  let quotes = null
-  const parsed = {}
-  const original = {}
-
-  Object.defineProperty(parsed, '__original__', { value: original })
-  Object.defineProperty(parsed, 'toString', {
-    value () {
-      const out = []
-      for (const key in this) {
-        if (IGNORE_KEYS.indexOf(key) === -1) {
-          const esc = original[key].escape || ['', '']
-          out.push(`${original[key].name}=${esc[0] || ''}${this[key]}${esc[1] || ''}`)
-        }
-      }
-      return out.join(';')
-    }
-  })
-
-  while (cursor < string.length) {
-    const char = string.charAt(cursor)
-    switch (char) {
-      case '=':
-        if (parsing === 'name') {
-          buffer = buffer.trim()
-          param = buffer.toLowerCase()
-          original[param] = { name: buffer }
-          parsing = 'value'
-          buffer = ''
-        } else {
-          buffer += char
-        }
-        break
-
-      case '\'': case '"':
-        if (parsing === 'value') {
-          if (!buffer.trim().length) {
-            // value is wrapped in qotes
-            original[param].escape = [char, char]
-            quotes = char
-            buffer = ''
-          } else if (quotes) {
-            if (char === quotes) {
-              // found same char as used for wrapping quotes
-              if (char === string.charAt(cursor + 1)) {
-                // escaped quote
-                buffer += char
-                cursor++
-              } else {
-                // end of value
-                parsed[param] = buffer
-                param = null
-                parsing = null
-                buffer = ''
-                quotes = null
-              }
-            } else {
-              buffer += char
-            }
-          } else {
-            buffer += char
-          }
-        } else {
-          throw new Error('Invalid connection string.')
-        }
-        break
-
-      case '{':
-        if (parsing === 'value') {
-          if (buffer.trim().length === 0) {
-            // value is wrapped in qotes
-            original[param].escape = ['{', '}']
-            quotes = '{}'
-            buffer = ''
-          } else {
-            buffer += char
-          }
-        } else {
-          throw new Error('Invalid connection string.')
-        }
-        break
-
-      case '}':
-        if (parsing === 'value') {
-          if (quotes === '{}') {
-            // end of value
-            parsed[param] = buffer
-            param = null
-            parsing = null
-            buffer = ''
-            quotes = null
-          } else {
-            buffer += char
-          }
-        } else {
-          throw new Error('Invalid connection string.')
-        }
-        break
-
-      case ';':
-        if (parsing === 'value') {
-          if (quotes) {
-            buffer += char
-          } else {
-            // end of value
-            parsed[param] = buffer
-            param = null
-            parsing = 'name'
-            buffer = ''
-          }
-        } else {
-          buffer = ''
-          parsing = 'name'
-        }
-        break
-
-      default:
-        buffer += char
-    }
-
-    cursor++
-  }
-
-  if (parsing === 'value') {
-    // end of value
-    parsed[param] = buffer
-  }
-
-  return parsed
-}
-
-const resolveConnectionString = function (string, driver) {
-  const parsed = /^(mssql|tedious|msnodesql|tds):\/\//i.test(string) ? parseConnectionURI(string) : parseConnectionString(string)
-  const stream = (parsed.stream || '').toLowerCase()
-  const encrypt = (parsed.encrypt || '').toLowerCase()
-
-  if (driver === 'msnodesqlv8') {
-    parsed.driver = 'SQL Server Native Client 11.0'
-
-    if (parsed.__original__) {
-      parsed.__original__.driver = { name: 'Driver', escape: ['{', '}'] }
-    }
-
-    return { connectionString: parsed.toString() }
-  }
-
-  let user = parsed.uid || parsed.uid || parsed['user id']
-  let server = parsed.server || parsed.address || parsed.addr || parsed['data source'] || parsed['network address']
-
-  const config = {
-    password: oror(parsed.pwd, parsed.password),
-    database: oror(parsed.database, parsed['initial catalog']),
-    connectionTimeout: oror(parsed.connectionTimeout, parsed.timeout, parsed['connect timeout'], parsed['connection timeout']),
-    requestTimeout: oror(parsed.requestTimeout, parsed['request timeout']),
-    stream: stream === 'true' || stream === 'yes' || stream === '1',
-    options: {
-      readOnlyIntent: parsed.applicationintent && parsed.applicationintent.toLowerCase() === 'readonly',
-      encrypt: encrypt === 'true' || encrypt === 'yes' || encrypt === '1'
-    }
-  }
-
-  if (parsed.trustservercertificate && ['true', '1', 'yes'].includes(parsed.trustservercertificate.toLowerCase())) {
-    Object.assign(config.options, {
-      trustServerCertificate: true
-    })
-  }
-
-  if (parsed.useUTC != null) {
-    const utc = parsed.useUTC.toLowerCase()
-    config.options.useUTC = utc === 'true' || utc === 'yes' || utc === '1'
-  }
-  if (config.connectionTimeout != null) {
-    config.connectionTimeout = parseInt(config.connectionTimeout, 10) * 1000
-  }
-  if (config.requestTimeout != null) {
-    config.requestTimeout = parseInt(config.requestTimeout, 10)
-  }
-
-  if (parsed.multisubnetfailover != null) {
-    config.options.multiSubnetFailover = parsed.multisubnetfailover.toLowerCase() === 'true'
-  }
-
-  if (/^(.*)\\(.*)$/.exec(user)) {
-    config.domain = RegExp.$1
-    user = RegExp.$2
-  }
-
-  if (server) {
-    server = server.trim()
-
-    if (/^np:/i.test(server)) {
-      throw new Error('Connection via Named Pipes is not supported.')
-    }
-
-    if (/^tcp:/i.test(server)) {
-      server = server.substr(4)
-    }
-
-    if (/^(.*)\\(.*)$/.exec(server)) {
-      server = RegExp.$1
-      config.options.instanceName = RegExp.$2
-    }
-
-    if (/^(.*),(.*)$/.exec(server)) {
-      server = RegExp.$1.trim()
-      config.port = parseInt(RegExp.$2.trim(), 10)
-    }
-
-    if (server === '.' || server === '(.)' || server.toLowerCase() === '(localdb)' || server.toLowerCase() === '(local)') {
-      server = 'localhost'
-    }
-  }
-
-  config.user = user
-  config.server = server
-  return config
-}
-
-module.exports = {
-  parse: parseConnectionString,
-  resolve: resolveConnectionString
-}

package/test2.js

@@ -1,211 +0,0 @@
-const values = [
-  1810,
-  1729,
-  1857,
-  1777,
-  1927,
-  1936,
-  1797,
-  1719,
-  1703,
-  1758,
-  1768,
-  2008,
-  1963,
-  1925,
-  1919,
-  1911,
-  1782,
-  2001,
-  1744,
-  1738,
-  1742,
-  1799,
-  1765,
-  1819,
-  1888,
-  127,
-  1880,
-  1984,
-  1697,
-  1760,
-  1680,
-  1951,
-  1745,
-  1817,
-  1704,
-  1736,
-  1969,
-  1705,
-  1690,
-  1848,
-  1885,
-  1912,
-  1982,
-  1895,
-  1959,
-  1769,
-  1722,
-  1807,
-  1901,
-  1983,
-  1993,
-  1871,
-  1795,
-  1955,
-  1921,
-  1934,
-  1743,
-  1899,
-  1942,
-  1964,
-  1034,
-  1952,
-  1851,
-  1716,
-  1800,
-  1771,
-  1945,
-  1877,
-  1917,
-  1930,
-  1970,
-  1948,
-  1914,
-  1767,
-  1910,
-  563,
-  1121,
-  1897,
-  1946,
-  1882,
-  1739,
-  1900,
-  1714,
-  1931,
-  2000,
-  311,
-  1881,
-  1876,
-  354,
-  1965,
-  1842,
-  1979,
-  1998,
-  1960,
-  1852,
-  1847,
-  1938,
-  1369,
-  1780,
-  1698,
-  1753,
-  1746,
-  1868,
-  1752,
-  1802,
-  1892,
-  1755,
-  1818,
-  1913,
-  1706,
-  1862,
-  326,
-  1941,
-  1926,
-  1809,
-  1879,
-  1815,
-  1939,
-  1859,
-  1999,
-  1947,
-  1898,
-  1794,
-  1737,
-  1971,
-  1977,
-  1944,
-  1812,
-  1905,
-  1359,
-  1788,
-  1754,
-  1774,
-  1825,
-  1748,
-  1701,
-  1791,
-  1786,
-  1692,
-  1894,
-  1961,
-  1902,
-  1849,
-  1967,
-  1770,
-  1987,
-  1831,
-  1728,
-  1896,
-  1805,
-  1733,
-  1918,
-  1731,
-  661,
-  1776,
-  1494,
-  2005,
-  2009,
-  2004,
-  1915,
-  1695,
-  1710,
-  1804,
-  1929,
-  1725,
-  1772,
-  1933,
-  609,
-  1708,
-  1822,
-  1978,
-  1811,
-  1816,
-  1073,
-  1874,
-  1845,
-  1989,
-  1696,
-  1953,
-  1823,
-  1923,
-  1907,
-  1834,
-  1806,
-  1861,
-  1785,
-  297,
-  1968,
-  1764,
-  1932,
-  1937,
-  1826,
-  1732,
-  1962,
-  1916,
-  1756,
-  1975,
-  1775,
-  1922,
-  1773
-]
-
-values.forEach((first) => {
-  values.forEach((second) => {
-    const third = 2020 - first - second
-    if (values.includes(third)) {
-      console.log(first * second * third)
-    }
-  })
-})