MapRDBTableImpl (MapR DB Client 5.1.0-mapr API)

java.lang.Object
- com.mapr.db.impl.MapRDBTableImpl

All Implemented Interfaces:: Table, AutoCloseable, org.ojai.store.DocumentStore

@API.Internal
public class MapRDBTableImpl
extends Object
implements Table

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class MapRDBTableImpl.TablePrivateOption
- Nested classes/interfaces inherited from interface com.mapr.db.Table
  Table.TableOption

Nested Classes
Modifier and Type	Class and Description
`static class`	`MapRDBTableImpl.TablePrivateOption`

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`DECOMPRESS_STR`
`static String`	`EXCLUDE_EMBEDDEDFAMILY_STR`
`static String`	`GET_DELETES_STR`
`static String`	`PRESERVE_TS_STR`
`int`	`testMulitOpExIdx`

Constructor Summary

Constructors
Constructor and Description

MapRDBTableImpl(org.apache.hadoop.fs.Path tablePath, org.apache.hadoop.conf.Configuration config)

Constructors
Constructor and Description
`MapRDBTableImpl(org.apache.hadoop.fs.Path tablePath, org.apache.hadoop.conf.Configuration config)`

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 a given row and if the condition holds true for the row then it is atomically deleted.
`boolean`	`checkAndDelete(org.ojai.Value id, org.ojai.store.QueryCondition condition)`
`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 the mutation is applied on the row.
`boolean`	`checkAndMutate(org.ojai.Value id, org.ojai.store.QueryCondition condition, org.ojai.store.DocumentMutation m)`
`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 a given row on the server and if the condition holds true for the row then it atomically replaces the row with the given record.
`boolean`	`checkAndReplace(org.ojai.Value id, org.ojai.store.QueryCondition condition, org.ojai.Document r)`
`void`	`close()` Overrides `AutoCloseable.close()` to avoid declaring a checked exception.
`boolean`	`decodeTimestamp()`
`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.
`void`	`delete(org.ojai.Value id)`
`boolean`	`excludeEmbeddedFamily()`
`org.ojai.DocumentStream`	`find()` Returns a record stream for all the rows in the table.
`org.ojai.DocumentStream`	`find(org.ojai.FieldPath... fields)`
`org.ojai.DocumentStream`	`find(org.ojai.store.QueryCondition c)` Returns a record stream for all the rows in the table that match the condition.
`org.ojai.DocumentStream`	`find(org.ojai.store.QueryCondition c, org.ojai.FieldPath... fields)`
`org.ojai.DocumentStream`	`find(org.ojai.store.QueryCondition c, String... paths)` Returns a record stream for all the rows in the table that match the condition.
`org.ojai.DocumentStream`	`find(String... paths)` Returns a record stream for all the rows in the table.
`org.ojai.Document`	`findById(ByteBuffer id)`
`org.ojai.Document`	`findById(ByteBuffer id, org.ojai.FieldPath... fields)`
`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... fields)`
`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... fields)`
`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... fields)`
`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 operations.
`void`	`findById(org.ojai.store.OpListener listener, String id, org.ojai.FieldPath... fields)`
`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... fields)`
`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.
`void`	`findById(org.ojai.store.OpListener listener, org.ojai.Value id)`
`void`	`findById(org.ojai.store.OpListener listener, org.ojai.Value id, org.ojai.FieldPath... fields)`
`void`	`findById(org.ojai.store.OpListener listener, org.ojai.Value id, org.ojai.store.QueryCondition c)`
`void`	`findById(org.ojai.store.OpListener listener, org.ojai.Value id, org.ojai.store.QueryCondition c, org.ojai.FieldPath... fields)`
`void`	`findById(org.ojai.store.OpListener listener, org.ojai.Value id, org.ojai.store.QueryCondition c, String... paths)`
`void`	`findById(org.ojai.store.OpListener listener, org.ojai.Value id, String... paths)`
`org.ojai.Document`	`findById(String id)` Reads a single full record identified by the id.
`org.ojai.Document`	`findById(String id, org.ojai.FieldPath... fields)`
`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... fields)`
`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)`
`org.ojai.Document`	`findById(org.ojai.Value id, org.ojai.FieldPath... fields)`
`org.ojai.Document`	`findById(org.ojai.Value id, org.ojai.store.QueryCondition c)`
`org.ojai.Document`	`findById(org.ojai.Value id, org.ojai.store.QueryCondition c, org.ojai.FieldPath... fields)`
`org.ojai.Document`	`findById(org.ojai.Value id, org.ojai.store.QueryCondition c, String... paths)`
`org.ojai.Document`	`findById(org.ojai.Value id, String... paths)`
`void`	`flush()` Flushes all the buffered update operations on the client.
`boolean`	`getDeletes()`
`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.
`boolean`	`getPrivateOption(MapRDBTableImpl.TablePrivateOption option)`
`TableDescriptor`	`getTableDescriptor()`
`TabletInfo`	`getTabletInfo(ByteBuffer _id)`
`TabletInfo`	`getTabletInfo(String _id)`
`TabletInfo`	`getTabletInfo(org.ojai.Value _id)`
`TabletInfo[]`	`getTabletInfos()`
`TabletInfo[]`	`getTabletInfos(org.ojai.store.QueryCondition condition)`
`com.google.common.collect.BiMap<org.ojai.FieldPath,Integer>`	`idPathMap()`
`Map<Integer,String>`	`idToCFNameMap()`
`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`	`increment(org.ojai.Value id, String field, BigDecimal inc)`
`void`	`increment(org.ojai.Value id, String field, byte inc)`
`void`	`increment(org.ojai.Value id, String field, double inc)`
`void`	`increment(org.ojai.Value id, String field, float inc)`
`void`	`increment(org.ojai.Value id, String field, int inc)`
`void`	`increment(org.ojai.Value id, String field, long inc)`
`void`	`increment(org.ojai.Value 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`	`insert(org.ojai.Value id, org.ojai.Document r)`
`void`	`insertOrReplace(ByteBuffer id, org.ojai.Document r)`
`void`	`insertOrReplace(org.ojai.Document r)` Inserts a new record 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)` Internally this API will get a number of records from the stream and write them to the table.
`void`	`insertOrReplace(org.ojai.Document r, String fieldAsKey)`
`void`	`insertOrReplace(String id, org.ojai.Document r)`
`void`	`insertOrReplace(org.ojai.Value id, org.ojai.Document r)`
`boolean`	`isKeepInsertionOrder()`
`boolean`	`isPreserveTS()`
`boolean`	`isReadOnly()`
`com.mapr.fs.MapRHTable`	`maprTable()`
`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.
`void`	`replace(org.ojai.Value id, org.ojai.Document r)`
`org.ojai.DocumentStream`	`segmentKeyScan()`
`void`	`setExcludeEmbeddedFamily(boolean v)`
`Table`	`setOption(Table.TableOption option, boolean value)`
`MapRDBTableImpl`	`setPrivateOption(MapRDBTableImpl.TablePrivateOption option, boolean value)`
`boolean`	`shouldDecompress()`
`Map<org.ojai.FieldPath,Integer>`	`sortedByPath()`
`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.
`void`	`update(org.ojai.Value id, org.ojai.store.DocumentMutation m)`
`void`	`updateSchema()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PRESERVE_TS_STR
```
public static final String PRESERVE_TS_STR
```
    See Also:
    Constant Field Values
  - GET_DELETES_STR
