sparrow Namespace Reference

Namespaces
namespace	chrono
namespace	detail
namespace	details
namespace	impl
namespace	mpl
namespace	predicate
namespace	ranges

Classes
class	any_allocator
class	array
	Dynamically typed array encapsulating an Arrow layout. More...
class	array_bitmap_base_impl
	Base class for arrays using a validity buffer for defining their bitmap. More...
class	array_crtp_base
	Base class defining common immutable interface for arrays with a bitmap. More...
struct	array_inner_types
	Traits class that must be specialized by array classes inheriting from array_crtp_base. More...
struct	array_inner_types< decimal_array< T > >
struct	array_inner_types< fixed_sized_list_array >
struct	array_inner_types< fixed_width_binary_array_impl< T, CR > >
struct	array_inner_types< list_array_impl< BIG > >
struct	array_inner_types< list_view_array_impl< BIG > >
struct	array_inner_types< map_array >
struct	array_inner_types< primitive_array_impl< T > >
struct	array_inner_types< struct_array >
struct	array_inner_types< timestamp_array< T > >
struct	array_inner_types< variable_size_binary_array_impl< T, CR, OT > >
struct	array_inner_types< variable_size_binary_view_array_impl< T > >
struct	array_inner_types_base
	Base class for array_inner_types specialization. More...
struct	array_traits
class	array_wrapper
	Base class for array type erasure. More...
class	array_wrapper_impl
struct	arrow_array_and_schema
struct	arrow_array_and_schema_pointers
class	arrow_array_private_data
	Private data for ArrowArray. More...
struct	arrow_data_ownership
	Specifies the ownership model when passing Arrow data to another system through ArrowArray and ArrowSchema More...
class	arrow_proxy
	Proxy class over ArrowArray and ArrowSchema. More...
class	arrow_proxy_exception
	Exception thrown by the arrow_proxy class. More...
class	arrow_schema_private_data
	Private data for ArrowSchema. More...
struct	arrow_traits
	Provides compile-time information about Arrow data types. More...
struct	arrow_traits< bool >
struct	arrow_traits< chrono::months >
struct	arrow_traits< chrono::time_microseconds >
struct	arrow_traits< chrono::time_milliseconds >
struct	arrow_traits< chrono::time_nanoseconds >
struct	arrow_traits< chrono::time_seconds >
struct	arrow_traits< date_days >
struct	arrow_traits< date_milliseconds >
struct	arrow_traits< days_time_interval >
struct	arrow_traits< decimal< int128_t > >
struct	arrow_traits< decimal< int256_t > >
struct	arrow_traits< decimal< std::int32_t > >
struct	arrow_traits< decimal< std::int64_t > >
struct	arrow_traits< list_value >
struct	arrow_traits< map_value >
struct	arrow_traits< month_day_nanoseconds_interval >
struct	arrow_traits< null_type >
struct	arrow_traits< std::chrono::microseconds >
struct	arrow_traits< std::chrono::milliseconds >
struct	arrow_traits< std::chrono::nanoseconds >
struct	arrow_traits< std::chrono::seconds >
struct	arrow_traits< std::string >
struct	arrow_traits< std::vector< byte_t > >
struct	arrow_traits< struct_value >
struct	arrow_traits< T >
struct	arrow_traits< timestamp< std::chrono::microseconds > >
struct	arrow_traits< timestamp< std::chrono::milliseconds > >
struct	arrow_traits< timestamp< std::chrono::nanoseconds > >
struct	arrow_traits< timestamp< std::chrono::seconds > >
struct	arrow_traits< zoned_time_without_timezone_microseconds >
struct	arrow_traits< zoned_time_without_timezone_milliseconds >
struct	arrow_traits< zoned_time_without_timezone_nanoseconds >
struct	arrow_traits< zoned_time_without_timezone_seconds >
class	bad_nullable_access
class	bitset_iterator
	Iterator used to iterate over the bits of a dynamic bitset as if they were addressable values. More...
class	bitset_reference
	Reference proxy used by the bitset_iterator class to make it possible to assign a bit of a bitset as a regular reference. More...
class	buffer
	Object that owns a piece of contiguous memory. More...
class	buffer_adaptor
	Class which have internally a reference to a contiguous container of a certain type and provides an API to access it as if it was a buffer<T>. More...
class	buffer_base
	Base class for buffer. More...
class	buffer_view
class	children_ownership
class	cloning_ptr
	Smart pointer behaving like a copiable std::unique_ptr. More...
struct	common_native_types_traits
class	contract_assertion_error
class	crtp_base
	Base class for CRTP base classes. More...
class	data_descriptor
struct	days_time_interval
class	decimal
class	decimal_array
class	decimal_reference
	Implementation of reference to inner type used for layout L. More...
class	dense_union_array
	A dense union array implementation. More...
struct	dense_union_flag_t
class	dict_encode
class	dictionary_encoded_array
	Dictionary encoded array class. More...
class	dictionary_ownership
class	dynamic_bitset
	This class represents a dynamic size sequence of bits. More...
class	dynamic_bitset_base
	Base class for dynamic_bitset and dynamic_bitset_view. More...
class	dynamic_bitset_view
	This class represents a view to a dynamic size sequence of bits. More...
class	empty_iterator
class	fixed_sized_list_array
class	fixed_width_binary_array_impl
class	fixed_width_binary_reference
	Implementation of reference to inner type used for layout L. More...
class	functor_index_iterator
class	holder
struct	is_date_array
struct	is_date_array< date_array< T > >
struct	is_duration_array
struct	is_duration_array< duration_array< T > >
struct	is_interval_array
struct	is_interval_array< interval_array< T > >
struct	is_move_iterator
struct	is_move_iterator< std::move_iterator< Iterator > >
struct	is_nullable
struct	is_nullable< nullable< T, B > >
struct	is_primitive_array
struct	is_primitive_array< primitive_array< T > >
struct	is_time_array
struct	is_time_array< time_array< T > >
struct	is_timestamp_array
struct	is_timestamp_array< timestamp_array< T > >
struct	is_timestamp_without_timezone_array
struct	is_timestamp_without_timezone_array< timestamp_without_timezone_array< T > >
struct	is_variable_size_binary_view_array_impl
struct	is_variable_size_binary_view_array_impl< variable_size_binary_view_array_impl< T > >
class	iterator_access
class	iterator_adaptor
class	iterator_base
class	iterator_root_base
class	iterator_root_base< Derived, Element, std::bidirectional_iterator_tag, Reference, Difference >
class	iterator_root_base< Derived, Element, std::contiguous_iterator_tag, Reference, Difference >
class	iterator_root_base< Derived, Element, std::forward_iterator_tag, Reference, Difference >
class	iterator_root_base< Derived, Element, std::random_access_iterator_tag, Reference, Difference >
class	key_value_view
class	key_value_view_iterator
struct	large_binary_flag_t
struct	large_list_flag_t
class	layout_element_functor
class	layout_iterator
	Layout iterator class. More...
class	list_array_crtp_base
class	list_array_impl
class	list_value
class	list_value_iterator
class	list_view_array_impl
class	map_array
class	map_value
struct	month_day_nanoseconds_interval
class	mutable_array_base
	Base class definining common interface for arrays with a bitmap. More...
class	non_owning_dynamic_bitset
class	null_array
	A null array implementation. More...
struct	null_type
class	nullable
	The nullable class models a value or a reference that can be "null", or missing, like values traditionally used in data science libraries. More...
struct	nullable_traits
struct	nullable_traits< T & >
class	nullable_variant
	variant of nullable, exposing has_value for convenience More...
struct	nullval_t
	nullval_t is an empty class used to indicate that a nullable is null. More...
struct	overloaded
class	pointer_iterator
class	pointer_iterator< T * >
class	primitive_array_impl
class	record_batch
	Table-like data structure. More...
class	repeat_view
	A view that repeats a value a given number of times. More...
class	repeat_view_iterator
class	run_encoded_array_iterator
class	run_end_encode
class	run_end_encoded_array
	A run-end encoded array. More...
class	sequence_view
	The class sequence_view describes an object that can refer to a constant contiguous sequence of T with the first element of the sequence at position zero. More...
class	sparse_union_array
	A sparse union array implementation. More...
struct	sparse_union_flag_t
class	struct_array
	A struct array. More...
class	struct_value
class	timestamp_array
	Array of timestamps. More...
class	timestamp_reference
	Implementation of reference to inner type used for layout L. More...
class	u8_buffer
	This buffer class is use as storage buffer for all sparrow arrays. More...
class	union_array_crtp_base
class	value_ptr
	A value_ptr is a smart pointer that behaves like a value. More...
class	variable_size_binary_array_impl
class	variable_size_binary_reference
	Implementation of reference to inner type used for layout L. More...
class	variable_size_binary_value_iterator
	Iterator over the data values of a variable size binary layout. More...
class	variable_size_binary_view_array_impl
struct	zoned_time_without_timezone_microseconds
	A zoned time value without timezone, in microseconds. More...
struct	zoned_time_without_timezone_milliseconds
	A zoned time value without timezone, in milliseconds. More...
struct	zoned_time_without_timezone_nanoseconds
	A zoned time value without timezone, in nanoseconds. More...
struct	zoned_time_without_timezone_seconds
	A zoned time value without timezone, in seconds. More...

Concepts
concept	layout_or_array
concept	allocator
concept	can_any_allocator_sbo
concept	is_buffer_view
concept	BufferReference
concept	T_is_const_if_FromBufferRef_is_const
concept	validity_bitmap_input
concept	any_arrow_c_interface
	Matches only the C interface structs for Arrow.
concept	arrow_schema_or_ptr
	Matches ArrowSchema or a non-const pointer to an ArrowSchema.
concept	arrow_array_or_ptr
	Matches ArrowArray or a non-const pointer to an ArrowArray.
concept	layout
concept	iterator_types
	Concept for iterator types.
concept	primitive_type
concept	trivial_copyable_type
concept	date_type
concept	duration_type
concept	interval_type
concept	time_type
concept	timestamp_type
concept	zoned_time_without_timezone_type
concept	variable_size_binary_view_impl_types
concept	is_arrow_base_type
	Matches C++ representation types which are supported by default.
concept	is_arrow_base_type_extended
	Checks if a type is an extended base type for Arrow.
concept	is_arrow_traits
	Matches valid and complete arrow_traits specializations for type T.
concept	has_arrow_type_traits
	Matches types providing valid and complete arrow_traits specialization.
concept	any_arrow_type
	Matches any type which is one of the base C++ types supported or at least that provides an arrow_traits specialization.
concept	layout_offset
concept	decimal_integer_type
concept	decimal_type
concept	RangeOfRanges
concept	Format
concept	RangeOfFormats
concept	clonable
	Matches types that provide a clone method.
concept	input_metadata_container
concept	nullable_of
concept	nullable_of_convertible_to
concept	range_of_nullables
concept	fixed_size_sequence_view

Typedefs
using	validity_bitmap = dynamic_bitset<std::uint8_t>
template<class D>
using	array_bitmap_base = array_bitmap_base_impl<D, false>
	Convenient typedef to be used as a crtp base class for arrays using an immutable validity buffer.
template<class D>
using	mutable_array_bitmap_base = array_bitmap_base_impl<D, true>
	Convenient typedef to be used as a crtp base class for arrays using a mutable validity buffer.
using	decimal_32_array = decimal_array<decimal<int32_t>>
using	decimal_64_array = decimal_array<decimal<int64_t>>
using	decimal_128_array = decimal_array<decimal<int128_t>>
using	decimal_256_array = decimal_array<decimal<int256_t>>
template<class F>
using	visit_result_t = std::invoke_result_t<F, null_array>
using	fixed_width_binary_traits = arrow_traits<std::vector<byte_t>>
using	fixed_width_binary_array
	A fixed-width binary array implementation.
using	list_array = list_array_impl<false>
	A list array implementation.
using	big_list_array = list_array_impl<true>
	A big list array implementation.
using	list_view_array = list_view_array_impl<false>
	A list view array implementation.
using	big_list_view_array = list_view_array_impl<true>
template<primitive_type T>
using	primitive_array = primitive_array_impl<T>
	Array of values of whose type has fixed binary size.
using	date_types_t = mpl::typelist<date_days, date_milliseconds>
template<date_type T>
using	date_array = primitive_array_impl<T>
	Array of std::chrono::duration values.
using	date_days_array = date_array<date_days>
	A date array for date_days values.
using	date_milliseconds_array = date_array<date_milliseconds>
	A date array for date_milliseconds values.
using	date_days = std::chrono::time_point<std::chrono::system_clock, chrono::days>
using	date_milliseconds = std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>
using	duration_types_t
template<duration_type T>
using	duration_array = primitive_array_impl<T>
	Array of std::chrono::duration values.
using	duration_seconds_array = duration_array<std::chrono::seconds>
	A duration array for std::chrono::seconds values.
using	duration_milliseconds_array = duration_array<std::chrono::milliseconds>
	A duration array for std::chrono::milliseconds values.
using	duration_microseconds_array = duration_array<std::chrono::microseconds>
	A duration array for std::chrono::microseconds values.
using	duration_nanoseconds_array = duration_array<std::chrono::nanoseconds>
	A duration array for std::chrono::nanoseconds values.
using	interval_types_t = mpl::typelist<chrono::months, days_time_interval, month_day_nanoseconds_interval>
template<interval_type T>
using	interval_array = primitive_array_impl<T>
	Array of interval values.
using	months_interval_array = interval_array<chrono::months>
	An interval array for std::chrono::months values.
using	days_time_interval_array = interval_array<days_time_interval>
	An interval array for days_time_interval values.
using	month_day_nanoseconds_interval_array = interval_array<month_day_nanoseconds_interval>
	An interval array for month_day_nanoseconds_interval values.
using	time_types_t
template<time_type T>
using	time_array = primitive_array_impl<T>
	Array of time values.
using	time_seconds_array = time_array<chrono::time_seconds>
	A time array for std::chrono::time_seconds values.
