text: //
  // Autogenerated by Thrift Compiler (0.10.0)
  //
  // DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  //
  "use strict";
  
  var Thrift = require('thrift').Thrift;
  var ttypes = module.exports = {};
  
  ttypes.TDatumType = {
    0:  'SMALLINT',
        'SMALLINT': 0,
    1:  'INT',
        'INT': 1,
    2:  'BIGINT',
        'BIGINT': 2,
    3:  'FLOAT',
        'FLOAT': 3,
    4:  'DECIMAL',
        'DECIMAL': 4,
    5:  'DOUBLE',
        'DOUBLE': 5,
    6:  'STR',
        'STR': 6,
    7:  'TIME',
        'TIME': 7,
    8:  'TIMESTAMP',
        'TIMESTAMP': 8,
    9:  'DATE',
        'DATE': 9,
    10: 'BOOL',
        'BOOL': 10,
    11: 'INTERVAL_DAY_TIME',
        'INTERVAL_DAY_TIME': 11,
    12: 'INTERVAL_YEAR_MONTH',
        'INTERVAL_YEAR_MONTH': 12
  };
  ttypes.TEncodingType = {
    0: 'NONE',
       'NONE': 0,
    1: 'FIXED',
       'FIXED': 1,
    2: 'RL',
       'RL': 2,
    3: 'DIFF',
       'DIFF': 3,
    4: 'DICT',
       'DICT': 4,
    5: 'SPARSE',
       'SPARSE': 5
  };
  ttypes.TExecuteMode = {
    0: 'HYBRID',
       'HYBRID': 0,
    1: 'GPU',
       'GPU': 1,
    2: 'CPU',
       'CPU': 2
  };
  ttypes.TDeviceType = {
    0: 'CPU',
       'CPU' : 0,
    1: 'GPU',
       'GPU' : 1
  };
  ttypes.TTableType = {
    0: 'DELIMITED',
       'DELIMITED': 0,
    1: 'POLYGON',
       'POLYGON': 1
  };
  ttypes.TMergeType = {
    0: 'UNION',
       'UNION': 0,
    1: 'REDUCE',
       'REDUCE': 1
  };
  ttypes.TExpressionRangeType = {
    0: 'INVALID',
       'INVALID': 0,
    1: 'INTEGER',
       'INTEGER': 1,
    2: 'FLOAT',
       'FLOAT': 2,
    3: 'DOUBLE',
       'DOUBLE': 3
  };
  var TDatumVal = module.exports.TDatumVal = function(args) {
    this.int_val = null;
    this.real_val = null;
    this.str_val = null;
    this.arr_val = null;
    if (args) {
      if (args.int_val !== undefined && args.int_val !== null) {
        this.int_val = args.int_val;
      }
      if (args.real_val !== undefined && args.real_val !== null) {
        this.real_val = args.real_val;
      }
      if (args.str_val !== undefined && args.str_val !== null) {
        this.str_val = args.str_val;
      }
      if (args.arr_val !== undefined && args.arr_val !== null) {
        this.arr_val = Thrift.copyList(args.arr_val, [null]);
      }
    }
  };
  TDatumVal.prototype = {};
  TDatumVal.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I64) {
          this.int_val = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.DOUBLE) {
          this.real_val = input.readDouble();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.STRING) {
          this.str_val = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.LIST) {
          var _size0 = 0;
          var _rtmp34;
          this.arr_val = [];
          var _etype3 = 0;
          _rtmp34 = input.readListBegin();
          _etype3 = _rtmp34.etype;
          _size0 = _rtmp34.size;
          for (var _i5 = 0; _i5 < _size0; ++_i5)
          {
            var elem6 = null;
            elem6 = new ttypes.TDatum();
            elem6.read(input);
            this.arr_val.push(elem6);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TDatumVal.prototype.write = function(output) {
    output.writeStructBegin('TDatumVal');
    if (this.int_val !== null && this.int_val !== undefined) {
      output.writeFieldBegin('int_val', Thrift.Type.I64, 1);
      output.writeI64(this.int_val);
      output.writeFieldEnd();
    }
    if (this.real_val !== null && this.real_val !== undefined) {
      output.writeFieldBegin('real_val', Thrift.Type.DOUBLE, 2);
      output.writeDouble(this.real_val);
      output.writeFieldEnd();
    }
    if (this.str_val !== null && this.str_val !== undefined) {
      output.writeFieldBegin('str_val', Thrift.Type.STRING, 3);
      output.writeString(this.str_val);
      output.writeFieldEnd();
    }
    if (this.arr_val !== null && this.arr_val !== undefined) {
      output.writeFieldBegin('arr_val', Thrift.Type.LIST, 4);
      output.writeListBegin(Thrift.Type.STRUCT, this.arr_val.length);
      for (var iter7 in this.arr_val)
      {
        if (this.arr_val.hasOwnProperty(iter7))
        {
          iter7 = this.arr_val[iter7];
          iter7.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TDatum = module.exports.TDatum = function(args) {
    this.val = null;
    this.is_null = null;
    if (args) {
      if (args.val !== undefined && args.val !== null) {
        this.val = new ttypes.TDatumVal(args.val);
      }
      if (args.is_null !== undefined && args.is_null !== null) {
        this.is_null = args.is_null;
      }
    }
  };
  TDatum.prototype = {};
  TDatum.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.val = new ttypes.TDatumVal();
          this.val.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.BOOL) {
          this.is_null = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TDatum.prototype.write = function(output) {
    output.writeStructBegin('TDatum');
    if (this.val !== null && this.val !== undefined) {
      output.writeFieldBegin('val', Thrift.Type.STRUCT, 1);
      this.val.write(output);
      output.writeFieldEnd();
    }
    if (this.is_null !== null && this.is_null !== undefined) {
      output.writeFieldBegin('is_null', Thrift.Type.BOOL, 2);
      output.writeBool(this.is_null);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TStringValue = module.exports.TStringValue = function(args) {
    this.str_val = null;
    this.is_null = null;
    if (args) {
      if (args.str_val !== undefined && args.str_val !== null) {
        this.str_val = args.str_val;
      }
      if (args.is_null !== undefined && args.is_null !== null) {
        this.is_null = args.is_null;
      }
    }
  };
  TStringValue.prototype = {};
  TStringValue.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.str_val = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.BOOL) {
          this.is_null = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TStringValue.prototype.write = function(output) {
    output.writeStructBegin('TStringValue');
    if (this.str_val !== null && this.str_val !== undefined) {
      output.writeFieldBegin('str_val', Thrift.Type.STRING, 1);
      output.writeString(this.str_val);
      output.writeFieldEnd();
    }
    if (this.is_null !== null && this.is_null !== undefined) {
      output.writeFieldBegin('is_null', Thrift.Type.BOOL, 2);
      output.writeBool(this.is_null);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TTypeInfo = module.exports.TTypeInfo = function(args) {
    this.type = null;
    this.encoding = null;
    this.nullable = null;
    this.is_array = null;
    this.precision = null;
    this.scale = null;
    this.comp_param = null;
    if (args) {
      if (args.type !== undefined && args.type !== null) {
        this.type = args.type;
      }
      if (args.encoding !== undefined && args.encoding !== null) {
        this.encoding = args.encoding;
      }
      if (args.nullable !== undefined && args.nullable !== null) {
        this.nullable = args.nullable;
      }
      if (args.is_array !== undefined && args.is_array !== null) {
        this.is_array = args.is_array;
      }
      if (args.precision !== undefined && args.precision !== null) {
        this.precision = args.precision;
      }
      if (args.scale !== undefined && args.scale !== null) {
        this.scale = args.scale;
      }
      if (args.comp_param !== undefined && args.comp_param !== null) {
        this.comp_param = args.comp_param;
      }
    }
  };
  TTypeInfo.prototype = {};
  TTypeInfo.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I32) {
          this.type = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.I32) {
          this.encoding = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.BOOL) {
          this.nullable = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.BOOL) {
          this.is_array = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.I32) {
          this.precision = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 6:
        if (ftype == Thrift.Type.I32) {
          this.scale = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 7:
        if (ftype == Thrift.Type.I32) {
          this.comp_param = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TTypeInfo.prototype.write = function(output) {
    output.writeStructBegin('TTypeInfo');
    if (this.type !== null && this.type !== undefined) {
      output.writeFieldBegin('type', Thrift.Type.I32, 1);
      output.writeI32(this.type);
      output.writeFieldEnd();
    }
    if (this.encoding !== null && this.encoding !== undefined) {
      output.writeFieldBegin('encoding', Thrift.Type.I32, 4);
      output.writeI32(this.encoding);
      output.writeFieldEnd();
    }
    if (this.nullable !== null && this.nullable !== undefined) {
      output.writeFieldBegin('nullable', Thrift.Type.BOOL, 2);
      output.writeBool(this.nullable);
      output.writeFieldEnd();
    }
    if (this.is_array !== null && this.is_array !== undefined) {
      output.writeFieldBegin('is_array', Thrift.Type.BOOL, 3);
      output.writeBool(this.is_array);
      output.writeFieldEnd();
    }
    if (this.precision !== null && this.precision !== undefined) {
      output.writeFieldBegin('precision', Thrift.Type.I32, 5);
      output.writeI32(this.precision);
      output.writeFieldEnd();
    }
    if (this.scale !== null && this.scale !== undefined) {
      output.writeFieldBegin('scale', Thrift.Type.I32, 6);
      output.writeI32(this.scale);
      output.writeFieldEnd();
    }
    if (this.comp_param !== null && this.comp_param !== undefined) {
      output.writeFieldBegin('comp_param', Thrift.Type.I32, 7);
      output.writeI32(this.comp_param);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TColumnType = module.exports.TColumnType = function(args) {
    this.col_name = null;
    this.col_type = null;
    this.is_reserved_keyword = null;
    this.src_name = null;
    if (args) {
      if (args.col_name !== undefined && args.col_name !== null) {
        this.col_name = args.col_name;
      }
      if (args.col_type !== undefined && args.col_type !== null) {
        this.col_type = new ttypes.TTypeInfo(args.col_type);
      }
      if (args.is_reserved_keyword !== undefined && args.is_reserved_keyword !== null) {
        this.is_reserved_keyword = args.is_reserved_keyword;
      }
      if (args.src_name !== undefined && args.src_name !== null) {
        this.src_name = args.src_name;
      }
    }
  };
  TColumnType.prototype = {};
  TColumnType.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.col_name = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.col_type = new ttypes.TTypeInfo();
          this.col_type.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.BOOL) {
          this.is_reserved_keyword = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.STRING) {
          this.src_name = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TColumnType.prototype.write = function(output) {
    output.writeStructBegin('TColumnType');
    if (this.col_name !== null && this.col_name !== undefined) {
      output.writeFieldBegin('col_name', Thrift.Type.STRING, 1);
      output.writeString(this.col_name);
      output.writeFieldEnd();
    }
    if (this.col_type !== null && this.col_type !== undefined) {
      output.writeFieldBegin('col_type', Thrift.Type.STRUCT, 2);
      this.col_type.write(output);
      output.writeFieldEnd();
    }
    if (this.is_reserved_keyword !== null && this.is_reserved_keyword !== undefined) {
      output.writeFieldBegin('is_reserved_keyword', Thrift.Type.BOOL, 3);
      output.writeBool(this.is_reserved_keyword);
      output.writeFieldEnd();
    }
    if (this.src_name !== null && this.src_name !== undefined) {
      output.writeFieldBegin('src_name', Thrift.Type.STRING, 4);
      output.writeString(this.src_name);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TRow = module.exports.TRow = function(args) {
    this.cols = null;
    if (args) {
      if (args.cols !== undefined && args.cols !== null) {
        this.cols = Thrift.copyList(args.cols, [ttypes.TDatum]);
      }
    }
  };
  TRow.prototype = {};
  TRow.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.LIST) {
          var _size8 = 0;
          var _rtmp312;
          this.cols = [];
          var _etype11 = 0;
          _rtmp312 = input.readListBegin();
          _etype11 = _rtmp312.etype;
          _size8 = _rtmp312.size;
          for (var _i13 = 0; _i13 < _size8; ++_i13)
          {
            var elem14 = null;
            elem14 = new ttypes.TDatum();
            elem14.read(input);
            this.cols.push(elem14);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TRow.prototype.write = function(output) {
    output.writeStructBegin('TRow');
    if (this.cols !== null && this.cols !== undefined) {
      output.writeFieldBegin('cols', Thrift.Type.LIST, 1);
      output.writeListBegin(Thrift.Type.STRUCT, this.cols.length);
      for (var iter15 in this.cols)
      {
        if (this.cols.hasOwnProperty(iter15))
        {
          iter15 = this.cols[iter15];
          iter15.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TColumnData = module.exports.TColumnData = function(args) {
    this.int_col = null;
    this.real_col = null;
    this.str_col = null;
    this.arr_col = null;
    if (args) {
      if (args.int_col !== undefined && args.int_col !== null) {
        this.int_col = Thrift.copyList(args.int_col, [null]);
      }
      if (args.real_col !== undefined && args.real_col !== null) {
        this.real_col = Thrift.copyList(args.real_col, [null]);
      }
      if (args.str_col !== undefined && args.str_col !== null) {
        this.str_col = Thrift.copyList(args.str_col, [null]);
      }
      if (args.arr_col !== undefined && args.arr_col !== null) {
        this.arr_col = Thrift.copyList(args.arr_col, [null]);
      }
    }
  };
  TColumnData.prototype = {};
  TColumnData.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.LIST) {
          var _size16 = 0;
          var _rtmp320;
          this.int_col = [];
          var _etype19 = 0;
          _rtmp320 = input.readListBegin();
          _etype19 = _rtmp320.etype;
          _size16 = _rtmp320.size;
          for (var _i21 = 0; _i21 < _size16; ++_i21)
          {
            var elem22 = null;
            elem22 = input.readI64();
            this.int_col.push(elem22);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          var _size23 = 0;
          var _rtmp327;
          this.real_col = [];
          var _etype26 = 0;
          _rtmp327 = input.readListBegin();
          _etype26 = _rtmp327.etype;
          _size23 = _rtmp327.size;
          for (var _i28 = 0; _i28 < _size23; ++_i28)
          {
            var elem29 = null;
            elem29 = input.readDouble();
            this.real_col.push(elem29);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.LIST) {
          var _size30 = 0;
          var _rtmp334;
          this.str_col = [];
          var _etype33 = 0;
          _rtmp334 = input.readListBegin();
          _etype33 = _rtmp334.etype;
          _size30 = _rtmp334.size;
          for (var _i35 = 0; _i35 < _size30; ++_i35)
          {
            var elem36 = null;
            elem36 = input.readString();
            this.str_col.push(elem36);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.LIST) {
          var _size37 = 0;
          var _rtmp341;
          this.arr_col = [];
          var _etype40 = 0;
          _rtmp341 = input.readListBegin();
          _etype40 = _rtmp341.etype;
          _size37 = _rtmp341.size;
          for (var _i42 = 0; _i42 < _size37; ++_i42)
          {
            var elem43 = null;
            elem43 = new ttypes.TColumn();
            elem43.read(input);
            this.arr_col.push(elem43);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TColumnData.prototype.write = function(output) {
    output.writeStructBegin('TColumnData');
    if (this.int_col !== null && this.int_col !== undefined) {
      output.writeFieldBegin('int_col', Thrift.Type.LIST, 1);
      output.writeListBegin(Thrift.Type.I64, this.int_col.length);
      for (var iter44 in this.int_col)
      {
        if (this.int_col.hasOwnProperty(iter44))
        {
          iter44 = this.int_col[iter44];
          output.writeI64(iter44);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.real_col !== null && this.real_col !== undefined) {
      output.writeFieldBegin('real_col', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.DOUBLE, this.real_col.length);
      for (var iter45 in this.real_col)
      {
        if (this.real_col.hasOwnProperty(iter45))
        {
          iter45 = this.real_col[iter45];
          output.writeDouble(iter45);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.str_col !== null && this.str_col !== undefined) {
      output.writeFieldBegin('str_col', Thrift.Type.LIST, 3);
      output.writeListBegin(Thrift.Type.STRING, this.str_col.length);
      for (var iter46 in this.str_col)
      {
        if (this.str_col.hasOwnProperty(iter46))
        {
          iter46 = this.str_col[iter46];
          output.writeString(iter46);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.arr_col !== null && this.arr_col !== undefined) {
      output.writeFieldBegin('arr_col', Thrift.Type.LIST, 4);
      output.writeListBegin(Thrift.Type.STRUCT, this.arr_col.length);
      for (var iter47 in this.arr_col)
      {
        if (this.arr_col.hasOwnProperty(iter47))
        {
          iter47 = this.arr_col[iter47];
          iter47.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TColumn = module.exports.TColumn = function(args) {
    this.data = null;
    this.nulls = null;
    if (args) {
      if (args.data !== undefined && args.data !== null) {
        this.data = new ttypes.TColumnData(args.data);
      }
      if (args.nulls !== undefined && args.nulls !== null) {
        this.nulls = Thrift.copyList(args.nulls, [null]);
      }
    }
  };
  TColumn.prototype = {};
  TColumn.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.data = new ttypes.TColumnData();
          this.data.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          var _size48 = 0;
          var _rtmp352;
          this.nulls = [];
          var _etype51 = 0;
          _rtmp352 = input.readListBegin();
          _etype51 = _rtmp352.etype;
          _size48 = _rtmp352.size;
          for (var _i53 = 0; _i53 < _size48; ++_i53)
          {
            var elem54 = null;
            elem54 = input.readBool();
            this.nulls.push(elem54);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TColumn.prototype.write = function(output) {
    output.writeStructBegin('TColumn');
    if (this.data !== null && this.data !== undefined) {
      output.writeFieldBegin('data', Thrift.Type.STRUCT, 1);
      this.data.write(output);
      output.writeFieldEnd();
    }
    if (this.nulls !== null && this.nulls !== undefined) {
      output.writeFieldBegin('nulls', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.BOOL, this.nulls.length);
      for (var iter55 in this.nulls)
      {
        if (this.nulls.hasOwnProperty(iter55))
        {
          iter55 = this.nulls[iter55];
          output.writeBool(iter55);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TStringRow = module.exports.TStringRow = function(args) {
    this.cols = null;
    if (args) {
      if (args.cols !== undefined && args.cols !== null) {
        this.cols = Thrift.copyList(args.cols, [ttypes.TStringValue]);
      }
    }
  };
  TStringRow.prototype = {};
  TStringRow.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.LIST) {
          var _size56 = 0;
          var _rtmp360;
          this.cols = [];
          var _etype59 = 0;
          _rtmp360 = input.readListBegin();
          _etype59 = _rtmp360.etype;
          _size56 = _rtmp360.size;
          for (var _i61 = 0; _i61 < _size56; ++_i61)
          {
            var elem62 = null;
            elem62 = new ttypes.TStringValue();
            elem62.read(input);
            this.cols.push(elem62);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TStringRow.prototype.write = function(output) {
    output.writeStructBegin('TStringRow');
    if (this.cols !== null && this.cols !== undefined) {
      output.writeFieldBegin('cols', Thrift.Type.LIST, 1);
      output.writeListBegin(Thrift.Type.STRUCT, this.cols.length);
      for (var iter63 in this.cols)
      {
        if (this.cols.hasOwnProperty(iter63))
        {
          iter63 = this.cols[iter63];
          iter63.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TStepResult = module.exports.TStepResult = function(args) {
    this.serialized_rows = null;
    this.execution_finished = null;
    this.merge_type = null;
    this.sharded = null;
    this.row_desc = null;
    this.node_id = null;
    if (args) {
      if (args.serialized_rows !== undefined && args.serialized_rows !== null) {
        this.serialized_rows = args.serialized_rows;
      }
      if (args.execution_finished !== undefined && args.execution_finished !== null) {
        this.execution_finished = args.execution_finished;
      }
      if (args.merge_type !== undefined && args.merge_type !== null) {
        this.merge_type = args.merge_type;
      }
      if (args.sharded !== undefined && args.sharded !== null) {
        this.sharded = args.sharded;
      }
      if (args.row_desc !== undefined && args.row_desc !== null) {
        this.row_desc = Thrift.copyList(args.row_desc, [ttypes.TColumnType]);
      }
      if (args.node_id !== undefined && args.node_id !== null) {
        this.node_id = args.node_id;
      }
    }
  };
  TStepResult.prototype = {};
  TStepResult.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.serialized_rows = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.BOOL) {
          this.execution_finished = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.I32) {
          this.merge_type = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.BOOL) {
          this.sharded = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.LIST) {
          var _size64 = 0;
          var _rtmp368;
          this.row_desc = [];
          var _etype67 = 0;
          _rtmp368 = input.readListBegin();
          _etype67 = _rtmp368.etype;
          _size64 = _rtmp368.size;
          for (var _i69 = 0; _i69 < _size64; ++_i69)
          {
            var elem70 = null;
            elem70 = new ttypes.TColumnType();
            elem70.read(input);
            this.row_desc.push(elem70);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 6:
        if (ftype == Thrift.Type.I32) {
          this.node_id = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TStepResult.prototype.write = function(output) {
    output.writeStructBegin('TStepResult');
    if (this.serialized_rows !== null && this.serialized_rows !== undefined) {
      output.writeFieldBegin('serialized_rows', Thrift.Type.STRING, 1);
      output.writeString(this.serialized_rows);
      output.writeFieldEnd();
    }
    if (this.execution_finished !== null && this.execution_finished !== undefined) {
      output.writeFieldBegin('execution_finished', Thrift.Type.BOOL, 2);
      output.writeBool(this.execution_finished);
      output.writeFieldEnd();
    }
    if (this.merge_type !== null && this.merge_type !== undefined) {
      output.writeFieldBegin('merge_type', Thrift.Type.I32, 3);
      output.writeI32(this.merge_type);
      output.writeFieldEnd();
    }
    if (this.sharded !== null && this.sharded !== undefined) {
      output.writeFieldBegin('sharded', Thrift.Type.BOOL, 4);
      output.writeBool(this.sharded);
      output.writeFieldEnd();
    }
    if (this.row_desc !== null && this.row_desc !== undefined) {
      output.writeFieldBegin('row_desc', Thrift.Type.LIST, 5);
      output.writeListBegin(Thrift.Type.STRUCT, this.row_desc.length);
      for (var iter71 in this.row_desc)
      {
        if (this.row_desc.hasOwnProperty(iter71))
        {
          iter71 = this.row_desc[iter71];
          iter71.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.node_id !== null && this.node_id !== undefined) {
      output.writeFieldBegin('node_id', Thrift.Type.I32, 6);
      output.writeI32(this.node_id);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TRowSet = module.exports.TRowSet = function(args) {
    this.row_desc = null;
    this.rows = null;
    this.columns = null;
    this.is_columnar = null;
    if (args) {
      if (args.row_desc !== undefined && args.row_desc !== null) {
        this.row_desc = Thrift.copyList(args.row_desc, [ttypes.TColumnType]);
      }
      if (args.rows !== undefined && args.rows !== null) {
        this.rows = Thrift.copyList(args.rows, [ttypes.TRow]);
      }
      if (args.columns !== undefined && args.columns !== null) {
        this.columns = Thrift.copyList(args.columns, [ttypes.TColumn]);
      }
      if (args.is_columnar !== undefined && args.is_columnar !== null) {
        this.is_columnar = args.is_columnar;
      }
    }
  };
  TRowSet.prototype = {};
  TRowSet.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.LIST) {
          var _size72 = 0;
          var _rtmp376;
          this.row_desc = [];
          var _etype75 = 0;
          _rtmp376 = input.readListBegin();
          _etype75 = _rtmp376.etype;
          _size72 = _rtmp376.size;
          for (var _i77 = 0; _i77 < _size72; ++_i77)
          {
            var elem78 = null;
            elem78 = new ttypes.TColumnType();
            elem78.read(input);
            this.row_desc.push(elem78);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          var _size79 = 0;
          var _rtmp383;
          this.rows = [];
          var _etype82 = 0;
          _rtmp383 = input.readListBegin();
          _etype82 = _rtmp383.etype;
          _size79 = _rtmp383.size;
          for (var _i84 = 0; _i84 < _size79; ++_i84)
          {
            var elem85 = null;
            elem85 = new ttypes.TRow();
            elem85.read(input);
            this.rows.push(elem85);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.LIST) {
          var _size86 = 0;
          var _rtmp390;
          this.columns = [];
          var _etype89 = 0;
          _rtmp390 = input.readListBegin();
          _etype89 = _rtmp390.etype;
          _size86 = _rtmp390.size;
          for (var _i91 = 0; _i91 < _size86; ++_i91)
          {
            var elem92 = null;
            elem92 = new ttypes.TColumn();
            elem92.read(input);
            this.columns.push(elem92);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.BOOL) {
          this.is_columnar = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TRowSet.prototype.write = function(output) {
    output.writeStructBegin('TRowSet');
    if (this.row_desc !== null && this.row_desc !== undefined) {
      output.writeFieldBegin('row_desc', Thrift.Type.LIST, 1);
      output.writeListBegin(Thrift.Type.STRUCT, this.row_desc.length);
      for (var iter93 in this.row_desc)
      {
        if (this.row_desc.hasOwnProperty(iter93))
        {
          iter93 = this.row_desc[iter93];
          iter93.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.rows !== null && this.rows !== undefined) {
      output.writeFieldBegin('rows', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.STRUCT, this.rows.length);
      for (var iter94 in this.rows)
      {
        if (this.rows.hasOwnProperty(iter94))
        {
          iter94 = this.rows[iter94];
          iter94.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.columns !== null && this.columns !== undefined) {
      output.writeFieldBegin('columns', Thrift.Type.LIST, 3);
      output.writeListBegin(Thrift.Type.STRUCT, this.columns.length);
      for (var iter95 in this.columns)
      {
        if (this.columns.hasOwnProperty(iter95))
        {
          iter95 = this.columns[iter95];
          iter95.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.is_columnar !== null && this.is_columnar !== undefined) {
      output.writeFieldBegin('is_columnar', Thrift.Type.BOOL, 4);
      output.writeBool(this.is_columnar);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TQueryResult = module.exports.TQueryResult = function(args) {
    this.row_set = null;
    this.execution_time_ms = null;
    this.total_time_ms = null;
    this.nonce = null;
    if (args) {
      if (args.row_set !== undefined && args.row_set !== null) {
        this.row_set = new ttypes.TRowSet(args.row_set);
      }
      if (args.execution_time_ms !== undefined && args.execution_time_ms !== null) {
        this.execution_time_ms = args.execution_time_ms;
      }
      if (args.total_time_ms !== undefined && args.total_time_ms !== null) {
        this.total_time_ms = args.total_time_ms;
      }
      if (args.nonce !== undefined && args.nonce !== null) {
        this.nonce = args.nonce;
      }
    }
  };
  TQueryResult.prototype = {};
  TQueryResult.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.row_set = new ttypes.TRowSet();
          this.row_set.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I64) {
          this.execution_time_ms = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.I64) {
          this.total_time_ms = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.STRING) {
          this.nonce = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TQueryResult.prototype.write = function(output) {
    output.writeStructBegin('TQueryResult');
    if (this.row_set !== null && this.row_set !== undefined) {
      output.writeFieldBegin('row_set', Thrift.Type.STRUCT, 1);
      this.row_set.write(output);
      output.writeFieldEnd();
    }
    if (this.execution_time_ms !== null && this.execution_time_ms !== undefined) {
      output.writeFieldBegin('execution_time_ms', Thrift.Type.I64, 2);
      output.writeI64(this.execution_time_ms);
      output.writeFieldEnd();
    }
    if (this.total_time_ms !== null && this.total_time_ms !== undefined) {
      output.writeFieldBegin('total_time_ms', Thrift.Type.I64, 3);
      output.writeI64(this.total_time_ms);
      output.writeFieldEnd();
    }
    if (this.nonce !== null && this.nonce !== undefined) {
      output.writeFieldBegin('nonce', Thrift.Type.STRING, 4);
      output.writeString(this.nonce);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TDataFrame = module.exports.TDataFrame = function(args) {
    this.sm_handle = null;
    this.sm_size = null;
    this.df_handle = null;
    this.df_size = null;
    if (args) {
      if (args.sm_handle !== undefined && args.sm_handle !== null) {
        this.sm_handle = args.sm_handle;
      }
      if (args.sm_size !== undefined && args.sm_size !== null) {
        this.sm_size = args.sm_size;
      }
      if (args.df_handle !== undefined && args.df_handle !== null) {
        this.df_handle = args.df_handle;
      }
      if (args.df_size !== undefined && args.df_size !== null) {
        this.df_size = args.df_size;
      }
    }
  };
  TDataFrame.prototype = {};
  TDataFrame.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.sm_handle = input.readBinary();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I64) {
          this.sm_size = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.STRING) {
          this.df_handle = input.readBinary();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.I64) {
          this.df_size = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TDataFrame.prototype.write = function(output) {
    output.writeStructBegin('TDataFrame');
    if (this.sm_handle !== null && this.sm_handle !== undefined) {
      output.writeFieldBegin('sm_handle', Thrift.Type.STRING, 1);
      output.writeBinary(this.sm_handle);
      output.writeFieldEnd();
    }
    if (this.sm_size !== null && this.sm_size !== undefined) {
      output.writeFieldBegin('sm_size', Thrift.Type.I64, 2);
      output.writeI64(this.sm_size);
      output.writeFieldEnd();
    }
    if (this.df_handle !== null && this.df_handle !== undefined) {
      output.writeFieldBegin('df_handle', Thrift.Type.STRING, 3);
      output.writeBinary(this.df_handle);
      output.writeFieldEnd();
    }
    if (this.df_size !== null && this.df_size !== undefined) {
      output.writeFieldBegin('df_size', Thrift.Type.I64, 4);
      output.writeI64(this.df_size);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TDBInfo = module.exports.TDBInfo = function(args) {
    this.db_name = null;
    this.db_owner = null;
    if (args) {
      if (args.db_name !== undefined && args.db_name !== null) {
        this.db_name = args.db_name;
      }
      if (args.db_owner !== undefined && args.db_owner !== null) {
        this.db_owner = args.db_owner;
      }
    }
  };
  TDBInfo.prototype = {};
  TDBInfo.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.db_name = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.db_owner = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TDBInfo.prototype.write = function(output) {
    output.writeStructBegin('TDBInfo');
    if (this.db_name !== null && this.db_name !== undefined) {
      output.writeFieldBegin('db_name', Thrift.Type.STRING, 1);
      output.writeString(this.db_name);
      output.writeFieldEnd();
    }
    if (this.db_owner !== null && this.db_owner !== undefined) {
      output.writeFieldBegin('db_owner', Thrift.Type.STRING, 2);
      output.writeString(this.db_owner);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TMapDException = module.exports.TMapDException = function(args) {
    Thrift.TException.call(this, "TMapDException");
    this.name = "TMapDException";
    this.error_msg = null;
    if (args) {
      if (args.error_msg !== undefined && args.error_msg !== null) {
        this.error_msg = args.error_msg;
      }
    }
  };
  Thrift.inherits(TMapDException, Thrift.TException);
  TMapDException.prototype.name = 'TMapDException';
  TMapDException.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.error_msg = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TMapDException.prototype.write = function(output) {
    output.writeStructBegin('TMapDException');
    if (this.error_msg !== null && this.error_msg !== undefined) {
      output.writeFieldBegin('error_msg', Thrift.Type.STRING, 1);
      output.writeString(this.error_msg);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TRenderProperty = module.exports.TRenderProperty = function(args) {
    this.property_type = null;
    this.property_value = null;
    if (args) {
      if (args.property_type !== undefined && args.property_type !== null) {
        this.property_type = args.property_type;
      }
      if (args.property_value !== undefined && args.property_value !== null) {
        this.property_value = new ttypes.TDatumVal(args.property_value);
      }
    }
  };
  TRenderProperty.prototype = {};
  TRenderProperty.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I32) {
          this.property_type = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.property_value = new ttypes.TDatumVal();
          this.property_value.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TRenderProperty.prototype.write = function(output) {
    output.writeStructBegin('TRenderProperty');
    if (this.property_type !== null && this.property_type !== undefined) {
      output.writeFieldBegin('property_type', Thrift.Type.I32, 1);
      output.writeI32(this.property_type);
      output.writeFieldEnd();
    }
    if (this.property_value !== null && this.property_value !== undefined) {
      output.writeFieldBegin('property_value', Thrift.Type.STRUCT, 2);
      this.property_value.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TCopyParams = module.exports.TCopyParams = function(args) {
    this.delimiter = null;
    this.null_str = null;
    this.has_header = null;
    this.quoted = null;
    this.quote = null;
    this.escape = null;
    this.line_delim = null;
    this.array_delim = null;
    this.array_begin = null;
    this.array_end = null;
    this.threads = null;
    this.table_type = 0;
    if (args) {
      if (args.delimiter !== undefined && args.delimiter !== null) {
        this.delimiter = args.delimiter;
      }
      if (args.null_str !== undefined && args.null_str !== null) {
        this.null_str = args.null_str;
      }
      if (args.has_header !== undefined && args.has_header !== null) {
        this.has_header = args.has_header;
      }
      if (args.quoted !== undefined && args.quoted !== null) {
        this.quoted = args.quoted;
      }
      if (args.quote !== undefined && args.quote !== null) {
        this.quote = args.quote;
      }
      if (args.escape !== undefined && args.escape !== null) {
        this.escape = args.escape;
      }
      if (args.line_delim !== undefined && args.line_delim !== null) {
        this.line_delim = args.line_delim;
      }
      if (args.array_delim !== undefined && args.array_delim !== null) {
        this.array_delim = args.array_delim;
      }
      if (args.array_begin !== undefined && args.array_begin !== null) {
        this.array_begin = args.array_begin;
      }
      if (args.array_end !== undefined && args.array_end !== null) {
        this.array_end = args.array_end;
      }
      if (args.threads !== undefined && args.threads !== null) {
        this.threads = args.threads;
      }
      if (args.table_type !== undefined && args.table_type !== null) {
        this.table_type = args.table_type;
      }
    }
  };
  TCopyParams.prototype = {};
  TCopyParams.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.delimiter = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.null_str = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.BOOL) {
          this.has_header = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.BOOL) {
          this.quoted = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.STRING) {
          this.quote = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 6:
        if (ftype == Thrift.Type.STRING) {
          this.escape = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 7:
        if (ftype == Thrift.Type.STRING) {
          this.line_delim = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 8:
        if (ftype == Thrift.Type.STRING) {
          this.array_delim = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 9:
        if (ftype == Thrift.Type.STRING) {
          this.array_begin = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 10:
        if (ftype == Thrift.Type.STRING) {
          this.array_end = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 11:
        if (ftype == Thrift.Type.I32) {
          this.threads = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 12:
        if (ftype == Thrift.Type.I32) {
          this.table_type = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TCopyParams.prototype.write = function(output) {
    output.writeStructBegin('TCopyParams');
    if (this.delimiter !== null && this.delimiter !== undefined) {
      output.writeFieldBegin('delimiter', Thrift.Type.STRING, 1);
      output.writeString(this.delimiter);
      output.writeFieldEnd();
    }
    if (this.null_str !== null && this.null_str !== undefined) {
      output.writeFieldBegin('null_str', Thrift.Type.STRING, 2);
      output.writeString(this.null_str);
      output.writeFieldEnd();
    }
    if (this.has_header !== null && this.has_header !== undefined) {
      output.writeFieldBegin('has_header', Thrift.Type.BOOL, 3);
      output.writeBool(this.has_header);
      output.writeFieldEnd();
    }
    if (this.quoted !== null && this.quoted !== undefined) {
      output.writeFieldBegin('quoted', Thrift.Type.BOOL, 4);
      output.writeBool(this.quoted);
      output.writeFieldEnd();
    }
    if (this.quote !== null && this.quote !== undefined) {
      output.writeFieldBegin('quote', Thrift.Type.STRING, 5);
      output.writeString(this.quote);
      output.writeFieldEnd();
    }
    if (this.escape !== null && this.escape !== undefined) {
      output.writeFieldBegin('escape', Thrift.Type.STRING, 6);
      output.writeString(this.escape);
      output.writeFieldEnd();
    }
    if (this.line_delim !== null && this.line_delim !== undefined) {
      output.writeFieldBegin('line_delim', Thrift.Type.STRING, 7);
      output.writeString(this.line_delim);
      output.writeFieldEnd();
    }
    if (this.array_delim !== null && this.array_delim !== undefined) {
      output.writeFieldBegin('array_delim', Thrift.Type.STRING, 8);
      output.writeString(this.array_delim);
      output.writeFieldEnd();
    }
    if (this.array_begin !== null && this.array_begin !== undefined) {
      output.writeFieldBegin('array_begin', Thrift.Type.STRING, 9);
      output.writeString(this.array_begin);
      output.writeFieldEnd();
    }
    if (this.array_end !== null && this.array_end !== undefined) {
      output.writeFieldBegin('array_end', Thrift.Type.STRING, 10);
      output.writeString(this.array_end);
      output.writeFieldEnd();
    }
    if (this.threads !== null && this.threads !== undefined) {
      output.writeFieldBegin('threads', Thrift.Type.I32, 11);
      output.writeI32(this.threads);
      output.writeFieldEnd();
    }
    if (this.table_type !== null && this.table_type !== undefined) {
      output.writeFieldBegin('table_type', Thrift.Type.I32, 12);
      output.writeI32(this.table_type);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TDetectResult = module.exports.TDetectResult = function(args) {
    this.row_set = null;
    this.copy_params = null;
    if (args) {
      if (args.row_set !== undefined && args.row_set !== null) {
        this.row_set = new ttypes.TRowSet(args.row_set);
      }
      if (args.copy_params !== undefined && args.copy_params !== null) {
        this.copy_params = new ttypes.TCopyParams(args.copy_params);
      }
    }
  };
  TDetectResult.prototype = {};
  TDetectResult.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.row_set = new ttypes.TRowSet();
          this.row_set.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.copy_params = new ttypes.TCopyParams();
          this.copy_params.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TDetectResult.prototype.write = function(output) {
    output.writeStructBegin('TDetectResult');
    if (this.row_set !== null && this.row_set !== undefined) {
      output.writeFieldBegin('row_set', Thrift.Type.STRUCT, 1);
      this.row_set.write(output);
      output.writeFieldEnd();
    }
    if (this.copy_params !== null && this.copy_params !== undefined) {
      output.writeFieldBegin('copy_params', Thrift.Type.STRUCT, 2);
      this.copy_params.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TImportStatus = module.exports.TImportStatus = function(args) {
    this.elapsed = null;
    this.rows_completed = null;
    this.rows_estimated = null;
    this.rows_rejected = null;
    if (args) {
      if (args.elapsed !== undefined && args.elapsed !== null) {
        this.elapsed = args.elapsed;
      }
      if (args.rows_completed !== undefined && args.rows_completed !== null) {
        this.rows_completed = args.rows_completed;
      }
      if (args.rows_estimated !== undefined && args.rows_estimated !== null) {
        this.rows_estimated = args.rows_estimated;
      }
      if (args.rows_rejected !== undefined && args.rows_rejected !== null) {
        this.rows_rejected = args.rows_rejected;
      }
    }
  };
  TImportStatus.prototype = {};
  TImportStatus.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I64) {
          this.elapsed = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I64) {
          this.rows_completed = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.I64) {
          this.rows_estimated = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.I64) {
          this.rows_rejected = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TImportStatus.prototype.write = function(output) {
    output.writeStructBegin('TImportStatus');
    if (this.elapsed !== null && this.elapsed !== undefined) {
      output.writeFieldBegin('elapsed', Thrift.Type.I64, 1);
      output.writeI64(this.elapsed);
      output.writeFieldEnd();
    }
    if (this.rows_completed !== null && this.rows_completed !== undefined) {
      output.writeFieldBegin('rows_completed', Thrift.Type.I64, 2);
      output.writeI64(this.rows_completed);
      output.writeFieldEnd();
    }
    if (this.rows_estimated !== null && this.rows_estimated !== undefined) {
      output.writeFieldBegin('rows_estimated', Thrift.Type.I64, 3);
      output.writeI64(this.rows_estimated);
      output.writeFieldEnd();
    }
    if (this.rows_rejected !== null && this.rows_rejected !== undefined) {
      output.writeFieldBegin('rows_rejected', Thrift.Type.I64, 4);
      output.writeI64(this.rows_rejected);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TFrontendView = module.exports.TFrontendView = function(args) {
    this.view_name = null;
    this.view_state = null;
    this.image_hash = null;
    this.update_time = null;
    this.view_metadata = null;
    if (args) {
      if (args.view_name !== undefined && args.view_name !== null) {
        this.view_name = args.view_name;
      }
      if (args.view_state !== undefined && args.view_state !== null) {
        this.view_state = args.view_state;
      }
      if (args.image_hash !== undefined && args.image_hash !== null) {
        this.image_hash = args.image_hash;
      }
      if (args.update_time !== undefined && args.update_time !== null) {
        this.update_time = args.update_time;
      }
      if (args.view_metadata !== undefined && args.view_metadata !== null) {
        this.view_metadata = args.view_metadata;
      }
    }
  };
  TFrontendView.prototype = {};
  TFrontendView.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.view_name = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.view_state = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.STRING) {
          this.image_hash = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.STRING) {
          this.update_time = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.STRING) {
          this.view_metadata = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TFrontendView.prototype.write = function(output) {
    output.writeStructBegin('TFrontendView');
    if (this.view_name !== null && this.view_name !== undefined) {
      output.writeFieldBegin('view_name', Thrift.Type.STRING, 1);
      output.writeString(this.view_name);
      output.writeFieldEnd();
    }
    if (this.view_state !== null && this.view_state !== undefined) {
      output.writeFieldBegin('view_state', Thrift.Type.STRING, 2);
      output.writeString(this.view_state);
      output.writeFieldEnd();
    }
    if (this.image_hash !== null && this.image_hash !== undefined) {
      output.writeFieldBegin('image_hash', Thrift.Type.STRING, 3);
      output.writeString(this.image_hash);
      output.writeFieldEnd();
    }
    if (this.update_time !== null && this.update_time !== undefined) {
      output.writeFieldBegin('update_time', Thrift.Type.STRING, 4);
      output.writeString(this.update_time);
      output.writeFieldEnd();
    }
    if (this.view_metadata !== null && this.view_metadata !== undefined) {
      output.writeFieldBegin('view_metadata', Thrift.Type.STRING, 5);
      output.writeString(this.view_metadata);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TServerStatus = module.exports.TServerStatus = function(args) {
    this.read_only = null;
    this.version = null;
    this.rendering_enabled = null;
    this.start_time = null;
    this.edition = null;
    if (args) {
      if (args.read_only !== undefined && args.read_only !== null) {
        this.read_only = args.read_only;
      }
      if (args.version !== undefined && args.version !== null) {
        this.version = args.version;
      }
      if (args.rendering_enabled !== undefined && args.rendering_enabled !== null) {
        this.rendering_enabled = args.rendering_enabled;
      }
      if (args.start_time !== undefined && args.start_time !== null) {
        this.start_time = args.start_time;
      }
      if (args.edition !== undefined && args.edition !== null) {
        this.edition = args.edition;
      }
    }
  };
  TServerStatus.prototype = {};
  TServerStatus.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.BOOL) {
          this.read_only = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.version = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.BOOL) {
          this.rendering_enabled = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.I64) {
          this.start_time = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.STRING) {
          this.edition = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TServerStatus.prototype.write = function(output) {
    output.writeStructBegin('TServerStatus');
    if (this.read_only !== null && this.read_only !== undefined) {
      output.writeFieldBegin('read_only', Thrift.Type.BOOL, 1);
      output.writeBool(this.read_only);
      output.writeFieldEnd();
    }
    if (this.version !== null && this.version !== undefined) {
      output.writeFieldBegin('version', Thrift.Type.STRING, 2);
      output.writeString(this.version);
      output.writeFieldEnd();
    }
    if (this.rendering_enabled !== null && this.rendering_enabled !== undefined) {
      output.writeFieldBegin('rendering_enabled', Thrift.Type.BOOL, 3);
      output.writeBool(this.rendering_enabled);
      output.writeFieldEnd();
    }
    if (this.start_time !== null && this.start_time !== undefined) {
      output.writeFieldBegin('start_time', Thrift.Type.I64, 4);
      output.writeI64(this.start_time);
      output.writeFieldEnd();
    }
    if (this.edition !== null && this.edition !== undefined) {
      output.writeFieldBegin('edition', Thrift.Type.STRING, 5);
      output.writeString(this.edition);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TPixel = module.exports.TPixel = function(args) {
    this.x = null;
    this.y = null;
    if (args) {
      if (args.x !== undefined && args.x !== null) {
        this.x = args.x;
      }
      if (args.y !== undefined && args.y !== null) {
        this.y = args.y;
      }
    }
  };
  TPixel.prototype = {};
  TPixel.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I64) {
          this.x = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I64) {
          this.y = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TPixel.prototype.write = function(output) {
    output.writeStructBegin('TPixel');
    if (this.x !== null && this.x !== undefined) {
      output.writeFieldBegin('x', Thrift.Type.I64, 1);
      output.writeI64(this.x);
      output.writeFieldEnd();
    }
    if (this.y !== null && this.y !== undefined) {
      output.writeFieldBegin('y', Thrift.Type.I64, 2);
      output.writeI64(this.y);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TPixelRowResult = module.exports.TPixelRowResult = function(args) {
    this.pixel = null;
    this.row_id = null;
    this.row_set = null;
    this.nonce = null;
    if (args) {
      if (args.pixel !== undefined && args.pixel !== null) {
        this.pixel = new ttypes.TPixel(args.pixel);
      }
      if (args.row_id !== undefined && args.row_id !== null) {
        this.row_id = args.row_id;
      }
      if (args.row_set !== undefined && args.row_set !== null) {
        this.row_set = new ttypes.TRowSet(args.row_set);
      }
      if (args.nonce !== undefined && args.nonce !== null) {
        this.nonce = args.nonce;
      }
    }
  };
  TPixelRowResult.prototype = {};
  TPixelRowResult.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.pixel = new ttypes.TPixel();
          this.pixel.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I64) {
          this.row_id = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.STRUCT) {
          this.row_set = new ttypes.TRowSet();
          this.row_set.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.STRING) {
          this.nonce = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TPixelRowResult.prototype.write = function(output) {
    output.writeStructBegin('TPixelRowResult');
    if (this.pixel !== null && this.pixel !== undefined) {
      output.writeFieldBegin('pixel', Thrift.Type.STRUCT, 1);
      this.pixel.write(output);
      output.writeFieldEnd();
    }
    if (this.row_id !== null && this.row_id !== undefined) {
      output.writeFieldBegin('row_id', Thrift.Type.I64, 2);
      output.writeI64(this.row_id);
      output.writeFieldEnd();
    }
    if (this.row_set !== null && this.row_set !== undefined) {
      output.writeFieldBegin('row_set', Thrift.Type.STRUCT, 3);
      this.row_set.write(output);
      output.writeFieldEnd();
    }
    if (this.nonce !== null && this.nonce !== undefined) {
      output.writeFieldBegin('nonce', Thrift.Type.STRING, 4);
      output.writeString(this.nonce);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TPixelTableRowResult = module.exports.TPixelTableRowResult = function(args) {
    this.pixel = null;
    this.vega_table_name = null;
    this.table_id = null;
    this.row_id = null;
    this.row_set = null;
    this.nonce = null;
    if (args) {
      if (args.pixel !== undefined && args.pixel !== null) {
        this.pixel = new ttypes.TPixel(args.pixel);
      }
      if (args.vega_table_name !== undefined && args.vega_table_name !== null) {
        this.vega_table_name = args.vega_table_name;
      }
      if (args.table_id !== undefined && args.table_id !== null) {
        this.table_id = args.table_id;
      }
      if (args.row_id !== undefined && args.row_id !== null) {
        this.row_id = args.row_id;
      }
      if (args.row_set !== undefined && args.row_set !== null) {
        this.row_set = new ttypes.TRowSet(args.row_set);
      }
      if (args.nonce !== undefined && args.nonce !== null) {
        this.nonce = args.nonce;
      }
    }
  };
  TPixelTableRowResult.prototype = {};
  TPixelTableRowResult.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.pixel = new ttypes.TPixel();
          this.pixel.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.vega_table_name = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.I64) {
          this.table_id = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.I64) {
          this.row_id = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.STRUCT) {
          this.row_set = new ttypes.TRowSet();
          this.row_set.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 6:
        if (ftype == Thrift.Type.STRING) {
          this.nonce = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TPixelTableRowResult.prototype.write = function(output) {
    output.writeStructBegin('TPixelTableRowResult');
    if (this.pixel !== null && this.pixel !== undefined) {
      output.writeFieldBegin('pixel', Thrift.Type.STRUCT, 1);
      this.pixel.write(output);
      output.writeFieldEnd();
    }
    if (this.vega_table_name !== null && this.vega_table_name !== undefined) {
      output.writeFieldBegin('vega_table_name', Thrift.Type.STRING, 2);
      output.writeString(this.vega_table_name);
      output.writeFieldEnd();
    }
    if (this.table_id !== null && this.table_id !== undefined) {
      output.writeFieldBegin('table_id', Thrift.Type.I64, 3);
      output.writeI64(this.table_id);
      output.writeFieldEnd();
    }
    if (this.row_id !== null && this.row_id !== undefined) {
      output.writeFieldBegin('row_id', Thrift.Type.I64, 4);
      output.writeI64(this.row_id);
      output.writeFieldEnd();
    }
    if (this.row_set !== null && this.row_set !== undefined) {
      output.writeFieldBegin('row_set', Thrift.Type.STRUCT, 5);
      this.row_set.write(output);
      output.writeFieldEnd();
    }
    if (this.nonce !== null && this.nonce !== undefined) {
      output.writeFieldBegin('nonce', Thrift.Type.STRING, 6);
      output.writeString(this.nonce);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TPixelRows = module.exports.TPixelRows = function(args) {
    this.pixel = null;
    this.row_set = null;
    if (args) {
      if (args.pixel !== undefined && args.pixel !== null) {
        this.pixel = new ttypes.TPixel(args.pixel);
      }
      if (args.row_set !== undefined && args.row_set !== null) {
        this.row_set = new ttypes.TRowSet(args.row_set);
      }
    }
  };
  TPixelRows.prototype = {};
  TPixelRows.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.pixel = new ttypes.TPixel();
          this.pixel.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.row_set = new ttypes.TRowSet();
          this.row_set.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TPixelRows.prototype.write = function(output) {
    output.writeStructBegin('TPixelRows');
    if (this.pixel !== null && this.pixel !== undefined) {
      output.writeFieldBegin('pixel', Thrift.Type.STRUCT, 1);
      this.pixel.write(output);
      output.writeFieldEnd();
    }
    if (this.row_set !== null && this.row_set !== undefined) {
      output.writeFieldBegin('row_set', Thrift.Type.STRUCT, 2);
      this.row_set.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TPixelResult = module.exports.TPixelResult = function(args) {
    this.pixel_rows = null;
    this.nonce = null;
    if (args) {
      if (args.pixel_rows !== undefined && args.pixel_rows !== null) {
        this.pixel_rows = Thrift.copyList(args.pixel_rows, [ttypes.TPixelRows]);
      }
      if (args.nonce !== undefined && args.nonce !== null) {
        this.nonce = args.nonce;
      }
    }
  };
  TPixelResult.prototype = {};
  TPixelResult.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.LIST) {
          var _size96 = 0;
          var _rtmp3100;
          this.pixel_rows = [];
          var _etype99 = 0;
          _rtmp3100 = input.readListBegin();
          _etype99 = _rtmp3100.etype;
          _size96 = _rtmp3100.size;
          for (var _i101 = 0; _i101 < _size96; ++_i101)
          {
            var elem102 = null;
            elem102 = new ttypes.TPixelRows();
            elem102.read(input);
            this.pixel_rows.push(elem102);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.nonce = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TPixelResult.prototype.write = function(output) {
    output.writeStructBegin('TPixelResult');
    if (this.pixel_rows !== null && this.pixel_rows !== undefined) {
      output.writeFieldBegin('pixel_rows', Thrift.Type.LIST, 1);
      output.writeListBegin(Thrift.Type.STRUCT, this.pixel_rows.length);
      for (var iter103 in this.pixel_rows)
      {
        if (this.pixel_rows.hasOwnProperty(iter103))
        {
          iter103 = this.pixel_rows[iter103];
          iter103.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.nonce !== null && this.nonce !== undefined) {
      output.writeFieldBegin('nonce', Thrift.Type.STRING, 2);
      output.writeString(this.nonce);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TRenderResult = module.exports.TRenderResult = function(args) {
    this.image = null;
    this.nonce = null;
    this.execution_time_ms = null;
    this.render_time_ms = null;
    this.total_time_ms = null;
    if (args) {
      if (args.image !== undefined && args.image !== null) {
        this.image = args.image;
      }
      if (args.nonce !== undefined && args.nonce !== null) {
        this.nonce = args.nonce;
      }
      if (args.execution_time_ms !== undefined && args.execution_time_ms !== null) {
        this.execution_time_ms = args.execution_time_ms;
      }
      if (args.render_time_ms !== undefined && args.render_time_ms !== null) {
        this.render_time_ms = args.render_time_ms;
      }
      if (args.total_time_ms !== undefined && args.total_time_ms !== null) {
        this.total_time_ms = args.total_time_ms;
      }
    }
  };
  TRenderResult.prototype = {};
  TRenderResult.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.image = input.readBinary();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.nonce = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.I64) {
          this.execution_time_ms = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.I64) {
          this.render_time_ms = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.I64) {
          this.total_time_ms = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TRenderResult.prototype.write = function(output) {
    output.writeStructBegin('TRenderResult');
    if (this.image !== null && this.image !== undefined) {
      output.writeFieldBegin('image', Thrift.Type.STRING, 1);
      output.writeBinary(this.image);
      output.writeFieldEnd();
    }
    if (this.nonce !== null && this.nonce !== undefined) {
      output.writeFieldBegin('nonce', Thrift.Type.STRING, 2);
      output.writeString(this.nonce);
      output.writeFieldEnd();
    }
    if (this.execution_time_ms !== null && this.execution_time_ms !== undefined) {
      output.writeFieldBegin('execution_time_ms', Thrift.Type.I64, 3);
      output.writeI64(this.execution_time_ms);
      output.writeFieldEnd();
    }
    if (this.render_time_ms !== null && this.render_time_ms !== undefined) {
      output.writeFieldBegin('render_time_ms', Thrift.Type.I64, 4);
      output.writeI64(this.render_time_ms);
      output.writeFieldEnd();
    }
    if (this.total_time_ms !== null && this.total_time_ms !== undefined) {
      output.writeFieldBegin('total_time_ms', Thrift.Type.I64, 5);
      output.writeI64(this.total_time_ms);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TGpuMemorySummary = module.exports.TGpuMemorySummary = function(args) {
    this.max = null;
    this.in_use = null;
    this.allocated = null;
    this.is_allocation_capped = null;
    if (args) {
      if (args.max !== undefined && args.max !== null) {
        this.max = args.max;
      }
      if (args.in_use !== undefined && args.in_use !== null) {
        this.in_use = args.in_use;
      }
      if (args.allocated !== undefined && args.allocated !== null) {
        this.allocated = args.allocated;
      }
      if (args.is_allocation_capped !== undefined && args.is_allocation_capped !== null) {
        this.is_allocation_capped = args.is_allocation_capped;
      }
    }
  };
  TGpuMemorySummary.prototype = {};
  TGpuMemorySummary.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I64) {
          this.max = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I64) {
          this.in_use = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.I64) {
          this.allocated = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.BOOL) {
          this.is_allocation_capped = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TGpuMemorySummary.prototype.write = function(output) {
    output.writeStructBegin('TGpuMemorySummary');
    if (this.max !== null && this.max !== undefined) {
      output.writeFieldBegin('max', Thrift.Type.I64, 1);
      output.writeI64(this.max);
      output.writeFieldEnd();
    }
    if (this.in_use !== null && this.in_use !== undefined) {
      output.writeFieldBegin('in_use', Thrift.Type.I64, 2);
      output.writeI64(this.in_use);
      output.writeFieldEnd();
    }
    if (this.allocated !== null && this.allocated !== undefined) {
      output.writeFieldBegin('allocated', Thrift.Type.I64, 3);
      output.writeI64(this.allocated);
      output.writeFieldEnd();
    }
    if (this.is_allocation_capped !== null && this.is_allocation_capped !== undefined) {
      output.writeFieldBegin('is_allocation_capped', Thrift.Type.BOOL, 4);
      output.writeBool(this.is_allocation_capped);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TMemorySummary = module.exports.TMemorySummary = function(args) {
    this.cpu_memory_in_use = null;
    this.gpu_summary = null;
    if (args) {
      if (args.cpu_memory_in_use !== undefined && args.cpu_memory_in_use !== null) {
        this.cpu_memory_in_use = args.cpu_memory_in_use;
      }
      if (args.gpu_summary !== undefined && args.gpu_summary !== null) {
        this.gpu_summary = Thrift.copyList(args.gpu_summary, [ttypes.TGpuMemorySummary]);
      }
    }
  };
  TMemorySummary.prototype = {};
  TMemorySummary.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I64) {
          this.cpu_memory_in_use = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          var _size104 = 0;
          var _rtmp3108;
          this.gpu_summary = [];
          var _etype107 = 0;
          _rtmp3108 = input.readListBegin();
          _etype107 = _rtmp3108.etype;
          _size104 = _rtmp3108.size;
          for (var _i109 = 0; _i109 < _size104; ++_i109)
          {
            var elem110 = null;
            elem110 = new ttypes.TGpuMemorySummary();
            elem110.read(input);
            this.gpu_summary.push(elem110);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TMemorySummary.prototype.write = function(output) {
    output.writeStructBegin('TMemorySummary');
    if (this.cpu_memory_in_use !== null && this.cpu_memory_in_use !== undefined) {
      output.writeFieldBegin('cpu_memory_in_use', Thrift.Type.I64, 1);
      output.writeI64(this.cpu_memory_in_use);
      output.writeFieldEnd();
    }
    if (this.gpu_summary !== null && this.gpu_summary !== undefined) {
      output.writeFieldBegin('gpu_summary', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.STRUCT, this.gpu_summary.length);
      for (var iter111 in this.gpu_summary)
      {
        if (this.gpu_summary.hasOwnProperty(iter111))
        {
          iter111 = this.gpu_summary[iter111];
          iter111.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TTableDetails = module.exports.TTableDetails = function(args) {
    this.row_desc = null;
    this.fragment_size = null;
    this.page_size = null;
    this.max_rows = null;
    this.view_sql = null;
    if (args) {
      if (args.row_desc !== undefined && args.row_desc !== null) {
        this.row_desc = Thrift.copyList(args.row_desc, [ttypes.TColumnType]);
      }
      if (args.fragment_size !== undefined && args.fragment_size !== null) {
        this.fragment_size = args.fragment_size;
      }
      if (args.page_size !== undefined && args.page_size !== null) {
        this.page_size = args.page_size;
      }
      if (args.max_rows !== undefined && args.max_rows !== null) {
        this.max_rows = args.max_rows;
      }
      if (args.view_sql !== undefined && args.view_sql !== null) {
        this.view_sql = args.view_sql;
      }
    }
  };
  TTableDetails.prototype = {};
  TTableDetails.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.LIST) {
          var _size112 = 0;
          var _rtmp3116;
          this.row_desc = [];
          var _etype115 = 0;
          _rtmp3116 = input.readListBegin();
          _etype115 = _rtmp3116.etype;
          _size112 = _rtmp3116.size;
          for (var _i117 = 0; _i117 < _size112; ++_i117)
          {
            var elem118 = null;
            elem118 = new ttypes.TColumnType();
            elem118.read(input);
            this.row_desc.push(elem118);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I64) {
          this.fragment_size = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.I64) {
          this.page_size = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.I64) {
          this.max_rows = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.STRING) {
          this.view_sql = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TTableDetails.prototype.write = function(output) {
    output.writeStructBegin('TTableDetails');
    if (this.row_desc !== null && this.row_desc !== undefined) {
      output.writeFieldBegin('row_desc', Thrift.Type.LIST, 1);
      output.writeListBegin(Thrift.Type.STRUCT, this.row_desc.length);
      for (var iter119 in this.row_desc)
      {
        if (this.row_desc.hasOwnProperty(iter119))
        {
          iter119 = this.row_desc[iter119];
          iter119.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.fragment_size !== null && this.fragment_size !== undefined) {
      output.writeFieldBegin('fragment_size', Thrift.Type.I64, 2);
      output.writeI64(this.fragment_size);
      output.writeFieldEnd();
    }
    if (this.page_size !== null && this.page_size !== undefined) {
      output.writeFieldBegin('page_size', Thrift.Type.I64, 3);
      output.writeI64(this.page_size);
      output.writeFieldEnd();
    }
    if (this.max_rows !== null && this.max_rows !== undefined) {
      output.writeFieldBegin('max_rows', Thrift.Type.I64, 4);
      output.writeI64(this.max_rows);
      output.writeFieldEnd();
    }
    if (this.view_sql !== null && this.view_sql !== undefined) {
      output.writeFieldBegin('view_sql', Thrift.Type.STRING, 5);
      output.writeString(this.view_sql);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TColumnRange = module.exports.TColumnRange = function(args) {
    this.type = null;
    this.col_id = null;
    this.table_id = null;
    this.has_nulls = null;
    this.int_min = null;
    this.int_max = null;
    this.bucket = null;
    this.fp_min = null;
    this.fp_max = null;
    if (args) {
      if (args.type !== undefined && args.type !== null) {
        this.type = args.type;
      }
      if (args.col_id !== undefined && args.col_id !== null) {
        this.col_id = args.col_id;
      }
      if (args.table_id !== undefined && args.table_id !== null) {
        this.table_id = args.table_id;
      }
      if (args.has_nulls !== undefined && args.has_nulls !== null) {
        this.has_nulls = args.has_nulls;
      }
      if (args.int_min !== undefined && args.int_min !== null) {
        this.int_min = args.int_min;
      }
      if (args.int_max !== undefined && args.int_max !== null) {
        this.int_max = args.int_max;
      }
      if (args.bucket !== undefined && args.bucket !== null) {
        this.bucket = args.bucket;
      }
      if (args.fp_min !== undefined && args.fp_min !== null) {
        this.fp_min = args.fp_min;
      }
      if (args.fp_max !== undefined && args.fp_max !== null) {
        this.fp_max = args.fp_max;
      }
    }
  };
  TColumnRange.prototype = {};
  TColumnRange.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I32) {
          this.type = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I32) {
          this.col_id = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.I32) {
          this.table_id = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.BOOL) {
          this.has_nulls = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.I64) {
          this.int_min = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 6:
        if (ftype == Thrift.Type.I64) {
          this.int_max = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 7:
        if (ftype == Thrift.Type.I64) {
          this.bucket = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 8:
        if (ftype == Thrift.Type.DOUBLE) {
          this.fp_min = input.readDouble();
        } else {
          input.skip(ftype);
        }
        break;
        case 9:
        if (ftype == Thrift.Type.DOUBLE) {
          this.fp_max = input.readDouble();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TColumnRange.prototype.write = function(output) {
    output.writeStructBegin('TColumnRange');
    if (this.type !== null && this.type !== undefined) {
      output.writeFieldBegin('type', Thrift.Type.I32, 1);
      output.writeI32(this.type);
      output.writeFieldEnd();
    }
    if (this.col_id !== null && this.col_id !== undefined) {
      output.writeFieldBegin('col_id', Thrift.Type.I32, 2);
      output.writeI32(this.col_id);
      output.writeFieldEnd();
    }
    if (this.table_id !== null && this.table_id !== undefined) {
      output.writeFieldBegin('table_id', Thrift.Type.I32, 3);
      output.writeI32(this.table_id);
      output.writeFieldEnd();
    }
    if (this.has_nulls !== null && this.has_nulls !== undefined) {
      output.writeFieldBegin('has_nulls', Thrift.Type.BOOL, 4);
      output.writeBool(this.has_nulls);
      output.writeFieldEnd();
    }
    if (this.int_min !== null && this.int_min !== undefined) {
      output.writeFieldBegin('int_min', Thrift.Type.I64, 5);
      output.writeI64(this.int_min);
      output.writeFieldEnd();
    }
    if (this.int_max !== null && this.int_max !== undefined) {
      output.writeFieldBegin('int_max', Thrift.Type.I64, 6);
      output.writeI64(this.int_max);
      output.writeFieldEnd();
    }
    if (this.bucket !== null && this.bucket !== undefined) {
      output.writeFieldBegin('bucket', Thrift.Type.I64, 7);
      output.writeI64(this.bucket);
      output.writeFieldEnd();
    }
    if (this.fp_min !== null && this.fp_min !== undefined) {
      output.writeFieldBegin('fp_min', Thrift.Type.DOUBLE, 8);
      output.writeDouble(this.fp_min);
      output.writeFieldEnd();
    }
    if (this.fp_max !== null && this.fp_max !== undefined) {
      output.writeFieldBegin('fp_max', Thrift.Type.DOUBLE, 9);
      output.writeDouble(this.fp_max);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TDictionaryGeneration = module.exports.TDictionaryGeneration = function(args) {
    this.dict_id = null;
    this.entry_count = null;
    if (args) {
      if (args.dict_id !== undefined && args.dict_id !== null) {
        this.dict_id = args.dict_id;
      }
      if (args.entry_count !== undefined && args.entry_count !== null) {
        this.entry_count = args.entry_count;
      }
    }
  };
  TDictionaryGeneration.prototype = {};
  TDictionaryGeneration.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I32) {
          this.dict_id = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I64) {
          this.entry_count = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TDictionaryGeneration.prototype.write = function(output) {
    output.writeStructBegin('TDictionaryGeneration');
    if (this.dict_id !== null && this.dict_id !== undefined) {
      output.writeFieldBegin('dict_id', Thrift.Type.I32, 1);
      output.writeI32(this.dict_id);
      output.writeFieldEnd();
    }
    if (this.entry_count !== null && this.entry_count !== undefined) {
      output.writeFieldBegin('entry_count', Thrift.Type.I64, 2);
      output.writeI64(this.entry_count);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TTableGeneration = module.exports.TTableGeneration = function(args) {
    this.table_id = null;
    this.tuple_count = null;
    this.start_rowid = null;
    if (args) {
      if (args.table_id !== undefined && args.table_id !== null) {
        this.table_id = args.table_id;
      }
      if (args.tuple_count !== undefined && args.tuple_count !== null) {
        this.tuple_count = args.tuple_count;
      }
      if (args.start_rowid !== undefined && args.start_rowid !== null) {
        this.start_rowid = args.start_rowid;
      }
    }
  };
  TTableGeneration.prototype = {};
  TTableGeneration.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I32) {
          this.table_id = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I64) {
          this.tuple_count = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.I64) {
          this.start_rowid = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TTableGeneration.prototype.write = function(output) {
    output.writeStructBegin('TTableGeneration');
    if (this.table_id !== null && this.table_id !== undefined) {
      output.writeFieldBegin('table_id', Thrift.Type.I32, 1);
      output.writeI32(this.table_id);
      output.writeFieldEnd();
    }
    if (this.tuple_count !== null && this.tuple_count !== undefined) {
      output.writeFieldBegin('tuple_count', Thrift.Type.I64, 2);
      output.writeI64(this.tuple_count);
      output.writeFieldEnd();
    }
    if (this.start_rowid !== null && this.start_rowid !== undefined) {
      output.writeFieldBegin('start_rowid', Thrift.Type.I64, 3);
      output.writeI64(this.start_rowid);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TPendingQuery = module.exports.TPendingQuery = function(args) {
    this.id = null;
    this.column_ranges = null;
    this.dictionary_generations = null;
    this.table_generations = null;
    if (args) {
      if (args.id !== undefined && args.id !== null) {
        this.id = args.id;
      }
      if (args.column_ranges !== undefined && args.column_ranges !== null) {
        this.column_ranges = Thrift.copyList(args.column_ranges, [ttypes.TColumnRange]);
      }
      if (args.dictionary_generations !== undefined && args.dictionary_generations !== null) {
        this.dictionary_generations = Thrift.copyList(args.dictionary_generations, [ttypes.TDictionaryGeneration]);
      }
      if (args.table_generations !== undefined && args.table_generations !== null) {
        this.table_generations = Thrift.copyList(args.table_generations, [ttypes.TTableGeneration]);
      }
    }
  };
  TPendingQuery.prototype = {};
  TPendingQuery.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I64) {
          this.id = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          var _size120 = 0;
          var _rtmp3124;
          this.column_ranges = [];
          var _etype123 = 0;
          _rtmp3124 = input.readListBegin();
          _etype123 = _rtmp3124.etype;
          _size120 = _rtmp3124.size;
          for (var _i125 = 0; _i125 < _size120; ++_i125)
          {
            var elem126 = null;
            elem126 = new ttypes.TColumnRange();
            elem126.read(input);
            this.column_ranges.push(elem126);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.LIST) {
          var _size127 = 0;
          var _rtmp3131;
          this.dictionary_generations = [];
          var _etype130 = 0;
          _rtmp3131 = input.readListBegin();
          _etype130 = _rtmp3131.etype;
          _size127 = _rtmp3131.size;
          for (var _i132 = 0; _i132 < _size127; ++_i132)
          {
            var elem133 = null;
            elem133 = new ttypes.TDictionaryGeneration();
            elem133.read(input);
            this.dictionary_generations.push(elem133);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.LIST) {
          var _size134 = 0;
          var _rtmp3138;
          this.table_generations = [];
          var _etype137 = 0;
          _rtmp3138 = input.readListBegin();
          _etype137 = _rtmp3138.etype;
          _size134 = _rtmp3138.size;
          for (var _i139 = 0; _i139 < _size134; ++_i139)
          {
            var elem140 = null;
            elem140 = new ttypes.TTableGeneration();
            elem140.read(input);
            this.table_generations.push(elem140);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TPendingQuery.prototype.write = function(output) {
    output.writeStructBegin('TPendingQuery');
    if (this.id !== null && this.id !== undefined) {
      output.writeFieldBegin('id', Thrift.Type.I64, 1);
      output.writeI64(this.id);
      output.writeFieldEnd();
    }
    if (this.column_ranges !== null && this.column_ranges !== undefined) {
      output.writeFieldBegin('column_ranges', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.STRUCT, this.column_ranges.length);
      for (var iter141 in this.column_ranges)
      {
        if (this.column_ranges.hasOwnProperty(iter141))
        {
          iter141 = this.column_ranges[iter141];
          iter141.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.dictionary_generations !== null && this.dictionary_generations !== undefined) {
      output.writeFieldBegin('dictionary_generations', Thrift.Type.LIST, 3);
      output.writeListBegin(Thrift.Type.STRUCT, this.dictionary_generations.length);
      for (var iter142 in this.dictionary_generations)
      {
        if (this.dictionary_generations.hasOwnProperty(iter142))
        {
          iter142 = this.dictionary_generations[iter142];
          iter142.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.table_generations !== null && this.table_generations !== undefined) {
      output.writeFieldBegin('table_generations', Thrift.Type.LIST, 4);
      output.writeListBegin(Thrift.Type.STRUCT, this.table_generations.length);
      for (var iter143 in this.table_generations)
      {
        if (this.table_generations.hasOwnProperty(iter143))
        {
          iter143 = this.table_generations[iter143];
          iter143.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TVarLen = module.exports.TVarLen = function(args) {
    this.payload = null;
    this.is_null = null;
    if (args) {
      if (args.payload !== undefined && args.payload !== null) {
        this.payload = args.payload;
      }
      if (args.is_null !== undefined && args.is_null !== null) {
        this.is_null = args.is_null;
      }
    }
  };
  TVarLen.prototype = {};
  TVarLen.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.payload = input.readBinary();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.BOOL) {
          this.is_null = input.readBool();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TVarLen.prototype.write = function(output) {
    output.writeStructBegin('TVarLen');
    if (this.payload !== null && this.payload !== undefined) {
      output.writeFieldBegin('payload', Thrift.Type.STRING, 1);
      output.writeBinary(this.payload);
      output.writeFieldEnd();
    }
    if (this.is_null !== null && this.is_null !== undefined) {
      output.writeFieldBegin('is_null', Thrift.Type.BOOL, 2);
      output.writeBool(this.is_null);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TDataBlockPtr = module.exports.TDataBlockPtr = function(args) {
    this.fixed_len_data = null;
    this.var_len_data = null;
    if (args) {
      if (args.fixed_len_data !== undefined && args.fixed_len_data !== null) {
        this.fixed_len_data = args.fixed_len_data;
      }
      if (args.var_len_data !== undefined && args.var_len_data !== null) {
        this.var_len_data = Thrift.copyList(args.var_len_data, [ttypes.TVarLen]);
      }
    }
  };
  TDataBlockPtr.prototype = {};
  TDataBlockPtr.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.fixed_len_data = input.readBinary();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          var _size144 = 0;
          var _rtmp3148;
          this.var_len_data = [];
          var _etype147 = 0;
          _rtmp3148 = input.readListBegin();
          _etype147 = _rtmp3148.etype;
          _size144 = _rtmp3148.size;
          for (var _i149 = 0; _i149 < _size144; ++_i149)
          {
            var elem150 = null;
            elem150 = new ttypes.TVarLen();
            elem150.read(input);
            this.var_len_data.push(elem150);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TDataBlockPtr.prototype.write = function(output) {
    output.writeStructBegin('TDataBlockPtr');
    if (this.fixed_len_data !== null && this.fixed_len_data !== undefined) {
      output.writeFieldBegin('fixed_len_data', Thrift.Type.STRING, 1);
      output.writeBinary(this.fixed_len_data);
      output.writeFieldEnd();
    }
    if (this.var_len_data !== null && this.var_len_data !== undefined) {
      output.writeFieldBegin('var_len_data', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.STRUCT, this.var_len_data.length);
      for (var iter151 in this.var_len_data)
      {
        if (this.var_len_data.hasOwnProperty(iter151))
        {
          iter151 = this.var_len_data[iter151];
          iter151.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TInsertData = module.exports.TInsertData = function(args) {
    this.db_id = null;
    this.table_id = null;
    this.column_ids = null;
    this.data = null;
    this.num_rows = null;
    if (args) {
      if (args.db_id !== undefined && args.db_id !== null) {
        this.db_id = args.db_id;
      }
      if (args.table_id !== undefined && args.table_id !== null) {
        this.table_id = args.table_id;
      }
      if (args.column_ids !== undefined && args.column_ids !== null) {
        this.column_ids = Thrift.copyList(args.column_ids, [null]);
      }
      if (args.data !== undefined && args.data !== null) {
        this.data = Thrift.copyList(args.data, [ttypes.TDataBlockPtr]);
      }
      if (args.num_rows !== undefined && args.num_rows !== null) {
        this.num_rows = args.num_rows;
      }
    }
  };
  TInsertData.prototype = {};
  TInsertData.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I32) {
          this.db_id = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I32) {
          this.table_id = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.LIST) {
          var _size152 = 0;
          var _rtmp3156;
          this.column_ids = [];
          var _etype155 = 0;
          _rtmp3156 = input.readListBegin();
          _etype155 = _rtmp3156.etype;
          _size152 = _rtmp3156.size;
          for (var _i157 = 0; _i157 < _size152; ++_i157)
          {
            var elem158 = null;
            elem158 = input.readI32();
            this.column_ids.push(elem158);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.LIST) {
          var _size159 = 0;
          var _rtmp3163;
          this.data = [];
          var _etype162 = 0;
          _rtmp3163 = input.readListBegin();
          _etype162 = _rtmp3163.etype;
          _size159 = _rtmp3163.size;
          for (var _i164 = 0; _i164 < _size159; ++_i164)
          {
            var elem165 = null;
            elem165 = new ttypes.TDataBlockPtr();
            elem165.read(input);
            this.data.push(elem165);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.I64) {
          this.num_rows = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TInsertData.prototype.write = function(output) {
    output.writeStructBegin('TInsertData');
    if (this.db_id !== null && this.db_id !== undefined) {
      output.writeFieldBegin('db_id', Thrift.Type.I32, 1);
      output.writeI32(this.db_id);
      output.writeFieldEnd();
    }
    if (this.table_id !== null && this.table_id !== undefined) {
      output.writeFieldBegin('table_id', Thrift.Type.I32, 2);
      output.writeI32(this.table_id);
      output.writeFieldEnd();
    }
    if (this.column_ids !== null && this.column_ids !== undefined) {
      output.writeFieldBegin('column_ids', Thrift.Type.LIST, 3);
      output.writeListBegin(Thrift.Type.I32, this.column_ids.length);
      for (var iter166 in this.column_ids)
      {
        if (this.column_ids.hasOwnProperty(iter166))
        {
          iter166 = this.column_ids[iter166];
          output.writeI32(iter166);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.data !== null && this.data !== undefined) {
      output.writeFieldBegin('data', Thrift.Type.LIST, 4);
      output.writeListBegin(Thrift.Type.STRUCT, this.data.length);
      for (var iter167 in this.data)
      {
        if (this.data.hasOwnProperty(iter167))
        {
          iter167 = this.data[iter167];
          iter167.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.num_rows !== null && this.num_rows !== undefined) {
      output.writeFieldBegin('num_rows', Thrift.Type.I64, 5);
      output.writeI64(this.num_rows);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TRawRenderPassDataResult = module.exports.TRawRenderPassDataResult = function(args) {
    this.num_channels = null;
    this.pixels = null;
    this.row_ids_A = null;
    this.row_ids_B = null;
    this.table_ids = null;
    if (args) {
      if (args.num_channels !== undefined && args.num_channels !== null) {
        this.num_channels = args.num_channels;
      }
      if (args.pixels !== undefined && args.pixels !== null) {
        this.pixels = args.pixels;
      }
      if (args.row_ids_A !== undefined && args.row_ids_A !== null) {
        this.row_ids_A = args.row_ids_A;
      }
      if (args.row_ids_B !== undefined && args.row_ids_B !== null) {
        this.row_ids_B = args.row_ids_B;
      }
      if (args.table_ids !== undefined && args.table_ids !== null) {
        this.table_ids = args.table_ids;
      }
    }
  };
  TRawRenderPassDataResult.prototype = {};
  TRawRenderPassDataResult.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I32) {
          this.num_channels = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.pixels = input.readBinary();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.STRING) {
          this.row_ids_A = input.readBinary();
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.STRING) {
          this.row_ids_B = input.readBinary();
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.STRING) {
          this.table_ids = input.readBinary();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TRawRenderPassDataResult.prototype.write = function(output) {
    output.writeStructBegin('TRawRenderPassDataResult');
    if (this.num_channels !== null && this.num_channels !== undefined) {
      output.writeFieldBegin('num_channels', Thrift.Type.I32, 1);
      output.writeI32(this.num_channels);
      output.writeFieldEnd();
    }
    if (this.pixels !== null && this.pixels !== undefined) {
      output.writeFieldBegin('pixels', Thrift.Type.STRING, 2);
      output.writeBinary(this.pixels);
      output.writeFieldEnd();
    }
    if (this.row_ids_A !== null && this.row_ids_A !== undefined) {
      output.writeFieldBegin('row_ids_A', Thrift.Type.STRING, 3);
      output.writeBinary(this.row_ids_A);
      output.writeFieldEnd();
    }
    if (this.row_ids_B !== null && this.row_ids_B !== undefined) {
      output.writeFieldBegin('row_ids_B', Thrift.Type.STRING, 4);
      output.writeBinary(this.row_ids_B);
      output.writeFieldEnd();
    }
    if (this.table_ids !== null && this.table_ids !== undefined) {
      output.writeFieldBegin('table_ids', Thrift.Type.STRING, 5);
      output.writeBinary(this.table_ids);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  var TRawPixelDataResult = module.exports.TRawPixelDataResult = function(args) {
    this.width = null;
    this.height = null;
    this.render_pass_map = null;
    this.execution_time_ms = null;
    this.render_time_ms = null;
    this.total_time_ms = null;
    if (args) {
      if (args.width !== undefined && args.width !== null) {
        this.width = args.width;
      }
      if (args.height !== undefined && args.height !== null) {
        this.height = args.height;
      }
      if (args.render_pass_map !== undefined && args.render_pass_map !== null) {
        this.render_pass_map = Thrift.copyMap(args.render_pass_map, [ttypes.TRawRenderPassDataResult]);
      }
      if (args.execution_time_ms !== undefined && args.execution_time_ms !== null) {
        this.execution_time_ms = args.execution_time_ms;
      }
      if (args.render_time_ms !== undefined && args.render_time_ms !== null) {
        this.render_time_ms = args.render_time_ms;
      }
      if (args.total_time_ms !== undefined && args.total_time_ms !== null) {
        this.total_time_ms = args.total_time_ms;
      }
    }
  };
  TRawPixelDataResult.prototype = {};
  TRawPixelDataResult.prototype.read = function(input) {
    input.readStructBegin();
    while (true)
    {
      var ret = input.readFieldBegin();
      var fname = ret.fname;
      var ftype = ret.ftype;
      var fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
        if (ftype == Thrift.Type.I32) {
          this.width = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I32) {
          this.height = input.readI32();
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.MAP) {
          var _size168 = 0;
          var _rtmp3172;
          this.render_pass_map = {};
          var _ktype169 = 0;
          var _vtype170 = 0;
          _rtmp3172 = input.readMapBegin();
          _ktype169 = _rtmp3172.ktype;
          _vtype170 = _rtmp3172.vtype;
          _size168 = _rtmp3172.size;
          for (var _i173 = 0; _i173 < _size168; ++_i173)
          {
            var key174 = null;
            var val175 = null;
            key174 = input.readI32();
            val175 = new ttypes.TRawRenderPassDataResult();
            val175.read(input);
            this.render_pass_map[key174] = val175;
          }
          input.readMapEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 8:
        if (ftype == Thrift.Type.I64) {
          this.execution_time_ms = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 9:
        if (ftype == Thrift.Type.I64) {
          this.render_time_ms = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 10:
        if (ftype == Thrift.Type.I64) {
          this.total_time_ms = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  TRawPixelDataResult.prototype.write = function(output) {
    output.writeStructBegin('TRawPixelDataResult');
    if (this.width !== null && this.width !== undefined) {
      output.writeFieldBegin('width', Thrift.Type.I32, 1);
      output.writeI32(this.width);
      output.writeFieldEnd();
    }
    if (this.height !== null && this.height !== undefined) {
      output.writeFieldBegin('height', Thrift.Type.I32, 2);
      output.writeI32(this.height);
      output.writeFieldEnd();
    }
    if (this.render_pass_map !== null && this.render_pass_map !== undefined) {
      output.writeFieldBegin('render_pass_map', Thrift.Type.MAP, 3);
      output.writeMapBegin(Thrift.Type.I32, Thrift.Type.STRUCT, Thrift.objectLength(this.render_pass_map));
      for (var kiter176 in this.render_pass_map)
      {
        if (this.render_pass_map.hasOwnProperty(kiter176))
        {
          var viter177 = this.render_pass_map[kiter176];
          output.writeI32(kiter176);
          viter177.write(output);
        }
      }
      output.writeMapEnd();
      output.writeFieldEnd();
    }
    if (this.execution_time_ms !== null && this.execution_time_ms !== undefined) {
      output.writeFieldBegin('execution_time_ms', Thrift.Type.I64, 8);
      output.writeI64(this.execution_time_ms);
      output.writeFieldEnd();
    }
    if (this.render_time_ms !== null && this.render_time_ms !== undefined) {
      output.writeFieldBegin('render_time_ms', Thrift.Type.I64, 9);
      output.writeI64(this.render_time_ms);
      output.writeFieldEnd();
    }
    if (this.total_time_ms !== null && this.total_time_ms !== undefined) {
      output.writeFieldBegin('total_time_ms', Thrift.Type.I64, 10);
      output.writeI64(this.total_time_ms);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  