DictionaryBlock (presto-common 0.272 API)

java.lang.Object
- com.facebook.presto.common.block.DictionaryBlock

All Implemented Interfaces:: Block, UncheckedBlock

public class DictionaryBlock
extends Object
implements Block

Constructor Summary

Constructors
Constructor and Description
`DictionaryBlock(Block dictionary, int[] ids)`
`DictionaryBlock(int positionCount, Block dictionary, int[] ids)`
`DictionaryBlock(int positionCount, Block dictionary, int[] ids, boolean dictionaryIsCompacted)`
`DictionaryBlock(int positionCount, Block dictionary, int[] ids, boolean dictionaryIsCompacted, DictionaryId dictionarySourceId)`
`DictionaryBlock(int positionCount, Block dictionary, int[] ids, DictionaryId dictionaryId)`
`DictionaryBlock(int idsOffset, int positionCount, Block dictionary, int[] ids, boolean dictionaryIsCompacted, DictionaryId dictionarySourceId)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Block`	`appendNull()` Returns a block that has an appended null at the end, no matter if the original block has null or not.
`int`	`bytesCompare(int position, int offset, int length, io.airlift.slice.Slice otherSlice, int otherOffset, int otherLength)` Compares the byte sequences at `offset` in the value at `position` to the byte sequence at `otherOffset` in `otherSlice`.
`boolean`	`bytesEqual(int position, int offset, io.airlift.slice.Slice otherSlice, int otherOffset, int length)` Is the byte sequences at `offset` in the value at `position` equal to the byte sequence at `otherOffset` in `otherSlice`.
`DictionaryBlock`	`compact()`
`int`	`compareTo(int leftPosition, int leftOffset, int leftLength, Block rightBlock, int rightPosition, int rightOffset, int rightLength)` Compares the byte sequences at `offset` in the value at `position` to the byte sequence at `otherOffset` in the value at `otherPosition` in `otherBlock`.
`Block`	`copyPositions(int[] positions, int offset, int length)` Returns a block containing the specified positions.
`Block`	`copyRegion(int position, int length)` Returns a block starting at the specified position and extends for the specified length.
`boolean`	`equals(int position, int offset, Block otherBlock, int otherPosition, int otherOffset, int length)` Is the byte sequences at `offset` in the value at `position` equal to the byte sequence at `otherOffset` in the value at `otherPosition` in `otherBlock`.
`OptionalInt`	`fixedSizeInBytesPerPosition()` Returns the number of bytes (in terms of `Block.getSizeInBytes()`) required per position that this block contains, assuming that the number of bytes required is a known static quantity and not dependent on any particular specific position.
`long`	`getApproximateRegionLogicalSizeInBytes(int position, int length)` Returns the approximate logical size of `block.getRegion(position, length)`.
`Block`	`getBlock(int position)` Gets a block in the value at `position`.
`Block`	`getBlockUnchecked(int internalPosition)` Gets a Block value at `internalPosition - getOffsetBase()`.
`byte`	`getByte(int position)` Gets a byte in the value at `position`.
`byte`	`getByteUnchecked(int internalPosition)` Gets a byte value at `internalPosition - getOffsetBase()`.
`Block`	`getDictionary()`
`DictionaryId`	`getDictionarySourceId()`
`String`	`getEncodingName()` Get the encoding for this block.
`long`	`getEstimatedDataSizeForStats(int position)` Returns the estimated in memory data size for stats of position.
`int`	`getId(int position)`
`int`	`getInt(int position)` Gets a little endian int in the value at `position`.
`int`	`getIntUnchecked(int internalPosition)` Gets a little endian int value at `internalPosition - getOffsetBase()`.
`Block`	`getLoadedBlock()` Returns a block that assures all data is in memory.
`long`	`getLogicalSizeInBytes()` Returns the size of the block contents, regardless of internal representation.
`long`	`getLong(int position)` Gets a little endian long in the value at `position`.
`long`	`getLong(int position, int offset)` Gets a little endian long at `offset` in the value at `position`.
`long`	`getLongUnchecked(int internalPosition)` Gets a little endian long value at `internalPosition - getOffsetBase()`.
`long`	`getLongUnchecked(int internalPosition, int offset)` Gets a little endian long at `offset` in the value at `internalPosition - getOffsetBase()`.
`int`	`getOffsetBase()`
`int`	`getPositionCount()` Returns the number of positions in this block.
`Block`	`getPositions(int[] positions, int offset, int length)` Create a new block from the current block by keeping the same elements only with respect to `positions` that starts at `offset` and has length of `length`.
`long`	`getPositionsSizeInBytes(boolean[] positions, int usedPositionCount)` Returns the size of all positions marked true in the positions array.
`Block`	`getRegion(int positionOffset, int length)` Returns a block starting at the specified position and extends for the specified length.
`long`	`getRegionLogicalSizeInBytes(int positionOffset, int length)` Returns the size of `block.getRegion(position, length)`.
`long`	`getRegionSizeInBytes(int positionOffset, int length)` Returns the size of `block.getRegion(position, length)`.
`long`	`getRetainedSizeInBytes()` Returns the retained size of this block in memory, including over-allocations.
`short`	`getShort(int position)` Gets a little endian short at in the value at `position`.
`short`	`getShortUnchecked(int internalPosition)` Gets a little endian short at value at `internalPosition - getOffsetBase()`.
`Block`	`getSingleValueBlock(int position)` Gets the value at the specified position as a single element block.
`long`	`getSizeInBytes()` Returns the size of this block as if it was compacted, ignoring any over-allocations.
`io.airlift.slice.Slice`	`getSlice(int position, int offset, int length)` Gets a slice at `offset` in the value at `position`.
`int`	`getSliceLength(int position)` Gets the length of the value at the `position`.
`int`	`getSliceLengthUnchecked(int internalPosition)` Gets the length of the slice value at `internalPosition - getOffsetBase()`.
`io.airlift.slice.Slice`	`getSliceUnchecked(int internalPosition, int offset, int length)` Gets a slice with offset `offset` at `internalPosition - getOffsetBase()`.
`long`	`hash(int position, int offset, int length)` Calculates the hash code the byte sequences at `offset` in the value at `position`.
`boolean`	`isCompact()`
`boolean`	`isNull(int position)` Is the specified position null?
`boolean`	`isNullUnchecked(int internalPosition)`
`boolean`	`mayHaveNull()` Is it possible the block may have a null value? If false, the block can not contain a null, but if true, the block may or may not have a null.
`void`	`retainedBytesForEachPart(BiConsumer<Object,Long> consumer)` `consumer` visits each of the internal data container and accepts the size for it.
`String`	`toString()`
`void`	`writeBytesTo(int position, int offset, int length, BlockBuilder blockBuilder)` Appends the byte sequences at `offset` in the value at `position` to `blockBuilder`.
`void`	`writeBytesTo(int position, int offset, int length, io.airlift.slice.SliceOutput sliceOutput)` Appends the byte sequences at `offset` in the value at `position` to `sliceOutput`.
`void`	`writePositionTo(int position, BlockBuilder blockBuilder)` Appends the value at `position` to `blockBuilder` and close the entry.
`void`	`writePositionTo(int position, io.airlift.slice.SliceOutput output)` Appends the value at `position` to `output`.

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

