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

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

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

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

Static Public Attributes
static constexpr bool	CONSTANT_SIZE = true

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::FixedSortKey< 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::FixedSortKey< SORT_KEY, HAS_PAYLOAD >::Construct ( const string_t &  str, data_ptr_t &    )

inline

                                                      {
        D_ASSERT(str.GetSize() <= SORT_KEY::INLINE_LENGTH);
        auto &sort_key = static_cast<SORT_KEY &>(*this);
        for (idx_t i = 0; i < SORT_KEY::PARTS; i++) {
            (&sort_key.part0)[i] = 0;
        }
 
        if (SORT_KEY::INLINE_LENGTH <= string_t::INLINE_LENGTH) {
            memcpy(&sort_key.part0, str.GetPrefix(), SORT_KEY::INLINE_LENGTH);
        } else if (str.IsInlined()) {
            memcpy(&sort_key.part0, str.GetPrefix(), string_t::INLINE_LENGTH);
        } else {
            FastMemcpy(&sort_key.part0, str.GetPointer(), str.GetSize());
        }
 
        // IMPORTANT NOTE: We don't actually store the data in byte-comparable order!
        // This allows us to do int64_t comparisons, yielding better performance.
        // This means we have to ByteSwap once more when decoding the keys later.
        ByteSwap();
    }

Construct() [2/2]

template<class SORT_KEY , bool HAS_PAYLOAD>

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

inline

                                                     {
        auto &sort_key = static_cast<SORT_KEY &>(*this);
        sort_key.part0 = static_cast<uint64_t>(val); // NOLINT: unsafe cast on purpose
    }

Deconstruct() [1/2]

template<class SORT_KEY , bool HAS_PAYLOAD>

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

inline

                                    {
        auto &sort_key = static_cast<SORT_KEY &>(*this);
        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::FixedSortKey< SORT_KEY, HAS_PAYLOAD >::Deconstruct ( int64_t &  val )

inline

                                   {
        auto &sort_key = static_cast<SORT_KEY &>(*this);
        val = static_cast<int64_t>(sort_key.part0); // NOLINT: unsafe cast on purpose
    }

GetData()

template<class SORT_KEY , bool HAS_PAYLOAD>

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

inline

                               {
        throw InternalException("GetData() called on a FixedSortKey");
    }

GetSize()

template<class SORT_KEY , bool HAS_PAYLOAD>

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

inline

                          {
        throw InternalException("GetSize() called on a FixedSortKey");
    }

GetHeapSize()

template<class SORT_KEY , bool HAS_PAYLOAD>

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

inline

                              {
        throw InternalException("GetHeapSize() called on a FixedSortKey");
    }

Friends And Related Symbol Documentation

operator<

template<class SORT_KEY , bool HAS_PAYLOAD>

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

friend

                                                                    {
        return SortKeyLessThan<SORT_KEY::PARTS>(&lhs.part0, &rhs.part0);
    }

---

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

• external/duckdb/duckdb.cpp