Uses of Class
org.apache.hadoop.hbase.thrift.generated.IOError

Packages that use IOError
org.apache.hadoop.hbase.thrift Provides an HBase Thrift service. 
org.apache.hadoop.hbase.thrift.generated   
 

Uses of IOError in org.apache.hadoop.hbase.thrift
 

Methods in org.apache.hadoop.hbase.thrift that throw IOError
 long ThriftServer.HBaseHandler.atomicIncrement(byte[] tableName, byte[] row, byte[] family, byte[] qualifier, long amount)
           
 long ThriftServer.HBaseHandler.atomicIncrement(byte[] tableName, byte[] row, byte[] column, long amount)
          Deprecated. 
 void ThriftServer.HBaseHandler.compact(byte[] tableNameOrRegionName)
           
 void ThriftServer.HBaseHandler.createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies)
           
 void ThriftServer.HBaseHandler.deleteAll(byte[] tableName, byte[] row, byte[] column)
           
 void ThriftServer.HBaseHandler.deleteAllRow(byte[] tableName, byte[] row)
           
 void ThriftServer.HBaseHandler.deleteAllRowTs(byte[] tableName, byte[] row, long timestamp)
           
 void ThriftServer.HBaseHandler.deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp)
           
 void ThriftServer.HBaseHandler.deleteTable(byte[] tableName)
           
 void ThriftServer.HBaseHandler.disableTable(byte[] tableName)
           
 void ThriftServer.HBaseHandler.enableTable(byte[] tableName)
           
 List<TCell> ThriftServer.HBaseHandler.get(byte[] tableName, byte[] row, byte[] column)
          Deprecated. 
 List<TCell> ThriftServer.HBaseHandler.get(byte[] tableName, byte[] row, byte[] family, byte[] qualifier)
           
 Map<byte[],ColumnDescriptor> ThriftServer.HBaseHandler.getColumnDescriptors(byte[] tableName)
           
 List<TRowResult> ThriftServer.HBaseHandler.getRow(byte[] tableName, byte[] row)
           
 List<TRowResult> ThriftServer.HBaseHandler.getRows(byte[] tableName, List<byte[]> rows)
           
 List<TRowResult> ThriftServer.HBaseHandler.getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp)
           
 List<TRowResult> ThriftServer.HBaseHandler.getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns)
           
 List<TRowResult> ThriftServer.HBaseHandler.getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp)
           
 List<TRowResult> ThriftServer.HBaseHandler.getRowTs(byte[] tableName, byte[] row, long timestamp)
           
 List<TRowResult> ThriftServer.HBaseHandler.getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns)
           
 List<TRowResult> ThriftServer.HBaseHandler.getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp)
           
protected  HTable ThriftServer.HBaseHandler.getTable(byte[] tableName)
          Creates and returns an HTable instance from a given table name.
 List<byte[]> ThriftServer.HBaseHandler.getTableNames()
           
 List<TRegionInfo> ThriftServer.HBaseHandler.getTableRegions(byte[] tableName)
           
 List<TCell> ThriftServer.HBaseHandler.getVer(byte[] tableName, byte[] row, byte[] family, byte[] qualifier, int numVersions)
           
 List<TCell> ThriftServer.HBaseHandler.getVer(byte[] tableName, byte[] row, byte[] column, int numVersions)
          Deprecated. 
 List<TCell> ThriftServer.HBaseHandler.getVerTs(byte[] tableName, byte[] row, byte[] family, byte[] qualifier, long timestamp, int numVersions)
           
 List<TCell> ThriftServer.HBaseHandler.getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions)
          Deprecated. 
 boolean ThriftServer.HBaseHandler.isTableEnabled(byte[] tableName)
           
 void ThriftServer.HBaseHandler.majorCompact(byte[] tableNameOrRegionName)
           
 void ThriftServer.HBaseHandler.mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations)
           
 void ThriftServer.HBaseHandler.mutateRows(byte[] tableName, List<BatchMutation> rowBatches)
           
 void ThriftServer.HBaseHandler.mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp)
           
 void ThriftServer.HBaseHandler.mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp)
           
 void ThriftServer.HBaseHandler.scannerClose(int id)
           
 List<TRowResult> ThriftServer.HBaseHandler.scannerGet(int id)
           
 List<TRowResult> ThriftServer.HBaseHandler.scannerGetList(int id, int nbRows)
           
 int ThriftServer.HBaseHandler.scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns)
           
 int ThriftServer.HBaseHandler.scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp)
           
 int ThriftServer.HBaseHandler.scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns)
           
 int ThriftServer.HBaseHandler.scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns)
           
 int ThriftServer.HBaseHandler.scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp)
           
 