using	time_milliseconds_array = time_array<chrono::time_milliseconds>
	A time array for std::chrono::time_milliseconds values.
using	time_microseconds_array = time_array<chrono::time_microseconds>
	A time array for std::chrono::time_microseconds values.
using	time_nanoseconds_array = time_array<chrono::time_nanoseconds>
	A time array for std::chrono::time_nanoseconds values.
using	timestamp_second = timestamp<std::chrono::seconds>
using	timestamp_millisecond = timestamp<std::chrono::milliseconds>
using	timestamp_microsecond = timestamp<std::chrono::microseconds>
using	timestamp_nanosecond = timestamp<std::chrono::nanoseconds>
using	timestamp_seconds_array = timestamp_array<timestamp_second>
using	timestamp_milliseconds_array = timestamp_array<timestamp_millisecond>
using	timestamp_microseconds_array = timestamp_array<timestamp_microsecond>
using	timestamp_nanoseconds_array = timestamp_array<timestamp_nanosecond>
using	timestamp_types_t
using	zoned_time_without_timezone_types_t
template<zoned_time_without_timezone_type T>
using	timestamp_without_timezone_array = primitive_array_impl<T>
	Array of timestamps without timezone.
using	timestamp_without_timezone_seconds_array = timestamp_without_timezone_array<zoned_time_without_timezone_seconds>
	A timestamp without timezone array for zoned_time_without_timezone_seconds values.
using	timestamp_without_timezone_milliseconds_array
	A timestamp without timezone array for zoned_time_without_timezone_milliseconds values.
using	timestamp_without_timezone_microseconds_array
	A timestamp without timezone array for zoned_time_without_timezone_microseconds values.
using	timestamp_without_timezone_nanoseconds_array
	A timestamp without timezone array for zoned_time_without_timezone_nanoseconds values.
using	binary_traits = arrow_traits<std::vector<byte_t>>
using	string_array = variable_size_binary_array_impl<std::string, std::string_view, std::int32_t>
	A variable-size string array implementation.
using	big_string_array = variable_size_binary_array_impl<std::string, std::string_view, std::int64_t>
	A variable-size string array implementation with 64-bit offsets.
using	binary_array = variable_size_binary_array_impl<binary_traits::value_type, binary_traits::const_reference, std::int32_t>
	A variable-size binary array implementation.
using	big_binary_array
	A variable-size binary array implementation with 64-bit offsets.
using	string_view_array = variable_size_binary_view_array_impl<std::string_view>
	A variable-size string view layout implementation.
using	binary_view_array = variable_size_binary_view_array_impl<sequence_view<const std::byte>>
	A variable-size binary view layout implementation.
using	float16_t = half_float::half
using	float32_t = float
using	float64_t = double
template<typename Duration, typename TimeZonePtr = const date::time_zone*>
using	timestamp = date::zoned_time<Duration, TimeZonePtr>
using	byte_t = std::byte
using	all_base_types_t
	C++ types value representation types matching Arrow types.
using	all_base_types_extended_t = mpl::append_t<all_base_types_t, char, std::string_view>
	is arrow base type or arrow compound type (list<T>, struct<T> etc.)
template<class T>
using	get_corresponding_arrow_type_t = std::conditional_t<std::same_as<T, std::string_view>, std::string, T>
	Template alias to get the corresponding Arrow type for a given type.
template<has_arrow_type_traits T>
using	default_layout_t = typename arrow_traits<T>::default_layout
	Binary layout type to use by default for the given C++ representation T of an arrow value.
using	int128_t = primesum::int128_t
using	int256_t = primesum::int256_t
using	metadata_key = std::string_view
using	metadata_value = std::string_view
using	metadata_pair = std::pair<metadata_key, metadata_value>

Enumerations
enum class	ArrowFlag : int64_t { DICTIONARY_ORDERED = 1 , NULLABLE = 2 , MAP_KEYS_SORTED = 4 }
enum class	ownership : bool { not_owning , owning }
	Specifies the ownership model when passing Arrow data to another system. More...
enum class	data_type : uint8_t {   NA = 0 , BOOL = 1 , UINT8 = 2 , INT8 = 3 ,   UINT16 = 4 , INT16 = 5 , UINT32 = 6 , INT32 = 7 ,   UINT64 = 8 , INT64 = 9 , HALF_FLOAT = 10 , FLOAT = 11 ,   DOUBLE = 12 , STRING = 13 , LARGE_STRING = 14 , BINARY = 15 ,   LARGE_BINARY = 16 , LIST = 19 , LARGE_LIST = 20 , LIST_VIEW = 21 ,   LARGE_LIST_VIEW = 22 , FIXED_SIZED_LIST = 23 , STRUCT = 24 , MAP = 25 ,   STRING_VIEW = 26 , BINARY_VIEW = 27 , DENSE_UNION , SPARSE_UNION ,   RUN_ENCODED , DECIMAL32 , DECIMAL64 , DECIMAL128 ,   DECIMAL256 , FIXED_WIDTH_BINARY , DATE_DAYS , DATE_MILLISECONDS ,   TIMESTAMP_SECONDS , TIMESTAMP_MILLISECONDS , TIMESTAMP_MICROSECONDS , TIMESTAMP_NANOSECONDS ,   TIME_SECONDS , TIME_MILLISECONDS , TIME_MICROSECONDS , TIME_NANOSECONDS ,   DURATION_SECONDS , DURATION_MILLISECONDS , DURATION_MICROSECONDS , DURATION_NANOSECONDS ,   INTERVAL_MONTHS , INTERVAL_DAYS_TIME , INTERVAL_MONTHS_DAYS_NANOSECONDS }
	Runtime identifier of arrow data types, usually associated with raw bytes with the associated value. More...

Functions
template<layout_or_array A>
bool	owns_arrow_array (const A &a)
	Returns true if the given layout or array has ownership of its internal ArrowArray.
template<layout_or_array A>
bool	owns_arrow_schema (const A &a)
	Returns true if the given layout or array has ownership of its internal ArrowSchema.
template<layout_or_array A>
ArrowArray *	get_arrow_array (A &a)
	Returns a pointer to the internal ArrowArray of the given array or layout.
template<layout_or_array A>
ArrowSchema *	get_arrow_schema (A &a)
	Returns a pointer to the internal ArrowSchema of the given array or layout.
template<layout_or_array A>
std::pair< ArrowArray *, ArrowSchema * >	get_arrow_structures (A &a)
	Returns pointers to the internal ArrowArray and ArrowSchema of the given Array or layout.
template<layout_or_array A>
ArrowArray	extract_arrow_array (A &&a)
	Extracts the internal ArrowArray structure from the given Array or typed layout.
template<layout_or_array A>
ArrowSchema	extract_arrow_schema (A &&a)
	Extracts the internal ArrowSchema structure from the given array or typed layout.
template<layout_or_array A>
std::pair< ArrowArray, ArrowSchema >	extract_arrow_structures (A &&a)
	Extracts the internal ArrowArrays and ArrowSchema structures from the given array or typed layout.
SPARROW_API bool	operator== (const array &lhs, const array &rhs)
	Compares the content of two arrays.
SPARROW_API cloning_ptr< array_wrapper >	array_factory (arrow_proxy proxy)
template<class B, std::ranges::input_range CHILDREN_OWNERSHIP> requires std::constructible_from<arrow_array_private_data::BufferType, B> && std::is_same_v<std::ranges::range_value_t<CHILDREN_OWNERSHIP>, bool>
ArrowArray	make_arrow_array (int64_t length, int64_t null_count, int64_t offset, B buffers, ArrowArray **children, const CHILDREN_OWNERSHIP &children_ownership, ArrowArray *dictionary, bool dictionary_ownership)
	Creates an ArrowArray.
SPARROW_API void	release_arrow_array (ArrowArray *array)
	Release function to use for the ArrowArray.release member.
SPARROW_API void	empty_release_arrow_array (ArrowArray *array)
	Empty release function to use for the ArrowArray.release member.
template<class B, std::ranges::input_range CHILDREN_OWNERSHIP> requires ( std::constructible_from<arrow_array_private_data::BufferType, B> && std::is_same_v<std::ranges::range_value_t<CHILDREN_OWNERSHIP>, bool> )
void	fill_arrow_array (ArrowArray &array, int64_t length, int64_t null_count, int64_t offset, B buffers, ArrowArray **children, const CHILDREN_OWNERSHIP &children_ownership, ArrowArray *dictionary, bool dictionary_ownership)
	Fill an ArrowArray object.
ArrowArray	make_empty_arrow_array ()
SPARROW_API sparrow::buffer_view< uint8_t >	get_bitmap_buffer (const ArrowArray &array)
SPARROW_API std::vector< sparrow::buffer_view< uint8_t > >	get_arrow_array_buffers (const ArrowArray &array, const ArrowSchema &schema)
SPARROW_API void	swap (ArrowArray &lhs, ArrowArray &rhs)
	Swaps the contents of the two ArrowArray objects.
SPARROW_API void	copy_array (const ArrowArray &source_array, const ArrowSchema &source_schema, ArrowArray &target)
	Fill the target ArrowArray with a deep copy of the data from the source ArrowArray.
ArrowArray	copy_array (const ArrowArray &source_array, const ArrowSchema &source_schema)
	Create a deep copy of the source ArrowArray.
ArrowArray	move_array (ArrowArray &&source)
	Moves the content of source into a stack-allocated array, and reset the source to an empty ArrowArray.
ArrowArray	move_array (ArrowArray &source)
	Moves the content of source into a stack-allocated array, and reset the source to an empty ArrowArray.
template<class T> requires std::same_as<T, ArrowArray> || std::same_as<T, ArrowSchema>
void	release_common_arrow (T &t)
	Release the children and dictionnary of an ArrowArray or ArrowSchema.
constexpr bool	has_bitmap (data_type dt) noexcept
template<class T>
constexpr int64_t	ssize (const T &value)
	Get the size of a range, a tuple or an optional.
template<typename T, typename U>
constexpr T *	get_raw_ptr (U &var)
	Get a raw pointer from a smart pointer, a range, an object or a pointer.
template<class T, std::ranges::input_range Range, class Allocator = std::allocator<T*>> requires (!std::ranges::view<Range>)
constexpr std::vector< T *, Allocator >	to_raw_ptr_vec (Range &range)
	Create a vector of pointers to elements from a range.
template<class T, class Optional, class Allocator = std::allocator<T*>> requires (mpl::is_type_instance_of_v<Optional, std::optional>)
constexpr std::vector< T *, Allocator >	to_raw_ptr_vec (Optional &optional)
	Create a vector of pointers to elements from a std::optional<range>.
template<class T, class Tuple, class Allocator = std::allocator<T*>> requires mpl::is_type_instance_of_v<Tuple, std::tuple>
constexpr std::vector< T *, Allocator >	to_raw_ptr_vec (Tuple &tuple)
	Create a vector of pointers to elements of a tuple.
template<class T> requires std::same_as<T, std::nullopt_t> || (mpl::is_type_instance_of_v<T, std::optional> && mpl::testable<std::ranges::range_value_t<typename T::value_type>>) || (std::ranges::range<T> && mpl::testable<std::ranges::range_value_t<T>>)
constexpr bool	all_element_are_true (const T &elements)
	Check if all elements of a range or std::optional<range> are valid by caling their bool operator.
constexpr bool	is_valid_ArrowFlag_value (int64_t value) noexcept
std::unordered_set< ArrowFlag >	to_set_of_ArrowFlags (int64_t flag_values)
	Converts a bitfield of ArrowFlag values to a set of ArrowFlag values.
int64_t	to_ArrowFlag_value (const std::unordered_set< ArrowFlag > &flags)
	Converts a vector of ArrowFlag values to a bitfield of ArrowFlag values.
template<class F, class N, input_metadata_container M = std::vector<metadata_pair>, std::ranges::input_range CHILDREN_OWNERSHIP> requires std::constructible_from<arrow_schema_private_data::FormatType, F> && std::constructible_from<arrow_schema_private_data::NameType, N> && std::is_same_v<std::ranges::range_value_t<CHILDREN_OWNERSHIP>, bool>
ArrowSchema	make_arrow_schema (F format, N name, std::optional< M > metadata, std::optional< std::unordered_set< ArrowFlag > > flags, ArrowSchema **children, const CHILDREN_OWNERSHIP &children_ownership, ArrowSchema *dictionary, bool dictionary_ownership)
	Creates an ArrowSchema owned by a unique_ptr and holding the provided data.
SPARROW_API void	release_arrow_schema (ArrowSchema *schema)
	Release function to use for the ArrowSchema.release member.
SPARROW_API void	empty_release_arrow_schema (ArrowSchema *schema)
	Empty release function to use for the ArrowSchema.release member.
template<class F, class N, input_metadata_container M = std::vector<metadata_pair>, std::ranges::input_range CHILDREN_OWNERSHIP> requires std::constructible_from<arrow_schema_private_data::FormatType, F> && std::constructible_from<arrow_schema_private_data::NameType, N> && std::is_same_v<std::ranges::range_value_t<CHILDREN_OWNERSHIP>, bool>
void	fill_arrow_schema (ArrowSchema &schema, F format, N name, std::optional< M > metadata, std::optional< std::unordered_set< ArrowFlag > > flags, ArrowSchema **children, const CHILDREN_OWNERSHIP &children_ownership, ArrowSchema *dictionary, bool dictionary_ownership)
ArrowSchema	make_empty_arrow_schema ()
SPARROW_API void	swap (ArrowSchema &lhs, ArrowSchema &rhs) noexcept
	Swaps the contents of the two ArrowSchema objects.
SPARROW_API void	copy_schema (const ArrowSchema &source, ArrowSchema &target)
	Fills the target ArrowSchema with a deep copy of the data from the source ArrowSchema.
ArrowSchema	copy_schema (const ArrowSchema &source)
	Deep copy an ArrowSchema.
