svn commit: r685258 [2/3] - in /hadoop/hbase/trunk: ./ src/examples/ src/examples/uploaders/ src/examples/uploaders/hbrep/ src/examples/uploaders/hbrep/Hbase/ src/java/org/apache/hadoop/hbase/io/

[st...@apache.org]

Added: hadoop/hbase/trunk/src/examples/uploaders/hbrep/Hbase/Hbase.py
URL: http://svn.apache.org/viewvc/hadoop/hbase/trunk/src/examples/uploaders/hbrep/Hbase/Hbase.py?rev=685258&view=auto
==============================================================================
--- hadoop/hbase/trunk/src/examples/uploaders/hbrep/Hbase/Hbase.py (added)
+++ hadoop/hbase/trunk/src/examples/uploaders/hbrep/Hbase/Hbase.py Tue Aug 12 11:43:38 2008
@@ -0,0 +1,5153 @@
+#
+# Autogenerated by Thrift
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+from thrift.Thrift import *
+from ttypes import *
+from thrift.Thrift import TProcessor
+from thrift.transport import TTransport
+from thrift.protocol import TBinaryProtocol
+try:
+  from thrift.protocol import fastbinary
+except:
+  fastbinary = None
+
+
+class Iface:
+  def getTableNames(self, ):
+    pass
+
+  def getColumnDescriptors(self, tableName):
+    pass
+
+  def getTableRegions(self, tableName):
+    pass
+
+  def createTable(self, tableName, columnFamilies):
+    pass
+
+  def deleteTable(self, tableName):
+    pass
+
+  def get(self, tableName, row, column):
+    pass
+
+  def getVer(self, tableName, row, column, numVersions):
+    pass
+
+  def getVerTs(self, tableName, row, column, timestamp, numVersions):
+    pass
+
+  def getRow(self, tableName, row):
+    pass
+
+  def getRowTs(self, tableName, row, timestamp):
+    pass
+
+  def put(self, tableName, row, column, value):
+    pass
+
+  def mutateRow(self, tableName, row, mutations):
+    pass
+
+  def mutateRowTs(self, tableName, row, mutations, timestamp):
+    pass
+
+  def mutateRows(self, tableName, rowBatches):
+    pass
+
+  def mutateRowsTs(self, tableName, rowBatches, timestamp):
+    pass
+
+  def deleteAll(self, tableName, row, column):
+    pass
+
+  def deleteAllTs(self, tableName, row, column, timestamp):
+    pass
+
+  def deleteAllRow(self, tableName, row):
+    pass
+
+  def deleteAllRowTs(self, tableName, row, timestamp):
+    pass
+
+  def scannerOpen(self, tableName, startRow, columns):
+    pass
+
+  def scannerOpenWithStop(self, tableName, startRow, stopRow, columns):
+    pass
+
+  def scannerOpenTs(self, tableName, startRow, columns, timestamp):
+    pass
+
+  def scannerOpenWithStopTs(self, tableName, startRow, stopRow, columns, timestamp):
+    pass
+
+  def scannerGet(self, id):
+    pass
+
+  def scannerClose(self, id):
+    pass
+
+
+class Client(Iface):
+  def __init__(self, iprot, oprot=None):
+    self._iprot = self._oprot = iprot
+    if oprot != None:
+      self._oprot = oprot
+    self._seqid = 0
+
+  def getTableNames(self, ):
+    self.send_getTableNames()
+    return self.recv_getTableNames()
+
+  def send_getTableNames(self, ):
+    self._oprot.writeMessageBegin('getTableNames', TMessageType.CALL, self._seqid)
+    args = getTableNames_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getTableNames(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getTableNames_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result");
+
+  def getColumnDescriptors(self, tableName):
+    self.send_getColumnDescriptors(tableName)
+    return self.recv_getColumnDescriptors()
+
+  def send_getColumnDescriptors(self, tableName):
+    self._oprot.writeMessageBegin('getColumnDescriptors', TMessageType.CALL, self._seqid)
+    args = getColumnDescriptors_args()
+    args.tableName = tableName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getColumnDescriptors(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getColumnDescriptors_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result");
+
+  def getTableRegions(self, tableName):
+    self.send_getTableRegions(tableName)
+    return self.recv_getTableRegions()
+
+  def send_getTableRegions(self, tableName):
+    self._oprot.writeMessageBegin('getTableRegions', TMessageType.CALL, self._seqid)
+    args = getTableRegions_args()
+    args.tableName = tableName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getTableRegions(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getTableRegions_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result");
+
+  def createTable(self, tableName, columnFamilies):
+    self.send_createTable(tableName, columnFamilies)
+    self.recv_createTable()
+
+  def send_createTable(self, tableName, columnFamilies):
+    self._oprot.writeMessageBegin('createTable', TMessageType.CALL, self._seqid)
+    args = createTable_args()
+    args.tableName = tableName
+    args.columnFamilies = columnFamilies
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_createTable(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = createTable_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    if result.ia != None:
+      raise result.ia
+    if result.exist != None:
+      raise result.exist
+    return
+
+  def deleteTable(self, tableName):
+    self.send_deleteTable(tableName)
+    self.recv_deleteTable()
+
+  def send_deleteTable(self, tableName):
+    self._oprot.writeMessageBegin('deleteTable', TMessageType.CALL, self._seqid)
+    args = deleteTable_args()
+    args.tableName = tableName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteTable(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteTable_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    if result.nf != None:
+      raise result.nf
+    return
+
+  def get(self, tableName, row, column):
+    self.send_get(tableName, row, column)
+    return self.recv_get()
+
+  def send_get(self, tableName, row, column):
+    self._oprot.writeMessageBegin('get', TMessageType.CALL, self._seqid)
+    args = get_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_get(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = get_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    if result.nf != None:
+      raise result.nf
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "get failed: unknown result");
+
+  def getVer(self, tableName, row, column, numVersions):
+    self.send_getVer(tableName, row, column, numVersions)
+    return self.recv_getVer()
+
+  def send_getVer(self, tableName, row, column, numVersions):
+    self._oprot.writeMessageBegin('getVer', TMessageType.CALL, self._seqid)
+    args = getVer_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.numVersions = numVersions
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getVer(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getVer_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    if result.nf != None:
+      raise result.nf
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVer failed: unknown result");
+
+  def getVerTs(self, tableName, row, column, timestamp, numVersions):
+    self.send_getVerTs(tableName, row, column, timestamp, numVersions)
+    return self.recv_getVerTs()
+
+  def send_getVerTs(self, tableName, row, column, timestamp, numVersions):
+    self._oprot.writeMessageBegin('getVerTs', TMessageType.CALL, self._seqid)
+    args = getVerTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.timestamp = timestamp
+    args.numVersions = numVersions
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getVerTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getVerTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    if result.nf != None:
+      raise result.nf
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result");
+
+  def getRow(self, tableName, row):
+    self.send_getRow(tableName, row)
+    return self.recv_getRow()
+
+  def send_getRow(self, tableName, row):
+    self._oprot.writeMessageBegin('getRow', TMessageType.CALL, self._seqid)
+    args = getRow_args()
+    args.tableName = tableName
+    args.row = row
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRow(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRow_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRow failed: unknown result");
+
+  def getRowTs(self, tableName, row, timestamp):
+    self.send_getRowTs(tableName, row, timestamp)
+    return self.recv_getRowTs()
+
+  def send_getRowTs(self, tableName, row, timestamp):
+    self._oprot.writeMessageBegin('getRowTs', TMessageType.CALL, self._seqid)
+    args = getRowTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.timestamp = timestamp
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRowTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRowTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result");
+
+  def put(self, tableName, row, column, value):
+    self.send_put(tableName, row, column, value)
+    self.recv_put()
+
+  def send_put(self, tableName, row, column, value):
+    self._oprot.writeMessageBegin('put', TMessageType.CALL, self._seqid)
+    args = put_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.value = value
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_put(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = put_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    if result.ia != None:
+      raise result.ia
+    return
+
+  def mutateRow(self, tableName, row, mutations):
+    self.send_mutateRow(tableName, row, mutations)
+    self.recv_mutateRow()
+
+  def send_mutateRow(self, tableName, row, mutations):
+    self._oprot.writeMessageBegin('mutateRow', TMessageType.CALL, self._seqid)
+    args = mutateRow_args()
+    args.tableName = tableName
+    args.row = row
+    args.mutations = mutations
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_mutateRow(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = mutateRow_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    if result.ia != None:
+      raise result.ia
+    return
+
+  def mutateRowTs(self, tableName, row, mutations, timestamp):
+    self.send_mutateRowTs(tableName, row, mutations, timestamp)
+    self.recv_mutateRowTs()
+
+  def send_mutateRowTs(self, tableName, row, mutations, timestamp):
+    self._oprot.writeMessageBegin('mutateRowTs', TMessageType.CALL, self._seqid)
+    args = mutateRowTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.mutations = mutations
+    args.timestamp = timestamp
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_mutateRowTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = mutateRowTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    if result.ia != None:
+      raise result.ia
+    return
+
+  def mutateRows(self, tableName, rowBatches):
+    self.send_mutateRows(tableName, rowBatches)
+    self.recv_mutateRows()
+
+  def send_mutateRows(self, tableName, rowBatches):
+    self._oprot.writeMessageBegin('mutateRows', TMessageType.CALL, self._seqid)
+    args = mutateRows_args()
+    args.tableName = tableName
+    args.rowBatches = rowBatches
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_mutateRows(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = mutateRows_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    if result.ia != None:
+      raise result.ia
+    return
+
+  def mutateRowsTs(self, tableName, rowBatches, timestamp):
+    self.send_mutateRowsTs(tableName, rowBatches, timestamp)
+    self.recv_mutateRowsTs()
+
+  def send_mutateRowsTs(self, tableName, rowBatches, timestamp):
+    self._oprot.writeMessageBegin('mutateRowsTs', TMessageType.CALL, self._seqid)
+    args = mutateRowsTs_args()
+    args.tableName = tableName
+    args.rowBatches = rowBatches
+    args.timestamp = timestamp
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_mutateRowsTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = mutateRowsTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    if result.ia != None:
+      raise result.ia
+    return
+
+  def deleteAll(self, tableName, row, column):
+    self.send_deleteAll(tableName, row, column)
+    self.recv_deleteAll()
+
+  def send_deleteAll(self, tableName, row, column):
+    self._oprot.writeMessageBegin('deleteAll', TMessageType.CALL, self._seqid)
+    args = deleteAll_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteAll(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteAll_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    return
+
+  def deleteAllTs(self, tableName, row, column, timestamp):
+    self.send_deleteAllTs(tableName, row, column, timestamp)
+    self.recv_deleteAllTs()
+
+  def send_deleteAllTs(self, tableName, row, column, timestamp):
+    self._oprot.writeMessageBegin('deleteAllTs', TMessageType.CALL, self._seqid)
+    args = deleteAllTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.timestamp = timestamp
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteAllTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteAllTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    return
+
+  def deleteAllRow(self, tableName, row):
+    self.send_deleteAllRow(tableName, row)
+    self.recv_deleteAllRow()
+
+  def send_deleteAllRow(self, tableName, row):
+    self._oprot.writeMessageBegin('deleteAllRow', TMessageType.CALL, self._seqid)
+    args = deleteAllRow_args()
+    args.tableName = tableName
+    args.row = row
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteAllRow(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteAllRow_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    return
+
+  def deleteAllRowTs(self, tableName, row, timestamp):
+    self.send_deleteAllRowTs(tableName, row, timestamp)
+    self.recv_deleteAllRowTs()
+
+  def send_deleteAllRowTs(self, tableName, row, timestamp):
+    self._oprot.writeMessageBegin('deleteAllRowTs', TMessageType.CALL, self._seqid)
+    args = deleteAllRowTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.timestamp = timestamp
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteAllRowTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteAllRowTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    return
+
+  def scannerOpen(self, tableName, startRow, columns):
+    self.send_scannerOpen(tableName, startRow, columns)
+    return self.recv_scannerOpen()
+
+  def send_scannerOpen(self, tableName, startRow, columns):
+    self._oprot.writeMessageBegin('scannerOpen', TMessageType.CALL, self._seqid)
+    args = scannerOpen_args()
+    args.tableName = tableName
+    args.startRow = startRow
+    args.columns = columns
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerOpen(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerOpen_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result");
+
+  def scannerOpenWithStop(self, tableName, startRow, stopRow, columns):
+    self.send_scannerOpenWithStop(tableName, startRow, stopRow, columns)
+    return self.recv_scannerOpenWithStop()
+
+  def send_scannerOpenWithStop(self, tableName, startRow, stopRow, columns):
+    self._oprot.writeMessageBegin('scannerOpenWithStop', TMessageType.CALL, self._seqid)
+    args = scannerOpenWithStop_args()
+    args.tableName = tableName
+    args.startRow = startRow
+    args.stopRow = stopRow
+    args.columns = columns
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerOpenWithStop(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerOpenWithStop_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
+
+  def scannerOpenTs(self, tableName, startRow, columns, timestamp):
+    self.send_scannerOpenTs(tableName, startRow, columns, timestamp)
+    return self.recv_scannerOpenTs()
+
+  def send_scannerOpenTs(self, tableName, startRow, columns, timestamp):
+    self._oprot.writeMessageBegin('scannerOpenTs', TMessageType.CALL, self._seqid)
+    args = scannerOpenTs_args()
+    args.tableName = tableName
+    args.startRow = startRow
+    args.columns = columns
+    args.timestamp = timestamp
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerOpenTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerOpenTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result");
+
+  def scannerOpenWithStopTs(self, tableName, startRow, stopRow, columns, timestamp):
+    self.send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp)
+    return self.recv_scannerOpenWithStopTs()
+
+  def send_scannerOpenWithStopTs(self, tableName, startRow, stopRow, columns, timestamp):
+    self._oprot.writeMessageBegin('scannerOpenWithStopTs', TMessageType.CALL, self._seqid)
+    args = scannerOpenWithStopTs_args()
+    args.tableName = tableName
+    args.startRow = startRow
+    args.stopRow = stopRow
+    args.columns = columns
+    args.timestamp = timestamp
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerOpenWithStopTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerOpenWithStopTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
+
+  def scannerGet(self, id):
+    self.send_scannerGet(id)
+    return self.recv_scannerGet()
+
+  def send_scannerGet(self, id):
+    self._oprot.writeMessageBegin('scannerGet', TMessageType.CALL, self._seqid)
+    args = scannerGet_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerGet(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerGet_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.io != None:
+      raise result.io
+    if result.ia != None:
+      raise result.ia
+    if result.nf != None:
+      raise result.nf
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerGet failed: unknown result");
+
+  def scannerClose(self, id):
+    self.send_scannerClose(id)
+    self.recv_scannerClose()
+
+  def send_scannerClose(self, id):
+    self._oprot.writeMessageBegin('scannerClose', TMessageType.CALL, self._seqid)
+    args = scannerClose_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerClose(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerClose_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io != None:
+      raise result.io
+    if result.ia != None:
+      raise result.ia
+    return
+
+
+class Processor(Iface, TProcessor):
+  def __init__(self, handler):
+    self._handler = handler
+    self._processMap = {}
+    self._processMap["getTableNames"] = Processor.process_getTableNames
+    self._processMap["getColumnDescriptors"] = Processor.process_getColumnDescriptors
+    self._processMap["getTableRegions"] = Processor.process_getTableRegions
+    self._processMap["createTable"] = Processor.process_createTable
+    self._processMap["deleteTable"] = Processor.process_deleteTable
+    self._processMap["get"] = Processor.process_get
+    self._processMap["getVer"] = Processor.process_getVer
+    self._processMap["getVerTs"] = Processor.process_getVerTs
+    self._processMap["getRow"] = Processor.process_getRow
+    self._processMap["getRowTs"] = Processor.process_getRowTs
+    self._processMap["put"] = Processor.process_put
+    self._processMap["mutateRow"] = Processor.process_mutateRow
+    self._processMap["mutateRowTs"] = Processor.process_mutateRowTs
+    self._processMap["mutateRows"] = Processor.process_mutateRows
+    self._processMap["mutateRowsTs"] = Processor.process_mutateRowsTs
+    self._processMap["deleteAll"] = Processor.process_deleteAll
+    self._processMap["deleteAllTs"] = Processor.process_deleteAllTs
+    self._processMap["deleteAllRow"] = Processor.process_deleteAllRow
+    self._processMap["deleteAllRowTs"] = Processor.process_deleteAllRowTs
+    self._processMap["scannerOpen"] = Processor.process_scannerOpen
+    self._processMap["scannerOpenWithStop"] = Processor.process_scannerOpenWithStop
+    self._processMap["scannerOpenTs"] = Processor.process_scannerOpenTs
+    self._processMap["scannerOpenWithStopTs"] = Processor.process_scannerOpenWithStopTs
+    self._processMap["scannerGet"] = Processor.process_scannerGet
+    self._processMap["scannerClose"] = Processor.process_scannerClose
+
+  def process(self, iprot, oprot):
+    (name, type, seqid) = iprot.readMessageBegin()
+    if name not in self._processMap:
+      iprot.skip(TType.STRUCT)
+      iprot.readMessageEnd()
+      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
+      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
+      x.write(oprot)
+      oprot.writeMessageEnd()
+      oprot.trans.flush()
+      return
+    else:
+      self._processMap[name](self, seqid, iprot, oprot)
+    return True
+
+  def process_getTableNames(self, seqid, iprot, oprot):
+    args = getTableNames_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getTableNames_result()
+    try:
+      result.success = self._handler.getTableNames()
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("getTableNames", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getColumnDescriptors(self, seqid, iprot, oprot):
+    args = getColumnDescriptors_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getColumnDescriptors_result()
+    try:
+      result.success = self._handler.getColumnDescriptors(args.tableName)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("getColumnDescriptors", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getTableRegions(self, seqid, iprot, oprot):
+    args = getTableRegions_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getTableRegions_result()
+    try:
+      result.success = self._handler.getTableRegions(args.tableName)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("getTableRegions", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_createTable(self, seqid, iprot, oprot):
+    args = createTable_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = createTable_result()
+    try:
+      self._handler.createTable(args.tableName, args.columnFamilies)
+    except IOError, io:
+      result.io = io
+    except IllegalArgument, ia:
+      result.ia = ia
+    except AlreadyExists, exist:
+      result.exist = exist
+    oprot.writeMessageBegin("createTable", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_deleteTable(self, seqid, iprot, oprot):
+    args = deleteTable_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteTable_result()
+    try:
+      self._handler.deleteTable(args.tableName)
+    except IOError, io:
+      result.io = io
+    except NotFound, nf:
+      result.nf = nf
+    oprot.writeMessageBegin("deleteTable", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_get(self, seqid, iprot, oprot):
+    args = get_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = get_result()
+    try:
+      result.success = self._handler.get(args.tableName, args.row, args.column)
+    except IOError, io:
+      result.io = io
+    except NotFound, nf:
+      result.nf = nf
+    oprot.writeMessageBegin("get", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getVer(self, seqid, iprot, oprot):
+    args = getVer_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getVer_result()
+    try:
+      result.success = self._handler.getVer(args.tableName, args.row, args.column, args.numVersions)
+    except IOError, io:
+      result.io = io
+    except NotFound, nf:
+      result.nf = nf
+    oprot.writeMessageBegin("getVer", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getVerTs(self, seqid, iprot, oprot):
+    args = getVerTs_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getVerTs_result()
+    try:
+      result.success = self._handler.getVerTs(args.tableName, args.row, args.column, args.timestamp, args.numVersions)
+    except IOError, io:
+      result.io = io
+    except NotFound, nf:
+      result.nf = nf
+    oprot.writeMessageBegin("getVerTs", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getRow(self, seqid, iprot, oprot):
+    args = getRow_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getRow_result()
+    try:
+      result.success = self._handler.getRow(args.tableName, args.row)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("getRow", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getRowTs(self, seqid, iprot, oprot):
+    args = getRowTs_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getRowTs_result()
+    try:
+      result.success = self._handler.getRowTs(args.tableName, args.row, args.timestamp)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("getRowTs", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_put(self, seqid, iprot, oprot):
+    args = put_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = put_result()
+    try:
+      self._handler.put(args.tableName, args.row, args.column, args.value)
+    except IOError, io:
+      result.io = io
+    except IllegalArgument, ia:
+      result.ia = ia
+    oprot.writeMessageBegin("put", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_mutateRow(self, seqid, iprot, oprot):
+    args = mutateRow_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = mutateRow_result()
+    try:
+      self._handler.mutateRow(args.tableName, args.row, args.mutations)
+    except IOError, io:
+      result.io = io
+    except IllegalArgument, ia:
+      result.ia = ia
+    oprot.writeMessageBegin("mutateRow", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_mutateRowTs(self, seqid, iprot, oprot):
+    args = mutateRowTs_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = mutateRowTs_result()
+    try:
+      self._handler.mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp)
+    except IOError, io:
+      result.io = io
+    except IllegalArgument, ia:
+      result.ia = ia
+    oprot.writeMessageBegin("mutateRowTs", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_mutateRows(self, seqid, iprot, oprot):
+    args = mutateRows_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = mutateRows_result()
+    try:
+      self._handler.mutateRows(args.tableName, args.rowBatches)
+    except IOError, io:
+      result.io = io
+    except IllegalArgument, ia:
+      result.ia = ia
+    oprot.writeMessageBegin("mutateRows", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_mutateRowsTs(self, seqid, iprot, oprot):
+    args = mutateRowsTs_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = mutateRowsTs_result()
+    try:
+      self._handler.mutateRowsTs(args.tableName, args.rowBatches, args.timestamp)
+    except IOError, io:
+      result.io = io
+    except IllegalArgument, ia:
+      result.ia = ia
+    oprot.writeMessageBegin("mutateRowsTs", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_deleteAll(self, seqid, iprot, oprot):
+    args = deleteAll_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteAll_result()
+    try:
+      self._handler.deleteAll(args.tableName, args.row, args.column)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("deleteAll", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_deleteAllTs(self, seqid, iprot, oprot):
+    args = deleteAllTs_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteAllTs_result()
+    try:
+      self._handler.deleteAllTs(args.tableName, args.row, args.column, args.timestamp)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("deleteAllTs", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_deleteAllRow(self, seqid, iprot, oprot):
+    args = deleteAllRow_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteAllRow_result()
+    try:
+      self._handler.deleteAllRow(args.tableName, args.row)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("deleteAllRow", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_deleteAllRowTs(self, seqid, iprot, oprot):
+    args = deleteAllRowTs_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteAllRowTs_result()
+    try:
+      self._handler.deleteAllRowTs(args.tableName, args.row, args.timestamp)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("deleteAllRowTs", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_scannerOpen(self, seqid, iprot, oprot):
+    args = scannerOpen_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = scannerOpen_result()
+    try:
+      result.success = self._handler.scannerOpen(args.tableName, args.startRow, args.columns)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("scannerOpen", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_scannerOpenWithStop(self, seqid, iprot, oprot):
+    args = scannerOpenWithStop_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = scannerOpenWithStop_result()
+    try:
+      result.success = self._handler.scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("scannerOpenWithStop", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_scannerOpenTs(self, seqid, iprot, oprot):
+    args = scannerOpenTs_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = scannerOpenTs_result()
+    try:
+      result.success = self._handler.scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("scannerOpenTs", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_scannerOpenWithStopTs(self, seqid, iprot, oprot):
+    args = scannerOpenWithStopTs_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = scannerOpenWithStopTs_result()
+    try:
+      result.success = self._handler.scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp)
+    except IOError, io:
+      result.io = io
+    oprot.writeMessageBegin("scannerOpenWithStopTs", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_scannerGet(self, seqid, iprot, oprot):
+    args = scannerGet_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = scannerGet_result()
+    try:
+      result.success = self._handler.scannerGet(args.id)
+    except IOError, io:
+      result.io = io
+    except IllegalArgument, ia:
+      result.ia = ia
+    except NotFound, nf:
+      result.nf = nf
+    oprot.writeMessageBegin("scannerGet", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_scannerClose(self, seqid, iprot, oprot):
+    args = scannerClose_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = scannerClose_result()
+    try:
+      self._handler.scannerClose(args.id)
+    except IOError, io:
+      result.io = io
+    except IllegalArgument, ia:
+      result.ia = ia
+    oprot.writeMessageBegin("scannerClose", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+
+# HELPER FUNCTIONS AND STRUCTURES
+
+class getTableNames_args:
+
+  thrift_spec = (
+  )
+
+  def __init__(self, d=None):
+    pass
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getTableNames_args')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getTableNames_result:
+
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
+    (1, TType.STRUCT, 'io', (IOError, IOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, d=None):
+    self.success = None
+    self.io = None
+    if isinstance(d, dict):
+      if 'success' in d:
+        self.success = d['success']
+      if 'io' in d:
+        self.io = d['io']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype19, _size16) = iprot.readListBegin()
+          for _i20 in xrange(_size16):
+            _elem21 = iprot.readString();
+            self.success.append(_elem21)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = IOError()
+          self.io.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getTableNames_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRING, len(self.success))
+      for iter22 in self.success:
+        oprot.writeString(iter22)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.io != None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getColumnDescriptors_args:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'tableName', None, None, ), # 1
+  )
+
+  def __init__(self, d=None):
+    self.tableName = None
+    if isinstance(d, dict):
+      if 'tableName' in d:
+        self.tableName = d['tableName']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.tableName = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getColumnDescriptors_args')
+    if self.tableName != None:
+      oprot.writeFieldBegin('tableName', TType.STRING, 1)
+      oprot.writeString(self.tableName)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getColumnDescriptors_result:
+
+  thrift_spec = (
+    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(ColumnDescriptor, ColumnDescriptor.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'io', (IOError, IOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, d=None):
+    self.success = None
+    self.io = None
+    if isinstance(d, dict):
+      if 'success' in d:
+        self.success = d['success']
+      if 'io' in d:
+        self.io = d['io']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.MAP:
+          self.success = {}
+          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin() 
+          for _i27 in xrange(_size23):
+            _key28 = iprot.readString();
+            _val29 = ColumnDescriptor()
+            _val29.read(iprot)
+            self.success[_key28] = _val29
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = IOError()
+          self.io.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getColumnDescriptors_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.MAP, 0)
+      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
+      for kiter30,viter31 in self.success.items():
+        oprot.writeString(kiter30)
+        viter31.write(oprot)
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    if self.io != None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getTableRegions_args:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'tableName', None, None, ), # 1
+  )
+
+  def __init__(self, d=None):
+    self.tableName = None
+    if isinstance(d, dict):
+      if 'tableName' in d:
+        self.tableName = d['tableName']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.tableName = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getTableRegions_args')
+    if self.tableName != None:
+      oprot.writeFieldBegin('tableName', TType.STRING, 1)
+      oprot.writeString(self.tableName)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getTableRegions_result:
+
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(RegionDescriptor, RegionDescriptor.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'io', (IOError, IOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, d=None):
+    self.success = None
+    self.io = None
+    if isinstance(d, dict):
+      if 'success' in d:
+        self.success = d['success']
+      if 'io' in d:
+        self.io = d['io']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype35, _size32) = iprot.readListBegin()
+          for _i36 in xrange(_size32):
+            _elem37 = RegionDescriptor()
+            _elem37.read(iprot)
+            self.success.append(_elem37)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = IOError()
+          self.io.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getTableRegions_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter38 in self.success:
+        iter38.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.io != None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class createTable_args:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'tableName', None, None, ), # 1
+    (2, TType.LIST, 'columnFamilies', (TType.STRUCT,(ColumnDescriptor, ColumnDescriptor.thrift_spec)), None, ), # 2
+  )
+
+  def __init__(self, d=None):
+    self.tableName = None
+    self.columnFamilies = None
+    if isinstance(d, dict):
+      if 'tableName' in d:
+        self.tableName = d['tableName']
+      if 'columnFamilies' in d:
+        self.columnFamilies = d['columnFamilies']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.tableName = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.LIST:
+          self.columnFamilies = []
+          (_etype42, _size39) = iprot.readListBegin()
+          for _i43 in xrange(_size39):
+            _elem44 = ColumnDescriptor()
+            _elem44.read(iprot)
+            self.columnFamilies.append(_elem44)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('createTable_args')
+    if self.tableName != None:
+      oprot.writeFieldBegin('tableName', TType.STRING, 1)
+      oprot.writeString(self.tableName)
+      oprot.writeFieldEnd()
+    if self.columnFamilies != None:
+      oprot.writeFieldBegin('columnFamilies', TType.LIST, 2)
+      oprot.writeListBegin(TType.STRUCT, len(self.columnFamilies))
+      for iter45 in self.columnFamilies:
+        iter45.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class createTable_result:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'io', (IOError, IOError.thrift_spec), None, ), # 1
+    (2, TType.STRUCT, 'ia', (IllegalArgument, IllegalArgument.thrift_spec), None, ), # 2
+    (3, TType.STRUCT, 'exist', (AlreadyExists, AlreadyExists.thrift_spec), None, ), # 3
+  )
+
+  def __init__(self, d=None):
+    self.io = None
+    self.ia = None
+    self.exist = None
+    if isinstance(d, dict):
+      if 'io' in d:
+        self.io = d['io']
+      if 'ia' in d:
+        self.ia = d['ia']
+      if 'exist' in d:
+        self.exist = d['exist']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = IOError()
+          self.io.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.ia = IllegalArgument()
+          self.ia.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRUCT:
+          self.exist = AlreadyExists()
+          self.exist.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('createTable_result')
+    if self.io != None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    if self.ia != None:
+      oprot.writeFieldBegin('ia', TType.STRUCT, 2)
+      self.ia.write(oprot)
+      oprot.writeFieldEnd()
+    if self.exist != None:
+      oprot.writeFieldBegin('exist', TType.STRUCT, 3)
+      self.exist.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class deleteTable_args:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'tableName', None, None, ), # 1
+  )
+
+  def __init__(self, d=None):
+    self.tableName = None
+    if isinstance(d, dict):
+      if 'tableName' in d:
+        self.tableName = d['tableName']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.tableName = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('deleteTable_args')
+    if self.tableName != None:
+      oprot.writeFieldBegin('tableName', TType.STRING, 1)
+      oprot.writeString(self.tableName)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class deleteTable_result:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'io', (IOError, IOError.thrift_spec), None, ), # 1
+    (2, TType.STRUCT, 'nf', (NotFound, NotFound.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, d=None):
+    self.io = None
+    self.nf = None
+    if isinstance(d, dict):
+      if 'io' in d:
+        self.io = d['io']
+      if 'nf' in d:
+        self.nf = d['nf']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = IOError()
+          self.io.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.nf = NotFound()
+          self.nf.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('deleteTable_result')
+    if self.io != None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    if self.nf != None:
+      oprot.writeFieldBegin('nf', TType.STRUCT, 2)
+      self.nf.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class get_args:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'tableName', None, None, ), # 1
+    (2, TType.STRING, 'row', None, None, ), # 2
+    (3, TType.STRING, 'column', None, None, ), # 3
+  )
+
+  def __init__(self, d=None):
+    self.tableName = None
+    self.row = None
+    self.column = None
+    if isinstance(d, dict):
+      if 'tableName' in d:
+        self.tableName = d['tableName']
+      if 'row' in d:
+        self.row = d['row']
+      if 'column' in d:
+        self.column = d['column']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.tableName = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.row = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.column = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_args')
+    if self.tableName != None:
+      oprot.writeFieldBegin('tableName', TType.STRING, 1)
+      oprot.writeString(self.tableName)
+      oprot.writeFieldEnd()
+    if self.row != None:
+      oprot.writeFieldBegin('row', TType.STRING, 2)
+      oprot.writeString(self.row)
+      oprot.writeFieldEnd()
+    if self.column != None:
+      oprot.writeFieldBegin('column', TType.STRING, 3)
+      oprot.writeString(self.column)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class get_result:
+
+  thrift_spec = (
+    (0, TType.STRING, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'io', (IOError, IOError.thrift_spec), None, ), # 1
+    (2, TType.STRUCT, 'nf', (NotFound, NotFound.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, d=None):
+    self.success = None
+    self.io = None
+    self.nf = None
+    if isinstance(d, dict):
+      if 'success' in d:
+        self.success = d['success']
+      if 'io' in d:
+        self.io = d['io']
+      if 'nf' in d:
+        self.nf = d['nf']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.STRING:
+          self.success = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = IOError()
+          self.io.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.nf = NotFound()
+          self.nf.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('get_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.STRING, 0)
+      oprot.writeString(self.success)
+      oprot.writeFieldEnd()
+    if self.io != None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    if self.nf != None:
+      oprot.writeFieldBegin('nf', TType.STRUCT, 2)
+      self.nf.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getVer_args:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'tableName', None, None, ), # 1
+    (2, TType.STRING, 'row', None, None, ), # 2
+    (3, TType.STRING, 'column', None, None, ), # 3
+    (4, TType.I32, 'numVersions', None, None, ), # 4
+  )
+
+  def __init__(self, d=None):
+    self.tableName = None
+    self.row = None
+    self.column = None
+    self.numVersions = None
+    if isinstance(d, dict):
+      if 'tableName' in d:
+        self.tableName = d['tableName']
+      if 'row' in d:
+        self.row = d['row']
+      if 'column' in d:
+        self.column = d['column']
+      if 'numVersions' in d:
+        self.numVersions = d['numVersions']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.tableName = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.row = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.column = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.I32:
+          self.numVersions = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getVer_args')
+    if self.tableName != None:
+      oprot.writeFieldBegin('tableName', TType.STRING, 1)
+      oprot.writeString(self.tableName)
+      oprot.writeFieldEnd()
+    if self.row != None:
+      oprot.writeFieldBegin('row', TType.STRING, 2)
+      oprot.writeString(self.row)
+      oprot.writeFieldEnd()
+    if self.column != None:
+      oprot.writeFieldBegin('column', TType.STRING, 3)
+      oprot.writeString(self.column)
+      oprot.writeFieldEnd()
+    if self.numVersions != None:
+      oprot.writeFieldBegin('numVersions', TType.I32, 4)
+      oprot.writeI32(self.numVersions)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getVer_result:
+
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
+    (1, TType.STRUCT, 'io', (IOError, IOError.thrift_spec), None, ), # 1
+    (2, TType.STRUCT, 'nf', (NotFound, NotFound.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, d=None):
+    self.success = None
+    self.io = None
+    self.nf = None
+    if isinstance(d, dict):
+      if 'success' in d:
+        self.success = d['success']
+      if 'io' in d:
+        self.io = d['io']
+      if 'nf' in d:
+        self.nf = d['nf']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype49, _size46) = iprot.readListBegin()
+          for _i50 in xrange(_size46):
+            _elem51 = iprot.readString();
+            self.success.append(_elem51)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = IOError()
+          self.io.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.nf = NotFound()
+          self.nf.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getVer_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRING, len(self.success))
+      for iter52 in self.success:
+        oprot.writeString(iter52)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.io != None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    if self.nf != None:
+      oprot.writeFieldBegin('nf', TType.STRUCT, 2)
+      self.nf.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getVerTs_args:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'tableName', None, None, ), # 1
+    (2, TType.STRING, 'row', None, None, ), # 2
+    (3, TType.STRING, 'column', None, None, ), # 3
+    (4, TType.I64, 'timestamp', None, None, ), # 4
+    (5, TType.I32, 'numVersions', None, None, ), # 5
+  )
+
+  def __init__(self, d=None):
+    self.tableName = None
+    self.row = None
+    self.column = None
+    self.timestamp = None
+    self.numVersions = None
+    if isinstance(d, dict):
+      if 'tableName' in d:
+        self.tableName = d['tableName']
+      if 'row' in d:
+        self.row = d['row']
+      if 'column' in d:
+        self.column = d['column']
+      if 'timestamp' in d:
+        self.timestamp = d['timestamp']
+      if 'numVersions' in d:
+        self.numVersions = d['numVersions']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.tableName = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.row = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.column = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.I64:
+          self.timestamp = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.I32:
+          self.numVersions = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getVerTs_args')
+    if self.tableName != None:
+      oprot.writeFieldBegin('tableName', TType.STRING, 1)
+      oprot.writeString(self.tableName)
+      oprot.writeFieldEnd()
+    if self.row != None:
+      oprot.writeFieldBegin('row', TType.STRING, 2)
+      oprot.writeString(self.row)
+      oprot.writeFieldEnd()
+    if self.column != None:
+      oprot.writeFieldBegin('column', TType.STRING, 3)
+      oprot.writeString(self.column)
+      oprot.writeFieldEnd()
+    if self.timestamp != None:
+      oprot.writeFieldBegin('timestamp', TType.I64, 4)
+      oprot.writeI64(self.timestamp)
+      oprot.writeFieldEnd()
+    if self.numVersions != None:
+      oprot.writeFieldBegin('numVersions', TType.I32, 5)
+      oprot.writeI32(self.numVersions)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getVerTs_result:
+
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
+    (1, TType.STRUCT, 'io', (IOError, IOError.thrift_spec), None, ), # 1
+    (2, TType.STRUCT, 'nf', (NotFound, NotFound.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, d=None):
+    self.success = None
+    self.io = None
+    self.nf = None
+    if isinstance(d, dict):
+      if 'success' in d:
+        self.success = d['success']
+      if 'io' in d:
+        self.io = d['io']
+      if 'nf' in d:
+        self.nf = d['nf']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype56, _size53) = iprot.readListBegin()
+          for _i57 in xrange(_size53):
+            _elem58 = iprot.readString();
+            self.success.append(_elem58)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = IOError()
+          self.io.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.nf = NotFound()
+          self.nf.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getVerTs_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRING, len(self.success))
+      for iter59 in self.success:
+        oprot.writeString(iter59)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.io != None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    if self.nf != None:
+      oprot.writeFieldBegin('nf', TType.STRUCT, 2)
+      self.nf.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getRow_args:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'tableName', None, None, ), # 1
+    (2, TType.STRING, 'row', None, None, ), # 2
+  )
+
+  def __init__(self, d=None):
+    self.tableName = None
+    self.row = None
+    if isinstance(d, dict):
+      if 'tableName' in d:
+        self.tableName = d['tableName']
+      if 'row' in d:
+        self.row = d['row']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.tableName = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.row = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getRow_args')
+    if self.tableName != None:
+      oprot.writeFieldBegin('tableName', TType.STRING, 1)
+      oprot.writeString(self.tableName)
+      oprot.writeFieldEnd()
+    if self.row != None:
+      oprot.writeFieldBegin('row', TType.STRING, 2)
+      oprot.writeString(self.row)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getRow_result:
+
+  thrift_spec = (
+    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
+    (1, TType.STRUCT, 'io', (IOError, IOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, d=None):
+    self.success = None
+    self.io = None
+    if isinstance(d, dict):
+      if 'success' in d:
+        self.success = d['success']
+      if 'io' in d:
+        self.io = d['io']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.MAP:
+          self.success = {}
+          (_ktype61, _vtype62, _size60 ) = iprot.readMapBegin() 
+          for _i64 in xrange(_size60):
+            _key65 = iprot.readString();
+            _val66 = iprot.readString();
+            self.success[_key65] = _val66
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = IOError()
+          self.io.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getRow_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.MAP, 0)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
+      for kiter67,viter68 in self.success.items():
+        oprot.writeString(kiter67)
+        oprot.writeString(viter68)
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    if self.io != None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+
+  def __repr__(self): 
+    return repr(self.__dict__)
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getRowTs_args:
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'tableName', None, None, ), # 1
+    (2, TType.STRING, 'row', None, None, ), # 2
+    (3, TType.I64, 'timestamp', None, None, ), # 3
+  )
+
+  def __init__(self, d=None):
+    self.tableName = None
+    self.row = None
+    self.timestamp = None
+    if isinstance(d, dict):
+      if 'tableName' in d:
+        self.tableName = d['tableName']
+      if 'row' in d:
+        self.row = d['row']
+      if 'timestamp' in d:
+        self.timestamp = d['timestamp']
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRING:
+          self.tableName = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.row = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
+          self.timestamp = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getRowTs_args')
+    if self.tableName != None:
+      oprot.writeFieldBegin('tableName', TType.STRING, 1)
+      oprot.writeString(self.tableName)
+      oprot.writeFieldEnd()
+    if self.row != None:
+      oprot.writeFieldBegin('row', TType.STRING, 2)
+      oprot.writeString(self.row)
+      oprot.writeFieldEnd()
+    if self.timestamp != None:
+      oprot.writeFieldBegin('timestamp', TType.I64, 3)
+      oprot.writeI64(self.timestamp)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def __str__(self): 
+    return str(self.__dict__)
+

[... 2429 lines stripped ...]