```
public static final String GET_DELETES_STR
```
    See Also:
    Constant Field Values
  - EXCLUDE_EMBEDDEDFAMILY_STR
```
public static final String EXCLUDE_EMBEDDEDFAMILY_STR
```
    See Also:
    Constant Field Values
  - DECOMPRESS_STR
```
public static final String DECOMPRESS_STR
```
    See Also:
    Constant Field Values
  - testMulitOpExIdx
```
public int testMulitOpExIdx
```
- Constructor Detail
  - MapRDBTableImpl
```
public MapRDBTableImpl(org.apache.hadoop.fs.Path tablePath,
               org.apache.hadoop.conf.Configuration config)
                throws DBException,
                       TableNotFoundException
```
    Throws:
    
    DBException
    
    TableNotFoundException
- Method Detail
  - maprTable
```
public com.mapr.fs.MapRHTable maprTable()
```
  - idPathMap
```
public com.google.common.collect.BiMap<org.ojai.FieldPath,Integer> idPathMap()
```
  - sortedByPath
```
public Map<org.ojai.FieldPath,Integer> sortedByPath()
```
  - idToCFNameMap
```
public Map<Integer,String> idToCFNameMap()
```
  - setOption
```
public Table setOption(Table.TableOption option,
              boolean value)
```
    Specified by:
    
    setOption in interface Table
  - isKeepInsertionOrder
