Scalars#

structScalar:publicstd::enable_shared_from_this<Scalar>,publicarrow::util::EqualityComparable<Scalar>#

Base class for scalar values.

AScalar represents a single value with a specificDataType. Scalars are useful for passing single value inputs to compute functions, or for representing individual array elements (with a non-trivial wrapping cost, though).

Subclassed byarrow::BaseListScalar,arrow::ExtensionScalar,arrow::NullScalar,arrow::RunEndEncodedScalar,arrow::StructScalar,arrow::UnionScalar, arrow::internal::PrimitiveScalarBase

Public Functions

StatusValidate()const#

Perform cheap validation checks.

This is O(k) where k is the number of descendents.

Returns:

Status

StatusValidateFull()const#

Perform extensive data validation checks.

This is potentially O(k*n) where k is the number of descendents and n is the length of descendents (if list scalars are involved).

Returns:

Status

StatusAccept(ScalarVisitor*visitor)const#

Apply theScalarVisitor::Visit() method specialized to the scalar type.

inlinestd::shared_ptr<Scalar>GetSharedPtr()const#

EXPERIMENTAL Enable obtaining shared_ptr<Scalar> from a constScalar& context.

Public Members

std::shared_ptr<DataType>type#

The type of the scalar value.

boolis_valid=false#

Whether the value is valid (not null) or not.

structHash#

Factory functions#

std::shared_ptr<Scalar>MakeNullScalar(std::shared_ptr<DataType>type)#

Scalar factory for null scalars.

template<typenameValue>
Result<std::shared_ptr<Scalar>>MakeScalar(std::shared_ptr<DataType>type,Value&&value)#

Scalar factory for non-null scalars.

template<typenameValue,typenameTraits=CTypeTraits<typenamestd::decay<Value>::type>,typenameScalarType=typenameTraits::ScalarType,typenameEnable=decltype(ScalarType(std::declval<Value>(),Traits::type_singleton()))>
std::shared_ptr<Scalar>MakeScalar(Valuevalue)#

Type-inferring scalar factory for non-null scalars.

Construct aScalar instance with aDataType determined by the input C++ type. (for exampleInt8Scalar for a int8_t input). Only non-parametric primitive types and String are supported.

inlinestd::shared_ptr<Scalar>MakeScalar(std::stringvalue)#
inlinestd::shared_ptr<Scalar>MakeScalar(conststd::shared_ptr<Scalar>&scalar)#

Concrete scalar subclasses#

structNullScalar:publicarrow::Scalar#
#include <arrow/scalar.h>

A scalar value forNullType. Never valid.

Public Types

usingTypeClass=NullType#

Public Functions

inlineNullScalar()#
structBooleanScalar:publicarrow::internal::PrimitiveScalar<BooleanType,bool>#
#include <arrow/scalar.h>

Public Types

usingBase=internal::PrimitiveScalar<BooleanType,bool>#

Public Functions

inlineexplicitBooleanScalar(boolvalue)#
inlineBooleanScalar()#
template<typenameT>
structNumericScalar:publicarrow::internal::PrimitiveScalar<T>#
#include <arrow/scalar.h>

Public Types

usingBase=typenameinternal::PrimitiveScalar<T>#
usingTypeClass=typenameBase::TypeClass#
usingValueType=typenameBase::ValueType#

Public Functions

inlineexplicitNumericScalar(ValueTypevalue)#
inlineNumericScalar()#
structInt8Scalar:publicarrow::NumericScalar<Int8Type>#
#include <arrow/scalar.h>
structInt16Scalar:publicarrow::NumericScalar<Int16Type>#
#include <arrow/scalar.h>
structInt32Scalar:publicarrow::NumericScalar<Int32Type>#
#include <arrow/scalar.h>
structInt64Scalar:publicarrow::NumericScalar<Int64Type>#
#include <arrow/scalar.h>
structUInt8Scalar:publicarrow::NumericScalar<UInt8Type>#
#include <arrow/scalar.h>
structUInt16Scalar:publicarrow::NumericScalar<UInt16Type>#
#include <arrow/scalar.h>
structUInt32Scalar:publicarrow::NumericScalar<UInt32Type>#
#include <arrow/scalar.h>
structUInt64Scalar:publicarrow::NumericScalar<UInt64Type>#
#include <arrow/scalar.h>
structHalfFloatScalar:publicarrow::NumericScalar<HalfFloatType>#
#include <arrow/scalar.h>