Uses of IOError in org.apache.hadoop.hbase.thrift.generated
 

Fields in org.apache.hadoop.hbase.thrift.generated declared as IOError
 IOError Hbase.enableTable_result.io
           
 IOError Hbase.disableTable_result.io
           
 IOError Hbase.isTableEnabled_result.io
           
 IOError Hbase.compact_result.io
           
 IOError Hbase.majorCompact_result.io
           
 IOError Hbase.getTableNames_result.io
           
 IOError Hbase.getColumnDescriptors_result.io
           
 IOError Hbase.getTableRegions_result.io
           
 IOError Hbase.createTable_result.io
           
 IOError Hbase.deleteTable_result.io
           
 IOError Hbase.get_result.io
           
 IOError Hbase.getVer_result.io
           
 IOError Hbase.getVerTs_result.io
           
 IOError Hbase.getRow_result.io
           
 IOError Hbase.getRowWithColumns_result.io
           
 IOError Hbase.getRowTs_result.io
           
 IOError Hbase.getRowWithColumnsTs_result.io
           
 IOError Hbase.getRows_result.io
           
 IOError Hbase.getRowsWithColumns_result.io
           
 IOError Hbase.getRowsTs_result.io
           
 IOError Hbase.getRowsWithColumnsTs_result.io
           
 IOError Hbase.mutateRow_result.io
           
 IOError Hbase.mutateRowTs_result.io
           
 IOError Hbase.mutateRows_result.io
           
 IOError Hbase.mutateRowsTs_result.io
           
 IOError Hbase.atomicIncrement_result.io
           
 IOError Hbase.deleteAll_result.io
           
 IOError Hbase.deleteAllTs_result.io
           
 IOError Hbase.deleteAllRow_result.io
           
 IOError Hbase.deleteAllRowTs_result.io
           
 IOError Hbase.scannerOpen_result.io
           
 IOError Hbase.scannerOpenWithStop_result.io
           
 IOError Hbase.scannerOpenWithPrefix_result.io
           
 IOError Hbase.scannerOpenTs_result.io
           
 IOError Hbase.scannerOpenWithStopTs_result.io
           
 IOError Hbase.scannerGet_result.io
           
 IOError Hbase.scannerGetList_result.io
           
 IOError Hbase.scannerClose_result.io
           
 

