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
class	array_crtp_base
struct	array_inner_types
	Traits class that must be specialized by array implementations. 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, CR > >
struct	array_inner_types_base
	Base class for array_inner_types specializations. 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
class	arrow_proxy_exception
	Exception thrown by arrow_proxy operations. 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
	Exception thrown when accessing a null nullable value. More...
class	bitset_iterator
	Iterator used to iterate over the bits of a dynamic bitset as if they were addressable values. More...
class	bitset_reference
	A proxy reference class that provides mutable access to individual bits in a bitset. More...
class	buffer
	Object that owns a piece of contiguous memory. More...
class	buffer_adaptor
	Class which has 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
	Array implementation for decimal types. More...
class	decimal_reference
class	dense_union_array
	Dense union array implementation with offset buffer. More...
struct	dense_union_flag_t
class	dict_encode
class	dictionary_encoded_array
	Forward declaration of dictionary_encoded_array. More...
class	dictionary_ownership
class	dynamic_bitset
	A dynamic size sequence of bits with efficient storage and manipulation operations. More...
class	dynamic_bitset_base
	Base class providing core functionality for dynamic bitset implementations. More...
class	dynamic_bitset_view
	A non-owning view to a dynamic size sequence of bits stored in external memory. More...
class	empty_iterator
	Iterator for null arrays where all elements are null. More...
class	fixed_sized_list_array
class	fixed_width_binary_array_impl
class	fixed_width_binary_reference
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_nullable_variant
struct	is_nullable_variant< nullable_variant< T... > >
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
	Type trait to check if a type is a timestamp_array. More...
struct	is_timestamp_array< timestamp_array< T > >
	Specialization for timestamp_array types. More...
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, CR > >
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
	Custom view for lazily extracting key-value pairs from a binary buffer. More...
class	key_value_view_iterator
	Iterator for traversing key-value pairs in a binary metadata buffer. More...
struct	large_binary_flag_t
struct	large_list_flag_t
class	layout_element_functor
	Functor for accessing elements in a layout. More...
class	layout_iterator
	Layout iterator class. More...
class	list_array_crtp_base
	CRTP base class for all list array implementations. More...
class	list_array_impl
class	list_value
class	list_value_iterator
	Iterator for traversing elements within a list_value. More...
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
	Memory-efficient array implementation for null data types. More...
struct	null_type
class	nullable
struct	nullable_traits
struct	nullable_traits< T & >
class	nullable_variant
	Variant of nullable types with has_value() convenience method. More...
struct	nullval_t
	Sentinel type to indicate a nullable value is null. More...
struct	overloaded
class	pointer_iterator
class	pointer_iterator< T * >
class	primitive_array_impl
class	record_batch
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
	Sparse union array implementation without offset buffer. More...
struct	sparse_union_flag_t
class	struct_array
class	struct_value
class	timestamp_array
	Array implementation for storing timestamp values with timezone information. More...
class	timestamp_reference
	Implementation of reference to inner type used for layout L. More...
class	u8_buffer
	This buffer class is used as storage buffer for all sparrow arrays. More...
class	union_array_crtp_base
	CRTP base class providing shared functionality for union array implementations. More...
class	value_ptr
	A value_ptr is a smart pointer that behaves like a value. More...
class	variable_size_binary_array_impl
	A variable-size binary array. More...
class	variable_size_binary_reference
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 that checks if a type is a buffer reference suitable for adaptation.
concept	T_is_const_if_FromBufferRef_is_const
	Concept that ensures T is const if FromBufferRef is const.
concept	validity_bitmap_input
	Concept defining valid input types for validity bitmap creation.
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	date_type
concept	duration_type
concept	interval_type
concept	layout
	Concept for layouts.
concept	iterator_types
	Concept for iterator types.
concept	trivial_copyable_type
concept	timestamp_type
concept	primitive_type
concept	time_type
concept	zoned_time_without_timezone_type
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 for valid decimal integer backing types.
concept	decimal_type
	Concept for valid decimal types.
concept	RangeOfRanges
concept	Format
concept	RangeOfFormats
concept	clonable
	Matches types that provide a clone method.
concept	input_metadata_container
	Concept for input containers that can provide metadata pairs.
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>
	Type alias for a validity bitmap using 8-bit storage blocks.
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	decimal_32_array = decimal_array<decimal<int32_t>>
	Type alias for 32-bit decimal array.