Public Functions

inlineexplicitHalfFloatScalar(util::Float16value)#
inlineHalfFloatScalar(util::Float16value,std::shared_ptr<DataType>type)#
structFloatScalar:publicarrow::NumericScalar<FloatType>#
#include <arrow/scalar.h>
structDoubleScalar:publicarrow::NumericScalar<DoubleType>#
#include <arrow/scalar.h>
structBaseBinaryScalar:publicarrow::internal::PrimitiveScalarBase#
#include <arrow/scalar.h>

Subclassed byarrow::BinaryScalar,arrow::BinaryViewScalar,arrow::LargeBinaryScalar

Public Types

usingValueType=std::shared_ptr<Buffer>#

Public Functions

inlineconstvoid*data()constoverride#
inlinestd::string_viewview()constoverride#
inlineexplicitBaseBinaryScalar(std::shared_ptr<DataType>type)#
inlineBaseBinaryScalar(std::shared_ptr<Buffer>value,std::shared_ptr<DataType>type)#
BaseBinaryScalar(std::strings,std::shared_ptr<DataType>type)#

Public Members

conststd::shared_ptr<Buffer>value=NULLPTR#
structBinaryScalar:publicarrow::BaseBinaryScalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<BinaryScalar>#
#include <arrow/scalar.h>

Subclassed byarrow::FixedSizeBinaryScalar,arrow::StringScalar

Public Types

usingTypeClass=BinaryType#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<BinaryScalar>#

Public Functions

inlineexplicitBinaryScalar(std::shared_ptr<DataType>type)#
inlineBinaryScalar(std::shared_ptr<Buffer>value,std::shared_ptr<DataType>type)#
inlineBinaryScalar(std::strings,std::shared_ptr<DataType>type)#
inlineexplicitBinaryScalar(std::shared_ptr<Buffer>value)#
inlineexplicitBinaryScalar(std::strings)#
inlineBinaryScalar()#
structStringScalar:publicarrow::BinaryScalar#
#include <arrow/scalar.h>

Public Types

usingTypeClass=StringType#

Public Functions

inlineexplicitStringScalar(std::shared_ptr<Buffer>value)#
inlineexplicitStringScalar(std::strings)#
inlineStringScalar()#
inlineexplicitBinaryScalar(std::shared_ptr<DataType>type)#
inlineBinaryScalar(std::shared_ptr<Buffer>value,std::shared_ptr<DataType>type)#
inlineBinaryScalar(std::strings,std::shared_ptr<DataType>type)#
inlineexplicitBinaryScalar(std::shared_ptr<Buffer>value)#
inlineexplicitBinaryScalar(std::strings)#
inlineBinaryScalar()#
structBinaryViewScalar:publicarrow::BaseBinaryScalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<BinaryViewScalar>#
#include <arrow/scalar.h>

Subclassed byarrow::StringViewScalar

Public Types

usingTypeClass=BinaryViewType#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<BinaryViewScalar>#

Public Functions

inlineexplicitBinaryViewScalar(std::shared_ptr<DataType>type)#
inlineBinaryViewScalar(std::shared_ptr<Buffer>value,std::shared_ptr<DataType>type)#
inlineBinaryViewScalar(std::strings,std::shared_ptr<DataType>type)#
inlineexplicitBinaryViewScalar(std::shared_ptr<Buffer>value)#
inlineexplicitBinaryViewScalar(std::strings)#
inlineBinaryViewScalar()#
inlinestd::string_viewview()constoverride#
structStringViewScalar:publicarrow::BinaryViewScalar#
#include <arrow/scalar.h>

Public Types

usingTypeClass=StringViewType#

Public Functions

inlineexplicitStringViewScalar(std::shared_ptr<Buffer>value)#
inlineexplicitStringViewScalar(std::strings)#
inlineStringViewScalar()#
inlineexplicitBinaryViewScalar(std::shared_ptr<DataType>type)#
inlineBinaryViewScalar(std::shared_ptr<Buffer>value,std::shared_ptr<DataType>type)#
inlineBinaryViewScalar(std::strings,std::shared_ptr<DataType>type)#
inlineexplicitBinaryViewScalar(std::shared_ptr<Buffer>value)#
inlineexplicitBinaryViewScalar(std::strings)#
inlineBinaryViewScalar()#
structLargeBinaryScalar:publicarrow::BaseBinaryScalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<LargeBinaryScalar>#
#include <arrow/scalar.h>