- Constructor Detail
  - DictionaryBlock
```
public DictionaryBlock(Block dictionary,
                       int[] ids)
```
  - DictionaryBlock
```
public DictionaryBlock(int positionCount,
                       Block dictionary,
                       int[] ids)
```
  - DictionaryBlock
```
public DictionaryBlock(int positionCount,
                       Block dictionary,
                       int[] ids,
                       DictionaryId dictionaryId)
```
  - DictionaryBlock
```
public DictionaryBlock(int positionCount,
                       Block dictionary,
                       int[] ids,
                       boolean dictionaryIsCompacted)
```
  - DictionaryBlock
```
public DictionaryBlock(int positionCount,
                       Block dictionary,
                       int[] ids,
                       boolean dictionaryIsCompacted,
                       DictionaryId dictionarySourceId)
```
  - DictionaryBlock
```
public DictionaryBlock(int idsOffset,
                       int positionCount,
                       Block dictionary,
                       int[] ids,
                       boolean dictionaryIsCompacted,
                       DictionaryId dictionarySourceId)
```
- Method Detail
  - getSliceLength
```
public int getSliceLength(int position)
```
    Description copied from interface: Block
    
    Gets the length of the value at the position. This method must be implemented if @{code getSlice} is implemented.
    
    Specified by:
    
    getSliceLength in interface Block
  - getByte
