Create a Schema instance.

Create a Schema instance from (name, type) pairs.

The schema’s fields will all be nullable with no associated metadata.

Create a Schema instance.

Create a Schema instance.

The schema’s fields will all be nullable with no associated metadata.

The combination of a field name and data type, with optional metadata.

Fields are used to describe the individual constituents of a nested DataType or a Schema .

A field’s metadata is represented by a KeyValueMetadata instance, which holds arbitrary key-value pairs.

Public Functions

Return the field’s attached metadata.

Return a copy of this field with the given metadata attached to it.

EXPERIMENTAL: Return a copy of this field with the given metadata merged with existing metadata (any colliding keys will be overridden by the passed metadata)

Merge the current field with a field of the same name.

The two fields must be compatible, i.e:

• have the same name

• have the same type, or of compatible types according to options .

The metadata of the current field is preserved; the metadata of the other field is discarded.

bool Equals ( const Field & other , bool check_metadata = false ) const #


Indicate if fields are equals.

Parameters :

• other – [in] field to check equality with.

• check_metadata – [in] controls if it should check for metadata equality.

Returns :

true if fields are equal, false otherwise.

bool IsCompatibleWith ( const Field & other ) const #


Indicate if fields are compatibles.

See the criteria of MergeWith.

Returns :

true if fields are compatible, false otherwise.

std :: string ToString ( bool show_metadata = false ) const #


Return a string representation ot the field.

Parameters :

show_metadata – [in] when true, if KeyValueMetadata is non-empty, print keys and values in the output

struct MergeOptions : public arrow :: util :: ToStringOstreamable < MergeOptions > #


Options that control the behavior of MergeWith .

Options are to be added to allow type conversions, including integer widening, promotion from integer to float, or conversion to or from boolean.

Public Functions

std :: string ToString ( ) const #


Get a human-readable representation of the options.

bool promote_nullability = true #


If true, a Field of NullType can be unified with a Field of another type.

The unified field will be of the other type and become nullable. Nullability will be promoted to the looser option (nullable if one is not nullable).

bool promote_decimal = false #


Allow a decimal to be unified with another decimal of the same width, adjusting scale and precision as appropriate.

May fail if the adjustment is not possible.

bool promote_integer_to_decimal = false #


Allow an integer to be promoted to a decimal.

May fail if the decimal has insufficient precision to accommodate the integer (see promote_numeric_width).

bool promote_integer_to_float = false #


Allow an integer of a given bit width to be promoted to a float; the result will be a float of an equal or greater bit width to both of the inputs.

Examples:

• int8 + float32 = float32

• int32 + float32 = float64

• int32 + float64 = float64 Because an int32 cannot always be represented exactly in the 24 bits of a float32 mantissa.

bool promote_dictionary_ordered = false #


Allow merging ordered and non-ordered dictionaries.

The result will be ordered if and only if both inputs are ordered.

class Schema : public arrow :: detail :: Fingerprintable , public arrow :: util :: EqualityComparable < Schema > , public arrow :: util :: ToStringOstreamable < Schema > #


Sequence of arrow::Field objects describing the columns of a record batch or table data structure.

Public Functions

bool Equals ( const Schema & other , bool check_metadata = false ) const #


Returns true if all of the schema fields are equal.

std :: shared_ptr < Schema > WithEndianness ( Endianness endianness ) const #


Set endianness in the schema.

Returns :

new Schema

const std :: shared_ptr < const KeyValueMetadata > & metadata ( ) const #


The custom key-value metadata, if any.

Returns :

metadata may be null

std :: string ToString ( bool show_metadata = false ) const #


Render a string representation of the schema suitable for debugging.

Parameters :

show_metadata – [in] when true, if KeyValueMetadata is non-empty, print keys and values in the output

Result < std :: shared_ptr < Schema > > WithNames ( const std :: vector < std :: string > & names ) const #


Replace field names with new names.

Parameters :

names – [in] new names

Returns :

new Schema

std :: shared_ptr < Schema > WithMetadata ( const std :: shared_ptr < const KeyValueMetadata > & metadata ) const #


Replace key-value metadata with new metadata.

Parameters :

metadata – [in] new KeyValueMetadata

Returns :

new Schema

class FieldPath #


Represents a path to a nested field using indices of child fields.

For example, given indices {5, 9, 3} the field would be retrieved with schema->field(5)->type()->field(9)->type()->field(3)

Attempting to retrieve a child field using a FieldPath which is not valid for a given schema will raise an error. Invalid FieldPaths include:

• an index is out of range

• the path is empty (note: a default constructed FieldPath will be empty)

FieldPaths provide a number of accessors for drilling down to potentially nested children. They are overloaded for convenience to support Schema (returns a field), DataType (returns a child field), Field (returns a child field of this field’s type) Array (returns a child array), RecordBatch (returns a column).

Public Functions

FieldPath ( ) = default #
Result < std :: shared_ptr < ChunkedArray > > Get ( const ChunkedArray & chunked_array ) const #


Retrieve the referenced child from a ChunkedArray .

Result < std :: shared_ptr < Array > > GetFlattened ( const Array & array , MemoryPool * pool = NULLPTR ) const #


Retrieve the referenced child/column from an Array , ArrayData , ChunkedArray , RecordBatch , or Table .

Unlike FieldPath::Get , these variants are not zero-copy and the retrieved child’s null bitmap is ANDed with its ancestors’

class FieldRef : public arrow :: util :: EqualityComparable < FieldRef > #


