Table (MapR DB Client 5.0.9-mapr API)

All Superinterfaces:

AutoCloseable

All Known Implementing Classes:

MapRDBTableImpl
```
@API.Public
public interface Table
extends AutoCloseable
```

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Table.TableOption` Following are different table options: `EXCLUDEID`: If this option is set to true then rowkey (field "_id") won't be returned in the result of a find or findById operation.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`checkAndDelete(ByteBuffer id, Condition condition)`
`boolean`	`checkAndDelete(String id, Condition condition)` Atomically evaluates the condition on given row and if the condition holds true for the row then it is atomically deleted.
`boolean`	`checkAndMutate(ByteBuffer id, Condition condition, Mutation m)`
`boolean`	`checkAndMutate(String id, Condition condition, Mutation m)` Atomically evaluates the condition on a given row and if the condition holds true for the row then a mutation is applied on the row.
`boolean`	`checkAndReplace(ByteBuffer id, Condition condition, org.ojai.Document r)`
`boolean`	`checkAndReplace(String id, Condition condition, org.ojai.Document r)` Atomically evaluates the condition on the given row and if the condition holds true for the row then it atomically replaces the row with the given document.
`void`	`close()` Override `AutoCloseable.close()` to avoid declaring a checked exception.
`void`	`delete(ByteBuffer id)`
`void`	`delete(org.ojai.Document r)`
`void`	`delete(org.ojai.Document r, org.ojai.FieldPath fieldAsKey)`
`void`	`delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs)` Deletes a set of documents from the table represented by the document stream.
`void`	`delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs, org.ojai.FieldPath fieldAsKey)`
`void`	`delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs, String fieldAsKey)`
`void`	`delete(org.ojai.Document r, String fieldAsKey)`
`void`	`delete(String id)` Deletes a row with the given rowkey.
`org.ojai.DocumentStream<DBDocument>`	`find()` Returns a document stream for all the rows in the table.
`org.ojai.DocumentStream<DBDocument>`	`find(Condition c)` Returns a document stream for all the rows in the table that match the condition.
`org.ojai.DocumentStream<DBDocument>`	`find(Condition c, org.ojai.FieldPath... paths)`
`org.ojai.DocumentStream<DBDocument>`	`find(Condition c, String... paths)` Returns a document reader for all the rows in the table that match the condition.
`org.ojai.DocumentStream<DBDocument>`	`find(org.ojai.FieldPath... paths)`
`org.ojai.DocumentStream<DBDocument>`	`find(String... paths)` Returns a document stream for all the rows in the table.
`DBDocument`	`findById(ByteBuffer id)`
`DBDocument`	`findById(ByteBuffer id, Condition c)`
`DBDocument`	`findById(ByteBuffer id, Condition c, org.ojai.FieldPath... paths)`
`DBDocument`	`findById(ByteBuffer id, Condition c, String... paths)`
`DBDocument`	`findById(ByteBuffer id, org.ojai.FieldPath... paths)`
`DBDocument`	`findById(ByteBuffer id, String... paths)`
`void`	`findById(OpListener listener, ByteBuffer id)`
`void`	`findById(OpListener listener, ByteBuffer id, Condition c)`
`void`	`findById(OpListener listener, ByteBuffer id, Condition c, org.ojai.FieldPath... paths)`
`void`	`findById(OpListener listener, ByteBuffer id, Condition c, String... paths)`
`void`	`findById(OpListener listener, ByteBuffer id, org.ojai.FieldPath... paths)`
`void`	`findById(OpListener listener, ByteBuffer id, String... paths)`
`void`	`findById(OpListener listener, String id)` Non-blocking read operation that gets called back on the listener object on success (with the document) or failure (with the error).
`void`	`findById(OpListener listener, String id, Condition c)` Non-blocking read operation that gets called back on the listener object on success or failure.
`void`	`findById(OpListener listener, String id, Condition c, org.ojai.FieldPath... paths)`
`void`	`findById(OpListener listener, String id, Condition c, String... paths)`
`void`	`findById(OpListener listener, String id, org.ojai.FieldPath... paths)`
`void`	`findById(OpListener listener, String id, String... paths)` Non-blocking read operation which gets called back on the listener object on success or failure.
`DBDocument`	`findById(String id)` Reads the entire document for a given key.
`DBDocument`	`findById(String id, Condition c)` Reads the row parts that match the condition and projects only the field paths requested.
`DBDocument`	`findById(String id, Condition c, org.ojai.FieldPath... paths)`
`DBDocument`	`findById(String id, Condition c, String... paths)`
`DBDocument`	`findById(String id, org.ojai.FieldPath... paths)`
`DBDocument`	`findById(String id, String... paths)` Reads the row and projects of only the field paths requested.
`DBDocument`	`findById(org.ojai.Value id)`
`void`	`flush()` Flushes all the buffered update operations on the client for this table.
`String`	`getName()` Returns just the name of the table (not the full path).
`org.ojai.Value`	`getOption(Table.TableOption option)`
`org.apache.hadoop.fs.Path`	`getPath()` Returns the full path of the table.
`TableDescriptor`	`getTableDescriptor()`
`TabletInfo`	`getTabletInfo(ByteBuffer _id)`
`TabletInfo`	`getTabletInfo(String _id)`
`TabletInfo[]`	`getTabletInfos()`
`TabletInfo[]`	`getTabletInfos(Condition c)`
`void`	`increment(ByteBuffer id, String field, BigDecimal inc)`
`void`	`increment(ByteBuffer id, String field, byte inc)`
`void`	`increment(ByteBuffer id, String field, double inc)`
`void`	`increment(ByteBuffer id, String field, float inc)`
`void`	`increment(ByteBuffer id, String field, int inc)`
`void`	`increment(ByteBuffer id, String field, long inc)`
`void`	`increment(ByteBuffer id, String field, short inc)`
`void`	`increment(String id, String field, BigDecimal inc)`
`void`	`increment(String id, String field, byte inc)` Atomically applies an increment to a given field (in dot separated notation) of the given row id.
`void`	`increment(String id, String field, double inc)`
`void`	`increment(String id, String field, float inc)`
`void`	`increment(String id, String field, int inc)`
`void`	`increment(String id, String field, long inc)`
`void`	`increment(String id, String field, short inc)`
`void`	`insert(ByteBuffer id, org.ojai.Document r)`
`void`	`insert(org.ojai.Document r)`
`void`	`insert(org.ojai.Document r, org.ojai.FieldPath fieldAsKey)`
`void`	`insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs)` Inserts a set of documents represented by the document stream into the table.
`void`	`insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs, org.ojai.FieldPath fieldAsKey)`
`void`	`insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs, String fieldAsKey)`
`void`	`insert(org.ojai.Document r, String fieldAsKey)`
`void`	`insert(String id, org.ojai.Document r)` Inserts a row with the given rowkey.
`void`	`insertOrReplace(ByteBuffer id, org.ojai.Document r)`
`void`	`insertOrReplace(org.ojai.Document r)` Inserts a new document in the table.
`void`	`insertOrReplace(org.ojai.Document r, org.ojai.FieldPath fieldAsKey)`
`void`	`insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs)` Inserts a set of documents represented by the document stream into the table.
`void`	`insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs, org.ojai.FieldPath fieldAsKey)`
`void`	`insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs, String fieldAsKey)`
`void`	`insertOrReplace(org.ojai.Document r, String fieldAsKey)`
`void`	`insertOrReplace(String id, org.ojai.Document r)`
`void`	`replace(ByteBuffer id, org.ojai.Document r)`
`void`	`replace(org.ojai.Document r)`
`void`	`replace(org.ojai.Document r, org.ojai.FieldPath fieldAsKey)`
`void`	`replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs)` Replaces a set of documents represented by the document stream into the table.
`void`	`replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs, org.ojai.FieldPath fieldAsKey)`
`void`	`replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs, String fieldAsKey)`
`void`	`replace(org.ojai.Document r, String fieldAsKey)`
`void`	`replace(String id, org.ojai.Document r)` Replaces a document in the table.
`Table`	`setOption(Table.TableOption option, boolean value)`
`void`	`update(ByteBuffer id, Mutation m)`
`void`	`update(String id, Mutation m)` Applies a row mutation on the row identified by the row id.

- Method Detail
  - getName
```
String getName()
```
    Returns just the name of the table (not the full path).
  - getPath
```
org.apache.hadoop.fs.Path getPath()
```
    Returns the full path of the table.
  - getTableDescriptor
```
TableDescriptor getTableDescriptor()
```
    Returns:
    The TableDescriptor for this table
  - setOption
```
Table setOption(Table.TableOption option,
              boolean value)
