# Type mapping between Arrow and kdb+¶

The data layout of an Arrow table is defined by its schema. The schema is composed from a list of fields, one for each column in the table. The field describes the name of the column and its datatype. This page examines each of these and details how they are mapped in kdb+.

## Arrow datatypes¶

Currently Arrow supports over 35 datatypes including concrete, parameterized and nested datatypes.

Similar to the C++ Arrow library and PyArrow, arrowkdb exposes the Arrow datatype constructors to q. When one of these constructors is called it will return an integer datatype identifier which can then be passed to other functions, e.g. when creating a field.

### Concrete¶

Concrete datatypes have a single fixed representation.

arrow datatype description kdb+ representation
na NULL type having no physical storage mixed list of empty lists
boolean boolean as 1 bit, LSB bit-packed ordering 1h
uint8 unsigned 8-bit little-endian integer 4h
int8 signed 8-bit little-endian integer 4h
uint16 unsigned 16-bit little-endian integer 5h
int16 signed 16-bit little-endian integer 5h
uint32 unsigned 32-bit little-endian integer 6h
int32 signed 32-bit little-endian integer 6h
uint64 unsigned 64-bit little-endian integer 7h
int64 signed 64-bit little-endian integer 7h
float16 2-byte floating point value (populated from uint16_t) 5h
float32 4-byte floating point value 8h
float64 8-byte floating point value 9h
utf8 UTF8 variable-length string mixed list of 10h
large_utf8 large UTF8 variable-length string mixed list of 10h
binary variable-length bytes (no guarantee of UTF8-ness) mixed list of 4h
large_binary large variable-length bytes (no guarantee of UTF8-ness) mixed list of 4h
date32 int32_t days since the Unix epoch 14h (with automatic epoch offsetting)
date64 int64_t milliseconds since the Unix epoch 12h (with automatic epoch offsetting and ms scaling)
month_interval interval described as a number of months 13h
day_time_interval interval described as number of days and milliseconds 16h (with automatic ns scaling)

### Parameterized¶

Parameterized datatypes represent multiple logical interpretations of the underlying physical data, where each parameterized interpretation is a distinct datatype in its own right.

arrow datatype description kdb+ representation
fixed_size_binary (byte_width) fixed-size binary: each value occupies the same number of bytes mixed list of 4h
timestamp (time_unit) exact timestamp encoded with int64_t (as number of seconds, milliseconds, microseconds or nanoseconds since Unix epoch) 12h (with automatic epoch offsetting and TimeUnit scaling)
time32 (time_unit) time as signed 32-bit integer, representing either seconds or milliseconds since midnight 19h (with automatic TimeUnit scaling)
time64 (time_unit) time as signed 64-bit integer, representing either microseconds or nanoseconds since midnight 16h (with automatic TimeUnit scaling)
duration (time_unit) measure of elapsed time in either seconds, milliseconds, microseconds or nanoseconds 16h (with automatic TimeUnit scaling)
decimal128 (precision, scale) precision- and scale-based signed 128-bit integer in twos complement mixed list of 4h (each of length 16)

### Nested¶

Nested datatypes define higher-level groupings of either the child datatypes or its constituent fields. (A field specifies its datatype and the field’s name.)

arrow datatype description kdb+ representation
list (datatype_id) list datatype specified in terms of its child datatype mixed list for the parent list array containing a set of sublists (of type determined by the child datatype), one for each of the list value sets
large_list (datatype_id) large list datatype specified in terms of its child datatype mixed list for the parent list array containing a set of sublists (of type determined by the child datatype), one for each of the list value sets
fixed_size_list (datatype_id, list_size) fixed size list datatype specified in terms of its child datatype and the fixed size of each of the child lists same as variable-length lists, except each of the sublists must be of length equal to the list_size
map (key_datatype_id, item_datatype_id) map datatype specified in terms of its key and item child datatypes mixed list for the parent map array, with a dictionary for each map value set
struct (field_ids) struct datatype specified in terms of a list of its constituent child field identifiers mixed list for the parent struct array, containing child lists for each field in the struct
dictionary (value_datatype_id, index_datatype_id) a dictionary datatype specified in terms of its value and index datatypes, similar to pandas categorical two-item mixed list: values and indexes lists
sparse_union (field_ids) union datatype specified in terms of a list of its constituent child field identifiers similar to a struct array except the mixed list has an additional type_id array (5h) at the start which identifies the live field in each union value set
dense_union (field_ids) union datatype specified in terms of a list of its constituent child field identifiers similar to a struct array except the mixed list has an additional type_id array (5h) at the start which identifies the live field in each union value set