```
public byte getByte(int position)
```
    Description copied from interface: Block
    
    Gets a byte in the value at position.
    
    Specified by:
    
    getByte in interface Block
  - getShort
```
public short getShort(int position)
```
    Description copied from interface: Block
    
    Gets a little endian short at in the value at position.
    
    Specified by:
    
    getShort in interface Block
  - getInt
```
public int getInt(int position)
```
    Description copied from interface: Block
    
    Gets a little endian int in the value at position.
    
    Specified by:
    
    getInt in interface Block
  - getLong
```
public long getLong(int position)
```
    Description copied from interface: Block
    
    Gets a little endian long in the value at position.
    
    Specified by:
    
    getLong in interface Block
  - getLong
```
public long getLong(int position,
                    int offset)
```
    Description copied from interface: Block
    
    Gets a little endian long at offset in the value at position.
    
    Specified by:
    
    getLong in interface Block
  - getSlice
```
public io.airlift.slice.Slice getSlice(int position,
                                       int offset,
                                       int length)
```
    Description copied from interface: Block
    
    Gets a slice at offset in the value at position.
    
    Specified by:
    
    getSlice in interface Block
  - getBlock
```
public Block getBlock(int position)
```
    Description copied from interface: Block
    
    Gets a block in the value at position.
    
    Specified by:
    
    getBlock in interface Block
    
    Returns:
  - bytesEqual
```
public boolean bytesEqual(int position,
                          int offset,
                          io.airlift.slice.Slice otherSlice,
                          int otherOffset,
                          int length)
```
    Description copied from interface: Block
    
    Is the byte sequences at offset in the value at position equal to the byte sequence at otherOffset in otherSlice. This method must be implemented if @{code getSlice} is implemented.
    
    Specified by:
    
    bytesEqual in interface Block
  - bytesCompare
```
public int bytesCompare(int position,
                        int offset,
                        int length,
                        io.airlift.slice.Slice otherSlice,
                        int otherOffset,
                        int otherLength)
```
    Description copied from interface: Block
    
    Compares the byte sequences at offset in the value at position to the byte sequence at otherOffset in otherSlice. This method must be implemented if @{code getSlice} is implemented.
    
    Specified by:
    
    bytesCompare in interface Block
  - writeBytesTo
```
public void writeBytesTo(int position,
                         int offset,
                         int length,
                         BlockBuilder blockBuilder)
```
    Description copied from interface: Block
    
    Appends the byte sequences at offset in the value at position to blockBuilder. This method must be implemented if @{code getSlice} is implemented.
    
    Specified by:
    
    writeBytesTo in interface Block
  - writeBytesTo
```
public void writeBytesTo(int position,
                         int offset,
                         int length,
                         io.airlift.slice.SliceOutput sliceOutput)
```
    Description copied from interface: Block
    
    Appends the byte sequences at offset in the value at position to sliceOutput. This method must be implemented if @{code getSlice} is implemented.
    
    Specified by:
    
    writeBytesTo in interface Block
  - writePositionTo
```
public void writePositionTo(int position,
                            BlockBuilder blockBuilder)
```
    Description copied from interface: Block
    
    Appends the value at position to blockBuilder and close the entry.
    
    Specified by:
    
    writePositionTo in interface Block
  - writePositionTo
```
public void writePositionTo(int position,
                            io.airlift.slice.SliceOutput output)
```
    Description copied from interface: Block
    
    Appends the value at position to output.
    
    Specified by:
    
    writePositionTo in interface Block
  - equals
```
public boolean equals(int position,
                      int offset,
                      Block otherBlock,
                      int otherPosition,
                      int otherOffset,
                      int length)
```
    Description copied from interface: Block
    
    Is the byte sequences at offset in the value at position equal to the byte sequence at otherOffset in the value at otherPosition in otherBlock. This method must be implemented if @{code getSlice} is implemented.
    
    Specified by:
    
    equals in interface Block
  - hash
```
public long hash(int position,
                 int offset,
                 int length)
```
    Description copied from interface: Block
    
    Calculates the hash code the byte sequences at offset in the value at position. This method must be implemented if @{code getSlice} is implemented.
    
    Specified by:
    
    hash in interface Block
  - compareTo
