duckdb::Uhugeint Class Reference

The uhugeint class contains static operations for the UINT128 type. More...

#include <duckdb.hpp>

Collaboration diagram for duckdb::Uhugeint:

Public Member Functions
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, int8_t &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, int16_t &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, int32_t &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, int64_t &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, uint8_t &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, uint16_t &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, uint32_t &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, uint64_t &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, hugeint_t &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, uhugeint_t &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, float &result)
template<>
DUCKDB_API bool	TryCast (uhugeint_t input, double &result)
template<>
bool	TryConvert (int8_t value, uhugeint_t &result)
template<>
bool	TryConvert (int16_t value, uhugeint_t &result)
template<>
bool	TryConvert (int32_t value, uhugeint_t &result)
template<>
bool	TryConvert (int64_t value, uhugeint_t &result)
template<>
bool	TryConvert (uint8_t value, uhugeint_t &result)
template<>
bool	TryConvert (uint16_t value, uhugeint_t &result)
template<>
bool	TryConvert (uint32_t value, uhugeint_t &result)
template<>
bool	TryConvert (uint64_t value, uhugeint_t &result)
template<>
bool	TryConvert (float value, uhugeint_t &result)
template<>
bool	TryConvert (double value, uhugeint_t &result)
template<>
bool	TryConvert (long double value, uhugeint_t &result)
template<>
bool	TryConvert (const char *value, uhugeint_t &result)

Static Public Member Functions
static string	ToString (uhugeint_t input)
	Convert a uhugeint object to a string.
template<class T >
static DUCKDB_API bool	TryCast (uhugeint_t input, T &result)
template<class T >
static T	Cast (uhugeint_t input)
template<class T >
static bool	TryConvert (T value, uhugeint_t &result)
template<class T >
static uhugeint_t	Convert (T value)
static bool	TryNegate (uhugeint_t input, uhugeint_t &result)
template<bool CHECK_OVERFLOW = true>
static void	NegateInPlace (uhugeint_t &input)
template<bool CHECK_OVERFLOW = true>
static uhugeint_t	Negate (uhugeint_t input)
static bool	TryMultiply (uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &result)
template<bool CHECK_OVERFLOW = true>
static uhugeint_t	Multiply (uhugeint_t lhs, uhugeint_t rhs)
static bool	TryDivMod (uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &result, uhugeint_t &remainder)
template<bool CHECK_OVERFLOW = true>
static uhugeint_t	Divide (uhugeint_t lhs, uhugeint_t rhs)
template<bool CHECK_OVERFLOW = true>
static uhugeint_t	Modulo (uhugeint_t lhs, uhugeint_t rhs)
static bool	TryAddInPlace (uhugeint_t &lhs, uhugeint_t rhs)
template<bool CHECK_OVERFLOW = true>
static uhugeint_t	Add (uhugeint_t lhs, uhugeint_t rhs)
static bool	TrySubtractInPlace (uhugeint_t &lhs, uhugeint_t rhs)
template<bool CHECK_OVERFLOW = true>
static uhugeint_t	Subtract (uhugeint_t lhs, uhugeint_t rhs)
static uhugeint_t	DivMod (uhugeint_t lhs, uhugeint_t rhs, uhugeint_t &remainder)
static int	Sign (hugeint_t n)
static hugeint_t	Abs (hugeint_t n)
static bool	Equals (uhugeint_t lhs, uhugeint_t rhs)
static bool	NotEquals (uhugeint_t lhs, uhugeint_t rhs)
static bool	GreaterThan (uhugeint_t lhs, uhugeint_t rhs)
static bool	GreaterThanEquals (uhugeint_t lhs, uhugeint_t rhs)
static bool	LessThan (uhugeint_t lhs, uhugeint_t rhs)
static bool	LessThanEquals (uhugeint_t lhs, uhugeint_t rhs)

Static Public Attributes
static constexpr uint8_t	CACHED_POWERS_OF_TEN = 39
static const uhugeint_t	POWERS_OF_TEN [CACHED_POWERS_OF_TEN]

Detailed Description

The uhugeint class contains static operations for the UINT128 type.

Member Function Documentation

Cast()

template<class T >

static T duckdb::Uhugeint::Cast ( uhugeint_t  input )

inlinestatic

                                    {
        T result = 0;
        TryCast(input, result);
        return result;
    }

Convert()

template<class T >

static uhugeint_t duckdb::Uhugeint::Convert ( T  value )