### Inferred¶

You can have arrowkbd infer a suitable Arrow datatype from the type of a kdb+ list. Similarly, Arrow schemas can be inferred from a kdb+ table.

This approach is easier to use but supports only a subset of the Arrow datatypes and is considerably less flexible.

Infer Arrow datatypes if you are less familiar with Arrow or do not wish to use the more complex or nested Arrow datatypes.

kdb+ list type inferred Arrow datatype notes
1h boolean
2h fixed_size_binary (16) writing path only, reads as mixed list of 4h
4h int8
5h int16
6h int32
7h int64
8h float32
9h float64
10h int8 writing path only, reads as 4h
11h utf8 writing path only, reads as mixed list of 10h
12h timestamp (nano)
13h month_interval
14h date32
15h NA cast in q with timestamp$ 16h time64 (nano) 17h NA cast in q with time$
18h NA cast in q with time\$
19h time32 (milli)
mixed list of 4h binary
mixed list of 10h utf8
The inference works only for trivial kdb+ lists containing simple datatypes

Only mixed lists of char arrays or byte arrays are supported, mapped to Arrow UTF8 and binary datatypes respectively. Other mixed list structures (e.g. those used by the nested arrow datatypes) cannot be interpreted – if required, create manually using the datatype constructors

### Parquet datatype limitations¶

The Parquet file format is less fully featured compared to Arrow and consequently the Arrow/Parquet file writer currently does not support some datatypes or represents them using a different datatype:

Arrow datatype status as of apache-arrow-2.0.0
float16 unsupported
month_interval unsupported
day_time_interval unsupported
duration unsupported
large_utf8 unsupported
large_binary unsupported
sparse_union unsupported
dense_union unsupported
date64 mapped to date32 (days)
fixed_size_list mapped to list
dictionary categorical representation stored
uint32 Parquet v2.0 only, otherwise mapped to int64
timestamp(nano) Parquet v2.0 only, otherwise mapped to timestamp (milli)

## Arrow fields¶

An Arrow field describes a column in the table and is composed of a datatype and a string field name.

Similar to the C++ Arrow library and PyArrow, arrowkdb exposes the Arrow field constructor to q. The field constructor takes the field name and its datatype identifier and returns an integer field identifier which can then be passed to other functions, e.g. when creating a schema.

## Arrow schemas¶

An Arrow schema is built up from a list of fields and is used when working with table data. The datatype of each field in the schema determines the array data layout for that column in the table.

Similar to the C++ Arrow library and PyArrow, arrowkdb exposes the Arrow schema constructor to q. The schema constructor takes a list of field identifiers and will return an integer schema identifier which can then be passed to other functions, e.g. when writing Arrow or Parquet files.

If you are less familiar with Arrow or do not wish to use the more complex or nested Arrow datatypes, arrowkdb` can infer the schema from a kdb+ table. Each column in the table is mapped to a field in the schema. The column’s name is used as the field name and the field’s datatype is inferred from the column’s kdb+ type.

## Arrow tables¶

An Arrow table is composed from a schema and a mixed list of Arrow array data kdb+ objects:

• The array data for each column in the table is then populated using a builder object specific to the field’s datatype
• Similarly, datatype-specific reader objects are used to interpret and inspect the array data for each column in the table

The mixed list of Arrow array data kdb+ objects should be ordered in schema field number. Each kdb+ object representing one of the arrays must be structured according to the field's datatype. This required array data structure is detailed above for each of the datatypes.

Alternatively, separate APIs are provided where the Arrow table is created from a kdb+ table using an inferred schema.