```
public boolean isKeepInsertionOrder()
```
  - getDeletes
```
public boolean getDeletes()
```
  - isPreserveTS
```
public boolean isPreserveTS()
```
  - shouldDecompress
```
public boolean shouldDecompress()
```
  - decodeTimestamp
```
public boolean decodeTimestamp()
```
  - setExcludeEmbeddedFamily
```
public void setExcludeEmbeddedFamily(boolean v)
```
  - excludeEmbeddedFamily
```
public boolean excludeEmbeddedFamily()
```
  - getOption
```
public org.ojai.Value getOption(Table.TableOption option)
```
    Specified by:
    
    getOption in interface Table
  - setPrivateOption
```
public MapRDBTableImpl setPrivateOption(MapRDBTableImpl.TablePrivateOption option,
                               boolean value)
```
  - getPrivateOption
```
public boolean getPrivateOption(MapRDBTableImpl.TablePrivateOption option)
```
  - getName
```
public String getName()
```
    Returns just the name of the table (not the full path).
    
    Specified by:
    
    getName in interface Table
  - getPath
```
public org.apache.hadoop.fs.Path getPath()
```
    Returns the full path of the table.
    
    Specified by:
    
    getPath in interface Table
  - getTableDescriptor
```
public TableDescriptor getTableDescriptor()
```
    Specified by:
    
    getTableDescriptor in interface Table
    
    Returns:
    The TableDescriptor for this table
  - flush
```
public void flush()
           throws DBException
```
    Flushes all the buffered update operations on the client.
    
    Specified by:
    
    flush in interface Table
    
    Specified by:
    
    flush in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException - if the flush failed or the flush of any buffered operation resulted in an error
  - findById
```
public org.ojai.Document findById(String id)
                           throws DBException
```
    Reads a single full record identified by the id. A NULL record is returned if the record with the given id doesn't exist in the table.
    
    Specified by:
    
    findById in interface Table
    
    Parameters:
    id - row key
    
    Returns:
    record for the row if it exists, otherwise null
    
    Throws:
    
    TableNotFoundException - when the table from which to get the row does not exist
    
    DBException
  - findById
```
public org.ojai.Document findById(ByteBuffer id)
                           throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(org.ojai.Value id)
                           throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(String id,
                         org.ojai.FieldPath... fields)
                           throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(String id,
                         String... paths)
                           throws DBException
```
    Description copied from interface: Table
    
    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.
    
    Specified by:
    
    findById in interface Table
    
    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
```
public org.ojai.Document findById(ByteBuffer id,
                         org.ojai.FieldPath... fields)
                           throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(ByteBuffer id,
                         String... paths)
                           throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(org.ojai.Value id,
                         org.ojai.FieldPath... fields)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(org.ojai.Value id,
                         String... paths)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(String id,
                         org.ojai.store.QueryCondition c)
                           throws DBException
```
    Description copied from interface: Table
    
    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.
    
    Specified by:
    
    findById in interface Table
    
    Parameters:
    id - document id
    c - condition to check for the query
    
    Returns:
    document object with the requested projection/conditions
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(ByteBuffer id,
                         org.ojai.store.QueryCondition c)
                           throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(org.ojai.Value id,
                         org.ojai.store.QueryCondition c)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(String id,
                         org.ojai.store.QueryCondition c,
                         org.ojai.FieldPath... fields)
                           throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(String id,
                         org.ojai.store.QueryCondition c,
                         String... paths)
                           throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(ByteBuffer id,
                         org.ojai.store.QueryCondition c,
                         org.ojai.FieldPath... fields)
                           throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(ByteBuffer id,
                         org.ojai.store.QueryCondition c,
                         String... paths)
                           throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(org.ojai.Value id,
                         org.ojai.store.QueryCondition c,
                         String... paths)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
