duckdb::Radix Struct Reference

Public Member Functions
template<>
void	EncodeData (data_ptr_t dataptr, bool value)
template<>
void	EncodeData (data_ptr_t dataptr, int8_t value)
template<>
void	EncodeData (data_ptr_t dataptr, int16_t value)
template<>
void	EncodeData (data_ptr_t dataptr, int32_t value)
template<>
void	EncodeData (data_ptr_t dataptr, int64_t value)
template<>
void	EncodeData (data_ptr_t dataptr, uint8_t value)
template<>
void	EncodeData (data_ptr_t dataptr, uint16_t value)
template<>
void	EncodeData (data_ptr_t dataptr, uint32_t value)
template<>
void	EncodeData (data_ptr_t dataptr, uint64_t value)
template<>
void	EncodeData (data_ptr_t dataptr, hugeint_t value)
template<>
void	EncodeData (data_ptr_t dataptr, uhugeint_t value)
template<>
void	EncodeData (data_ptr_t dataptr, float value)
template<>
void	EncodeData (data_ptr_t dataptr, double value)
template<>
void	EncodeData (data_ptr_t dataptr, interval_t value)
template<>
bool	DecodeData (const_data_ptr_t input)
template<>
int8_t	DecodeData (const_data_ptr_t input)
template<>
int16_t	DecodeData (const_data_ptr_t input)
template<>
int32_t	DecodeData (const_data_ptr_t input)
template<>
int64_t	DecodeData (const_data_ptr_t input)
template<>
uint8_t	DecodeData (const_data_ptr_t input)
template<>
uint16_t	DecodeData (const_data_ptr_t input)
template<>
uint32_t	DecodeData (const_data_ptr_t input)
template<>
uint64_t	DecodeData (const_data_ptr_t input)
template<>
hugeint_t	DecodeData (const_data_ptr_t input)
template<>
uhugeint_t	DecodeData (const_data_ptr_t input)
template<>
float	DecodeData (const_data_ptr_t input)
template<>
double	DecodeData (const_data_ptr_t input)
template<>
interval_t	DecodeData (const_data_ptr_t input)

Static Public Member Functions
template<class T >
static void	EncodeData (data_ptr_t dataptr, T value)
template<class T >
static T	DecodeData (const_data_ptr_t input)
static void	EncodeStringDataPrefix (data_ptr_t dataptr, string_t value, idx_t prefix_len)
static uint8_t	FlipSign (uint8_t key_byte)
static uint32_t	EncodeFloat (float x)
static float	DecodeFloat (uint32_t input)
static uint64_t	EncodeDouble (double x)
static double	DecodeDouble (uint64_t input)

Static Private Member Functions
template<class T >
static void	EncodeSigned (data_ptr_t dataptr, T value)
template<class T >
static T	DecodeSigned (const_data_ptr_t input)

Member Function Documentation

EncodeData() [1/15]

template<class T >

static void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, T  value  )

inlinestatic

                                                               {
        throw NotImplementedException("Cannot create data from this type");
    }

DecodeData() [1/15]

template<class T >

static T duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inlinestatic

                                                       {
        throw NotImplementedException("Cannot read data from this type");
    }

EncodeStringDataPrefix()

static void duckdb::Radix::EncodeStringDataPrefix ( data_ptr_t  dataptr, string_t  value, idx_t  prefix_len  )

inlinestatic

                                                                                                    {
        auto len = value.GetSize();
        memcpy(dataptr, value.GetData(), MinValue(len, prefix_len));
        if (len < prefix_len) {
            memset(dataptr + len, '\0', prefix_len - len);
        }
    }

FlipSign()

static uint8_t duckdb::Radix::FlipSign ( uint8_t  key_byte )

inlinestatic

                                                     {
        return key_byte ^ 128;
    }

EncodeFloat()

static uint32_t duckdb::Radix::EncodeFloat ( float  x )

inlinestatic

zero

infinity

-infinity

+0 and positive numbers

negative numbers

