Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.facebook.presto.jdbc.internal.spi.block;
import static com.facebook.presto.jdbc.internal.spi.block.BlockUtil.checkValidPositionsArray;
import static com.facebook.presto.jdbc.internal.spi.block.BlockUtil.compactArray;
import static com.facebook.presto.jdbc.internal.spi.block.BlockUtil.compactOffsets;
import static java.lang.String.format;
public abstract class AbstractArrayBlock
implements Block
{
protected abstract Block getValues();
protected abstract int[] getOffsets();
protected abstract int getOffsetBase();
protected abstract boolean[] getValueIsNull();
int getOffset(int position)
{
return getOffsets()[position + getOffsetBase()];
}
@Override
public BlockEncoding getEncoding()
{
return new ArrayBlockEncoding(getValues().getEncoding());
}
@Override
public Block copyPositions(int[] positions, int offset, int length)
{
checkValidPositionsArray(positions, offset, length);
int[] newOffsets = new int[length + 1];
boolean[] newValueIsNull = new boolean[length];
IntArrayList valuesPositions = new IntArrayList();
int newPosition = 0;
for (int i = offset; i < offset + length; ++i) {
int position = positions[i];
if (isNull(position)) {
newValueIsNull[newPosition] = true;
newOffsets[newPosition + 1] = newOffsets[newPosition];
}
else {
int valuesStartOffset = getOffset(position);
int valuesEndOffset = getOffset(position + 1);
int valuesLength = valuesEndOffset - valuesStartOffset;
newOffsets[newPosition + 1] = newOffsets[newPosition] + valuesLength;
for (int elementIndex = valuesStartOffset; elementIndex < valuesEndOffset; elementIndex++) {
valuesPositions.add(elementIndex);
}
}
newPosition++;
}
Block newValues = getValues().copyPositions(valuesPositions.elements(), 0, valuesPositions.size());
return new ArrayBlock(length, newValueIsNull, newOffsets, newValues);
}
@Override
public Block getRegion(int position, int length)
{
int positionCount = getPositionCount();
if (position < 0 || length < 0 || position + length > positionCount) {
throw new IndexOutOfBoundsException(format("Invalid position range [%s, %s) in block with %s positions", position, position + length, positionCount));
}
if (position == 0 && length == positionCount) {
return this;
}
return new ArrayBlock(
position + getOffsetBase(),
length,
getValueIsNull(),
getOffsets(),
getValues());
}
@Override
public long getRegionSizeInBytes(int position, int length)
{
int positionCount = getPositionCount();
if (position < 0 || length < 0 || position + length > positionCount) {
throw new IndexOutOfBoundsException(format("Invalid position range [%s, %s) in block with %s positions", position, position + length, positionCount));
}
int valueStart = getOffsets()[getOffsetBase() + position];
int valueEnd = getOffsets()[getOffsetBase() + position + length];
return getValues().getRegionSizeInBytes(valueStart, valueEnd - valueStart) + ((Integer.BYTES + Byte.BYTES) * (long) length);
}
@Override
public Block copyRegion(int position, int length)
{
int positionCount = getPositionCount();
if (position < 0 || length < 0 || position + length > positionCount) {
throw new IndexOutOfBoundsException(format("Invalid position range [%s, %s) in block with %s positions", position, position + length, positionCount));
}
int startValueOffset = getOffset(position);
int endValueOffset = getOffset(position + length);
Block newValues = getValues().copyRegion(startValueOffset, endValueOffset - startValueOffset);
int[] newOffsets = compactOffsets(getOffsets(), position + getOffsetBase(), length);
boolean[] newValueIsNull = compactArray(getValueIsNull(), position + getOffsetBase(), length);
if (newValues == getValues() && newOffsets == getOffsets() && newValueIsNull == getValueIsNull()) {
return this;
}
return new ArrayBlock(length, newValueIsNull, newOffsets, newValues);
}
@Override
public T getObject(int position, Class clazz)
{
if (clazz != Block.class) {
throw new IllegalArgumentException("clazz must be Block.class");
}
checkReadablePosition(position);
int startValueOffset = getOffset(position);
int endValueOffset = getOffset(position + 1);
return clazz.cast(getValues().getRegion(startValueOffset, endValueOffset - startValueOffset));
}
@Override
public void writePositionTo(int position, BlockBuilder blockBuilder)
{
checkReadablePosition(position);
BlockBuilder entryBuilder = blockBuilder.beginBlockEntry();
int startValueOffset = getOffset(position);
int endValueOffset = getOffset(position + 1);
for (int i = startValueOffset; i < endValueOffset; i++) {
if (getValues().isNull(i)) {
entryBuilder.appendNull();
}
else {
getValues().writePositionTo(i, entryBuilder);
entryBuilder.closeEntry();
}
}
}
@Override
public Block getSingleValueBlock(int position)
{
checkReadablePosition(position);
int startValueOffset = getOffset(position);
int valueLength = getOffset(position + 1) - startValueOffset;
Block newValues = getValues().copyRegion(startValueOffset, valueLength);
return new ArrayBlock(
1,
new boolean[] {isNull(position)},
new int[] {0, valueLength},
newValues);
}
@Override
public boolean isNull(int position)
{
checkReadablePosition(position);
return getValueIsNull()[position + getOffsetBase()];
}
public T apply(ArrayBlockFunction function, int position)
{
checkReadablePosition(position);
int startValueOffset = getOffset(position);
int endValueOffset = getOffset(position + 1);
return function.apply(getValues(), startValueOffset, endValueOffset - startValueOffset);
}
private void checkReadablePosition(int position)
{
if (position < 0 || position >= getPositionCount()) {
throw new IllegalArgumentException("position is not valid");
}
}
public interface ArrayBlockFunction
{
T apply(Block block, int startPosition, int length);
}
}