ArrowSchema	move_schema (ArrowSchema &&source)
	Moves the content of source into a stack-allocated array, and reset the source to an empty ArrowSchema.
ArrowSchema	move_schema (ArrowSchema &source)
	Moves the content of source into a stack-allocated array, and reset the source to an empty ArrowSchema.
template<class T>
constexpr std::optional< std::string >	to_optional_string (T &&t)
template<class T>
constexpr bool	operator== (const any_allocator< T > &lhs, const any_allocator< T > &rhs)
template<class T>
constexpr bool	operator== (const buffer< T > &lhs, const buffer< T > &rhs) noexcept
template<typename To, class FromBufferRef>
auto	make_buffer_adaptor (FromBufferRef &buf)
template<class T>
bool	operator== (const buffer_view< T > &lhs, const buffer_view< T > &rhs)
template<class B1, class B2>
bool	operator== (const bitset_reference< B1 > &lhs, const bitset_reference< B2 > &rhs)
template<class B>
bool	operator== (const bitset_reference< B > &lhs, bool rhs)
template<validity_bitmap_input R>
validity_bitmap	ensure_validity_bitmap (std::size_t size, R &&validity_input)
template<class T, class... OPTION_FLAGS>
constexpr auto	build (T &&t, OPTION_FLAGS &&...)
	function to create a sparrow array from arbitrary nested combinations of ranges, tuples, and nullable types, variants.
template<class T, class... OPTION_FLAGS>
constexpr auto	build (std::initializer_list< T > t, OPTION_FLAGS &&... flags)
template<class D>
constexpr bool	operator== (const array_crtp_base< D > &lhs, const array_crtp_base< D > &rhs)
	Checks if the contents of lhs and rhs are equal, that is, they have the same number of elements and each element in lhs compares equal with the element in rhs at the same position.
SPARROW_API std::size_t	array_size (const array_wrapper &ar)
SPARROW_API bool	array_has_value (const array_wrapper &ar, std::size_t index)
SPARROW_API array_traits::const_reference	array_element (const array_wrapper &ar, std::size_t index)
SPARROW_API array_traits::inner_value_type	array_default_element_value (const array_wrapper &ar)
template<class T>
T &	unwrap_array (array_wrapper &)
template<class T>
const T &	unwrap_array (const array_wrapper &)
template<class IT>
constexpr bool	operator== (const dictionary_encoded_array< IT > &lhs, const dictionary_encoded_array< IT > &rhs)
template<class F>
visit_result_t< F >	visit (F &&func, const array_wrapper &ar)
SPARROW_API std::size_t	num_bytes_for_fixed_sized_binary (std::string_view format)
	Get the number of bytes for a fixed width binary layout from the ArrowArray format string.
SPARROW_API bool	operator== (const list_value &lhs, const list_value &rhs)
SPARROW_API bool	operator== (const map_value &lhs, const map_value &rhs)
SPARROW_API bool	operator== (const null_array &lhs, const null_array &rhs)
SPARROW_API bool	operator== (const run_end_encoded_array &lhs, const run_end_encoded_array &rhs)
SPARROW_API bool	operator== (const struct_value &lhs, const struct_value &rhs)
constexpr bool	operator== (const days_time_interval &lhs, const days_time_interval &rhs)
constexpr bool	operator== (const month_day_nanoseconds_interval &lhs, const month_day_nanoseconds_interval &rhs)
template<class D>
constexpr bool	operator== (const union_array_crtp_base< D > &lhs, const union_array_crtp_base< D > &rhs)
SPARROW_API bool	operator== (const record_batch &lhs, const record_batch &rhs)
	Compares the content of two record_batch objects.
constexpr bool	operator== (const null_type &, const null_type &) noexcept
constexpr bool	all_digits (const std::string_view s)
SPARROW_API std::size_t	num_bytes_for_decimal (const char *format)
constexpr data_type	format_to_data_type (std::string_view format)
template<std::floating_point T> requires (sizeof(T) >= 2 && sizeof(T) <= 8)
constexpr data_type	data_type_from_size (T={}) noexcept
template<std::integral T> requires (sizeof(T) >= 1 && sizeof(T) <= 8)
constexpr data_type	data_type_from_size (T={}) noexcept
constexpr std::string_view	data_type_to_format (data_type type)
constexpr bool	data_type_is_primitive (data_type dt) noexcept
constexpr bool	data_type_is_integer (data_type dt) noexcept
template<std::integral T>
constexpr T	byteswap (T value) noexcept
	Reverses the bytes in the given integer value.
template<std::endian input_value_endianess>
constexpr auto	to_native_endian (std::integral auto value) noexcept
template<std::ranges::range R> requires std::ranges::sized_range<std::ranges::range_value_t<R>>
size_t	number_of_bytes (const R &ranges)
template<std::ranges::range R> requires (std::ranges::sized_range<std::ranges::range_value_t<R>>)
buffer< uint8_t >	strings_to_buffer (R &&strings)
template<std::ranges::range R> requires (std::is_arithmetic_v<std::ranges::range_value_t<R>>)
buffer< uint8_t >	range_to_buffer (R &&range)
constexpr size_t	max_width (const std::ranges::input_range auto &data)
template<RangeOfRanges Columns>
constexpr std::vector< size_t >	columns_widths (const Columns &columns)
template<typename OutputIt, std::ranges::input_range Widths, std::ranges::input_range Values> requires (std::same_as<std::ranges::range_value_t<Widths>, size_t>)
constexpr void	to_row (OutputIt out, const Widths &widths, const Values &values, std::string_view separator="|")
template<typename OutputIt>
constexpr void	horizontal_separator (OutputIt out, const std::vector< size_t > &widths, std::string_view separator="-")
template<std::ranges::input_range Headers, RangeOfRanges Columns, typename OutputIt> requires (std::convertible_to<std::ranges::range_value_t<Headers>, std::string>)
constexpr void	to_table_with_columns (OutputIt out, const Headers &headers, const Columns &columns)
template<class T>
constexpr pointer_iterator< T * >	make_pointer_iterator (T *t)
template<class InputIt, std::integral Distance>
constexpr InputIt	next (InputIt it, Distance n)
template<typename T>
constexpr T	stobigint (std::string_view str)
template<class T>
void	swap (cloning_ptr< T > &lhs, cloning_ptr< T > &rhs) noexcept
template<class T1, class T2> requires std::equality_comparable_with<typename cloning_ptr<T1>::pointer, typename cloning_ptr<T2>::pointer>
constexpr bool	operator== (const cloning_ptr< T1 > &lhs, const cloning_ptr< T2 > &rhs) noexcept
template<class T1, class T2> requires std::three_way_comparable_with<typename cloning_ptr<T1>::pointer, typename cloning_ptr<T2>::pointer>
constexpr std::compare_three_way_result_t< typename cloning_ptr< T1 >::pointer, typename cloning_ptr< T2 >::pointer >	operator<=> (const cloning_ptr< T1 > &lhs, const cloning_ptr< T2 > &rhs) noexcept
template<class T>
constexpr bool	operator== (const cloning_ptr< T > &lhs, std::nullptr_t) noexcept
template<class T> requires std::three_way_comparable<typename cloning_ptr<T>::pointer>
constexpr std::compare_three_way_result_t< typename cloning_ptr< T >::pointer >	operator<=> (const cloning_ptr< T > &lhs, std::nullptr_t) noexcept
template<class T, class... Args>
cloning_ptr< T >	make_cloning_ptr (Args &&... args)
SPARROW_API int32_t	extract_int32 (const char *&ptr)
template<input_metadata_container T>
std::string	get_metadata_from_key_values (const T &metadata)
constexpr nullval_t	nullval (0)
template<class T, class B>
constexpr void	swap (nullable< T, B > &lhs, nullable< T, B > &rhs) noexcept
template<class T, class B>
constexpr bool	operator== (const nullable< T, B > &lhs, nullval_t) noexcept
template<class T, mpl::boolean_like B>
constexpr std::strong_ordering	operator<=> (const nullable< T, B > &lhs, nullval_t) noexcept
template<class T, class B, class U> requires (!is_nullable_v<U> && mpl::weakly_equality_comparable_with<T, U>)
constexpr bool	operator== (const nullable< T, B > &lhs, const U &rhs) noexcept
template<class T, class B, class U> requires (!is_nullable_v<U> && std::three_way_comparable_with<U, T>)
constexpr std::compare_three_way_result_t< T, U >	operator<=> (const nullable< T, B > &lhs, const U &rhs) noexcept
template<class T, class B, class U, class UB> requires (mpl::weakly_equality_comparable_with<T, U>)
constexpr bool	operator== (const nullable< T, B > &lhs, const nullable< U, UB > &rhs) noexcept
template<class T, class B, std::three_way_comparable_with< T > U, class UB>
constexpr std::compare_three_way_result_t< T, U >	operator<=> (const nullable< T, B > &lhs, const nullable< U, UB > &rhs) noexcept
template<class T, mpl::boolean_like B = bool>
constexpr nullable< T, B >	make_nullable (T &&value, B &&flag=true)
template<std::ranges::range R, typename T = typename std::ranges::range_value_t<R>::value_type> requires (nullable_of<std::ranges::range_value_t<R>, T>)
constexpr void	zero_null_values (R &range, const T &default_value=T{})
template<layout_offset OT, std::ranges::sized_range R> requires std::ranges::sized_range<std::ranges::range_value_t<R>>
constexpr buffer< OT >	make_offset_buffer (const R &range)
template<std::ranges::input_range R> requires (std::ranges::sized_range<R>)
constexpr std::size_t	range_size (R &&r)
template<std::ranges::input_range R> requires (!std::ranges::sized_range<R>)
constexpr std::size_t	range_size (R &&r)
template<std::ranges::range Range> requires std::ranges::sized_range<std::ranges::range_value_t<Range>>
constexpr bool	all_same_size (const Range &range)
template<class T, std::size_t E>
constexpr bool	operator== (const sequence_view< T, E > &lhs, const sequence_view< T, E > &rhs)
template<class T, std::size_t E, std::ranges::input_range R> requires mpl::weakly_equality_comparable_with<T, std::ranges::range_value_t<R>>
constexpr bool	operator== (const sequence_view< T, E > &lhs, const R &rhs)
template<class T, std::size_t E>
constexpr std::compare_three_way_result< T >	operator<=> (const sequence_view< T, E > &lhs, const sequence_view< T, E > &rhs)
template<class T, std::size_t E, std::ranges::input_range R>
constexpr std::compare_three_way_result< T, std::ranges::range_value_t< R > >	operator<=> (const sequence_view< T, E > &lhs, const R &rhs)
SPARROW_API const date::time_zone *	get_timezone (const arrow_proxy &proxy)
template<class... Ts>
	overloaded (Ts...) -> overloaded< Ts... >

Variables
template<typename T>
constexpr bool	is_move_iterator_v = is_move_iterator<T>::value
constexpr large_list_flag_t	large_list_flag
constexpr auto	doesnt_own_arrow_data
	Useful shortcut value to specify non-owning handled Arrow data.
constexpr auto	owns_arrow_data
	Useful shortcut value to specify full owning of handled Arrow data.
constexpr int	SPARROW_VERSION_MAJOR = 0
constexpr int	SPARROW_VERSION_MINOR = 9
constexpr int	SPARROW_VERSION_PATCH = 0
constexpr int	SPARROW_BINARY_CURRENT = 8
constexpr int	SPARROW_BINARY_REVISION = 0
constexpr int	SPARROW_BINARY_AGE = 0
template<class T>
constexpr bool	is_decimal_array_v = mpl::is_type_instance_of_v<T, decimal_array>
template<class T>
constexpr bool	is_dictionary_encoded_array_v = detail::is_dictionary_encoded_array<T>::get()
	Checks whether T is a dictionary_encoded_array type.
template<class T>
constexpr bool	is_list_array_v = std::same_as<T, list_array>
	Checks whether T is a list_array type.
template<class T>
constexpr bool	is_big_list_array_v = std::same_as<T, big_list_array>
	Checks whether T is a big_list_array type.
template<class T>
constexpr bool	is_list_view_array_v = std::same_as<T, list_view_array>
	Checks whether T is a list_view_array type.
template<class T>
constexpr bool	is_big_list_view_array_v = std::same_as<T, big_list_view_array>
	Checks whether T is a big_list_view_array type.
template<class T>
constexpr bool	is_fixed_sized_list_array_v = std::same_as<T, fixed_sized_list_array>
	Checks whether T is a fixed_sized_list_array type.
template<class T>
constexpr bool	is_map_array_v = std::same_as<T, map_array>
template<class T>
constexpr bool	is_null_array_v = std::same_as<T, null_array>
	Checks whether T is a null_array type.
template<class T>
constexpr bool	is_primitive_array_v = is_primitive_array<T>::value
	Checkes whether T is a primitive_array type.
template<class T>
constexpr bool	is_run_end_encoded_array_v = std::same_as<T, run_end_encoded_array>
	Checks whether T is a run_end_encoded_array type.
template<class T>
constexpr bool	is_struc_array_v = std::same_as<T, struct_array>
	Checks whether T is a struct_array type.
template<class T>
constexpr bool	is_date_array_v = is_date_array<T>::value
	Checks whether T is a date_array type.
template<class T>
constexpr bool	is_duration_array_v = is_duration_array<T>::value
	Checks whether T is a duration_array type.
template<class T>
constexpr bool	is_interval_array_v = is_interval_array<T>::value
	Checks whether T is a interval_array type.
template<class T>
constexpr bool	is_time_array_v = is_time_array<T>::value
	Checks whether T is a time_array type.
template<typename T>
constexpr bool	is_timestamp_array_v = is_timestamp_array<T>::value
template<class T>
constexpr bool	is_timestamp_without_timezone_array_v = is_timestamp_without_timezone_array<T>::value
	Checks whether T is a timestamp_without_timezone_array type.
template<class T>
constexpr bool	is_dense_union_array_v = std::same_as<T, dense_union_array>
	Checks whether T is a dense_union_array type.
