duckdb::SelectionVector Struct Reference

Collaboration diagram for duckdb::SelectionVector:

Public Member Functions
	SelectionVector (sel_t *sel)
	SelectionVector (idx_t count)
	SelectionVector (idx_t start, idx_t count)
	SelectionVector (const SelectionVector &sel_vector)
	SelectionVector (buffer_ptr< SelectionData > data)
SelectionVector &	operator= (SelectionVector &&other) noexcept
void	Initialize (sel_t *sel)
void	Initialize (idx_t count=STANDARD_VECTOR_SIZE)
void	Initialize (buffer_ptr< SelectionData > data)
void	Initialize (const SelectionVector &other)
void	set_index (idx_t idx, idx_t loc)
void	swap (idx_t i, idx_t j)
idx_t	get_index (idx_t idx) const
idx_t	get_index_unsafe (idx_t idx) const
sel_t *	data ()
const sel_t *	data () const
buffer_ptr< SelectionData >	sel_data ()
buffer_ptr< SelectionData >	Slice (const SelectionVector &sel, idx_t count) const
idx_t	SliceInPlace (const SelectionVector &sel, idx_t count)
string	ToString (idx_t count=0) const
void	Print (idx_t count=0) const
const sel_t &	operator[] (idx_t index) const
sel_t &	operator[] (idx_t index)
bool	IsSet () const
void	Verify (idx_t count, idx_t vector_size) const
void	Sort (idx_t count)

Static Public Member Functions
static idx_t	Inverted (const SelectionVector &src, SelectionVector &dst, idx_t source_size, idx_t count)

Private Attributes
sel_t *	sel_vector
buffer_ptr< SelectionData >	selection_data

Constructor & Destructor Documentation

SelectionVector() [1/6]

duckdb::SelectionVector::SelectionVector ( )

inline

                      : sel_vector(nullptr) {
    }

SelectionVector() [2/6]

duckdb::SelectionVector::SelectionVector ( sel_t *  sel )

inlineexplicit

                                         {
        Initialize(sel);
    }

SelectionVector() [3/6]

duckdb::SelectionVector::SelectionVector ( idx_t  count )

inlineexplicit

                                          {
        Initialize(count);
    }

SelectionVector() [4/6]

duckdb::SelectionVector::SelectionVector ( idx_t  start, idx_t  count  )

inline

                                              {
        Initialize(MaxValue<idx_t>(count, STANDARD_VECTOR_SIZE));
        for (idx_t i = 0; i < count; i++) {
            set_index(i, start + i);
        }
    }

SelectionVector() [5/6]

duckdb::SelectionVector::SelectionVector ( const SelectionVector &  sel_vector )

inline

                                                       {
        Initialize(sel_vector);
    }

SelectionVector() [6/6]

duckdb::SelectionVector::SelectionVector ( buffer_ptr< SelectionData >  data )

inlineexplicit

                                                             {
        Initialize(std::move(data));
    }

Member Function Documentation

operator=()

SelectionVector & duckdb::SelectionVector::operator= ( SelectionVector &&  other )

inlinenoexcept

                                                                 {
        sel_vector = other.sel_vector;
        other.sel_vector = nullptr;
        selection_data = std::move(other.selection_data);
        return *this;
    }

Inverted()

static idx_t duckdb::SelectionVector::Inverted ( const SelectionVector &  src, SelectionVector &  dst, idx_t  source_size, idx_t  count  )

inlinestatic

                                                                                                            {
        idx_t src_idx = 0;
        idx_t dst_idx = 0;
        for (idx_t i = 0; i < count; i++) {
            if (src_idx < source_size && src.get_index(src_idx) == i) {
                src_idx++;
                // This index is selected by 'src', skip it in 'dst'
                continue;
            }
            // This index does not exist in 'src', add it to the selection of 'dst'
            dst.set_index(dst_idx++, i);
        }
        return dst_idx;
    }

Initialize() [1/4]

void duckdb::SelectionVector::Initialize ( sel_t *  sel )

inline

                                {
        selection_data.reset();
        sel_vector = sel;
    }

Initialize() [2/4]

void duckdb::SelectionVector::Initialize ( idx_t  count = STANDARD_VECTOR_SIZE )

inline

                                                        {
        selection_data = make_shared_ptr<SelectionData>(count);
        sel_vector = reinterpret_cast<sel_t *>(selection_data->owned_data.get());
    }

Initialize() [3/4]

void duckdb::SelectionVector::Initialize ( buffer_ptr< SelectionData >  data )

inline

                                                    {
        selection_data = std::move(data);
        sel_vector = reinterpret_cast<sel_t *>(selection_data->owned_data.get());
    }

Initialize() [4/4]

void duckdb::SelectionVector::Initialize ( const SelectionVector &  other )

inline

                                                  {
        selection_data = other.selection_data;
        sel_vector = other.sel_vector;
    }

set_index()

void duckdb::SelectionVector::set_index ( idx_t  idx, idx_t  loc  )

inline

                                                { // NOLINT: allow casing for legacy reasons
        sel_vector[idx] = UnsafeNumericCast<sel_t>(loc);
    }

swap()

void duckdb::SelectionVector::swap ( idx_t  i, idx_t  j  )

inline

                                       { // NOLINT: allow casing for legacy reasons
        sel_t tmp = sel_vector[i];
        sel_vector[i] = sel_vector[j];
        sel_vector[j] = tmp;
    }

get_index()

idx_t duckdb::SelectionVector::get_index ( idx_t  idx ) const

inline

                                            { // NOLINT: allow casing for legacy reasons
        return sel_vector ? get_index_unsafe(idx) : idx;
    }

get_index_unsafe()

idx_t duckdb::SelectionVector::get_index_unsafe ( idx_t  idx ) const

inline

                                                   { // NOLINT: allow casing for legacy reasons
        return sel_vector[idx];
    }

data() [1/2]

sel_t * duckdb::SelectionVector::data ( )

inline

                  { // NOLINT: allow casing for legacy reasons
        return sel_vector;
    }

data() [2/2]

const sel_t * duckdb::SelectionVector::data ( ) const

inline

                              { // NOLINT: allow casing for legacy reasons
        return sel_vector;
    }

sel_data()

buffer_ptr< SelectionData > duckdb::SelectionVector::sel_data ( )

inline

                                         { // NOLINT: allow casing for legacy reasons
        return selection_data;
    }

operator[]() [1/2]

const sel_t & duckdb::SelectionVector::operator[] ( idx_t  index ) const

inline

                                                      {
        return sel_vector[index];
    }

operator[]() [2/2]

sel_t & duckdb::SelectionVector::operator[] ( idx_t  index )

inline

                                          {
        return sel_vector[index];
    }

IsSet()

bool duckdb::SelectionVector::IsSet ( ) const

inline

                              {
        return sel_vector;
    }

---

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

• external/duckdb/duckdb.hpp