Methods in org.apache.hadoop.hbase.thrift.generated that return IOError
 IOError IOError.clone()
          Deprecated. 
 IOError IOError.deepCopy()
           
 IOError Hbase.enableTable_result.getIo()
           
 IOError Hbase.disableTable_result.getIo()
           
 IOError Hbase.isTableEnabled_result.getIo()
           
 IOError Hbase.compact_result.getIo()
           
 IOError Hbase.majorCompact_result.getIo()
           
 IOError Hbase.getTableNames_result.getIo()
           
 IOError Hbase.getColumnDescriptors_result.getIo()
           
 IOError Hbase.getTableRegions_result.getIo()
           
 IOError Hbase.createTable_result.getIo()
           
 IOError Hbase.deleteTable_result.getIo()
           
 IOError Hbase.get_result.getIo()
           
 IOError Hbase.getVer_result.getIo()
           
 IOError Hbase.getVerTs_result.getIo()
           
 IOError Hbase.getRow_result.getIo()
           
 IOError Hbase.getRowWithColumns_result.getIo()
           
 IOError Hbase.getRowTs_result.getIo()
           
 IOError Hbase.getRowWithColumnsTs_result.getIo()
           
 IOError Hbase.getRows_result.getIo()
           
 IOError Hbase.getRowsWithColumns_result.getIo()
           
 IOError Hbase.getRowsTs_result.getIo()
           
 IOError Hbase.getRowsWithColumnsTs_result.getIo()
           
 IOError Hbase.mutateRow_result.getIo()
           
 IOError Hbase.mutateRowTs_result.getIo()
           
 IOError Hbase.mutateRows_result.getIo()
           
 IOError Hbase.mutateRowsTs_result.getIo()
           
 IOError Hbase.atomicIncrement_result.getIo()
           
 IOError Hbase.deleteAll_result.getIo()
           
 IOError Hbase.deleteAllTs_result.getIo()
           
 IOError Hbase.deleteAllRow_result.getIo()
           
 IOError Hbase.deleteAllRowTs_result.getIo()
           
 IOError Hbase.scannerOpen_result.getIo()
           
 IOError Hbase.scannerOpenWithStop_result.getIo()
           
 IOError Hbase.scannerOpenWithPrefix_result.getIo()
           
 IOError Hbase.scannerOpenTs_result.getIo()
           
 IOError Hbase.scannerOpenWithStopTs_result.getIo()
           
 IOError Hbase.scannerGet_result.getIo()
           
 IOError Hbase.scannerGetList_result.getIo()
           
 IOError Hbase.scannerClose_result.getIo()
           
 IOError IOError.setMessage(String message)
           
 

Methods in org.apache.hadoop.hbase.thrift.generated with parameters of type IOError
 int IOError.compareTo(IOError other)
           
 boolean IOError.equals(IOError that)
           
 Hbase.enableTable_result Hbase.enableTable_result.setIo(IOError io)
           
 Hbase.disableTable_result Hbase.disableTable_result.setIo(IOError io)
           
 Hbase.isTableEnabled_result Hbase.isTableEnabled_result.setIo(IOError io)
           
 Hbase.compact_result Hbase.compact_result.setIo(IOError io)
           
 Hbase.majorCompact_result Hbase.majorCompact_result.setIo(IOError io)
           
 Hbase.getTableNames_result Hbase.getTableNames_result.setIo(IOError io)
           
 Hbase.getColumnDescriptors_result Hbase.getColumnDescriptors_result.setIo(IOError io)
           
 Hbase.getTableRegions_result Hbase.getTableRegions_result.setIo(IOError io)
           
 Hbase.createTable_result Hbase.createTable_result.setIo(IOError io)
           
 Hbase.deleteTable_result Hbase.deleteTable_result.setIo(IOError io)
           
 Hbase.get_result Hbase.get_result.setIo(IOError io)
           
 Hbase.getVer_result Hbase.getVer_result.setIo(IOError io)
           
 Hbase.getVerTs_result Hbase.getVerTs_result.setIo(IOError io)
           
 Hbase.getRow_result Hbase.getRow_result.setIo(IOError io)
           
 Hbase.getRowWithColumns_result Hbase.getRowWithColumns_result.setIo(IOError io)
           
 Hbase.getRowTs_result Hbase.getRowTs_result.setIo(IOError io)
           
 Hbase.getRowWithColumnsTs_result Hbase.getRowWithColumnsTs_result.setIo(IOError io)
           
 Hbase.getRows_result Hbase.getRows_result.setIo(IOError io)
           
 Hbase.getRowsWithColumns_result Hbase.getRowsWithColumns_result.setIo(IOError io)
           
 Hbase.getRowsTs_result Hbase.getRowsTs_result.setIo(IOError io)
           
 Hbase.getRowsWithColumnsTs_result Hbase.getRowsWithColumnsTs_result.setIo(IOError io)
           
 Hbase.mutateRow_result Hbase.mutateRow_result.setIo(IOError io)
           
 Hbase.mutateRowTs_result Hbase.mutateRowTs_result.setIo(IOError io)
           
 Hbase.mutateRows_result Hbase.mutateRows_result.setIo(IOError io)
           
 Hbase.mutateRowsTs_result Hbase.mutateRowsTs_result.setIo(IOError io)
           
 Hbase.atomicIncrement_result Hbase.atomicIncrement_result.setIo(IOError io)
           
 Hbase.deleteAll_result Hbase.deleteAll_result.setIo(IOError io)
           
 Hbase.deleteAllTs_result Hbase.deleteAllTs_result.setIo(IOError io)
           
 Hbase.deleteAllRow_result Hbase.deleteAllRow_result.setIo(IOError io)
           
 Hbase.deleteAllRowTs_result Hbase.deleteAllRowTs_result.setIo(IOError io)
           
 Hbase.scannerOpen_result Hbase.scannerOpen_result.setIo(IOError io)
           
 Hbase.scannerOpenWithStop_result Hbase.scannerOpenWithStop_result.setIo(IOError io)
           
 Hbase.scannerOpenWithPrefix_result Hbase.scannerOpenWithPrefix_result.setIo(IOError io)
           
 Hbase.scannerOpenTs_result Hbase.scannerOpenTs_result.setIo(IOError io)
           
 Hbase.scannerOpenWithStopTs_result Hbase.scannerOpenWithStopTs_result.setIo(IOError io)
           
 Hbase.scannerGet_result Hbase.scannerGet_result.setIo(IOError io)
           
 Hbase.scannerGetList_result Hbase.scannerGetList_result.setIo(IOError io)
           
 Hbase.scannerClose_result Hbase.scannerClose_result.setIo(IOError io)
           
 

