use of org.apache.drill.exec.physical.rowSet.RowSet.SingleRowSet in project drill by apache.
the class TestVariantAccessors method testUnionWithMap.
/**
* Test a variant (AKA "union vector") at the top level which
* includes a map.
*/
@Test
public void testUnionWithMap() {
final TupleMetadata schema = new SchemaBuilder().addUnion("u").addType(MinorType.VARCHAR).addMap().addNullable("a", MinorType.INT).addNullable("b", MinorType.VARCHAR).resumeUnion().resumeSchema().buildSchema();
SingleRowSet result;
// Write values
{
final ExtendableRowSet rs = fixture.rowSet(schema);
final RowSetWriter writer = rs.writer();
// Sanity check of writer structure
final ObjectWriter wo = writer.column(0);
assertEquals(ObjectType.VARIANT, wo.type());
final VariantWriter vw = wo.variant();
assertTrue(vw.hasType(MinorType.VARCHAR));
final ObjectWriter strObj = vw.member(MinorType.VARCHAR);
final ScalarWriter strWriter = strObj.scalar();
assertSame(strWriter, vw.scalar(MinorType.VARCHAR));
assertTrue(vw.hasType(MinorType.MAP));
final ObjectWriter mapObj = vw.member(MinorType.MAP);
final TupleWriter mWriter = mapObj.tuple();
assertSame(mWriter, vw.tuple());
final ScalarWriter aWriter = mWriter.scalar("a");
final ScalarWriter bWriter = mWriter.scalar("b");
// First row: string "first"
vw.setType(MinorType.VARCHAR);
strWriter.setString("first");
writer.save();
// Second row: a map
vw.setType(MinorType.MAP);
aWriter.setInt(20);
bWriter.setString("fred");
writer.save();
// Third row: null
vw.setNull();
writer.save();
// Fourth row: map with a null string
vw.setType(MinorType.MAP);
aWriter.setInt(40);
bWriter.setNull();
writer.save();
// Fifth row: string "last"
vw.setType(MinorType.VARCHAR);
strWriter.setString("last");
writer.save();
result = writer.done();
assertEquals(5, result.rowCount());
}
// Read the values.
{
final RowSetReader reader = result.reader();
// Sanity check of structure
final ObjectReader ro = reader.column(0);
assertEquals(ObjectType.VARIANT, ro.type());
final VariantReader vr = ro.variant();
assertTrue(vr.hasType(MinorType.VARCHAR));
final ObjectReader strObj = vr.member(MinorType.VARCHAR);
final ScalarReader strReader = strObj.scalar();
assertSame(strReader, vr.scalar(MinorType.VARCHAR));
assertTrue(vr.hasType(MinorType.MAP));
final ObjectReader mapObj = vr.member(MinorType.MAP);
final TupleReader mReader = mapObj.tuple();
assertSame(mReader, vr.tuple());
final ScalarReader aReader = mReader.scalar("a");
final ScalarReader bReader = mReader.scalar("b");
// First row: string "first"
assertTrue(reader.next());
assertFalse(vr.isNull());
assertEquals(MinorType.VARCHAR, vr.dataType());
assertFalse(strReader.isNull());
assertTrue(mReader.isNull());
assertEquals("first", strReader.getString());
// Second row: a map
assertTrue(reader.next());
assertFalse(vr.isNull());
assertEquals(MinorType.MAP, vr.dataType());
assertTrue(strReader.isNull());
assertFalse(mReader.isNull());
assertFalse(aReader.isNull());
assertEquals(20, aReader.getInt());
assertFalse(bReader.isNull());
assertEquals("fred", bReader.getString());
// Third row: null
assertTrue(reader.next());
assertTrue(vr.isNull());
assertTrue(strReader.isNull());
assertTrue(mReader.isNull());
assertTrue(aReader.isNull());
assertTrue(bReader.isNull());
// Fourth row: map with a null string
assertTrue(reader.next());
assertEquals(MinorType.MAP, vr.dataType());
assertEquals(40, aReader.getInt());
assertTrue(bReader.isNull());
// Fifth row: string "last"
assertTrue(reader.next());
assertEquals(MinorType.VARCHAR, vr.dataType());
assertEquals("last", strReader.getString());
assertFalse(reader.next());
}
result.clear();
}
use of org.apache.drill.exec.physical.rowSet.RowSet.SingleRowSet in project drill by apache.
the class TestVariantAccessors method testAddTypes.
/**
* Test a variant (AKA "union vector") at the top level, using
* just scalar values.
*/
@Test
public void testAddTypes() {
final TupleMetadata batchSchema = new SchemaBuilder().addNullable("v", MinorType.UNION).buildSchema();
final ExtendableRowSet rs = fixture.rowSet(batchSchema);
final RowSetWriter writer = rs.writer();
// Sanity check of writer structure
final ObjectWriter wo = writer.column(0);
assertEquals(ObjectType.VARIANT, wo.type());
final VariantWriter vw = wo.variant();
assertSame(vw, writer.variant(0));
assertSame(vw, writer.variant("v"));
for (final MinorType type : MinorType.values()) {
assertFalse(vw.hasType(type));
}
// Write values of different types
vw.scalar(MinorType.INT).setInt(10);
assertTrue(vw.hasType(MinorType.INT));
assertFalse(vw.hasType(MinorType.VARCHAR));
writer.save();
vw.scalar(MinorType.VARCHAR).setString("fred");
assertTrue(vw.hasType(MinorType.VARCHAR));
writer.save();
vw.setNull();
writer.save();
vw.scalar(MinorType.FLOAT8).setDouble(123.45);
assertTrue(vw.hasType(MinorType.INT));
assertTrue(vw.hasType(MinorType.FLOAT8));
writer.save();
final SingleRowSet result = writer.done();
assertEquals(4, result.rowCount());
// Read the values.
final RowSetReader reader = result.reader();
// Sanity check of structure
final ObjectReader ro = reader.column(0);
assertEquals(ObjectType.VARIANT, ro.type());
final VariantReader vr = ro.variant();
assertSame(vr, reader.variant(0));
assertSame(vr, reader.variant("v"));
for (final MinorType type : MinorType.values()) {
if (type == MinorType.INT || type == MinorType.VARCHAR || type == MinorType.FLOAT8) {
assertTrue(vr.hasType(type));
} else {
assertFalse(vr.hasType(type));
}
}
// Verify the data
assertTrue(reader.next());
assertFalse(vr.isNull());
assertSame(vr.dataType(), MinorType.INT);
assertSame(vr.scalar(MinorType.INT), vr.scalar());
assertNotNull(vr.member());
assertSame(vr.scalar(), vr.member().scalar());
assertEquals(10, vr.scalar().getInt());
assertTrue(reader.next());
assertFalse(vr.isNull());
assertSame(vr.dataType(), MinorType.VARCHAR);
assertSame(vr.scalar(MinorType.VARCHAR), vr.scalar());
assertEquals("fred", vr.scalar().getString());
assertTrue(reader.next());
assertTrue(vr.isNull());
assertNull(vr.dataType());
assertNull(vr.scalar());
assertTrue(reader.next());
assertFalse(vr.isNull());
assertSame(vr.dataType(), MinorType.FLOAT8);
assertSame(vr.scalar(MinorType.FLOAT8), vr.scalar());
assertEquals(123.45, vr.scalar().getDouble(), 0.001);
assertFalse(reader.next());
result.clear();
}
use of org.apache.drill.exec.physical.rowSet.RowSet.SingleRowSet in project drill by apache.
the class TestVariantAccessors method testUnionWithList.
/**
* Test a variant (AKA "union vector") at the top level which includes
* a list.
*/
@Test
public void testUnionWithList() {
final TupleMetadata schema = new SchemaBuilder().addUnion("u").addType(MinorType.INT).addList().addType(MinorType.VARCHAR).resumeUnion().resumeSchema().buildSchema();
SingleRowSet result;
// Write values
{
final ExtendableRowSet rs = fixture.rowSet(schema);
final RowSetWriter writer = rs.writer();
final VariantWriter vw = writer.variant("u");
assertTrue(vw.hasType(MinorType.INT));
final ScalarWriter intWriter = vw.scalar(MinorType.INT);
assertTrue(vw.hasType(MinorType.LIST));
final ArrayWriter aWriter = vw.array();
final ScalarWriter strWriter = aWriter.scalar();
// Row 1: 1, ["fred", "barney"]
intWriter.setInt(1);
strWriter.setString("fred");
aWriter.save();
strWriter.setString("barney");
aWriter.save();
writer.save();
// Row 2, 2, ["wilma", "betty"]
intWriter.setInt(2);
strWriter.setString("wilma");
aWriter.save();
strWriter.setString("betty");
aWriter.save();
writer.save();
result = writer.done();
assertEquals(2, result.rowCount());
}
// Read the values.
{
final RowSetReader reader = result.reader();
final VariantReader vr = reader.variant("u");
assertTrue(vr.hasType(MinorType.INT));
final ScalarReader intReader = vr.scalar(MinorType.INT);
assertTrue(vr.hasType(MinorType.LIST));
final ArrayReader aReader = vr.array();
final ScalarReader strReader = aReader.scalar();
assertTrue(reader.next());
assertEquals(1, intReader.getInt());
assertEquals(2, aReader.size());
assertTrue(aReader.next());
assertEquals("fred", strReader.getString());
assertTrue(aReader.next());
assertEquals("barney", strReader.getString());
assertFalse(aReader.next());
assertTrue(reader.next());
assertEquals(2, intReader.getInt());
assertEquals(2, aReader.size());
assertTrue(aReader.next());
assertEquals("wilma", strReader.getString());
assertTrue(aReader.next());
assertEquals("betty", strReader.getString());
assertFalse(aReader.next());
assertFalse(reader.next());
}
result.clear();
}
use of org.apache.drill.exec.physical.rowSet.RowSet.SingleRowSet in project drill by apache.
the class TestVariantAccessors method testScalarVariant.
/**
* Test a variant (AKA "union vector") at the top level, using
* just scalar values.
*/
@Test
public void testScalarVariant() {
final TupleMetadata schema = new SchemaBuilder().addUnion("u").addType(MinorType.INT).addType(MinorType.VARCHAR).addType(MinorType.FLOAT8).resumeSchema().buildSchema();
final ExtendableRowSet rs = fixture.rowSet(schema);
final RowSetWriter writer = rs.writer();
// Sanity check of writer structure
final ObjectWriter wo = writer.column(0);
assertEquals(ObjectType.VARIANT, wo.type());
final VariantWriter vw = wo.variant();
assertSame(vw, writer.variant(0));
assertSame(vw, writer.variant("u"));
assertTrue(vw.hasType(MinorType.INT));
assertTrue(vw.hasType(MinorType.VARCHAR));
assertTrue(vw.hasType(MinorType.FLOAT8));
// Write values of different types
vw.scalar(MinorType.INT).setInt(10);
writer.save();
vw.scalar(MinorType.VARCHAR).setString("fred");
writer.save();
// The entire variant is null
vw.setNull();
writer.save();
vw.scalar(MinorType.FLOAT8).setDouble(123.45);
writer.save();
// Strange case: just the value is null, but the variant
// is not null.
vw.scalar(MinorType.INT).setNull();
writer.save();
// Marker to avoid fill-empty issues (fill-empties tested elsewhere.)
vw.scalar(MinorType.INT).setInt(20);
writer.save();
final SingleRowSet result = writer.done();
assertEquals(6, result.rowCount());
// Read the values.
final RowSetReader reader = result.reader();
// Sanity check of structure
final ObjectReader ro = reader.column(0);
assertEquals(ObjectType.VARIANT, ro.type());
final VariantReader vr = ro.variant();
assertSame(vr, reader.variant(0));
assertSame(vr, reader.variant("u"));
for (final MinorType type : MinorType.values()) {
if (type == MinorType.INT || type == MinorType.VARCHAR || type == MinorType.FLOAT8) {
assertTrue(vr.hasType(type));
} else {
assertFalse(vr.hasType(type));
}
}
// Can get readers up front
final ScalarReader intReader = vr.scalar(MinorType.INT);
final ScalarReader strReader = vr.scalar(MinorType.VARCHAR);
final ScalarReader floatReader = vr.scalar(MinorType.FLOAT8);
// Verify the data
// Int 10
assertTrue(reader.next());
assertFalse(vr.isNull());
assertSame(vr.dataType(), MinorType.INT);
assertSame(intReader, vr.scalar());
assertNotNull(vr.member());
assertSame(vr.scalar(), vr.member().scalar());
assertFalse(intReader.isNull());
assertEquals(10, intReader.getInt());
assertTrue(strReader.isNull());
assertTrue(floatReader.isNull());
// String "fred"
assertTrue(reader.next());
assertFalse(vr.isNull());
assertSame(vr.dataType(), MinorType.VARCHAR);
assertSame(strReader, vr.scalar());
assertFalse(strReader.isNull());
assertEquals("fred", strReader.getString());
assertTrue(intReader.isNull());
assertTrue(floatReader.isNull());
// Null value
assertTrue(reader.next());
assertTrue(vr.isNull());
assertNull(vr.dataType());
assertNull(vr.scalar());
assertTrue(intReader.isNull());
assertTrue(strReader.isNull());
assertTrue(floatReader.isNull());
// Double 123.45
assertTrue(reader.next());
assertFalse(vr.isNull());
assertSame(vr.dataType(), MinorType.FLOAT8);
assertSame(floatReader, vr.scalar());
assertFalse(floatReader.isNull());
assertEquals(123.45, vr.scalar().getDouble(), 0.001);
assertTrue(intReader.isNull());
assertTrue(strReader.isNull());
// Strange case: null int (but union is not null)
assertTrue(reader.next());
assertFalse(vr.isNull());
assertSame(vr.dataType(), MinorType.INT);
assertTrue(intReader.isNull());
// Int 20
assertTrue(reader.next());
assertFalse(vr.isNull());
assertFalse(intReader.isNull());
assertEquals(20, intReader.getInt());
assertFalse(reader.next());
result.clear();
}
use of org.apache.drill.exec.physical.rowSet.RowSet.SingleRowSet in project drill by apache.
the class TestVariantAccessors method testScalarList.
/**
* Test a scalar list. Should act just like a repeated type, with the
* addition of allowing the list for a row to be null. But, a list
* writer does not do auto-increment, so we must do that explicitly
* after each write.
*/
@Test
public void testScalarList() {
final TupleMetadata schema = new SchemaBuilder().addList("list").addType(MinorType.VARCHAR).resumeSchema().buildSchema();
final ExtendableRowSet rowSet = fixture.rowSet(schema);
final RowSetWriter writer = rowSet.writer();
{
final ObjectWriter listObj = writer.column(0);
assertEquals(ObjectType.ARRAY, listObj.type());
final ArrayWriter listArray = listObj.array();
// The list contains only a scalar. But, because lists can,
// in general, contain multiple contents, the list requires
// an explicit save after each entry.
final ObjectWriter itemObj = listArray.entry();
assertEquals(ObjectType.SCALAR, itemObj.type());
final ScalarWriter strWriter = itemObj.scalar();
// First row: two strings and a null
// Unlike a repeated type, a list can mark individual elements
// as null.
// List will automatically detect that data was written.
strWriter.setString("fred");
listArray.save();
strWriter.setNull();
listArray.save();
strWriter.setString("wilma");
listArray.save();
writer.save();
// Second row: null
writer.save();
// Third row: one string
strWriter.setString("dino");
listArray.save();
writer.save();
// Fourth row: empty array. Note that there is no trigger
// to say that the column is not null, so we have to do it
// explicitly.
listArray.setNull(false);
writer.save();
// Last row: a null string and non-null
strWriter.setNull();
listArray.save();
strWriter.setString("pebbles");
listArray.save();
writer.save();
}
final SingleRowSet result = writer.done();
assertEquals(5, result.rowCount());
{
final RowSetReader reader = result.reader();
final ObjectReader listObj = reader.column(0);
assertEquals(ObjectType.ARRAY, listObj.type());
final ArrayReader listArray = listObj.array();
// The list is a repeated scalar
assertEquals(ObjectType.SCALAR, listArray.entry().type());
final ScalarReader strReader = listArray.scalar();
// First row: two strings and a null
assertTrue(reader.next());
assertFalse(listArray.isNull());
assertEquals(3, listArray.size());
assertTrue(listArray.next());
assertFalse(strReader.isNull());
assertEquals("fred", strReader.getString());
assertTrue(listArray.next());
assertTrue(strReader.isNull());
assertTrue(listArray.next());
assertFalse(strReader.isNull());
assertEquals("wilma", strReader.getString());
assertFalse(listArray.next());
// Second row: null
assertTrue(reader.next());
assertTrue(listArray.isNull());
assertEquals(0, listArray.size());
// Third row: one string
assertTrue(reader.next());
assertFalse(listArray.isNull());
assertEquals(1, listArray.size());
assertTrue(listArray.next());
assertEquals("dino", strReader.getString());
assertFalse(listArray.next());
// Fourth row: empty array.
assertTrue(reader.next());
assertFalse(listArray.isNull());
assertEquals(0, listArray.size());
assertFalse(listArray.next());
// Last row: a null string and non-null
assertTrue(reader.next());
assertFalse(listArray.isNull());
assertEquals(2, listArray.size());
assertTrue(listArray.next());
assertTrue(strReader.isNull());
assertTrue(listArray.next());
assertFalse(strReader.isNull());
assertEquals("pebbles", strReader.getString());
assertFalse(listArray.next());
assertFalse(reader.next());
}
result.clear();
}
Aggregations