package com.netflix.astyanax.cql.test;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import junit.framework.Assert;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.log4j.Logger;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import com.netflix.astyanax.ColumnListMutation;
import com.netflix.astyanax.MutationBatch;
import com.netflix.astyanax.connectionpool.OperationResult;
import com.netflix.astyanax.connectionpool.exceptions.ConnectionException;
import com.netflix.astyanax.connectionpool.exceptions.NotFoundException;
import com.netflix.astyanax.model.Column;
import com.netflix.astyanax.model.ColumnFamily;
import com.netflix.astyanax.model.ColumnList;
import com.netflix.astyanax.model.ColumnSlice;
import com.netflix.astyanax.model.ConsistencyLevel;
import com.netflix.astyanax.model.CqlResult;
import com.netflix.astyanax.model.Row;
import com.netflix.astyanax.model.Rows;
import com.netflix.astyanax.query.ColumnQuery;
import com.netflix.astyanax.query.RowQuery;
import com.netflix.astyanax.serializers.ObjectSerializer;
import com.netflix.astyanax.serializers.StringSerializer;
import com.netflix.astyanax.util.RangeBuilder;
public class CFStandardTests extends KeyspaceTests {
private static final Logger LOG = Logger.getLogger(CFStandardTests.class);
public static ColumnFamily<String, String> CF_STANDARD1 = ColumnFamily
.newColumnFamily(
"Standard1",
StringSerializer.get(),
StringSerializer.get());
public static ColumnFamily<String, String> CF_STANDARD2 = ColumnFamily
.newColumnFamily(
"Standard2",
StringSerializer.get(),
StringSerializer.get());
private static ColumnFamily<String, String> CF_USER_INFO = ColumnFamily.newColumnFamily(
"UserInfo", // Column Family Name
StringSerializer.get(), // Key Serializer
StringSerializer.get()); // Column Serializer
@BeforeClass
public static void init() throws Exception {
initContext();
keyspace.createColumnFamily(CF_STANDARD1, null);
keyspace.createColumnFamily(CF_STANDARD2, null);
keyspace.createColumnFamily(CF_USER_INFO, null);
CF_STANDARD1.describe(keyspace);
CF_STANDARD2.describe(keyspace);
CF_USER_INFO.describe(keyspace);
}
@AfterClass
public static void tearDown() throws Exception {
keyspace.dropColumnFamily(CF_STANDARD1);
keyspace.dropColumnFamily(CF_STANDARD2);
keyspace.dropColumnFamily(CF_USER_INFO);
}
@Test
public void testSerializedClassValue() throws Exception {
UserInfo smo = new UserInfo();
smo.setLastName("Landau");
smo.setFirstName("Eran");
ByteBuffer bb = ObjectSerializer.get().toByteBuffer(smo);
keyspace.prepareColumnMutation(CF_STANDARD1, "Key_SerializeTest",
"Column1").putValue(bb, null).execute();
UserInfo smo2 = (UserInfo) keyspace.prepareQuery(CF_STANDARD1)
.getKey("Key_SerializeTest").getColumn("Column1").execute()
.getResult().getValue(ObjectSerializer.get());
Assert.assertEquals(smo, smo2);
}
@Test
public void testSingleOps() throws Exception {
String key = "SingleOpsTest";
Random prng = new Random();
// Set a string value
{
String column = "StringColumn";
String value = RandomStringUtils.randomAlphanumeric(32);
// Set
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.putValue(value, null).execute();
// Read
ColumnQuery<String> query = keyspace.prepareQuery(CF_STANDARD1).getKey(key).getColumn(column);
String v = query.execute().getResult().getStringValue();
Assert.assertEquals(value, v);
// Delete
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.deleteColumn().execute();
try {
keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult()
.getStringValue();
Assert.fail();
} catch (RuntimeException e) {
} catch (NotFoundException e) {
} catch (ConnectionException e) {
e.printStackTrace();
Assert.fail();
}
}
// Set a byte value
{
String column = "ByteColumn";
byte value = (byte) prng.nextInt(Byte.MAX_VALUE);
// Set
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.putValue(value, null).execute();
// Read
byte v = keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getByteValue();
Assert.assertEquals(value, v);
// Delete
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.deleteColumn().execute();
// verify column gone
try {
keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getByteValue();
Assert.fail();
} catch (NullPointerException e) {
} catch (NotFoundException e) {
// expected
}
}
// Set a short value
{
String column = "ShortColumn";
short value = (short) prng.nextInt(Short.MAX_VALUE);
// Set
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.putValue(value, null).execute();
// Read
short v = keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getShortValue();
Assert.assertEquals(value, v);
// Delete
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.deleteColumn().execute();
// verify column gone
try {
keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getShortValue();
Assert.fail();
} catch (NullPointerException e) {
// expected
} catch (NotFoundException e) {
// expected
}
}
// Set a int value
{
String column = "IntColumn";
int value = prng.nextInt();
// Set
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.putValue(value, null).execute();
// Read
int v = keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getIntegerValue();
Assert.assertEquals(value, v);
// Delete
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.deleteColumn().execute();
// verify column gone
try {
keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getIntegerValue();
Assert.fail();
} catch (NullPointerException e) {
// expected
} catch (NotFoundException e) {
// expected
}
}
// Set a long value
{
String column = "LongColumn";
long value = prng.nextLong();
// Set
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.putValue(value, null).execute();
// Read
long v = keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getLongValue();
Assert.assertEquals(value, v);
// get as integer should fail
try {
keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult()
.getIntegerValue();
Assert.fail();
} catch (Exception e) {
// expected
}
// Delete
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.deleteColumn().execute();
// verify column gone
try {
keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getLongValue();
Assert.fail();
} catch (NullPointerException e) {
// expected
} catch (NotFoundException e) {
// expected
}
}
// Set a float value
{
String column = "FloatColumn";
float value = prng.nextFloat();
// Set
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.putValue(value, null).execute();
// Read
float v = keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getFloatValue();
Assert.assertEquals(value, v);
// Delete
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.deleteColumn().execute();
// verify column gone
try {
keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getFloatValue();
Assert.fail();
} catch (NullPointerException e) {
// expected
} catch (NotFoundException e) {
// expected
}
}
// Set a double value
{
String column = "DoubleColumn";
double value = prng.nextDouble();
// Set
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.putValue(value, null).execute();
// Read
double v = keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult().getDoubleValue();
Assert.assertEquals(value, v);
// get as integer should fail
try {
keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult()
.getIntegerValue();
Assert.fail();
} catch (Exception e) {
// expected
}
// Delete
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.deleteColumn().execute();
try {
keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult()
.getDoubleValue();
Assert.fail();
} catch (NullPointerException e) {
// expected
} catch (NotFoundException e) {
} catch (ConnectionException e) {
Assert.fail();
}
}
// Set long column with timestamp
{
String column = "TimestampColumn";
long value = prng.nextLong();
// Set
keyspace.prepareColumnMutation(CF_STANDARD1, key, column)
.withTimestamp(100)
.putValue(value, null)
.execute();
// Read
Column<String> c = keyspace.prepareQuery(CF_STANDARD1).getKey(key)
.getColumn(column).execute().getResult();
Assert.assertEquals(100, c.getTimestamp());
}
}
@Test
public void testEmptyColumn() {
ColumnListMutation<String> mutation = keyspace.prepareMutationBatch().withRow(CF_STANDARD1, "ABC");
try {
mutation.putColumn(null, 1L);
Assert.fail();
}
catch (Exception e) {
LOG.info(e.getMessage());
}
try {
mutation.putColumn("", 1L);
Assert.fail();
}
catch (Exception e) {
LOG.info(e.getMessage());
}
try {
mutation.deleteColumn("");
Assert.fail();
}
catch (Exception e) {
LOG.info(e.getMessage());
}
try {
mutation.deleteColumn(null);
Assert.fail();
}
catch (Exception e) {
LOG.info(e.getMessage());
}
}
@Test
public void testCqlCount() throws Exception {
LOG.info("CQL Test");
OperationResult<CqlResult<String, String>> result = keyspace
.prepareQuery(CF_STANDARD1)
.withCql("SELECT count(*) FROM astyanaxunittests.standard1 where KEY='A';")
.execute();
long count = result.getResult().getNumber();
LOG.info("CQL Count: " + count);
Assert.assertTrue(0 <= count);
}
@Test
public void testGetSingleColumn() throws Exception {
keyspace.prepareColumnMutation(CF_STANDARD1, "A", "a").putValue(1, null).execute();
Column<String> column = keyspace.prepareQuery(CF_STANDARD1).getRow("A").getColumn("a").execute().getResult();
Assert.assertNotNull(column);
Assert.assertEquals(1, column.getIntegerValue());
}
@Test
public void testGetSingleKeyNotExists() throws Exception {
Column<String> column = keyspace.prepareQuery(CF_STANDARD1).getRow("AA").getColumn("ab").execute().getResult();
Assert.assertNull(column);
}
@Test
public void testFunctionalQuery() throws Exception {
MutationBatch m = keyspace.prepareMutationBatch();
for (char keyName = 'A'; keyName <= 'Z'; keyName++) {
String rowKey = Character.toString(keyName);
ColumnListMutation<String> cfmStandard = m.withRow(CF_STANDARD1, rowKey);
for (char cName = 'a'; cName <= 'z'; cName++) {
cfmStandard.putColumn(Character.toString(cName),
(int) (cName - 'a') + 1, null);
}
m.withCaching(true);
m.execute();
m.discardMutations();
}
OperationResult<ColumnList<String>> r1 = keyspace
.prepareQuery(CF_STANDARD1).getKey("A").execute();
Assert.assertTrue(26 <= r1.getResult().size());
}
@Test
public void testNullKeyInMutation() throws Exception {
try {
keyspace.prepareMutationBatch().withRow(CF_STANDARD1, null).putColumn("abc", "def");
Assert.fail();
}
catch (Exception e) {
}
}
@Test
public void testColumnSlice() throws ConnectionException {
OperationResult<ColumnList<String>> r1 = keyspace
.prepareQuery(CF_STANDARD1).getKey("A")
.withColumnSlice("a", "b").execute();
Assert.assertEquals(2, r1.getResult().size());
}
@Test
public void testColumnRangeSlice() throws ConnectionException {
OperationResult<ColumnList<String>> r1 = keyspace
.prepareQuery(CF_STANDARD1)
.getKey("A")
.withColumnRange(
new RangeBuilder().setStart("a").setEnd("b")
.setLimit(5).build()).execute();
Assert.assertEquals(2, r1.getResult().size());
OperationResult<ColumnList<String>> r2 = keyspace
.prepareQuery(CF_STANDARD1).getKey("A")
.withColumnRange("a", null, false, 5).execute();
Assert.assertEquals(5, r2.getResult().size());
Assert.assertEquals("a", r2.getResult().getColumnByIndex(0).getName());
ByteBuffer EMPTY_BUFFER = ByteBuffer.wrap(new byte[0]);
OperationResult<ColumnList<String>> r3 = keyspace
.prepareQuery(CF_STANDARD1).getKey("A")
.withColumnRange(EMPTY_BUFFER, EMPTY_BUFFER, true, 5).execute();
Assert.assertEquals(5, r3.getResult().size());
Assert.assertEquals("z", r3.getResult().getColumnByIndex(0).getName());
}
@Test
public void testGetSingleColumnNotExists() throws ConnectionException {
Column<String> column = keyspace.prepareQuery(CF_STANDARD1).getRow("A").getColumn("DoesNotExist").execute().getResult();
Assert.assertNull(column);
}
@Test
public void testGetSingleColumnNotExistsAsync() {
Future<OperationResult<Column<String>>> future = null;
try {
future = keyspace.prepareQuery(CF_STANDARD1).getKey("A")
.getColumn("DoesNotExist").executeAsync();
future.get(1000, TimeUnit.MILLISECONDS);
} catch (ConnectionException e) {
LOG.info("ConnectionException: " + e.getMessage());
Assert.fail();
} catch (InterruptedException e) {
LOG.info(e.getMessage());
Assert.fail();
} catch (ExecutionException e) {
if (e.getCause() instanceof NotFoundException)
LOG.info(e.getCause().getMessage());
else {
Assert.fail(e.getMessage());
}
} catch (TimeoutException e) {
future.cancel(true);
LOG.info(e.getMessage());
Assert.fail();
}
}
@Test
public void testGetSingleKey() throws ConnectionException {
for (char key = 'A'; key <= 'Z'; key++) {
String keyName = Character.toString(key);
OperationResult<ColumnList<String>> result = keyspace.prepareQuery(CF_STANDARD1).getKey(keyName).execute();
Assert.assertNotNull(result.getResult());
Assert.assertFalse(result.getResult().isEmpty());
}
}
@Test
public void testGetSingleKeyAsync() throws Exception {
Future<OperationResult<ColumnList<String>>> future = keyspace.prepareQuery(CF_STANDARD1).getKey("A").executeAsync();
ColumnList<String> result = future.get(1000, TimeUnit.MILLISECONDS).getResult();
Assert.assertFalse(result.isEmpty());
}
@Test
public void testGetAllKeysRoot() throws ConnectionException {
LOG.info("Starting testGetAllKeysRoot...");
List<String> keys = new ArrayList<String>();
for (char key = 'A'; key <= 'Z'; key++) {
String keyName = Character.toString(key);
keys.add(keyName);
}
OperationResult<Rows<String, String>> result = keyspace
.prepareQuery(CF_STANDARD1)
.getKeySlice(keys.toArray(new String[keys.size()]))
.execute();
Assert.assertEquals(26, result.getResult().size());
Row<String, String> row;
row = result.getResult().getRow("A");
Assert.assertEquals("A", row.getKey());
row = result.getResult().getRow("B");
Assert.assertEquals("B", row.getKey());
row = result.getResult().getRow("NonExistent");
Assert.assertNull(row);
row = result.getResult().getRowByIndex(10);
Assert.assertEquals("K", row.getKey());
LOG.info("... testGetAllKeysRoot");
}
@Test
public void testEmptyRowKey() {
try {
keyspace.prepareMutationBatch().withRow(CF_STANDARD1, "");
Assert.fail();
}
catch (Exception e) {
LOG.info(e.getMessage());
}
try {
keyspace.prepareMutationBatch().withRow(CF_STANDARD1, null);
Assert.fail();
}
catch (Exception e) {
LOG.info(e.getMessage());
}
}
@Test
public void testGetColumnSlice() throws ConnectionException {
LOG.info("Starting testGetColumnSlice...");
OperationResult<ColumnList<String>> result = keyspace
.prepareQuery(CF_STANDARD1)
.getKey("A")
.withColumnSlice(
new ColumnSlice<String>("c", "h").setLimit(5))
.execute();
Assert.assertNotNull(result.getResult());
Assert.assertEquals(5, result.getResult().size());
}
@Test
public void testGetAllKeysPath() throws ConnectionException {
LOG.info("Starting testGetAllKeysPath...");
List<String> keys = new ArrayList<String>();
for (char key = 'A'; key <= 'Z'; key++) {
String keyName = Character.toString(key);
keys.add(keyName);
}
OperationResult<Rows<String, String>> result = keyspace
.prepareQuery(CF_STANDARD1)
.getKeySlice(keys.toArray(new String[keys.size()]))
.execute();
for (Row<String, String> row : result.getResult()) {
System.out.println(row.getColumns().size());
}
OperationResult<Map<String, Integer>> counts = keyspace
.prepareQuery(CF_STANDARD1)
.getKeySlice(keys.toArray(new String[keys.size()]))
.getColumnCounts()
.execute();
Assert.assertEquals(26, counts.getResult().size());
for (Entry<String, Integer> count : counts.getResult().entrySet()) {
Assert.assertEquals(new Integer(26), count.getValue());
}
LOG.info("Starting testGetAllKeysPath...");
}
public static class UserInfo implements Serializable {
private static final long serialVersionUID = 6366200973810770033L;
private String firstName;
private String lastName;
public UserInfo() {
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getFirstName() {
return this.firstName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getLastName() {
return this.lastName;
}
public boolean equals(Object other) {
UserInfo smo = (UserInfo) other;
return firstName.equals(smo.firstName)
&& lastName.equals(smo.lastName);
}
}
@Test
public void testHasValue() throws Exception {
MutationBatch m = keyspace.prepareMutationBatch();
m.withRow(CF_USER_INFO, "acct1234")
.putColumn("firstname", "john", null)
.putColumn("lastname", "smith", null)
.putColumn("address", "555 Elm St", null)
.putColumn("age", 30, null)
.putEmptyColumn("empty");
m.execute();
ColumnList<String> response = keyspace.prepareQuery(CF_USER_INFO).getRow("acct1234").execute().getResult();
Assert.assertEquals("firstname", response.getColumnByName("firstname").getName());
Assert.assertEquals("firstname", response.getColumnByName("firstname").getName());
Assert.assertEquals("john", response.getColumnByName("firstname").getStringValue());
Assert.assertEquals("john", response.getColumnByName("firstname").getStringValue());
Assert.assertEquals(true, response.getColumnByName("firstname").hasValue());
Assert.assertEquals(false, response.getColumnByName("empty").hasValue());
}
@Test
public void testDelete() throws Exception {
LOG.info("Starting testDelete...");
String rowKey = "DeleteMe_testDelete";
MutationBatch m = keyspace.prepareMutationBatch();
m.withRow(CF_STANDARD1, rowKey).putColumn("Column1", "X", null).putColumn("Column2", "X", null);
m.execute();
Column<String> column = keyspace.prepareQuery(CF_STANDARD1).getRow(rowKey).getColumn("Column1").execute().getResult();
Assert.assertEquals("X", column.getStringValue());
m = keyspace.prepareMutationBatch();
m.withRow(CF_STANDARD1, rowKey).deleteColumn("Column1");
m.execute();
column = keyspace.prepareQuery(CF_STANDARD1).getRow(rowKey).getColumn("Column1").execute().getResult();
Assert.assertNull(column);
LOG.info("... testDelete");
}
@Test
public void testDeleteLotsOfColumns() throws Exception {
LOG.info("Starting testDelete...");
String rowKey = "DeleteMe_testDeleteLotsOfColumns";
int nColumns = 100;
int pageSize = 25;
// Insert a bunch of rows
MutationBatch m = keyspace.prepareMutationBatch();
ColumnListMutation<String> rm = m.withRow(CF_STANDARD1, rowKey);
for (int i = 0; i < nColumns; i++) {
rm.putEmptyColumn("" + i, null);
}
m.execute();
// Verify count
int count = keyspace.prepareQuery(CF_STANDARD1)
.setConsistencyLevel(ConsistencyLevel.CL_QUORUM)
.getKey(rowKey).getCount().execute().getResult();
Assert.assertEquals(nColumns, count);
// Delete half of the columns
m = keyspace.prepareMutationBatch().setConsistencyLevel(ConsistencyLevel.CL_QUORUM);
rm = m.withRow(CF_STANDARD1, rowKey);
for (int i = 0; i < nColumns / 2; i++) {
rm.deleteColumn("" + i);
}
m.execute();
// Verify count
count = keyspace.prepareQuery(CF_STANDARD1)
.setConsistencyLevel(ConsistencyLevel.CL_QUORUM)
.getKey(rowKey).getCount().execute().getResult();
Assert.assertEquals(nColumns / 2, count);
// GET ROW COUNT WITH PAGINATION
RowQuery<String, String> query = keyspace.prepareQuery(CF_STANDARD1)
.setConsistencyLevel(ConsistencyLevel.CL_QUORUM).getKey(rowKey)
.withColumnRange(new RangeBuilder().setLimit(pageSize).build())
.autoPaginate(true);
ColumnList<String> result;
count = 0;
while (!(result = query.execute().getResult()).isEmpty()) {
count += result.size();
}
Assert.assertEquals(nColumns / 2, count);
// Delete all of the columns
m = keyspace.prepareMutationBatch().setConsistencyLevel(ConsistencyLevel.CL_QUORUM);
rm = m.withRow(CF_STANDARD1, rowKey);
for (int i = 0; i < nColumns; i++) {
rm.deleteColumn("" + i);
}
m.execute();
// Verify count
count = keyspace.prepareQuery(CF_STANDARD1)
.setConsistencyLevel(ConsistencyLevel.CL_QUORUM)
.getKey(rowKey).getCount().execute().getResult();
Assert.assertEquals(0, count);
LOG.info("... testDelete");
}
@Test
public void testCopy() throws ConnectionException {
String keyName = "A";
keyspace.prepareQuery(CF_STANDARD1).getKey(keyName).copyTo(CF_STANDARD2, keyName).execute();
ColumnList<String> list1 = keyspace.prepareQuery(CF_STANDARD1).getKey(keyName).execute().getResult();
ColumnList<String> list2 = keyspace.prepareQuery(CF_STANDARD2).getKey(keyName).execute().getResult();
Iterator<Column<String>> iter1 = list1.iterator();
Iterator<Column<String>> iter2 = list2.iterator();
while (iter1.hasNext()) {
Column<String> column1 = iter1.next();
Column<String> column2 = iter2.next();
Assert.assertEquals(column1.getName(), column2.getName());
Assert.assertEquals(column1.getByteBufferValue(),column2.getByteBufferValue());
}
Assert.assertFalse(iter2.hasNext());
}
@Test
public void testMutationMerge() throws Exception {
MutationBatch m1 = keyspace.prepareMutationBatch();
MutationBatch m2 = keyspace.prepareMutationBatch();
MutationBatch m3 = keyspace.prepareMutationBatch();
MutationBatch m4 = keyspace.prepareMutationBatch();
MutationBatch m5 = keyspace.prepareMutationBatch();
m1.withRow(CF_STANDARD1, "1").putColumn("1", "X", null);
m2.withRow(CF_STANDARD1, "2").putColumn("2", "X", null).putColumn("3", "X", null);
m3.withRow(CF_STANDARD1, "3").putColumn("4", "X", null).putColumn("5", "X", null).putColumn("6", "X", null);
m4.withRow(CF_STANDARD1, "1").putColumn("7", "X", null).putColumn("8", "X", null).putColumn("9", "X", null).putColumn("10", "X", null);
MutationBatch merged = keyspace.prepareMutationBatch();
Assert.assertEquals(merged.getRowCount(), 0);
merged.mergeShallow(m1);
Assert.assertEquals(merged.getRowCount(), 1);
merged.mergeShallow(m2);
Assert.assertEquals(merged.getRowCount(), 2);
merged.mergeShallow(m3);
Assert.assertEquals(merged.getRowCount(), 3);
merged.mergeShallow(m4);
Assert.assertEquals(merged.getRowCount(), 3);
merged.mergeShallow(m5);
Assert.assertEquals(merged.getRowCount(), 3);
merged.execute();
Rows<String, String> result = keyspace.prepareQuery(CF_STANDARD1).getRowSlice("1", "2", "3").execute().getResult();
Assert.assertTrue(5 == result.getRow("1").getColumns().size());
Assert.assertTrue(2 == result.getRow("2").getColumns().size());
Assert.assertTrue(3 == result.getRow("3").getColumns().size());
}
}