tedious 2.2.3 → 2.2.4

package/lib/data-types/image.js

@@ -0,0 +1,46 @@
+'use strict';
+
+module.exports = {
+  id: 0x22,
+  type: 'IMAGE',
+  name: 'Image',
+  hasTableName: true,
+  hasTextPointerAndTimestamp: true,
+  dataLengthLength: 4,
+
+  declaration: function declaration() {
+    return 'image';
+  },
+
+  resolveLength: function resolveLength(parameter) {
+    if (parameter.value != null) {
+      return parameter.value.length;
+    } else {
+      return -1;
+    }
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(this.id);
+    buffer.writeInt32LE(parameter.length);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeInt32LE(parameter.length);
+      buffer.writeBuffer(parameter.value);
+    } else {
+      buffer.writeInt32LE(parameter.length);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    if (!Buffer.isBuffer(value)) {
+      return new TypeError('Invalid buffer.');
+    }
+    return value;
+  }
+};

package/lib/data-types/int.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var IntN = require('./intn');
+
+module.exports = {
+  id: 0x38,
+  type: 'INT4',
+  name: 'Int',
+
+  declaration: function declaration() {
+    return 'int';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(IntN.id);
+    buffer.writeUInt8(4);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUInt8(4);
+      buffer.writeInt32LE(parseInt(parameter.value));
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    value = parseInt(value);
+    if (isNaN(value)) {
+      return new TypeError('Invalid number.');
+    }
+    if (value < -2147483648 || value > 2147483647) {
+      return new TypeError('Value must be between -2147483648 and 2147483647.');
+    }
+    return value;
+  }
+};

package/lib/data-types/intn.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  id: 0x26,
+  type: 'INTN',
+  name: 'IntN',
+  dataLengthLength: 1
+};

package/lib/data-types/money.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var MoneyN = require('./moneyn');
+
+module.exports = {
+  id: 0x3C,
+  type: 'MONEY',
+  name: 'Money',
+
+  declaration: function declaration() {
+    return 'money';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(MoneyN.id);
+    buffer.writeUInt8(8);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUInt8(8);
+      buffer.writeMoney(parameter.value * 10000);
+    } 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/moneyn.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  id: 0x6E,
+  type: 'MONEYN',
+  name: 'MoneyN',
+  dataLengthLength: 1
+};

package/lib/data-types/nchar.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var NULL = (1 << 16) - 1;
+
+module.exports = {
+  id: 0xEF,
+  type: 'NCHAR',
+  name: 'NChar',
+  hasCollation: true,
+  dataLengthLength: 2,
+  maximumLength: 4000,
+
+  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 'nchar(' + length + ')';
+    } else {
+      return 'nchar(' + 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 / 2 || 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 * 2);
+    buffer.writeBuffer(new Buffer([0x00, 0x00, 0x00, 0x00, 0x00]));
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUsVarbyte(parameter.value, 'ucs2');
+    } 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/ntext.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = {
+  id: 0x63,
+  type: 'NTEXT',
+  name: 'NText',
+  hasCollation: true,
+  hasTableName: true,
+  hasTextPointerAndTimestamp: true,
+  dataLengthLength: 4
+};

package/lib/data-types/null.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  id: 0x1F,
+  type: 'NULL',
+  name: 'Null'
+};

