Writer.js

// Copyright 2013 SAP AG.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http: //www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
// either express or implied. See the License for the specific
// language governing permissions and limitations under the License.
'use strict';

var util = require('../util');
var Readable = util.stream.Readable;
var Transform = util.stream.Transform;
var common = require('./common');
var TypeCode = common.TypeCode;
var LobOptions = common.LobOptions;
var NormalizedTypeCode = common.NormalizedTypeCode;
var bignum = util.bignum;
var calendar = util.calendar;
var zeropad = require('../util/zeropad');
var isValidDay = calendar.isValidDay;
var isValidTime = calendar.isValidTime;
var isZeroDay = calendar.isZeroDay;
var isZeroTime = calendar.isZeroTime;
var WRITE_LOB_REQUEST_HEADER_LENGTH = 21;

exports = module.exports = Writer;

var REGEX = {
  DATE: /(\d{4})-(\d{2})-(\d{2})/,
  TIME: /(\d{2}):(\d{2}):(\d{2}(?:\.\d+)?)/,
  TIMESTAMP: /(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2}(?:\.\d+)?)/,
  // DECIMAL will match "" and ".", both of which are invalid, requires an
  // additional check
  DECIMAL: /^([+-])?(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/
};

const maxDecimalMantissaLen = 34;
const maxFixedMantissaLen = 38;

/**
 * Constructs a Writer to write input parameters into server readable representation
 * @param {Object} params - Metadata for input parameters to be written to the server
 * @param {number[]} params.types - Array of type codes for each parameter
 * @param {number[]} params.fractions - Array of the fraction / scale of each parameter
 * (fraction metadata is only necessary for FIXED / DECIMAL types)
 * @param {Object} options - Stores options to modify the way data types are written
 */
function Writer(params, options) {
  this._types = params.types.map(normalizeType);
  this._fractions = params.fractions;
  this.reset();
  this._useCesu8 = (options && options.useCesu8 === true);
  this._spatialTypes = ((options && options.spatialTypes === 1) ? 1 : 0);
}

function normalizeType(type) {
  return NormalizedTypeCode[type];
}

Writer.prototype.clear = function clear() {
  this._params = false;
  this._buffers = [];
  this._bytesWritten = 0;
  this._argumentCount = 0;
};

Writer.prototype.reset = function reset() {
  this._lobs = [];
  this.clear();
};

Writer.prototype.setValues = function setValues(values) {
  this.reset();
  for (var i = 0; i < values.length; i++) {
    this.add(this._types[i], values[i], this._fractions ? this._fractions[i] : undefined);
  }
  this._params = true;
};

exports.create = function createWriter(params, options) {
  var writer = new Writer(params, options);
  writer.setValues(params.values);
  return writer;
};

Object.defineProperties(Writer.prototype, {
  hasParameters: {
    get: function hasParameters() {
      return this._params;
    }
  },
  finished: {
    get: function isFinished() {
      return !this._lobs.length && !this._buffers.length;
    }
  },
  length: {
    get: function getLength() {
      return this._bytesWritten;
    }
  }
});

Writer.prototype.add = function add(type, value, fraction) {
  if (typeof value === 'undefined' || value === null) {
    this.pushNull(type);
  } else if (type === TypeCode.DECIMAL || type === TypeCode.FIXED8
    || type === TypeCode.FIXED12 || type === TypeCode.FIXED16) {
    this[type](value, fraction);
  } else {
    this[type](value);
  }
};

function storeErrorOnStream (err) {
  this._errored = err;
}