using	decimal_64_array = decimal_array<decimal<int64_t>>
	Type alias for 64-bit decimal array.
using	decimal_128_array = decimal_array<decimal<int128_t>>
	Type alias for 128-bit decimal array.
using	decimal_256_array = decimal_array<decimal<int256_t>>
	Type alias for 256-bit decimal array.
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	fixed_width_binary_traits = arrow_traits<std::vector<byte_t>>
using	fixed_width_binary_array
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.
template<class D>
using	array_bitmap_base = array_bitmap_base_impl<D, false>
	Convenient alias for arrays with immutable validity bitmaps.
template<class D>
using	mutable_array_bitmap_base = array_bitmap_base_impl<D, true>
	Convenient alias for arrays with mutable validity bitmaps.
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>
template<class F>
using	visit_result_t = std::invoke_result_t<F, null_array>
using	timestamp_types_t
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	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>
	Type aliases for common timestamp durations.
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>
	Type aliases for timestamp arrays with common durations.
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	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	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
	Type alias for metadata keys.
using	metadata_key_const_reference = std::string_view
using	metadata_value = std::string
	Type alias for metadata values.
using	metadata_value_const_reference = std::string_view
using	metadata_pair = std::pair<metadata_key, metadata_value>
	Type alias for metadata key-value pairs.
using	metadata_pair_const_reference = std::pair<metadata_key_const_reference, metadata_value_const_reference>
template<layout_offset OT>
using	string_array_impl
template<layout_offset OT>
using	binary_array_impl
using	string_array = string_array_impl<std::int32_t>
	Type alias for variable-size string arrays with 32-bit offsets.
using	big_string_array = string_array_impl<std::int64_t>
	Type alias for variable-size string arrays with 64-bit offsets.
using	binary_array = binary_array_impl<std::int32_t>
	Type alias for variable-size binary arrays with 32-bit offsets.
using	big_binary_array = binary_array_impl<std::int64_t>
	Type alias for variable-size binary arrays with 64-bit offsets.
using	string_view_array
	A variable-size string view layout implementation.
using	binary_view_array
	A variable-size binary view layout implementation.

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>
std::pair< const ArrowArray *, const ArrowSchema * >	get_arrow_structures (const A &a)
	Returns const 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 ArrowArray 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.
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)
	Equality comparison between two bitset references.
template<class B>
bool	operator== (const bitset_reference< B > &lhs, bool rhs)
	Equality comparison between a bitset reference and a boolean value.
template<validity_bitmap_input R>
validity_bitmap	ensure_validity_bitmap (std::size_t size, R &&validity_input)
	Ensures a validity bitmap of the specified size from various input types.
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 IT>
constexpr bool	operator== (const dictionary_encoded_array< IT > &lhs, const dictionary_encoded_array< IT > &rhs)
	Equality comparison operator for dictionary_encoded_array.
template<class D>
constexpr bool	operator== (const array_crtp_base< D > &lhs, const array_crtp_base< D > &rhs)
SPARROW_API cloning_ptr< array_wrapper >	array_factory (arrow_proxy proxy)
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 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.
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)
SPARROW_API bool	operator== (const list_value &lhs, const list_value &rhs)
	Equality comparison operator for list_value objects.
SPARROW_API bool	operator== (const map_value &lhs, const map_value &rhs)
SPARROW_API bool	operator== (const struct_value &lhs, const struct_value &rhs)
SPARROW_API bool	operator== (const null_array &lhs, const null_array &rhs)
	Equality comparison operator for null arrays.
SPARROW_API bool	operator== (const record_batch &lhs, const record_batch &rhs)
	Compares two record_batch objects for equality.
SPARROW_API bool	operator== (const run_end_encoded_array &lhs, const run_end_encoded_array &rhs)
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<class D>
constexpr bool	operator== (const union_array_crtp_base< D > &lhs, const union_array_crtp_base< D > &rhs)
	Equality comparison operator for union arrays.
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)
	Helper function to extract a 32-bit integer from a character buffer.
template<input_metadata_container T>
std::string	get_metadata_from_key_values (const T &metadata)
	Converts a container of key-value pairs to binary metadata format.
constexpr nullval_t	nullval (0)
template<class T, class B>
constexpr void	swap (nullable< T, B > &lhs, nullable< T, B > &rhs) noexcept
	Swaps two nullable objects.
