duckdb::FlatVector Struct Reference

Static Public Member Functions
static void	VerifyFlatVector (const Vector &vector)
static data_ptr_t	GetData (Vector &vector)
template<class T >
static const T *	GetData (const Vector &vector)
template<class T >
static T *	GetData (Vector &vector)
template<class T >
static const T *	GetDataUnsafe (const Vector &vector)
template<class T >
static T *	GetDataUnsafe (Vector &vector)
static void	SetData (Vector &vector, data_ptr_t data)
template<class T >
static T	GetValue (Vector &vector, idx_t idx)
static const ValidityMask &	Validity (const Vector &vector)
static ValidityMask &	Validity (Vector &vector)
static void	SetValidity (Vector &vector, const ValidityMask &new_validity)
static DUCKDB_API void	SetNull (Vector &vector, idx_t idx, bool is_null)
static bool	IsNull (const Vector &vector, idx_t idx)
static DUCKDB_API const SelectionVector *	IncrementalSelectionVector ()

Member Function Documentation

VerifyFlatVector()

static void duckdb::FlatVector::VerifyFlatVector ( const Vector &  vector )

inlinestatic

                                                       {
#ifdef DUCKDB_DEBUG_NO_SAFETY
        D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
#else
        if (vector.GetVectorType() != VectorType::FLAT_VECTOR) {
            throw InternalException("Operation requires a flat vector but a non-flat vector was encountered");
        }
#endif
    }

GetData() [1/3]

static data_ptr_t duckdb::FlatVector::GetData ( Vector &  vector )

inlinestatic

                                                     {
        return ConstantVector::GetData(vector);
    }

GetData() [2/3]

template<class T >

static const T * duckdb::FlatVector::GetData ( const Vector &  vector )

inlinestatic

                                                         {
        return ConstantVector::GetData<T>(vector);
    }

GetData() [3/3]

template<class T >

static T * duckdb::FlatVector::GetData ( Vector &  vector )

inlinestatic

                                             {
        return ConstantVector::GetData<T>(vector);
    }

GetDataUnsafe() [1/2]

template<class T >

static const T * duckdb::FlatVector::GetDataUnsafe ( const Vector &  vector )

inlinestatic

                                                               {
        return ConstantVector::GetDataUnsafe<T>(vector);
    }

GetDataUnsafe() [2/2]

template<class T >

static T * duckdb::FlatVector::GetDataUnsafe ( Vector &  vector )

inlinestatic

                                                   {
        return ConstantVector::GetDataUnsafe<T>(vector);
    }

SetData()

static void duckdb::FlatVector::SetData ( Vector &  vector, data_ptr_t  data  )

inlinestatic

                                                                {
        D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
        vector.data = data;
    }

GetValue()

template<class T >

static T duckdb::FlatVector::GetValue ( Vector &  vector, idx_t  idx  )

inlinestatic

                                                        {
        D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
        return FlatVector::GetData<T>(vector)[idx];
    }

Validity() [1/2]

static const ValidityMask & duckdb::FlatVector::Validity ( const Vector &  vector )

inlinestatic

                                                                     {
        VerifyFlatVector(vector);
        return vector.validity;
    }

Validity() [2/2]

static ValidityMask & duckdb::FlatVector::Validity ( Vector &  vector )

inlinestatic

                                                         {
        VerifyFlatVector(vector);
        return vector.validity;
    }

SetValidity()

static void duckdb::FlatVector::SetValidity ( Vector &  vector, const ValidityMask &  new_validity  )

inlinestatic

                                                                                     {
        VerifyFlatVector(vector);
        vector.validity.Initialize(new_validity);
    }

IsNull()

static bool duckdb::FlatVector::IsNull ( const Vector &  vector, idx_t  idx  )

inlinestatic

                                                               {
        D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
        return !vector.validity.RowIsValid(idx);
    }

---

The documentation for this struct was generated from the following file:

• external/duckdb/duckdb.hpp