Writer.prototype.finializeParameters = function finializeParameters(
  bytesRemainingForLOBs, cb) {
  var self = this;
  var stream, header;
  this._streamErrorListeners = [];

  this._lobs.forEach((stream) => {
    if (stream._readableState.errored) {
      cb(stream._readableState.errored);
      return;
    }
    var errorListener = storeErrorOnStream.bind(stream);
    self._streamErrorListeners.push(errorListener); // keep track so it can
                                                    // be removed later
    stream.once('error', errorListener);
  });

  function finalize() {
    /* jshint bitwise:false */
    // update lob options in header
    header[1] |= LobOptions.LAST_DATA;
    // remove current lob from stack
    if(self._streamErrorListeners && self._streamErrorListeners.length) {
      stream.removeListener('error', self._streamErrorListeners[0]);
      self._streamErrorListeners.shift();
    }
    if (stream instanceof LobTransform) {
      // Destory wrapping stream
      stream.destroy();
    }
    self._lobs.shift();
  }

  function cleanup() {
    // remove event listeners
    stream.removeListener('error', onerror);
    stream.removeListener('end', onend);
    stream.removeListener('readable', onreadable);
  }

  function onerror(err) {
    /* jshint validthis:true */
    cleanup();
    // stop appending on error
    cb(err);
  }

  function onend() {
    /* jshint validthis:true */
    cleanup();
    // finalize lob
    finalize();
    // process next lob in stack
    util.setImmediate(next);
  }

  function onreadable() {
    /* jshint validthis:true */
    var chunk = this.read(bytesRemainingForLOBs);
    if (chunk === null) {
      chunk = this.read();
    }
    if (chunk === null) {
      return;
    }
    // store lob length in header
    var length = header.readInt32LE(2);
    // readable events might not emit for every chunk so we handle all
    // avaliable chunks immediately
    while (chunk !== null) {
      if (chunk.length > bytesRemainingForLOBs) {
        cleanup();
        return cb(createReadStreamError());
      }
      // increase lob length
      length += chunk.length;
      // push chunk
      self.push(chunk);
      bytesRemainingForLOBs -= chunk.length;
      // stop appending if there is no remaining space
      if (bytesRemainingForLOBs === 0) {
        break;
      }
      
      chunk = this.read(bytesRemainingForLOBs);
      if (chunk === null) {
        chunk = this.read();
      }
    }
    // update lob length in header
    header.writeInt32LE(length, 2);

    if (bytesRemainingForLOBs === 0) {
      cleanup();
      // finalize lob if the stream has already ended
      // because of cleanup we don't get end event in this case
      var state = this._readableState;
      if (state.ended && !state.length) {
        finalize();
      }
      // we are done
      cb(null);
    }
  }

  function next() {
    if (!self._lobs.length || bytesRemainingForLOBs <= 0) {
      return cb(null);
    }
    // set readable stream
    stream = self._lobs[0];
    // set lob header
    header = stream._header;
    // update lob options in header
    header[1] = LobOptions.DATA_INCLUDED;
    // update lob position in header
    var position = self._bytesWritten + 1;
    header.writeInt32LE(position, 6);
    // register event handlers
    stream.on('error', onerror);
    stream.on('end', onend);
    stream.on('readable', onreadable);
    onreadable.call(stream);
  }

  next();
};

Writer.prototype.getParameters = function getParameters(bytesAvailableForLOBs, cb) {
  var self = this;

  function done(err) {
    util.setImmediate(function () {
      if (err) {
        return cb(err);
      }
      var buffer = Buffer.concat(self._buffers, self._bytesWritten);
      self.clear();
      cb(null, buffer);
    });
  }
  var bytesRemainingForLOBs = bytesAvailableForLOBs - this._bytesWritten;
  this.finializeParameters(bytesRemainingForLOBs, done);
};

Writer.prototype.finalizeWriteLobRequest = function finalizeWriteLobRequest(
  bytesRemaining, cb) {
  var self = this;
  var stream, header;

  this._lobs.forEach((stream) => {
    if (stream._errored) {
      cb(stream._errored);
      return;
    }
  });

  function cleanup() {
    // remove event listeners
    stream.removeListener('error', onerror);
    stream.removeListener('end', onend);
    stream.removeListener('readable', onreadable);
  }

  function onerror(err) {
    /* jshint validthis:true */
    cleanup();
    // stop appending on error
    cb(err);
  }

  function finalize() {
    /* jshint bitwise:false */
    // update lob options in header
    header[8] |= LobOptions.LAST_DATA;
    // remove current lob from stack
    if(self._streamErrorListeners && self._streamErrorListeners.length) {
      stream.removeListener('error', self._streamErrorListeners[0]);
      self._streamErrorListeners.shift();
    }
    if (stream instanceof LobTransform) {
      // Destory wrapping stream
      stream.destroy();
    }
    self._lobs.shift();
  }

  function onend() {
    /* jshint validthis:true */
    cleanup();
    // finalize lob
    finalize();
    // process next lob in stack
    util.setImmediate(next);
  }

  function onreadable() {
    /* jshint validthis:true */
    var chunk = this.read(bytesRemaining);
    if (chunk === null) {
      chunk = this.read();
    }
    if (chunk === null) {
      return;
    }
    // store lob length in header
    var length = header.readInt32LE(17);
    // readable events might not emit for every chunk so we handle all
    // avaliable chunks immediately
    while (chunk !== null) {
      if (chunk.length > bytesRemaining) {
        cleanup();
        return cb(createReadStreamError());
      }
      // increase lob length
      length += chunk.length;
      // push chunk
      self.push(chunk);
      bytesRemaining -= chunk.length;
      // stop appending if there is no remaining space
      if (bytesRemaining === 0) {
        break;
      }
      
      chunk = this.read(bytesRemaining);
      if (chunk === null) {
        chunk = this.read();
      }
    }
    // update lob length in header
    header.writeInt32LE(length, 17);

    if (bytesRemaining === 0) {
      cleanup();
      // finalize lob if the stream has already ended
      // because of cleanup we don't get end event in this case
      var state = this._readableState;
      if (state.ended && !state.length) {
        finalize();
      }
      // we are done
      cb(null);
    }
  }

  function next() {
    // no more lobs to write or not enough bytes remaining for next lob
    if (!self._lobs.length || bytesRemaining <= WRITE_LOB_REQUEST_HEADER_LENGTH) {
      return cb(null);
    }
    // set reabable stream
    stream = self._lobs[0];
    // set lob header
    header = new Buffer(WRITE_LOB_REQUEST_HEADER_LENGTH);
    // set locatorId
    stream._locatorId.copy(header, 0);
    // update lob options in header
    header[8] = LobOptions.DATA_INCLUDED;
    // offset 0 means append
    header.fill(0x00, 9, 17);
    // length
    header.writeInt32LE(0, 17);
    // push header
    self.push(header);
    bytesRemaining -= header.length;
    // increase count
    self._argumentCount += 1;
    // register event handlers
    stream.on('error', onerror);
    stream.on('end', onend);
    stream.on('readable', onreadable);
    onreadable.call(stream);
  }

  next();
};