```
  - getOption
```
org.ojai.Value getOption(Table.TableOption option)
```
  - flush
```
void flush()
           throws DBException
```
    Flushes all the buffered update operations on the client for this table. Throws an exception if the flush failed or if the flush of any buffered operation resulted in an error.
    
    Throws:
    
    DBException
  - findById
```
DBDocument findById(String id)
                    throws DBException
```
    Reads the entire document for a given key. NULL is returned if the document with a given id doesn't exist in the table. Blocking operation. Throws DBException if there is an error in getting the document. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    Parameters:
    id - document id
    
    Returns:
    document object
    
    Throws:
    
    DBException
  - findById
```
DBDocument findById(ByteBuffer id)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
DBDocument findById(org.ojai.Value id)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
DBDocument findById(String id,
                  String... paths)
                    throws DBException
```
    Reads the row and projects of only the field paths requested. Blocking operation. NULL is returned if the document with given id doesn't exist in the table. Throws DBException if there is an error in getting the document. If no path parameter is specified then it returns a full document for a given row. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    Parameters:
    id - document id
    paths - list of fields that should be returned in the read document
    
    Returns:
    document object with the requested projection/conditions
    
    Throws:
    
    DBException
  - findById
```
DBDocument findById(String id,
                  org.ojai.FieldPath... paths)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
