com.thinkaurelius.titan.diskstorage.keycolumnvalue

## Class StandardStoreFeatures

- java.lang.Object
- - com.thinkaurelius.titan.diskstorage.keycolumnvalue.StandardStoreFeatures

- All Implemented Interfaces:
    StoreFeatures

      public class StandardStoreFeatures
      extends Object
      implements StoreFeatures

  Immutable, `StandardStoreFeatures.Builder`-customizable implementation of StoreFeatures.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `StandardStoreFeatures.Builder` The only way to instantiate `StandardStoreFeatures`.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Configuration` | `getKeyConsistentTxConfig()` Get a transaction configuration that enforces key consistency.
    `Configuration` | `getLocalKeyConsistentTxConfig()` Get a transaction configuration that enforces local key consistency.
    `Timestamps` | `getPreferredTimestamps()` If this storage backend supports one particular type of data timestamp/version better than others.
    `boolean` | `hasBatchMutation()` Whether this storage backend supports batch mutations via `KeyColumnValueStoreManager.mutateMany(java.util.Map, StoreTransaction)`.
    `boolean` | `hasCellTTL()` Returns true if this storage backend support time-to-live (TTL) settings for column-value entries.
    `boolean` | `hasLocalKeyPartition()`
    `boolean` | `hasLocking()` Whether this store supports locking via `KeyColumnValueStore.acquireLock(com.thinkaurelius.titan.diskstorage.StaticBuffer, com.thinkaurelius.titan.diskstorage.StaticBuffer, com.thinkaurelius.titan.diskstorage.StaticBuffer, StoreTransaction)`
    `boolean` | `hasMultiQuery()` Whether this storage backend supports query operations on multiple keys via `KeyColumnValueStore.getSlice(java.util.List, SliceQuery, StoreTransaction)`
    `boolean` | `hasOrderedScan()` Whether this storage backend supports global key scans via `KeyColumnValueStore.getKeys(KeyRangeQuery, StoreTransaction)`.
    `boolean` | `hasScan()` Equivalent to calling `StoreFeatures.hasUnorderedScan()` `||` `StoreFeatures.hasOrderedScan()`.
    `boolean` | `hasStoreTTL()` Returns true if this storage backend supports time-to-live (TTL) settings on a per-store basis.
    `boolean` | `hasTimestamps()` Returns true if column-value entries in this storage backend are annotated with a timestamp, else false.
    `boolean` | `hasTxIsolation()` Whether this storage backend's transactions support isolation.
    `boolean` | `hasUnorderedScan()` Whether this storage backend supports global key scans via `KeyColumnValueStore.getKeys(SliceQuery, StoreTransaction)`.
    `boolean` | `hasVisibility()` Returns true if this storage backend supports entry-level visibility by attaching a visibility or authentication token to each column-value entry in the data store and limited retrievals to "visible" entries.
    `boolean` | `isDistributed()` Whether this storage backend writes and reads data from more than one machine.
    `boolean` | `isKeyConsistent()` Whether this storage backend provides strong consistency within each key/row.
    `boolean` | `isKeyOrdered()` Whether this storage backend preserves key locality.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### hasScan

          public boolean hasScan()

      Description copied from interface: `StoreFeatures`
      Equivalent to calling `StoreFeatures.hasUnorderedScan()` `||` `StoreFeatures.hasOrderedScan()`.
      Specified by:
        `hasScan` in interface `StoreFeatures`

    - #### hasUnorderedScan

          public boolean hasUnorderedScan()

      Description copied from interface: `StoreFeatures`
      Whether this storage backend supports global key scans via `KeyColumnValueStore.getKeys(SliceQuery, StoreTransaction)`.
      Specified by:
        `hasUnorderedScan` in interface `StoreFeatures`

    - #### hasOrderedScan

          public boolean hasOrderedScan()

      Description copied from interface: `StoreFeatures`
      Whether this storage backend supports global key scans via `KeyColumnValueStore.getKeys(KeyRangeQuery, StoreTransaction)`.
      Specified by:
        `hasOrderedScan` in interface `StoreFeatures`

    - #### hasMultiQuery

          public boolean hasMultiQuery()

      Description copied from interface: `StoreFeatures`
      Whether this storage backend supports query operations on multiple keys via `KeyColumnValueStore.getSlice(java.util.List, SliceQuery, StoreTransaction)`
      Specified by:
        `hasMultiQuery` in interface `StoreFeatures`

    - #### hasLocking

          public boolean hasLocking()

      Description copied from interface: `StoreFeatures`
      Whether this store supports locking via `KeyColumnValueStore.acquireLock(com.thinkaurelius.titan.diskstorage.StaticBuffer, com.thinkaurelius.titan.diskstorage.StaticBuffer, com.thinkaurelius.titan.diskstorage.StaticBuffer, StoreTransaction)`
      Specified by:
        `hasLocking` in interface `StoreFeatures`

    - #### hasBatchMutation

          public boolean hasBatchMutation()

      Description copied from interface: `StoreFeatures`
      Whether this storage backend supports batch mutations via `KeyColumnValueStoreManager.mutateMany(java.util.Map, StoreTransaction)`.
      Specified by:
        `hasBatchMutation` in interface `StoreFeatures`

    - #### isKeyOrdered

          public boolean isKeyOrdered()

      Description copied from interface: `StoreFeatures`
      Whether this storage backend preserves key locality. This affects Titan's use of vertex ID partitioning.
      Specified by:
        `isKeyOrdered` in interface `StoreFeatures`

    - #### isDistributed

          public boolean isDistributed()

      Description copied from interface: `StoreFeatures`
      Whether this storage backend writes and reads data from more than one machine.
      Specified by:
        `isDistributed` in interface `StoreFeatures`

    - #### hasTxIsolation

          public boolean hasTxIsolation()

      Description copied from interface: `StoreFeatures`
      Whether this storage backend's transactions support isolation.
      Specified by:
        `hasTxIsolation` in interface `StoreFeatures`

    - #### isKeyConsistent

          public boolean isKeyConsistent()

      Description copied from interface: `StoreFeatures`
      Whether this storage backend provides strong consistency within each key/row. This property is weaker than general strong consistency, since reads and writes to different keys need not obey strong consistency. "Key consistency" is shorthand for "strong consistency at the key/row level".
      Specified by:
        `isKeyConsistent` in interface `StoreFeatures`
      Returns:
        true if the backend supports key-level strong consistency

    - #### hasTimestamps

          public boolean hasTimestamps()

      Description copied from interface: `StoreFeatures`
      Returns true if column-value entries in this storage backend are annotated with a timestamp, else false. It is assumed that the timestamp matches the one set during the committing transaction.
      Specified by:
        `hasTimestamps` in interface `StoreFeatures`
      Returns:

    - #### getPreferredTimestamps

          public Timestamps getPreferredTimestamps()

      Description copied from interface: `StoreFeatures`
      If this storage backend supports one particular type of data timestamp/version better than others. For example, HBase server-side TTLs assume row timestamps are in milliseconds; some Cassandra client utils assume timestamps in microseconds. This method should return null if the backend has no preference for a specific timestamp resolution. This method will be ignored by Titan if `StoreFeatures.hasTimestamps()` is false.
      Specified by:
        `getPreferredTimestamps` in interface `StoreFeatures`
      Returns:
        null or a Timestamps enum value

    - #### hasCellTTL

          public boolean hasCellTTL()

      Description copied from interface: `StoreFeatures`
      Returns true if this storage backend support time-to-live (TTL) settings for column-value entries. If such a value is provided as a meta-data annotation on the `Entry`, the entry will disappear from the storage backend after the given amount of time.
      Specified by:
        `hasCellTTL` in interface `StoreFeatures`
      Returns:
        true if the storage backend supports TTL, else false

    - #### hasStoreTTL

          public boolean hasStoreTTL()

      Description copied from interface: `StoreFeatures`
      Returns true if this storage backend supports time-to-live (TTL) settings on a per-store basis. That means, that entries added to such a store will require after a configured amount of time.
      Specified by:
        `hasStoreTTL` in interface `StoreFeatures`
      Returns:

    - #### hasVisibility

          public boolean hasVisibility()

      Description copied from interface: `StoreFeatures`
      Returns true if this storage backend supports entry-level visibility by attaching a visibility or authentication token to each column-value entry in the data store and limited retrievals to "visible" entries.
      Specified by:
        `hasVisibility` in interface `StoreFeatures`
      Returns:

    - #### getKeyConsistentTxConfig

          public Configuration getKeyConsistentTxConfig()

      Description copied from interface: `StoreFeatures`
      Get a transaction configuration that enforces key consistency. This method has undefined behavior when `StoreFeatures.isKeyConsistent()` is false.
      Specified by:
        `getKeyConsistentTxConfig` in interface `StoreFeatures`
      Returns:
        a key-consistent tx config

    - #### getLocalKeyConsistentTxConfig

          public Configuration getLocalKeyConsistentTxConfig()

      Description copied from interface: `StoreFeatures`
      Get a transaction configuration that enforces local key consistency. "Local" has flexible meaning depending on the backend implementation. An example is Cassandra's notion of LOCAL_QUORUM, which provides strong consistency among all replicas in the same datacenter as the node handling the request, but not nodes at other datacenters. This method has undefined behavior when `StoreFeatures.isKeyConsistent()` is false. Backends which don't support the notion of "local" strong consistency may return the same configuration returned by `#getKeyConsistencyTxConfig()`.
      Specified by:
        `getLocalKeyConsistentTxConfig` in interface `StoreFeatures`
      Returns:
        a locally (or globally) key-consistent tx config

    - #### hasLocalKeyPartition

          public boolean hasLocalKeyPartition()

      Specified by:
        `hasLocalKeyPartition` in interface `StoreFeatures`

Copyright © 2012–2014. All rights reserved.