duckdb::TemplatedValidityMask< V > Struct Template Reference

Type used for validity masks. More...

Collaboration diagram for duckdb::TemplatedValidityMask< V >:

Public Types
using	ValidityBuffer = TemplatedValidityData< V >

Public Member Functions
	TemplatedValidityMask (idx_t target_count)
	TemplatedValidityMask (V *ptr, idx_t capacity)
	TemplatedValidityMask (const TemplatedValidityMask &original, idx_t count)
bool	AllValid () const
bool	CheckAllValid (idx_t count) const
bool	CheckAllInvalid (idx_t count) const
bool	CheckAllValid (idx_t to, idx_t from) const
idx_t	CountValid (const idx_t count) const
V *	GetData () const
void	Reset (idx_t target_count_p=STANDARD_VECTOR_SIZE)
V	GetValidityEntry (idx_t entry_idx) const
V &	GetValidityEntryUnsafe (idx_t entry_idx) const
bool	RowIsValidUnsafe (idx_t row_idx) const
bool	RowIsValid (idx_t row_idx) const
	Returns true if a row is valid (i.e. not null), false otherwise.
void	SetValidUnsafe (idx_t row_idx)
	Same as SetValid, but skips a null check on validity_mask.
void	SetValid (idx_t row_idx)
	Marks the entry at the specified row index as valid (i.e. not-null)
void	SetInvalidUnsafe (idx_t entry_idx, idx_t idx_in_entry)
	Marks the bit at the specified entry as invalid (i.e. null)
void	SetInvalidUnsafe (idx_t row_idx)
	Marks the bit at the specified row index as invalid (i.e. null)
void	SetInvalid (idx_t row_idx)
	Marks the entry at the specified row index as invalid (i.e. null)
void	Set (idx_t row_idx, bool valid)
	Mark the entry at the specified index as either valid or invalid (non-null or null)
void	EnsureWritable ()
	Ensure the validity mask is writable, allocating space if it is not initialized.
void	SetRangeInvalid (const idx_t count, const idx_t begin_entry, const idx_t end_entry)
void	SetAllInvalid (idx_t count)
	Marks exactly "count" bits in the validity mask as invalid (null)
void	SetAllValid (idx_t count)
	Marks exactly "count" bits in the validity mask as valid (not null)
bool	IsMaskSet () const
void	Initialize (validity_t *validity, idx_t new_capacity)
void	Initialize (const TemplatedValidityMask &other)
void	Initialize (idx_t count)
void	Initialize ()
void	Copy (const TemplatedValidityMask &other, idx_t count)

Static Public Member Functions
static idx_t	ValidityMaskSize (idx_t count=STANDARD_VECTOR_SIZE)
static idx_t	EntryCount (idx_t count)
static bool	AllValid (V entry)
static bool	NoneValid (V entry)
static bool	RowIsValid (const V &entry, const idx_t &idx_in_entry)
static void	GetEntryIndex (idx_t row_idx, idx_t &entry_idx, idx_t &idx_in_entry)
static V	EntryWithValidBits (idx_t n)
	Get an entry that has first-n bits set as valid and rest set as invalid.
static idx_t	SizeInBytes (idx_t n)

Static Public Attributes
static constexpr const idx_t	BITS_PER_VALUE = ValidityBuffer::BITS_PER_VALUE
static constexpr const idx_t	STANDARD_ENTRY_COUNT = (STANDARD_VECTOR_SIZE + (BITS_PER_VALUE - 1)) / BITS_PER_VALUE
static constexpr const idx_t	STANDARD_MASK_SIZE = STANDARD_ENTRY_COUNT * sizeof(V)

Protected Attributes
V *	validity_mask
buffer_ptr< ValidityBuffer >	validity_data
idx_t	capacity

Detailed Description

template<typename V>
struct duckdb::TemplatedValidityMask< V >

Type used for validity masks.

Constructor & Destructor Documentation

TemplatedValidityMask() [1/4]

template<typename V >

duckdb::TemplatedValidityMask< V >::TemplatedValidityMask ( )

inline

                                   : validity_mask(nullptr), capacity(STANDARD_VECTOR_SIZE) {
    }

TemplatedValidityMask() [2/4]

template<typename V >

duckdb::TemplatedValidityMask< V >::TemplatedValidityMask ( idx_t  target_count )

inlineexplicit

                                                              : validity_mask(nullptr), capacity(target_count) {
    }

TemplatedValidityMask() [3/4]

template<typename V >

duckdb::TemplatedValidityMask< V >::TemplatedValidityMask ( V *  ptr, idx_t  capacity  )

inlineexplicit

                                                                  : validity_mask(ptr), capacity(capacity) {
    }

TemplatedValidityMask() [4/4]

