Base class for all data array builders.
This class provides a facilities for incrementally building the null bitmap (see Append methods) and as a side effect the current number of slots and the null count.
Note
Users are expected to use builders as one of the concrete types below. For example, ArrayBuilder* pointing to BinaryBuilder should be downcast before use.
Subclassed by arrow::BaseBinaryBuilder< BinaryType >, arrow::BaseBinaryBuilder< LargeBinaryType >, arrow::NumericBuilder< DayTimeIntervalType >, arrow::NumericBuilder< MonthDayNanoIntervalType >, arrow::VarLengthListLikeBuilder< LargeListType >, arrow::VarLengthListLikeBuilder< LargeListViewType >, arrow::VarLengthListLikeBuilder< ListType >, arrow::VarLengthListLikeBuilder< ListViewType >, arrow::internal::DictionaryBuilderBase< Int32Builder, T >, arrow::internal::DictionaryBuilderBase< AdaptiveIntBuilder, T >, arrow::BaseBinaryBuilder< TYPE >, arrow::BasicUnionBuilder, arrow::BinaryViewBuilder, arrow::BooleanBuilder, arrow::FixedSizeBinaryBuilder, arrow::FixedSizeListBuilder, arrow::MapBuilder, arrow::NullBuilder, arrow::NumericBuilder< T >, arrow::RunEndEncodedBuilder, arrow::StructBuilder, arrow::VarLengthListLikeBuilder< TYPE >, arrow::internal::AdaptiveIntBuilderBase, arrow::internal::DictionaryBuilderBase< BuilderType, T >, arrow::internal::DictionaryBuilderBase< BuilderType, NullType >, arrow::internal::RunCompressorBuilder
Public Functions
For nested types.
Since the objects are owned by this class instance, we skip shared pointers and just return a raw pointer
Ensure that enough memory has been allocated to fit the indicated number of total elements in the builder, including any that have already been appended.
Does not account for reallocations that may be due to variable size data, like binary values. To make space for incremental appends, use Reserve instead.
capacity â [in] the minimum number of total array values to accommodate. Must be greater than the current capacity.
Ensure that there is enough space allocated to append the indicated number of elements without any further reallocation.
Overallocation is used in order to minimize the impact of incremental Reserve() calls. Note that additional_capacity is relative to the current number of elements rather than to the current capacity, so calls to Reserve() which are not interspersed with addition of new elements may not increase the capacity.
additional_capacity â [in] the number of additional array values
Reset the builder.
Append a null value to builder.
Append a number of null values to builder.
Append a non-null value to builder.
The appended value is an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending a null value to a parent nested type.
Append a number of non-null values to builder.
The appended values are an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending null values to a parent nested type.
Append a value from a scalar.
Append a range of values from an array.
The given array must be the same type as the builder.
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Return result of builder as an Array object.
The builder is reset except for DictionaryBuilder.
Return result of builder as an Array object.
The builder is reset except for DictionaryBuilder.
The finalized Array object
Return the type of the built Array.
Public Functions
Append the specified number of null elements.
Append a single null element.
Append a number of non-null values to builder.
The appended values are an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending null values to a parent nested type.
Append a non-null value to builder.
The appended value is an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending a null value to a parent nested type.
Append a range of values from an array.
The given array must be the same type as the builder.
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Return the type of the built Array.
Public Functions
Write nulls as uint8_t* (0 value indicates null) into pre-allocated memory.
Append a null value to builder.
Append a non-null value to builder.
The appended value is an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending a null value to a parent nested type.
Append a number of non-null values to builder.
The appended values are an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending null values to a parent nested type.
Scalar append.
Scalar append, without checking for capacity.
Append a sequence of elements in one shot.
values â [in] a contiguous array of bytes (non-zero is 1)
length â [in] the number of values to append
valid_bytes â [in] an optional sequence of bytes where non-zero indicates a valid (non-null) value
Append a sequence of elements in one shot.
values â [in] a bitmap of values
length â [in] the number of values to append
validity â [in] a validity bitmap to copy (may be null)
offset â [in] an offset into the values and validity bitmaps
Append a sequence of elements in one shot.
values â [in] a contiguous C array of values
length â [in] the number of values to append
is_valid â [in] an std::vector<bool> indicating valid (1) or null (0). Equal in length to values
Append a sequence of elements in one shot.
values â [in] a std::vector of bytes
is_valid â [in] an std::vector<bool> indicating valid (1) or null (0). Equal in length to values
Append a sequence of elements in one shot.
values â [in] a std::vector of bytes
Append a sequence of elements in one shot.
values â [in] an std::vector<bool> indicating true (1) or false
is_valid â [in] an std::vector<bool> indicating valid (1) or null (0). Equal in length to values
Append a sequence of elements in one shot.
values â [in] an std::vector<bool> indicating true (1) or false
Append a sequence of elements in one shot.
values_begin â [in] InputIterator to the beginning of the values
values_end â [in] InputIterator pointing to the end of the values or null(0) values
Append a sequence of elements in one shot, with a specified nullmap.
values_begin â [in] InputIterator to the beginning of the values
values_end â [in] InputIterator pointing to the end of the values
valid_begin â [in] InputIterator with elements indication valid(1) or null(0) values
Append a range of values from an array.
The given array must be the same type as the builder.
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Reset the builder.
Ensure that enough memory has been allocated to fit the indicated number of total elements in the builder, including any that have already been appended.
Does not account for reallocations that may be due to variable size data, like binary values. To make space for incremental appends, use Reserve instead.
capacity â [in] the minimum number of total array values to accommodate. Must be greater than the current capacity.
Return the type of the built Array.
#include <arrow/array/builder_adaptive.h>
Public Functions
Scalar append.
Append a sequence of elements in one shot.
values â [in] a contiguous C array of values
length â [in] the number of values to append
valid_bytes â [in] an optional sequence of bytes where non-zero indicates a valid (non-null) value
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Return the type of the built Array.
#include <arrow/array/builder_adaptive.h>
Public Functions
Scalar append.
Append a sequence of elements in one shot.
values â [in] a contiguous C array of values
length â [in] the number of values to append
valid_bytes â [in] an optional sequence of bytes where non-zero indicates a valid (non-null) value
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Return the type of the built Array.
#include <arrow/array/builder_decimal.h>
Public Functions
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Return the type of the built Array.
Reset the builder.
#include <arrow/array/builder_decimal.h>
Public Functions
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Return the type of the built Array.
Reset the builder.
#include <arrow/array/builder_decimal.h>
Public Functions
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Return the type of the built Array.
Reset the builder.
#include <arrow/array/builder_decimal.h>
Public Functions
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Return the type of the built Array.
Reset the builder.
#include <arrow/array/builder_primitive.h>
Base class for all Builders that emit an Array of a scalar numerical type.
Public Functions
Append a single scalar and increase the size if necessary.
Write nulls as uint8_t* (0 value indicates null) into pre-allocated memory The memory at the corresponding data slot is set to 0 to prevent uninitialized memory access.
Append a single null element.
Append a empty element.
Append several empty elements.
Reset the builder.
Ensure that enough memory has been allocated to fit the indicated number of total elements in the builder, including any that have already been appended.
Does not account for reallocations that may be due to variable size data, like binary values. To make space for incremental appends, use Reserve instead.
capacity â [in] the minimum number of total array values to accommodate. Must be greater than the current capacity.
Append a sequence of elements in one shot.
values â [in] a contiguous C array of values
length â [in] the number of values to append
valid_bytes â [in] an optional sequence of bytes where non-zero indicates a valid (non-null) value
Append a sequence of elements in one shot.
values â [in] a contiguous C array of values
length â [in] the number of values to append
bitmap â [in] a validity bitmap to copy (may be null)
bitmap_offset â [in] an offset into the validity bitmap
Append a sequence of elements in one shot.
values â [in] a contiguous C array of values
length â [in] the number of values to append
is_valid â [in] an std::vector<bool> indicating valid (1) or null (0). Equal in length to values
Append a sequence of elements in one shot.
values â [in] a std::vector of values
is_valid â [in] an std::vector<bool> indicating valid (1) or null (0). Equal in length to values
Append a sequence of elements in one shot.
values â [in] a std::vector of values
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Append a sequence of elements in one shot.
values_begin â [in] InputIterator to the beginning of the values
values_end â [in] InputIterator pointing to the end of the values
Append a sequence of elements in one shot, with a specified nullmap.
values_begin â [in] InputIterator to the beginning of the values
values_end â [in] InputIterator pointing to the end of the values
valid_begin â [in] InputIterator with elements indication valid(1) or null(0) values.
Append a range of values from an array.
The given array must be the same type as the builder.
Append a single scalar under the assumption that the underlying Buffer is large enough.
This method does not capacity-check; make sure to call Reserve beforehand.
Advance builder without allocating nor writing any values.
The internal pointer is advanced by length values and the same number of non-null entries are appended to the validity bitmap. This method assumes that the length values were populated directly, for example using GetMutableValue.
Advance builder without allocating nor writing any values.
The internal pointer is advanced by length values and the same number of validity bits are appended to the validity bitmap. This method assumes that the length values were populated directly, for example using GetMutableValue.
Return the type of the built Array.
#include <arrow/array/builder_time.h>
#include <arrow/array/builder_time.h>
#include <arrow/array/builder_binary.h>
Public Functions
Extend the last appended value by appending more data at the end.
Unlike Append, this does not create a new offset.
Append a number of null values to builder.
Append a null value to builder.
Append a non-null value to builder.
The appended value is an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending a null value to a parent nested type.
Append a number of non-null values to builder.
The appended values are an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending null values to a parent nested type.
Append without checking capacity.
Offsets and data should have been presized using Reserve() and ReserveData(), respectively.
Like ExtendCurrent, but do not check capacity.
Append a sequence of strings in one shot.
values â [in] a vector of strings
valid_bytes â [in] an optional sequence of bytes where non-zero indicates a valid (non-null) value
Append a sequence of nul-terminated strings in one shot.
If one of the values is NULL, it is processed as a null value even if the corresponding valid_bytes entry is 1.
values â [in] a contiguous C array of nul-terminated char *
length â [in] the number of values to append
valid_bytes â [in] an optional sequence of bytes where non-zero indicates a valid (non-null) value
Append a range of values from an array.
The given array must be the same type as the builder.
Reset the builder.
Ensure that enough memory has been allocated to fit the indicated number of total elements in the builder, including any that have already been appended.
Does not account for reallocations that may be due to variable size data, like binary values. To make space for incremental appends, use Reserve instead.
capacity â [in] the minimum number of total array values to accommodate. Must be greater than the current capacity.
Ensures there is enough allocated capacity to append the indicated number of bytes to the value data buffer without additional allocations.
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
data pointer of the value date builder
size of values buffer so far
capacity of values buffer
data pointer of the value date builder
Temporary access to a value.
This pointer becomes invalid on the next modifying operation.
Temporary access to a value.
This view becomes invalid on the next modifying operation.
#include <arrow/array/builder_binary.h>
Builder class for variable-length binary data.
Subclassed by arrow::StringBuilder
Public Functions
Return the type of the built Array.
#include <arrow/array/builder_binary.h>
Builder class for UTF8 strings.
Public Functions
Return the type of the built Array.
#include <arrow/array/builder_binary.h>
Builder class for large variable-length binary data.
Subclassed by arrow::LargeStringBuilder
Public Functions
Return the type of the built Array.
#include <arrow/array/builder_binary.h>
Builder class for large UTF8 strings.
Public Functions
Return the type of the built Array.
#include <arrow/array/builder_binary.h>
Subclassed by arrow::StringViewBuilder
Public Functions
Set the size for future preallocated data buffers.
The default size is 32KB, so after each 32KB of string data appended to the builder a new data buffer will be allocated. Adjust this to a larger value to decrease the frequency of allocation, or to a smaller value to lower the overhead of each allocation.
The number of bytes which can be appended to this builder without allocating another data buffer.
Append without checking capacity.
Builder should have been presized using Reserve() and ReserveData(), respectively, and the value must not be larger than 2GB
Ensures there is enough allocated available capacity in the out-of-line data heap to append the indicated number of bytes without additional allocations.
Append a number of null values to builder.
Append a single null element.
Append a empty element (length-0 inline string)
Append several empty elements.
Append a slice of a BinaryViewArray passed as an ArraySpan.
Copies the underlying out-of-line string memory to avoid memory lifetime issues
Reset the builder.
Ensure that enough memory has been allocated to fit the indicated number of total elements in the builder, including any that have already been appended.
Does not account for reallocations that may be due to variable size data, like binary values. To make space for incremental appends, use Reserve instead.
capacity â [in] the minimum number of total array values to accommodate. Must be greater than the current capacity.
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Return the type of the built Array.
#include <arrow/array/builder_binary.h>
Public Functions
Return the type of the built Array.
#include <arrow/array/builder_binary.h>
Subclassed by arrow::Decimal128Builder, arrow::Decimal256Builder, arrow::Decimal32Builder, arrow::Decimal64Builder
Public Functions
Append a null value to builder.
Append a number of null values to builder.
Append a non-null value to builder.
The appended value is an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending a null value to a parent nested type.
Append a number of non-null values to builder.
The appended values are an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending null values to a parent nested type.
Append a range of values from an array.
The given array must be the same type as the builder.
Ensures there is enough allocated capacity to append the indicated number of bytes to the value data buffer without additional allocations.
Reset the builder.
Ensure that enough memory has been allocated to fit the indicated number of total elements in the builder, including any that have already been appended.
Does not account for reallocations that may be due to variable size data, like binary values. To make space for incremental appends, use Reserve instead.
capacity â [in] the minimum number of total array values to accommodate. Must be greater than the current capacity.
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
size of values buffer so far
Temporary access to a value.
This pointer becomes invalid on the next modifying operation.
Temporary mutable access to a value.
This pointer becomes invalid on the next modifying operation.
Temporary mutable access to a value.
This view becomes invalid on the next modifying operation.
Advance builder without allocating nor writing any values.
The internal pointer is advanced by length values and the same number of non-null entries are appended to the validity bitmap. This method assumes that the length values were populated directly, for example using GetMutableValue.
Advance builder without allocating nor writing any values.
The internal pointer is advanced by length values and the same number of validity bits are appended to the validity bitmap. This method assumes that the length values were populated directly, for example using GetMutableValue.
Return the type of the built Array.
#include <arrow/array/builder_nested.h>
Subclassed by arrow::BaseListBuilder< TYPE >, arrow::BaseListViewBuilder< TYPE >
Public Functions
Use this constructor to incrementally build the value array along with offsets and null bitmap.
Ensure that enough memory has been allocated to fit the indicated number of total elements in the builder, including any that have already been appended.
Does not account for reallocations that may be due to variable size data, like binary values. To make space for incremental appends, use Reserve instead.
capacity â [in] the minimum number of total array values to accommodate. Must be greater than the current capacity.
Reset the builder.
Start a new variable-length list slot.
This function should be called before appending elements to the value builder. Elements appended to the value builder before this function is called for the first time, will not be members of any list value.
After this function is called, list_length elements SHOULD be appended to the values builder. If this contract is violated, the behavior is defined by the concrete builder implementation and SHOULD NOT be relied upon unless the caller is specifically building a [Large]List or [Large]ListView array.
For [Large]List arrays, the list slot length will be the number of elements appended to the values builder before the next call to Append* or Finish. For [Large]ListView arrays, the list slot length will be exactly list_length, but if Append* is called before at least list_length elements are appended to the values builder, the current list slot will share elements with the next list slots or an invalid [Large]ListView array will be generated because there arenât enough elements in the values builder to fill the list slots.
If youâre building a [Large]List and donât need to be compatible with [Large]ListView, then BaseListBuilder::Append(bool is_valid) is a simpler API.
is_valid â Whether the new list slot is valid
list_length â The number of elements in the list
if is_valid is false, list_length MUST be 0
Append a null value to builder.
Append a number of null values to builder.
Append an empty list slot.
Another call to Append* or Finish should be made before appending to the values builder to ensure list slot remains empty
Append an empty list slot.
Another call to Append* or Finish should be made before appending to the values builder to ensure the last list slot remains empty
Vector append.
For list-array builders, the sizes are inferred from the offsets. BaseListBuilder<T> provides an implementation that doesnât take sizes, but this virtual function allows dispatching calls to both list-array and list-view-array builders (which need the sizes)
offsets â The offsets of the variable-length lists
sizes â The sizes of the variable-length lists
length â The number of offsets, sizes, and validity bits to append
valid_bytes â If passed, valid_bytes is of equal length to values, and any zero byte will be considered as a null for that slot
Append a range of values from an array.
The given array must be the same type as the builder.
Return the type of the built Array.
#include <arrow/array/builder_nested.h>
Public Functions
Start a new variable-length list slot.
This function should be called before beginning to append elements to the value builder
Vector append.
If passed, valid_bytes is of equal length to values, and any zero byte will be considered as a null for that slot
Vector append.
For list-array builders, the sizes are inferred from the offsets. BaseListBuilder<T> provides an implementation that doesnât take sizes, but this virtual function allows dispatching calls to both list-array and list-view-array builders (which need the sizes)
offsets â The offsets of the variable-length lists
sizes â The sizes of the variable-length lists
length â The number of offsets, sizes, and validity bits to append
valid_bytes â If passed, valid_bytes is of equal length to values, and any zero byte will be considered as a null for that slot
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Start a new variable-length list slot.
This function should be called before appending elements to the value builder. Elements appended to the value builder before this function is called for the first time, will not be members of any list value.
After this function is called, list_length elements SHOULD be appended to the values builder. If this contract is violated, the behavior is defined by the concrete builder implementation and SHOULD NOT be relied upon unless the caller is specifically building a [Large]List or [Large]ListView array.
For [Large]List arrays, the list slot length will be the number of elements appended to the values builder before the next call to Append* or Finish. For [Large]ListView arrays, the list slot length will be exactly list_length, but if Append* is called before at least list_length elements are appended to the values builder, the current list slot will share elements with the next list slots or an invalid [Large]ListView array will be generated because there arenât enough elements in the values builder to fill the list slots.
If youâre building a [Large]List and donât need to be compatible with [Large]ListView, then BaseListBuilder::Append(bool is_valid) is a simpler API.
is_valid â Whether the new list slot is valid
list_length â The number of elements in the list
if is_valid is false, list_length MUST be 0
#include <arrow/array/builder_nested.h>
Builder class for variable-length list array value types.
To use this class, you must append values to the child array builder and use the Append function to delimit each distinct list value (once the values have been appended to the child array) or use the bulk API to append a sequence of offsets and null values.
A note on types. Per arrow/type.h all types in the c++ implementation are logical so even though this class always builds list array, this can represent multiple different logical types. If no logical type is provided at construction time, the class defaults to List<T> where t is taken from the value_builder/values that the object is constructed with.
#include <arrow/array/builder_nested.h>
Builder class for large variable-length list array value types.
Like ListBuilder, but to create large list arrays (with 64-bit offsets).
#include <arrow/array/builder_nested.h>
Public Functions
Ensure that enough memory has been allocated to fit the indicated number of total elements in the builder, including any that have already been appended.
Does not account for reallocations that may be due to variable size data, like binary values. To make space for incremental appends, use Reserve instead.
capacity â [in] the minimum number of total array values to accommodate. Must be greater than the current capacity.
Reset the builder.
Vector append.
If passed, valid_bytes is of equal length to values, and any zero byte will be considered as a null for that slot
#include <arrow/array/builder_nested.h>
#include <arrow/array/builder_nested.h>
#include <arrow/array/builder_nested.h>
Builder class for arrays of variable-size maps.
To use this class, you must use the Append function to delimit each distinct map before appending values to the key and item array builders, or use the bulk API to append a sequence of offsets and null maps.
Key uniqueness and ordering are not validated.
Public Functions
Use this constructor to define the built arrayâs type explicitly.
If key_builder or item_builder has indeterminate type, this builder will also.
Use this constructor to infer the built arrayâs type.
If key_builder or item_builder has indeterminate type, this builder will also.
Ensure that enough memory has been allocated to fit the indicated number of total elements in the builder, including any that have already been appended.
Does not account for reallocations that may be due to variable size data, like binary values. To make space for incremental appends, use Reserve instead.
capacity â [in] the minimum number of total array values to accommodate. Must be greater than the current capacity.
Reset the builder.
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Vector append.
If passed, valid_bytes is of equal length to values, and any zero byte will be considered as a null for that slot
Start a new variable-length map slot.
This function should be called before beginning to append elements to the key and item builders
Append a null value to builder.
Append a number of null values to builder.
Append a non-null value to builder.
The appended value is an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending a null value to a parent nested type.
Append a number of non-null values to builder.
The appended values are an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending null values to a parent nested type.
Append a range of values from an array.
The given array must be the same type as the builder.
Get builder to append keys.
Append a key with this builder should be followed by appending an item or null value with item_builder().
Get builder to append items.
Appending an item with this builder should have been preceded by appending a key with key_builder().
Get builder to add Map entries as struct values.
This is used instead of key_builder()/item_builder() and allows the Map to be built as a list of struct values.
Return the type of the built Array.
#include <arrow/array/builder_nested.h>
Builder class for fixed-length list array value types.
Public Functions
Use this constructor to define the built arrayâs type explicitly.
If value_builder has indeterminate type, this builder will also.
Use this constructor to infer the built arrayâs type.
If value_builder has indeterminate type, this builder will also.
Ensure that enough memory has been allocated to fit the indicated number of total elements in the builder, including any that have already been appended.
Does not account for reallocations that may be due to variable size data, like binary values. To make space for incremental appends, use Reserve instead.
capacity â [in] the minimum number of total array values to accommodate. Must be greater than the current capacity.
Reset the builder.
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Append a valid fixed length list.
This function affects only the validity bitmap; the child values must be appended using the child array builder.
Vector append.
If passed, valid_bytes will be read and any zero byte will cause the corresponding slot to be null
This function affects only the validity bitmap; the child values must be appended using the child array builder. This includes appending nulls for null lists. XXX this restriction is confusing, should this method be omitted?
Append a null fixed length list.
The child array builder will have the appropriate number of nulls appended automatically.
Append length null fixed length lists.
The child array builder will have the appropriate number of nulls appended automatically.
Append a non-null value to builder.
The appended value is an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending a null value to a parent nested type.
Append a number of non-null values to builder.
The appended values are an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending null values to a parent nested type.
Append a range of values from an array.
The given array must be the same type as the builder.
Return the type of the built Array.
#include <arrow/array/builder_nested.h>
Append, Resize and Reserve methods are acting on StructBuilder.
Please make sure all these methods of all child-buildersâ are consistently called to maintain data-structure consistency.
Public Functions
If any of field_builders has indeterminate type, this builder will also.
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Null bitmap is of equal length to every child field, and any zero byte will be considered as a null for that field, but users must using app- end methods or advance methods of the child buildersâ independently to insert data.
Append an element to the Struct.
All child-buildersâ Append method must be called independently to maintain data-structure consistency.
Append a null value.
Automatically appends an empty value to each child builder.
Append multiple null values.
Automatically appends empty values to each child builder.
Append a non-null value to builder.
The appended value is an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending a null value to a parent nested type.
Append a number of non-null values to builder.
The appended values are an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending null values to a parent nested type.
Append a range of values from an array.
The given array must be the same type as the builder.
Reset the builder.
Return the type of the built Array.
#include <arrow/array/builder_union.h>
Base class for union array builds.
Note that while we subclass ArrayBuilder, as union types do not have a validity bitmap, the bitmap builder member of ArrayBuilder is not used.
Subclassed by arrow::DenseUnionBuilder, arrow::SparseUnionBuilder
Public Functions
Return result of builder as an internal generic ArrayData object.
Resets builder except for dictionary builder
Make a new child builder available to the UnionArray.
new_child â [in] the child builder
field_name â [in] the name of the field in the union array type if type inference is used
child index, which is the âtypeâ argument that needs to be passed to the âAppendâ method to add a new element to the union array.
Return the type of the built Array.
#include <arrow/array/builder_union.h>
This API is EXPERIMENTAL.
Public Functions
Use this constructor to initialize the UnionBuilder with no child builders, allowing type to be inferred.
You will need to call AppendChild for each of the children builders you want to use.
Use this constructor to specify the type explicitly.
You can still add child builders to the union after using this constructor
Append a null value to builder.
Append a number of null values to builder.
Append a non-null value to builder.
The appended value is an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending a null value to a parent nested type.
Append a number of non-null values to builder.
The appended values are an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending null values to a parent nested type.
Append an element to the UnionArray.
This must be followed by an append to the appropriate child builder.
The corresponding child builder must be appended to independently after this method is called.
next_type â [in] type_id of the child to which the next value will be appended.
Append a range of values from an array.
The given array must be the same type as the builder.
#include <arrow/array/builder_union.h>
This API is EXPERIMENTAL.
Public Functions
Use this constructor to initialize the UnionBuilder with no child builders, allowing type to be inferred.
You will need to call AppendChild for each of the children builders you want to use.
Use this constructor to specify the type explicitly.
You can still add child builders to the union after using this constructor
Append a null value.
A null is appended to the first child, empty values to the other children.
Append multiple null values.
Nulls are appended to the first child, empty values to the other children.
Append a non-null value to builder.
The appended value is an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending a null value to a parent nested type.
Append a number of non-null values to builder.
The appended values are an implementation detail, but the corresponding memory slot is guaranteed to be initialized. This method is useful when appending null values to a parent nested type.
Append an element to the UnionArray.
This must be followed by an append to the appropriate child builder.
The corresponding child builder must be appended to independently after this method is called, and all other child builders must have null or empty value appended.
next_type â [in] type_id of the child to which the next value will be appended.
Append a range of values from an array.
The given array must be the same type as the builder.
A DictionaryArray builder that uses AdaptiveIntBuilder to return the smallest index size that can accommodate the dictionary indices.
Public Functions
Append dictionary indices directly without modifying memo.
NOTE: Experimental API
Helper class for creating record batches iteratively given a known schema.
Public Functions
Get base pointer to field builder.
i â the field index
pointer to ArrayBuilder
Return field builder casted to indicated specific builder type.
i â the field index
pointer to template type
Finish current batch and optionally reset.
reset_builders â [in] the resulting RecordBatch
the resulting RecordBatch
Finish current batch and reset.
the resulting RecordBatch
Set the initial capacity for new builders.
The initial capacity for builders.
The number of fields in the schema.
The number of fields in the schema.
Public Static Functions
Create and initialize a RecordBatchBuilder.
schema â [in] The schema for the record batch
pool â [in] A MemoryPool to use for allocations
the created builder instance
Create and initialize a RecordBatchBuilder.
schema â [in] The schema for the record batch
pool â [in] A MemoryPool to use for allocations
initial_capacity â [in] The initial capacity for the builders
the created builder instance
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4