StandardTransactionBuilder (JanusGraph-Core: Core Library for JanusGraph 1.1.0-20240508-135019.66416f9 API)

java.lang.Object
- org.janusgraph.graphdb.transaction.StandardTransactionBuilder

All Implemented Interfaces:

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

Author:

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

See Also:

JanusGraphTransaction

Constructor Summary

Constructors
Constructor and Description
`StandardTransactionBuilder(GraphDatabaseConfiguration graphConfig, StandardJanusGraph graph)` Constructs a new JanusGraphTransaction configuration with default configuration parameters.
`StandardTransactionBuilder(GraphDatabaseConfiguration graphConfig, StandardJanusGraph 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(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 JanusGraph to speed up the ingestion of data under the assumptions that inconsistencies are resolved prior to loading.
`DefaultSchemaMaker`	`getAutoSchemaMaker()`
`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.
`MultiQueryHasStepStrategyMode`	`getHasStepStrategyMode()`
`long`	`getIndexCacheWeight()` The maximum weight for the index cache store used in this particular transaction
`MultiQueryLabelStepStrategyMode`	`getLabelStepStrategyMode()`
`String`	`getLogIdentifier()` The name of the log to be used for logging the mutations in this transaction.
`MultiQueryPropertiesStrategyMode`	`getPropertiesStrategyMode()`
`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`	`hasDisabledSchemaConstraints()` Allows to disable schema constraints.
`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 if the queried 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`	`isLazyLoadRelations()` Returns true if all properties and edges are lazy-loaded: ids and values are deserialized upon demand.
`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`	`isSkipDBCacheRead()` Returns true if read queries should skip accessing JanusGraph database level cache (db-cache).
`boolean`	`isThreadBound()` Whether this transaction is bound to a running thread.
`TransactionBuilder`	`lazyLoadRelations()` Set lazy-load for all properties and edges: ids and values are deserialized upon demand.
`StandardTransactionBuilder`	`logIdentifier(String logName)` Name of the log to be used for logging the mutations in this transaction.
`StandardTransactionBuilder`	`multiQuery(boolean enabled)` Enable or disable multi-query, i.e.
`StandardTransactionBuilder`	`propertyPrefetching(boolean enabled)` Enable or disable property pre-fetching, i.e.
`StandardTransactionBuilder`	`readOnly()` Makes the transaction read only.
`StandardTransactionBuilder`	`readOnlyOLAP()` A shortcut for a number of configs that are commonly used by read-only OLAP jobs.
`TransactionBuilder`	`restrictedPartitions(int[] partitions)` Configures this transaction such that queries against partitioned vertices are restricted to the given partitions.
`void`	`setCommitTime(Instant time)` Sets the commit time of this transaction.
`TransactionBuilder`	`setHasStepStrategyMode(MultiQueryHasStepStrategyMode hasStepStrategyMode)` Sets `has` step strategy mode.
`TransactionBuilder`	`setLabelsStepStrategyMode(MultiQueryLabelStepStrategyMode labelStepStrategyMode)` Sets `label` step strategy mode.
`TransactionBuilder`	`setPreloadedData(boolean preloaded)`
`TransactionBuilder`	`setPropertiesStrategyMode(MultiQueryPropertiesStrategyMode propertiesStrategyMode)` Sets properties strategy mode.
`TransactionBuilder`	`skipDBCacheRead()` Skips usage of JanusGraph database level cache during read operations.
`JanusGraphTransaction`	`start()` Starts and returns the transaction build by this builder
`StandardTransactionBuilder`	`threadBound()`
`boolean`	`useMultiQuery()` Whether this transaction should batch backend queries.
`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,
                                  StandardJanusGraph graph)
```
    Constructs a new JanusGraphTransaction configuration with default configuration parameters.
  - StandardTransactionBuilder