template<class T, class B>
constexpr bool	operator== (const nullable< T, B > &lhs, nullval_t) noexcept
	Equality comparison between nullable and nullval_t.
template<class T, mpl::boolean_like B>
constexpr std::strong_ordering	operator<=> (const nullable< T, B > &lhs, nullval_t dummy) noexcept
	Three-way comparison between nullable and nullval_t.
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
	Equality comparison between nullable and regular value.
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
	Three-way comparison between nullable and regular value.
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
	Equality comparison between two nullable objects.
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
	Three-way comparison between two nullable objects.
template<class T, mpl::boolean_like B = bool>
constexpr nullable< T, B >	make_nullable (T &&value, B &&flag=true)
	Creates a nullable object with deduced types.
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{})
	Sets null values in a range to a default value.
std::ostream &	operator<< (std::ostream &os, const nullval_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 = 1
constexpr int	SPARROW_VERSION_MINOR = 0
constexpr int	SPARROW_VERSION_PATCH = 0
constexpr int	SPARROW_BINARY_CURRENT = 9
constexpr int	SPARROW_BINARY_REVISION = 0
constexpr int	SPARROW_BINARY_AGE = 0
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_decimal_array_v = mpl::is_type_instance_of_v<T, decimal_array>
	Type trait to check if a type is a 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_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_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>
	Type trait to check if a type is a null_array.
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>
	Type trait to check if a type is a struct_array.
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
	Variable template for convenient access to is_timestamp_array.
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>
	Type trait to check if a type is a dense_union_array.
template<class T>
constexpr bool	is_sparse_union_array_v = std::same_as<T, sparse_union_array>
	Type trait to check if a type is a sparse_union_array.
template<typename T>
constexpr bool	is_decimal_v = mpl::is_type_instance_of_v<T, decimal>
	Type trait to check if a type is a decimal instantiation.
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
template<class T>
constexpr bool	is_nullable_variant_v = is_nullable_variant<T>::value
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<class 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.

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 678 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 625 of file data_type.hpp.

array_bitmap_base

template<class D>

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

Convenient alias for arrays with immutable validity bitmaps.

This alias creates an array_bitmap_base_impl with is_mutable = false, providing read-only access to the validity bitmap.

Template Parameters

D	The derived array type

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/layout/array_bitmap_base.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/map_array.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/struct_array.hpp.

Definition at line 294 of file array_bitmap_base.hpp.

big_binary_array

using sparrow::big_binary_array = binary_array_impl<std::int64_t>

Type alias for variable-size binary arrays with 64-bit offsets.

A variable-size binary array implementation for storing arbitrary binary data where the cumulative length may exceed 2^31-1 bytes. Use this for very large binary datasets.

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

See also

binary_array for smaller datasets with 32-bit offsets

Definition at line 150 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.

Related Apache Arrow description and specification:

• https://arrow.apache.org/docs/dev/format/Intro.html#list
• https://arrow.apache.org/docs/format/Columnar.html#list-layout

  See also

  list_array

Definition at line 68 of file list_array.hpp.

big_list_view_array

using sparrow::big_list_view_array = list_view_array_impl<true>

Definition at line 83 of file list_array.hpp.

big_string_array

using sparrow::big_string_array = string_array_impl<std::int64_t>

Type alias for variable-size string arrays with 64-bit offsets.

A variable-size string array implementation for storing UTF-8 strings where the cumulative length of all strings may exceed 2^31-1 bytes. Use this for very large string datasets.

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

See also

string_array for smaller datasets with 32-bit offsets

Definition at line 122 of file variable_size_binary_array.hpp.

binary_array

using sparrow::binary_array = binary_array_impl<std::int32_t>

Type alias for variable-size binary arrays with 32-bit offsets.

A variable-size binary array implementation for storing arbitrary binary data where the cumulative length does not exceed 2^31-1 bytes. This is the standard choice for most binary datasets.

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

See also

big_binary_array for larger datasets requiring 64-bit offsets

Definition at line 136 of file variable_size_binary_array.hpp.

binary_array_impl

template<layout_offset OT>

using sparrow::binary_array_impl

Initial value:

variable_size_binary_array_impl<
    arrow_traits<std::vector<byte_t>>::value_type,
    arrow_traits<std::vector<byte_t>>::const_reference,
    OT>

Definition at line 91 of file variable_size_binary_array.hpp.

binary_view_array

using sparrow::binary_view_array

Initial value:

variable_size_binary_view_array_impl<
    arrow_traits<std::vector<byte_t>>::value_type,
    arrow_traits<std::vector<byte_t>>::const_reference>

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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/variable_size_binary_view_array.hpp.

Definition at line 60 of file variable_size_binary_view_array.hpp.

byte_t

using sparrow::byte_t = std::byte

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp.

Definition at line 115 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

primitive_array_impl

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 76 of file interval_array.hpp.

decimal_128_array

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

Type alias for 128-bit decimal array.

Definition at line 49 of file decimal_array.hpp.

decimal_256_array

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

Type alias for 256-bit decimal array.

Definition at line 51 of file decimal_array.hpp.

decimal_32_array

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

Type alias for 32-bit decimal array.

Definition at line 45 of file decimal_array.hpp.

decimal_64_array

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

Type alias for 64-bit decimal array.

Definition at line 47 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 756 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.

Definition at line 71 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 87 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 82 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 92 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 77 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>

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp.

Definition at line 77 of file fixed_width_binary_array.hpp.

fixed_width_binary_traits

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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp.

Definition at line 46 of file fixed_width_binary_array.hpp.

float16_t

using sparrow::float16_t = half_float::half

Definition at line 93 of file data_type.hpp.

float32_t

using sparrow::float32_t = float

Definition at line 94 of file data_type.hpp.

float64_t

using sparrow::float64_t = double

Definition at line 95 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 700 of file data_type.hpp.

int128_t

using sparrow::int128_t = primesum::int128_t

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/utils/decimal.hpp.

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.

Definition at line 65 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.

Related Apache Arrow description and specification:

• https://arrow.apache.org/docs/dev/format/Intro.html#list
• https://arrow.apache.org/docs/format/Columnar.html#list-layout

  See also

  big_list_array

Definition at line 57 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.

Related Apache Arrow description and specification:

• https://arrow.apache.org/docs/dev/format/Intro.html#list-view
• https://arrow.apache.org/docs/dev/format/Columnar.html#listview-layout

Definition at line 82 of file list_array.hpp.

metadata_key

using sparrow::metadata_key = std::string

Type alias for metadata keys.

Represents the key portion of a metadata key-value pair as a string view. String views are used for efficiency to avoid unnecessary string copies.

Definition at line 43 of file metadata.hpp.

metadata_key_const_reference

using sparrow::metadata_key_const_reference = std::string_view

Definition at line 44 of file metadata.hpp.

metadata_pair

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

Type alias for metadata key-value pairs.

Represents a complete metadata entry consisting of a key and value, both as string views for efficient processing.

Definition at line 61 of file metadata.hpp.

metadata_pair_const_reference

using sparrow::metadata_pair_const_reference = std::pair<metadata_key_const_reference, metadata_value_const_reference>

Definition at line 62 of file metadata.hpp.

metadata_value

using sparrow::metadata_value = std::string

Type alias for metadata values.

Represents the value portion of a metadata key-value pair as a string view. String views are used for efficiency to avoid unnecessary string copies.

Definition at line 52 of file metadata.hpp.

metadata_value_const_reference

using sparrow::metadata_value_const_reference = std::string_view

Definition at line 53 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 81 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 71 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 alias for arrays with mutable validity bitmaps.

This alias creates an array_bitmap_base_impl with is_mutable = true, providing full read-write access to the validity bitmap including resize, insert, and erase operations.

Template Parameters

D	The derived array type

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/array_bitmap_base.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/primitive_array_impl.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/variable_size_binary_view_array.hpp.

Definition at line 306 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 = string_array_impl<std::int32_t>

Type alias for variable-size string arrays with 32-bit offsets.

A variable-size string array implementation for storing UTF-8 strings where the cumulative length of all strings does not exceed 2^31-1 bytes. This is the standard choice for most string datasets.

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

See also

big_string_array for larger datasets requiring 64-bit offsets

Definition at line 108 of file variable_size_binary_array.hpp.

string_array_impl

template<layout_offset OT>

using sparrow::string_array_impl

Initial value:

variable_size_binary_array_impl<
    arrow_traits<std::string>::value_type,
    arrow_traits<std::string>::const_reference,
    OT>

Definition at line 85 of file variable_size_binary_array.hpp.

string_view_array

using sparrow::string_view_array

Initial value:

variable_size_binary_view_array_impl<
    arrow_traits<std::string>::value_type,
    arrow_traits<std::string>::const_reference>

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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/variable_size_binary_view_array.hpp.

Definition at line 49 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 104 of file data_type.hpp.

timestamp_microsecond

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

Definition at line 94 of file timestamp_array.hpp.

timestamp_microseconds_array

using sparrow::timestamp_microseconds_array = timestamp_array<timestamp_microsecond>

Definition at line 102 of file timestamp_array.hpp.

timestamp_millisecond

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

Definition at line 93 of file timestamp_array.hpp.

timestamp_milliseconds_array

using sparrow::timestamp_milliseconds_array = timestamp_array<timestamp_millisecond>

Definition at line 101 of file timestamp_array.hpp.

timestamp_nanosecond

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

Definition at line 95 of file timestamp_array.hpp.

timestamp_nanoseconds_array

using sparrow::timestamp_nanoseconds_array = timestamp_array<timestamp_nanosecond>

Definition at line 103 of file timestamp_array.hpp.

timestamp_second

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

Type aliases for common timestamp durations.

Definition at line 92 of file timestamp_array.hpp.

timestamp_seconds_array

using sparrow::timestamp_seconds_array = timestamp_array<timestamp_second>

Type aliases for timestamp arrays with common durations.

Definition at line 100 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>

Type alias for a validity bitmap using 8-bit storage blocks.

A validity bitmap is a specialized dynamic_bitset commonly used in data processing to track which elements in a data array are valid (non-null). Uses std::uint8_t for efficient memory usage and cache performance.

Example usage:

validity_bitmap validity(1000, true);  // 1000 valid elements
validity.set(42, false);  // Mark element 42 as invalid/null

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/primitive_array_impl.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/map_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/struct_array.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/variable_size_binary_view_array.hpp.

Definition at line 234 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 46 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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp.

Definition at line 130 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 188 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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp.

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 198 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 222 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 403 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 424 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 601 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 578 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.

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/layout/primitive_array_impl.hpp.

Definition at line 491 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 )

