use of org.apache.drill.exec.physical.resultSet.impl.UnionState.UnionColumnState in project drill by apache.
the class ColumnBuilder method buildSimpleList.
/**
* Create a list that is promised to only ever contain a single type (at least
* during this write session). The list acts as a repeated vector in which each
* element can be null. The writer is presented as an array of the single type.
* <p>
* List vectors (lists of optional values) are not supported in
* Drill. The code here works up through the scan operator. But, other operators do
* not support the {@code ListVector</tt> type.
*
* @param parent the parent (tuple, union or list) that holds this list
* @param columnSchema metadata description of the list which must contain
* exactly one subtype
* @return the column state for the list
*/
private ColumnState buildSimpleList(ContainerState parent, ColumnMetadata columnSchema) {
// The variant must have the one and only type.
assert columnSchema.variantSchema().size() == 1;
assert columnSchema.variantSchema().isSimple();
// Create the manager for the one and only column within the list.
final ListState listState = new ListState(parent.loader(), parent.vectorCache().childCache(columnSchema.name()));
// Create the child vector, writer and state.
final ColumnMetadata memberSchema = columnSchema.variantSchema().listSubtype();
final ColumnState memberState = buildColumn(listState, memberSchema);
listState.setSubColumn(memberState);
// Create the list vector. Contains a single type.
final ListVector listVector = new ListVector(columnSchema.schema().cloneEmpty(), parent.loader().allocator(), null);
listVector.setChildVector(memberState.vector());
// Create the list writer: an array of the one type.
final ListWriterImpl listWriter = new ListWriterImpl(columnSchema, listVector, memberState.writer());
final AbstractObjectWriter listObjWriter = new ArrayObjectWriter(listWriter);
// Create the list vector state that tracks the list vector lifecycle.
final ListVectorState vectorState = new ListVectorState(listWriter, memberState.writer().events(), listVector);
// Assemble it all into a union column state.
return new UnionColumnState(parent.loader(), listObjWriter, vectorState, listState);
}
use of org.apache.drill.exec.physical.resultSet.impl.UnionState.UnionColumnState in project drill by apache.
the class ColumnBuilder method buildUnionList.
/**
* Create a list based on a (possible) union. The list starts empty here. The client
* can then add types as they are discovered. The list itself will transition from a
* list of nulls (no child type), to a list of a single type, to a list of unions.
* The writer interface will consistently present the list as a list of unions, even
* when the list itself has no subtype or a single subtype.
* <p>
* List vectors (lists of unions) are not supported in
* Drill. The code here works up through the scan operator. But, other operators do
* not support the {@code ListVector} type.
*
* @param parent the parent (tuple, union or list) that holds this list
* @param columnSchema description of the list (must be empty of
* subtypes)
* @return the column state for the list
*/
private ColumnState buildUnionList(ContainerState parent, ColumnMetadata columnSchema) {
// The variant must start out empty.
assert columnSchema.variantSchema().size() == 0;
// Create the union writer, bound to an empty list shim.
final UnionWriterImpl unionWriter = new UnionWriterImpl(columnSchema);
unionWriter.bindShim(new EmptyListShim());
final VariantObjectWriter unionObjWriter = new VariantObjectWriter(unionWriter);
// Create the list vector. Starts with the default (dummy) data
// vector which corresponds to the empty union shim above.
// Don't get the list vector from the vector cache. List vectors may
// have content that varies from batch to batch. Only the leaf
// vectors can be cached.
final ListVector listVector = new ListVector(columnSchema.schema(), parent.loader().allocator(), null);
// Create the list vector state that tracks the list vector lifecycle.
final ListVectorState vectorState = new ListVectorState(unionWriter, listVector);
// Create the list writer: an array of unions.
final AbstractObjectWriter listWriter = new ArrayObjectWriter(new ListWriterImpl(columnSchema, listVector, unionObjWriter));
// Create the manager for the columns within the list (which may or
// may not be grouped into a union.)
final ListState listState = new ListState(parent.loader(), parent.vectorCache().childCache(columnSchema.name()));
// Bind the union state to the union writer to handle column additions.
unionWriter.bindListener(listState);
// Assemble it all into a union column state.
return new UnionColumnState(parent.loader(), listWriter, vectorState, listState);
}
use of org.apache.drill.exec.physical.resultSet.impl.UnionState.UnionColumnState in project drill by apache.
the class ColumnBuilder method buildUnion.
/**
* Builds a union column.
* <p>
* The union vector type is not well supported in Drill. The idea is that
* arbitrary operators can absorb schema changes by converting vectors to
* unions so that an operator can handle, say, a nullable int and a varchar.
* In practice, most operators don't support this feature. (Sort does -- but
* does not manage memory for the union case.) In principal, union can't solve
* the problem because ODBC and JDBC don't support unions, and it is easy
* to envision changes that unions won't solve (int and varchar types combining
* in a join column, say.) Still, Drill supports unions, so the code here
* does so. Unions are fully tested in the row set writer mechanism.
*
* @param parent container of vectors
* @param columnSchema implied projection type for the column
* @return column
*/
private ColumnState buildUnion(ContainerState parent, ColumnMetadata columnSchema) {
assert columnSchema.isVariant() && !columnSchema.isArray();
// vectors can be cached.
assert columnSchema.variantSchema().size() == 0;
final UnionVector vector = new UnionVector(columnSchema.schema(), parent.loader().allocator(), null);
// Then the union writer.
final UnionWriterImpl unionWriter = new UnionWriterImpl(columnSchema, vector, null);
final VariantObjectWriter writer = new VariantObjectWriter(unionWriter);
// The union vector state which manages the types vector.
final UnionVectorState vectorState = new UnionVectorState(vector, unionWriter);
// Create the manager for the columns within the union.
final UnionState unionState = new UnionState(parent.loader(), parent.vectorCache().childCache(columnSchema.name()));
// Bind the union state to the union writer to handle column additions.
unionWriter.bindListener(unionState);
// Assemble it all into a union column state.
return new UnionColumnState(parent.loader(), writer, vectorState, unionState);
}
Aggregations