oracle.kv.table

## Interface TableAPI

-     public interface TableAPI

  TableAPI is a handle for the table interface to an Oracle NoSQL store. Tables are an independent layer implemented on top of the `key/value interface`. While the two interfaces are not incompatible, in general applications will use one or the other. To create a TableAPI instance use `getTableAPI()`.

  The table interface is required to use secondary indexes and supported data types.

  Tables are similar to tables in a relational database. They are named and contain a set of strongly typed records, called rows. Rows in an Oracle NoSQL Database table are analogous to rows in a relational system and each row has one or more named, typed data values. These fields can be compared to a relational database column. A single top-level row in a table is contained in a `Row` object. Row is used as return value for TableAPI get operations as well as a key plus value object for TableAPI put operations. All rows in a given table have the same fields. Tables have a well-defined primary key which comprises one or more of its fields, in order. Primary key fields must be simple (single-valued) data types.

  The data types supported in tables are well-defined and include simple single-valued types such as Integer, String, Date, etc., in addition to several complex, multi-valued types -- Array, Map, and Record. Complex objects allow for creation of arbitrarily complex, nested rows.

  All operations on this interface include parameters that supply optional arguments to control non-default behavior. The types of these parameter objects varies depending on whether the operation is a read, update, or a multi-read style operation returning more than one result or an iterator.

  In order to control, and take advantage of sharding across partitions tables may be defined in a hierarchy. A top-level table is one without a parent and may be defined in a way such that its primary key spreads the table rows across partitions. The primary key for this sort of table has a complete shard key but an empty minor key. Tables with parents always have a primary key with a minor key. The primary key of a child table comprises the primary key of its immediate parent plus the fields defined in the child table as being part of its primary key. This means that the fields of a child table implicitly include the primary key fields of all of its ancestors.

  Some of the methods in this interface include `MultiRowOptions` which can be used to cause operations to return not only rows from the target table but from its ancestors and descendant tables as well. This allows for efficient and transactional mechanisms to return related groups of rows. The MultiRowOptions object is also used to specify value ranges that apply to the operation.

  Since:
    3.0

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `delete(PrimaryKey key, ReturnRow prevRow, WriteOptions writeOptions)` Deletes a row from a table.
    `boolean` | `deleteIfVersion(PrimaryKey key, Version matchVersion, ReturnRow prevRow, WriteOptions writeOptions)` Deletes a row from a table but only if its version matches the one specified in matchVersion.
    `List<TableOperationResult>` | `execute(List<TableOperation> operations, WriteOptions writeOptions)` This method provides an efficient and transactional mechanism for executing a sequence of operations associated with tables that share the same shard key portion of their primary keys.
    `Row` | `get(PrimaryKey key, ReadOptions readOptions)` Gets the `Row` associated with the primary key.
    `Table` | `getTable(String tableName)` Gets an instance of a table.
    `TableOperationFactory` | `getTableOperationFactory()` Returns a `TableOperationFactory` to create operations passed to `execute(java.util.List<oracle.kv.table.TableOperation>, oracle.kv.table.WriteOptions)`.
    `Map<String,Table>` | `getTables()` Gets all known tables.
    `int` | `multiDelete(PrimaryKey key, MultiRowOptions getOptions, WriteOptions writeOptions)` Deletes multiple rows from a table in an atomic operation.
    `List<Row>` | `multiGet(PrimaryKey key, MultiRowOptions getOptions, ReadOptions readOptions)` Returns the rows associated with a partial primary key in an atomic manner.
    `List<PrimaryKey>` | `multiGetKeys(PrimaryKey key, MultiRowOptions getOptions, ReadOptions readOptions)` Return the rows associated with a partial primary key in an atomic manner.
    `Version` | `put(Row row, ReturnRow prevRow, WriteOptions writeOptions)` Puts a row into a table.
    `Version` | `putIfAbsent(Row row, ReturnRow prevRow, WriteOptions writeOptions)` Puts a row into a table, but only if the row does not exist.
    `Version` | `putIfPresent(Row row, ReturnRow prevRow, WriteOptions writeOptions)` Puts a row into a table, but only if the row already exists.
    `Version` | `putIfVersion(Row row, Version matchVersion, ReturnRow prevRow, WriteOptions writeOptions)` Puts a row, but only if the version of the existing row matches the matchVersion argument.
    `TableIterator<Row>` | `tableIterator(IndexKey key, MultiRowOptions getOptions, TableIteratorOptions iterateOptions)` Returns an iterator over the rows associated with an index key.
    `TableIterator<Row>` | `tableIterator(PrimaryKey key, MultiRowOptions getOptions, TableIteratorOptions iterateOptions)` Returns an iterator over the rows associated with a partial primary key.
    `TableIterator<KeyPair>` | `tableKeysIterator(IndexKey key, MultiRowOptions getOptions, TableIteratorOptions iterateOptions)` Return the keys for matching rows associated with an index key.
    `TableIterator<PrimaryKey>` | `tableKeysIterator(PrimaryKey key, MultiRowOptions getOptions, TableIteratorOptions iterateOptions)` Returns an iterator over the keys associated with a partial primary key.

