duckdb::EncodingUtil Struct Reference

Static Public Member Functions
template<class T >
static idx_t	EncodeUnsignedLEB128 (data_ptr_t target, T value)
template<class T >
static idx_t	DecodeUnsignedLEB128 (const_data_ptr_t source, T &result)
template<class T >
static idx_t	EncodeSignedLEB128 (data_ptr_t target, T value)
template<class T >
static idx_t	DecodeSignedLEB128 (const_data_ptr_t source, T &result)
template<class T >
static std::enable_if< std::is_signed< T >::value, idx_t >::type	DecodeLEB128 (const_data_ptr_t source, T &result)
template<class T >
static std::enable_if< std::is_unsigned< T >::value, idx_t >::type	DecodeLEB128 (const_data_ptr_t source, T &result)
template<class T >
static std::enable_if< std::is_signed< T >::value, idx_t >::type	EncodeLEB128 (data_ptr_t target, T value)
template<class T >
static std::enable_if< std::is_unsigned< T >::value, idx_t >::type	EncodeLEB128 (data_ptr_t target, T value)

Member Function Documentation

EncodeUnsignedLEB128()

template<class T >

static idx_t duckdb::EncodingUtil::EncodeUnsignedLEB128 ( data_ptr_t  target, T  value  )

inlinestatic

                                                                  {
        static_assert(std::is_integral<T>::value, "Must be integral");
        static_assert(std::is_unsigned<T>::value, "Must be unsigned");
        static_assert(sizeof(T) <= sizeof(uint64_t), "Must be uint64_t or smaller");
 
        idx_t offset = 0;
        do {
            uint8_t byte = value & 0x7F;
            value >>= 7;
            if (value != 0) {
                byte |= 0x80;
            }
            target[offset++] = byte;
        } while (value != 0);
        return offset;
    }

DecodeUnsignedLEB128()

template<class T >

static idx_t duckdb::EncodingUtil::DecodeUnsignedLEB128 ( const_data_ptr_t  source, T &  result  )

inlinestatic

                                                                          {
        constexpr idx_t max_shift = sizeof(T) * 8;
        static_assert(std::is_integral<T>::value, "Must be integral");
        static_assert(std::is_unsigned<T>::value, "Must be unsigned");
        static_assert(sizeof(T) <= sizeof(uint64_t), "Must be uint64_t or smaller");
 
        result = 0;
        idx_t shift = 0;
        idx_t offset = 0;
        uint8_t byte;
        do {
            byte = source[offset++];
            if (shift >= max_shift) {
                throw IOException("Failed to decode LEB128 integer: data may be corrupt");
            }
            result |= static_cast<T>(byte & 0x7F) << shift;
            shift += 7;
        } while (byte & 0x80);
 
        return offset;
    }

EncodeSignedLEB128()

template<class T >

static idx_t duckdb::EncodingUtil::EncodeSignedLEB128 ( data_ptr_t  target, T  value  )

inlinestatic

                                                                {
        static_assert(std::is_integral<T>::value, "Must be integral");
        static_assert(std::is_signed<T>::value, "Must be signed");
        static_assert(sizeof(T) <= sizeof(int64_t), "Must be int64_t or smaller");
 
        idx_t offset = 0;
        do {
            uint8_t byte = value & 0x7F;
            value >>= 7;
 
            // Determine whether more bytes are needed
            if ((value == 0 && (byte & 0x40) == 0) || (value == -1 && (byte & 0x40))) {
                target[offset++] = byte;
                break;
            } else {
                byte |= 0x80;
                target[offset++] = byte;
            }
        } while (true);
        return offset;
    }

DecodeSignedLEB128()

template<class T >

static idx_t duckdb::EncodingUtil::DecodeSignedLEB128 ( const_data_ptr_t  source, T &  result  )

inlinestatic

                                                                        {
        constexpr idx_t max_shift = sizeof(T) * 8;
        static_assert(std::is_integral<T>::value, "Must be integral");
        static_assert(std::is_signed<T>::value, "Must be signed");
        static_assert(sizeof(T) <= sizeof(int64_t), "Must be int64_t or smaller");
 
        // This is used to avoid undefined behavior when shifting into the sign bit
        using unsigned_type = typename std::make_unsigned<T>::type;
 
        result = 0;
        idx_t shift = 0;
        idx_t offset = 0;
 
        uint8_t byte;
        do {
            byte = source[offset++];
            if (shift >= max_shift) {
                throw IOException("Failed to decode LEB128 integer: data may be corrupt");
            }
            result |= static_cast<unsigned_type>(byte & 0x7F) << shift;
            shift += 7;
        } while (byte & 0x80);
 
        // Sign-extend if the most significant bit of the last byte is set
        if (shift < sizeof(T) * 8 && (byte & 0x40)) {
            result |= -(static_cast<unsigned_type>(1) << shift);
        }
        return offset;
    }

DecodeLEB128() [1/2]

template<class T >

static std::enable_if< std::is_signed< T >::value, idx_t >::type duckdb::EncodingUtil::DecodeLEB128 ( const_data_ptr_t  source, T &  result  )

inlinestatic

                                                                                                  {
        return DecodeSignedLEB128(source, result);
    }

DecodeLEB128() [2/2]

template<class T >

static std::enable_if< std::is_unsigned< T >::value, idx_t >::type duckdb::EncodingUtil::DecodeLEB128 ( const_data_ptr_t  source, T &  result  )

inlinestatic

                                                                                                    {
        return DecodeUnsignedLEB128(source, result);
    }

EncodeLEB128() [1/2]

template<class T >

static std::enable_if< std::is_signed< T >::value, idx_t >::type duckdb::EncodingUtil::EncodeLEB128 ( data_ptr_t  target, T  value  )

inlinestatic

                                                                                                           {
        return EncodeSignedLEB128(target, value);
    }

EncodeLEB128() [2/2]

template<class T >

static std::enable_if< std::is_unsigned< T >::value, idx_t >::type duckdb::EncodingUtil::EncodeLEB128 ( data_ptr_t  target, T  value  )

inlinestatic

                                                                                                             {
        return EncodeUnsignedLEB128(target, value);
    }

---

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

• external/duckdb/duckdb.cpp