DBDocument findById(ByteBuffer id,
                  String... paths)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
DBDocument findById(ByteBuffer id,
                  org.ojai.FieldPath... paths)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
DBDocument findById(String id,
                  Condition c)
                    throws DBException
```
    Reads the row parts that match the condition and projects only the field paths requested. Blocking operation. If no path parameter is specified then it returns a full document for a given row. NULL is returned if the document with given id doesn't exist in the table. Throws DBException if there is an error in getting the document. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    Parameters:
    id - document id
    paths - list of fields that should be returned in the read document
    c - condition to check for the query
    
    Returns:
    document object with the requested projection/conditions
    
    Throws:
    
    DBException
  - findById
```
DBDocument findById(ByteBuffer id,
                  Condition c)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
DBDocument findById(String id,
                  Condition c,
                  String... paths)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
DBDocument findById(String id,
                  Condition c,
                  org.ojai.FieldPath... paths)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
DBDocument findById(ByteBuffer id,
                  Condition c,
                  String... paths)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
DBDocument findById(ByteBuffer id,
                  Condition c,
                  org.ojai.FieldPath... paths)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
void findById(OpListener listener,
            String id)
```
    Non-blocking read operation that gets called back on the listener object on success (with the document) or failure (with the error).
    
    Parameters:
    listener - object to be used as the callback
    id - document id
  - findById
```
void findById(OpListener listener,
            ByteBuffer id)
```
  - findById
```
void findById(OpListener listener,
            String id,
            String... paths)
```
    Non-blocking read operation which gets called back on the listener object on success or failure. Returns only the field paths requested. If no path parameter is specified then it returns a full document for a given row.
    
    Parameters:
    listener - object to be used as the callback
    id - document id
    paths - list of fields that should be returned in the read document
  - findById
```
void findById(OpListener listener,
            String id,
            org.ojai.FieldPath... paths)
```
  - findById
```
void findById(OpListener listener,
            ByteBuffer id,
            String... paths)
```
  - findById
```
void findById(OpListener listener,
            ByteBuffer id,
            org.ojai.FieldPath... paths)
```
  - findById
```
void findById(OpListener listener,
            String id,
            Condition c)
```
    Non-blocking read operation that gets called back on the listener object on success or failure. Returns only the row data only if the condition matches for the given row. Also, returns only the field paths requested in the document to listener. If no path parameter is specified then it returns a full document for a given row. Condition is used to specify additional criteria for reading the row. For example, I want to read from row with id as "abc" but only if the field "age" > 50. Then "age" > 50 is specified as condition.
    
    Parameters:
    listener - object to be used as the callback
    id - document id
    c - condition to check for the query
    paths - list of fields that should be returned in the read document
  - findById
```
void findById(OpListener listener,
            ByteBuffer id,
            Condition c)
