## Uses of Class
com.thinkaurelius.titan.diskstorage.BackendException

- Packages that use BackendException
  Package | Description
  --- | ---
  com.thinkaurelius.titan.diskstorage |
  com.thinkaurelius.titan.diskstorage.common |
  com.thinkaurelius.titan.diskstorage.configuration.backend |
  com.thinkaurelius.titan.diskstorage.idmanagement |
  com.thinkaurelius.titan.diskstorage.indexing |
  com.thinkaurelius.titan.diskstorage.keycolumnvalue |
  com.thinkaurelius.titan.diskstorage.keycolumnvalue.cache |
  com.thinkaurelius.titan.diskstorage.keycolumnvalue.inmemory |
  com.thinkaurelius.titan.diskstorage.keycolumnvalue.keyvalue |
  com.thinkaurelius.titan.diskstorage.keycolumnvalue.ttl |
  com.thinkaurelius.titan.diskstorage.locking |
  com.thinkaurelius.titan.diskstorage.locking.consistentkey |
  com.thinkaurelius.titan.diskstorage.log |
  com.thinkaurelius.titan.diskstorage.log.kcvs |
  com.thinkaurelius.titan.diskstorage.util |
  com.thinkaurelius.titan.graphdb.database |

- - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage

    Subclasses of BackendException in com.thinkaurelius.titan.diskstorage
    Modifier and Type | Class and Description
    --- | ---
    `class` | `PermanentBackendException` This exception signifies a permanent exception in a Titan storage backend, that is, an exception that is due to a permanent failure while persisting data.
    `class` | `TemporaryBackendException` This exception signifies a (potentially) temporary exception in a Titan storage backend, that is, an exception that is due to a temporary unavailability or other exception that is not permanent in nature.

    Methods in com.thinkaurelius.titan.diskstorage that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | BackendTransaction.`acquireEdgeLock(StaticBuffer key, Entry entry)`
    `void` | BackendTransaction.`acquireEdgeLock(StaticBuffer key, StaticBuffer column)` Acquires a lock for the key-column pair on the edge store which ensures that nobody else can take a lock on that respective entry for the duration of this lock (but somebody could potentially still overwrite the key-value entry without taking a lock).
    `void` | BackendTransaction.`acquireIndexLock(StaticBuffer key, Entry entry)`
    `void` | BackendTransaction.`acquireIndexLock(StaticBuffer key, StaticBuffer column)` Acquires a lock for the key-column pair on the property index which ensures that nobody else can take a lock on that respective entry for the duration of this lock (but somebody could potentially still overwrite the key-value entry without taking a lock).
    `BackendTransaction` | Backend.`beginTransaction(TransactionConfiguration configuration, KeyInformation.Retriever indexKeyRetriever)` Opens a new transaction against all registered backend system wrapped in one `BackendTransaction`.
    `void` | Backend.`clearStorage()` Clears the storage of all registered backend data providers.
    `void` | IDAuthority.`close()` Closes the IDAuthority and any underlying storage backend.
    `void` | Backend.`close()`
    `void` | BackendTransaction.`commit()`
    `void` | BaseTransaction.`commit()` Commits the transaction and persists all modifications to the backend.
    `void` | BackendTransaction.`commitStorage()`
    `IDBlock` | IDAuthority.`getIDBlock(int partition, int idNamespace, Duration timeout)` Returns a block of new ids in the form of `IDBlock`.
    `List<KeyRange>` | IDAuthority.`getLocalIDPartition()` Returns the lower and upper limits of the key range assigned to this local machine as an array with two entries.
    `Log` | Backend.`getUserLog(String identifier)`
    `void` | BackendTransaction.`mutateEdges(StaticBuffer key, List<Entry> additions, List<Entry> deletions)` Applies the specified insertion and deletion mutations on the edge store to the provided key.
    `void` | BackendTransaction.`mutateIndex(StaticBuffer key, List<Entry> additions, List<Entry> deletions)` Applies the specified insertion and deletion mutations on the property index to the provided key.
    `void` | BackendTransaction.`rollback()` Rolls back all transactions and makes sure that this does not get cut short by exceptions.
    `void` | BaseTransaction.`rollback()` Aborts (or rolls back) the transaction.

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.common

    Methods in com.thinkaurelius.titan.diskstorage.common that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractStoreTransaction.`commit()`
    `void` | AbstractStoreTransaction.`rollback()`
    `protected void` | DistributedStoreManager.`sleepAfterWrite(StoreTransaction txh, DistributedStoreManager.MaskedTimestamp mustPass)` This method attempts to generate Rid in the following three ways, in order, returning the value produced by the first successful attempt in the sequence.

    Constructors in com.thinkaurelius.titan.diskstorage.common that throw BackendException
    Constructor and Description
    `LocalStoreManager(Configuration storageConfig)`

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.configuration.backend

    Constructors in com.thinkaurelius.titan.diskstorage.configuration.backend that throw BackendException
    Constructor and Description
    `KCVSConfiguration(BackendOperation.TransactionalProvider txProvider, TimestampProvider times, KeyColumnValueStore store, String identifier)`

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.idmanagement

    Methods in com.thinkaurelius.titan.diskstorage.idmanagement that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | ConsistentKeyIDAuthority.`close()`
    `IDBlock` | ConsistentKeyIDAuthority.`getIDBlock(int partition, int idNamespace, Duration timeout)`
    `List<KeyRange>` | ConsistentKeyIDAuthority.`getLocalIDPartition()`
    `StoreTransaction` | ConsistentKeyIDAuthority.`openTx()`

    Constructors in com.thinkaurelius.titan.diskstorage.idmanagement that throw BackendException
    Constructor and Description
    `ConsistentKeyIDAuthority(KeyColumnValueStore idStore, StoreManager manager, Configuration config)`

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.indexing

    Methods in com.thinkaurelius.titan.diskstorage.indexing that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `BaseTransactionConfigurable` | IndexProvider.`beginTransaction(BaseTransactionConfig config)` Returns a transaction handle for a new index transaction.
    `void` | IndexProvider.`clearStorage()` Clears the index and removes all entries in all stores.
    `void` | IndexProvider.`close()` Closes the index
    `void` | IndexTransaction.`commit()`
    `void` | IndexProvider.`mutate(Map<String,Map<String,IndexMutation>> mutations, KeyInformation.IndexRetriever informations, BaseTransaction tx)` Mutates the index (adds and removes fields or entire documents)
    `List<String>` | IndexTransaction.`query(IndexQuery query)`
    `List<String>` | IndexProvider.`query(IndexQuery query, KeyInformation.IndexRetriever informations, BaseTransaction tx)` Executes the given query against the index.
    `Iterable<RawQuery.Result<String>>` | IndexTransaction.`query(RawQuery query)`
    `Iterable<RawQuery.Result<String>>` | IndexProvider.`query(RawQuery query, KeyInformation.IndexRetriever informations, BaseTransaction tx)` Executes the given raw query against the index
    `void` | IndexTransaction.`register(String store, String key, KeyInformation information)`
    `void` | IndexProvider.`register(String store, String key, KeyInformation information, BaseTransaction tx)` This method registers a new key for the specified index store with the given data type.
    `void` | IndexTransaction.`restore(Map<String,Map<String,List<IndexEntry>>> documents)`
    `void` | IndexProvider.`restore(Map<String,Map<String,List<IndexEntry>>> documents, KeyInformation.IndexRetriever informations, BaseTransaction tx)` Restores the index to the state of the primary data store as given in the `documents` variable.
    `void` | IndexTransaction.`rollback()`

    Constructors in com.thinkaurelius.titan.diskstorage.indexing that throw BackendException
    Constructor and Description
    `IndexTransaction(IndexProvider index, KeyInformation.IndexRetriever keyInformations, BaseTransactionConfig config, Duration maxWriteTime)`

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.keycolumnvalue

    Methods in com.thinkaurelius.titan.diskstorage.keycolumnvalue that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | ReadOnlyKeyColumnValueStore.`acquireLock(StaticBuffer key, StaticBuffer column, StaticBuffer expectedValue, StoreTransaction txh)`
    `void` | KeyColumnValueStore.`acquireLock(StaticBuffer key, StaticBuffer column, StaticBuffer expectedValue, StoreTransaction txh)` Attempts to claim a lock on the value at the specified `key` and `column` pair.
    `void` | KCVSProxy.`acquireLock(StaticBuffer key, StaticBuffer column, StaticBuffer expectedValue, StoreTransaction txh)`
    `StoreTransaction` | KCVSManagerProxy.`beginTransaction(BaseTransactionConfig config)`
    `StoreTransaction` | StoreManager.`beginTransaction(BaseTransactionConfig config)` Returns a transaction handle for a new transaction according to the given configuration.
    `void` | KCVSManagerProxy.`clearStorage()`
    `void` | StoreManager.`clearStorage()` Deletes and clears all database in this storage manager.
    `void` | KCVSManagerProxy.`close()`
    `void` | KeyColumnValueStore.`close()` Closes this store
    `void` | KCVSProxy.`close()`
    `void` | StoreManager.`close()` Closes the Storage Manager and all databases that have been opened.
    `static boolean` | KCVSUtil.`containsKey(KeyColumnValueStore store, StaticBuffer key, int maxColumnLength, StoreTransaction txh)`
    `static boolean` | KCVSUtil.`containsKey(KeyColumnValueStore store, StaticBuffer key, StoreTransaction txh)`
    `static boolean` | KCVSUtil.`containsKeyColumn(KeyColumnValueStore store, StaticBuffer key, StaticBuffer column, StoreTransaction txh)` Returns true if the specified key-column pair exists in the store.
    `static StaticBuffer` | KCVSUtil.`get(KeyColumnValueStore store, StaticBuffer key, StaticBuffer column, StoreTransaction txh)` Retrieves the value for the specified column and key under the given transaction from the store if such exists, otherwise returns NULL
    `static KeyIterator` | KCVSUtil.`getKeys(KeyColumnValueStore store, StoreFeatures features, int keyLength, int sliceLength, StoreTransaction txh)` If the store supports unordered scans, then call {#link `KeyColumnValueStore.getKeys(SliceQuery, StoreTransaction)`.
    `KeyIterator` | KeyColumnValueStore.`getKeys(KeyRangeQuery query, StoreTransaction txh)` Returns a `KeyIterator` over all keys that fall within the key-range specified by the given query and have one or more columns matching the column-range.
    `KeyIterator` | KCVSProxy.`getKeys(KeyRangeQuery keyQuery, StoreTransaction txh)`
    `KeyIterator` | KeyColumnValueStore.`getKeys(SliceQuery query, StoreTransaction txh)` Returns a `KeyIterator` over all keys in the store that have one or more columns matching the column-range.
    `KeyIterator` | KCVSProxy.`getKeys(SliceQuery columnQuery, StoreTransaction txh)`
    `List<KeyRange>` | KCVSManagerProxy.`getLocalKeyPartition()`
    `List<KeyRange>` | StoreManager.`getLocalKeyPartition()` Returns `KeyRange`s locally hosted on this machine.
    `EntryList` | KeyColumnValueStore.`getSlice(KeySliceQuery query, StoreTransaction txh)` Retrieves the list of entries (i.e.
    `EntryList` | KCVSProxy.`getSlice(KeySliceQuery query, StoreTransaction txh)`
    `Map<StaticBuffer,EntryList>` | KeyColumnValueStore.`getSlice(List<StaticBuffer> keys, SliceQuery query, StoreTransaction txh)` Retrieves the list of entries (i.e.
    `Map<StaticBuffer,EntryList>` | KCVSProxy.`getSlice(List<StaticBuffer> keys, SliceQuery query, StoreTransaction txh)`
    `void` | ReadOnlyKeyColumnValueStore.`mutate(StaticBuffer key, List<Entry> additions, List<StaticBuffer> deletions, StoreTransaction txh)`
    `void` | KeyColumnValueStore.`mutate(StaticBuffer key, List<Entry> additions, List<StaticBuffer> deletions, StoreTransaction txh)` Verifies acquisition of locks `txh` from previous calls to `KeyColumnValueStore.acquireLock(StaticBuffer, StaticBuffer, StaticBuffer, StoreTransaction)` , then writes supplied `additions` and/or `deletions` to `key` in the underlying data store.
    `void` | KCVSProxy.`mutate(StaticBuffer key, List<Entry> additions, List<StaticBuffer> deletions, StoreTransaction txh)`
    `void` | KCVSManagerProxy.`mutateMany(Map<String,Map<StaticBuffer,KCVMutation>> mutations, StoreTransaction txh)`
    `void` | KeyColumnValueStoreManager.`mutateMany(Map<String,Map<StaticBuffer,KCVMutation>> mutations, StoreTransaction txh)` Executes multiple mutations at once.
    `KeyColumnValueStore` | KCVSManagerProxy.`openDatabase(String name)`
    `KeyColumnValueStore` | KeyColumnValueStoreManager.`openDatabase(String name)` Opens an ordered database by the given name.
    `KeyColumnValueStore` | CustomizeStoreKCVSManager.`openDatabase(String name, int ttlInSeconds)` Opens a database against this `KeyColumnValueStoreManager` with the given TTL in seconds.

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.keycolumnvalue.cache

    Methods in com.thinkaurelius.titan.diskstorage.keycolumnvalue.cache that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | ExpirationKCVSCache.`close()`
    `void` | CacheTransaction.`commit()`
    `EntryList` | ExpirationKCVSCache.`getSlice(KeySliceQuery query, StoreTransaction txh)`
    `Map<StaticBuffer,EntryList>` | ExpirationKCVSCache.`getSlice(List<StaticBuffer> keys, SliceQuery query, StoreTransaction txh)`
    `EntryList` | KCVSCache.`getSliceNoCache(KeySliceQuery query, StoreTransaction txh)`
    `Map<StaticBuffer,EntryList>` | KCVSCache.`getSliceNoCache(List<StaticBuffer> keys, SliceQuery query, StoreTransaction txh)`
    `void` | KCVSCache.`mutate(StaticBuffer key, List<Entry> additions, List<StaticBuffer> deletions, StoreTransaction txh)`
    `void` | KCVSCache.`mutateEntries(StaticBuffer key, List<Entry> additions, List<Entry> deletions, StoreTransaction txh)`
    `void` | CacheTransaction.`rollback()`

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.keycolumnvalue.inmemory

    Methods in com.thinkaurelius.titan.diskstorage.keycolumnvalue.inmemory that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | InMemoryKeyColumnValueStore.`acquireLock(StaticBuffer key, StaticBuffer column, StaticBuffer expectedValue, StoreTransaction txh)`
    `StoreTransaction` | InMemoryStoreManager.`beginTransaction(BaseTransactionConfig config)`
    `void` | InMemoryStoreManager.`clearStorage()`
    `void` | InMemoryStoreManager.`close()`
    `void` | InMemoryKeyColumnValueStore.`close()`
    `KeyIterator` | InMemoryKeyColumnValueStore.`getKeys(KeyRangeQuery query, StoreTransaction txh)`
    `KeyIterator` | InMemoryKeyColumnValueStore.`getKeys(SliceQuery query, StoreTransaction txh)`
    `List<KeyRange>` | InMemoryStoreManager.`getLocalKeyPartition()`
    `EntryList` | InMemoryKeyColumnValueStore.`getSlice(KeySliceQuery query, StoreTransaction txh)`
    `Map<StaticBuffer,EntryList>` | InMemoryKeyColumnValueStore.`getSlice(List<StaticBuffer> keys, SliceQuery query, StoreTransaction txh)`
    `void` | InMemoryKeyColumnValueStore.`mutate(StaticBuffer key, List<Entry> additions, List<StaticBuffer> deletions, StoreTransaction txh)`
    `void` | InMemoryStoreManager.`mutateMany(Map<String,Map<StaticBuffer,KCVMutation>> mutations, StoreTransaction txh)`
    `KeyColumnValueStore` | InMemoryStoreManager.`openDatabase(String name)`

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.keycolumnvalue.keyvalue

    Methods in com.thinkaurelius.titan.diskstorage.keycolumnvalue.keyvalue that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | OrderedKeyValueStoreAdapter.`acquireLock(StaticBuffer key, StaticBuffer column, StaticBuffer expectedValue, StoreTransaction txh)`
    `void` | KeyValueStore.`acquireLock(StaticBuffer key, StaticBuffer expectedValue, StoreTransaction txh)` Acquires a lock for the given key and expected value (null, if not value is expected).
    `StoreTransaction` | OrderedKeyValueStoreManagerAdapter.`beginTransaction(BaseTransactionConfig config)`
    `void` | OrderedKeyValueStoreManagerAdapter.`clearStorage()`
    `void` | OrderedKeyValueStoreManagerAdapter.`close()`
    `void` | BaseKeyColumnValueAdapter.`close()`
    `void` | KeyValueStore.`close()` Closes this store and releases its resources.
    `boolean` | KeyValueStore.`containsKey(StaticBuffer key, StoreTransaction txh)` Returns true iff the store contains the given key, else false
    `static EntryList` | KVUtil.`convert(RecordIterator<KeyValueEntry> iter)`
    `void` | KeyValueStore.`delete(StaticBuffer key, StoreTransaction txh)` Deletes the given key from the store.
    `StaticBuffer` | KeyValueStore.`get(StaticBuffer key, StoreTransaction txh)` Returns the value associated with the given key.
    `KeyIterator` | OrderedKeyValueStoreAdapter.`getKeys(KeyRangeQuery keyQuery, StoreTransaction txh)`
    `KeyIterator` | OrderedKeyValueStoreAdapter.`getKeys(SliceQuery columnQuery, StoreTransaction txh)`
    `List<KeyRange>` | OrderedKeyValueStoreManagerAdapter.`getLocalKeyPartition()`
    `EntryList` | OrderedKeyValueStoreAdapter.`getSlice(KeySliceQuery query, StoreTransaction txh)`
    `RecordIterator<KeyValueEntry>` | OrderedKeyValueStore.`getSlice(KVQuery query, StoreTransaction txh)` Returns a list of all Key-value pairs (`KeyValueEntry` where the keys satisfy the given `KVQuery`.
    `Map<StaticBuffer,EntryList>` | OrderedKeyValueStoreAdapter.`getSlice(List<StaticBuffer> keys, SliceQuery query, StoreTransaction txh)`
    `static EntryList` | KVUtil.`getSlice(OrderedKeyValueStore store, StaticBuffer keyStart, StaticBuffer keyEnd, int limit, StoreTransaction txh)`
    `static EntryList` | KVUtil.`getSlice(OrderedKeyValueStore store, StaticBuffer keyStart, StaticBuffer keyEnd, StoreTransaction txh)`
    `Map<KVQuery,RecordIterator<KeyValueEntry>>` | OrderedKeyValueStore.`getSlices(List<KVQuery> queries, StoreTransaction txh)` Like `OrderedKeyValueStore.getSlice(KVQuery, com.thinkaurelius.titan.diskstorage.keycolumnvalue.StoreTransaction)` but executes all of the given queries at once and returns a map of all the result sets of each query.
    `void` | OrderedKeyValueStore.`insert(StaticBuffer key, StaticBuffer value, StoreTransaction txh)` Inserts the given key-value pair into the store.
    `void` | OrderedKeyValueStoreAdapter.`mutate(StaticBuffer key, List<Entry> additions, List<StaticBuffer> deletions, StoreTransaction txh)`
    `void` | OrderedKeyValueStoreManager.`mutateMany(Map<String,KVMutation> mutations, StoreTransaction txh)` Executes multiple mutations at once.
    `void` | OrderedKeyValueStoreManagerAdapter.`mutateMany(Map<String,Map<StaticBuffer,KCVMutation>> mutations, StoreTransaction txh)`
    `OrderedKeyValueStoreAdapter` | OrderedKeyValueStoreManagerAdapter.`openDatabase(String name)`
    `KeyValueStore` | KeyValueStoreManager.`openDatabase(String name)` Opens a key-value database by the given name.
    `OrderedKeyValueStore` | OrderedKeyValueStoreManager.`openDatabase(String name)` Opens an ordered database by the given name.

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.keycolumnvalue.ttl

    Methods in com.thinkaurelius.titan.diskstorage.keycolumnvalue.ttl that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | TTLKCVS.`mutate(StaticBuffer key, List<Entry> additions, List<StaticBuffer> deletions, StoreTransaction txh)`
    `void` | TTLKVCSManager.`mutateMany(Map<String,Map<StaticBuffer,KCVMutation>> mutations, StoreTransaction txh)`
    `KeyColumnValueStore` | TTLKVCSManager.`openDatabase(String name)`
    `KeyColumnValueStore` | TTLKVCSManager.`openDatabase(String name, int ttlInSeconds)`

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.locking

    Subclasses of BackendException in com.thinkaurelius.titan.diskstorage.locking
    Modifier and Type | Class and Description
    --- | ---
    `class` | `PermanentLockingException` This exception signifies a failure to lock based on durable state.
    `class` | `TemporaryLockingException` This exception signifies a (potentially) temporary exception while attempting to acquire a lock in the Titan storage backend.

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.locking.consistentkey

    Methods in com.thinkaurelius.titan.diskstorage.locking.consistentkey that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | ExpectedValueCheckingStore.`acquireLock(StaticBuffer key, StaticBuffer column, StaticBuffer expectedValue, StoreTransaction txh)` Attempts to claim a lock on the value at the specified `key` and `column` pair.
    `ExpectedValueCheckingTransaction` | ExpectedValueCheckingStoreManager.`beginTransaction(BaseTransactionConfig configuration)`
    `protected void` | ConsistentKeyLocker.`checkSingleLock(KeyColumn kc, ConsistentKeyLockStatus ls, StoreTransaction tx)`
    `void` | ExpectedValueCheckingTransaction.`commit()`
    `void` | ExpectedValueCheckingStore.`mutate(StaticBuffer key, List<Entry> additions, List<StaticBuffer> deletions, StoreTransaction txh)` Verifies acquisition of locks `txh` from previous calls to `KeyColumnValueStore.acquireLock(StaticBuffer, StaticBuffer, StaticBuffer, StoreTransaction)` , then writes supplied `additions` and/or `deletions` to `key` in the underlying data store.
    `void` | ExpectedValueCheckingStoreManager.`mutateMany(Map<String,Map<StaticBuffer,KCVMutation>> mutations, StoreTransaction txh)`
    `KeyColumnValueStore` | ExpectedValueCheckingStoreManager.`openDatabase(String name)`
    `void` | ExpectedValueCheckingTransaction.`rollback()`

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.log

    Methods in com.thinkaurelius.titan.diskstorage.log that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | Log.`close()` Closes this log and stops the reading process.
    `void` | LogManager.`close()` Closes the log manager and all open logs (if they haven't already been explicitly closed)
    `Log` | LogManager.`openLog(String name)` Opens a log for the given name.

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.log.kcvs

    Methods in com.thinkaurelius.titan.diskstorage.log.kcvs that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | KCVSLog.`close()` Closes the log by terminating all threads and waiting for their termination.
    `void` | KCVSLogManager.`close()`
    `KCVSLog` | KCVSLogManager.`openLog(String name)`
    `StoreTransaction` | KCVSLog.`openTx()`

  - ### Uses of BackendException in com.thinkaurelius.titan.diskstorage.util

    Methods in com.thinkaurelius.titan.diskstorage.util that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `void` | MetricInstrumentedStore.`acquireLock(StaticBuffer key, StaticBuffer column, StaticBuffer expectedValue, StoreTransaction txh)`
    `T` | StorageCallable.`call()`
    `R` | BackendOperation.Transactional.`call(StoreTransaction txh)`
    `void` | MetricInstrumentedStore.`close()`
    `void` | BackendOperation.TransactionalProvider.`close()`
    `void` | DefaultTransaction.`commit()`
    `static <R> R` | BackendOperation.`execute(BackendOperation.Transactional<R> exe, BackendOperation.TransactionalProvider provider, TimestampProvider times)`
    `static <V> V` | BackendOperation.`executeDirect(Callable<V> exe, Duration totalWaitTime)`
    `KeyIterator` | MetricInstrumentedStore.`getKeys(KeyRangeQuery query, StoreTransaction txh)`
    `KeyIterator` | MetricInstrumentedStore.`getKeys(SliceQuery query, StoreTransaction txh)`
    `static File` | DirectoryUtil.`getOrCreateDataDirectory(String location)`
    `EntryList` | MetricInstrumentedStore.`getSlice(KeySliceQuery query, StoreTransaction txh)`
    `Map<StaticBuffer,EntryList>` | MetricInstrumentedStore.`getSlice(List<StaticBuffer> keys, SliceQuery query, StoreTransaction txh)`
    `void` | MetricInstrumentedStore.`mutate(StaticBuffer key, List<Entry> additions, List<StaticBuffer> deletions, StoreTransaction txh)`
    `StoreTransaction` | BackendOperation.TransactionalProvider.`openTx()`
    `void` | DefaultTransaction.`rollback()`

  - ### Uses of BackendException in com.thinkaurelius.titan.graphdb.database

    Methods in com.thinkaurelius.titan.graphdb.database that throw BackendException
    Modifier and Type | Method and Description
    --- | ---
    `com.thinkaurelius.titan.graphdb.database.StandardTitanGraph.ModificationSummary` | StandardTitanGraph.`prepareCommit(Collection<InternalRelation> addedRelations, Collection<InternalRelation> deletedRelations, com.google.common.base.Predicate<InternalRelation> filter, BackendTransaction mutator, StandardTitanTx tx, boolean acquireLocks)`
    `static void` | IndexSerializer.`register(MixedIndexType index, PropertyKey key, BackendTransaction tx)`

Copyright © 2012–2014. All rights reserved.