Examples with TrustedByteArrayOutputStream org.apache.phoenix.util.TrustedByteArrayOutputStream used on opensource projects

Example 1 with TrustedByteArrayOutputStream

use of org.apache.phoenix.util.TrustedByteArrayOutputStream in project phoenix by apache.

the class ArrayConstructorExpression method evaluate.

@Override
public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) {
    if (position == elements.length) {
        ptr.set(valuePtr.get(), valuePtr.getOffset(), valuePtr.getLength());
        return true;
    }
    TrustedByteArrayOutputStream byteStream = new TrustedByteArrayOutputStream(estimatedSize);
    DataOutputStream oStream = new DataOutputStream(byteStream);
    PArrayDataTypeEncoder builder = new PArrayDataTypeEncoder(byteStream, oStream, children.size(), baseType, getSortOrder(), rowKeyOrderOptimizable, PArrayDataType.SORTABLE_SERIALIZATION_VERSION);
    for (int i = position >= 0 ? position : 0; i < elements.length; i++) {
        Expression child = children.get(i);
        if (!child.evaluate(tuple, ptr)) {
            if (tuple != null && !tuple.isImmutable()) {
                if (position >= 0)
                    position = i;
                return false;
            }
        } else {
            builder.appendValue(ptr.get(), ptr.getOffset(), ptr.getLength());
        }
    }
    if (position >= 0)
        position = elements.length;
    byte[] bytes = builder.encode();
    ptr.set(bytes, 0, bytes.length);
    valuePtr.set(ptr.get(), ptr.getOffset(), ptr.getLength());
    return true;
}

Example 2 with TrustedByteArrayOutputStream

use of org.apache.phoenix.util.TrustedByteArrayOutputStream in project phoenix by apache.

the class PArrayDataType method toBytes.

public byte[] toBytes(Object object, PDataType baseType, SortOrder sortOrder, boolean rowKeyOrderOptimizable) {
    if (object == null) {
        throw new ConstraintViolationException(this + " may not be null");
    }
    PhoenixArray arr = toPhoenixArray(object, baseType);
    int noOfElements = arr.numElements;
    if (noOfElements == 0) {
        return ByteUtil.EMPTY_BYTE_ARRAY;
    }
    TrustedByteArrayOutputStream byteStream = null;
    if (!baseType.isFixedWidth()) {
        Pair<Integer, Integer> nullsVsNullRepeationCounter = new Pair<>();
        int size = estimateByteSize(object, nullsVsNullRepeationCounter, PDataType.fromTypeId((baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE)));
        size += ((2 * Bytes.SIZEOF_BYTE) + (noOfElements - nullsVsNullRepeationCounter.getFirst()) * Bytes.SIZEOF_BYTE) + (nullsVsNullRepeationCounter.getSecond() * 2 * Bytes.SIZEOF_BYTE);
        // Assume an offset array that fit into Short.MAX_VALUE. Also not considering nulls that could be > 255
        // In both of these cases, finally an array copy would happen
        int capacity = noOfElements * Bytes.SIZEOF_SHORT;
        // Here the int for noofelements, byte for the version, int for the offsetarray position and 2 bytes for the
        // end seperator
        byteStream = new TrustedByteArrayOutputStream(size + capacity + Bytes.SIZEOF_INT + Bytes.SIZEOF_BYTE + Bytes.SIZEOF_INT);
    } else {
        int elemLength = (arr.getMaxLength() == null ? baseType.getByteSize() : arr.getMaxLength());
        int size = elemLength * noOfElements;
        // Here the int for noofelements, byte for the version
        byteStream = new TrustedByteArrayOutputStream(size);
    }
    DataOutputStream oStream = new DataOutputStream(byteStream);
    // Handles bit inversion also
    return createArrayBytes(byteStream, oStream, arr, noOfElements, baseType, sortOrder, rowKeyOrderOptimizable);
}

Example 3 with TrustedByteArrayOutputStream

use of org.apache.phoenix.util.TrustedByteArrayOutputStream in project phoenix by apache.

the class IndexMaintainer method getViewIndexIdFromIndexRowKey.

/*
     * return the view index id from the index row key
     */
public byte[] getViewIndexIdFromIndexRowKey(ImmutableBytesWritable indexRowKeyPtr) {
    assert (isLocalIndex);
    RowKeySchema indexRowKeySchema = getIndexRowKeySchema();
    // TODO add logic to skip region start key as well because we cannot find the region startkey in indexhalfstorefilereader.
    ImmutableBytesWritable ptr = new ImmutableBytesWritable();
    TrustedByteArrayOutputStream stream = new TrustedByteArrayOutputStream(estimatedIndexRowKeyBytes);
    DataOutput output = new DataOutputStream(stream);
    try {
        int indexPosOffset = (!isLocalIndex && nIndexSaltBuckets > 0 ? 1 : 0) + (isMultiTenant ? 1 : 0) + (viewIndexId == null ? 0 : 1);
        Boolean hasValue = indexRowKeySchema.iterator(indexRowKeyPtr, ptr, indexPosOffset);
        if (Boolean.TRUE.equals(hasValue)) {
            output.write(ptr.get(), ptr.getOffset(), ptr.getLength());
        }
        int length = stream.size();
        byte[] dataRowKey = stream.getBuffer();
        return dataRowKey.length == length ? dataRowKey : Arrays.copyOf(dataRowKey, length);
    } catch (IOException e) {
        // Impossible
        throw new RuntimeException(e);
    } finally {
        try {
            stream.close();
        } catch (IOException e) {
            // Impossible
            throw new RuntimeException(e);
        }
    }
}