Ensures a validity bitmap of the specified size from various input types.

This function creates or adapts a validity bitmap to have the specified size, handling different input types appropriately:

• If given an existing validity_bitmap with size 0, creates a new one with all bits set to true
• If given an existing validity_bitmap with the correct size, returns it (copy or move)
• If given a range of booleans, creates a bitmap where true means valid
• If given a range of indices, creates a bitmap where those indices are marked invalid

Template Parameters

R	Type of the validity input, must satisfy validity_bitmap_input concept

Parameters

size	The desired size of the resulting validity bitmap
validity_input	The input data to create/adapt the validity bitmap from

Returns

A validity_bitmap of the specified size

Precondition

For range inputs: range size must match the specified size or be empty

For index ranges: all indices must be less than the specified size

Example usage:

//Create from boolean range
std::vector<bool> valid = {true, false, true};
auto bitmap1 = ensure_validity_bitmap(3, valid);
 
//Create from invalid indices
std::vector<std::size_t> invalid_indices = {1, 5, 9};
auto bitmap2 = ensure_validity_bitmap(10, invalid_indices);

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/primitive_array_impl.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/map_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/struct_array.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/variable_size_binary_view_array.hpp.

Definition at line 349 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.

Template Parameters

A	The layout or array type.

Parameters

a	An array or a typed layout.

