标量#

struct Scalar : public std::enable_shared_from_this<Scalar>, public arrow::util::EqualityComparable<Scalar>#

标量值的基类。

Scalar（标量）表示具有特定 DataType（数据类型）的单个值。标量适用于将单个值输入传递给计算函数，或用于表示单个数组元素（尽管包装成本较高）。

派生类包括 arrow::BaseListScalar, arrow::ExtensionScalar, arrow::NullScalar, arrow::RunEndEncodedScalar, arrow::StructScalar, arrow::UnionScalar, arrow::internal::PrimitiveScalarBase

公共函数

Status Validate() const#

执行轻量级的验证检查。

复杂度为 O(k)，其中 k 是后代节点的数量。

返回：: Status（状态）

Status ValidateFull() const#

执行广泛的数据验证检查。

复杂度可能为 O(k*n)，其中 k 是后代节点的数量，n 是后代节点的长度（如果涉及列表标量）。

返回：: Status（状态）

Status Accept(ScalarVisitor *visitor) const#: 应用专门针对标量类型的 ScalarVisitor::Visit() 方法。

inline std::shared_ptr<Scalar> GetSharedPtr() const#: 实验性功能：允许从 const Scalar& 上下文中获取 shared_ptr<Scalar>。

公共成员

std::shared_ptr<DataType> type#: 标量值的类型。

bool is_valid = false#: 该值是否有效（非 null）。

struct Hash#

工厂函数#

std::shared_ptr<Scalar> MakeNullScalar(std::shared_ptr<DataType> type)#: 用于 null 标量的 Scalar 工厂。

template<typename Value> Result<std::shared_ptr<Scalar>> MakeScalar(std::shared_ptr<DataType> type, Value &&value)#: 用于非 null 标量的 Scalar 工厂。

template<typename Value, typename Traits = CTypeTraits<typename std::decay<Value>::type>, typename ScalarType = typename Traits::ScalarType, typename Enable = decltype(ScalarType(std::declval<Value>(), Traits::type_singleton()))> std::shared_ptr<Scalar> MakeScalar(Value value)#

用于非 null 标量的类型推断标量工厂。

根据输入的 C++ 类型构造一个 Scalar 实例，并确定其 DataType（例如 int8_t 输入对应 Int8Scalar）。仅支持非参数化的原生类型和 String。

inline std::shared_ptr<Scalar> MakeScalar(std::string value)#

inline std::shared_ptr<Scalar> MakeScalar(const std::shared_ptr<Scalar> &scalar)#

具体的标量派生类#

struct NullScalar : public arrow::Scalar #

#include <arrow/scalar.h>

NullType 的标量值。永远无效。

公共类型

using TypeClass = NullType #

公共函数

inline NullScalar()#

struct BooleanScalar : public arrow::internal::PrimitiveScalar<BooleanType, bool>#

#include <arrow/scalar.h>

公共类型

using Base = internal::PrimitiveScalar<BooleanType, bool>#

公共函数

inline explicit BooleanScalar(bool value)#

inline BooleanScalar()#

template<typename T> struct NumericScalar : public arrow::internal::PrimitiveScalar<T>#

#include <arrow/scalar.h>

公共类型

using Base = typename internal::PrimitiveScalar<T>#

using TypeClass = typename Base::TypeClass#

using ValueType = typename Base::ValueType#

公共函数

inline explicit NumericScalar(ValueType value)#

inline NumericScalar()#

struct Int8Scalar : public arrow::NumericScalar<Int8Type>#: #include <arrow/scalar.h>

struct Int16Scalar : public arrow::NumericScalar<Int16Type>#: #include <arrow/scalar.h>

struct Int32Scalar : public arrow::NumericScalar<Int32Type>#: #include <arrow/scalar.h>

struct Int64Scalar : public arrow::NumericScalar<Int64Type>#: #include <arrow/scalar.h>

struct UInt8Scalar : public arrow::NumericScalar<UInt8Type>#: #include <arrow/scalar.h>

struct UInt16Scalar : public arrow::NumericScalar<UInt16Type>#: #include <arrow/scalar.h>

struct UInt32Scalar : public arrow::NumericScalar<UInt32Type>#: #include <arrow/scalar.h>

struct UInt64Scalar : public arrow::NumericScalar<UInt64Type>#: #include <arrow/scalar.h>

