tedious 2.2.2 → 2.3.1

package/lib/data-types/bigint.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var IntN = require('./intn');
+
+module.exports = {
+  id: 0x7F,
+  type: 'INT8',
+  name: 'BigInt',
+
+  declaration: function declaration() {
+    return 'bigint';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(IntN.id);
+    buffer.writeUInt8(8);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      var val = typeof parameter.value !== 'number' ? parameter.value : parseInt(parameter.value);
+      buffer.writeUInt8(8);
+      buffer.writeInt64LE(val);
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (isNaN(value)) {
+      return new TypeError('Invalid number.');
+    }
+    if (value < -9007199254740991 || value > 9007199254740991) {
+      // Number.MIN_SAFE_INTEGER = -9007199254740991
+      // Number.MAX_SAFE_INTEGER = 9007199254740991
+      // 9007199254740991 = (2**53) - 1
+      // Can't use Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER directly though
+      // as these constants are not available in node 0.10.
+      return new TypeError('Value must be between -9007199254740991 and 9007199254740991, inclusive.' + ' For bigger numbers, use VarChar type.');
+    }
+    return value;
+  }
+};

package/lib/data-types/binary.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var NULL = (1 << 16) - 1;
+
+module.exports = {
+  id: 0xAD,
+  type: 'BIGBinary',
+  name: 'Binary',
+  dataLengthLength: 2,
+  maximumLength: 8000,
+
+  declaration: function declaration(parameter) {
+    var length;
+    if (parameter.length) {
+      length = parameter.length;
+    } else if (parameter.value != null) {
+      length = parameter.value.length || 1;
+    } else if (parameter.value === null && !parameter.output) {
+      length = 1;
+    } else {
+      length = this.maximumLength;
+    }
+    return 'binary(' + length + ')';
+  },
+
+  resolveLength: function resolveLength(parameter) {
+    if (parameter.value != null) {
+      return parameter.value.length;
+    } else {
+      return this.maximumLength;
+    }
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(this.id);
+    buffer.writeUInt16LE(parameter.length);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUInt16LE(parameter.length);
+      buffer.writeBuffer(parameter.value.slice(0, Math.min(parameter.length, this.maximumLength)));
+    } else {
+      buffer.writeUInt16LE(NULL);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (!Buffer.isBuffer(value)) {
+      return new TypeError('Invalid buffer.');
+    }
+    return value;
+  }
+};

