duckdb::DecimalCastOperation Struct Reference

Static Public Member Functions
template<class T , bool NEGATIVE>
static bool	HandleDigit (T &state, uint8_t digit)
template<class T , bool NEGATIVE>
static bool	HandleHexDigit (T &state, uint8_t digit)
template<class T , bool NEGATIVE>
static bool	HandleBinaryDigit (T &state, uint8_t digit)
template<class T , bool NEGATIVE>
static void	RoundUpResult (T &state)
template<class T , bool NEGATIVE>
static bool	HandleExponent (T &state, int32_t exponent)
template<class T , bool NEGATIVE, bool ALLOW_EXPONENT>
static bool	HandleDecimal (T &state, uint8_t digit)
template<class T , bool NEGATIVE>
static bool	TruncateExcessiveDecimals (T &state)
template<class T , bool NEGATIVE>
static bool	Finalize (T &state)

Member Function Documentation

HandleDigit()

template<class T , bool NEGATIVE>

static bool duckdb::DecimalCastOperation::HandleDigit ( T &  state, uint8_t  digit  )

inlinestatic

                                                     {
        if (state.result == 0 && digit == 0) {
            // leading zero's don't count towards the digit count
            return true;
        }
        if (state.digit_count == state.width - state.scale) {
            // width of decimal type is exceeded!
            return false;
        }
        state.digit_count++;
        if (NEGATIVE) {
            if (state.result < (NumericLimits<typename T::StoreType>::Minimum() / 10)) {
                return false;
            }
            state.result = state.result * 10 - digit;
        } else {
            if (state.result > (NumericLimits<typename T::StoreType>::Maximum() / 10)) {
                return false;
            }
            state.result = state.result * 10 + digit;
        }
        return true;
    }

HandleHexDigit()

template<class T , bool NEGATIVE>

static bool duckdb::DecimalCastOperation::HandleHexDigit ( T &  state, uint8_t  digit  )

inlinestatic

                                                        {
        return false;
    }

HandleBinaryDigit()

template<class T , bool NEGATIVE>

static bool duckdb::DecimalCastOperation::HandleBinaryDigit ( T &  state, uint8_t  digit  )

inlinestatic

                                                           {
        return false;
    }

RoundUpResult()

template<class T , bool NEGATIVE>

static void duckdb::DecimalCastOperation::RoundUpResult ( T &  state )

inlinestatic

                                        {
        if (NEGATIVE) {
            state.result -= 1;
        } else {
            state.result += 1;
        }
    }

HandleExponent()

template<class T , bool NEGATIVE>

static bool duckdb::DecimalCastOperation::HandleExponent ( T &  state, int32_t  exponent  )

inlinestatic

                                                           {
        auto decimal_excess = (state.decimal_count > state.scale) ? state.decimal_count - state.scale : 0;
        if (exponent > 0) {
            state.exponent_type = ExponentType::POSITIVE;
            // Positive exponents need up to 'exponent' amount of digits
            // Everything beyond that amount needs to be truncated
            if (decimal_excess > exponent) {
                // We've allowed too many decimals
                state.excessive_decimals = UnsafeNumericCast<uint8_t>(decimal_excess - exponent);
                exponent = 0;
            } else {
                exponent -= decimal_excess;
            }
            D_ASSERT(exponent >= 0);
        } else if (exponent < 0) {
            state.exponent_type = ExponentType::NEGATIVE;
        }
        if (!Finalize<T, NEGATIVE>(state)) {
            return false;
        }
        if (exponent < 0) {
            bool round_up = false;
            for (idx_t i = 0; i < idx_t(-int64_t(exponent)); i++) {
                auto mod = state.result % 10;
                round_up = NEGATIVE ? mod <= -5 : mod >= 5;
                state.result /= 10;
                if (state.result == 0) {
                    break;
                }
            }
            if (round_up) {
                RoundUpResult<T, NEGATIVE>(state);
            }
            return true;
        } else {
            // positive exponent: append 0's
            for (idx_t i = 0; i < idx_t(exponent); i++) {
                if (!HandleDigit<T, NEGATIVE>(state, 0)) {
                    return false;
                }
            }
            return true;
        }
    }

HandleDecimal()

template<class T , bool NEGATIVE, bool ALLOW_EXPONENT>

static bool duckdb::DecimalCastOperation::HandleDecimal ( T &  state, uint8_t  digit  )

inlinestatic

If we expect an exponent, we need to preserve the decimals But we don't want to overflow, so we prevent overflowing the result with this check

                                                       {
        if (state.decimal_count == state.scale && !state.round_set) {
            // Determine whether the last registered decimal should be rounded or not
            state.round_set = true;
            state.should_round = digit >= 5;
        }
        if (!ALLOW_EXPONENT && state.decimal_count == state.scale) {
            // we exceeded the amount of supported decimals
            // however, we don't throw an error here
            // we just truncate the decimal
            return true;
        }
        if (state.digit_count + state.decimal_count >= DecimalWidth<decltype(state.result)>::max) {
            return true;
        }
        state.decimal_count++;
        if (NEGATIVE) {
            state.result = state.result * 10 - digit;
        } else {
            state.result = state.result * 10 + digit;
        }
        return true;
    }

Here is the call graph for this function:

TruncateExcessiveDecimals()

template<class T , bool NEGATIVE>

static bool duckdb::DecimalCastOperation::TruncateExcessiveDecimals ( T &  state )

inlinestatic

Only round up when exponents are involved

                                                    {
        D_ASSERT(state.excessive_decimals);
        bool round_up = false;
        for (idx_t i = 0; i < state.excessive_decimals; i++) {
            auto mod = state.result % 10;
            round_up = NEGATIVE ? mod <= -5 : mod >= 5;
            state.result /= static_cast<typename T::StoreType>(10.0);
        }
        if (state.exponent_type == ExponentType::POSITIVE && round_up) {
            RoundUpResult<T, NEGATIVE>(state);
        }
        D_ASSERT(state.decimal_count > state.scale);
        state.decimal_count = state.scale;
        return true;
    }

Finalize()

template<class T , bool NEGATIVE>

static bool duckdb::DecimalCastOperation::Finalize ( T &  state )

inlinestatic

Did not encounter an exponent, but ALLOW_EXPONENT was on

                                   {
        if (state.exponent_type != ExponentType::POSITIVE && state.decimal_count > state.scale) {
            state.excessive_decimals = state.decimal_count - state.scale;
        }
        if (state.excessive_decimals && !TruncateExcessiveDecimals<T, NEGATIVE>(state)) {
            return false;
        }
        if (state.exponent_type == ExponentType::NONE && state.round_set && state.should_round) {
            RoundUpResult<T, NEGATIVE>(state);
        }
        //  if we have not gotten exactly "scale" decimals, we need to multiply the result
        //  e.g. if we have a string "1.0" that is cast to a DECIMAL(9,3), the value needs to be 1000
        //  but we have only gotten the value "10" so far, so we multiply by 1000
        for (uint8_t i = state.decimal_count; i < state.scale; i++) {
            state.result *= 10;
        }
        if (NEGATIVE) {
            return state.result > -state.limit;
        } else {
            return state.result < state.limit;
        }
    }

---

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

• external/duckdb/duckdb.cpp