public org.ojai.Document findById(org.ojai.Value id,
                         org.ojai.store.QueryCondition c,
                         org.ojai.FieldPath... fields)
                           throws DBException
```
    Throws:
    
    DBException
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            String id)
```
    Non-blocking read operations. Gets called back on the listener object on success or failure.
    
    Specified by:
    
    findById in interface Table
    
    Parameters:
    listener - object to be used as the callback
    id - document id
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            ByteBuffer id)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            org.ojai.Value id)
```
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            String id,
            org.ojai.FieldPath... fields)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            String id,
            String... paths)
```
    Description copied from interface: Table
    
    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.
    
    Specified by:
    
    findById in interface Table
    
    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
```
public void findById(org.ojai.store.OpListener listener,
            ByteBuffer id,
            org.ojai.FieldPath... fields)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            ByteBuffer id,
            String... paths)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            org.ojai.Value id,
            String... paths)
```
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            org.ojai.Value id,
            org.ojai.FieldPath... fields)
```
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            String id,
            org.ojai.store.QueryCondition c)
```
    Description copied from interface: Table
    
    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.
    
    Specified by:
    
    findById in interface Table
    
    Parameters:
    listener - object to be used as the callback
    id - document id
    c - condition to check for the query
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            ByteBuffer id,
            org.ojai.store.QueryCondition c)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            org.ojai.Value id,
            org.ojai.store.QueryCondition c)
```
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            String id,
            org.ojai.store.QueryCondition c,
            org.ojai.FieldPath... fields)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            String id,
            org.ojai.store.QueryCondition c,
            String... paths)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            ByteBuffer id,
            org.ojai.store.QueryCondition c,
            org.ojai.FieldPath... fields)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            ByteBuffer id,
            org.ojai.store.QueryCondition c,
            String... paths)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            org.ojai.Value id,
            org.ojai.store.QueryCondition c,
            org.ojai.FieldPath... fields)
```
  - findById
```
public void findById(org.ojai.store.OpListener listener,
            org.ojai.Value id,
            org.ojai.store.QueryCondition c,
            String... paths)
```
  - find
```
public org.ojai.DocumentStream find()
                             throws DBException
```
    Returns a record stream for all the rows in the table.
    
    Specified by:
    
    find in interface Table
    
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    Returns:
    record stream that can be used to retrieve each row in the table
    
    Throws:
    
    TableNotFoundException - when the table from which to get any row does not exist
    
    DBException
  - find
```
public org.ojai.DocumentStream find(String... paths)
                             throws DBException
```
    Returns a record stream for all the rows in the table. Each Document will contain only the fields 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 record.
    
    Specified by:
    
    find in interface Table
    
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    Parameters:
    paths - list of fields that should be returned in the read document
    
    Returns:
    record stream that can be used to get rows with requested fields
    
    Throws:
    
    TableNotFoundException - when the table from which to get any row does not exist
    
    DBException
  - find
```
public org.ojai.DocumentStream find(org.ojai.FieldPath... fields)
                             throws DBException
```
    Specified by:
    
    find in interface Table
    
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - find
```
public org.ojai.DocumentStream find(org.ojai.store.QueryCondition c)
                             throws DBException
```
    Returns a record stream for all the rows in the table that match the condition.
    
    Specified by:
    
    find in interface Table
    
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    Parameters:
    c - condition to check for the query
    
    Returns:
    record stream that can be used to get rows with requested fields
    
    Throws:
    
    TableNotFoundException - when the table from which to get any row does not exist
    
    DBException
  - find
```
public org.ojai.DocumentStream find(org.ojai.store.QueryCondition c,
                           String... paths)
                             throws DBException
```
    Returns a record stream for all the rows in the table that match the condition. Each Document will contain only the fields that are specified in the argument. If a given field doesn't exist in the row or the user doesn't have permission to access that field, then that field won't be returned in the read record.
    
    Specified by:
    
    find in interface Table
    
    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:
    record stream that can be used to get rows with requested fields
    
    Throws:
    
    TableNotFoundException - when the table from which to get any row does not exist
    
    DBException
  - find
