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[] column, long amount)
           
 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)
           
 TCell ThriftServer.HBaseHandler.get(byte[] tableName, byte[] row, byte[] column)
           
 Map<byte[],ColumnDescriptor> ThriftServer.HBaseHandler.getColumnDescriptors(byte[] tableName)
           
 TRowResult ThriftServer.HBaseHandler.getRow(byte[] tableName, byte[] row)
           
 TRowResult ThriftServer.HBaseHandler.getRowTs(byte[] tableName, byte[] row, long timestamp)
           
 TRowResult ThriftServer.HBaseHandler.getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns)
           
 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[] column, int numVersions)
           
 List<TCell> ThriftServer.HBaseHandler.getVerTs(byte[] tableName, byte[] row, byte[] column, long timestamp, int numVersions)
           
 boolean ThriftServer.HBaseHandler.isTableEnabled(byte[] tableName)
           
 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)
           
 TRowResult ThriftServer.HBaseHandler.scannerGet(int id)
           
 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.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.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.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.scannerOpenTs_result.io
           
 IOError Hbase.scannerOpenWithStopTs_result.io
           
 IOError Hbase.scannerGet_result.io
           
 IOError Hbase.scannerClose_result.io
           
 

Methods in org.apache.hadoop.hbase.thrift.generated with parameters of type IOError
 boolean IOError.equals(IOError that)
           
 

Methods in org.apache.hadoop.hbase.thrift.generated that throw IOError
 long Hbase.Iface.atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value)
           
 long Hbase.Client.atomicIncrement(byte[] tableName, byte[] row, byte[] column, long value)
           
 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)
           
 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.
 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)
           
 TRowResult Hbase.Iface.getRow(byte[] tableName, byte[] row)
          Get all the data for the specified table and row at the latest timestamp.
 TRowResult Hbase.Client.getRow(byte[] tableName, byte[] row)
           
 TRowResult Hbase.Iface.getRowTs(byte[] tableName, byte[] row, long timestamp)
          Get all the data for the specified table and row at the specified timestamp.
 TRowResult Hbase.Client.getRowTs(byte[] tableName, byte[] row, long timestamp)
           
 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.
 TRowResult Hbase.Client.getRowWithColumns(byte[] tableName, byte[] row, List<byte[]> columns)
           
 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.
 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.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_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()
           
 TCell Hbase.Client.recv_get()
           
 Map<byte[],ColumnDescriptor> Hbase.Client.recv_getColumnDescriptors()
           
 TRowResult Hbase.Client.recv_getRow()
           
 TRowResult Hbase.Client.recv_getRowTs()
           
 TRowResult Hbase.Client.recv_getRowWithColumns()
           
 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_mutateRow()
           
 void Hbase.Client.recv_mutateRows()
           
 void Hbase.Client.recv_mutateRowsTs()
           
 void Hbase.Client.recv_mutateRowTs()
           
 void Hbase.Client.recv_scannerClose()
           
 TRowResult Hbase.Client.recv_scannerGet()
           
 int Hbase.Client.recv_scannerOpen()
           
 int Hbase.Client.recv_scannerOpenTs()
           
 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)
           
 TRowResult Hbase.Iface.scannerGet(int id)
          Returns the scanner's current row value and advances to the next row in the table.
 TRowResult Hbase.Client.scannerGet(int id)
           
 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.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.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, NotFound nf)
           
Hbase.disableTable_result(IOError io)
           
Hbase.enableTable_result(IOError io)
           
Hbase.get_result(TCell success, IOError io, NotFound nf)
           
Hbase.getColumnDescriptors_result(Map<byte[],ColumnDescriptor> success, IOError io)
           
Hbase.getRow_result(TRowResult success, IOError io, NotFound nf)
           
Hbase.getRowTs_result(TRowResult success, IOError io, NotFound nf)
           
Hbase.getRowWithColumns_result(TRowResult success, IOError io, NotFound nf)
           
Hbase.getRowWithColumnsTs_result(TRowResult success, IOError io, NotFound nf)
           
Hbase.getTableNames_result(List<byte[]> success, IOError io)
           
Hbase.getTableRegions_result(List<TRegionInfo> success, IOError io)
           
Hbase.getVer_result(List<TCell> success, IOError io, NotFound nf)
           
Hbase.getVerTs_result(List<TCell> success, IOError io, NotFound nf)
           
Hbase.isTableEnabled_result(boolean success, 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(TRowResult success, IOError io, IllegalArgument ia, NotFound nf)
           
Hbase.scannerOpen_result(int success, IOError io)
           
Hbase.scannerOpenTs_result(int success, IOError io)
           
Hbase.scannerOpenWithStop_result(int success, IOError io)
           
Hbase.scannerOpenWithStopTs_result(int success, IOError io)
           
 



Copyright © 2008 The Apache Software Foundation