Subclassed byarrow::LargeStringScalar

Public Types

usingTypeClass=LargeBinaryType#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<LargeBinaryScalar>#

Public Functions

inlineexplicitLargeBinaryScalar(std::shared_ptr<DataType>type)#
inlineLargeBinaryScalar(std::shared_ptr<Buffer>value,std::shared_ptr<DataType>type)#
inlineLargeBinaryScalar(std::strings,std::shared_ptr<DataType>type)#
inlineexplicitLargeBinaryScalar(std::shared_ptr<Buffer>value)#
inlineexplicitLargeBinaryScalar(std::strings)#
inlineLargeBinaryScalar()#
structLargeStringScalar:publicarrow::LargeBinaryScalar#
#include <arrow/scalar.h>

Public Types

usingTypeClass=LargeStringType#

Public Functions

inlineexplicitLargeStringScalar(std::shared_ptr<Buffer>value)#
inlineexplicitLargeStringScalar(std::strings)#
inlineLargeStringScalar()#
inlineexplicitLargeBinaryScalar(std::shared_ptr<DataType>type)#
inlineLargeBinaryScalar(std::shared_ptr<Buffer>value,std::shared_ptr<DataType>type)#
inlineLargeBinaryScalar(std::strings,std::shared_ptr<DataType>type)#
inlineexplicitLargeBinaryScalar(std::shared_ptr<Buffer>value)#
inlineexplicitLargeBinaryScalar(std::strings)#
inlineLargeBinaryScalar()#
structFixedSizeBinaryScalar:publicarrow::BinaryScalar#
#include <arrow/scalar.h>

Public Types

usingTypeClass=FixedSizeBinaryType#

Public Functions

FixedSizeBinaryScalar(std::shared_ptr<Buffer>value,std::shared_ptr<DataType>type,boolis_valid=true)#
explicitFixedSizeBinaryScalar(conststd::shared_ptr<Buffer>&value,boolis_valid=true)#
explicitFixedSizeBinaryScalar(std::strings,boolis_valid=true)#
template<typenameT>
structTemporalScalar:publicarrow::internal::PrimitiveScalar<T>#
#include <arrow/scalar.h>

Subclassed byarrow::DateScalar< T >,arrow::IntervalScalar< T >,arrow::TimeScalar< T >

Public Types

usingValueType=typenameinternal::PrimitiveScalar<T>::ValueType#

Public Functions

inlineTemporalScalar(ValueTypevalue,std::shared_ptr<DataType>type)#
template<typenameT>
structDateScalar:publicarrow::TemporalScalar<T>#
#include <arrow/scalar.h>

Public Types

usingValueType=typenameTemporalScalar<T>::ValueType#

Public Functions

inlineexplicitDateScalar(ValueTypevalue)#
inlineDateScalar()#
structDate32Scalar:publicarrow::DateScalar<Date32Type>#
#include <arrow/scalar.h>
structDate64Scalar:publicarrow::DateScalar<Date64Type>#
#include <arrow/scalar.h>
template<typenameT>
structTimeScalar:publicarrow::TemporalScalar<T>#
#include <arrow/scalar.h>

Public Functions

inlineTimeScalar(typenameTemporalScalar<T>::ValueTypevalue,TimeUnit::typeunit)#
structTime32Scalar:publicarrow::TimeScalar<Time32Type>#
#include <arrow/scalar.h>
structTime64Scalar:publicarrow::TimeScalar<Time64Type>#
#include <arrow/scalar.h>
structTimestampScalar:publicarrow::TemporalScalar<TimestampType>#
#include <arrow/scalar.h>

Public Functions

inlineTimestampScalar(typenameTemporalScalar<TimestampType>::ValueTypevalue,TimeUnit::typeunit,std::stringtz="")#

Public Static Functions

staticResult<TimestampScalar>FromISO8601(std::string_viewiso8601,TimeUnit::typeunit)#
template<typenameT>
structIntervalScalar:publicarrow::TemporalScalar<T>#
#include <arrow/scalar.h>

Public Types

usingValueType=typenameTemporalScalar<T>::ValueType#

Public Functions

inlineexplicitIntervalScalar(ValueTypevalue)#
inlineIntervalScalar()#
structMonthIntervalScalar:publicarrow::IntervalScalar<MonthIntervalType>#
#include <arrow/scalar.h>
structDayTimeIntervalScalar:publicarrow::IntervalScalar<DayTimeIntervalType>#
#include <arrow/scalar.h>
structMonthDayNanoIntervalScalar:publicarrow::IntervalScalar<MonthDayNanoIntervalType>#
#include <arrow/scalar.h>
structDurationScalar:publicarrow::TemporalScalar<DurationType>#
#include <arrow/scalar.h>