Methods in org.apache.hadoop.hbase.thrift.generated that throw IOError
 long Hbase.Iface.atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value)
          Atomically increment the column value specified.
 long Hbase.Client.atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value)
           
 void Hbase.Iface.compact(byte[] tableNameOrRegionName)
           
 void Hbase.Client.compact(byte[] tableNameOrRegionName)
           
 void Hbase.Iface.createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies)
          Create a table with the specified column families.
 void Hbase.Client.createTable(byte[] tableName, List<ColumnDescriptor> columnFamilies)
           
 void Hbase.Iface.deleteAll(byte[] tableName, byte[] row, byte[] column)
          Delete all cells that match the passed row and column.
 void Hbase.Client.deleteAll(byte[] tableName, byte[] row, byte[] column)
           
 void Hbase.Iface.deleteAllRow(byte[] tableName, byte[] row)
          Completely delete the row's cells.
 void Hbase.Client.deleteAllRow(byte[] tableName, byte[] row)
           
 void Hbase.Iface.deleteAllRowTs(byte[] tableName, byte[] row, long timestamp)
          Completely delete the row's cells marked with a timestamp equal-to or older than the passed timestamp.
 void Hbase.Client.deleteAllRowTs(byte[] tableName, byte[] row, long timestamp)
           
 void Hbase.Iface.deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp)
          Delete all cells that match the passed row and column and whose timestamp is equal-to or older than the passed timestamp.
 void Hbase.Client.deleteAllTs(byte[] tableName, byte[] row, byte[] column, long timestamp)
           
 void Hbase.Iface.deleteTable(byte[] tableName)
          Deletes a table
 void Hbase.Client.deleteTable(byte[] tableName)
           
 void Hbase.Iface.disableTable(byte[] tableName)
          Disables a table (takes it off-line) If it is being served, the master will tell the servers to stop serving it.
 void Hbase.Client.disableTable(byte[] tableName)
           
 void Hbase.Iface.enableTable(byte[] tableName)
          Brings a table on-line (enables it)
 void Hbase.Client.enableTable(byte[] tableName)
           
 List<TCell> Hbase.Iface.get(byte[] tableName, byte[] row, byte[] column)
          Get a single TCell for the specified table, row, and column at the latest timestamp.
 List<TCell> Hbase.Client.get(byte[] tableName, byte[] row, byte[] column)
           
 Map<byte[],ColumnDescriptor> Hbase.Iface.getColumnDescriptors(byte[] tableName)
          List all the column families assoicated with a table.
 Map<byte[],ColumnDescriptor> Hbase.Client.getColumnDescriptors(byte[] tableName)
           
 List<TRowResult> Hbase.Iface.getRow(byte[] tableName, byte[] row)
          Get all the data for the specified table and row at the latest timestamp.
 List<TRowResult> Hbase.Client.getRow(byte[] tableName, byte[] row)
           
 List<TRowResult> Hbase.Iface.getRows(byte[] tableName, List<byte[]> rows)
          Get all the data for the specified table and rows at the latest timestamp.
 List<TRowResult> Hbase.Client.getRows(byte[] tableName, List<byte[]> rows)
           
 List<TRowResult> Hbase.Iface.getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp)
          Get all the data for the specified table and rows at the specified timestamp.
 List<TRowResult> Hbase.Client.getRowsTs(byte[] tableName, List<byte[]> rows, long timestamp)
           
 List<TRowResult> Hbase.Iface.getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns)
          Get the specified columns for the specified table and rows at the latest timestamp.
 List<TRowResult> Hbase.Client.getRowsWithColumns(byte[] tableName, List<byte[]> rows, List<byte[]> columns)
           
 List<TRowResult> Hbase.Iface.getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp)
          Get the specified columns for the specified table and rows at the specified timestamp.
 List<TRowResult> Hbase.Client.getRowsWithColumnsTs(byte[] tableName, List<byte[]> rows, List<byte[]> columns, long timestamp)
           
 List<TRowResult> Hbase.Iface.getRowTs(byte[] tableName, byte[] row, long timestamp)
          Get all the data for the specified table and row at the specified timestamp.
 List<TRowResult> Hbase.Client.getRowTs(byte[] tableName, byte[] row, long timestamp)
           
 List<TRowResult> Hbase.Iface.getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns)
          Get the specified columns for the specified table and row at the latest timestamp.
 List<TRowResult> Hbase.Client.getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns)
           
 List<TRowResult> Hbase.Iface.getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp)
          Get the specified columns for the specified table and row at the specified timestamp.
 List<TRowResult> Hbase.Client.getRowWithColumnsTs(byte[] tableName, byte[] row, List<byte[]> columns, long timestamp)
           
 List<byte[]> Hbase.Iface.getTableNames()
          List all the userspace tables.
 List<byte[]> Hbase.Client.getTableNames()
           
 List<TRegionInfo> Hbase.Iface.getTableRegions(byte[] tableName)
          List the regions associated with a table.
 List<TRegionInfo> Hbase.Client.getTableRegions(byte[] tableName)
           
 List<TCell> Hbase.Iface.getVer(byte[] tableName, byte[] row, byte[] column, int numVersions)
          Get the specified number of versions for the specified table, row, and column.
 List<TCell> Hbase.Client.getVer(byte[] tableName, byte[] row, byte[] column, int numVersions)
           
 List<TCell> Hbase.Iface.getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions)
          Get the specified number of versions for the specified table, row, and column.
 List<TCell> Hbase.Client.getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions)
           
 boolean Hbase.Iface.isTableEnabled(byte[] tableName)
           
 boolean Hbase.Client.isTableEnabled(byte[] tableName)
           
 void Hbase.Iface.majorCompact(byte[] tableNameOrRegionName)
           
 void Hbase.Client.majorCompact(byte[] tableNameOrRegionName)
           
 void Hbase.Iface.mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations)
          Apply a series of mutations (updates/deletes) to a row in a single transaction.
 void Hbase.Client.mutateRow(byte[] tableName, byte[] row, List<Mutation> mutations)
           
 void Hbase.Iface.mutateRows(byte[] tableName, List<BatchMutation> rowBatches)
          Apply a series of batches (each a series of mutations on a single row) in a single transaction.
 void Hbase.Client.mutateRows(byte[] tableName, List<BatchMutation> rowBatches)
           
 void Hbase.Iface.mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp)
          Apply a series of batches (each a series of mutations on a single row) in a single transaction.
 void Hbase.Client.mutateRowsTs(byte[] tableName, List<BatchMutation> rowBatches, long timestamp)
           
 void Hbase.Iface.mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp)
          Apply a series of mutations (updates/deletes) to a row in a single transaction.
 void Hbase.Client.mutateRowTs(byte[] tableName, byte[] row, List<Mutation> mutations, long timestamp)
           
 long Hbase.Client.recv_atomicIncrement()
           
 void Hbase.Client.recv_compact()
           
 void Hbase.Client.recv_createTable()
           
 void Hbase.Client.recv_deleteAll()
           
 void Hbase.Client.recv_deleteAllRow()
           
 void Hbase.Client.recv_deleteAllRowTs()
           
 void Hbase.Client.recv_deleteAllTs()
           
 void Hbase.Client.recv_deleteTable()
           
 void Hbase.Client.recv_disableTable()
           
 void Hbase.Client.recv_enableTable()
           
 List<TCell> Hbase.Client.recv_get()
           
 Map<byte[],ColumnDescriptor> Hbase.Client.recv_getColumnDescriptors()
           
 List<TRowResult> Hbase.Client.recv_getRow()
           
 List<TRowResult> Hbase.Client.recv_getRows()
           
 List<TRowResult> Hbase.Client.recv_getRowsTs()
           
 List<TRowResult> Hbase.Client.recv_getRowsWithColumns()
           
 List<TRowResult> Hbase.Client.recv_getRowsWithColumnsTs()
           
 List<TRowResult> Hbase.Client.recv_getRowTs()
           
 List<TRowResult> Hbase.Client.recv_getRowWithColumns()
           
 List<TRowResult> Hbase.Client.recv_getRowWithColumnsTs()
           
 List<byte[]> Hbase.Client.recv_getTableNames()
           
 List<TRegionInfo> Hbase.Client.recv_getTableRegions()
           
 List<TCell> Hbase.Client.recv_getVer()
           
 List<TCell> Hbase.Client.recv_getVerTs()
           
 boolean Hbase.Client.recv_isTableEnabled()
           
 void Hbase.Client.recv_majorCompact()
           
 void Hbase.Client.recv_mutateRow()
           
 void Hbase.Client.recv_mutateRows()
           
 void Hbase.Client.recv_mutateRowsTs()
           
 void Hbase.Client.recv_mutateRowTs()
           
 void Hbase.Client.recv_scannerClose()
           
 List<TRowResult> Hbase.Client.recv_scannerGet()
           
 List<TRowResult> Hbase.Client.recv_scannerGetList()
           
 int Hbase.Client.recv_scannerOpen()
           
 int Hbase.Client.recv_scannerOpenTs()
           
 int Hbase.Client.recv_scannerOpenWithPrefix()
           
 int Hbase.Client.recv_scannerOpenWithStop()
           
 int Hbase.Client.recv_scannerOpenWithStopTs()
           
 void Hbase.Iface.scannerClose(int id)
          Closes the server-state associated with an open scanner.
 void Hbase.Client.scannerClose(int id)
           
 List<TRowResult> Hbase.Iface.scannerGet(int id)
          Returns the scanner's current row value and advances to the next row in the table.
 List<TRowResult> Hbase.Client.scannerGet(int id)
           
 List<TRowResult> Hbase.Iface.scannerGetList(int id, int nbRows)
          Returns, starting at the scanner's current row value nbRows worth of rows and advances to the next row in the table.
 List<TRowResult> Hbase.Client.scannerGetList(int id, int nbRows)
           
 int Hbase.Iface.scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns)
          Get a scanner on the current table starting at the specified row and ending at the last row in the table.
 int Hbase.Client.scannerOpen(byte[] tableName, byte[] startRow, List<byte[]> columns)
           
 int Hbase.Iface.scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp)
          Get a scanner on the current table starting at the specified row and ending at the last row in the table.
 int Hbase.Client.scannerOpenTs(byte[] tableName, byte[] startRow, List<byte[]> columns, long timestamp)
           
 int Hbase.Iface.scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns)
          Open a scanner for a given prefix.
 int Hbase.Client.scannerOpenWithPrefix(byte[] tableName, byte[] startAndPrefix, List<byte[]> columns)
           
 int Hbase.Iface.scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns)
          Get a scanner on the current table starting and stopping at the specified rows.
 int Hbase.Client.scannerOpenWithStop(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns)
           
 int Hbase.Iface.scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp)
          Get a scanner on the current table starting and stopping at the specified rows.
 int Hbase.Client.scannerOpenWithStopTs(byte[] tableName, byte[] startRow, byte[] stopRow, List<byte[]> columns, long timestamp)
           
 