struct HalfFloatScalar : public arrow::NumericScalar<HalfFloatType>#

#include <arrow/scalar.h>

公共函数

inline explicit HalfFloatScalar(util::Float16 value)#

inline HalfFloatScalar(util::Float16 value, std::shared_ptr<DataType> type)#

struct FloatScalar : public arrow::NumericScalar<FloatType>#: #include <arrow/scalar.h>

struct DoubleScalar : public arrow::NumericScalar<DoubleType>#: #include <arrow/scalar.h>

struct BaseBinaryScalar : public arrow::internal::PrimitiveScalarBase#

#include <arrow/scalar.h>

派生类包括 arrow::BinaryScalar, arrow::BinaryViewScalar, arrow::LargeBinaryScalar

公共类型

using ValueType = std::shared_ptr<Buffer>#

公共函数

inline const void *data() const override#

inline std::string_view view() const override#

inline explicit BaseBinaryScalar(std::shared_ptr<DataType> type)#

inline BaseBinaryScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)#

BaseBinaryScalar(std::string s, std::shared_ptr<DataType> type)#

公共成员

const std::shared_ptr<Buffer> value = NULLPTR#

struct BinaryScalar : public arrow::BaseBinaryScalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<BinaryScalar>#

#include <arrow/scalar.h>

派生类包括 arrow::FixedSizeBinaryScalar, arrow::StringScalar

公共类型

using TypeClass = BinaryType #

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<BinaryScalar>#

公共函数

inline explicit BinaryScalar(std::shared_ptr<DataType> type)#

inline BinaryScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)#

inline BinaryScalar(std::string s, std::shared_ptr<DataType> type)#

inline explicit BinaryScalar(std::shared_ptr<Buffer> value)#

inline explicit BinaryScalar(std::string s)#

inline BinaryScalar()#

struct StringScalar : public arrow::BinaryScalar #

#include <arrow/scalar.h>

公共类型

using TypeClass = StringType #

公共函数

inline explicit StringScalar(std::shared_ptr<Buffer> value)#

inline explicit StringScalar(std::string s)#

inline StringScalar()#

inline explicit BinaryScalar(std::shared_ptr<DataType> type)#

inline BinaryScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)#

inline BinaryScalar(std::string s, std::shared_ptr<DataType> type)#

inline explicit BinaryScalar(std::shared_ptr<Buffer> value)#

inline explicit BinaryScalar(std::string s)#

inline BinaryScalar()#

struct BinaryViewScalar : public arrow::BaseBinaryScalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<BinaryViewScalar>#

#include <arrow/scalar.h>

派生类包括 arrow::StringViewScalar

公共类型

using TypeClass = BinaryViewType #

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<BinaryViewScalar>#

公共函数

inline explicit BinaryViewScalar(std::shared_ptr<DataType> type)#

inline BinaryViewScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)#

inline BinaryViewScalar(std::string s, std::shared_ptr<DataType> type)#

inline explicit BinaryViewScalar(std::shared_ptr<Buffer> value)#

inline explicit BinaryViewScalar(std::string s)#

inline BinaryViewScalar()#

inline std::string_view view() const override#

struct StringViewScalar : public arrow::BinaryViewScalar #

#include <arrow/scalar.h>

公共类型

using TypeClass = StringViewType #

公共函数

inline explicit StringViewScalar(std::shared_ptr<Buffer> value)#

inline explicit StringViewScalar(std::string s)#

inline StringViewScalar()#

inline explicit BinaryViewScalar(std::shared_ptr<DataType> type)#

inline BinaryViewScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)#

inline BinaryViewScalar(std::string s, std::shared_ptr<DataType> type)#

inline explicit BinaryViewScalar(std::shared_ptr<Buffer> value)#

inline explicit BinaryViewScalar(std::string s)#

inline BinaryViewScalar()#

struct LargeBinaryScalar : public arrow::BaseBinaryScalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<LargeBinaryScalar>#

#include <arrow/scalar.h>

子类为 arrow::LargeStringScalar

公共类型

using TypeClass = LargeBinaryType #

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<LargeBinaryScalar>#

公共函数

inline explicit LargeBinaryScalar(std::shared_ptr<DataType> type)#

inline LargeBinaryScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)#

inline LargeBinaryScalar(std::string s, std::shared_ptr<DataType> type)#