package/lib/data-types/numeric.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var NumericN = require('./numericn');
+
+module.exports = {
+  id: 0x3F,
+  type: 'NUMERIC',
+  name: 'Numeric',
+  hasPrecision: true,
+  hasScale: true,
+
+  declaration: function declaration(parameter) {
+    return 'numeric(' + 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(NumericN.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/numericn.js

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

package/lib/data-types/nvarchar.js

@@ -0,0 +1,86 @@
+'use strict';
+
+var NULL = (1 << 16) - 1;
+var MAX = (1 << 16) - 1;
+
+module.exports = {
+  id: 0xE7,
+  type: 'NVARCHAR',
+  name: 'NVarChar',
+  hasCollation: true,
+  dataLengthLength: 2,
+  maximumLength: 4000,
+
+  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 'nvarchar(' + length + ')';
+    } else {
+      return 'nvarchar(max)';
+    }
+  },
+
+  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 / 2 || 1;
+      } else {
+        return parameter.value.toString().length || 1;
+      }
+    } else {
+      return this.maximumLength;
+    }
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(this.id);
+    if (parameter.length <= this.maximumLength) {
+      buffer.writeUInt16LE(parameter.length * 2);
+    } else {
+      buffer.writeUInt16LE(MAX);
+    }
+    buffer.writeBuffer(new Buffer([0x00, 0x00, 0x00, 0x00, 0x00]));
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      if (parameter.length <= this.maximumLength) {
+        buffer.writeUsVarbyte(parameter.value, 'ucs2');
+      } else {
+        buffer.writePLPBody(parameter.value, 'ucs2');
+      }
+    } else {
+      if (parameter.length <= this.maximumLength) {
+        buffer.writeUInt16LE(NULL);
+      } else {
+        buffer.writeUInt32LE(0xFFFFFFFF);
+        buffer.writeUInt32LE(0xFFFFFFFF);
+      }
+    }
+  },
+
+  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/real.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var FloatN = require('./floatn');
+
+module.exports = {
+  id: 0x3B,
+  type: 'FLT4',
+  name: 'Real',
+
+  declaration: function declaration() {
+    return 'real';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(FloatN.id);
+    buffer.writeUInt8(4);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUInt8(4);
+      buffer.writeFloatLE(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/smalldatetime.js

@@ -0,0 +1,60 @@
+'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: 0x3A,
+  type: 'DATETIM4',
+  name: 'SmallDateTime',
+
+  declaration: function declaration() {
+    return 'smalldatetime';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(DateTimeN.id);
+    buffer.writeUInt8(4);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter, options) {
+    if (parameter.value != null) {
+      var days = void 0,
+          dstDiff = void 0,
+          minutes = void 0;
+      if (options.useUTC) {
+        days = Math.floor((parameter.value.getTime() - UTC_EPOCH_DATE.getTime()) / (1000 * 60 * 60 * 24));
+        minutes = parameter.value.getUTCHours() * 60 + parameter.value.getUTCMinutes();
+      } else {
+        dstDiff = -(parameter.value.getTimezoneOffset() - EPOCH_DATE.getTimezoneOffset()) * 60 * 1000;
+        days = Math.floor((parameter.value.getTime() - EPOCH_DATE.getTime() + dstDiff) / (1000 * 60 * 60 * 24));
+        minutes = parameter.value.getHours() * 60 + parameter.value.getMinutes();
+      }
+
+      buffer.writeUInt8(4);
+      buffer.writeUInt16LE(days);
+
+      buffer.writeUInt16LE(minutes);
+    } 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/smallint.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var IntN = require('./intn');
+
+module.exports = {
+  id: 0x34,
+  type: 'INT2',
+  name: 'SmallInt',
+
+  declaration: function declaration() {
+    return 'smallint';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(IntN.id);
+    buffer.writeUInt8(2);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUInt8(2);
+      buffer.writeInt16LE(parseInt(parameter.value));
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    value = parseInt(value);
+    if (isNaN(value)) {
+      return new TypeError('Invalid number.');
+    }
+    if (value < -32768 || value > 32767) {
+      return new TypeError('Value must be between -32768 and 32767.');
+    }
+    return value;
+  }
+};

package/lib/data-types/smallmoney.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var MoneyN = require('./moneyn');
+
+module.exports = {
+  id: 0x7A,
+  type: 'MONEY4',
+  name: 'SmallMoney',
+
+  declaration: function declaration() {
+    return 'smallmoney';
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer) {
+    buffer.writeUInt8(MoneyN.id);
+    buffer.writeUInt8(4);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    if (parameter.value != null) {
+      buffer.writeUInt8(4);
+      buffer.writeInt32LE(parameter.value * 10000);
+    } else {
+      buffer.writeUInt8(0);
+    }
+  },
+
+  validate: function validate(value) {
+    if (value == null) {
+      return null;
+    }
+    value = parseFloat(value);
+    if (isNaN(value)) {
+      return new TypeError('Invalid number.');
+    }
+    if (value < -214748.3648 || value > 214748.3647) {
+      return new TypeError('Value must be between -214748.3648 and 214748.3647.');
+    }
+    return value;
+  }
+};

package/lib/data-types/sql-variant.js

@@ -0,0 +1,12 @@
+'use strict';
+
+module.exports = {
+  id: 0x62,
+  type: 'SSVARIANTTYPE',
+  name: 'Variant',
+  dataLengthLength: 4,
+
+  declaration: function declaration(parameter) {
+    return 'sql_variant';
+  }
+};

package/lib/data-types/text.js

@@ -0,0 +1,51 @@
+'use strict';
+
+module.exports = {
+  id: 0x23,
+  type: 'TEXT',
+  name: 'Text',
+  hasCollation: true,
+  hasTableName: true,
+  hasTextPointerAndTimestamp: true,
+  dataLengthLength: 4,
+
+  declaration: function declaration() {
+    return 'text';
+  },
+
+  resolveLength: function resolveLength(parameter) {
+    if (parameter.value != null) {
+      return parameter.value.length;
+    } else {
+      return -1;
+    }
+  },
+
+  writeTypeInfo: function writeTypeInfo(buffer, parameter) {
+    buffer.writeUInt8(this.id);
+    buffer.writeInt32LE(parameter.length);
+  },
+
+  writeParameterData: function writeParameterData(buffer, parameter) {
+    buffer.writeBuffer(new Buffer([0x00, 0x00, 0x00, 0x00, 0x00]));
+    if (parameter.value != null) {
+      buffer.writeInt32LE(parameter.length);
+      buffer.writeString(parameter.value.toString(), 'ascii');
+    } else {
+      buffer.writeInt32LE(parameter.length);
+    }
+  },
+
+  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;
+  }
+};