```
public org.ojai.DocumentStream find(org.ojai.store.QueryCondition c,
                           org.ojai.FieldPath... fields)
                             throws DBException
```
    Specified by:
    
    find in interface Table
    
    Specified by:
    
    find in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insertOrReplace
```
public void insertOrReplace(org.ojai.Document r)
                     throws DBException
```
    Inserts a new record in the table. The row key is either explicitly specified as parameter "id" or it is implicitly specified as the field "_id" in the passed record. If the row key is explicitly passed then the record 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 exists on the server, then it will be overwritten by the new record.
    
    Specified by:
    
    insertOrReplace in interface Table
    
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Parameters:
    r - JSON record as the new value for the given row
    
    Throws:
    
    TableNotFoundException - when table does not exist to add this row
    
    AccessDeniedException - user credentials mismatch
    
    ReadOnlyException - when the table is not accepting writes
    
    OpNotPermittedException - server returned EPERM
    
    DBException
  - insertOrReplace
```
public void insertOrReplace(String id,
                   org.ojai.Document r)
                     throws DBException
```
    Specified by:
    
    insertOrReplace in interface Table
    
    Throws:
    
    DBException
  - insertOrReplace
```
public void insertOrReplace(ByteBuffer id,
                   org.ojai.Document r)
                     throws DBException
```
    Specified by:
    
    insertOrReplace in interface Table
    
    Throws:
    
    DBException
  - insertOrReplace
```
public void insertOrReplace(org.ojai.Value id,
                   org.ojai.Document r)
                     throws DBException
```
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insertOrReplace
```
public void insertOrReplace(org.ojai.Document r,
                   org.ojai.FieldPath fieldAsKey)
                     throws DBException
```
    Specified by:
    
    insertOrReplace in interface Table
    
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insertOrReplace
```
public void insertOrReplace(org.ojai.Document r,
                   String fieldAsKey)
                     throws DBException
```
    Specified by:
    
    insertOrReplace in interface Table
    
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insertOrReplace
```
public void insertOrReplace(org.ojai.DocumentStream rs)
                     throws org.ojai.store.exceptions.MultiOpException
```
    Description copied from interface: Table
    
    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 Table
    
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Parameters:
    rs - DocumentStream
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException - that has a list of write-failed documents and their errors
  - insertOrReplace
```
public void insertOrReplace(org.ojai.DocumentStream rs,
                   org.ojai.FieldPath fieldAsKey)
                     throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    insertOrReplace in interface Table
    
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - insertOrReplace
```
public void insertOrReplace(org.ojai.DocumentStream rs,
                   String fieldAsKey)
                     throws org.ojai.store.exceptions.MultiOpException
```
    Internally this API will get a number of records from the stream and write them to the table. Make sure the write batch is flushed to server to ensure that the error list can be populated correctly.
    
    Specified by:
    
    insertOrReplace in interface Table
    
    Specified by:
    
    insertOrReplace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - update
```
public 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 are applied. For example, the mutation object specifies an increment on a field "address" by 5 and a set of field "zip" as "95134". On the server, if the "address" field is not of a numeric type then the increment operation will fail. Since the set of field "zip" is also part of same mutation, that operation will also not be applied on the server.
    
    Specified by:
    
    update in interface Table
    
    Parameters:
    id - row id
    m - mutation object specifying the operation on fields of a row
    
    Throws:
    
    TableNotFoundException - when the table does not exist to add this row
    
    AccessDeniedException - user credentials mismatch
    
    ReadOnlyException - when the table is not accepting writes
    
    DBException
  - update
```
public void update(ByteBuffer id,
          org.ojai.store.DocumentMutation m)
            throws DBException
```
    Specified by:
    
    update in interface Table
    
    Throws:
    
    DBException
  - update
```
public void update(org.ojai.Value id,
          org.ojai.store.DocumentMutation m)
            throws DBException
```
    Specified by:
    
    update in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - delete
