Package com.couchbase.client.core.transaction

Class CoreTransactionAttemptContext

java.lang.Object
com.couchbase.client.core.transaction.CoreTransactionAttemptContext
@Internal public class CoreTransactionAttemptContext extends Object
Provides methods to allow an application's transaction logic to read, mutate, insert and delete documents, as well as commit or rollback the transaction.

  • Field Details

    • TRANSACTION_STATE_BIT_COMMIT_NOT_ALLOWED

      public static final int TRANSACTION_STATE_BIT_COMMIT_NOT_ALLOWED
      See Also:

    • TRANSACTION_STATE_BIT_APP_ROLLBACK_NOT_ALLOWED

      public static final int TRANSACTION_STATE_BIT_APP_ROLLBACK_NOT_ALLOWED
      See Also:

    • TRANSACTION_STATE_BIT_SHOULD_NOT_ROLLBACK

      public static final int TRANSACTION_STATE_BIT_SHOULD_NOT_ROLLBACK
      See Also:

    • TRANSACTION_STATE_BIT_SHOULD_NOT_RETRY

      public static final int TRANSACTION_STATE_BIT_SHOULD_NOT_RETRY
      See Also:

    • STATE_BITS_POSITION_FINAL_ERROR

      public static final int STATE_BITS_POSITION_FINAL_ERROR
      See Also:

    • STATE_BITS_MASK_FINAL_ERROR

      public static final int STATE_BITS_MASK_FINAL_ERROR
      See Also:

    • STATE_BITS_MASK_BITS

      public static final int STATE_BITS_MASK_BITS
      See Also:

    • DEFAULT_DELAY_RETRYING_OPERATION

      public static final Duration DEFAULT_DELAY_RETRYING_OPERATION

  • Constructor Details

  • Method Details

    • core

      public Core core()

    • scheduler

      public Scheduler scheduler()
      Bear in mind, in this code with the blocking API: 
       cluster.transactions().run((ctx) -> {
     Thread ct = Thread.currentThread();

     ctx.insert(collection, docId, content);

     Thread ct2 = Thread.currentThread();
 });
      ct will _always_ equal ct2 (which is what we want), regardless of what we do with schedulers. As there's no way to change the current thread of execution in that way.

      We put things onto our scheduler for the benefit of reactive users. Because we don't want to pass control back to user space (the lambda) while still on a limited internal SDK thread.

    • attemptId

      public String attemptId()
      Returns the globally unique ID of this attempt, which may be useful for debugging and logging purposes.

    • transactionId

      public String transactionId()
      Returns the globally unique ID of the overall transaction owning this attempt, which may be useful for debugging and logging purposes.

    • get

      public Mono<CoreTransactionGetResult> get(CollectionIdentifier collection, String id)
      Gets a document with the specified id and from the specified Couchbase bucket.

      Parameters:
      collection - the Couchbase collection the document exists on
      id - the document's ID
      Returns:
      a TransactionGetResultInternal containing the document

    • atrId

      public Optional<String> atrId()

    • atrCollection

      public Optional<CollectionIdentifier> atrCollection()

    • insert

      public Mono<CoreTransactionGetResult> insert(CollectionIdentifier collection, String id, byte[] content, SpanWrapper pspan)
      Inserts a new document into the specified Couchbase collection.
      Parameters:
      collection - the Couchbase collection in which to insert the doc
      id - the document's unique ID
      content - the content to insert
      Returns:
      the doc, updated with its new CAS value and ID, and converted to a TransactionGetResultInternal

    • randomAtrIdForVbucket

      protected String randomAtrIdForVbucket(CoreTransactionAttemptContext self, Integer vbucketIdForDoc, int numAtrs)

    • replace

      public Mono<CoreTransactionGetResult> replace(CoreTransactionGetResult doc, byte[] content, SpanWrapper pspan)
      Mutates the specified doc with new content, using the document's last CoreTransactionGetResult.cas().
      Parameters:
      doc - the doc to be mutated
      content - the content to replace the doc with
      Returns:
      the doc, updated with its new CAS value. For performance a copy is not created and the original doc object is modified.

    • doQueryOperation

      public <T> Mono<T> doQueryOperation(String lockDebugIn, String statement, @Nullable SpanWrapper pspan, TriFunction<Integer,AtomicReference<ReactiveLock.Waiter>,SpanWrapper,Mono<T>> op)
      Doesn't need everything from doKVOperation, as queryWrapper already centralises a lot of logic

    • remove

      public Mono<Void> remove(CoreTransactionGetResult doc, SpanWrapper pspan)
      Removes the specified doc, using the document's last CoreTransactionGetResult.cas().

      Parameters:
      doc - - the doc to be removed

    • commit

      public Mono<Void> commit()
      Commits the transaction. All staged replaces, inserts and removals will be written.

      The semantics are the same as commit(), except that the a Mono is returned so the operation can be performed asynchronously.

    • span

      public RequestSpan span()

    • rollback

      public Mono<Void> rollback()
      Rolls back the transaction. All staged replaces, inserts and removals will be removed. The transaction will not be retried, so this will be the final attempt.

    • operationFailed

      public TransactionOperationFailedException operationFailed(boolean updateInternalState, TransactionOperationFailedException err)
      Rollback errors rules: Errors during auto-rollback: do not update internal state, as the user cares more about the original error that provoked the rollback Errors during app-rollback: do update internal state. Nothing else has gone wrong with the transaction, and the user will care about rollback problems. If !updateInternalState, the internal state bits are not changed.

    • operationFailed

      public TransactionOperationFailedException operationFailed(TransactionOperationFailedException err)

    • queryWrapperLocked

      public Mono<ClassicCoreReactiveQueryResult> queryWrapperLocked(int sidx, @Nullable CoreQueryContext qc, String statement, @Nullable CoreQueryOptions options, String hookPoint, boolean isBeginWork, boolean existingErrorCheck, @Nullable com.couchbase.client.core.deps.com.fasterxml.jackson.databind.node.ObjectNode txdata, @Nullable com.couchbase.client.core.deps.com.fasterxml.jackson.databind.node.ArrayNode params, @Nullable SpanWrapper span, boolean tximplicit, AtomicReference<ReactiveLock.Waiter> lockToken, boolean updateInternalState)
      This will return a TransactionOperationFailedException if that's what query returns, else will return the error after passing through convertQueryError.

      If an error is universally handled the same way, then convertQueryError will return a TransactionOperationFailedException.

      Because this is a general-purpose wrapper, TransactionOperationFaileds will _not_ be added to internal errors array. So the transaction is allowed to continue after failures, unless the caller prevents it. Update: appears to no longer be the case. Keep this routine in sync with queryWrapperReactiveLocked.

      Parameters:
      lockToken - if null, the lock is held throughout

    • queryBlocking

      public Mono<CoreQueryResult> queryBlocking(String statement, @Nullable CoreQueryContext qc, @Nullable CoreQueryOptions options, boolean tximplicit)
      Used by AttemptContext, buffers all query rows in-memory.

    • logger

      public CoreTransactionLogger logger()
      Returns the CoreTransactionLogger used by this instance, so the developer can insert their own log messages.

    • toString

      public String toString()
      Overrides:
      toString in class Object