duckdb::IntegerDecimalCastOperation Struct Reference

Inheritance diagram for duckdb::IntegerDecimalCastOperation:

Collaboration diagram for duckdb::IntegerDecimalCastOperation:

Static Public Member Functions
template<class T , bool NEGATIVE>
static bool	HandleExponent (T &state, int16_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	Finalize (T &state)
Static Public Member Functions inherited from duckdb::IntegerCastOperation
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 bool	HandleExponent (T &state, int16_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	Finalize (T &state)

Member Function Documentation

HandleExponent()

template<class T , bool NEGATIVE>

static bool duckdb::IntegerDecimalCastOperation::HandleExponent ( T &  state, int16_t  exponent  )

inlinestatic

                                                           {
        using store_t = typename T::StoreType;
 
        int16_t e = exponent;
        // Negative Exponent
        if (e < 0) {
            while (e++ < 0) {
                state.decimal = state.result % 10;
                state.result /= 10;
                if (state.result == 0 && state.decimal == 0) {
                    break;
                }
            }
            if (state.decimal < 0) {
                state.decimal = -state.decimal;
            }
            state.decimal_digits = 1;
            return Finalize<T, NEGATIVE>(state);
        }
 
        // Positive Exponent
        while (state.result != 0 && e-- > 0) {
            if (!TryMultiplyOperator::Operation(state.result, (store_t)10, state.result)) {
                return false;
            }
        }
 
        if (state.decimal == 0) {
            return Finalize<T, NEGATIVE>(state);
        }
 
        // Handle decimals
        e = UnsafeNumericCast<int16_t>(exponent - state.decimal_digits);
        store_t remainder = 0;
        if (e < 0) {
            if (static_cast<uint16_t>(-e) <= NumericLimits<store_t>::Digits()) {
                store_t power = 1;
                while (e++ < 0) {
                    power *= 10;
                }
                remainder = state.decimal % power;
                state.decimal /= power;
            } else {
                state.decimal = 0;
            }
        } else {
            while (e-- > 0) {
                if (!TryMultiplyOperator::Operation(state.decimal, (store_t)10, state.decimal)) {
                    return false;
                }
            }
        }
 
        state.decimal_digits -= exponent;
 
        if (NEGATIVE) {
            if (!TrySubtractOperator::Operation(state.result, state.decimal, state.result)) {
                return false;
            }
        } else if (!TryAddOperator::Operation(state.result, state.decimal, state.result)) {
            return false;
        }
        state.decimal = remainder;
        return Finalize<T, NEGATIVE>(state);
    }

HandleDecimal()

template<class T , bool NEGATIVE, bool ALLOW_EXPONENT>

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

inlinestatic

                                                       {
        using store_t = typename T::StoreType;
        if (DUCKDB_UNLIKELY(state.decimal > (NumericLimits<store_t>::Maximum() - digit) / 10)) {
            // Simply ignore any more decimals
            return true;
        }
        state.decimal_digits++;
        state.decimal = state.decimal * 10 + digit;
        return true;
    }

Finalize()

template<class T , bool NEGATIVE>

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

inlinestatic

                                   {
        using result_t = typename T::ResultType;
        using store_t = typename T::StoreType;
 
        result_t tmp;
        if (!TryCast::Operation<store_t, result_t>(state.result, tmp)) {
            return false;
        }
 
        while (state.decimal > 10) {
            state.decimal /= 10;
            state.decimal_digits--;
        }
 
        bool success = true;
        if (state.decimal_digits == 1 && state.decimal >= 5) {
            if (NEGATIVE) {
                success = TrySubtractOperator::Operation(tmp, (result_t)1, tmp);
            } else {
                success = TryAddOperator::Operation(tmp, (result_t)1, tmp);
            }
        }
        state.result = tmp;
        return success;
    }

---

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

• external/duckdb/duckdb.cpp