Returns

The internal ArrowArray.

Exceptions

std::runtime_error

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

Definition at line 86 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.

Template Parameters

A	The layout or array type.

Parameters

a	An array or a typed layout.

Returns

The internal ArrowSchema.

Exceptions

std::runtime_error

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

Definition at line 92 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 ArrowArray 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.

Template Parameters

A	The layout or array type.

Parameters

a	An array or a typed layout.

Returns

The internal ArrowArray and ArrowSchema.

Exceptions

std::runtime_error

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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/map_array.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/struct_array.hpp.

Definition at line 98 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

)

Helper function to extract a 32-bit integer from a character buffer.

Reads a 32-bit integer from the current position in the buffer and advances the pointer past the read data. Used for parsing binary metadata formats.

Parameters

ptr	Reference to character pointer that will be advanced

Returns

The extracted 32-bit integer value

Precondition

ptr must point to a valid buffer with at least sizeof(int32_t) bytes available

Postcondition

ptr is advanced by sizeof(int32_t) bytes

Return value contains the integer read from the original ptr position

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.
children_ownership	Ownership of the children arrays. Must be true if the ArrowArray owns the children arrays, false otherwise.
dictionary	ArrowArray pointer or nullptr.
dictionary_ownership	Whether the dictionary is owned by the ArrowArray or not.

