duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD > Struct Template Reference

Inheritance diagram for duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >:

Collaboration diagram for duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >:

Public Member Functions
void	ByteSwap ()
void	Construct (const string_t &val, data_ptr_t &heap_ptr)
void	Construct (const int64_t &, data_ptr_t &)
void	Deconstruct (string_t &val)
void	Deconstruct (int64_t &)
data_ptr_t	GetData () const
void	SetData (const data_ptr_t &data)
idx_t	GetSize () const
idx_t	GetHeapSize () const

Static Public Member Functions
static int32_t	TernaryCompare (const uint64_t &lhs, const uint64_t &rhs)
static int32_t	LessThan (const uint64_t *const &lhs, const uint64_t *const &rhs)

Static Public Attributes
static constexpr bool	CONSTANT_SIZE = false

Protected Attributes
friend	SORT_KEY

Friends
bool	operator< (const SORT_KEY &lhs, const SORT_KEY &rhs)

Member Function Documentation

ByteSwap()

template<class SORT_KEY , bool HAS_PAYLOAD>

void duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::ByteSwap ( )

inline

                    {
        auto &sort_key = static_cast<SORT_KEY &>(*this);
        for (idx_t i = 0; i < SORT_KEY::PARTS; i++) {
            (&sort_key.part0)[i] = BSwapIfLE((&sort_key.part0)[i]);
        }
    }

Construct() [1/2]

template<class SORT_KEY , bool HAS_PAYLOAD>

void duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::Construct ( const string_t &  val, data_ptr_t &  heap_ptr  )

inline

                                                              {
        auto &sort_key = static_cast<SORT_KEY &>(*this);
        // Initialize to 0's (including size by doing + 1)
        for (idx_t i = 0; i < SORT_KEY::PARTS + 1; i++) {
            (&sort_key.part0)[i] = 0;
        }
 
        // Deal with inlined part first
        memcpy(&sort_key.part0, val.GetData(), MinValue(val.GetSize(), SORT_KEY::INLINE_LENGTH));
        // Same as FixedSortKey, we do not store the data in byte-comparable order
        ByteSwap();
 
        // Deal with non-inlined part (if necessary)
        if (val.GetSize() > SORT_KEY::INLINE_LENGTH) {
            sort_key.size = val.GetSize();
            sort_key.data.u.ptr = heap_ptr;
            memcpy(sort_key.data.u.ptr, val.GetData(), sort_key.size);
            heap_ptr += sort_key.size;
        }
    }

Construct() [2/2]

template<class SORT_KEY , bool HAS_PAYLOAD>

void duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::Construct ( const int64_t &  , data_ptr_t &    )

inline

                                                  {
        throw InternalException("VariableSortKey::Construct() called with an int64_t");
    }

Deconstruct() [1/2]

template<class SORT_KEY , bool HAS_PAYLOAD>

void duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::Deconstruct ( string_t &  val )

inline

                                    {
        auto &sort_key = static_cast<SORT_KEY &>(*this);
        if (sort_key.size > SORT_KEY::INLINE_LENGTH) {
            val = string_t(const_char_ptr_cast(sort_key.data.u.ptr), UnsafeNumericCast<uint32_t>(sort_key.size));
        } else {
            ByteSwap();
            val = string_t(const_char_ptr_cast(&sort_key.part0), UnsafeNumericCast<uint32_t>(SORT_KEY::INLINE_LENGTH));
        }
    }

Deconstruct() [2/2]

template<class SORT_KEY , bool HAS_PAYLOAD>

void duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::Deconstruct ( int64_t &  )

inline

                                {
        throw InternalException("VariableSortKey::Deconstruct() called with an int64_t");
    }

GetData()

template<class SORT_KEY , bool HAS_PAYLOAD>

data_ptr_t duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::GetData ( ) const

inline

                               {
        auto &sort_key = static_cast<const SORT_KEY &>(*this);
        return sort_key.data.u.ptr;
    }

SetData()

template<class SORT_KEY , bool HAS_PAYLOAD>

void duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::SetData ( const data_ptr_t &  data )

inline

                                         {
        auto &sort_key = static_cast<SORT_KEY &>(*this);
        sort_key.data.u.ptr = data;
    }

GetSize()

template<class SORT_KEY , bool HAS_PAYLOAD>

idx_t duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::GetSize ( ) const

inline

                          {
        auto &sort_key = static_cast<const SORT_KEY &>(*this);
        return MaxValue(sort_key.size, SORT_KEY::INLINE_LENGTH);
    }

GetHeapSize()

template<class SORT_KEY , bool HAS_PAYLOAD>

idx_t duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::GetHeapSize ( ) const

inline

                              {
        auto &sort_key = static_cast<const SORT_KEY &>(*this);
        return sort_key.size;
    }

TernaryCompare()

template<class SORT_KEY , bool HAS_PAYLOAD>

static int32_t duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::TernaryCompare ( const uint64_t &  lhs, const uint64_t &  rhs  )

inlinestatic

                                                                            {
        return (lhs > rhs) - (lhs < rhs);
    }

LessThan()

template<class SORT_KEY , bool HAS_PAYLOAD>

static int32_t duckdb::VariableSortKey< SORT_KEY, HAS_PAYLOAD >::LessThan ( const uint64_t *const &  lhs, const uint64_t *const &  rhs  )

inlinestatic

                                                                                    {
        switch (SORT_KEY::PARTS) {
        case 1:
            return TernaryCompare(lhs[0], rhs[0]);
        case 2:
            return 2 * TernaryCompare(lhs[0], rhs[0]) + TernaryCompare(lhs[1], rhs[1]);
        default:
            throw NotImplementedException("VariableSortKey::LessThan for %llu parts", SORT_KEY::PARTS);
        }
    }

Friends And Related Symbol Documentation

operator<

template<class SORT_KEY , bool HAS_PAYLOAD>

bool operator< ( const SORT_KEY &  lhs, const SORT_KEY &  rhs  )

friend

                                                                    {
        auto comp_res = LessThan(&lhs.part0, &rhs.part0);
        // If inlined is not equal, we can return already
        if (comp_res != 0) {
            return comp_res < 0;
        }
 
        // Inlined is equal. If either string is inlined, it is considered "less than"
        if (lhs.size <= SORT_KEY::INLINE_LENGTH || rhs.size <= SORT_KEY::INLINE_LENGTH) {
            return lhs.size < rhs.size;
        }
 
        // Both strings are non-inlined
        comp_res = memcmp(lhs.data.u.ptr, rhs.data.u.ptr, MinValue(lhs.size, rhs.size));
        return comp_res < 0 || (comp_res == 0 && lhs.size < rhs.size);
    }

---

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

• external/duckdb/duckdb.cpp