ByteKeyRangeTracker (Apache Beam 2.15.0)

java.lang.Object
- org.apache.beam.sdk.transforms.splittabledofn.RestrictionTracker<ByteKeyRange,ByteKey>
- - org.apache.beam.sdk.transforms.splittabledofn.ByteKeyRangeTracker

All Implemented Interfaces:

Sizes.HasSize
```
public class ByteKeyRangeTracker
extends RestrictionTracker<ByteKeyRange,ByteKey>
implements Sizes.HasSize
```
A RestrictionTracker for claiming ByteKeys in a ByteKeyRange in a monotonically increasing fashion. The range is a semi-open bounded interval [startKey, endKey) where the limits are both represented by ByteKey.EMPTY.
Note, one can complete a range by claiming the ByteKey.EMPTY once one runs out of keys to process.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkDone()` Called by the runner after `DoFn.ProcessElement` returns.
`ByteKeyRange`	`checkpoint()` Signals that the current `DoFn.ProcessElement` call should terminate as soon as possible: after this method returns, the tracker MUST refuse all future claim calls, and `RestrictionTracker.checkDone()` MUST succeed.
`ByteKeyRange`	`currentRestriction()` Returns a restriction accurately describing the full range of work the current `DoFn.ProcessElement` call will do, including already completed work.
`double`	`getSize()` A representation for the amount of known work represented as a size.
`static ByteKeyRangeTracker`	`of(ByteKeyRange range)`
`java.lang.String`	`toString()`
`boolean`	`tryClaim(ByteKey key)` Attempts to claim the given key.

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

- Method Detail
  - of
```
public static ByteKeyRangeTracker of(ByteKeyRange range)
```
  - currentRestriction
```
public ByteKeyRange currentRestriction()
```
    Description copied from class: RestrictionTracker
    
    Returns a restriction accurately describing the full range of work the current DoFn.ProcessElement call will do, including already completed work.
    
    Specified by:
    
    currentRestriction in class RestrictionTracker<ByteKeyRange,ByteKey>
  - checkpoint
```
public ByteKeyRange checkpoint()
```
    Description copied from class: RestrictionTracker
    
    Signals that the current DoFn.ProcessElement call should terminate as soon as possible: after this method returns, the tracker MUST refuse all future claim calls, and RestrictionTracker.checkDone() MUST succeed.
    Modifies RestrictionTracker.currentRestriction(). Returns a restriction representing the rest of the work: the old value of RestrictionTracker.currentRestriction() is equivalent to the new value and the return value of this method combined.
    Must be called at most once on a given object.
    
    Specified by:
    
    checkpoint in class RestrictionTracker<ByteKeyRange,ByteKey>
  - tryClaim
```
public boolean tryClaim(ByteKey key)
```
    Attempts to claim the given key.
    Must be larger than the last attempted key. Since this restriction tracker represents a range over a semi-open bounded interval [start, end), the last key that was attempted may have failed but still have consumed the interval [lastAttemptedKey, end) since this range tracker processes keys in a monotonically increasing order. Note that passing in ByteKey.EMPTY claims all keys to the end of range and can only be claimed once.
    
    Specified by:
    
    tryClaim in class RestrictionTracker<ByteKeyRange,ByteKey>
    
    Returns:
    
    true if the key was successfully claimed, false if it is outside the current ByteKeyRange of this tracker.
  - checkDone
```
public void checkDone()
               throws java.lang.IllegalStateException
```
    Description copied from class: RestrictionTracker
    
    Called by the runner after DoFn.ProcessElement returns.
    Must throw an exception with an informative error message, if there is still any unclaimed work remaining in the restriction.
    
    Specified by:
    
    checkDone in class RestrictionTracker<ByteKeyRange,ByteKey>
    
    Throws:
    
    java.lang.IllegalStateException
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getSize
```
public double getSize()
```
    Description copied from interface: Sizes.HasSize
    A representation for the amount of known work represented as a size. Size double representations should preferably represent a linear space and be comparable within the same partition.
    It is up to each restriction tracker to convert between their natural representation of outstanding work and this representation. For example:
    - Block based file source (e.g. Avro): From the end of the current block, the remaining number of bytes to the end of the restriction.
    - Pull based queue based source (e.g. Pubsub): The local/global size available in number of messages or number of message bytes that have not been processed.
    - Key range based source (e.g. Shuffle, Bigtable, ...): Scale the start key to be one and end key to be zero and interpolate the position of the next splittable key as the size. If information about the probability density function or cumulative distribution function is available, size interpolation can be improved. Alternatively, if the number of encoded bytes for the keys and values is known for the key range, the number of remaining bytes can be used.
    DoFns should provide a method annotated with DoFn.GetPartition to report a partition identifier if the element and restriction represent the size for a shared resource such as a message queue topic. See DoFn.GetPartition for additional details.
    Specified by:
    
    getSize in interface Sizes.HasSize

Class ByteKeyRangeTracker

Method Summary

Methods inherited from class java.lang.Object

Method Detail

of

currentRestriction

checkpoint

tryClaim

checkDone

toString

getSize