Java Code Examples for io.prestosql.spi.block.Block#getSlice()

@Override
public void deleteRows(Block rowIds)
{
    Schema schema = table.getSchema();
    KuduSession session = clientSession.newSession();
    session.setFlushMode(FlushMode.AUTO_FLUSH_BACKGROUND);
    try {
        try {
            for (int i = 0; i < rowIds.getPositionCount(); i++) {
                int len = rowIds.getSliceLength(i);
                Slice slice = rowIds.getSlice(i, 0, len);
                PartialRow row = KeyEncoderAccessor.decodePrimaryKey(schema, slice.getBytes());
                Delete delete = table.newDelete();
                RowHelper.copyPrimaryKey(schema, row, delete.getRow());
                session.apply(delete);
            }
        }
        finally {
            session.close();
        }
    }
    catch (KuduException e) {
        throw new RuntimeException(e);
    }
}
 

@Override
public int compareTo(Block leftBlock, int leftPosition, Block rightBlock, int rightPosition)
{
    Slice leftSlice = leftBlock.getSlice(leftPosition, 0, leftBlock.getSliceLength(leftPosition));
    Slice rightSlice = rightBlock.getSlice(rightPosition, 0, rightBlock.getSliceLength(rightPosition));

    return compareChars(leftSlice, rightSlice);
}
 

@Override
public Object getObject(Block block, int position)
{
    if (block.isNull(position)) {
        return null;
    }

    Slice slice = block.getSlice(position, 0, block.getSliceLength(position));
    int[] codePoints = new int[slice.length() / Integer.BYTES];
    slice.getBytes(0, Slices.wrappedIntArray(codePoints));
    return codePoints;
}
 

@Override
public boolean equalTo(Block leftBlock, int leftPosition, Block rightBlock, int rightPosition)
{
    Slice leftValue = leftBlock.getSlice(leftPosition, 0, leftBlock.getSliceLength(leftPosition));
    Slice rightValue = rightBlock.getSlice(rightPosition, 0, rightBlock.getSliceLength(rightPosition));
    return leftValue.equals(rightValue);
}
 

@Override
public Object getObjectValue(ConnectorSession session, Block block, int position)
{
    if (block.isNull(position)) {
        return null;
    }
    Slice slice = block.getSlice(position, 0, block.getSliceLength(position));
    return deserialize(slice).asText();
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

@Override
public final Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, getFixedSize());
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

@Override
public final Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, getFixedSize());
}
 

private void bufferOutputData()
{
    checkState(closed);
    checkState(!directEncoded);

    Block dictionaryElements = dictionary.getElementBlock();

    // write dictionary in sorted order
    int[] sortedDictionaryIndexes = getSortedDictionaryNullsLast(dictionaryElements);
    for (int sortedDictionaryIndex : sortedDictionaryIndexes) {
        if (!dictionaryElements.isNull(sortedDictionaryIndex)) {
            int length = dictionaryElements.getSliceLength(sortedDictionaryIndex);
            dictionaryLengthStream.writeLong(length);
            Slice value = dictionaryElements.getSlice(sortedDictionaryIndex, 0, length);
            dictionaryDataStream.writeSlice(value);
        }
    }
    columnEncoding = new ColumnEncoding(DICTIONARY_V2, dictionaryElements.getPositionCount() - 1);

    // build index from original dictionary index to new sorted position
    int[] originalDictionaryToSortedIndex = new int[sortedDictionaryIndexes.length];
    for (int sortOrdinal = 0; sortOrdinal < sortedDictionaryIndexes.length; sortOrdinal++) {
        int dictionaryIndex = sortedDictionaryIndexes[sortOrdinal];
        originalDictionaryToSortedIndex[dictionaryIndex] = sortOrdinal;
    }

    if (!rowGroups.isEmpty()) {
        presentStream.recordCheckpoint();
        dataStream.recordCheckpoint();
    }
    for (DictionaryRowGroup rowGroup : rowGroups) {
        IntBigArray dictionaryIndexes = rowGroup.getDictionaryIndexes();
        for (int position = 0; position < rowGroup.getValueCount(); position++) {
            presentStream.writeBoolean(dictionaryIndexes.get(position) != 0);
        }
        for (int position = 0; position < rowGroup.getValueCount(); position++) {
            int originalDictionaryIndex = dictionaryIndexes.get(position);
            // index zero in original dictionary is reserved for null
            if (originalDictionaryIndex != 0) {
                int sortedIndex = originalDictionaryToSortedIndex[originalDictionaryIndex];
                if (sortedIndex < 0) {
                    throw new IllegalArgumentException();
                }
                dataStream.writeLong(sortedIndex);
            }
        }
        presentStream.recordCheckpoint();
        dataStream.recordCheckpoint();
    }

    // free the dictionary memory
    dictionary.clear();

    dictionaryDataStream.close();
    dictionaryLengthStream.close();

    dataStream.close();
    presentStream.close();
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

@Override
public Slice getSlice(Block block, int position)
{
    return block.getSlice(position, 0, block.getSliceLength(position));
}
 

/**
 * Returns an array of addresses from {@link PagesIndex#valueAddresses} corresponding
 * to rows with matching geometries.
 * <p>
 * The caller is responsible for calling {@link #isJoinPositionEligible(int, int, Page)}
 * for each of these addresses to apply additional join filters.
 */
@Override
public int[] findJoinPositions(int probePosition, Page probe, int probeGeometryChannel, Optional<Integer> probePartitionChannel)
{
    Block probeGeometryBlock = probe.getBlock(probeGeometryChannel);
    if (probeGeometryBlock.isNull(probePosition)) {
        return EMPTY_ADDRESSES;
    }

    int probePartition = probePartitionChannel.map(channel -> toIntExact(INTEGER.getLong(probe.getBlock(channel), probePosition))).orElse(-1);

    Slice slice = probeGeometryBlock.getSlice(probePosition, 0, probeGeometryBlock.getSliceLength(probePosition));
    OGCGeometry probeGeometry = deserialize(slice);
    verifyNotNull(probeGeometry);
    if (probeGeometry.isEmpty()) {
        return EMPTY_ADDRESSES;
    }

    boolean probeIsPoint = probeGeometry instanceof OGCPoint;

    IntArrayList matchingPositions = new IntArrayList();

    Envelope envelope = getEnvelope(probeGeometry);
    rtree.query(envelope, item -> {
        GeometryWithPosition geometryWithPosition = (GeometryWithPosition) item;
        OGCGeometry buildGeometry = geometryWithPosition.getGeometry();
        if (partitions.isEmpty() || (probePartition == geometryWithPosition.getPartition() && (probeIsPoint || (buildGeometry instanceof OGCPoint) || testReferencePoint(envelope, buildGeometry, probePartition)))) {
            if (radiusChannel == -1) {
                if (spatialRelationshipTest.apply(buildGeometry, probeGeometry, OptionalDouble.empty())) {
                    matchingPositions.add(geometryWithPosition.getPosition());
                }
            }
            else {
                if (spatialRelationshipTest.apply(geometryWithPosition.getGeometry(), probeGeometry, OptionalDouble.of(getRadius(geometryWithPosition.getPosition())))) {
                    matchingPositions.add(geometryWithPosition.getPosition());
                }
            }
        }
    });

    return matchingPositions.toIntArray(null);
}