- - ### Method Detail

    - #### getTable

          Table getTable(String tableName)
                         throws FaultException

      Gets an instance of a table. This method can be retried in the event that the specified table is not yet fully initialized. This call will typically go to a server node to find the requested metadata and/or verify that it is current.

      This interface will only retrieve top-level tables -- those with no parent table. Child tables are retrieved using `Table.getChildTable(java.lang.String)`.

      Parameters:
        `tableName` - the name of the target table
      Returns:
        the table or null if the table does not exist
      Throws:
        `FaultException` - if the operation fails to communicate with a server node that has the table metadata

    - #### getTables

          Map<String,Table> getTables()
                                      throws FaultException

      Gets all known tables. Only top-level tables -- those without parent tables -- are returned. Child tables of a parent are retrieved using `Table.getChildTables()`.
      Returns:
        the map of tables
      Throws:
        `FaultException` - if the operation fails to communicate with a server node that has the table metadata

    - #### get

          Row get(PrimaryKey key,
                ReadOptions readOptions)
                  throws ConsistencyException,
                         RequestTimeoutException,
                         FaultException

      Gets the `Row` associated with the primary key.
      Parameters:
        `key` - the primary key for a table. It must be a complete primary key, with all fields set.
        `readOptions` - non-default options for the operation or null to get default behavior
      Returns:
        the matching Row, or null if not found
      Throws:
        `ConsistencyException` - if the specified `Consistency` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the primary key is not complete

    - #### multiGet

          List<Row> multiGet(PrimaryKey key,
                           MultiRowOptions getOptions,
                           ReadOptions readOptions)
                             throws ConsistencyException,
                                    RequestTimeoutException,
                                    FaultException

      Returns the rows associated with a partial primary key in an atomic manner. Rows are returned in primary key order. The key used must contain all of the fields defined for the table's shard key.
      Parameters:
        `key` - the primary key for the operation. It may be partial or complete.
        `getOptions` - a `MultiRowOptions` object used to control ranges in the operation and whether ancestor and descendant tables are included in the results. It may be null. The table used to construct the `PrimaryKey` parameter is always included as a target.
        `readOptions` - non-default options for the operation or null to get default behavior
      Returns:
        a list of matching rows, one for each selected record, or an empty list if no rows are matched
      Throws:
        `ConsistencyException` - if the specified `Consistency` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the primary key is malformed or does not contain the required fields

    - #### multiGetKeys

          List<PrimaryKey> multiGetKeys(PrimaryKey key,
                                      MultiRowOptions getOptions,
                                      ReadOptions readOptions)
                                        throws ConsistencyException,
                                               RequestTimeoutException,
                                               FaultException

      Return the rows associated with a partial primary key in an atomic manner. Keys are returned in primary key order. The key used must contain all of the fields defined for the table's shard key.
      Parameters:
        `key` - the primary key for the operation. It may be partial or complete
        `getOptions` - a `MultiRowOptions` object used to control ranges in the operation and whether ancestor and descendant tables are included in the results. It may be null. The table used to construct the `PrimaryKey` parameter is always included as a target.
        `readOptions` - non-default options for the operation or null to get default behavior
      Returns:
        a list of matching keys, one for each selected row, or an empty list if no rows are matched
      Throws:
        `ConsistencyException` - if the specified `Consistency` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the primary key is malformed or does not contain the required fields

    - #### tableIterator

          TableIterator<Row> tableIterator(PrimaryKey key,
                                         MultiRowOptions getOptions,
                                         TableIteratorOptions iterateOptions)
                                           throws ConsistencyException,
                                                  RequestTimeoutException,
                                                  FaultException

      Returns an iterator over the rows associated with a partial primary key.
      Parameters:
        `key` - the primary key for the operation. It may be partial or complete shard key. If the key contains a partial shard key the iteration goes to all partitions in the store. If the key contains a complete shard key the operation is restricted to the target partition. If the key has no fields set the entire table is matched.
        `getOptions` - a `MultiRowOptions` object used to control ranges in the operation and whether ancestor and descendant tables are included in the results. It may be null. The table used to construct the `PrimaryKey` parameter is always included as a target.
        `iterateOptions` - the non-default arguments for consistency of the operation and to control the iteration or null to get default behavior. The default Direction in `TableIteratorOptions` is `Direction.UNORDERED`. If the primary key contains a complete shard key both `Direction.FORWARD` and `Direction.REVERSE` are allowed.
      Returns:
        an iterator over the matching rows, or if none match an empty iterator. If the primary key contains a complete shard key the methods on TableIterator associated with `ParallelScanIterator`, such as statistics, will not return meaningful information because the iteration will be single-partition and not parallel.
      Throws:
        `ConsistencyException` - if the specified `Consistency` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the primary key is malformed

    - #### tableKeysIterator

          TableIterator<PrimaryKey> tableKeysIterator(PrimaryKey key,
                                                    MultiRowOptions getOptions,
                                                    TableIteratorOptions iterateOptions)
                                                      throws ConsistencyException,
                                                             RequestTimeoutException,
                                                             FaultException

      Returns an iterator over the keys associated with a partial primary key.
      Parameters:
        `key` - the primary key for the operation. It may be partial or complete shard key. If the key contains a partial shard key the iteration goes to all partitions in the store. If the key contains a complete shard key the operation is restricted to the target partition. If the key has no fields set the entire table is matched.
        `getOptions` - a `MultiRowOptions` object used to control ranges in the operation and whether ancestor and descendant tables are included in the results. It may be null. The table used to construct the `PrimaryKey` parameter is always included as a target.
        `iterateOptions` - the non-default arguments for consistency of the operation and to control the iteration or null to get default behavior. The default Direction in `TableIteratorOptions` is `Direction.UNORDERED`. If the primary key contains a complete shard key both `Direction.FORWARD` and `Direction.REVERSE` are allowed.
      Returns:
        an iterator over the primary keys of matching rows, or if none match an empty iterator. If the primary key contains a complete shard key the methods on TableIterator associated with `ParallelScanIterator`, such as statistics, will not return meaningful information because the iteration will be single-partition and not parallel.
      Throws:
        `ConsistencyException` - if the specified `Consistency` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the primary key is malformed

    - #### tableIterator

          TableIterator<Row> tableIterator(IndexKey key,
                                         MultiRowOptions getOptions,
                                         TableIteratorOptions iterateOptions)
                                           throws ConsistencyException,
                                                  RequestTimeoutException,
                                                  FaultException

      Returns an iterator over the rows associated with an index key. This method requires an additional database read on the server side to get row information for matching rows. Ancestor table rows for matching index rows may be returned as well if specified in the `getOptions` paramter. Index operations may not specify the return of child table rows.
      Parameters:
        `key` - the index key for the operation. It may be partial or complete. If the key has no fields set the entire index is matched.
        `getOptions` - a `MultiRowOptions` object used to control ranges in the operation and whether ancestor and descendant tables are included in the results. It may be null. The table on which the index is defined is always included as a target. Child tables cannot be included for index operations.
        `iterateOptions` - the non-default arguments for consistency of the operation and to control the iteration or null to get default behavior. The default Direction in `TableIteratorOptions` is `Direction.FORWARD`.
      Returns:
        an iterator over the matching rows, or if none match an empty iterator
      Throws:
        `ConsistencyException` - if the specified `Consistency` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the primary key is malformed
        `UnsupportedOperationException` - if the `getOptions` parameter specifies the return of child tables

    - #### tableKeysIterator

          TableIterator<KeyPair> tableKeysIterator(IndexKey key,
                                                 MultiRowOptions getOptions,
                                                 TableIteratorOptions iterateOptions)
                                                   throws ConsistencyException,
                                                          RequestTimeoutException,
                                                          FaultException

      Return the keys for matching rows associated with an index key. The iterator returned only references information directly available from the index. No extra fetch operations are performed. Ancestor table keys for matching index keys may be returned as well if specified in the `getOptions` paramter. Index operations may not specify the return of child table keys.
      Parameters:
        `key` - the index key for the operation. It may be partial or complete. If the key has no fields set the entire index is matched.
        `getOptions` - a `MultiRowOptions` object used to control ranges in the operation and whether ancestor and descendant tables are included in the results. It may be null. The table on which the index is defined is always included as a target. Child tables cannot be included for index operations.
        `iterateOptions` - the non-default arguments for consistency of the operation and to control the iteration or null to get default behavior. The default Direction in `TableIteratorOptions` is `Direction.FORWARD`.
      Returns:
        an iterator over `KeyPair` objects, which provide access to both the `PrimaryKey` associated with a match but the values in the matching `IndexKey` as well without an additional fetch of the Row itself.
      Throws:
        `ConsistencyException` - if the specified `Consistency` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the primary key is malformed
        `UnsupportedOperationException` - if the `getOptions` parameter specifies the return of child tables

    - #### put

          Version put(Row row,
                    ReturnRow prevRow,
                    WriteOptions writeOptions)
                      throws DurabilityException,
                             RequestTimeoutException,
                             FaultException

      Puts a row into a table. The row must contain a complete primary key and all required fields.
      Parameters:
        `row` - the row to put
        `prevRow` - a `ReturnRow` object to contain the previous row value and version associated with the given row, or null if they should not be returned. If a previous row does not exist, or the `ReturnRow.Choice` specifies that they should not be returned, the version in this object is set to null and none of the row's fields are available.
        `writeOptions` - non-default arguments controlling the durability of the operation, or null to get default behavior. See `WriteOptions` for more information.
      Returns:
        the version of the new row value
      Throws:
        `DurabilityException` - if the specified `Durability` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the `row` does not have a complete primary key or is otherwise invalid

    - #### putIfAbsent

          Version putIfAbsent(Row row,
                            ReturnRow prevRow,
                            WriteOptions writeOptions)
                              throws DurabilityException,
                                     RequestTimeoutException,
                                     FaultException

      Puts a row into a table, but only if the row does not exist. The row must contain a complete primary key and all required fields.
      Parameters:
        `row` - the row to put
        `prevRow` - a `ReturnRow` object to contain the previous row value and version associated with the given row, or null if they should not be returned. If a previous row does not exist, or the `ReturnRow.Choice` specifies that they should not be returned, the version in this object is set to null and none of the row's fields are available.
        `writeOptions` - non-default arguments controlling the durability of the operation, or null to get default behavior.
      Returns:
        the version of the new value, or null if an existing value is present and the put is unsuccessful
      Throws:
        `DurabilityException` - if the specified `Durability` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the `row` does not have a complete primary key or is otherwise invalid

    - #### putIfPresent

          Version putIfPresent(Row row,
                             ReturnRow prevRow,
                             WriteOptions writeOptions)
                               throws DurabilityException,
                                      RequestTimeoutException,
                                      FaultException

      Puts a row into a table, but only if the row already exists. The row must contain a complete primary key and all required fields.
      Parameters:
        `row` - the row to put
        `prevRow` - a `ReturnRow` object to contain the previous row value and version associated with the given row, or null if they should not be returned. If a previous row does not exist, or the `ReturnRow.Choice` specifies that they should not be returned, the version in this object is set to null and none of the row's fields are available.
        `writeOptions` - non-default arguments controlling the durability of the operation, or null to get default behavior.
      Returns:
        the version of the new value, or null if there is no existing row and the put is unsuccessful
      Throws:
        `DurabilityException` - if the specified `Durability` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the `Row` does not have a complete primary key or is otherwise invalid.

    - #### putIfVersion

          Version putIfVersion(Row row,
                             Version matchVersion,
                             ReturnRow prevRow,
                             WriteOptions writeOptions)
                               throws DurabilityException,
                                      RequestTimeoutException,
                                      FaultException

      Puts a row, but only if the version of the existing row matches the matchVersion argument. Used when updating a value to ensure that it has not changed since it was last read. The row must contain a complete primary key and all required fields.
      Parameters:
        `row` - the row to put
        `matchVersion` - the version to match
        `prevRow` - a `ReturnRow` object to contain the previous row value and version associated with the given row, or null if they should not be returned. If a previous row does not exist, or the `ReturnRow.Choice` specifies that they should not be returned, the version in this object is set to null and none of the row's fields are available.
        `writeOptions` - non-default arguments controlling the durability of the operation, or null to get default behavior.
      Returns:
        the version of the new value, or null if the versions do not match and the put is unsuccessful
      Throws:
        `DurabilityException` - if the specified `Durability` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the `Row` does not have a complete primary key or is otherwise invalid

    - #### delete

          boolean delete(PrimaryKey key,
                       ReturnRow prevRow,
                       WriteOptions writeOptions)
                         throws DurabilityException,
                                RequestTimeoutException,
                                FaultException

      Deletes a row from a table.
      Parameters:
        `key` - the primary key for the row to delete
        `prevRow` - a `ReturnRow` object to contain the previous row value and version associated with the given row, or null if they should not be returned. If a previous row does not exist, or the `ReturnRow.Choice` specifies that they should not be returned, the version in this object is set to null and none of the row's fields are available.
        `writeOptions` - non-default arguments controlling the durability of the operation, or null to get default behavior.
      Returns:
        true if the row existed and was deleted, false otherwise
      Throws:
        `DurabilityException` - if the specified `Durability` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the primary key is not complete

    - #### deleteIfVersion

          boolean deleteIfVersion(PrimaryKey key,
                                Version matchVersion,
                                ReturnRow prevRow,
                                WriteOptions writeOptions)
                                  throws DurabilityException,
                                         RequestTimeoutException,
                                         FaultException

      Deletes a row from a table but only if its version matches the one specified in matchVersion.
      Parameters:
        `key` - the primary key for the row to delete
        `matchVersion` - the version to match
        `prevRow` - a `ReturnRow` object to contain the previous row value and version associated with the given row, or null if they should not be returned. If a previous row does not exist, or the `ReturnRow.Choice` specifies that they should not be returned, or the matchVersion parameter matches the existing value and the delete is successful, the version in this object is set to null and none of the row's fields are available.
        `writeOptions` - non-default arguments controlling the durability of the operation, or null to get default behavior.
      Returns:
        true if the row existed and its version matched matchVersion and was successfully deleted, false otherwise
      Throws:
        `DurabilityException` - if the specified `Durability` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the primary key is not complete

    - #### multiDelete

          int multiDelete(PrimaryKey key,
                        MultiRowOptions getOptions,
                        WriteOptions writeOptions)
                          throws DurabilityException,
                                 RequestTimeoutException,
                                 FaultException

      Deletes multiple rows from a table in an atomic operation. The key used may be partial but must contain all of the fields that are in the shard key.
      Parameters:
        `key` - the primary key for the row to delete
        `getOptions` - a `MultiRowOptions` object used to control ranges in the operation and whether ancestor and descendant tables are included in the operation. It may be null. The table used to construct the `PrimaryKey` parameter is always included as a target.
        `writeOptions` - non-default arguments controlling the durability of the operation, or null to get default behavior.
      Returns:
        the number of rows deleted from the table
      Throws:
        `DurabilityException` - if the specified `Durability` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if the primary key is malformed or does not contain all shard key fields

    - #### getTableOperationFactory

          TableOperationFactory getTableOperationFactory()

      Returns a `TableOperationFactory` to create operations passed to `execute(java.util.List<oracle.kv.table.TableOperation>, oracle.kv.table.WriteOptions)`. Not all operations must use the same table but they must all use the same shard portion of the primary key.
      Returns:
        an empty `TableOperationFactory`

    - #### execute

          List<TableOperationResult> execute(List<TableOperation> operations,
                                           WriteOptions writeOptions)
                                             throws OperationExecutionException,
                                                    DurabilityException,
                                                    FaultException

      This method provides an efficient and transactional mechanism for executing a sequence of operations associated with tables that share the same shard key portion of their primary keys. The efficiency results from the use of a single network interaction to accomplish the entire sequence of operations.

      The operations passed to this method are created using an `TableOperationFactory`, which is obtained from the `getTableOperationFactory()` method.

      All the `operations` specified are executed within the scope of a single transaction that effectively provides serializable isolation. The transaction is started and either committed or aborted by this method. If the method returns without throwing an exception, then all operations were executed atomically, the transaction was committed, and the returned list contains the result of each operation.

      If the transaction is aborted for any reason, an exception is thrown. An abort may occur for two reasons:

      1. An operation or transaction results in an exception that is considered a fault, such as a durability or consistency error, a failure due to message delivery or networking error, etc. A `FaultException` is thrown.
      2. An individual operation returns normally but is unsuccessful as defined by the particular operation (e.g., a delete operation for a non-existent key) and `true` was passed for the `abortIfUnsuccessful` parameter when the operation was created using the `TableOperationFactory`. An `OperationExecutionException` is thrown, and the exception contains information about the failed operation.

      Operations are not executed in the sequence they appear the `operations` list, but are rather executed in an internally defined sequence that prevents deadlocks. Additionally, if there are two operations for the same key, their relative order of execution is arbitrary; this should be avoided.

      Parameters:
        `operations` - the list of operations to be performed. Note that all operations in the list must specify primary keys with the same complete shard key.
        `writeOptions` - non-default arguments controlling the durability of the operation, or null to get default behavior.
      Returns:
        the sequence of results associated with the operation. There is one entry for each TableOperation in the operations argument list. The returned list is in the same order as the operations argument list.
      Throws:
        `OperationExecutionException` - if an operation is not successful as defined by the particular operation (e.g., a delete operation for a non-existent key) and `true` was passed for the `abortIfUnsuccessful` parameter when the operation was created using the `TableOperationFactory`.
        `DurabilityException` - if the specified `Durability` cannot be satisfied
        `RequestTimeoutException` - if the request timeout interval was exceeded
        `FaultException` - if the operation cannot be completed for any reason
        `IllegalArgumentException` - if operations is null or empty, or not all operations operate on primary keys with the same shard key, or more than one operation has the same primary key, or any of the primary keys are incomplete.

Copyright (c) 2011, 2014 Oracle and/or its affiliates. All rights reserved.