```
public int compareTo(int leftPosition,
                     int leftOffset,
                     int leftLength,
                     Block rightBlock,
                     int rightPosition,
                     int rightOffset,
                     int rightLength)
```
    Description copied from interface: Block
    
    Compares the byte sequences at offset in the value at position to the byte sequence at otherOffset in the value at otherPosition in otherBlock. This method must be implemented if @{code getSlice} is implemented.
    
    Specified by:
    
    compareTo in interface Block
  - getSingleValueBlock
```
public Block getSingleValueBlock(int position)
```
    Description copied from interface: Block
    
    Gets the value at the specified position as a single element block. The returned block should retain only the memory required for a single block.
    This method is useful for operators that hold on to a single value without holding on to the entire block.
    
    Specified by:
    
    getSingleValueBlock in interface Block
  - getPositionCount
```
public int getPositionCount()
```
    Description copied from interface: Block
    
    Returns the number of positions in this block.
    
    Specified by:
    
    getPositionCount in interface Block
  - getSizeInBytes
```
public long getSizeInBytes()
```
    Description copied from interface: Block
    
    Returns the size of this block as if it was compacted, ignoring any over-allocations. For example, in dictionary blocks, this only counts each dictionary entry once, rather than each time a value is referenced.
    
    Specified by:
    
    getSizeInBytes in interface Block
  - fixedSizeInBytesPerPosition
```
public OptionalInt fixedSizeInBytesPerPosition()
```
    Description copied from interface: Block
    
    Returns the number of bytes (in terms of Block.getSizeInBytes()) required per position that this block contains, assuming that the number of bytes required is a known static quantity and not dependent on any particular specific position. This allows for some complex block wrappings to potentially avoid having to call Block.getPositionsSizeInBytes(boolean[], int) which would require computing the specific positions selected
    
    Specified by:
    
    fixedSizeInBytesPerPosition in interface Block
    
    Returns:
    
    The size in bytes, per position, if this block type does not require specific position information to compute its size
  - getLogicalSizeInBytes
```
public long getLogicalSizeInBytes()
```
    Description copied from interface: Block
    
    Returns the size of the block contents, regardless of internal representation. The same logical data values should always have the same size, no matter what block type is used or how they are represented within a specific block. This can differ substantially from Block.getSizeInBytes() for certain block types. For RLE, it will be N times larger. For dictionary, it will be larger based on how many times dictionary entries are reused.
    
    Specified by:
    
    getLogicalSizeInBytes in interface Block
  - getRegionSizeInBytes
```
public long getRegionSizeInBytes(int positionOffset,
                                 int length)
```
    Description copied from interface: Block
    
    Returns the size of block.getRegion(position, length). The method can be expensive. Do not use it outside an implementation of Block.
    
    Specified by:
    
    getRegionSizeInBytes in interface Block
  - getRegionLogicalSizeInBytes
```
public long getRegionLogicalSizeInBytes(int positionOffset,
                                        int length)
```
    Description copied from interface: Block
    
    Returns the size of block.getRegion(position, length). The method can be expensive. Do not use it outside an implementation of Block.
    
    Specified by:
    
    getRegionLogicalSizeInBytes in interface Block
  - getApproximateRegionLogicalSizeInBytes
```
public long getApproximateRegionLogicalSizeInBytes(int position,
                                                   int length)
```
    Description copied from interface: Block
    
    Returns the approximate logical size of block.getRegion(position, length). This method is faster than getRegionLogicalSizeInBytes(). For dictionary blocks, this counts the amortized flattened size of the included positions. For example, for a DictionaryBlock with 5 ids [1, 1, 1, 1, 1] and a dictionary of VariableWidthBlock with 3 elements of sizes [9, 5, 7], the result of getApproximateRegionLogicalSizeInBytes(0, 5) would be (9 + 5 + 7) / 3 * 5 = 35, while getRegionLogicalSizeInBytes(0, 5) would be 5 * 5 = 25.
    
    Specified by:
    
    getApproximateRegionLogicalSizeInBytes in interface Block
  - getPositionsSizeInBytes