Example 4 with TrustedByteArrayOutputStream

use of org.apache.phoenix.util.TrustedByteArrayOutputStream in project phoenix by apache.

the class IndexMaintainer method buildRowKey.

public byte[] buildRowKey(ValueGetter valueGetter, ImmutableBytesWritable rowKeyPtr, byte[] regionStartKey, byte[] regionEndKey) {
    ImmutableBytesWritable ptr = new ImmutableBytesWritable();
    boolean prependRegionStartKey = isLocalIndex && regionStartKey != null;
    boolean isIndexSalted = !isLocalIndex && nIndexSaltBuckets > 0;
    int prefixKeyLength = prependRegionStartKey ? (regionStartKey.length != 0 ? regionStartKey.length : regionEndKey.length) : 0;
    TrustedByteArrayOutputStream stream = new TrustedByteArrayOutputStream(estimatedIndexRowKeyBytes + (prependRegionStartKey ? prefixKeyLength : 0));
    DataOutput output = new DataOutputStream(stream);
    try {
        // For local indexes, we must prepend the row key with the start region key
        if (prependRegionStartKey) {
            if (regionStartKey.length == 0) {
                output.write(new byte[prefixKeyLength]);
            } else {
                output.write(regionStartKey);
            }
        }
        if (isIndexSalted) {
            // will be set at end to index salt byte
            output.write(0);
        }
        // The dataRowKeySchema includes the salt byte field,
        // so we must adjust for that here.
        int dataPosOffset = isDataTableSalted ? 1 : 0;
        BitSet viewConstantColumnBitSet = this.rowKeyMetaData.getViewConstantColumnBitSet();
        int nIndexedColumns = getIndexPkColumnCount() - getNumViewConstants();
        int[][] dataRowKeyLocator = new int[2][nIndexedColumns];
        // Skip data table salt byte
        int maxRowKeyOffset = rowKeyPtr.getOffset() + rowKeyPtr.getLength();
        dataRowKeySchema.iterator(rowKeyPtr, ptr, dataPosOffset);
        if (viewIndexId != null) {
            output.write(viewIndexId);
        }
        if (isMultiTenant) {
            dataRowKeySchema.next(ptr, dataPosOffset, maxRowKeyOffset);
            output.write(ptr.get(), ptr.getOffset(), ptr.getLength());
            if (!dataRowKeySchema.getField(dataPosOffset).getDataType().isFixedWidth()) {
                output.writeByte(SchemaUtil.getSeparatorByte(rowKeyOrderOptimizable, ptr.getLength() == 0, dataRowKeySchema.getField(dataPosOffset)));
            }
            dataPosOffset++;
        }
        // Write index row key
        for (int i = dataPosOffset; i < dataRowKeySchema.getFieldCount(); i++) {
            Boolean hasValue = dataRowKeySchema.next(ptr, i, maxRowKeyOffset);
            // same for all rows in this index)
            if (!viewConstantColumnBitSet.get(i)) {
                int pos = rowKeyMetaData.getIndexPkPosition(i - dataPosOffset);
                if (Boolean.TRUE.equals(hasValue)) {
                    dataRowKeyLocator[0][pos] = ptr.getOffset();
                    dataRowKeyLocator[1][pos] = ptr.getLength();
                } else {
                    dataRowKeyLocator[0][pos] = 0;
                    dataRowKeyLocator[1][pos] = 0;
                }
            }
        }
        BitSet descIndexColumnBitSet = rowKeyMetaData.getDescIndexColumnBitSet();
        Iterator<Expression> expressionIterator = indexedExpressions.iterator();
        for (int i = 0; i < nIndexedColumns; i++) {
            PDataType dataColumnType;
            boolean isNullable;
            SortOrder dataSortOrder;
            if (dataPkPosition[i] == EXPRESSION_NOT_PRESENT) {
                Expression expression = expressionIterator.next();
                dataColumnType = expression.getDataType();
                dataSortOrder = expression.getSortOrder();
                isNullable = expression.isNullable();
                expression.evaluate(new ValueGetterTuple(valueGetter), ptr);
            } else {
                Field field = dataRowKeySchema.getField(dataPkPosition[i]);
                dataColumnType = field.getDataType();
                ptr.set(rowKeyPtr.get(), dataRowKeyLocator[0][i], dataRowKeyLocator[1][i]);
                dataSortOrder = field.getSortOrder();
                isNullable = field.isNullable();
            }
            boolean isDataColumnInverted = dataSortOrder != SortOrder.ASC;
            PDataType indexColumnType = IndexUtil.getIndexColumnDataType(isNullable, dataColumnType);
            boolean isBytesComparable = dataColumnType.isBytesComparableWith(indexColumnType);
            boolean isIndexColumnDesc = descIndexColumnBitSet.get(i);
            if (isBytesComparable && isDataColumnInverted == isIndexColumnDesc) {
                output.write(ptr.get(), ptr.getOffset(), ptr.getLength());
            } else {
                if (!isBytesComparable) {
                    indexColumnType.coerceBytes(ptr, dataColumnType, dataSortOrder, SortOrder.getDefault());
                }
                if (isDataColumnInverted != isIndexColumnDesc) {
                    writeInverted(ptr.get(), ptr.getOffset(), ptr.getLength(), output);
                } else {
                    output.write(ptr.get(), ptr.getOffset(), ptr.getLength());
                }
            }
            if (!indexColumnType.isFixedWidth()) {
                output.writeByte(SchemaUtil.getSeparatorByte(rowKeyOrderOptimizable, ptr.getLength() == 0, isIndexColumnDesc ? SortOrder.DESC : SortOrder.ASC));
            }
        }
        int length = stream.size();
        int minLength = length - maxTrailingNulls;
        byte[] indexRowKey = stream.getBuffer();
        // Remove trailing nulls
        while (length > minLength && indexRowKey[length - 1] == QueryConstants.SEPARATOR_BYTE) {
            length--;
        }
        if (isIndexSalted) {
            // Set salt byte
            byte saltByte = SaltingUtil.getSaltingByte(indexRowKey, SaltingUtil.NUM_SALTING_BYTES, length - SaltingUtil.NUM_SALTING_BYTES, nIndexSaltBuckets);
            indexRowKey[0] = saltByte;
        }
        return indexRowKey.length == length ? indexRowKey : Arrays.copyOf(indexRowKey, length);
    } catch (IOException e) {
        // Impossible
        throw new RuntimeException(e);
    } finally {
        try {
            stream.close();
        } catch (IOException e) {
            // Impossible
            throw new RuntimeException(e);
        }
    }
}