Writer.prototype.getWriteLobRequest = function getWriteLobRequest(
  bytesRemaining, cb) {
  var self = this;

  function done(err) {
    util.setImmediate(function () {
      if (err) {
        return cb(err);
      }
      var part = {
        argumentCount: self._argumentCount,
        buffer: Buffer.concat(self._buffers, self._bytesWritten)
      };
      self.clear();
      cb(null, part);
    });
  }
  this.clear();
  this.finalizeWriteLobRequest(bytesRemaining, done);
};

Writer.prototype.update = function update(writeLobReply) {
  var stream, locatorId;
  for (var i = 0; i < this._lobs.length; i++) {
    locatorId = writeLobReply[i];
    stream = this._lobs[i];
    if (Buffer.isBuffer(locatorId) && util.isObject(stream)) {
      stream._header = undefined;
      stream._locatorId = locatorId;
    }
  }
};

Writer.prototype.push = function push(buffer) {
  this._bytesWritten += buffer.length;
  this._buffers.push(buffer);
};

Writer.prototype.pushNull = function pushNull(type) {
  /* jshint bitwise:false */
  var nullTypeCode;
  switch(type) {
    case TypeCode.LONGDATE:
    case TypeCode.SECONDDATE:
      nullTypeCode = TypeCode.TIMESTAMP | 0x80;
      break;
    case TypeCode.DAYDATE:
      nullTypeCode = TypeCode.DATE | 0x80;
      break;
    case TypeCode.SECONDTIME:
      nullTypeCode = TypeCode.TIME | 0x80;
      break;
    case TypeCode.ST_GEOMETRY:
      nullTypeCode = TypeCode.BINARY | 0x80;
      break;
    default:
      nullTypeCode = NormalizedTypeCode[type] | 0x80;
  }
  var buffer = new Buffer([nullTypeCode]);
  this.push(buffer);
};

Writer.prototype.pushLob = function pushLob(buffer, value) {
  this.push(buffer);
  var stream;
  if (Buffer.isBuffer(value)) {
    stream = new Readable();
    stream.push(value);
    stream.push(null);
  } else if (value instanceof Readable) {
    if (value.readableObjectMode) {
      // Wrap the stream with another stream with objectMode false, so that a given 
      // number of bytes can be read at a time not each object
      stream = new LobTransform(value, ['error'], { objectMode: false });
    } else {
      stream = value;
    }
  } else if (value.readable === true) {
    stream = new Readable().wrap(value);
  } else {
    throw createInputError('LOB');
  }
  if (stream) {
    stream._header = buffer;
    this._lobs.push(stream);
  }
};

Writer.prototype[TypeCode.TINYINT] = function writeTinyInt(value) {
  if (isNaN(value)) {
    throw createInputError('TINYINT');
  }
  var buffer = new Buffer(2);
  buffer[0] = TypeCode.TINYINT;
  buffer.writeUInt8(value, 1);
  this.push(buffer);
};

