ak.to_arrow_table
-----------------

.. py:module: ak.to_arrow_table

Defined in `awkward.operations.ak_to_arrow_table <https://github.com/scikit-hep/awkward/blob/76cb66b946cbf2ae355bddf2530b323465395bae/src/awkward/operations/ak_to_arrow_table.py>`__ on `line 18 <https://github.com/scikit-hep/awkward/blob/76cb66b946cbf2ae355bddf2530b323465395bae/src/awkward/operations/ak_to_arrow_table.py#L18>`__.

.. py:function:: ak.to_arrow_table(array, *, list_to32=False, string_to32=False, bytestring_to32=False, emptyarray_to=None, categorical_as_dictionary=False, extensionarray=True, count_nulls=True)


    :param array: Array-like data (anything :py:obj:`ak.to_layout` recognizes).
    :param list_to32: If True, convert Awkward lists into 32-bit Arrow lists
                  if they're small enough, even if it means an extra conversion. Otherwise,
                  signed 32-bit :py:obj:`ak.types.ListType` maps to Arrow ``ListType``,
                  signed 64-bit :py:obj:`ak.types.ListType` maps to Arrow ``LargeListType``,
                  and unsigned 32-bit :py:obj:`ak.types.ListType` picks whichever Arrow type its
                  values fit into.
    :type list_to32: bool
    :param string_to32: Same as the above for Arrow ``string`` and ``large_string``.
    :type string_to32: bool
    :param bytestring_to32: Same as the above for Arrow ``binary`` and ``large_binary``.
    :type bytestring_to32: bool
    :param emptyarray_to: If None, :py:obj:`ak.types.UnknownType` maps to Arrow's
                      null type; otherwise, it is converted a given numeric dtype.
    :type emptyarray_to: None or dtype
    :param categorical_as_dictionary: If True, :py:obj:`ak.contents.IndexedArray` and
                                  :py:obj:`ak.contents.IndexedOptionArray` labeled with ``__array__ = "categorical"``
                                  are mapped to Arrow ``DictionaryArray``; otherwise, the projection is
                                  evaluated before conversion (always the case without
                                  ``__array__ = "categorical"``).
    :type categorical_as_dictionary: bool
    :param extensionarray: If True, this function returns extended Arrow arrays
                       (at all levels of nesting), which preserve metadata so that Awkward →
                       Arrow → Awkward preserves the array's :py:obj:`ak.types.Type` (though not
                       the :py:obj:`ak.forms.Form`). If False, this function returns generic Arrow arrays
                       that might be needed for third-party tools that don't recognize Arrow's
                       extensions. Even with ``extensionarray=False``, the values produced by
                       Arrow's ``to_pylist`` method are the same as the values produced by Awkward's
                       :py:obj:`ak.to_list`.
    :type extensionarray: bool
    :param count_nulls: If True, count the number of missing values at each level
                    and include these in the resulting Arrow array, which makes some downstream
                    applications faster. If False, skip the up-front cost of counting them.
    :type count_nulls: bool

Converts an Awkward Array into an Apache Arrow table.

This produces arrays of type ``pyarrow.Table``. If you want an Arrow array,
see :py:obj:`ak.to_arrow`.

This function always preserves the values of a dataset; i.e. the Python objects
returned by :py:obj:`ak.to_list` are identical to the Python objects returned by Arrow's
``to_pylist`` method. With ``extensionarray=True``, this function also preserves the
data type (high-level :py:obj:`ak.types.Type`, though not the low-level :py:obj:`ak.forms.Form`),
even through Parquet, making Parquet a good way to save Awkward Arrays for later
use. If any third-party tools don't recognize Arrow's extension arrays, set this
option to False for plain Arrow arrays.

See also :py:obj:`ak.from_arrow`, :py:obj:`ak.to_arrow`, :py:obj:`ak.to_parquet`.