hbase-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From larsgeo...@apache.org
Subject svn commit: r1501723 [10/11] - in /hbase/branches/0.95/hbase-examples: src/main/java/org/apache/hadoop/hbase/thrift/generated/ src/main/java/org/apache/hadoop/hbase/thrift2/ src/main/python/ src/main/python/gen-py/hbase/ src/main/python/thrift1/ src/ma...
Date Wed, 10 Jul 2013 11:17:37 GMT
Added: hbase/branches/0.95/hbase-examples/src/main/python/thrift2/gen-py/hbase/THBaseService.py
URL: http://svn.apache.org/viewvc/hbase/branches/0.95/hbase-examples/src/main/python/thrift2/gen-py/hbase/THBaseService.py?rev=1501723&view=auto
==============================================================================
--- hbase/branches/0.95/hbase-examples/src/main/python/thrift2/gen-py/hbase/THBaseService.py (added)
+++ hbase/branches/0.95/hbase-examples/src/main/python/thrift2/gen-py/hbase/THBaseService.py Wed Jul 10 11:17:36 2013
@@ -0,0 +1,3007 @@
+#
+# Autogenerated by Thrift Compiler (0.9.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+#  options string: py
+#
+
+from thrift.Thrift import TType, TMessageType, TException, TApplicationException
+from ttypes import *
+from thrift.Thrift import TProcessor
+from thrift.transport import TTransport
+from thrift.protocol import TBinaryProtocol, TProtocol
+try:
+  from thrift.protocol import fastbinary
+except:
+  fastbinary = None
+
+
+class Iface:
+  def exists(self, table, get):
+    """
+    Test for the existence of columns in the table, as specified in the TGet.
+
+    @return true if the specified TGet matches one or more keys, false if not
+
+    Parameters:
+     - table: the table to check on
+     - get: the TGet to check for
+    """
+    pass
+
+  def get(self, table, get):
+    """
+    Method for getting data from a row.
+
+    If the row cannot be found an empty Result is returned.
+    This can be checked by the empty field of the TResult
+
+    @return the result
+
+    Parameters:
+     - table: the table to get from
+     - get: the TGet to fetch
+    """
+    pass
+
+  def getMultiple(self, table, gets):
+    """
+    Method for getting multiple rows.
+
+    If a row cannot be found there will be a null
+    value in the result list for that TGet at the
+    same position.
+
+    So the Results are in the same order as the TGets.
+
+    Parameters:
+     - table: the table to get from
+     - gets: a list of TGets to fetch, the Result list
+    will have the Results at corresponding positions
+    or null if there was an error
+    """
+    pass
+
+  def put(self, table, put):
+    """
+    Commit a TPut to a table.
+
+    Parameters:
+     - table: the table to put data in
+     - put: the TPut to put
+    """
+    pass
+
+  def checkAndPut(self, table, row, family, qualifier, value, put):
+    """
+    Atomically checks if a row/family/qualifier value matches the expected
+    value. If it does, it adds the TPut.
+
+    @return true if the new put was executed, false otherwise
+
+    Parameters:
+     - table: to check in and put to
+     - row: row to check
+     - family: column family to check
+     - qualifier: column qualifier to check
+     - value: the expected value, if not provided the
+    check is for the non-existence of the
+    column in question
+     - put: the TPut to put if the check succeeds
+    """
+    pass
+
+  def putMultiple(self, table, puts):
+    """
+    Commit a List of Puts to the table.
+
+    Parameters:
+     - table: the table to put data in
+     - puts: a list of TPuts to commit
+    """
+    pass
+
+  def deleteSingle(self, table, deleteSingle):
+    """
+    Deletes as specified by the TDelete.
+
+    Note: "delete" is a reserved keyword and cannot be used in Thrift
+    thus the inconsistent naming scheme from the other functions.
+
+    Parameters:
+     - table: the table to delete from
+     - deleteSingle: the TDelete to delete
+    """
+    pass
+
+  def deleteMultiple(self, table, deletes):
+    """
+    Bulk commit a List of TDeletes to the table.
+
+    Throws a TIOError if any of the deletes fail.
+
+    Always returns an empty list for backwards compatibility.
+
+    Parameters:
+     - table: the table to delete from
+     - deletes: list of TDeletes to delete
+    """
+    pass
+
+  def checkAndDelete(self, table, row, family, qualifier, value, deleteSingle):
+    """
+    Atomically checks if a row/family/qualifier value matches the expected
+    value. If it does, it adds the delete.
+
+    @return true if the new delete was executed, false otherwise
+
+    Parameters:
+     - table: to check in and delete from
+     - row: row to check
+     - family: column family to check
+     - qualifier: column qualifier to check
+     - value: the expected value, if not provided the
+    check is for the non-existence of the
+    column in question
+     - deleteSingle: the TDelete to execute if the check succeeds
+    """
+    pass
+
+  def increment(self, table, increment):
+    """
+    Parameters:
+     - table: the table to increment the value on
+     - increment: the TIncrement to increment
+    """
+    pass
+
+  def openScanner(self, table, scan):
+    """
+    Get a Scanner for the provided TScan object.
+
+    @return Scanner Id to be used with other scanner procedures
+
+    Parameters:
+     - table: the table to get the Scanner for
+     - scan: the scan object to get a Scanner for
+    """
+    pass
+
+  def getScannerRows(self, scannerId, numRows):
+    """
+    Grabs multiple rows from a Scanner.
+
+    @return Between zero and numRows TResults
+
+    Parameters:
+     - scannerId: the Id of the Scanner to return rows from. This is an Id returned from the openScanner function.
+     - numRows: number of rows to return
+    """
+    pass
+
+  def closeScanner(self, scannerId):
+    """
+    Closes the scanner. Should be called if you need to close
+    the Scanner before all results are read.
+
+    Exhausted scanners are closed automatically.
+
+    Parameters:
+     - scannerId: the Id of the Scanner to close *
+    """
+    pass
+
+
+class Client(Iface):
+  def __init__(self, iprot, oprot=None):
+    self._iprot = self._oprot = iprot
+    if oprot is not None:
+      self._oprot = oprot
+    self._seqid = 0
+
+  def exists(self, table, get):
+    """
+    Test for the existence of columns in the table, as specified in the TGet.
+
+    @return true if the specified TGet matches one or more keys, false if not
+
+    Parameters:
+     - table: the table to check on
+     - get: the TGet to check for
+    """
+    self.send_exists(table, get)
+    return self.recv_exists()
+
+  def send_exists(self, table, get):
+    self._oprot.writeMessageBegin('exists', TMessageType.CALL, self._seqid)
+    args = exists_args()
+    args.table = table
+    args.get = get
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_exists(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = exists_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "exists failed: unknown result");
+
+  def get(self, table, get):
+    """
+    Method for getting data from a row.
+
+    If the row cannot be found an empty Result is returned.
+    This can be checked by the empty field of the TResult
+
+    @return the result
+
+    Parameters:
+     - table: the table to get from
+     - get: the TGet to fetch
+    """
+    self.send_get(table, get)
+    return self.recv_get()
+
+  def send_get(self, table, get):
+    self._oprot.writeMessageBegin('get', TMessageType.CALL, self._seqid)
+    args = get_args()
+    args.table = table
+    args.get = get
+    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 is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "get failed: unknown result");
+
+  def getMultiple(self, table, gets):
+    """
+    Method for getting multiple rows.
+
+    If a row cannot be found there will be a null
+    value in the result list for that TGet at the
+    same position.
+
+    So the Results are in the same order as the TGets.
+
+    Parameters:
+     - table: the table to get from
+     - gets: a list of TGets to fetch, the Result list
+    will have the Results at corresponding positions
+    or null if there was an error
+    """
+    self.send_getMultiple(table, gets)
+    return self.recv_getMultiple()
+
+  def send_getMultiple(self, table, gets):
+    self._oprot.writeMessageBegin('getMultiple', TMessageType.CALL, self._seqid)
+    args = getMultiple_args()
+    args.table = table
+    args.gets = gets
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getMultiple(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getMultiple_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMultiple failed: unknown result");
+
+  def put(self, table, put):
+    """
+    Commit a TPut to a table.
+
+    Parameters:
+     - table: the table to put data in
+     - put: the TPut to put
+    """
+    self.send_put(table, put)
+    self.recv_put()
+
+  def send_put(self, table, put):
+    self._oprot.writeMessageBegin('put', TMessageType.CALL, self._seqid)
+    args = put_args()
+    args.table = table
+    args.put = put
+    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 is not None:
+      raise result.io
+    return
+
+  def checkAndPut(self, table, row, family, qualifier, value, put):
+    """
+    Atomically checks if a row/family/qualifier value matches the expected
+    value. If it does, it adds the TPut.
+
+    @return true if the new put was executed, false otherwise
+
+    Parameters:
+     - table: to check in and put to
+     - row: row to check
+     - family: column family to check
+     - qualifier: column qualifier to check
+     - value: the expected value, if not provided the
+    check is for the non-existence of the
+    column in question
+     - put: the TPut to put if the check succeeds
+    """
+    self.send_checkAndPut(table, row, family, qualifier, value, put)
+    return self.recv_checkAndPut()
+
+  def send_checkAndPut(self, table, row, family, qualifier, value, put):
+    self._oprot.writeMessageBegin('checkAndPut', TMessageType.CALL, self._seqid)
+    args = checkAndPut_args()
+    args.table = table
+    args.row = row
+    args.family = family
+    args.qualifier = qualifier
+    args.value = value
+    args.put = put
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_checkAndPut(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = checkAndPut_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkAndPut failed: unknown result");
+
+  def putMultiple(self, table, puts):
+    """
+    Commit a List of Puts to the table.
+
+    Parameters:
+     - table: the table to put data in
+     - puts: a list of TPuts to commit
+    """
+    self.send_putMultiple(table, puts)
+    self.recv_putMultiple()
+
+  def send_putMultiple(self, table, puts):
+    self._oprot.writeMessageBegin('putMultiple', TMessageType.CALL, self._seqid)
+    args = putMultiple_args()
+    args.table = table
+    args.puts = puts
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_putMultiple(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = putMultiple_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def deleteSingle(self, table, deleteSingle):
+    """
+    Deletes as specified by the TDelete.
+
+    Note: "delete" is a reserved keyword and cannot be used in Thrift
+    thus the inconsistent naming scheme from the other functions.
+
+    Parameters:
+     - table: the table to delete from
+     - deleteSingle: the TDelete to delete
+    """
+    self.send_deleteSingle(table, deleteSingle)
+    self.recv_deleteSingle()
+
+  def send_deleteSingle(self, table, deleteSingle):
+    self._oprot.writeMessageBegin('deleteSingle', TMessageType.CALL, self._seqid)
+    args = deleteSingle_args()
+    args.table = table
+    args.deleteSingle = deleteSingle
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteSingle(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteSingle_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def deleteMultiple(self, table, deletes):
+    """
+    Bulk commit a List of TDeletes to the table.
+
+    Throws a TIOError if any of the deletes fail.
+
+    Always returns an empty list for backwards compatibility.
+
+    Parameters:
+     - table: the table to delete from
+     - deletes: list of TDeletes to delete
+    """
+    self.send_deleteMultiple(table, deletes)
+    return self.recv_deleteMultiple()
+
+  def send_deleteMultiple(self, table, deletes):
+    self._oprot.writeMessageBegin('deleteMultiple', TMessageType.CALL, self._seqid)
+    args = deleteMultiple_args()
+    args.table = table
+    args.deletes = deletes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteMultiple(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteMultiple_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteMultiple failed: unknown result");
+
+  def checkAndDelete(self, table, row, family, qualifier, value, deleteSingle):
+    """
+    Atomically checks if a row/family/qualifier value matches the expected
+    value. If it does, it adds the delete.
+
+    @return true if the new delete was executed, false otherwise
+
+    Parameters:
+     - table: to check in and delete from
+     - row: row to check
+     - family: column family to check
+     - qualifier: column qualifier to check
+     - value: the expected value, if not provided the
+    check is for the non-existence of the
+    column in question
+     - deleteSingle: the TDelete to execute if the check succeeds
+    """
+    self.send_checkAndDelete(table, row, family, qualifier, value, deleteSingle)
+    return self.recv_checkAndDelete()
+
+  def send_checkAndDelete(self, table, row, family, qualifier, value, deleteSingle):
+    self._oprot.writeMessageBegin('checkAndDelete', TMessageType.CALL, self._seqid)
+    args = checkAndDelete_args()
+    args.table = table
+    args.row = row
+    args.family = family
+    args.qualifier = qualifier
+    args.value = value
+    args.deleteSingle = deleteSingle
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_checkAndDelete(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = checkAndDelete_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkAndDelete failed: unknown result");
+
+  def increment(self, table, increment):
+    """
+    Parameters:
+     - table: the table to increment the value on
+     - increment: the TIncrement to increment
+    """
+    self.send_increment(table, increment)
+    return self.recv_increment()
+
+  def send_increment(self, table, increment):
+    self._oprot.writeMessageBegin('increment', TMessageType.CALL, self._seqid)
+    args = increment_args()
+    args.table = table
+    args.increment = increment
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_increment(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = increment_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "increment failed: unknown result");
+
+  def openScanner(self, table, scan):
+    """
+    Get a Scanner for the provided TScan object.
+
+    @return Scanner Id to be used with other scanner procedures
+
+    Parameters:
+     - table: the table to get the Scanner for
+     - scan: the scan object to get a Scanner for
+    """
+    self.send_openScanner(table, scan)
+    return self.recv_openScanner()
+
+  def send_openScanner(self, table, scan):
+    self._oprot.writeMessageBegin('openScanner', TMessageType.CALL, self._seqid)
+    args = openScanner_args()
+    args.table = table
+    args.scan = scan
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_openScanner(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = openScanner_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "openScanner failed: unknown result");
+
+  def getScannerRows(self, scannerId, numRows):
+    """
+    Grabs multiple rows from a Scanner.
+
+    @return Between zero and numRows TResults
+
+    Parameters:
+     - scannerId: the Id of the Scanner to return rows from. This is an Id returned from the openScanner function.
+     - numRows: number of rows to return
+    """
+    self.send_getScannerRows(scannerId, numRows)
+    return self.recv_getScannerRows()
+
+  def send_getScannerRows(self, scannerId, numRows):
+    self._oprot.writeMessageBegin('getScannerRows', TMessageType.CALL, self._seqid)
+    args = getScannerRows_args()
+    args.scannerId = scannerId
+    args.numRows = numRows
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getScannerRows(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getScannerRows_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getScannerRows failed: unknown result");
+
+  def closeScanner(self, scannerId):
+    """
+    Closes the scanner. Should be called if you need to close
+    the Scanner before all results are read.
+
+    Exhausted scanners are closed automatically.
+
+    Parameters:
+     - scannerId: the Id of the Scanner to close *
+    """
+    self.send_closeScanner(scannerId)
+    self.recv_closeScanner()
+
+  def send_closeScanner(self, scannerId):
+    self._oprot.writeMessageBegin('closeScanner', TMessageType.CALL, self._seqid)
+    args = closeScanner_args()
+    args.scannerId = scannerId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_closeScanner(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = closeScanner_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    return
+
+
+class Processor(Iface, TProcessor):
+  def __init__(self, handler):
+    self._handler = handler
+    self._processMap = {}
+    self._processMap["exists"] = Processor.process_exists
+    self._processMap["get"] = Processor.process_get
+    self._processMap["getMultiple"] = Processor.process_getMultiple
+    self._processMap["put"] = Processor.process_put
+    self._processMap["checkAndPut"] = Processor.process_checkAndPut
+    self._processMap["putMultiple"] = Processor.process_putMultiple
+    self._processMap["deleteSingle"] = Processor.process_deleteSingle
+    self._processMap["deleteMultiple"] = Processor.process_deleteMultiple
+    self._processMap["checkAndDelete"] = Processor.process_checkAndDelete
+    self._processMap["increment"] = Processor.process_increment
+    self._processMap["openScanner"] = Processor.process_openScanner
+    self._processMap["getScannerRows"] = Processor.process_getScannerRows
+    self._processMap["closeScanner"] = Processor.process_closeScanner
+
+  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_exists(self, seqid, iprot, oprot):
+    args = exists_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = exists_result()
+    try:
+      result.success = self._handler.exists(args.table, args.get)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("exists", 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.table, args.get)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("get", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getMultiple(self, seqid, iprot, oprot):
+    args = getMultiple_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getMultiple_result()
+    try:
+      result.success = self._handler.getMultiple(args.table, args.gets)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("getMultiple", 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.table, args.put)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("put", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_checkAndPut(self, seqid, iprot, oprot):
+    args = checkAndPut_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = checkAndPut_result()
+    try:
+      result.success = self._handler.checkAndPut(args.table, args.row, args.family, args.qualifier, args.value, args.put)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("checkAndPut", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_putMultiple(self, seqid, iprot, oprot):
+    args = putMultiple_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = putMultiple_result()
+    try:
+      self._handler.putMultiple(args.table, args.puts)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("putMultiple", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_deleteSingle(self, seqid, iprot, oprot):
+    args = deleteSingle_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteSingle_result()
+    try:
+      self._handler.deleteSingle(args.table, args.deleteSingle)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("deleteSingle", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_deleteMultiple(self, seqid, iprot, oprot):
+    args = deleteMultiple_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteMultiple_result()
+    try:
+      result.success = self._handler.deleteMultiple(args.table, args.deletes)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("deleteMultiple", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_checkAndDelete(self, seqid, iprot, oprot):
+    args = checkAndDelete_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = checkAndDelete_result()
+    try:
+      result.success = self._handler.checkAndDelete(args.table, args.row, args.family, args.qualifier, args.value, args.deleteSingle)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("checkAndDelete", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_increment(self, seqid, iprot, oprot):
+    args = increment_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = increment_result()
+    try:
+      result.success = self._handler.increment(args.table, args.increment)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("increment", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_openScanner(self, seqid, iprot, oprot):
+    args = openScanner_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = openScanner_result()
+    try:
+      result.success = self._handler.openScanner(args.table, args.scan)
+    except TIOError as io:
+      result.io = io
+    oprot.writeMessageBegin("openScanner", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getScannerRows(self, seqid, iprot, oprot):
+    args = getScannerRows_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getScannerRows_result()
+    try:
+      result.success = self._handler.getScannerRows(args.scannerId, args.numRows)
+    except TIOError as io:
+      result.io = io
+    except TIllegalArgument as ia:
+      result.ia = ia
+    oprot.writeMessageBegin("getScannerRows", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_closeScanner(self, seqid, iprot, oprot):
+    args = closeScanner_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = closeScanner_result()
+    try:
+      self._handler.closeScanner(args.scannerId)
+    except TIOError as io:
+      result.io = io
+    except TIllegalArgument as ia:
+      result.ia = ia
+    oprot.writeMessageBegin("closeScanner", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+
+# HELPER FUNCTIONS AND STRUCTURES
+
+class exists_args:
+  """
+  Attributes:
+   - table: the table to check on
+   - get: the TGet to check for
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.STRUCT, 'get', (TGet, TGet.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, table=None, get=None,):
+    self.table = table
+    self.get = get
+
+  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.table = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.get = TGet()
+          self.get.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('exists_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.get is not None:
+      oprot.writeFieldBegin('get', TType.STRUCT, 2)
+      self.get.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.get is None:
+      raise TProtocol.TProtocolException(message='Required field get is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class exists_result:
+  """
+  Attributes:
+   - success
+   - io
+  """
+
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, io=None,):
+    self.success = success
+    self.io = 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.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('exists_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  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:
+  """
+  Attributes:
+   - table: the table to get from
+   - get: the TGet to fetch
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.STRUCT, 'get', (TGet, TGet.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, table=None, get=None,):
+    self.table = table
+    self.get = get
+
+  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.table = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.get = TGet()
+          self.get.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_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.get is not None:
+      oprot.writeFieldBegin('get', TType.STRUCT, 2)
+      self.get.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.get is None:
+      raise TProtocol.TProtocolException(message='Required field get is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  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:
+  """
+  Attributes:
+   - success
+   - io
+  """
+
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (TResult, TResult.thrift_spec), None, ), # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, io=None,):
+    self.success = success
+    self.io = 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.STRUCT:
+          self.success = TResult()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('get_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getMultiple_args:
+  """
+  Attributes:
+   - table: the table to get from
+   - gets: a list of TGets to fetch, the Result list
+  will have the Results at corresponding positions
+  or null if there was an error
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.LIST, 'gets', (TType.STRUCT,(TGet, TGet.thrift_spec)), None, ), # 2
+  )
+
+  def __init__(self, table=None, gets=None,):
+    self.table = table
+    self.gets = gets
+
+  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.table = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.LIST:
+          self.gets = []
+          (_etype45, _size42) = iprot.readListBegin()
+          for _i46 in xrange(_size42):
+            _elem47 = TGet()
+            _elem47.read(iprot)
+            self.gets.append(_elem47)
+          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('getMultiple_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.gets is not None:
+      oprot.writeFieldBegin('gets', TType.LIST, 2)
+      oprot.writeListBegin(TType.STRUCT, len(self.gets))
+      for iter48 in self.gets:
+        iter48.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.gets is None:
+      raise TProtocol.TProtocolException(message='Required field gets is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getMultiple_result:
+  """
+  Attributes:
+   - success
+   - io
+  """
+
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(TResult, TResult.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, io=None,):
+    self.success = success
+    self.io = 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 = []
+          (_etype52, _size49) = iprot.readListBegin()
+          for _i53 in xrange(_size49):
+            _elem54 = TResult()
+            _elem54.read(iprot)
+            self.success.append(_elem54)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('getMultiple_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter55 in self.success:
+        iter55.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class put_args:
+  """
+  Attributes:
+   - table: the table to put data in
+   - put: the TPut to put
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.STRUCT, 'put', (TPut, TPut.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, table=None, put=None,):
+    self.table = table
+    self.put = put
+
+  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.table = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.put = TPut()
+          self.put.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('put_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.put is not None:
+      oprot.writeFieldBegin('put', TType.STRUCT, 2)
+      self.put.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.put is None:
+      raise TProtocol.TProtocolException(message='Required field put is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class put_result:
+  """
+  Attributes:
+   - io
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, io=None,):
+    self.io = 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 == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('put_result')
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class checkAndPut_args:
+  """
+  Attributes:
+   - table: to check in and put to
+   - row: row to check
+   - family: column family to check
+   - qualifier: column qualifier to check
+   - value: the expected value, if not provided the
+  check is for the non-existence of the
+  column in question
+   - put: the TPut to put if the check succeeds
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.STRING, 'row', None, None, ), # 2
+    (3, TType.STRING, 'family', None, None, ), # 3
+    (4, TType.STRING, 'qualifier', None, None, ), # 4
+    (5, TType.STRING, 'value', None, None, ), # 5
+    (6, TType.STRUCT, 'put', (TPut, TPut.thrift_spec), None, ), # 6
+  )
+
+  def __init__(self, table=None, row=None, family=None, qualifier=None, value=None, put=None,):
+    self.table = table
+    self.row = row
+    self.family = family
+    self.qualifier = qualifier
+    self.value = value
+    self.put = put
+
+  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.table = 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.family = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.STRING:
+          self.qualifier = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.STRING:
+          self.value = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 6:
+        if ftype == TType.STRUCT:
+          self.put = TPut()
+          self.put.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('checkAndPut_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.row is not None:
+      oprot.writeFieldBegin('row', TType.STRING, 2)
+      oprot.writeString(self.row)
+      oprot.writeFieldEnd()
+    if self.family is not None:
+      oprot.writeFieldBegin('family', TType.STRING, 3)
+      oprot.writeString(self.family)
+      oprot.writeFieldEnd()
+    if self.qualifier is not None:
+      oprot.writeFieldBegin('qualifier', TType.STRING, 4)
+      oprot.writeString(self.qualifier)
+      oprot.writeFieldEnd()
+    if self.value is not None:
+      oprot.writeFieldBegin('value', TType.STRING, 5)
+      oprot.writeString(self.value)
+      oprot.writeFieldEnd()
+    if self.put is not None:
+      oprot.writeFieldBegin('put', TType.STRUCT, 6)
+      self.put.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.row is None:
+      raise TProtocol.TProtocolException(message='Required field row is unset!')
+    if self.family is None:
+      raise TProtocol.TProtocolException(message='Required field family is unset!')
+    if self.qualifier is None:
+      raise TProtocol.TProtocolException(message='Required field qualifier is unset!')
+    if self.put is None:
+      raise TProtocol.TProtocolException(message='Required field put is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class checkAndPut_result:
+  """
+  Attributes:
+   - success
+   - io
+  """
+
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, io=None,):
+    self.success = success
+    self.io = 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.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('checkAndPut_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class putMultiple_args:
+  """
+  Attributes:
+   - table: the table to put data in
+   - puts: a list of TPuts to commit
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.LIST, 'puts', (TType.STRUCT,(TPut, TPut.thrift_spec)), None, ), # 2
+  )
+
+  def __init__(self, table=None, puts=None,):
+    self.table = table
+    self.puts = puts
+
+  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.table = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.LIST:
+          self.puts = []
+          (_etype59, _size56) = iprot.readListBegin()
+          for _i60 in xrange(_size56):
+            _elem61 = TPut()
+            _elem61.read(iprot)
+            self.puts.append(_elem61)
+          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('putMultiple_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.puts is not None:
+      oprot.writeFieldBegin('puts', TType.LIST, 2)
+      oprot.writeListBegin(TType.STRUCT, len(self.puts))
+      for iter62 in self.puts:
+        iter62.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.puts is None:
+      raise TProtocol.TProtocolException(message='Required field puts is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class putMultiple_result:
+  """
+  Attributes:
+   - io
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, io=None,):
+    self.io = 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 == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('putMultiple_result')
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class deleteSingle_args:
+  """
+  Attributes:
+   - table: the table to delete from
+   - deleteSingle: the TDelete to delete
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.STRUCT, 'deleteSingle', (TDelete, TDelete.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, table=None, deleteSingle=None,):
+    self.table = table
+    self.deleteSingle = deleteSingle
+
+  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.table = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.deleteSingle = TDelete()
+          self.deleteSingle.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('deleteSingle_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.deleteSingle is not None:
+      oprot.writeFieldBegin('deleteSingle', TType.STRUCT, 2)
+      self.deleteSingle.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.deleteSingle is None:
+      raise TProtocol.TProtocolException(message='Required field deleteSingle is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class deleteSingle_result:
+  """
+  Attributes:
+   - io
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, io=None,):
+    self.io = 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 == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('deleteSingle_result')
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class deleteMultiple_args:
+  """
+  Attributes:
+   - table: the table to delete from
+   - deletes: list of TDeletes to delete
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.LIST, 'deletes', (TType.STRUCT,(TDelete, TDelete.thrift_spec)), None, ), # 2
+  )
+
+  def __init__(self, table=None, deletes=None,):
+    self.table = table
+    self.deletes = deletes
+
+  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.table = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.LIST:
+          self.deletes = []
+          (_etype66, _size63) = iprot.readListBegin()
+          for _i67 in xrange(_size63):
+            _elem68 = TDelete()
+            _elem68.read(iprot)
+            self.deletes.append(_elem68)
+          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('deleteMultiple_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.deletes is not None:
+      oprot.writeFieldBegin('deletes', TType.LIST, 2)
+      oprot.writeListBegin(TType.STRUCT, len(self.deletes))
+      for iter69 in self.deletes:
+        iter69.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.deletes is None:
+      raise TProtocol.TProtocolException(message='Required field deletes is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class deleteMultiple_result:
+  """
+  Attributes:
+   - success
+   - io
+  """
+
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(TDelete, TDelete.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, io=None,):
+    self.success = success
+    self.io = 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 = []
+          (_etype73, _size70) = iprot.readListBegin()
+          for _i74 in xrange(_size70):
+            _elem75 = TDelete()
+            _elem75.read(iprot)
+            self.success.append(_elem75)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('deleteMultiple_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter76 in self.success:
+        iter76.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class checkAndDelete_args:
+  """
+  Attributes:
+   - table: to check in and delete from
+   - row: row to check
+   - family: column family to check
+   - qualifier: column qualifier to check
+   - value: the expected value, if not provided the
+  check is for the non-existence of the
+  column in question
+   - deleteSingle: the TDelete to execute if the check succeeds
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.STRING, 'row', None, None, ), # 2
+    (3, TType.STRING, 'family', None, None, ), # 3
+    (4, TType.STRING, 'qualifier', None, None, ), # 4
+    (5, TType.STRING, 'value', None, None, ), # 5
+    (6, TType.STRUCT, 'deleteSingle', (TDelete, TDelete.thrift_spec), None, ), # 6
+  )
+
+  def __init__(self, table=None, row=None, family=None, qualifier=None, value=None, deleteSingle=None,):
+    self.table = table
+    self.row = row
+    self.family = family
+    self.qualifier = qualifier
+    self.value = value
+    self.deleteSingle = deleteSingle
+
+  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.table = 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.family = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.STRING:
+          self.qualifier = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.STRING:
+          self.value = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 6:
+        if ftype == TType.STRUCT:
+          self.deleteSingle = TDelete()
+          self.deleteSingle.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('checkAndDelete_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.row is not None:
+      oprot.writeFieldBegin('row', TType.STRING, 2)
+      oprot.writeString(self.row)
+      oprot.writeFieldEnd()
+    if self.family is not None:
+      oprot.writeFieldBegin('family', TType.STRING, 3)
+      oprot.writeString(self.family)
+      oprot.writeFieldEnd()
+    if self.qualifier is not None:
+      oprot.writeFieldBegin('qualifier', TType.STRING, 4)
+      oprot.writeString(self.qualifier)
+      oprot.writeFieldEnd()
+    if self.value is not None:
+      oprot.writeFieldBegin('value', TType.STRING, 5)
+      oprot.writeString(self.value)
+      oprot.writeFieldEnd()
+    if self.deleteSingle is not None:
+      oprot.writeFieldBegin('deleteSingle', TType.STRUCT, 6)
+      self.deleteSingle.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.row is None:
+      raise TProtocol.TProtocolException(message='Required field row is unset!')
+    if self.family is None:
+      raise TProtocol.TProtocolException(message='Required field family is unset!')
+    if self.qualifier is None:
+      raise TProtocol.TProtocolException(message='Required field qualifier is unset!')
+    if self.deleteSingle is None:
+      raise TProtocol.TProtocolException(message='Required field deleteSingle is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class checkAndDelete_result:
+  """
+  Attributes:
+   - success
+   - io
+  """
+
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, io=None,):
+    self.success = success
+    self.io = 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.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('checkAndDelete_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class increment_args:
+  """
+  Attributes:
+   - table: the table to increment the value on
+   - increment: the TIncrement to increment
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.STRUCT, 'increment', (TIncrement, TIncrement.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, table=None, increment=None,):
+    self.table = table
+    self.increment = increment
+
+  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.table = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.increment = TIncrement()
+          self.increment.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('increment_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.increment is not None:
+      oprot.writeFieldBegin('increment', TType.STRUCT, 2)
+      self.increment.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.increment is None:
+      raise TProtocol.TProtocolException(message='Required field increment is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class increment_result:
+  """
+  Attributes:
+   - success
+   - io
+  """
+
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (TResult, TResult.thrift_spec), None, ), # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, io=None,):
+    self.success = success
+    self.io = 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.STRUCT:
+          self.success = TResult()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('increment_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class openScanner_args:
+  """
+  Attributes:
+   - table: the table to get the Scanner for
+   - scan: the scan object to get a Scanner for
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'table', None, None, ), # 1
+    (2, TType.STRUCT, 'scan', (TScan, TScan.thrift_spec), None, ), # 2
+  )
+
+  def __init__(self, table=None, scan=None,):
+    self.table = table
+    self.scan = scan
+
+  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.table = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRUCT:
+          self.scan = TScan()
+          self.scan.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('openScanner_args')
+    if self.table is not None:
+      oprot.writeFieldBegin('table', TType.STRING, 1)
+      oprot.writeString(self.table)
+      oprot.writeFieldEnd()
+    if self.scan is not None:
+      oprot.writeFieldBegin('scan', TType.STRUCT, 2)
+      self.scan.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.table is None:
+      raise TProtocol.TProtocolException(message='Required field table is unset!')
+    if self.scan is None:
+      raise TProtocol.TProtocolException(message='Required field scan is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class openScanner_result:
+  """
+  Attributes:
+   - success
+   - io
+  """
+
+  thrift_spec = (
+    (0, TType.I32, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'io', (TIOError, TIOError.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, io=None,):
+    self.success = success
+    self.io = 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.I32:
+          self.success = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.io = TIOError()
+          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('openScanner_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.I32, 0)
+      oprot.writeI32(self.success)
+      oprot.writeFieldEnd()
+    if self.io is not None:
+      oprot.writeFieldBegin('io', TType.STRUCT, 1)
+      self.io.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class getScannerRows_args:
+  """
+  Attributes:
+   - scannerId: the Id of the Scanner to return rows from. This is an Id returned from the openScanner function.
+   - numRows: number of rows to return
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'scannerId', None, None, ), # 1
+    (2, TType.I32, 'numRows', None, 1, ), # 2
+  )
+
+  def __init__(self, scannerId=None, numRows=thrift_spec[2][4],):
+    self.scannerId = scannerId
+    self.numRows = numRows
+
+  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.I32:
+          self.scannerId = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I32:
+          self.numRows = 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('getScannerRows_args')
+    if self.scannerId is not None:
+      oprot.writeFieldBegin('scannerId', TType.I32, 1)
+      oprot.writeI32(self.scannerId)
+      oprot.writeFieldEnd()
+    if self.numRows is not None:
+      oprot.writeFieldBegin('numRows', TType.I32, 2)
+      oprot.writeI32(self.numRows)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):

[... 246 lines stripped ...]


Mime
View raw message