complement 1

                                                {
        uint32_t buff;
        if (x == 0) {
            buff = 0;
            buff |= (1u << 31);
            return buff;
        }
 
        // nan
        if (Value::IsNan(x)) {
            return UINT_MAX;
        }
        if (x > FLT_MAX) {
            return UINT_MAX - 1;
        }
        if (x < -FLT_MAX) {
            return 0;
        }
        buff = Load<uint32_t>(const_data_ptr_cast(&x));
        if ((buff & (1U << 31)) == 0) { 
            buff |= (1U << 31);
        } else {          
            buff = ~buff; 
        }
 
        return buff;
    }

DecodeFloat()

static float duckdb::Radix::DecodeFloat ( uint32_t  input )

inlinestatic

                                                    {
        // nan
        if (input == UINT_MAX) {
            return std::numeric_limits<float>::quiet_NaN();
        }
        if (input == UINT_MAX - 1) {
            return std::numeric_limits<float>::infinity();
        }
        if (input == 0) {
            return -std::numeric_limits<float>::infinity();
        }
        float result;
        if (input & (1U << 31)) {
            // positive numbers - flip sign bit
            input = input ^ (1U << 31);
        } else {
            // negative numbers - invert
            input = ~input;
        }
        Store<uint32_t>(input, data_ptr_cast(&result));
        return result;
    }

EncodeDouble()

static uint64_t duckdb::Radix::EncodeDouble ( double  x )

inlinestatic

zero

infinity

-infinity

+0 and positive numbers

negative numbers

complement 1

                                                  {
        uint64_t buff;
        if (x == 0) {
            buff = 0;
            buff += (1ULL << 63);
            return buff;
        }
        // nan
        if (Value::IsNan(x)) {
            return ULLONG_MAX;
        }
        if (x > DBL_MAX) {
            return ULLONG_MAX - 1;
        }
        if (x < -DBL_MAX) {
            return 0;
        }
        buff = Load<uint64_t>(const_data_ptr_cast(&x));
        if (buff < (1ULL << 63)) { 
            buff += (1ULL << 63);
        } else {          
            buff = ~buff; 
        }
        return buff;
    }

DecodeDouble()

static double duckdb::Radix::DecodeDouble ( uint64_t  input )

inlinestatic

                                                      {
        // nan
        if (input == ULLONG_MAX) {
            return std::numeric_limits<double>::quiet_NaN();
        }
        if (input == ULLONG_MAX - 1) {
            return std::numeric_limits<double>::infinity();
        }
        if (input == 0) {
            return -std::numeric_limits<double>::infinity();
        }
        double result;
        if (input & (1ULL << 63)) {
            // positive numbers - flip sign bit
            input = input ^ (1ULL << 63);
        } else {
            // negative numbers - invert
            input = ~input;
        }
        Store<uint64_t>(input, data_ptr_cast(&result));
        return result;
    }

EncodeSigned()

template<class T >

void duckdb::Radix::EncodeSigned ( data_ptr_t  dataptr, T  value  )

staticprivate

                                                    {
    using UNSIGNED = typename MakeUnsigned<T>::type;
    UNSIGNED bytes;
    Store<T>(value, data_ptr_cast(&bytes));
    Store<UNSIGNED>(BSwapIfLE(bytes), dataptr);
    dataptr[0] = FlipSign(dataptr[0]);
}

DecodeSigned()

template<class T >

T duckdb::Radix::DecodeSigned ( const_data_ptr_t  input )

staticprivate

                                            {
    using UNSIGNED = typename MakeUnsigned<T>::type;
    UNSIGNED bytes = Load<UNSIGNED>(input);
    auto bytes_data = data_ptr_cast(&bytes);
    bytes_data[0] = FlipSign(bytes_data[0]);
    T result;
    Store<UNSIGNED>(BSwapIfLE(bytes), data_ptr_cast(&result));
    return result;
}

EncodeData() [2/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, bool  value  )

inline

                                                            {
    Store<uint8_t>(value ? 1 : 0, dataptr);
}

EncodeData() [3/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, int8_t  value  )

inline

                                                              {
    EncodeSigned<int8_t>(dataptr, value);
}

EncodeData() [4/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, int16_t  value  )

inline

                                                               {
    EncodeSigned<int16_t>(dataptr, value);
}

EncodeData() [5/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, int32_t  value  )

inline

                                                               {
    EncodeSigned<int32_t>(dataptr, value);
}

EncodeData() [6/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, int64_t  value  )