template<class T>
constexpr bool	is_sparse_union_array_v = std::same_as<T, sparse_union_array>
	Checks whether T is a sparse_union_array type.
template<class T>
constexpr bool	is_string_array_v = std::same_as<T, string_array>
	Checks whether T is a string_array type.
template<class T>
constexpr bool	is_big_string_array_v = std::same_as<T, big_string_array>
	Checks whether T is a big_string_array type.
template<class T>
constexpr bool	is_binary_array_v = std::same_as<T, binary_array>
	Checks whether T is a binary_array type.
template<class T>
constexpr bool	is_big_binary_array_v = std::same_as<T, big_binary_array>
	Checks whether T is a big_binary_array type.
template<variable_size_binary_view_impl_types T>
constexpr bool	is_variable_size_binary_view_array = is_variable_size_binary_view_array_impl<T>::value
	Checks whether T is a variable_size_binary_view_array_impl type.
template<typename T>
constexpr bool	is_decimal_v = mpl::is_type_instance_of_v<T, decimal>
template<class T>
constexpr bool	is_int_placeholder_v = false
constexpr bool	large_int_placeholders = false
template<class T>
constexpr bool	is_nullable_v = is_nullable<T>::value

Typedef Documentation

all_base_types_extended_t

using sparrow::all_base_types_extended_t = mpl::append_t<all_base_types_t, char, std::string_view>

is arrow base type or arrow compound type (list<T>, struct<T> etc.)

Definition at line 677 of file data_type.hpp.

all_base_types_t

using sparrow::all_base_types_t

C++ types value representation types matching Arrow types.

Definition at line 624 of file data_type.hpp.

array_bitmap_base

template<class D>

using sparrow::array_bitmap_base = array_bitmap_base_impl<D, false>

Convenient typedef to be used as a crtp base class for arrays using an immutable validity buffer.

Template Parameters

D	The derived type,

Definition at line 102 of file array_bitmap_base.hpp.

big_binary_array

using sparrow::big_binary_array

Initial value:

variable_size_binary_array_impl<
    binary_traits::value_type,
    binary_traits::const_reference,
    std::int64_t>

A variable-size binary array implementation with 64-bit offsets.

Related Apache Arrow specification: https://arrow.apache.org/docs/dev/format/Columnar.html#variable-size-binary-layout Use this class when you want to store binary data with cumulated lengths up to 2^63-1 bytes. This is useful for large datasets where the total size of binary data may exceed 2^31-1 bytes. Use binary_array for smaller datasets.

See also

binary_array

Definition at line 128 of file variable_size_binary_array.hpp.

big_list_array

using sparrow::big_list_array = list_array_impl<true>

A big list array implementation.

Stores variable-length lists of values, where each list can have a different length. Uses 64-bit offsets for larger datasets. Apache Arrow specification: https://arrow.apache.org/docs/format/Columnar.html#list-layout

See also

list_array

Definition at line 62 of file list_array.hpp.

big_list_view_array

using sparrow::big_list_view_array = list_view_array_impl<true>

Definition at line 73 of file list_array.hpp.

big_string_array

using sparrow::big_string_array = variable_size_binary_array_impl<std::string, std::string_view, std::int64_t>

A variable-size string array implementation with 64-bit offsets.

Related Apache Arrow specification: https://arrow.apache.org/docs/dev/format/Columnar.html#variable-size-binary-layout Use this class when you want to store strings with cumulated lengths up to 2^63-1 bytes. This is useful for large datasets where the total size of strings may exceed 2^31-1 bytes. Use string_array for smaller datasets.

See also

string_array

Definition at line 106 of file variable_size_binary_array.hpp.

binary_array

using sparrow::binary_array = variable_size_binary_array_impl<binary_traits::value_type, binary_traits::const_reference, std::int32_t>

A variable-size binary array implementation.

Related Apache Arrow specification: https://arrow.apache.org/docs/dev/format/Columnar.html#variable-size-binary-layout Use this class when you want to store binary data with cumulated lengths up to 2^31-1 bytes. This is useful for datasets where the total size of binary data does not exceed 2^31-1 bytes. Use big_binary_array for larger datasets.

See also

big_binary_array

Definition at line 117 of file variable_size_binary_array.hpp.

binary_traits

using sparrow::binary_traits = arrow_traits<std::vector<byte_t>>

Definition at line 84 of file variable_size_binary_array.hpp.

binary_view_array

using sparrow::binary_view_array = variable_size_binary_view_array_impl<sequence_view<const std::byte>>

A variable-size binary view layout implementation.

Related Apache Arrow specification: https://arrow.apache.org/docs/dev/format/Columnar.html#variable-size-binary-view-layout

See also

string_view_array

variable_size_binary_view_array_impl

Definition at line 62 of file variable_size_binary_view_array.hpp.

byte_t

using sparrow::byte_t = std::byte

Definition at line 114 of file data_type.hpp.

date_array

template<date_type T>

using sparrow::date_array = primitive_array_impl<T>

Array of std::chrono::duration values.

As the other arrays in sparrow, date_array<T> provides an API as if it was holding nullable<T> values instead of T values.

Internally, the array contains a validity bitmap and a contiguous memory buffer holding the values.

Template Parameters

T	the type of the values in the array.

See also

https://arrow.apache.org/docs/dev/format/Columnar.html#fixed-size-primitive-layout

Definition at line 58 of file date_array.hpp.

date_days

using sparrow::date_days = std::chrono::time_point<std::chrono::system_clock, chrono::days>

Definition at line 23 of file date_types.hpp.

date_days_array

using sparrow::date_days_array = date_array<date_days>

A date array for date_days values.

This is useful for representing dates with day precision.

Definition at line 64 of file date_array.hpp.

date_milliseconds

using sparrow::date_milliseconds = std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>

Definition at line 24 of file date_types.hpp.

date_milliseconds_array

using sparrow::date_milliseconds_array = date_array<date_milliseconds>

A date array for date_milliseconds values.

This is useful for representing dates with millisecond precision.

Definition at line 69 of file date_array.hpp.

date_types_t

using sparrow::date_types_t = mpl::typelist<date_days, date_milliseconds>

Definition at line 25 of file date_array.hpp.

days_time_interval_array

using sparrow::days_time_interval_array = interval_array<days_time_interval>

An interval array for days_time_interval values.

This is useful for representing intervals in days and time.

Definition at line 77 of file interval_array.hpp.

decimal_128_array

using sparrow::decimal_128_array = decimal_array<decimal<int128_t>>

Definition at line 41 of file decimal_array.hpp.

decimal_256_array

using sparrow::decimal_256_array = decimal_array<decimal<int256_t>>

Definition at line 42 of file decimal_array.hpp.

decimal_32_array

using sparrow::decimal_32_array = decimal_array<decimal<int32_t>>

Definition at line 39 of file decimal_array.hpp.

decimal_64_array

using sparrow::decimal_64_array = decimal_array<decimal<int64_t>>

Definition at line 40 of file decimal_array.hpp.

default_layout_t

template<has_arrow_type_traits T>

using sparrow::default_layout_t = typename arrow_traits<T>::default_layout

Binary layout type to use by default for the given C++ representation T of an arrow value.

Definition at line 755 of file data_type.hpp.

duration_array

template<duration_type T>

using sparrow::duration_array = primitive_array_impl<T>

Array of std::chrono::duration values.

As the other arrays in sparrow, duration_array<T> provides an API as if it was holding nullable<T> values instead of T values.

Internally, the array contains a validity bitmap and a contiguous memory buffer holding the values.

Template Parameters

T	the type of the values in the array.

See also

https://arrow.apache.org/docs/dev/format/Columnar.html#fixed-size-primitive-layout

Definition at line 72 of file duration_array.hpp.

duration_microseconds_array

using sparrow::duration_microseconds_array = duration_array<std::chrono::microseconds>

A duration array for std::chrono::microseconds values.

This is useful for representing durations in microseconds.

Definition at line 88 of file duration_array.hpp.

duration_milliseconds_array

using sparrow::duration_milliseconds_array = duration_array<std::chrono::milliseconds>

A duration array for std::chrono::milliseconds values.

This is useful for representing durations in milliseconds.

Definition at line 83 of file duration_array.hpp.

duration_nanoseconds_array

using sparrow::duration_nanoseconds_array = duration_array<std::chrono::nanoseconds>

A duration array for std::chrono::nanoseconds values.

This is useful for representing durations in nanoseconds.

Definition at line 93 of file duration_array.hpp.

duration_seconds_array

using sparrow::duration_seconds_array = duration_array<std::chrono::seconds>

A duration array for std::chrono::seconds values.

This is useful for representing durations in seconds.

Definition at line 78 of file duration_array.hpp.

duration_types_t

using sparrow::duration_types_t

Initial value:

mpl::
    typelist<std::chrono::seconds, std::chrono::milliseconds, std::chrono::microseconds, std::chrono::nanoseconds>

Definition at line 26 of file duration_array.hpp.

fixed_width_binary_array

using sparrow::fixed_width_binary_array

Initial value:

fixed_width_binary_array_impl<
    fixed_width_binary_traits::value_type,
    fixed_width_binary_traits::const_reference>

A fixed-width binary array implementation.

Related Apache Arrow specification: https://arrow.apache.org/docs/dev/format/Columnar.html#fixed-width-binary-layout

Definition at line 53 of file fixed_width_binary_array.hpp.

fixed_width_binary_traits

using sparrow::fixed_width_binary_traits = arrow_traits<std::vector<byte_t>>

Definition at line 46 of file fixed_width_binary_array.hpp.

float16_t

using sparrow::float16_t = half_float::half

Definition at line 92 of file data_type.hpp.

float32_t

using sparrow::float32_t = float

Definition at line 93 of file data_type.hpp.

float64_t

using sparrow::float64_t = double

Definition at line 94 of file data_type.hpp.

get_corresponding_arrow_type_t

template<class T>

using sparrow::get_corresponding_arrow_type_t = std::conditional_t<std::same_as<T, std::string_view>, std::string, T>

Template alias to get the corresponding Arrow type for a given type.

This template alias is used to determine the corresponding Arrow type for a given type. For example, the given type is std::string_view, the corresponding Arrow type is std::string. Otherwise, the corresponding Arrow type is the same as the given type.

Template Parameters

T	The type for which to determine the corresponding Arrow type.

Returns

The corresponding Arrow type for the given type.

Definition at line 699 of file data_type.hpp.

int128_t

using sparrow::int128_t = primesum::int128_t

Definition at line 84 of file large_int.hpp.

int256_t

using sparrow::int256_t = primesum::int256_t

Definition at line 85 of file large_int.hpp.

interval_array

template<interval_type T>

using sparrow::interval_array = primitive_array_impl<T>

Array of interval values.

As the other arrays in sparrow, interval_array<T> provides an API as if it was holding nullable<T> values instead of T values.

Internally, the array contains a validity bitmap and a contiguous memory buffer holding the values.

Template Parameters

T	the type of the values in the array.

See also

https://arrow.apache.org/docs/dev/format/Columnar.html#fixed-size-primitive-layout

Definition at line 66 of file interval_array.hpp.

interval_types_t

using sparrow::interval_types_t = mpl::typelist<chrono::months, days_time_interval, month_day_nanoseconds_interval>

Definition at line 27 of file interval_array.hpp.

list_array

using sparrow::list_array = list_array_impl<false>

A list array implementation.

Stores variable-length lists of values, where each list can have a different length. Uses 32-bit offsets for smaller datasets. Apache Arrow specification: https://arrow.apache.org/docs/format/Columnar.html#list-layout

See also

big_list_array

Definition at line 54 of file list_array.hpp.

list_view_array

using sparrow::list_view_array = list_view_array_impl<false>

A list view array implementation.

Stores variable-length lists where each element can contain a different number of sub-elements. Use the List layout when your data consists of variable-length lists and you want a straightforward, efficient representation where the order of elements in the child array matches the logical order in the parent array. This is the standard layout for most use cases involving variable-length lists, such as arrays of strings or arrays of arrays of numbers.

Definition at line 72 of file list_array.hpp.

metadata_key

using sparrow::metadata_key = std::string_view

Definition at line 37 of file metadata.hpp.

metadata_pair

using sparrow::metadata_pair = std::pair<metadata_key, metadata_value>

Definition at line 39 of file metadata.hpp.

metadata_value

using sparrow::metadata_value = std::string_view

Definition at line 38 of file metadata.hpp.

month_day_nanoseconds_interval_array

using sparrow::month_day_nanoseconds_interval_array = interval_array<month_day_nanoseconds_interval>

An interval array for month_day_nanoseconds_interval values.

This is useful for representing intervals in months, days, and nanoseconds.

Definition at line 82 of file interval_array.hpp.

months_interval_array

using sparrow::months_interval_array = interval_array<chrono::months>

An interval array for std::chrono::months values.

This is useful for representing intervals in months.

Definition at line 72 of file interval_array.hpp.

mutable_array_bitmap_base

template<class D>

using sparrow::mutable_array_bitmap_base = array_bitmap_base_impl<D, true>

Convenient typedef to be used as a crtp base class for arrays using a mutable validity buffer.

Template Parameters

D	The derived type,

Definition at line 111 of file array_bitmap_base.hpp.

primitive_array

template<primitive_type T>

using sparrow::primitive_array = primitive_array_impl<T>

Array of values of whose type has fixed binary size.

The type of the values in the array can be a primitive type, whose size is known at compile time, or an arbitrary binary type whose fixed size is known at runtime only. The current implementation supports types whose size is known at compile time only.

As the other arrays in sparrow, primitive_array<T> provides an API as if it was holding nullable<T> values instead of T values.

Internally, the array contains a validity bitmap and a contiguous memory buffer holding the values.

Template Parameters

T	the type of the values in the array.

See also

https://arrow.apache.org/docs/dev/format/Columnar.html#fixed-size-primitive-layout