Public Functions

inlineDurationScalar(typenameTemporalScalar<DurationType>::ValueTypevalue,TimeUnit::typeunit)#
template<template<typename,typename>classStdDuration,typenameRep>
inlineexplicitDurationScalar(StdDuration<Rep,std::nano>d)#
template<template<typename,typename>classStdDuration,typenameRep>
inlineexplicitDurationScalar(StdDuration<Rep,std::micro>d)#
template<template<typename,typename>classStdDuration,typenameRep>
inlineexplicitDurationScalar(StdDuration<Rep,std::milli>d)#
template<template<typename,typename>classStdDuration,typenameRep,intmax_tNum>
inlineexplicitDurationScalar(StdDuration<Rep,std::ratio<Num,1>>d)#
template<typenameTYPE_CLASS,typenameVALUE_TYPE>
structDecimalScalar:publicarrow::internal::PrimitiveScalarBase#
#include <arrow/scalar.h>

Public Types

usingTypeClass=TYPE_CLASS#
usingValueType=VALUE_TYPE#

Public Functions

inlineDecimalScalar(ValueTypevalue,std::shared_ptr<DataType>type)#
inlineconstvoid*data()constoverride#
inlinestd::string_viewview()constoverride#

Public Members

ValueTypevalue#
structDecimal32Scalar:publicarrow::DecimalScalar<Decimal32Type,Decimal32>#
#include <arrow/scalar.h>

Public Functions

inlineDecimalScalar(ValueTypevalue,std::shared_ptr<DataType>type)#
structDecimal64Scalar:publicarrow::DecimalScalar<Decimal64Type,Decimal64>#
#include <arrow/scalar.h>

Public Functions

inlineDecimalScalar(ValueTypevalue,std::shared_ptr<DataType>type)#
structDecimal128Scalar:publicarrow::DecimalScalar<Decimal128Type,Decimal128>#
#include <arrow/scalar.h>

Public Functions

inlineDecimalScalar(ValueTypevalue,std::shared_ptr<DataType>type)#
structDecimal256Scalar:publicarrow::DecimalScalar<Decimal256Type,Decimal256>#
#include <arrow/scalar.h>

Public Functions

inlineDecimalScalar(ValueTypevalue,std::shared_ptr<DataType>type)#
structBaseListScalar:publicarrow::Scalar#
#include <arrow/scalar.h>

Subclassed byarrow::FixedSizeListScalar,arrow::LargeListScalar,arrow::LargeListViewScalar,arrow::ListScalar,arrow::ListViewScalar,arrow::MapScalar

Public Types

usingValueType=std::shared_ptr<Array>#

Public Functions

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

Public Members

conststd::shared_ptr<Array>value#
structListScalar:publicarrow::BaseListScalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<ListScalar>#
#include <arrow/scalar.h>

Public Types

usingTypeClass=ListType#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<ListScalar>#

Public Functions

inlineListScalar(std::shared_ptr<Array>value,std::shared_ptr<DataType>type,boolis_valid=true)#
explicitListScalar(std::shared_ptr<Array>value,boolis_valid=true)#
structLargeListScalar:publicarrow::BaseListScalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<LargeListScalar>#
#include <arrow/scalar.h>

Public Types

usingTypeClass=LargeListType#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<LargeListScalar>#

Public Functions

inlineLargeListScalar(std::shared_ptr<Array>value,std::shared_ptr<DataType>type,boolis_valid=true)#
explicitLargeListScalar(std::shared_ptr<Array>value,boolis_valid=true)#
structListViewScalar:publicarrow::BaseListScalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<ListViewScalar>#
#include <arrow/scalar.h>

Public Types

usingTypeClass=ListViewType#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<ListViewScalar>#

Public Functions

inlineListViewScalar(std::shared_ptr<Array>value,std::shared_ptr<DataType>type,boolis_valid=true)#
explicitListViewScalar(std::shared_ptr<Array>value,boolis_valid=true)#
structLargeListViewScalar:publicarrow::BaseListScalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<LargeListViewScalar>#
#include <arrow/scalar.h>

Public Types

usingTypeClass=LargeListViewType#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<LargeListViewScalar>#

Public Functions