inline explicit LargeBinaryScalar(std::shared_ptr<Buffer> value)#

inline explicit LargeBinaryScalar(std::string s)#

inline LargeBinaryScalar()#

struct LargeStringScalar : public arrow::LargeBinaryScalar #

#include <arrow/scalar.h>

公共类型

using TypeClass = LargeStringType #

公共函数

inline explicit LargeStringScalar(std::shared_ptr<Buffer> value)#

inline explicit LargeStringScalar(std::string s)#

inline LargeStringScalar()#

inline explicit LargeBinaryScalar(std::shared_ptr<DataType> type)#

inline LargeBinaryScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)#

inline LargeBinaryScalar(std::string s, std::shared_ptr<DataType> type)#

inline explicit LargeBinaryScalar(std::shared_ptr<Buffer> value)#

inline explicit LargeBinaryScalar(std::string s)#

inline LargeBinaryScalar()#

struct FixedSizeBinaryScalar : public arrow::BinaryScalar #

#include <arrow/scalar.h>

公共类型

using TypeClass = FixedSizeBinaryType #

公共函数

FixedSizeBinaryScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type, bool is_valid = true)#

explicit FixedSizeBinaryScalar(const std::shared_ptr<Buffer> &value, bool is_valid = true)#

explicit FixedSizeBinaryScalar(std::string s, bool is_valid = true)#

template<typename T> struct TemporalScalar : public arrow::internal::PrimitiveScalar<T>#

#include <arrow/scalar.h>

子类为 arrow::DateScalar< Date32Type >, arrow::DateScalar< Date64Type >, arrow::IntervalScalar< DayTimeIntervalType >, arrow::IntervalScalar< MonthDayNanoIntervalType >, arrow::IntervalScalar< MonthIntervalType >, arrow::TimeScalar< Time32Type >, arrow::TimeScalar< Time64Type >, arrow::DateScalar< T >, arrow::IntervalScalar< T >, arrow::TimeScalar< T >

公共类型

using ValueType = typename internal::PrimitiveScalar<T>::ValueType#

公共函数

inline TemporalScalar(ValueType value, std::shared_ptr<DataType> type)#

template<typename T> struct DateScalar : public arrow::TemporalScalar<T>#

#include <arrow/scalar.h>

公共类型

using ValueType = typename TemporalScalar<T>::ValueType#

公共函数

inline explicit DateScalar(ValueType value)#

inline DateScalar()#

struct Date32Scalar : public arrow::DateScalar<Date32Type>#: #include <arrow/scalar.h>

struct Date64Scalar : public arrow::DateScalar<Date64Type>#: #include <arrow/scalar.h>

template<typename T> struct TimeScalar : public arrow::TemporalScalar<T>#

#include <arrow/scalar.h>

公共函数

inline TimeScalar(typename TemporalScalar<T>::ValueType value, TimeUnit::type unit)#

struct Time32Scalar : public arrow::TimeScalar<Time32Type>#: #include <arrow/scalar.h>

struct Time64Scalar : public arrow::TimeScalar<Time64Type>#: #include <arrow/scalar.h>

struct TimestampScalar : public arrow::TemporalScalar<TimestampType>#

#include <arrow/scalar.h>

公共函数

inline TimestampScalar(typename TemporalScalar<TimestampType>::ValueType value, TimeUnit::type unit, std::string tz = "")#

公共静态函数

static Result<TimestampScalar> FromISO8601(std::string_view iso8601, TimeUnit::type unit)#

template<typename T> struct IntervalScalar : public arrow::TemporalScalar<T>#

#include <arrow/scalar.h>

公共类型

using ValueType = typename TemporalScalar<T>::ValueType#

公共函数

inline explicit IntervalScalar(ValueType value)#

inline IntervalScalar()#

struct MonthIntervalScalar : public arrow::IntervalScalar<MonthIntervalType>#: #include <arrow/scalar.h>

struct DayTimeIntervalScalar : public arrow::IntervalScalar<DayTimeIntervalType>#: #include <arrow/scalar.h>

struct MonthDayNanoIntervalScalar : public arrow::IntervalScalar<MonthDayNanoIntervalType>#: #include <arrow/scalar.h>

struct DurationScalar : public arrow::TemporalScalar<DurationType>#

