duckdb::BignumIntermediate Struct Reference

Public Member Functions
	BignumIntermediate (const bignum_t &value)
	BignumIntermediate (uint8_t *value, idx_t size)
void	Print () const
AbsoluteNumberComparison	IsAbsoluteBigger (const BignumIntermediate &rhs) const
uint8_t	GetAbsoluteByte (int64_t index) const
	Get the absolute value of a byte.
bool	IsMSBSet () const
	If the most significant bit of the first byte is set.
void	Initialize (ArenaAllocator &allocator)
	Initializes our bignum to 0 and 1 byte.
void	Reallocate (ArenaAllocator &allocator, idx_t min_size)
	If necessary, we reallocate our intermediate to the next power of 2.
uint32_t	GetStartDataPos () const
void	Trim ()
void	AddInPlace (ArenaAllocator &allocator, const BignumIntermediate &rhs)
	Add a BignumIntermediate to another BignumIntermediate, equivalent of a +=.
string_t	Negate (Vector &result_vector) const
	Negates a value, e.g., -x.
void	NegateInPlace ()
bignum_t	ToBignum (ArenaAllocator &allocator)
	Exports to a bignum, either arena allocated.
bool	OverOrUnderflow () const

Static Public Member Functions
static uint32_t	GetStartDataPos (data_ptr_t data, idx_t size, bool is_negative)
static idx_t	Trim (data_ptr_t data, uint32_t &size, bool is_negative)
	In case we have unnecessary extra 0's or 1's in our bignum we trim them.
static string_t	Add (Vector &result, const BignumIntermediate &lhs, const BignumIntermediate &rhs)
	Adds two BignumIntermediates and returns a string_t result, equivalent of a +.
static bool	OverOrUnderflow (data_ptr_t data, idx_t size, bool is_negative)
	Check if an over/underflow has occurred.

Public Attributes
bool	is_negative
	Information on the header.
uint32_t	size
data_ptr_t	data
	The actual data.

Constructor & Destructor Documentation

BignumIntermediate() [1/3]

duckdb::BignumIntermediate::BignumIntermediate ( )

inline

: is_negative(false), size(0), data(nullptr) {};

BignumIntermediate() [2/3]

duckdb::BignumIntermediate::BignumIntermediate ( const bignum_t &  value )

explicit

                                                            {
    is_negative = (value.data.GetData()[0] & 0x80) == 0;
    data = reinterpret_cast<data_ptr_t>(value.data.GetDataWriteable() + Bignum::BIGNUM_HEADER_SIZE);
    size = static_cast<uint32_t>(value.data.GetSize()) - Bignum::BIGNUM_HEADER_SIZE;
}

BignumIntermediate() [3/3]

duckdb::BignumIntermediate::BignumIntermediate	(	uint8_t *	value,
		idx_t	size
	)

                                                                     {
    is_negative = (value[0] & 0x80) == 0;
    data = value + Bignum::BIGNUM_HEADER_SIZE;
    size = static_cast<uint32_t>(ptr_size) - Bignum::BIGNUM_HEADER_SIZE;
}

Member Function Documentation

Print()

void duckdb::BignumIntermediate::Print

(

)

const

                                     {
    string result;
    for (idx_t i = 0; i < size; ++i) {
        for (int j = 7; j >= 0; --j) {
            result += to_string((data[i] >> j) & 1);
        }
        result += "  ";
    }
    Printer::Print(OutputStream::STREAM_STDOUT, result);
}

IsAbsoluteBigger()

AbsoluteNumberComparison duckdb::BignumIntermediate::IsAbsoluteBigger

(

const BignumIntermediate &

rhs

)

const