```
  - findById
```
void findById(OpListener listener,
            String id,
            Condition c,
            String... paths)
```
  - findById
```
void findById(OpListener listener,
            String id,
            Condition c,
            org.ojai.FieldPath... paths)
```
  - findById
```
void findById(OpListener listener,
            ByteBuffer id,
            Condition c,
            String... paths)
```
  - findById
```
void findById(OpListener listener,
            ByteBuffer id,
            Condition c,
            org.ojai.FieldPath... paths)
```
  - find
```
org.ojai.DocumentStream<DBDocument> find()
                                         throws DBException
```
    Returns a document stream for all the rows in the table.
    
    Returns:
    document stream that can be used to retrieve each row in the table document stream must be closed after retrieving the documents
    
    Throws:
    
    DBException
  - find
```
org.ojai.DocumentStream<DBDocument> find(String... paths)
                                         throws DBException
```
    Returns a document stream for all the rows in the table. Each Document will contain only the paths that are specified in the argument. If a given field doesn't exist in the row or user doesn't have permissions to access that field then that field won't be returned in the read document. If no path parameter is specified then it returns a full document for a given row.
    
    Parameters:
    paths - list of fields that should be returned in the read document
    
    Returns:
    document stream that can be used to requested paths document stream must be closed after retrieving the documents
    
    Throws:
    
    DBException
  - find
```
org.ojai.DocumentStream<DBDocument> find(org.ojai.FieldPath... paths)
                                         throws DBException
```
    Throws:
    
    DBException
  - find
```
org.ojai.DocumentStream<DBDocument> find(Condition c)
                                         throws DBException
```
    Returns a document stream for all the rows in the table that match the condition.
    
    Parameters:
    c - condition to check for the query
    
    Returns:
    document stream that can be used to get rows document stream must be closed after retrieving the documents
    
    Throws:
    
    TableNotFoundException - when a table does not exist from which to get any row
    
    DBException
  - find
```
org.ojai.DocumentStream<DBDocument> find(Condition c,
                                       String... paths)
                                         throws DBException
```
    Returns a document reader for all the rows in the table that match the condition. Each Document will contain only the paths that are specified in the argument. If a given field doesn't exist in the row or the user doesn't have permissions to access that field then that field won't be returned in the read document. If no path parameter is specified then it returns full document for a given row.
    
    Parameters:
    c - condition to check for the query
    paths - list of fields that should be returned in the read document
    
    Returns:
    document stream that can be used to read docuemnts with requested paths. Document stream must be closed after retrieving the documents
    
    Throws:
    
    DBException
  - find
```
org.ojai.DocumentStream<DBDocument> find(Condition c,
                                       org.ojai.FieldPath... paths)
                                         throws DBException
```
    Throws:
    
    DBException
  - insertOrReplace
```
void insertOrReplace(org.ojai.Document r)
                     throws DBException
```
    Inserts a new document in the table. The document id is either explicitly specified as parameter "id" or it is implicitly specified as the field "_id" in the passed document. If the document id is explicitly passed then the document should not contain an "_id" field or its value should be same as the explicitly specified id. Otherwise the operation will fail. If the row with the given key exists on the server then that document will be overwritten by the new document. "fieldAsKey", when provided, will also be stored as the "_id" field in the written document for the row. If "_id" already existed in the document, then an error will be thrown. When reading the document back from the DB, the key will be returned back as usual as an "_id" field. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    Parameters:
    r - JSON document as the new value for the given row
    id - to be used as the key for the document
    fieldAsKey - document's field to be used as the key when an id is not passed in and the document doesn't have an "_id" field
    
    Throws:
    
    DBException
  - insertOrReplace
```
void insertOrReplace(String id,
                   org.ojai.Document r)
                     throws DBException
```
    Throws:
    
    DBException
  - insertOrReplace
```
void insertOrReplace(ByteBuffer id,
                   org.ojai.Document r)
                     throws DBException
