duckdb::block_iterator_t< STATE, T > Class Template Reference

Iterator for data spread out over multiple blocks. More...

Public Types
using	iterator_category = std::random_access_iterator_tag
using	value_type = T
using	pointer = value_type *
using	reference = value_type &
using	difference_type = idx_t
using	traits = std::iterator_traits< block_iterator_t >

Public Member Functions
	block_iterator_t (STATE &state_p)
	block_iterator_t (STATE &state_p, const idx_t &index)
	block_iterator_t (STATE &state_p, const idx_t &block_idx_p, const idx_t &tuple_idx_p)
	block_iterator_t (const block_iterator_t &other)
block_iterator_t &	operator= (const block_iterator_t &other)
reference	operator* () const
	(De-)referencing
pointer	operator-> () const
block_iterator_t &	operator++ ()
	Prefix and postfix increment and decrement.
block_iterator_t	operator++ (int)
block_iterator_t &	operator-- ()
block_iterator_t	operator-- (int)
block_iterator_t &	operator+= (const difference_type &n)
	Random access.
block_iterator_t &	operator-= (const difference_type &n)
block_iterator_t	operator+ (const difference_type &n) const
block_iterator_t	operator- (const difference_type &n) const
reference	operator[] (const difference_type &n) const
difference_type	operator- (const block_iterator_t &other) const
	Difference between iterators.
bool	operator== (const block_iterator_t &other) const
	Comparison operators.
bool	operator!= (const block_iterator_t &other) const
bool	operator< (const block_iterator_t &other) const
bool	operator> (const block_iterator_t &other) const
bool	operator<= (const block_iterator_t &other) const
bool	operator>= (const block_iterator_t &other) const

Private Attributes
STATE *	state
idx_t	block_or_chunk_idx
idx_t	tuple_idx

Detailed Description

template<class STATE, class T>
class duckdb::block_iterator_t< STATE, T >

Iterator for data spread out over multiple blocks.

Constructor & Destructor Documentation

block_iterator_t() [1/5]

template<class STATE , class T >

duckdb::block_iterator_t< STATE, T >::block_iterator_t ( STATE &  state_p )

inlineexplicit

                                              : state(&state_p), block_or_chunk_idx(0), tuple_idx(0) {
    }

block_iterator_t() [2/5]

template<class STATE , class T >

duckdb::block_iterator_t< STATE, T >::block_iterator_t ( )

inlineexplicit

        : state(nullptr), block_or_chunk_idx(DConstants::INVALID_INDEX), tuple_idx(DConstants::INVALID_INDEX) {
        // Ideally, we wouldn't have a default constructor, because we always need a state.
        // However, some sorting algorithms use the default constructor before initializing, so we need this
    }

block_iterator_t() [3/5]

template<class STATE , class T >

duckdb::block_iterator_t< STATE, T >::block_iterator_t ( STATE &  state_p, const idx_t &  index  )

inline

                                                         : state(&state_p) { // NOLINT: uninitialized on purpose
        state->RandomAccess(block_or_chunk_idx, tuple_idx, index);
    }

block_iterator_t() [4/5]

template<class STATE , class T >

duckdb::block_iterator_t< STATE, T >::block_iterator_t ( STATE &  state_p, const idx_t &  block_idx_p, const idx_t &  tuple_idx_p  )

inline

        : state(&state_p), block_or_chunk_idx(block_idx_p), tuple_idx(tuple_idx_p) {
    }

block_iterator_t() [5/5]

template<class STATE , class T >

duckdb::block_iterator_t< STATE, T >::block_iterator_t ( const block_iterator_t< STATE, T > &  other )

inline

        : state(other.state), block_or_chunk_idx(other.block_or_chunk_idx), tuple_idx(other.tuple_idx) {
    }

Member Function Documentation

operator=()

template<class STATE , class T >

block_iterator_t & duckdb::block_iterator_t< STATE, T >::operator= ( const block_iterator_t< STATE, T > &  other )

inline

                                                               {
        D_ASSERT(!state || RefersToSameObject(*state, *other.state));
        if (this != &other) { // This check is needed to shut clang-tidy up
            block_or_chunk_idx = other.block_or_chunk_idx;
            tuple_idx = other.tuple_idx;
        }
        return *this;
    }

operator*()

template<class STATE , class T >

reference duckdb::block_iterator_t< STATE, T >::operator* ( ) const

inline

(De-)referencing

                                {
        return state->template GetValueAtIndex<T>(block_or_chunk_idx, tuple_idx);
    }

operator->()

template<class STATE , class T >

pointer duckdb::block_iterator_t< STATE, T >::operator-> ( ) const

inline

                               {
        return &operator*();
    }

operator++() [1/2]

template<class STATE , class T >

block_iterator_t & duckdb::block_iterator_t< STATE, T >::operator++ ( )

inline

Prefix and postfix increment and decrement.

                                   {
        state->Increment(block_or_chunk_idx, tuple_idx);
        return *this;
    }

operator++() [2/2]

template<class STATE , class T >