```
public long getPositionsSizeInBytes(boolean[] positions,
                                    int usedPositionCount)
```
    Description copied from interface: Block
    
    Returns the size of all positions marked true in the positions array. This is equivalent to multiple calls of block.getRegionSizeInBytes(position, length) where you mark all positions for the regions first.
    
    Specified by:
    
    getPositionsSizeInBytes in interface Block
  - getRetainedSizeInBytes
```
public long getRetainedSizeInBytes()
```
    Description copied from interface: Block
    
    Returns the retained size of this block in memory, including over-allocations. This method is called from the inner most execution loop and must be fast.
    
    Specified by:
    
    getRetainedSizeInBytes in interface Block
  - getEstimatedDataSizeForStats
```
public long getEstimatedDataSizeForStats(int position)
```
    Description copied from interface: Block
    
    Returns the estimated in memory data size for stats of position. Do not use it for other purpose.
    
    Specified by:
    
    getEstimatedDataSizeForStats in interface Block
  - retainedBytesForEachPart
```
public void retainedBytesForEachPart(BiConsumer<Object,Long> consumer)
```
    Description copied from interface: Block
    
    consumer visits each of the internal data container and accepts the size for it. This method can be helpful in cases such as memory counting for internal data structure. Also, the method should be non-recursive, only visit the elements at the top level, and specifically should not call retainedBytesForEachPart on nested blocks consumer should be called at least once with the current block and must include the instance size of the current block
    
    Specified by:
    
    retainedBytesForEachPart in interface Block
  - getEncodingName
```
public String getEncodingName()
```
    Description copied from interface: Block
    
    Get the encoding for this block.
    
    Specified by:
    
    getEncodingName in interface Block
  - copyPositions
```
public Block copyPositions(int[] positions,
                           int offset,
                           int length)
```
    Description copied from interface: Block
    
    Returns a block containing the specified positions. Positions to copy are stored in a subarray within positions array that starts at offset and has length of length. All specified positions must be valid for this block.
    The returned block must be a compact representation of the original block.
    
    Specified by:
    
    copyPositions in interface Block
  - getRegion
```
public Block getRegion(int positionOffset,
                       int length)
```
    Description copied from interface: Block
    
    Returns a block starting at the specified position and extends for the specified length. The specified region must be entirely contained within this block.
    The region can be a view over this block. If this block is released the region block may also be released. If the region block is released this block may also be released.
    
    Specified by:
    
    getRegion in interface Block
  - copyRegion
```
public Block copyRegion(int position,
                        int length)
```
    Description copied from interface: Block
    
    Returns a block starting at the specified position and extends for the specified length. The specified region must be entirely contained within this block.
    The region returned must be a compact representation of the original block, unless their internal representation will be exactly the same. This method is useful for operators that hold on to a range of values without holding on to the entire block.
    
    Specified by:
    
    copyRegion in interface Block
  - isNull
```
public boolean isNull(int position)
```
    Description copied from interface: Block
    
    Is the specified position null?
    
    Specified by:
    
    isNull in interface Block
  - mayHaveNull
```
public boolean mayHaveNull()
```
    Description copied from interface: Block
    
    Is it possible the block may have a null value? If false, the block can not contain a null, but if true, the block may or may not have a null.
    
    Specified by:
    
    mayHaveNull in interface Block
  - getPositions
```
public Block getPositions(int[] positions,
                          int offset,
                          int length)
```
    Description copied from interface: Block
    
    Create a new block from the current block by keeping the same elements only with respect to positions that starts at offset and has length of length. May return a view over the data in this block or may return a copy
    
    Specified by:
    
    getPositions in interface Block
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getLoadedBlock
```
public Block getLoadedBlock()
```
    Description copied from interface: Block
    
    Returns a block that assures all data is in memory. May return the same block if all block data is already in memory.
    This allows streaming data sources to skip sections that are not accessed in a query.
    
    Specified by:
    
    getLoadedBlock in interface Block
  - getDictionary
```
public Block getDictionary()
```
  - getId
```
public int getId(int position)
```
  - getDictionarySourceId
```
public DictionaryId getDictionarySourceId()
```
  - isCompact
```
public boolean isCompact()
```
  - compact
```
public DictionaryBlock compact()
```
  - getByteUnchecked