template<typename V >

duckdb::TemplatedValidityMask< V >::TemplatedValidityMask ( const TemplatedValidityMask< V > &  original, idx_t  count  )

inline

                                                                                     {
        Copy(original, count);
    }

Member Function Documentation

ValidityMaskSize()

template<typename V >

static idx_t duckdb::TemplatedValidityMask< V >::ValidityMaskSize ( idx_t  count = STANDARD_VECTOR_SIZE )

inlinestatic

                                                                             {
        return ValidityBuffer::EntryCount(count) * sizeof(V);
    }

AllValid() [1/2]

template<typename V >

bool duckdb::TemplatedValidityMask< V >::AllValid ( ) const

inline

                                 {
        return !validity_mask;
    }

CheckAllValid() [1/2]

template<typename V >

bool duckdb::TemplatedValidityMask< V >::CheckAllValid ( idx_t  count ) const

inline

                                                 {
        return CountValid(count) == count;
    }

CheckAllInvalid()

template<typename V >

bool duckdb::TemplatedValidityMask< V >::CheckAllInvalid ( idx_t  count ) const

inline

                                                   {
        return CountValid(count) == 0;
    }

CheckAllValid() [2/2]

template<typename V >

bool duckdb::TemplatedValidityMask< V >::CheckAllValid ( idx_t  to, idx_t  from  ) const

inline

                                                          {
        if (AllValid()) {
            return true;
        }
        for (idx_t i = from; i < to; i++) {
            if (!RowIsValid(i)) {
                return false;
            }
        }
        return true;
    }

CountValid()

template<typename V >

idx_t duckdb::TemplatedValidityMask< V >::CountValid ( const idx_t  count ) const

inline

                                              {
        if (AllValid() || count == 0) {
            return count;
        }
 
        idx_t valid = 0;
        const auto entry_count = EntryCount(count);
        for (idx_t entry_idx = 0; entry_idx < entry_count;) {
            auto entry = GetValidityEntry(entry_idx++);
            // Handle ragged end (if not exactly multiple of BITS_PER_VALUE)
            if (entry_idx == entry_count && count % BITS_PER_VALUE != 0) {
                const auto shift = BITS_PER_VALUE - (count % BITS_PER_VALUE);
                const auto mask = ValidityBuffer::MAX_ENTRY >> shift;
                entry &= mask;
            } else if (AllValid(entry)) {
                // Handle all set
                valid += BITS_PER_VALUE;
                continue;
            }
 
            // Count partial entry (Kernighan's algorithm)
            while (entry) {
                entry &= (entry - 1);
                ++valid;
            }
        }
 
        return valid;
    }

GetData()

template<typename V >

V * duckdb::TemplatedValidityMask< V >::GetData ( ) const

inline

                              {
        return validity_mask;
    }

Reset()

template<typename V >

void duckdb::TemplatedValidityMask< V >::Reset ( idx_t  target_count_p = STANDARD_VECTOR_SIZE )

inline

                                                                   {
        validity_mask = nullptr;
        validity_data.reset();
        capacity = target_count_p;
    }

EntryCount()

template<typename V >

static idx_t duckdb::TemplatedValidityMask< V >::EntryCount ( idx_t  count )

inlinestatic

                                                {
        return ValidityBuffer::EntryCount(count);
    }

GetValidityEntry()

template<typename V >

V duckdb::TemplatedValidityMask< V >::GetValidityEntry ( idx_t  entry_idx ) const

inline

                                                     {
        if (!validity_mask) {
            return ValidityBuffer::MAX_ENTRY;
        }
        return GetValidityEntryUnsafe(entry_idx);
    }

GetValidityEntryUnsafe()

template<typename V >

V & duckdb::TemplatedValidityMask< V >::GetValidityEntryUnsafe ( idx_t  entry_idx ) const

inline

                                                            {
        return validity_mask[entry_idx];
    }

AllValid() [2/2]

template<typename V >

static bool duckdb::TemplatedValidityMask< V >::AllValid ( V  entry )

inlinestatic

                                         {
        // Check if all the tuples that are covered by this entry (usually 64) are valid
        return entry == ValidityBuffer::MAX_ENTRY;
    }

NoneValid()

template<typename V >

static bool duckdb::TemplatedValidityMask< V >::NoneValid ( V  entry )

inlinestatic

                                          {
        return entry == 0;
    }

RowIsValid() [1/2]

template<typename V >

static bool duckdb::TemplatedValidityMask< V >::RowIsValid ( const V &  entry, const idx_t &  idx_in_entry  )

inlinestatic

                                                                             {
        return entry & (V(1) << V(idx_in_entry));
    }

GetEntryIndex()

template<typename V >

