MapRDBTableImpl (MapR DB Client 5.0.9-mapr API)

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

All Implemented Interfaces:: Table, AutoCloseable

@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 EXCLUDE_EMBEDDEDFAMILY_STR

static String GET_DELETES_STR

static String PRESERVE_TS_STR

int testMulitOpExIdx

Fields
Modifier and Type	Field and Description
`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, Condition condition)`
`boolean`	`checkAndDelete(String id, Condition 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, Condition condition)`
`boolean`	`checkAndMutate(ByteBuffer id, Condition condition, Mutation m)`
`boolean`	`checkAndMutate(String id, Condition condition, Mutation m)` Atomically evaluates the condition on given row and if the condition holds true for the row then mutation is applied on the row.
`boolean`	`checkAndMutate(org.ojai.Value id, Condition condition, Mutation m)`
`boolean`	`checkAndReplace(ByteBuffer id, Condition condition, org.ojai.Document r)`
`boolean`	`checkAndReplace(String id, Condition condition, org.ojai.Document r)` Atomically evaluates the condition on 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, Condition condition, org.ojai.Document r)`
`void`	`close()` Override `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<? extends org.ojai.Document> rs)` Deletes a set of documents from the table represented by the document stream.
`void`	`delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs, org.ojai.FieldPath fieldAsKey)`
`void`	`delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs, String fieldAsKey)`
`void`	`delete(org.ojai.Document r, String fieldAsKey)`
`void`	`delete(String id)` Deletes a row with the given rowkey.
`void`	`delete(org.ojai.Value id)`
`boolean`	`excludeEmbeddedFamily()`
`org.ojai.DocumentStream<DBDocument>`	`find()` Returns record stream for all the rows in the table
`org.ojai.DocumentStream<DBDocument>`	`find(Condition c)` Returns record stream for all the rows in the table that match the condition.
`org.ojai.DocumentStream<DBDocument>`	`find(Condition c, org.ojai.FieldPath... fields)`
`org.ojai.DocumentStream<DBDocument>`	`find(Condition c, String... paths)` Returns record stream for all the rows in the table that match the condition.
`org.ojai.DocumentStream<DBDocument>`	`find(org.ojai.FieldPath... fields)`
`org.ojai.DocumentStream<DBDocument>`	`find(String... paths)` Returns record stream for all the rows in the table.
`DBDocument`	`findById(ByteBuffer id)`
`DBDocument`	`findById(ByteBuffer id, Condition c)`
`DBDocument`	`findById(ByteBuffer id, Condition c, org.ojai.FieldPath... fields)`
`DBDocument`	`findById(ByteBuffer id, Condition c, String... paths)`
`DBDocument`	`findById(ByteBuffer id, org.ojai.FieldPath... fields)`
`DBDocument`	`findById(ByteBuffer id, String... paths)`
`void`	`findById(OpListener listener, ByteBuffer id)`
`void`	`findById(OpListener listener, ByteBuffer id, Condition c)`
`void`	`findById(OpListener listener, ByteBuffer id, Condition c, org.ojai.FieldPath... fields)`
`void`	`findById(OpListener listener, ByteBuffer id, Condition c, String... paths)`
`void`	`findById(OpListener listener, ByteBuffer id, org.ojai.FieldPath... fields)`
`void`	`findById(OpListener listener, ByteBuffer id, String... paths)`
`void`	`findById(OpListener listener, String id)` Non-blocking read operations.
`void`	`findById(OpListener listener, String id, Condition c)` Non-blocking read operation that gets called back on the listener object on success or failure.
`void`	`findById(OpListener listener, String id, Condition c, org.ojai.FieldPath... fields)`
`void`	`findById(OpListener listener, String id, Condition c, String... paths)`
`void`	`findById(OpListener listener, String id, org.ojai.FieldPath... fields)`
`void`	`findById(OpListener listener, String id, String... paths)` Non-blocking read operation which gets called back on the listener object on success or failure.
`void`	`findById(OpListener listener, org.ojai.Value id)`
`void`	`findById(OpListener listener, org.ojai.Value id, Condition c)`
`void`	`findById(OpListener listener, org.ojai.Value id, Condition c, org.ojai.FieldPath... fields)`
`void`	`findById(OpListener listener, org.ojai.Value id, Condition c, String... paths)`
`void`	`findById(OpListener listener, org.ojai.Value id, org.ojai.FieldPath... fields)`
`void`	`findById(OpListener listener, org.ojai.Value id, String... paths)`
`DBDocument`	`findById(String id)` Reads a single full record identified by the id.
`DBDocument`	`findById(String id, Condition c)` Reads the row parts that match the condition and projects only the field paths requested.
`DBDocument`	`findById(String id, Condition c, org.ojai.FieldPath... fields)`
`DBDocument`	`findById(String id, Condition c, String... paths)`
`DBDocument`	`findById(String id, org.ojai.FieldPath... fields)`
`DBDocument`	`findById(String id, String... paths)` Reads the row and projects of only the field paths requested.
`DBDocument`	`findById(org.ojai.Value id)`
`DBDocument`	`findById(org.ojai.Value id, Condition c)`
`DBDocument`	`findById(org.ojai.Value id, Condition c, org.ojai.FieldPath... fields)`
`DBDocument`	`findById(org.ojai.Value id, Condition c, String... paths)`
`DBDocument`	`findById(org.ojai.Value id, org.ojai.FieldPath... fields)`
`DBDocument`	`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(Condition 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<? extends org.ojai.Document> rs)` Inserts a set of documents represented by the document stream into the table.
`void`	`insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs, org.ojai.FieldPath fieldAsKey)`
`void`	`insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs, String fieldAsKey)`
`void`	`insert(org.ojai.Document r, String fieldAsKey)`
`void`	`insert(String id, org.ojai.Document r)` Inserts a row with the given rowkey.
`void`	`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<? extends org.ojai.Document> rs)` Inserts a set of documents represented by the document stream into the table.
`void`	`insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs, org.ojai.FieldPath fieldAsKey)`
`void`	`insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs, String fieldAsKey)` Internally this API will get a bunch of records from the stream and write it 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()`
`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<? extends org.ojai.Document> rs)` Replaces a set of documents represented by the document stream into the table.
`void`	`replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs, org.ojai.FieldPath fieldAsKey)`
`void`	`replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs, String fieldAsKey)`
`void`	`replace(org.ojai.Document r, String fieldAsKey)`
`void`	`replace(String id, org.ojai.Document r)` Replaces a document in the table.
`void`	`replace(org.ojai.Value id, org.ojai.Document r)`
`void`	`setExcludeEmbeddedFamily(boolean v)`
`Table`	`setOption(Table.TableOption option, boolean value)`
`MapRDBTableImpl`	`setPrivateOption(MapRDBTableImpl.TablePrivateOption option, boolean value)`
`Map<org.ojai.FieldPath,Integer>`	`sortedByPath()`
`void`	`update(ByteBuffer id, Mutation m)`
`void`	`update(String id, Mutation m)` Applies a row mutation on the row identified by the row id.
`void`	`update(org.ojai.Value id, Mutation m)`

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
  - 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()
