StandardTransactionBuilder (Titan 1.0.0 API)

java.lang.Object
- com.thinkaurelius.titan.graphdb.transaction.StandardTransactionBuilder

All Implemented Interfaces:

TransactionBuilder, BaseTransactionConfig, TransactionConfiguration
```
public class StandardTransactionBuilder
extends Object
implements TransactionConfiguration, TransactionBuilder
```
Used to configure a TitanTransaction.

Author:

Matthias Bröcheler (me@matthiasb.com);

See Also:

TitanTransaction

Constructor Summary

Constructors
Constructor and Description
`StandardTransactionBuilder(GraphDatabaseConfiguration graphConfig, StandardTitanGraph graph)` Constructs a new TitanTransaction configuration with default configuration parameters.
`StandardTransactionBuilder(GraphDatabaseConfiguration graphConfig, StandardTitanGraph graph, Configuration customOptions)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`StandardTransactionBuilder`	`checkExternalVertexExistence(boolean enabled)` Enables/disables checking whether the vertex with a user provided id indeed exists.
`StandardTransactionBuilder`	`checkInternalVertexExistence(boolean enabled)` Enables/disables checks that verify that each vertex actually exists in the underlying data store when it is retrieved.
`StandardTransactionBuilder`	`commitTime(java.time.Instant timestampSinceEpoch)` Sets the timestamp for this transaction.
`TransactionBuilder`	`consistencyChecks(boolean enabled)` Enables/disables consistency checking and locking for this transaction.
`TransactionBuilder`	`customOption(String k, Object v)` Configures a custom option on this transaction which will be passed through to the storage and indexing backends.
`TransactionBuilder`	`dirtyVertexSize(int size)` Configures the initial size of the map of modified vertices held by this transaction.
`StandardTransactionBuilder`	`disableBatchLoading()` Disables batch loading by ensuring that consistency checks are applied in this transaction.
`StandardTransactionBuilder`	`enableBatchLoading()` Enabling batch loading disables a number of consistency checks inside Titan to speed up the ingestion of data under the assumptions that inconsistencies are resolved prior to loading.
`DefaultSchemaMaker`	`getAutoSchemaMaker()`
`java.time.Instant`	`getCommitTime()` Returns the commit time of this transaction which is either a custom timestamp provided by the user, the commit time as set by the enclosing operation, or the first time this method is called.
`<V> V`	`getCustomOption(ConfigOption<V> opt)` Get an arbitrary transaction-specific option.
`Configuration`	`getCustomOptions()` Return any transaction-specific options.
`int`	`getDirtyVertexSize()` The initial size of the dirty (modified) vertex map used by a transaction.
`String`	`getGroupName()` Returns the (possibly null) group name for this transaction.
`long`	`getIndexCacheWeight()` The maximum weight for the index cache store used in this particular transaction
`String`	`getLogIdentifier()` The name of the log to be used for logging the mutations in this transaction.
`int[]`	`getRestrictedPartitions()` Querying of partitioned vertices is restricted to the partitions returned by this method.
`TimestampProvider`	`getTimestampProvider()` Returns the timestamp provider of this transaction.
`int`	`getVertexCacheSize()` The maximum number of recently-used vertices to cache in this transaction.
`StandardTransactionBuilder`	`groupName(String p)` Sets the group name for this transaction which provides a way for gathering reporting on multiple transactions into one group.
`boolean`	`hasAcquireLocks()` Whether the persistence layer should acquire locks for this transaction during persistence.
`boolean`	`hasAssignIDsImmediately()`
`boolean`	`hasCommitTime()` Returns true if a commit time has been set on this transaction.
`boolean`	`hasEnabledBatchLoading()` Whether this transaction should be optimized for batch-loading, i.e.
`boolean`	`hasForceIndexUsage()` Whether this transaction should throw an exception when a graph query is issued that cannot be answered with any existing index but instead requires a full graph-scan.
`boolean`	`hasGroupName()` True when `BaseTransactionConfig.getGroupName()` is non-null, false when null.
`boolean`	`hasPreloadedData()` Whether the incident relation data on vertices is being externally pre-loaded.
`boolean`	`hasPropertyPrefetching()` Whether this transaction loads all properties on a vertex when a single property is requested.
`boolean`	`hasRestrictedPartitions()` Returns true of the queryied partitions should be restricted in this transaction
`boolean`	`hasVerifyExternalVertexExistence()` Whether the graph transaction is configured to verify that a vertex with the id GIVEN BY THE USER actually exists in the database or not.
`boolean`	`hasVerifyInternalVertexExistence()` Whether the graph transaction is configured to verify that a vertex with the id actually exists in the database or not on every retrieval.
`boolean`	`hasVerifyUniqueness()` Whether the graph transaction is configured to verify that an added key does not yet exist in the database.
`boolean`	`isReadOnly()` Checks whether the graph transaction is configured as read-only.
`boolean`	`isSingleThreaded()` Whether this transaction is only accessed by a single thread.
`boolean`	`isThreadBound()` Whether this transaction is bound to a running thread.
`StandardTransactionBuilder`	`logIdentifier(String logName)` Name of the log to be used for logging the mutations in this transaction.
`StandardTransactionBuilder`	`readOnly()` Makes the transaction read only.
`TransactionBuilder`	`restrictedPartitions(int[] partitions)` Configures this transaction such that queries against partitioned vertices are restricted to the given partitions.
`void`	`setCommitTime(java.time.Instant time)` Sets the commit time of this transaction.
`TransactionBuilder`	`setPreloadedData(boolean preloaded)`
`TitanTransaction`	`start()` Starts and returns the transaction build by this builder
`StandardTransactionBuilder`	`threadBound()`
`StandardTransactionBuilder`	`vertexCacheSize(int size)` Configures the size of the internal caches used in the transaction.

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

- Constructor Detail
  - StandardTransactionBuilder
```
public StandardTransactionBuilder(GraphDatabaseConfiguration graphConfig,
                                  StandardTitanGraph graph)
