Repository: cassandra Updated Branches: refs/heads/trunk a0901b8a5 -> 2f4124319
http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/db/rows/NativeCell.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/rows/NativeCell.java b/src/java/org/apache/cassandra/db/rows/NativeCell.java new file mode 100644 index 0000000..9d816f3 --- /dev/null +++ b/src/java/org/apache/cassandra/db/rows/NativeCell.java @@ -0,0 +1,151 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.cassandra.db.rows; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.utils.ObjectSizes; +import org.apache.cassandra.utils.concurrent.OpOrder; +import org.apache.cassandra.utils.memory.MemoryUtil; +import org.apache.cassandra.utils.memory.NativeAllocator; + +public class NativeCell extends AbstractCell +{ + private static final long EMPTY_SIZE = ObjectSizes.measure(new NativeCell()); + + private static final long HAS_CELLPATH = 0; + private static final long TIMESTAMP = 1; + private static final long TTL = 9; + private static final long DELETION = 13; + private static final long LENGTH = 17; + private static final long VALUE = 21; + + private final long peer; + + private NativeCell() + { + super(null); + this.peer = 0; + } + + public NativeCell(NativeAllocator allocator, + OpOrder.Group writeOp, + Cell cell) + { + this(allocator, + writeOp, + cell.column(), + cell.timestamp(), + cell.ttl(), + cell.localDeletionTime(), + cell.value(), + cell.path()); + } + + public NativeCell(NativeAllocator allocator, + OpOrder.Group writeOp, + ColumnDefinition column, + long timestamp, + int ttl, + int localDeletionTime, + ByteBuffer value, + CellPath path) + { + super(column); + long size = simpleSize(value.remaining()); + + assert value.order() == ByteOrder.BIG_ENDIAN; + assert column.isComplex() == (path != null); + if (path != null) + { + assert path.size() == 1; + size += 4 + path.get(0).remaining(); + } + + if (size > Integer.MAX_VALUE) + throw new IllegalStateException(); + + // cellpath? : timestamp : ttl : localDeletionTime : length : <data> : [cell path length] : [<cell path data>] + peer = allocator.allocate((int) size, writeOp); + MemoryUtil.setByte(peer + HAS_CELLPATH, (byte)(path == null ? 0 : 1)); + MemoryUtil.setLong(peer + TIMESTAMP, timestamp); + MemoryUtil.setInt(peer + TTL, ttl); + MemoryUtil.setInt(peer + DELETION, localDeletionTime); + MemoryUtil.setInt(peer + LENGTH, value.remaining()); + MemoryUtil.setBytes(peer + VALUE, value); + + if (path != null) + { + ByteBuffer pathbuffer = path.get(0); + assert pathbuffer.order() == ByteOrder.BIG_ENDIAN; + + long offset = peer + VALUE + value.remaining(); + MemoryUtil.setInt(offset, pathbuffer.remaining()); + MemoryUtil.setBytes(offset + 4, pathbuffer); + } + } + + private static long simpleSize(int length) + { + return VALUE + length; + } + + public long timestamp() + { + return MemoryUtil.getLong(peer + TIMESTAMP); + } + + public int ttl() + { + return MemoryUtil.getInt(peer + TTL); + } + + public int localDeletionTime() + { + return MemoryUtil.getInt(peer + DELETION); + } + + public ByteBuffer value() + { + int length = MemoryUtil.getInt(peer + LENGTH); + return MemoryUtil.getByteBuffer(peer + VALUE, length, ByteOrder.BIG_ENDIAN); + } + + public CellPath path() + { + if (MemoryUtil.getByte(peer+ HAS_CELLPATH) == 0) + return null; + + long offset = peer + VALUE + MemoryUtil.getInt(peer + LENGTH); + int size = MemoryUtil.getInt(offset); + return CellPath.create(MemoryUtil.getByteBuffer(offset + 4, size, ByteOrder.BIG_ENDIAN)); + } + + public Cell withUpdatedValue(ByteBuffer newValue) + { + throw new UnsupportedOperationException(); + } + + public long unsharedHeapSizeExcludingData() + { + return EMPTY_SIZE; + } + +} http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/db/rows/RowIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/rows/RowIterator.java b/src/java/org/apache/cassandra/db/rows/RowIterator.java index f0b4499..0cc4a3c 100644 --- a/src/java/org/apache/cassandra/db/rows/RowIterator.java +++ b/src/java/org/apache/cassandra/db/rows/RowIterator.java @@ -17,11 +17,6 @@ */ package org.apache.cassandra.db.rows; -import java.util.Iterator; - -import org.apache.cassandra.config.CFMetaData; -import org.apache.cassandra.db.*; - /** * An iterator over rows belonging to a partition. * http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/db/rows/UnfilteredRowIterators.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/rows/UnfilteredRowIterators.java b/src/java/org/apache/cassandra/db/rows/UnfilteredRowIterators.java index 9aa7cc4..52b346a 100644 --- a/src/java/org/apache/cassandra/db/rows/UnfilteredRowIterators.java +++ b/src/java/org/apache/cassandra/db/rows/UnfilteredRowIterators.java @@ -36,7 +36,6 @@ import org.apache.cassandra.net.MessagingService; import org.apache.cassandra.utils.FBUtilities; import org.apache.cassandra.utils.IMergeIterator; import org.apache.cassandra.utils.MergeIterator; -import org.apache.cassandra.utils.memory.AbstractAllocator; /** * Static methods to work with atom iterators. @@ -175,32 +174,6 @@ public abstract class UnfilteredRowIterators return MoreRows.extend(iter1, new Extend()); } - public static UnfilteredRowIterator cloningIterator(UnfilteredRowIterator iterator, final AbstractAllocator allocator) - { - class Cloner extends Transformation - { - private final Row.Builder builder = allocator.cloningBTreeRowBuilder(); - - public Row applyToStatic(Row row) - { - return Rows.copy(row, builder).build(); - } - - @Override - public Row applyToRow(Row row) - { - return Rows.copy(row, builder).build(); - } - - @Override - public RangeTombstoneMarker applyToMarker(RangeTombstoneMarker marker) - { - return marker.copy(allocator); - } - } - return Transformation.apply(iterator, new Cloner()); - } - /** * Validate that the data of the provided iterator is valid, that is that the values * it contains are valid for the type they represent, and more generally that the http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/db/transform/BaseRows.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/transform/BaseRows.java b/src/java/org/apache/cassandra/db/transform/BaseRows.java index 78526e8..825db44 100644 --- a/src/java/org/apache/cassandra/db/transform/BaseRows.java +++ b/src/java/org/apache/cassandra/db/transform/BaseRows.java @@ -13,11 +13,13 @@ implements BaseRowIterator<R> { private Row staticRow; + private DecoratedKey partitionKey; public BaseRows(I input) { super(input); staticRow = input.staticRow(); + partitionKey = input.partitionKey(); } // swap parameter order to avoid casting errors @@ -25,6 +27,7 @@ implements BaseRowIterator<R> { super(copyFrom); staticRow = copyFrom.staticRow; + partitionKey = copyFrom.partitionKey(); } public CFMetaData metadata() @@ -84,6 +87,7 @@ implements BaseRowIterator<R> // transform any existing data staticRow = transformation.applyToStatic(staticRow); next = applyOne(next, transformation); + partitionKey = transformation.applyToPartitionKey(partitionKey); } @Override http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/db/transform/Transformation.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/transform/Transformation.java b/src/java/org/apache/cassandra/db/transform/Transformation.java index 29e2e15..230be5f 100644 --- a/src/java/org/apache/cassandra/db/transform/Transformation.java +++ b/src/java/org/apache/cassandra/db/transform/Transformation.java @@ -1,5 +1,6 @@ package org.apache.cassandra.db.transform; +import org.apache.cassandra.db.DecoratedKey; import org.apache.cassandra.db.DeletionTime; import org.apache.cassandra.db.partitions.PartitionIterator; import org.apache.cassandra.db.partitions.UnfilteredPartitionIterator; @@ -62,6 +63,11 @@ public abstract class Transformation<I extends BaseRowIterator<?>> } /** + * Applied to the partition key of any rows/unfiltered iterator we are applied to + */ + protected DecoratedKey applyToPartitionKey(DecoratedKey key) { return key; } + + /** * Applied to the static row of any rows iterator. * * NOTE that this is only applied to the first iterator in any sequence of iterators filled by a MoreContents; http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/db/view/TemporalRow.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/view/TemporalRow.java b/src/java/org/apache/cassandra/db/view/TemporalRow.java index 23705b9..4774be4 100644 --- a/src/java/org/apache/cassandra/db/view/TemporalRow.java +++ b/src/java/org/apache/cassandra/db/view/TemporalRow.java @@ -37,16 +37,7 @@ import com.google.common.collect.Iterables; import org.apache.cassandra.config.CFMetaData; import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.cql3.ColumnIdentifier; -import org.apache.cassandra.db.CBuilder; -import org.apache.cassandra.db.Clustering; -import org.apache.cassandra.db.ColumnFamilyStore; -import org.apache.cassandra.db.Conflicts; -import org.apache.cassandra.db.DecoratedKey; -import org.apache.cassandra.db.DeletionInfo; -import org.apache.cassandra.db.DeletionTime; -import org.apache.cassandra.db.LivenessInfo; -import org.apache.cassandra.db.RangeTombstone; -import org.apache.cassandra.db.Slice; +import org.apache.cassandra.db.*; import org.apache.cassandra.db.marshal.CompositeType; import org.apache.cassandra.db.partitions.AbstractBTreePartition; import org.apache.cassandra.db.rows.BufferCell; http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/index/internal/IndexEntry.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/index/internal/IndexEntry.java b/src/java/org/apache/cassandra/index/internal/IndexEntry.java index 6f94ace..834dd6a 100644 --- a/src/java/org/apache/cassandra/index/internal/IndexEntry.java +++ b/src/java/org/apache/cassandra/index/internal/IndexEntry.java @@ -3,6 +3,7 @@ package org.apache.cassandra.index.internal; import java.nio.ByteBuffer; import org.apache.cassandra.db.Clustering; +import org.apache.cassandra.db.Clustering; import org.apache.cassandra.db.DecoratedKey; /** http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/index/internal/keys/KeysSearcher.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/index/internal/keys/KeysSearcher.java b/src/java/org/apache/cassandra/index/internal/keys/KeysSearcher.java index 0ad0891..101f2bb 100644 --- a/src/java/org/apache/cassandra/index/internal/keys/KeysSearcher.java +++ b/src/java/org/apache/cassandra/index/internal/keys/KeysSearcher.java @@ -145,7 +145,7 @@ public class KeysSearcher extends CassandraIndexSearcher // is the indexed name. Ans so we need to materialize the partition. ImmutableBTreePartition result = ImmutableBTreePartition.create(iterator); iterator.close(); - Row data = result.getRow(new Clustering(index.getIndexedColumn().name.bytes)); + Row data = result.getRow(Clustering.make(index.getIndexedColumn().name.bytes)); // for thrift tables, we need to compare the index entry against the compact value column, // not the column actually designated as the indexed column so we don't use the index function @@ -155,7 +155,7 @@ public class KeysSearcher extends CassandraIndexSearcher { // Index is stale, remove the index entry and ignore index.deleteStaleEntry(index.getIndexCfs().decorateKey(indexedValue), - new Clustering(index.getIndexedColumn().name.bytes), + Clustering.make(index.getIndexedColumn().name.bytes), new DeletionTime(indexHit.primaryKeyLivenessInfo().timestamp(), nowInSec), writeOp); return null; http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/io/sstable/metadata/MetadataCollector.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/io/sstable/metadata/MetadataCollector.java b/src/java/org/apache/cassandra/io/sstable/metadata/MetadataCollector.java index 1c93f58..3de0e5a 100644 --- a/src/java/org/apache/cassandra/io/sstable/metadata/MetadataCollector.java +++ b/src/java/org/apache/cassandra/io/sstable/metadata/MetadataCollector.java @@ -17,14 +17,11 @@ */ package org.apache.cassandra.io.sstable.metadata; -import java.io.File; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Collections; -import java.util.HashSet; import java.util.List; import java.util.Map; -import java.util.Set; import com.google.common.collect.Maps; @@ -35,7 +32,6 @@ import org.apache.cassandra.db.commitlog.ReplayPosition; import org.apache.cassandra.db.marshal.AbstractType; import org.apache.cassandra.db.partitions.PartitionStatisticsCollector; import org.apache.cassandra.db.rows.Cell; -import org.apache.cassandra.io.sstable.Component; import org.apache.cassandra.io.sstable.SSTable; import org.apache.cassandra.io.sstable.format.SSTableReader; import org.apache.cassandra.service.ActiveRepairService; http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/io/util/MemoryInputStream.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/io/util/MemoryInputStream.java b/src/java/org/apache/cassandra/io/util/MemoryInputStream.java index e009528..3daa4c4 100644 --- a/src/java/org/apache/cassandra/io/util/MemoryInputStream.java +++ b/src/java/org/apache/cassandra/io/util/MemoryInputStream.java @@ -71,6 +71,6 @@ public class MemoryInputStream extends RebufferingInputStream implements DataInp private static ByteBuffer getByteBuffer(long offset, int length) { - return MemoryUtil.getByteBuffer(offset, length).order(ByteOrder.BIG_ENDIAN); + return MemoryUtil.getByteBuffer(offset, length, ByteOrder.BIG_ENDIAN); } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/service/CacheService.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/service/CacheService.java b/src/java/org/apache/cassandra/service/CacheService.java index 03d7cd4..9bda3a0 100644 --- a/src/java/org/apache/cassandra/service/CacheService.java +++ b/src/java/org/apache/cassandra/service/CacheService.java @@ -40,10 +40,8 @@ import org.apache.cassandra.cache.*; import org.apache.cassandra.cache.AutoSavingCache.CacheSerializer; import org.apache.cassandra.concurrent.Stage; import org.apache.cassandra.concurrent.StageManager; -import org.apache.cassandra.config.CFMetaData; import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.config.DatabaseDescriptor; -import org.apache.cassandra.config.Schema; import org.apache.cassandra.db.*; import org.apache.cassandra.db.rows.*; import org.apache.cassandra.db.filter.*; http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/thrift/CassandraServer.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/thrift/CassandraServer.java b/src/java/org/apache/cassandra/thrift/CassandraServer.java index 61d9b5f..378a051 100644 --- a/src/java/org/apache/cassandra/thrift/CassandraServer.java +++ b/src/java/org/apache/cassandra/thrift/CassandraServer.java @@ -360,7 +360,7 @@ public class CassandraServer implements Cassandra.Iface private ClusteringIndexFilter toInternalFilter(CFMetaData metadata, ColumnParent parent, SliceRange range) { if (metadata.isSuper() && parent.isSetSuper_column()) - return new ClusteringIndexNamesFilter(FBUtilities.singleton(new Clustering(parent.bufferForSuper_column()), metadata.comparator), range.reversed); + return new ClusteringIndexNamesFilter(FBUtilities.singleton(Clustering.make(parent.bufferForSuper_column()), metadata.comparator), range.reversed); else return new ClusteringIndexSliceFilter(makeSlices(metadata, range), range.reversed); } @@ -384,13 +384,13 @@ public class CassandraServer implements Cassandra.Iface { if (parent.isSetSuper_column()) { - return new ClusteringIndexNamesFilter(FBUtilities.singleton(new Clustering(parent.bufferForSuper_column()), metadata.comparator), false); + return new ClusteringIndexNamesFilter(FBUtilities.singleton(Clustering.make(parent.bufferForSuper_column()), metadata.comparator), false); } else { NavigableSet<Clustering> clusterings = new TreeSet<>(metadata.comparator); for (ByteBuffer bb : predicate.column_names) - clusterings.add(new Clustering(bb)); + clusterings.add(Clustering.make(bb)); return new ClusteringIndexNamesFilter(clusterings, false); } } @@ -460,7 +460,7 @@ public class CassandraServer implements Cassandra.Iface // We only want to include the static columns that are selected by the slices for (ColumnDefinition def : columns.statics) { - if (slices.selects(new Clustering(def.name.bytes))) + if (slices.selects(Clustering.make(def.name.bytes))) builder.add(def); } columns = builder.build(); @@ -617,7 +617,7 @@ public class CassandraServer implements Cassandra.Iface builder.select(dynamicDef, CellPath.create(column_path.column)); columns = builder.build(); } - filter = new ClusteringIndexNamesFilter(FBUtilities.singleton(new Clustering(column_path.super_column), metadata.comparator), + filter = new ClusteringIndexNamesFilter(FBUtilities.singleton(Clustering.make(column_path.super_column), metadata.comparator), false); } else @@ -631,7 +631,7 @@ public class CassandraServer implements Cassandra.Iface builder.add(cellname.column); builder.add(metadata.compactValueColumn()); columns = builder.build(); - filter = new ClusteringIndexNamesFilter(FBUtilities.singleton(new Clustering(column_path.column), metadata.comparator), false); + filter = new ClusteringIndexNamesFilter(FBUtilities.singleton(Clustering.make(column_path.column), metadata.comparator), false); } else { @@ -1353,7 +1353,7 @@ public class CassandraServer implements Cassandra.Iface } else if (column_path.super_column != null && column_path.column == null) { - Row row = BTreeRow.emptyDeletedRow(new Clustering(column_path.super_column), Row.Deletion.regular(new DeletionTime(timestamp, nowInSec))); + Row row = BTreeRow.emptyDeletedRow(Clustering.make(column_path.super_column), Row.Deletion.regular(new DeletionTime(timestamp, nowInSec))); update = PartitionUpdate.singleRowUpdate(metadata, dk, row); } else @@ -1611,7 +1611,7 @@ public class CassandraServer implements Cassandra.Iface ClusteringIndexFilter filter = new ClusteringIndexSliceFilter(Slices.ALL, false); DataLimits limits = getLimits(range.count, true, Integer.MAX_VALUE); Clustering pageFrom = metadata.isSuper() - ? new Clustering(start_column) + ? Clustering.make(start_column) : LegacyLayout.decodeCellName(metadata, start_column).clustering; PartitionRangeReadCommand cmd = new PartitionRangeReadCommand(false, 0, http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/thrift/ThriftResultsMerger.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/thrift/ThriftResultsMerger.java b/src/java/org/apache/cassandra/thrift/ThriftResultsMerger.java index ea3fa2f..a14409e 100644 --- a/src/java/org/apache/cassandra/thrift/ThriftResultsMerger.java +++ b/src/java/org/apache/cassandra/thrift/ThriftResultsMerger.java @@ -199,7 +199,7 @@ public class ThriftResultsMerger extends Transformation<UnfilteredRowIterator> Cell cell = staticCells.next(); // Given a static cell, the equivalent row uses the column name as clustering and the value as unique cell value. - builder.newRow(new Clustering(cell.column().name.bytes)); + builder.newRow(Clustering.make(cell.column().name.bytes)); builder.addCell(new BufferCell(metadata().compactValueColumn(), cell.timestamp(), cell.ttl(), cell.localDeletionTime(), cell.value(), cell.path())); nextToMerge = builder.build(); } http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/AbstractAllocator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/AbstractAllocator.java b/src/java/org/apache/cassandra/utils/memory/AbstractAllocator.java index 9066335..c3cac2b 100644 --- a/src/java/org/apache/cassandra/utils/memory/AbstractAllocator.java +++ b/src/java/org/apache/cassandra/utils/memory/AbstractAllocator.java @@ -20,7 +20,6 @@ package org.apache.cassandra.utils.memory; import java.nio.ByteBuffer; import org.apache.cassandra.db.Clustering; -import org.apache.cassandra.db.Columns; import org.apache.cassandra.db.rows.BTreeRow; import org.apache.cassandra.db.rows.Cell; import org.apache.cassandra.db.rows.Row; http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/EnsureOnHeap.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/EnsureOnHeap.java b/src/java/org/apache/cassandra/utils/memory/EnsureOnHeap.java new file mode 100644 index 0000000..b53c2a0 --- /dev/null +++ b/src/java/org/apache/cassandra/utils/memory/EnsureOnHeap.java @@ -0,0 +1,150 @@ +package org.apache.cassandra.utils.memory; + +import java.util.Iterator; + +import org.apache.cassandra.db.BufferDecoratedKey; +import org.apache.cassandra.db.Clustering; +import org.apache.cassandra.db.DecoratedKey; +import org.apache.cassandra.db.DeletionInfo; +import org.apache.cassandra.db.rows.*; +import org.apache.cassandra.db.transform.Transformation; +import org.apache.cassandra.utils.SearchIterator; + +public abstract class EnsureOnHeap extends Transformation +{ + public abstract DecoratedKey applyToPartitionKey(DecoratedKey key); + public abstract UnfilteredRowIterator applyToPartition(UnfilteredRowIterator partition); + public abstract SearchIterator<Clustering, Row> applyToPartition(SearchIterator<Clustering, Row> partition); + public abstract Iterator<Row> applyToPartition(Iterator<Row> partition); + public abstract DeletionInfo applyToDeletionInfo(DeletionInfo deletionInfo); + public abstract Row applyToRow(Row row); + public abstract Row applyToStatic(Row row); + public abstract RangeTombstoneMarker applyToMarker(RangeTombstoneMarker marker); + + static class CloneToHeap extends EnsureOnHeap + { + protected BaseRowIterator<?> applyToPartition(BaseRowIterator partition) + { + return partition instanceof UnfilteredRowIterator + ? Transformation.apply((UnfilteredRowIterator) partition, this) + : Transformation.apply((RowIterator) partition, this); + } + + public DecoratedKey applyToPartitionKey(DecoratedKey key) + { + return new BufferDecoratedKey(key.getToken(), HeapAllocator.instance.clone(key.getKey())); + } + + public Row applyToRow(Row row) + { + if (row == null) + return null; + return Rows.copy(row, HeapAllocator.instance.cloningBTreeRowBuilder()).build(); + } + + public Row applyToStatic(Row row) + { + if (row == Rows.EMPTY_STATIC_ROW) + return row; + return applyToRow(row); + } + + public RangeTombstoneMarker applyToMarker(RangeTombstoneMarker marker) + { + return marker.copy(HeapAllocator.instance); + } + + public UnfilteredRowIterator applyToPartition(UnfilteredRowIterator partition) + { + return Transformation.apply(partition, this); + } + + public SearchIterator<Clustering, Row> applyToPartition(SearchIterator<Clustering, Row> partition) + { + return new SearchIterator<Clustering, Row>() + { + public boolean hasNext() + { + return partition.hasNext(); + } + + public Row next(Clustering key) + { + return applyToRow(partition.next(key)); + } + }; + } + + public Iterator<Row> applyToPartition(Iterator<Row> partition) + { + return new Iterator<Row>() + { + public boolean hasNext() + { + return partition.hasNext(); + } + public Row next() + { + return applyToRow(partition.next()); + } + public void remove() + { + partition.remove(); + } + }; + } + + public DeletionInfo applyToDeletionInfo(DeletionInfo deletionInfo) + { + return deletionInfo.copy(HeapAllocator.instance); + } + } + + static class NoOp extends EnsureOnHeap + { + protected BaseRowIterator<?> applyToPartition(BaseRowIterator partition) + { + return partition; + } + + public DecoratedKey applyToPartitionKey(DecoratedKey key) + { + return key; + } + + public Row applyToRow(Row row) + { + return row; + } + + public Row applyToStatic(Row row) + { + return row; + } + + public RangeTombstoneMarker applyToMarker(RangeTombstoneMarker marker) + { + return marker; + } + + public UnfilteredRowIterator applyToPartition(UnfilteredRowIterator partition) + { + return partition; + } + + public SearchIterator<Clustering, Row> applyToPartition(SearchIterator<Clustering, Row> partition) + { + return partition; + } + + public Iterator<Row> applyToPartition(Iterator<Row> partition) + { + return partition; + } + + public DeletionInfo applyToDeletionInfo(DeletionInfo deletionInfo) + { + return deletionInfo; + } + } +} http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/HeapAllocator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/HeapAllocator.java b/src/java/org/apache/cassandra/utils/memory/HeapAllocator.java index 41877f5..8333142 100644 --- a/src/java/org/apache/cassandra/utils/memory/HeapAllocator.java +++ b/src/java/org/apache/cassandra/utils/memory/HeapAllocator.java @@ -33,4 +33,9 @@ public final class HeapAllocator extends AbstractAllocator { return ByteBuffer.allocate(size); } + + public boolean allocatingOnHeap() + { + return true; + } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/HeapPool.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/HeapPool.java b/src/java/org/apache/cassandra/utils/memory/HeapPool.java index 19f81be..593b443 100644 --- a/src/java/org/apache/cassandra/utils/memory/HeapPool.java +++ b/src/java/org/apache/cassandra/utils/memory/HeapPool.java @@ -32,11 +32,6 @@ public class HeapPool extends MemtablePool super(maxOnHeapMemory, 0, cleanupThreshold, cleaner); } - public boolean needToCopyOnHeap() - { - return false; - } - public MemtableAllocator newAllocator() { // TODO http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/MemoryUtil.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/MemoryUtil.java b/src/java/org/apache/cassandra/utils/memory/MemoryUtil.java index 7fa01d2..f205e7b 100644 --- a/src/java/org/apache/cassandra/utils/memory/MemoryUtil.java +++ b/src/java/org/apache/cassandra/utils/memory/MemoryUtil.java @@ -106,6 +106,11 @@ public abstract class MemoryUtil unsafe.putByte(address, b); } + public static void setByte(long address, int count, byte b) + { + unsafe.setMemory(address, count, b); + } + public static void setShort(long address, short s) { unsafe.putShort(address, s); @@ -149,13 +154,23 @@ public abstract class MemoryUtil public static ByteBuffer getByteBuffer(long address, int length) { - ByteBuffer instance = getHollowDirectByteBuffer(); + return getByteBuffer(address, length, ByteOrder.nativeOrder()); + } + + public static ByteBuffer getByteBuffer(long address, int length, ByteOrder order) + { + ByteBuffer instance = getHollowDirectByteBuffer(order); setByteBuffer(instance, address, length); return instance; } public static ByteBuffer getHollowDirectByteBuffer() { + return getHollowDirectByteBuffer(ByteOrder.nativeOrder()); + } + + public static ByteBuffer getHollowDirectByteBuffer(ByteOrder order) + { ByteBuffer instance; try { @@ -165,7 +180,7 @@ public abstract class MemoryUtil { throw new AssertionError(e); } - instance.order(ByteOrder.nativeOrder()); + instance.order(order); return instance; } http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/MemtableAllocator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/MemtableAllocator.java b/src/java/org/apache/cassandra/utils/memory/MemtableAllocator.java index 588b433..1f1bf5e 100644 --- a/src/java/org/apache/cassandra/utils/memory/MemtableAllocator.java +++ b/src/java/org/apache/cassandra/utils/memory/MemtableAllocator.java @@ -20,7 +20,6 @@ package org.apache.cassandra.utils.memory; import java.util.concurrent.atomic.AtomicLongFieldUpdater; -import org.apache.cassandra.config.CFMetaData; import org.apache.cassandra.db.*; import org.apache.cassandra.db.rows.*; import org.apache.cassandra.utils.concurrent.OpOrder; @@ -32,7 +31,7 @@ public abstract class MemtableAllocator private final SubAllocator offHeap; volatile LifeCycle state = LifeCycle.LIVE; - static enum LifeCycle + enum LifeCycle { LIVE, DISCARDING, DISCARDED; LifeCycle transition(LifeCycle targetState) @@ -62,6 +61,7 @@ public abstract class MemtableAllocator public abstract Row.Builder rowBuilder(OpOrder.Group opGroup); public abstract DecoratedKey clone(DecoratedKey key, OpOrder.Group opGroup); public abstract DataReclaimer reclaimer(); + public abstract EnsureOnHeap ensureOnHeap(); public SubAllocator onHeap() { @@ -251,4 +251,5 @@ public abstract class MemtableAllocator private static final AtomicLongFieldUpdater<SubAllocator> reclaimingUpdater = AtomicLongFieldUpdater.newUpdater(SubAllocator.class, "reclaiming"); } + } http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/MemtablePool.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/MemtablePool.java b/src/java/org/apache/cassandra/utils/memory/MemtablePool.java index bb85884..8f35042 100644 --- a/src/java/org/apache/cassandra/utils/memory/MemtablePool.java +++ b/src/java/org/apache/cassandra/utils/memory/MemtablePool.java @@ -56,7 +56,6 @@ public abstract class MemtablePool return cleaner == null ? null : new MemtableCleanerThread<>(this, cleaner); } - public abstract boolean needToCopyOnHeap(); public abstract MemtableAllocator newAllocator(); /** http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/NativeAllocator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/NativeAllocator.java b/src/java/org/apache/cassandra/utils/memory/NativeAllocator.java index e5458b4..6acf6c6 100644 --- a/src/java/org/apache/cassandra/utils/memory/NativeAllocator.java +++ b/src/java/org/apache/cassandra/utils/memory/NativeAllocator.java @@ -24,10 +24,8 @@ import java.util.concurrent.Semaphore; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; -import org.apache.cassandra.config.CFMetaData; -import org.apache.cassandra.db.DecoratedKey; -import org.apache.cassandra.db.NativeDecoratedKey; -import org.apache.cassandra.db.rows.Row; +import org.apache.cassandra.db.*; +import org.apache.cassandra.db.rows.*; import org.apache.cassandra.utils.concurrent.OpOrder; public class NativeAllocator extends MemtableAllocator @@ -47,16 +45,42 @@ public class NativeAllocator extends MemtableAllocator private final AtomicReference<Region> currentRegion = new AtomicReference<>(); private final ConcurrentLinkedQueue<Region> regions = new ConcurrentLinkedQueue<>(); + private final EnsureOnHeap.CloneToHeap cloneToHeap = new EnsureOnHeap.CloneToHeap(); protected NativeAllocator(NativePool pool) { super(pool.onHeap.newAllocator(), pool.offHeap.newAllocator()); } + private static class CloningBTreeRowBuilder extends BTreeRow.Builder + { + final OpOrder.Group writeOp; + final NativeAllocator allocator; + private CloningBTreeRowBuilder(OpOrder.Group writeOp, NativeAllocator allocator) + { + super(true); + this.writeOp = writeOp; + this.allocator = allocator; + } + + @Override + public void newRow(Clustering clustering) + { + if (clustering != Clustering.STATIC_CLUSTERING) + clustering = new NativeClustering(allocator, writeOp, clustering); + super.newRow(clustering); + } + + @Override + public void addCell(Cell cell) + { + super.addCell(new NativeCell(allocator, writeOp, cell)); + } + } + public Row.Builder rowBuilder(OpOrder.Group opGroup) { - // TODO - throw new UnsupportedOperationException(); + return new CloningBTreeRowBuilder(opGroup, this); } public DecoratedKey clone(DecoratedKey key, OpOrder.Group writeOp) @@ -70,6 +94,11 @@ public class NativeAllocator extends MemtableAllocator return NO_OP; } + public EnsureOnHeap ensureOnHeap() + { + return cloneToHeap; + } + public long allocate(int size, OpOrder.Group opGroup) { assert size >= 0; @@ -136,6 +165,7 @@ public class NativeAllocator extends MemtableAllocator { for (Region region : regions) MemoryUtil.free(region.peer); + super.setDiscarded(); } @@ -181,12 +211,12 @@ public class NativeAllocator extends MemtableAllocator * Offset for the next allocation, or the sentinel value -1 * which implies that the region is still uninitialized. */ - private AtomicInteger nextFreeOffset = new AtomicInteger(0); + private final AtomicInteger nextFreeOffset = new AtomicInteger(0); /** * Total number of allocations satisfied from this buffer */ - private AtomicInteger allocCount = new AtomicInteger(); + private final AtomicInteger allocCount = new AtomicInteger(); /** * Create an uninitialized region. Note that memory is not allocated yet, so http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/NativePool.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/NativePool.java b/src/java/org/apache/cassandra/utils/memory/NativePool.java index 012867a..800c777 100644 --- a/src/java/org/apache/cassandra/utils/memory/NativePool.java +++ b/src/java/org/apache/cassandra/utils/memory/NativePool.java @@ -26,12 +26,6 @@ public class NativePool extends MemtablePool } @Override - public boolean needToCopyOnHeap() - { - return true; - } - - @Override public NativeAllocator newAllocator() { return new NativeAllocator(this); http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/SlabAllocator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/SlabAllocator.java b/src/java/org/apache/cassandra/utils/memory/SlabAllocator.java index 8defd25..ce4f41f 100644 --- a/src/java/org/apache/cassandra/utils/memory/SlabAllocator.java +++ b/src/java/org/apache/cassandra/utils/memory/SlabAllocator.java @@ -59,13 +59,20 @@ public class SlabAllocator extends MemtableBufferAllocator // this queue is used to keep references to off-heap allocated regions so that we can free them when we are discarded private final ConcurrentLinkedQueue<Region> offHeapRegions = new ConcurrentLinkedQueue<>(); - private AtomicLong unslabbedSize = new AtomicLong(0); + private final AtomicLong unslabbedSize = new AtomicLong(0); private final boolean allocateOnHeapOnly; + private final EnsureOnHeap ensureOnHeap; SlabAllocator(SubAllocator onHeap, SubAllocator offHeap, boolean allocateOnHeapOnly) { super(onHeap, offHeap); this.allocateOnHeapOnly = allocateOnHeapOnly; + this.ensureOnHeap = allocateOnHeapOnly ? new EnsureOnHeap.NoOp() : new EnsureOnHeap.CloneToHeap(); + } + + public EnsureOnHeap ensureOnHeap() + { + return ensureOnHeap; } public ByteBuffer allocate(int size) @@ -168,18 +175,18 @@ public class SlabAllocator extends MemtableBufferAllocator /** * Actual underlying data */ - private ByteBuffer data; + private final ByteBuffer data; /** * Offset for the next allocation, or the sentinel value -1 * which implies that the region is still uninitialized. */ - private AtomicInteger nextFreeOffset = new AtomicInteger(0); + private final AtomicInteger nextFreeOffset = new AtomicInteger(0); /** * Total number of allocations satisfied from this buffer */ - private AtomicInteger allocCount = new AtomicInteger(); + private final AtomicInteger allocCount = new AtomicInteger(); /** * Create an uninitialized region. Note that memory is not allocated yet, so http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/src/java/org/apache/cassandra/utils/memory/SlabPool.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/memory/SlabPool.java b/src/java/org/apache/cassandra/utils/memory/SlabPool.java index c5c44e1..bd7ec1f 100644 --- a/src/java/org/apache/cassandra/utils/memory/SlabPool.java +++ b/src/java/org/apache/cassandra/utils/memory/SlabPool.java @@ -32,9 +32,4 @@ public class SlabPool extends MemtablePool { return new SlabAllocator(onHeap.newAllocator(), offHeap.newAllocator(), allocateOnHeap); } - - public boolean needToCopyOnHeap() - { - return !allocateOnHeap; - } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/conf/cassandra.yaml ---------------------------------------------------------------------- diff --git a/test/conf/cassandra.yaml b/test/conf/cassandra.yaml index 1dba284..eb03d17 100644 --- a/test/conf/cassandra.yaml +++ b/test/conf/cassandra.yaml @@ -3,7 +3,8 @@ # Consider the effects on 'o.a.c.i.s.LegacySSTableTest' before changing schemas in this file. # cluster_name: Test Cluster -memtable_allocation_type: heap_buffers +# memtable_allocation_type: heap_buffers +memtable_allocation_type: offheap_objects commitlog_sync: batch commitlog_sync_batch_window_in_ms: 1.0 commitlog_segment_size_in_mb: 5 http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/db/KeyspaceTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/KeyspaceTest.java b/test/unit/org/apache/cassandra/db/KeyspaceTest.java index c0c2753..6536285 100644 --- a/test/unit/org/apache/cassandra/db/KeyspaceTest.java +++ b/test/unit/org/apache/cassandra/db/KeyspaceTest.java @@ -129,8 +129,8 @@ public class KeyspaceTest extends CQLTester private static void assertRowsInSlice(ColumnFamilyStore cfs, String key, int sliceStart, int sliceEnd, int limit, boolean reversed, String columnValuePrefix) { - Clustering startClustering = new Clustering(ByteBufferUtil.bytes(sliceStart)); - Clustering endClustering = new Clustering(ByteBufferUtil.bytes(sliceEnd)); + Clustering startClustering = Clustering.make(ByteBufferUtil.bytes(sliceStart)); + Clustering endClustering = Clustering.make(ByteBufferUtil.bytes(sliceEnd)); Slices slices = Slices.with(cfs.getComparator(), Slice.make(startClustering, endClustering)); ClusteringIndexSliceFilter filter = new ClusteringIndexSliceFilter(slices, reversed); SinglePartitionReadCommand command = singlePartitionSlice(cfs, key, filter, limit); http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/db/NativeCellTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/NativeCellTest.java b/test/unit/org/apache/cassandra/db/NativeCellTest.java new file mode 100644 index 0000000..69e615b --- /dev/null +++ b/test/unit/org/apache/cassandra/db/NativeCellTest.java @@ -0,0 +1,171 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.cassandra.db; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.Random; +import java.util.UUID; + +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.cql3.ColumnIdentifier; +import org.apache.cassandra.db.marshal.BytesType; +import org.apache.cassandra.db.marshal.SetType; +import org.apache.cassandra.db.marshal.UTF8Type; +import org.apache.cassandra.db.rows.*; +import org.apache.cassandra.utils.concurrent.OpOrder; +import org.apache.cassandra.utils.memory.HeapAllocator; +import org.apache.cassandra.utils.memory.NativeAllocator; +import org.apache.cassandra.utils.memory.NativePool; + +public class NativeCellTest +{ + + private static final Logger logger = LoggerFactory.getLogger(NativeCellTest.class); + private static final NativeAllocator nativeAllocator = new NativePool(Integer.MAX_VALUE, Integer.MAX_VALUE, 1f, null).newAllocator(); + private static final OpOrder.Group group = new OpOrder().start(); + private static Random rand; + + @BeforeClass + public static void setUp() + { + long seed = System.currentTimeMillis(); + logger.info("Seed : {}", seed); + rand = new Random(seed); + } + + @Test + public void testCells() throws IOException + { + for (int run = 0 ; run < 1000 ; run++) + { + Row.Builder builder = BTreeRow.unsortedBuilder(1); + builder.newRow(rndclustering()); + int count = 1 + rand.nextInt(10); + for (int i = 0 ; i < count ; i++) + rndcd(builder); + test(builder.build()); + } + } + + private static Clustering rndclustering() + { + int count = 1 + rand.nextInt(100); + ByteBuffer[] values = new ByteBuffer[count]; + int size = rand.nextInt(65535); + for (int i = 0 ; i < count ; i++) + { + int twiceShare = 1 + (2 * size) / (count - i); + int nextSize = Math.min(size, rand.nextInt(twiceShare)); + if (nextSize < 10 && rand.nextBoolean()) + continue; + + byte[] bytes = new byte[nextSize]; + rand.nextBytes(bytes); + values[i] = ByteBuffer.wrap(bytes); + size -= nextSize; + } + return Clustering.make(values); + } + + private static void rndcd(Row.Builder builder) + { + ColumnDefinition col = rndcol(); + if (!col.isComplex()) + { + builder.addCell(rndcell(col)); + } + else + { + int count = 1 + rand.nextInt(100); + for (int i = 0 ; i < count ; i++) + builder.addCell(rndcell(col)); + } + } + + private static ColumnDefinition rndcol() + { + UUID uuid = new UUID(rand.nextLong(), rand.nextLong()); + boolean isComplex = rand.nextBoolean(); + return new ColumnDefinition("", + "", + ColumnIdentifier.getInterned(uuid.toString(), false), + isComplex ? new SetType<>(BytesType.instance, true) : BytesType.instance, + -1, + ColumnDefinition.Kind.REGULAR); + } + + private static Cell rndcell(ColumnDefinition col) + { + long timestamp = rand.nextLong(); + int ttl = rand.nextInt(); + int localDeletionTime = rand.nextInt(); + byte[] value = new byte[rand.nextInt(sanesize(expdecay()))]; + rand.nextBytes(value); + CellPath path = null; + if (col.isComplex()) + { + byte[] pathbytes = new byte[rand.nextInt(sanesize(expdecay()))]; + rand.nextBytes(value); + path = CellPath.create(ByteBuffer.wrap(pathbytes)); + } + + return new BufferCell(col, timestamp, ttl, localDeletionTime, ByteBuffer.wrap(value), path); + } + + private static int expdecay() + { + return 1 << Integer.numberOfTrailingZeros(Integer.lowestOneBit(rand.nextInt())); + } + + private static int sanesize(int randomsize) + { + return Math.min(Math.max(1, randomsize), 1 << 26); + } + + private static void test(Row row) + { + Row nrow = clone(row, nativeAllocator.rowBuilder(group)); + Row brow = clone(row, HeapAllocator.instance.cloningBTreeRowBuilder()); + Assert.assertEquals(row, nrow); + Assert.assertEquals(row, brow); + Assert.assertEquals(nrow, brow); + + Assert.assertEquals(row.clustering(), nrow.clustering()); + Assert.assertEquals(row.clustering(), brow.clustering()); + Assert.assertEquals(nrow.clustering(), brow.clustering()); + + ClusteringComparator comparator = new ClusteringComparator(UTF8Type.instance); + Assert.assertTrue(comparator.compare(row.clustering(), nrow.clustering()) == 0); + Assert.assertTrue(comparator.compare(row.clustering(), brow.clustering()) == 0); + Assert.assertTrue(comparator.compare(nrow.clustering(), brow.clustering()) == 0); + } + + private static Row clone(Row row, Row.Builder builder) + { + return Rows.copy(row, builder).build(); + } + +} http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/db/RangeTombstoneListTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/RangeTombstoneListTest.java b/test/unit/org/apache/cassandra/db/RangeTombstoneListTest.java index f40abe9..1e637b3 100644 --- a/test/unit/org/apache/cassandra/db/RangeTombstoneListTest.java +++ b/test/unit/org/apache/cassandra/db/RangeTombstoneListTest.java @@ -605,7 +605,7 @@ public class RangeTombstoneListTest private static Clustering clustering(int i) { - return new Clustering(bb(i)); + return Clustering.make(bb(i)); } private static ByteBuffer bb(int i) http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/db/RangeTombstoneTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/RangeTombstoneTest.java b/test/unit/org/apache/cassandra/db/RangeTombstoneTest.java index d0cc890..4be46ff 100644 --- a/test/unit/org/apache/cassandra/db/RangeTombstoneTest.java +++ b/test/unit/org/apache/cassandra/db/RangeTombstoneTest.java @@ -112,17 +112,17 @@ public class RangeTombstoneTest int nowInSec = FBUtilities.nowInSeconds(); for (int i : live) - assertTrue("Row " + i + " should be live", partition.getRow(new Clustering(bb(i))).hasLiveData(nowInSec)); + assertTrue("Row " + i + " should be live", partition.getRow(Clustering.make(bb(i))).hasLiveData(nowInSec)); for (int i : dead) - assertFalse("Row " + i + " shouldn't be live", partition.getRow(new Clustering(bb(i))).hasLiveData(nowInSec)); + assertFalse("Row " + i + " shouldn't be live", partition.getRow(Clustering.make(bb(i))).hasLiveData(nowInSec)); // Queries by slices partition = Util.getOnlyPartitionUnfiltered(Util.cmd(cfs, key).fromIncl(7).toIncl(30).build()); for (int i : new int[]{ 7, 8, 9, 11, 13, 15, 17, 28, 29, 30 }) - assertTrue("Row " + i + " should be live", partition.getRow(new Clustering(bb(i))).hasLiveData(nowInSec)); + assertTrue("Row " + i + " should be live", partition.getRow(Clustering.make(bb(i))).hasLiveData(nowInSec)); for (int i : new int[]{ 10, 12, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 }) - assertFalse("Row " + i + " shouldn't be live", partition.getRow(new Clustering(bb(i))).hasLiveData(nowInSec)); + assertFalse("Row " + i + " shouldn't be live", partition.getRow(Clustering.make(bb(i))).hasLiveData(nowInSec)); } @Test @@ -408,22 +408,22 @@ public class RangeTombstoneTest int nowInSec = FBUtilities.nowInSeconds(); for (int i = 0; i < 5; i++) - assertTrue("Row " + i + " should be live", partition.getRow(new Clustering(bb(i))).hasLiveData(nowInSec)); + assertTrue("Row " + i + " should be live", partition.getRow(Clustering.make(bb(i))).hasLiveData(nowInSec)); for (int i = 16; i < 20; i++) - assertTrue("Row " + i + " should be live", partition.getRow(new Clustering(bb(i))).hasLiveData(nowInSec)); + assertTrue("Row " + i + " should be live", partition.getRow(Clustering.make(bb(i))).hasLiveData(nowInSec)); for (int i = 5; i <= 15; i++) - assertFalse("Row " + i + " shouldn't be live", partition.getRow(new Clustering(bb(i))).hasLiveData(nowInSec)); + assertFalse("Row " + i + " shouldn't be live", partition.getRow(Clustering.make(bb(i))).hasLiveData(nowInSec)); // Compact everything and re-test CompactionManager.instance.performMaximal(cfs, false); partition = Util.getOnlyPartitionUnfiltered(Util.cmd(cfs, key).build()); for (int i = 0; i < 5; i++) - assertTrue("Row " + i + " should be live", partition.getRow(new Clustering(bb(i))).hasLiveData(FBUtilities.nowInSeconds())); + assertTrue("Row " + i + " should be live", partition.getRow(Clustering.make(bb(i))).hasLiveData(FBUtilities.nowInSeconds())); for (int i = 16; i < 20; i++) - assertTrue("Row " + i + " should be live", partition.getRow(new Clustering(bb(i))).hasLiveData(FBUtilities.nowInSeconds())); + assertTrue("Row " + i + " should be live", partition.getRow(Clustering.make(bb(i))).hasLiveData(FBUtilities.nowInSeconds())); for (int i = 5; i <= 15; i++) - assertFalse("Row " + i + " shouldn't be live", partition.getRow(new Clustering(bb(i))).hasLiveData(nowInSec)); + assertFalse("Row " + i + " shouldn't be live", partition.getRow(Clustering.make(bb(i))).hasLiveData(nowInSec)); } @Test http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/db/ReadMessageTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/ReadMessageTest.java b/test/unit/org/apache/cassandra/db/ReadMessageTest.java index d801b32..6dafa37 100644 --- a/test/unit/org/apache/cassandra/db/ReadMessageTest.java +++ b/test/unit/org/apache/cassandra/db/ReadMessageTest.java @@ -219,7 +219,7 @@ public class ReadMessageTest { for (PartitionUpdate upd : mutation.getPartitionUpdates()) { - Row r = upd.getRow(new Clustering(ByteBufferUtil.bytes("c"))); + Row r = upd.getRow(Clustering.make(ByteBufferUtil.bytes("c"))); if (r != null) { if (r.getCell(withCommit) != null) http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/db/RowCacheTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/RowCacheTest.java b/test/unit/org/apache/cassandra/db/RowCacheTest.java index 267e5e4..21d7b8f 100644 --- a/test/unit/org/apache/cassandra/db/RowCacheTest.java +++ b/test/unit/org/apache/cassandra/db/RowCacheTest.java @@ -480,7 +480,7 @@ public class RowCacheTest for (int i = offset; i < offset + numberOfRows; i++) { DecoratedKey key = Util.dk("key" + i); - Clustering cl = new Clustering(ByteBufferUtil.bytes("col" + i)); + Clustering cl = Clustering.make(ByteBufferUtil.bytes("col" + i)); Util.getAll(Util.cmd(store, key).build()); } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/db/rows/DigestBackwardCompatibilityTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/rows/DigestBackwardCompatibilityTest.java b/test/unit/org/apache/cassandra/db/rows/DigestBackwardCompatibilityTest.java index 5503cfb..15e961b 100644 --- a/test/unit/org/apache/cassandra/db/rows/DigestBackwardCompatibilityTest.java +++ b/test/unit/org/apache/cassandra/db/rows/DigestBackwardCompatibilityTest.java @@ -18,7 +18,6 @@ package org.apache.cassandra.db.rows; import java.nio.ByteBuffer; -import java.util.*; import java.security.MessageDigest; import org.junit.Test; @@ -28,7 +27,6 @@ import org.apache.cassandra.config.CFMetaData; import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.cql3.CQLTester; import org.apache.cassandra.db.*; -import org.apache.cassandra.db.filter.*; import org.apache.cassandra.db.partitions.*; import org.apache.cassandra.db.context.CounterContext; import org.apache.cassandra.net.MessagingService; http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/db/rows/UnfilteredRowIteratorsMergeTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/rows/UnfilteredRowIteratorsMergeTest.java b/test/unit/org/apache/cassandra/db/rows/UnfilteredRowIteratorsMergeTest.java index 7637fa0..6f1985a 100644 --- a/test/unit/org/apache/cassandra/db/rows/UnfilteredRowIteratorsMergeTest.java +++ b/test/unit/org/apache/cassandra/db/rows/UnfilteredRowIteratorsMergeTest.java @@ -364,7 +364,7 @@ public class UnfilteredRowIteratorsMergeTest private static Clustering clusteringFor(int i) { - return new Clustering(Int32Type.instance.decompose(i)); + return Clustering.make(Int32Type.instance.decompose(i)); } static Row emptyRowAt(int pos, Function<Integer, Integer> timeGenerator) http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/io/sstable/CQLSSTableWriterClientTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/io/sstable/CQLSSTableWriterClientTest.java b/test/unit/org/apache/cassandra/io/sstable/CQLSSTableWriterClientTest.java index d38276f..6df2d65 100644 --- a/test/unit/org/apache/cassandra/io/sstable/CQLSSTableWriterClientTest.java +++ b/test/unit/org/apache/cassandra/io/sstable/CQLSSTableWriterClientTest.java @@ -28,14 +28,10 @@ import org.junit.Before; import org.junit.Test; import org.apache.cassandra.config.Config; -import org.apache.cassandra.config.DatabaseDescriptor; -import org.apache.cassandra.db.Directories; -import org.apache.cassandra.db.Keyspace; import org.apache.cassandra.exceptions.InvalidRequestException; import org.apache.cassandra.io.util.FileUtils; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; public class CQLSSTableWriterClientTest { http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/io/sstable/SSTableLoaderTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/io/sstable/SSTableLoaderTest.java b/test/unit/org/apache/cassandra/io/sstable/SSTableLoaderTest.java index ad7523d..72c7467 100644 --- a/test/unit/org/apache/cassandra/io/sstable/SSTableLoaderTest.java +++ b/test/unit/org/apache/cassandra/io/sstable/SSTableLoaderTest.java @@ -142,7 +142,7 @@ public class SSTableLoaderTest assertEquals(1, partitions.size()); assertEquals("key1", AsciiType.instance.getString(partitions.get(0).partitionKey().getKey())); - assertEquals(ByteBufferUtil.bytes("100"), partitions.get(0).getRow(new Clustering(ByteBufferUtil.bytes("col1"))) + assertEquals(ByteBufferUtil.bytes("100"), partitions.get(0).getRow(Clustering.make(ByteBufferUtil.bytes("col1"))) .getCell(cfmeta.getColumnDefinition(ByteBufferUtil.bytes("val"))) .value()); http://git-wip-us.apache.org/repos/asf/cassandra/blob/2f412431/test/unit/org/apache/cassandra/service/pager/PagingStateTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/service/pager/PagingStateTest.java b/test/unit/org/apache/cassandra/service/pager/PagingStateTest.java index ba82e85..f4ac377 100644 --- a/test/unit/org/apache/cassandra/service/pager/PagingStateTest.java +++ b/test/unit/org/apache/cassandra/service/pager/PagingStateTest.java @@ -49,7 +49,7 @@ public class PagingStateTest ByteBuffer pk = ByteBufferUtil.bytes("someKey"); ColumnDefinition def = metadata.getColumnDefinition(new ColumnIdentifier("myCol", false)); - Clustering c = new Clustering(ByteBufferUtil.bytes("c1"), ByteBufferUtil.bytes(42)); + Clustering c = Clustering.make(ByteBufferUtil.bytes("c1"), ByteBufferUtil.bytes(42)); Row row = BTreeRow.singleCellRow(c, BufferCell.live(metadata, def, 0, ByteBufferUtil.EMPTY_BYTE_BUFFER)); PagingState.RowMark mark = PagingState.RowMark.create(metadata, row, protocolVersion); return new PagingState(pk, mark, 10, 0);