Definition at line 99 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 93 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 207 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.

Template Parameters

A	The layout or array type.

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.

Template Parameters

A	The layout or array type.

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() [1/2]

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.

Template Parameters

A	The layout or array type.

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_arrow_structures() [2/2]

template<layout_or_array A>

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

(

const A &

a

)

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

Template Parameters

A	The layout or array type.

Parameters

a	An Array or a typed layout.

Returns

const pointers to the internal ArrowArray and ArrowSchema.

Definition at line 79 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

)

Converts a container of key-value pairs to binary metadata format.

Takes a container of metadata pairs and serializes them into a binary format suitable for storage or transmission. The resulting string contains a packed representation with length-prefixed strings.

Binary format:

• int32_t: number of key-value pairs
• For each pair:
  • int32_t: key length
  • char[]: key data (no null terminator)
  • int32_t: value length
  • char[]: value data (no null terminator)

Template Parameters

T	Type of input metadata container

Parameters

metadata

Container of key-value pairs to serialize

Returns

String containing the binary representation

Precondition

T must satisfy input_metadata_container concept

Container size must be < INT32_MAX

All keys and values must have size < INT32_MAX

Postcondition

Returned string contains valid binary metadata format

String can be used to reconstruct the metadata pairs via key_value_view

Note

Internal assertions verify size constraints:

• SPARROW_ASSERT_TRUE(std::cmp_less(metadata.size(), std::numeric_limits<int32_t>::max()))
• SPARROW_ASSERT_TRUE(std::cmp_less(key.size(), std::numeric_limits<int32_t>::max()))
• SPARROW_ASSERT_TRUE(std::cmp_less(value.size(), std::numeric_limits<int32_t>::max()))

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/arrow_interface/arrow_array_schema_proxy.hpp.

Definition at line 338 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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/arrow_interface/arrow_array_schema_proxy.hpp.

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.
children_ownership	Ownership of the children arrays. Must be true if the ArrowArray owns the children arrays, false otherwise.
dictionary	ArrowArray pointer or nullptr.
dictionary_ownership	Whether the dictionary is owned by the ArrowArray or not.

Returns

The created ArrowArray.

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/primitive_array_impl.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/map_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/struct_array.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/variable_size_binary_view_array.hpp.

Definition at line 136 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.
children_ownership	A range of booleans indicating ownership of the ArrowSchema pointers in children. If the range is empty, children must be nullptr.
dictionary	Pointer to an ArrowSchema. Must be present if the ArrowSchema represents a dictionary-encoded type. Must be nullptr otherwise.
dictionary_ownership	Indicates whether the dictionary is owned by the ArrowSchema.

Returns

The created ArrowSchema unique pointer.

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/primitive_array_impl.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/map_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/struct_array.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/variable_size_binary_view_array.hpp.

Definition at line 153 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 880 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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/record_batch.hpp.

Definition at line 168 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 190 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

Creates a nullable object with deduced types.

Template Parameters

T	Value type (deduced)
B	Flag type (deduced, defaults to bool)

Parameters

value	Value to store
flag	Validity flag (defaults to true)

Returns

Nullable object containing the value and flag

Postcondition

Returned nullable has specified value and flag

has_value() returns the flag value

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/utils/nullable.hpp.

Definition at line 1361 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 209 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 221 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 233 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 245 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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/array_base.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/array_bitmap_base.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/fixed_width_binary_reference.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/layout/variable_size_binary_reference.hpp.

Definition at line 503 of file iterator.hpp.

Here is the caller graph for this function:

nullval()

nullval_t sparrow::nullval ( 0 )

inlineconstexpr

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/utils/nullable.hpp.

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.

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/fixed_width_binary_array.hpp.

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<<()

std::ostream & sparrow::operator<< ( std::ostream & os, const nullval_t &  )

