diff --git a/docs/source/format/Columnar.rst b/docs/source/format/Columnar.rst index 4bd937d760d59..a99f1cb06bf27 100644 --- a/docs/source/format/Columnar.rst +++ b/docs/source/format/Columnar.rst @@ -89,6 +89,8 @@ concepts, here is a small glossary to help disambiguate. are parametric by construction. A timestamp is also parametric as it needs a unit (such as microseconds) and a timezone. +.. _data_types: + Data Types ========== diff --git a/docs/source/format/Glossary.rst b/docs/source/format/Glossary.rst index 11c19c5fa70e9..7c6a23b8ce58b 100644 --- a/docs/source/format/Glossary.rst +++ b/docs/source/format/Glossary.rst @@ -15,6 +15,8 @@ .. specific language governing permissions and limitations .. under the License. +.. _glossary: + ======== Glossary ======== diff --git a/docs/source/format/Intro.rst b/docs/source/format/Intro.rst new file mode 100644 index 0000000000000..c230be724dbcc --- /dev/null +++ b/docs/source/format/Intro.rst @@ -0,0 +1,512 @@ +.. Licensed to the Apache Software Foundation (ASF) under one +.. or more contributor license agreements. See the NOTICE file +.. distributed with this work for additional information +.. regarding copyright ownership. The ASF licenses this file +.. to you under the Apache License, Version 2.0 (the +.. "License"); you may not use this file except in compliance +.. with the License. You may obtain a copy of the License at + +.. http://www.apache.org/licenses/LICENSE-2.0 + +.. Unless required by applicable law or agreed to in writing, +.. software distributed under the License is distributed on an +.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +.. KIND, either express or implied. See the License for the +.. specific language governing permissions and limitations +.. under the License. + +************ +Introduction +************ + +Apache Arrow was born from the need for a set of standards around +tabular data representation and interchange between systems. +The adoption of these standards reduces computing costs of data +serialization/deserialization and implementation costs across +systems implemented in different programming languages. + +The Apache Arrow specification can be implemented in any programming +language but official implementations for many languages are available. +An implementation consists of format definitions using the constructs +offered by the language and common in-memory data processing algorithms +(e.g. slicing and concatenating). Users can extend and use the utilities +provided by the Apache Arrow implementation in their programming +language of choice. Some implementations are further ahead and feature a +vast set of algorithms for in-memory analytical data processing. More detail +about how implementations differ can be found on the :ref:`status` page. + +Apart from this initial vision, Arrow has grown to also develop a +multi-language collection of libraries for solving problems related to +in-memory analytical data processing. This covers topics like: + +* Zero-copy shared memory and RPC-based data movement +* Reading and writing file formats (like CSV, `Apache ORC`_, and `Apache Parquet`_) +* In-memory analytics and query processing + +.. _Apache ORC: https://orc.apache.org/ +.. _Apache Parquet: https://parquet.apache.org/ + +Arrow Columnar Format +===================== + +Apache Arrow focuses on tabular data. For an example, let's consider +we have data that can be organized into a table: + +.. figure:: ./images/columnar-diagram_1.svg + :scale: 70% + :alt: Diagram with tabular data of 4 rows and columns. + + Diagram of a tabular data structure. + +Tabular data can be represented in memory using a row-based format or a +column-based format. The row-based format stores data row-by-row, meaning the rows +are adjacent in the computer memory: + +.. figure:: ./images/columnar-diagram_2.svg + :alt: Tabular data being structured row by row in computer memory. + + Tabular data being saved in memory row by row. + +In a columnar format, the data is organized column-by-column instead. +This organization makes analytical operations like filtering, grouping, +aggregations and others, more efficient thanks to memory locality. +When processing the data, the memory locations accessed by the CPU tend +be near one another. By keeping the data contiguous in memory, it also +enables vectorization of the computations. Most modern CPUs have +`SIMD instructions`_ (a single instruction that operates on multiple values at +once) enabling parallel processing and execution of operations on vector data +using a single CPU instruction. + +.. _SIMD instructions: https://en.wikipedia.org/wiki/Single_instruction,_multiple_data + +Apache Arrow is solving this exact problem. It is the specification that +uses the columnar layout. + +.. figure:: ./images/columnar-diagram_3.svg + :alt: Tabular data being structured column by column in computer memory. + + The same tabular data being saved in memory column by column. + +Each column is called an **Array** in Arrow terminology. Arrays can be of +different data types and the way their values are stored in memory varies among +the data types. The specification of how these values are arranged in memory is +what we call a **physical memory layout**. One contiguous region of memory that +stores data for arrays is called a **Buffer**. An array consists of one or more +buffers. + +Next sections give an introduction to Arrow Columnar Format explaining the +different physical layouts. The full specification of the format can be found +at :ref:`format_columnar`. + +Support for Null Values +======================= + +Arrow supports missing values or "nulls" for all data types: any value +in an array may be semantically null, whether primitive or nested data type. + +In Arrow, a dedicated buffer, known as the validity (or "null") bitmap, +is used alongside the data indicating whether each value in the array is +null or not: a value of 1 means that the value is not-null ("valid"), whereas +a value of 0 indicates that the value is null. + +This validity bitmap is optional: if there are no missing values in +the array the buffer does not need to be allocated (as in the example +column 1 in the diagram below). + +.. note:: + + We read validity bitmaps right-to-left within a group of 8 bits due to + `least-significant bit numbering `_ + being used. + + This is also how we have represented the validity bitmaps in the + diagrams included in this document. + +Primitive Layouts +================= + +Fixed Size Primitive Layout +--------------------------- + +A primitive column represents an array of values where each value +has the same physical size measured in bytes. Data types that use the +fixed size primitive layout are, for example, signed and unsigned +integer data types, floating point numbers, boolean, decimal and temporal +data types. + +.. figure:: ./images/primitive-diagram.svg + :alt: Diagram is showing the difference between the primitive data + type presented in a Table and the data actually stored in + computer memory. + + Physical layout diagram for primitive data types. + +.. note:: + The boolean data type is represented with a primitive layout where the + values are encoded in bits instead of bytes. That means the physical + layout includes a values bitmap buffer and possibly a validity bitmap + buffer. + + .. figure:: ./images/bool-diagram.svg + :alt: Diagram is showing the difference between the boolean data + type presented in a Table and the data actually stored in + computer memory. + + Physical layout diagram for boolean data type. + +.. note:: + Arrow also has a concept of Null data type where all values are null. In + this case no buffers are allocated. + +Variable length binary and string +--------------------------------- + +In contrast to the fixed size primitive layout, the variable length layout +allows representing an array where each element can have a variable size +in bytes. This layout is used for binary and string data. + +The bytes of all elements in a binary or string column are stored together +consecutively in a single buffer or region of memory. To know where each element +of the column starts and ends, the physical layout also includes integer offsets. +The offsets buffer is always one element longer than the array. +The last two offsets define the start and the end of the last +binary/string element. + +Binary and string data types share the same physical layout. The only +difference between them is that a string-typed array is assumed to contain +valid UTF-8 string data. + +The difference between binary/string and large binary/string is in the offset +data type. In the first case that is int32 and in the second it is int64. + +The limitation of data types using 32 bit offsets is that they have a maximum size of +2GB per array. One can still use the non-large variants for bigger data, but +then multiple chunks are needed. + +.. figure:: ./images/var-string-diagram.svg + :alt: Diagram is showing the difference between the variable length + string data type presented in a Table and the data actually + stored in computer memory. + + Physical layout diagram for variable length string data types. + +Variable length binary and string view +-------------------------------------- + +.. _UmbraDB: https://umbra-db.com/ +.. _DuckDB: https://duckdb.com +.. _Velox: https://velox-lib.io/ + +This layout is an alternative for the variable length binary layout and is adapted +from TU Munich's `UmbraDB`_ and is similar to the string layout used in `DuckDB`_ and +`Velox`_ (and sometimes also called "German strings"). + +The main difference to the classical binary and string layout is the views buffer. +It includes the length of the string, and then either its characters appearing +inline (for small strings) or only the first 4 bytes of the string and an offset into +one of the potentially several data buffers. Because it uses an offset and length to refer +to the data buffer, the bytes of all elements do not need to be stored +consecutively in a single buffer. This enables out of order writing of +variable length elements into the array. + +These properties are important for efficient string processing. The prefix +enables a profitable fast path for string comparisons, which are frequently +determined within the first four bytes. Selecting elements is a simple "gather" +operation on the fixed-width views buffer and does not need to rewrite the +values buffers. + +.. figure:: ./images/var-string-view-diagram.svg + :alt: Diagram is showing the difference between the variable length + string view data type presented in a Table and the data actually + stored in computer memory. + + Physical layout diagram for variable length string view data type. + +Nested Layouts +============== + +Nested data types introduce the concept of parent and child arrays. They express +relationships between physical value arrays in a nested data type structure. + +Nested data types depend on one or more other child data types. For instance, List +is a nested data type (parent) that has one child (the data type of the values in +the list). + +List +---- + +The list data type enables representing an array where each element is a sequence +of elements of the same data type. The layout is similar to variable-size binary +or string layout as it has an offsets buffer to define where the sequence of values +for each element starts and ends, with all the values being stored consecutively +in a values child array. + +The offsets in the list data type are int32 while in the large list the offsets +are int64. + +.. figure:: ./images/var-list-diagram.svg + :alt: Diagram is showing the difference between the variable size + list data type presented in a Table and the data actually + stored in computer memory. + + Physical layout diagram for variable size list data type. + +Fixed Size List +--------------- + +Fixed-size list is a special case of variable-size list where each column slot +contains a fixed size sequence meaning all lists are the same size and so the +offset buffer is no longer needed. + +.. figure:: ./images/fixed-list-diagram.svg + :alt: Diagram is showing the difference between the fixed size list data + type presented in a Table and the data actually stored in computer + memory. + + Physical layout diagram for fixed size list data type. + +List View +--------- + +In contrast to the list type, list view type also has a size buffer together +with an offset buffer. The offsets continue to indicate the start of each +element but size is now saved in a separate size buffer. This allows +out-of-order offsets as the sizes aren't derived from the consecutive +offsets anymore. + +.. figure:: ./images/var-list-view-diagram.svg + :alt: Diagram is showing the difference between the variable size list view + data type presented in a Table and the data actually stored in + computer memory. + + Physical layout diagram for variable size list view data type. + +Struct +------ + +A struct is a nested data type parameterized by an ordered sequence of fields +(a data type and a name). + +* There is one child array for each field +* Child arrays are independent and need not be adjacent to each other in + memory. They only need to have the same length. + +One can think of an individual struct field as a key-value pair where the +key is the field name and the child array its values. The field (key) is +saved in the schema and the values of a specific field (key) are saved in +the child array. + +.. figure:: ./images/struct-diagram.svg + :alt: Diagram is showing the difference between the struct data type + presented in a Table and the data actually stored in computer + memory. + + Physical layout diagram for struct data type. + +Map +--- + +The Map data type represents nested data where each value is a variable number of +key-value pairs. Its physical representation is the same as a list of ``{key, value}`` +structs. + +The difference between the struct and map data types is that a struct holds the key +in the schema, requiring keys to be strings, and the values are stored in the +child arrays, +one for each field. There can be multiple keys and therefore multiple child arrays. +The map, on the other hand, has one child array holding all the different keys (that +thus all need to be of the same data type, but not necessarily strings) and a second +child array holding all the values. The values need to be of the same data type; however, +the data type doesn't have to match that of the keys. + +Also, the map stores the struct in a list and needs an offset as the list is +variable shape. + +.. figure:: ./images/map-diagram.svg + :alt: Diagram is showing the difference between the map data type + presented in a Table and the data actually stored in computer + memory. + + Physical layout diagram for map data type. + +Union +----- + +The union is a nested data type where each slot in the union has a value with a data type +chosen from a subset of possible Arrow data types. That means that a union array represents +a mixed-type array. Unlike other data types, unions do not have their own validity bitmap +and the nullness is determined by the child arrays. + +Arrow defines two distinct union data types, "dense" and "sparse". + +Dense Union +^^^^^^^^^^^ + +A Dense Union has one child array for each data type present in the mixed-type array and +two buffers of its own: + +* **Types buffer:** holds data type id for each slot of the array. Data type id is + frequently the index of the child array; however, the relationship between data type + ID and the child index is a parameter of the data type. +* **Offsets buffer:** holds relative offset into the respective child array for each + array slot. + +.. figure:: ./images/dense-union-diagram.svg + :alt: Diagram is showing the difference between the dense union data type + presented in a Table and the data actually stored in computer + memory. + + Physical layout diagram for dense union data type. + +Sparse union +^^^^^^^^^^^^ + +A sparse union has the same structure as a dense union, with the omission of the offsets +buffer. In this case, the child arrays are each equal in length to the length of the union. + + +.. figure:: ./images/sparse-union-diagram.svg + :alt: Diagram is showing the difference between the sparse union data type + presented in a Table and the data actually stored in computer + memory. + + Physical layout diagram for sparse union data type. + +Dictionary Encoded Layout +========================= + +Dictionary encoding can be effective when one has data with many repeated values. +The values are represented by integers referencing a dictionary usually consisting of +unique values. + +.. figure:: ./images/dictionary-diagram.svg + :alt: Diagram is showing the difference between the dictionary data type + presented in a Table and the data actually stored in computer + memory. + + Physical layout diagram for dictionary data type. + +Run-End Encoded Layout +====================== + +Run-end encoding is well-suited for representing data containing sequences of the +same value. These sequences are called runs. A run-end encoded array has no buffers +of its own, but has two child arrays: + +* **Run ends array:** holds the index in the array where each run ends. The number + of run ends is the same as the length of its parent array. +* **Values array:** the actual values without repetitions (together with null values). + +Note that nulls of the parent array are strictly represented in the values array. + +.. figure:: ./images/ree-diagram.svg + :alt: Diagram is showing the difference between the run-end encoded data + type presented in a Table and the data actually stored in computer + memory. + + Physical layout diagram for run-end encoded data type. + +.. seealso:: + Table of all Arrow :ref:`data_types`. + +Overview of Arrow Terminology +============================= + +**Physical layout** +A specification for how to represent values of an array in memory. + +**Buffer** +A contiguous region of memory with a given length in bytes. Buffers are used to store data +for arrays. Sometimes we use the notion of number of elements in a buffer which can only be +used if we know the data type of the array that wraps this specific buffer. + +**Array** +A contiguous, one-dimensional sequence of values with known length where all values have the +same data type. An array consists of zero or more buffers. + +**Chunked Array** +A discontiguous, one-dimensional sequence of values with known length where all values have +the same data type. Consists of zero or more arrays, the “chunks”. + +.. note:: + Chunked Array is a concept specific to certain implementations such as Arrow C++ and PyArrow. + +**RecordBatch** +A contiguous, two-dimensional data structure which consists of an ordered collection of arrays +of the same length. + +**Schema** +An ordered collection of fields that communicates all the data types of an object +like a RecordBatch or Table. Schemas can contain optional key/value metadata. + +A Field includes a field name, a data type, a nullability flag and optional key-value metadata +for a specific column in a RecordBatch. + +**Table** +A discontiguous, two-dimensional chunk of data consisting of an ordered collection of Chunked +Arrays. All Chunked Arrays have the same length, but may have different types. Different columns +may be chunked differently. + +.. note:: + Table is a concept specific to certain implementations such as Arrow C++ and PyArrow. In Java + implementation, for example, a Table is not a collection of Chunked Arrays but a collection of + RecordBatches. + +.. image:: ../cpp/tables-versus-record-batches.svg + :alt: A graphical representation of an Arrow Table and a + Record Batch, with structure as described in text above. + +.. seealso:: + The :ref:`glossary` for more terms. + +Extension Types +=============== + +In case the system or application needs to extend standard Arrow data types with +custom semantics, this is enabled by defining extension types. + +Examples of an extension type are :ref:`uuid_extension` or +:ref:`fixed_shape_tensor_extension` extension type. + +Extension types can be defined by annotating any of the built-in Arrow data types +(the “storage type”) with a custom type name and optional serialized representation +(``'ARROW:extension:name'`` and ``'ARROW:extension:metadata'`` keys in the Field +metadata structure). + +.. seealso:: + The :ref:`format_metadata_extension_types` documentation. + +Canonical Extension Types +------------------------- + +It is beneficial to share the definitions of well-known extension types so as to +improve interoperability between different systems integrating Arrow columnar data. +For this reason canonical extension types are defined in Arrow itself. + +.. seealso:: + The :ref:`format_canonical_extensions` documentation. + +Community Extension Types +------------------------- +These are Arrow extension types that have been established as standards within specific +domain areas. + +Example: + +* `GeoArrow`_: A collection of Arrow extension types for representing vector geometries + +.. _GeoArrow: https://geoarrow.org + +Sharing Arrow data +================== + +Arrow memory layout is meant to be a universal standard for representing tabular data in memory, +not tied to a specific implementation. The Arrow standard defines two protocols for +well-defined and unambiguous communication of Arrow data between applications: + +* Protocol to share Arrow data between processes or over the network is called :ref:`format-ipc`. + The specification for sharing data is called IPC message format which defines how Arrow + array or record batch buffers are stacked together to be serialized and deserialized. + +* To share Arrow data in the same process :ref:`c-data-interface` is used, meant for sharing + the same buffer zero-copy in memory between different libraries within the same process. diff --git a/docs/source/format/images/all-diagrams.svg b/docs/source/format/images/all-diagrams.svg new file mode 100644 index 0000000000000..0238fb84bf368 --- /dev/null +++ b/docs/source/format/images/all-diagrams.svg @@ -0,0 +1,17 @@ + + + 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 + + + + + integer and floatPhysical layout - Fixed-size Primitive Layoutcolumn 1column 2139291.23.49.02.9nullcolumn 1Values bufferValidity bitmap bufferNonecolumn 2Values bufferValidity bitmap buffer00010111struct1 3 9 9 21.2 3.4 9.0 _ 2.9uint8, int8uint16, int16uint32, int32uint64, int64half float (float16)float (float32)double (float64)0 6 10 20 20 26 stringPhysical layout - Variable-size Binary Layoutcolumn 3"python""data""conference""Berlin"nullcolumn 3Offsets bufferValues bufferValidity bitmap buffer00010111pythondataconferenceBerlinbinary (utf8), large_binarystring, large_stringbinary(2)binary with length 2Physical layout - Fixed-size binary Layoutcolumn 4"Py""th""on"column 4Values bufferValidity bitmap bufferPythonNonedecimal128, decimal256 (with metadata for precision and scale)temporal types (date32, date64, time32, time64, timestamp,interval_month, interval_day_time, interval_month_day_nano,duration)binary viewstring viewnestedlist_structPhysical layout - Struct Layoutcolumn 4{"name": "joe", "id": 1}{"name": null, "id": 2}null{"name": "jane", "id": null}{"name": "mark", "id": 4}column 4Values bufferValidity bitmap bufferOffset bufferValidity bitmap buffer0001110100011011children arraysValues bufferjoemarkjaneVariable-size Binary child arrayFixed-size Primitive child arrayValidity bitmap buffer000010110 3 3 3 7 111 2 _ 4 _listPhysical layout - Variable-size List Layoutcolumn 1[12, -7, 25]null[0, -127, 127, 50][]column 1Validity bitmap buffer00001101values array - Fixed-size Primitive child arrayValues bufferOffset bufferValidity bitmap buffer12 -7 25 0 -127 127 500 3 3 7 7 NonedictionarydictionaryPhysical layout - Dictionary-encoded Layoutcolumn 5"Python""Data""Python""Berlin"nullcolumn 5Values bufferValidity bitmap buffer00010111dictionary - Variable-size Binary child arrayValues buffer0 1 0 _ 2Offset buffer0 6 10 16PythonDataBerlinlist_(2)fixed size list with length 2Physical layout - Fixed-size List Layoutcolumn 2[12, -7]null[0, null]column 2Validity bitmap buffer00000101Values bufferValidity bitmap buffer12 -7 _ _ 0 _00011111values array - Fixed-size Primitive child arraylist_viewstring viewPhysical layout - Variable-size Binary View Layoutcolumn 5"String longer than 12""Short"null"Another long string""Short string"column 5lengthViews bufferValues buffersValidity bitmap buffer00011011String longer than 12Another long stringlengthprefixbuffer indexoffsetdata21 Stri 0 05 Short-12 Short string19 Anot 0 210multiple values buffers can exist!buffer indexcolumn 6lengthViews bufferValues buffersValidity bitmap buffer00011011String longer than 12Another long stringlengthprefixbuffer indexoffsetdata21 Stri 0 0-12 Short string19 Anot 0 21019 pyth 1 0pythondataconferenceBerlinstring values buffer1buffer index"String longer than 12""Another long string""pythondataconference"Column 6null"Short string"mapmapPhysical layout - List of Structs Layoutcolumn 6{"Dark Knight": 10}{"Dark Knight": 8, "Meet the Parents": 4, Superman": 5}{"Meet the Parents": 10, "Superman": null}nullcolumn 6Offset bufferValidity bitmap buffer00001011child array - struct0 1 4 4 6Variable-size Binary child arrayFixed-size Primitive child arrayValues bufferOffset bufferValidity bitmap bufferDark KnightDark KnightMeet the ParentsSupermanMeet the ParentsSupermanValues bufferValidity bitmap buffer0001111110 8 4 5 10 0None0 11 22 38 46 62 70list viewPhysical layout -Variable-size List View Layoutcolumn 3[12, -7, 25]null[0, -127, 127, 50][]column 3Validity bitmap buffer00011101Values bufferOffset bufferValidity bitmap buffer0 -127 127 50 12 -7 254 7 0 0 3NoneSize buffer3 0 4 0 2values array - Fixed-size Primitive child array[50, 12]1RobertUK33.52AlbertoPortugal54.023PiotrPoland45.34MarcoItaly23.09idNameCountryCost1RobertUK33.52AlbertoPortugal54.023PiotrPoland45.34MarcoItaly23.091RobertUK33.52AlbertoPortugal54.023PiotrPoland45.34MarcoItaly23.09run-end encodedPhysical layout - Run-End Encoded Layoutcolumn 71.01.01.02.0nullchildren arraysFixed-size Primitive child array (values)Values bufferValidity bitmap bufferValues bufferValidity bitmap buffer1.0 _ 2.03 4 5Fixed-size Primitive child array (run_ends)00000101should be None or all 1sboolbooleanPhysical layout - Primitive Layout, data as a bitmapcolumn 10TrueTrueFalseFalsenullcolumn 10Values bitmap bufferValidity bitmap buffer0011011111000100TruenullnullPhysical layout - Null Layout (empty with one integer for array length)column 0nullnullnullcolumn 0Values bufferValidity bitmap bufferNone3dense union (int, float, string)Physical layout - Dense Union Layoutcolumn 8column 8Offset bufferTypes buffer0 0 1 2 1 0 20 1 0 0 1 2 1children arraysFixed-size Primitive child array (Field-1)Values bufferValidity bitmap bufferValues bufferValidity bitmap buffer1.2 3.45 _ 4Fixed-size Primitive child array (Field-0)00000101NoneVariable-size Binary child array (Field-2)51.2"joe"43.4"mark"nullNoneOffsets bufferValidity bitmap buffer0 3 7Values bufferjoemarksparse union (int, float, string)Physical layout - Sparse Union Layoutcolumn 9column 9Types buffer0 0 1 2 1 0 2children arraysFixed-size Primitive child array 1Values bufferValidity bitmap bufferValues bufferValidity bitmap buffer_ _ 1.2 _ 3.4 _ _5 _ _ _ _ 4 _Fixed-size Primitive child array 000100001Variable-size Binary child array 2Offsets bufferValidity bitmap buffer0 0 0 0 3 3 3 70001010001001000Values bufferjoemark51.2"joe"43.4"mark"null1RobertUK33.52AlbertoPortugal54.023PiotrPoland45.34MarcoItaly23.09idNameCountryCost \ No newline at end of file diff --git a/docs/source/format/images/bool-diagram.svg b/docs/source/format/images/bool-diagram.svg new file mode 100644 index 0000000000000..76ac8af55ee18 --- /dev/null +++ b/docs/source/format/images/bool-diagram.svg @@ -0,0 +1,10 @@ + + + + + + + + booleanPhysical layout - Primitive Layout, data as a bitmapcolumn 10TrueTrueFalseFalsenullcolumn 10Values bitmap bufferValidity bitmap buffer0011011111000100True \ No newline at end of file diff --git a/docs/source/format/images/columnar-diagram_1.svg b/docs/source/format/images/columnar-diagram_1.svg new file mode 100644 index 0000000000000..5cc05eaf4db2e --- /dev/null +++ b/docs/source/format/images/columnar-diagram_1.svg @@ -0,0 +1,21 @@ + + + + + + + + 1RobertUK33.52AlbertoPortugal54.023PiotrPoland45.34MarcoItaly23.09idNameCountryCost \ No newline at end of file diff --git a/docs/source/format/images/columnar-diagram_2.svg b/docs/source/format/images/columnar-diagram_2.svg new file mode 100644 index 0000000000000..5f7b72486cb58 --- /dev/null +++ b/docs/source/format/images/columnar-diagram_2.svg @@ -0,0 +1,21 @@ + + + + + + + + 1RobertUK33.52AlbertoPortugal54.023PiotrPoland45.34MarcoItaly23.09 \ No newline at end of file diff --git a/docs/source/format/images/columnar-diagram_3.svg b/docs/source/format/images/columnar-diagram_3.svg new file mode 100644 index 0000000000000..ce4838d3011ce --- /dev/null +++ b/docs/source/format/images/columnar-diagram_3.svg @@ -0,0 +1,21 @@ + + + + + + + + 1RobertUK33.52AlbertoPortugal54.023PiotrPoland45.34MarcoItaly23.09 \ No newline at end of file diff --git a/docs/source/format/images/dense-union-diagram.svg b/docs/source/format/images/dense-union-diagram.svg new file mode 100644 index 0000000000000..a2fadf8bb7be8 --- /dev/null +++ b/docs/source/format/images/dense-union-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + dense union (int, float, string)Physical layout - Dense Union Layoutcolumn 8column 8Offset bufferTypes buffer0 0 1 2 1 0 20 1 0 0 1 2 1children arraysFixed-size Primitive child array (Field-1)Values bufferValidity bitmap bufferValues bufferValidity bitmap buffer1.2 3.45 _ 4Fixed-size Primitive child array (Field-0)00000101NoneVariable-size Binary child array (Field-2)51.2"joe"43.4"mark"nullNoneOffsets bufferValidity bitmap buffer0 3 7Values bufferjoemark \ No newline at end of file diff --git a/docs/source/format/images/dictionary-diagram.svg b/docs/source/format/images/dictionary-diagram.svg new file mode 100644 index 0000000000000..be1facb3f421b --- /dev/null +++ b/docs/source/format/images/dictionary-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + dictionaryPhysical layout - Dictionary-encoded Layoutcolumn 5"Python""Data""Python""Berlin"nullcolumn 5Values bufferValidity bitmap buffer00010111dictionary - Variable-size Binary child arrayValues buffer0 1 0 _ 2Offset buffer0 6 10 16PythonDataBerlin \ No newline at end of file diff --git a/docs/source/format/images/fixed-list-diagram.svg b/docs/source/format/images/fixed-list-diagram.svg new file mode 100644 index 0000000000000..e0be404e54cb8 --- /dev/null +++ b/docs/source/format/images/fixed-list-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + fixed size list with length 2Physical layout - Fixed-size List Layoutcolumn 2[12, -7]null[0, null]column 2Validity bitmap buffer00000101Values bufferValidity bitmap buffer12 -7 _ _ 0 _00011111values array - Fixed-size Primitive child array \ No newline at end of file diff --git a/docs/source/format/images/fixed-string-diagram.svg b/docs/source/format/images/fixed-string-diagram.svg new file mode 100644 index 0000000000000..2f857ef149292 --- /dev/null +++ b/docs/source/format/images/fixed-string-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + binary with length 2Physical layout - Fixed-size binary Layoutcolumn 4"Py""th""on"column 4Values bufferValidity bitmap bufferPythonNone \ No newline at end of file diff --git a/docs/source/format/images/map-diagram.svg b/docs/source/format/images/map-diagram.svg new file mode 100644 index 0000000000000..b50c2a9e2cf99 --- /dev/null +++ b/docs/source/format/images/map-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + mapPhysical layout - List of Structs Layoutcolumn 6{"Dark Knight": 10}{"Dark Knight": 8, "Meet the Parents": 4, Superman": 5}{"Meet the Parents": 10, "Superman": null}nullcolumn 6Offset bufferValidity bitmap buffer00001011child array - struct0 1 4 4 6Variable-size Binary child arrayFixed-size Primitive child arrayValues bufferOffset bufferValidity bitmap bufferDark KnightDark KnightMeet the ParentsSupermanMeet the ParentsSupermanValues bufferValidity bitmap buffer0001111110 8 4 5 10 0None0 11 22 38 46 62 70 \ No newline at end of file diff --git a/docs/source/format/images/primitive-diagram.svg b/docs/source/format/images/primitive-diagram.svg new file mode 100644 index 0000000000000..c7158ef4d99ef --- /dev/null +++ b/docs/source/format/images/primitive-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + integer and floatPhysical layout - Fixed-size Primitive Layoutcolumn 1column 2139291.23.49.02.9nullcolumn 1Values bufferValidity bitmap bufferNonecolumn 2Values bufferValidity bitmap buffer000101111 3 9 9 21.2 3.4 9.0 _ 2.9 \ No newline at end of file diff --git a/docs/source/format/images/ree-diagram.svg b/docs/source/format/images/ree-diagram.svg new file mode 100644 index 0000000000000..8913ef91e13d0 --- /dev/null +++ b/docs/source/format/images/ree-diagram.svg @@ -0,0 +1,13 @@ + + + + + + + + run-end encodedPhysical layout - Run-End Encoded Layoutcolumn 71.01.01.02.0nullchildren arraysFixed-size Primitive child array (values)Values bufferValidity bitmap bufferValues bufferValidity bitmap buffer1.0 _ 2.03 4 5Fixed-size Primitive child array (run_ends)00000101should be None or all 1s \ No newline at end of file diff --git a/docs/source/format/images/sparse-union-diagram.svg b/docs/source/format/images/sparse-union-diagram.svg new file mode 100644 index 0000000000000..cc150f0e70a6d --- /dev/null +++ b/docs/source/format/images/sparse-union-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + sparse union (int, float, string)Physical layout - Sparse Union Layoutcolumn 9column 9Types buffer0 0 1 2 1 0 2children arraysFixed-size Primitive child array 1Values bufferValidity bitmap bufferValues bufferValidity bitmap buffer_ _ 1.2 _ 3.4 _ _5 _ _ _ _ 4 _Fixed-size Primitive child array 000100001Variable-size Binary child array 2Offsets bufferValidity bitmap buffer0 0 0 0 3 3 3 70001010001001000Values bufferjoemark51.2"joe"43.4"mark"null \ No newline at end of file diff --git a/docs/source/format/images/struct-diagram.svg b/docs/source/format/images/struct-diagram.svg new file mode 100644 index 0000000000000..81ff29689a855 --- /dev/null +++ b/docs/source/format/images/struct-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + structPhysical layout - Struct Layoutcolumn 4{"name": "joe", "id": 1}{"name": null, "id": 2}null{"name": "jane", "id": null}{"name": "mark", "id": 4}column 4Values bufferValidity bitmap bufferOffset bufferValidity bitmap buffer0001110100011011children arraysValues bufferjoemarkjaneVariable-size Binary child arrayFixed-size Primitive child arrayValidity bitmap buffer000010110 3 3 3 7 111 2 _ 4 _ \ No newline at end of file diff --git a/docs/source/format/images/var-list-diagram.svg b/docs/source/format/images/var-list-diagram.svg new file mode 100644 index 0000000000000..a3024371d3380 --- /dev/null +++ b/docs/source/format/images/var-list-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + listPhysical layout - Variable-size List Layoutcolumn 1[12, -7, 25]null[0, -127, 127, 50][]column 1Validity bitmap buffer00001101values array - Fixed-size Primitive child arrayValues bufferOffset bufferValidity bitmap buffer12 -7 25 0 -127 127 500 3 3 7 7 None \ No newline at end of file diff --git a/docs/source/format/images/var-list-view-diagram.svg b/docs/source/format/images/var-list-view-diagram.svg new file mode 100644 index 0000000000000..dab451556d9e2 --- /dev/null +++ b/docs/source/format/images/var-list-view-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + list viewPhysical layout -Variable-size List View Layoutcolumn 3[12, -7, 25]null[0, -127, 127, 50][]column 3Validity bitmap buffer00011101Values bufferOffset bufferValidity bitmap buffer0 -127 127 50 12 -7 254 7 0 0 3NoneSize buffer3 0 4 0 2values array - Fixed-size Primitive child array[50, 12] \ No newline at end of file diff --git a/docs/source/format/images/var-string-diagram.svg b/docs/source/format/images/var-string-diagram.svg new file mode 100644 index 0000000000000..8cf17498ba6aa --- /dev/null +++ b/docs/source/format/images/var-string-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + 0 6 10 20 20 26 stringPhysical layout - Variable-size Binary Layoutcolumn 3"python""data""conference""Berlin"nullcolumn 3Offsets bufferValues bufferValidity bitmap buffer00010111pythondataconferenceBerlin \ No newline at end of file diff --git a/docs/source/format/images/var-string-view-diagram.svg b/docs/source/format/images/var-string-view-diagram.svg new file mode 100644 index 0000000000000..c3aa87ac4a5e6 --- /dev/null +++ b/docs/source/format/images/var-string-view-diagram.svg @@ -0,0 +1,21 @@ + + + + + + + + string viewPhysical layout - Variable-size Binary View Layoutcolumn 5"String longer than 12""Short"null"Another long string""Short string"column 5lengthViews bufferValues buffersValidity bitmap buffer00011011String longer than 12Another long stringlengthprefixbuffer indexoffsetdata21 Stri 0 05 Short-12 Short string19 Anot 0 210multiple values buffers can exist!buffer indexcolumn 6lengthViews bufferValues buffersValidity bitmap buffer00011011String longer than 12Another long stringlengthprefixbuffer indexoffsetdata21 Stri 0 0-12 Short string19 Anot 0 21019 pyth 1 0pythondataconferenceBerlinstring values buffer1buffer index"String longer than 12""Another long string""pythondataconference"Column 6null"Short string" \ No newline at end of file diff --git a/docs/source/format/index.rst b/docs/source/format/index.rst index 44ea3e8e7e608..ce31a15a1f36a 100644 --- a/docs/source/format/index.rst +++ b/docs/source/format/index.rst @@ -23,8 +23,10 @@ Specifications .. toctree:: :maxdepth: 2 - Versioning + Intro Columnar + Versioning + Changing CanonicalExtensions Other CDataInterface @@ -34,6 +36,5 @@ Specifications Flight FlightSql ADBC - Changing Integration Glossary