block_iterator_t duckdb::block_iterator_t< STATE, T >::operator++ ( int  )

inline

                                     {
        block_iterator_t tmp = *this;
        ++(*this);
        return tmp;
    }

operator--() [1/2]

template<class STATE , class T >

block_iterator_t & duckdb::block_iterator_t< STATE, T >::operator-- ( )

inline

                                   {
        state->Decrement(block_or_chunk_idx, tuple_idx);
        return *this;
    }

operator--() [2/2]

template<class STATE , class T >

block_iterator_t duckdb::block_iterator_t< STATE, T >::operator-- ( int  )

inline

                                     {
        block_iterator_t tmp = *this;
        --(*this);
        return tmp;
    }

operator+=()

template<class STATE , class T >

block_iterator_t & duckdb::block_iterator_t< STATE, T >::operator+= ( const difference_type &  n )

inline

Random access.

                                                           {
        state->Add(block_or_chunk_idx, tuple_idx, n);
        return *this;
    }

operator-=()

template<class STATE , class T >

block_iterator_t & duckdb::block_iterator_t< STATE, T >::operator-= ( const difference_type &  n )

inline

                                                           {
        state->Subtract(block_or_chunk_idx, tuple_idx, n);
        return *this;
    }

operator+()

template<class STATE , class T >

block_iterator_t duckdb::block_iterator_t< STATE, T >::operator+ ( const difference_type &  n ) const

inline

                                                               {
        idx_t new_block_or_chunk_idx = block_or_chunk_idx;
        idx_t new_tuple_idx = tuple_idx;
        state->Add(new_block_or_chunk_idx, new_tuple_idx, n);
        return block_iterator_t(*state, new_block_or_chunk_idx, new_tuple_idx);
    }

operator-() [1/2]

template<class STATE , class T >

block_iterator_t duckdb::block_iterator_t< STATE, T >::operator- ( const difference_type &  n ) const

inline

                                                               {
        idx_t new_block_or_chunk_idx = block_or_chunk_idx;
        idx_t new_tuple_idx = tuple_idx;
        state->Subtract(new_block_or_chunk_idx, new_tuple_idx, n);
        return block_iterator_t(*state, new_block_or_chunk_idx, new_tuple_idx);
    }

operator[]()

template<class STATE , class T >

reference duckdb::block_iterator_t< STATE, T >::operator[] ( const difference_type &  n ) const

inline

                                                         {
        return state->template GetValueAtIndex<T>(n);
    }

operator-() [2/2]

template<class STATE , class T >

difference_type duckdb::block_iterator_t< STATE, T >::operator- ( const block_iterator_t< STATE, T > &  other ) const

inline

Difference between iterators.

                                                                   {
        return state->GetIndex(block_or_chunk_idx, tuple_idx) -
               other.state->GetIndex(other.block_or_chunk_idx, other.tuple_idx);
    }

operator==()

template<class STATE , class T >

bool duckdb::block_iterator_t< STATE, T >::operator== ( const block_iterator_t< STATE, T > &  other ) const

inline

Comparison operators.

                                                         {
        return block_or_chunk_idx == other.block_or_chunk_idx && tuple_idx == other.tuple_idx;
    }

operator!=()

template<class STATE , class T >

bool duckdb::block_iterator_t< STATE, T >::operator!= ( const block_iterator_t< STATE, T > &  other ) const

inline

                                                         {
        return block_or_chunk_idx != other.block_or_chunk_idx || tuple_idx != other.tuple_idx;
    }

operator<()

template<class STATE , class T >

bool duckdb::block_iterator_t< STATE, T >::operator< ( const block_iterator_t< STATE, T > &  other ) const

inline

                                                        {
        return block_or_chunk_idx == other.block_or_chunk_idx ? tuple_idx < other.tuple_idx
                                                              : block_or_chunk_idx < other.block_or_chunk_idx;
    }

operator>()

template<class STATE , class T >

bool duckdb::block_iterator_t< STATE, T >::operator> ( const block_iterator_t< STATE, T > &  other ) const

inline

                                                        {
        return block_or_chunk_idx == other.block_or_chunk_idx ? tuple_idx > other.tuple_idx
                                                              : block_or_chunk_idx > other.block_or_chunk_idx;
    }

operator<=()

template<class STATE , class T >

bool duckdb::block_iterator_t< STATE, T >::operator<= ( const block_iterator_t< STATE, T > &  other ) const

inline

                                                         {
        return block_or_chunk_idx == other.block_or_chunk_idx ? tuple_idx <= other.tuple_idx
                                                              : block_or_chunk_idx <= other.block_or_chunk_idx;
    }

operator>=()

template<class STATE , class T >

bool duckdb::block_iterator_t< STATE, T >::operator>= ( const block_iterator_t< STATE, T > &  other ) const

inline

                                                         {
        return block_or_chunk_idx == other.block_or_chunk_idx ? tuple_idx >= other.tuple_idx
                                                              : block_or_chunk_idx >= other.block_or_chunk_idx;
    }

---

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

• external/duckdb/duckdb.cpp