@Override public void clear() { vector.clear(); }
/** * Allocate memory for the vector. We internally use a default value count * of 4096 to allocate memory for at least these many elements in the * vector. * * @return false if memory allocation fails, true otherwise. */ public boolean allocateNewSafe() { boolean success = false; try { /* we are doing a new allocation -- release the current buffers */ clear(); /* allocate validity buffer */ allocateValidityBuffer(validityAllocationSizeInBytes); /* allocate offset and data buffer */ success = super.allocateNewSafe(); } finally { if (!success) { clear(); return false; } } return true; }
/** * Transfer this vector'data to another vector. The memory associated * with this vector is transferred to the allocator of target vector * for accounting and management purposes. */ @Override public void transfer() { to.clear(); dataTransferPair.transfer(); to.validityBuffer = validityBuffer.transferOwnership(to.allocator).buffer; to.offsetBuffer = offsetBuffer.transferOwnership(to.allocator).buffer; to.lastSet = lastSet; if (valueCount > 0) { to.setValueCount(valueCount); } clear(); }
buffer.retain(); clear();
/** * Slice this vector at desired index and length and transfer the * corresponding data to the target vector. * @param startIndex start position of the split in source vector. * @param length length of the split. */ @Override public void splitAndTransfer(int startIndex, int length) { final int startPoint = offsetBuffer.getInt(startIndex * OFFSET_WIDTH); final int sliceLength = offsetBuffer.getInt((startIndex + length) * OFFSET_WIDTH) - startPoint; to.clear(); to.allocateOffsetBuffer((length + 1) * OFFSET_WIDTH); /* splitAndTransfer offset buffer */ for (int i = 0; i < length + 1; i++) { final int relativeOffset = offsetBuffer.getInt((startIndex + i) * OFFSET_WIDTH) - startPoint; to.offsetBuffer.setInt(i * OFFSET_WIDTH, relativeOffset); } /* splitAndTransfer validity buffer */ splitAndTransferValidityBuffer(startIndex, length, to); /* splitAndTransfer data buffer */ dataTransferPair.splitAndTransfer(startPoint, sliceLength); to.lastSet = length; to.setValueCount(length); }
public void load(SerializedField metadata, ArrowBuf buffer) { /* release the current buffers (if any) */ listVector.clear(); /* load inner offset buffer */ final SerializedField offsetMetadata = metadata.getChild(0); final int offsetLength = offsetMetadata.getBufferLength(); loadOffsetBuffer(offsetMetadata, buffer); /* load inner validity buffer */ final SerializedField bitMetadata = metadata.getChild(1); final int bitLength = bitMetadata.getBufferLength(); loadValidityBuffer(bitMetadata, buffer.slice(offsetLength, bitLength)); /* load inner data vector */ final SerializedField vectorMetadata = metadata.getChild(2); if (listVector.getDataVector() == BaseRepeatedValueVector.DEFAULT_DATA_VECTOR) { listVector.addOrGetVector(FieldType.nullable(getArrowMinorType(vectorMetadata.getMajorType().getMinorType()).getType())); } final int vectorLength = vectorMetadata.getBufferLength(); TypeHelper.load(listVector.vector, vectorMetadata, buffer.slice(offsetLength + bitLength, vectorLength)); listVector.setLastSet(metadata.getValueCount()); listVector.valueCount = metadata.getValueCount(); }