You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by st...@apache.org on 2012/11/06 22:22:30 UTC
svn commit: r1406339 [14/17] - in /hbase/trunk: ./ examples/ hbase-examples/
hbase-examples/src/ hbase-examples/src/main/ hbase-examples/src/main/cpp/
hbase-examples/src/main/cpp/gen-cpp/ hbase-examples/src/main/java/
hbase-examples/src/main/java/org/ ...
Added: hbase/trunk/hbase-examples/src/main/python/gen-py/hbase/Hbase.py
URL: http://svn.apache.org/viewvc/hbase/trunk/hbase-examples/src/main/python/gen-py/hbase/Hbase.py?rev=1406339&view=auto
==============================================================================
--- hbase/trunk/hbase-examples/src/main/python/gen-py/hbase/Hbase.py (added)
+++ hbase/trunk/hbase-examples/src/main/python/gen-py/hbase/Hbase.py Tue Nov 6 21:22:27 2012
@@ -0,0 +1,10286 @@
+#
+# 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 enableTable(self, tableName):
+ """
+ Brings a table on-line (enables it)
+
+ Parameters:
+ - tableName: name of the table
+ """
+ pass
+
+ def disableTable(self, tableName):
+ """
+ Disables a table (takes it off-line) If it is being served, the master
+ will tell the servers to stop serving it.
+
+ Parameters:
+ - tableName: name of the table
+ """
+ pass
+
+ def isTableEnabled(self, tableName):
+ """
+ @return true if table is on-line
+
+ Parameters:
+ - tableName: name of the table to check
+ """
+ pass
+
+ def compact(self, tableNameOrRegionName):
+ """
+ Parameters:
+ - tableNameOrRegionName
+ """
+ pass
+
+ def majorCompact(self, tableNameOrRegionName):
+ """
+ Parameters:
+ - tableNameOrRegionName
+ """
+ pass
+
+ def getTableNames(self, ):
+ """
+ List all the userspace tables.
+
+ @return returns a list of names
+ """
+ pass
+
+ def getColumnDescriptors(self, tableName):
+ """
+ List all the column families assoicated with a table.
+
+ @return list of column family descriptors
+
+ Parameters:
+ - tableName: table name
+ """
+ pass
+
+ def getTableRegions(self, tableName):
+ """
+ List the regions associated with a table.
+
+ @return list of region descriptors
+
+ Parameters:
+ - tableName: table name
+ """
+ pass
+
+ def createTable(self, tableName, columnFamilies):
+ """
+ Create a table with the specified column families. The name
+ field for each ColumnDescriptor must be set and must end in a
+ colon (:). All other fields are optional and will get default
+ values if not explicitly specified.
+
+ @throws IllegalArgument if an input parameter is invalid
+
+ @throws AlreadyExists if the table name already exists
+
+ Parameters:
+ - tableName: name of table to create
+ - columnFamilies: list of column family descriptors
+ """
+ pass
+
+ def deleteTable(self, tableName):
+ """
+ Deletes a table
+
+ @throws IOError if table doesn't exist on server or there was some other
+ problem
+
+ Parameters:
+ - tableName: name of table to delete
+ """
+ pass
+
+ def get(self, tableName, row, column, attributes):
+ """
+ Get a single TCell for the specified table, row, and column at the
+ latest timestamp. Returns an empty list if no such value exists.
+
+ @return value for specified row/column
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - column: column name
+ - attributes: Get attributes
+ """
+ pass
+
+ def getVer(self, tableName, row, column, numVersions, attributes):
+ """
+ Get the specified number of versions for the specified table,
+ row, and column.
+
+ @return list of cells for specified row/column
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - column: column name
+ - numVersions: number of versions to retrieve
+ - attributes: Get attributes
+ """
+ pass
+
+ def getVerTs(self, tableName, row, column, timestamp, numVersions, attributes):
+ """
+ Get the specified number of versions for the specified table,
+ row, and column. Only versions less than or equal to the specified
+ timestamp will be returned.
+
+ @return list of cells for specified row/column
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - column: column name
+ - timestamp: timestamp
+ - numVersions: number of versions to retrieve
+ - attributes: Get attributes
+ """
+ pass
+
+ def getRow(self, tableName, row, attributes):
+ """
+ Get all the data for the specified table and row at the latest
+ timestamp. Returns an empty list if the row does not exist.
+
+ @return TRowResult containing the row and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - attributes: Get attributes
+ """
+ pass
+
+ def getRowWithColumns(self, tableName, row, columns, attributes):
+ """
+ Get the specified columns for the specified table and row at the latest
+ timestamp. Returns an empty list if the row does not exist.
+
+ @return TRowResult containing the row and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - columns: List of columns to return, null for all columns
+ - attributes: Get attributes
+ """
+ pass
+
+ def getRowTs(self, tableName, row, timestamp, attributes):
+ """
+ Get all the data for the specified table and row at the specified
+ timestamp. Returns an empty list if the row does not exist.
+
+ @return TRowResult containing the row and map of columns to TCells
+
+ Parameters:
+ - tableName: name of the table
+ - row: row key
+ - timestamp: timestamp
+ - attributes: Get attributes
+ """
+ pass
+
+ def getRowWithColumnsTs(self, tableName, row, columns, timestamp, attributes):
+ """
+ Get the specified columns for the specified table and row at the specified
+ timestamp. Returns an empty list if the row does not exist.
+
+ @return TRowResult containing the row and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - columns: List of columns to return, null for all columns
+ - timestamp
+ - attributes: Get attributes
+ """
+ pass
+
+ def getRows(self, tableName, rows, attributes):
+ """
+ Get all the data for the specified table and rows at the latest
+ timestamp. Returns an empty list if no rows exist.
+
+ @return TRowResult containing the rows and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - rows: row keys
+ - attributes: Get attributes
+ """
+ pass
+
+ def getRowsWithColumns(self, tableName, rows, columns, attributes):
+ """
+ Get the specified columns for the specified table and rows at the latest
+ timestamp. Returns an empty list if no rows exist.
+
+ @return TRowResult containing the rows and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - rows: row keys
+ - columns: List of columns to return, null for all columns
+ - attributes: Get attributes
+ """
+ pass
+
+ def getRowsTs(self, tableName, rows, timestamp, attributes):
+ """
+ Get all the data for the specified table and rows at the specified
+ timestamp. Returns an empty list if no rows exist.
+
+ @return TRowResult containing the rows and map of columns to TCells
+
+ Parameters:
+ - tableName: name of the table
+ - rows: row keys
+ - timestamp: timestamp
+ - attributes: Get attributes
+ """
+ pass
+
+ def getRowsWithColumnsTs(self, tableName, rows, columns, timestamp, attributes):
+ """
+ Get the specified columns for the specified table and rows at the specified
+ timestamp. Returns an empty list if no rows exist.
+
+ @return TRowResult containing the rows and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - rows: row keys
+ - columns: List of columns to return, null for all columns
+ - timestamp
+ - attributes: Get attributes
+ """
+ pass
+
+ def mutateRow(self, tableName, row, mutations, attributes):
+ """
+ Apply a series of mutations (updates/deletes) to a row in a
+ single transaction. If an exception is thrown, then the
+ transaction is aborted. Default current timestamp is used, and
+ all entries will have an identical timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - mutations: list of mutation commands
+ - attributes: Mutation attributes
+ """
+ pass
+
+ def mutateRowTs(self, tableName, row, mutations, timestamp, attributes):
+ """
+ Apply a series of mutations (updates/deletes) to a row in a
+ single transaction. If an exception is thrown, then the
+ transaction is aborted. The specified timestamp is used, and
+ all entries will have an identical timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - mutations: list of mutation commands
+ - timestamp: timestamp
+ - attributes: Mutation attributes
+ """
+ pass
+
+ def mutateRows(self, tableName, rowBatches, attributes):
+ """
+ Apply a series of batches (each a series of mutations on a single row)
+ in a single transaction. If an exception is thrown, then the
+ transaction is aborted. Default current timestamp is used, and
+ all entries will have an identical timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - rowBatches: list of row batches
+ - attributes: Mutation attributes
+ """
+ pass
+
+ def mutateRowsTs(self, tableName, rowBatches, timestamp, attributes):
+ """
+ Apply a series of batches (each a series of mutations on a single row)
+ in a single transaction. If an exception is thrown, then the
+ transaction is aborted. The specified timestamp is used, and
+ all entries will have an identical timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - rowBatches: list of row batches
+ - timestamp: timestamp
+ - attributes: Mutation attributes
+ """
+ pass
+
+ def atomicIncrement(self, tableName, row, column, value):
+ """
+ Atomically increment the column value specified. Returns the next value post increment.
+
+ Parameters:
+ - tableName: name of table
+ - row: row to increment
+ - column: name of column
+ - value: amount to increment by
+ """
+ pass
+
+ def deleteAll(self, tableName, row, column, attributes):
+ """
+ Delete all cells that match the passed row and column.
+
+ Parameters:
+ - tableName: name of table
+ - row: Row to update
+ - column: name of column whose value is to be deleted
+ - attributes: Delete attributes
+ """
+ pass
+
+ def deleteAllTs(self, tableName, row, column, timestamp, attributes):
+ """
+ Delete all cells that match the passed row and column and whose
+ timestamp is equal-to or older than the passed timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - row: Row to update
+ - column: name of column whose value is to be deleted
+ - timestamp: timestamp
+ - attributes: Delete attributes
+ """
+ pass
+
+ def deleteAllRow(self, tableName, row, attributes):
+ """
+ Completely delete the row's cells.
+
+ Parameters:
+ - tableName: name of table
+ - row: key of the row to be completely deleted.
+ - attributes: Delete attributes
+ """
+ pass
+
+ def increment(self, increment):
+ """
+ Increment a cell by the ammount.
+ Increments can be applied async if hbase.regionserver.thrift.coalesceIncrement is set to true.
+ False is the default. Turn to true if you need the extra performance and can accept some
+ data loss if a thrift server dies with increments still in the queue.
+
+ Parameters:
+ - increment: The single increment to apply
+ """
+ pass
+
+ def incrementRows(self, increments):
+ """
+ Parameters:
+ - increments: The list of increments
+ """
+ pass
+
+ def deleteAllRowTs(self, tableName, row, timestamp, attributes):
+ """
+ Completely delete the row's cells marked with a timestamp
+ equal-to or older than the passed timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - row: key of the row to be completely deleted.
+ - timestamp: timestamp
+ - attributes: Delete attributes
+ """
+ pass
+
+ def scannerOpenWithScan(self, tableName, scan, attributes):
+ """
+ Get a scanner on the current table, using the Scan instance
+ for the scan parameters.
+
+ Parameters:
+ - tableName: name of table
+ - scan: Scan instance
+ - attributes: Scan attributes
+ """
+ pass
+
+ def scannerOpen(self, tableName, startRow, columns, attributes):
+ """
+ Get a scanner on the current table starting at the specified row and
+ ending at the last row in the table. Return the specified columns.
+
+ @return scanner id to be used with other scanner procedures
+
+ Parameters:
+ - tableName: name of table
+ - startRow: Starting row in table to scan.
+ Send "" (empty string) to start at the first row.
+ - columns: columns to scan. If column name is a column family, all
+ columns of the specified column family are returned. It's also possible
+ to pass a regex in the column qualifier.
+ - attributes: Scan attributes
+ """
+ pass
+
+ def scannerOpenWithStop(self, tableName, startRow, stopRow, columns, attributes):
+ """
+ Get a scanner on the current table starting and stopping at the
+ specified rows. ending at the last row in the table. Return the
+ specified columns.
+
+ @return scanner id to be used with other scanner procedures
+
+ Parameters:
+ - tableName: name of table
+ - startRow: Starting row in table to scan.
+ Send "" (empty string) to start at the first row.
+ - stopRow: row to stop scanning on. This row is *not* included in the
+ scanner's results
+ - columns: columns to scan. If column name is a column family, all
+ columns of the specified column family are returned. It's also possible
+ to pass a regex in the column qualifier.
+ - attributes: Scan attributes
+ """
+ pass
+
+ def scannerOpenWithPrefix(self, tableName, startAndPrefix, columns, attributes):
+ """
+ Open a scanner for a given prefix. That is all rows will have the specified
+ prefix. No other rows will be returned.
+
+ @return scanner id to use with other scanner calls
+
+ Parameters:
+ - tableName: name of table
+ - startAndPrefix: the prefix (and thus start row) of the keys you want
+ - columns: the columns you want returned
+ - attributes: Scan attributes
+ """
+ pass
+
+ def scannerOpenTs(self, tableName, startRow, columns, timestamp, attributes):
+ """
+ Get a scanner on the current table starting at the specified row and
+ ending at the last row in the table. Return the specified columns.
+ Only values with the specified timestamp are returned.
+
+ @return scanner id to be used with other scanner procedures
+
+ Parameters:
+ - tableName: name of table
+ - startRow: Starting row in table to scan.
+ Send "" (empty string) to start at the first row.
+ - columns: columns to scan. If column name is a column family, all
+ columns of the specified column family are returned. It's also possible
+ to pass a regex in the column qualifier.
+ - timestamp: timestamp
+ - attributes: Scan attributes
+ """
+ pass
+
+ def scannerOpenWithStopTs(self, tableName, startRow, stopRow, columns, timestamp, attributes):
+ """
+ Get a scanner on the current table starting and stopping at the
+ specified rows. ending at the last row in the table. Return the
+ specified columns. Only values with the specified timestamp are
+ returned.
+
+ @return scanner id to be used with other scanner procedures
+
+ Parameters:
+ - tableName: name of table
+ - startRow: Starting row in table to scan.
+ Send "" (empty string) to start at the first row.
+ - stopRow: row to stop scanning on. This row is *not* included in the
+ scanner's results
+ - columns: columns to scan. If column name is a column family, all
+ columns of the specified column family are returned. It's also possible
+ to pass a regex in the column qualifier.
+ - timestamp: timestamp
+ - attributes: Scan attributes
+ """
+ pass
+
+ def scannerGet(self, id):
+ """
+ Returns the scanner's current row value and advances to the next
+ row in the table. When there are no more rows in the table, or a key
+ greater-than-or-equal-to the scanner's specified stopRow is reached,
+ an empty list is returned.
+
+ @return a TRowResult containing the current row and a map of the columns to TCells.
+
+ @throws IllegalArgument if ScannerID is invalid
+
+ @throws NotFound when the scanner reaches the end
+
+ Parameters:
+ - id: id of a scanner returned by scannerOpen
+ """
+ pass
+
+ def scannerGetList(self, id, nbRows):
+ """
+ Returns, starting at the scanner's current row value nbRows worth of
+ rows and advances to the next row in the table. When there are no more
+ rows in the table, or a key greater-than-or-equal-to the scanner's
+ specified stopRow is reached, an empty list is returned.
+
+ @return a TRowResult containing the current row and a map of the columns to TCells.
+
+ @throws IllegalArgument if ScannerID is invalid
+
+ @throws NotFound when the scanner reaches the end
+
+ Parameters:
+ - id: id of a scanner returned by scannerOpen
+ - nbRows: number of results to return
+ """
+ pass
+
+ def scannerClose(self, id):
+ """
+ Closes the server-state associated with an open scanner.
+
+ @throws IllegalArgument if ScannerID is invalid
+
+ Parameters:
+ - id: id of a scanner returned by scannerOpen
+ """
+ pass
+
+ def getRowOrBefore(self, tableName, row, family):
+ """
+ Get the row just before the specified one.
+
+ @return value for specified row/column
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - family: column name
+ """
+ pass
+
+ def getRegionInfo(self, row):
+ """
+ Get the regininfo for the specified row. It scans
+ the metatable to find region's start and end keys.
+
+ @return value for specified row/column
+
+ Parameters:
+ - row: row key
+ """
+ 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 enableTable(self, tableName):
+ """
+ Brings a table on-line (enables it)
+
+ Parameters:
+ - tableName: name of the table
+ """
+ self.send_enableTable(tableName)
+ self.recv_enableTable()
+
+ def send_enableTable(self, tableName):
+ self._oprot.writeMessageBegin('enableTable', TMessageType.CALL, self._seqid)
+ args = enableTable_args()
+ args.tableName = tableName
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_enableTable(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = enableTable_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.io is not None:
+ raise result.io
+ return
+
+ def disableTable(self, tableName):
+ """
+ Disables a table (takes it off-line) If it is being served, the master
+ will tell the servers to stop serving it.
+
+ Parameters:
+ - tableName: name of the table
+ """
+ self.send_disableTable(tableName)
+ self.recv_disableTable()
+
+ def send_disableTable(self, tableName):
+ self._oprot.writeMessageBegin('disableTable', TMessageType.CALL, self._seqid)
+ args = disableTable_args()
+ args.tableName = tableName
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_disableTable(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = disableTable_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.io is not None:
+ raise result.io
+ return
+
+ def isTableEnabled(self, tableName):
+ """
+ @return true if table is on-line
+
+ Parameters:
+ - tableName: name of the table to check
+ """
+ self.send_isTableEnabled(tableName)
+ return self.recv_isTableEnabled()
+
+ def send_isTableEnabled(self, tableName):
+ self._oprot.writeMessageBegin('isTableEnabled', TMessageType.CALL, self._seqid)
+ args = isTableEnabled_args()
+ args.tableName = tableName
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_isTableEnabled(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = isTableEnabled_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, "isTableEnabled failed: unknown result");
+
+ def compact(self, tableNameOrRegionName):
+ """
+ Parameters:
+ - tableNameOrRegionName
+ """
+ self.send_compact(tableNameOrRegionName)
+ self.recv_compact()
+
+ def send_compact(self, tableNameOrRegionName):
+ self._oprot.writeMessageBegin('compact', TMessageType.CALL, self._seqid)
+ args = compact_args()
+ args.tableNameOrRegionName = tableNameOrRegionName
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_compact(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = compact_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.io is not None:
+ raise result.io
+ return
+
+ def majorCompact(self, tableNameOrRegionName):
+ """
+ Parameters:
+ - tableNameOrRegionName
+ """
+ self.send_majorCompact(tableNameOrRegionName)
+ self.recv_majorCompact()
+
+ def send_majorCompact(self, tableNameOrRegionName):
+ self._oprot.writeMessageBegin('majorCompact', TMessageType.CALL, self._seqid)
+ args = majorCompact_args()
+ args.tableNameOrRegionName = tableNameOrRegionName
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_majorCompact(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = majorCompact_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.io is not None:
+ raise result.io
+ return
+
+ def getTableNames(self, ):
+ """
+ List all the userspace tables.
+
+ @return returns a list of names
+ """
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result");
+
+ def getColumnDescriptors(self, tableName):
+ """
+ List all the column families assoicated with a table.
+
+ @return list of column family descriptors
+
+ Parameters:
+ - tableName: table name
+ """
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result");
+
+ def getTableRegions(self, tableName):
+ """
+ List the regions associated with a table.
+
+ @return list of region descriptors
+
+ Parameters:
+ - tableName: table name
+ """
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result");
+
+ def createTable(self, tableName, columnFamilies):
+ """
+ Create a table with the specified column families. The name
+ field for each ColumnDescriptor must be set and must end in a
+ colon (:). All other fields are optional and will get default
+ values if not explicitly specified.
+
+ @throws IllegalArgument if an input parameter is invalid
+
+ @throws AlreadyExists if the table name already exists
+
+ Parameters:
+ - tableName: name of table to create
+ - columnFamilies: list of column family descriptors
+ """
+ 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 is not None:
+ raise result.io
+ if result.ia is not None:
+ raise result.ia
+ if result.exist is not None:
+ raise result.exist
+ return
+
+ def deleteTable(self, tableName):
+ """
+ Deletes a table
+
+ @throws IOError if table doesn't exist on server or there was some other
+ problem
+
+ Parameters:
+ - tableName: name of table to delete
+ """
+ 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 is not None:
+ raise result.io
+ return
+
+ def get(self, tableName, row, column, attributes):
+ """
+ Get a single TCell for the specified table, row, and column at the
+ latest timestamp. Returns an empty list if no such value exists.
+
+ @return value for specified row/column
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - column: column name
+ - attributes: Get attributes
+ """
+ self.send_get(tableName, row, column, attributes)
+ return self.recv_get()
+
+ def send_get(self, tableName, row, column, attributes):
+ self._oprot.writeMessageBegin('get', TMessageType.CALL, self._seqid)
+ args = get_args()
+ args.tableName = tableName
+ args.row = row
+ args.column = column
+ args.attributes = attributes
+ 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 getVer(self, tableName, row, column, numVersions, attributes):
+ """
+ Get the specified number of versions for the specified table,
+ row, and column.
+
+ @return list of cells for specified row/column
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - column: column name
+ - numVersions: number of versions to retrieve
+ - attributes: Get attributes
+ """
+ self.send_getVer(tableName, row, column, numVersions, attributes)
+ return self.recv_getVer()
+
+ def send_getVer(self, tableName, row, column, numVersions, attributes):
+ self._oprot.writeMessageBegin('getVer', TMessageType.CALL, self._seqid)
+ args = getVer_args()
+ args.tableName = tableName
+ args.row = row
+ args.column = column
+ args.numVersions = numVersions
+ args.attributes = attributes
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "getVer failed: unknown result");
+
+ def getVerTs(self, tableName, row, column, timestamp, numVersions, attributes):
+ """
+ Get the specified number of versions for the specified table,
+ row, and column. Only versions less than or equal to the specified
+ timestamp will be returned.
+
+ @return list of cells for specified row/column
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - column: column name
+ - timestamp: timestamp
+ - numVersions: number of versions to retrieve
+ - attributes: Get attributes
+ """
+ self.send_getVerTs(tableName, row, column, timestamp, numVersions, attributes)
+ return self.recv_getVerTs()
+
+ def send_getVerTs(self, tableName, row, column, timestamp, numVersions, attributes):
+ 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.attributes = attributes
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result");
+
+ def getRow(self, tableName, row, attributes):
+ """
+ Get all the data for the specified table and row at the latest
+ timestamp. Returns an empty list if the row does not exist.
+
+ @return TRowResult containing the row and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - attributes: Get attributes
+ """
+ self.send_getRow(tableName, row, attributes)
+ return self.recv_getRow()
+
+ def send_getRow(self, tableName, row, attributes):
+ self._oprot.writeMessageBegin('getRow', TMessageType.CALL, self._seqid)
+ args = getRow_args()
+ args.tableName = tableName
+ args.row = row
+ args.attributes = attributes
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "getRow failed: unknown result");
+
+ def getRowWithColumns(self, tableName, row, columns, attributes):
+ """
+ Get the specified columns for the specified table and row at the latest
+ timestamp. Returns an empty list if the row does not exist.
+
+ @return TRowResult containing the row and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - columns: List of columns to return, null for all columns
+ - attributes: Get attributes
+ """
+ self.send_getRowWithColumns(tableName, row, columns, attributes)
+ return self.recv_getRowWithColumns()
+
+ def send_getRowWithColumns(self, tableName, row, columns, attributes):
+ self._oprot.writeMessageBegin('getRowWithColumns', TMessageType.CALL, self._seqid)
+ args = getRowWithColumns_args()
+ args.tableName = tableName
+ args.row = row
+ args.columns = columns
+ args.attributes = attributes
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_getRowWithColumns(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = getRowWithColumns_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, "getRowWithColumns failed: unknown result");
+
+ def getRowTs(self, tableName, row, timestamp, attributes):
+ """
+ Get all the data for the specified table and row at the specified
+ timestamp. Returns an empty list if the row does not exist.
+
+ @return TRowResult containing the row and map of columns to TCells
+
+ Parameters:
+ - tableName: name of the table
+ - row: row key
+ - timestamp: timestamp
+ - attributes: Get attributes
+ """
+ self.send_getRowTs(tableName, row, timestamp, attributes)
+ return self.recv_getRowTs()
+
+ def send_getRowTs(self, tableName, row, timestamp, attributes):
+ self._oprot.writeMessageBegin('getRowTs', TMessageType.CALL, self._seqid)
+ args = getRowTs_args()
+ args.tableName = tableName
+ args.row = row
+ args.timestamp = timestamp
+ args.attributes = attributes
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result");
+
+ def getRowWithColumnsTs(self, tableName, row, columns, timestamp, attributes):
+ """
+ Get the specified columns for the specified table and row at the specified
+ timestamp. Returns an empty list if the row does not exist.
+
+ @return TRowResult containing the row and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - columns: List of columns to return, null for all columns
+ - timestamp
+ - attributes: Get attributes
+ """
+ self.send_getRowWithColumnsTs(tableName, row, columns, timestamp, attributes)
+ return self.recv_getRowWithColumnsTs()
+
+ def send_getRowWithColumnsTs(self, tableName, row, columns, timestamp, attributes):
+ self._oprot.writeMessageBegin('getRowWithColumnsTs', TMessageType.CALL, self._seqid)
+ args = getRowWithColumnsTs_args()
+ args.tableName = tableName
+ args.row = row
+ args.columns = columns
+ args.timestamp = timestamp
+ args.attributes = attributes
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_getRowWithColumnsTs(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = getRowWithColumnsTs_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, "getRowWithColumnsTs failed: unknown result");
+
+ def getRows(self, tableName, rows, attributes):
+ """
+ Get all the data for the specified table and rows at the latest
+ timestamp. Returns an empty list if no rows exist.
+
+ @return TRowResult containing the rows and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - rows: row keys
+ - attributes: Get attributes
+ """
+ self.send_getRows(tableName, rows, attributes)
+ return self.recv_getRows()
+
+ def send_getRows(self, tableName, rows, attributes):
+ self._oprot.writeMessageBegin('getRows', TMessageType.CALL, self._seqid)
+ args = getRows_args()
+ args.tableName = tableName
+ args.rows = rows
+ args.attributes = attributes
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_getRows(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = getRows_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, "getRows failed: unknown result");
+
+ def getRowsWithColumns(self, tableName, rows, columns, attributes):
+ """
+ Get the specified columns for the specified table and rows at the latest
+ timestamp. Returns an empty list if no rows exist.
+
+ @return TRowResult containing the rows and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - rows: row keys
+ - columns: List of columns to return, null for all columns
+ - attributes: Get attributes
+ """
+ self.send_getRowsWithColumns(tableName, rows, columns, attributes)
+ return self.recv_getRowsWithColumns()
+
+ def send_getRowsWithColumns(self, tableName, rows, columns, attributes):
+ self._oprot.writeMessageBegin('getRowsWithColumns', TMessageType.CALL, self._seqid)
+ args = getRowsWithColumns_args()
+ args.tableName = tableName
+ args.rows = rows
+ args.columns = columns
+ args.attributes = attributes
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_getRowsWithColumns(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = getRowsWithColumns_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, "getRowsWithColumns failed: unknown result");
+
+ def getRowsTs(self, tableName, rows, timestamp, attributes):
+ """
+ Get all the data for the specified table and rows at the specified
+ timestamp. Returns an empty list if no rows exist.
+
+ @return TRowResult containing the rows and map of columns to TCells
+
+ Parameters:
+ - tableName: name of the table
+ - rows: row keys
+ - timestamp: timestamp
+ - attributes: Get attributes
+ """
+ self.send_getRowsTs(tableName, rows, timestamp, attributes)
+ return self.recv_getRowsTs()
+
+ def send_getRowsTs(self, tableName, rows, timestamp, attributes):
+ self._oprot.writeMessageBegin('getRowsTs', TMessageType.CALL, self._seqid)
+ args = getRowsTs_args()
+ args.tableName = tableName
+ args.rows = rows
+ args.timestamp = timestamp
+ args.attributes = attributes
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_getRowsTs(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = getRowsTs_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, "getRowsTs failed: unknown result");
+
+ def getRowsWithColumnsTs(self, tableName, rows, columns, timestamp, attributes):
+ """
+ Get the specified columns for the specified table and rows at the specified
+ timestamp. Returns an empty list if no rows exist.
+
+ @return TRowResult containing the rows and map of columns to TCells
+
+ Parameters:
+ - tableName: name of table
+ - rows: row keys
+ - columns: List of columns to return, null for all columns
+ - timestamp
+ - attributes: Get attributes
+ """
+ self.send_getRowsWithColumnsTs(tableName, rows, columns, timestamp, attributes)
+ return self.recv_getRowsWithColumnsTs()
+
+ def send_getRowsWithColumnsTs(self, tableName, rows, columns, timestamp, attributes):
+ self._oprot.writeMessageBegin('getRowsWithColumnsTs', TMessageType.CALL, self._seqid)
+ args = getRowsWithColumnsTs_args()
+ args.tableName = tableName
+ args.rows = rows
+ args.columns = columns
+ args.timestamp = timestamp
+ args.attributes = attributes
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_getRowsWithColumnsTs(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = getRowsWithColumnsTs_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, "getRowsWithColumnsTs failed: unknown result");
+
+ def mutateRow(self, tableName, row, mutations, attributes):
+ """
+ Apply a series of mutations (updates/deletes) to a row in a
+ single transaction. If an exception is thrown, then the
+ transaction is aborted. Default current timestamp is used, and
+ all entries will have an identical timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - mutations: list of mutation commands
+ - attributes: Mutation attributes
+ """
+ self.send_mutateRow(tableName, row, mutations, attributes)
+ self.recv_mutateRow()
+
+ def send_mutateRow(self, tableName, row, mutations, attributes):
+ self._oprot.writeMessageBegin('mutateRow', TMessageType.CALL, self._seqid)
+ args = mutateRow_args()
+ args.tableName = tableName
+ args.row = row
+ args.mutations = mutations
+ args.attributes = attributes
+ 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 is not None:
+ raise result.io
+ if result.ia is not None:
+ raise result.ia
+ return
+
+ def mutateRowTs(self, tableName, row, mutations, timestamp, attributes):
+ """
+ Apply a series of mutations (updates/deletes) to a row in a
+ single transaction. If an exception is thrown, then the
+ transaction is aborted. The specified timestamp is used, and
+ all entries will have an identical timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - mutations: list of mutation commands
+ - timestamp: timestamp
+ - attributes: Mutation attributes
+ """
+ self.send_mutateRowTs(tableName, row, mutations, timestamp, attributes)
+ self.recv_mutateRowTs()
+
+ def send_mutateRowTs(self, tableName, row, mutations, timestamp, attributes):
+ self._oprot.writeMessageBegin('mutateRowTs', TMessageType.CALL, self._seqid)
+ args = mutateRowTs_args()
+ args.tableName = tableName
+ args.row = row
+ args.mutations = mutations
+ args.timestamp = timestamp
+ args.attributes = attributes
+ 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 is not None:
+ raise result.io
+ if result.ia is not None:
+ raise result.ia
+ return
+
+ def mutateRows(self, tableName, rowBatches, attributes):
+ """
+ Apply a series of batches (each a series of mutations on a single row)
+ in a single transaction. If an exception is thrown, then the
+ transaction is aborted. Default current timestamp is used, and
+ all entries will have an identical timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - rowBatches: list of row batches
+ - attributes: Mutation attributes
+ """
+ self.send_mutateRows(tableName, rowBatches, attributes)
+ self.recv_mutateRows()
+
+ def send_mutateRows(self, tableName, rowBatches, attributes):
+ self._oprot.writeMessageBegin('mutateRows', TMessageType.CALL, self._seqid)
+ args = mutateRows_args()
+ args.tableName = tableName
+ args.rowBatches = rowBatches
+ args.attributes = attributes
+ 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 is not None:
+ raise result.io
+ if result.ia is not None:
+ raise result.ia
+ return
+
+ def mutateRowsTs(self, tableName, rowBatches, timestamp, attributes):
+ """
+ Apply a series of batches (each a series of mutations on a single row)
+ in a single transaction. If an exception is thrown, then the
+ transaction is aborted. The specified timestamp is used, and
+ all entries will have an identical timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - rowBatches: list of row batches
+ - timestamp: timestamp
+ - attributes: Mutation attributes
+ """
+ self.send_mutateRowsTs(tableName, rowBatches, timestamp, attributes)
+ self.recv_mutateRowsTs()
+
+ def send_mutateRowsTs(self, tableName, rowBatches, timestamp, attributes):
+ self._oprot.writeMessageBegin('mutateRowsTs', TMessageType.CALL, self._seqid)
+ args = mutateRowsTs_args()
+ args.tableName = tableName
+ args.rowBatches = rowBatches
+ args.timestamp = timestamp
+ args.attributes = attributes
+ 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 is not None:
+ raise result.io
+ if result.ia is not None:
+ raise result.ia
+ return
+
+ def atomicIncrement(self, tableName, row, column, value):
+ """
+ Atomically increment the column value specified. Returns the next value post increment.
+
+ Parameters:
+ - tableName: name of table
+ - row: row to increment
+ - column: name of column
+ - value: amount to increment by
+ """
+ self.send_atomicIncrement(tableName, row, column, value)
+ return self.recv_atomicIncrement()
+
+ def send_atomicIncrement(self, tableName, row, column, value):
+ self._oprot.writeMessageBegin('atomicIncrement', TMessageType.CALL, self._seqid)
+ args = atomicIncrement_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_atomicIncrement(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = atomicIncrement_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, "atomicIncrement failed: unknown result");
+
+ def deleteAll(self, tableName, row, column, attributes):
+ """
+ Delete all cells that match the passed row and column.
+
+ Parameters:
+ - tableName: name of table
+ - row: Row to update
+ - column: name of column whose value is to be deleted
+ - attributes: Delete attributes
+ """
+ self.send_deleteAll(tableName, row, column, attributes)
+ self.recv_deleteAll()
+
+ def send_deleteAll(self, tableName, row, column, attributes):
+ self._oprot.writeMessageBegin('deleteAll', TMessageType.CALL, self._seqid)
+ args = deleteAll_args()
+ args.tableName = tableName
+ args.row = row
+ args.column = column
+ args.attributes = attributes
+ 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 is not None:
+ raise result.io
+ return
+
+ def deleteAllTs(self, tableName, row, column, timestamp, attributes):
+ """
+ Delete all cells that match the passed row and column and whose
+ timestamp is equal-to or older than the passed timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - row: Row to update
+ - column: name of column whose value is to be deleted
+ - timestamp: timestamp
+ - attributes: Delete attributes
+ """
+ self.send_deleteAllTs(tableName, row, column, timestamp, attributes)
+ self.recv_deleteAllTs()
+
+ def send_deleteAllTs(self, tableName, row, column, timestamp, attributes):
+ self._oprot.writeMessageBegin('deleteAllTs', TMessageType.CALL, self._seqid)
+ args = deleteAllTs_args()
+ args.tableName = tableName
+ args.row = row
+ args.column = column
+ args.timestamp = timestamp
+ args.attributes = attributes
+ 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 is not None:
+ raise result.io
+ return
+
+ def deleteAllRow(self, tableName, row, attributes):
+ """
+ Completely delete the row's cells.
+
+ Parameters:
+ - tableName: name of table
+ - row: key of the row to be completely deleted.
+ - attributes: Delete attributes
+ """
+ self.send_deleteAllRow(tableName, row, attributes)
+ self.recv_deleteAllRow()
+
+ def send_deleteAllRow(self, tableName, row, attributes):
+ self._oprot.writeMessageBegin('deleteAllRow', TMessageType.CALL, self._seqid)
+ args = deleteAllRow_args()
+ args.tableName = tableName
+ args.row = row
+ args.attributes = attributes
+ 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 is not None:
+ raise result.io
+ return
+
+ def increment(self, increment):
+ """
+ Increment a cell by the ammount.
+ Increments can be applied async if hbase.regionserver.thrift.coalesceIncrement is set to true.
+ False is the default. Turn to true if you need the extra performance and can accept some
+ data loss if a thrift server dies with increments still in the queue.
+
+ Parameters:
+ - increment: The single increment to apply
+ """
+ self.send_increment(increment)
+ self.recv_increment()
+
+ def send_increment(self, increment):
+ self._oprot.writeMessageBegin('increment', TMessageType.CALL, self._seqid)
+ args = increment_args()
+ 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.io is not None:
+ raise result.io
+ return
+
+ def incrementRows(self, increments):
+ """
+ Parameters:
+ - increments: The list of increments
+ """
+ self.send_incrementRows(increments)
+ self.recv_incrementRows()
+
+ def send_incrementRows(self, increments):
+ self._oprot.writeMessageBegin('incrementRows', TMessageType.CALL, self._seqid)
+ args = incrementRows_args()
+ args.increments = increments
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_incrementRows(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = incrementRows_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.io is not None:
+ raise result.io
+ return
+
+ def deleteAllRowTs(self, tableName, row, timestamp, attributes):
+ """
+ Completely delete the row's cells marked with a timestamp
+ equal-to or older than the passed timestamp.
+
+ Parameters:
+ - tableName: name of table
+ - row: key of the row to be completely deleted.
+ - timestamp: timestamp
+ - attributes: Delete attributes
+ """
+ self.send_deleteAllRowTs(tableName, row, timestamp, attributes)
+ self.recv_deleteAllRowTs()
+
+ def send_deleteAllRowTs(self, tableName, row, timestamp, attributes):
+ self._oprot.writeMessageBegin('deleteAllRowTs', TMessageType.CALL, self._seqid)
+ args = deleteAllRowTs_args()
+ args.tableName = tableName
+ args.row = row
+ args.timestamp = timestamp
+ args.attributes = attributes
+ 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 is not None:
+ raise result.io
+ return
+
+ def scannerOpenWithScan(self, tableName, scan, attributes):
+ """
+ Get a scanner on the current table, using the Scan instance
+ for the scan parameters.
+
+ Parameters:
+ - tableName: name of table
+ - scan: Scan instance
+ - attributes: Scan attributes
+ """
+ self.send_scannerOpenWithScan(tableName, scan, attributes)
+ return self.recv_scannerOpenWithScan()
+
+ def send_scannerOpenWithScan(self, tableName, scan, attributes):
+ self._oprot.writeMessageBegin('scannerOpenWithScan', TMessageType.CALL, self._seqid)
+ args = scannerOpenWithScan_args()
+ args.tableName = tableName
+ args.scan = scan
+ args.attributes = attributes
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_scannerOpenWithScan(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = scannerOpenWithScan_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, "scannerOpenWithScan failed: unknown result");
+
+ def scannerOpen(self, tableName, startRow, columns, attributes):
+ """
+ Get a scanner on the current table starting at the specified row and
+ ending at the last row in the table. Return the specified columns.
+
+ @return scanner id to be used with other scanner procedures
+
+ Parameters:
+ - tableName: name of table
+ - startRow: Starting row in table to scan.
+ Send "" (empty string) to start at the first row.
+ - columns: columns to scan. If column name is a column family, all
+ columns of the specified column family are returned. It's also possible
+ to pass a regex in the column qualifier.
+ - attributes: Scan attributes
+ """
+ self.send_scannerOpen(tableName, startRow, columns, attributes)
+ return self.recv_scannerOpen()
+
+ def send_scannerOpen(self, tableName, startRow, columns, attributes):
+ self._oprot.writeMessageBegin('scannerOpen', TMessageType.CALL, self._seqid)
+ args = scannerOpen_args()
+ args.tableName = tableName
+ args.startRow = startRow
+ args.columns = columns
+ args.attributes = attributes
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result");
+
+ def scannerOpenWithStop(self, tableName, startRow, stopRow, columns, attributes):
+ """
+ Get a scanner on the current table starting and stopping at the
+ specified rows. ending at the last row in the table. Return the
+ specified columns.
+
+ @return scanner id to be used with other scanner procedures
+
+ Parameters:
+ - tableName: name of table
+ - startRow: Starting row in table to scan.
+ Send "" (empty string) to start at the first row.
+ - stopRow: row to stop scanning on. This row is *not* included in the
+ scanner's results
+ - columns: columns to scan. If column name is a column family, all
+ columns of the specified column family are returned. It's also possible
+ to pass a regex in the column qualifier.
+ - attributes: Scan attributes
+ """
+ self.send_scannerOpenWithStop(tableName, startRow, stopRow, columns, attributes)
+ return self.recv_scannerOpenWithStop()
+
+ def send_scannerOpenWithStop(self, tableName, startRow, stopRow, columns, attributes):
+ self._oprot.writeMessageBegin('scannerOpenWithStop', TMessageType.CALL, self._seqid)
+ args = scannerOpenWithStop_args()
+ args.tableName = tableName
+ args.startRow = startRow
+ args.stopRow = stopRow
+ args.columns = columns
+ args.attributes = attributes
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
+
+ def scannerOpenWithPrefix(self, tableName, startAndPrefix, columns, attributes):
+ """
+ Open a scanner for a given prefix. That is all rows will have the specified
+ prefix. No other rows will be returned.
+
+ @return scanner id to use with other scanner calls
+
+ Parameters:
+ - tableName: name of table
+ - startAndPrefix: the prefix (and thus start row) of the keys you want
+ - columns: the columns you want returned
+ - attributes: Scan attributes
+ """
+ self.send_scannerOpenWithPrefix(tableName, startAndPrefix, columns, attributes)
+ return self.recv_scannerOpenWithPrefix()
+
+ def send_scannerOpenWithPrefix(self, tableName, startAndPrefix, columns, attributes):
+ self._oprot.writeMessageBegin('scannerOpenWithPrefix', TMessageType.CALL, self._seqid)
+ args = scannerOpenWithPrefix_args()
+ args.tableName = tableName
+ args.startAndPrefix = startAndPrefix
+ args.columns = columns
+ args.attributes = attributes
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_scannerOpenWithPrefix(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = scannerOpenWithPrefix_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, "scannerOpenWithPrefix failed: unknown result");
+
+ def scannerOpenTs(self, tableName, startRow, columns, timestamp, attributes):
+ """
+ Get a scanner on the current table starting at the specified row and
+ ending at the last row in the table. Return the specified columns.
+ Only values with the specified timestamp are returned.
+
+ @return scanner id to be used with other scanner procedures
+
+ Parameters:
+ - tableName: name of table
+ - startRow: Starting row in table to scan.
+ Send "" (empty string) to start at the first row.
+ - columns: columns to scan. If column name is a column family, all
+ columns of the specified column family are returned. It's also possible
+ to pass a regex in the column qualifier.
+ - timestamp: timestamp
+ - attributes: Scan attributes
+ """
+ self.send_scannerOpenTs(tableName, startRow, columns, timestamp, attributes)
+ return self.recv_scannerOpenTs()
+
+ def send_scannerOpenTs(self, tableName, startRow, columns, timestamp, attributes):
+ self._oprot.writeMessageBegin('scannerOpenTs', TMessageType.CALL, self._seqid)
+ args = scannerOpenTs_args()
+ args.tableName = tableName
+ args.startRow = startRow
+ args.columns = columns
+ args.timestamp = timestamp
+ args.attributes = attributes
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result");
+
+ def scannerOpenWithStopTs(self, tableName, startRow, stopRow, columns, timestamp, attributes):
+ """
+ Get a scanner on the current table starting and stopping at the
+ specified rows. ending at the last row in the table. Return the
+ specified columns. Only values with the specified timestamp are
+ returned.
+
+ @return scanner id to be used with other scanner procedures
+
+ Parameters:
+ - tableName: name of table
+ - startRow: Starting row in table to scan.
+ Send "" (empty string) to start at the first row.
+ - stopRow: row to stop scanning on. This row is *not* included in the
+ scanner's results
+ - columns: columns to scan. If column name is a column family, all
+ columns of the specified column family are returned. It's also possible
+ to pass a regex in the column qualifier.
+ - timestamp: timestamp
+ - attributes: Scan attributes
+ """
+ self.send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp, attributes)
+ return self.recv_scannerOpenWithStopTs()
+
+ def send_scannerOpenWithStopTs(self, tableName, startRow, stopRow, columns, timestamp, attributes):
+ 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.attributes = attributes
+ 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 is not None:
+ return result.success
+ if result.io is not None:
+ raise result.io
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
+
+ def scannerGet(self, id):
+ """
+ Returns the scanner's current row value and advances to the next
+ row in the table. When there are no more rows in the table, or a key
+ greater-than-or-equal-to the scanner's specified stopRow is reached,
+ an empty list is returned.
+
+ @return a TRowResult containing the current row and a map of the columns to TCells.
+
+ @throws IllegalArgument if ScannerID is invalid
+
+ @throws NotFound when the scanner reaches the end
+
+ Parameters:
+ - id: id of a scanner returned by scannerOpen
+ """
+ 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 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, "scannerGet failed: unknown result");
+
+ def scannerGetList(self, id, nbRows):
+ """
+ Returns, starting at the scanner's current row value nbRows worth of
+ rows and advances to the next row in the table. When there are no more
+ rows in the table, or a key greater-than-or-equal-to the scanner's
+ specified stopRow is reached, an empty list is returned.
+
+ @return a TRowResult containing the current row and a map of the columns to TCells.
+
+ @throws IllegalArgument if ScannerID is invalid
+
+ @throws NotFound when the scanner reaches the end
+
+ Parameters:
+ - id: id of a scanner returned by scannerOpen
+ - nbRows: number of results to return
+ """
+ self.send_scannerGetList(id, nbRows)
+ return self.recv_scannerGetList()
+
+ def send_scannerGetList(self, id, nbRows):
+ self._oprot.writeMessageBegin('scannerGetList', TMessageType.CALL, self._seqid)
+ args = scannerGetList_args()
+ args.id = id
+ args.nbRows = nbRows
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_scannerGetList(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = scannerGetList_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, "scannerGetList failed: unknown result");
+
+ def scannerClose(self, id):
+ """
+ Closes the server-state associated with an open scanner.
+
+ @throws IllegalArgument if ScannerID is invalid
+
+ Parameters:
+ - id: id of a scanner returned by scannerOpen
+ """
+ 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 is not None:
+ raise result.io
+ if result.ia is not None:
+ raise result.ia
+ return
+
+ def getRowOrBefore(self, tableName, row, family):
+ """
+ Get the row just before the specified one.
+
+ @return value for specified row/column
+
+ Parameters:
+ - tableName: name of table
+ - row: row key
+ - family: column name
+ """
+ self.send_getRowOrBefore(tableName, row, family)
+ return self.recv_getRowOrBefore()
+
+ def send_getRowOrBefore(self, tableName, row, family):
+ self._oprot.writeMessageBegin('getRowOrBefore', TMessageType.CALL, self._seqid)
+ args = getRowOrBefore_args()
+ args.tableName = tableName
+ args.row = row
+ args.family = family
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_getRowOrBefore(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = getRowOrBefore_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, "getRowOrBefore failed: unknown result");
+
+ def getRegionInfo(self, row):
+ """
+ Get the regininfo for the specified row. It scans
+ the metatable to find region's start and end keys.
+
+ @return value for specified row/column
+
+ Parameters:
+ - row: row key
+ """
+ self.send_getRegionInfo(row)
+ return self.recv_getRegionInfo()
+
+ def send_getRegionInfo(self, row):
+ self._oprot.writeMessageBegin('getRegionInfo', TMessageType.CALL, self._seqid)
+ args = getRegionInfo_args()
+ args.row = row
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_getRegionInfo(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = getRegionInfo_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, "getRegionInfo failed: unknown result");
+
+
+class Processor(Iface, TProcessor):
+ def __init__(self, handler):
+ self._handler = handler
+ self._processMap = {}
+ self._processMap["enableTable"] = Processor.process_enableTable
+ self._processMap["disableTable"] = Processor.process_disableTable
+ self._processMap["isTableEnabled"] = Processor.process_isTableEnabled
+ self._processMap["compact"] = Processor.process_compact
+ self._processMap["majorCompact"] = Processor.process_majorCompact
+ 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["getRowWithColumns"] = Processor.process_getRowWithColumns
+ self._processMap["getRowTs"] = Processor.process_getRowTs
+ self._processMap["getRowWithColumnsTs"] = Processor.process_getRowWithColumnsTs
+ self._processMap["getRows"] = Processor.process_getRows
+ self._processMap["getRowsWithColumns"] = Processor.process_getRowsWithColumns
+ self._processMap["getRowsTs"] = Processor.process_getRowsTs
+ self._processMap["getRowsWithColumnsTs"] = Processor.process_getRowsWithColumnsTs
+ 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["atomicIncrement"] = Processor.process_atomicIncrement
+ self._processMap["deleteAll"] = Processor.process_deleteAll
+ self._processMap["deleteAllTs"] = Processor.process_deleteAllTs
+ self._processMap["deleteAllRow"] = Processor.process_deleteAllRow
+ self._processMap["increment"] = Processor.process_increment
+ self._processMap["incrementRows"] = Processor.process_incrementRows
+ self._processMap["deleteAllRowTs"] = Processor.process_deleteAllRowTs
+ self._processMap["scannerOpenWithScan"] = Processor.process_scannerOpenWithScan
+ self._processMap["scannerOpen"] = Processor.process_scannerOpen
+ self._processMap["scannerOpenWithStop"] = Processor.process_scannerOpenWithStop
+ self._processMap["scannerOpenWithPrefix"] = Processor.process_scannerOpenWithPrefix
+ self._processMap["scannerOpenTs"] = Processor.process_scannerOpenTs
+ self._processMap["scannerOpenWithStopTs"] = Processor.process_scannerOpenWithStopTs
+ self._processMap["scannerGet"] = Processor.process_scannerGet
+ self._processMap["scannerGetList"] = Processor.process_scannerGetList
+ self._processMap["scannerClose"] = Processor.process_scannerClose
+ self._processMap["getRowOrBefore"] = Processor.process_getRowOrBefore
+ self._processMap["getRegionInfo"] = Processor.process_getRegionInfo
+
+ 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_enableTable(self, seqid, iprot, oprot):
+ args = enableTable_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = enableTable_result()
+ try:
+ self._handler.enableTable(args.tableName)
+ except IOError as io:
+ result.io = io
+ oprot.writeMessageBegin("enableTable", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_disableTable(self, seqid, iprot, oprot):
+ args = disableTable_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = disableTable_result()
+ try:
+ self._handler.disableTable(args.tableName)
+ except IOError as io:
+ result.io = io
+ oprot.writeMessageBegin("disableTable", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_isTableEnabled(self, seqid, iprot, oprot):
+ args = isTableEnabled_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = isTableEnabled_result()
+ try:
+ result.success = self._handler.isTableEnabled(args.tableName)
+ except IOError as io:
+ result.io = io
+ oprot.writeMessageBegin("isTableEnabled", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_compact(self, seqid, iprot, oprot):
+ args = compact_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = compact_result()
+ try:
+ self._handler.compact(args.tableNameOrRegionName)
+ except IOError as io:
+ result.io = io
+ oprot.writeMessageBegin("compact", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_majorCompact(self, seqid, iprot, oprot):
+ args = majorCompact_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = majorCompact_result()
+ try:
+ self._handler.majorCompact(args.tableNameOrRegionName)
+ except IOError as io:
+ result.io = io
+ oprot.writeMessageBegin("majorCompact", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ 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 as 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 as 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 as 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 as io:
+ result.io = io
+ except IllegalArgument as ia:
+ result.ia = ia
+ except AlreadyExists as 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 as io:
+ result.io = io
+ 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, args.attributes)
+ except IOError as io:
+ result.io = io
+ 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, args.attributes)
+ except IOError as io:
+ result.io = io
+ 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, args.attributes)
+ except IOError as io:
+ result.io = io
+ 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, args.attributes)
+ except IOError as io:
+ result.io = io
+ oprot.writeMessageBegin("getRow", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_getRowWithColumns(self, seqid, iprot, oprot):
+ args = getRowWithColumns_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = getRowWithColumns_result()
+ try:
+ result.success = self._handler.getRowWithColumns(args.tableName, args.row, args.columns, args.attributes)
+ except IOError as io:
+ result.io = io
+ oprot.writeMessageBegin("getRowWithColumns", 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, args.attributes)
[... 7640 lines stripped ...]