```
    Throws:
    
    DBException
  - insertOrReplace
```
void insertOrReplace(org.ojai.Document r,
                   org.ojai.FieldPath fieldAsKey)
                     throws DBException
```
    Throws:
    
    DBException
  - insertOrReplace
```
void insertOrReplace(org.ojai.Document r,
                   String fieldAsKey)
                     throws DBException
```
    Throws:
    
    DBException
  - insertOrReplace
```
void insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs)
                     throws MultiOpException
```
    Inserts a set of documents represented by the document stream into the table. This is a synchronous API and it won't return until all the documents in the document stream are written to the table or some error occurs while writing the documents. Each document read from the document stream must have a field "_id" of type BINARY or UTF8-string; otherwise, the operation will fail. If there is an error in reading from the stream or in writing to the table then a MultiOpException will be thrown that contains a list of documents that failed to write to the table. Reading from a stream stops on the first read error. If only write errors occur, the iterator will stop and the rest of the documents will remain unconsumed. "fieldAsKey", when provided, will also be stored as the "_id" field in the written document for the row. If "_id" already existed in the document, then an error will be thrown. When reading the document back from the DB - the key will be returned back as usual as the "_id" field. If there is an error in reading from the stream or in writing to the table then a MultiOpException will be thrown that contains a list of documents that failed to write to the table. Reading from a stream stops on the first read error. If only write errors occur, the iterator will stop and the current list of failed document is returned in a multi op exception. The untouched documents will remain in the documentstream.
    
    Parameters:
    rs - document stream
    fieldAsKey - field from each document whose value is to be used as the document key for insertion
    
    Throws:
    
    MultiOpException - which has a list of write-failed documents and their errors.
  - insertOrReplace
```
void insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
                   org.ojai.FieldPath fieldAsKey)
                     throws MultiOpException
```
    Throws:
    
    MultiOpException
  - insertOrReplace
```
void insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
                   String fieldAsKey)
                     throws MultiOpException
```
    Throws:
    
    MultiOpException
  - update
```
void update(String id,
          Mutation m)
            throws DBException
```
    Applies a row mutation on the row identified by the row id. All the updates specified by the mutation object are applied atomically, meaning either all of the updates in mutation are applied or none of them is applied. For example, the mutation object specified an increment on field "address" by 5 and a set of field "zip" as "95134". If the "address" field on the server is not of the numeric type then the increment operation will fail. Because the set of field "zip" is also part of same mutation, that operation will also not be applied on the server. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    Parameters:
    id - document id
    m - mutation object specifying the operation on paths of a row
    
    Throws:
    
    DBException
  - update
```
void update(ByteBuffer id,
          Mutation m)
            throws DBException
```
    Throws:
    
    DBException
  - delete
```
void delete(String id)
            throws DBException
```
    Deletes a row with the given rowkey. This operation is successful even when the row with the given id doesn't exist. "fieldAsKey", when provided, will also be stored as the "_id" field in the written document for the row. If "_id" already existed in the document, then an error will be thrown. When reading the document back from the DB, the key will be returned back as usual as "_id" field. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    Parameters:
    id - document id
    r - JSON document to be deleted
    fieldAsKey - document's field to be used as the key when an id is not passed in and a document doesn't have an "_id" field
    
    Throws:
    
    DBException
  - delete
```
void delete(ByteBuffer id)
            throws DBException
```
    Throws:
    
    DBException
  - delete
```
void delete(org.ojai.Document r)
            throws DBException
```
    Throws:
    
    DBException
  - delete
```
void delete(org.ojai.Document r,
          org.ojai.FieldPath fieldAsKey)
            throws DBException
```
    Throws:
    
    DBException
  - delete
```
void delete(org.ojai.Document r,
          String fieldAsKey)
            throws DBException
```
    Throws:
    
    DBException
  - delete
```
void delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs)
            throws MultiOpException
