adelapena commented on a change in pull request #890:
URL: https://github.com/apache/cassandra/pull/890#discussion_r581119728
##########
File path: test/unit/org/apache/cassandra/db/filter/ColumnFilterTest.java
##########
@@ -18,53 +18,348 @@
package org.apache.cassandra.db.filter;
+import java.io.IOException;
+import java.util.function.Consumer;
+
+import com.google.common.base.Throwables;
+import org.junit.Assert;
import org.junit.Test;
-import junit.framework.Assert;
import org.apache.cassandra.config.CFMetaData;
import org.apache.cassandra.config.ColumnDefinition;
+import org.apache.cassandra.db.PartitionColumns;
import org.apache.cassandra.db.marshal.Int32Type;
+import org.apache.cassandra.db.marshal.SetType;
+import org.apache.cassandra.db.rows.CellPath;
import org.apache.cassandra.dht.Murmur3Partitioner;
import org.apache.cassandra.io.util.DataInputBuffer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.net.MessagingService;
import org.apache.cassandra.utils.ByteBufferUtil;
+import static org.junit.Assert.assertEquals;
+
public class ColumnFilterTest
{
- final static ColumnFilter.Serializer serializer = new
ColumnFilter.Serializer();
+ private static final ColumnFilter.Serializer serializer = new
ColumnFilter.Serializer();
+
+ private final CFMetaData metadata = CFMetaData.Builder.create("ks",
"table")
+
.withPartitioner(Murmur3Partitioner.instance)
+
.addPartitionKey("pk", Int32Type.instance)
+
.addClusteringColumn("ck", Int32Type.instance)
+
.addStaticColumn("s1", Int32Type.instance)
+
.addStaticColumn("s2", SetType.getInstance(Int32Type.instance, true))
+
.addRegularColumn("v1", Int32Type.instance)
+
.addRegularColumn("v2", SetType.getInstance(Int32Type.instance, true))
+ .build();
+
+ private final ColumnDefinition s1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("s1"));
+ private final ColumnDefinition s2 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("s2"));
+ private final ColumnDefinition v1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v1"));
+ private final ColumnDefinition v2 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v2"));
+ private final CellPath path0 = CellPath.create(ByteBufferUtil.bytes(0));
+ private final CellPath path1 = CellPath.create(ByteBufferUtil.bytes(1));
+ private final CellPath path2 = CellPath.create(ByteBufferUtil.bytes(2));
+ private final CellPath path3 = CellPath.create(ByteBufferUtil.bytes(3));
+ private final CellPath path4 = CellPath.create(ByteBufferUtil.bytes(4));
+
+ // Select all
+
+ @Test
+ public void testSelectAll() throws Exception
Review comment:
Nit: Now that `testRoundTrip` body in inside a try-catch block (I assume
that to avoid problems when calling it from the lambdas), none of the methods
need the `throws Exception` part.
##########
File path: test/unit/org/apache/cassandra/db/filter/ColumnFilterTest.java
##########
@@ -18,53 +18,348 @@
package org.apache.cassandra.db.filter;
+import java.io.IOException;
+import java.util.function.Consumer;
+
+import com.google.common.base.Throwables;
+import org.junit.Assert;
import org.junit.Test;
-import junit.framework.Assert;
import org.apache.cassandra.config.CFMetaData;
import org.apache.cassandra.config.ColumnDefinition;
+import org.apache.cassandra.db.PartitionColumns;
import org.apache.cassandra.db.marshal.Int32Type;
+import org.apache.cassandra.db.marshal.SetType;
+import org.apache.cassandra.db.rows.CellPath;
import org.apache.cassandra.dht.Murmur3Partitioner;
import org.apache.cassandra.io.util.DataInputBuffer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.net.MessagingService;
import org.apache.cassandra.utils.ByteBufferUtil;
+import static org.junit.Assert.assertEquals;
+
public class ColumnFilterTest
{
- final static ColumnFilter.Serializer serializer = new
ColumnFilter.Serializer();
+ private static final ColumnFilter.Serializer serializer = new
ColumnFilter.Serializer();
+
+ private final CFMetaData metadata = CFMetaData.Builder.create("ks",
"table")
+
.withPartitioner(Murmur3Partitioner.instance)
+
.addPartitionKey("pk", Int32Type.instance)
+
.addClusteringColumn("ck", Int32Type.instance)
+
.addStaticColumn("s1", Int32Type.instance)
+
.addStaticColumn("s2", SetType.getInstance(Int32Type.instance, true))
+
.addRegularColumn("v1", Int32Type.instance)
+
.addRegularColumn("v2", SetType.getInstance(Int32Type.instance, true))
+ .build();
+
+ private final ColumnDefinition s1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("s1"));
+ private final ColumnDefinition s2 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("s2"));
+ private final ColumnDefinition v1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v1"));
+ private final ColumnDefinition v2 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v2"));
+ private final CellPath path0 = CellPath.create(ByteBufferUtil.bytes(0));
+ private final CellPath path1 = CellPath.create(ByteBufferUtil.bytes(1));
+ private final CellPath path2 = CellPath.create(ByteBufferUtil.bytes(2));
+ private final CellPath path3 = CellPath.create(ByteBufferUtil.bytes(3));
+ private final CellPath path4 = CellPath.create(ByteBufferUtil.bytes(4));
+
+ // Select all
+
+ @Test
+ public void testSelectAll() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+ check.accept(ColumnFilter.all(metadata));
+ check.accept(ColumnFilter.allColumnsBuilder(metadata).build());
+ }
+
+ // Selections
+
+ @Test
+ public void testSelectNothing() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[]", filter.toString());
+ assertFetchedQueried(false, false, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+ check.accept(ColumnFilter.selection(PartitionColumns.NONE));
+ check.accept(ColumnFilter.selectionBuilder().build());
+ }
+
+ @Test
+ public void testSelectSimpleColumn() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[v1]", filter.toString());
+ assertFetchedQueried(true, true, filter, v1);
+ assertFetchedQueried(false, false, filter, v2, s1, s2);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(v1).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(v1).build());
+ }
+
+ @Test
+ public void testSelectComplexColumn() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[v2]", filter.toString());
+ assertFetchedQueried(true, true, filter, v2);
+ assertFetchedQueried(false, false, filter, v1, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(v2).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(v2).build());
+ }
@Test
- public void columnFilterSerialisationRoundTrip() throws Exception
+ public void testSelectStaticColumn() throws Exception
{
- CFMetaData metadata = CFMetaData.Builder.create("ks", "table")
-
.withPartitioner(Murmur3Partitioner.instance)
- .addPartitionKey("pk",
Int32Type.instance)
- .addClusteringColumn("ck",
Int32Type.instance)
- .addRegularColumn("v1",
Int32Type.instance)
- .addRegularColumn("v2",
Int32Type.instance)
- .addRegularColumn("v3",
Int32Type.instance)
- .build();
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[s1]", filter.toString());
+ assertFetchedQueried(true, true, filter, s1);
+ assertFetchedQueried(false, false, filter, v1, v2, s2);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(s1).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(s1).build());
+ }
+
+ @Test
+ public void testSelectStaticComplexColumn() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[s2]", filter.toString());
+ assertFetchedQueried(true, true, filter, s2);
+ assertFetchedQueried(false, false, filter, v1, v2, s1);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(s2).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(s2).build());
+ }
- ColumnDefinition v1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v1"));
+ @Test
+ public void testSelectColumns() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[s1, s2, v1, v2]", filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
- testRoundTrip(ColumnFilter.all(metadata), metadata,
MessagingService.VERSION_30);
- testRoundTrip(ColumnFilter.all(metadata), metadata,
MessagingService.VERSION_3014);
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(v1).add(v2).add(s1).add(s2).build()));
+
check.accept(ColumnFilter.selectionBuilder().add(v1).add(v2).add(s1).add(s2).build());
+ }
-
testRoundTrip(ColumnFilter.selection(metadata.partitionColumns().without(v1)),
metadata, MessagingService.VERSION_30);
-
testRoundTrip(ColumnFilter.selection(metadata.partitionColumns().without(v1)),
metadata, MessagingService.VERSION_3014);
+ @Test
+ public void testSelectIndividualCells() throws Exception
+ {
+ ColumnFilter filter = ColumnFilter.selectionBuilder().select(v2,
path1).select(v2, path3).build();
+ testRoundTrips(filter);
+ assertEquals("[v2[1], v2[3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, v2);
+ assertFetchedQueried(false, false, filter, v1, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path1, path3);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path2,
path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ }
- testRoundTrip(ColumnFilter.selection(metadata,
metadata.partitionColumns().without(v1)), metadata,
MessagingService.VERSION_30);
- testRoundTrip(ColumnFilter.selection(metadata,
metadata.partitionColumns().without(v1)), metadata,
MessagingService.VERSION_3014);
+ @Test
+ public void testSelectIndividualCellsFromStatic() throws Exception
+ {
+ ColumnFilter filter = ColumnFilter.selectionBuilder().select(s2,
path1).select(s2, path3).build();
+ testRoundTrips(filter);
+ assertEquals("[s2[1], s2[3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, s2);
+ assertFetchedQueried(false, false, filter, v1, v2, s1);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path1, path3);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path2,
path4);
}
- static void testRoundTrip(ColumnFilter columnFilter, CFMetaData metadata,
int version) throws Exception
+ @Test
+ public void testSelectCellSlice() throws Exception
{
- DataOutputBuffer output = new DataOutputBuffer();
- serializer.serialize(columnFilter, output, version);
- Assert.assertEquals(serializer.serializedSize(columnFilter, version),
output.position());
- DataInputPlus input = new DataInputBuffer(output.buffer(), false);
- Assert.assertEquals(serializer.deserialize(input, version, metadata),
columnFilter);
+ ColumnFilter filter = ColumnFilter.selectionBuilder().slice(v2, path1,
path3).build();
+ testRoundTrips(filter);
+ assertEquals("[v2[1:3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, v2);
+ assertFetchedQueried(false, false, filter, v1, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path1, path2, path3);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ }
+
+ @Test
+ public void testSelectCellSliceFromStatic() throws Exception
+ {
+ ColumnFilter filter = ColumnFilter.selectionBuilder().slice(s2, path1,
path3).build();
+ testRoundTrips(filter);
+ assertEquals("[s2[1:3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, s2);
+ assertFetchedQueried(false, false, filter, v1, v2, s1);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path1, path2, path3);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path4);
+ }
+
+ @Test
+ public void testSelectColumnsWithCellsAndSlices() throws Exception
+ {
+ ColumnFilter filter =
ColumnFilter.selectionBuilder().add(v1).add(s1).slice(v2, path0,
path2).select(v2, path4).select(s2, path0).slice(s2, path2, path4).build();
Review comment:
Nit: we could break this long line:
```suggestion
ColumnFilter filter = ColumnFilter.selectionBuilder()
.add(v1)
.add(s1)
.slice(v2, path0, path2)
.select(v2, path4)
.select(s2, path0)
.slice(s2, path2, path4)
.build();
```
##########
File path: test/unit/org/apache/cassandra/db/filter/ColumnFilterTest.java
##########
@@ -18,53 +18,348 @@
package org.apache.cassandra.db.filter;
+import java.io.IOException;
+import java.util.function.Consumer;
+
+import com.google.common.base.Throwables;
+import org.junit.Assert;
import org.junit.Test;
-import junit.framework.Assert;
import org.apache.cassandra.config.CFMetaData;
import org.apache.cassandra.config.ColumnDefinition;
+import org.apache.cassandra.db.PartitionColumns;
import org.apache.cassandra.db.marshal.Int32Type;
+import org.apache.cassandra.db.marshal.SetType;
+import org.apache.cassandra.db.rows.CellPath;
import org.apache.cassandra.dht.Murmur3Partitioner;
import org.apache.cassandra.io.util.DataInputBuffer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.net.MessagingService;
import org.apache.cassandra.utils.ByteBufferUtil;
+import static org.junit.Assert.assertEquals;
+
public class ColumnFilterTest
{
- final static ColumnFilter.Serializer serializer = new
ColumnFilter.Serializer();
+ private static final ColumnFilter.Serializer serializer = new
ColumnFilter.Serializer();
+
+ private final CFMetaData metadata = CFMetaData.Builder.create("ks",
"table")
+
.withPartitioner(Murmur3Partitioner.instance)
+
.addPartitionKey("pk", Int32Type.instance)
+
.addClusteringColumn("ck", Int32Type.instance)
+
.addStaticColumn("s1", Int32Type.instance)
+
.addStaticColumn("s2", SetType.getInstance(Int32Type.instance, true))
+
.addRegularColumn("v1", Int32Type.instance)
+
.addRegularColumn("v2", SetType.getInstance(Int32Type.instance, true))
+ .build();
+
+ private final ColumnDefinition s1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("s1"));
+ private final ColumnDefinition s2 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("s2"));
+ private final ColumnDefinition v1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v1"));
+ private final ColumnDefinition v2 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v2"));
+ private final CellPath path0 = CellPath.create(ByteBufferUtil.bytes(0));
+ private final CellPath path1 = CellPath.create(ByteBufferUtil.bytes(1));
+ private final CellPath path2 = CellPath.create(ByteBufferUtil.bytes(2));
+ private final CellPath path3 = CellPath.create(ByteBufferUtil.bytes(3));
+ private final CellPath path4 = CellPath.create(ByteBufferUtil.bytes(4));
+
+ // Select all
+
+ @Test
+ public void testSelectAll() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+ check.accept(ColumnFilter.all(metadata));
+ check.accept(ColumnFilter.allColumnsBuilder(metadata).build());
+ }
+
+ // Selections
+
+ @Test
+ public void testSelectNothing() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[]", filter.toString());
+ assertFetchedQueried(false, false, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+ check.accept(ColumnFilter.selection(PartitionColumns.NONE));
+ check.accept(ColumnFilter.selectionBuilder().build());
+ }
+
+ @Test
+ public void testSelectSimpleColumn() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[v1]", filter.toString());
+ assertFetchedQueried(true, true, filter, v1);
+ assertFetchedQueried(false, false, filter, v2, s1, s2);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(v1).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(v1).build());
+ }
+
+ @Test
+ public void testSelectComplexColumn() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[v2]", filter.toString());
+ assertFetchedQueried(true, true, filter, v2);
+ assertFetchedQueried(false, false, filter, v1, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(v2).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(v2).build());
+ }
@Test
- public void columnFilterSerialisationRoundTrip() throws Exception
+ public void testSelectStaticColumn() throws Exception
{
- CFMetaData metadata = CFMetaData.Builder.create("ks", "table")
-
.withPartitioner(Murmur3Partitioner.instance)
- .addPartitionKey("pk",
Int32Type.instance)
- .addClusteringColumn("ck",
Int32Type.instance)
- .addRegularColumn("v1",
Int32Type.instance)
- .addRegularColumn("v2",
Int32Type.instance)
- .addRegularColumn("v3",
Int32Type.instance)
- .build();
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[s1]", filter.toString());
+ assertFetchedQueried(true, true, filter, s1);
+ assertFetchedQueried(false, false, filter, v1, v2, s2);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(s1).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(s1).build());
+ }
+
+ @Test
+ public void testSelectStaticComplexColumn() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[s2]", filter.toString());
+ assertFetchedQueried(true, true, filter, s2);
+ assertFetchedQueried(false, false, filter, v1, v2, s1);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(s2).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(s2).build());
+ }
- ColumnDefinition v1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v1"));
+ @Test
+ public void testSelectColumns() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[s1, s2, v1, v2]", filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
- testRoundTrip(ColumnFilter.all(metadata), metadata,
MessagingService.VERSION_30);
- testRoundTrip(ColumnFilter.all(metadata), metadata,
MessagingService.VERSION_3014);
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(v1).add(v2).add(s1).add(s2).build()));
+
check.accept(ColumnFilter.selectionBuilder().add(v1).add(v2).add(s1).add(s2).build());
+ }
-
testRoundTrip(ColumnFilter.selection(metadata.partitionColumns().without(v1)),
metadata, MessagingService.VERSION_30);
-
testRoundTrip(ColumnFilter.selection(metadata.partitionColumns().without(v1)),
metadata, MessagingService.VERSION_3014);
+ @Test
+ public void testSelectIndividualCells() throws Exception
+ {
+ ColumnFilter filter = ColumnFilter.selectionBuilder().select(v2,
path1).select(v2, path3).build();
+ testRoundTrips(filter);
+ assertEquals("[v2[1], v2[3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, v2);
+ assertFetchedQueried(false, false, filter, v1, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path1, path3);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path2,
path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ }
- testRoundTrip(ColumnFilter.selection(metadata,
metadata.partitionColumns().without(v1)), metadata,
MessagingService.VERSION_30);
- testRoundTrip(ColumnFilter.selection(metadata,
metadata.partitionColumns().without(v1)), metadata,
MessagingService.VERSION_3014);
+ @Test
+ public void testSelectIndividualCellsFromStatic() throws Exception
+ {
+ ColumnFilter filter = ColumnFilter.selectionBuilder().select(s2,
path1).select(s2, path3).build();
+ testRoundTrips(filter);
+ assertEquals("[s2[1], s2[3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, s2);
+ assertFetchedQueried(false, false, filter, v1, v2, s1);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path1, path3);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path2,
path4);
}
- static void testRoundTrip(ColumnFilter columnFilter, CFMetaData metadata,
int version) throws Exception
+ @Test
+ public void testSelectCellSlice() throws Exception
{
- DataOutputBuffer output = new DataOutputBuffer();
- serializer.serialize(columnFilter, output, version);
- Assert.assertEquals(serializer.serializedSize(columnFilter, version),
output.position());
- DataInputPlus input = new DataInputBuffer(output.buffer(), false);
- Assert.assertEquals(serializer.deserialize(input, version, metadata),
columnFilter);
+ ColumnFilter filter = ColumnFilter.selectionBuilder().slice(v2, path1,
path3).build();
+ testRoundTrips(filter);
+ assertEquals("[v2[1:3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, v2);
+ assertFetchedQueried(false, false, filter, v1, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path1, path2, path3);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ }
+
+ @Test
+ public void testSelectCellSliceFromStatic() throws Exception
+ {
+ ColumnFilter filter = ColumnFilter.selectionBuilder().slice(s2, path1,
path3).build();
+ testRoundTrips(filter);
+ assertEquals("[s2[1:3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, s2);
+ assertFetchedQueried(false, false, filter, v1, v2, s1);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path1, path2, path3);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path4);
+ }
+
+ @Test
+ public void testSelectColumnsWithCellsAndSlices() throws Exception
+ {
+ ColumnFilter filter =
ColumnFilter.selectionBuilder().add(v1).add(s1).slice(v2, path0,
path2).select(v2, path4).select(s2, path0).slice(s2, path2, path4).build();
+ testRoundTrips(filter);
+ assertEquals("[s1, s2[0], s2[2:4], v1, v2[0:2], v2[4]]",
filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1, path2,
path4);
+ assertCellFetchedQueried(false, false, filter, v2, path3);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path2, path3,
path4);
+ assertCellFetchedQueried(false, false, filter, s2, path1);
+ }
+
+ // select with metadata
+
+ @Test
+ public void testSelectSimpleColumnWithMetadata() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertFetchedQueried(true, true, filter, v1);
+
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, s1, s2, v2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+ check.accept(ColumnFilter.selection(metadata,
PartitionColumns.builder().add(v1).build()));
+ check.accept(ColumnFilter.allColumnsBuilder(metadata).add(v1).build());
+ }
+
+ @Test
+ public void testSelectStaticColumnWithMetadata() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertFetchedQueried(true, true, filter, s1);
+
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+ check.accept(ColumnFilter.selection(metadata,
PartitionColumns.builder().add(s1).build()));
+ check.accept(ColumnFilter.allColumnsBuilder(metadata).add(s1).build());
+ }
+
+ @Test
+ public void testSelectCellWithMetadata() throws Exception
+ {
+ ColumnFilter filter =
ColumnFilter.allColumnsBuilder(metadata).select(v2, path1).build();
+ testRoundTrips(filter);
+ assertFetchedQueried(true, true, filter, v2);
+
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, s1, s2, v1);
+ assertCellFetchedQueried(true, true, filter, v2, path1);
+ assertCellFetchedQueried(true, false, filter, v2, path0, path2, path3,
path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1, path2,
path3, path4);
+ }
+
+ @Test
+ public void testSelectStaticColumnCellWithMetadata() throws Exception
+ {
+ ColumnFilter filter =
ColumnFilter.allColumnsBuilder(metadata).select(s2, path1).build();
+ testRoundTrips(filter);
+ assertFetchedQueried(true, true, filter, s2);
+
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s1);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1, path2,
path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path1);
+ assertCellFetchedQueried(true, false, filter, s2, path0, path2, path3,
path4);
+ }
+
+ private void testRoundTrips(ColumnFilter cf)
+ {
+ testRoundTrip(cf, MessagingService.VERSION_30);
+ testRoundTrip(cf, MessagingService.VERSION_3014);
+ }
+
+ private void testRoundTrip(ColumnFilter columnFilter, int version)
+ {
+ try
+ {
+ DataOutputBuffer output = new DataOutputBuffer();
+ serializer.serialize(columnFilter, output, version);
+ Assert.assertEquals(serializer.serializedSize(columnFilter,
version), output.position());
+ DataInputPlus input = new DataInputBuffer(output.buffer(), false);
+ ColumnFilter deserialized = serializer.deserialize(input, version,
metadata);
+ Assert.assertEquals(deserialized, columnFilter);
+ }
+ catch (IOException e)
+ {
+ throw Throwables.propagate(e);
+ }
+ }
+
+ private static void assertFetchedQueried(boolean expectedFetched,
+ boolean expectedQueried,
+ ColumnFilter filter,
+ ColumnDefinition... columns)
+ {
+ for (ColumnDefinition column : columns)
+ {
+ assertEquals(String.format("Expected fetches(%s) to be %s",
column.name, expectedFetched), expectedFetched, filter.includes(column));
+ if (expectedFetched)
+ assertEquals(String.format("Expected
fetchedColumnIsQueried(%s) to be %s", column.name, expectedQueried),
expectedQueried, !filter.canSkipValue(column));
+ }
Review comment:
It seems that the error messages here are mentioning the methods used in
3.11, not the ones actually used. Also, we could break the lines.
##########
File path: test/unit/org/apache/cassandra/db/filter/ColumnFilterTest.java
##########
@@ -18,53 +18,348 @@
package org.apache.cassandra.db.filter;
+import java.io.IOException;
+import java.util.function.Consumer;
+
+import com.google.common.base.Throwables;
+import org.junit.Assert;
import org.junit.Test;
-import junit.framework.Assert;
import org.apache.cassandra.config.CFMetaData;
import org.apache.cassandra.config.ColumnDefinition;
+import org.apache.cassandra.db.PartitionColumns;
import org.apache.cassandra.db.marshal.Int32Type;
+import org.apache.cassandra.db.marshal.SetType;
+import org.apache.cassandra.db.rows.CellPath;
import org.apache.cassandra.dht.Murmur3Partitioner;
import org.apache.cassandra.io.util.DataInputBuffer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.net.MessagingService;
import org.apache.cassandra.utils.ByteBufferUtil;
+import static org.junit.Assert.assertEquals;
+
public class ColumnFilterTest
{
- final static ColumnFilter.Serializer serializer = new
ColumnFilter.Serializer();
+ private static final ColumnFilter.Serializer serializer = new
ColumnFilter.Serializer();
+
+ private final CFMetaData metadata = CFMetaData.Builder.create("ks",
"table")
+
.withPartitioner(Murmur3Partitioner.instance)
+
.addPartitionKey("pk", Int32Type.instance)
+
.addClusteringColumn("ck", Int32Type.instance)
+
.addStaticColumn("s1", Int32Type.instance)
+
.addStaticColumn("s2", SetType.getInstance(Int32Type.instance, true))
+
.addRegularColumn("v1", Int32Type.instance)
+
.addRegularColumn("v2", SetType.getInstance(Int32Type.instance, true))
+ .build();
+
+ private final ColumnDefinition s1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("s1"));
+ private final ColumnDefinition s2 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("s2"));
+ private final ColumnDefinition v1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v1"));
+ private final ColumnDefinition v2 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v2"));
+ private final CellPath path0 = CellPath.create(ByteBufferUtil.bytes(0));
+ private final CellPath path1 = CellPath.create(ByteBufferUtil.bytes(1));
+ private final CellPath path2 = CellPath.create(ByteBufferUtil.bytes(2));
+ private final CellPath path3 = CellPath.create(ByteBufferUtil.bytes(3));
+ private final CellPath path4 = CellPath.create(ByteBufferUtil.bytes(4));
+
+ // Select all
+
+ @Test
+ public void testSelectAll() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+ check.accept(ColumnFilter.all(metadata));
+ check.accept(ColumnFilter.allColumnsBuilder(metadata).build());
+ }
+
+ // Selections
+
+ @Test
+ public void testSelectNothing() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[]", filter.toString());
+ assertFetchedQueried(false, false, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+ check.accept(ColumnFilter.selection(PartitionColumns.NONE));
+ check.accept(ColumnFilter.selectionBuilder().build());
+ }
+
+ @Test
+ public void testSelectSimpleColumn() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[v1]", filter.toString());
+ assertFetchedQueried(true, true, filter, v1);
+ assertFetchedQueried(false, false, filter, v2, s1, s2);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(v1).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(v1).build());
+ }
+
+ @Test
+ public void testSelectComplexColumn() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[v2]", filter.toString());
+ assertFetchedQueried(true, true, filter, v2);
+ assertFetchedQueried(false, false, filter, v1, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(v2).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(v2).build());
+ }
@Test
- public void columnFilterSerialisationRoundTrip() throws Exception
+ public void testSelectStaticColumn() throws Exception
{
- CFMetaData metadata = CFMetaData.Builder.create("ks", "table")
-
.withPartitioner(Murmur3Partitioner.instance)
- .addPartitionKey("pk",
Int32Type.instance)
- .addClusteringColumn("ck",
Int32Type.instance)
- .addRegularColumn("v1",
Int32Type.instance)
- .addRegularColumn("v2",
Int32Type.instance)
- .addRegularColumn("v3",
Int32Type.instance)
- .build();
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[s1]", filter.toString());
+ assertFetchedQueried(true, true, filter, s1);
+ assertFetchedQueried(false, false, filter, v1, v2, s2);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(s1).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(s1).build());
+ }
+
+ @Test
+ public void testSelectStaticComplexColumn() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[s2]", filter.toString());
+ assertFetchedQueried(true, true, filter, s2);
+ assertFetchedQueried(false, false, filter, v1, v2, s1);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(s2).build()));
+ check.accept(ColumnFilter.selectionBuilder().add(s2).build());
+ }
- ColumnDefinition v1 =
metadata.getColumnDefinition(ByteBufferUtil.bytes("v1"));
+ @Test
+ public void testSelectColumns() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertEquals("[s1, s2, v1, v2]", filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
- testRoundTrip(ColumnFilter.all(metadata), metadata,
MessagingService.VERSION_30);
- testRoundTrip(ColumnFilter.all(metadata), metadata,
MessagingService.VERSION_3014);
+
check.accept(ColumnFilter.selection(PartitionColumns.builder().add(v1).add(v2).add(s1).add(s2).build()));
+
check.accept(ColumnFilter.selectionBuilder().add(v1).add(v2).add(s1).add(s2).build());
+ }
-
testRoundTrip(ColumnFilter.selection(metadata.partitionColumns().without(v1)),
metadata, MessagingService.VERSION_30);
-
testRoundTrip(ColumnFilter.selection(metadata.partitionColumns().without(v1)),
metadata, MessagingService.VERSION_3014);
+ @Test
+ public void testSelectIndividualCells() throws Exception
+ {
+ ColumnFilter filter = ColumnFilter.selectionBuilder().select(v2,
path1).select(v2, path3).build();
+ testRoundTrips(filter);
+ assertEquals("[v2[1], v2[3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, v2);
+ assertFetchedQueried(false, false, filter, v1, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path1, path3);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path2,
path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ }
- testRoundTrip(ColumnFilter.selection(metadata,
metadata.partitionColumns().without(v1)), metadata,
MessagingService.VERSION_30);
- testRoundTrip(ColumnFilter.selection(metadata,
metadata.partitionColumns().without(v1)), metadata,
MessagingService.VERSION_3014);
+ @Test
+ public void testSelectIndividualCellsFromStatic() throws Exception
+ {
+ ColumnFilter filter = ColumnFilter.selectionBuilder().select(s2,
path1).select(s2, path3).build();
+ testRoundTrips(filter);
+ assertEquals("[s2[1], s2[3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, s2);
+ assertFetchedQueried(false, false, filter, v1, v2, s1);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path1, path3);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path2,
path4);
}
- static void testRoundTrip(ColumnFilter columnFilter, CFMetaData metadata,
int version) throws Exception
+ @Test
+ public void testSelectCellSlice() throws Exception
{
- DataOutputBuffer output = new DataOutputBuffer();
- serializer.serialize(columnFilter, output, version);
- Assert.assertEquals(serializer.serializedSize(columnFilter, version),
output.position());
- DataInputPlus input = new DataInputBuffer(output.buffer(), false);
- Assert.assertEquals(serializer.deserialize(input, version, metadata),
columnFilter);
+ ColumnFilter filter = ColumnFilter.selectionBuilder().slice(v2, path1,
path3).build();
+ testRoundTrips(filter);
+ assertEquals("[v2[1:3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, v2);
+ assertFetchedQueried(false, false, filter, v1, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path1, path2, path3);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path4);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path1,
path2, path3, path4);
+ }
+
+ @Test
+ public void testSelectCellSliceFromStatic() throws Exception
+ {
+ ColumnFilter filter = ColumnFilter.selectionBuilder().slice(s2, path1,
path3).build();
+ testRoundTrips(filter);
+ assertEquals("[s2[1:3]]", filter.toString());
+ assertFetchedQueried(true, true, filter, s2);
+ assertFetchedQueried(false, false, filter, v1, v2, s1);
+ assertCellFetchedQueried(false, false, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path1, path2, path3);
+ assertCellFetchedQueried(false, false, filter, s2, path0, path4);
+ }
+
+ @Test
+ public void testSelectColumnsWithCellsAndSlices() throws Exception
+ {
+ ColumnFilter filter =
ColumnFilter.selectionBuilder().add(v1).add(s1).slice(v2, path0,
path2).select(v2, path4).select(s2, path0).slice(s2, path2, path4).build();
+ testRoundTrips(filter);
+ assertEquals("[s1, s2[0], s2[2:4], v1, v2[0:2], v2[4]]",
filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s1, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1, path2,
path4);
+ assertCellFetchedQueried(false, false, filter, v2, path3);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path2, path3,
path4);
+ assertCellFetchedQueried(false, false, filter, s2, path1);
+ }
+
+ // select with metadata
+
+ @Test
+ public void testSelectSimpleColumnWithMetadata() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertFetchedQueried(true, true, filter, v1);
+
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, s1, s2, v2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+ check.accept(ColumnFilter.selection(metadata,
PartitionColumns.builder().add(v1).build()));
+ check.accept(ColumnFilter.allColumnsBuilder(metadata).add(v1).build());
+ }
+
+ @Test
+ public void testSelectStaticColumnWithMetadata() throws Exception
+ {
+ Consumer<ColumnFilter> check = filter -> {
+ testRoundTrips(filter);
+ assertFetchedQueried(true, true, filter, s1);
+
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s2);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1,
path2, path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1,
path2, path3, path4);
+ };
+
+ check.accept(ColumnFilter.selection(metadata,
PartitionColumns.builder().add(s1).build()));
+ check.accept(ColumnFilter.allColumnsBuilder(metadata).add(s1).build());
+ }
+
+ @Test
+ public void testSelectCellWithMetadata() throws Exception
+ {
+ ColumnFilter filter =
ColumnFilter.allColumnsBuilder(metadata).select(v2, path1).build();
+ testRoundTrips(filter);
+ assertFetchedQueried(true, true, filter, v2);
+
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, s1, s2, v1);
+ assertCellFetchedQueried(true, true, filter, v2, path1);
+ assertCellFetchedQueried(true, false, filter, v2, path0, path2, path3,
path4);
+ assertCellFetchedQueried(true, true, filter, s2, path0, path1, path2,
path3, path4);
+ }
+
+ @Test
+ public void testSelectStaticColumnCellWithMetadata() throws Exception
+ {
+ ColumnFilter filter =
ColumnFilter.allColumnsBuilder(metadata).select(s2, path1).build();
+ testRoundTrips(filter);
+ assertFetchedQueried(true, true, filter, s2);
+
+ assertEquals("*/*", filter.toString());
+ assertFetchedQueried(true, true, filter, v1, v2, s1);
+ assertCellFetchedQueried(true, true, filter, v2, path0, path1, path2,
path3, path4);
+ assertCellFetchedQueried(true, true, filter, s2, path1);
+ assertCellFetchedQueried(true, false, filter, s2, path0, path2, path3,
path4);
+ }
+
+ private void testRoundTrips(ColumnFilter cf)
+ {
+ testRoundTrip(cf, MessagingService.VERSION_30);
+ testRoundTrip(cf, MessagingService.VERSION_3014);
+ }
+
+ private void testRoundTrip(ColumnFilter columnFilter, int version)
+ {
+ try
+ {
+ DataOutputBuffer output = new DataOutputBuffer();
+ serializer.serialize(columnFilter, output, version);
+ Assert.assertEquals(serializer.serializedSize(columnFilter,
version), output.position());
+ DataInputPlus input = new DataInputBuffer(output.buffer(), false);
+ ColumnFilter deserialized = serializer.deserialize(input, version,
metadata);
+ Assert.assertEquals(deserialized, columnFilter);
+ }
+ catch (IOException e)
+ {
+ throw Throwables.propagate(e);
+ }
+ }
+
+ private static void assertFetchedQueried(boolean expectedFetched,
+ boolean expectedQueried,
+ ColumnFilter filter,
+ ColumnDefinition... columns)
+ {
+ for (ColumnDefinition column : columns)
+ {
+ assertEquals(String.format("Expected fetches(%s) to be %s",
column.name, expectedFetched), expectedFetched, filter.includes(column));
+ if (expectedFetched)
+ assertEquals(String.format("Expected
fetchedColumnIsQueried(%s) to be %s", column.name, expectedQueried),
expectedQueried, !filter.canSkipValue(column));
+ }
+ }
+
+ private static void assertCellFetchedQueried(boolean expectedFetched,
+ boolean expectedQueried,
+ ColumnFilter filter,
+ ColumnDefinition column,
+ CellPath... paths)
+ {
+ ColumnFilter.Tester tester = filter.newTester(column);
+
+ for (CellPath path : paths)
+ {
+ int p = ByteBufferUtil.toInt(path.get(0));
+
+ if (tester != null)
+ {
+ assertEquals(String.format("Expected includesAllColumns ||
tester.includes(%s:%s) to be %s", column.name, p, expectedFetched),
expectedFetched, tester.includes(path));
+ if (expectedFetched)
+ assertEquals(String.format("Expected
tester.includes(%s:%s) to be %s", column.name, p, expectedQueried),
expectedQueried, !tester.canSkipValue(path));
Review comment:
As before, the error messages here are mentioning the methods used in
3.11 and the long lines could be broken.
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