```
    Constructs a new TitanTransaction configuration with default configuration parameters.
  - StandardTransactionBuilder
```
public StandardTransactionBuilder(GraphDatabaseConfiguration graphConfig,
                                  StandardTitanGraph graph,
                                  Configuration customOptions)
```
- Method Detail
  - threadBound
```
public StandardTransactionBuilder threadBound()
```
  - readOnly
```
public StandardTransactionBuilder readOnly()
```
    Description copied from interface: TransactionBuilder
    
    Makes the transaction read only. Any writes will cause an exception. Read-only transactions do not have to maintain certain data structures and can hence be more efficient.
    
    Specified by:
    
    readOnly in interface TransactionBuilder
    
    Returns:
  - enableBatchLoading
```
public StandardTransactionBuilder enableBatchLoading()
```
    Description copied from interface: TransactionBuilder
    
    Enabling batch loading disables a number of consistency checks inside Titan to speed up the ingestion of data under the assumptions that inconsistencies are resolved prior to loading.
    
    Specified by:
    
    enableBatchLoading in interface TransactionBuilder
    
    Returns:
  - disableBatchLoading
```
public StandardTransactionBuilder disableBatchLoading()
```
    Description copied from interface: TransactionBuilder
    
    Disables batch loading by ensuring that consistency checks are applied in this transaction. This allows an individual transaction to use consistency checks when the graph as a whole is configured to not use them, which is useful when defining schema elements in a graph with batch-loading enabled.
    
    Specified by:
    
    disableBatchLoading in interface TransactionBuilder
    
    Returns:
  - vertexCacheSize
```
public StandardTransactionBuilder vertexCacheSize(int size)
```
    Description copied from interface: TransactionBuilder
    
    Configures the size of the internal caches used in the transaction.
    
    Specified by:
    
    vertexCacheSize in interface TransactionBuilder
    
    Returns:
  - dirtyVertexSize
```
public TransactionBuilder dirtyVertexSize(int size)
```
    Description copied from interface: TransactionBuilder
    
    Configures the initial size of the map of modified vertices held by this transaction. This is a performance hint, not a hard upper bound. The map will grow if the transaction ends up modifying more vertices than expected.
    
    Specified by:
    
    dirtyVertexSize in interface TransactionBuilder
    
    Parameters:
    
    size - initial size of the transaction's dirty vertex collection
    
    Returns:
  - checkInternalVertexExistence
```
public StandardTransactionBuilder checkInternalVertexExistence(boolean enabled)
```
    Description copied from interface: TransactionBuilder
    
    Enables/disables checks that verify that each vertex actually exists in the underlying data store when it is retrieved. This might be useful to address common data degradation issues but has adverse impacts on performance due to repeated existence checks.
    Note, that these checks apply to vertex retrievals inside the query execution engine and not to vertex ids provided by the user.
    
    Specified by:
    
    checkInternalVertexExistence in interface TransactionBuilder
    
    Returns:
  - checkExternalVertexExistence
```
public StandardTransactionBuilder checkExternalVertexExistence(boolean enabled)
```
    Description copied from interface: TransactionBuilder
    
    Enables/disables checking whether the vertex with a user provided id indeed exists. If the user is absolutely sure that the vertices for the ids provided in this transaction exist in the underlying data store, then disabling the vertex existence check will improve performance because it eliminates a database call. However, if a provided vertex id does not exist in the database and checking is disabled, Titan will assume it exists which can lead to data and query inconsistencies.
    
    Specified by:
    
    checkExternalVertexExistence in interface TransactionBuilder
    
    Returns:
  - consistencyChecks
```
public TransactionBuilder consistencyChecks(boolean enabled)
```
    Description copied from interface: TransactionBuilder
    
    Enables/disables consistency checking and locking for this transaction. Disabling consistency checks improves performance but requires that the user ensures consistency at the application level. Use with great care.
    
    Specified by:
    
    consistencyChecks in interface TransactionBuilder
    
    Returns:
  - commitTime
```
public StandardTransactionBuilder commitTime(java.time.Instant timestampSinceEpoch)
```
    Description copied from interface: TransactionBuilder
    
    Sets the timestamp for this transaction. The transaction will be recorded with this timestamp in those storage backends where the timestamp is recorded.
    
    Specified by:
    
    commitTime in interface TransactionBuilder
    
    Parameters:
    
    timestampSinceEpoch - The instant at which the commit took place
    
    Returns:
  - setCommitTime
```
public void setCommitTime(java.time.Instant time)
```
    Description copied from interface: BaseTransactionConfig
    
    Sets the commit time of this transaction. If a commit time has already been set, this method throws an exception. Use BaseTransactionConfig.hasCommitTime() to check prior to setting.
    
    Specified by:
    
    setCommitTime in interface BaseTransactionConfig
  - groupName
```
public StandardTransactionBuilder groupName(String p)
```
    Description copied from interface: TransactionBuilder
    
    Sets the group name for this transaction which provides a way for gathering reporting on multiple transactions into one group. By setting a group one enables Metrics for this transaction, and defines what string should start the transaction's metric names.
    If null, Metrics collection is totally disabled for this transaction.
    If empty, Metrics collection is enabled, but there will be no prefix. Where the default setting would generate metrics names in the form "prefix.x.y.z", this transaction will instead use metric names in the form "x.y.z".
    If nonempty, Metrics collection is enabled and the prefix will be used for all of this transaction's measurements.
    Note: setting this to a non-null value only partially overrides GraphDatabaseConfiguration.BASIC_METRICS = false in the graph database configuration. When Metrics are disabled at the graph level and enabled at the transaction level, storage backend timings and counters will remain disabled.
    The default value is GraphDatabaseConfiguration.METRICS_PREFIX_DEFAULT. Sets the name prefix used for Metrics recorded by this transaction. If metrics is enabled via GraphDatabaseConfiguration.BASIC_METRICS, this string will be prepended to all Titan metric names.
    
    Specified by:
    
    groupName in interface TransactionBuilder
    
    Parameters:
    
    p - Metric name prefix for this transaction
    
    Returns:
  - logIdentifier
```
public StandardTransactionBuilder logIdentifier(String logName)
```
    Description copied from interface: TransactionBuilder
    
    Name of the log to be used for logging the mutations in this transaction. If no log identifier is set, then this transaction will not be logged.
    
    Specified by:
    
    logIdentifier in interface TransactionBuilder
    
    Returns:
  - restrictedPartitions
```
public TransactionBuilder restrictedPartitions(int[] partitions)
```
    Description copied from interface: TransactionBuilder
    
    Configures this transaction such that queries against partitioned vertices are restricted to the given partitions.
    
    Specified by:
    
    restrictedPartitions in interface TransactionBuilder
    
    Returns:
  - setPreloadedData
```
public TransactionBuilder setPreloadedData(boolean preloaded)
```
  - customOption
```
public TransactionBuilder customOption(String k,
                                       Object v)