```
    Deletes a set of documents from the table represented by the document stream. This is a synchronous API and it won't return until all the documents in the document stream are written to the table or some error occurs while writing the documents. Each document read from the document stream must have a field "_id" of type BINARY or UTF8-string; otherwise the operation will fail. If there is an error in reading from the stream or in writing to the table then a MultiOpException will be thrown that contains a list of documents that failed to write to the table. Reading from a stream stops on the first read error. If only write errors occur, the iterator will stop and the current list of failed document is returned in a multi op exception. The untouched documents will remain in the documentstream.
    
    Parameters:
    rs - document stream
    fieldAsKey - a field from each document whose value is to be used as the document key for deletion
    
    Throws:
    
    MultiOpException - which has a list of write-failed documents and their errors
  - delete
```
void delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
          org.ojai.FieldPath fieldAsKey)
            throws MultiOpException
```
    Throws:
    
    MultiOpException
  - delete
```
void delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
          String fieldAsKey)
            throws MultiOpException
```
    Throws:
    
    MultiOpException
  - insert
```
void insert(String id,
          org.ojai.Document r)
            throws DBException
```
    Inserts a row with the given rowkey. This operation is successful even when the row with the given id doesn't exist. "fieldAsKey", when provided, will also be stored as the "_id" field in the written document for the row. If "_id" already existed in the document, then an error will be thrown. When reading the document back from the DB, the key will be returned back as usual as the "_id" field. If the passed in id is not a direct byte buffer, there will be a copy to one. Note that an insertOrReplace() operation would be more efficient than an insert() call.
    
    Parameters:
    r - JSON document as the new value for the given row
    id - to be used as the key for the document
    fieldAsKey - document's field to be used as the key when the id is not passed in and document doesn't have an "_id" field
    
    Throws:
    
    TableNotFoundException - when a table does not exist to add this row
    
    AccessDeniedException - when user credentials are a mismatch
    
    ReadOnlyException - when a table is not accepting writes
    
    OpNotPermittedException - when the server returned EPERM
    
    DocumentExistsException - when a document with id already exists in table
    
    DBException
  - insert
```
void insert(ByteBuffer id,
          org.ojai.Document r)
            throws DBException
```
    Throws:
    
    DBException
  - insert
```
void insert(org.ojai.Document r)
            throws DBException
```
    Throws:
    
    DBException
  - insert
```
void insert(org.ojai.Document r,
          org.ojai.FieldPath fieldAsKey)
            throws DBException
```
    Throws:
    
    DBException
  - insert
```
void insert(org.ojai.Document r,
          String fieldAsKey)
            throws DBException
```
    Throws:
    
    DBException
  - insert
```
void insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs)
            throws MultiOpException
```
    Inserts a set of documents represented by the document stream into the table. This is a synchronous API that won't return until all the documents in the document stream are written to the table or some error occurs while writing the documents. Each document read from the document stream must have a field "_id" of type BINARY or UTF8-string; otherwise, the operation will fail or it will be of the DBDocument type. If a row with the given key exists on the server then it throws a document exists exception, similar to the non-documentstream-based insert() API. If there is an error in reading from the stream or in writing to the table then a MultiOpException will be thrown that contains a list of documents that failed to write to the table. Reading from a stream stops on the first read error. If only write errors occur, the iterator will stop and the current list of failed document is returned in a multi op exception. The untouched documents will remain in the documentstream.
    
    Parameters:
    rs - document stream
    fieldAsKey - a field from each document whose value is to be used as the document key for deletion
    
    Throws:
    
    MultiOpException - which has a list of write-failed documents and their errors
  - insert
```
void insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
          org.ojai.FieldPath fieldAsKey)
            throws MultiOpException
```
    Throws:
    
    MultiOpException
  - insert
```
void insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
          String fieldAsKey)
            throws MultiOpException
```
    Throws:
    
    MultiOpException
  - replace
```
void replace(String id,
           org.ojai.Document r)
             throws DBException
