feat: returnvalue token parser for fixed length types

Suraiya Hameed · Suraiya Hameed · commit afdb8008c6ee · 2018-05-15T14:18:37.000-07:00
diff --git a/src/dataTypes.js b/src/dataTypes.js
@@ -0,0 +1,84 @@
+/* @flow */
+
+const type = {
+  // FIXEDLENTYPE
+  [0x1F]: {
+    id: 0x1F,
+    type: 'NULL',
+    name: 'Null'
+  },
+  [0x30]: {
+    id: 0x30,
+    type: 'INT1',
+    name: 'TinyInt'
+  },
+  [0x32]: {
+    id: 0x32,
+    type: 'BIT',
+    name: 'Bit'
+  },
+  [0x34]: {
+    id: 0x34,
+    type: 'INT2',
+    name: 'SmallInt'
+  },
+  [0x38]: {
+    id: 0x38,
+    type: 'INT4',
+    name: 'Int'
+  },
+  [0x3A]: {
+    id: 0x3A,
+    type: 'DATETIM4',
+    name: 'SmallDateTime'
+  },
+  [0x3B]: {
+    id: 0x3B,
+    type: 'FLT4',
+    name: 'Real'
+  },
+  [0x3C]: {
+    id: 0x3C,
+    type: 'MONEY',
+    name: 'Money'
+  },
+  [0x3D]: {
+    id: 0x3D,
+    type: 'DATETIME',
+    name: 'DateTime'
+  },
+  [0x3E]: {
+    id: 0x3E,
+    type: 'FLT8',
+    name: 'Float'
+  },
+  [0x7A]: {
+    id: 0x7A,
+    type: 'MONEY4',
+    name: 'SmallMoney'
+  },
+  [0x7F]: {
+    id: 0x7F,
+    type: 'INT8',
+    name: 'BigInt'
+  },
+
+  //VARLENTYPE
+  [0x26]: {
+    id: 0x26,
+    name: 'IntN',
+    type: 'INTN',
+    LengthOfDataLength: 1
+  }
+};
+
+const typeByName = {};
+var keys = Object.keys(type);
+for (const key of keys) {
+  typeByName[type[key].name] = type[key];
+}
+
+module.exports.TYPE = type;
+
+// TODO: export typeByName as TYPES in index/tedious.js
+// module.exports.TYPE = typeByName;
diff --git a/src/reader.js b/src/reader.js
@@ -24,6 +24,7 @@ function nextToken(reader) {
     case 0xAD: return readLoginAckToken;
     case 0xA9: return readOrderToken;
     case 0x79: return readReturnStatus;
+    case 0xAC: return readReturnValueToken;
     default:
       console.log(reader.buffer.slice(reader.position - 1));
       throw new Error('Unknown token type ' + type.toString(16));
@@ -37,15 +38,17 @@ const Reader = module.exports = class Reader extends Transform {
   position: number
   buffer: Buffer
   version: number
+  options: ?any // assign connection.options
 
   stash: Array<any>
 
-  constructor(version: 0x07000000 | 0x07010000 | 0x71000001 | 0x72090002 | 0x730A0003 | 0x730B0003 | 0x74000004) {
+  constructor(version: 0x07000000 | 0x07010000 | 0x71000001 | 0x72090002 | 0x730A0003 | 0x730B0003 | 0x74000004, options: ?any) {
     super({ readableObjectMode: true });
 
     this.buffer = Buffer.alloc(0);
     this.version = version;
     this.position = 0;
+    this.options = options;
 
     this.stash = [];
 
@@ -76,6 +79,10 @@ const Reader = module.exports = class Reader extends Transform {
     return this.buffer.readUInt16LE(this.position + offset);
   }
 
+  readInt16LE(offset: number) : number {
+    return this.buffer.readInt16LE(this.position + offset);
+  }
+
   readUInt32LE(offset: number) : number {
     return this.buffer.readUInt32LE(this.position + offset);
   }
@@ -93,6 +100,19 @@ const Reader = module.exports = class Reader extends Transform {
     return 4294967296 * this.buffer.readUInt32LE(this.position + 4) + this.buffer.readUInt32LE(this.position);
   }
 
+  readInt64LE(offset: number) {
+    // TODO: This can overflow
+    return 4294967296 * this.buffer.readInt32LE(this.position + 4) + (this.buffer[this.position + 4] & (0x80 === 0x80 ? 1 : -1)) * this.buffer.readUInt32LE(this.position);
+  }
+
+  readFloatLE(offset: number) {
+    return this.buffer.readFloatLE(this.position + offset);
+  }
+
+  readDoubleLE(offset: number) {
+    return this.buffer.readDoubleLE(this.position + offset);
+  }
+
   _transform(chunk: Buffer | string, encoding: string | null, callback: (error: ?Error) => void) {
     if (!(chunk instanceof Buffer)) {
       return callback(new Error('Expected Buffer'));
@@ -133,3 +153,4 @@ const readInfoErrorToken = require('./tokens/infoerror/read');
 const readLoginAckToken = require('./tokens/loginack/read');
 const readOrderToken = require('./tokens/order/read');
 const readReturnStatus = require('./tokens/returnStatus/read');
+const readReturnValueToken = require('./tokens/returnvalue/read');
diff --git a/src/tokens/returnvalue/index.js b/src/tokens/returnvalue/index.js
@@ -0,0 +1,50 @@
+/* @flow */
+
+const Token = require('../../token');
+import type { TypeInfo } from '../../types';
+
+class ReturnValueToken extends Token {
+  paramOrdinal: ?number
+  paramName: ?string
+  status: ?number
+  userType: ?number
+  // TODO: parser flag
+  flags: {
+        nullable: ?boolean,
+        caseSensitive: ?boolean,
+        updateable: ?boolean,
+        identity: ?boolean,
+        computed: ?boolean,
+        reservedODBC: ?boolean,
+        fixedLenCLRType: ?boolean,
+        encrypted: ?boolean
+    }
+  typeInfo: ?TypeInfo
+  valueLength: ?number
+  value: ?any
+
+  constructor() {
+    super(0xAC);
+
+    this.paramOrdinal = undefined;
+    this.paramName = undefined;
+    this.status = undefined;
+    this.userType = undefined;
+    this.flags = {
+      nullable: undefined,
+      caseSensitive: undefined,
+      updateable: undefined,
+      identity: undefined,
+      computed: undefined,
+      reservedODBC: undefined,
+      fixedLenCLRType: undefined,
+      encrypted: undefined
+    };
+    this.typeInfo = undefined;
+    this.valueLength = undefined;
+    this.value = undefined;
+  }
+}
+module.exports = ReturnValueToken;
+
+ReturnValueToken.read = require('./read');
diff --git a/src/tokens/returnvalue/read.js b/src/tokens/returnvalue/read.js
@@ -0,0 +1,128 @@
+/* @flow */
+
+import type Reader from '../../reader';
+import type { TypeInfo } from '../../types';
+
+function readReturnValueToken(reader: Reader) {
+  const token = new ReturnValueToken();
+
+  let offset = 0;
+  token.paramOrdinal = reader.readUInt16LE(offset);
+  offset += 2;
+  const paramLength = reader.readUInt8(offset) * 2;
+  offset += 1;
+  token.paramName = reader.readString('ucs2', offset, offset + paramLength);
+  offset += paramLength;
+
+  token.status = reader.readUInt8(offset);
+  offset += 1;
+  reader.consumeBytes(offset);
+
+  reader.stash.push(token);
+  return parseUserType;
+}
+
+function parseUserType(reader: Reader) {
+  if (reader.version < 0x72090002) {
+    return parseUserType_7_0;
+  } else {
+    return parseUserType_7_2;
+  }
+}
+
+function parseUserType_7_0(reader: Reader) {
+  if (!reader.bytesAvailable(2)) {
+    return;
+  }
+
+  const userType = reader.readUInt16LE(0);
+  reader.consumeBytes(2);
+
+  const token: ReturnValueToken = reader.stash[reader.stash.length - 1];
+  token.userType = userType;
+
+  return parseFlags;
+}
+
+function parseUserType_7_2(reader: Reader) {
+  if (!reader.bytesAvailable(4)) {
+    return;
+  }
+
+  const userType = reader.readUInt32LE(0);
+  reader.consumeBytes(4);
+
+  const token: ReturnValueToken = reader.stash[reader.stash.length - 1];
+  token.userType = userType;
+
+  return parseFlags;
+}
+
+function parseFlags(reader: Reader) {
+  if (reader.version < 0x72090002) {
+    return parseFlags_7_0;
+  } else if (reader.version < 0x74000004) {
+    return parseFlags_7_2;
+  } else {
+    return parseFlags_7_4;
+  }
+}
+
+
+function parseFlags_7_0(reader: Reader) {
+  if (!reader.bytesAvailable(2)) {
+    return;
+  }
+
+  // TODO: Implement flag parsing
+  const flags = reader.readUInt16LE(0); // eslint-disable-line no-unused-vars
+  reader.consumeBytes(2);
+
+  return parseTypeInfo;
+}
+
+function parseFlags_7_2(reader: Reader) {
+  if (!reader.bytesAvailable(2)) {
+    return;
+  }
+
+  // TODO: Implement flag parsing
+  const flags = reader.readUInt16LE(0); // eslint-disable-line no-unused-vars
+  reader.consumeBytes(2);
+
+  return parseTypeInfo;
+}
+
+function parseFlags_7_4(reader: Reader) {
+  if (!reader.bytesAvailable(2)) {
+    return;
+  }
+
+  // TODO: Implement flag parsing
+  const flags = reader.readUInt16LE(0); // eslint-disable-line no-unused-vars
+  reader.consumeBytes(2);
+
+  return parseTypeInfo;
+}
+
+function parseTypeInfo(reader: Reader) {
+  return readTypeInfo(parseValue, reader);
+}
+
+function parseValue(reader: Reader) {
+  const typeInfo: TypeInfo = reader.stash.pop();
+  const token: ReturnValueToken = reader.stash[reader.stash.length - 1];
+  token.typeInfo = typeInfo;
+  return valueParse(afterReadingValue, reader);
+}
+
+function afterReadingValue(reader: Reader) {
+  const token: ReturnValueToken = reader.stash.pop();
+  reader.push(token);
+  return reader.nextToken;
+}
+
+module.exports = readReturnValueToken;
+const ReturnValueToken = require('.');
+const { readTypeInfo } = require('../../types');
+const { valueParse } = require('../../value-parser');
diff --git a/src/value-parser.js b/src/value-parser.js
diff --git a/test/returnValue-test.js b/test/returnValue-test.js
