Interface CommitTimestampLoader


  • public interface CommitTimestampLoader
    • Method Detail

      • getCommitTimestamps

        com.google.common.util.concurrent.ListenableFuture<org.eclipse.collections.api.map.primitive.LongLongMap> getCommitTimestamps​(@Nullable
                                                                                                                                      TableReference tableRef,
                                                                                                                                      org.eclipse.collections.api.LongIterable startTimestamps)
        Returns a map from start timestamp to commit timestamp. If the transaction corresponding to a start timestamp has neither committed nor aborted, it will be missing from the map. This method will block until the transactions for these start timestamps are believed to no longer be running. Note that this method does not actively abort transactions - in particular, a transaction that is believed to no longer be running may still commit in the future.
      • getCommitTimestampsNonBlockingForValidation

        com.google.common.util.concurrent.ListenableFuture<org.eclipse.collections.api.map.primitive.LongLongMap> getCommitTimestampsNonBlockingForValidation​(@Nullable
                                                                                                                                                              TableReference tableRef,
                                                                                                                                                              org.eclipse.collections.api.LongIterable startTimestamps)
        Performs getCommitTimestamps(TableReference, LongIterable) as described above, but does not wait for transactions for these start timestamps to be believed to no longer be running. This is likely to be relevant in contexts such as conflict checking, where we want to check for conflicts with transactions that are still running while avoiding possible deadlocks between transactions reading or writing to overlapping sets of cells.