#include <arrow/scalar.h>

公共函数

inline DurationScalar(typename TemporalScalar<DurationType>::ValueType value, TimeUnit::type unit)#

template<template<typename, typename> class StdDuration, typename Rep> inline explicit DurationScalar(StdDuration<Rep, std::nano> d)#

template<template<typename, typename> class StdDuration, typename Rep> inline explicit DurationScalar(StdDuration<Rep, std::micro> d)#

template<template<typename, typename> class StdDuration, typename Rep> inline explicit DurationScalar(StdDuration<Rep, std::milli> d)#

template<template<typename, typename> class StdDuration, typename Rep, intmax_t Num> inline explicit DurationScalar(StdDuration<Rep, std::ratio<Num, 1>> d)#

template<typename TYPE_CLASS, typename VALUE_TYPE> struct DecimalScalar : public arrow::internal::PrimitiveScalarBase#

#include <arrow/scalar.h>

公共类型

using TypeClass = TYPE_CLASS #

using ValueType = VALUE_TYPE #

公共函数

inline DecimalScalar(ValueType value, std::shared_ptr<DataType> type)#

inline const void *data() const override#

inline std::string_view view() const override#

公共成员

ValueType value#

struct Decimal32Scalar : public arrow::DecimalScalar<Decimal32Type, Decimal32>#

#include <arrow/scalar.h>

公共函数

inline DecimalScalar(ValueType value, std::shared_ptr<DataType> type)#

struct Decimal64Scalar : public arrow::DecimalScalar<Decimal64Type, Decimal64>#

#include <arrow/scalar.h>

公共函数

inline DecimalScalar(ValueType value, std::shared_ptr<DataType> type)#

struct Decimal128Scalar : public arrow::DecimalScalar<Decimal128Type, Decimal128>#

#include <arrow/scalar.h>

公共函数

inline DecimalScalar(ValueType value, std::shared_ptr<DataType> type)#

struct Decimal256Scalar : public arrow::DecimalScalar<Decimal256Type, Decimal256>#

#include <arrow/scalar.h>

公共函数

inline DecimalScalar(ValueType value, std::shared_ptr<DataType> type)#

struct BaseListScalar : public arrow::Scalar #

#include <arrow/scalar.h>

子类化由以下类实现: arrow::FixedSizeListScalar, arrow::LargeListScalar, arrow::LargeListViewScalar, arrow::ListScalar, arrow::ListViewScalar, arrow::MapScalar

公共类型

using ValueType = std::shared_ptr<Array>#

公共函数

BaseListScalar(std::shared_ptr<Array> value, std::shared_ptr<DataType> type, bool is_valid = true)#

公共成员

const std::shared_ptr<Array> value#

struct ListScalar : public arrow::BaseListScalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<ListScalar>#

#include <arrow/scalar.h>

公共类型

using TypeClass = ListType #

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<ListScalar>#

公共函数

inline ListScalar(std::shared_ptr<Array> value, std::shared_ptr<DataType> type, bool is_valid = true)#

explicit ListScalar(std::shared_ptr<Array> value, bool is_valid = true)#

struct LargeListScalar : public arrow::BaseListScalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<LargeListScalar>#

#include <arrow/scalar.h>

公共类型

using TypeClass = LargeListType #

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<LargeListScalar>#

公共函数

inline LargeListScalar(std::shared_ptr<Array> value, std::shared_ptr<DataType> type, bool is_valid = true)#

explicit LargeListScalar(std::shared_ptr<Array> value, bool is_valid = true)#

struct ListViewScalar : public arrow::BaseListScalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<ListViewScalar>#

#include <arrow/scalar.h>

公共类型

using TypeClass = ListViewType #

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<ListViewScalar>#

公共函数

inline ListViewScalar(std::shared_ptr<Array> value, std::shared_ptr<DataType> type, bool is_valid = true)#

explicit ListViewScalar(std::shared_ptr<Array> value, bool is_valid = true)#

struct LargeListViewScalar : public arrow::BaseListScalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<LargeListViewScalar>#

#include <arrow/scalar.h>

公共类型

using TypeClass = LargeListViewType #

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<LargeListViewScalar>#

公共函数

inline LargeListViewScalar(std::shared_ptr<Array> value, std::shared_ptr<DataType> type, bool is_valid = true)#