Writer.prototype[TypeCode.SMALLINT] = function writeSmallInt(value) {
  if (isNaN(value)) {
    throw createInputError('SMALLINT');
  }
  var buffer = new Buffer(3);
  buffer[0] = TypeCode.SMALLINT;
  buffer.writeInt16LE(value, 1);
  this.push(buffer);
};

Writer.prototype[TypeCode.INT] = function writeInt(value) {
  if (isNaN(value)) {
    throw createInputError('INT');
  }
  var buffer = new Buffer(5);
  buffer[0] = TypeCode.INT;
  buffer.writeInt32LE(value, 1);
  this.push(buffer);
};

Writer.prototype[TypeCode.BIGINT] = function writeBigInt(value) {
  if (isNaN(value)) {
    throw createInputError('BIGINT');
  }
  var buffer = new Buffer(9);
  buffer[0] = TypeCode.BIGINT;
  bignum.writeInt64LE(buffer, value, 1);
  this.push(buffer);
};

Writer.prototype[TypeCode.REAL] = function writeReal(value) {
  if (isNaN(value)) {
    throw createInputError('REAL');
  }
  var buffer = new Buffer(5);
  buffer[0] = TypeCode.REAL;
  buffer.writeFloatLE(value, 1);
  this.push(buffer);
};

Writer.prototype[TypeCode.DOUBLE] = function writeDouble(value) {
  if (isNaN(value)) {
    throw createInputError('DOUBLE');
  }
  var buffer = new Buffer(9);
  buffer[0] = TypeCode.DOUBLE;
  buffer.writeDoubleLE(value, 1);
  this.push(buffer);
};

Writer.prototype[TypeCode.DECIMAL] = function writeDecimal(value, fraction) {
  var decimal;
  if (util.isString(value)) {
    decimal = stringToDecimal(value, maxDecimalMantissaLen, fraction);
  } else if (util.isNumber(value)) {
    decimal = stringToDecimal(value.toExponential(), maxDecimalMantissaLen, fraction);
  } else {
    throw createInputError('DECIMAL');
  }
  var buffer = new Buffer(17);
  buffer[0] = TypeCode.DECIMAL;
  bignum.writeDec128(buffer, decimal, 1);
  this.push(buffer);
};

function toFixedDecimal(value, fraction, typeStr) {
  var decimal;
  // Convert to decimal object with maximum number of digits 38
  if (util.isString(value)) {
    decimal = stringToDecimal(value, maxFixedMantissaLen, fraction, typeStr);
  } else if (util.isNumber(value)) {
    decimal = stringToDecimal(value.toExponential(), maxFixedMantissaLen, fraction, typeStr);
  } else {
    throw createInputError(typeStr);
  }
  // Truncate decimal with the minimum exponent being -fraction, so there are at most
  // 'fraction' digits after the decimal
  decimal = truncateDecimalToExp(decimal, -fraction);

  if (decimal.m.length + decimal.e + fraction > maxFixedMantissaLen) {
    throw createInputError(typeStr); // Numeric overflow, greater than maximum precision 
  }

  if ((-decimal.e) < fraction) {
    decimal.m += zeropad.ZEROS[fraction + decimal.e];
  }
  return decimal;
}

function writeFixed16Buffer(decimal, buffer, offset) {
  bignum.writeUInt128LE(buffer, decimal.m, offset);
  if (decimal.s === -1) {
    // Apply two's complement conversion
    var extraOne = true;
    for (var i = offset; i < offset + 16; i++) {
      if (extraOne) {
        if (buffer[i] !== 0) {
          buffer[i] = 0xff - buffer[i] + 1;
          extraOne = false;
        } else {
          buffer[i] = 0;
        }
      } else {
        buffer[i] = 0xff - buffer[i];
      }
    }
  }
}

function checkFixedOverflow(decimal, extBuffer, byteLimit, typeStr) {
  if (decimal.s === -1) {
    for (var i = byteLimit; i < 16; ++i) {
      if (extBuffer[i] != 0xff) {
        throw createInputError(typeStr);
      }
    }
    if ((extBuffer[byteLimit - 1] & 0x80) == 0) {
      throw createInputError(typeStr);
    }
  } else {
    for (var i = byteLimit; i < 16; ++i) {
      if (extBuffer[i] != 0) {
        throw createInputError(typeStr);
      }
    }
    if (extBuffer[byteLimit - 1] & 0x80) {
      throw createInputError(typeStr);
    }
  }
}