inlineLargeListViewScalar(std::shared_ptr<Array>value,std::shared_ptr<DataType>type,boolis_valid=true)#
explicitLargeListViewScalar(std::shared_ptr<Array>value,boolis_valid=true)#
structMapScalar:publicarrow::BaseListScalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<MapScalar>#
#include <arrow/scalar.h>

Public Types

usingTypeClass=MapType#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<MapScalar>#

Public Functions

inlineMapScalar(std::shared_ptr<Array>value,std::shared_ptr<DataType>type,boolis_valid=true)#
explicitMapScalar(std::shared_ptr<Array>value,boolis_valid=true)#
structFixedSizeListScalar:publicarrow::BaseListScalar#
#include <arrow/scalar.h>

Public Types

usingTypeClass=FixedSizeListType#

Public Functions

FixedSizeListScalar(std::shared_ptr<Array>value,std::shared_ptr<DataType>type,boolis_valid=true)#
explicitFixedSizeListScalar(std::shared_ptr<Array>value,boolis_valid=true)#
structStructScalar:publicarrow::Scalar#
#include <arrow/scalar.h>

Public Types

usingTypeClass=StructType#
usingValueType=std::vector<std::shared_ptr<Scalar>>#

Public Functions

Result<std::shared_ptr<Scalar>>field(FieldRefref)const#
inlineStructScalar(ValueTypevalue,std::shared_ptr<DataType>type,boolis_valid=true)#

Public Members

ScalarVectorvalue#

Public Static Functions

staticResult<std::shared_ptr<StructScalar>>Make(ValueTypevalue,std::vector<std::string>field_names)#
structUnionScalar:publicarrow::Scalar#
#include <arrow/scalar.h>

Subclassed byarrow::DenseUnionScalar,arrow::SparseUnionScalar

Public Functions

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

Public Members

constint8_ttype_code#
structSparseUnionScalar:publicarrow::UnionScalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<SparseUnionScalar>#
#include <arrow/scalar.h>

Public Types

usingTypeClass=SparseUnionType#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<SparseUnionScalar>#
usingValueType=std::vector<std::shared_ptr<Scalar>>#

Public Functions

SparseUnionScalar(ValueTypevalue,int8_ttype_code,std::shared_ptr<DataType>type)#
inlinevirtualconststd::shared_ptr<Scalar>&child_value()constoverride#

Public Members

constValueTypevalue#
intchild_id#

Public Static Functions

staticstd::shared_ptr<Scalar>FromValue(std::shared_ptr<Scalar>value,intfield_index,std::shared_ptr<DataType>type)#

Construct aSparseUnionScalar from a single value, versus having to construct a vector of scalars.

structDenseUnionScalar:publicarrow::UnionScalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<DenseUnionScalar>#
#include <arrow/scalar.h>

Public Types

usingTypeClass=DenseUnionType#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<DenseUnionScalar>#
usingValueType=std::shared_ptr<Scalar>#

Public Functions

inlinevirtualconststd::shared_ptr<Scalar>&child_value()constoverride#
inlineDenseUnionScalar(ValueTypevalue,int8_ttype_code,std::shared_ptr<DataType>type)#

Public Members

constValueTypevalue#
structRunEndEncodedScalar:publicarrow::Scalar,privatearrow::internal::ArraySpanFillFromScalarScratchSpace<RunEndEncodedScalar>#
#include <arrow/scalar.h>

Public Types

usingTypeClass=RunEndEncodedType#
usingValueType=std::shared_ptr<Scalar>#
usingArraySpanFillFromScalarScratchSpace=internal::ArraySpanFillFromScalarScratchSpace<RunEndEncodedScalar>#

Public Functions

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

Constructs a NULLRunEndEncodedScalar.

~RunEndEncodedScalar()override#
inlineconststd::shared_ptr<DataType>&run_end_type()const#
inlineconststd::shared_ptr<DataType>&value_type()const#

Public Members

constValueTypevalue#
structDictionaryScalar:publicarrow::internal::PrimitiveScalarBase#
#include <arrow/scalar.h>

AScalar value forDictionaryType.

is_valid denotes the validity of theindex, regardless of the corresponding value in thedictionary.

Public Types

usingTypeClass=DictionaryType#

Public Functions

explicitDictionaryScalar(std::shared_ptr<DataType>type)#
inlineDictionaryScalar(ValueTypevalue,std::shared_ptr<DataType>type,boolis_valid=true)#
Result<std::shared_ptr<Scalar>>GetEncodedValue()const#
inlineconstvoid*data()constoverride#
inlinestd::string_viewview()constoverride#