If the absolute number is bigger than the absolute rhs 1 = true, 0 = equal, -1 = false

                                                                                                 {
    idx_t actual_start_pos = GetStartDataPos();
    idx_t actual_size = size - actual_start_pos;
 
    idx_t rhs_actual_start_pos = rhs.GetStartDataPos();
    idx_t rhs_actual_size = rhs.size - rhs_actual_start_pos;
 
    // we have opposing signs, gotta do a bunch of checks to figure out who is the biggest
    // check sizes
    if (actual_size > rhs_actual_size) {
        return GREATER;
    }
    if (actual_size < rhs_actual_size) {
        return SMALLER;
    } else {
        // they have the same size then
        idx_t target_idx = actual_start_pos;
        idx_t source_idx = rhs_actual_start_pos;
        while (target_idx < size) {
            auto data_byte = GetAbsoluteByte(static_cast<int64_t>(target_idx));
            auto rhs_byte = rhs.GetAbsoluteByte(static_cast<int64_t>(source_idx));
            if (data_byte > rhs_byte) {
                return GREATER;
            } else if (data_byte < rhs_byte) {
                return SMALLER;
            }
            target_idx++;
            source_idx++;
        }
    }
    // If we got here, the values are equal.
    return EQUAL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetAbsoluteByte()

uint8_t duckdb::BignumIntermediate::GetAbsoluteByte

(

int64_t

index

)

const

Get the absolute value of a byte.

                                                               {
    if (index < 0) {
        // byte-extension
        return 0;
    }
    return is_negative ? static_cast<uint8_t>(~data[index]) : static_cast<uint8_t>(data[index]);
}

Here is the caller graph for this function:

IsMSBSet()

bool duckdb::BignumIntermediate::IsMSBSet

(

)

const

If the most significant bit of the first byte is set.

                                        {
    if (is_negative) {
        return (data[0] & 0x80) == 0;
    }
    return (data[0] & 0x80) != 0;
}

Here is the caller graph for this function:

Initialize()

void duckdb::BignumIntermediate::Initialize

(

ArenaAllocator &

allocator

)

Initializes our bignum to 0 and 1 byte.

                                                             {
    is_negative = false;
    size = 1;
    data = allocator.Allocate(size);
    // initialize the data
    data[0] = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Reallocate()

void duckdb::BignumIntermediate::Reallocate	(	ArenaAllocator &	allocator,
		idx_t	min_size
	)

If necessary, we reallocate our intermediate to the next power of 2.

                                                                             {
    if (min_size < size) {
        return;
    }
    uint32_t new_size = size;
    while (new_size <= min_size) {
        new_size *= 2;
    }
    auto new_data = allocator.Allocate(new_size);
    // Then we initialize to 0's until we have valid data again
    memset(new_data, is_negative ? 0xFF : 0x00, new_size - size);
    // Copy the old data to the new data
    memcpy(new_data + new_size - size, data, size);
    // Set size and pointer
    data = new_data;
    size = new_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetStartDataPos() [1/2]

uint32_t duckdb::BignumIntermediate::GetStartDataPos ( data_ptr_t  data, idx_t  size, bool  is_negative  )

static

                                                                                          {
    uint8_t non_initialized = is_negative ? 0xFF : 0x00;
    uint32_t actual_start = 0;
    for (idx_t i = 0; i < size; ++i) {
        if (data[i] == non_initialized) {
            actual_start++;
        } else {
            break;
        }
    }
    return actual_start;
}

GetStartDataPos() [2/2]

uint32_t duckdb::BignumIntermediate::GetStartDataPos

(

)

const

                                                   {
    return GetStartDataPos(data, size, is_negative);
}

Trim() [1/2]

idx_t duckdb::BignumIntermediate::Trim ( data_ptr_t  data, uint32_t &  size, bool  is_negative  )

static

In case we have unnecessary extra 0's or 1's in our bignum we trim them.

                                                                                {
    auto actual_start = GetStartDataPos(data, size, is_negative);
    if (actual_start == 0) {
        return 0;
    }
    // This bad-boy is wearing shoe lifts, time to prune it.
    D_ASSERT(actual_start <= size);
    size -= actual_start;
    if (size == 0) {
        // Always keep at least one byte
        actual_start = 0;
        size++;
    }
    memmove(data, data + actual_start, size);
    return actual_start;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Trim() [2/2]

void duckdb::BignumIntermediate::Trim

(

)

                              {
    Trim(data, size, is_negative);
}

AddInPlace()

void duckdb::BignumIntermediate::AddInPlace	(	ArenaAllocator &	allocator,
		const BignumIntermediate &	rhs
	)

Add a BignumIntermediate to another BignumIntermediate, equivalent of a +=.

                                                                                            {
    const bool same_sign = is_negative == rhs.is_negative;
    idx_t actual_size = size - GetStartDataPos();
    idx_t actual_rhs_size = rhs.size - rhs.GetStartDataPos();
    if (actual_size < actual_rhs_size || (same_sign && (IsMSBSet() || (rhs.IsMSBSet() && size == rhs.size)))) {
        // We must reallocate
        idx_t min_size = actual_size < actual_rhs_size ? actual_rhs_size + 1 : size + 1;
        Reallocate(allocator, min_size);
    }
    bool is_target_absolute_bigger = true;
    if (rhs.is_negative != is_negative) {
        auto is_absolute_bigger = IsAbsoluteBigger(rhs);
        if (is_absolute_bigger == EQUAL) {
            // We set this value to 0
            *this = BignumIntermediate();
            Initialize(allocator);
            return;
        } else if (is_absolute_bigger == SMALLER) {
            is_target_absolute_bigger = false;
        }
    }
 
    bool is_result_negative = is_target_absolute_bigger ? is_negative : rhs.is_negative;
    BignumAddition(data, size, is_target_absolute_bigger, *this, rhs);
    if (is_result_negative != is_negative) {
        is_negative = is_result_negative;
    }
    if (OverOrUnderflow()) {
        // We must throw an error, usually we should print the numbers, but I have a feeling that it won't be possible
        // here.
        throw OutOfRangeException(ProduceOverUnderFlowError(is_result_negative, GetStartDataPos(), size));
    }
}

Here is the call graph for this function:

Add()

string_t duckdb::BignumIntermediate::Add ( Vector &  result, const BignumIntermediate &  lhs, const BignumIntermediate &  rhs  )

static

Adds two BignumIntermediates and returns a string_t result, equivalent of a +.

                                                                                                                    {
    const bool same_sign = lhs.is_negative == rhs.is_negative;
    const uint32_t actual_size = lhs.size - lhs.GetStartDataPos();
    const uint32_t actual_rhs_size = rhs.size - rhs.GetStartDataPos();
    uint32_t result_size = actual_size;
    if (actual_size < actual_rhs_size || (same_sign && (lhs.IsMSBSet() || (rhs.IsMSBSet() && lhs.size == rhs.size)))) {
        result_size = actual_size < actual_rhs_size ? actual_rhs_size + 1 : actual_size + 1;
    }
    bool is_target_absolute_bigger = true;
    if (result_size == 0) {
        result_size++;
    }
    result_size += Bignum::BIGNUM_HEADER_SIZE;
    if (lhs.is_negative != rhs.is_negative) {
        auto is_absolute_bigger = lhs.IsAbsoluteBigger(rhs);
        if (is_absolute_bigger == EQUAL) {
            // We set this value to 0
            auto target = StringVector::EmptyString(result_vector, result_size);
            auto target_data = target.GetDataWriteable();
            Bignum::SetHeader(target_data, 1, false);
            target_data[Bignum::BIGNUM_HEADER_SIZE] = 0;
            target.SetSizeAndFinalize(1 + Bignum::BIGNUM_HEADER_SIZE, result_size);
            return target;
 
        } else if (is_absolute_bigger == SMALLER) {
            is_target_absolute_bigger = false;
        }
    }
 
    auto target = StringVector::EmptyString(result_vector, result_size);
    auto result_size_data = result_size - Bignum::BIGNUM_HEADER_SIZE;
 
    auto target_data = target.GetDataWriteable();
    BignumAddition(reinterpret_cast<data_ptr_t>(target_data + Bignum::BIGNUM_HEADER_SIZE), result_size_data,
                   is_target_absolute_bigger, lhs, rhs);
    bool is_result_negative = is_target_absolute_bigger ? lhs.is_negative : rhs.is_negative;
    if (OverOrUnderflow(reinterpret_cast<data_ptr_t>(target_data + Bignum::BIGNUM_HEADER_SIZE), result_size_data,
                        is_result_negative)) {
        auto actual_start = GetStartDataPos(reinterpret_cast<data_ptr_t>(target_data + Bignum::BIGNUM_HEADER_SIZE),
                                            result_size_data, is_result_negative);
        throw OutOfRangeException(ProduceOverUnderFlowError(is_result_negative, actual_start, result_size_data));
    }
    Trim(reinterpret_cast<data_ptr_t>(target_data + Bignum::BIGNUM_HEADER_SIZE), result_size_data, is_result_negative);
    Bignum::SetHeader(target_data, result_size_data, is_result_negative);
    target.SetSizeAndFinalize(result_size_data + Bignum::BIGNUM_HEADER_SIZE, result_size);
    return target;
}

Here is the call graph for this function:

Negate()

string_t duckdb::BignumIntermediate::Negate

(

Vector &

result_vector

)

const

Negates a value, e.g., -x.

                                                               {
    auto target = StringVector::EmptyString(result_vector, size + Bignum::BIGNUM_HEADER_SIZE);
    auto ptr = target.GetDataWriteable();
 
    if (!is_negative && size == 1 && data[0] == 0x00) {
        // If we have a zero, we just do a copy
        Bignum::SetHeader(ptr, size, is_negative);
        for (idx_t i = 0; i < size; ++i) {
            ptr[i + Bignum::BIGNUM_HEADER_SIZE] = static_cast<char>(data[i]);
        }
    } else {
        // Otherwise, we set the header with a flip on the signal
        Bignum::SetHeader(ptr, size, !is_negative);
        for (idx_t i = 0; i < size; ++i) {
            // And flip all the data bits
            ptr[i + Bignum::BIGNUM_HEADER_SIZE] = static_cast<char>(~data[i]);
        }
    }
 
    return target;
}

Here is the call graph for this function:

NegateInPlace()

void duckdb::BignumIntermediate::NegateInPlace

(

)

                                       {
    if (!is_negative && size == 1 && data[0] == 0x00) {
        // this is a zero, there is no negation
        return;
    }
    is_negative = !is_negative;
    for (size_t i = 0; i < size; i++) {
        data[i] = ~data[i]; // flip each byte of the pointer
    }
}

ToBignum()

bignum_t duckdb::BignumIntermediate::ToBignum

(

ArenaAllocator &

allocator

)

Exports to a bignum, either arena allocated.

                                                               {
    // This must be trimmed before transforming
    Trim();
    bignum_t result;
    uint32_t bignum_size = Bignum::BIGNUM_HEADER_SIZE + size;
    auto ptr = reinterpret_cast<char *>(allocator.Allocate(bignum_size));
    // Set Header
    Bignum::SetHeader(ptr, size, is_negative);
    // Copy data
    memcpy(ptr + Bignum::BIGNUM_HEADER_SIZE, data, size);
    result.data = string_t(ptr, bignum_size);
    return result;
}

Here is the call graph for this function:

OverOrUnderflow() [1/2]

bool duckdb::BignumIntermediate::OverOrUnderflow ( data_ptr_t  data, idx_t  size, bool  is_negative  )

static

Check if an over/underflow has occurred.

                                                                                      {
    if (size <= Bignum::MAX_DATA_SIZE) {
        return false;
    }
    // variable that stores a fully unset byte can safely be ignored
    uint8_t byte_to_compare = is_negative ? 0xFF : 0x00;
    // we will basically check if any byte has any set bit up to Bignum::MAX_DATA_SIZE, if so, that's an under/overflow
    idx_t data_pos = 0;
    for (idx_t i = size; i > Bignum::MAX_DATA_SIZE; i--) {
        if (data[data_pos++] != byte_to_compare) {
            return true;
        }
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

OverOrUnderflow() [2/2]

bool duckdb::BignumIntermediate::OverOrUnderflow

(

)

const

                                               {
    return OverOrUnderflow(data, size, is_negative);
}

---

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

• external/duckdb/duckdb.cpp