```
    Description copied from interface: TransactionBuilder
    
    Configures a custom option on this transaction which will be passed through to the storage and indexing backends.
    
    Specified by:
    
    customOption in interface TransactionBuilder
    
    Returns:
  - start
```
public TitanTransaction start()
```
    Description copied from interface: TransactionBuilder
    
    Starts and returns the transaction build by this builder
    
    Specified by:
    
    start in interface TransactionBuilder
    
    Returns:
    
    A new transaction configured according to this builder
  - isReadOnly
```
public final boolean isReadOnly()
```
    Description copied from interface: TransactionConfiguration
    
    Checks whether the graph transaction is configured as read-only.
    
    Specified by:
    
    isReadOnly in interface TransactionConfiguration
    
    Returns:
    
    True, if the transaction is configured as read-only, else false.
  - hasAssignIDsImmediately
```
public final boolean hasAssignIDsImmediately()
```
    Specified by:
    
    hasAssignIDsImmediately in interface TransactionConfiguration
    
    Returns:
    
    Whether this transaction is configured to assign idAuthorities immediately.
  - hasPreloadedData
```
public boolean hasPreloadedData()
```
    Description copied from interface: TransactionConfiguration
    
    Whether the incident relation data on vertices is being externally pre-loaded. This causes the transaction to only return stub vertices and leave any data loading up to the caller.
    
    Specified by:
    
    hasPreloadedData in interface TransactionConfiguration
    
    Returns:
  - hasForceIndexUsage
```
public final boolean hasForceIndexUsage()
```
    Description copied from interface: TransactionConfiguration
    
    Whether this transaction should throw an exception when a graph query is issued that cannot be answered with any existing index but instead requires a full graph-scan.
    
    Specified by:
    
    hasForceIndexUsage in interface TransactionConfiguration
    
    Returns:
  - hasEnabledBatchLoading
```
public boolean hasEnabledBatchLoading()
```
    Description copied from interface: TransactionConfiguration
    
    Whether this transaction should be optimized for batch-loading, i.e. ingestion of lots of data.
    
    Specified by:
    
    hasEnabledBatchLoading in interface TransactionConfiguration
    
    Returns:
  - hasVerifyExternalVertexExistence
```
public final boolean hasVerifyExternalVertexExistence()
```
    Description copied from interface: TransactionConfiguration
    
    Whether the graph transaction is configured to verify that a vertex with the id GIVEN BY THE USER actually exists in the database or not. In other words, it is verified that user provided vertex ids (through public APIs) actually exist.
    
    Specified by:
    
    hasVerifyExternalVertexExistence in interface TransactionConfiguration
    
    Returns:
    
    True, if vertex existence is verified, else false
  - hasVerifyInternalVertexExistence
```
public final boolean hasVerifyInternalVertexExistence()
```
    Description copied from interface: TransactionConfiguration
    
    Whether the graph transaction is configured to verify that a vertex with the id actually exists in the database or not on every retrieval. In other words, it is always verified that a vertex for a given id exists, even if that id is retrieved internally (through private APIs).
    Hence, this is a defensive setting against data degradation, where edges and/or index entries might point to no longer existing vertices. Use this setting with caution as it introduces additional overhead entailed by checking the existence.
    Unlike TransactionConfiguration.hasVerifyExternalVertexExistence() this is about internally verifying ids.
    
    Specified by:
    
    hasVerifyInternalVertexExistence in interface TransactionConfiguration
    
    Returns:
    
    True, if vertex existence is verified, else false
  - hasAcquireLocks
```
public final boolean hasAcquireLocks()
```
    Description copied from interface: TransactionConfiguration
    
    Whether the persistence layer should acquire locks for this transaction during persistence.
    
    Specified by:
    
    hasAcquireLocks in interface TransactionConfiguration
    
    Returns:
    
    True, if locks should be acquired, else false
  - getAutoSchemaMaker
```
public final DefaultSchemaMaker getAutoSchemaMaker()
```
    Specified by:
    
    getAutoSchemaMaker in interface TransactionConfiguration
    
    Returns:
    
    The default edge type maker used to automatically create not yet existing edge types.
  - hasVerifyUniqueness
```
public final boolean hasVerifyUniqueness()
```
    Description copied from interface: TransactionConfiguration
    
    Whether the graph transaction is configured to verify that an added key does not yet exist in the database.
    
    Specified by:
    
    hasVerifyUniqueness in interface TransactionConfiguration
    
    Returns:
    
    True, if vertex existence is verified, else false
  - hasPropertyPrefetching
```
public boolean hasPropertyPrefetching()
```
    Description copied from interface: TransactionConfiguration
    
    Whether this transaction loads all properties on a vertex when a single property is requested. This can be highly beneficial when additional properties are requested on the same vertex at a later time. For vertices with very many properties this might increase latencies of property fetching.
    
    Specified by:
    
    hasPropertyPrefetching in interface TransactionConfiguration
    
    Returns:
    
    True, if this transaction pre-fetches all properties
  - isSingleThreaded
```
public final boolean isSingleThreaded()
```
    Description copied from interface: TransactionConfiguration
    
    Whether this transaction is only accessed by a single thread. If so, then certain data structures may be optimized for single threaded access since locking can be avoided.
    
    Specified by:
    
    isSingleThreaded in interface TransactionConfiguration
    
    Returns:
  - isThreadBound
```
public final boolean isThreadBound()
```
    Description copied from interface: TransactionConfiguration
    
    Whether this transaction is bound to a running thread. If so, then elements in this transaction can expand their life cycle to the next transaction in the thread.
    
    Specified by:
    
    isThreadBound in interface TransactionConfiguration
    
    Returns:
  - getVertexCacheSize
```
public final int getVertexCacheSize()
```
    Description copied from interface: TransactionConfiguration
    
    The maximum number of recently-used vertices to cache in this transaction. The recently-used vertex cache can include both clean and dirty vertices.
    
    Specified by:
    
    getVertexCacheSize in interface TransactionConfiguration
    
    Returns:
  - getDirtyVertexSize
```
public final int getDirtyVertexSize()
```
    Description copied from interface: TransactionConfiguration
    
    The initial size of the dirty (modified) vertex map used by a transaction.
    
    Specified by:
    
    getDirtyVertexSize in interface TransactionConfiguration
    
    Returns:
  - getIndexCacheWeight
```
public final long getIndexCacheWeight()
```
    Description copied from interface: TransactionConfiguration
    
    The maximum weight for the index cache store used in this particular transaction
    
    Specified by:
    
    getIndexCacheWeight in interface TransactionConfiguration
    
    Returns:
  - getLogIdentifier
```
public String getLogIdentifier()
```
    Description copied from interface: TransactionConfiguration
    
    The name of the log to be used for logging the mutations in this transaction. If the identifier is NULL the mutations will not be logged.
    
    Specified by:
    
    getLogIdentifier in interface TransactionConfiguration
    
    Returns:
  - getRestrictedPartitions
```
public int[] getRestrictedPartitions()
```
    Description copied from interface: TransactionConfiguration
    
    Querying of partitioned vertices is restricted to the partitions returned by this method. If the return value has length 0 all partitions are queried (i.e. unrestricted).
    
    Specified by:
    
    getRestrictedPartitions in interface TransactionConfiguration
    
    Returns:
  - hasRestrictedPartitions
```
public boolean hasRestrictedPartitions()
```
    Description copied from interface: TransactionConfiguration
    
    Returns true of the queryied partitions should be restricted in this transaction
    
    Specified by:
    
    hasRestrictedPartitions in interface TransactionConfiguration
  - getGroupName
```
public String getGroupName()
```
    Description copied from interface: BaseTransactionConfig
    
    Returns the (possibly null) group name for this transaction. Transactions are grouped under this name for reporting and error tracking purposes.
    
    Specified by:
    
    getGroupName in interface BaseTransactionConfig
    
    Returns:
    
    group name prefix string or null
  - hasGroupName
```
public boolean hasGroupName()
```
    Description copied from interface: BaseTransactionConfig
    
    True when BaseTransactionConfig.getGroupName() is non-null, false when null.
    
    Specified by:
    
    hasGroupName in interface BaseTransactionConfig
  - getCommitTime
```
public java.time.Instant getCommitTime()
```
    Description copied from interface: BaseTransactionConfig
    
    Returns the commit time of this transaction which is either a custom timestamp provided by the user, the commit time as set by the enclosing operation, or the first time this method is called.
    
    Specified by:
    
    getCommitTime in interface BaseTransactionConfig
    
    Returns:
    
    commit timestamp for this transaction
  - hasCommitTime
```
public boolean hasCommitTime()
```
    Description copied from interface: BaseTransactionConfig
    
    Returns true if a commit time has been set on this transaction.
    
    Specified by:
    
    hasCommitTime in interface BaseTransactionConfig
    
    Returns:
  - getCustomOption
```
public <V> V getCustomOption(ConfigOption<V> opt)
```
    Description copied from interface: BaseTransactionConfig
    
    Get an arbitrary transaction-specific option.
    
    Specified by:
    
    getCustomOption in interface BaseTransactionConfig
    
    Parameters:
    
    opt - option for which to return a value
    
    Returns:
    
    value of the option
  - getCustomOptions
```
public Configuration getCustomOptions()
```
    Description copied from interface: BaseTransactionConfig
    
    Return any transaction-specific options.
    
    Specified by:
    
    getCustomOptions in interface BaseTransactionConfig
    
    Returns:
    
    options for this tx
    
    See Also:
    
    BaseTransactionConfig.getCustomOption(ConfigOption)
  - getTimestampProvider
```
public TimestampProvider getTimestampProvider()
```
    Description copied from interface: BaseTransactionConfig
    
    Returns the timestamp provider of this transaction.
    
    Specified by:
    
    getTimestampProvider in interface BaseTransactionConfig

Class StandardTransactionBuilder

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

StandardTransactionBuilder

StandardTransactionBuilder

Method Detail

threadBound

readOnly

enableBatchLoading

disableBatchLoading

vertexCacheSize

dirtyVertexSize

checkInternalVertexExistence

checkExternalVertexExistence

consistencyChecks

commitTime

setCommitTime

groupName

logIdentifier

restrictedPartitions

setPreloadedData

customOption

start

isReadOnly

hasAssignIDsImmediately

hasPreloadedData

hasForceIndexUsage

hasEnabledBatchLoading

hasVerifyExternalVertexExistence

hasVerifyInternalVertexExistence

hasAcquireLocks

getAutoSchemaMaker

hasVerifyUniqueness

hasPropertyPrefetching

isSingleThreaded

isThreadBound

getVertexCacheSize

getDirtyVertexSize

getIndexCacheWeight

getLogIdentifier

getRestrictedPartitions

hasRestrictedPartitions

getGroupName

hasGroupName

getCommitTime

hasCommitTime

getCustomOption

getCustomOptions

getTimestampProvider