explicit LargeListViewScalar(std::shared_ptr<Array> value, bool is_valid = true)#

struct MapScalar : public arrow::BaseListScalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<MapScalar>#

#include <arrow/scalar.h>

公共类型

using TypeClass = MapType #

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<MapScalar>#

公共函数

inline MapScalar(std::shared_ptr<Array> value, std::shared_ptr<DataType> type, bool is_valid = true)#

explicit MapScalar(std::shared_ptr<Array> value, bool is_valid = true)#

struct FixedSizeListScalar : public arrow::BaseListScalar #

#include <arrow/scalar.h>

公共类型

using TypeClass = FixedSizeListType #

公共函数

FixedSizeListScalar(std::shared_ptr<Array> value, std::shared_ptr<DataType> type, bool is_valid = true)#

explicit FixedSizeListScalar(std::shared_ptr<Array> value, bool is_valid = true)#

struct StructScalar : public arrow::Scalar #

#include <arrow/scalar.h>

公共类型

using TypeClass = StructType #

using ValueType = std::vector<std::shared_ptr<Scalar>>#

公共函数

Result<std::shared_ptr<Scalar>> field(FieldRef ref) const#

inline StructScalar(ValueType value, std::shared_ptr<DataType> type, bool is_valid = true)#

公共成员

ScalarVector value#

公共静态函数

static Result<std::shared_ptr<StructScalar>> Make(ValueType value, std::vector<std::string> field_names)#

struct UnionScalar : public arrow::Scalar #

#include <arrow/scalar.h>

子类化由以下类实现: arrow::DenseUnionScalar, arrow::SparseUnionScalar

公共函数

virtual const std::shared_ptr<Scalar> &child_value() const = 0#

公共成员

const int8_t type_code#

struct SparseUnionScalar : public arrow::UnionScalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<SparseUnionScalar>#

#include <arrow/scalar.h>

公共类型

using TypeClass = SparseUnionType #

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<SparseUnionScalar>#

using ValueType = std::vector<std::shared_ptr<Scalar>>#

公共函数

SparseUnionScalar(ValueType value, int8_t type_code, std::shared_ptr<DataType> type)#

inline virtual const std::shared_ptr<Scalar> &child_value() const override#

公共成员

const ValueType value#

int child_id#

公共静态函数

static std::shared_ptr<Scalar> FromValue(std::shared_ptr<Scalar> value, int field_index, std::shared_ptr<DataType> type)#: 通过单个值构造 SparseUnionScalar，而无需构造标量向量。

struct DenseUnionScalar : public arrow::UnionScalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<DenseUnionScalar>#

#include <arrow/scalar.h>

公共类型

using TypeClass = DenseUnionType #

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<DenseUnionScalar>#

using ValueType = std::shared_ptr<Scalar>#

公共函数

inline virtual const std::shared_ptr<Scalar> &child_value() const override#

inline DenseUnionScalar(ValueType value, int8_t type_code, std::shared_ptr<DataType> type)#

公共成员

const ValueType value#

struct RunEndEncodedScalar : public arrow::Scalar, private arrow::internal::ArraySpanFillFromScalarScratchSpace<RunEndEncodedScalar>#

#include <arrow/scalar.h>

公共类型

using TypeClass = RunEndEncodedType #

using ValueType = std::shared_ptr<Scalar>#

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<RunEndEncodedScalar>#

公共函数

RunEndEncodedScalar(std::shared_ptr<Scalar> value, std::shared_ptr<DataType> type)#

explicit RunEndEncodedScalar(const std::shared_ptr<DataType> &type)#: 构建一个 NULL RunEndEncodedScalar。

~RunEndEncodedScalar() override#

inline const std::shared_ptr<DataType> &run_end_type() const#

inline const std::shared_ptr<DataType> &value_type() const#

公共成员

const ValueType value#

struct DictionaryScalar : public arrow::internal::PrimitiveScalarBase#

#include <arrow/scalar.h>

Scalar 类型的 DictionaryType 值。

is_valid 表示 index 的有效性，与 dictionary 中的对应值无关。

公共类型

using TypeClass = DictionaryType #

公共函数

explicit DictionaryScalar(std::shared_ptr<DataType> type)#

inline DictionaryScalar(ValueType value, std::shared_ptr<DataType> type, bool is_valid = true)#

