duckdb::ValidityArray Struct Reference

Collaboration diagram for duckdb::ValidityArray:

Public Member Functions
bool	AllValid () const
void	Initialize (idx_t count, bool initial=true)
void	InitializeEmpty (idx_t count)
idx_t	Capacity () 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	Pack (ValidityMask &mask, const idx_t count) const

Private Attributes
bool *	validity_mask = nullptr
unsafe_unique_array< bool >	validity_data
idx_t	capacity = 0

Constructor & Destructor Documentation

ValidityArray()

duckdb::ValidityArray::ValidityArray ( )

inline

                           {
    }

Member Function Documentation

AllValid()

bool duckdb::ValidityArray::AllValid ( ) const

inline

                                 {
        return !validity_mask;
    }

Initialize()

void duckdb::ValidityArray::Initialize ( idx_t  count, bool  initial = true  )

inline

                                                             {
        capacity = count;
        validity_data = make_unsafe_uniq_array<bool>(count);
        validity_mask = validity_data.get();
        memset(validity_mask, initial, sizeof(bool) * count);
    }

InitializeEmpty()

void duckdb::ValidityArray::InitializeEmpty ( idx_t  count )

inline

                                             {
        capacity = count;
    }

Capacity()

idx_t duckdb::ValidityArray::Capacity ( ) const

inline

                           {
        return capacity;
    }

RowIsValidUnsafe()

bool duckdb::ValidityArray::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);
        return validity_mask[row_idx];
    }

Here is the caller graph for this function:

RowIsValid()

bool duckdb::ValidityArray::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("ValidityData::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:

Here is the caller graph for this function:

SetValidUnsafe()

void duckdb::ValidityArray::SetValidUnsafe ( idx_t  row_idx )

inline

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

                                              {
        D_ASSERT(validity_mask);
        validity_mask[row_idx] = true;
    }

Here is the caller graph for this function:

SetValid()

void duckdb::ValidityArray::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("ValidityData::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:

Pack()

void duckdb::ValidityArray::Pack ( ValidityMask &  mask, const idx_t  count  ) const

inline

                                                                  {
        if (AllValid()) {
            mask.Reset(count);
            return;
        }
        mask.Initialize(count);
 
        const auto entire_entries = count / ValidityMask::BITS_PER_VALUE;
        const auto ragged = count % ValidityMask::BITS_PER_VALUE;
        auto bits = mask.GetData();
        idx_t row_idx = 0;
        for (idx_t i = 0; i < entire_entries; ++i) {
            validity_t entry = 0;
            for (idx_t j = 0; j < ValidityMask::BITS_PER_VALUE; ++j) {
                if (RowIsValidUnsafe(row_idx++)) {
                    entry |= validity_t(1) << j;
                }
            }
            *bits++ = entry;
        }
        if (ragged) {
            validity_t entry = 0;
            for (idx_t j = 0; j < ragged; ++j) {
                if (RowIsValidUnsafe(row_idx++)) {
                    entry |= validity_t(1) << j;
                }
            }
            *bits++ = entry;
        }
    }

---

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

• external/duckdb/duckdb.hpp