duckdb::ConstantVector Struct Reference

Static Public Member Functions
template<class T >
static void	VerifyVectorType (const Vector &vector)
static const_data_ptr_t	GetData (const Vector &vector)
static data_ptr_t	GetData (Vector &vector)
template<class T >
static const T *	GetDataUnsafe (const Vector &vector)
template<class T >
static T *	GetDataUnsafe (Vector &vector)
template<class T >
static const T *	GetData (const Vector &vector)
template<class T >
static T *	GetData (Vector &vector)
static bool	IsNull (const Vector &vector)
static DUCKDB_API void	SetNull (Vector &vector, bool is_null)
static ValidityMask &	Validity (Vector &vector)
static DUCKDB_API const SelectionVector *	ZeroSelectionVector (idx_t count, SelectionVector &owned_sel)
static DUCKDB_API const SelectionVector *	ZeroSelectionVector ()
static DUCKDB_API void	Reference (Vector &vector, Vector &source, idx_t position, idx_t count)
	Turns "vector" into a constant vector by referencing a value within the source vector.

Static Public Attributes
static const sel_t	ZERO_VECTOR [STANDARD_VECTOR_SIZE]

Member Function Documentation

VerifyVectorType()

template<class T >

static void duckdb::ConstantVector::VerifyVectorType ( const Vector &  vector )

inlinestatic

                                                       {
#ifdef DUCKDB_DEBUG_NO_SAFETY
        D_ASSERT(StorageTypeCompatible<T>(vector.GetType().InternalType()));
#else
        if (!StorageTypeCompatible<T>(vector.GetType().InternalType())) {
            throw InternalException("Expected vector of type %s, but found vector of type %s", GetTypeId<T>(),
                                    vector.GetType().InternalType());
        }
#endif
    }

GetData() [1/4]

static const_data_ptr_t duckdb::ConstantVector::GetData ( const Vector &  vector )

inlinestatic

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

GetData() [2/4]

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

inlinestatic

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

GetDataUnsafe() [1/2]

template<class T >

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

inlinestatic

                                                               {
        return reinterpret_cast<const T *>(GetData(vector));
    }

GetDataUnsafe() [2/2]

template<class T >

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

inlinestatic

                                                   {
        return reinterpret_cast<T *>(GetData(vector));
    }

GetData() [3/4]

template<class T >

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

inlinestatic

                                                         {
        VerifyVectorType<T>(vector);
        return GetDataUnsafe<T>(vector);
    }

GetData() [4/4]

template<class T >

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

inlinestatic

                                             {
        VerifyVectorType<T>(vector);
        return GetDataUnsafe<T>(vector);
    }

IsNull()

static bool duckdb::ConstantVector::IsNull ( const Vector &  vector )

inlinestatic

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

Validity()

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

inlinestatic

                                                         {
        D_ASSERT(vector.GetVectorType() == VectorType::CONSTANT_VECTOR);
        return vector.validity;
    }

---

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

• external/duckdb/duckdb.hpp