inlinestatic

                                       {
        uhugeint_t result;
        if (!TryConvert(value, result)) { // LCOV_EXCL_START
            throw OutOfRangeException(double(value), GetTypeId<T>(), GetTypeId<uhugeint_t>());
        } // LCOV_EXCL_STOP
        return result;
    }

NegateInPlace()

template<bool CHECK_OVERFLOW = true>

static void duckdb::Uhugeint::NegateInPlace ( uhugeint_t &  input )

inlinestatic

                                                        {
        if (!TryNegate(input, input)) {
            throw OutOfRangeException("UHUGEINT is out of range");
        }
    }

Negate()

template<bool CHECK_OVERFLOW = true>

static uhugeint_t duckdb::Uhugeint::Negate ( uhugeint_t  input )

inlinestatic

                                                      {
        NegateInPlace<CHECK_OVERFLOW>(input);
        return input;
    }

Multiply()

template<bool CHECK_OVERFLOW = true>

static uhugeint_t duckdb::Uhugeint::Multiply ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                                      {
        uhugeint_t result;
        if (!TryMultiply(lhs, rhs, result)) {
            throw OutOfRangeException("Overflow in UHUGEINT multiplication: %s * %s", lhs.ToString(), rhs.ToString());
        }
        return result;
    }

Divide()

template<bool CHECK_OVERFLOW = true>

static uhugeint_t duckdb::Uhugeint::Divide ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                                    {
        // division between two same-size unsigned integers can only go wrong with division by zero
        if (rhs == 0) {
            throw OutOfRangeException("Division of UHUGEINT by zero: %s / %s", lhs.ToString(), rhs.ToString());
        }
        return Divide<false>(lhs, rhs);
    }

Modulo()

template<bool CHECK_OVERFLOW = true>

static uhugeint_t duckdb::Uhugeint::Modulo ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                                    {
        if (rhs == 0) {
            throw OutOfRangeException("Modulo of UHUGEINT by zero: %s %% %s", lhs.ToString(), rhs.ToString());
        }
        return Modulo<false>(lhs, rhs);
    }

Add()

template<bool CHECK_OVERFLOW = true>

static uhugeint_t duckdb::Uhugeint::Add ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                                 {
        if (!TryAddInPlace(lhs, rhs)) {
            throw OutOfRangeException("Overflow in UHUGEINT addition: %s + %s", lhs.ToString(), rhs.ToString());
        }
        return lhs;
    }

Subtract()

template<bool CHECK_OVERFLOW = true>

static uhugeint_t duckdb::Uhugeint::Subtract ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                                      {
        if (!TrySubtractInPlace(lhs, rhs)) {
            throw OutOfRangeException("Underflow in HUGEINT subtraction: %s - %s", lhs.ToString(), rhs.ToString());
        }
        return lhs;
    }

Equals()

static bool duckdb::Uhugeint::Equals ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                       {
        bool lower_equals = lhs.lower == rhs.lower;
        bool upper_equals = lhs.upper == rhs.upper;
        return lower_equals && upper_equals;
    }

NotEquals()

static bool duckdb::Uhugeint::NotEquals ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                          {
        return !Equals(lhs, rhs);
    }

GreaterThan()

static bool duckdb::Uhugeint::GreaterThan ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                            {
        bool upper_bigger = lhs.upper > rhs.upper;
        bool upper_equal = lhs.upper == rhs.upper;
        bool lower_bigger = lhs.lower > rhs.lower;
        return upper_bigger || (upper_equal && lower_bigger);
    }

GreaterThanEquals()

static bool duckdb::Uhugeint::GreaterThanEquals ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                                  {
        bool upper_bigger = lhs.upper > rhs.upper;
        bool upper_equal = lhs.upper == rhs.upper;
        bool lower_bigger_equals = lhs.lower >= rhs.lower;
        return upper_bigger || (upper_equal && lower_bigger_equals);
    }

LessThan()

static bool duckdb::Uhugeint::LessThan ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                         {
        bool upper_smaller = lhs.upper < rhs.upper;
        bool upper_equal = lhs.upper == rhs.upper;
        bool lower_smaller = lhs.lower < rhs.lower;
        return upper_smaller || (upper_equal && lower_smaller);
    }

LessThanEquals()

static bool duckdb::Uhugeint::LessThanEquals ( uhugeint_t  lhs, uhugeint_t  rhs  )

inlinestatic

                                                               {
        bool upper_smaller = lhs.upper < rhs.upper;
        bool upper_equal = lhs.upper == rhs.upper;
        bool lower_smaller_equals = lhs.lower <= rhs.lower;
        return upper_smaller || (upper_equal && lower_smaller_equals);
    }

---

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

• external/duckdb/duckdb.hpp