Writer.prototype[TypeCode.FIXED8] = function writeFixed8(value, fraction) {
  var extBuffer = new Buffer(16);
  var decimal = toFixedDecimal(value, fraction, 'FIXED8');
  writeFixed16Buffer(decimal, extBuffer, 0);
  // Check that the representation does not exceed 8 bytes
  checkFixedOverflow(decimal, extBuffer, 8, 'FIXED8');
  var buffer = new Buffer(9);
  buffer[0] = TypeCode.FIXED8;
  extBuffer.copy(buffer, 1, 0, 8);
  this.push(buffer);
}

Writer.prototype[TypeCode.FIXED12] = function writeFixed12(value, fraction) {
  var extBuffer = new Buffer(16);
  var decimal = toFixedDecimal(value, fraction, 'FIXED12');
  writeFixed16Buffer(decimal, extBuffer, 0);
  // Check that the representation does not exceed 12 bytes
  checkFixedOverflow(decimal, extBuffer, 12, 'FIXED12');
  var buffer = new Buffer(13);
  buffer[0] = TypeCode.FIXED12;
  extBuffer.copy(buffer, 1, 0, 12);
  this.push(buffer);
}

Writer.prototype[TypeCode.FIXED16] = function writeFixed16(value, fraction) {
  var buffer = new Buffer(17);
  buffer[0] = TypeCode.FIXED16;
  writeFixed16Buffer(toFixedDecimal(value, fraction, 'FIXED16'), buffer, 1);
  this.push(buffer);
}

Writer.prototype[TypeCode.NSTRING] = function writeNString(value) {
  this.writeCharacters(TypeCode.NSTRING, value);
};

Writer.prototype[TypeCode.STRING] = function writeString(value) {
  this.writeCharacters(TypeCode.STRING, value);
};

Writer.prototype.writeCharacters = function writeCharacters(type, value) {
  if (typeof value !== 'string') {
    throw new TypeError('Argument must be a string');
  }

  var encoded = util.convert.encode(value, this._useCesu8);
  this.push(createBinaryOutBuffer(type, encoded));
};

Writer.prototype[TypeCode.BINARY] = function writeBinary(value) {
  if (!Buffer.isBuffer(value)) {
    throw createInputError('BINARY');
  }
  this.push(createBinaryOutBuffer(TypeCode.BINARY, value));
};

Writer.prototype[TypeCode.BLOB] = function writeBLob(value) {
  var buffer = new Buffer(10);
  buffer.fill(0x00);
  buffer[0] = TypeCode.BLOB;
  if (util.isString(value)) {
    value = util.convert.encode(value, this._useCesu8);
  }
  this.pushLob(buffer, value);
};

Writer.prototype[TypeCode.CLOB] = function writeCLob(value) {
  var buffer = new Buffer(10);
  buffer.fill(0x00);
  buffer[0] = TypeCode.CLOB;
  if (util.isString(value)) {
    value = new Buffer(value, 'ascii');
  }
  this.pushLob(buffer, value);
};

Writer.prototype[TypeCode.NCLOB] = function writeNCLob(value) {
  var buffer = new Buffer(10);
  buffer.fill(0x00);
  buffer[0] = TypeCode.NCLOB;
  if (util.isString(value)) {
    value = util.convert.encode(value, this._useCesu8);
  }
  this.pushLob(buffer, value);
};

Writer.prototype[TypeCode.TIME] = function writeTime(value) {
  /* jshint bitwise:false */
  var hours, minutes, milliseconds;
  if (util.isString(value)) {
    var time = value.match(REGEX.TIME);
    if (!time) {
      throw createInputError('TIME');
    }
    hours = ~~time[1];
    minutes = ~~time[2];
    milliseconds = Math.round(time[3] * 1000);
  } else {
    throw createInputError('TIME');
  }
  var buffer = new Buffer(5);
  buffer[0] = TypeCode.TIME;
  buffer[1] = hours | 0x80;
  buffer[2] = minutes;
  buffer.writeUInt16LE(milliseconds, 3);
  this.push(buffer);
};

Writer.prototype[TypeCode.DATE] = function writeDate(value) {
  /* jshint bitwise:false */
  var year, month, day;
  if (util.isString(value)) {
    var date = value.match(REGEX.DATE);
    if (!date) {
      throw createInputError('DATE');
    }
    year = ~~date[1];
    month = ~~date[2] - 1;
    day = ~~date[3];
  } else {
    throw createInputError('DATE');
  }
  var buffer = new Buffer(5);
  buffer[0] = TypeCode.DATE;
  buffer.writeUInt16LE(year, 1);
  buffer[2] |= 0x80;
  buffer[3] = month;
  buffer[4] = day;
  this.push(buffer);
};