Definition at line 63 of file primitive_array.hpp.

string_array

using sparrow::string_array = variable_size_binary_array_impl<std::string, std::string_view, std::int32_t>

A variable-size string array implementation.

Related Apache Arrow specification: https://arrow.apache.org/docs/dev/format/Columnar.html#variable-size-binary-layout Use this class when you want to store strings with cumulated lengths up to 2^31-1 bytes. This is useful for datasets where the total size of strings does not exceed 2^31-1 bytes. Use big_string_array for larger datasets.

See also

big_string_array

Definition at line 95 of file variable_size_binary_array.hpp.

string_view_array

using sparrow::string_view_array = variable_size_binary_view_array_impl<std::string_view>

A variable-size string view layout implementation.

Related Apache Arrow specification: https://arrow.apache.org/docs/dev/format/Columnar.html#variable-size-binary-view-layout

See also

binary_view_array

variable_size_binary_view_array_impl

Definition at line 53 of file variable_size_binary_view_array.hpp.

time_array

template<time_type T>

using sparrow::time_array = primitive_array_impl<T>

Array of time values.

As the other arrays in sparrow, time_array<T> provides an API as if it was holding nullable<T> values instead of T values.

Internally, the array contains a validity bitmap and a contiguous memory buffer holding the values.

Template Parameters

T	the type of the values in the array.

See also

https://arrow.apache.org/docs/dev/format/Columnar.html#fixed-size-primitive-layout

Definition at line 70 of file time_array.hpp.

time_microseconds_array

using sparrow::time_microseconds_array = time_array<chrono::time_microseconds>

A time array for std::chrono::time_microseconds values.

This is useful for representing times with microsecond precision.

Definition at line 86 of file time_array.hpp.

time_milliseconds_array

using sparrow::time_milliseconds_array = time_array<chrono::time_milliseconds>

A time array for std::chrono::time_milliseconds values.

This is useful for representing times with millisecond precision.

Definition at line 81 of file time_array.hpp.

time_nanoseconds_array

using sparrow::time_nanoseconds_array = time_array<chrono::time_nanoseconds>

A time array for std::chrono::time_nanoseconds values.

This is useful for representing times with nanosecond precision.

Definition at line 91 of file time_array.hpp.

time_seconds_array

using sparrow::time_seconds_array = time_array<chrono::time_seconds>

A time array for std::chrono::time_seconds values.

This is useful for representing times with second precision.

Definition at line 76 of file time_array.hpp.

time_types_t

using sparrow::time_types_t

Initial value:

mpl::
    typelist<chrono::time_seconds, chrono::time_milliseconds, chrono::time_microseconds, chrono::time_nanoseconds>

Definition at line 24 of file time_array.hpp.

timestamp

template<typename Duration, typename TimeZonePtr = const date::time_zone*>

using sparrow::timestamp = date::zoned_time<Duration, TimeZonePtr>

Definition at line 103 of file data_type.hpp.

timestamp_microsecond

using sparrow::timestamp_microsecond = timestamp<std::chrono::microseconds>

Definition at line 76 of file timestamp_array.hpp.

timestamp_microseconds_array

using sparrow::timestamp_microseconds_array = timestamp_array<timestamp_microsecond>

Definition at line 81 of file timestamp_array.hpp.

timestamp_millisecond

using sparrow::timestamp_millisecond = timestamp<std::chrono::milliseconds>

Definition at line 75 of file timestamp_array.hpp.

timestamp_milliseconds_array

using sparrow::timestamp_milliseconds_array = timestamp_array<timestamp_millisecond>

Definition at line 80 of file timestamp_array.hpp.

timestamp_nanosecond

using sparrow::timestamp_nanosecond = timestamp<std::chrono::nanoseconds>

Definition at line 77 of file timestamp_array.hpp.

timestamp_nanoseconds_array

using sparrow::timestamp_nanoseconds_array = timestamp_array<timestamp_nanosecond>

Definition at line 82 of file timestamp_array.hpp.

timestamp_second

using sparrow::timestamp_second = timestamp<std::chrono::seconds>

Definition at line 74 of file timestamp_array.hpp.

timestamp_seconds_array

using sparrow::timestamp_seconds_array = timestamp_array<timestamp_second>

Definition at line 79 of file timestamp_array.hpp.

timestamp_types_t

using sparrow::timestamp_types_t

Initial value:

mpl::typelist<
    timestamp<std::chrono::seconds>,
    timestamp<std::chrono::milliseconds>,
    timestamp<std::chrono::microseconds>,
    timestamp<std::chrono::nanoseconds>>

Definition at line 22 of file timestamp_concepts.hpp.

timestamp_without_timezone_array

template<zoned_time_without_timezone_type T>

using sparrow::timestamp_without_timezone_array = primitive_array_impl<T>

Array of timestamps without timezone.

Definition at line 63 of file timestamp_without_timezone_array.hpp.

timestamp_without_timezone_microseconds_array

using sparrow::timestamp_without_timezone_microseconds_array

Initial value:

timestamp_without_timezone_array<
    zoned_time_without_timezone_microseconds>

A timestamp without timezone array for zoned_time_without_timezone_microseconds values.

This is useful for representing timestamps with microsecond precision.

Definition at line 82 of file timestamp_without_timezone_array.hpp.

timestamp_without_timezone_milliseconds_array

using sparrow::timestamp_without_timezone_milliseconds_array

Initial value:

timestamp_without_timezone_array<
    zoned_time_without_timezone_milliseconds>

A timestamp without timezone array for zoned_time_without_timezone_milliseconds values.

This is useful for representing timestamps with millisecond precision.

Definition at line 75 of file timestamp_without_timezone_array.hpp.

timestamp_without_timezone_nanoseconds_array

using sparrow::timestamp_without_timezone_nanoseconds_array

Initial value:

timestamp_without_timezone_array<
    zoned_time_without_timezone_nanoseconds>

A timestamp without timezone array for zoned_time_without_timezone_nanoseconds values.

This is useful for representing timestamps with nanosecond precision.

Definition at line 88 of file timestamp_without_timezone_array.hpp.

timestamp_without_timezone_seconds_array

using sparrow::timestamp_without_timezone_seconds_array = timestamp_without_timezone_array<zoned_time_without_timezone_seconds>

A timestamp without timezone array for zoned_time_without_timezone_seconds values.

This is useful for representing timestamps with second precision.

Definition at line 69 of file timestamp_without_timezone_array.hpp.

validity_bitmap

using sparrow::validity_bitmap = dynamic_bitset<std::uint8_t>

Definition at line 121 of file dynamic_bitset.hpp.

visit_result_t

template<class F>

using sparrow::visit_result_t = std::invoke_result_t<F, null_array>

Definition at line 45 of file dispatch.hpp.

zoned_time_without_timezone_types_t

using sparrow::zoned_time_without_timezone_types_t

Initial value:

mpl::typelist<
    zoned_time_without_timezone_seconds,
    zoned_time_without_timezone_milliseconds,
    zoned_time_without_timezone_microseconds,
    zoned_time_without_timezone_nanoseconds>

Definition at line 23 of file timestamp_without_timezone_array.hpp.

Enumeration Type Documentation

ArrowFlag

enum class sparrow::ArrowFlag : int64_t

strong

Enumerator
DICTIONARY_ORDERED
NULLABLE
MAP_KEYS_SORTED

Definition at line 66 of file c_interface.hpp.

data_type

enum class sparrow::data_type : uint8_t

strong

Runtime identifier of arrow data types, usually associated with raw bytes with the associated value.

Enumerator
NA
BOOL
UINT8
INT8
UINT16
INT16
UINT32
INT32
UINT64
INT64
HALF_FLOAT
FLOAT
DOUBLE
STRING
LARGE_STRING
BINARY
LARGE_BINARY
LIST
LARGE_LIST
LIST_VIEW
LARGE_LIST_VIEW
FIXED_SIZED_LIST
STRUCT
MAP
STRING_VIEW
BINARY_VIEW
DENSE_UNION
SPARSE_UNION
RUN_ENCODED
DECIMAL32
DECIMAL64
DECIMAL128
DECIMAL256
FIXED_WIDTH_BINARY
DATE_DAYS
DATE_MILLISECONDS
TIMESTAMP_SECONDS
TIMESTAMP_MILLISECONDS
TIMESTAMP_MICROSECONDS
TIMESTAMP_NANOSECONDS
TIME_SECONDS
TIME_MILLISECONDS
TIME_MICROSECONDS
TIME_NANOSECONDS
DURATION_SECONDS
DURATION_MILLISECONDS
DURATION_MICROSECONDS
DURATION_NANOSECONDS
INTERVAL_MONTHS
INTERVAL_DAYS_TIME
INTERVAL_MONTHS_DAYS_NANOSECONDS

Definition at line 129 of file data_type.hpp.

ownership

enum class sparrow::ownership : bool

strong

Specifies the ownership model when passing Arrow data to another system.

Enumerator
not_owning	The system handling the related Arrow data do not own that data, that system must not and will not release it.
owning	The system handling the related Arrow data owns that data and is responsible for releasing it through the release function associated to the Arrow data.

Definition at line 76 of file c_interface.hpp.

Function Documentation

all_digits()

bool sparrow::all_digits ( const std::string_view s )

nodiscardconstexpr

Definition at line 187 of file data_type.hpp.

all_element_are_true()

template<class T>
requires std::same_as<T, std::nullopt_t> || (mpl::is_type_instance_of_v<T, std::optional> && mpl::testable<std::ranges::range_value_t<typename T::value_type>>) || (std::ranges::range<T> && mpl::testable<std::ranges::range_value_t<T>>)

bool sparrow::all_element_are_true ( const T & elements )

nodiscardconstexpr

Check if all elements of a range or std::optional<range> are valid by caling their bool operator.

If the type is nullptr, it returns true. If the std::optional does not have a value, it returns true.

Definition at line 230 of file arrow_array_schema_utils.hpp.

all_same_size()

template<std::ranges::range Range>
requires std::ranges::sized_range<std::ranges::range_value_t<Range>>

bool sparrow::all_same_size ( const Range & range )

nodiscardconstexpr

Definition at line 46 of file ranges.hpp.

Here is the caller graph for this function:

array_default_element_value()

SPARROW_API array_traits::inner_value_type sparrow::array_default_element_value ( const array_wrapper & ar )

nodiscard

array_element()

SPARROW_API array_traits::const_reference sparrow::array_element ( const array_wrapper & ar, std::size_t index )

nodiscard

Here is the caller graph for this function:

array_factory()

SPARROW_API cloning_ptr< array_wrapper > sparrow::array_factory ( arrow_proxy proxy )

nodiscard

Here is the caller graph for this function:

array_has_value()

SPARROW_API bool sparrow::array_has_value ( const array_wrapper & ar, std::size_t index )

nodiscard

array_size()

SPARROW_API std::size_t sparrow::array_size ( const array_wrapper & ar )

nodiscard

build() [1/2]

template<class T, class... OPTION_FLAGS>

auto sparrow::build ( std::initializer_list< T > t, OPTION_FLAGS &&... flags )

nodiscardconstexpr

Definition at line 106 of file builder.hpp.

Here is the call graph for this function:

build() [2/2]

template<class T, class... OPTION_FLAGS>

auto sparrow::build ( T && t, OPTION_FLAGS && ... )

nodiscardconstexpr

function to create a sparrow array from arbitrary nested combinations of ranges, tuples, and nullable types, variants.

Have a look at the buider documentation for more information.

Definition at line 80 of file builder.hpp.

Here is the caller graph for this function:

byteswap()

template<std::integral T>

T sparrow::byteswap ( T value )

nodiscardconstexprnoexcept

Reverses the bytes in the given integer value.

Template Parameters

T	The type of the integer value.

Parameters

value

The integer value to reverse.

Returns

The integer value with the bytes reversed.

Note

Implementation comes from https://en.cppreference.com/w/cpp/numeric/byteswap

Definition at line 32 of file bit.hpp.

Here is the caller graph for this function:

columns_widths()

template<RangeOfRanges Columns>

std::vector< size_t > sparrow::columns_widths ( const Columns & columns )

constexpr

Definition at line 83 of file format.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

copy_array() [1/2]

ArrowArray sparrow::copy_array ( const ArrowArray & source_array, const ArrowSchema & source_schema )

inlinenodiscard

Create a deep copy of the source ArrowArray.

The buffers, children and dictionary are deep copied.

Definition at line 192 of file arrow_array.hpp.

Here is the call graph for this function:

copy_array() [2/2]

SPARROW_API void sparrow::copy_array	(	const ArrowArray &	source_array,
		const ArrowSchema &	source_schema,
		ArrowArray &	target )

Fill the target ArrowArray with a deep copy of the data from the source ArrowArray.

Parameters

source_array	The source ArrowArray to copy from.
source_schema	The schema of the source ArrowArray.
target	The target ArrowArray to copy to.

Here is the caller graph for this function:

copy_schema() [1/2]

ArrowSchema sparrow::copy_schema ( const ArrowSchema & source )

inlinenodiscard

Deep copy an ArrowSchema.

Parameters

source

The source ArrowSchema.

Returns

The deep copy of the ArrowSchema.

Definition at line 219 of file arrow_schema.hpp.

Here is the call graph for this function:

copy_schema() [2/2]

SPARROW_API void sparrow::copy_schema	(	const ArrowSchema &	source,
		ArrowSchema &	target )

Fills the target ArrowSchema with a deep copy of the data from the source ArrowSchema.

Here is the caller graph for this function:

data_type_from_size() [1/2]

template<std::floating_point T>
requires (sizeof(T) >= 2 && sizeof(T) <= 8)

data_type sparrow::data_type_from_size ( T = {} )

nodiscardconstexprnoexcept

Returns

The default floating-point data_type that should be associated with the provided type. The deduction will be based on the size of the type. Calling this function with unsupported sizes will not compile.

Definition at line 402 of file data_type.hpp.

data_type_from_size() [2/2]