package/lib/data-types/bit.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var BitN = require('./bitn');
+
+module.exports = {
+  id: 0x32,
+  type: 'BIT',
+  name: 'Bit',
+
+  declaration: function declaration() {
+    return 'bit';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(BitN.id);
+    buffer.writeUInt8(1);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (typeof parameter.value === 'undefined' || parameter.value === null) {
+      buffer.writeUInt8(0);
+    } else {
+      buffer.writeUInt8(1);
+      buffer.writeUInt8(parameter.value ? 1 : 0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (value) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+};

package/lib/data-types/bitn.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  id: 0x68,
+  type: 'BITN',
+  name: 'BitN',
+  dataLengthLength: 1
+};

package/lib/data-types/char.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var NULL = (1 << 16) - 1;
+
+module.exports = {
+  id: 0xAF,
+  type: 'BIGCHAR',
+  name: 'Char',
+  hasCollation: true,
+  dataLengthLength: 2,
+  maximumLength: 8000,
+
+  declaration: function declaration(parameter) {
+    var length = void 0;
+    if (parameter.length) {
+      length = parameter.length;
+    } else if (parameter.value != null) {
+      length = parameter.value.toString().length || 1;
+    } else if (parameter.value === null && !parameter.output) {
+      length = 1;
+    } else {
+      length = this.maximumLength;
+    }
+
+    if (length < this.maximumLength) {
+      return 'char(' + length + ')';
+    } else {
+      return 'char(' + this.maximumLength + ')';
+    }
+  },
+
+  resolveLength: function resolveLength(parameter) {
+    if (parameter.length != null) {
+      return parameter.length;
+    } else if (parameter.value != null) {
+      if (Buffer.isBuffer(parameter.value)) {
+        return parameter.value.length || 1;
+      } else {
+        return parameter.value.toString().length || 1;
+      }
+    } else {
+      return this.maximumLength;
+    }
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(this.id);
+    buffer.writeUInt16LE(parameter.length);
+    buffer.writeBuffer(new Buffer([0x00, 0x00, 0x00, 0x00, 0x00]));
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUsVarbyte(parameter.value, 'ascii');
+    } else {
+      buffer.writeUInt16LE(NULL);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (typeof value !== 'string') {
+      if (typeof value.toString !== 'function') {
+        return TypeError('Invalid string.');
+      }
+      value = value.toString();
+    }
+    return value;
+  }
+};

package/lib/data-types/date.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var YEAR_ONE = new Date(2000, 0, -730118);
+var UTC_YEAR_ONE = Date.UTC(2000, 0, -730118);
+
+module.exports = {
+  id: 0x28,
+  type: 'DATEN',
+  name: 'Date',
+  dataLengthLength: 1,
+  fixedDataLength: 3,
+
+  declaration: function declaration() {
+    return 'date';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(this.id);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter, options) {
+    if (parameter.value != null) {
+      buffer.writeUInt8(3);
+      if (options.useUTC) {
+        buffer.writeUInt24LE(Math.floor((+parameter.value - UTC_YEAR_ONE) / 86400000));
+      } else {
+        var dstDiff = -(parameter.value.getTimezoneOffset() - YEAR_ONE.getTimezoneOffset()) * 60 * 1000;
+        buffer.writeUInt24LE(Math.floor((+parameter.value - YEAR_ONE + dstDiff) / 86400000));
+      }
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (!(value instanceof Date)) {
+      value = Date.parse(value);
+    }
+    if (isNaN(value)) {
+      return new TypeError('Invalid date.');
+    }
+    return value;
+  }
+};

package/lib/data-types/datetime.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var DateTimeN = require('./datetimen');
+
+var EPOCH_DATE = new Date(1900, 0, 1);
+var UTC_EPOCH_DATE = new Date(Date.UTC(1900, 0, 1));
+
+module.exports = {
+  id: 0x3D,
+  type: 'DATETIME',
+  name: 'DateTime',
+
+  declaration: function declaration() {
+    return 'datetime';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(DateTimeN.id);
+    buffer.writeUInt8(8);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter, options) {
+    if (parameter.value != null) {
+      var days = void 0,
+          dstDiff = void 0,
+          milliseconds = void 0,
+          seconds = void 0,
+          threeHundredthsOfSecond = void 0;
+      if (options.useUTC) {
+        days = Math.floor((parameter.value.getTime() - UTC_EPOCH_DATE.getTime()) / (1000 * 60 * 60 * 24));
+        seconds = parameter.value.getUTCHours() * 60 * 60;
+        seconds += parameter.value.getUTCMinutes() * 60;
+        seconds += parameter.value.getUTCSeconds();
+        milliseconds = seconds * 1000 + parameter.value.getUTCMilliseconds();
+      } else {
+        dstDiff = -(parameter.value.getTimezoneOffset() - EPOCH_DATE.getTimezoneOffset()) * 60 * 1000;
+        days = Math.floor((parameter.value.getTime() - EPOCH_DATE.getTime() + dstDiff) / (1000 * 60 * 60 * 24));
+        seconds = parameter.value.getHours() * 60 * 60;
+        seconds += parameter.value.getMinutes() * 60;
+        seconds += parameter.value.getSeconds();
+        milliseconds = seconds * 1000 + parameter.value.getMilliseconds();
+      }
+
+      threeHundredthsOfSecond = milliseconds / (3 + 1 / 3);
+      threeHundredthsOfSecond = Math.round(threeHundredthsOfSecond);
+
+      buffer.writeUInt8(8);
+      buffer.writeInt32LE(days);
+
+      buffer.writeUInt32LE(threeHundredthsOfSecond);
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (!(value instanceof Date)) {
+      value = Date.parse(value);
+    }
+    if (isNaN(value)) {
+      return new TypeError('Invalid date.');
+    }
+    return value;
+  }
+};

package/lib/data-types/datetime2.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var YEAR_ONE = new Date(2000, 0, -730118);
+var UTC_YEAR_ONE = Date.UTC(2000, 0, -730118);
+
+module.exports = {
+  id: 0x2A,
+  type: 'DATETIME2N',
+  name: 'DateTime2',
+  hasScale: true,
+  dataLengthLength: 1,
+
+  dataLengthFromScale: function dataLengthFromScale(scale) {
+    switch (scale) {
+      case 0:
+      case 1:
+      case 2:
+        return 3;
+      case 3:
+      case 4:
+        return 4;
+      case 5:
+      case 6:
+      case 7:
+        return 5;
+    }
+  },
+
+  declaration: function declaration(parameter) {
+    return 'datetime2(' + this.resolveScale(parameter) + ')';
+  },
+
+  resolveScale: function resolveScale(parameter) {
+    if (parameter.scale != null) {
+      return parameter.scale;
+    } else if (parameter.value === null) {
+      return 0;
+    } else {
+      return 7;
+    }
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(this.id);
+    buffer.writeUInt8(parameter.scale);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter, options) {
+    if (parameter.value != null) {
+      var time = new Date(+parameter.value);
+
+      var timestamp = void 0;
+      if (options.useUTC) {
+        timestamp = ((time.getUTCHours() * 60 + time.getUTCMinutes()) * 60 + time.getUTCSeconds()) * 1000 + time.getUTCMilliseconds();
+      } else {
+        timestamp = ((time.getHours() * 60 + time.getMinutes()) * 60 + time.getSeconds()) * 1000 + time.getMilliseconds();
+      }
+
+      timestamp = timestamp * Math.pow(10, parameter.scale - 3);
+      timestamp += (parameter.value.nanosecondDelta != null ? parameter.value.nanosecondDelta : 0) * Math.pow(10, parameter.scale);
+      timestamp = Math.round(timestamp);
+
+      switch (parameter.scale) {
+        case 0:
+        case 1:
+        case 2:
+          buffer.writeUInt8(6);
+          buffer.writeUInt24LE(timestamp);
+          break;
+        case 3:
+        case 4:
+          buffer.writeUInt8(7);
+          buffer.writeUInt32LE(timestamp);
+          break;
+        case 5:
+        case 6:
+        case 7:
+          buffer.writeUInt8(8);
+          buffer.writeUInt40LE(timestamp);
+      }
+      if (options.useUTC) {
+        buffer.writeUInt24LE(Math.floor((+parameter.value - UTC_YEAR_ONE) / 86400000));
+      } else {
+        var dstDiff = -(parameter.value.getTimezoneOffset() - YEAR_ONE.getTimezoneOffset()) * 60 * 1000;
+        buffer.writeUInt24LE(Math.floor((+parameter.value - YEAR_ONE + dstDiff) / 86400000));
+      }
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (!(value instanceof Date)) {
+      value = Date.parse(value);
+    }
+    if (isNaN(value)) {
+      return new TypeError('Invalid date.');
+    }
+    return value;
+  }
+};

package/lib/data-types/datetimen.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  id: 0x6F,
+  type: 'DATETIMN',
+  name: 'DateTimeN',
+  dataLengthLength: 1
+};

package/lib/data-types/datetimeoffset.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var UTC_YEAR_ONE = Date.UTC(2000, 0, -730118);
+
+module.exports = {
+  id: 0x2B,
+  type: 'DATETIMEOFFSETN',
+  name: 'DateTimeOffset',
+  hasScale: true,
+  dataLengthLength: 1,
+  dataLengthFromScale: function dataLengthFromScale(scale) {
+    switch (scale) {
+      case 0:
+      case 1:
+      case 2:
+        return 3;
+      case 3:
+      case 4:
+        return 4;
+      case 5:
+      case 6:
+      case 7:
+        return 5;
+    }
+  },
+  declaration: function declaration(parameter) {
+    return 'datetimeoffset(' + this.resolveScale(parameter) + ')';
+  },
+  resolveScale: function resolveScale(parameter) {
+    if (parameter.scale != null) {
+      return parameter.scale;
+    } else if (parameter.value === null) {
+      return 0;
+    } else {
+      return 7;
+    }
+  },
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(this.id);
+    buffer.writeUInt8(parameter.scale);
+  },
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      var time = new Date(+parameter.value);
+      time.setUTCFullYear(1970);
+      time.setUTCMonth(0);
+      time.setUTCDate(1);
+
+      var timestamp = time * Math.pow(10, parameter.scale - 3);
+      timestamp += (parameter.value.nanosecondDelta != null ? parameter.value.nanosecondDelta : 0) * Math.pow(10, parameter.scale);
+      timestamp = Math.round(timestamp);
+
+      var offset = -parameter.value.getTimezoneOffset();
+      switch (parameter.scale) {
+        case 0:
+        case 1:
+        case 2:
+          buffer.writeUInt8(8);
+          buffer.writeUInt24LE(timestamp);
+          break;
+        case 3:
+        case 4:
+          buffer.writeUInt8(9);
+          buffer.writeUInt32LE(timestamp);
+          break;
+        case 5:
+        case 6:
+        case 7:
+          buffer.writeUInt8(10);
+          buffer.writeUInt40LE(timestamp);
+      }
+      buffer.writeUInt24LE(Math.floor((+parameter.value - UTC_YEAR_ONE) / 86400000));
+      buffer.writeInt16LE(offset);
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (!(value instanceof Date)) {
+      value = Date.parse(value);
+    }
+    if (isNaN(value)) {
+      return new TypeError('Invalid date.');
+    }
+    return value;
+  }
+};

package/lib/data-types/decimal.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var DecimalN = require('./decimaln');
+
+module.exports = {
+  id: 0x37,
+  type: 'DECIMAL',
+  name: 'Decimal',
+  hasPrecision: true,
+  hasScale: true,
+
+  declaration: function declaration(parameter) {
+    return 'decimal(' + this.resolvePrecision(parameter) + ', ' + this.resolveScale(parameter) + ')';
+  },
+
+  resolvePrecision: function resolvePrecision(parameter) {
+    if (parameter.precision != null) {
+      return parameter.precision;
+    } else if (parameter.value === null) {
+      return 1;
+    } else {
+      return 18;
+    }
+  },
+
+  resolveScale: function resolveScale(parameter) {
+    if (parameter.scale != null) {
+      return parameter.scale;
+    } else {
+      return 0;
+    }
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(DecimalN.id);
+    if (parameter.precision <= 9) {
+      buffer.writeUInt8(5);
+    } else if (parameter.precision <= 19) {
+      buffer.writeUInt8(9);
+    } else if (parameter.precision <= 28) {
+      buffer.writeUInt8(13);
+    } else {
+      buffer.writeUInt8(17);
+    }
+    buffer.writeUInt8(parameter.precision);
+    buffer.writeUInt8(parameter.scale);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      var sign = parameter.value < 0 ? 0 : 1;
+      var value = Math.round(Math.abs(parameter.value * Math.pow(10, parameter.scale)));
+      if (parameter.precision <= 9) {
+        buffer.writeUInt8(5);
+        buffer.writeUInt8(sign);
+        buffer.writeUInt32LE(value);
+      } else if (parameter.precision <= 19) {
+        buffer.writeUInt8(9);
+        buffer.writeUInt8(sign);
+        buffer.writeUInt64LE(value);
+      } else if (parameter.precision <= 28) {
+        buffer.writeUInt8(13);
+        buffer.writeUInt8(sign);
+        buffer.writeUInt64LE(value);
+        buffer.writeUInt32LE(0x00000000);
+      } else {
+        buffer.writeUInt8(17);
+        buffer.writeUInt8(sign);
+        buffer.writeUInt64LE(value);
+        buffer.writeUInt32LE(0x00000000);
+        buffer.writeUInt32LE(0x00000000);
+      }
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    value = parseFloat(value);
+    if (isNaN(value)) {
+      return new TypeError('Invalid number.');
+    }
+    return value;
+  }
+};

package/lib/data-types/decimaln.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = {
+  id: 0x6A,
+  type: 'DECIMALN',
+  name: 'DecimalN',
+  dataLengthLength: 1,
+  hasPrecision: true,
+  hasScale: true
+};

package/lib/data-types/float.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var FloatN = require('./floatn');
+
+module.exports = {
+  id: 0x3E,
+  type: 'FLT8',
+  name: 'Float',
+
+  declaration: function declaration() {
+    return 'float';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(FloatN.id);
+    buffer.writeUInt8(8);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUInt8(8);
+      buffer.writeDoubleLE(parseFloat(parameter.value));
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    value = parseFloat(value);
+    if (isNaN(value)) {
+      return new TypeError('Invalid number.');
+    }
+    return value;
+  }
+};

package/lib/data-types/floatn.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  id: 0x6D,
+  type: 'FLTN',
+  name: 'FloatN',
+  dataLengthLength: 1
+};