static void duckdb::TemplatedValidityMask< V >::GetEntryIndex ( idx_t  row_idx, idx_t &  entry_idx, idx_t &  idx_in_entry  )

inlinestatic

                                                                                           {
        entry_idx = row_idx / BITS_PER_VALUE;
        idx_in_entry = row_idx % BITS_PER_VALUE;
    }

EntryWithValidBits()

template<typename V >

static V duckdb::TemplatedValidityMask< V >::EntryWithValidBits ( idx_t  n )

inlinestatic

Get an entry that has first-n bits set as valid and rest set as invalid.

                                                {
        if (n == 0) {
            return V(0);
        }
        return ValidityBuffer::MAX_ENTRY >> (BITS_PER_VALUE - n);
    }

SizeInBytes()

template<typename V >

static idx_t duckdb::TemplatedValidityMask< V >::SizeInBytes ( idx_t  n )

inlinestatic

                                             {
        return (n + BITS_PER_VALUE - 1) / BITS_PER_VALUE;
    }

RowIsValidUnsafe()

template<typename V >

bool duckdb::TemplatedValidityMask< V >::RowIsValidUnsafe ( idx_t  row_idx ) const

inline

RowIsValidUnsafe should only be used if AllValid() is false: it achieves the same as RowIsValid but skips a not-null check

                                                      {
        D_ASSERT(validity_mask);
        idx_t entry_idx, idx_in_entry;
        GetEntryIndex(row_idx, entry_idx, idx_in_entry);
        auto entry = GetValidityEntryUnsafe(entry_idx);
        return RowIsValid(entry, idx_in_entry);
    }

Here is the caller graph for this function:

RowIsValid() [2/2]

template<typename V >

bool duckdb::TemplatedValidityMask< V >::RowIsValid ( idx_t  row_idx ) const

inline

Returns true if a row is valid (i.e. not null), false otherwise.

                                                {
#ifdef DEBUG
        if (row_idx >= capacity) {
            throw InternalException("ValidityMask::RowIsValid - row_idx %d is out-of-range for mask with capacity %llu",
                                    row_idx, capacity);
        }
#endif
        if (!validity_mask) {
            return true;
        }
        return RowIsValidUnsafe(row_idx);
    }

Here is the call graph for this function:

SetValidUnsafe()

template<typename V >

void duckdb::TemplatedValidityMask< V >::SetValidUnsafe ( idx_t  row_idx )

inline

Same as SetValid, but skips a null check on validity_mask.

                                              {
        D_ASSERT(validity_mask);
        idx_t entry_idx, idx_in_entry;
        GetEntryIndex(row_idx, entry_idx, idx_in_entry);
        validity_mask[entry_idx] |= (V(1) << V(idx_in_entry));
    }

Here is the caller graph for this function:

SetValid()

template<typename V >

void duckdb::TemplatedValidityMask< V >::SetValid ( idx_t  row_idx )

inline