```
    Replaces a document in the table. The document id is either explicitly specified as parameter "id" or it is implicitly specified as the field "_id" in the passed document. If the document id is explicitly passed then the document should not contain "_id" field or its value should be the same as the explicitly specified id; otherwise, the operation will fail. If the row with the given key does not exist on the server then it will throw DocumentNotFoundException. "fieldAsKey", when provided, will also be stored as the "_id" field in the written document for the row. If "_id" already existed in the document, then an error will be thrown. When reading the document back from the DB, the key would be returned back as usual as "_id" field. If the passed in id is not a direct byte buffer, there will be a copy to one. Note that an insertOrReplace() operation would be more efficient than an replace() call.
    
    Parameters:
    r - JSON document as the new value for the given row
    id - to be used as the key for the document
    fieldAsKey - document's field to be used as the key when an id is not passed in and document doesn't have an "_id" field
    
    Throws:
    
    TableNotFoundException - when a table does not exist to which to add this row
    
    AccessDeniedException - when user credentials are a mismatch
    
    ReadOnlyException - when a table is not accepting writes
    
    OpNotPermittedException - when the server returns EPERM
    
    DocumentNotFoundException - when a document with the id does not exist in table
    
    DBException
  - replace
```
void replace(ByteBuffer id,
           org.ojai.Document r)
             throws DBException
```
    Throws:
    
    DBException
  - replace
```
void replace(org.ojai.Document r)
             throws DBException
```
    Throws:
    
    DBException
  - replace
```
void replace(org.ojai.Document r,
           org.ojai.FieldPath fieldAsKey)
             throws DBException
```
    Throws:
    
    DBException
  - replace
```
void replace(org.ojai.Document r,
           String fieldAsKey)
             throws DBException
```
    Throws:
    
    DBException
  - replace
```
void replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs)
             throws MultiOpException
```
    Replaces a set of documents represented by the document stream into the table. This is a synchronous API and it won't return until all the documents in the document stream are written to the table or some error occurs while writing the documents. Each document read from the document stream must have a field "_id" of type BINARY or UTF8-string; otherwise, the operation will fail or it will be of DBDocument type. If the row with the given key does not exist on the server then it throws, a document not exists exception, similar to the non-documentstream based replace() API. If there is an error in reading from the stream or in writing to the table then a MultiOpException will be thrown that contains a list of documents that failed to write to the table. Reading from a stream stops on the first read error. If only write errors occur, the iterator will stop and the current list of failed document is returned in a multi op exception. The untouched documents will remain in the documentstream.
    
    Parameters:
    rs - document stream
    fieldAsKey - field from each document whose value is to be used as the document key for deletion
    
    Throws:
    
    MultiOpException - which has list of write-failed documents and their errors
  - replace
```
void replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
           org.ojai.FieldPath fieldAsKey)
             throws MultiOpException
```
    Throws:
    
    MultiOpException
  - replace
```
void replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
           String fieldAsKey)
             throws MultiOpException
```
    Throws:
    
    MultiOpException
  - increment
```
void increment(String id,
             String field,
             byte inc)
               throws DBException