template<std::integral T>
requires (sizeof(T) >= 1 && sizeof(T) <= 8)

data_type sparrow::data_type_from_size ( T = {} )

nodiscardconstexprnoexcept

Returns

The default integral data_type that should be associated with the provided type. The deduction will be based on the size of the type. Calling this function with unsupported sizes will not compile.

Definition at line 423 of file data_type.hpp.

data_type_is_integer()

bool sparrow::data_type_is_integer ( data_type dt )

nodiscardconstexprnoexcept

Returns

True if the provided data_type is an integer type, false otherwise.

Definition at line 600 of file data_type.hpp.

Here is the caller graph for this function:

data_type_is_primitive()

bool sparrow::data_type_is_primitive ( data_type dt )

nodiscardconstexprnoexcept

Returns

True if the provided data_type is a primitive type, false otherwise.

Definition at line 577 of file data_type.hpp.

data_type_to_format()

std::string_view sparrow::data_type_to_format ( data_type type )

nodiscardconstexpr

Returns

Format string matching the provided data_type. The returned string is guaranteed to be null-terminated and to have static storage lifetime. (this means you can do data_type_to_format(mytype).data() to get a C pointer.

Definition at line 490 of file data_type.hpp.

Here is the caller graph for this function:

empty_release_arrow_array()

SPARROW_API void sparrow::empty_release_arrow_array

(

ArrowArray *

array

)

Empty release function to use for the ArrowArray.release member.

Should be used for view of ArrowArray.

empty_release_arrow_schema()

SPARROW_API void sparrow::empty_release_arrow_schema

(

ArrowSchema *

schema

)

Empty release function to use for the ArrowSchema.release member.

Should be used for view of ArrowSchema.

ensure_validity_bitmap()

template<validity_bitmap_input R>

validity_bitmap sparrow::ensure_validity_bitmap	(	std::size_t	size,
		R &&	validity_input )

Definition at line 193 of file dynamic_bitset.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

extract_arrow_array()

template<layout_or_array A>

ArrowArray sparrow::extract_arrow_array

(

A &&

a

)

Extracts the internal ArrowArray structure from the given Array or typed layout.

After this call, the user is responsible for the management of the returned ArrowArray.

Exceptions

std::runtime_error

If a does not own its internal ArrowSchema before this call.

Parameters

a	An array or a typed layout.

Returns

The internal ArrowArray.

Definition at line 79 of file array.hpp.

Here is the call graph for this function:

extract_arrow_schema()

template<layout_or_array A>

ArrowSchema sparrow::extract_arrow_schema

(

A &&

a

)

Extracts the internal ArrowSchema structure from the given array or typed layout.

After this call, the user is responsible for the management of the returned ArrowSchema.

Exceptions

std::runtime_error

If a does not own its internal ArrowSchema before this call.

Parameters

a	An array or a typed layout.

Returns

The internal ArrowSchema.

Definition at line 85 of file array.hpp.

Here is the call graph for this function:

extract_arrow_structures()

template<layout_or_array A>

std::pair< ArrowArray, ArrowSchema > sparrow::extract_arrow_structures

(

A &&

a

)

Extracts the internal ArrowArrays and ArrowSchema structures from the given array or typed layout.

After this call, the user is responsible for the management of the returned ArrowArray and ArrowSchema.

Exceptions

std::runtime_error

If a does not own its internal ArrowArray and ArrowSchema before this call.

Parameters

a	An array or a typed layout.

Returns

The internal ArrowArray and ArrowSchema.

Definition at line 91 of file array.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

extract_int32()

SPARROW_API int32_t sparrow::extract_int32

(

const char *&

ptr

)

fill_arrow_array()

template<class B, std::ranges::input_range CHILDREN_OWNERSHIP>
requires ( std::constructible_from<arrow_array_private_data::BufferType, B> && std::is_same_v<std::ranges::range_value_t<CHILDREN_OWNERSHIP>, bool> )

void sparrow::fill_arrow_array	(	ArrowArray &	array,
		int64_t	length,
		int64_t	null_count,
		int64_t	offset,
		B	buffers,
		ArrowArray **	children,
		const CHILDREN_OWNERSHIP &	children_ownership,
		ArrowArray *	dictionary,
		bool	dictionary_ownership )

Fill an ArrowArray object.

Template Parameters

B	Value, reference or rvalue of std::vector<sparrow::buffer<uint8_t>>

Parameters

array	The ArrowArray to fill.
length	The logical length of the array (i.e. its number of items). Must be 0 or positive.
null_count	The number of null items in the array. May be -1 if not yet computed. Must be 0 or positive otherwise.
offset	The logical offset inside the array (i.e. the number of items from the physical start of the buffers). Must be 0 or positive.
buffers	Vector of sparrow::buffer<uint8_t>.
children	Pointer to a sequence of ArrowArray pointers or nullptr. Must be nullptr if n_children is 0.
dictionary	ArrowArray pointer or nullptr.

Definition at line 93 of file arrow_array.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

fill_arrow_schema()

template<class F, class N, input_metadata_container M = std::vector<metadata_pair>, std::ranges::input_range CHILDREN_OWNERSHIP>
requires std::constructible_from<arrow_schema_private_data::FormatType, F> && std::constructible_from<arrow_schema_private_data::NameType, N> && std::is_same_v<std::ranges::range_value_t<CHILDREN_OWNERSHIP>, bool>

void sparrow::fill_arrow_schema	(	ArrowSchema &	schema,
		F	format,
		N	name,
		std::optional< M >	metadata,
		std::optional< std::unordered_set< ArrowFlag > >	flags,
		ArrowSchema **	children,
		const CHILDREN_OWNERSHIP &	children_ownership,
		ArrowSchema *	dictionary,
		bool	dictionary_ownership )

Definition at line 90 of file arrow_schema.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

format_to_data_type()

data_type sparrow::format_to_data_type ( std::string_view format )

nodiscardconstexpr

Returns

The data_type value matching the provided format string or data_type::NA if we couldnt find a matching data_type.

Definition at line 206 of file data_type.hpp.

Here is the call graph for this function:

get_arrow_array()

template<layout_or_array A>

ArrowArray * sparrow::get_arrow_array

(

A &

a

)

Returns a pointer to the internal ArrowArray of the given array or layout.

Parameters

a	An Array or a typed layout.

Returns

a pointer to the internal ArrowArray.

Definition at line 60 of file array.hpp.

Here is the call graph for this function:

get_arrow_array_buffers()

SPARROW_API std::vector< sparrow::buffer_view< uint8_t > > sparrow::get_arrow_array_buffers ( const ArrowArray & array, const ArrowSchema & schema )

nodiscard

get_arrow_schema()

template<layout_or_array A>

ArrowSchema * sparrow::get_arrow_schema

(

A &

a

)

Returns a pointer to the internal ArrowSchema of the given array or layout.

Parameters

a	An Array or a typed layout.

Returns

a pointer to the internal ArrowSchema.

Definition at line 66 of file array.hpp.

Here is the call graph for this function:

get_arrow_structures()

template<layout_or_array A>

std::pair< ArrowArray *, ArrowSchema * > sparrow::get_arrow_structures

(

A &

a

)

Returns pointers to the internal ArrowArray and ArrowSchema of the given Array or layout.

Parameters

a	An Array or a typed layout.

Returns

pointers to the internal ArrowArray and ArrowSchema.

Definition at line 72 of file array.hpp.

Here is the call graph for this function:

get_bitmap_buffer()

SPARROW_API sparrow::buffer_view< uint8_t > sparrow::get_bitmap_buffer ( const ArrowArray & array )

nodiscard

get_metadata_from_key_values()

template<input_metadata_container T>

std::string sparrow::get_metadata_from_key_values

(

const T &

metadata

)

Definition at line 109 of file metadata.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

get_raw_ptr()

template<typename T, typename U>

T * sparrow::get_raw_ptr ( U & var )

nodiscardconstexpr

Get a raw pointer from a smart pointer, a range, an object or a pointer.

Template Parameters

T	The type of the pointer to obtain.
U	The type of the variable.

Parameters

var	The variable.

Returns

A raw pointer. If the variable is a smart pointer, the pointer is obtained by calling get(). If the variable is a range, the pointer is obtained by calling data(). If the variable is a pointer, the pointer is returned as is. If the variable is an object, the pointer is returned by calling the address-of operator.

Definition at line 145 of file arrow_array_schema_utils.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

get_timezone()

SPARROW_API const date::time_zone * sparrow::get_timezone ( const arrow_proxy & proxy )

nodiscard

Here is the caller graph for this function:

has_bitmap()

bool sparrow::has_bitmap ( data_type dt )

nodiscardconstexprnoexcept

Definition at line 22 of file arrow_array_schema_info_utils.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

horizontal_separator()

template<typename OutputIt>

void sparrow::horizontal_separator ( OutputIt out, const std::vector< size_t > & widths, std::string_view separator = "-" )

constexpr

Definition at line 119 of file format.hpp.

Here is the caller graph for this function:

is_valid_ArrowFlag_value()

bool sparrow::is_valid_ArrowFlag_value ( int64_t value )

nodiscardconstexprnoexcept

Returns

true if the given value is a valid ArrowFlag value, false otherwise.

Definition at line 24 of file arrow_flag_utils.hpp.

Here is the caller graph for this function:

make_arrow_array()

template<class B, std::ranges::input_range CHILDREN_OWNERSHIP>
requires std::constructible_from<arrow_array_private_data::BufferType, B> && std::is_same_v<std::ranges::range_value_t<CHILDREN_OWNERSHIP>, bool>

ArrowArray sparrow::make_arrow_array ( int64_t length, int64_t null_count, int64_t offset, B buffers, ArrowArray ** children, const CHILDREN_OWNERSHIP & children_ownership, ArrowArray * dictionary, bool dictionary_ownership )

nodiscard

Creates an ArrowArray.

Template Parameters

B	Value, reference or rvalue of std::vector<sparrow::buffer<uint8_t>>

Parameters

length	The logical length of the array (i.e. its number of items). Must be 0 or positive.
null_count	The number of null items in the array. May be -1 if not yet computed. Must be 0 or positive otherwise.
offset	The logical offset inside the array (i.e. the number of items from the physical start of the buffers). Must be 0 or positive.
buffers	Vector of sparrow::buffer<uint8_t>.
children	Pointer to a sequence of ArrowArray pointers or nullptr. Must be nullptr if n_children is 0.
dictionary	ArrowArray pointer or nullptr.

Returns

The created ArrowArray.

Definition at line 130 of file arrow_array.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

make_arrow_schema()

template<class F, class N, input_metadata_container M = std::vector<metadata_pair>, std::ranges::input_range CHILDREN_OWNERSHIP>
requires std::constructible_from<arrow_schema_private_data::FormatType, F> && std::constructible_from<arrow_schema_private_data::NameType, N> && std::is_same_v<std::ranges::range_value_t<CHILDREN_OWNERSHIP>, bool>

ArrowSchema sparrow::make_arrow_schema ( F format, N name, std::optional< M > metadata, std::optional< std::unordered_set< ArrowFlag > > flags, ArrowSchema ** children, const CHILDREN_OWNERSHIP & children_ownership, ArrowSchema * dictionary, bool dictionary_ownership )

nodiscard

Creates an ArrowSchema owned by a unique_ptr and holding the provided data.

Template Parameters

F	Value, reference or rvalue of arrow_schema_private_data::FormatType
N	Value, reference or rvalue of arrow_schema_private_data::NameType
M	Value, reference or rvalue of arrow_schema_private_data::MetadataType

Parameters

format	A mandatory, null-terminated, UTF8-encoded string describing the data type. If the data type is nested, child types are not encoded here but in the ArrowSchema.children structures.
name	An optional, null-terminated, UTF8-encoded string of the field or array name. This is mainly used to reconstruct child fields of nested types.
metadata	An optional, range of key-value pairs to attach to the schema.
flags	An optional set of flags to attach to the schema.
children	Pointer to a sequence of ArrowSchema pointers or nullptr. Must be nullptr if n_children is 0.
dictionary	Pointer to an ArrowSchema. Must be present if the ArrowSchema represents a dictionary-encoded type. Must be nullptr otherwise.

Returns

The created ArrowSchema unique pointer.

Definition at line 150 of file arrow_schema.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

make_buffer_adaptor()

template<typename To, class FromBufferRef>

auto sparrow::make_buffer_adaptor

(

FromBufferRef &

buf

)

Definition at line 621 of file buffer_adaptor.hpp.

Here is the caller graph for this function:

make_cloning_ptr()

template<class T, class... Args>

cloning_ptr< T > sparrow::make_cloning_ptr

(

Args &&...

args

)

Definition at line 495 of file memory.hpp.

Here is the caller graph for this function:

make_empty_arrow_array()

ArrowArray sparrow::make_empty_arrow_array ( )

inlinenodiscard

Definition at line 162 of file arrow_array.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

make_empty_arrow_schema()

ArrowSchema sparrow::make_empty_arrow_schema ( )

inline

Definition at line 187 of file arrow_schema.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

make_nullable()

template<class T, mpl::boolean_like B = bool>

nullable< T, B > sparrow::make_nullable ( T && value, B && flag = true )

constexpr

Definition at line 768 of file nullable.hpp.

Here is the caller graph for this function:

make_offset_buffer()

template<layout_offset OT, std::ranges::sized_range R>
requires std::ranges::sized_range<std::ranges::range_value_t<R>>

buffer< OT > sparrow::make_offset_buffer ( const R & range )

nodiscardconstexpr

Definition at line 27 of file offsets.hpp.

Here is the call graph for this function:

make_pointer_iterator()

template<class T>

pointer_iterator< T * > sparrow::make_pointer_iterator ( T * t )

nodiscardconstexpr

Definition at line 497 of file iterator.hpp.

Here is the caller graph for this function:

max_width()

size_t sparrow::max_width ( const std::ranges::input_range auto & data )

constexpr

Definition at line 72 of file format.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

move_array() [1/2]

ArrowArray sparrow::move_array ( ArrowArray && source )

inlinenodiscard

Moves the content of source into a stack-allocated array, and reset the source to an empty ArrowArray.

Definition at line 203 of file arrow_array.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

move_array() [2/2]

ArrowArray sparrow::move_array ( ArrowArray & source )

inlinenodiscard

Moves the content of source into a stack-allocated array, and reset the source to an empty ArrowArray.

Definition at line 215 of file arrow_array.hpp.

Here is the call graph for this function:

move_schema() [1/2]

ArrowSchema sparrow::move_schema ( ArrowSchema && source )

inline

Moves the content of source into a stack-allocated array, and reset the source to an empty ArrowSchema.

Definition at line 230 of file arrow_schema.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

move_schema() [2/2]

ArrowSchema sparrow::move_schema ( ArrowSchema & source )

inline

Moves the content of source into a stack-allocated array, and reset the source to an empty ArrowSchema.

Definition at line 242 of file arrow_schema.hpp.

Here is the call graph for this function:

next()

template<class InputIt, std::integral Distance>

InputIt sparrow::next ( InputIt it, Distance n )

nodiscardconstexpr

Definition at line 503 of file iterator.hpp.

Here is the caller graph for this function:

nullval()

nullval_t sparrow::nullval ( 0 )

inlineconstexpr

Here is the caller graph for this function:

num_bytes_for_decimal()

SPARROW_API std::size_t sparrow::num_bytes_for_decimal ( const char * format )

nodiscard

Here is the caller graph for this function:

num_bytes_for_fixed_sized_binary()

SPARROW_API std::size_t sparrow::num_bytes_for_fixed_sized_binary ( std::string_view format )

nodiscard

Get the number of bytes for a fixed width binary layout from the ArrowArray format string.

Example: w:42 -> 42 bytes w:1 -> 1 bytes

Parameters

format

the format string

Returns

the number of bytes

Exceptions

std::invalid_argument	if no conversion could be performed.
std::out_of_range	if the converted value would fall out of the range of the result type or if the underlying function (std::strtoul or std::strtoull) sets errno to ERANGE.

Here is the caller graph for this function:

number_of_bytes()

template<std::ranges::range R>
requires std::ranges::sized_range<std::ranges::range_value_t<R>>

size_t sparrow::number_of_bytes ( const R & ranges )

nodiscard

Definition at line 29 of file buffers.hpp.

Here is the caller graph for this function:

operator<=>() [1/7]

template<class T>
requires std::three_way_comparable<typename cloning_ptr<T>::pointer>

std::compare_three_way_result_t< typename cloning_ptr< T >::pointer > sparrow::operator<=> ( const cloning_ptr< T > & lhs, std::nullptr_t  )

constexprnoexcept

Definition at line 487 of file memory.hpp.

operator<=>() [2/7]

template<class T1, class T2>
requires std::three_way_comparable_with<typename cloning_ptr<T1>::pointer, typename cloning_ptr<T2>::pointer>

std::compare_three_way_result_t< typename cloning_ptr< T1 >::pointer, typename cloning_ptr< T2 >::pointer > sparrow::operator<=> ( const cloning_ptr< T1 > & lhs, const cloning_ptr< T2 > & rhs )

constexprnoexcept

Definition at line 473 of file memory.hpp.

Here is the caller graph for this function:

operator<=>() [3/7]

template<class T, class B, std::three_way_comparable_with< T > U, class UB>

std::compare_three_way_result_t< T, U > sparrow::operator<=> ( const nullable< T, B > & lhs, const nullable< U, UB > & rhs )

constexprnoexcept

Definition at line 761 of file nullable.hpp.

Here is the call graph for this function:

operator<=>() [4/7]

template<class T, class B, class U>
requires (!is_nullable_v<U> && std::three_way_comparable_with<U, T>)

std::compare_three_way_result_t< T, U > sparrow::operator<=> ( const nullable< T, B > & lhs, const U & rhs )

constexprnoexcept

Definition at line 748 of file nullable.hpp.

Here is the call graph for this function:

operator<=>() [5/7]

template<class T, mpl::boolean_like B>

std::strong_ordering sparrow::operator<=> ( const nullable< T, B > & lhs, nullval_t  )

constexprnoexcept

Definition at line 734 of file nullable.hpp.

operator<=>() [6/7]

template<class T, std::size_t E, std::ranges::input_range R>

std::compare_three_way_result< T, std::ranges::range_value_t< R > > sparrow::operator<=> ( const sequence_view< T, E > & lhs, const R & rhs )

constexpr

Definition at line 122 of file sequence_view.hpp.

operator<=>() [7/7]

template<class T, std::size_t E>

std::compare_three_way_result< T > sparrow::operator<=> ( const sequence_view< T, E > & lhs, const sequence_view< T, E > & rhs )

constexpr

Definition at line 115 of file sequence_view.hpp.

operator==() [1/25]

template<class T>

bool sparrow::operator== ( const any_allocator< T > & lhs, const any_allocator< T > & rhs )

constexpr

Definition at line 326 of file allocator.hpp.

Here is the call graph for this function:

operator==() [2/25]

SPARROW_API bool sparrow::operator==	(	const array &	lhs,
		const array &	rhs )

Compares the content of two arrays.

Parameters

lhs	the first Array to compare
rhs	the second Array to compare

Returns

true if the contents of both arrays are equal, false otherwise.

Here is the caller graph for this function:

operator==() [3/25]

template<class D>

bool sparrow::operator== ( const array_crtp_base< D > & lhs, const array_crtp_base< D > & rhs )

constexpr

Checks if the contents of lhs and rhs are equal, that is, they have the same number of elements and each element in lhs compares equal with the element in rhs at the same position.

Parameters

lhs	the first array to compare.
rhs	the second array to compare.

Definition at line 459 of file array_base.hpp.

operator==() [4/25]

template<class B>

bool sparrow::operator==	(	const bitset_reference< B > &	lhs,
		bool	rhs )

Definition at line 175 of file bitset_reference.hpp.

operator==() [5/25]

template<class B1, class B2>

bool sparrow::operator==	(	const bitset_reference< B1 > &	lhs,
		const bitset_reference< B2 > &	rhs )

Definition at line 169 of file bitset_reference.hpp.

operator==() [6/25]

template<class T>

bool sparrow::operator== ( const buffer< T > & lhs, const buffer< T > & rhs )

constexprnoexcept

Definition at line 1133 of file buffer.hpp.

operator==() [7/25]

template<class T>

bool sparrow::operator==	(	const buffer_view< T > &	lhs,
		const buffer_view< T > &	rhs )

Definition at line 358 of file buffer_view.hpp.

Here is the call graph for this function:

operator==() [8/25]

template<class T>

bool sparrow::operator== ( const cloning_ptr< T > & lhs, std::nullptr_t  )

constexprnoexcept

Definition at line 480 of file memory.hpp.

operator==() [9/25]

template<class T1, class T2>
requires std::equality_comparable_with<typename cloning_ptr<T1>::pointer, typename cloning_ptr<T2>::pointer>

bool sparrow::operator== ( const cloning_ptr< T1 > & lhs, const cloning_ptr< T2 > & rhs )

constexprnoexcept

Definition at line 466 of file memory.hpp.

operator==() [10/25]

bool sparrow::operator== ( const days_time_interval & lhs, const days_time_interval & rhs )

constexpr

Definition at line 38 of file interval_types.hpp.

operator==() [11/25]

template<class IT>

bool sparrow::operator== ( const dictionary_encoded_array< IT > & lhs, const dictionary_encoded_array< IT > & rhs )

constexpr

Definition at line 666 of file dictionary_encoded_array.hpp.

operator==() [12/25]

SPARROW_API bool sparrow::operator==	(	const list_value &	lhs,
		const list_value &	rhs )

Here is the call graph for this function:

operator==() [13/25]

SPARROW_API bool sparrow::operator==	(	const map_value &	lhs,
		const map_value &	rhs )

operator==() [14/25]

bool sparrow::operator== ( const month_day_nanoseconds_interval & lhs, const month_day_nanoseconds_interval & rhs )

constexpr

Definition at line 55 of file interval_types.hpp.

operator==() [15/25]

SPARROW_API bool sparrow::operator==	(	const null_array &	lhs,
		const null_array &	rhs )

operator==() [16/25]

bool sparrow::operator== ( const null_type & , const null_type &  )

constexprnoexcept

Definition at line 121 of file data_type.hpp.

operator==() [17/25]

template<class T, class B, class U, class UB>
requires (mpl::weakly_equality_comparable_with<T, U>)

bool sparrow::operator== ( const nullable< T, B > & lhs, const nullable< U, UB > & rhs )

constexprnoexcept

Definition at line 755 of file nullable.hpp.

Here is the call graph for this function:

operator==() [18/25]

template<class T, class B, class U>
requires (!is_nullable_v<U> && mpl::weakly_equality_comparable_with<T, U>)

bool sparrow::operator== ( const nullable< T, B > & lhs, const U & rhs )

constexprnoexcept

Definition at line 741 of file nullable.hpp.

Here is the call graph for this function:

operator==() [19/25]

template<class T, class B>

bool sparrow::operator== ( const nullable< T, B > & lhs, nullval_t  )

constexprnoexcept

Definition at line 728 of file nullable.hpp.

operator==() [20/25]

SPARROW_API bool sparrow::operator==	(	const record_batch &	lhs,
		const record_batch &	rhs )

Compares the content of two record_batch objects.

Parameters

lhs	the first record_batch to compare
rhs	the second record_batch to compare

Returns

true if the contents of both record_batch are equal, false otherwise.

operator==() [21/25]

SPARROW_API bool sparrow::operator==	(	const run_end_encoded_array &	lhs,
		const run_end_encoded_array &	rhs )

operator==() [22/25]

template<class T, std::size_t E, std::ranges::input_range R>
requires mpl::weakly_equality_comparable_with<T, std::ranges::range_value_t<R>>

bool sparrow::operator== ( const sequence_view< T, E > & lhs, const R & rhs )

constexpr

Definition at line 109 of file sequence_view.hpp.

operator==() [23/25]

template<class T, std::size_t E>

bool sparrow::operator== ( const sequence_view< T, E > & lhs, const sequence_view< T, E > & rhs )

constexpr

Definition at line 102 of file sequence_view.hpp.

operator==() [24/25]

SPARROW_API bool sparrow::operator==	(	const struct_value &	lhs,
		const struct_value &	rhs )

operator==() [25/25]

template<class D>

bool sparrow::operator== ( const union_array_crtp_base< D > & lhs, const union_array_crtp_base< D > & rhs )

constexpr

Definition at line 602 of file union_array.hpp.

overloaded()

template<class... Ts>

sparrow::overloaded

(

Ts...

)

-> overloaded< Ts... >

owns_arrow_array()

template<layout_or_array A>

bool sparrow::owns_arrow_array

(

const A &

a

)

Returns true if the given layout or array has ownership of its internal ArrowArray.

Parameters

a	An array or a typed layout object.

Returns

true if a owns its internal ArrowArray, false otherwise.

Definition at line 48 of file array.hpp.

Here is the call graph for this function:

owns_arrow_schema()

template<layout_or_array A>

bool sparrow::owns_arrow_schema

(

const A &

a

)

Returns true if the given layout or array has ownership of its internal ArrowSchema.

Parameters

a	An array or a typed layout object.

Returns

true if a owns its internal ArrowSchema, false otherwise.

Definition at line 54 of file array.hpp.

Here is the call graph for this function:

range_size() [1/2]

template<std::ranges::input_range R>
requires (std::ranges::sized_range<R>)

std::size_t sparrow::range_size ( R && r )

nodiscardconstexpr

Definition at line 32 of file ranges.hpp.

Here is the caller graph for this function:

range_size() [2/2]

template<std::ranges::input_range R>
requires (!std::ranges::sized_range<R>)

std::size_t sparrow::range_size ( R && r )

nodiscardconstexpr

Definition at line 39 of file ranges.hpp.

range_to_buffer()

template<std::ranges::range R>
requires (std::is_arithmetic_v<std::ranges::range_value_t<R>>)

buffer< uint8_t > sparrow::range_to_buffer ( R && range )

nodiscard

Definition at line 74 of file buffers.hpp.

Here is the call graph for this function:

release_arrow_array()

SPARROW_API void sparrow::release_arrow_array

(

ArrowArray *

array

)

Release function to use for the ArrowArray.release member.

Here is the caller graph for this function:

release_arrow_schema()

SPARROW_API void sparrow::release_arrow_schema

(

ArrowSchema *

schema

)

Release function to use for the ArrowSchema.release member.

Here is the caller graph for this function:

release_common_arrow()

template<class T>
requires std::same_as<T, ArrowArray> || std::same_as<T, ArrowSchema>

void sparrow::release_common_arrow

(

T &

t

)

Release the children and dictionnary of an ArrowArray or ArrowSchema.

Template Parameters

T	ArrowArray or ArrowSchema

Parameters

t	The ArrowArray or ArrowSchema to release.

Definition at line 31 of file arrow_array_schema_common_release.hpp.

ssize()

template<class T>

int64_t sparrow::ssize ( const T & value )

nodiscardconstexpr

Get the size of a range, a tuple or an optional.

If the range is a sized range, the size is obtained by calling std::ranges::size(). If the range is a tuple, the size is obtained by calling tuple_size_v. If the optional has a value, the size is obtained by calling ssize() on the value.

Template Parameters

T	The type of the value.

Parameters

value

The value.

Returns

The number of elements in value.

Definition at line 117 of file arrow_array_schema_utils.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

stobigint()

template<typename T>

T sparrow::stobigint ( std::string_view str )

constexpr

Definition at line 88 of file large_int.hpp.

strings_to_buffer()

template<std::ranges::range R>
requires (std::ranges::sized_range<std::ranges::range_value_t<R>>)

buffer< uint8_t > sparrow::strings_to_buffer ( R && strings )

nodiscard

Definition at line 46 of file buffers.hpp.

Here is the call graph for this function:

swap() [1/4]

SPARROW_API void sparrow::swap	(	ArrowArray &	lhs,
		ArrowArray &	rhs )

Swaps the contents of the two ArrowArray objects.

Here is the caller graph for this function:

swap() [2/4]

SPARROW_API void sparrow::swap ( ArrowSchema & lhs, ArrowSchema & rhs )

noexcept

Swaps the contents of the two ArrowSchema objects.

swap() [3/4]

template<class T>

void sparrow::swap ( cloning_ptr< T > & lhs, cloning_ptr< T > & rhs )

noexcept

Definition at line 459 of file memory.hpp.

swap() [4/4]

template<class T, class B>

void sparrow::swap ( nullable< T, B > & lhs, nullable< T, B > & rhs )

constexprnoexcept

Definition at line 722 of file nullable.hpp.

to_ArrowFlag_value()

int64_t sparrow::to_ArrowFlag_value ( const std::unordered_set< ArrowFlag > & flags )

inline

Converts a vector of ArrowFlag values to a bitfield of ArrowFlag values.

Definition at line 62 of file arrow_flag_utils.hpp.

to_native_endian()

template<std::endian input_value_endianess>

auto sparrow::to_native_endian ( std::integral auto value )

nodiscardconstexprnoexcept

Definition at line 41 of file bit.hpp.

Here is the call graph for this function:

to_optional_string()

template<class T>

std::optional< std::string > sparrow::to_optional_string ( T && t )

constexpr

Definition at line 85 of file private_data.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

to_raw_ptr_vec() [1/3]

template<class T, class Optional, class Allocator = std::allocator<T*>>
requires (mpl::is_type_instance_of_v<Optional, std::optional>)

std::vector< T *, Allocator > sparrow::to_raw_ptr_vec ( Optional & optional )

nodiscardconstexpr

Create a vector of pointers to elements from a std::optional<range>.

Requirement: The provided range must own it's elements.

Template Parameters

T	The type of the pointers to obtain.
Optional	The optional type.
Allocator	The allocator type.

Parameters

optional

The optional range.

Returns

A vector of pointers.

Definition at line 200 of file arrow_array_schema_utils.hpp.

Here is the call graph for this function:

to_raw_ptr_vec() [2/3]

template<class T, std::ranges::input_range Range, class Allocator = std::allocator<T*>>
requires (!std::ranges::view<Range>)

std::vector< T *, Allocator > sparrow::to_raw_ptr_vec ( Range & range )

nodiscardconstexpr

Create a vector of pointers to elements from a range.

Requirement: The provided range must own it's elements.

Template Parameters

T	The type of the pointers to obtain.
Range	The range type.
Allocator	The allocator type.

Parameters

range

The range.

Returns

A vector of pointers.

Definition at line 183 of file arrow_array_schema_utils.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

to_raw_ptr_vec() [3/3]

template<class T, class Tuple, class Allocator = std::allocator<T*>>
requires mpl::is_type_instance_of_v<Tuple, std::tuple>

std::vector< T *, Allocator > sparrow::to_raw_ptr_vec ( Tuple & tuple )

nodiscardconstexpr

Create a vector of pointers to elements of a tuple.

Types of the tuple can be value_ptr, smart pointers, ranges, objects or pointers. The type of the elements can be different. E.g: std::tuple<value_ptr<int>, std::unique_ptr<char>, double>. Casting is used to convert the pointers to the desired type.

Template Parameters

T	The type of the pointers to obtain.
Tuple	The tuple type.
Allocator	The allocator type.

Parameters

tuple

The tuple.

Returns

A vector of pointers.

Definition at line 211 of file arrow_array_schema_utils.hpp.

Here is the call graph for this function:

to_row()

template<typename OutputIt, std::ranges::input_range Widths, std::ranges::input_range Values>
requires (std::same_as<std::ranges::range_value_t<Widths>, size_t>)

void sparrow::to_row ( OutputIt out, const Widths & widths, const Values & values, std::string_view separator = "|" )

constexpr

Definition at line 97 of file format.hpp.

Here is the caller graph for this function:

to_set_of_ArrowFlags()

std::unordered_set< ArrowFlag > sparrow::to_set_of_ArrowFlags ( int64_t flag_values )

inline

Converts a bitfield of ArrowFlag values to a set of ArrowFlag values.

Definition at line 41 of file arrow_flag_utils.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

to_table_with_columns()

template<std::ranges::input_range Headers, RangeOfRanges Columns, typename OutputIt>
requires (std::convertible_to<std::ranges::range_value_t<Headers>, std::string>)

void sparrow::to_table_with_columns ( OutputIt out, const Headers & headers, const Columns & columns )

constexpr

Definition at line 139 of file format.hpp.

Here is the call graph for this function:

unwrap_array() [1/2]

template<class T>

T & sparrow::unwrap_array

(

array_wrapper &

ar

)

Definition at line 264 of file array_wrapper.hpp.

Here is the caller graph for this function:

unwrap_array() [2/2]

template<class T>

const T & sparrow::unwrap_array

(

const array_wrapper &

ar

)

Definition at line 270 of file array_wrapper.hpp.

visit()

template<class F>

visit_result_t< F > sparrow::visit ( F && func, const array_wrapper & ar )

nodiscard

Definition at line 48 of file dispatch.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

zero_null_values()

template<std::ranges::range R, typename T = typename std::ranges::range_value_t<R>::value_type>
requires (nullable_of<std::ranges::range_value_t<R>, T>)

void sparrow::zero_null_values ( R & range, const T & default_value = T{} )

constexpr

Definition at line 775 of file nullable.hpp.

Here is the caller graph for this function:

Variable Documentation

doesnt_own_arrow_data

auto sparrow::doesnt_own_arrow_data

inlineconstexpr

Initial value:

=arrow_data_ownership{
    .schema = ownership::not_owning,
    .array = ownership::not_owning,
}

Useful shortcut value to specify non-owning handled Arrow data.

Definition at line 98 of file c_interface.hpp.

is_big_binary_array_v

template<class T>

bool sparrow::is_big_binary_array_v = std::same_as<T, big_binary_array>

constexpr

Checks whether T is a big_binary_array type.

Definition at line 194 of file variable_size_binary_array.hpp.

is_big_list_array_v

template<class T>

bool sparrow::is_big_list_array_v = std::same_as<T, big_list_array>

constexpr

Checks whether T is a big_list_array type.

Definition at line 87 of file list_array.hpp.

is_big_list_view_array_v

template<class T>

bool sparrow::is_big_list_view_array_v = std::same_as<T, big_list_view_array>

constexpr

Checks whether T is a big_list_view_array type.

Definition at line 99 of file list_array.hpp.

is_big_string_array_v

template<class T>

bool sparrow::is_big_string_array_v = std::same_as<T, big_string_array>

constexpr

Checks whether T is a big_string_array type.

Definition at line 182 of file variable_size_binary_array.hpp.

is_binary_array_v

template<class T>

bool sparrow::is_binary_array_v = std::same_as<T, binary_array>

constexpr

Checks whether T is a binary_array type.

Definition at line 188 of file variable_size_binary_array.hpp.

is_date_array_v

template<class T>

bool sparrow::is_date_array_v = is_date_array<T>::value

constexpr

Checks whether T is a date_array type.

Definition at line 85 of file date_array.hpp.

is_decimal_array_v

template<class T>

bool sparrow::is_decimal_array_v = mpl::is_type_instance_of_v<T, decimal_array>

constexpr

Definition at line 105 of file decimal_array.hpp.

is_decimal_v

template<typename T>

bool sparrow::is_decimal_v = mpl::is_type_instance_of_v<T, decimal>

constexpr

Definition at line 62 of file decimal.hpp.

is_dense_union_array_v

template<class T>

bool sparrow::is_dense_union_array_v = std::same_as<T, dense_union_array>

constexpr

Checks whether T is a dense_union_array type.

Definition at line 67 of file union_array.hpp.

is_dictionary_encoded_array_v

template<class T>

bool sparrow::is_dictionary_encoded_array_v = detail::is_dictionary_encoded_array<T>::get()

constexpr

Checks whether T is a dictionary_encoded_array type.

Definition at line 93 of file dictionary_encoded_array.hpp.

is_duration_array_v

template<class T>

bool sparrow::is_duration_array_v = is_duration_array<T>::value

constexpr

Checks whether T is a duration_array type.

Definition at line 109 of file duration_array.hpp.

is_fixed_sized_list_array_v

template<class T>

bool sparrow::is_fixed_sized_list_array_v = std::same_as<T, fixed_sized_list_array>

constexpr

Checks whether T is a fixed_sized_list_array type.

Definition at line 105 of file list_array.hpp.

is_int_placeholder_v

template<class T>

bool sparrow::is_int_placeholder_v = false

constexpr

Definition at line 82 of file large_int.hpp.

is_interval_array_v

template<class T>

bool sparrow::is_interval_array_v = is_interval_array<T>::value

constexpr

Checks whether T is a interval_array type.

Definition at line 98 of file interval_array.hpp.

is_list_array_v

template<class T>

bool sparrow::is_list_array_v = std::same_as<T, list_array>

constexpr

Checks whether T is a list_array type.

Definition at line 81 of file list_array.hpp.

is_list_view_array_v

template<class T>

bool sparrow::is_list_view_array_v = std::same_as<T, list_view_array>

constexpr

Checks whether T is a list_view_array type.

Definition at line 93 of file list_array.hpp.

is_map_array_v

template<class T>

bool sparrow::is_map_array_v = std::same_as<T, map_array>

constexpr

Definition at line 44 of file map_array.hpp.

is_move_iterator_v

template<typename T>

bool sparrow::is_move_iterator_v = is_move_iterator<T>::value

constexpr

Definition at line 855 of file buffer.hpp.

is_null_array_v

template<class T>

bool sparrow::is_null_array_v = std::same_as<T, null_array>

constexpr

Checks whether T is a null_array type.

Definition at line 73 of file null_array.hpp.

is_nullable_v

template<class T>

bool sparrow::is_nullable_v = is_nullable<T>::value

inlineconstexpr

Definition at line 61 of file nullable.hpp.

is_primitive_array_v

template<class T>

bool sparrow::is_primitive_array_v = is_primitive_array<T>::value

constexpr

Checkes whether T is a primitive_array type.

Definition at line 79 of file primitive_array.hpp.

is_run_end_encoded_array_v

template<class T>

bool sparrow::is_run_end_encoded_array_v = std::same_as<T, run_end_encoded_array>

constexpr

Checks whether T is a run_end_encoded_array type.

Definition at line 44 of file run_end_encoded_array.hpp.

is_sparse_union_array_v

template<class T>

bool sparrow::is_sparse_union_array_v = std::same_as<T, sparse_union_array>

constexpr

Checks whether T is a sparse_union_array type.

Definition at line 73 of file union_array.hpp.

is_string_array_v

template<class T>

bool sparrow::is_string_array_v = std::same_as<T, string_array>

constexpr

Checks whether T is a string_array type.

Definition at line 176 of file variable_size_binary_array.hpp.

is_struc_array_v

template<class T>

bool sparrow::is_struc_array_v = std::same_as<T, struct_array>

constexpr

Checks whether T is a struct_array type.

Definition at line 71 of file struct_array.hpp.

is_time_array_v

template<class T>

bool sparrow::is_time_array_v = is_time_array<T>::value

constexpr

Checks whether T is a time_array type.

Definition at line 107 of file time_array.hpp.

is_timestamp_array_v

template<typename T>

bool sparrow::is_timestamp_array_v = is_timestamp_array<T>::value

constexpr

Definition at line 72 of file timestamp_array.hpp.

is_timestamp_without_timezone_array_v

template<class T>

bool sparrow::is_timestamp_without_timezone_array_v = is_timestamp_without_timezone_array<T>::value

constexpr

Checks whether T is a timestamp_without_timezone_array type.

Definition at line 105 of file timestamp_without_timezone_array.hpp.

is_variable_size_binary_view_array

template<variable_size_binary_view_impl_types T>

bool sparrow::is_variable_size_binary_view_array = is_variable_size_binary_view_array_impl<T>::value

constexpr

Checks whether T is a variable_size_binary_view_array_impl type.

Definition at line 113 of file variable_size_binary_view_array.hpp.

large_int_placeholders

bool sparrow::large_int_placeholders = false

constexpr

Definition at line 83 of file large_int.hpp.

large_list_flag

large_list_flag_t sparrow::large_list_flag

inlineconstexpr

Definition at line 72 of file builder.hpp.

owns_arrow_data

auto sparrow::owns_arrow_data

inlineconstexpr

Initial value:

=arrow_data_ownership{
    .schema = ownership::owning,
    .array = ownership::owning,
}

Useful shortcut value to specify full owning of handled Arrow data.

Definition at line 104 of file c_interface.hpp.

SPARROW_BINARY_AGE

int sparrow::SPARROW_BINARY_AGE = 0

constexpr

Definition at line 25 of file sparrow_version.hpp.

SPARROW_BINARY_CURRENT

int sparrow::SPARROW_BINARY_CURRENT = 8

constexpr

Definition at line 23 of file sparrow_version.hpp.

SPARROW_BINARY_REVISION

int sparrow::SPARROW_BINARY_REVISION = 0

constexpr

Definition at line 24 of file sparrow_version.hpp.

SPARROW_VERSION_MAJOR

int sparrow::SPARROW_VERSION_MAJOR = 0

constexpr

Definition at line 19 of file sparrow_version.hpp.

SPARROW_VERSION_MINOR

int sparrow::SPARROW_VERSION_MINOR = 9

constexpr

Definition at line 20 of file sparrow_version.hpp.

SPARROW_VERSION_PATCH

int sparrow::SPARROW_VERSION_PATCH = 0

constexpr

Definition at line 21 of file sparrow_version.hpp.