Writer.prototype[TypeCode.TIMESTAMP] = function writeTimestamp(value) {
  /* jshint bitwise:false */
  var year, month, day, hours, minutes, milliseconds;
  if (util.isString(value)) {
    var ts = value.match(REGEX.TIMESTAMP);
    if (!ts) {
      throw createInputError('TIMESTAMP');
    }
    year = ~~ts[1];
    month = ~~ts[2] - 1;
    day = ~~ts[3];
    hours = ~~ts[4];
    minutes = ~~ts[5];
    milliseconds = Math.round(ts[6] * 1000);
  } else {
    throw createInputError('TIMESTAMP');
  }
  var buffer = new Buffer(9);
  buffer[0] = TypeCode.TIMESTAMP;
  buffer.writeUInt16LE(year, 1);
  buffer[2] |= 0x80;
  buffer[3] = month;
  buffer[4] = day;
  buffer[5] = hours | 0x80;
  buffer[6] = minutes;
  buffer.writeUInt16LE(milliseconds, 7);
  this.push(buffer);
};

Writer.prototype[TypeCode.DAYDATE] = function writeDayDate(value) {
  /* jshint unused:false */
  var year, month, day;
  if (util.isString(value)) {
    var date = value.match(REGEX.DATE);
    if (!date) {
      throw createInputError('DATE');
    }
    year = ~~date[1];
    month = ~~date[2];
    day = ~~date[3];
  } else {
    throw createInputError('DATE');
  }
  if(isZeroDay(day, month, year)) {
    var buffer = new Buffer(5);
    buffer[0] = TypeCode.DAYDATE;
    buffer.writeUInt32LE(0, 1);
    this.push(buffer);
    return;
  }
  if(!isValidDay(day, month, year)) {
    throw createInputError('DAYDATE');
  }
  const dayDate = calendar.DAYDATE(year, month, day);
  var buffer = new Buffer(5);
  buffer[0] = TypeCode.DAYDATE;
  buffer.writeUInt32LE(dayDate, 1);
  this.push(buffer);
};

Writer.prototype[TypeCode.SECONDTIME] = function writeSecondTime(value) {
  /* jshint unused:false */
  var hours, minutes, seconds;
  if (util.isString(value)) {
    var ts = value.match(REGEX.TIME);
    if(!ts) {
      throw createInputError('SECONDTIME');
    }
    hours = ~~ts[1];
    minutes = ~~ts[2];
    seconds = ~~ts[3];
  } else {
    throw createInputError('SECONDTIME');
  }
  if(!isValidTime(seconds, minutes, hours)) {
    throw createInputError('SECONDTIME');
  }
  const timeValue = ((hours * 60) + minutes) * 60 + seconds;
  var buffer = new Buffer(5);
  buffer[0] = TypeCode.SECONDTIME;
  buffer.writeUInt32LE(timeValue + 1, 1);
  this.push(buffer);
};

Writer.prototype[TypeCode.LONGDATE] = function writeLongDate(value) {
  /* jshint unused:false */
  var year, month, day, hours, minutes, seconds, nanoseconds;
  if (util.isString(value)) {
    var ts = value.match(REGEX.TIMESTAMP);
    if (!ts) {
      throw createInputError('LONGDATE');
    }
    year = ~~ts[1];
    month = ~~ts[2];
    day = ~~ts[3];
    hours = ~~ts[4];
    minutes = ~~ts[5];
    seconds = ~~ts[6];
    nanoseconds = ~~((ts[6] * 1000000000) % 1000000000);
  } else {
    throw createInputError('LONGDATE');
  }
  if(isZeroDay(day, month, year) && isZeroTime(seconds, minutes, hours) && nanoseconds === 0) {
    var buffer = new Buffer(9);
    buffer[0] = TypeCode.LONGDATE;
    bignum.writeUInt64LE(buffer, 0, 1);
    this.push(buffer);
    return;
  }
  if(!isValidDay(day, month, year) || !isValidTime(seconds, minutes, hours)) {
    throw createInputError('LONGDATE');
  }
  const dayDate = calendar.DAYDATE(year, month, day);
  const dayFactor = BigInt(10000000) * BigInt(60 * 60 * 24);
  const timeValue = BigInt(((hours * 60) + minutes) * 60 + seconds) * BigInt(10000000) + BigInt(~~(nanoseconds / 100));
  const longDate = BigInt(dayDate - 1) * dayFactor + timeValue + BigInt(1);
  var buffer = new Buffer(9);
  buffer[0] = TypeCode.LONGDATE;
  bignum.writeUInt64LE(buffer, String(longDate), 1);
  this.push(buffer);
};

