Java Block.getPositionCount方法代码示例

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
@UsedByGeneratedCode
public static Object subscript(MethodHandle keyEqualsMethod, Type keyType, Type valueType, Block map, Slice key)
{
    for (int position = 0; position < map.getPositionCount(); position += 2) {
        try {
            if ((boolean) keyEqualsMethod.invokeExact(keyType.getSlice(map, position), key)) {
                return readNativeValue(valueType, map, position + 1); // position + 1: value position
            }
        }
        catch (Throwable t) {
            Throwables.propagateIfInstanceOf(t, Error.class);
            Throwables.propagateIfInstanceOf(t, PrestoException.class);
            throw new PrestoException(INTERNAL_ERROR, t);
        }
    }
    return null;
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
public static Boolean contains(Type elementType, MethodHandle equals, Block arrayBlock, double value)
{
    boolean foundNull = false;
    for (int i = 0; i < arrayBlock.getPositionCount(); i++) {
        if (arrayBlock.isNull(i)) {
            foundNull = true;
            continue;
        }
        try {
            if ((boolean) equals.invokeExact(elementType.getDouble(arrayBlock, i), value)) {
                return true;
            }
        }
        catch (Throwable t) {
            Throwables.propagateIfInstanceOf(t, Error.class);
            Throwables.propagateIfInstanceOf(t, PrestoException.class);

            throw new PrestoException(INTERNAL_ERROR, t);
        }
    }
    if (foundNull) {
        return null;
    }
    return false;
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
private static int checkedIndexToBlockPosition(Block block, long index)
{
    int arrayLength = block.getPositionCount();
    if (index == 0) {
        throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "SQL array indices start at 1");
    }
    if (Math.abs(index) > arrayLength) {
        throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "Array subscript out of bounds");
    }

    if (index > 0) {
        return Ints.checkedCast(index - 1);
    }
    else {
        return Ints.checkedCast(arrayLength + index);
    }
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
private static SortedMap<Integer, Object> indexStackValues(Type type, Block block)
{
    SortedMap<Integer, Object> values = new TreeMap<>();
    for (int position = 0; position < block.getPositionCount(); position++) {
        if (block.isNull(position)) {
            values.put(position, null);
        }
        else if (type.getJavaType() == boolean.class) {
            values.put(position, type.getBoolean(block, position));
        }
        else if (type.getJavaType() == long.class) {
            values.put(position, type.getLong(block, position));
        }
        else if (type.getJavaType() == double.class) {
            values.put(position, type.getDouble(block, position));
        }
        else if (type.getJavaType() == Slice.class) {
            values.put(position, type.getSlice(block, position));
        }
        else {
            values.put(position, type.getObject(block, position));
        }
    }
    return unmodifiableSortedMap(values);
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
@TypeParameter(StandardTypes.DOUBLE)
@SqlType(StandardTypes.BOOLEAN)
@Nullable
public static Boolean contains(
        @TypeParameter(StandardTypes.DOUBLE) Type elementType,
        @SqlType("array(double)") Block arrayBlock,
        @SqlType(StandardTypes.DOUBLE) double lng,
        @SqlType(StandardTypes.DOUBLE) double lat)
{
    double[] array= new double[arrayBlock.getPositionCount()] ;
    Polygon poly = new Polygon();

    for (int i = 0; i < arrayBlock.getPositionCount(); i++) {

        if (arrayBlock.isNull(i)) {
            continue;
        }
        array[i]=elementType.getDouble(arrayBlock, i);

    }

    poly.startPath(array[0], array[1]);
    for (int i = 2; i < array.length; i += 2) {
        poly.lineTo(array[i], array[i + 1]);
    }
    return OperatorContains.local().execute(poly, new Point(lng,lat), null, null);
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
@UsedByGeneratedCode
public static Block appendElement(Type elementType, Block block, Slice value)
{
    BlockBuilder blockBuilder = elementType.createBlockBuilder(new BlockBuilderStatus(), block.getPositionCount() + 1);
    for (int i = 0; i < block.getPositionCount(); i++) {
        elementType.appendTo(block, i, blockBuilder);
    }

    elementType.writeSlice(blockBuilder, value);

    return blockBuilder.build();
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
@Override
public boolean equalTo(Block leftBlock, int leftPosition, Block rightBlock, int rightPosition)
{
    Block leftMapBlock = leftBlock.getObject(leftPosition, Block.class);
    Block rightMapBlock = rightBlock.getObject(rightPosition, Block.class);

    if (leftMapBlock.getPositionCount() != rightMapBlock.getPositionCount()) {
        return false;
    }

    Map<KeyWrapper, Integer> wrappedLeftMap = new HashMap<>();
    for (int position = 0; position < leftMapBlock.getPositionCount(); position += 2) {
        wrappedLeftMap.put(new KeyWrapper(keyType, leftMapBlock, position), position + 1);
    }

    for (int position = 0; position < rightMapBlock.getPositionCount(); position += 2) {
        KeyWrapper key = new KeyWrapper(keyType, rightMapBlock, position);
        Integer leftValuePosition = wrappedLeftMap.get(key);
        if (leftValuePosition == null) {
            return false;
        }
        int rightValuePosition = position + 1;
        checkElementNotNull(leftMapBlock.isNull(leftValuePosition), MAP_NULL_ELEMENT_MSG);
        checkElementNotNull(rightMapBlock.isNull(rightValuePosition), MAP_NULL_ELEMENT_MSG);

        if (!valueType.equalTo(leftMapBlock, leftValuePosition, rightMapBlock, rightValuePosition)) {
            return false;
        }
    }
    return true;
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
public static Block getKeys(Type keyType, Block block)
{
    BlockBuilder blockBuilder = keyType.createBlockBuilder(new BlockBuilderStatus(), block.getPositionCount() / 2);
    for (int i = 0; i < block.getPositionCount(); i += 2) {
        keyType.appendTo(block, i, blockBuilder);
    }
    return blockBuilder.build();
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
public static Slice toJson(Type arrayType, ConnectorSession session, Block array)
{
    Type elementType = arrayType.getTypeParameters().get(0);
    List<Object> objectValues = new ArrayList<>(array.getPositionCount());
    for (int i = 0; i < array.getPositionCount(); i++) {
        objectValues.add(elementType.getObjectValue(session, array, i));
    }
    try {
        return Slices.utf8Slice(OBJECT_MAPPER.get().writeValueAsString(objectValues));
    }
    catch (JsonProcessingException e) {
        throw Throwables.propagate(e);
    }
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
private static void initializePercentilesArray(DigestAndPercentileArrayState state, Block percentilesArrayBlock)
{
    if (state.getPercentiles() == null) {
        ImmutableList.Builder<Double> percentilesListBuilder = ImmutableList.builder();

        for (int i = 0; i < percentilesArrayBlock.getPositionCount(); i++) {
            checkCondition(!percentilesArrayBlock.isNull(i), INVALID_FUNCTION_ARGUMENT, "Percentile cannot be null");
            double percentile = DOUBLE.getDouble(percentilesArrayBlock, i);
            checkCondition(0 <= percentile && percentile <= 1, INVALID_FUNCTION_ARGUMENT, "Percentile must be between 0 and 1");
            percentilesListBuilder.add(percentile);
        }

        state.setPercentiles(percentilesListBuilder.build());
    }
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
@Override
public void addInput(Page page)
{
    requireNonNull(page, "page is null");
    checkState(state == State.RUNNING, "Operator is %s", state);

    Block rowIds = page.getBlock(rowIdChannel);
    pageSource().deleteRows(rowIds);
    rowCount += rowIds.getPositionCount();
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
/**
 * Serialize as a multimap: map<key, array<value>>, each key can be associated with multiple values
 */
public Block toMultimapNativeEncoding()
{
    if (!isMultiValue) {
        throw new PrestoException(INTERNAL_ERROR, "This KeyValuePairs is not multimap.");
    }

    Block keys = keyBlockBuilder.build();
    Block values = valueBlockBuilder.build();

    // Merge values of the same key into an array
    BlockBuilder distinctKeyBlockBuilder = keyType.createBlockBuilder(new BlockBuilderStatus(), keys.getPositionCount(), expectedValueSize(keyType, EXPECTED_ENTRY_SIZE));
    ObjectBigArray<BlockBuilder> valueArrayBlockBuilders = new ObjectBigArray<>();
    valueArrayBlockBuilders.ensureCapacity(keys.getPositionCount());
    TypedSet keySet = new TypedSet(keyType, keys.getPositionCount());
    for (int keyValueIndex = 0; keyValueIndex < keys.getPositionCount(); keyValueIndex++) {
        if (!keySet.contains(keys, keyValueIndex)) {
            keySet.add(keys, keyValueIndex);
            keyType.appendTo(keys, keyValueIndex, distinctKeyBlockBuilder);
            BlockBuilder valueArrayBuilder = valueType.createBlockBuilder(new BlockBuilderStatus(), 10, expectedValueSize(valueType, EXPECTED_ENTRY_SIZE));
            valueArrayBlockBuilders.set(keySet.positionOf(keys, keyValueIndex), valueArrayBuilder);
        }
        valueType.appendTo(values, keyValueIndex, valueArrayBlockBuilders.get(keySet.positionOf(keys, keyValueIndex)));
    }

    // Write keys and value arrays into one Block
    Block distinctKeys = distinctKeyBlockBuilder.build();
    Type valueArrayType = new ArrayType(valueType);
    BlockBuilder multimapBlockBuilder = new InterleavedBlockBuilder(ImmutableList.of(keyType, valueArrayType), new BlockBuilderStatus(), distinctKeyBlockBuilder.getPositionCount());
    for (int i = 0; i < distinctKeys.getPositionCount(); i++) {
        keyType.appendTo(distinctKeys, i, multimapBlockBuilder);
        valueArrayType.writeObject(multimapBlockBuilder, valueArrayBlockBuilders.get(i).build());
    }

    return multimapBlockBuilder.build();
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
private Page createPageWithExtractedDictionary(Page page)
{
    Block[] blocks = new Block[page.getChannelCount()];
    Block dictionary = ((DictionaryBlock) page.getBlock(channels[0])).getDictionary();

    // extract data dictionary
    blocks[channels[0]] = dictionary;

    // extract hash dictionary
    if (inputHashChannel.isPresent()) {
        blocks[inputHashChannel.get()] = ((DictionaryBlock) page.getBlock(inputHashChannel.get())).getDictionary();
    }

    return new Page(dictionary.getPositionCount(), blocks);
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
@UsedByGeneratedCode
public static Block prependElement(Type elementType, Object value, Block block)
{
    BlockBuilder blockBuilder = elementType.createBlockBuilder(new BlockBuilderStatus(), block.getPositionCount() + 1);

    elementType.writeObject(blockBuilder, value);
    for (int i = 0; i < block.getPositionCount(); i++) {
        elementType.appendTo(block, i, blockBuilder);
    }

    return blockBuilder.build();
}
 

import com.facebook.presto.spi.block.Block; //导入方法依赖的package包/类
public static List<Object> toValues(Type type, Block block)
{
    List<Object> values = new ArrayList<>();
    for (int position = 0; position < block.getPositionCount(); position++) {
        values.add(type.getObjectValue(SESSION, block, position));
    }
    return Collections.unmodifiableList(values);
}