```
public 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.
    
    Specified by:
    
    delete in interface Table
    
    Parameters:
    id - row id
    
    Throws:
    
    TableNotFoundException - when a table does not exist to add this row
    
    AccessDeniedException - on a user credentials mismatch
    
    ReadOnlyException - when a table is not accepting writes
    
    DBException
  - delete
```
public void delete(ByteBuffer id)
            throws DBException
```
    Specified by:
    
    delete in interface Table
    
    Throws:
    
    DBException
  - delete
```
public void delete(org.ojai.Value id)
            throws DBException
```
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - delete
```
public void delete(org.ojai.Document r)
            throws DBException
```
    Specified by:
    
    delete in interface Table
    
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - delete
```
public void delete(org.ojai.Document r,
          org.ojai.FieldPath fieldAsKey)
            throws DBException
```
    Specified by:
    
    delete in interface Table
    
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - delete
```
public void delete(org.ojai.Document r,
          String fieldAsKey)
            throws DBException
```
    Specified by:
    
    delete in interface Table
    
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - delete
```
public void delete(org.ojai.DocumentStream rs,
          org.ojai.FieldPath fieldAsKey)
            throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    delete in interface Table
    
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - delete
```
public void delete(org.ojai.DocumentStream rs)
            throws org.ojai.store.exceptions.MultiOpException
```
    Description copied from interface: Table
    
    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 Table
    
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Parameters:
    rs - DocumentStream
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException - that has a list of write-failed documents and their errors
  - delete
