Simplify some 8099's implementations patch by slebresne; reviewed by iamalesky for CASSANDRA-9705
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/24575994 Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/24575994 Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/24575994 Branch: refs/heads/trunk Commit: 2457599427d361314dce4833abeb5cd4915d0b06 Parents: 7659ae2 Author: Sylvain Lebresne <[email protected]> Authored: Tue Jun 30 15:58:02 2015 +0200 Committer: Sylvain Lebresne <[email protected]> Committed: Wed Jul 22 18:05:09 2015 +0200 ---------------------------------------------------------------------- .../org/apache/cassandra/config/CFMetaData.java | 2 +- .../cassandra/config/ColumnDefinition.java | 39 +- .../apache/cassandra/cql3/ColumnCondition.java | 7 +- .../org/apache/cassandra/cql3/Constants.java | 23 +- src/java/org/apache/cassandra/cql3/Lists.java | 69 +- src/java/org/apache/cassandra/cql3/Maps.java | 29 +- .../org/apache/cassandra/cql3/Operation.java | 6 +- src/java/org/apache/cassandra/cql3/Sets.java | 27 +- .../apache/cassandra/cql3/UntypedResultSet.java | 14 +- .../apache/cassandra/cql3/UpdateParameters.java | 109 ++- .../cassandra/cql3/selection/Selection.java | 13 +- .../cql3/statements/AlterTableStatement.java | 5 +- .../cql3/statements/CQL3CasRequest.java | 2 +- .../cql3/statements/DeleteStatement.java | 25 +- .../cql3/statements/ModificationStatement.java | 2 +- .../cql3/statements/SelectStatement.java | 8 +- .../cql3/statements/UpdateStatement.java | 18 +- .../cassandra/db/AbstractClusteringPrefix.java | 47 +- .../cassandra/db/AbstractLivenessInfo.java | 164 ---- src/java/org/apache/cassandra/db/Aliasable.java | 62 -- src/java/org/apache/cassandra/db/CBuilder.java | 6 +- .../org/apache/cassandra/db/Clustering.java | 87 +- .../cassandra/db/ClusteringComparator.java | 71 +- .../apache/cassandra/db/ClusteringPrefix.java | 120 +-- .../org/apache/cassandra/db/ColumnIndex.java | 16 +- src/java/org/apache/cassandra/db/Columns.java | 33 +- .../apache/cassandra/db/CounterMutation.java | 10 +- src/java/org/apache/cassandra/db/DataRange.java | 4 +- .../org/apache/cassandra/db/DeletionInfo.java | 251 +---- .../org/apache/cassandra/db/DeletionPurger.java | 35 + .../org/apache/cassandra/db/DeletionTime.java | 39 +- .../apache/cassandra/db/DeletionTimeArray.java | 153 --- .../cassandra/db/HintedHandOffManager.java | 25 +- .../org/apache/cassandra/db/LegacyLayout.java | 123 +-- .../org/apache/cassandra/db/LivenessInfo.java | 296 ++++-- .../apache/cassandra/db/LivenessInfoArray.java | 174 ---- .../cassandra/db/MutableDeletionInfo.java | 311 +++++++ .../apache/cassandra/db/PartitionColumns.java | 5 + .../cassandra/db/PartitionRangeReadCommand.java | 6 +- .../org/apache/cassandra/db/RangeTombstone.java | 59 +- .../apache/cassandra/db/RangeTombstoneList.java | 29 +- .../org/apache/cassandra/db/ReadCommand.java | 65 +- .../apache/cassandra/db/ReusableClustering.java | 82 -- .../cassandra/db/ReusableClusteringPrefix.java | 57 -- .../cassandra/db/ReusableLivenessInfo.java | 65 -- .../apache/cassandra/db/RowUpdateBuilder.java | 133 +-- .../cassandra/db/SerializationHeader.java | 17 +- .../apache/cassandra/db/SimpleClustering.java | 93 -- .../apache/cassandra/db/SimpleDeletionTime.java | 61 -- .../apache/cassandra/db/SimpleLivenessInfo.java | 75 -- .../db/SinglePartitionNamesCommand.java | 6 +- .../db/SinglePartitionReadCommand.java | 4 +- src/java/org/apache/cassandra/db/Slice.java | 151 +-- src/java/org/apache/cassandra/db/Slices.java | 4 +- .../org/apache/cassandra/db/SystemKeyspace.java | 2 +- src/java/org/apache/cassandra/db/TypeSizes.java | 5 + .../cassandra/db/UnfilteredDeserializer.java | 30 +- .../columniterator/AbstractSSTableIterator.java | 196 ++-- .../db/columniterator/SSTableIterator.java | 352 ++++--- .../columniterator/SSTableReversedIterator.java | 447 ++++----- .../db/compaction/CompactionIterator.java | 92 +- .../filter/AbstractClusteringIndexFilter.java | 8 +- .../db/filter/ClusteringIndexFilter.java | 4 +- .../db/filter/ClusteringIndexNamesFilter.java | 23 +- .../db/filter/ClusteringIndexSliceFilter.java | 18 +- .../cassandra/db/filter/ColumnFilter.java | 75 +- .../cassandra/db/filter/ColumnSubselection.java | 50 +- .../apache/cassandra/db/filter/DataLimits.java | 19 +- .../apache/cassandra/db/filter/RowFilter.java | 33 +- .../AbstractSimplePerColumnSecondaryIndex.java | 21 +- .../db/index/PerColumnSecondaryIndex.java | 12 +- .../db/index/SecondaryIndexManager.java | 16 +- .../db/index/SecondaryIndexSearcher.java | 2 +- .../db/index/composites/CompositesIndex.java | 11 +- .../CompositesIndexOnClusteringKey.java | 2 +- .../CompositesIndexOnCollectionValue.java | 5 +- .../CompositesIndexOnPartitionKey.java | 2 +- .../db/index/composites/CompositesSearcher.java | 45 +- .../cassandra/db/index/keys/KeysSearcher.java | 6 +- .../cassandra/db/marshal/AbstractType.java | 20 +- .../cassandra/db/marshal/CollectionType.java | 15 +- .../db/partitions/AbstractPartitionData.java | 850 ----------------- .../AbstractThreadUnsafePartition.java | 393 ++++++++ .../AlteringUnfilteredPartitionIterator.java | 72 ++ .../partitions/ArrayBackedCachedPartition.java | 217 +++-- .../db/partitions/ArrayBackedPartition.java | 82 +- .../db/partitions/AtomicBTreePartition.java | 415 ++------- .../CountingUnfilteredRowIterator.java | 8 +- .../db/partitions/FilteredPartition.java | 89 +- .../partitions/FilteringPartitionIterator.java | 146 --- .../PartitionStatisticsCollector.java | 30 + .../db/partitions/PartitionUpdate.java | 714 +++++++------- .../db/partitions/PurgingPartitionIterator.java | 150 +++ .../TombstonePurgingPartitionIterator.java | 103 --- .../UnfilteredPartitionIterators.java | 84 +- .../apache/cassandra/db/rows/AbstractCell.java | 70 +- .../db/rows/AbstractRangeTombstoneMarker.java | 27 +- .../cassandra/db/rows/AbstractReusableRow.java | 207 ----- .../apache/cassandra/db/rows/AbstractRow.java | 102 +- .../db/rows/AbstractUnfilteredRowIterator.java | 14 - .../db/rows/AlteringUnfilteredRowIterator.java | 98 ++ .../cassandra/db/rows/ArrayBackedRow.java | 927 +++++++++++++++++++ .../apache/cassandra/db/rows/BufferCell.java | 387 ++++++++ src/java/org/apache/cassandra/db/rows/Cell.java | 122 +-- .../org/apache/cassandra/db/rows/CellData.java | 275 ------ .../org/apache/cassandra/db/rows/CellPath.java | 50 +- .../org/apache/cassandra/db/rows/Cells.java | 163 +--- .../apache/cassandra/db/rows/ColumnData.java | 95 +- .../cassandra/db/rows/ComplexColumnData.java | 343 +++++++ .../cassandra/db/rows/ComplexRowDataBlock.java | 796 ---------------- .../apache/cassandra/db/rows/FilteringRow.java | 121 --- .../cassandra/db/rows/FilteringRowIterator.java | 126 --- .../cassandra/db/rows/MemtableRowData.java | 204 ---- .../db/rows/RangeTombstoneBoundMarker.java | 45 +- .../db/rows/RangeTombstoneBoundaryMarker.java | 44 +- .../cassandra/db/rows/RangeTombstoneMarker.java | 87 +- .../apache/cassandra/db/rows/ReusableRow.java | 104 --- src/java/org/apache/cassandra/db/rows/Row.java | 569 ++++++------ .../db/rows/RowAndDeletionMergeIterator.java | 191 ++++ .../db/rows/RowAndTombstoneMergeIterator.java | 171 ---- .../apache/cassandra/db/rows/RowDataBlock.java | 275 ------ .../cassandra/db/rows/RowDiffListener.java | 78 ++ .../apache/cassandra/db/rows/RowIterators.java | 24 +- .../org/apache/cassandra/db/rows/RowStats.java | 82 +- src/java/org/apache/cassandra/db/rows/Rows.java | 258 ++++-- .../cassandra/db/rows/SerializationHelper.java | 87 +- .../cassandra/db/rows/SimpleRowDataBlock.java | 188 ---- .../org/apache/cassandra/db/rows/StaticRow.java | 193 ---- .../db/rows/TombstoneFilteringRow.java | 55 -- .../apache/cassandra/db/rows/Unfiltered.java | 10 + .../rows/UnfilteredRowIteratorSerializer.java | 97 +- .../db/rows/UnfilteredRowIterators.java | 345 ++----- .../cassandra/db/rows/UnfilteredSerializer.java | 489 ++++------ .../apache/cassandra/db/rows/WrappingRow.java | 214 ----- .../db/rows/WrappingUnfilteredRowIterator.java | 21 +- .../cassandra/io/sstable/CQLSSTableWriter.java | 1 + .../io/sstable/SSTableIdentityIterator.java | 2 +- .../io/sstable/SSTableSimpleIterator.java | 28 +- .../io/sstable/SSTableSimpleUnsortedWriter.java | 86 +- .../io/sstable/format/big/BigTableWriter.java | 87 +- .../io/sstable/metadata/MetadataCollector.java | 38 +- .../cassandra/schema/LegacySchemaMigrator.java | 6 +- .../apache/cassandra/schema/SchemaKeyspace.java | 2 +- .../apache/cassandra/service/DataResolver.java | 115 +-- .../service/pager/RangeSliceQueryPager.java | 2 +- .../service/pager/SinglePartitionPager.java | 2 +- .../apache/cassandra/service/paxos/Commit.java | 50 +- .../cassandra/streaming/StreamReader.java | 25 +- .../cassandra/thrift/CassandraServer.java | 154 +-- .../cassandra/thrift/ThriftConversion.java | 7 +- .../cassandra/thrift/ThriftResultsMerger.java | 123 +-- .../apache/cassandra/utils/ByteBufferUtil.java | 31 + .../org/apache/cassandra/utils/ObjectSizes.java | 3 + .../org/apache/cassandra/utils/Sorting.java | 254 ----- .../utils/memory/AbstractAllocator.java | 33 + .../utils/memory/MemtableAllocator.java | 17 +- .../utils/memory/MemtableBufferAllocator.java | 78 +- .../cassandra/utils/memory/NativeAllocator.java | 10 +- test/data/corrupt-sstables/la-1-big-CRC.db | Bin 8 -> 8 bytes test/data/corrupt-sstables/la-1-big-Data.db | Bin 280 -> 259 bytes .../corrupt-sstables/la-1-big-Digest.adler32 | 2 +- test/data/corrupt-sstables/la-1-big-Index.db | Bin 105 -> 105 bytes .../corrupt-sstables/la-1-big-Statistics.db | Bin 4649 -> 4645 bytes test/data/corrupt-sstables/la-1-big-TOC.txt | 8 +- .../db/commitlog/CommitLogStressTest.java | 2 +- .../unit/org/apache/cassandra/SchemaLoader.java | 2 +- test/unit/org/apache/cassandra/Util.java | 20 +- .../cassandra/cache/AutoSavingCacheTest.java | 2 +- .../cassandra/config/ColumnDefinitionTest.java | 4 +- .../cassandra/cql3/ColumnConditionTest.java | 75 +- .../apache/cassandra/cql3/SimpleQueryTest.java | 4 +- test/unit/org/apache/cassandra/db/CellTest.java | 73 +- .../cassandra/db/ColumnFamilyStoreTest.java | 4 +- .../org/apache/cassandra/db/CommitLogTest.java | 16 +- .../apache/cassandra/db/CounterCellTest.java | 178 ++-- .../org/apache/cassandra/db/KeyspaceTest.java | 4 +- .../cassandra/db/RangeTombstoneListTest.java | 10 +- .../apache/cassandra/db/RangeTombstoneTest.java | 25 +- .../apache/cassandra/db/ReadMessageTest.java | 2 +- .../db/RecoveryManagerMissingHeaderTest.java | 4 +- .../cassandra/db/RecoveryManagerTest.java | 4 +- .../org/apache/cassandra/db/RowCacheTest.java | 20 +- test/unit/org/apache/cassandra/db/RowTest.java | 44 +- .../unit/org/apache/cassandra/db/ScrubTest.java | 3 +- .../db/commitlog/CommitLogUpgradeTest.java | 3 +- .../rows/RowAndDeletionMergeIteratorTest.java | 407 ++++++++ .../rows/RowAndTombstoneMergeIteratorTest.java | 415 --------- .../rows/UnfilteredRowIteratorsMergeTest.java | 198 +--- .../cassandra/io/sstable/IndexHelperTest.java | 4 +- .../cassandra/io/sstable/SSTableLoaderTest.java | 5 +- .../cassandra/io/sstable/SSTableReaderTest.java | 2 +- .../io/sstable/SSTableRewriterTest.java | 26 +- .../org/apache/cassandra/schema/DefsTest.java | 8 +- .../cassandra/service/DataResolverTest.java | 10 +- .../cassandra/triggers/TriggerExecutorTest.java | 26 +- 195 files changed, 7554 insertions(+), 11165 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/config/CFMetaData.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/config/CFMetaData.java b/src/java/org/apache/cassandra/config/CFMetaData.java index 3b43960..fbfb7fa 100644 --- a/src/java/org/apache/cassandra/config/CFMetaData.java +++ b/src/java/org/apache/cassandra/config/CFMetaData.java @@ -715,7 +715,7 @@ public final class CFMetaData // it means that it's a dropped column from before 3.0, and in that case using // BytesType is fine for what we'll be using it for, even if that's a hack. AbstractType<?> type = dropped.type == null ? BytesType.instance : dropped.type; - return ColumnDefinition.regularDef(this, name, type, null); + return ColumnDefinition.regularDef(this, name, type); } @Override http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/config/ColumnDefinition.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/config/ColumnDefinition.java b/src/java/org/apache/cassandra/config/ColumnDefinition.java index 432d5a8..54a00f5 100644 --- a/src/java/org/apache/cassandra/config/ColumnDefinition.java +++ b/src/java/org/apache/cassandra/config/ColumnDefinition.java @@ -70,7 +70,6 @@ public class ColumnDefinition extends ColumnSpecification implements Comparable< private final Integer componentIndex; private final Comparator<CellPath> cellPathComparator; - private final Comparator<Cell> cellComparator; /** * These objects are compared frequently, so we encode several of their comparison components @@ -103,19 +102,19 @@ public class ColumnDefinition extends ColumnSpecification implements Comparable< return new ColumnDefinition(ksName, cfName, ColumnIdentifier.getInterned(name, true), validator, null, null, null, componentIndex, Kind.CLUSTERING); } - public static ColumnDefinition regularDef(CFMetaData cfm, ByteBuffer name, AbstractType<?> validator, Integer componentIndex) + public static ColumnDefinition regularDef(CFMetaData cfm, ByteBuffer name, AbstractType<?> validator) { - return new ColumnDefinition(cfm, name, validator, componentIndex, Kind.REGULAR); + return new ColumnDefinition(cfm, name, validator, null, Kind.REGULAR); } - public static ColumnDefinition regularDef(String ksName, String cfName, String name, AbstractType<?> validator, Integer componentIndex) + public static ColumnDefinition regularDef(String ksName, String cfName, String name, AbstractType<?> validator) { - return new ColumnDefinition(ksName, cfName, ColumnIdentifier.getInterned(name, true), validator, null, null, null, componentIndex, Kind.REGULAR); + return new ColumnDefinition(ksName, cfName, ColumnIdentifier.getInterned(name, true), validator, null, null, null, null, Kind.REGULAR); } - public static ColumnDefinition staticDef(CFMetaData cfm, ByteBuffer name, AbstractType<?> validator, Integer componentIndex) + public static ColumnDefinition staticDef(CFMetaData cfm, ByteBuffer name, AbstractType<?> validator) { - return new ColumnDefinition(cfm, name, validator, componentIndex, Kind.STATIC); + return new ColumnDefinition(cfm, name, validator, null, Kind.STATIC); } public ColumnDefinition(CFMetaData cfm, ByteBuffer name, AbstractType<?> validator, Integer componentIndex, Kind kind) @@ -150,12 +149,13 @@ public class ColumnDefinition extends ColumnSpecification implements Comparable< super(ksName, cfName, name, validator); assert name != null && validator != null && kind != null; assert name.isInterned(); + assert componentIndex == null || kind.isPrimaryKeyKind(); // The componentIndex really only make sense for partition and clustering columns, + // so make sure we don't sneak it for something else since it'd breaks equals() this.kind = kind; this.indexName = indexName; this.componentIndex = componentIndex; this.setIndexType(indexType, indexOptions); this.cellPathComparator = makeCellPathComparator(kind, validator); - this.cellComparator = makeCellComparator(cellPathComparator); this.comparisonOrder = comparisonOrder(kind, isComplex(), position()); } @@ -185,21 +185,6 @@ public class ColumnDefinition extends ColumnSpecification implements Comparable< }; } - private static Comparator<Cell> makeCellComparator(final Comparator<CellPath> cellPathComparator) - { - return new Comparator<Cell>() - { - public int compare(Cell c1, Cell c2) - { - int cmp = c1.column().compareTo(c2.column()); - if (cmp != 0 || cellPathComparator == null) - return cmp; - - return cellPathComparator.compare(c1.path(), c2.path()); - } - }; - } - public ColumnDefinition copy() { return new ColumnDefinition(ksName, cfName, name, type, indexType, indexOptions, indexName, componentIndex, kind); @@ -422,14 +407,14 @@ public class ColumnDefinition extends ColumnSpecification implements Comparable< return cellPathComparator; } - public Comparator<Cell> cellComparator() + public boolean isComplex() { - return cellComparator; + return cellPathComparator != null; } - public boolean isComplex() + public boolean isSimple() { - return cellPathComparator != null; + return !isComplex(); } public CellPath.Serializer cellPathSerializer() http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/ColumnCondition.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/ColumnCondition.java b/src/java/org/apache/cassandra/cql3/ColumnCondition.java index 50f79f4..0c2ea2a 100644 --- a/src/java/org/apache/cassandra/cql3/ColumnCondition.java +++ b/src/java/org/apache/cassandra/cql3/ColumnCondition.java @@ -38,7 +38,6 @@ import static com.google.common.collect.Lists.newArrayList; */ public class ColumnCondition { - public final ColumnDefinition column; // For collection, when testing the equality of a specific element, null otherwise. @@ -210,7 +209,11 @@ public class ColumnCondition { // If we're asking for a complex cells, and we didn't got any row from our read, it's // the same as not having any cells for that column. - return row == null ? Collections.<Cell>emptyIterator() : row.getCells(column); + if (row == null) + return Collections.<Cell>emptyIterator(); + + ComplexColumnData complexData = row.getComplexColumnData(column); + return complexData == null ? Collections.<Cell>emptyIterator() : complexData.iterator(); } /** http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/Constants.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/Constants.java b/src/java/org/apache/cassandra/cql3/Constants.java index 859b1b5..f10484d 100644 --- a/src/java/org/apache/cassandra/cql3/Constants.java +++ b/src/java/org/apache/cassandra/cql3/Constants.java @@ -23,7 +23,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.db.*; -import org.apache.cassandra.db.rows.*; import org.apache.cassandra.db.marshal.AbstractType; import org.apache.cassandra.db.marshal.BytesType; import org.apache.cassandra.db.marshal.CounterColumnType; @@ -318,13 +317,13 @@ public abstract class Constants super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { ByteBuffer value = t.bindAndGet(params.options); if (value == null) - params.addTombstone(column, writer); + params.addTombstone(column); else if (value != ByteBufferUtil.UNSET_BYTE_BUFFER) // use reference equality and not object equality - params.addCell(clustering, column, writer, value); + params.addCell(column, value); } } @@ -335,7 +334,7 @@ public abstract class Constants super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { ByteBuffer bytes = t.bindAndGet(params.options); if (bytes == null) @@ -344,7 +343,7 @@ public abstract class Constants return; long increment = ByteBufferUtil.toLong(bytes); - params.addCounter(column, writer, increment); + params.addCounter(column, increment); } } @@ -355,7 +354,7 @@ public abstract class Constants super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { ByteBuffer bytes = t.bindAndGet(params.options); if (bytes == null) @@ -367,7 +366,7 @@ public abstract class Constants if (increment == Long.MIN_VALUE) throw new InvalidRequestException("The negation of " + increment + " overflows supported counter precision (signed 8 bytes integer)"); - params.addCounter(column, writer, -increment); + params.addCounter(column, -increment); } } @@ -380,12 +379,12 @@ public abstract class Constants super(column, null); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { if (column.type.isMultiCell()) - params.setComplexDeletionTime(column, writer); + params.setComplexDeletionTime(column); else - params.addTombstone(column, writer); + params.addTombstone(column); } - }; + } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/Lists.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/Lists.java b/src/java/org/apache/cassandra/cql3/Lists.java index 5da2b37..d9dac22 100644 --- a/src/java/org/apache/cassandra/cql3/Lists.java +++ b/src/java/org/apache/cassandra/cql3/Lists.java @@ -21,12 +21,9 @@ import static org.apache.cassandra.cql3.Constants.UNSET_VALUE; import java.nio.ByteBuffer; import java.util.ArrayList; -import java.util.Iterator; import java.util.List; import java.util.concurrent.atomic.AtomicReference; -import com.google.common.collect.Iterators; - import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.cql3.functions.Function; import org.apache.cassandra.db.*; @@ -72,7 +69,7 @@ public abstract class Lists validateAssignableTo(keyspace, receiver); ColumnSpecification valueSpec = Lists.valueSpecOf(receiver); - List<Term> values = new ArrayList<Term>(elements.size()); + List<Term> values = new ArrayList<>(elements.size()); boolean allTerminal = true; for (Term.Raw rt : elements) { @@ -300,7 +297,7 @@ public abstract class Lists super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { Term.Terminal value = t.bind(params.options); if (value == UNSET_VALUE) @@ -308,8 +305,8 @@ public abstract class Lists // delete + append if (column.type.isMultiCell()) - params.setComplexDeletionTimeForOverwrite(column, writer); - Appender.doAppend(value, clustering, writer, column, params); + params.setComplexDeletionTimeForOverwrite(column); + Appender.doAppend(value, column, params); } } @@ -318,17 +315,8 @@ public abstract class Lists if (row == null) return 0; - Iterator<Cell> cells = row.getCells(column); - return cells == null ? 0 : Iterators.size(cells); - } - - private static Cell existingElement(Row row, ColumnDefinition column, int idx) - { - assert row != null; - Iterator<Cell> cells = row.getCells(column); - assert cells != null; - - return Iterators.get(cells, idx); + ComplexColumnData complexData = row.getComplexColumnData(column); + return complexData == null ? 0 : complexData.cellsCount(); } public static class SetterByIndex extends Operation @@ -354,7 +342,7 @@ public abstract class Lists idx.collectMarkerSpecification(boundNames); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { // we should not get here for frozen lists assert column.type.isMultiCell() : "Attempted to set an individual element on a frozen list"; @@ -367,7 +355,7 @@ public abstract class Lists if (index == ByteBufferUtil.UNSET_BYTE_BUFFER) throw new InvalidRequestException("Invalid unset value for list index"); - Row existingRow = params.getPrefetchedRow(partitionKey, clustering); + Row existingRow = params.getPrefetchedRow(partitionKey, params.currentClustering()); int existingSize = existingSize(existingRow, column); int idx = ByteBufferUtil.toInt(index); if (existingSize == 0) @@ -375,10 +363,10 @@ public abstract class Lists if (idx < 0 || idx >= existingSize) throw new InvalidRequestException(String.format("List index %d out of bound, list has size %d", idx, existingSize)); - CellPath elementPath = existingElement(existingRow, column, idx).path(); + CellPath elementPath = existingRow.getComplexColumnData(column).getCellByIndex(idx).path(); if (value == null) { - params.addTombstone(column, writer); + params.addTombstone(column); } else if (value != ByteBufferUtil.UNSET_BYTE_BUFFER) { @@ -388,7 +376,7 @@ public abstract class Lists FBUtilities.MAX_UNSIGNED_SHORT, value.remaining())); - params.addCell(clustering, column, writer, elementPath, value); + params.addCell(column, elementPath, value); } } } @@ -400,14 +388,14 @@ public abstract class Lists super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { assert column.type.isMultiCell() : "Attempted to append to a frozen list"; Term.Terminal value = t.bind(params.options); - doAppend(value, clustering, writer, column, params); + doAppend(value, column, params); } - static void doAppend(Term.Terminal value, Clustering clustering, Row.Writer writer, ColumnDefinition column, UpdateParameters params) throws InvalidRequestException + static void doAppend(Term.Terminal value, ColumnDefinition column, UpdateParameters params) throws InvalidRequestException { if (column.type.isMultiCell()) { @@ -419,16 +407,16 @@ public abstract class Lists for (ByteBuffer buffer : ((Value) value).elements) { ByteBuffer uuid = ByteBuffer.wrap(UUIDGen.getTimeUUIDBytes()); - params.addCell(clustering, column, writer, CellPath.create(uuid), buffer); + params.addCell(column, CellPath.create(uuid), buffer); } } else { // for frozen lists, we're overwriting the whole cell value if (value == null) - params.addTombstone(column, writer); + params.addTombstone(column); else - params.addCell(clustering, column, writer, value.get(Server.CURRENT_VERSION)); + params.addCell(column, value.get(Server.CURRENT_VERSION)); } } } @@ -440,7 +428,7 @@ public abstract class Lists super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { assert column.type.isMultiCell() : "Attempted to prepend to a frozen list"; Term.Terminal value = t.bind(params.options); @@ -454,7 +442,7 @@ public abstract class Lists { PrecisionTime pt = PrecisionTime.getNext(time); ByteBuffer uuid = ByteBuffer.wrap(UUIDGen.getTimeUUIDBytes(pt.millis, pt.nanos)); - params.addCell(clustering, column, writer, CellPath.create(uuid), toAdd.get(i)); + params.addCell(column, CellPath.create(uuid), toAdd.get(i)); } } } @@ -472,16 +460,16 @@ public abstract class Lists return true; } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { assert column.type.isMultiCell() : "Attempted to delete from a frozen list"; // We want to call bind before possibly returning to reject queries where the value provided is not a list. Term.Terminal value = t.bind(params.options); - Row existingRow = params.getPrefetchedRow(partitionKey, clustering); - Iterator<Cell> cells = existingRow == null ? null : existingRow.getCells(column); - if (value == null || value == UNSET_VALUE || cells == null) + Row existingRow = params.getPrefetchedRow(partitionKey, params.currentClustering()); + ComplexColumnData complexData = existingRow == null ? null : existingRow.getComplexColumnData(column); + if (value == null || value == UNSET_VALUE || complexData == null) return; // Note: below, we will call 'contains' on this toDiscard list for each element of existingList. @@ -489,11 +477,10 @@ public abstract class Lists // the read-before-write this operation requires limits its usefulness on big lists, so in practice // toDiscard will be small and keeping a list will be more efficient. List<ByteBuffer> toDiscard = ((Value)value).elements; - while (cells.hasNext()) + for (Cell cell : complexData) { - Cell cell = cells.next(); if (toDiscard.contains(cell.value())) - params.addTombstone(column, writer, cell.path()); + params.addTombstone(column, cell.path()); } } } @@ -511,7 +498,7 @@ public abstract class Lists return true; } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { assert column.type.isMultiCell() : "Attempted to delete an item by index from a frozen list"; Term.Terminal index = t.bind(params.options); @@ -520,7 +507,7 @@ public abstract class Lists if (index == Constants.UNSET_VALUE) return; - Row existingRow = params.getPrefetchedRow(partitionKey, clustering); + Row existingRow = params.getPrefetchedRow(partitionKey, params.currentClustering()); int existingSize = existingSize(existingRow, column); int idx = ByteBufferUtil.toInt(index.get(params.options.getProtocolVersion())); if (existingSize == 0) @@ -528,7 +515,7 @@ public abstract class Lists if (idx < 0 || idx >= existingSize) throw new InvalidRequestException(String.format("List index %d out of bound, list has size %d", idx, existingSize)); - params.addTombstone(column, writer, existingElement(existingRow, column, idx).path()); + params.addTombstone(column, existingRow.getComplexColumnData(column).getCellByIndex(idx).path()); } } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/Maps.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/Maps.java b/src/java/org/apache/cassandra/cql3/Maps.java index 2644108..0f0672f 100644 --- a/src/java/org/apache/cassandra/cql3/Maps.java +++ b/src/java/org/apache/cassandra/cql3/Maps.java @@ -26,7 +26,6 @@ import com.google.common.collect.Iterables; import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.cql3.functions.Function; -import org.apache.cassandra.db.Clustering; import org.apache.cassandra.db.DecoratedKey; import org.apache.cassandra.db.rows.*; import org.apache.cassandra.db.marshal.MapType; @@ -290,7 +289,7 @@ public abstract class Maps super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { Term.Terminal value = t.bind(params.options); if (value == UNSET_VALUE) @@ -298,8 +297,8 @@ public abstract class Maps // delete + put if (column.type.isMultiCell()) - params.setComplexDeletionTimeForOverwrite(column, writer); - Putter.doPut(value, clustering, writer, column, params); + params.setComplexDeletionTimeForOverwrite(column); + Putter.doPut(value, column, params); } } @@ -320,7 +319,7 @@ public abstract class Maps k.collectMarkerSpecification(boundNames); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { assert column.type.isMultiCell() : "Attempted to set a value for a single key on a frozen map"; ByteBuffer key = k.bindAndGet(params.options); @@ -334,7 +333,7 @@ public abstract class Maps if (value == null) { - params.addTombstone(column, writer, path); + params.addTombstone(column, path); } else if (value != ByteBufferUtil.UNSET_BYTE_BUFFER) { @@ -344,7 +343,7 @@ public abstract class Maps FBUtilities.MAX_UNSIGNED_SHORT, value.remaining())); - params.addCell(clustering, column, writer, path, value); + params.addCell(column, path, value); } } } @@ -356,15 +355,15 @@ public abstract class Maps super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { assert column.type.isMultiCell() : "Attempted to add items to a frozen map"; Term.Terminal value = t.bind(params.options); if (value != UNSET_VALUE) - doPut(value, clustering, writer, column, params); + doPut(value, column, params); } - static void doPut(Term.Terminal value, Clustering clustering, Row.Writer writer, ColumnDefinition column, UpdateParameters params) throws InvalidRequestException + static void doPut(Term.Terminal value, ColumnDefinition column, UpdateParameters params) throws InvalidRequestException { if (column.type.isMultiCell()) { @@ -373,15 +372,15 @@ public abstract class Maps Map<ByteBuffer, ByteBuffer> elements = ((Value) value).map; for (Map.Entry<ByteBuffer, ByteBuffer> entry : elements.entrySet()) - params.addCell(clustering, column, writer, CellPath.create(entry.getKey()), entry.getValue()); + params.addCell(column, CellPath.create(entry.getKey()), entry.getValue()); } else { // for frozen maps, we're overwriting the whole cell if (value == null) - params.addTombstone(column, writer); + params.addTombstone(column); else - params.addCell(clustering, column, writer, value.get(Server.CURRENT_VERSION)); + params.addCell(column, value.get(Server.CURRENT_VERSION)); } } } @@ -393,7 +392,7 @@ public abstract class Maps super(column, k); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { assert column.type.isMultiCell() : "Attempted to delete a single key in a frozen map"; Term.Terminal key = t.bind(params.options); @@ -402,7 +401,7 @@ public abstract class Maps if (key == Constants.UNSET_VALUE) throw new InvalidRequestException("Invalid unset map key"); - params.addTombstone(column, writer, CellPath.create(key.get(params.options.getProtocolVersion()))); + params.addTombstone(column, CellPath.create(key.get(params.options.getProtocolVersion()))); } } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/Operation.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/Operation.java b/src/java/org/apache/cassandra/cql3/Operation.java index 5e72e7f..51c8969 100644 --- a/src/java/org/apache/cassandra/cql3/Operation.java +++ b/src/java/org/apache/cassandra/cql3/Operation.java @@ -21,9 +21,7 @@ import java.util.Collections; import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.cql3.functions.Function; -import org.apache.cassandra.db.Clustering; import org.apache.cassandra.db.DecoratedKey; -import org.apache.cassandra.db.rows.Row; import org.apache.cassandra.db.marshal.*; import org.apache.cassandra.exceptions.InvalidRequestException; @@ -87,11 +85,9 @@ public abstract class Operation * Execute the operation. * * @param partitionKey partition key for the update. - * @param clustering the clustering for the row on which the operation applies - * @param writer the row update to which to add the updates generated by this operation. * @param params parameters of the update. */ - public abstract void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException; + public abstract void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException; /** * A parsed raw UPDATE operation. http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/Sets.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/Sets.java b/src/java/org/apache/cassandra/cql3/Sets.java index c03005d..7ff3815 100644 --- a/src/java/org/apache/cassandra/cql3/Sets.java +++ b/src/java/org/apache/cassandra/cql3/Sets.java @@ -26,7 +26,6 @@ import com.google.common.base.Joiner; import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.cql3.functions.Function; -import org.apache.cassandra.db.Clustering; import org.apache.cassandra.db.DecoratedKey; import org.apache.cassandra.db.rows.*; import org.apache.cassandra.db.marshal.*; @@ -257,7 +256,7 @@ public abstract class Sets super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { Term.Terminal value = t.bind(params.options); if (value == UNSET_VALUE) @@ -265,8 +264,8 @@ public abstract class Sets // delete + add if (column.type.isMultiCell()) - params.setComplexDeletionTimeForOverwrite(column, writer); - Adder.doAdd(value, clustering, writer, column, params); + params.setComplexDeletionTimeForOverwrite(column); + Adder.doAdd(value, column, params); } } @@ -277,15 +276,15 @@ public abstract class Sets super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { assert column.type.isMultiCell() : "Attempted to add items to a frozen set"; Term.Terminal value = t.bind(params.options); if (value != UNSET_VALUE) - doAdd(value, clustering, writer, column, params); + doAdd(value, column, params); } - static void doAdd(Term.Terminal value, Clustering clustering, Row.Writer writer, ColumnDefinition column, UpdateParameters params) throws InvalidRequestException + static void doAdd(Term.Terminal value, ColumnDefinition column, UpdateParameters params) throws InvalidRequestException { if (column.type.isMultiCell()) { @@ -297,16 +296,16 @@ public abstract class Sets if (bb == ByteBufferUtil.UNSET_BYTE_BUFFER) continue; - params.addCell(clustering, column, writer, CellPath.create(bb), ByteBufferUtil.EMPTY_BYTE_BUFFER); + params.addCell(column, CellPath.create(bb), ByteBufferUtil.EMPTY_BYTE_BUFFER); } } else { // for frozen sets, we're overwriting the whole cell if (value == null) - params.addTombstone(column, writer); + params.addTombstone(column); else - params.addCell(clustering, column, writer, value.get(Server.CURRENT_VERSION)); + params.addCell(column, value.get(Server.CURRENT_VERSION)); } } } @@ -319,7 +318,7 @@ public abstract class Sets super(column, t); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { assert column.type.isMultiCell() : "Attempted to remove items from a frozen set"; @@ -333,7 +332,7 @@ public abstract class Sets : Collections.singleton(value.get(params.options.getProtocolVersion())); for (ByteBuffer bb : toDiscard) - params.addTombstone(column, writer, CellPath.create(bb)); + params.addTombstone(column, CellPath.create(bb)); } } @@ -344,14 +343,14 @@ public abstract class Sets super(column, k); } - public void execute(DecoratedKey partitionKey, Clustering clustering, Row.Writer writer, UpdateParameters params) throws InvalidRequestException + public void execute(DecoratedKey partitionKey, UpdateParameters params) throws InvalidRequestException { assert column.type.isMultiCell() : "Attempted to delete a single element in a frozen set"; Term.Terminal elt = t.bind(params.options); if (elt == null) throw new InvalidRequestException("Invalid null set element"); - params.addTombstone(column, writer, CellPath.create(elt.get(params.options.getProtocolVersion()))); + params.addTombstone(column, CellPath.create(elt.get(params.options.getProtocolVersion()))); } } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/UntypedResultSet.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/UntypedResultSet.java b/src/java/org/apache/cassandra/cql3/UntypedResultSet.java index 978cb96..97ab60a 100644 --- a/src/java/org/apache/cassandra/cql3/UntypedResultSet.java +++ b/src/java/org/apache/cassandra/cql3/UntypedResultSet.java @@ -234,18 +234,18 @@ public abstract class UntypedResultSet implements Iterable<UntypedResultSet.Row> for (ColumnDefinition def : metadata.partitionColumns()) { - if (def.isComplex()) - { - Iterator<Cell> cells = row.getCells(def); - if (cells != null) - data.put(def.name.toString(), ((CollectionType)def.type).serializeForNativeProtocol(def, cells, Server.VERSION_3)); - } - else + if (def.isSimple()) { Cell cell = row.getCell(def); if (cell != null) data.put(def.name.toString(), cell.value()); } + else + { + ComplexColumnData complexData = row.getComplexColumnData(def); + if (complexData != null) + data.put(def.name.toString(), ((CollectionType)def.type).serializeForNativeProtocol(def, complexData.iterator(), Server.VERSION_3)); + } } return new Row(data); http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/UpdateParameters.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/UpdateParameters.java b/src/java/org/apache/cassandra/cql3/UpdateParameters.java index 66f6b43..8dcb7e5 100644 --- a/src/java/org/apache/cassandra/cql3/UpdateParameters.java +++ b/src/java/org/apache/cassandra/cql3/UpdateParameters.java @@ -29,19 +29,21 @@ import org.apache.cassandra.db.context.CounterContext; import org.apache.cassandra.db.index.SecondaryIndexManager; import org.apache.cassandra.db.partitions.*; import org.apache.cassandra.exceptions.InvalidRequestException; -import org.apache.cassandra.utils.ByteBufferUtil; import org.apache.cassandra.utils.FBUtilities; /** - * A simple container that simplify passing parameters for collections methods. + * Groups the parameters of an update query, and make building updates easier. */ public class UpdateParameters { public final CFMetaData metadata; + public final PartitionColumns updatedColumns; public final QueryOptions options; - private final LivenessInfo defaultLiveness; - private final LivenessInfo deletionLiveness; + private final int nowInSec; + private final long timestamp; + private final int ttl; + private final DeletionTime deletionTime; private final SecondaryIndexManager indexManager; @@ -49,16 +51,30 @@ public class UpdateParameters // For lists operation that require a read-before-write. Will be null otherwise. private final Map<DecoratedKey, Partition> prefetchedRows; - public UpdateParameters(CFMetaData metadata, QueryOptions options, long timestamp, int ttl, Map<DecoratedKey, Partition> prefetchedRows, boolean validateIndexedColumns) + private Row.Builder staticBuilder; + private Row.Builder regularBuilder; + + // The builder currently in use. Will alias either staticBuilder or regularBuilder, which are themselves built lazily. + private Row.Builder builder; + + public UpdateParameters(CFMetaData metadata, + PartitionColumns updatedColumns, + QueryOptions options, + long timestamp, + int ttl, + Map<DecoratedKey, Partition> prefetchedRows, + boolean validateIndexedColumns) throws InvalidRequestException { this.metadata = metadata; + this.updatedColumns = updatedColumns; this.options = options; - int nowInSec = FBUtilities.nowInSeconds(); - this.defaultLiveness = SimpleLivenessInfo.forUpdate(timestamp, ttl, nowInSec, metadata); - this.deletionLiveness = SimpleLivenessInfo.forDeletion(timestamp, nowInSec); - this.deletionTime = new SimpleDeletionTime(timestamp, nowInSec); + this.nowInSec = FBUtilities.nowInSeconds(); + this.timestamp = timestamp; + this.ttl = ttl; + + this.deletionTime = new DeletionTime(timestamp, nowInSec); this.prefetchedRows = prefetchedRows; @@ -85,7 +101,7 @@ public class UpdateParameters indexManager.validate(partitionKey); } - public void writeClustering(Clustering clustering, Row.Writer writer) throws InvalidRequestException + public void newRow(Clustering clustering) throws InvalidRequestException { if (indexManager != null) indexManager.validate(clustering); @@ -101,66 +117,93 @@ public class UpdateParameters throw new InvalidRequestException("Invalid empty or null value for column " + metadata.clusteringColumns().get(0).name); } - Rows.writeClustering(clustering, writer); + if (clustering == Clustering.STATIC_CLUSTERING) + { + if (staticBuilder == null) + staticBuilder = ArrayBackedRow.unsortedBuilder(updatedColumns.statics, nowInSec); + builder = staticBuilder; + } + else + { + if (regularBuilder == null) + regularBuilder = ArrayBackedRow.unsortedBuilder(updatedColumns.regulars, nowInSec); + builder = regularBuilder; + } + + builder.newRow(clustering); + } + + public Clustering currentClustering() + { + return builder.clustering(); } - public void writePartitionKeyLivenessInfo(Row.Writer writer) + public void addPrimaryKeyLivenessInfo() { - writer.writePartitionKeyLivenessInfo(defaultLiveness); + builder.addPrimaryKeyLivenessInfo(LivenessInfo.create(metadata, timestamp, ttl, nowInSec)); } - public void writeRowDeletion(Row.Writer writer) + public void addRowDeletion() { - writer.writeRowDeletion(deletionTime); + builder.addRowDeletion(deletionTime); } - public void addTombstone(ColumnDefinition column, Row.Writer writer) throws InvalidRequestException + public void addTombstone(ColumnDefinition column) throws InvalidRequestException { - addTombstone(column, writer, null); + addTombstone(column, null); } - public void addTombstone(ColumnDefinition column, Row.Writer writer, CellPath path) throws InvalidRequestException + public void addTombstone(ColumnDefinition column, CellPath path) throws InvalidRequestException { - writer.writeCell(column, false, ByteBufferUtil.EMPTY_BYTE_BUFFER, deletionLiveness, path); + builder.addCell(BufferCell.tombstone(column, timestamp, nowInSec, path)); } - public void addCell(Clustering clustering, ColumnDefinition column, Row.Writer writer, ByteBuffer value) throws InvalidRequestException + public void addCell(ColumnDefinition column, ByteBuffer value) throws InvalidRequestException { - addCell(clustering, column, writer, null, value); + addCell(column, null, value); } - public void addCell(Clustering clustering, ColumnDefinition column, Row.Writer writer, CellPath path, ByteBuffer value) throws InvalidRequestException + public void addCell(ColumnDefinition column, CellPath path, ByteBuffer value) throws InvalidRequestException { if (indexManager != null) indexManager.validate(column, value, path); - writer.writeCell(column, false, value, defaultLiveness, path); + Cell cell = ttl == LivenessInfo.NO_TTL + ? BufferCell.live(metadata, column, timestamp, value, path) + : BufferCell.expiring(column, timestamp, ttl, nowInSec, value, path); + builder.addCell(cell); } - public void addCounter(ColumnDefinition column, Row.Writer writer, long increment) throws InvalidRequestException + public void addCounter(ColumnDefinition column, long increment) throws InvalidRequestException { - assert defaultLiveness.ttl() == LivenessInfo.NO_TTL; + assert ttl == LivenessInfo.NO_TTL; // In practice, the actual CounterId (and clock really) that we use doesn't matter, because we will - // actually ignore it in CounterMutation when we do the read-before-write to create the actual value - // that is applied. In other words, this is not the actual value that will be written to the memtable + // ignore it in CounterMutation when we do the read-before-write to create the actual value that is + // applied. In other words, this is not the actual value that will be written to the memtable // because this will be replaced in CounterMutation.updateWithCurrentValue(). // As an aside, since we don't care about the CounterId/clock, we used to only send the incremement, // but that makes things a bit more complex as this means we need to be able to distinguish inside // PartitionUpdate between counter updates that has been processed by CounterMutation and those that // haven't. - ByteBuffer value = CounterContext.instance().createLocal(increment); - writer.writeCell(column, true, value, defaultLiveness, null); + builder.addCell(BufferCell.live(metadata, column, timestamp, CounterContext.instance().createLocal(increment))); + } + + public void setComplexDeletionTime(ColumnDefinition column) + { + builder.addComplexDeletion(column, deletionTime); } - public void setComplexDeletionTime(ColumnDefinition column, Row.Writer writer) + public void setComplexDeletionTimeForOverwrite(ColumnDefinition column) { - writer.writeComplexDeletion(column, deletionTime); + builder.addComplexDeletion(column, new DeletionTime(deletionTime.markedForDeleteAt() - 1, deletionTime.localDeletionTime())); } - public void setComplexDeletionTimeForOverwrite(ColumnDefinition column, Row.Writer writer) + public Row buildRow() { - writer.writeComplexDeletion(column, new SimpleDeletionTime(deletionTime.markedForDeleteAt() - 1, deletionTime.localDeletionTime())); + Row built = builder.build(); + builder = null; // Resetting to null just so we quickly bad usage where we forget to call newRow() after that. + return built; } public DeletionTime deletionTime() http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/selection/Selection.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/selection/Selection.java b/src/java/org/apache/cassandra/cql3/selection/Selection.java index 6a68598..bbb8b25 100644 --- a/src/java/org/apache/cassandra/cql3/selection/Selection.java +++ b/src/java/org/apache/cassandra/cql3/selection/Selection.java @@ -307,10 +307,19 @@ public abstract class Selection current.add(value(c)); if (timestamps != null) - timestamps[current.size() - 1] = c.livenessInfo().timestamp(); + timestamps[current.size() - 1] = c.timestamp(); if (ttls != null) - ttls[current.size() - 1] = c.livenessInfo().remainingTTL(nowInSec); + ttls[current.size() - 1] = remainingTTL(c, nowInSec); + } + + private int remainingTTL(Cell c, int nowInSec) + { + if (!c.isExpiring()) + return -1; + + int remaining = c.localDeletionTime() - nowInSec; + return remaining >= 0 ? remaining : -1; } private ByteBuffer value(Cell c) http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/statements/AlterTableStatement.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/statements/AlterTableStatement.java b/src/java/org/apache/cassandra/cql3/statements/AlterTableStatement.java index ebd3d5b..c6ac7cc 100644 --- a/src/java/org/apache/cassandra/cql3/statements/AlterTableStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/AlterTableStatement.java @@ -141,10 +141,9 @@ public class AlterTableStatement extends SchemaAlteringStatement } } - Integer componentIndex = cfm.isCompound() ? cfm.comparator.size() : null; cfm.addColumnDefinition(isStatic - ? ColumnDefinition.staticDef(cfm, columnName.bytes, type, componentIndex) - : ColumnDefinition.regularDef(cfm, columnName.bytes, type, componentIndex)); + ? ColumnDefinition.staticDef(cfm, columnName.bytes, type) + : ColumnDefinition.regularDef(cfm, columnName.bytes, type)); break; case ALTER: http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/statements/CQL3CasRequest.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/statements/CQL3CasRequest.java b/src/java/org/apache/cassandra/cql3/statements/CQL3CasRequest.java index 9352930..dc70bd2 100644 --- a/src/java/org/apache/cassandra/cql3/statements/CQL3CasRequest.java +++ b/src/java/org/apache/cassandra/cql3/statements/CQL3CasRequest.java @@ -200,7 +200,7 @@ public class CQL3CasRequest implements CASRequest public void applyUpdates(FilteredPartition current, PartitionUpdate updates) throws InvalidRequestException { Map<DecoratedKey, Partition> map = stmt.requiresRead() ? Collections.<DecoratedKey, Partition>singletonMap(key, current) : null; - UpdateParameters params = new UpdateParameters(cfm, options, timestamp, stmt.getTimeToLive(options), map, true); + UpdateParameters params = new UpdateParameters(cfm, updates.columns(), options, timestamp, stmt.getTimeToLive(options), map, true); stmt.addUpdateForKey(updates, cbuilder, params); } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/statements/DeleteStatement.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/statements/DeleteStatement.java b/src/java/org/apache/cassandra/cql3/statements/DeleteStatement.java index b4d7853..5fdf023 100644 --- a/src/java/org/apache/cassandra/cql3/statements/DeleteStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/DeleteStatement.java @@ -26,7 +26,6 @@ import org.apache.cassandra.cql3.restrictions.Restriction; import org.apache.cassandra.config.CFMetaData; import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.db.*; -import org.apache.cassandra.db.rows.Row; import org.apache.cassandra.db.partitions.*; import org.apache.cassandra.exceptions.*; import org.apache.cassandra.utils.Pair; @@ -62,16 +61,14 @@ public class DeleteStatement extends ModificationStatement // ... or a row deletion ... else if (cbuilder.remainingCount() == 0) { - Clustering clustering = cbuilder.build(); - Row.Writer writer = update.writer(); - params.writeClustering(clustering, writer); - params.writeRowDeletion(writer); - writer.endOfRow(); + params.newRow(cbuilder.build()); + params.addRowDeletion(); + update.add(params.buildRow()); } // ... or a range of rows deletion. else { - update.addRangeTombstone(params.makeRangeTombstone(cbuilder)); + update.add(params.makeRangeTombstone(cbuilder)); } } else @@ -82,20 +79,18 @@ public class DeleteStatement extends ModificationStatement if (cbuilder.remainingCount() > 0) throw new InvalidRequestException(String.format("Primary key column '%s' must be specified in order to delete column '%s'", getFirstEmptyKey().name, regularDeletions.get(0).column.name)); - Clustering clustering = cbuilder.build(); - Row.Writer writer = update.writer(); - params.writeClustering(clustering, writer); + params.newRow(cbuilder.build()); for (Operation op : regularDeletions) - op.execute(update.partitionKey(), clustering, writer, params); - writer.endOfRow(); + op.execute(update.partitionKey(), params); + update.add(params.buildRow()); } if (!staticDeletions.isEmpty()) { - Row.Writer writer = update.staticWriter(); + params.newRow(Clustering.STATIC_CLUSTERING); for (Operation op : staticDeletions) - op.execute(update.partitionKey(), Clustering.STATIC_CLUSTERING, writer, params); - writer.endOfRow(); + op.execute(update.partitionKey(), params); + update.add(params.buildRow()); } } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java b/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java index ee493f5..e827309 100644 --- a/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/ModificationStatement.java @@ -816,7 +816,7 @@ public abstract class ModificationStatement implements CQLStatement { // Some lists operation requires reading Map<DecoratedKey, Partition> lists = readRequiredLists(keys, clustering, local, options.getConsistency()); - return new UpdateParameters(cfm, options, getTimestamp(now, options), getTimeToLive(options), lists, true); + return new UpdateParameters(cfm, updatedColumns(), options, getTimestamp(now, options), getTimeToLive(options), lists, true); } /** http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java index b55125a..1a7de37 100644 --- a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java @@ -594,7 +594,7 @@ public class SelectStatement implements CQLStatement ByteBuffer[] keyComponents = getComponents(cfm, partition.partitionKey()); - Row staticRow = partition.staticRow().takeAlias(); + Row staticRow = partition.staticRow(); // If there is no rows, then provided the select was a full partition selection // (i.e. not a 2ndary index search and there was no condition on clustering columns), // we want to include static columns and we're done. @@ -653,11 +653,11 @@ public class SelectStatement implements CQLStatement { // Collections are the only complex types we have so far assert def.type.isCollection() && def.type.isMultiCell(); - Iterator<Cell> cells = row.getCells(def); - if (cells == null) + ComplexColumnData complexData = row.getComplexColumnData(def); + if (complexData == null) result.add((ByteBuffer)null); else - result.add(((CollectionType)def.type).serializeForNativeProtocol(def, cells, protocolVersion)); + result.add(((CollectionType)def.type).serializeForNativeProtocol(def, complexData.iterator(), protocolVersion)); } else { http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/cql3/statements/UpdateStatement.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/cql3/statements/UpdateStatement.java b/src/java/org/apache/cassandra/cql3/statements/UpdateStatement.java index 6229019..c6bfc98 100644 --- a/src/java/org/apache/cassandra/cql3/statements/UpdateStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/UpdateStatement.java @@ -23,7 +23,6 @@ import org.apache.cassandra.cql3.*; import org.apache.cassandra.config.CFMetaData; import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.db.*; -import org.apache.cassandra.db.rows.*; import org.apache.cassandra.db.partitions.PartitionUpdate; import org.apache.cassandra.exceptions.*; import org.apache.cassandra.utils.ByteBufferUtil; @@ -54,16 +53,13 @@ public class UpdateStatement extends ModificationStatement if (updatesRegularRows()) { - Clustering clustering = cbuilder.build(); - Row.Writer writer = update.writer(); - params.writeClustering(clustering, writer); - + params.newRow(cbuilder.build()); // We update the row timestamp (ex-row marker) only on INSERT (#6782) // Further, COMPACT tables semantic differs from "CQL3" ones in that a row exists only if it has // a non-null column, so we don't want to set the row timestamp for them. if (type == StatementType.INSERT && cfm.isCQLTable()) - params.writePartitionKeyLivenessInfo(writer); + params.addPrimaryKeyLivenessInfo(); List<Operation> updates = getRegularOperations(); @@ -82,17 +78,17 @@ public class UpdateStatement extends ModificationStatement } for (Operation op : updates) - op.execute(update.partitionKey(), clustering, writer, params); + op.execute(update.partitionKey(), params); - writer.endOfRow(); + update.add(params.buildRow()); } if (updatesStaticRow()) { - Row.Writer writer = update.staticWriter(); + params.newRow(Clustering.STATIC_CLUSTERING); for (Operation op : getStaticOperations()) - op.execute(update.partitionKey(), Clustering.STATIC_CLUSTERING, writer, params); - writer.endOfRow(); + op.execute(update.partitionKey(), params); + update.add(params.buildRow()); } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/db/AbstractClusteringPrefix.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/AbstractClusteringPrefix.java b/src/java/org/apache/cassandra/db/AbstractClusteringPrefix.java index 9ea071d..2631b46 100644 --- a/src/java/org/apache/cassandra/db/AbstractClusteringPrefix.java +++ b/src/java/org/apache/cassandra/db/AbstractClusteringPrefix.java @@ -22,14 +22,48 @@ import java.security.MessageDigest; import java.util.Objects; import org.apache.cassandra.utils.FBUtilities; +import org.apache.cassandra.utils.ObjectSizes; public abstract class AbstractClusteringPrefix implements ClusteringPrefix { + protected static final ByteBuffer[] EMPTY_VALUES_ARRAY = new ByteBuffer[0]; + + private static final long EMPTY_SIZE = ObjectSizes.measure(new Clustering(EMPTY_VALUES_ARRAY)); + + protected final Kind kind; + protected final ByteBuffer[] values; + + protected AbstractClusteringPrefix(Kind kind, ByteBuffer[] values) + { + this.kind = kind; + this.values = values; + } + + public Kind kind() + { + return kind; + } + public ClusteringPrefix clustering() { return this; } + public int size() + { + return values.length; + } + + public ByteBuffer get(int i) + { + return values[i]; + } + + public ByteBuffer[] getRawValues() + { + return values; + } + public int dataSize() { int size = 0; @@ -47,22 +81,19 @@ public abstract class AbstractClusteringPrefix implements ClusteringPrefix { ByteBuffer bb = get(i); if (bb != null) - digest.update(bb.duplicate()); + digest.update(bb.duplicate()); } FBUtilities.updateWithByte(digest, kind().ordinal()); } - public void writeTo(Writer writer) + public long unsharedHeapSize() { - for (int i = 0; i < size(); i++) - writer.writeClusteringValue(get(i)); + return EMPTY_SIZE + ObjectSizes.sizeOnHeapOf(values); } - public long unsharedHeapSize() + public long unsharedHeapSizeExcludingData() { - // unsharedHeapSize is used inside the cache and in memtables. Implementations that are - // safe to use there (SimpleClustering, Slice.Bound.SimpleBound and MemtableRow.* classes) overwrite this. - throw new UnsupportedOperationException(); + return EMPTY_SIZE + ObjectSizes.sizeOnHeapExcludingData(values); } @Override http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/db/AbstractLivenessInfo.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/AbstractLivenessInfo.java b/src/java/org/apache/cassandra/db/AbstractLivenessInfo.java deleted file mode 100644 index 4f4b5d1..0000000 --- a/src/java/org/apache/cassandra/db/AbstractLivenessInfo.java +++ /dev/null @@ -1,164 +0,0 @@ -/* - * 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.util.Objects; -import java.security.MessageDigest; - -import org.apache.cassandra.serializers.MarshalException; -import org.apache.cassandra.utils.FBUtilities; - -/** - * Base abstract class for {@code LivenessInfo} implementations. - * - * All {@code LivenessInfo} should extends this class unless it has a very - * good reason not to. - */ -public abstract class AbstractLivenessInfo implements LivenessInfo -{ - public boolean hasTimestamp() - { - return timestamp() != NO_TIMESTAMP; - } - - public boolean hasTTL() - { - return ttl() != NO_TTL; - } - - public boolean hasLocalDeletionTime() - { - return localDeletionTime() != NO_DELETION_TIME; - } - - public int remainingTTL(int nowInSec) - { - if (!hasTTL()) - return -1; - - int remaining = localDeletionTime() - nowInSec; - return remaining >= 0 ? remaining : -1; - } - - public boolean isLive(int nowInSec) - { - // Note that we don't rely on localDeletionTime() only because if we were to, we - // could potentially consider a tombstone as a live cell (due to time skew). So - // if a cell has a local deletion time and no ttl, it's a tombstone and consider - // dead no matter what it's actual local deletion value is. - return hasTimestamp() && (!hasLocalDeletionTime() || (hasTTL() && nowInSec < localDeletionTime())); - } - - public void digest(MessageDigest digest) - { - FBUtilities.updateWithLong(digest, timestamp()); - FBUtilities.updateWithInt(digest, localDeletionTime()); - FBUtilities.updateWithInt(digest, ttl()); - } - - public void validate() - { - if (ttl() < 0) - throw new MarshalException("A TTL should not be negative"); - if (localDeletionTime() < 0) - throw new MarshalException("A local deletion time should not be negative"); - if (hasTTL() && !hasLocalDeletionTime()) - throw new MarshalException("Shoud not have a TTL without an associated local deletion time"); - } - - public int dataSize() - { - int size = 0; - if (hasTimestamp()) - size += TypeSizes.sizeof(timestamp()); - if (hasTTL()) - size += TypeSizes.sizeof(ttl()); - if (hasLocalDeletionTime()) - size += TypeSizes.sizeof(localDeletionTime()); - return size; - - } - - public boolean supersedes(LivenessInfo other) - { - return timestamp() > other.timestamp(); - } - - public LivenessInfo mergeWith(LivenessInfo other) - { - return supersedes(other) ? this : other; - } - - public LivenessInfo takeAlias() - { - return new SimpleLivenessInfo(timestamp(), ttl(), localDeletionTime()); - }; - - public LivenessInfo withUpdatedTimestamp(long newTimestamp) - { - if (!hasTimestamp()) - return this; - - return new SimpleLivenessInfo(newTimestamp, ttl(), localDeletionTime()); - } - - public boolean isPurgeable(long maxPurgeableTimestamp, int gcBefore) - { - return timestamp() < maxPurgeableTimestamp && localDeletionTime() < gcBefore; - } - - @Override - public String toString() - { - StringBuilder sb = new StringBuilder(); - sb.append('['); - boolean needSpace = false; - if (hasTimestamp()) - { - sb.append("ts=").append(timestamp()); - needSpace = true; - } - if (hasTTL()) - { - sb.append(needSpace ? ' ' : "").append("ttl=").append(ttl()); - needSpace = true; - } - if (hasLocalDeletionTime()) - sb.append(needSpace ? ' ' : "").append("ldt=").append(localDeletionTime()); - sb.append(']'); - return sb.toString(); - } - - @Override - public boolean equals(Object other) - { - if(!(other instanceof LivenessInfo)) - return false; - - LivenessInfo that = (LivenessInfo)other; - return this.timestamp() == that.timestamp() - && this.ttl() == that.ttl() - && this.localDeletionTime() == that.localDeletionTime(); - } - - @Override - public int hashCode() - { - return Objects.hash(timestamp(), ttl(), localDeletionTime()); - } -} http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/db/Aliasable.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/Aliasable.java b/src/java/org/apache/cassandra/db/Aliasable.java deleted file mode 100644 index a4396fc..0000000 --- a/src/java/org/apache/cassandra/db/Aliasable.java +++ /dev/null @@ -1,62 +0,0 @@ -/* - * 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; - -/** - * This interface marks objects that are only valid in a restricted scope and - * shouldn't be simply aliased outside of this scope (in other words, you should - * not keep a reference to the object that escaped said scope as the object will - * likely become invalid). - * - * For instance, most {@link RowIterator} implementation reuse the same {@link - * Row} object during iteration. This means that the following code would be - * incorrect. - * <pre> - * RowIterator iter = ...; - * Row someRow = null; - * while (iter.hasNext()) - * { - * Row row = iter.next(); - * if (someCondition(row)) - * someRow = row; // This isn't safe - * doSomethingElse(); - * } - * useRow(someRow); - * </pre> - * The problem being that, because the row iterator reuse the same object, - * {@code someRow} will not point to the row that had met {@code someCondition} - * at the end of the iteration ({@code someRow} will point to the last iterated - * row in practice). - * - * When code do need to alias such {@code Aliasable} object, it should call the - * {@code takeAlias} method that will make a copy of the object if necessary. - * - * Of course, the {@code takeAlias} should not be abused, as it defeat the purpose - * of sharing objects in the first place. - * - * Also note that some implementation of an {@code Aliasable} object may be - * safe to alias, in which case its {@code takeAlias} method will be a no-op. - */ -public interface Aliasable<T> -{ - /** - * Returns either this object (if it's safe to alias) or a copy of it - * (it it isn't safe to alias). - */ - public T takeAlias(); -} http://git-wip-us.apache.org/repos/asf/cassandra/blob/24575994/src/java/org/apache/cassandra/db/CBuilder.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/CBuilder.java b/src/java/org/apache/cassandra/db/CBuilder.java index 56cabf1..fe130dc 100644 --- a/src/java/org/apache/cassandra/db/CBuilder.java +++ b/src/java/org/apache/cassandra/db/CBuilder.java @@ -163,7 +163,7 @@ public abstract class CBuilder built = true; // Currently, only dense table can leave some clustering column out (see #7990) - return size == 0 ? Clustering.EMPTY : new SimpleClustering(values); + return size == 0 ? Clustering.EMPTY : new Clustering(values); } public Slice.Bound buildBound(boolean isStart, boolean isInclusive) @@ -197,7 +197,7 @@ public abstract class CBuilder ByteBuffer[] newValues = Arrays.copyOf(values, size+1); newValues[size] = value; - return new SimpleClustering(newValues); + return new Clustering(newValues); } public Clustering buildWith(List<ByteBuffer> newValues) @@ -208,7 +208,7 @@ public abstract class CBuilder for (ByteBuffer value : newValues) buffers[newSize++] = value; - return new SimpleClustering(buffers); + return new Clustering(buffers); } public Slice.Bound buildBoundWith(ByteBuffer value, boolean isStart, boolean isInclusive)
