http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/test/unit/org/apache/cassandra/db/ColumnsTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/ColumnsTest.java b/test/unit/org/apache/cassandra/db/ColumnsTest.java index d64a5bd..ae0bbd8 100644 --- a/test/unit/org/apache/cassandra/db/ColumnsTest.java +++ b/test/unit/org/apache/cassandra/db/ColumnsTest.java @@ -30,14 +30,14 @@ import org.junit.AfterClass; import org.junit.Test; import junit.framework.Assert; -import org.apache.cassandra.MockSchema; -import org.apache.cassandra.config.CFMetaData; -import org.apache.cassandra.config.ColumnDefinition; import org.apache.cassandra.config.DatabaseDescriptor; import org.apache.cassandra.db.marshal.SetType; import org.apache.cassandra.db.marshal.UTF8Type; import org.apache.cassandra.io.util.DataInputBuffer; import org.apache.cassandra.io.util.DataOutputBuffer; +import org.apache.cassandra.schema.ColumnMetadata; +import org.apache.cassandra.schema.MockSchema; +import org.apache.cassandra.schema.TableMetadata; import org.apache.cassandra.utils.btree.BTreeSet; import static org.apache.cassandra.utils.ByteBufferUtil.bytes; @@ -49,7 +49,7 @@ public class ColumnsTest DatabaseDescriptor.daemonInitialization(); } - private static final CFMetaData cfMetaData = MockSchema.newCFS().metadata; + private static final TableMetadata TABLE_METADATA = MockSchema.newCFS().metadata(); // this tests most of our functionality, since each subset we perform // reasonably comprehensive tests of basic functionality against @@ -64,8 +64,8 @@ public class ColumnsTest { // pick some arbitrary groupings of columns to remove at-once (to avoid factorial complexity) // whatever is left after each removal, we perform this logic on again, recursively - List<List<ColumnDefinition>> removeGroups = shuffleAndGroup(Lists.newArrayList(input.definitions)); - for (List<ColumnDefinition> defs : removeGroups) + List<List<ColumnMetadata>> removeGroups = shuffleAndGroup(Lists.newArrayList(input.definitions)); + for (List<ColumnMetadata> defs : removeGroups) { ColumnsCheck subset = input.remove(defs); @@ -77,7 +77,7 @@ public class ColumnsTest // test .mergeTo Columns otherSubset = input.columns; - for (ColumnDefinition def : subset.definitions) + for (ColumnMetadata def : subset.definitions) { otherSubset = otherSubset.without(def); assertContents(otherSubset.mergeTo(subset.columns), input.definitions); @@ -102,7 +102,7 @@ public class ColumnsTest testSerialize(randomColumns.columns, randomColumns.definitions); } - private void testSerialize(Columns columns, List<ColumnDefinition> definitions) throws IOException + private void testSerialize(Columns columns, List<ColumnMetadata> definitions) throws IOException { try (DataOutputBuffer out = new DataOutputBuffer()) { @@ -136,7 +136,7 @@ public class ColumnsTest for (int i = 0; i < 50; i++) names.add("clustering_" + i); - List<ColumnDefinition> defs = new ArrayList<>(); + List<ColumnMetadata> defs = new ArrayList<>(); addClustering(names, defs); Columns columns = Columns.from(new HashSet<>(defs)); @@ -153,8 +153,8 @@ public class ColumnsTest { testSerializeSubset(input.columns, input.columns, input.definitions); testSerializeSubset(input.columns, Columns.NONE, Collections.emptyList()); - List<List<ColumnDefinition>> removeGroups = shuffleAndGroup(Lists.newArrayList(input.definitions)); - for (List<ColumnDefinition> defs : removeGroups) + List<List<ColumnMetadata>> removeGroups = shuffleAndGroup(Lists.newArrayList(input.definitions)); + for (List<ColumnMetadata> defs : removeGroups) { Collections.sort(defs); ColumnsCheck subset = input.remove(defs); @@ -162,7 +162,7 @@ public class ColumnsTest } } - private void testSerializeSubset(Columns superset, Columns subset, List<ColumnDefinition> subsetDefinitions) throws IOException + private void testSerializeSubset(Columns superset, Columns subset, List<ColumnMetadata> subsetDefinitions) throws IOException { try (DataOutputBuffer out = new DataOutputBuffer()) { @@ -175,17 +175,17 @@ public class ColumnsTest } } - private static void assertContents(Columns columns, List<ColumnDefinition> defs) + private static void assertContents(Columns columns, List<ColumnMetadata> defs) { Assert.assertEquals(defs, Lists.newArrayList(columns)); boolean hasSimple = false, hasComplex = false; int firstComplexIdx = 0; int i = 0; - Iterator<ColumnDefinition> simple = columns.simpleColumns(); - Iterator<ColumnDefinition> complex = columns.complexColumns(); - Iterator<ColumnDefinition> all = columns.iterator(); - Predicate<ColumnDefinition> predicate = columns.inOrderInclusionTester(); - for (ColumnDefinition def : defs) + Iterator<ColumnMetadata> simple = columns.simpleColumns(); + Iterator<ColumnMetadata> complex = columns.complexColumns(); + Iterator<ColumnMetadata> all = columns.iterator(); + Predicate<ColumnMetadata> predicate = columns.inOrderInclusionTester(); + for (ColumnMetadata def : defs) { Assert.assertEquals(def, all.next()); Assert.assertTrue(columns.contains(def)); @@ -218,9 +218,9 @@ public class ColumnsTest // check select order if (!columns.hasSimple() || !columns.getSimple(0).kind.isPrimaryKeyKind()) { - List<ColumnDefinition> selectOrderDefs = new ArrayList<>(defs); + List<ColumnMetadata> selectOrderDefs = new ArrayList<>(defs); Collections.sort(selectOrderDefs, (a, b) -> a.name.bytes.compareTo(b.name.bytes)); - List<ColumnDefinition> selectOrderColumns = new ArrayList<>(); + List<ColumnMetadata> selectOrderColumns = new ArrayList<>(); Iterators.addAll(selectOrderColumns, columns.selectOrderIterator()); Assert.assertEquals(selectOrderDefs, selectOrderColumns); } @@ -262,27 +262,27 @@ public class ColumnsTest private static class ColumnsCheck { final Columns columns; - final List<ColumnDefinition> definitions; + final List<ColumnMetadata> definitions; - private ColumnsCheck(Columns columns, List<ColumnDefinition> definitions) + private ColumnsCheck(Columns columns, List<ColumnMetadata> definitions) { this.columns = columns; this.definitions = definitions; } - private ColumnsCheck(List<ColumnDefinition> definitions) + private ColumnsCheck(List<ColumnMetadata> definitions) { this.columns = Columns.from(BTreeSet.of(definitions)); this.definitions = definitions; } - ColumnsCheck remove(List<ColumnDefinition> remove) + ColumnsCheck remove(List<ColumnMetadata> remove) { Columns subset = columns; - for (ColumnDefinition def : remove) + for (ColumnMetadata def : remove) subset = subset.without(def); Assert.assertEquals(columns.size() - remove.size(), subset.size()); - List<ColumnDefinition> remainingDefs = Lists.newArrayList(columns); + List<ColumnMetadata> remainingDefs = Lists.newArrayList(columns); remainingDefs.removeAll(remove); return new ColumnsCheck(subset, remainingDefs); } @@ -332,7 +332,7 @@ public class ColumnsTest for (char c = 'a' ; c <= 'z' ; c++) names .add(Character.toString(c)); - List<ColumnDefinition> result = new ArrayList<>(); + List<ColumnMetadata> result = new ArrayList<>(); addPartition(select(names, pkCount), result); addClustering(select(names, clCount), result); addRegular(select(names, regularCount), result); @@ -356,7 +356,7 @@ public class ColumnsTest private static ColumnsCheck randomHuge(int pkCount, int clCount, int regularCount, int complexCount) { - List<ColumnDefinition> result = new ArrayList<>(); + List<ColumnMetadata> result = new ArrayList<>(); Set<String> usedNames = new HashSet<>(); addPartition(names(pkCount, usedNames), result); addClustering(names(clCount, usedNames), result); @@ -383,43 +383,44 @@ public class ColumnsTest return names; } - private static void addPartition(List<String> names, List<ColumnDefinition> results) + private static void addPartition(List<String> names, List<ColumnMetadata> results) { for (String name : names) - results.add(ColumnDefinition.partitionKeyDef(cfMetaData, bytes(name), UTF8Type.instance, 0)); + results.add(ColumnMetadata.partitionKeyColumn(TABLE_METADATA, bytes(name), UTF8Type.instance, 0)); } - private static void addClustering(List<String> names, List<ColumnDefinition> results) + private static void addClustering(List<String> names, List<ColumnMetadata> results) { int i = 0; for (String name : names) - results.add(ColumnDefinition.clusteringDef(cfMetaData, bytes(name), UTF8Type.instance, i++)); + results.add(ColumnMetadata.clusteringColumn(TABLE_METADATA, bytes(name), UTF8Type.instance, i++)); } - private static void addRegular(List<String> names, List<ColumnDefinition> results) + private static void addRegular(List<String> names, List<ColumnMetadata> results) { for (String name : names) - results.add(ColumnDefinition.regularDef(cfMetaData, bytes(name), UTF8Type.instance)); + results.add(ColumnMetadata.regularColumn(TABLE_METADATA, bytes(name), UTF8Type.instance)); } - private static <V> void addComplex(List<String> names, List<ColumnDefinition> results) + private static <V> void addComplex(List<String> names, List<ColumnMetadata> results) { for (String name : names) - results.add(ColumnDefinition.regularDef(cfMetaData, bytes(name), SetType.getInstance(UTF8Type.instance, true))); + results.add(ColumnMetadata.regularColumn(TABLE_METADATA, bytes(name), SetType.getInstance(UTF8Type.instance, true))); } - private static CFMetaData mock(Columns columns) + private static TableMetadata mock(Columns columns) { if (columns.isEmpty()) - return cfMetaData; - CFMetaData.Builder builder = CFMetaData.Builder.create(cfMetaData.ksName, cfMetaData.cfName); + return TABLE_METADATA; + + TableMetadata.Builder builder = TableMetadata.builder(TABLE_METADATA.keyspace, TABLE_METADATA.name); boolean hasPartitionKey = false; - for (ColumnDefinition def : columns) + for (ColumnMetadata def : columns) { switch (def.kind) { case PARTITION_KEY: - builder.addPartitionKey(def.name, def.type); + builder.addPartitionKeyColumn(def.name, def.type); hasPartitionKey = true; break; case CLUSTERING: @@ -431,7 +432,7 @@ public class ColumnsTest } } if (!hasPartitionKey) - builder.addPartitionKey("219894021498309239rufejsfjdksfjheiwfhjes", UTF8Type.instance); + builder.addPartitionKeyColumn("219894021498309239rufejsfjdksfjheiwfhjes", UTF8Type.instance); return builder.build(); } }
http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/test/unit/org/apache/cassandra/db/CounterCacheTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/CounterCacheTest.java b/test/unit/org/apache/cassandra/db/CounterCacheTest.java index 4cfd848..a913133 100644 --- a/test/unit/org/apache/cassandra/db/CounterCacheTest.java +++ b/test/unit/org/apache/cassandra/db/CounterCacheTest.java @@ -20,8 +20,8 @@ package org.apache.cassandra.db; import java.util.Collections; import java.util.concurrent.ExecutionException; -import org.apache.cassandra.config.CFMetaData; -import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.schema.TableMetadata; +import org.apache.cassandra.schema.ColumnMetadata; import org.apache.cassandra.dht.Bounds; import org.apache.cassandra.dht.Token; import org.apache.cassandra.schema.KeyspaceParams; @@ -33,7 +33,7 @@ import org.junit.Test; import org.apache.cassandra.SchemaLoader; import org.apache.cassandra.db.marshal.*; import org.apache.cassandra.exceptions.ConfigurationException; -import org.apache.cassandra.config.Schema; +import org.apache.cassandra.schema.Schema; import org.apache.cassandra.exceptions.WriteTimeoutException; import org.apache.cassandra.service.CacheService; @@ -52,15 +52,14 @@ public class CounterCacheTest { SchemaLoader.prepareServer(); - CFMetaData counterTable = CFMetaData.Builder.create(KEYSPACE1, COUNTER1, false, true, true) - .addPartitionKey("key", Int32Type.instance) - .addClusteringColumn("name", Int32Type.instance) - .addRegularColumn("c", CounterColumnType.instance) - .build(); + TableMetadata.Builder counterTable = + TableMetadata.builder(KEYSPACE1, COUNTER1) + .isCounter(true) + .addPartitionKeyColumn("key", Int32Type.instance) + .addClusteringColumn("name", Int32Type.instance) + .addRegularColumn("c", CounterColumnType.instance); - SchemaLoader.createKeyspace(KEYSPACE1, - KeyspaceParams.simple(1), - counterTable); + SchemaLoader.createKeyspace(KEYSPACE1, KeyspaceParams.simple(1), counterTable); } @AfterClass @@ -76,9 +75,9 @@ public class CounterCacheTest cfs.truncateBlocking(); CacheService.instance.invalidateCounterCache(); - Clustering c1 = CBuilder.create(cfs.metadata.comparator).add(ByteBufferUtil.bytes(1)).build(); - Clustering c2 = CBuilder.create(cfs.metadata.comparator).add(ByteBufferUtil.bytes(2)).build(); - ColumnDefinition cd = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("c")); + Clustering c1 = CBuilder.create(cfs.metadata().comparator).add(ByteBufferUtil.bytes(1)).build(); + Clustering c2 = CBuilder.create(cfs.metadata().comparator).add(ByteBufferUtil.bytes(2)).build(); + ColumnMetadata cd = cfs.metadata().getColumn(ByteBufferUtil.bytes("c")); assertEquals(0, CacheService.instance.counterCache.size()); assertNull(cfs.getCachedCounter(bytes(1), c1, cd, null)); @@ -104,9 +103,9 @@ public class CounterCacheTest cfs.truncateBlocking(); CacheService.instance.invalidateCounterCache(); - Clustering c1 = CBuilder.create(cfs.metadata.comparator).add(ByteBufferUtil.bytes(1)).build(); - Clustering c2 = CBuilder.create(cfs.metadata.comparator).add(ByteBufferUtil.bytes(2)).build(); - ColumnDefinition cd = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("c")); + Clustering c1 = CBuilder.create(cfs.metadata().comparator).add(ByteBufferUtil.bytes(1)).build(); + Clustering c2 = CBuilder.create(cfs.metadata().comparator).add(ByteBufferUtil.bytes(2)).build(); + ColumnMetadata cd = cfs.metadata().getColumn(ByteBufferUtil.bytes("c")); assertEquals(0, CacheService.instance.counterCache.size()); assertNull(cfs.getCachedCounter(bytes(1), c1, cd, null)); @@ -149,10 +148,10 @@ public class CounterCacheTest cfs.truncateBlocking(); CacheService.instance.invalidateCounterCache(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(1)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(1)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(2)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(2)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(1)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(1)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(2)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(2)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); assertEquals(4, CacheService.instance.counterCache.size()); @@ -165,9 +164,9 @@ public class CounterCacheTest CacheService.instance.counterCache.loadSaved(); assertEquals(4, CacheService.instance.counterCache.size()); - Clustering c1 = CBuilder.create(cfs.metadata.comparator).add(ByteBufferUtil.bytes(1)).build(); - Clustering c2 = CBuilder.create(cfs.metadata.comparator).add(ByteBufferUtil.bytes(2)).build(); - ColumnDefinition cd = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("c")); + Clustering c1 = CBuilder.create(cfs.metadata().comparator).add(ByteBufferUtil.bytes(1)).build(); + Clustering c2 = CBuilder.create(cfs.metadata().comparator).add(ByteBufferUtil.bytes(2)).build(); + ColumnMetadata cd = cfs.metadata().getColumn(ByteBufferUtil.bytes("c")); assertEquals(1L, cfs.getCachedCounter(bytes(1), c1, cd, null).count); assertEquals(2L, cfs.getCachedCounter(bytes(1), c2, cd, null).count); @@ -182,10 +181,10 @@ public class CounterCacheTest cfs.truncateBlocking(); CacheService.instance.invalidateCounterCache(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(1)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(1)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(2)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(2)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(1)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(1)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(2)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(2)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); // flush the counter cache and invalidate CacheService.instance.counterCache.submitWrite(Integer.MAX_VALUE).get(); @@ -213,10 +212,10 @@ public class CounterCacheTest cfs.truncateBlocking(); CacheService.instance.invalidateCounterCache(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(1)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(1)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(2)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); - new CounterMutation(new RowUpdateBuilder(cfs.metadata, 0, bytes(2)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(1)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(1)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(2)).clustering(1).add("c", 1L).build(), ConsistencyLevel.ONE).apply(); + new CounterMutation(new RowUpdateBuilder(cfs.metadata(), 0, bytes(2)).clustering(2).add("c", 2L).build(), ConsistencyLevel.ONE).apply(); // flush the counter cache and invalidate CacheService.instance.counterCache.submitWrite(Integer.MAX_VALUE).get(); http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/test/unit/org/apache/cassandra/db/CounterCellTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/CounterCellTest.java b/test/unit/org/apache/cassandra/db/CounterCellTest.java index a043b1b..8c1347d 100644 --- a/test/unit/org/apache/cassandra/db/CounterCellTest.java +++ b/test/unit/org/apache/cassandra/db/CounterCellTest.java @@ -28,7 +28,7 @@ import org.junit.BeforeClass; import org.junit.Test; import org.apache.cassandra.SchemaLoader; -import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.schema.ColumnMetadata; import org.apache.cassandra.db.rows.BufferCell; import org.apache.cassandra.db.rows.Cell; import org.apache.cassandra.db.rows.Cells; @@ -98,27 +98,27 @@ public class CounterCellTest private Cell createLegacyCounterCell(ColumnFamilyStore cfs, ByteBuffer colName, long count, long ts) { - ColumnDefinition cDef = cfs.metadata.getColumnDefinition(colName); + ColumnMetadata cDef = cfs.metadata().getColumn(colName); ByteBuffer val = CounterContext.instance().createLocal(count); return BufferCell.live(cDef, ts, val); } private Cell createCounterCell(ColumnFamilyStore cfs, ByteBuffer colName, CounterId id, long count, long ts) { - ColumnDefinition cDef = cfs.metadata.getColumnDefinition(colName); + ColumnMetadata cDef = cfs.metadata().getColumn(colName); ByteBuffer val = CounterContext.instance().createGlobal(id, ts, count); return BufferCell.live(cDef, ts, val); } private Cell createCounterCellFromContext(ColumnFamilyStore cfs, ByteBuffer colName, ContextState context, long ts) { - ColumnDefinition cDef = cfs.metadata.getColumnDefinition(colName); + ColumnMetadata cDef = cfs.metadata().getColumn(colName); return BufferCell.live(cDef, ts, context.context); } private Cell createDeleted(ColumnFamilyStore cfs, ByteBuffer colName, long ts, int localDeletionTime) { - ColumnDefinition cDef = cfs.metadata.getColumnDefinition(colName); + ColumnMetadata cDef = cfs.metadata().getColumn(colName); return BufferCell.tombstone(cDef, ts, localDeletionTime); } @@ -272,7 +272,7 @@ public class CounterCellTest Cell original = createCounterCellFromContext(cfs, col, state, 5); - ColumnDefinition cDef = cfs.metadata.getColumnDefinition(col); + ColumnMetadata cDef = cfs.metadata().getColumn(col); Cell cleared = BufferCell.live(cDef, 5, CounterContext.instance().clearAllLocal(state.context)); CounterContext.instance().updateDigest(digest1, original.value()); http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/test/unit/org/apache/cassandra/db/CounterMutationTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/CounterMutationTest.java b/test/unit/org/apache/cassandra/db/CounterMutationTest.java index c8d4703..f36deea 100644 --- a/test/unit/org/apache/cassandra/db/CounterMutationTest.java +++ b/test/unit/org/apache/cassandra/db/CounterMutationTest.java @@ -21,7 +21,7 @@ import org.junit.BeforeClass; import org.junit.Test; import org.apache.cassandra.Util; -import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.schema.ColumnMetadata; import org.apache.cassandra.SchemaLoader; import org.apache.cassandra.db.rows.Row; import org.apache.cassandra.db.context.CounterContext; @@ -53,7 +53,7 @@ public class CounterMutationTest { ColumnFamilyStore cfs = Keyspace.open(KEYSPACE1).getColumnFamilyStore(CF1); cfs.truncateBlocking(); - ColumnDefinition cDef = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("val")); + ColumnMetadata cDef = cfs.metadata().getColumn(ByteBufferUtil.bytes("val")); // Do the initial update (+1) addAndCheck(cfs, 1, 1); @@ -67,8 +67,8 @@ public class CounterMutationTest private void addAndCheck(ColumnFamilyStore cfs, long toAdd, long expected) { - ColumnDefinition cDef = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("val")); - Mutation m = new RowUpdateBuilder(cfs.metadata, 5, "key1").clustering("cc").add("val", toAdd).build(); + ColumnMetadata cDef = cfs.metadata().getColumn(ByteBufferUtil.bytes("val")); + Mutation m = new RowUpdateBuilder(cfs.metadata(), 5, "key1").clustering("cc").add("val", toAdd).build(); new CounterMutation(m, ConsistencyLevel.ONE).apply(); Row row = Util.getOnlyRow(Util.cmd(cfs).includeRow("cc").columns("val").build()); @@ -93,10 +93,10 @@ public class CounterMutationTest private void addTwoAndCheck(ColumnFamilyStore cfs, long addOne, long expectedOne, long addTwo, long expectedTwo) { - ColumnDefinition cDefOne = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("val")); - ColumnDefinition cDefTwo = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("val2")); + ColumnMetadata cDefOne = cfs.metadata().getColumn(ByteBufferUtil.bytes("val")); + ColumnMetadata cDefTwo = cfs.metadata().getColumn(ByteBufferUtil.bytes("val2")); - Mutation m = new RowUpdateBuilder(cfs.metadata, 5, "key1") + Mutation m = new RowUpdateBuilder(cfs.metadata(), 5, "key1") .clustering("cc") .add("val", addOne) .add("val2", addTwo) @@ -119,35 +119,35 @@ public class CounterMutationTest // Do the update (+1, -1), (+2, -2) Mutation batch = new Mutation(KEYSPACE1, Util.dk("key1")); - batch.add(new RowUpdateBuilder(cfsOne.metadata, 5, "key1") + batch.add(new RowUpdateBuilder(cfsOne.metadata(), 5, "key1") .clustering("cc") .add("val", 1L) .add("val2", -1L) - .build().get(cfsOne.metadata)); + .build().get(cfsOne.metadata())); - batch.add(new RowUpdateBuilder(cfsTwo.metadata, 5, "key1") + batch.add(new RowUpdateBuilder(cfsTwo.metadata(), 5, "key1") .clustering("cc") .add("val", 2L) .add("val2", -2L) - .build().get(cfsTwo.metadata)); + .build().get(cfsTwo.metadata())); new CounterMutation(batch, ConsistencyLevel.ONE).apply(); - ColumnDefinition c1cfs1 = cfsOne.metadata.getColumnDefinition(ByteBufferUtil.bytes("val")); - ColumnDefinition c2cfs1 = cfsOne.metadata.getColumnDefinition(ByteBufferUtil.bytes("val2")); + ColumnMetadata c1cfs1 = cfsOne.metadata().getColumn(ByteBufferUtil.bytes("val")); + ColumnMetadata c2cfs1 = cfsOne.metadata().getColumn(ByteBufferUtil.bytes("val2")); Row row = Util.getOnlyRow(Util.cmd(cfsOne).includeRow("cc").columns("val", "val2").build()); assertEquals(1L, CounterContext.instance().total(row.getCell(c1cfs1).value())); assertEquals(-1L, CounterContext.instance().total(row.getCell(c2cfs1).value())); - ColumnDefinition c1cfs2 = cfsTwo.metadata.getColumnDefinition(ByteBufferUtil.bytes("val")); - ColumnDefinition c2cfs2 = cfsTwo.metadata.getColumnDefinition(ByteBufferUtil.bytes("val2")); + ColumnMetadata c1cfs2 = cfsTwo.metadata().getColumn(ByteBufferUtil.bytes("val")); + ColumnMetadata c2cfs2 = cfsTwo.metadata().getColumn(ByteBufferUtil.bytes("val2")); row = Util.getOnlyRow(Util.cmd(cfsTwo).includeRow("cc").columns("val", "val2").build()); assertEquals(2L, CounterContext.instance().total(row.getCell(c1cfs2).value())); assertEquals(-2L, CounterContext.instance().total(row.getCell(c2cfs2).value())); // Check the caches, separately - CBuilder cb = CBuilder.create(cfsOne.metadata.comparator); + CBuilder cb = CBuilder.create(cfsOne.metadata().comparator); cb.add("cc"); assertEquals(1L, cfsOne.getCachedCounter(Util.dk("key1").getKey(), cb.build(), c1cfs1, null).count); @@ -162,12 +162,12 @@ public class CounterMutationTest { ColumnFamilyStore cfs = Keyspace.open(KEYSPACE1).getColumnFamilyStore(CF1); cfs.truncateBlocking(); - ColumnDefinition cOne = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("val")); - ColumnDefinition cTwo = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("val2")); + ColumnMetadata cOne = cfs.metadata().getColumn(ByteBufferUtil.bytes("val")); + ColumnMetadata cTwo = cfs.metadata().getColumn(ByteBufferUtil.bytes("val2")); // Do the initial update (+1, -1) new CounterMutation( - new RowUpdateBuilder(cfs.metadata, 5, "key1") + new RowUpdateBuilder(cfs.metadata(), 5, "key1") .clustering("cc") .add("val", 1L) .add("val2", -1L) @@ -180,7 +180,7 @@ public class CounterMutationTest // Remove the first counter, increment the second counter new CounterMutation( - new RowUpdateBuilder(cfs.metadata, 5, "key1") + new RowUpdateBuilder(cfs.metadata(), 5, "key1") .clustering("cc") .delete(cOne) .add("val2", -5L) @@ -193,7 +193,7 @@ public class CounterMutationTest // Increment the first counter, make sure it's still shadowed by the tombstone new CounterMutation( - new RowUpdateBuilder(cfs.metadata, 5, "key1") + new RowUpdateBuilder(cfs.metadata(), 5, "key1") .clustering("cc") .add("val", 1L) .build(), @@ -202,12 +202,12 @@ public class CounterMutationTest assertEquals(null, row.getCell(cOne)); // Get rid of the complete partition - RowUpdateBuilder.deleteRow(cfs.metadata, 6, "key1", "cc").applyUnsafe(); + RowUpdateBuilder.deleteRow(cfs.metadata(), 6, "key1", "cc").applyUnsafe(); Util.assertEmpty(Util.cmd(cfs).includeRow("cc").columns("val", "val2").build()); // Increment both counters, ensure that both stay dead new CounterMutation( - new RowUpdateBuilder(cfs.metadata, 6, "key1") + new RowUpdateBuilder(cfs.metadata(), 6, "key1") .clustering("cc") .add("val", 1L) .add("val2", 1L) http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/test/unit/org/apache/cassandra/db/DeletePartitionTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/DeletePartitionTest.java b/test/unit/org/apache/cassandra/db/DeletePartitionTest.java index a65befd..95bb5a4 100644 --- a/test/unit/org/apache/cassandra/db/DeletePartitionTest.java +++ b/test/unit/org/apache/cassandra/db/DeletePartitionTest.java @@ -23,7 +23,7 @@ import org.junit.Test; import org.apache.cassandra.SchemaLoader; import org.apache.cassandra.Util; -import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.schema.ColumnMetadata; import org.apache.cassandra.db.rows.Row; import org.apache.cassandra.db.partitions.*; import org.apache.cassandra.schema.KeyspaceParams; @@ -59,10 +59,10 @@ public class DeletePartitionTest public void testDeletePartition(DecoratedKey key, boolean flushBeforeRemove, boolean flushAfterRemove) { ColumnFamilyStore store = Keyspace.open(KEYSPACE1).getColumnFamilyStore(CF_STANDARD1); - ColumnDefinition column = store.metadata.getColumnDefinition(ByteBufferUtil.bytes("val")); + ColumnMetadata column = store.metadata().getColumn(ByteBufferUtil.bytes("val")); // write - new RowUpdateBuilder(store.metadata, 0, key.getKey()) + new RowUpdateBuilder(store.metadata(), 0, key.getKey()) .clustering("Column1") .add("val", "asdf") .build() @@ -79,7 +79,7 @@ public class DeletePartitionTest // delete the partition new Mutation(KEYSPACE1, key) - .add(PartitionUpdate.fullPartitionDelete(store.metadata, key, 0, FBUtilities.nowInSeconds())) + .add(PartitionUpdate.fullPartitionDelete(store.metadata(), key, 0, FBUtilities.nowInSeconds())) .applyUnsafe(); if (flushAfterRemove) http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/test/unit/org/apache/cassandra/db/DirectoriesTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/DirectoriesTest.java b/test/unit/org/apache/cassandra/db/DirectoriesTest.java index 5841c36..904354a 100644 --- a/test/unit/org/apache/cassandra/db/DirectoriesTest.java +++ b/test/unit/org/apache/cassandra/db/DirectoriesTest.java @@ -30,8 +30,9 @@ import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; -import org.apache.cassandra.config.CFMetaData; -import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.cql3.ColumnIdentifier; +import org.apache.cassandra.schema.Indexes; +import org.apache.cassandra.schema.TableMetadata; import org.apache.cassandra.config.Config.DiskFailurePolicy; import org.apache.cassandra.config.DatabaseDescriptor; import org.apache.cassandra.cql3.statements.IndexTarget; @@ -45,7 +46,6 @@ import org.apache.cassandra.io.sstable.format.SSTableFormat; import org.apache.cassandra.io.util.FileUtils; import org.apache.cassandra.schema.IndexMetadata; import org.apache.cassandra.service.DefaultFSErrorHandler; -import org.apache.cassandra.utils.ByteBufferUtil; import org.apache.cassandra.utils.Pair; import static org.junit.Assert.assertEquals; @@ -60,7 +60,7 @@ public class DirectoriesTest private static final String KS = "ks"; private static final String[] TABLES = new String[] { "cf1", "ks" }; - private static final Set<CFMetaData> CFM = new HashSet<>(TABLES.length); + private static final Set<TableMetadata> CFM = new HashSet<>(TABLES.length); private static final Map<String, List<File>> files = new HashMap<>(); @@ -73,12 +73,10 @@ public class DirectoriesTest for (String table : TABLES) { - UUID tableID = CFMetaData.generateLegacyCfId(KS, table); - CFM.add(CFMetaData.Builder.create(KS, table) - .withId(tableID) - .addPartitionKey("thekey", UTF8Type.instance) - .addClusteringColumn("thecolumn", UTF8Type.instance) - .build()); + CFM.add(TableMetadata.builder(KS, table) + .addPartitionKeyColumn("thekey", UTF8Type.instance) + .addClusteringColumn("thecolumn", UTF8Type.instance) + .build()); } tempDataDir = File.createTempFile("cassandra", "unittest"); @@ -99,23 +97,23 @@ public class DirectoriesTest private static void createTestFiles() throws IOException { - for (CFMetaData cfm : CFM) + for (TableMetadata cfm : CFM) { List<File> fs = new ArrayList<>(); - files.put(cfm.cfName, fs); + files.put(cfm.name, fs); File dir = cfDir(cfm); dir.mkdirs(); - createFakeSSTable(dir, cfm.cfName, 1, fs); - createFakeSSTable(dir, cfm.cfName, 2, fs); + createFakeSSTable(dir, cfm.name, 1, fs); + createFakeSSTable(dir, cfm.name, 2, fs); File backupDir = new File(dir, Directories.BACKUPS_SUBDIR); backupDir.mkdir(); - createFakeSSTable(backupDir, cfm.cfName, 1, fs); + createFakeSSTable(backupDir, cfm.name, 1, fs); File snapshotDir = new File(dir, Directories.SNAPSHOT_SUBDIR + File.separator + "42"); snapshotDir.mkdirs(); - createFakeSSTable(snapshotDir, cfm.cfName, 1, fs); + createFakeSSTable(snapshotDir, cfm.name, 1, fs); } } @@ -130,33 +128,33 @@ public class DirectoriesTest } } - private static File cfDir(CFMetaData metadata) + private static File cfDir(TableMetadata metadata) { - String cfId = ByteBufferUtil.bytesToHex(ByteBufferUtil.bytes(metadata.cfId)); - int idx = metadata.cfName.indexOf(Directories.SECONDARY_INDEX_NAME_SEPARATOR); + String tableId = metadata.id.toHexString(); + int idx = metadata.name.indexOf(Directories.SECONDARY_INDEX_NAME_SEPARATOR); if (idx >= 0) { // secondary index return new File(tempDataDir, - metadata.ksName + File.separator + - metadata.cfName.substring(0, idx) + '-' + cfId + File.separator + - metadata.cfName.substring(idx)); + metadata.keyspace + File.separator + + metadata.name.substring(0, idx) + '-' + tableId + File.separator + + metadata.name.substring(idx)); } else { - return new File(tempDataDir, metadata.ksName + File.separator + metadata.cfName + '-' + cfId); + return new File(tempDataDir, metadata.keyspace + File.separator + metadata.name + '-' + tableId); } } @Test public void testStandardDirs() { - for (CFMetaData cfm : CFM) + for (TableMetadata cfm : CFM) { Directories directories = new Directories(cfm); assertEquals(cfDir(cfm), directories.getDirectoryForNewSSTables()); - Descriptor desc = new Descriptor(cfDir(cfm), KS, cfm.cfName, 1, SSTableFormat.Type.BIG); + Descriptor desc = new Descriptor(cfDir(cfm), KS, cfm.name, 1, SSTableFormat.Type.BIG); File snapshotDir = new File(cfDir(cfm), File.separator + Directories.SNAPSHOT_SUBDIR + File.separator + "42"); assertEquals(snapshotDir, Directories.getSnapshotDirectory(desc, "42")); @@ -168,21 +166,22 @@ public class DirectoriesTest @Test public void testSecondaryIndexDirectories() { - UUID tableID = CFMetaData.generateLegacyCfId(KS, "cf"); - CFMetaData PARENT_CFM = CFMetaData.Builder.create(KS, "cf") - .withId(tableID) - .addPartitionKey("thekey", UTF8Type.instance) - .addClusteringColumn("col", UTF8Type.instance) - .build(); - ColumnDefinition col = PARENT_CFM.getColumnDefinition(ByteBufferUtil.bytes("col")); + TableMetadata.Builder builder = + TableMetadata.builder(KS, "cf") + .addPartitionKeyColumn("thekey", UTF8Type.instance) + .addClusteringColumn("col", UTF8Type.instance); + + ColumnIdentifier col = ColumnIdentifier.getInterned("col", true); IndexMetadata indexDef = - IndexMetadata.fromIndexTargets(PARENT_CFM, - Collections.singletonList(new IndexTarget(col.name, IndexTarget.Type.VALUES)), + IndexMetadata.fromIndexTargets( + Collections.singletonList(new IndexTarget(col, IndexTarget.Type.VALUES)), "idx", IndexMetadata.Kind.KEYS, Collections.emptyMap()); - PARENT_CFM.indexes(PARENT_CFM.getIndexes().with(indexDef)); - CFMetaData INDEX_CFM = CassandraIndex.indexCfsMetadata(PARENT_CFM, indexDef); + builder.indexes(Indexes.of(indexDef)); + + TableMetadata PARENT_CFM = builder.build(); + TableMetadata INDEX_CFM = CassandraIndex.indexCfsMetadata(PARENT_CFM, indexDef); Directories parentDirectories = new Directories(PARENT_CFM); Directories indexDirectories = new Directories(INDEX_CFM); // secondary index has its own directory @@ -190,8 +189,8 @@ public class DirectoriesTest { assertEquals(cfDir(INDEX_CFM), dir); } - Descriptor parentDesc = new Descriptor(parentDirectories.getDirectoryForNewSSTables(), KS, PARENT_CFM.cfName, 0, SSTableFormat.Type.BIG); - Descriptor indexDesc = new Descriptor(indexDirectories.getDirectoryForNewSSTables(), KS, INDEX_CFM.cfName, 0, SSTableFormat.Type.BIG); + Descriptor parentDesc = new Descriptor(parentDirectories.getDirectoryForNewSSTables(), KS, PARENT_CFM.name, 0, SSTableFormat.Type.BIG); + Descriptor indexDesc = new Descriptor(indexDirectories.getDirectoryForNewSSTables(), KS, INDEX_CFM.name, 0, SSTableFormat.Type.BIG); // snapshot dir should be created under its parent's File parentSnapshotDirectory = Directories.getSnapshotDirectory(parentDesc, "test"); @@ -208,9 +207,9 @@ public class DirectoriesTest indexDirectories.snapshotCreationTime("test")); // check true snapshot size - Descriptor parentSnapshot = new Descriptor(parentSnapshotDirectory, KS, PARENT_CFM.cfName, 0, SSTableFormat.Type.BIG); + Descriptor parentSnapshot = new Descriptor(parentSnapshotDirectory, KS, PARENT_CFM.name, 0, SSTableFormat.Type.BIG); createFile(parentSnapshot.filenameFor(Component.DATA), 30); - Descriptor indexSnapshot = new Descriptor(indexSnapshotDirectory, KS, INDEX_CFM.cfName, 0, SSTableFormat.Type.BIG); + Descriptor indexSnapshot = new Descriptor(indexSnapshotDirectory, KS, INDEX_CFM.name, 0, SSTableFormat.Type.BIG); createFile(indexSnapshot.filenameFor(Component.DATA), 40); assertEquals(30, parentDirectories.trueSnapshotsSize()); @@ -246,20 +245,20 @@ public class DirectoriesTest @Test public void testSSTableLister() { - for (CFMetaData cfm : CFM) + for (TableMetadata cfm : CFM) { Directories directories = new Directories(cfm); checkFiles(cfm, directories); } } - private void checkFiles(CFMetaData cfm, Directories directories) + private void checkFiles(TableMetadata cfm, Directories directories) { Directories.SSTableLister lister; Set<File> listed;// List all but no snapshot, backup lister = directories.sstableLister(Directories.OnTxnErr.THROW); listed = new HashSet<>(lister.listFiles()); - for (File f : files.get(cfm.cfName)) + for (File f : files.get(cfm.name)) { if (f.getPath().contains(Directories.SNAPSHOT_SUBDIR) || f.getPath().contains(Directories.BACKUPS_SUBDIR)) assertFalse(f + " should not be listed", listed.contains(f)); @@ -270,7 +269,7 @@ public class DirectoriesTest // List all but including backup (but no snapshot) lister = directories.sstableLister(Directories.OnTxnErr.THROW).includeBackups(true); listed = new HashSet<>(lister.listFiles()); - for (File f : files.get(cfm.cfName)) + for (File f : files.get(cfm.name)) { if (f.getPath().contains(Directories.SNAPSHOT_SUBDIR)) assertFalse(f + " should not be listed", listed.contains(f)); @@ -281,7 +280,7 @@ public class DirectoriesTest // Skip temporary and compacted lister = directories.sstableLister(Directories.OnTxnErr.THROW).skipTemporary(true); listed = new HashSet<>(lister.listFiles()); - for (File f : files.get(cfm.cfName)) + for (File f : files.get(cfm.name)) { if (f.getPath().contains(Directories.SNAPSHOT_SUBDIR) || f.getPath().contains(Directories.BACKUPS_SUBDIR)) assertFalse(f + " should not be listed", listed.contains(f)); @@ -295,7 +294,7 @@ public class DirectoriesTest @Test public void testTemporaryFile() throws IOException { - for (CFMetaData cfm : CFM) + for (TableMetadata cfm : CFM) { Directories directories = new Directories(cfm); @@ -351,14 +350,14 @@ public class DirectoriesTest @Test public void testMTSnapshots() throws Exception { - for (final CFMetaData cfm : CFM) + for (final TableMetadata cfm : CFM) { final Directories directories = new Directories(cfm); assertEquals(cfDir(cfm), directories.getDirectoryForNewSSTables()); final String n = Long.toString(System.nanoTime()); Callable<File> directoryGetter = new Callable<File>() { public File call() throws Exception { - Descriptor desc = new Descriptor(cfDir(cfm), KS, cfm.cfName, 1, SSTableFormat.Type.BIG); + Descriptor desc = new Descriptor(cfDir(cfm), KS, cfm.name, 1, SSTableFormat.Type.BIG); return Directories.getSnapshotDirectory(desc, n); } }; http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/test/unit/org/apache/cassandra/db/KeyCacheTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/KeyCacheTest.java b/test/unit/org/apache/cassandra/db/KeyCacheTest.java index ada6b5b..d7a31d6 100644 --- a/test/unit/org/apache/cassandra/db/KeyCacheTest.java +++ b/test/unit/org/apache/cassandra/db/KeyCacheTest.java @@ -269,8 +269,8 @@ public class KeyCacheTest Mutation rm; // inserts - new RowUpdateBuilder(cfs.metadata, 0, "key1").clustering("1").build().applyUnsafe(); - new RowUpdateBuilder(cfs.metadata, 0, "key2").clustering("2").build().applyUnsafe(); + new RowUpdateBuilder(cfs.metadata(), 0, "key1").clustering("1").build().applyUnsafe(); + new RowUpdateBuilder(cfs.metadata(), 0, "key2").clustering("2").build().applyUnsafe(); // to make sure we have SSTable cfs.forceBlockingFlush(); http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/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 5036749..d913f3e 100644 --- a/test/unit/org/apache/cassandra/db/KeyspaceTest.java +++ b/test/unit/org/apache/cassandra/db/KeyspaceTest.java @@ -80,20 +80,20 @@ public class KeyspaceTest extends CQLTester { // slice with limit 1 Row row = Util.getOnlyRow(Util.cmd(cfs, "0").columns("c").withLimit(1).build()); - assertEquals(ByteBufferUtil.bytes(0), row.getCell(cfs.metadata.getColumnDefinition(new ColumnIdentifier("c", false))).value()); + assertEquals(ByteBufferUtil.bytes(0), row.getCell(cfs.metadata().getColumn(new ColumnIdentifier("c", false))).value()); // fetch each row by name for (int i = 0; i < 2; i++) { row = Util.getOnlyRow(Util.cmd(cfs, "0").columns("c").includeRow(i).build()); - assertEquals(ByteBufferUtil.bytes(i), row.getCell(cfs.metadata.getColumnDefinition(new ColumnIdentifier("c", false))).value()); + assertEquals(ByteBufferUtil.bytes(i), row.getCell(cfs.metadata().getColumn(new ColumnIdentifier("c", false))).value()); } // fetch each row by slice for (int i = 0; i < 2; i++) { row = Util.getOnlyRow(Util.cmd(cfs, "0").columns("c").fromIncl(i).toIncl(i).build()); - assertEquals(ByteBufferUtil.bytes(i), row.getCell(cfs.metadata.getColumnDefinition(new ColumnIdentifier("c", false))).value()); + assertEquals(ByteBufferUtil.bytes(i), row.getCell(cfs.metadata().getColumn(new ColumnIdentifier("c", false))).value()); } if (round == 0) @@ -145,7 +145,7 @@ public class KeyspaceTest extends CQLTester for (int i = sliceEnd; i >= sliceStart; i--) { Row row = rowIterator.next(); - Cell cell = row.getCell(cfs.metadata.getColumnDefinition(new ColumnIdentifier("c", false))); + Cell cell = row.getCell(cfs.metadata().getColumn(new ColumnIdentifier("c", false))); assertEquals(ByteBufferUtil.bytes(columnValuePrefix + i), cell.value()); } } @@ -154,7 +154,7 @@ public class KeyspaceTest extends CQLTester for (int i = sliceStart; i <= sliceEnd; i++) { Row row = rowIterator.next(); - Cell cell = row.getCell(cfs.metadata.getColumnDefinition(new ColumnIdentifier("c", false))); + Cell cell = row.getCell(cfs.metadata().getColumn(new ColumnIdentifier("c", false))); assertEquals(ByteBufferUtil.bytes(columnValuePrefix + i), cell.value()); } } @@ -206,7 +206,7 @@ public class KeyspaceTest extends CQLTester { execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", "0", i, i); - PartitionColumns columns = PartitionColumns.of(cfs.metadata.getColumnDefinition(new ColumnIdentifier("c", false))); + RegularAndStaticColumns columns = RegularAndStaticColumns.of(cfs.metadata().getColumn(new ColumnIdentifier("c", false))); ClusteringIndexSliceFilter filter = new ClusteringIndexSliceFilter(Slices.ALL, false); SinglePartitionReadCommand command = singlePartitionSlice(cfs, "0", filter, null); try (ReadExecutionController executionController = command.executionController(); @@ -215,7 +215,7 @@ public class KeyspaceTest extends CQLTester try (RowIterator rowIterator = iterator.next()) { Row row = rowIterator.next(); - Cell cell = row.getCell(cfs.metadata.getColumnDefinition(new ColumnIdentifier("c", false))); + Cell cell = row.getCell(cfs.metadata().getColumn(new ColumnIdentifier("c", false))); assertEquals(ByteBufferUtil.bytes(i), cell.value()); } } @@ -230,7 +230,7 @@ public class KeyspaceTest extends CQLTester if (columnValues.length == 0) { if (iterator.hasNext()) - fail("Didn't expect any results, but got rows starting with: " + iterator.next().next().toString(cfs.metadata)); + fail("Didn't expect any results, but got rows starting with: " + iterator.next().next().toString(cfs.metadata())); return; } @@ -239,7 +239,7 @@ public class KeyspaceTest extends CQLTester for (int expected : columnValues) { Row row = rowIterator.next(); - Cell cell = row.getCell(cfs.metadata.getColumnDefinition(new ColumnIdentifier("c", false))); + Cell cell = row.getCell(cfs.metadata().getColumn(new ColumnIdentifier("c", false))); assertEquals( String.format("Expected %s, but got %s", ByteBufferUtil.bytesToHex(ByteBufferUtil.bytes(expected)), ByteBufferUtil.bytesToHex(cell.value())), ByteBufferUtil.bytes(expected), cell.value()); @@ -267,7 +267,7 @@ public class KeyspaceTest extends CQLTester ? DataLimits.NONE : DataLimits.cqlLimits(rowLimit); return SinglePartitionReadCommand.create( - cfs.metadata, FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata), RowFilter.NONE, limit, Util.dk(key), filter); + cfs.metadata(), FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata()), RowFilter.NONE, limit, Util.dk(key), filter); } @Test @@ -474,17 +474,17 @@ public class KeyspaceTest extends CQLTester { ClusteringIndexSliceFilter filter = slices(cfs, 1000, null, false); SinglePartitionReadCommand command = SinglePartitionReadCommand.create( - cfs.metadata, FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); + cfs.metadata(), FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata()), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); assertRowsInResult(cfs, command, 1000, 1001, 1002); filter = slices(cfs, 1195, null, false); command = SinglePartitionReadCommand.create( - cfs.metadata, FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); + cfs.metadata(), FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata()), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); assertRowsInResult(cfs, command, 1195, 1196, 1197); filter = slices(cfs, null, 1996, true); command = SinglePartitionReadCommand.create( - cfs.metadata, FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata), RowFilter.NONE, DataLimits.cqlLimits(1000), Util.dk("0"), filter); + cfs.metadata(), FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata()), RowFilter.NONE, DataLimits.cqlLimits(1000), Util.dk("0"), filter); int[] expectedValues = new int[997]; for (int i = 0, v = 1996; v >= 1000; i++, v--) expectedValues[i] = v; @@ -492,22 +492,22 @@ public class KeyspaceTest extends CQLTester filter = slices(cfs, 1990, null, false); command = SinglePartitionReadCommand.create( - cfs.metadata, FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); + cfs.metadata(), FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata()), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); assertRowsInResult(cfs, command, 1990, 1991, 1992); filter = slices(cfs, null, null, true); command = SinglePartitionReadCommand.create( - cfs.metadata, FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); + cfs.metadata(), FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata()), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); assertRowsInResult(cfs, command, 1999, 1998, 1997); filter = slices(cfs, null, 9000, true); command = SinglePartitionReadCommand.create( - cfs.metadata, FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); + cfs.metadata(), FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata()), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); assertRowsInResult(cfs, command, 1999, 1998, 1997); filter = slices(cfs, 9000, null, false); command = SinglePartitionReadCommand.create( - cfs.metadata, FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); + cfs.metadata(), FBUtilities.nowInSeconds(), ColumnFilter.all(cfs.metadata()), RowFilter.NONE, DataLimits.cqlLimits(3), Util.dk("0"), filter); assertRowsInResult(cfs, command); } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/test/unit/org/apache/cassandra/db/NameSortTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/NameSortTest.java b/test/unit/org/apache/cassandra/db/NameSortTest.java index 1da6ea6..0b00f40 100644 --- a/test/unit/org/apache/cassandra/db/NameSortTest.java +++ b/test/unit/org/apache/cassandra/db/NameSortTest.java @@ -23,7 +23,7 @@ import java.nio.ByteBuffer; import org.apache.cassandra.SchemaLoader; import org.apache.cassandra.Util; -import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.schema.ColumnMetadata; import org.apache.cassandra.db.rows.Row; import org.apache.cassandra.db.partitions.*; import org.apache.cassandra.db.marshal.AsciiType; @@ -77,7 +77,7 @@ public class NameSortTest for (int i = 0; i < N; i++) { ByteBuffer key = ByteBufferUtil.bytes(Integer.toString(i)); - RowUpdateBuilder rub = new RowUpdateBuilder(cfs.metadata, 0, key); + RowUpdateBuilder rub = new RowUpdateBuilder(cfs.metadata(), 0, key); rub.clustering("cc"); for (int j = 0; j < 8; j++) rub.add("val" + j, j % 2 == 0 ? "a" : "b"); @@ -94,7 +94,7 @@ public class NameSortTest { for (Row r : partition) { - for (ColumnDefinition cd : r.columns()) + for (ColumnMetadata cd : r.columns()) { if (r.getCell(cd) == null) continue; http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/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 index 69e615b..cd7074f 100644 --- a/test/unit/org/apache/cassandra/db/NativeCellTest.java +++ b/test/unit/org/apache/cassandra/db/NativeCellTest.java @@ -29,7 +29,7 @@ import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.schema.ColumnMetadata; import org.apache.cassandra.cql3.ColumnIdentifier; import org.apache.cassandra.db.marshal.BytesType; import org.apache.cassandra.db.marshal.SetType; @@ -92,7 +92,7 @@ public class NativeCellTest private static void rndcd(Row.Builder builder) { - ColumnDefinition col = rndcol(); + ColumnMetadata col = rndcol(); if (!col.isComplex()) { builder.addCell(rndcell(col)); @@ -105,19 +105,19 @@ public class NativeCellTest } } - private static ColumnDefinition rndcol() + private static ColumnMetadata rndcol() { UUID uuid = new UUID(rand.nextLong(), rand.nextLong()); boolean isComplex = rand.nextBoolean(); - return new ColumnDefinition("", - "", - ColumnIdentifier.getInterned(uuid.toString(), false), + return new ColumnMetadata("", + "", + ColumnIdentifier.getInterned(uuid.toString(), false), isComplex ? new SetType<>(BytesType.instance, true) : BytesType.instance, - -1, - ColumnDefinition.Kind.REGULAR); + -1, + ColumnMetadata.Kind.REGULAR); } - private static Cell rndcell(ColumnDefinition col) + private static Cell rndcell(ColumnMetadata col) { long timestamp = rand.nextLong(); int ttl = rand.nextInt(); http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/test/unit/org/apache/cassandra/db/PartitionRangeReadTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/PartitionRangeReadTest.java b/test/unit/org/apache/cassandra/db/PartitionRangeReadTest.java index e409592..c433d8e 100644 --- a/test/unit/org/apache/cassandra/db/PartitionRangeReadTest.java +++ b/test/unit/org/apache/cassandra/db/PartitionRangeReadTest.java @@ -30,7 +30,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import org.apache.cassandra.*; -import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.schema.ColumnMetadata; import org.apache.cassandra.db.rows.Row; import org.apache.cassandra.db.marshal.IntegerType; import org.apache.cassandra.db.partitions.*; @@ -62,10 +62,10 @@ public class PartitionRangeReadTest public void testInclusiveBounds() { ColumnFamilyStore cfs = Keyspace.open(KEYSPACE2).getColumnFamilyStore(CF_STANDARD1); - new RowUpdateBuilder(cfs.metadata, 0, ByteBufferUtil.bytes("key1")) + new RowUpdateBuilder(cfs.metadata(), 0, ByteBufferUtil.bytes("key1")) .clustering("cc1") .add("val", "asdf").build().applyUnsafe(); - new RowUpdateBuilder(cfs.metadata, 0, ByteBufferUtil.bytes("key2")) + new RowUpdateBuilder(cfs.metadata(), 0, ByteBufferUtil.bytes("key2")) .clustering("cc2") .add("val", "asdf").build().applyUnsafe(); @@ -81,18 +81,18 @@ public class PartitionRangeReadTest cfs.truncateBlocking(); ByteBuffer col = ByteBufferUtil.bytes("val"); - ColumnDefinition cDef = cfs.metadata.getColumnDefinition(col); + ColumnMetadata cDef = cfs.metadata().getColumn(col); // insert two columns that represent the same integer but have different binary forms (the // second one is padded with extra zeros) - new RowUpdateBuilder(cfs.metadata, 0, "k1") + new RowUpdateBuilder(cfs.metadata(), 0, "k1") .clustering(new BigInteger(new byte[]{1})) .add("val", "val1") .build() .applyUnsafe(); cfs.forceBlockingFlush(); - new RowUpdateBuilder(cfs.metadata, 1, "k1") + new RowUpdateBuilder(cfs.metadata(), 1, "k1") .clustering(new BigInteger(new byte[]{0, 0, 1})) .add("val", "val2") .build() @@ -119,7 +119,7 @@ public class PartitionRangeReadTest for (int i = 0; i < 10; ++i) { - RowUpdateBuilder builder = new RowUpdateBuilder(cfs.metadata, 10, String.valueOf(i)); + RowUpdateBuilder builder = new RowUpdateBuilder(cfs.metadata(), 10, String.valueOf(i)); builder.clustering("c"); builder.add("val", String.valueOf(i)); builder.build().applyUnsafe(); @@ -127,7 +127,7 @@ public class PartitionRangeReadTest cfs.forceBlockingFlush(); - ColumnDefinition cDef = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("val")); + ColumnMetadata cDef = cfs.metadata().getColumn(ByteBufferUtil.bytes("val")); List<FilteredPartition> partitions; http://git-wip-us.apache.org/repos/asf/cassandra/blob/af3fe39d/test/unit/org/apache/cassandra/db/PartitionTest.java ---------------------------------------------------------------------- diff --git a/test/unit/org/apache/cassandra/db/PartitionTest.java b/test/unit/org/apache/cassandra/db/PartitionTest.java index 7f44d51..c1796be 100644 --- a/test/unit/org/apache/cassandra/db/PartitionTest.java +++ b/test/unit/org/apache/cassandra/db/PartitionTest.java @@ -25,7 +25,7 @@ import java.util.Arrays; import org.junit.BeforeClass; import org.junit.Test; -import org.apache.cassandra.config.ColumnDefinition; +import org.apache.cassandra.schema.ColumnMetadata; import org.apache.cassandra.db.rows.EncodingStats; import org.apache.cassandra.db.rows.UnfilteredRowIterators; import org.apache.cassandra.db.marshal.AsciiType; @@ -67,7 +67,7 @@ public class PartitionTest public void testSingleColumn() throws IOException { ColumnFamilyStore cfs = Keyspace.open(KEYSPACE1).getColumnFamilyStore(CF_STANDARD1); - PartitionUpdate update = new RowUpdateBuilder(cfs.metadata, 5, "key1") + PartitionUpdate update = new RowUpdateBuilder(cfs.metadata(), 5, "key1") .clustering("c") .add("val", "val1") .buildUpdate(); @@ -80,7 +80,7 @@ public class PartitionTest CachedPartition deserialized = CachedPartition.cacheSerializer.deserialize(new DataInputBuffer(bufOut.getData())); assert deserialized != null; - assert deserialized.metadata().cfName.equals(CF_STANDARD1); + assert deserialized.metadata().name.equals(CF_STANDARD1); assert deserialized.partitionKey().equals(partition.partitionKey()); } @@ -88,7 +88,7 @@ public class PartitionTest public void testManyColumns() throws IOException { ColumnFamilyStore cfs = Keyspace.open(KEYSPACE1).getColumnFamilyStore(CF_TENCOL); - RowUpdateBuilder builder = new RowUpdateBuilder(cfs.metadata, 5, "key1") + RowUpdateBuilder builder = new RowUpdateBuilder(cfs.metadata(), 5, "key1") .clustering("c") .add("val", "val1"); @@ -108,7 +108,7 @@ public class PartitionTest assertTrue(deserialized.columns().regulars.getSimple(1).equals(partition.columns().regulars.getSimple(1))); assertTrue(deserialized.columns().regulars.getSimple(5).equals(partition.columns().regulars.getSimple(5))); - ColumnDefinition cDef = cfs.metadata.getColumnDefinition(ByteBufferUtil.bytes("val8")); + ColumnMetadata cDef = cfs.metadata().getColumn(ByteBufferUtil.bytes("val8")); assertTrue(partition.lastRow().getCell(cDef).value().equals(deserialized.lastRow().getCell(cDef).value())); assert deserialized.partitionKey().equals(partition.partitionKey()); } @@ -125,12 +125,12 @@ public class PartitionTest try { - RowUpdateBuilder builder = new RowUpdateBuilder(cfs.metadata, 5, "key1").clustering("c").add("val", "val1"); + RowUpdateBuilder builder = new RowUpdateBuilder(cfs.metadata(), 5, "key1").clustering("c").add("val", "val1"); for (int i = 0; i < 10; i++) builder.add("val" + i, "val" + i); builder.build().applyUnsafe(); - new RowUpdateBuilder(cfs.metadata, 5, "key2").clustering("c").add("val", "val2").build().applyUnsafe(); + new RowUpdateBuilder(cfs.metadata(), 5, "key2").clustering("c").add("val", "val2").build().applyUnsafe(); ReadCommand cmd1 = Util.cmd(cfs, "key1").build(); ReadCommand cmd2 = Util.cmd(cfs, "key2").build(); @@ -152,7 +152,7 @@ public class PartitionTest assertTrue(Arrays.equals(digest1.digest(), digest2.digest())); p1 = Util.getOnlyPartitionUnfiltered(Util.cmd(cfs, "key2").build()); - RowUpdateBuilder.deleteRow(cfs.metadata, 6, "key2", "c").applyUnsafe(); + RowUpdateBuilder.deleteRow(cfs.metadata(), 6, "key2", "c").applyUnsafe(); p2 = Util.getOnlyPartitionUnfiltered(Util.cmd(cfs, "key2").build()); digest1 = MessageDigest.getInstance("MD5"); digest2 = MessageDigest.getInstance("MD5"); @@ -173,12 +173,12 @@ public class PartitionTest int localDeletionTime = (int) (timestamp / 1000); ColumnFamilyStore cfs = Keyspace.open(KEYSPACE1).getColumnFamilyStore(CF_TENCOL); - RowUpdateBuilder builder = new RowUpdateBuilder(cfs.metadata, 5, "key1").clustering("c").add("val", "val1"); + RowUpdateBuilder builder = new RowUpdateBuilder(cfs.metadata(), 5, "key1").clustering("c").add("val", "val1"); for (int i = 0; i < 10; i++) builder.add("val" + i, "val" + i); builder.build().applyUnsafe(); - RowUpdateBuilder.deleteRowAt(cfs.metadata, 10L, localDeletionTime, "key1", "c").applyUnsafe(); + RowUpdateBuilder.deleteRowAt(cfs.metadata(), 10L, localDeletionTime, "key1", "c").applyUnsafe(); ImmutableBTreePartition partition = Util.getOnlyPartitionUnfiltered(Util.cmd(cfs, "key1").build()); EncodingStats stats = partition.stats(); assertEquals(localDeletionTime, stats.minLocalDeletionTime);