Writer.prototype[TypeCode.SECONDDATE] = function writeSecondDate(value) {
  /* jshint unused:false */
  var year, month, day, hours, minutes, seconds;
  if (util.isString(value)) {
    var ts = value.match(REGEX.TIMESTAMP);
    if (!ts) {
      throw createInputError('SECONDDATE');
    }
    year = ~~ts[1];
    month = ~~ts[2];
    day = ~~ts[3];
    hours = ~~ts[4];
    minutes = ~~ts[5];
    seconds = ~~ts[6];
  } else {
    throw createInputError('SECONDDATE');
  }
  if(isZeroDay(day, month, year) && isZeroTime(seconds, minutes, hours)) {
    var buffer = new Buffer(9);
    buffer[0] = TypeCode.SECONDDATE;
    bignum.writeUInt64LE(buffer, 0, 1);
    this.push(buffer);
    return;
  }
  if(!isValidDay(day, month, year) || !isValidTime(seconds, minutes, hours)) {
    throw createInputError('SECONDDATE');
  }
  const dayDate = calendar.DAYDATE(year, month, day);
  const dayFactor = 60 * 60 * 24;
  const timeValue = ((hours * 60) + minutes) * 60 + seconds;
  const seconddate = BigInt(dayDate - 1) * BigInt(dayFactor) + BigInt(timeValue + 1);
  var buffer = new Buffer(9);
  buffer[0] = TypeCode.SECONDDATE;
  bignum.writeUInt64LE(buffer, String(seconddate), 1)
  this.push(buffer);
};

Writer.prototype[TypeCode.ST_GEOMETRY] = function writeST_GEOMETRY(value) {
  if (Buffer.isBuffer(value)) {
    this.push(createBinaryOutBuffer(TypeCode.BINARY, value));
  } else if (util.isString(value)) {
    if (this._spatialTypes === 1) {
      this.writeCharacters(TypeCode.STRING, value);
    } else {
      this.push(createBinaryOutBuffer(TypeCode.BINARY, Buffer.from(value, 'hex')));
    }
  } else {
    throw new TypeError('Argument must be a string or Buffer');
  }
}

Writer.prototype[TypeCode.BOOLEAN] = function writeBoolean(value) {
  var buffer = new Buffer(2);
  buffer[0] = TypeCode.BOOLEAN;
  // 0x02 - True, 0x01 - Null, 0x00 - False
  if (value === null) {
    buffer[1] = 0x01;
  } else if (util.isString(value)) {
    if (value.toUpperCase() === 'TRUE' || value === '1') {
      buffer[1] = 0x02;
    } else if (value.toUpperCase() === 'FALSE' || value === '0') {
      buffer[1] = 0x00;
    } else if (value.toUpperCase() === 'UNKNOWN' || value.length === 0) {
      buffer[1] = 0x01;
    } else {
      throw createInputError('BOOLEAN');
    }
  } else if (util.isNumber(value)) {
    buffer[1] = value == 0 ? 0x00 : 0x02;
  } else if (value === true) {
    buffer[1] = 0x02;
  } else if (value === false) {
    buffer[1] = 0x00;
  } else {
    throw createInputError('BOOLEAN');
  }

  this.push(buffer);
}

function setChar(str, i, c) {
    if(i >= str.length) return str;
    return str.substring(0, i) + c + str.substring(i + 1);
}

function trimLeadingZeroes(str) {
  var i = 0;
  while(i < str.length && str[i] === '0') {
    ++i;
  }
  return str.substring(i);
}

function trimTrailingZeroes(str) {
  var i = str.length - 1;
  while(i >= 0 && str[i] === '0') {
    --i;
  }
  return str.substring(0, i + 1);
}

