/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with this
* work for additional information regarding copyright ownership. The ASF
* licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package org.apache.pig.backend.hadoop.accumulo;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.accumulo.core.data.ColumnUpdate;
import org.apache.accumulo.core.data.Key;
import org.apache.accumulo.core.data.Mutation;
import org.apache.accumulo.core.data.Value;
import org.apache.accumulo.core.iterators.user.WholeRowIterator;
import org.apache.commons.cli.ParseException;
import org.apache.pig.data.DataByteArray;
import org.apache.pig.data.DataType;
import org.apache.pig.data.InternalMap;
import org.apache.pig.data.Tuple;
import org.apache.pig.data.TupleFactory;
import org.junit.Assert;
import org.junit.Test;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
public class TestAccumuloStorage {
@Test
public void testWrite1Tuple() throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage();
Tuple t = TupleFactory.getInstance().newTuple(1);
t.set(0, "row");
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(0, mutations.size());
}
@Test(expected = ClassCastException.class)
public void testWriteLiteralAsMap() throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage();
Tuple t = TupleFactory.getInstance().newTuple(2);
t.set(0, "row");
t.set(1, "value");
storage.getMutations(t).size();
}
@Test(expected = ClassCastException.class)
public void testWriteLiteralAsMapWithAsterisk() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage("*");
Tuple t = TupleFactory.getInstance().newTuple(2);
t.set(0, "row");
t.set(1, "value");
storage.getMutations(t).size();
}
@Test
public void testWrite2TupleWithColumn() throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage("col");
Tuple t = TupleFactory.getInstance().newTuple(2);
t.set(0, "row");
t.set(1, "value");
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(1, mutations.size());
Mutation m = mutations.iterator().next();
Assert.assertTrue("Rows not equal",
Arrays.equals(m.getRow(), ((String) t.get(0)).getBytes()));
List<ColumnUpdate> colUpdates = m.getUpdates();
Assert.assertEquals(1, colUpdates.size());
ColumnUpdate colUpdate = colUpdates.get(0);
Assert.assertTrue("CF not equal",
Arrays.equals(colUpdate.getColumnFamily(), "col".getBytes()));
Assert.assertTrue("CQ not equal",
Arrays.equals(colUpdate.getColumnQualifier(), new byte[0]));
Assert.assertTrue("Values not equal",
Arrays.equals(colUpdate.getValue(), "value".getBytes()));
}
@Test
public void testWrite2TupleWithColumnQual() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage("col:qual");
Tuple t = TupleFactory.getInstance().newTuple(2);
t.set(0, "row");
t.set(1, "value");
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(1, mutations.size());
Mutation m = mutations.iterator().next();
Assert.assertTrue("Rows not equal",
Arrays.equals(m.getRow(), ((String) t.get(0)).getBytes()));
List<ColumnUpdate> colUpdates = m.getUpdates();
Assert.assertEquals(1, colUpdates.size());
ColumnUpdate colUpdate = colUpdates.get(0);
Assert.assertTrue("CF not equal",
Arrays.equals(colUpdate.getColumnFamily(), "col".getBytes()));
Assert.assertTrue("CQ not equal", Arrays.equals(
colUpdate.getColumnQualifier(), "qual".getBytes()));
Assert.assertTrue("Values not equal",
Arrays.equals(colUpdate.getValue(), "value".getBytes()));
}
@Test
public void testWrite2TupleWithMixedColumns() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage(
"col1,col1:qual,col2:qual,col2");
Tuple t = TupleFactory.getInstance().newTuple(5);
t.set(0, "row");
t.set(1, "value1");
t.set(2, "value2");
t.set(3, "value3");
t.set(4, "value4");
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(1, mutations.size());
Mutation m = mutations.iterator().next();
Assert.assertTrue("Rows not equal",
Arrays.equals(m.getRow(), ((String) t.get(0)).getBytes()));
List<ColumnUpdate> colUpdates = m.getUpdates();
Assert.assertEquals(4, colUpdates.size());
ColumnUpdate colUpdate = colUpdates.get(0);
Assert.assertTrue("CF not equal",
Arrays.equals(colUpdate.getColumnFamily(), "col1".getBytes()));
Assert.assertTrue("CQ not equal",
Arrays.equals(colUpdate.getColumnQualifier(), new byte[0]));
Assert.assertTrue("Values not equal",
Arrays.equals(colUpdate.getValue(), "value1".getBytes()));
colUpdate = colUpdates.get(1);
Assert.assertTrue("CF not equal",
Arrays.equals(colUpdate.getColumnFamily(), "col1".getBytes()));
Assert.assertTrue("CQ not equal", Arrays.equals(
colUpdate.getColumnQualifier(), "qual".getBytes()));
Assert.assertTrue("Values not equal",
Arrays.equals(colUpdate.getValue(), "value2".getBytes()));
colUpdate = colUpdates.get(2);
Assert.assertTrue("CF not equal",
Arrays.equals(colUpdate.getColumnFamily(), "col2".getBytes()));
Assert.assertTrue("CQ not equal", Arrays.equals(
colUpdate.getColumnQualifier(), "qual".getBytes()));
Assert.assertTrue("Values not equal",
Arrays.equals(colUpdate.getValue(), "value3".getBytes()));
colUpdate = colUpdates.get(3);
Assert.assertTrue("CF not equal",
Arrays.equals(colUpdate.getColumnFamily(), "col2".getBytes()));
Assert.assertTrue("CQ not equal",
Arrays.equals(colUpdate.getColumnQualifier(), new byte[0]));
Assert.assertTrue("Values not equal",
Arrays.equals(colUpdate.getValue(), "value4".getBytes()));
}
@Test
public void testWriteIgnoredExtraColumns() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage("col");
Tuple t = TupleFactory.getInstance().newTuple(3);
t.set(0, "row");
t.set(1, "value1");
t.set(2, "value2");
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(1, mutations.size());
Mutation m = mutations.iterator().next();
Assert.assertTrue("Rows not equal",
Arrays.equals(m.getRow(), ((String) t.get(0)).getBytes()));
List<ColumnUpdate> colUpdates = m.getUpdates();
Assert.assertEquals(1, colUpdates.size());
ColumnUpdate colUpdate = colUpdates.get(0);
Assert.assertTrue("CF not equal",
Arrays.equals(colUpdate.getColumnFamily(), "col".getBytes()));
Assert.assertTrue("CQ not equal",
Arrays.equals(colUpdate.getColumnQualifier(), new byte[0]));
Assert.assertTrue("Values not equal",
Arrays.equals(colUpdate.getValue(), "value1".getBytes()));
}
@Test
public void testWriteIgnoredExtraMap() throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage("col1");
Map<String, Object> map = Maps.newHashMap();
map.put("mapcol1", "mapval1");
map.put("mapcol2", "mapval2");
map.put("mapcol3", "mapval3");
map.put("mapcol4", "mapval4");
Tuple t = TupleFactory.getInstance().newTuple(3);
t.set(0, "row");
t.set(1, "value1");
t.set(2, map);
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(1, mutations.size());
Mutation m = mutations.iterator().next();
Assert.assertTrue("Rows not equal",
Arrays.equals(m.getRow(), ((String) t.get(0)).getBytes()));
List<ColumnUpdate> colUpdates = m.getUpdates();
Assert.assertEquals(1, colUpdates.size());
ColumnUpdate update = colUpdates.get(0);
Assert.assertEquals("col1", new String(update.getColumnFamily()));
Assert.assertEquals("", new String(update.getColumnQualifier()));
Assert.assertEquals("value1", new String(update.getValue()));
}
@Test
public void testWriteMultipleColumnsWithNonExpandedMap()
throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage("col1,col2");
Map<String, Object> map = Maps.newHashMap();
map.put("mapcol1", "mapval1");
map.put("mapcol2", "mapval2");
map.put("mapcol3", "mapval3");
map.put("mapcol4", "mapval4");
Tuple t = TupleFactory.getInstance().newTuple(3);
t.set(0, "row");
t.set(1, "value1");
t.set(2, map);
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(1, mutations.size());
Mutation m = mutations.iterator().next();
Assert.assertTrue("Rows not equal",
Arrays.equals(m.getRow(), ((String) t.get(0)).getBytes()));
List<ColumnUpdate> colUpdates = m.getUpdates();
Assert.assertEquals(2, colUpdates.size());
ColumnUpdate update = colUpdates.get(0);
Assert.assertEquals("col1", new String(update.getColumnFamily()));
Assert.assertEquals("", new String(update.getColumnQualifier()));
Assert.assertEquals("value1", new String(update.getValue()));
update = colUpdates.get(1);
Assert.assertEquals("col2", new String(update.getColumnFamily()));
Assert.assertEquals("", new String(update.getColumnQualifier()));
Assert.assertArrayEquals(storage.objToBytes(map, DataType.MAP),
update.getValue());
}
@Test
public void testWriteMultipleColumnsWithExpandedMap() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage("col1,col2:");
Map<String, Object> map = Maps.newHashMap();
map.put("mapcol1", "mapval1");
map.put("mapcol2", "mapval2");
map.put("mapcol3", "mapval3");
map.put("mapcol4", "mapval4");
Tuple t = TupleFactory.getInstance().newTuple(3);
t.set(0, "row");
t.set(1, "value1");
t.set(2, map);
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(1, mutations.size());
Mutation m = mutations.iterator().next();
Assert.assertTrue("Rows not equal",
Arrays.equals(m.getRow(), ((String) t.get(0)).getBytes()));
List<ColumnUpdate> colUpdates = m.getUpdates();
Assert.assertEquals(5, colUpdates.size());
ColumnUpdate update = colUpdates.get(0);
Assert.assertEquals("col1", new String(update.getColumnFamily()));
Assert.assertEquals("", new String(update.getColumnQualifier()));
Assert.assertEquals("value1", new String(update.getValue()));
Map<Entry<String, String>, String> expectations = Maps.newHashMap();
expectations.put(Maps.immutableEntry("col2", "mapcol1"), "mapval1");
expectations.put(Maps.immutableEntry("col2", "mapcol2"), "mapval2");
expectations.put(Maps.immutableEntry("col2", "mapcol3"), "mapval3");
expectations.put(Maps.immutableEntry("col2", "mapcol4"), "mapval4");
for (int i = 1; i < 5; i++) {
update = colUpdates.get(i);
Entry<String, String> key = Maps.immutableEntry(
new String(update.getColumnFamily()),
new String(update.getColumnQualifier()));
String value = new String(update.getValue());
Assert.assertTrue("Did not find expected key: " + key,
expectations.containsKey(key));
String actual = expectations.remove(key);
Assert.assertEquals(value, actual);
}
Assert.assertTrue("Did not find all expectations",
expectations.isEmpty());
}
@Test
public void testWriteMapWithColFamWithColon() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage("col:");
Map<String, Object> map = Maps.newHashMap();
map.put("mapcol1", "mapval1");
map.put("mapcol2", "mapval2");
map.put("mapcol3", "mapval3");
map.put("mapcol4", "mapval4");
Tuple t = TupleFactory.getInstance().newTuple(2);
t.set(0, "row");
t.set(1, map);
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(1, mutations.size());
Mutation m = mutations.iterator().next();
Assert.assertTrue("Rows not equal",
Arrays.equals(m.getRow(), ((String) t.get(0)).getBytes()));
List<ColumnUpdate> colUpdates = m.getUpdates();
Assert.assertEquals(4, colUpdates.size());
Map<Entry<String, String>, String> expectations = Maps.newHashMap();
expectations.put(Maps.immutableEntry("col", "mapcol1"), "mapval1");
expectations.put(Maps.immutableEntry("col", "mapcol2"), "mapval2");
expectations.put(Maps.immutableEntry("col", "mapcol3"), "mapval3");
expectations.put(Maps.immutableEntry("col", "mapcol4"), "mapval4");
for (ColumnUpdate update : colUpdates) {
Entry<String, String> key = Maps.immutableEntry(
new String(update.getColumnFamily()),
new String(update.getColumnQualifier()));
String value = new String(update.getValue());
Assert.assertTrue("Did not find expected key: " + key,
expectations.containsKey(key));
String actual = expectations.remove(key);
Assert.assertEquals(value, actual);
}
Assert.assertTrue("Did not find all expectations",
expectations.isEmpty());
}
@Test
public void testWriteMapWithColFamWithColonAsterisk() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage("col:*");
Map<String, Object> map = Maps.newHashMap();
map.put("mapcol1", "mapval1");
map.put("mapcol2", "mapval2");
map.put("mapcol3", "mapval3");
map.put("mapcol4", "mapval4");
Tuple t = TupleFactory.getInstance().newTuple(2);
t.set(0, "row");
t.set(1, map);
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(1, mutations.size());
Mutation m = mutations.iterator().next();
Assert.assertTrue("Rows not equal",
Arrays.equals(m.getRow(), ((String) t.get(0)).getBytes()));
List<ColumnUpdate> colUpdates = m.getUpdates();
Assert.assertEquals(4, colUpdates.size());
Map<Entry<String, String>, String> expectations = Maps.newHashMap();
expectations.put(Maps.immutableEntry("col", "mapcol1"), "mapval1");
expectations.put(Maps.immutableEntry("col", "mapcol2"), "mapval2");
expectations.put(Maps.immutableEntry("col", "mapcol3"), "mapval3");
expectations.put(Maps.immutableEntry("col", "mapcol4"), "mapval4");
for (ColumnUpdate update : colUpdates) {
Entry<String, String> key = Maps.immutableEntry(
new String(update.getColumnFamily()),
new String(update.getColumnQualifier()));
String value = new String(update.getValue());
Assert.assertTrue("Did not find expected key: " + key,
expectations.containsKey(key));
String actual = expectations.remove(key);
Assert.assertEquals(value, actual);
}
Assert.assertTrue("Did not find all expectations",
expectations.isEmpty());
}
@Test
public void testWriteMapWithColFamColQualPrefix() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage("col:qual_*");
Map<String, Object> map = Maps.newHashMap();
map.put("mapcol1", "mapval1");
map.put("mapcol2", "mapval2");
map.put("mapcol3", "mapval3");
map.put("mapcol4", "mapval4");
Tuple t = TupleFactory.getInstance().newTuple(2);
t.set(0, "row");
t.set(1, map);
Collection<Mutation> mutations = storage.getMutations(t);
Assert.assertEquals(1, mutations.size());
Mutation m = mutations.iterator().next();
Assert.assertTrue("Rows not equal",
Arrays.equals(m.getRow(), ((String) t.get(0)).getBytes()));
List<ColumnUpdate> colUpdates = m.getUpdates();
Assert.assertEquals(4, colUpdates.size());
Map<Entry<String, String>, String> expectations = Maps.newHashMap();
expectations.put(Maps.immutableEntry("col", "qual_mapcol1"), "mapval1");
expectations.put(Maps.immutableEntry("col", "qual_mapcol2"), "mapval2");
expectations.put(Maps.immutableEntry("col", "qual_mapcol3"), "mapval3");
expectations.put(Maps.immutableEntry("col", "qual_mapcol4"), "mapval4");
for (ColumnUpdate update : colUpdates) {
Entry<String, String> key = Maps.immutableEntry(
new String(update.getColumnFamily()),
new String(update.getColumnQualifier()));
String value = new String(update.getValue());
Assert.assertTrue(expectations.containsKey(key));
String actual = expectations.remove(key);
Assert.assertEquals(value, actual);
}
Assert.assertTrue("Did not find all expectations",
expectations.isEmpty());
}
@Test
public void testReadSingleKey() throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage();
List<Key> keys = Lists.newArrayList();
List<Value> values = Lists.newArrayList();
keys.add(new Key("1", "", "col1"));
values.add(new Value("value1".getBytes()));
Key k = new Key("1");
Value v = WholeRowIterator.encodeRow(keys, values);
Tuple t = storage.getTuple(k, v);
Assert.assertEquals(2, t.size());
Assert.assertEquals("1", t.get(0).toString());
InternalMap map = new InternalMap();
map.put(":col1", new DataByteArray("value1"));
Assert.assertEquals(map, t.get(1));
}
@Test
public void testReadSingleColumn() throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage();
List<Key> keys = Lists.newArrayList();
List<Value> values = Lists.newArrayList();
keys.add(new Key("1", "col1", "cq1"));
keys.add(new Key("1", "col1", "cq2"));
keys.add(new Key("1", "col1", "cq3"));
values.add(new Value("value1".getBytes()));
values.add(new Value("value2".getBytes()));
values.add(new Value("value3".getBytes()));
Key k = new Key("1");
Value v = WholeRowIterator.encodeRow(keys, values);
Tuple t = storage.getTuple(k, v);
Assert.assertEquals(2, t.size());
Assert.assertEquals("1", t.get(0).toString());
InternalMap map = new InternalMap();
map.put("col1:cq1", new DataByteArray("value1"));
map.put("col1:cq2", new DataByteArray("value2"));
map.put("col1:cq3", new DataByteArray("value3"));
Assert.assertEquals(map, t.get(1));
}
@Test
public void testReadMultipleColumnsAggregateColfamsAsterisk()
throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage("*");
List<Key> keys = Lists.newArrayList();
List<Value> values = Lists.newArrayList();
keys.add(new Key("1", "col1", "cq1"));
keys.add(new Key("1", "col1", "cq2"));
keys.add(new Key("1", "col1", "cq3"));
keys.add(new Key("1", "col2", "cq1"));
keys.add(new Key("1", "col3", "cq1"));
keys.add(new Key("1", "col3", "cq2"));
values.add(new Value("value1".getBytes()));
values.add(new Value("value2".getBytes()));
values.add(new Value("value3".getBytes()));
values.add(new Value("value1".getBytes()));
values.add(new Value("value1".getBytes()));
values.add(new Value("value2".getBytes()));
Key k = new Key("1");
Value v = WholeRowIterator.encodeRow(keys, values);
Tuple t = storage.getTuple(k, v);
Assert.assertEquals(2, t.size());
Assert.assertEquals("1", t.get(0).toString());
InternalMap map = new InternalMap();
map.put("col1:cq1", new DataByteArray("value1"));
map.put("col1:cq2", new DataByteArray("value2"));
map.put("col1:cq3", new DataByteArray("value3"));
map.put("col2:cq1", new DataByteArray("value1"));
map.put("col3:cq1", new DataByteArray("value1"));
map.put("col3:cq2", new DataByteArray("value2"));
Assert.assertEquals(map, t.get(1));
}
@Test
public void testReadMultipleColumnsAggregateColfamsAsteriskEmptyColfam()
throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage("*");
List<Key> keys = Lists.newArrayList();
List<Value> values = Lists.newArrayList();
keys.add(new Key("1", "col1", ""));
keys.add(new Key("1", "col2", ""));
keys.add(new Key("1", "col3", ""));
values.add(new Value("value1".getBytes()));
values.add(new Value("value2".getBytes()));
values.add(new Value("value3".getBytes()));
Key k = new Key("1");
Value v = WholeRowIterator.encodeRow(keys, values);
Tuple t = storage.getTuple(k, v);
Assert.assertEquals(2, t.size());
Assert.assertEquals("1", t.get(0).toString());
InternalMap map = new InternalMap();
map.put("col1", new DataByteArray("value1"));
map.put("col2", new DataByteArray("value2"));
map.put("col3", new DataByteArray("value3"));
Assert.assertEquals(map, t.get(1));
}
@Test
public void testReadMultipleColumnsEmptyString() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage("");
List<Key> keys = Lists.newArrayList();
List<Value> values = Lists.newArrayList();
keys.add(new Key("1", "col1", "cq1"));
keys.add(new Key("1", "col1", "cq2"));
keys.add(new Key("1", "col1", "cq3"));
keys.add(new Key("1", "col2", "cq1"));
keys.add(new Key("1", "col3", "cq1"));
keys.add(new Key("1", "col3", "cq2"));
values.add(new Value("value1".getBytes()));
values.add(new Value("value2".getBytes()));
values.add(new Value("value3".getBytes()));
values.add(new Value("value1".getBytes()));
values.add(new Value("value1".getBytes()));
values.add(new Value("value2".getBytes()));
Key k = new Key("1");
Value v = WholeRowIterator.encodeRow(keys, values);
Tuple t = storage.getTuple(k, v);
Assert.assertEquals(2, t.size());
Assert.assertEquals("1", t.get(0).toString());
InternalMap map = new InternalMap();
map.put("col1:cq1", new DataByteArray("value1"));
map.put("col1:cq2", new DataByteArray("value2"));
map.put("col1:cq3", new DataByteArray("value3"));
map.put("col2:cq1", new DataByteArray("value1"));
map.put("col3:cq1", new DataByteArray("value1"));
map.put("col3:cq2", new DataByteArray("value2"));
Assert.assertEquals(map, t.get(1));
}
@Test
public void testReadMultipleColumnsNoColfamAggregate() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage();
List<Key> keys = Lists.newArrayList();
List<Value> values = Lists.newArrayList();
keys.add(new Key("1", "col1", "cq1"));
keys.add(new Key("1", "col1", "cq2"));
keys.add(new Key("1", "col1", "cq3"));
keys.add(new Key("1", "col2", "cq1"));
keys.add(new Key("1", "col3", "cq1"));
keys.add(new Key("1", "col3", "cq2"));
values.add(new Value("value1".getBytes()));
values.add(new Value("value2".getBytes()));
values.add(new Value("value3".getBytes()));
values.add(new Value("value1".getBytes()));
values.add(new Value("value1".getBytes()));
values.add(new Value("value2".getBytes()));
Key k = new Key("1");
Value v = WholeRowIterator.encodeRow(keys, values);
Tuple t = storage.getTuple(k, v);
Assert.assertEquals(2, t.size());
Assert.assertEquals("1", t.get(0).toString());
InternalMap map = new InternalMap();
map.put("col1:cq1", new DataByteArray("value1"));
map.put("col1:cq2", new DataByteArray("value2"));
map.put("col1:cq3", new DataByteArray("value3"));
map.put("col2:cq1", new DataByteArray("value1"));
map.put("col3:cq1", new DataByteArray("value1"));
map.put("col3:cq2", new DataByteArray("value2"));
Assert.assertEquals(map, t.get(1));
}
@Test
public void testReadMultipleScalars() throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage("col1,col3,col5");
List<Key> keys = Lists.newArrayList();
List<Value> values = Lists.newArrayList();
// Filtering by AccumuloInputFormat isn't applied here since we're
// shortcircuiting things
keys.add(new Key("1", "col1", ""));
// keys.add(new Key("1", "col2", ""));
keys.add(new Key("1", "col3", ""));
// keys.add(new Key("1", "col4", ""));
keys.add(new Key("1", "col5", ""));
values.add(new Value("value1".getBytes()));
// values.add(new Value("value2".getBytes()));
values.add(new Value("value3".getBytes()));
// values.add(new Value("value4".getBytes()));
values.add(new Value("value5".getBytes()));
Key k = new Key("1");
Value v = WholeRowIterator.encodeRow(keys, values);
Tuple t = storage.getTuple(k, v);
Assert.assertEquals(4, t.size());
Assert.assertEquals("1", t.get(0).toString());
Assert.assertEquals("value1", t.get(1).toString());
Assert.assertEquals("value3", t.get(2).toString());
Assert.assertEquals("value5", t.get(3).toString());
}
@Test
public void testUnsortedColumnList() throws IOException, ParseException {
AccumuloStorage storage = new AccumuloStorage("z,a");
List<Key> keys = Lists.newArrayList();
List<Value> values = Lists.newArrayList();
keys.add(new Key("1", "a", ""));
keys.add(new Key("1", "z", ""));
values.add(new Value("a".getBytes()));
values.add(new Value("z".getBytes()));
Key k = new Key("1");
Value v = WholeRowIterator.encodeRow(keys, values);
Tuple t = storage.getTuple(k, v);
Assert.assertEquals(3, t.size());
Assert.assertEquals("z", t.get(1).toString());
Assert.assertEquals("a", t.get(2).toString());
}
@Test
public void testReadMultipleScalarsAndMaps() throws IOException,
ParseException {
AccumuloStorage storage = new AccumuloStorage("z,r:,m:2,b:");
List<Key> keys = Lists.newArrayList();
List<Value> values = Lists.newArrayList();
keys.add(new Key("1", "a", "1"));
keys.add(new Key("1", "b", "1"));
keys.add(new Key("1", "b", "2"));
keys.add(new Key("1", "f", "1"));
keys.add(new Key("1", "f", "2"));
keys.add(new Key("1", "m", "1"));
keys.add(new Key("1", "m", "2"));
keys.add(new Key("1", "r", "1"));
keys.add(new Key("1", "r", "2"));
keys.add(new Key("1", "r", "3"));
keys.add(new Key("1", "z", ""));
values.add(new Value("a1".getBytes()));
values.add(new Value("b1".getBytes()));
values.add(new Value("b2".getBytes()));
values.add(new Value("f1".getBytes()));
values.add(new Value("f2".getBytes()));
values.add(new Value("m1".getBytes()));
values.add(new Value("m2".getBytes()));
values.add(new Value("r1".getBytes()));
values.add(new Value("r2".getBytes()));
values.add(new Value("r3".getBytes()));
values.add(new Value("z1".getBytes()));
Key k = new Key("1");
Value v = WholeRowIterator.encodeRow(keys, values);
Tuple t = storage.getTuple(k, v);
Assert.assertEquals(5, t.size());
Assert.assertEquals(new DataByteArray("z1".getBytes()), t.get(1));
HashMap<String, DataByteArray> rMap = new HashMap<String, DataByteArray>();
rMap.put("r:1", new DataByteArray("r1".getBytes()));
rMap.put("r:2", new DataByteArray("r2".getBytes()));
rMap.put("r:3", new DataByteArray("r3".getBytes()));
Assert.assertEquals(rMap, t.get(2));
Assert.assertEquals(new DataByteArray("m2".getBytes()), t.get(3));
HashMap<String, DataByteArray> bMap = new HashMap<String, DataByteArray>();
bMap.put("b:1", new DataByteArray("b1".getBytes()));
bMap.put("b:2", new DataByteArray("b2".getBytes()));
Assert.assertEquals(bMap, t.get(4));
}
}