```
  - 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
    
    Throws:
    
    DBException - if the flush failed or flush of any buffered operation resulted in error
  - findById
```
public DBDocument findById(String id)
                    throws DBException
```
    Reads a single full record identified by the id. 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, null otherwise
    
    Throws:
    
    TableNotFoundException - when table does not exist to get any row
    
    DBException
  - findById
```
public DBDocument findById(ByteBuffer id)
                    throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(org.ojai.Value id)
                    throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(String id,
                  org.ojai.FieldPath... fields)
                    throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(String id,
                  String... paths)
                    throws DBException
```
    Description copied from interface: Table
    
    Reads the row and projects of only the field paths requested. Blocking operation. NULL is returned if the document with given id doesn't exist in the table. Throws DBException if there is an error in getting the document. If no path parameter is specified then it returns a full document for a given row. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    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 DBDocument findById(ByteBuffer id,
                  org.ojai.FieldPath... fields)
                    throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(ByteBuffer id,
                  String... paths)
                    throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(org.ojai.Value id,
                  org.ojai.FieldPath... fields)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(org.ojai.Value id,
                  String... paths)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(String id,
                  Condition 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 given id doesn't exist in the table. Throws DBException if there is an error in getting the document. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    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 DBDocument findById(ByteBuffer id,
                  Condition c)
                    throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(org.ojai.Value id,
                  Condition c)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(String id,
                  Condition c,
                  org.ojai.FieldPath... fields)
                    throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(String id,
                  Condition c,
                  String... paths)
                    throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(ByteBuffer id,
                  Condition c,
                  org.ojai.FieldPath... fields)
                    throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(ByteBuffer id,
                  Condition c,
                  String... paths)
                    throws DBException
```
    Specified by:
    
    findById in interface Table
    
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(org.ojai.Value id,
                  Condition c,
                  String... paths)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
