Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://arrow.apache.org/docs/cpp/api/scalar.html below:

Scalars — Apache Arrow v21.0.0

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

Base class for scalar values.

A Scalar represents a single value with a specific DataType. 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 by arrow::BaseListScalar, arrow::ExtensionScalar, arrow::NullScalar, arrow::RunEndEncodedScalar, arrow::StructScalar, arrow::UnionScalar, arrow::internal::PrimitiveScalarBase

Public Functions

Status Validate() const#

Perform cheap validation checks.

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

Returns:

Status

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

Status Accept(ScalarVisitor *visitor) const#

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

inline std::shared_ptr<Scalar> GetSharedPtr() const#

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

Public Members

std::shared_ptr<DataType> type#

The type of the scalar value.

bool is_valid = false#

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

struct Hash#

Scalar factory for null scalars.

Scalar factory for non-null scalars.

Type-inferring scalar factory for non-null scalars.

Construct a Scalar instance with a DataType determined by the input C++ type. (for example Int8Scalar for a int8_t input). Only non-parametric primitive types and String are supported.

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

struct NullScalar : public arrow::Scalar#

#include <arrow/scalar.h>

A scalar value for NullType. Never valid.

Public Functions

inline NullScalar()#

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

#include <arrow/scalar.h>

Public Types

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

Public Functions

inline explicit BooleanScalar(bool value)#

inline BooleanScalar()#

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

#include <arrow/scalar.h>

Public Types

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

using TypeClass = typename Base::TypeClass#

using ValueType = typename Base::ValueType#

Public Functions

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>

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>

Subclassed by arrow::BinaryScalar, arrow::BinaryViewScalar, arrow::LargeBinaryScalar

Public Types

using ValueType = std::shared_ptr<Buffer>#

Public Functions

inline const void *data() const override#

inline std::string_view view() const override#

Public Members

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

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

#include <arrow/scalar.h>

Subclassed by arrow::FixedSizeBinaryScalar, arrow::StringScalar

Public Types

using TypeClass = BinaryType#

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<BinaryScalar>#

Public Functions

inline explicit BinaryScalar(std::string s)#

inline BinaryScalar()#

struct StringScalar : public arrow::BinaryScalar#

#include <arrow/scalar.h>

Public Functions

inline explicit StringScalar(std::string s)#

inline StringScalar()#

inline explicit BinaryScalar(std::string s)#

inline BinaryScalar()#

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

#include <arrow/scalar.h>

Subclassed by arrow::StringViewScalar

Public Functions

inline explicit BinaryViewScalar(std::string s)#

inline BinaryViewScalar()#

inline std::string_view view() const override#

struct StringViewScalar : public arrow::BinaryViewScalar#

#include <arrow/scalar.h>

Public Functions

inline explicit StringViewScalar(std::string s)#

inline StringViewScalar()#

inline explicit BinaryViewScalar(std::string s)#

inline BinaryViewScalar()#

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

#include <arrow/scalar.h>

Subclassed by arrow::LargeStringScalar

Public Functions

inline explicit LargeBinaryScalar(std::string s)#

inline LargeBinaryScalar()#

struct LargeStringScalar : public arrow::LargeBinaryScalar#

#include <arrow/scalar.h>

Public Functions

inline explicit LargeStringScalar(std::string s)#

inline LargeStringScalar()#

inline explicit LargeBinaryScalar(std::string s)#

inline LargeBinaryScalar()#

struct FixedSizeBinaryScalar : public arrow::BinaryScalar#

#include <arrow/scalar.h>

Public Functions

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

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

#include <arrow/scalar.h>

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

Public Types

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

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

#include <arrow/scalar.h>

Public Functions

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>

Public Functions

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>

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

#include <arrow/scalar.h>

Public Functions

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>

Public Functions

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>

Public Functions

inline const void *data() const override#

inline std::string_view view() const override#

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

#include <arrow/scalar.h>

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

#include <arrow/scalar.h>

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

#include <arrow/scalar.h>

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

#include <arrow/scalar.h>

struct BaseListScalar : public arrow::Scalar#

#include <arrow/scalar.h>

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

Public Types

using ValueType = std::shared_ptr<Array>#

Public Members

const std::shared_ptr<Array> value#

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

#include <arrow/scalar.h>

Public Types

using TypeClass = ListType#

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<ListScalar>#

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

#include <arrow/scalar.h>

Public Types

using TypeClass = LargeListType#

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<LargeListScalar>#

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

#include <arrow/scalar.h>

Public Types

using TypeClass = ListViewType#

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<ListViewScalar>#

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

#include <arrow/scalar.h>

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

#include <arrow/scalar.h>

Public Types

using TypeClass = MapType#

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<MapScalar>#

struct FixedSizeListScalar : public arrow::BaseListScalar#

#include <arrow/scalar.h>

struct StructScalar : public arrow::Scalar#

#include <arrow/scalar.h>

Public Types

using TypeClass = StructType#

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

Public Members

ScalarVector value#

struct UnionScalar : public arrow::Scalar#

#include <arrow/scalar.h>

Subclassed by arrow::DenseUnionScalar, arrow::SparseUnionScalar

Public Functions

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

Public Members

const int8_t type_code#

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

#include <arrow/scalar.h>

Public Types

using TypeClass = SparseUnionType#

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<SparseUnionScalar>#

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

Public Functions

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

Public Static Functions

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

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

#include <arrow/scalar.h>

Public Types

using TypeClass = DenseUnionType#

using ArraySpanFillFromScalarScratchSpace = internal::ArraySpanFillFromScalarScratchSpace<DenseUnionScalar>#

using ValueType = std::shared_ptr<Scalar>#

Public Functions

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

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

#include <arrow/scalar.h>

Public Functions

Constructs a NULL RunEndEncodedScalar.

~RunEndEncodedScalar() override#

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

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

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

#include <arrow/scalar.h>

A Scalar value for DictionaryType.

is_valid denotes the validity of the index, regardless of the corresponding value in the dictionary.

Public Functions

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

inline const void *data() const override#

inline std::string_view view() const override#

struct ValueType#

#include <arrow/scalar.h>

Public Members

std::shared_ptr<Scalar> index#

std::shared_ptr<Array> dictionary#

struct ExtensionScalar : public arrow::Scalar#

#include <arrow/scalar.h>

A Scalar value for ExtensionType.

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

Public Members

std::shared_ptr<Scalar> value#

class ScalarVisitor#

Abstract scalar visitor class.

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4