use of org.apache.drill.exec.record.metadata.ColumnMetadata in project drill by apache.
the class BuildVectorsFromMetadata method populateMap.
/**
* Create the contents building the model as we go.
*
* @param mapVector the vector to populate
* @param mapSchema description of the map
*/
private void populateMap(AbstractMapVector mapVector, TupleMetadata mapSchema, boolean inUnion) {
for (int i = 0; i < mapSchema.size(); i++) {
final ColumnMetadata childSchema = mapSchema.metadata(i);
if (inUnion && !childSchema.isMap() && childSchema.mode() == DataMode.REQUIRED) {
throw new IllegalArgumentException("Map members in a list or union must not be non-nullable");
}
mapVector.putChild(childSchema.name(), buildVector(childSchema));
}
}
use of org.apache.drill.exec.record.metadata.ColumnMetadata 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.record.metadata.ColumnMetadata in project drill by apache.
the class ColumnBuilder method buildSingleDict.
private ColumnState buildSingleDict(ContainerState parent, ColumnMetadata columnSchema) {
final ProjectionFilter projFilter = parent.projection();
final ProjResult projResult = projFilter.projection(columnSchema);
// Create the dict's offset vector.
final DictVector dictVector;
final UInt4Vector offsetVector;
if (projResult.isProjected) {
// Creating the dict vector will create its contained vectors if we
// give it a materialized field with children. So, instead pass a clone
// without children so we can add them.
final ColumnMetadata dictColMetadata = columnSchema.cloneEmpty();
// vectors can be cached.
assert columnSchema.tupleSchema().isEmpty();
dictVector = new DictVector(dictColMetadata.schema(), parent.loader().allocator(), null);
offsetVector = dictVector.getOffsetVector();
} else {
dictVector = null;
offsetVector = null;
}
// Create the writer using the offset vector
final AbstractObjectWriter writer = ObjectDictWriter.buildDict(columnSchema, dictVector, new ArrayList<>());
// Wrap the offset vector in a vector state
final VectorState offsetVectorState;
if (!projResult.isProjected) {
offsetVectorState = new NullVectorState();
} else {
offsetVectorState = new OffsetVectorState((((AbstractArrayWriter) writer.dict()).offsetWriter()), offsetVector, writer.dict().entry().events());
}
final VectorState mapVectorState = new TupleState.SingleDictVectorState(dictVector, offsetVectorState);
// Assemble it all into the column state.
final SingleDictState dictArrayState = new SingleDictState(parent.loader(), parent.vectorCache().childCache(columnSchema.name()), projResult.mapFilter);
return new TupleState.DictColumnState(dictArrayState, writer, mapVectorState, parent.isVersioned());
}
use of org.apache.drill.exec.record.metadata.ColumnMetadata in project drill by apache.
the class ColumnBuilder method buildRepeatedList.
private ColumnState buildRepeatedList(ContainerState parent, ColumnMetadata columnSchema) {
assert columnSchema.type() == MinorType.LIST;
assert columnSchema.mode() == DataMode.REPEATED;
// the element type after creating the repeated writer itself.
assert columnSchema.childSchema() == null;
// Build the repeated vector.
final RepeatedListVector vector = new RepeatedListVector(columnSchema.emptySchema(), parent.loader().allocator(), null);
// No inner type yet. The result set loader builds the subtype
// incrementally because it might be complex (a map or another
// repeated list.) To start, use a dummy to avoid need for if-statements
// everywhere.
final ColumnMetadata dummyElementSchema = new PrimitiveColumnMetadata(MaterializedField.create(columnSchema.name(), Types.repeated(MinorType.NULL)));
final AbstractObjectWriter dummyElement = ColumnWriterFactory.buildDummyColumnWriter(dummyElementSchema);
// Create the list writer: an array of arrays.
final AbstractObjectWriter arrayWriter = RepeatedListWriter.buildRepeatedList(columnSchema, vector, dummyElement);
// Create the list vector state that tracks the list vector lifecycle.
final RepeatedListVectorState vectorState = new RepeatedListVectorState(arrayWriter, vector);
// Build the container that tracks the array contents
final RepeatedListState listState = new RepeatedListState(parent.loader(), parent.vectorCache().childCache(columnSchema.name()));
// Bind the list state as the list event listener.
((RepeatedListWriter) arrayWriter.array()).bindListener(listState);
// propagate events down to the (one and only) child state.
return new RepeatedListColumnState(parent.loader(), arrayWriter, vectorState, listState);
}
use of org.apache.drill.exec.record.metadata.ColumnMetadata in project drill by apache.
the class BuildFromSchema method buildTuple.
/**
* When creating a schema up front, provide the schema of the desired tuple,
* then build vectors and writers to match. Allows up-front schema definition
* in addition to on-the-fly schema creation handled elsewhere.
*
* @param schema desired tuple schema to be materialized
*/
public void buildTuple(TupleWriter writer, TupleMetadata schema) {
final ParentShim tupleShim = new TupleShim(writer);
for (int i = 0; i < schema.size(); i++) {
final ColumnMetadata colSchema = schema.metadata(i);
buildColumn(tupleShim, colSchema);
}
}
Aggregations