public DBDocument findById(org.ojai.Value id,
                  Condition c,
                  org.ojai.FieldPath... fields)
                    throws DBException
```
    Throws:
    
    DBException
  - findById
```
public void findById(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(OpListener listener,
            ByteBuffer id)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(OpListener listener,
            org.ojai.Value id)
```
  - findById
```
public void findById(OpListener listener,
            String id,
            org.ojai.FieldPath... fields)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(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(OpListener listener,
            ByteBuffer id,
            org.ojai.FieldPath... fields)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(OpListener listener,
            ByteBuffer id,
            String... paths)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(OpListener listener,
            org.ojai.Value id,
            String... paths)
```
  - findById
```
public void findById(OpListener listener,
            org.ojai.Value id,
            org.ojai.FieldPath... fields)
```
  - findById
```
public void findById(OpListener listener,
            String id,
            Condition 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 listener. If no path parameter is specified then it returns a full document for a given row. Condition is used to specify additional criteria for reading the row. For example, I want to read from row with id as "abc" but only if the field "age" > 50. Then "age" > 50 is specified as condition.
    
    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(OpListener listener,
            ByteBuffer id,
            Condition c)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(OpListener listener,
            org.ojai.Value id,
            Condition c)
```
  - findById
```
public void findById(OpListener listener,
            String id,
            Condition c,
            org.ojai.FieldPath... fields)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(OpListener listener,
            String id,
            Condition c,
            String... paths)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(OpListener listener,
            ByteBuffer id,
            Condition c,
            org.ojai.FieldPath... fields)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(OpListener listener,
            ByteBuffer id,
            Condition c,
            String... paths)
```
    Specified by:
    
    findById in interface Table
  - findById
```
public void findById(OpListener listener,
            org.ojai.Value id,
            Condition c,
            org.ojai.FieldPath... fields)
```
  - findById
```
public void findById(OpListener listener,
            org.ojai.Value id,
            Condition c,
            String... paths)
```
  - find
```
public org.ojai.DocumentStream<DBDocument> find()
                                         throws DBException
```
    Returns record stream for all the rows in the table
    
    Specified by:
    
    find in interface Table
    
    Returns:
    record stream which can be used to retrieve each row in the table
    
    Throws:
    
    TableNotFoundException - when table does not exist to get any row
    
    DBException
  - find
```
public org.ojai.DocumentStream<DBDocument> find(String... paths)
                                         throws DBException
```
    Returns 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 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
    
    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 table does not exist to get any row
    
    DBException
  - find
```
public org.ojai.DocumentStream<DBDocument> find(org.ojai.FieldPath... fields)
                                         throws DBException
```
    Specified by:
    
    find in interface Table
    
    Throws:
    
    DBException
  - find
```
public org.ojai.DocumentStream<DBDocument> find(Condition c)
                                         throws DBException
```
    Returns record stream for all the rows in the table that match the condition.
    
    Specified by:
    
    find in interface Table
    
    Parameters:
    c - condition to check for the query
    
    Returns:
    record stream that can be used to get rows with requested fields
    
    Throws:
    
    TableNotFoundException - when table does not exist to get any row
    
    DBException
  - find
```
public org.ojai.DocumentStream<DBDocument> find(Condition c,
                                       String... paths)
                                         throws DBException
```
    Returns 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 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
    
    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 table does not exist to get any row
    
    DBException
  - find
```
public org.ojai.DocumentStream<DBDocument> find(Condition c,
                                       org.ojai.FieldPath... fields)
                                         throws DBException
```
    Specified by:
    
    find in interface Table
    
    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
    
    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 table is not accepting writes
    
    OpNotPermittedException - aerver 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
```
    Throws:
    
    DBException
  - insertOrReplace
```
public void insertOrReplace(org.ojai.Document r,
                   org.ojai.FieldPath fieldAsKey)
                     throws DBException
```
    Specified by:
    
    insertOrReplace in interface Table
    
    Throws:
    
    DBException
  - insertOrReplace
```
public void insertOrReplace(org.ojai.Document r,
                   String fieldAsKey)
                     throws DBException
```
    Specified by:
    
    insertOrReplace in interface Table
    
    Throws:
    
    DBException
  - insertOrReplace
```
public void insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs)
                     throws MultiOpException
```
    Description copied from interface: Table
    
    Inserts a set of documents represented by the document stream into the table. This is a synchronous API and it won't return until all the documents in the document stream are written to the table or some error occurs while writing the documents. Each document read from the document stream must have a field "_id" of type BINARY or UTF8-string; otherwise, the operation will fail. If there is an error in reading from the stream or in writing to the table then a MultiOpException will be thrown that contains a list of documents that failed to write to the table. Reading from a stream stops on the first read error. If only write errors occur, the iterator will stop and the rest of the documents will remain unconsumed. "fieldAsKey", when provided, will also be stored as the "_id" field in the written document for the row. If "_id" already existed in the document, then an error will be thrown. When reading the document back from the DB - the key will be returned back as usual as the "_id" field. If there is an error in reading from the stream or in writing to the table then a MultiOpException will be thrown that contains a list of documents that failed to write to the table. Reading from a stream stops on the first read error. If only write errors occur, the iterator will stop and the current list of failed document is returned in a multi op exception. The untouched documents will remain in the documentstream.
    
    Specified by:
    
    insertOrReplace in interface Table
    
    Parameters:
    rs - document stream
    
    Throws:
    
    MultiOpException - which has a list of write-failed documents and their errors.
  - insertOrReplace
```
public void insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
                   org.ojai.FieldPath fieldAsKey)
                     throws MultiOpException
```
    Specified by:
    
    insertOrReplace in interface Table
    
    Throws:
    
    MultiOpException
  - insertOrReplace
```
public void insertOrReplace(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
                   String fieldAsKey)
                     throws MultiOpException
```
    Internally this API will get a bunch of records from the stream and write it 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
    
    Throws:
    
    MultiOpException
  - update
```
public void update(String id,
          Mutation m)
            throws DBException
```
    Applies a row mutation on the row identified by the row id. All the updates specified by the mutation object are applied atomically, meaning either all of the updates in mutation are applied or none of them are applied. For example, if the mutation object specified 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 increment operation will fail. Since the set of field "zip" is also part of same mutation that operation will also be not 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,
          Mutation m)
            throws DBException
```
    Specified by:
    
    update in interface Table
    
    Throws:
    
    DBException
  - update
```
public void update(org.ojai.Value id,
          Mutation m)
            throws DBException
```
    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 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
```
    Throws:
    
    DBException
  - delete
```
public void delete(org.ojai.Document r)
            throws DBException
```
    Specified by:
    
    delete in interface Table
    
    Throws:
    
    DBException
  - delete
```
public void delete(org.ojai.Document r,
          org.ojai.FieldPath fieldAsKey)
            throws DBException
```
    Specified by:
    
    delete in interface Table
    
    Throws:
    
    DBException
  - delete
```
public void delete(org.ojai.Document r,
          String fieldAsKey)
            throws DBException
```
    Specified by:
    
    delete in interface Table
    
    Throws:
    
    DBException
  - delete
```
public void delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
          org.ojai.FieldPath fieldAsKey)
            throws MultiOpException
```
    Specified by:
    
    delete in interface Table
    
    Throws:
    
    MultiOpException
  - delete
```
public void delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs)
            throws MultiOpException
```
    Description copied from interface: Table
    
    Deletes a set of documents from the table represented by the document stream. This is a synchronous API and it won't return until all the documents in the document stream are written to the table or some error occurs while writing the documents. Each document read from the document stream must have a field "_id" of type BINARY or UTF8-string; otherwise the operation will fail. If there is an error in reading from the stream or in writing to the table then a MultiOpException will be thrown that contains a list of documents that failed to write to the table. Reading from a stream stops on the first read error. If only write errors occur, the iterator will stop and the current list of failed document is returned in a multi op exception. The untouched documents will remain in the documentstream.
    
    Specified by:
    
    delete in interface Table
    
    Parameters:
    rs - document stream
    
    Throws:
    
    MultiOpException - which has a list of write-failed documents and their errors
  - delete
```
public void delete(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
          String fieldAsKey)
            throws MultiOpException
```
    Specified by:
    
    delete in interface Table
    
    Throws:
    
    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
```
    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
```
    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
```
    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
```
    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 existing value stored in the given field for the row. The resultant value of the field will be truncated based on the original type of the field. For example, if a field 'score' is of type int and contains 60 and an increment of double '5.675' is applied, then the resultant value of the field will be 65 (65.675 will be truncated to 65). If the type to which the increment is applied is a byte, short, or int, then it needs to use long as the operation. If the passed in id is not a direct byte buffer, there will be a copy to one.
    
    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
```
    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
```
    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
```
    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 back as usual as the "_id" field. If the passed in id is not a direct byte buffer, there will be a copy to one. Note that an insertOrReplace() operation would be more efficient than an insert() call.
    
    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
    
    DocumentExistsException - when a document with id already exists in table
    
    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
```
    Throws:
    
    DBException
  - insert
```
public void insert(org.ojai.Document r)
            throws DBException
```
    Specified by:
    
    insert in interface Table
    
    Throws:
    
    DBException
  - insert
```
public void insert(org.ojai.Document r,
          org.ojai.FieldPath fieldAsKey)
            throws DBException
```
    Specified by:
    
    insert in interface Table
    
    Throws:
    
    DBException
  - insert
```
public void insert(org.ojai.Document r,
          String fieldAsKey)
            throws DBException
```
    Specified by:
    
    insert in interface Table
    
    Throws:
    
    DBException
  - insert
```
public void insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
          org.ojai.FieldPath fieldAsKey)
            throws MultiOpException
```
    Specified by:
    
    insert in interface Table
    
    Throws:
    
    MultiOpException
  - insert
```
public void insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs)
            throws MultiOpException
```
    Description copied from interface: Table
    
    Inserts a set of documents represented by the document stream into the table. This is a synchronous API that won't return until all the documents in the document stream are written to the table or some error occurs while writing the documents. Each document read from the document stream must have a field "_id" of type BINARY or UTF8-string; otherwise, the operation will fail or it will be of the DBDocument type. If a row with the given key exists on the server then it throws a document exists exception, similar to the non-documentstream-based insert() API. If there is an error in reading from the stream or in writing to the table then a MultiOpException will be thrown that contains a list of documents that failed to write to the table. Reading from a stream stops on the first read error. If only write errors occur, the iterator will stop and the current list of failed document is returned in a multi op exception. The untouched documents will remain in the documentstream.
    
    Specified by:
    
    insert in interface Table
    
    Parameters:
    rs - document stream
    
    Throws:
    
    MultiOpException - which has a list of write-failed documents and their errors
  - insert
```
public void insert(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
          String fieldAsKey)
            throws MultiOpException
```
    Specified by:
    
    insert in interface Table
    
    Throws:
    
    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 "_id" field or its value should be the same as the explicitly specified id; otherwise, the operation will fail. If the row with the given key does not exist on the server then it will throw DocumentNotFoundException. "fieldAsKey", when provided, will also be stored as the "_id" field in the written document for the row. If "_id" already existed in the document, then an error will be thrown. When reading the document back from the DB, the key would be returned back as usual as "_id" field. If the passed in id is not a direct byte buffer, there will be a copy to one. Note that an insertOrReplace() operation would be more efficient than an replace() call.
    
    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 which to add this row
    
    AccessDeniedException - when user credentials are a mismatch
    
    ReadOnlyException - when a table is not accepting writes
    
    OpNotPermittedException - when the server returns EPERM
    
    DocumentNotFoundException - when a document with the id does not exist in table
    
    DBException
  - replace
```
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
```
    Throws:
    
    DBException
  - replace
```
public void replace(org.ojai.Document r)
             throws DBException
```
    Specified by:
    
    replace in interface Table
    
    Throws:
    
    DBException
  - replace
```
public void replace(org.ojai.Document r,
           org.ojai.FieldPath fieldAsKey)
             throws DBException
```
    Specified by:
    
    replace in interface Table
    
    Throws:
    
    DBException
  - replace
```
public void replace(org.ojai.Document r,
           String fieldAsKey)
             throws DBException
```
    Specified by:
    
    replace in interface Table
    
    Throws:
    
    DBException
  - replace
```
public void replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
           org.ojai.FieldPath fieldAsKey)
             throws MultiOpException
```
    Specified by:
    
    replace in interface Table
    
    Throws:
    
    MultiOpException
  - replace
```
public void replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs)
             throws MultiOpException
```
    Description copied from interface: Table
    
    Replaces a set of documents represented by the document stream into the table. This is a synchronous API and it won't return until all the documents in the document stream are written to the table or some error occurs while writing the documents. Each document read from the document stream must have a field "_id" of type BINARY or UTF8-string; otherwise, the operation will fail or it will be of DBDocument type. If the row with the given key does not exist on the server then it throws, a document not exists exception, similar to the non-documentstream based replace() API. If there is an error in reading from the stream or in writing to the table then a MultiOpException will be thrown that contains a list of documents that failed to write to the table. Reading from a stream stops on the first read error. If only write errors occur, the iterator will stop and the current list of failed document is returned in a multi op exception. The untouched documents will remain in the documentstream.
    
    Specified by:
    
    replace in interface Table
    
    Parameters:
    rs - document stream
    
    Throws:
    
    MultiOpException - which has list of write-failed documents and their errors
  - replace
```
public void replace(org.ojai.DocumentStream<? extends org.ojai.Document> rs,
           String fieldAsKey)
             throws MultiOpException
```
    Specified by:
    
    replace in interface Table
    
    Throws:
    
    MultiOpException
  - checkAndMutate
```
public boolean checkAndMutate(String id,
                     Condition condition,
                     Mutation m)
                       throws DBException
```
    Atomically evaluates the condition on given row and if the condition holds true for the row then mutation is applied on the row. If id doesn't exist, returns false (no exception is thrown). If mutation operation fails, it throws an exception.
    
    Specified by:
    
    checkAndMutate in interface Table
    
    Parameters:
    id - row id
    condition - condition to evaluate on the row
    m - mutation to apply on the row
    
    Returns:
    True if the condition is true for the row otherwise false
    
    Throws:
    
    DBException
  - checkAndMutate
```
public boolean checkAndMutate(ByteBuffer id,
                     Condition condition,
                     Mutation m)
                       throws DBException
```
    Specified by:
    
    checkAndMutate in interface Table
    
    Throws:
    
    DBException
  - checkAndMutate
```
public boolean checkAndMutate(org.ojai.Value id,
                     Condition condition,
                     Mutation m)
                       throws DBException
```
    Throws:
    
    DBException
  - checkAndDelete
```
public boolean checkAndDelete(String id,
                     Condition 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 - 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,
                     Condition condition)
                       throws DBException
```
    Specified by:
    
    checkAndDelete in interface Table
    
    Throws:
    
    DBException
  - checkAndDelete
```
public boolean checkAndDelete(org.ojai.Value id,
                     Condition condition)
                       throws DBException
```
    Throws:
    
    DBException
  - checkAndReplace
```
public boolean checkAndReplace(String id,
                      Condition 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 - 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,
                      Condition condition,
                      org.ojai.Document r)
                        throws DBException
```
    Specified by:
    
    checkAndReplace in interface Table
    
    Throws:
    
    DBException
  - checkAndReplace
```
public boolean checkAndReplace(org.ojai.Value id,
                      Condition condition,
                      org.ojai.Document r)
                        throws DBException
```
    Throws:
    
    DBException
  - close
```
public void close()
           throws DBException
```
    Description copied from interface: Table
    
    Override AutoCloseable.close() to avoid declaring a checked exception.
    
    Specified by:
    
    close in interface Table
    
    Specified by:
    
    close in interface AutoCloseable
    
    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(Condition condition)
                            throws DBException
```
    Specified by:
    
    getTabletInfos in interface Table
    
    Returns:
    TabletInfo for all current tablets of this table that has a start and end key matching the range specified by the condition object
    
    Throws:
    
    DBException

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

testMulitOpExIdx

Constructor Detail

MapRDBTableImpl

Method Detail

maprTable

idPathMap

sortedByPath

idToCFNameMap

setOption

isKeepInsertionOrder

getDeletes

isPreserveTS

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

insertOrReplace

insertOrReplace