Result<std::shared_ptr<Scalar>> GetEncodedValue() const#

inline const void *data() const override#

inline std::string_view view() const override#

公共成员

struct arrow::DictionaryScalar::ValueType value#

公共静态函数

static std::shared_ptr<DictionaryScalar> Make(std::shared_ptr<Scalar> index, std::shared_ptr<Array> dict)#

struct ValueType#

#include <arrow/scalar.h>

公共成员

std::shared_ptr<Scalar> index#

std::shared_ptr<Array> dictionary#

struct ExtensionScalar : public arrow::Scalar #

#include <arrow/scalar.h>

Scalar 类型的 ExtensionType 值。

该值是底层的存储标量。只有当 value 非空且 value->is_valid 为 true 时，is_valid 才必须为 true。

公共类型

using TypeClass = ExtensionType #

using ValueType = std::shared_ptr<Scalar>#

公共函数

inline ExtensionScalar(std::shared_ptr<Scalar> storage, std::shared_ptr<DataType> type, bool is_valid = true)#

template<typename Storage, typename = enable_if_t<std::is_base_of<Scalar, Storage>::value>> inline ExtensionScalar(Storage &&storage, std::shared_ptr<DataType> type, bool is_valid = true)#

公共成员

std::shared_ptr<Scalar> value#

工具#

class ScalarVisitor#

抽象标量访问者类。

通过子类化此类来创建一个可用于 Scalar::Accept() 方法的访问者。

公共函数

virtual ~ScalarVisitor() = default#

virtual Status Visit(const NullScalar &scalar)#

virtual Status Visit(const BooleanScalar &scalar)#

virtual Status Visit(const Int8Scalar &scalar)#

virtual Status Visit(const Int16Scalar &scalar)#

virtual Status Visit(const Int32Scalar &scalar)#

virtual Status Visit(const Int64Scalar &scalar)#

virtual Status Visit(const UInt8Scalar &scalar)#

virtual Status Visit(const UInt16Scalar &scalar)#

virtual Status Visit(const UInt32Scalar &scalar)#

virtual Status Visit(const UInt64Scalar &scalar)#

virtual Status Visit(const HalfFloatScalar &scalar)#

virtual Status Visit(const FloatScalar &scalar)#

virtual Status Visit(const DoubleScalar &scalar)#

virtual Status Visit(const StringScalar &scalar)#

virtual Status Visit(const StringViewScalar &scalar)#

virtual Status Visit(const BinaryScalar &scalar)#

virtual Status Visit(const BinaryViewScalar &scalar)#

virtual Status Visit(const LargeStringScalar &scalar)#

virtual Status Visit(const LargeBinaryScalar &scalar)#

virtual Status Visit(const FixedSizeBinaryScalar &scalar)#

virtual Status Visit(const Date64Scalar &scalar)#

virtual Status Visit(const Date32Scalar &scalar)#

virtual Status Visit(const Time32Scalar &scalar)#

virtual Status Visit(const Time64Scalar &scalar)#

virtual Status Visit(const TimestampScalar &scalar)#

virtual Status Visit(const DayTimeIntervalScalar &scalar)#

virtual Status Visit(const MonthDayNanoIntervalScalar &type)#

virtual Status Visit(const MonthIntervalScalar &scalar)#

virtual Status Visit(const DurationScalar &scalar)#

virtual Status Visit(const Decimal32Scalar &scalar)#

virtual Status Visit(const Decimal64Scalar &scalar)#

virtual Status Visit(const Decimal128Scalar &scalar)#

virtual Status Visit(const Decimal256Scalar &scalar)#

virtual Status Visit(const ListScalar &scalar)#

virtual Status Visit(const LargeListScalar &scalar)#

virtual Status Visit(const ListViewScalar &scalar)#

virtual Status Visit(const LargeListViewScalar &scalar)#

virtual Status Visit(const MapScalar &scalar)#

virtual Status Visit(const FixedSizeListScalar &scalar)#

virtual Status Visit(const StructScalar &scalar)#

virtual Status Visit(const DictionaryScalar &scalar)#

virtual Status Visit(const SparseUnionScalar &scalar)#

virtual Status Visit(const DenseUnionScalar &scalar)#

virtual Status Visit(const RunEndEncodedScalar &scalar)#

virtual Status Visit(const ExtensionScalar &scalar)#