Public Members

structarrow::DictionaryScalar::ValueTypevalue#

Public Static Functions

staticstd::shared_ptr<DictionaryScalar>Make(std::shared_ptr<Scalar>index,std::shared_ptr<Array>dict)#
structValueType#
#include <arrow/scalar.h>

Public Members

std::shared_ptr<Scalar>index#
std::shared_ptr<Array>dictionary#
structExtensionScalar:publicarrow::Scalar#
#include <arrow/scalar.h>

AScalar value forExtensionType.

The value is the underlying storage scalar.is_valid must only be true ifvalue is non-null andvalue->is_valid is true

Public Types

usingTypeClass=ExtensionType#
usingValueType=std::shared_ptr<Scalar>#

Public Functions

inlineExtensionScalar(std::shared_ptr<Scalar>storage,std::shared_ptr<DataType>type,boolis_valid=true)#
template<typenameStorage,typename=enable_if_t<std::is_base_of<Scalar,Storage>::value>>
inlineExtensionScalar(Storage&&storage,std::shared_ptr<DataType>type,boolis_valid=true)#

Public Members

std::shared_ptr<Scalar>value#

Utilities#

classScalarVisitor#

Abstract scalar visitor class.

Subclass this to create a visitor that can be used with theScalar::Accept() method.

Public Functions

virtual~ScalarVisitor()=default#
virtualStatusVisit(constNullScalar&scalar)#
virtualStatusVisit(constBooleanScalar&scalar)#
virtualStatusVisit(constInt8Scalar&scalar)#
virtualStatusVisit(constInt16Scalar&scalar)#
virtualStatusVisit(constInt32Scalar&scalar)#
virtualStatusVisit(constInt64Scalar&scalar)#
virtualStatusVisit(constUInt8Scalar&scalar)#
virtualStatusVisit(constUInt16Scalar&scalar)#
virtualStatusVisit(constUInt32Scalar&scalar)#
virtualStatusVisit(constUInt64Scalar&scalar)#
virtualStatusVisit(constHalfFloatScalar&scalar)#
virtualStatusVisit(constFloatScalar&scalar)#
virtualStatusVisit(constDoubleScalar&scalar)#
virtualStatusVisit(constStringScalar&scalar)#
virtualStatusVisit(constStringViewScalar&scalar)#
virtualStatusVisit(constBinaryScalar&scalar)#
virtualStatusVisit(constBinaryViewScalar&scalar)#
virtualStatusVisit(constLargeStringScalar&scalar)#
virtualStatusVisit(constLargeBinaryScalar&scalar)#
virtualStatusVisit(constFixedSizeBinaryScalar&scalar)#
virtualStatusVisit(constDate64Scalar&scalar)#
virtualStatusVisit(constDate32Scalar&scalar)#
virtualStatusVisit(constTime32Scalar&scalar)#
virtualStatusVisit(constTime64Scalar&scalar)#
virtualStatusVisit(constTimestampScalar&scalar)#
virtualStatusVisit(constDayTimeIntervalScalar&scalar)#
virtualStatusVisit(constMonthDayNanoIntervalScalar&type)#
virtualStatusVisit(constMonthIntervalScalar&scalar)#
virtualStatusVisit(constDurationScalar&scalar)#
virtualStatusVisit(constDecimal32Scalar&scalar)#
virtualStatusVisit(constDecimal64Scalar&scalar)#
virtualStatusVisit(constDecimal128Scalar&scalar)#
virtualStatusVisit(constDecimal256Scalar&scalar)#
virtualStatusVisit(constListScalar&scalar)#
virtualStatusVisit(constLargeListScalar&scalar)#
virtualStatusVisit(constListViewScalar&scalar)#
virtualStatusVisit(constLargeListViewScalar&scalar)#
virtualStatusVisit(constMapScalar&scalar)#
virtualStatusVisit(constFixedSizeListScalar&scalar)#
virtualStatusVisit(constStructScalar&scalar)#
virtualStatusVisit(constDictionaryScalar&scalar)#
virtualStatusVisit(constSparseUnionScalar&scalar)#
virtualStatusVisit(constDenseUnionScalar&scalar)#
virtualStatusVisit(constRunEndEncodedScalar&scalar)#
virtualStatusVisit(constExtensionScalar&scalar)#
On this page