inline

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/arrow_interface/arrow_array_schema_proxy.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/array_base.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/decimal_reference.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/fixed_width_binary_reference.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/list_value.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/variable_size_binary_reference.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/record_batch.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/struct_array.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/utils/decimal.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/utils/nullable.hpp.

Definition at line 1530 of file nullable.hpp.

Here is the call graph for this function:

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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/utils/nullable.hpp.

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

Three-way comparison between two nullable objects.

Template Parameters

T	First value type
B	First flag type
U	Second value type (must be three-way comparable with T)
UB	Second flag type

Parameters

lhs	First nullable to compare
rhs	Second nullable to compare

Returns

Ordering result

Precondition

U must be three-way comparable with T

Postcondition

Null values compare less than non-null values

If both non-null, returns lhs.get() <=> rhs.get()

If both null, returns std::strong_ordering::equal

Definition at line 1354 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

Three-way comparison between nullable and regular value.

Template Parameters

T	Value type
B	Flag type
U	Type of value to compare with

Parameters

lhs	Nullable to compare
rhs	Value to compare with

Returns

Ordering result

Precondition

U must be three-way comparable with T

Postcondition

Returns std::strong_ordering::less if lhs is null

Returns lhs.get() <=> rhs if lhs is non-null

Definition at line 1341 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 dummy )

constexprnoexcept

Three-way comparison between nullable and nullval_t.

Template Parameters

T	Value type
B	Flag type

Parameters

lhs	Nullable to compare
dummy	nullval sentinel

Returns

Ordering reflecting null state comparison

Postcondition

Returns std::strong_ordering::greater if lhs.has_value()

Returns std::strong_ordering::equal if !lhs.has_value()

Definition at line 1327 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.

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/layout/array_base.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/layout/list_value.hpp, /home/runner/work/sparrow/sparrow/include/sparrow/record_batch.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/utils/nullable.hpp.

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

Definition at line 693 of file array_base.hpp.

operator==() [4/25]

template<class B>

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

Equality comparison between a bitset reference and a boolean value.

Template Parameters

B	Type of the bitset reference

Parameters

lhs	The reference to compare
rhs	The boolean value to compare against

Returns

true if the referenced bit equals the boolean value

Postcondition

Return value is true iff bool(lhs) == rhs

Definition at line 300 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 )

Equality comparison between two bitset references.

Template Parameters

B1	Type of the first bitset reference
B2	Type of the second bitset reference

Parameters

lhs	The first reference to compare
rhs	The second reference to compare

Returns

true if both references point to bits with the same value

Postcondition

Return value is true iff bool(lhs) == bool(rhs)

Definition at line 294 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 1134 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

Equality comparison operator for dictionary_encoded_array.

Template Parameters

IT	The integral type used for dictionary keys.

Parameters

lhs	The first dictionary_encoded_array to compare.
rhs	The second dictionary_encoded_array to compare.

Returns

true if the arrays are equal, false otherwise.

Definition at line 953 of file dictionary_encoded_array.hpp.

operator==() [12/25]

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

Equality comparison operator for list_value objects.

Compares two list_value objects for element-wise equality. Two lists are considered equal if they have the same size and all corresponding elements compare equal.

Parameters

lhs	First list to compare
rhs	Second list to compare

Returns

true if lists are element-wise equal, false otherwise

Postcondition

Returns true iff both lists have same size and all elements compare equal

Comparison is performed element by element using array element equality

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 )

Equality comparison operator for null arrays.

Two null arrays are considered equal if they have the same size, since all elements are conceptually null.

Parameters

lhs	First null array to compare
rhs	Second null array to compare

Returns

true if arrays have the same size, false otherwise

Postcondition

Returns true iff lhs.size() == rhs.size()

Content comparison is trivial since all elements are null

operator==() [16/25]

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

constexprnoexcept

Definition at line 122 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

Equality comparison between two nullable objects.

Template Parameters

T	First value type
B	First flag type
U	Second value type
UB	Second flag type

Parameters

lhs	First nullable to compare
rhs	Second nullable to compare

Returns

true if both null or both non-null with equal values

Postcondition

Returns true if both are null

Returns false if only one is null

Returns lhs.get() == rhs.get() if both are non-null

Definition at line 1348 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

Equality comparison between nullable and regular value.

Template Parameters

T	Value type
B	Flag type
U	Type of value to compare with

Parameters

lhs	Nullable to compare
rhs	Value to compare with

Returns

true if nullable is non-null and values are equal