Constructors in org.apache.hadoop.hbase.thrift.generated with parameters of type IOError
Hbase.atomicIncrement_result(long success, IOError io, IllegalArgument ia)
           
Hbase.compact_result(IOError io)
           
Hbase.createTable_result(IOError io, IllegalArgument ia, AlreadyExists exist)
           
Hbase.deleteAll_result(IOError io)
           
Hbase.deleteAllRow_result(IOError io)
           
Hbase.deleteAllRowTs_result(IOError io)
           
Hbase.deleteAllTs_result(IOError io)
           
Hbase.deleteTable_result(IOError io)
           
Hbase.disableTable_result(IOError io)
           
Hbase.enableTable_result(IOError io)
           
Hbase.get_result(List<TCell> success, IOError io)
           
Hbase.getColumnDescriptors_result(Map<byte[],ColumnDescriptor> success, IOError io)
           
Hbase.getRow_result(List<TRowResult> success, IOError io)
           
Hbase.getRows_result(List<TRowResult> success, IOError io)
           
Hbase.getRowsTs_result(List<TRowResult> success, IOError io)
           
Hbase.getRowsWithColumns_result(List<TRowResult> success, IOError io)
           
Hbase.getRowsWithColumnsTs_result(List<TRowResult> success, IOError io)
           
