nosqldb-oraclejs/lib/thrift/ondb_types.js

Oracle NoSQL Database JS Driver

//
// Autogenerated by Thrift Compiler (0.12.0)
//
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
//
"use strict";

var thrift = require('thrift');
var Thrift = thrift.Thrift;
var Q = thrift.Q;


var ttypes = module.exports = {};
ttypes.TModuleInfo = {
  'PROXY_SERVER' : 2,
  'JAVA_CLIENT' : 3
};
ttypes.TVerifyError = {
  'INVALID_KVSTORE_Name' : 1,
  'INVALID_KVSTORE_HelperHosts' : 2,
  'Unsupported_Driver_ProtocolVersion' : 3
};
ttypes.TSyncPolicy = {
  'NO_SYNC' : 1,
  'SYNC' : 2,
  'WRITE_NO_SYNC' : 3
};
ttypes.TReplicaAckPolicy = {
  'ALL' : 1,
  'NONE' : 2,
  'SIMPLE_MAJORITY' : 3
};
ttypes.TReturnChoice = {
  'ALL' : 1,
  'NONE' : 2,
  'ONLY_VALUE' : 3,
  'ONLY_VERSION' : 4
};
ttypes.TSimpleConsistency = {
  'ABSOLUTE' : 1,
  'NONE_REQUIRED' : 2,
  'NONE_REQUIRED_NO_MASTER' : 3
};
ttypes.TTimeUnit = {
  'HOURS' : 1,
  'DAYS' : 2
};
ttypes.TDirection = {
  'FORWARD' : 1,
  'REVERSE' : 2,
  'UNORDERED' : 3
};
ttypes.TOperationType = {
  'DELETE' : 1,
  'DELETE_IF_VERSION' : 2,
  'PUT' : 3,
  'PUT_IF_ABSENT' : 4,
  'PUT_IF_PRESENT' : 5,
  'PUT_IF_VERSION' : 6
};
var TVerifyProperties = module.exports.TVerifyProperties = function(args) {
  this.kvStoreName = null;
  this.kvStoreHelperHosts = null;
  this.username = null;
  this.readZones = null;
  this.driverProtocolVersion = null;
  if (args) {
    if (args.kvStoreName !== undefined && args.kvStoreName !== null) {
      this.kvStoreName = args.kvStoreName;
    }
    if (args.kvStoreHelperHosts !== undefined && args.kvStoreHelperHosts !== null) {
      this.kvStoreHelperHosts = Thrift.copyList(args.kvStoreHelperHosts, [null]);
    }
    if (args.username !== undefined && args.username !== null) {
      this.username = args.username;
    }
    if (args.readZones !== undefined && args.readZones !== null) {
      this.readZones = Thrift.copyList(args.readZones, [null]);
    }
    if (args.driverProtocolVersion !== undefined && args.driverProtocolVersion !== null) {
      this.driverProtocolVersion = args.driverProtocolVersion;
    }
  }
};
TVerifyProperties.prototype = {};
TVerifyProperties.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.kvStoreName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        this.kvStoreHelperHosts = [];
        var _rtmp31 = input.readListBegin();
        var _size0 = _rtmp31.size || 0;
        for (var _i2 = 0; _i2 < _size0; ++_i2) {
          var elem3 = null;
          elem3 = input.readString();
          this.kvStoreHelperHosts.push(elem3);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.username = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.LIST) {
        this.readZones = [];
        var _rtmp35 = input.readListBegin();
        var _size4 = _rtmp35.size || 0;
        for (var _i6 = 0; _i6 < _size4; ++_i6) {
          var elem7 = null;
          elem7 = input.readString();
          this.readZones.push(elem7);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.I32) {
        this.driverProtocolVersion = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TVerifyProperties.prototype.write = function(output) {
  output.writeStructBegin('TVerifyProperties');
  if (this.kvStoreName !== null && this.kvStoreName !== undefined) {
    output.writeFieldBegin('kvStoreName', Thrift.Type.STRING, 1);
    output.writeString(this.kvStoreName);
    output.writeFieldEnd();
  }
  if (this.kvStoreHelperHosts !== null && this.kvStoreHelperHosts !== undefined) {
    output.writeFieldBegin('kvStoreHelperHosts', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRING, this.kvStoreHelperHosts.length);
    for (var iter8 in this.kvStoreHelperHosts) {
      if (this.kvStoreHelperHosts.hasOwnProperty(iter8)) {
        iter8 = this.kvStoreHelperHosts[iter8];
        output.writeString(iter8);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.username !== null && this.username !== undefined) {
    output.writeFieldBegin('username', Thrift.Type.STRING, 3);
    output.writeString(this.username);
    output.writeFieldEnd();
  }
  if (this.readZones !== null && this.readZones !== undefined) {
    output.writeFieldBegin('readZones', Thrift.Type.LIST, 4);
    output.writeListBegin(Thrift.Type.STRING, this.readZones.length);
    for (var iter9 in this.readZones) {
      if (this.readZones.hasOwnProperty(iter9)) {
        iter9 = this.readZones[iter9];
        output.writeString(iter9);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.driverProtocolVersion !== null && this.driverProtocolVersion !== undefined) {
    output.writeFieldBegin('driverProtocolVersion', Thrift.Type.I32, 5);
    output.writeI32(this.driverProtocolVersion);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TVerifyResult = module.exports.TVerifyResult = function(args) {
  this.isConnected = null;
  this.errorType = null;
  this.message = null;
  this.proxyProtocolVersion = 5;
  if (args) {
    if (args.isConnected !== undefined && args.isConnected !== null) {
      this.isConnected = args.isConnected;
    }
    if (args.errorType !== undefined && args.errorType !== null) {
      this.errorType = args.errorType;
    }
    if (args.message !== undefined && args.message !== null) {
      this.message = args.message;
    }
    if (args.proxyProtocolVersion !== undefined && args.proxyProtocolVersion !== null) {
      this.proxyProtocolVersion = args.proxyProtocolVersion;
    }
  }
};
TVerifyResult.prototype = {};
TVerifyResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.BOOL) {
        this.isConnected = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.errorType = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.message = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.I32) {
        this.proxyProtocolVersion = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TVerifyResult.prototype.write = function(output) {
  output.writeStructBegin('TVerifyResult');
  if (this.isConnected !== null && this.isConnected !== undefined) {
    output.writeFieldBegin('isConnected', Thrift.Type.BOOL, 1);
    output.writeBool(this.isConnected);
    output.writeFieldEnd();
  }
  if (this.errorType !== null && this.errorType !== undefined) {
    output.writeFieldBegin('errorType', Thrift.Type.I32, 2);
    output.writeI32(this.errorType);
    output.writeFieldEnd();
  }
  if (this.message !== null && this.message !== undefined) {
    output.writeFieldBegin('message', Thrift.Type.STRING, 3);
    output.writeString(this.message);
    output.writeFieldEnd();
  }
  if (this.proxyProtocolVersion !== null && this.proxyProtocolVersion !== undefined) {
    output.writeFieldBegin('proxyProtocolVersion', Thrift.Type.I32, 4);
    output.writeI32(this.proxyProtocolVersion);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TDurability = module.exports.TDurability = function(args) {
  this.masterSync = null;
  this.replicaAck = null;
  this.replicaSync = null;
  if (args) {
    if (args.masterSync !== undefined && args.masterSync !== null) {
      this.masterSync = args.masterSync;
    }
    if (args.replicaAck !== undefined && args.replicaAck !== null) {
      this.replicaAck = args.replicaAck;
    }
    if (args.replicaSync !== undefined && args.replicaSync !== null) {
      this.replicaSync = args.replicaSync;
    }
  }
};
TDurability.prototype = {};
TDurability.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.masterSync = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.replicaAck = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.replicaSync = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TDurability.prototype.write = function(output) {
  output.writeStructBegin('TDurability');
  if (this.masterSync !== null && this.masterSync !== undefined) {
    output.writeFieldBegin('masterSync', Thrift.Type.I32, 1);
    output.writeI32(this.masterSync);
    output.writeFieldEnd();
  }
  if (this.replicaAck !== null && this.replicaAck !== undefined) {
    output.writeFieldBegin('replicaAck', Thrift.Type.I32, 2);
    output.writeI32(this.replicaAck);
    output.writeFieldEnd();
  }
  if (this.replicaSync !== null && this.replicaSync !== undefined) {
    output.writeFieldBegin('replicaSync', Thrift.Type.I32, 3);
    output.writeI32(this.replicaSync);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TWriteOptions = module.exports.TWriteOptions = function(args) {
  this.durability = null;
  this.timeoutMs = null;
  this.returnChoice = null;
  this.updateTTL = false;
  if (args) {
    if (args.durability !== undefined && args.durability !== null) {
      this.durability = new ttypes.TDurability(args.durability);
    }
    if (args.timeoutMs !== undefined && args.timeoutMs !== null) {
      this.timeoutMs = args.timeoutMs;
    }
    if (args.returnChoice !== undefined && args.returnChoice !== null) {
      this.returnChoice = args.returnChoice;
    }
    if (args.updateTTL !== undefined && args.updateTTL !== null) {
      this.updateTTL = args.updateTTL;
    }
  }
};
TWriteOptions.prototype = {};
TWriteOptions.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.durability = new ttypes.TDurability();
        this.durability.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.timeoutMs = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.returnChoice = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.BOOL) {
        this.updateTTL = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TWriteOptions.prototype.write = function(output) {
  output.writeStructBegin('TWriteOptions');
  if (this.durability !== null && this.durability !== undefined) {
    output.writeFieldBegin('durability', Thrift.Type.STRUCT, 1);
    this.durability.write(output);
    output.writeFieldEnd();
  }
  if (this.timeoutMs !== null && this.timeoutMs !== undefined) {
    output.writeFieldBegin('timeoutMs', Thrift.Type.I64, 2);
    output.writeI64(this.timeoutMs);
    output.writeFieldEnd();
  }
  if (this.returnChoice !== null && this.returnChoice !== undefined) {
    output.writeFieldBegin('returnChoice', Thrift.Type.I32, 3);
    output.writeI32(this.returnChoice);
    output.writeFieldEnd();
  }
  if (this.updateTTL !== null && this.updateTTL !== undefined) {
    output.writeFieldBegin('updateTTL', Thrift.Type.BOOL, 4);
    output.writeBool(this.updateTTL);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TTimeConsistency = module.exports.TTimeConsistency = function(args) {
  this.permissibleLag = null;
  this.timeoutMs = null;
  if (args) {
    if (args.permissibleLag !== undefined && args.permissibleLag !== null) {
      this.permissibleLag = args.permissibleLag;
    }
    if (args.timeoutMs !== undefined && args.timeoutMs !== null) {
      this.timeoutMs = args.timeoutMs;
    }
  }
};
TTimeConsistency.prototype = {};
TTimeConsistency.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.I64) {
        this.permissibleLag = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.timeoutMs = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TTimeConsistency.prototype.write = function(output) {
  output.writeStructBegin('TTimeConsistency');
  if (this.permissibleLag !== null && this.permissibleLag !== undefined) {
    output.writeFieldBegin('permissibleLag', Thrift.Type.I64, 1);
    output.writeI64(this.permissibleLag);
    output.writeFieldEnd();
  }
  if (this.timeoutMs !== null && this.timeoutMs !== undefined) {
    output.writeFieldBegin('timeoutMs', Thrift.Type.I64, 2);
    output.writeI64(this.timeoutMs);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TVersionConsistency = module.exports.TVersionConsistency = function(args) {
  this.version = null;
  this.timeoutMs = null;
  if (args) {
    if (args.version !== undefined && args.version !== null) {
      this.version = args.version;
    }
    if (args.timeoutMs !== undefined && args.timeoutMs !== null) {
      this.timeoutMs = args.timeoutMs;
    }
  }
};
TVersionConsistency.prototype = {};
TVersionConsistency.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.version = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.timeoutMs = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TVersionConsistency.prototype.write = function(output) {
  output.writeStructBegin('TVersionConsistency');
  if (this.version !== null && this.version !== undefined) {
    output.writeFieldBegin('version', Thrift.Type.STRING, 1);
    output.writeBinary(this.version);
    output.writeFieldEnd();
  }
  if (this.timeoutMs !== null && this.timeoutMs !== undefined) {
    output.writeFieldBegin('timeoutMs', Thrift.Type.I64, 2);
    output.writeI64(this.timeoutMs);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TConsistency = module.exports.TConsistency = function(args) {
  this.simple = null;
  this.time = null;
  this.version = null;
  if (args) {
    if (args.simple !== undefined && args.simple !== null) {
      this.simple = args.simple;
    }
    if (args.time !== undefined && args.time !== null) {
      this.time = new ttypes.TTimeConsistency(args.time);
    }
    if (args.version !== undefined && args.version !== null) {
      this.version = new ttypes.TVersionConsistency(args.version);
    }
  }
};
TConsistency.prototype = {};
TConsistency.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.simple = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.time = new ttypes.TTimeConsistency();
        this.time.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRUCT) {
        this.version = new ttypes.TVersionConsistency();
        this.version.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TConsistency.prototype.write = function(output) {
  output.writeStructBegin('TConsistency');
  if (this.simple !== null && this.simple !== undefined) {
    output.writeFieldBegin('simple', Thrift.Type.I32, 1);
    output.writeI32(this.simple);
    output.writeFieldEnd();
  }
  if (this.time !== null && this.time !== undefined) {
    output.writeFieldBegin('time', Thrift.Type.STRUCT, 2);
    this.time.write(output);
    output.writeFieldEnd();
  }
  if (this.version !== null && this.version !== undefined) {
    output.writeFieldBegin('version', Thrift.Type.STRUCT, 3);
    this.version.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TReadOptions = module.exports.TReadOptions = function(args) {
  this.consistency = null;
  this.timeoutMs = null;
  if (args) {
    if (args.consistency !== undefined && args.consistency !== null) {
      this.consistency = new ttypes.TConsistency(args.consistency);
    }
    if (args.timeoutMs !== undefined && args.timeoutMs !== null) {
      this.timeoutMs = args.timeoutMs;
    }
  }
};
TReadOptions.prototype = {};
TReadOptions.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.consistency = new ttypes.TConsistency();
        this.consistency.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.timeoutMs = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TReadOptions.prototype.write = function(output) {
  output.writeStructBegin('TReadOptions');
  if (this.consistency !== null && this.consistency !== undefined) {
    output.writeFieldBegin('consistency', Thrift.Type.STRUCT, 1);
    this.consistency.write(output);
    output.writeFieldEnd();
  }
  if (this.timeoutMs !== null && this.timeoutMs !== undefined) {
    output.writeFieldBegin('timeoutMs', Thrift.Type.I64, 2);
    output.writeI64(this.timeoutMs);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TTimeToLive = module.exports.TTimeToLive = function(args) {
  this.value = null;
  this.timeUnit = null;
  if (args) {
    if (args.value !== undefined && args.value !== null) {
      this.value = args.value;
    }
    if (args.timeUnit !== undefined && args.timeUnit !== null) {
      this.timeUnit = args.timeUnit;
    }
  }
};
TTimeToLive.prototype = {};
TTimeToLive.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.I64) {
        this.value = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.timeUnit = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TTimeToLive.prototype.write = function(output) {
  output.writeStructBegin('TTimeToLive');
  if (this.value !== null && this.value !== undefined) {
    output.writeFieldBegin('value', Thrift.Type.I64, 1);
    output.writeI64(this.value);
    output.writeFieldEnd();
  }
  if (this.timeUnit !== null && this.timeUnit !== undefined) {
    output.writeFieldBegin('timeUnit', Thrift.Type.I32, 2);
    output.writeI32(this.timeUnit);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TRow = module.exports.TRow = function(args) {
  this.jsonRow = null;
  this.ttl = null;
  if (args) {
    if (args.jsonRow !== undefined && args.jsonRow !== null) {
      this.jsonRow = args.jsonRow;
    }
    if (args.ttl !== undefined && args.ttl !== null) {
      this.ttl = new ttypes.TTimeToLive(args.ttl);
    }
  }
};
TRow.prototype = {};
TRow.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.jsonRow = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.ttl = new ttypes.TTimeToLive();
        this.ttl.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TRow.prototype.write = function(output) {
  output.writeStructBegin('TRow');
  if (this.jsonRow !== null && this.jsonRow !== undefined) {
    output.writeFieldBegin('jsonRow', Thrift.Type.STRING, 1);
    output.writeString(this.jsonRow);
    output.writeFieldEnd();
  }
  if (this.ttl !== null && this.ttl !== undefined) {
    output.writeFieldBegin('ttl', Thrift.Type.STRUCT, 2);
    this.ttl.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TWriteResult = module.exports.TWriteResult = function(args) {
  this.currentRowVersion = null;
  this.previousRow = null;
  this.previousRowVersion = null;
  this.wasDeleted = null;
  this.expiration = 0;
  this.identityGeneratedValue = null;
  if (args) {
    if (args.currentRowVersion !== undefined && args.currentRowVersion !== null) {
      this.currentRowVersion = args.currentRowVersion;
    }
    if (args.previousRow !== undefined && args.previousRow !== null) {
      this.previousRow = new ttypes.TRow(args.previousRow);
    }
    if (args.previousRowVersion !== undefined && args.previousRowVersion !== null) {
      this.previousRowVersion = args.previousRowVersion;
    }
    if (args.wasDeleted !== undefined && args.wasDeleted !== null) {
      this.wasDeleted = args.wasDeleted;
    }
    if (args.expiration !== undefined && args.expiration !== null) {
      this.expiration = args.expiration;
    }
    if (args.identityGeneratedValue !== undefined && args.identityGeneratedValue !== null) {
      this.identityGeneratedValue = args.identityGeneratedValue;
    }
  }
};
TWriteResult.prototype = {};
TWriteResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.currentRowVersion = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.previousRow = new ttypes.TRow();
        this.previousRow.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.previousRowVersion = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.BOOL) {
        this.wasDeleted = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.I64) {
        this.expiration = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.STRING) {
        this.identityGeneratedValue = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TWriteResult.prototype.write = function(output) {
  output.writeStructBegin('TWriteResult');
  if (this.currentRowVersion !== null && this.currentRowVersion !== undefined) {
    output.writeFieldBegin('currentRowVersion', Thrift.Type.STRING, 1);
    output.writeBinary(this.currentRowVersion);
    output.writeFieldEnd();
  }
  if (this.previousRow !== null && this.previousRow !== undefined) {
    output.writeFieldBegin('previousRow', Thrift.Type.STRUCT, 2);
    this.previousRow.write(output);
    output.writeFieldEnd();
  }
  if (this.previousRowVersion !== null && this.previousRowVersion !== undefined) {
    output.writeFieldBegin('previousRowVersion', Thrift.Type.STRING, 3);
    output.writeBinary(this.previousRowVersion);
    output.writeFieldEnd();
  }
  if (this.wasDeleted !== null && this.wasDeleted !== undefined) {
    output.writeFieldBegin('wasDeleted', Thrift.Type.BOOL, 4);
    output.writeBool(this.wasDeleted);
    output.writeFieldEnd();
  }
  if (this.expiration !== null && this.expiration !== undefined) {
    output.writeFieldBegin('expiration', Thrift.Type.I64, 5);
    output.writeI64(this.expiration);
    output.writeFieldEnd();
  }
  if (this.identityGeneratedValue !== null && this.identityGeneratedValue !== undefined) {
    output.writeFieldBegin('identityGeneratedValue', Thrift.Type.STRING, 6);
    output.writeString(this.identityGeneratedValue);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TGetResult = module.exports.TGetResult = function(args) {
  this.currentRow = null;
  this.currentRowVersion = null;
  this.expiration = 0;
  if (args) {
    if (args.currentRow !== undefined && args.currentRow !== null) {
      this.currentRow = new ttypes.TRow(args.currentRow);
    }
    if (args.currentRowVersion !== undefined && args.currentRowVersion !== null) {
      this.currentRowVersion = args.currentRowVersion;
    }
    if (args.expiration !== undefined && args.expiration !== null) {
      this.expiration = args.expiration;
    }
  }
};
TGetResult.prototype = {};
TGetResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.currentRow = new ttypes.TRow();
        this.currentRow.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.currentRowVersion = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I64) {
        this.expiration = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TGetResult.prototype.write = function(output) {
  output.writeStructBegin('TGetResult');
  if (this.currentRow !== null && this.currentRow !== undefined) {
    output.writeFieldBegin('currentRow', Thrift.Type.STRUCT, 1);
    this.currentRow.write(output);
    output.writeFieldEnd();
  }
  if (this.currentRowVersion !== null && this.currentRowVersion !== undefined) {
    output.writeFieldBegin('currentRowVersion', Thrift.Type.STRING, 2);
    output.writeBinary(this.currentRowVersion);
    output.writeFieldEnd();
  }
  if (this.expiration !== null && this.expiration !== undefined) {
    output.writeFieldBegin('expiration', Thrift.Type.I64, 3);
    output.writeI64(this.expiration);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TFieldRange = module.exports.TFieldRange = function(args) {
  this.fieldName = null;
  this.startValue = null;
  this.startIsInclusive = null;
  this.endValue = null;
  this.endIsInclusive = null;
  if (args) {
    if (args.fieldName !== undefined && args.fieldName !== null) {
      this.fieldName = args.fieldName;
    }
    if (args.startValue !== undefined && args.startValue !== null) {
      this.startValue = args.startValue;
    }
    if (args.startIsInclusive !== undefined && args.startIsInclusive !== null) {
      this.startIsInclusive = args.startIsInclusive;
    }
    if (args.endValue !== undefined && args.endValue !== null) {
      this.endValue = args.endValue;
    }
    if (args.endIsInclusive !== undefined && args.endIsInclusive !== null) {
      this.endIsInclusive = args.endIsInclusive;
    }
  }
};
TFieldRange.prototype = {};
TFieldRange.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.fieldName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.startValue = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.BOOL) {
        this.startIsInclusive = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.endValue = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.BOOL) {
        this.endIsInclusive = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TFieldRange.prototype.write = function(output) {
  output.writeStructBegin('TFieldRange');
  if (this.fieldName !== null && this.fieldName !== undefined) {
    output.writeFieldBegin('fieldName', Thrift.Type.STRING, 1);
    output.writeString(this.fieldName);
    output.writeFieldEnd();
  }
  if (this.startValue !== null && this.startValue !== undefined) {
    output.writeFieldBegin('startValue', Thrift.Type.STRING, 2);
    output.writeString(this.startValue);
    output.writeFieldEnd();
  }
  if (this.startIsInclusive !== null && this.startIsInclusive !== undefined) {
    output.writeFieldBegin('startIsInclusive', Thrift.Type.BOOL, 3);
    output.writeBool(this.startIsInclusive);
    output.writeFieldEnd();
  }
  if (this.endValue !== null && this.endValue !== undefined) {
    output.writeFieldBegin('endValue', Thrift.Type.STRING, 4);
    output.writeString(this.endValue);
    output.writeFieldEnd();
  }
  if (this.endIsInclusive !== null && this.endIsInclusive !== undefined) {
    output.writeFieldBegin('endIsInclusive', Thrift.Type.BOOL, 5);
    output.writeBool(this.endIsInclusive);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TRowAndMetadata = module.exports.TRowAndMetadata = function(args) {
  this.jsonRow = null;
  this.rowVersion = null;
  this.tableId = null;
  this.expiration = 0;
  if (args) {
    if (args.jsonRow !== undefined && args.jsonRow !== null) {
      this.jsonRow = args.jsonRow;
    }
    if (args.rowVersion !== undefined && args.rowVersion !== null) {
      this.rowVersion = args.rowVersion;
    }
    if (args.tableId !== undefined && args.tableId !== null) {
      this.tableId = args.tableId;
    }
    if (args.expiration !== undefined && args.expiration !== null) {
      this.expiration = args.expiration;
    }
  }
};
TRowAndMetadata.prototype = {};
TRowAndMetadata.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.jsonRow = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.rowVersion = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.tableId = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.I64) {
        this.expiration = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TRowAndMetadata.prototype.write = function(output) {
  output.writeStructBegin('TRowAndMetadata');
  if (this.jsonRow !== null && this.jsonRow !== undefined) {
    output.writeFieldBegin('jsonRow', Thrift.Type.STRING, 1);
    output.writeString(this.jsonRow);
    output.writeFieldEnd();
  }
  if (this.rowVersion !== null && this.rowVersion !== undefined) {
    output.writeFieldBegin('rowVersion', Thrift.Type.STRING, 2);
    output.writeBinary(this.rowVersion);
    output.writeFieldEnd();
  }
  if (this.tableId !== null && this.tableId !== undefined) {
    output.writeFieldBegin('tableId', Thrift.Type.I32, 3);
    output.writeI32(this.tableId);
    output.writeFieldEnd();
  }
  if (this.expiration !== null && this.expiration !== undefined) {
    output.writeFieldBegin('expiration', Thrift.Type.I64, 4);
    output.writeI64(this.expiration);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TMultiGetResult = module.exports.TMultiGetResult = function(args) {
  this.idToTableNames = null;
  this.rowsWithMetadata = null;
  if (args) {
    if (args.idToTableNames !== undefined && args.idToTableNames !== null) {
      this.idToTableNames = Thrift.copyMap(args.idToTableNames, [null]);
    }
    if (args.rowsWithMetadata !== undefined && args.rowsWithMetadata !== null) {
      this.rowsWithMetadata = Thrift.copyList(args.rowsWithMetadata, [ttypes.TRowAndMetadata]);
    }
  }
};
TMultiGetResult.prototype = {};
TMultiGetResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.MAP) {
        this.idToTableNames = {};
        var _rtmp311 = input.readMapBegin();
        var _size10 = _rtmp311.size || 0;
        for (var _i12 = 0; _i12 < _size10; ++_i12) {
          var key13 = null;
          var val14 = null;
          key13 = input.readI32();
          val14 = input.readString();
          this.idToTableNames[key13] = val14;
        }
        input.readMapEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        this.rowsWithMetadata = [];
        var _rtmp316 = input.readListBegin();
        var _size15 = _rtmp316.size || 0;
        for (var _i17 = 0; _i17 < _size15; ++_i17) {
          var elem18 = null;
          elem18 = new ttypes.TRowAndMetadata();
          elem18.read(input);
          this.rowsWithMetadata.push(elem18);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TMultiGetResult.prototype.write = function(output) {
  output.writeStructBegin('TMultiGetResult');
  if (this.idToTableNames !== null && this.idToTableNames !== undefined) {
    output.writeFieldBegin('idToTableNames', Thrift.Type.MAP, 1);
    output.writeMapBegin(Thrift.Type.I32, Thrift.Type.STRING, Thrift.objectLength(this.idToTableNames));
    for (var kiter19 in this.idToTableNames) {
      if (this.idToTableNames.hasOwnProperty(kiter19)) {
        var viter20 = this.idToTableNames[kiter19];
        output.writeI32(kiter19);
        output.writeString(viter20);
      }
    }
    output.writeMapEnd();
    output.writeFieldEnd();
  }
  if (this.rowsWithMetadata !== null && this.rowsWithMetadata !== undefined) {
    output.writeFieldBegin('rowsWithMetadata', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRUCT, this.rowsWithMetadata.length);
    for (var iter21 in this.rowsWithMetadata) {
      if (this.rowsWithMetadata.hasOwnProperty(iter21)) {
        iter21 = this.rowsWithMetadata[iter21];
        iter21.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TIteratorResult = module.exports.TIteratorResult = function(args) {
  this.iteratorId = null;
  this.result = null;
  this.hasMore = null;
  if (args) {
    if (args.iteratorId !== undefined && args.iteratorId !== null) {
      this.iteratorId = args.iteratorId;
    }
    if (args.result !== undefined && args.result !== null) {
      this.result = new ttypes.TMultiGetResult(args.result);
    }
    if (args.hasMore !== undefined && args.hasMore !== null) {
      this.hasMore = args.hasMore;
    }
  }
};
TIteratorResult.prototype = {};
TIteratorResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.I64) {
        this.iteratorId = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.result = new ttypes.TMultiGetResult();
        this.result.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.BOOL) {
        this.hasMore = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TIteratorResult.prototype.write = function(output) {
  output.writeStructBegin('TIteratorResult');
  if (this.iteratorId !== null && this.iteratorId !== undefined) {
    output.writeFieldBegin('iteratorId', Thrift.Type.I64, 1);
    output.writeI64(this.iteratorId);
    output.writeFieldEnd();
  }
  if (this.result !== null && this.result !== undefined) {
    output.writeFieldBegin('result', Thrift.Type.STRUCT, 2);
    this.result.write(output);
    output.writeFieldEnd();
  }
  if (this.hasMore !== null && this.hasMore !== undefined) {
    output.writeFieldBegin('hasMore', Thrift.Type.BOOL, 3);
    output.writeBool(this.hasMore);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TStatementResult = module.exports.TStatementResult = function(args) {
  this.planId = null;
  this.info = null;
  this.infoAsJson = null;
  this.isSuccessful = null;
  this.errorMessage = null;
  this.isCancelled = null;
  this.isDone = null;
  if (args) {
    if (args.planId !== undefined && args.planId !== null) {
      this.planId = args.planId;
    }
    if (args.info !== undefined && args.info !== null) {
      this.info = args.info;
    }
    if (args.infoAsJson !== undefined && args.infoAsJson !== null) {
      this.infoAsJson = args.infoAsJson;
    }
    if (args.isSuccessful !== undefined && args.isSuccessful !== null) {
      this.isSuccessful = args.isSuccessful;
    }
    if (args.errorMessage !== undefined && args.errorMessage !== null) {
      this.errorMessage = args.errorMessage;
    }
    if (args.isCancelled !== undefined && args.isCancelled !== null) {
      this.isCancelled = args.isCancelled;
    }
    if (args.isDone !== undefined && args.isDone !== null) {
      this.isDone = args.isDone;
    }
  }
};
TStatementResult.prototype = {};
TStatementResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.planId = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.info = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.infoAsJson = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.BOOL) {
        this.isSuccessful = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.STRING) {
        this.errorMessage = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.BOOL) {
        this.isCancelled = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 7:
      if (ftype == Thrift.Type.BOOL) {
        this.isDone = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TStatementResult.prototype.write = function(output) {
  output.writeStructBegin('TStatementResult');
  if (this.planId !== null && this.planId !== undefined) {
    output.writeFieldBegin('planId', Thrift.Type.I32, 1);
    output.writeI32(this.planId);
    output.writeFieldEnd();
  }
  if (this.info !== null && this.info !== undefined) {
    output.writeFieldBegin('info', Thrift.Type.STRING, 2);
    output.writeString(this.info);
    output.writeFieldEnd();
  }
  if (this.infoAsJson !== null && this.infoAsJson !== undefined) {
    output.writeFieldBegin('infoAsJson', Thrift.Type.STRING, 3);
    output.writeString(this.infoAsJson);
    output.writeFieldEnd();
  }
  if (this.isSuccessful !== null && this.isSuccessful !== undefined) {
    output.writeFieldBegin('isSuccessful', Thrift.Type.BOOL, 4);
    output.writeBool(this.isSuccessful);
    output.writeFieldEnd();
  }
  if (this.errorMessage !== null && this.errorMessage !== undefined) {
    output.writeFieldBegin('errorMessage', Thrift.Type.STRING, 5);
    output.writeString(this.errorMessage);
    output.writeFieldEnd();
  }
  if (this.isCancelled !== null && this.isCancelled !== undefined) {
    output.writeFieldBegin('isCancelled', Thrift.Type.BOOL, 6);
    output.writeBool(this.isCancelled);
    output.writeFieldEnd();
  }
  if (this.isDone !== null && this.isDone !== undefined) {
    output.writeFieldBegin('isDone', Thrift.Type.BOOL, 7);
    output.writeBool(this.isDone);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TResult = module.exports.TResult = function(args) {
  this.stringResult = null;
  if (args) {
    if (args.stringResult !== undefined && args.stringResult !== null) {
      this.stringResult = args.stringResult;
    }
  }
};
TResult.prototype = {};
TResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.stringResult = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TResult.prototype.write = function(output) {
  output.writeStructBegin('TResult');
  if (this.stringResult !== null && this.stringResult !== undefined) {
    output.writeFieldBegin('stringResult', Thrift.Type.STRING, 1);
    output.writeString(this.stringResult);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TStatementResultV2 = module.exports.TStatementResultV2 = function(args) {
  this.executionId = null;
  this.planId = null;
  this.info = null;
  this.infoAsJson = null;
  this.isSuccessful = null;
  this.errorMessage = null;
  this.isCancelled = null;
  this.isDone = null;
  this.statement = null;
  this.result = null;
  if (args) {
    if (args.executionId !== undefined && args.executionId !== null) {
      this.executionId = args.executionId;
    }
    if (args.planId !== undefined && args.planId !== null) {
      this.planId = args.planId;
    }
    if (args.info !== undefined && args.info !== null) {
      this.info = args.info;
    }
    if (args.infoAsJson !== undefined && args.infoAsJson !== null) {
      this.infoAsJson = args.infoAsJson;
    }
    if (args.isSuccessful !== undefined && args.isSuccessful !== null) {
      this.isSuccessful = args.isSuccessful;
    }
    if (args.errorMessage !== undefined && args.errorMessage !== null) {
      this.errorMessage = args.errorMessage;
    }
    if (args.isCancelled !== undefined && args.isCancelled !== null) {
      this.isCancelled = args.isCancelled;
    }
    if (args.isDone !== undefined && args.isDone !== null) {
      this.isDone = args.isDone;
    }
    if (args.statement !== undefined && args.statement !== null) {
      this.statement = args.statement;
    }
    if (args.result !== undefined && args.result !== null) {
      this.result = new ttypes.TResult(args.result);
    }
  }
};
TStatementResultV2.prototype = {};
TStatementResultV2.prototype.read = function(input) {
  input.readStructBegin();
  while (true) {
    var ret = input.readFieldBegin();
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid) {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.executionId = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.planId = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.info = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.infoAsJson = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.BOOL) {
        this.isSuccessful = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.STRING) {
        this.errorMessage = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 7:
      if (ftype == Thrift.Type.BOOL) {
        this.isCancelled = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 8:
      if (ftype == Thrift.Type.BOOL) {
        this.isDone = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 9:
      if (ftype == Thrift.Type.STRING) {
        this.statement = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 10:
      if (ftype == Thrift.Type.STRUCT) {
        this.result = new ttypes.TResult();
        this.result.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TStatementResultV2.prototype.write = function(output) {
  output.writeStructBegin('TStatementResultV2');
  if (this.execu