Marks the entry at the specified row index as valid (i.e. not-null)

                                        {
#ifdef DEBUG
        if (row_idx >= capacity) {
            throw InternalException("ValidityMask::SetValid - row_idx %d is out-of-range for mask with capacity %llu",
                                    row_idx, capacity);
        }
#endif
        if (!validity_mask) {
            // if AllValid() we don't need to do anything
            // the row is already valid
            return;
        }
        SetValidUnsafe(row_idx);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

SetInvalidUnsafe() [1/2]

template<typename V >

void duckdb::TemplatedValidityMask< V >::SetInvalidUnsafe ( idx_t  entry_idx, idx_t  idx_in_entry  )

inline

Marks the bit at the specified entry as invalid (i.e. null)

                                                                      {
        D_ASSERT(validity_mask);
        validity_mask[entry_idx] &= ~(V(1) << V(idx_in_entry));
    }

Here is the caller graph for this function:

SetInvalidUnsafe() [2/2]

template<typename V >

void duckdb::TemplatedValidityMask< V >::SetInvalidUnsafe ( idx_t  row_idx )

inline

Marks the bit at the specified row index as invalid (i.e. null)

                                                {
        idx_t entry_idx, idx_in_entry;
        GetEntryIndex(row_idx, entry_idx, idx_in_entry);
        SetInvalidUnsafe(entry_idx, idx_in_entry);
    }

Here is the call graph for this function:

SetInvalid()

template<typename V >

void duckdb::TemplatedValidityMask< V >::SetInvalid ( idx_t  row_idx )

inline

Marks the entry at the specified row index as invalid (i.e. null)

                                          {
#ifdef DEBUG
        if (row_idx >= capacity) {
            throw InternalException("ValidityMask::SetInvalid - row_idx %d is out-of-range for mask with capacity %llu",
                                    row_idx, capacity);
        }
#endif
        if (!validity_mask) {
            Initialize(capacity);
        }
        SetInvalidUnsafe(row_idx);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Set()

template<typename V >

void duckdb::TemplatedValidityMask< V >::Set ( idx_t  row_idx, bool  valid  )

inline

Mark the entry at the specified index as either valid or invalid (non-null or null)

                                               {
        if (valid) {
            SetValid(row_idx);
        } else {
            SetInvalid(row_idx);
        }
    }

Here is the call graph for this function:

EnsureWritable()

template<typename V >

void duckdb::TemplatedValidityMask< V >::EnsureWritable ( )

inline

Ensure the validity mask is writable, allocating space if it is not initialized.

                                 {
        if (!validity_mask) {
            Initialize();
        }
    }

Here is the caller graph for this function:

SetRangeInvalid()

template<typename V >

void duckdb::TemplatedValidityMask< V >::SetRangeInvalid ( const idx_t  count, const idx_t  begin_entry, const idx_t  end_entry  )

inline

Marks a range of entries in the validity mask as invalid (null) This is useful for initialising large masks in parallel.

                                                                                                   {
        EnsureWritable();
        if (count == 0) {
            return;
        }
        const auto last_entry_index = ValidityBuffer::EntryCount(count) - 1;
        for (idx_t i = begin_entry; i < MinValue(last_entry_index, end_entry); i++) {
            validity_mask[i] = 0;
        }
        if (end_entry <= last_entry_index) {
            return;
        }
        const auto last_entry_bits = count % BITS_PER_VALUE;
        validity_mask[last_entry_index] =
            (last_entry_bits == 0) ? 0 : static_cast<V>(ValidityBuffer::MAX_ENTRY << (last_entry_bits));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

SetAllInvalid()

template<typename V >

void duckdb::TemplatedValidityMask< V >::SetAllInvalid ( idx_t  count )

inline

Marks exactly "count" bits in the validity mask as invalid (null)

                                           {
        SetRangeInvalid(count, 0, EntryCount(count));
    }

Here is the call graph for this function:

SetAllValid()

template<typename V >

void duckdb::TemplatedValidityMask< V >::SetAllValid ( idx_t  count )

inline

Marks exactly "count" bits in the validity mask as valid (not null)

                                         {
        EnsureWritable();
        if (count == 0) {
            return;
        }
        auto last_entry_index = ValidityBuffer::EntryCount(count) - 1;
        for (idx_t i = 0; i < last_entry_index; i++) {
            validity_mask[i] = ValidityBuffer::MAX_ENTRY;
        }
        auto last_entry_bits = count % BITS_PER_VALUE;
        validity_mask[last_entry_index] |= (last_entry_bits == 0)
                                               ? ValidityBuffer::MAX_ENTRY
                                               : ~static_cast<V>(ValidityBuffer::MAX_ENTRY << (last_entry_bits));
    }

Here is the call graph for this function:

IsMaskSet()

template<typename V >

bool duckdb::TemplatedValidityMask< V >::IsMaskSet ( ) const

inline

                                  {
        if (validity_mask) {
            return true;
        }
        return false;
    }

Initialize() [1/4]

template<typename V >

void duckdb::TemplatedValidityMask< V >::Initialize ( validity_t *  validity, idx_t  new_capacity  )

inline

                                                                     {
        validity_data.reset();
        validity_mask = validity;
        capacity = new_capacity;
    }

Initialize() [2/4]

template<typename V >

void duckdb::TemplatedValidityMask< V >::Initialize ( const TemplatedValidityMask< V > &  other )

inline

                                                               {
        validity_mask = other.validity_mask;
        validity_data = other.validity_data;
        capacity = other.capacity;
    }

Initialize() [3/4]

template<typename V >

void duckdb::TemplatedValidityMask< V >::Initialize ( idx_t  count )

inline

                                        {
        capacity = count;
        validity_data = make_buffer<ValidityBuffer>(count);
        validity_mask = validity_data->owned_data.get();
    }

Initialize() [4/4]

template<typename V >

void duckdb::TemplatedValidityMask< V >::Initialize ( )

inline

                             {
        Initialize(capacity);
    }

Copy()

template<typename V >

void duckdb::TemplatedValidityMask< V >::Copy ( const TemplatedValidityMask< V > &  other, idx_t  count  )

inline

                                                                      {
        capacity = count;
        if (other.AllValid()) {
            validity_data = nullptr;
            validity_mask = nullptr;
        } else {
            validity_data = make_buffer<ValidityBuffer>(other.validity_mask, count);
            validity_mask = validity_data->owned_data.get();
        }
    }

---

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

• external/duckdb/duckdb.hpp