Example 5 with TrustedByteArrayOutputStream

use of org.apache.phoenix.util.TrustedByteArrayOutputStream in project phoenix by apache.

the class IndexMaintainer method serializeAdditional.

/**
 * For client-side to append serialized IndexMaintainers of keyValueIndexes
 * @param dataTable data table
 * @param indexMetaDataPtr bytes pointer to hold returned serialized value
 * @param keyValueIndexes indexes to serialize
 */
public static void serializeAdditional(PTable table, ImmutableBytesWritable indexMetaDataPtr, List<PTable> keyValueIndexes, PhoenixConnection connection) {
    int nMutableIndexes = indexMetaDataPtr.getLength() == 0 ? 0 : ByteUtil.vintFromBytes(indexMetaDataPtr);
    int nIndexes = nMutableIndexes + keyValueIndexes.size();
    // Just in case new size increases buffer
    int estimatedSize = indexMetaDataPtr.getLength() + 1;
    if (indexMetaDataPtr.getLength() == 0) {
        estimatedSize += table.getRowKeySchema().getEstimatedByteSize();
    }
    for (PTable index : keyValueIndexes) {
        estimatedSize += index.getIndexMaintainer(table, connection).getEstimatedByteSize();
    }
    TrustedByteArrayOutputStream stream = new TrustedByteArrayOutputStream(estimatedSize + 1);
    DataOutput output = new DataOutputStream(stream);
    try {
        // Encode data table salting in sign of number of indexes
        WritableUtils.writeVInt(output, nIndexes * (table.getBucketNum() == null ? 1 : -1));
        // as its still included
        if (indexMetaDataPtr.getLength() > 0) {
            output.write(indexMetaDataPtr.get(), indexMetaDataPtr.getOffset(), indexMetaDataPtr.getLength() - WritableUtils.getVIntSize(nMutableIndexes));
        } else {
            table.getRowKeySchema().write(output);
        }
        // Serialize mutable indexes afterwards
        for (PTable index : keyValueIndexes) {
            IndexMaintainer maintainer = index.getIndexMaintainer(table, connection);
            byte[] protoBytes = IndexMaintainer.toProto(maintainer).toByteArray();
            WritableUtils.writeVInt(output, protoBytes.length);
            output.write(protoBytes);
        }
    } catch (IOException e) {
        // Impossible
        throw new RuntimeException(e);
    }
    indexMetaDataPtr.set(stream.getBuffer(), 0, stream.size());
}