```
public StandardTransactionBuilder(GraphDatabaseConfiguration graphConfig,
                                  StandardJanusGraph 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:
    
    Object containing read-only properties set to true
  - readOnlyOLAP
```
public StandardTransactionBuilder readOnlyOLAP()
```
    Description copied from interface: TransactionBuilder
    
    A shortcut for a number of configs that are commonly used by read-only OLAP jobs.
    
    Specified by:
    
    readOnlyOLAP in interface TransactionBuilder
    
    Returns:
    
    Object containing a number of properties optimized for read-only OLAP jobs
  - enableBatchLoading
```
public StandardTransactionBuilder enableBatchLoading()
```
    Description copied from interface: TransactionBuilder
    
    Enabling batch loading disables a number of consistency checks inside JanusGraph to speed up the ingestion of data under the assumptions that inconsistencies are resolved prior to loading.
    
    Specified by:
    
    enableBatchLoading in interface TransactionBuilder
    
    Returns:
    
    Object containing properties that will enable batch loading
  - 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:
    
    Object containing properties that will disable batch loading
  - propertyPrefetching
```
public StandardTransactionBuilder propertyPrefetching(boolean enabled)
```
    Description copied from interface: TransactionBuilder
    
    Enable or disable property pre-fetching, i.e. query.fast-property option.
    
    Specified by:
    
    propertyPrefetching in interface TransactionBuilder
    
    Returns:
    
    Object containing properties that will enable/disable property pre-fetching
  - multiQuery
```
public StandardTransactionBuilder multiQuery(boolean enabled)
```
    Description copied from interface: TransactionBuilder
    
    Enable or disable multi-query, i.e. `query.batch.enabled`
    
    Specified by:
    
    multiQuery in interface TransactionBuilder
    
    Returns:
    
    Object containing properties that will enable/disable multi-query
  - 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
    
    Parameters:
    
    size - The size of the initial cache for the transaction
    
    Returns:
    
    Object containing the internal cache properties
  - 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 - The initial size of the transaction's dirty vertex collection
    
    Returns:
    
    Object containing properties that configure initial map size of modified vertices
  - 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
    
    Parameters:
    
    enabled - Enable or disable the internal vertex existence checks
    
    Returns:
    
    Object with the internal vertex existence check properties
  - 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, JanusGraph will assume it exists which can lead to data and query inconsistencies.
    
    Specified by:
    
    checkExternalVertexExistence in interface TransactionBuilder
    
    Parameters:
    
    enabled - Enable or disable the external vertex existence checks
    
    Returns:
    
    Object with the external vertex existence check properties
  - 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
    
    Parameters:
    
    enabled - Enable or disable consistency check and locking
    
    Returns:
    
    Object with the consistency check settings
  - commitTime
```
public StandardTransactionBuilder commitTime(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:
    
    Object with the commit time property
  - skipDBCacheRead
```
public TransactionBuilder skipDBCacheRead()
```
    Description copied from interface: TransactionBuilder
    
    Skips usage of JanusGraph database level cache during read operations.
    Doesn't have any effect if database level cache was disabled via config `cache.db-cache`.
    
    Specified by:
    
    skipDBCacheRead in interface TransactionBuilder
    
    Returns:
    
    Object with the skip db-cache reads check settings
  - lazyLoadRelations
```
public TransactionBuilder lazyLoadRelations()
```
    Description copied from interface: TransactionBuilder
    
    Set lazy-load for all properties and edges: ids and values are deserialized upon demand.
    When enabled, it can have a boost on large scale read operations, when only certain type of relations are being read.
    
    Specified by:
    
    lazyLoadRelations in interface TransactionBuilder
    
    Returns:
    
    Object with lazy-load setting.
  - setHasStepStrategyMode
```
public TransactionBuilder setHasStepStrategyMode(MultiQueryHasStepStrategyMode hasStepStrategyMode)
```
    Description copied from interface: TransactionBuilder
    
    Sets `has` step strategy mode.
    Doesn't have any effect if multi-query was disabled via config `query.batch.enabled = false`.
    
    Specified by:
    
    setHasStepStrategyMode in interface TransactionBuilder
    
    Returns:
    
    Object with the set `has` step strategy mode settings
  - setPropertiesStrategyMode
```
public TransactionBuilder setPropertiesStrategyMode(MultiQueryPropertiesStrategyMode propertiesStrategyMode)
```
    Description copied from interface: TransactionBuilder
    
    Sets properties strategy mode.
    Doesn't have any effect if multi-query was disabled via config `query.batch.enabled = false`.
    
    Specified by:
    
    setPropertiesStrategyMode in interface TransactionBuilder
    
    Returns:
    
    Object with the set properties strategy mode settings
  - setLabelsStepStrategyMode
```
public TransactionBuilder setLabelsStepStrategyMode(MultiQueryLabelStepStrategyMode labelStepStrategyMode)
```
    Description copied from interface: TransactionBuilder
    
    Sets `label` step strategy mode.
    Doesn't have any effect if multi-query was disabled via config `query.batch.enabled = false`.
    
    Specified by:
    
    setLabelsStepStrategyMode in interface TransactionBuilder
    
    Returns:
    
    Object with the set labels strategy mode settings
  - setCommitTime
```
public void setCommitTime(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 JanusGraph metric names.
    
    Specified by:
    
    groupName in interface TransactionBuilder
    
    Parameters:
    
    p - Metric name prefix for this transaction
    
    Returns:
    
    Object containing transaction prefix name property
  - 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
    
    Parameters:
    
    logName - name of transaction log
    
    Returns:
    
    Object containing log identifier property
  - 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
    
    Parameters:
    
    partitions - Array of the int identifier of the partitions to be queried
    
    Returns:
    
    Object with restricted partitions
  - 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
    
    Parameters:
    
    k - Name of the configuration element.
    
    v - Object containing the custom options to be applied.
    
    Returns:
    
    Object containing the properties in param v
  - start
```
public JanusGraphTransaction 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.
  - hasDisabledSchemaConstraints
```
public boolean hasDisabledSchemaConstraints()
```
    Description copied from interface: TransactionConfiguration
    
    Allows to disable schema constraints.
    
    Specified by:
    
    hasDisabledSchemaConstraints in interface TransactionConfiguration
    
    Returns:
    
    True, if schema constraints should not be applied, else false.
  - 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
  - useMultiQuery
```
public boolean useMultiQuery()
```
    Description copied from interface: TransactionConfiguration
    
    Whether this transaction should batch backend queries. This can lead to significant performance improvement if there is non-trivial latency to the backend.
    
    Specified by:
    
    useMultiQuery in interface TransactionConfiguration
    
    Returns:
    
    True, if this transaction has multi-query enabled
  - 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 if the queried partitions should be restricted in this transaction
    
    Specified by:
    
    hasRestrictedPartitions in interface TransactionConfiguration
  - isSkipDBCacheRead
```
public boolean isSkipDBCacheRead()
```
    Description copied from interface: TransactionConfiguration
    
    Returns true if read queries should skip accessing JanusGraph database level cache (db-cache). Doesn't have any effect if database level cache was disabled via config `cache.db-cache`.
    
    Specified by:
    
    isSkipDBCacheRead in interface TransactionConfiguration
  - isLazyLoadRelations
```
public boolean isLazyLoadRelations()
```
    Description copied from interface: TransactionConfiguration
    
    Returns true if all properties and edges are lazy-loaded: ids and values are deserialized upon demand. When enabled, it can have a boost on large scale read operations, when only certain type of relations are being read.
    
    Specified by:
    
    isLazyLoadRelations in interface TransactionConfiguration
  - getHasStepStrategyMode
```
public MultiQueryHasStepStrategyMode getHasStepStrategyMode()
```
    Specified by:
    
    getHasStepStrategyMode in interface TransactionConfiguration
    
    Returns:
    
    Has step strategy mode used for the transaction. Can be configured via config `query.batch.has-step-mode`.
  - getPropertiesStrategyMode
```
public MultiQueryPropertiesStrategyMode getPropertiesStrategyMode()
```
    Specified by:
    
    getPropertiesStrategyMode in interface TransactionConfiguration
    
    Returns:
    
    Properties strategy mode used for the transaction. Can be configured via config `query.batch.properties-mode`.
  - getLabelStepStrategyMode
```
public MultiQueryLabelStepStrategyMode getLabelStepStrategyMode()
```
    Specified by:
    
    getLabelStepStrategyMode in interface TransactionConfiguration
    
    Returns:
    
    Label step strategy mode used for the transaction. Can be configured via config `query.batch.label-step-mode`.
  - 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 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

readOnlyOLAP

enableBatchLoading

disableBatchLoading

propertyPrefetching

multiQuery

vertexCacheSize

dirtyVertexSize

checkInternalVertexExistence

checkExternalVertexExistence

consistencyChecks

commitTime

skipDBCacheRead

lazyLoadRelations

setHasStepStrategyMode

setPropertiesStrategyMode

setLabelsStepStrategyMode

setCommitTime

groupName

logIdentifier

restrictedPartitions

setPreloadedData

customOption

start

isReadOnly

hasAssignIDsImmediately

hasPreloadedData

hasForceIndexUsage

hasEnabledBatchLoading

hasVerifyExternalVertexExistence

hasVerifyInternalVertexExistence

hasAcquireLocks

getAutoSchemaMaker

hasDisabledSchemaConstraints

hasVerifyUniqueness

hasPropertyPrefetching

useMultiQuery

isSingleThreaded

isThreadBound

getVertexCacheSize

getDirtyVertexSize

getIndexCacheWeight

getLogIdentifier

getRestrictedPartitions

hasRestrictedPartitions

isSkipDBCacheRead

isLazyLoadRelations

getHasStepStrategyMode

getPropertiesStrategyMode

getLabelStepStrategyMode

getGroupName

hasGroupName

getCommitTime

hasCommitTime

getCustomOption

getCustomOptions

getTimestampProvider