incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [31/51] [partial] Restructuring the distribution projects to allow for seperate hadoop2 and hadoop1 binaries.
Date Tue, 29 Apr 2014 21:51:49 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/7395b9cb/distribution-hadoop1/src/main/scripts/interface/gen-js/Blur_types.js
----------------------------------------------------------------------
diff --git a/distribution-hadoop1/src/main/scripts/interface/gen-js/Blur_types.js b/distribution-hadoop1/src/main/scripts/interface/gen-js/Blur_types.js
new file mode 100644
index 0000000..3e04369
--- /dev/null
+++ b/distribution-hadoop1/src/main/scripts/interface/gen-js/Blur_types.js
@@ -0,0 +1,3641 @@
+//
+// Autogenerated by Thrift Compiler (0.9.0)
+//
+// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+//
+
+ErrorType = {
+'UNKNOWN' : 0,
+'QUERY_CANCEL' : 1,
+'QUERY_TIMEOUT' : 2,
+'BACK_PRESSURE' : 3,
+'REQUEST_TIMEOUT' : 4
+};
+ScoreType = {
+'SUPER' : 0,
+'AGGREGATE' : 1,
+'BEST' : 2,
+'CONSTANT' : 3
+};
+QueryState = {
+'RUNNING' : 0,
+'INTERRUPTED' : 1,
+'COMPLETE' : 2,
+'BACK_PRESSURE_INTERRUPTED' : 3
+};
+Status = {
+'NOT_FOUND' : 0,
+'FOUND' : 1
+};
+RowMutationType = {
+'DELETE_ROW' : 0,
+'REPLACE_ROW' : 1,
+'UPDATE_ROW' : 2
+};
+RecordMutationType = {
+'DELETE_ENTIRE_RECORD' : 0,
+'REPLACE_ENTIRE_RECORD' : 1,
+'REPLACE_COLUMNS' : 2,
+'APPEND_COLUMN_VALUES' : 3
+};
+ShardState = {
+'OPENING' : 0,
+'OPEN' : 1,
+'OPENING_ERROR' : 2,
+'CLOSING' : 3,
+'CLOSED' : 4,
+'CLOSING_ERROR' : 5
+};
+Level = {
+'OFF' : 0,
+'FATAL' : 1,
+'ERROR' : 2,
+'WARN' : 3,
+'INFO' : 4,
+'DEBUG' : 5,
+'TRACE' : 6,
+'ALL' : 7
+};
+BlurException = function(args) {
+  this.message = null;
+  this.stackTraceStr = null;
+  this.errorType = null;
+  if (args) {
+    if (args.message !== undefined) {
+      this.message = args.message;
+    }
+    if (args.stackTraceStr !== undefined) {
+      this.stackTraceStr = args.stackTraceStr;
+    }
+    if (args.errorType !== undefined) {
+      this.errorType = args.errorType;
+    }
+  }
+};
+Thrift.inherits(BlurException, Thrift.TException);
+BlurException.prototype.name = 'BlurException';
+BlurException.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.message = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.stackTraceStr = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I32) {
+        this.errorType = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+BlurException.prototype.write = function(output) {
+  output.writeStructBegin('BlurException');
+  if (this.message !== null && this.message !== undefined) {
+    output.writeFieldBegin('message', Thrift.Type.STRING, 1);
+    output.writeString(this.message);
+    output.writeFieldEnd();
+  }
+  if (this.stackTraceStr !== null && this.stackTraceStr !== undefined) {
+    output.writeFieldBegin('stackTraceStr', Thrift.Type.STRING, 2);
+    output.writeString(this.stackTraceStr);
+    output.writeFieldEnd();
+  }
+  if (this.errorType !== null && this.errorType !== undefined) {
+    output.writeFieldBegin('errorType', Thrift.Type.I32, 3);
+    output.writeI32(this.errorType);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Column = function(args) {
+  this.name = null;
+  this.value = null;
+  if (args) {
+    if (args.name !== undefined) {
+      this.name = args.name;
+    }
+    if (args.value !== undefined) {
+      this.value = args.value;
+    }
+  }
+};
+Column.prototype = {};
+Column.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.name = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.value = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Column.prototype.write = function(output) {
+  output.writeStructBegin('Column');
+  if (this.name !== null && this.name !== undefined) {
+    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
+    output.writeString(this.name);
+    output.writeFieldEnd();
+  }
+  if (this.value !== null && this.value !== undefined) {
+    output.writeFieldBegin('value', Thrift.Type.STRING, 2);
+    output.writeString(this.value);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Record = function(args) {
+  this.recordId = null;
+  this.family = null;
+  this.columns = null;
+  if (args) {
+    if (args.recordId !== undefined) {
+      this.recordId = args.recordId;
+    }
+    if (args.family !== undefined) {
+      this.family = args.family;
+    }
+    if (args.columns !== undefined) {
+      this.columns = args.columns;
+    }
+  }
+};
+Record.prototype = {};
+Record.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.recordId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.family = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.LIST) {
+        var _size0 = 0;
+        var _rtmp34;
+        this.columns = [];
+        var _etype3 = 0;
+        _rtmp34 = input.readListBegin();
+        _etype3 = _rtmp34.etype;
+        _size0 = _rtmp34.size;
+        for (var _i5 = 0; _i5 < _size0; ++_i5)
+        {
+          var elem6 = null;
+          elem6 = new Column();
+          elem6.read(input);
+          this.columns.push(elem6);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Record.prototype.write = function(output) {
+  output.writeStructBegin('Record');
+  if (this.recordId !== null && this.recordId !== undefined) {
+    output.writeFieldBegin('recordId', Thrift.Type.STRING, 1);
+    output.writeString(this.recordId);
+    output.writeFieldEnd();
+  }
+  if (this.family !== null && this.family !== undefined) {
+    output.writeFieldBegin('family', Thrift.Type.STRING, 2);
+    output.writeString(this.family);
+    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 iter7 in this.columns)
+    {
+      if (this.columns.hasOwnProperty(iter7))
+      {
+        iter7 = this.columns[iter7];
+        iter7.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Row = function(args) {
+  this.id = null;
+  this.records = null;
+  if (args) {
+    if (args.id !== undefined) {
+      this.id = args.id;
+    }
+    if (args.records !== undefined) {
+      this.records = args.records;
+    }
+  }
+};
+Row.prototype = {};
+Row.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.id = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.LIST) {
+        var _size8 = 0;
+        var _rtmp312;
+        this.records = [];
+        var _etype11 = 0;
+        _rtmp312 = input.readListBegin();
+        _etype11 = _rtmp312.etype;
+        _size8 = _rtmp312.size;
+        for (var _i13 = 0; _i13 < _size8; ++_i13)
+        {
+          var elem14 = null;
+          elem14 = new Record();
+          elem14.read(input);
+          this.records.push(elem14);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Row.prototype.write = function(output) {
+  output.writeStructBegin('Row');
+  if (this.id !== null && this.id !== undefined) {
+    output.writeFieldBegin('id', Thrift.Type.STRING, 1);
+    output.writeString(this.id);
+    output.writeFieldEnd();
+  }
+  if (this.records !== null && this.records !== undefined) {
+    output.writeFieldBegin('records', Thrift.Type.LIST, 2);
+    output.writeListBegin(Thrift.Type.STRUCT, this.records.length);
+    for (var iter15 in this.records)
+    {
+      if (this.records.hasOwnProperty(iter15))
+      {
+        iter15 = this.records[iter15];
+        iter15.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Query = function(args) {
+  this.query = null;
+  this.rowQuery = true;
+  this.scoreType = 0;
+  this.rowFilter = null;
+  this.recordFilter = null;
+  if (args) {
+    if (args.query !== undefined) {
+      this.query = args.query;
+    }
+    if (args.rowQuery !== undefined) {
+      this.rowQuery = args.rowQuery;
+    }
+    if (args.scoreType !== undefined) {
+      this.scoreType = args.scoreType;
+    }
+    if (args.rowFilter !== undefined) {
+      this.rowFilter = args.rowFilter;
+    }
+    if (args.recordFilter !== undefined) {
+      this.recordFilter = args.recordFilter;
+    }
+  }
+};
+Query.prototype = {};
+Query.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.query = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.BOOL) {
+        this.rowQuery = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I32) {
+        this.scoreType = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.STRING) {
+        this.rowFilter = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.STRING) {
+        this.recordFilter = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Query.prototype.write = function(output) {
+  output.writeStructBegin('Query');
+  if (this.query !== null && this.query !== undefined) {
+    output.writeFieldBegin('query', Thrift.Type.STRING, 1);
+    output.writeString(this.query);
+    output.writeFieldEnd();
+  }
+  if (this.rowQuery !== null && this.rowQuery !== undefined) {
+    output.writeFieldBegin('rowQuery', Thrift.Type.BOOL, 2);
+    output.writeBool(this.rowQuery);
+    output.writeFieldEnd();
+  }
+  if (this.scoreType !== null && this.scoreType !== undefined) {
+    output.writeFieldBegin('scoreType', Thrift.Type.I32, 3);
+    output.writeI32(this.scoreType);
+    output.writeFieldEnd();
+  }
+  if (this.rowFilter !== null && this.rowFilter !== undefined) {
+    output.writeFieldBegin('rowFilter', Thrift.Type.STRING, 4);
+    output.writeString(this.rowFilter);
+    output.writeFieldEnd();
+  }
+  if (this.recordFilter !== null && this.recordFilter !== undefined) {
+    output.writeFieldBegin('recordFilter', Thrift.Type.STRING, 5);
+    output.writeString(this.recordFilter);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+HighlightOptions = function(args) {
+  this.query = null;
+  this.preTag = '<<<';
+  this.postTag = '>>>';
+  if (args) {
+    if (args.query !== undefined) {
+      this.query = args.query;
+    }
+    if (args.preTag !== undefined) {
+      this.preTag = args.preTag;
+    }
+    if (args.postTag !== undefined) {
+      this.postTag = args.postTag;
+    }
+  }
+};
+HighlightOptions.prototype = {};
+HighlightOptions.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.query = new Query();
+        this.query.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.preTag = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.STRING) {
+        this.postTag = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+HighlightOptions.prototype.write = function(output) {
+  output.writeStructBegin('HighlightOptions');
+  if (this.query !== null && this.query !== undefined) {
+    output.writeFieldBegin('query', Thrift.Type.STRUCT, 1);
+    this.query.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.preTag !== null && this.preTag !== undefined) {
+    output.writeFieldBegin('preTag', Thrift.Type.STRING, 2);
+    output.writeString(this.preTag);
+    output.writeFieldEnd();
+  }
+  if (this.postTag !== null && this.postTag !== undefined) {
+    output.writeFieldBegin('postTag', Thrift.Type.STRING, 3);
+    output.writeString(this.postTag);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Selector = function(args) {
+  this.recordOnly = null;
+  this.locationId = null;
+  this.rowId = null;
+  this.recordId = null;
+  this.columnFamiliesToFetch = null;
+  this.columnsToFetch = null;
+  this.startRecord = 0;
+  this.maxRecordsToFetch = 1000;
+  this.highlightOptions = null;
+  this.orderOfFamiliesToFetch = null;
+  if (args) {
+    if (args.recordOnly !== undefined) {
+      this.recordOnly = args.recordOnly;
+    }
+    if (args.locationId !== undefined) {
+      this.locationId = args.locationId;
+    }
+    if (args.rowId !== undefined) {
+      this.rowId = args.rowId;
+    }
+    if (args.recordId !== undefined) {
+      this.recordId = args.recordId;
+    }
+    if (args.columnFamiliesToFetch !== undefined) {
+      this.columnFamiliesToFetch = args.columnFamiliesToFetch;
+    }
+    if (args.columnsToFetch !== undefined) {
+      this.columnsToFetch = args.columnsToFetch;
+    }
+    if (args.startRecord !== undefined) {
+      this.startRecord = args.startRecord;
+    }
+    if (args.maxRecordsToFetch !== undefined) {
+      this.maxRecordsToFetch = args.maxRecordsToFetch;
+    }
+    if (args.highlightOptions !== undefined) {
+      this.highlightOptions = args.highlightOptions;
+    }
+    if (args.orderOfFamiliesToFetch !== undefined) {
+      this.orderOfFamiliesToFetch = args.orderOfFamiliesToFetch;
+    }
+  }
+};
+Selector.prototype = {};
+Selector.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.recordOnly = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.locationId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.STRING) {
+        this.rowId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.STRING) {
+        this.recordId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.SET) {
+        var _size16 = 0;
+        var _rtmp320;
+        this.columnFamiliesToFetch = [];
+        var _etype19 = 0;
+        _rtmp320 = input.readSetBegin();
+        _etype19 = _rtmp320.etype;
+        _size16 = _rtmp320.size;
+        for (var _i21 = 0; _i21 < _size16; ++_i21)
+        {
+          var elem22 = null;
+          elem22 = input.readString().value;
+          this.columnFamiliesToFetch.push(elem22);
+        }
+        input.readSetEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.MAP) {
+        var _size23 = 0;
+        var _rtmp327;
+        this.columnsToFetch = {};
+        var _ktype24 = 0;
+        var _vtype25 = 0;
+        _rtmp327 = input.readMapBegin();
+        _ktype24 = _rtmp327.ktype;
+        _vtype25 = _rtmp327.vtype;
+        _size23 = _rtmp327.size;
+        for (var _i28 = 0; _i28 < _size23; ++_i28)
+        {
+          if (_i28 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key29 = null;
+          var val30 = null;
+          key29 = input.readString().value;
+          var _size31 = 0;
+          var _rtmp335;
+          val30 = [];
+          var _etype34 = 0;
+          _rtmp335 = input.readSetBegin();
+          _etype34 = _rtmp335.etype;
+          _size31 = _rtmp335.size;
+          for (var _i36 = 0; _i36 < _size31; ++_i36)
+          {
+            var elem37 = null;
+            elem37 = input.readString().value;
+            val30.push(elem37);
+          }
+          input.readSetEnd();
+          this.columnsToFetch[key29] = val30;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 8:
+      if (ftype == Thrift.Type.I32) {
+        this.startRecord = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 9:
+      if (ftype == Thrift.Type.I32) {
+        this.maxRecordsToFetch = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 10:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.highlightOptions = new HighlightOptions();
+        this.highlightOptions.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 11:
+      if (ftype == Thrift.Type.LIST) {
+        var _size38 = 0;
+        var _rtmp342;
+        this.orderOfFamiliesToFetch = [];
+        var _etype41 = 0;
+        _rtmp342 = input.readListBegin();
+        _etype41 = _rtmp342.etype;
+        _size38 = _rtmp342.size;
+        for (var _i43 = 0; _i43 < _size38; ++_i43)
+        {
+          var elem44 = null;
+          elem44 = input.readString().value;
+          this.orderOfFamiliesToFetch.push(elem44);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Selector.prototype.write = function(output) {
+  output.writeStructBegin('Selector');
+  if (this.recordOnly !== null && this.recordOnly !== undefined) {
+    output.writeFieldBegin('recordOnly', Thrift.Type.BOOL, 1);
+    output.writeBool(this.recordOnly);
+    output.writeFieldEnd();
+  }
+  if (this.locationId !== null && this.locationId !== undefined) {
+    output.writeFieldBegin('locationId', Thrift.Type.STRING, 2);
+    output.writeString(this.locationId);
+    output.writeFieldEnd();
+  }
+  if (this.rowId !== null && this.rowId !== undefined) {
+    output.writeFieldBegin('rowId', Thrift.Type.STRING, 3);
+    output.writeString(this.rowId);
+    output.writeFieldEnd();
+  }
+  if (this.recordId !== null && this.recordId !== undefined) {
+    output.writeFieldBegin('recordId', Thrift.Type.STRING, 4);
+    output.writeString(this.recordId);
+    output.writeFieldEnd();
+  }
+  if (this.columnFamiliesToFetch !== null && this.columnFamiliesToFetch !== undefined) {
+    output.writeFieldBegin('columnFamiliesToFetch', Thrift.Type.SET, 5);
+    output.writeSetBegin(Thrift.Type.STRING, this.columnFamiliesToFetch.length);
+    for (var iter45 in this.columnFamiliesToFetch)
+    {
+      if (this.columnFamiliesToFetch.hasOwnProperty(iter45))
+      {
+        iter45 = this.columnFamiliesToFetch[iter45];
+        output.writeString(iter45);
+      }
+    }
+    output.writeSetEnd();
+    output.writeFieldEnd();
+  }
+  if (this.columnsToFetch !== null && this.columnsToFetch !== undefined) {
+    output.writeFieldBegin('columnsToFetch', Thrift.Type.MAP, 6);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.SET, Thrift.objectLength(this.columnsToFetch));
+    for (var kiter46 in this.columnsToFetch)
+    {
+      if (this.columnsToFetch.hasOwnProperty(kiter46))
+      {
+        var viter47 = this.columnsToFetch[kiter46];
+        output.writeString(kiter46);
+        output.writeSetBegin(Thrift.Type.STRING, viter47.length);
+        for (var iter48 in viter47)
+        {
+          if (viter47.hasOwnProperty(iter48))
+          {
+            iter48 = viter47[iter48];
+            output.writeString(iter48);
+          }
+        }
+        output.writeSetEnd();
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  if (this.startRecord !== null && this.startRecord !== undefined) {
+    output.writeFieldBegin('startRecord', Thrift.Type.I32, 8);
+    output.writeI32(this.startRecord);
+    output.writeFieldEnd();
+  }
+  if (this.maxRecordsToFetch !== null && this.maxRecordsToFetch !== undefined) {
+    output.writeFieldBegin('maxRecordsToFetch', Thrift.Type.I32, 9);
+    output.writeI32(this.maxRecordsToFetch);
+    output.writeFieldEnd();
+  }
+  if (this.highlightOptions !== null && this.highlightOptions !== undefined) {
+    output.writeFieldBegin('highlightOptions', Thrift.Type.STRUCT, 10);
+    this.highlightOptions.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.orderOfFamiliesToFetch !== null && this.orderOfFamiliesToFetch !== undefined) {
+    output.writeFieldBegin('orderOfFamiliesToFetch', Thrift.Type.LIST, 11);
+    output.writeListBegin(Thrift.Type.STRING, this.orderOfFamiliesToFetch.length);
+    for (var iter49 in this.orderOfFamiliesToFetch)
+    {
+      if (this.orderOfFamiliesToFetch.hasOwnProperty(iter49))
+      {
+        iter49 = this.orderOfFamiliesToFetch[iter49];
+        output.writeString(iter49);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+FetchRowResult = function(args) {
+  this.row = null;
+  this.startRecord = -1;
+  this.maxRecordsToFetch = -1;
+  this.moreRecordsToFetch = false;
+  this.totalRecords = null;
+  if (args) {
+    if (args.row !== undefined) {
+      this.row = args.row;
+    }
+    if (args.startRecord !== undefined) {
+      this.startRecord = args.startRecord;
+    }
+    if (args.maxRecordsToFetch !== undefined) {
+      this.maxRecordsToFetch = args.maxRecordsToFetch;
+    }
+    if (args.moreRecordsToFetch !== undefined) {
+      this.moreRecordsToFetch = args.moreRecordsToFetch;
+    }
+    if (args.totalRecords !== undefined) {
+      this.totalRecords = args.totalRecords;
+    }
+  }
+};
+FetchRowResult.prototype = {};
+FetchRowResult.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 = new Row();
+        this.row.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.I32) {
+        this.startRecord = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I32) {
+        this.maxRecordsToFetch = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.BOOL) {
+        this.moreRecordsToFetch = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.I32) {
+        this.totalRecords = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+FetchRowResult.prototype.write = function(output) {
+  output.writeStructBegin('FetchRowResult');
+  if (this.row !== null && this.row !== undefined) {
+    output.writeFieldBegin('row', Thrift.Type.STRUCT, 1);
+    this.row.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.startRecord !== null && this.startRecord !== undefined) {
+    output.writeFieldBegin('startRecord', Thrift.Type.I32, 2);
+    output.writeI32(this.startRecord);
+    output.writeFieldEnd();
+  }
+  if (this.maxRecordsToFetch !== null && this.maxRecordsToFetch !== undefined) {
+    output.writeFieldBegin('maxRecordsToFetch', Thrift.Type.I32, 3);
+    output.writeI32(this.maxRecordsToFetch);
+    output.writeFieldEnd();
+  }
+  if (this.moreRecordsToFetch !== null && this.moreRecordsToFetch !== undefined) {
+    output.writeFieldBegin('moreRecordsToFetch', Thrift.Type.BOOL, 4);
+    output.writeBool(this.moreRecordsToFetch);
+    output.writeFieldEnd();
+  }
+  if (this.totalRecords !== null && this.totalRecords !== undefined) {
+    output.writeFieldBegin('totalRecords', Thrift.Type.I32, 5);
+    output.writeI32(this.totalRecords);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+FetchRecordResult = function(args) {
+  this.rowid = null;
+  this.record = null;
+  if (args) {
+    if (args.rowid !== undefined) {
+      this.rowid = args.rowid;
+    }
+    if (args.record !== undefined) {
+      this.record = args.record;
+    }
+  }
+};
+FetchRecordResult.prototype = {};
+FetchRecordResult.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.rowid = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.record = new Record();
+        this.record.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+FetchRecordResult.prototype.write = function(output) {
+  output.writeStructBegin('FetchRecordResult');
+  if (this.rowid !== null && this.rowid !== undefined) {
+    output.writeFieldBegin('rowid', Thrift.Type.STRING, 1);
+    output.writeString(this.rowid);
+    output.writeFieldEnd();
+  }
+  if (this.record !== null && this.record !== undefined) {
+    output.writeFieldBegin('record', Thrift.Type.STRUCT, 2);
+    this.record.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+FetchResult = function(args) {
+  this.exists = null;
+  this.deleted = null;
+  this.table = null;
+  this.rowResult = null;
+  this.recordResult = null;
+  if (args) {
+    if (args.exists !== undefined) {
+      this.exists = args.exists;
+    }
+    if (args.deleted !== undefined) {
+      this.deleted = args.deleted;
+    }
+    if (args.table !== undefined) {
+      this.table = args.table;
+    }
+    if (args.rowResult !== undefined) {
+      this.rowResult = args.rowResult;
+    }
+    if (args.recordResult !== undefined) {
+      this.recordResult = args.recordResult;
+    }
+  }
+};
+FetchResult.prototype = {};
+FetchResult.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.exists = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.BOOL) {
+        this.deleted = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.STRING) {
+        this.table = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.rowResult = new FetchRowResult();
+        this.rowResult.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.recordResult = new FetchRecordResult();
+        this.recordResult.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+FetchResult.prototype.write = function(output) {
+  output.writeStructBegin('FetchResult');
+  if (this.exists !== null && this.exists !== undefined) {
+    output.writeFieldBegin('exists', Thrift.Type.BOOL, 1);
+    output.writeBool(this.exists);
+    output.writeFieldEnd();
+  }
+  if (this.deleted !== null && this.deleted !== undefined) {
+    output.writeFieldBegin('deleted', Thrift.Type.BOOL, 2);
+    output.writeBool(this.deleted);
+    output.writeFieldEnd();
+  }
+  if (this.table !== null && this.table !== undefined) {
+    output.writeFieldBegin('table', Thrift.Type.STRING, 3);
+    output.writeString(this.table);
+    output.writeFieldEnd();
+  }
+  if (this.rowResult !== null && this.rowResult !== undefined) {
+    output.writeFieldBegin('rowResult', Thrift.Type.STRUCT, 4);
+    this.rowResult.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.recordResult !== null && this.recordResult !== undefined) {
+    output.writeFieldBegin('recordResult', Thrift.Type.STRUCT, 5);
+    this.recordResult.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Facet = function(args) {
+  this.queryStr = null;
+  this.minimumNumberOfBlurResults = 9223372036854775807;
+  if (args) {
+    if (args.queryStr !== undefined) {
+      this.queryStr = args.queryStr;
+    }
+    if (args.minimumNumberOfBlurResults !== undefined) {
+      this.minimumNumberOfBlurResults = args.minimumNumberOfBlurResults;
+    }
+  }
+};
+Facet.prototype = {};
+Facet.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.queryStr = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.I64) {
+        this.minimumNumberOfBlurResults = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Facet.prototype.write = function(output) {
+  output.writeStructBegin('Facet');
+  if (this.queryStr !== null && this.queryStr !== undefined) {
+    output.writeFieldBegin('queryStr', Thrift.Type.STRING, 1);
+    output.writeString(this.queryStr);
+    output.writeFieldEnd();
+  }
+  if (this.minimumNumberOfBlurResults !== null && this.minimumNumberOfBlurResults !== undefined) {
+    output.writeFieldBegin('minimumNumberOfBlurResults', Thrift.Type.I64, 2);
+    output.writeI64(this.minimumNumberOfBlurResults);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+SortField = function(args) {
+  this.family = null;
+  this.column = null;
+  this.reverse = null;
+  if (args) {
+    if (args.family !== undefined) {
+      this.family = args.family;
+    }
+    if (args.column !== undefined) {
+      this.column = args.column;
+    }
+    if (args.reverse !== undefined) {
+      this.reverse = args.reverse;
+    }
+  }
+};
+SortField.prototype = {};
+SortField.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.family = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.column = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.BOOL) {
+        this.reverse = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+SortField.prototype.write = function(output) {
+  output.writeStructBegin('SortField');
+  if (this.family !== null && this.family !== undefined) {
+    output.writeFieldBegin('family', Thrift.Type.STRING, 1);
+    output.writeString(this.family);
+    output.writeFieldEnd();
+  }
+  if (this.column !== null && this.column !== undefined) {
+    output.writeFieldBegin('column', Thrift.Type.STRING, 2);
+    output.writeString(this.column);
+    output.writeFieldEnd();
+  }
+  if (this.reverse !== null && this.reverse !== undefined) {
+    output.writeFieldBegin('reverse', Thrift.Type.BOOL, 3);
+    output.writeBool(this.reverse);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+BlurQuery = function(args) {
+  this.query = null;
+  this.facets = null;
+  this.selector = null;
+  this.useCacheIfPresent = true;
+  this.start = 0;
+  this.fetch = 10;
+  this.minimumNumberOfResults = 9223372036854775807;
+  this.maxQueryTime = 9223372036854775807;
+  this.uuid = null;
+  this.userContext = null;
+  this.cacheResult = true;
+  this.startTime = 0;
+  this.sortFields = null;
+  this.rowId = null;
+  if (args) {
+    if (args.query !== undefined) {
+      this.query = args.query;
+    }
+    if (args.facets !== undefined) {
+      this.facets = args.facets;
+    }
+    if (args.selector !== undefined) {
+      this.selector = args.selector;
+    }
+    if (args.useCacheIfPresent !== undefined) {
+      this.useCacheIfPresent = args.useCacheIfPresent;
+    }
+    if (args.start !== undefined) {
+      this.start = args.start;
+    }
+    if (args.fetch !== undefined) {
+      this.fetch = args.fetch;
+    }
+    if (args.minimumNumberOfResults !== undefined) {
+      this.minimumNumberOfResults = args.minimumNumberOfResults;
+    }
+    if (args.maxQueryTime !== undefined) {
+      this.maxQueryTime = args.maxQueryTime;
+    }
+    if (args.uuid !== undefined) {
+      this.uuid = args.uuid;
+    }
+    if (args.userContext !== undefined) {
+      this.userContext = args.userContext;
+    }
+    if (args.cacheResult !== undefined) {
+      this.cacheResult = args.cacheResult;
+    }
+    if (args.startTime !== undefined) {
+      this.startTime = args.startTime;
+    }
+    if (args.sortFields !== undefined) {
+      this.sortFields = args.sortFields;
+    }
+    if (args.rowId !== undefined) {
+      this.rowId = args.rowId;
+    }
+  }
+};
+BlurQuery.prototype = {};
+BlurQuery.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.query = new Query();
+        this.query.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.LIST) {
+        var _size50 = 0;
+        var _rtmp354;
+        this.facets = [];
+        var _etype53 = 0;
+        _rtmp354 = input.readListBegin();
+        _etype53 = _rtmp354.etype;
+        _size50 = _rtmp354.size;
+        for (var _i55 = 0; _i55 < _size50; ++_i55)
+        {
+          var elem56 = null;
+          elem56 = new Facet();
+          elem56.read(input);
+          this.facets.push(elem56);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.selector = new Selector();
+        this.selector.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.BOOL) {
+        this.useCacheIfPresent = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 7:
+      if (ftype == Thrift.Type.I64) {
+        this.start = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 8:
+      if (ftype == Thrift.Type.I32) {
+        this.fetch = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 9:
+      if (ftype == Thrift.Type.I64) {
+        this.minimumNumberOfResults = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 10:
+      if (ftype == Thrift.Type.I64) {
+        this.maxQueryTime = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 11:
+      if (ftype == Thrift.Type.STRING) {
+        this.uuid = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 12:
+      if (ftype == Thrift.Type.STRING) {
+        this.userContext = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 13:
+      if (ftype == Thrift.Type.BOOL) {
+        this.cacheResult = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 14:
+      if (ftype == Thrift.Type.I64) {
+        this.startTime = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 15:
+      if (ftype == Thrift.Type.LIST) {
+        var _size57 = 0;
+        var _rtmp361;
+        this.sortFields = [];
+        var _etype60 = 0;
+        _rtmp361 = input.readListBegin();
+        _etype60 = _rtmp361.etype;
+        _size57 = _rtmp361.size;
+        for (var _i62 = 0; _i62 < _size57; ++_i62)
+        {
+          var elem63 = null;
+          elem63 = new SortField();
+          elem63.read(input);
+          this.sortFields.push(elem63);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 16:
+      if (ftype == Thrift.Type.STRING) {
+        this.rowId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+BlurQuery.prototype.write = function(output) {
+  output.writeStructBegin('BlurQuery');
+  if (this.query !== null && this.query !== undefined) {
+    output.writeFieldBegin('query', Thrift.Type.STRUCT, 1);
+    this.query.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.facets !== null && this.facets !== undefined) {
+    output.writeFieldBegin('facets', Thrift.Type.LIST, 3);
+    output.writeListBegin(Thrift.Type.STRUCT, this.facets.length);
+    for (var iter64 in this.facets)
+    {
+      if (this.facets.hasOwnProperty(iter64))
+      {
+        iter64 = this.facets[iter64];
+        iter64.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.selector !== null && this.selector !== undefined) {
+    output.writeFieldBegin('selector', Thrift.Type.STRUCT, 4);
+    this.selector.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.useCacheIfPresent !== null && this.useCacheIfPresent !== undefined) {
+    output.writeFieldBegin('useCacheIfPresent', Thrift.Type.BOOL, 6);
+    output.writeBool(this.useCacheIfPresent);
+    output.writeFieldEnd();
+  }
+  if (this.start !== null && this.start !== undefined) {
+    output.writeFieldBegin('start', Thrift.Type.I64, 7);
+    output.writeI64(this.start);
+    output.writeFieldEnd();
+  }
+  if (this.fetch !== null && this.fetch !== undefined) {
+    output.writeFieldBegin('fetch', Thrift.Type.I32, 8);
+    output.writeI32(this.fetch);
+    output.writeFieldEnd();
+  }
+  if (this.minimumNumberOfResults !== null && this.minimumNumberOfResults !== undefined) {
+    output.writeFieldBegin('minimumNumberOfResults', Thrift.Type.I64, 9);
+    output.writeI64(this.minimumNumberOfResults);
+    output.writeFieldEnd();
+  }
+  if (this.maxQueryTime !== null && this.maxQueryTime !== undefined) {
+    output.writeFieldBegin('maxQueryTime', Thrift.Type.I64, 10);
+    output.writeI64(this.maxQueryTime);
+    output.writeFieldEnd();
+  }
+  if (this.uuid !== null && this.uuid !== undefined) {
+    output.writeFieldBegin('uuid', Thrift.Type.STRING, 11);
+    output.writeString(this.uuid);
+    output.writeFieldEnd();
+  }
+  if (this.userContext !== null && this.userContext !== undefined) {
+    output.writeFieldBegin('userContext', Thrift.Type.STRING, 12);
+    output.writeString(this.userContext);
+    output.writeFieldEnd();
+  }
+  if (this.cacheResult !== null && this.cacheResult !== undefined) {
+    output.writeFieldBegin('cacheResult', Thrift.Type.BOOL, 13);
+    output.writeBool(this.cacheResult);
+    output.writeFieldEnd();
+  }
+  if (this.startTime !== null && this.startTime !== undefined) {
+    output.writeFieldBegin('startTime', Thrift.Type.I64, 14);
+    output.writeI64(this.startTime);
+    output.writeFieldEnd();
+  }
+  if (this.sortFields !== null && this.sortFields !== undefined) {
+    output.writeFieldBegin('sortFields', Thrift.Type.LIST, 15);
+    output.writeListBegin(Thrift.Type.STRUCT, this.sortFields.length);
+    for (var iter65 in this.sortFields)
+    {
+      if (this.sortFields.hasOwnProperty(iter65))
+      {
+        iter65 = this.sortFields[iter65];
+        iter65.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.rowId !== null && this.rowId !== undefined) {
+    output.writeFieldBegin('rowId', Thrift.Type.STRING, 16);
+    output.writeString(this.rowId);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+SortFieldResult = function(args) {
+  this.nullValue = null;
+  this.stringValue = null;
+  this.intValue = null;
+  this.longValue = null;
+  this.doubleValue = null;
+  this.binaryValue = null;
+  if (args) {
+    if (args.nullValue !== undefined) {
+      this.nullValue = args.nullValue;
+    }
+    if (args.stringValue !== undefined) {
+      this.stringValue = args.stringValue;
+    }
+    if (args.intValue !== undefined) {
+      this.intValue = args.intValue;
+    }
+    if (args.longValue !== undefined) {
+      this.longValue = args.longValue;
+    }
+    if (args.doubleValue !== undefined) {
+      this.doubleValue = args.doubleValue;
+    }
+    if (args.binaryValue !== undefined) {
+      this.binaryValue = args.binaryValue;
+    }
+  }
+};
+SortFieldResult.prototype = {};
+SortFieldResult.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.nullValue = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.stringValue = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I32) {
+        this.intValue = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.I64) {
+        this.longValue = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.DOUBLE) {
+        this.doubleValue = input.readDouble().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.STRING) {
+        this.binaryValue = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+SortFieldResult.prototype.write = function(output) {
+  output.writeStructBegin('SortFieldResult');
+  if (this.nullValue !== null && this.nullValue !== undefined) {
+    output.writeFieldBegin('nullValue', Thrift.Type.BOOL, 1);
+    output.writeBool(this.nullValue);
+    output.writeFieldEnd();
+  }
+  if (this.stringValue !== null && this.stringValue !== undefined) {
+    output.writeFieldBegin('stringValue', Thrift.Type.STRING, 2);
+    output.writeString(this.stringValue);
+    output.writeFieldEnd();
+  }
+  if (this.intValue !== null && this.intValue !== undefined) {
+    output.writeFieldBegin('intValue', Thrift.Type.I32, 3);
+    output.writeI32(this.intValue);
+    output.writeFieldEnd();
+  }
+  if (this.longValue !== null && this.longValue !== undefined) {
+    output.writeFieldBegin('longValue', Thrift.Type.I64, 4);
+    output.writeI64(this.longValue);
+    output.writeFieldEnd();
+  }
+  if (this.doubleValue !== null && this.doubleValue !== undefined) {
+    output.writeFieldBegin('doubleValue', Thrift.Type.DOUBLE, 5);
+    output.writeDouble(this.doubleValue);
+    output.writeFieldEnd();
+  }
+  if (this.binaryValue !== null && this.binaryValue !== undefined) {
+    output.writeFieldBegin('binaryValue', Thrift.Type.STRING, 6);
+    output.writeString(this.binaryValue);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+BlurResult = function(args) {
+  this.locationId = null;
+  this.score = null;
+  this.fetchResult = null;
+  this.sortFieldResults = null;
+  if (args) {
+    if (args.locationId !== undefined) {
+      this.locationId = args.locationId;
+    }
+    if (args.score !== undefined) {
+      this.score = args.score;
+    }
+    if (args.fetchResult !== undefined) {
+      this.fetchResult = args.fetchResult;
+    }
+    if (args.sortFieldResults !== undefined) {
+      this.sortFieldResults = args.sortFieldResults;
+    }
+  }
+};
+BlurResult.prototype = {};
+BlurResult.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.locationId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.DOUBLE) {
+        this.score = input.readDouble().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.fetchResult = new FetchResult();
+        this.fetchResult.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.LIST) {
+        var _size66 = 0;
+        var _rtmp370;
+        this.sortFieldResults = [];
+        var _etype69 = 0;
+        _rtmp370 = input.readListBegin();
+        _etype69 = _rtmp370.etype;
+        _size66 = _rtmp370.size;
+        for (var _i71 = 0; _i71 < _size66; ++_i71)
+        {
+          var elem72 = null;
+          elem72 = new SortFieldResult();
+          elem72.read(input);
+          this.sortFieldResults.push(elem72);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+BlurResult.prototype.write = function(output) {
+  output.writeStructBegin('BlurResult');
+  if (this.locationId !== null && this.locationId !== undefined) {
+    output.writeFieldBegin('locationId', Thrift.Type.STRING, 1);
+    output.writeString(this.locationId);
+    output.writeFieldEnd();
+  }
+  if (this.score !== null && this.score !== undefined) {
+    output.writeFieldBegin('score', Thrift.Type.DOUBLE, 2);
+    output.writeDouble(this.score);
+    output.writeFieldEnd();
+  }
+  if (this.fetchResult !== null && this.fetchResult !== undefined) {
+    output.writeFieldBegin('fetchResult', Thrift.Type.STRUCT, 3);
+    this.fetchResult.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.sortFieldResults !== null && this.sortFieldResults !== undefined) {
+    output.writeFieldBegin('sortFieldResults', Thrift.Type.LIST, 4);
+    output.writeListBegin(Thrift.Type.STRUCT, this.sortFieldResults.length);
+    for (var iter73 in this.sortFieldResults)
+    {
+      if (this.sortFieldResults.hasOwnProperty(iter73))
+      {
+        iter73 = this.sortFieldResults[iter73];
+        iter73.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+BlurResults = function(args) {
+  this.totalResults = 0;
+  this.shardInfo = null;
+  this.results = null;
+  this.facetCounts = null;
+  this.exceptions = null;
+  this.query = null;
+  if (args) {
+    if (args.totalResults !== undefined) {
+      this.totalResults = args.totalResults;
+    }
+    if (args.shardInfo !== undefined) {
+      this.shardInfo = args.shardInfo;
+    }
+    if (args.results !== undefined) {
+      this.results = args.results;
+    }
+    if (args.facetCounts !== undefined) {
+      this.facetCounts = args.facetCounts;
+    }
+    if (args.exceptions !== undefined) {
+      this.exceptions = args.exceptions;
+    }
+    if (args.query !== undefined) {
+      this.query = args.query;
+    }
+  }
+};
+BlurResults.prototype = {};
+BlurResults.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.totalResults = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.MAP) {
+        var _size74 = 0;
+        var _rtmp378;
+        this.shardInfo = {};
+        var _ktype75 = 0;
+        var _vtype76 = 0;
+        _rtmp378 = input.readMapBegin();
+        _ktype75 = _rtmp378.ktype;
+        _vtype76 = _rtmp378.vtype;
+        _size74 = _rtmp378.size;
+        for (var _i79 = 0; _i79 < _size74; ++_i79)
+        {
+          if (_i79 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key80 = null;
+          var val81 = null;
+          key80 = input.readString().value;
+          val81 = input.readI64().value;
+          this.shardInfo[key80] = val81;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.LIST) {
+        var _size82 = 0;
+        var _rtmp386;
+        this.results = [];
+        var _etype85 = 0;
+        _rtmp386 = input.readListBegin();
+        _etype85 = _rtmp386.etype;
+        _size82 = _rtmp386.size;
+        for (var _i87 = 0; _i87 < _size82; ++_i87)
+        {
+          var elem88 = null;
+          elem88 = new BlurResult();
+          elem88.read(input);
+          this.results.push(elem88);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.LIST) {
+        var _size89 = 0;
+        var _rtmp393;
+        this.facetCounts = [];
+        var _etype92 = 0;
+        _rtmp393 = input.readListBegin();
+        _etype92 = _rtmp393.etype;
+        _size89 = _rtmp393.size;
+        for (var _i94 = 0; _i94 < _size89; ++_i94)
+        {
+          var elem95 = null;
+          elem95 = input.readI64().value;
+          this.facetCounts.push(elem95);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.LIST) {
+        var _size96 = 0;
+        var _rtmp3100;
+        this.exceptions = [];
+        var _etype99 = 0;
+        _rtmp3100 = input.readListBegin();
+        _etype99 = _rtmp3100.etype;
+        _size96 = _rtmp3100.size;
+        for (var _i101 = 0; _i101 < _size96; ++_i101)
+        {
+          var elem102 = null;
+          elem102 = new BlurException();
+          elem102.read(input);
+          this.exceptions.push(elem102);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.query = new BlurQuery();
+        this.query.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+BlurResults.prototype.write = function(output) {
+  output.writeStructBegin('BlurResults');
+  if (this.totalResults !== null && this.totalResults !== undefined) {
+    output.writeFieldBegin('totalResults', Thrift.Type.I64, 1);
+    output.writeI64(this.totalResults);
+    output.writeFieldEnd();
+  }
+  if (this.shardInfo !== null && this.shardInfo !== undefined) {
+    output.writeFieldBegin('shardInfo', Thrift.Type.MAP, 2);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.I64, Thrift.objectLength(this.shardInfo));
+    for (var kiter103 in this.shardInfo)
+    {
+      if (this.shardInfo.hasOwnProperty(kiter103))
+      {
+        var viter104 = this.shardInfo[kiter103];
+        output.writeString(kiter103);
+        output.writeI64(viter104);
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  if (this.results !== null && this.results !== undefined) {
+    output.writeFieldBegin('results', Thrift.Type.LIST, 3);
+    output.writeListBegin(Thrift.Type.STRUCT, this.results.length);
+    for (var iter105 in this.results)
+    {
+      if (this.results.hasOwnProperty(iter105))
+      {
+        iter105 = this.results[iter105];
+        iter105.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.facetCounts !== null && this.facetCounts !== undefined) {
+    output.writeFieldBegin('facetCounts', Thrift.Type.LIST, 4);
+    output.writeListBegin(Thrift.Type.I64, this.facetCounts.length);
+    for (var iter106 in this.facetCounts)
+    {
+      if (this.facetCounts.hasOwnProperty(iter106))
+      {
+        iter106 = this.facetCounts[iter106];
+        output.writeI64(iter106);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.exceptions !== null && this.exceptions !== undefined) {
+    output.writeFieldBegin('exceptions', Thrift.Type.LIST, 5);
+    output.writeListBegin(Thrift.Type.STRUCT, this.exceptions.length);
+    for (var iter107 in this.exceptions)
+    {
+      if (this.exceptions.hasOwnProperty(iter107))
+      {
+        iter107 = this.exceptions[iter107];
+        iter107.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  if (this.query !== null && this.query !== undefined) {
+    output.writeFieldBegin('query', Thrift.Type.STRUCT, 6);
+    this.query.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+RecordMutation = function(args) {
+  this.recordMutationType = 1;
+  this.record = null;
+  if (args) {
+    if (args.recordMutationType !== undefined) {
+      this.recordMutationType = args.recordMutationType;
+    }
+    if (args.record !== undefined) {
+      this.record = args.record;
+    }
+  }
+};
+RecordMutation.prototype = {};
+RecordMutation.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.recordMutationType = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.record = new Record();
+        this.record.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+RecordMutation.prototype.write = function(output) {
+  output.writeStructBegin('RecordMutation');
+  if (this.recordMutationType !== null && this.recordMutationType !== undefined) {
+    output.writeFieldBegin('recordMutationType', Thrift.Type.I32, 1);
+    output.writeI32(this.recordMutationType);
+    output.writeFieldEnd();
+  }
+  if (this.record !== null && this.record !== undefined) {
+    output.writeFieldBegin('record', Thrift.Type.STRUCT, 2);
+    this.record.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+RowMutation = function(args) {
+  this.table = null;
+  this.rowId = null;
+  this.rowMutationType = 1;
+  this.recordMutations = null;
+  if (args) {
+    if (args.table !== undefined) {
+      this.table = args.table;
+    }
+    if (args.rowId !== undefined) {
+      this.rowId = args.rowId;
+    }
+    if (args.rowMutationType !== undefined) {
+      this.rowMutationType = args.rowMutationType;
+    }
+    if (args.recordMutations !== undefined) {
+      this.recordMutations = args.recordMutations;
+    }
+  }
+};
+RowMutation.prototype = {};
+RowMutation.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.table = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.rowId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.I32) {
+        this.rowMutationType = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.LIST) {
+        var _size108 = 0;
+        var _rtmp3112;
+        this.recordMutations = [];
+        var _etype111 = 0;
+        _rtmp3112 = input.readListBegin();
+        _etype111 = _rtmp3112.etype;
+        _size108 = _rtmp3112.size;
+        for (var _i113 = 0; _i113 < _size108; ++_i113)
+        {
+          var elem114 = null;
+          elem114 = new RecordMutation();
+          elem114.read(input);
+          this.recordMutations.push(elem114);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+RowMutation.prototype.write = function(output) {
+  output.writeStructBegin('RowMutation');
+  if (this.table !== null && this.table !== undefined) {
+    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
+    output.writeString(this.table);
+    output.writeFieldEnd();
+  }
+  if (this.rowId !== null && this.rowId !== undefined) {
+    output.writeFieldBegin('rowId', Thrift.Type.STRING, 2);
+    output.writeString(this.rowId);
+    output.writeFieldEnd();
+  }
+  if (this.rowMutationType !== null && this.rowMutationType !== undefined) {
+    output.writeFieldBegin('rowMutationType', Thrift.Type.I32, 4);
+    output.writeI32(this.rowMutationType);
+    output.writeFieldEnd();
+  }
+  if (this.recordMutations !== null && this.recordMutations !== undefined) {
+    output.writeFieldBegin('recordMutations', Thrift.Type.LIST, 5);
+    output.writeListBegin(Thrift.Type.STRUCT, this.recordMutations.length);
+    for (var iter115 in this.recordMutations)
+    {
+      if (this.recordMutations.hasOwnProperty(iter115))
+      {
+        iter115 = this.recordMutations[iter115];
+        iter115.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+CpuTime = function(args) {
+  this.cpuTime = null;
+  this.realTime = null;
+  if (args) {
+    if (args.cpuTime !== undefined) {
+      this.cpuTime = args.cpuTime;
+    }
+    if (args.realTime !== undefined) {
+      this.realTime = args.realTime;
+    }
+  }
+};
+CpuTime.prototype = {};
+CpuTime.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.cpuTime = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.I64) {
+        this.realTime = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+CpuTime.prototype.write = function(output) {
+  output.writeStructBegin('CpuTime');
+  if (this.cpuTime !== null && this.cpuTime !== undefined) {
+    output.writeFieldBegin('cpuTime', Thrift.Type.I64, 1);
+    output.writeI64(this.cpuTime);
+    output.writeFieldEnd();
+  }
+  if (this.realTime !== null && this.realTime !== undefined) {
+    output.writeFieldBegin('realTime', Thrift.Type.I64, 2);
+    output.writeI64(this.realTime);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+BlurQueryStatus = function(args) {
+  this.query = null;
+  this.cpuTimes = null;
+  this.completeShards = null;
+  this.totalShards = null;
+  this.state = null;
+  this.uuid = null;
+  this.status = null;
+  if (args) {
+    if (args.query !== undefined) {
+      this.query = args.query;
+    }
+    if (args.cpuTimes !== undefined) {
+      this.cpuTimes = args.cpuTimes;
+    }
+    if (args.completeShards !== undefined) {
+      this.completeShards = args.completeShards;
+    }
+    if (args.totalShards !== undefined) {
+      this.totalShards = args.totalShards;
+    }
+    if (args.state !== undefined) {
+      this.state = args.state;
+    }
+    if (args.uuid !== undefined) {
+      this.uuid = args.uuid;
+    }
+    if (args.status !== undefined) {
+      this.status = args.status;
+    }
+  }
+};
+BlurQueryStatus.prototype = {};
+BlurQueryStatus.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.query = new BlurQuery();
+        this.query.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.MAP) {
+        var _size116 = 0;
+        var _rtmp3120;
+        this.cpuTimes = {};
+        var _ktype117 = 0;
+        var _vtype118 = 0;
+        _rtmp3120 = input.readMapBegin();
+        _ktype117 = _rtmp3120.ktype;
+        _vtype118 = _rtmp3120.vtype;
+        _size116 = _rtmp3120.size;
+        for (var _i121 = 0; _i121 < _size116; ++_i121)
+        {
+          if (_i121 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key122 = null;
+          var val123 = null;
+          key122 = input.readString().value;
+          val123 = new CpuTime();
+          val123.read(input);
+          this.cpuTimes[key122] = val123;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I32) {
+        this.completeShards = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.I32) {
+        this.totalShards = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.I32) {
+        this.state = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.STRING) {
+        this.uuid = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 7:
+      if (ftype == Thrift.Type.I32) {
+        this.status = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+BlurQueryStatus.prototype.write = function(output) {
+  output.writeStructBegin('BlurQueryStatus');
+  if (this.query !== null && this.query !== undefined) {
+    output.writeFieldBegin('query', Thrift.Type.STRUCT, 1);
+    this.query.write(output);
+    output.writeFieldEnd();
+  }
+  if (this.cpuTimes !== null && this.cpuTimes !== undefined) {
+    output.writeFieldBegin('cpuTimes', Thrift.Type.MAP, 2);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRUCT, Thrift.objectLength(this.cpuTimes));
+    for (var kiter124 in this.cpuTimes)
+    {
+      if (this.cpuTimes.hasOwnProperty(kiter124))
+      {
+        var viter125 = this.cpuTimes[kiter124];
+        output.writeString(kiter124);
+        viter125.write(output);
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  if (this.completeShards !== null && this.completeShards !== undefined) {
+    output.writeFieldBegin('completeShards', Thrift.Type.I32, 3);
+    output.writeI32(this.completeShards);
+    output.writeFieldEnd();
+  }
+  if (this.totalShards !== null && this.totalShards !== undefined) {
+    output.writeFieldBegin('totalShards', Thrift.Type.I32, 4);
+    output.writeI32(this.totalShards);
+    output.writeFieldEnd();
+  }
+  if (this.state !== null && this.state !== undefined) {
+    output.writeFieldBegin('state', Thrift.Type.I32, 5);
+    output.writeI32(this.state);
+    output.writeFieldEnd();
+  }
+  if (this.uuid !== null && this.uuid !== undefined) {
+    output.writeFieldBegin('uuid', Thrift.Type.STRING, 6);
+    output.writeString(this.uuid);
+    output.writeFieldEnd();
+  }
+  if (this.status !== null && this.status !== undefined) {
+    output.writeFieldBegin('status', Thrift.Type.I32, 7);
+    output.writeI32(this.status);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+TableStats = function(args) {
+  this.tableName = null;
+  this.bytes = null;
+  this.recordCount = null;
+  this.rowCount = null;
+  if (args) {
+    if (args.tableName !== undefined) {
+      this.tableName = args.tableName;
+    }
+    if (args.bytes !== undefined) {
+      this.bytes = args.bytes;
+    }
+    if (args.recordCount !== undefined) {
+      this.recordCount = args.recordCount;
+    }
+    if (args.rowCount !== undefined) {
+      this.rowCount = args.rowCount;
+    }
+  }
+};
+TableStats.prototype = {};
+TableStats.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.tableName = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.I64) {
+        this.bytes = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I64) {
+        this.recordCount = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.I64) {
+        this.rowCount = input.readI64().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+TableStats.prototype.write = function(output) {
+  output.writeStructBegin('TableStats');
+  if (this.tableName !== null && this.tableName !== undefined) {
+    output.writeFieldBegin('tableName', Thrift.Type.STRING, 1);
+    output.writeString(this.tableName);
+    output.writeFieldEnd();
+  }
+  if (this.bytes !== null && this.bytes !== undefined) {
+    output.writeFieldBegin('bytes', Thrift.Type.I64, 2);
+    output.writeI64(this.bytes);
+    output.writeFieldEnd();
+  }
+  if (this.recordCount !== null && this.recordCount !== undefined) {
+    output.writeFieldBegin('recordCount', Thrift.Type.I64, 3);
+    output.writeI64(this.recordCount);
+    output.writeFieldEnd();
+  }
+  if (this.rowCount !== null && this.rowCount !== undefined) {
+    output.writeFieldBegin('rowCount', Thrift.Type.I64, 4);
+    output.writeI64(this.rowCount);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+ColumnDefinition = function(args) {
+  this.family = null;
+  this.columnName = null;
+  this.subColumnName = null;
+  this.fieldLessIndexed = null;
+  this.fieldType = null;
+  this.properties = null;
+  this.sortable = null;
+  if (args) {
+    if (args.family !== undefined) {
+      this.family = args.family;
+    }
+    if (args.columnName !== undefined) {
+      this.columnName = args.columnName;
+    }
+    if (args.subColumnName !== undefined) {
+      this.subColumnName = args.subColumnName;
+    }
+    if (args.fieldLessIndexed !== undefined) {
+      this.fieldLessIndexed = args.fieldLessIndexed;
+    }
+    if (args.fieldType !== undefined) {
+      this.fieldType = args.fieldType;
+    }
+    if (args.properties !== undefined) {
+      this.properties = args.properties;
+    }
+    if (args.sortable !== undefined) {
+      this.sortable = args.sortable;
+    }
+  }
+};
+ColumnDefinition.prototype = {};
+ColumnDefinition.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.family = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.columnName = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.STRING) {
+        this.subColumnName = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.BOOL) {
+        this.fieldLessIndexed = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 5:
+      if (ftype == Thrift.Type.STRING) {
+        this.fieldType = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 6:
+      if (ftype == Thrift.Type.MAP) {
+        var _size126 = 0;
+        var _rtmp3130;
+        this.properties = {};
+        var _ktype127 = 0;
+        var _vtype128 = 0;
+        _rtmp3130 = input.readMapBegin();
+        _ktype127 = _rtmp3130.ktype;
+        _vtype128 = _rtmp3130.vtype;
+        _size126 = _rtmp3130.size;
+        for (var _i131 = 0; _i131 < _size126; ++_i131)
+        {
+          if (_i131 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key132 = null;
+          var val133 = null;
+          key132 = input.readString().value;
+          val133 = input.readString().value;
+          this.properties[key132] = val133;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 7:
+      if (ftype == Thrift.Type.BOOL) {
+        this.sortable = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+ColumnDefinition.prototype.write = function(output) {
+  output.writeStructBegin('ColumnDefinition');
+  if (this.family !== null && this.family !== undefined) {
+    output.writeFieldBegin('family', Thrift.Type.STRING, 1);
+    output.writeString(this.family);
+    output.writeFieldEnd();
+  }
+  if (this.columnName !== null && this.columnName !== undefined) {
+    output.writeFieldBegin('columnName', Thrift.Type.STRING, 2);
+    output.writeString(this.columnName);
+    output.writeFieldEnd();
+  }
+  if (this.subColumnName !== null && this.subColumnName !== undefined) {
+    output.writeFieldBegin('subColumnName', Thrift.Type.STRING, 3);
+    output.writeString(this.subColumnName);
+    output.writeFieldEnd();
+  }
+  if (this.fieldLessIndexed !== null && this.fieldLessIndexed !== undefined) {
+    output.writeFieldBegin('fieldLessIndexed', Thrift.Type.BOOL, 4);
+    output.writeBool(this.fieldLessIndexed);
+    output.writeFieldEnd();
+  }
+  if (this.fieldType !== null && this.fieldType !== undefined) {
+    output.writeFieldBegin('fieldType', Thrift.Type.STRING, 5);
+    output.writeString(this.fieldType);
+    output.writeFieldEnd();
+  }
+  if (this.properties !== null && this.properties !== undefined) {
+    output.writeFieldBegin('properties', Thrift.Type.MAP, 6);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.properties));
+    for (var kiter134 in this.properties)
+    {
+      if (this.properties.hasOwnProperty(kiter134))
+      {
+        var viter135 = this.properties[kiter134];
+        output.writeString(kiter134);
+        output.writeString(viter135);
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  if (this.sortable !== null && this.sortable !== undefined) {
+    output.writeFieldBegin('sortable', Thrift.Type.BOOL, 7);
+    output.writeBool(this.sortable);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Schema = function(args) {
+  this.table = null;
+  this.families = null;
+  if (args) {
+    if (args.table !== undefined) {
+      this.table = args.table;
+    }
+    if (args.families !== undefined) {
+      this.families = args.families;
+    }
+  }
+};
+Schema.prototype = {};
+Schema.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.table = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.MAP) {
+        var _size136 = 0;
+        var _rtmp3140;
+        this.families = {};
+        var _ktype137 = 0;
+        var _vtype138 = 0;
+        _rtmp3140 = input.readMapBegin();
+        _ktype137 = _rtmp3140.ktype;
+        _vtype138 = _rtmp3140.vtype;
+        _size136 = _rtmp3140.size;
+        for (var _i141 = 0; _i141 < _size136; ++_i141)
+        {
+          if (_i141 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key142 = null;
+          var val143 = null;
+          key142 = input.readString().value;
+          var _size144 = 0;
+          var _rtmp3148;
+          val143 = {};
+          var _ktype145 = 0;
+          var _vtype146 = 0;
+          _rtmp3148 = input.readMapBegin();
+          _ktype145 = _rtmp3148.ktype;
+          _vtype146 = _rtmp3148.vtype;
+          _size144 = _rtmp3148.size;
+          for (var _i149 = 0; _i149 < _size144; ++_i149)
+          {
+            if (_i149 > 0 ) {
+              if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+                input.rstack.pop();
+              }
+            }
+            var key150 = null;
+            var val151 = null;
+            key150 = input.readString().value;
+            val151 = new ColumnDefinition();
+            val151.read(input);
+            val143[key150] = val151;
+          }
+          input.readMapEnd();
+          this.families[key142] = val143;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Schema.prototype.write = function(output) {
+  output.writeStructBegin('Schema');
+  if (this.table !== null && this.table !== undefined) {
+    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
+    output.writeString(this.table);
+    output.writeFieldEnd();
+  }
+  if (this.families !== null && this.families !== undefined) {
+    output.writeFieldBegin('families', Thrift.Type.MAP, 2);
+    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.MAP, Thrift.objectLength(this.families));
+    for (var kiter152 in this.families)
+    {
+      if (this.families.hasOwnProperty(kiter152))
+      {
+        var viter153 = this.families[kiter152];
+        output.writeString(kiter152);
+        output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRUCT, Thrift.objectLength(viter153));
+        for (var kiter154 in viter153)
+        {
+          if (viter153.hasOwnProperty(kiter154))
+          {
+            var viter155 = viter153[kiter154];
+            output.writeString(kiter154);
+            viter155.write(output);
+          }
+        }
+        output.writeMapEnd();
+      }
+    }
+    output.writeMapEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+TableDescriptor = function(args) {
+  this.enabled = true;
+  this.shardCount = 1;
+  this.tableUri = null;
+  this.cluster = 'default';
+  this.name = null;
+  this.similarityClass = null;
+  this.blockCaching = true;
+  this.blockCachingFileTypes = null;
+  this.readOnly = false;
+  this.preCacheCols = null;
+  this.tableProperties = null;
+  this.strictTypes = false;
+  this.defaultMissingFieldType = 'text';
+  this.defaultMissingFieldLessIndexing = true;
+  this.defaultMissingFieldProps = null;
+  if (args) {
+    if (args.enabled !== undefined) {
+      this.enabled = args.enabled;
+    }
+    if (args.shardCount !== undefined) {
+      this.shardCount = args.shardCount;
+    }
+    if (args.tableUri !== undefined) {
+      this.tableUri = args.tableUri;
+    }
+    if (args.cluster !== undefined) {
+      this.cluster = args.cluster;
+    }
+    if (args.name !== undefined) {
+      this.name = args.name;
+    }
+    if (args.similarityClass !== undefined) {
+      this.similarityClass = args.similarityClass;
+    }
+    if (args.blockCaching !== undefined) {
+      this.blockCaching = args.blockCaching;
+    }
+    if (args.blockCachingFileTypes !== undefined) {
+      this.blockCachingFileTypes = args.blockCachingFileTypes;
+    }
+    if (args.readOnly !== undefined) {
+      this.readOnly = args.readOnly;
+    }
+    if (args.preCacheCols !== undefined) {
+      this.preCacheCols = args.preCacheCols;
+    }
+    if (args.tableProperties !== undefined) {
+      this.tableProperties = args.tableProperties;
+    }
+    if (args.strictTypes !== undefined) {
+      this.strictTypes = args.strictTypes;
+    }
+    if (args.defaultMissingFieldType !== undefined) {
+      this.defaultMissingFieldType = args.defaultMissingFieldType;
+    }
+    if (args.defaultMissingFieldLessIndexing !== undefined) {
+      this.defaultMissingFieldLessIndexing = args.defaultMissingFieldLessIndexing;
+    }
+    if (args.defaultMissingFieldProps !== undefined) {
+      this.defaultMissingFieldProps = args.defaultMissingFieldProps;
+    }
+  }
+};
+TableDescriptor.prototype = {};
+TableDescriptor.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.enabled = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.I32) {
+        this.shardCount = input.readI32().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.STRING) {
+        this.tableUri = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 7:
+      if (ftype == Thrift.Type.STRING) {
+        this.cluster = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 8:
+      if (ftype == Thrift.Type.STRING) {
+        this.name = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 9:
+      if (ftype == Thrift.Type.STRING) {
+        this.similarityClass = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 10:
+      if (ftype == Thrift.Type.BOOL) {
+        this.blockCaching = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 11:
+      if (ftype == Thrift.Type.SET) {
+        var _size156 = 0;
+        var _rtmp3160;
+        this.blockCachingFileTypes = [];
+        var _etype159 = 0;
+        _rtmp3160 = input.readSetBegin();
+        _etype159 = _rtmp3160.etype;
+        _size156 = _rtmp3160.size;
+        for (var _i161 = 0; _i161 < _size156; ++_i161)
+        {
+          var elem162 = null;
+          elem162 = input.readString().value;
+          this.blockCachingFileTypes.push(elem162);
+        }
+        input.readSetEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 12:
+      if (ftype == Thrift.Type.BOOL) {
+        this.readOnly = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 13:
+      if (ftype == Thrift.Type.LIST) {
+        var _size163 = 0;
+        var _rtmp3167;
+        this.preCacheCols = [];
+        var _etype166 = 0;
+        _rtmp3167 = input.readListBegin();
+        _etype166 = _rtmp3167.etype;
+        _size163 = _rtmp3167.size;
+        for (var _i168 = 0; _i168 < _size163; ++_i168)
+        {
+          var elem169 = null;
+          elem169 = input.readString().value;
+          this.preCacheCols.push(elem169);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 14:
+      if (ftype == Thrift.Type.MAP) {
+        var _size170 = 0;
+        var _rtmp3174;
+        this.tableProperties = {};
+        var _ktype171 = 0;
+        var _vtype172 = 0;
+        _rtmp3174 = input.readMapBegin();
+        _ktype171 = _rtmp3174.ktype;
+        _vtype172 = _rtmp3174.vtype;
+        _size170 = _rtmp3174.size;
+        for (var _i175 = 0; _i175 < _size170; ++_i175)
+        {
+          if (_i175 > 0 ) {
+            if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
+              input.rstack.pop();
+            }
+          }
+          var key176 = null;
+          var val177 = null;
+          key176 = input.readString().value;
+          val177 = input.readString().value;
+          this.tableProperties[key176] = val177;
+        }
+        input.readMapEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 15:
+      if (ftype == Thrift.Type.BOOL) {
+        this.strictTypes = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 16:
+      if (ftype == Thrift.Type.STRING) {
+        this.defaultMissingFieldType = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 17:
+      if (ftype == Thrift.Type.BOOL) {
+        this.defaultMissingFieldLessIndexing = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 18:
+      if (ftype == Thrift.Type.MAP) {
+        var _size178 = 0;
+        var _rtmp3182;
+        this.defaultMissingFieldProps = {};
+        var _ktype179 = 0;
+        var _vtype180 = 0;
+        _rtmp3182 = input.readMapBegin();
+        _ktype179 = _rtmp3182.ktype;
+        _vtype180 = _rtmp3182.vtype;
+        _size178 = _rtmp3182.size;
+        for

<TRUNCATED>

Mime
View raw message