function stringToDecimal(str, maxMantissaLen, fraction, typeStr) {
  /* jshint bitwise:false */
  var dec = str.match(REGEX.DECIMAL);
  // REGEX.DECIMAL will match "." and "" despite these being invalid.
  if (!dec || str === "." || str === "") {
    throw createInputError(typeStr === undefined ? 'DECIMAL' : typeStr);
  }
  var sign = dec[1] === '-' ? -1 : 1;
  var mInt = dec[2] || '';
  var mFrac = dec[3] || '';
  var exp = ~~dec[4];

  mFrac = trimTrailingZeroes(mFrac);
  var mantissa = trimLeadingZeroes(mInt + mFrac);
  if(mantissa.length === 0) mantissa = "0";
  exp -= mFrac.length

  // Fit to maxMantissaLen digits and increment exp appropriately
  if(mantissa.length > maxMantissaLen) {
    var followDigit = mantissa[maxMantissaLen];
    exp += (mantissa.length - maxMantissaLen)
    mantissa = mantissa.substring(0, maxMantissaLen);
    // When writing a floating point decimal (fraction > maxMantissaLen or
    // fraction === undefined), we round to the max mantissa size, but with
    // fixed we truncate to the max mantissa size
    if((fraction === undefined || fraction > maxMantissaLen) && followDigit > '4') {
      // round up
      var i = maxMantissaLen - 1;
      while(i >= 0 && mantissa[i] === '9') {
        i -= 1;
      }
      // i = index of first non-9 digit from back
      if(i === -1) {
        exp += mantissa.length;
        mantissa = "1";
      } else {
        exp += mantissa.length - 1 - i;
        mantissa = mantissa.substring(0, i + 1);
        mantissa = setChar(mantissa, i, String.fromCharCode(mantissa.charCodeAt(i) + 1));
      }
    } else if(mantissa[maxMantissaLen - 1] === '0') {
      var trimmed = trimTrailingZeroes(mantissa);
      exp += (maxMantissaLen - trimmed.length);
      mantissa = trimmed;
    }
  }

  return {
    s: sign,
    m: mantissa,
    e: exp
  };
}

function truncateDecimalToExp(decimal, minExp) {
  var mantissa = decimal.m;
  var exp = decimal.e;
  var calcMaxMantissaLength;
  if (exp < minExp) {
    // Shift the max mantissa length such that the exponent is minExp
    calcMaxMantissaLength = exp + mantissa.length - minExp;
    if (calcMaxMantissaLength <= 0) {
      // All digits are truncated away
      return {s: 1, m: "0", e: minExp};
    }
  }

  // truncate to calcMaxMantissaLen digits and increment exp appropriately
  if(calcMaxMantissaLength && mantissa.length > calcMaxMantissaLength) {
    exp += (mantissa.length - calcMaxMantissaLength);
    mantissa = mantissa.substring(0, calcMaxMantissaLength);
    // No need to trim trailing zeros since FIXED types will add zeros to
    // match minExp
  }

  return {
    s: decimal.s,
    m: mantissa,
    e: exp
  };
}

function createInputError(type) {
  return new Error(util.format('Wrong input for %s type', type));
}

function createNotImplementedError() {
  return new Error('Not implemented yet');
}

function createReadStreamError() {
  return new Error('Chunk length larger than remaining bytes');
}

function createBinaryOutBuffer(type, value) {
  var length = value.length;
  var buffer;
  if (length <= common.DATA_LENGTH_MAX1BYTE_LENGTH) {
    buffer = new Buffer(2 + length);
    buffer[0] = type;
    buffer[1] = length;
    value.copy(buffer, 2);
  } else if (length <= common.DATA_LENGTH_MAX2BYTE_LENGTH) {
    buffer = new Buffer(4 + length);
    buffer[0] = type;
    buffer[1] = common.DATA_LENGTH_2BYTE_LENGTH_INDICATOR;
    buffer.writeInt16LE(length, 2);
    value.copy(buffer, 4);
  } else {
    buffer = new Buffer(6 + length);
    buffer[0] = type;
    buffer[1] = common.DATA_LENGTH_4BYTE_LENGTH_INDICATOR;
    buffer.writeInt32LE(length, 2);
    value.copy(buffer, 6);
  }
  return buffer;
}

util.inherits(LobTransform, Transform);

// Wraps a Readable stream with a stream that is not in object mode
function LobTransform(source, events, options) {
  this._source = source;
  Transform.call(this, options);
  // Forward all events indicated to the LobTransform wrapper
  this._proxiedEvents = [];
  for (var event of events) {
    var listener = this.emit.bind(this, event);
    source.on(event, listener);
    this._proxiedEvents.push({eventName: event, listener: listener});
  }
  source.pipe(this);
}

LobTransform.prototype._transform = function _transform(chunk, encoding, cb) {
  this.push(chunk);
  cb();
}

LobTransform.prototype._destroy = function _destroy() {
  var self = this;
  this._proxiedEvents.forEach(function (value) {
    self._source.removeListener(value.eventName, value.listener);
  });
  this._source.unpipe(this);
}