```
    Atomically applies an increment to a given field (in dot separated notation) of the given row id. If the field doesn't exist on the server then it will be created with the type of the incremental value. The increment operation can be applied on any of the numeric types, such as byte, short, int, long, float, double, or decimal, of a field. The operation will fail if the increment is applied to a field that is of a non-numeric type. If an id doesn't exist, it gets created (similar to the insertOrReplace behavior). And it is created, with the value of 'inc' parameter. The same logic applies to intermittent paths in the path: they get created top to bottom. If the type is different than the field in the operation, it fails. The increment operation won't change the type of existing value stored in the given field for the row. The resultant value of the field will be truncated based on the original type of the field. For example, if a field 'score' is of type int and contains 60 and an increment of double '5.675' is applied, then the resultant value of the field will be 65 (65.675 will be truncated to 65). If the type to which the increment is applied is a byte, short, or int, then it needs to use long as the operation. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    Parameters:
    id - document id
    field - the field name in dot separated notation
    inc - increment to apply to a field. Can be positive or negative
    
    Throws:
    
    DBException
  - increment
```
void increment(ByteBuffer id,
             String field,
             byte inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(String id,
             String field,
             short inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(ByteBuffer id,
             String field,
             short inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(String id,
             String field,
             int inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(ByteBuffer id,
             String field,
             int inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(String id,
             String field,
             long inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(ByteBuffer id,
             String field,
             long inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(String id,
             String field,
             float inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(ByteBuffer id,
             String field,
             float inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(String id,
             String field,
             double inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(ByteBuffer id,
             String field,
             double inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(String id,
             String field,
             BigDecimal inc)
               throws DBException
```
    Throws:
    
    DBException
  - increment
```
void increment(ByteBuffer id,
             String field,
             BigDecimal inc)
               throws DBException
```
    Throws:
    
    DBException
  - checkAndMutate
```
boolean checkAndMutate(String id,
                     Condition condition,
                     Mutation m)
                       throws DBException
```
    Atomically evaluates the condition on a given row and if the condition holds true for the row then a mutation is applied on the row. If an id doesn't exist, the function returns false (no exception is thrown). If the mutation operation fails, it throws exception. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    Parameters:
    id - document id
    condition - the condition to evaluate on the row
    m - mutation to apply on the row
    
    Returns:
    True if the condition is true for the row; otherwise, false
    
    Throws:
    
    DBException - if the condition passes but the mutate fails
  - checkAndMutate
```
boolean checkAndMutate(ByteBuffer id,
                     Condition condition,
                     Mutation m)
                       throws DBException
```
    Throws:
    
    DBException
  - checkAndDelete
```
boolean checkAndDelete(String id,
                     Condition condition)
                       throws DBException
```
    Atomically evaluates the condition on given row and if the condition holds true for the row then it is atomically deleted. If id doesnt exist, returns false (no exception is thrown). If deletion operation fails, it throws exception. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    Parameters:
    id - document id
    condition - condition to evaluate on the row
    
    Returns:
    True if the condition is valid for the row, otherwise false.
    
    Throws:
    
    DBException - if the condition passes but the delete fails
  - checkAndDelete
```
boolean checkAndDelete(ByteBuffer id,
                     Condition condition)
                       throws DBException
```
    Throws:
    
    DBException
  - checkAndReplace
```
boolean checkAndReplace(String id,
                      Condition condition,
                      org.ojai.Document r)
                        throws DBException
```
    Atomically evaluates the condition on the given row and if the condition holds true for the row then it atomically replaces the row with the given document. If the id doesn't exist, the function returns false (no exception is thrown). If the replace operation fails, it throws an exception. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    Parameters:
    id - document id
    condition - the condition to evaluate on the row
    r - document to replace
    
    Returns:
    True if the condition is true for the row otherwise false
    
    Throws:
    
    DBException - if the condition passes but the replace fails
  - checkAndReplace
```
boolean checkAndReplace(ByteBuffer id,
                      Condition condition,
                      org.ojai.Document r)
                        throws DBException
```
    Throws:
    
    DBException
  - getTabletInfo
```
TabletInfo getTabletInfo(String _id)
                         throws DBException
```
    Parameters:
    _id - the document id for which the TabletInfo is required
    
    Returns:
    TabletInfo for the tablet of this table to which the specified key belongs
    
    Throws:
    
    DBException
  - getTabletInfo
```
TabletInfo getTabletInfo(ByteBuffer _id)
                         throws DBException
```
    Parameters:
    _id - the document id for which the TabletInfo is required
    
    Returns:
    TabletInfo for the tablet of this table to which the specified key belongs
    
    Throws:
    
    DBException
  - getTabletInfos
```
TabletInfo[] getTabletInfos()
                            throws DBException
```
    Returns:
    TabletInfo for all current tablets of this table
    
    Throws:
    
    DBException
  - getTabletInfos
```
TabletInfo[] getTabletInfos(Condition c)
                            throws DBException
```
    Parameters:
    Condition - a condition object provided by the user or application
    
    Returns:
    TabletInfo for all current tablets of this table that has a start and end key matching the range specified by the condition object
    
    Throws:
    
    DBException
  - close
```
void close()
           throws DBException
```
    Override AutoCloseable.close() to avoid declaring a checked exception.
    
    Specified by:
    
    close in interface AutoCloseable
    
    Throws:
    
    DBException

Interface Table

Nested Class Summary

Method Summary

Method Detail

getName

getPath

getTableDescriptor

setOption

getOption

flush

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

find

find

find

find

find

find

insertOrReplace

insertOrReplace

insertOrReplace

insertOrReplace

insertOrReplace

insertOrReplace

insertOrReplace

insertOrReplace

update

update

delete

delete

delete

delete

delete

delete

delete

delete

insert

insert

insert

insert

insert

insert

insert

insert

replace

replace

replace

replace

replace

replace

replace

replace

increment

increment

increment

increment

increment