Hbase.getRowTs_result(List<TRowResult> success, IOError io)
           
Hbase.getRowWithColumns_result(List<TRowResult> success, IOError io)
           
Hbase.getRowWithColumnsTs_result(List<TRowResult> success, IOError io)
           
Hbase.getTableNames_result(List<byte[]> success, IOError io)
           
Hbase.getTableRegions_result(List<TRegionInfo> success, IOError io)
           
Hbase.getVer_result(List<TCell> success, IOError io)
           
Hbase.getVerTs_result(List<TCell> success, IOError io)
           
Hbase.isTableEnabled_result(boolean success, IOError io)
           
Hbase.majorCompact_result(IOError io)
           
Hbase.mutateRow_result(IOError io, IllegalArgument ia)
           
Hbase.mutateRows_result(IOError io, IllegalArgument ia)
           
Hbase.mutateRowsTs_result(IOError io, IllegalArgument ia)
           
Hbase.mutateRowTs_result(IOError io, IllegalArgument ia)
           
Hbase.scannerClose_result(IOError io, IllegalArgument ia)
           
Hbase.scannerGet_result(List<TRowResult> success, IOError io, IllegalArgument ia)
           
Hbase.scannerGetList_result(List<TRowResult> success, IOError io, IllegalArgument ia)
           
Hbase.scannerOpen_result(int success, IOError io)
           
Hbase.scannerOpenTs_result(int success, IOError io)
           
Hbase.scannerOpenWithPrefix_result(int success, IOError io)
           
Hbase.scannerOpenWithStop_result(int success, IOError io)
           
Hbase.scannerOpenWithStopTs_result(int success, IOError io)
           
IOError(IOError other)
          Performs a deep copy on other.
 



Copyright © 2011 The Apache Software Foundation. All Rights Reserved.