```
public void delete(org.ojai.DocumentStream rs,
          String fieldAsKey)
            throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    delete in interface Table
    
    Specified by:
    
    delete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - increment
```
public void increment(String id,
             String field,
             long inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(ByteBuffer id,
             String field,
             long inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(org.ojai.Value id,
             String field,
             long inc)
               throws DBException
```
    Specified by:
    
    increment in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - increment
```
public void increment(String id,
             String field,
             float inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(ByteBuffer id,
             String field,
             float inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(org.ojai.Value id,
             String field,
             float inc)
               throws DBException
```
    Specified by:
    
    increment in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - increment
```
public void increment(String id,
             String field,
             double inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(ByteBuffer id,
             String field,
             double inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(org.ojai.Value id,
             String field,
             double inc)
               throws DBException
```
    Specified by:
    
    increment in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - increment
```
public void increment(String id,
             String field,
             BigDecimal inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(ByteBuffer id,
             String field,
             BigDecimal inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(org.ojai.Value id,
             String field,
             BigDecimal inc)
               throws DBException
```
    Specified by:
    
    increment in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - increment
```
public void increment(String id,
             String field,
             byte inc)
               throws DBException
```
    Description copied from interface: Table
    
    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.
    
    Specified by:
    
    increment in interface Table
    
    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
```
public void increment(ByteBuffer id,
             String field,
             byte inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(org.ojai.Value id,
             String field,
             byte inc)
               throws DBException
```
    Specified by:
    
    increment in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - increment
```
public void increment(String id,
             String field,
             short inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(ByteBuffer id,
             String field,
             short inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(org.ojai.Value id,
             String field,
             short inc)
               throws DBException
```
    Specified by:
    
    increment in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - increment
```
public void increment(String id,
             String field,
             int inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(ByteBuffer id,
             String field,
             int inc)
               throws DBException
```
    Specified by:
    
    increment in interface Table
    
    Throws:
    
    DBException
  - increment
```
public void increment(org.ojai.Value id,
             String field,
             int inc)
               throws DBException
```
    Specified by:
    
    increment in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insert
```
public void insert(String id,
          org.ojai.Document r)
            throws DBException
```
    Description copied from interface: Table
    
    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.
    
    Specified by:
    
    insert in interface Table
    
    Parameters:
    id - to be used as the key for the document
    r - JSON document as the new value for the given row
    
    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
    
    DBException
  - insert
```
public void insert(ByteBuffer id,
          org.ojai.Document r)
            throws DBException
```
    Specified by:
    
    insert in interface Table
    
    Throws:
    
    DBException
  - insert
```
public void insert(org.ojai.Value id,
          org.ojai.Document r)
            throws DBException
```
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insert
```
public void insert(org.ojai.Document r)
            throws DBException
```
    Specified by:
    
    insert in interface Table
    
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insert
```
public void insert(org.ojai.Document r,
          org.ojai.FieldPath fieldAsKey)
            throws DBException
```
    Specified by:
    
    insert in interface Table
    
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insert
```
public void insert(org.ojai.Document r,
          String fieldAsKey)
            throws DBException
```
    Specified by:
    
    insert in interface Table
    
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - insert
```
public void insert(org.ojai.DocumentStream rs,
          org.ojai.FieldPath fieldAsKey)
            throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    insert in interface Table
    
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - insert
```
public void insert(org.ojai.DocumentStream rs)
            throws org.ojai.store.exceptions.MultiOpException
```
    Description copied from interface: Table
    
    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 Table
    
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Parameters:
    rs - DocumentStream
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException - that has a list of write-failed documents and their errors
  - insert
```
public void insert(org.ojai.DocumentStream rs,
          String fieldAsKey)
            throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    insert in interface Table
    
    Specified by:
    
    insert in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - replace
```
public void replace(String id,
           org.ojai.Document r)
             throws DBException
```
    Description copied from interface: Table
    
    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.
    
    Specified by:
    
    replace in interface Table
    
    Parameters:
    id - to be used as the key for the document
    r - JSON document as the new value for the given row
    
    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
    
    DBException
  - replace
```
public void replace(ByteBuffer id,
           org.ojai.Document r)
             throws DBException
```
    Specified by:
    
    replace in interface Table
    
    Throws:
    
    DBException
  - replace
```
public void replace(org.ojai.Value id,
           org.ojai.Document r)
             throws DBException
```
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - replace
```
public void replace(org.ojai.Document r)
             throws DBException
```
    Specified by:
    
    replace in interface Table
    
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - replace
```
public void replace(org.ojai.Document r,
           org.ojai.FieldPath fieldAsKey)
             throws DBException
```
    Specified by:
    
    replace in interface Table
    
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - replace
```
public void replace(org.ojai.Document r,
           String fieldAsKey)
             throws DBException
```
    Specified by:
    
    replace in interface Table
    
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - replace
```
public void replace(org.ojai.DocumentStream rs,
           org.ojai.FieldPath fieldAsKey)
             throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    replace in interface Table
    
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - replace
```
public void replace(org.ojai.DocumentStream rs)
             throws org.ojai.store.exceptions.MultiOpException
```
    Description copied from interface: Table
    
    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 Table
    
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Parameters:
    rs - DocumentStream
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException - that has a list of write-failed documents and their errors
  - replace
```
public void replace(org.ojai.DocumentStream rs,
           String fieldAsKey)
             throws org.ojai.store.exceptions.MultiOpException
```
    Specified by:
    
    replace in interface Table
    
    Specified by:
    
    replace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    org.ojai.store.exceptions.MultiOpException
  - checkAndMutate
```
public 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 the mutation is applied on the row. If the id doesn't exist, returns false (no exception is thrown). If the mutation operation fails, it throws an exception.
    
    Specified by:
    
    checkAndMutate in interface Table
    
    Parameters:
    id - row 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
  - checkAndMutate
```
public boolean checkAndMutate(ByteBuffer id,
                     org.ojai.store.QueryCondition condition,
                     org.ojai.store.DocumentMutation m)
                       throws DBException
```
    Specified by:
    
    checkAndMutate in interface Table
    
    Throws:
    
    DBException
  - checkAndMutate
```
public boolean checkAndMutate(org.ojai.Value id,
                     org.ojai.store.QueryCondition condition,
                     org.ojai.store.DocumentMutation m)
                       throws DBException
```
    Specified by:
    
    checkAndMutate in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - checkAndDelete
```
public boolean checkAndDelete(String id,
                     org.ojai.store.QueryCondition condition)
                       throws DBException
```
    Atomically evaluates the condition on a given row and if the condition holds true for the row then it is atomically deleted.
    
    Specified by:
    
    checkAndDelete in interface Table
    
    Parameters:
    id - row id
    condition - the condition to evaluate on the row
    
    Returns:
    True if the condition is true for the row, otherwise false
    
    Throws:
    
    DBException
  - checkAndDelete
```
public boolean checkAndDelete(ByteBuffer id,
                     org.ojai.store.QueryCondition condition)
                       throws DBException
```
    Specified by:
    
    checkAndDelete in interface Table
    
    Throws:
    
    DBException
  - checkAndDelete
```
public boolean checkAndDelete(org.ojai.Value id,
                     org.ojai.store.QueryCondition condition)
                       throws DBException
```
    Specified by:
    
    checkAndDelete in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - checkAndReplace
```
public boolean checkAndReplace(String id,
                      org.ojai.store.QueryCondition condition,
                      org.ojai.Document r)
                        throws DBException
```
    Atomically evaluates the condition on a given row on the server and if the condition holds true for the row then it atomically replaces the row with the given record.
    
    Specified by:
    
    checkAndReplace in interface Table
    
    Parameters:
    id - row id
    condition - the condition to evaluate on the row
    r - record to replace
    
    Returns:
    True if the condition is true for the row, otherwise false
    
    Throws:
    
    DBException
  - checkAndReplace
```
public boolean checkAndReplace(ByteBuffer id,
                      org.ojai.store.QueryCondition condition,
                      org.ojai.Document r)
                        throws DBException
```
    Specified by:
    
    checkAndReplace in interface Table
    
    Throws:
    
    DBException
  - checkAndReplace
```
public boolean checkAndReplace(org.ojai.Value id,
                      org.ojai.store.QueryCondition condition,
                      org.ojai.Document r)
                        throws DBException
```
    Specified by:
    
    checkAndReplace in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - close
```
public void close()
           throws DBException
```
    Description copied from interface: Table
    
    Overrides AutoCloseable.close() to avoid declaring a checked exception.
    
    Specified by:
    
    close in interface Table
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface org.ojai.store.DocumentStore
    
    Throws:
    
    DBException
  - getTabletInfo
```
public TabletInfo getTabletInfo(String _id)
                         throws DBException
```
    Specified by:
    
    getTabletInfo in interface Table
    
    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
```
public TabletInfo getTabletInfo(ByteBuffer _id)
                         throws DBException
```
    Specified by:
    
    getTabletInfo in interface Table
    
    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
```
public TabletInfo getTabletInfo(org.ojai.Value _id)
                         throws DBException
```
    Throws:
    
    DBException
  - getTabletInfos
```
public TabletInfo[] getTabletInfos()
                            throws DBException
```
    Specified by:
    
    getTabletInfos in interface Table
    
    Returns:
    TabletInfo for all current tablets of this table
    
    Throws:
    
    DBException
  - getTabletInfos
```
public TabletInfo[] getTabletInfos(org.ojai.store.QueryCondition condition)
                            throws DBException
```
    Specified by:
    
    getTabletInfos in interface Table
    
    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
  - isReadOnly
```
public boolean isReadOnly()
```
    Specified by:
    
    isReadOnly in interface org.ojai.store.DocumentStore
  - segmentKeyScan
```
@API.Internal
public org.ojai.DocumentStream segmentKeyScan()
                                       throws DBException
```
    Throws:
    
    DBException
  - updateSchema
```
public void updateSchema()
                  throws DBException
```
    Throws:
    
    DBException

Class MapRDBTableImpl

Nested Class Summary

Nested classes/interfaces inherited from interface com.mapr.db.Table

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PRESERVE_TS_STR

GET_DELETES_STR

EXCLUDE_EMBEDDEDFAMILY_STR

DECOMPRESS_STR

testMulitOpExIdx

Constructor Detail

MapRDBTableImpl

Method Detail

maprTable

idPathMap

sortedByPath

idToCFNameMap

setOption

isKeepInsertionOrder

getDeletes

isPreserveTS

shouldDecompress

decodeTimestamp

setExcludeEmbeddedFamily

excludeEmbeddedFamily

getOption

setPrivateOption

getPrivateOption

getName

getPath

getTableDescriptor

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

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

findById

find

find

find

find

find

find

insertOrReplace

insertOrReplace

insertOrReplace