```
public byte getByteUnchecked(int internalPosition)
```
    Description copied from interface: UncheckedBlock
    
    Gets a byte value at internalPosition - getOffsetBase().
    
    Specified by:
    
    getByteUnchecked in interface UncheckedBlock
  - getShortUnchecked
```
public short getShortUnchecked(int internalPosition)
```
    Description copied from interface: UncheckedBlock
    
    Gets a little endian short at value at internalPosition - getOffsetBase().
    
    Specified by:
    
    getShortUnchecked in interface UncheckedBlock
  - getIntUnchecked
```
public int getIntUnchecked(int internalPosition)
```
    Description copied from interface: UncheckedBlock
    
    Gets a little endian int value at internalPosition - getOffsetBase().
    
    Specified by:
    
    getIntUnchecked in interface UncheckedBlock
  - getLongUnchecked
```
public long getLongUnchecked(int internalPosition)
```
    Description copied from interface: UncheckedBlock
    
    Gets a little endian long value at internalPosition - getOffsetBase().
    
    Specified by:
    
    getLongUnchecked in interface UncheckedBlock
  - getLongUnchecked
```
public long getLongUnchecked(int internalPosition,
                             int offset)
```
    Description copied from interface: UncheckedBlock
    
    Gets a little endian long at offset in the value at internalPosition - getOffsetBase().
    
    Specified by:
    
    getLongUnchecked in interface UncheckedBlock
  - getSliceUnchecked
```
public io.airlift.slice.Slice getSliceUnchecked(int internalPosition,
                                                int offset,
                                                int length)
```
    Description copied from interface: UncheckedBlock
    
    Gets a slice with offset offset at internalPosition - getOffsetBase().
    
    Specified by:
    
    getSliceUnchecked in interface UncheckedBlock
  - getSliceLengthUnchecked
```
public int getSliceLengthUnchecked(int internalPosition)
```
    Description copied from interface: UncheckedBlock
    
    Gets the length of the slice value at internalPosition - getOffsetBase(). This method must be implemented if getSliceUnchecked is implemented.
    
    Specified by:
    
    getSliceLengthUnchecked in interface UncheckedBlock
  - getBlockUnchecked
```
public Block getBlockUnchecked(int internalPosition)
```
    Description copied from interface: UncheckedBlock
    
    Gets a Block value at internalPosition - getOffsetBase().
    
    Specified by:
    
    getBlockUnchecked in interface UncheckedBlock
  - getOffsetBase
```
public int getOffsetBase()
```
    Specified by:
    
    getOffsetBase in interface UncheckedBlock
    
    Returns:
    
    the internal offset of the underlying data structure of this block
  - isNullUnchecked
```
public boolean isNullUnchecked(int internalPosition)
```
    Specified by:
    
    isNullUnchecked in interface UncheckedBlock
    
    Returns:
    
    true if value at internalPosition - getOffsetBase() is null
  - appendNull
```
public Block appendNull()
```
    Description copied from interface: Block
    
    Returns a block that has an appended null at the end, no matter if the original block has null or not. The original block won't be modified.
    
    Specified by:
    
    appendNull in interface Block

Class DictionaryBlock

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DictionaryBlock

DictionaryBlock

DictionaryBlock

DictionaryBlock

DictionaryBlock

DictionaryBlock

Method Detail

getSliceLength

getByte

getShort

getInt

getLong

getLong

getSlice

getBlock

bytesEqual

bytesCompare

writeBytesTo

writeBytesTo

writePositionTo

writePositionTo

equals

hash

compareTo

getSingleValueBlock

getPositionCount

getSizeInBytes

fixedSizeInBytesPerPosition

getLogicalSizeInBytes

getRegionSizeInBytes

getRegionLogicalSizeInBytes

getApproximateRegionLogicalSizeInBytes

getPositionsSizeInBytes

getRetainedSizeInBytes

getEstimatedDataSizeForStats

retainedBytesForEachPart

getEncodingName

copyPositions

getRegion

copyRegion

isNull

mayHaveNull

getPositions

toString

getLoadedBlock

getDictionary

getId

getDictionarySourceId

isCompact

compact

getByteUnchecked

getShortUnchecked

getIntUnchecked

getLongUnchecked

getLongUnchecked

getSliceUnchecked

getSliceLengthUnchecked

getBlockUnchecked

getOffsetBase

isNullUnchecked

appendNull