inline

                                                               {
    EncodeSigned<int64_t>(dataptr, value);
}

EncodeData() [7/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, uint8_t  value  )

inline

                                                               {
    Store<uint8_t>(value, dataptr);
}

EncodeData() [8/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, uint16_t  value  )

inline

                                                                {
    Store<uint16_t>(BSwapIfLE(value), dataptr);
}

EncodeData() [9/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, uint32_t  value  )

inline

                                                                {
    Store<uint32_t>(BSwapIfLE(value), dataptr);
}

EncodeData() [10/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, uint64_t  value  )

inline

                                                                {
    Store<uint64_t>(BSwapIfLE(value), dataptr);
}

EncodeData() [11/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, hugeint_t  value  )

inline

                                                                 {
    EncodeData<int64_t>(dataptr, value.upper);
    EncodeData<uint64_t>(dataptr + sizeof(value.upper), value.lower);
}

EncodeData() [12/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, uhugeint_t  value  )

inline

                                                                  {
    EncodeData<uint64_t>(dataptr, value.upper);
    EncodeData<uint64_t>(dataptr + sizeof(value.upper), value.lower);
}

EncodeData() [13/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, float  value  )

inline

                                                             {
    uint32_t converted_value = EncodeFloat(value);
    Store<uint32_t>(BSwapIfLE(converted_value), dataptr);
}

EncodeData() [14/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, double  value  )

inline

                                                              {
    uint64_t converted_value = EncodeDouble(value);
    Store<uint64_t>(BSwapIfLE(converted_value), dataptr);
}

EncodeData() [15/15]

template<>

void duckdb::Radix::EncodeData ( data_ptr_t  dataptr, interval_t  value  )

inline

                                                                  {
    EncodeData<int32_t>(dataptr, value.months);
    dataptr += sizeof(value.months);
    EncodeData<int32_t>(dataptr, value.days);
    dataptr += sizeof(value.days);
    EncodeData<int64_t>(dataptr, value.micros);
}

DecodeData() [2/15]

template<>

bool duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                    {
    return Load<uint8_t>(input) != 0;
}

DecodeData() [3/15]

template<>

int8_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                      {
    return DecodeSigned<int8_t>(input);
}

DecodeData() [4/15]

template<>

int16_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                       {
    return DecodeSigned<int16_t>(input);
}

DecodeData() [5/15]

template<>

int32_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                       {
    return DecodeSigned<int32_t>(input);
}

DecodeData() [6/15]

template<>

int64_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                       {
    return DecodeSigned<int64_t>(input);
}

DecodeData() [7/15]

template<>

uint8_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                       {
    return Load<uint8_t>(input);
}

DecodeData() [8/15]

template<>

uint16_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                        {
    return BSwapIfLE(Load<uint16_t>(input));
}

DecodeData() [9/15]

template<>

uint32_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                        {
    return BSwapIfLE(Load<uint32_t>(input));
}

DecodeData() [10/15]

template<>

uint64_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                        {
    return BSwapIfLE(Load<uint64_t>(input));
}

DecodeData() [11/15]

template<>

hugeint_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                         {
    hugeint_t result;
    result.upper = DecodeData<int64_t>(input);
    result.lower = DecodeData<uint64_t>(input + sizeof(int64_t));
    return result;
}

DecodeData() [12/15]

template<>

uhugeint_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                          {
    uhugeint_t result;
    result.upper = DecodeData<uint64_t>(input);
    result.lower = DecodeData<uint64_t>(input + sizeof(uint64_t));
    return result;
}

DecodeData() [13/15]

template<>

float duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                     {
    return DecodeFloat(BSwapIfLE(Load<uint32_t>(input)));
}

DecodeData() [14/15]

template<>

double duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                      {
    return DecodeDouble(BSwapIfLE(Load<uint64_t>(input)));
}

DecodeData() [15/15]

template<>

interval_t duckdb::Radix::DecodeData ( const_data_ptr_t  input )

inline

                                                          {
    interval_t result;
    result.months = DecodeData<int32_t>(input);
    result.days = DecodeData<int32_t>(input + sizeof(int32_t));
    result.micros = DecodeData<int64_t>(input + sizeof(int32_t) + sizeof(int32_t));
    return result;
}

---

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

• external/duckdb/duckdb.cpp