Postcondition

Returns false if lhs is null

Returns lhs.get() == rhs if lhs is non-null

Definition at line 1334 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

Equality comparison between nullable and nullval_t.

Template Parameters

T	Value type
B	Flag type

Parameters

lhs	Nullable to compare
dummy	nullval sentinel

Returns

true if nullable is null, false otherwise

Postcondition

Return value equals !lhs.has_value()

Definition at line 1321 of file nullable.hpp.

operator==() [20/25]

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

Compares two record_batch objects for equality.

Two record batches are considered equal if:

• They have the same number of columns
• Column names match in the same order
• Corresponding arrays are equal
• Record batch names match (both present and equal, or both absent)

Parameters

lhs	First record batch to compare
rhs	Second record batch to compare

Returns

true if the record batches are equal, false otherwise

Postcondition

Comparison is symmetric: lhs == rhs iff rhs == lhs

Comparison includes both structure and data equality

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

Equality comparison operator for union arrays.

Compares two union arrays element-wise, ensuring both type IDs and values match.

Template Parameters

D	Union array type

Parameters

lhs	First union array to compare
rhs	Second union array to compare

Returns

true if arrays are element-wise equal, false otherwise

Postcondition

Returns true iff arrays have same size and all elements compare equal

Comparison includes both type IDs and actual values

Definition at line 1169 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.

Template Parameters

A	The layout or array type.

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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/variable_size_binary_view_array.hpp.

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.

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/utils/nullable.hpp.

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

Swaps two nullable objects.

Template Parameters

T	Value type
B	Flag type

Parameters

lhs	First nullable to swap
rhs	Second nullable to swap

Postcondition

lhs contains rhs's previous value and flag

rhs contains lhs's previous value and flag

Definition at line 1315 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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/record_batch.hpp.

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 250 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 256 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 49 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

Sets null values in a range to a default value.

Template Parameters

R	Range type containing nullable values
T	Value type for the default

Parameters

range	Range of nullable objects to process
default_value	Value to assign to null elements

Precondition

R must be a range of nullable objects with value type T

Postcondition

All previously null elements in range now contain default_value

All previously null elements now have has_value() == true

Non-null elements remain unchanged

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/utils/nullable.hpp.

Definition at line 1368 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 213 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 97 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 109 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 201 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 207 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

Type trait to check if a type is a decimal array.

Template Parameters

T	The type to check.

Definition at line 142 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

Type trait to check if a type is a decimal instantiation.

Template Parameters

T	Type to check

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/utils/decimal.hpp.

Definition at line 245 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

Type trait to check if a type is a dense_union_array.

Template Parameters

T	Type to check

Definition at line 69 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.

Template Parameters

T	The type to check.

Definition at line 136 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 108 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 115 of file list_array.hpp.

is_int_placeholder_v

template<class T>

bool sparrow::is_int_placeholder_v = false

constexpr

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/layout/decimal_reference.hpp, and /home/runner/work/sparrow/sparrow/include/sparrow/utils/decimal.hpp.

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 97 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 91 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 103 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

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/map_array.hpp.

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 856 of file buffer.hpp.

is_null_array_v

template<class T>

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

constexpr

Type trait to check if a type is a null_array.

Template Parameters

T	Type to check

Definition at line 159 of file null_array.hpp.

is_nullable_v

template<class T>

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

inlineconstexpr

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/utils/nullable.hpp.

Definition at line 62 of file nullable.hpp.

is_nullable_variant_v

template<class T>

bool sparrow::is_nullable_variant_v = is_nullable_variant<T>::value

inlineconstexpr

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/utils/nullable.hpp.

Definition at line 1137 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

Type trait to check if a type is a sparse_union_array.

Template Parameters

T	Type to check

Definition at line 77 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 195 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

Type trait to check if a type is a struct_array.

Template Parameters

T	Type to check

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/struct_array.hpp.

Definition at line 73 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

Variable template for convenient access to is_timestamp_array.

Template Parameters

T	Type to check

Definition at line 87 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<class 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.

Examples

/home/runner/work/sparrow/sparrow/include/sparrow/variable_size_binary_view_array.hpp.

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 = 9

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 = 1

constexpr

Definition at line 19 of file sparrow_version.hpp.

SPARROW_VERSION_MINOR

int sparrow::SPARROW_VERSION_MINOR = 0

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.