Table (MapR DB Client 5.1.0-mapr API)

All Superinterfaces:: AutoCloseable, org.ojai.store.DocumentStore

@API.Public
public interface Table
extends org.ojai.store.DocumentStore

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, org.ojai.store.QueryCondition condition)`
`boolean`	`checkAndDelete(String id, org.ojai.store.QueryCondition 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, org.ojai.store.QueryCondition condition, org.ojai.store.DocumentMutation m)`
`boolean`	`checkAndMutate(String id, org.ojai.store.QueryCondition condition, org.ojai.store.DocumentMutation 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, org.ojai.store.QueryCondition condition, org.ojai.Document r)`
`boolean`	`checkAndReplace(String id, org.ojai.store.QueryCondition 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()` Overrides `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 rs)` Deletes a set of documents from the table represented by the DocumentStream.
`void`	`delete(org.ojai.DocumentStream rs, org.ojai.FieldPath fieldAsKey)`
`void`	`delete(org.ojai.DocumentStream 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`	`find()` Returns a DocumentStream for all the rows in the table.
`org.ojai.DocumentStream`	`find(org.ojai.FieldPath... paths)`
`org.ojai.DocumentStream`	`find(org.ojai.store.QueryCondition c)` Returns a DocumentStream for all the rows in the table that match the condition.
`org.ojai.DocumentStream`	`find(org.ojai.store.QueryCondition c, org.ojai.FieldPath... paths)`
`org.ojai.DocumentStream`	`find(org.ojai.store.QueryCondition c, String... paths)` Returns a document reader for all the rows in the table that match the condition.
`org.ojai.DocumentStream`	`find(String... paths)` Returns a DocumentStream for all the rows in the table.
`org.ojai.Document`	`findById(ByteBuffer id)`
`org.ojai.Document`	`findById(ByteBuffer id, org.ojai.FieldPath... paths)`
`org.ojai.Document`	`findById(ByteBuffer id, org.ojai.store.QueryCondition c)`
`org.ojai.Document`	`findById(ByteBuffer id, org.ojai.store.QueryCondition c, org.ojai.FieldPath... paths)`
`org.ojai.Document`	`findById(ByteBuffer id, org.ojai.store.QueryCondition c, String... paths)`
`org.ojai.Document`	`findById(ByteBuffer id, String... paths)`
`void`	`findById(org.ojai.store.OpListener listener, ByteBuffer id)`
`void`	`findById(org.ojai.store.OpListener listener, ByteBuffer id, org.ojai.FieldPath... paths)`
`void`	`findById(org.ojai.store.OpListener listener, ByteBuffer id, org.ojai.store.QueryCondition c)`
`void`	`findById(org.ojai.store.OpListener listener, ByteBuffer id, org.ojai.store.QueryCondition c, org.ojai.FieldPath... paths)`
`void`	`findById(org.ojai.store.OpListener listener, ByteBuffer id, org.ojai.store.QueryCondition c, String... paths)`
`void`	`findById(org.ojai.store.OpListener listener, ByteBuffer id, String... paths)`
`void`	`findById(org.ojai.store.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(org.ojai.store.OpListener listener, String id, org.ojai.FieldPath... paths)`
`void`	`findById(org.ojai.store.OpListener listener, String id, org.ojai.store.QueryCondition c)` Non-blocking read operation that gets called back on the listener object on success or failure.
`void`	`findById(org.ojai.store.OpListener listener, String id, org.ojai.store.QueryCondition c, org.ojai.FieldPath... paths)`
`void`	`findById(org.ojai.store.OpListener listener, String id, org.ojai.store.QueryCondition c, String... paths)`
`void`	`findById(org.ojai.store.OpListener listener, String id, String... paths)` Non-blocking read operation which gets called back on the listener object on success or failure.
`org.ojai.Document`	`findById(String id)` Reads the entire document for a given key.
`org.ojai.Document`	`findById(String id, org.ojai.FieldPath... paths)`
`org.ojai.Document`	`findById(String id, org.ojai.store.QueryCondition c)` Reads the row parts that match the condition and projects only the field paths requested.
`org.ojai.Document`	`findById(String id, org.ojai.store.QueryCondition c, org.ojai.FieldPath... paths)`
`org.ojai.Document`	`findById(String id, org.ojai.store.QueryCondition c, String... paths)`
`org.ojai.Document`	`findById(String id, String... paths)` Reads the row and projects only the field paths requested.
`org.ojai.Document`	`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(org.ojai.store.QueryCondition 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 rs)` Inserts a set of documents represented by the DocumentStream into the table.
`void`	`insert(org.ojai.DocumentStream rs, org.ojai.FieldPath fieldAsKey)`
`void`	`insert(org.ojai.DocumentStream 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 rs)` Inserts a set of documents represented by the DocumentStream into the table.
`void`	`insertOrReplace(org.ojai.DocumentStream rs, org.ojai.FieldPath fieldAsKey)`
`void`	`insertOrReplace(org.ojai.DocumentStream 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 rs)` Replaces a set of documents represented by the DocumentStream into the table.
`void`	`replace(org.ojai.DocumentStream rs, org.ojai.FieldPath fieldAsKey)`
`void`	`replace(org.ojai.DocumentStream 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, org.ojai.store.DocumentMutation m)`
`void`	`update(String id, org.ojai.store.DocumentMutation m)` Applies a row mutation on the row identified by the row id.

Methods inherited from interface org.ojai.store.DocumentStore
checkAndDelete, checkAndMutate, checkAndReplace, delete, increment, increment, increment, increment, increment, increment, increment, insert, insertOrReplace, isReadOnly, replace, update

- 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.
    
    Specified by:
    
    flush in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - findById
```
org.ojai.Document 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.
    
    Parameters:
    id - document id
    
    Returns:
    document object
    
    Throws:
    
    DBException
  - findById
```
org.ojai.Document findById(ByteBuffer id)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
org.ojai.Document findById(org.ojai.Value id)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
org.ojai.Document findById(String id,
                         String... paths)
                           throws DBException
```
    Reads the row and projects only the field paths requested. Blocking operation. NULL is returned if the document with the 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.
    
    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
```
org.ojai.Document findById(String id,
                         org.ojai.FieldPath... paths)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
org.ojai.Document findById(ByteBuffer id,
                         String... paths)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
org.ojai.Document findById(ByteBuffer id,
                         org.ojai.FieldPath... paths)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
org.ojai.Document findById(String id,
                         org.ojai.store.QueryCondition 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 a given id doesn't exist in the table. Throws DBException if there is an error in getting the document.
    
    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
```
org.ojai.Document findById(ByteBuffer id,
                         org.ojai.store.QueryCondition c)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
org.ojai.Document findById(String id,
                         org.ojai.store.QueryCondition c,
                         String... paths)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
org.ojai.Document findById(String id,
                         org.ojai.store.QueryCondition c,
                         org.ojai.FieldPath... paths)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
org.ojai.Document findById(ByteBuffer id,
                         org.ojai.store.QueryCondition c,
                         String... paths)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
org.ojai.Document findById(ByteBuffer id,
                         org.ojai.store.QueryCondition c,
                         org.ojai.FieldPath... paths)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
void findById(org.ojai.store.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(org.ojai.store.OpListener listener,
            ByteBuffer id)
```
  - findById
```
void findById(org.ojai.store.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(org.ojai.store.OpListener listener,
            String id,
            org.ojai.FieldPath... paths)
```
  - findById
```
void findById(org.ojai.store.OpListener listener,
            ByteBuffer id,
            String... paths)
```
  - findById
```
void findById(org.ojai.store.OpListener listener,
            ByteBuffer id,
            org.ojai.FieldPath... paths)
```
  - findById
```
void findById(org.ojai.store.OpListener listener,
            String id,
            org.ojai.store.QueryCondition 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 the listener. If no path parameter is specified then it returns a full document for a given row. QueryCondition 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(org.ojai.store.OpListener listener,
            ByteBuffer id,
            org.ojai.store.QueryCondition c)
```
  - findById
```
void findById(org.ojai.store.OpListener listener,
            String id,
            org.ojai.store.QueryCondition c,
            String... paths)
```
  - findById
```
void findById(org.ojai.store.OpListener listener,
            String id,
            org.ojai.store.QueryCondition c,
            org.ojai.FieldPath... paths)
```
  - findById
```
void findById(org.ojai.store.OpListener listener,
            ByteBuffer id,
            org.ojai.store.QueryCondition c,
            String... paths)
```
  - findById
```
void findById(org.ojai.store.OpListener listener,
            ByteBuffer id,
            org.ojai.store.QueryCondition c,
            org.ojai.FieldPath... paths)
```
  - find
```
org.ojai.DocumentStream find()
                             throws DBException
```
    Returns a DocumentStream for all the rows in the table.
    
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    Returns:
    A DocumentStream that can be used to retrieve each row in the table. The DocumentStream must be closed after retrieving the documents
    
    Throws:
    
    DBException
  - find
```
org.ojai.DocumentStream find(String... paths)
                             throws DBException
```
    Returns a DocumentStream 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 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 a full document for a given row.
    
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    Parameters:
    paths - list of fields that should be returned in the read document
    
    Returns:
    A DocumentStream that can be used to requested paths. The DocumentStream must be closed after retrieving the documents.
    
    Throws:
    
    DBException
  - find
```
org.ojai.DocumentStream find(org.ojai.FieldPath... paths)
                             throws DBException
```
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - find
```
org.ojai.DocumentStream find(org.ojai.store.QueryCondition c)
                             throws DBException
```
    Returns a DocumentStream for all the rows in the table that match the condition.
    
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    Parameters:
    c - condition to check for the query
    
    Returns:
    A DocumentStream that can be used to get rows. The DocumentStream must be closed after retrieving the documents.
    
    Throws:
    
    TableNotFoundException - when the table from which to get any row does not exist
    
    DBException
  - find
```
org.ojai.DocumentStream find(org.ojai.store.QueryCondition 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 a full document for a given row.
    
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    Parameters:
    c - condition to check for the query
    paths - list of fields that should be returned in the read document
    
    Returns:
    A DocumentStream that can be used to read docuemnts with requested paths. The DocumentStream must be closed after retrieving the documents
    
    Throws:
    
    DBException
  - find
```
org.ojai.DocumentStream find(org.ojai.store.QueryCondition c,
                           org.ojai.FieldPath... paths)
                             throws DBException
```
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    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 as usual as an "_id" field.
    
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    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
```
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insertOrReplace
```
void insertOrReplace(org.ojai.Document r,
                   String fieldAsKey)
                     throws DBException
```
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insertOrReplace
```
void insertOrReplace(org.ojai.DocumentStream rs)
                     throws org.ojai.store.exceptions.MultiOpException
```
    Inserts a set of documents represented by the DocumentStream into the table. This is a synchronous API and it won't return until all the documents in the DocumentStream are written to the table or some error occurs while writing the documents. Each document read from the DocumentStream 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 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.
    
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Parameters:
    rs - DocumentStream
    fieldAsKey - field from each document whose value is to be used as the document key for insertion
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException - that has a list of write-failed documents and their errors
  - insertOrReplace
```
void insertOrReplace(org.ojai.DocumentStream rs,
                   org.ojai.FieldPath fieldAsKey)
                     throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - insertOrReplace
```
void insertOrReplace(org.ojai.DocumentStream rs,
                   String fieldAsKey)
                     throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - update
```
void update(String id,
          org.ojai.store.DocumentMutation 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 the 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.
    
    Parameters:
    id - document id
    m - mutation object specifying the operation on paths of a row
    
    Throws:
    
    DBException
  - update
```
void update(ByteBuffer id,
          org.ojai.store.DocumentMutation 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 as usual as "_id" field.
    
    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
```
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - delete
```
void delete(org.ojai.Document r,
          org.ojai.FieldPath fieldAsKey)
            throws DBException
```
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - delete
```
void delete(org.ojai.Document r,
          String fieldAsKey)
            throws DBException
```
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - delete
```
void delete(org.ojai.DocumentStream rs)
            throws org.ojai.store.exceptions.MultiOpException
```
    Deletes a set of documents from the table represented by the DocumentStream. This is a synchronous API and it won't return until all the documents in the DocumentStream are written to the table or some error occurs while writing the documents. Each document read from the DocumentStream 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 documents is returned in a multi op exception. The untouched documents will remain in the DocumentStream.
    
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Parameters:
    rs - DocumentStream
    fieldAsKey - a field from each document whose value is to be used as the document key for deletion
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException - that has a list of write-failed documents and their errors
  - delete
```
void delete(org.ojai.DocumentStream rs,
          org.ojai.FieldPath fieldAsKey)
            throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - delete
```
void delete(org.ojai.DocumentStream rs,
          String fieldAsKey)
            throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.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 as usual as the "_id" field. 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
    
    org.ojai.store.exceptions.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
```
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insert
```
void insert(org.ojai.Document r,
          org.ojai.FieldPath fieldAsKey)
            throws DBException
```
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insert
```
void insert(org.ojai.Document r,
          String fieldAsKey)
            throws DBException
```
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insert
```
void insert(org.ojai.DocumentStream rs)
            throws org.ojai.store.exceptions.MultiOpException
```
    Inserts a set of documents represented by the DocumentStream into the table. This is a synchronous API that won't return until all the documents in the DocumentStream are written to the table or some error occurs while writing the documents. Each document read from the DocumentStream must have a field "_id" of type BINARY or UTF8-string; otherwise, the operation will fail or it will be of the Document 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 documents is returned in a multi op exception. The untouched documents will remain in the DocumentStream.
    
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Parameters:
    rs - DocumentStream
    fieldAsKey - a field from each document whose value is to be used as the document key for deletion
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException - that has a list of write-failed documents and their errors
  - insert
```
void insert(org.ojai.DocumentStream rs,
          org.ojai.FieldPath fieldAsKey)
            throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - insert
```
void insert(org.ojai.DocumentStream rs,
          String fieldAsKey)
            throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.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 an "_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 a 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 as usual as an "_id" field. 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 the 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 returns EPERM
    
    org.ojai.store.exceptions.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
```
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - replace
```
void replace(org.ojai.Document r,
           org.ojai.FieldPath fieldAsKey)
             throws DBException
```
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - replace
```
void replace(org.ojai.Document r,
           String fieldAsKey)
             throws DBException
```
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - replace
```
void replace(org.ojai.DocumentStream rs)
             throws org.ojai.store.exceptions.MultiOpException
```
    Replaces a set of documents represented by the DocumentStream into the table. This is a synchronous API and it won't return until all the documents in the DocumentStream are written to the table or some error occurs while writing the documents. Each document read from the DocumentStream must have a field "_id" of type BINARY or UTF8-string; otherwise, the operation will fail or it will be of the Document 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 documents is returned in a multi op exception. The untouched documents will remain in the DocumentStream.
    
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Parameters:
    rs - DocumentStream
    fieldAsKey - field from each document whose value is to be used as the document key for deletion
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException - that has a list of write-failed documents and their errors
  - replace
```
void replace(org.ojai.DocumentStream rs,
           org.ojai.FieldPath fieldAsKey)
             throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - replace
```
void replace(org.ojai.DocumentStream rs,
           String fieldAsKey)
             throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.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 an 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.
    
    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,
                     org.ojai.store.QueryCondition condition,
                     org.ojai.store.DocumentMutation 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.
    
    Parameters:
    id - document id
    condition - the condition to evaluate on the row
    m - the 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 mutation fails
  - checkAndMutate
```
boolean checkAndMutate(ByteBuffer id,
                     org.ojai.store.QueryCondition condition,
                     org.ojai.store.DocumentMutation m)
                       throws DBException
```
    Throws:
    
    DBException
  - checkAndDelete
```
boolean checkAndDelete(String id,
                     org.ojai.store.QueryCondition 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 doesn't exist, returns false (no exception is thrown). If the deletion operation fails, it throws an exception.
    
    Parameters:
    id - document id
    condition - the 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,
                     org.ojai.store.QueryCondition condition)
                       throws DBException
```
    Throws:
    
    DBException
  - checkAndReplace
```
boolean checkAndReplace(String id,
                      org.ojai.store.QueryCondition 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.
    
    Parameters:
    id - document id
    condition - the condition to evaluate on the row
    r - the 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,
                      org.ojai.store.QueryCondition 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(org.ojai.store.QueryCondition c)
                            throws DBException
```
    Parameters:
    QueryCondition - a condition object provided by the user or application
    
    Returns:
    TabletInfo for all current tablets of this table, which has a start and end key matching the range specified by the condition object
    
    Throws:
    
    DBException
  - close
```
void close()
           throws DBException
```
    Overrides AutoCloseable.close() to avoid declaring a checked exception.
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException

Interface Table

Nested Class Summary

Method Summary

Methods inherited from interface org.ojai.store.DocumentStore

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