Descriptor of a (potentially nested) field within a schema.

Unlike FieldPath (which exclusively uses indices of child fields), FieldRef may reference a field by name. It is intended to replace parameters like int field_index and const std::string& field_name ; it can be implicitly constructed from either a field index or a name.

Nested fields can be referenced as well. Given schema({field(“a”, struct_({field(“n”, null() )})), field(“b”, int32() )})

the following all indicate the nested field named “n”: FieldRef ref1(0, 0); FieldRef ref2(“a”, 0); FieldRef ref3(“a”, “n”); FieldRef ref4(0, “n”); ARROW_ASSIGN_OR_RAISE( FieldRef ref5, FieldRef::FromDotPath (“.a[0]”));

FieldPaths matching a FieldRef are retrieved using the member function FindAll. Multiple matches are possible because field names may be duplicated within a schema. For example: Schema a_is_ambiguous({field(“a”, int32() ), field(“a”, float32() )}); auto matches = FieldRef (“a”).FindAll(a_is_ambiguous); assert(matches.size() == 2); assert(matches[0].Get(a_is_ambiguous)->Equals(a_is_ambiguous.field(0))); assert(matches[1].Get(a_is_ambiguous)->Equals(a_is_ambiguous.field(1)));

Convenience accessors are available which raise a helpful error if the field is not found or ambiguous, and for immediately calling FieldPath::Get to retrieve any matching children: auto maybe_match = FieldRef (“struct”, “field_i32”).FindOneOrNone(schema); auto maybe_column = FieldRef (“struct”, “field_i32”).GetOne(some_table);

Public Types

template < typename T >
using GetType = decltype ( std :: declval < FieldPath > ( ) . Get ( std :: declval < T > ( ) ) . ValueOrDie ( ) ) #
FieldRef ( FieldPath indices ) #


Construct a FieldRef using a string of indices.

The reference will be retrieved as: schema.fields[self.indices[0]].type.fields[self.indices[1]] …

Empty indices are not valid.

template < typename A0 , typename A1 , typename ... A >
inline FieldRef ( A0 & & a0 , A1 & & a1 , A & & ... a ) #


Convenience constructor for nested FieldRefs: each argument will be used to construct a FieldRef .

inline bool IsNameSequence ( ) const #


Return true if this ref is a name or a nested sequence of only names.

Useful for determining if iteration is possible without recursion or inner loops

template < typename T >
inline Status CheckNonEmpty ( const std :: vector < FieldPath > & matches , const T & root ) const #


Convenience function: raise an error if matches is empty.

template < typename T >
inline Status CheckNonMultiple ( const std :: vector < FieldPath > & matches , const T & root ) const #


Convenience function: raise an error if matches contains multiple FieldPaths.

template < typename T >
inline Result < FieldPath > FindOne ( const T & root ) const #


Retrieve FieldPath of a single child field which matches this FieldRef .

Emit an error if none or multiple match.

template < typename T >
inline Result < FieldPath > FindOneOrNone ( const T & root ) const #


Retrieve FieldPath of a single child field which matches this FieldRef .

Emit an error if multiple match. An empty (invalid) FieldPath will be returned if none match.

template < typename T >
inline Result < std :: vector < GetType < T > > > GetAllFlattened ( const T & root , MemoryPool * pool = NULLPTR ) const #


Get all children matching this FieldRef .

Unlike FieldRef::GetAll , this variant is not zero-copy and the retrieved children’s null bitmaps are ANDed with their ancestors’

template < typename T >
inline Result < GetType < T > > GetOne ( const T & root ) const #


Get the single child matching this FieldRef .

Emit an error if none or multiple match.

template < typename T >
inline Result < GetType < T > > GetOneFlattened ( const T & root , MemoryPool * pool = NULLPTR ) const #


Get the single child matching this FieldRef .

Unlike FieldRef::GetOne , this variant is not zero-copy and the retrieved child’s null bitmap is ANDed with its ancestors’

template < typename T >
inline Result < GetType < T > > GetOneOrNone ( const T & root ) const #


Get the single child matching this FieldRef .

Return nullptr if none match, emit an error if multiple match.

template < typename T >
inline Result < GetType < T > > GetOneOrNoneFlattened ( const T & root , MemoryPool * pool = NULLPTR ) const #


Get the single child matching this FieldRef .

Return nullptr if none match, emit an error if multiple match. Unlike FieldRef::GetOneOrNone , this variant is not zero-copy and the retrieved child’s null bitmap is ANDed with its ancestors’

static Result < FieldRef > FromDotPath ( const std :: string & dot_path ) #


Parse a dot path into a FieldRef .

dot_path = ‘.’ name | ‘[’ digit+ ‘]’ | dot_path+

Examples: “.alpha” => FieldRef (“alpha”) “[2]” => FieldRef(2) “.beta[3]” => FieldRef (“beta”, 3) “[5].gamma.delta[7]” => FieldRef (5, “gamma”, “delta”, 7) “.hello world” => FieldRef (“hello world”) R”(.\[y\]\tho.\)” => FieldRef (R”([y]\tho.\)”)

Note: When parsing a name, a ‘' preceding any other character will be dropped from the resulting name. Therefore if a name must contain the characters ‘.’, ‘', or ‘[’ those must be escaped with a preceding ‘'.

class TypeVisitor #


Abstract type visitor class.

Subclass this to create a visitor that can be used with the DataType::Accept() method.

Public Functions

virtual ~TypeVisitor ( ) = default #