public PartitionIterator(UnfilteredRowIterator partition, Collection<Unfiltered> content) { super(partition.metadata(), partition.partitionKey(), partition.partitionLevelDeletion(), partition.columns(), partition.staticRow(), partition.isReverseOrder(), partition.stats()); rows = content.iterator(); }
public void close() { if (iterator != null) iterator.close(); } }
public UnfilteredRows(UnfilteredRowIterator input) { super(input); partitionColumns = input.columns(); partitionLevelDeletion = input.partitionLevelDeletion(); }
public long serializedSize(UnfilteredRowIterator iterator, ColumnFilter selection, int version, int rowEstimate) { SerializationHeader header = new SerializationHeader(false, iterator.metadata(), iterator.columns(), iterator.stats()); assert rowEstimate >= 0; long size = ByteBufferUtil.serializedSizeWithVIntLength(iterator.partitionKey().getKey()) + 1; // flags if (iterator.isEmpty()) return size; DeletionTime partitionDeletion = iterator.partitionLevelDeletion(); Row staticRow = iterator.staticRow(); boolean hasStatic = staticRow != Rows.EMPTY_STATIC_ROW; size += SerializationHeader.serializer.serializedSizeForMessaging(header, selection, hasStatic); if (!partitionDeletion.isLive()) size += header.deletionTimeSerializedSize(partitionDeletion); if (hasStatic) size += UnfilteredSerializer.serializer.serializedSize(staticRow, header, version); if (rowEstimate >= 0) size += TypeSizes.sizeofUnsignedVInt(rowEstimate); while (iterator.hasNext()) size += UnfilteredSerializer.serializer.serializedSize(iterator.next(), header, version); size += UnfilteredSerializer.serializer.serializedSizeEndOfPartition(); return size; }
@Override protected UnfilteredRowIterator applyToPartition(UnfilteredRowIterator partition) { onNewPartition(partition.partitionKey()); isReverseOrder = partition.isReverseOrder(); UnfilteredRowIterator purged = Transformation.apply(partition, this); if (!isForThrift && purged.isEmpty()) { onEmptyPartitionPostPurge(purged.partitionKey()); purged.close(); return null; } return purged; }
/** * Returns whether this iterator has no data (including no deletion data). */ public default boolean isEmpty() { return partitionLevelDeletion().isLive() && staticRow().isEmpty() && !hasNext(); } }
public void serialize(UnfilteredRowIterator iterator, ColumnFilter selection, DataOutputPlus out, int version, int rowEstimate) throws IOException { SerializationHeader header = new SerializationHeader(false, iterator.metadata(), iterator.columns(), iterator.stats()); serialize(iterator, header, selection, out, version, rowEstimate); }
private void writePartitionHeader(UnfilteredRowIterator iterator) throws IOException { ByteBufferUtil.writeWithShortLength(iterator.partitionKey().getKey(), writer); DeletionTime.serializer.serialize(iterator.partitionLevelDeletion(), writer); if (header.hasStatic()) { Row staticRow = iterator.staticRow(); UnfilteredSerializer.serializer.serializeStaticRow(staticRow, header, writer, version); if (!observers.isEmpty()) observers.forEach((o) -> o.nextUnfilteredCluster(staticRow)); } }
@Override protected UnfilteredRowIterator applyToPartition(UnfilteredRowIterator partition) { Iterable<UnfilteredRowIterator> sources = controller.shadowSources(partition.partitionKey(), !cellLevelGC); if (sources == null) return partition; List<UnfilteredRowIterator> iters = new ArrayList<>(); for (UnfilteredRowIterator iter : sources) { if (!iter.isEmpty()) iters.add(iter); else iter.close(); } if (iters.isEmpty()) return partition; return new GarbageSkippingUnfilteredRowIterator(partition, UnfilteredRowIterators.merge(iters, nowInSec), nowInSec, cellLevelGC); } }
/** * Writes a partition in an implementation specific way * @param partition the partition to append * @return true if the partition was written, false otherwise */ public final boolean append(UnfilteredRowIterator partition) { maybeSwitchWriter(partition.partitionKey()); return realAppend(partition); }
private boolean isReversed(List<UnfilteredRowIterator> versions) { for (UnfilteredRowIterator iter : versions) { if (iter == null) continue; // Everything will be in the same order return iter.isReverseOrder(); } assert false : "Expected at least one iterator"; return false; }
private SuperColumnsPartitionMerger(UnfilteredRowIterator applyTo, int nowInSec) { assert applyTo.metadata().isSuper(); this.nowInSec = nowInSec; this.superColumnMapColumn = applyTo.metadata().compactValueColumn(); assert superColumnMapColumn != null && superColumnMapColumn.type instanceof MapType; this.builder = BTreeRow.sortedBuilder(); this.columnComparator = ((MapType)superColumnMapColumn.type).nameComparator(); }
public Unfiltered next() { return wrapped.next(); }
@Override public UnfilteredRowIterator applyToPartition(UnfilteredRowIterator partition) { return Transformation.apply(partition, new RowsTransformation(partition.metadata(), partition.isReverseOrder(), enforceIsClosed)); }
@Override public boolean isEmpty() { return iterator.isEmpty(); }
public UnfilteredRows(UnfilteredRowIterator input) { this(input, input.columns()); }
@Override public boolean hasNext() { return nextToOffer != null || wrapped.hasNext(); }
public UnfilteredRows(UnfilteredRowIterator input, PartitionColumns columns) { super(input); partitionColumns = columns; partitionLevelDeletion = input.partitionLevelDeletion(); }
public Row staticRow() { maybeInit(); return iterator.staticRow(); }