duckdb::interval_t Struct Reference

Public Member Functions
void	Normalize (int64_t &months, int64_t &days, int64_t &micros) const
interval_t	Normalize () const
bool	operator== (const interval_t &right) const
bool	operator!= (const interval_t &right) const
bool	operator> (const interval_t &right) const
bool	operator< (const interval_t &right) const
bool	operator<= (const interval_t &right) const
bool	operator>= (const interval_t &right) const
void	Serialize (Serializer &serializer) const

Static Public Member Functions
static void	Borrow (const int64_t msf, int64_t &lsf, int32_t &f, const int64_t scale)
static interval_t	Deserialize (Deserializer &source)

Public Attributes
int32_t	months
int32_t	days
int64_t	micros

Member Function Documentation

Normalize() [1/2]

void duckdb::interval_t::Normalize ( int64_t &  months, int64_t &  days, int64_t &  micros  ) const

inline

                                                                                {
    auto &input = *this;
 
    //  Carry left
    micros = input.micros;
    int64_t carry_days = micros / Interval::MICROS_PER_DAY;
    micros -= carry_days * Interval::MICROS_PER_DAY;
 
    days = input.days;
    days += carry_days;
    int64_t carry_months = days / Interval::DAYS_PER_MONTH;
    days -= carry_months * Interval::DAYS_PER_MONTH;
 
    months = input.months;
    months += carry_months;
}

Borrow()

void duckdb::interval_t::Borrow ( const int64_t  msf, int64_t &  lsf, int32_t &  f, const int64_t  scale  )

inlinestatic

                                                                                        {
    if (msf > NumericLimits<int32_t>::Maximum()) {
        f = NumericLimits<int32_t>::Maximum();
        lsf += (msf - f) * scale;
    } else if (msf < NumericLimits<int32_t>::Minimum()) {
        f = NumericLimits<int32_t>::Minimum();
        lsf += (msf - f) * scale;
    } else {
        f = UnsafeNumericCast<int32_t>(msf);
    }
}

Normalize() [2/2]

interval_t duckdb::interval_t::Normalize ( ) const

inline

                                       {
    interval_t result;
 
    int64_t mm;
    int64_t dd;
    Normalize(mm, dd, result.micros);
 
    //  Borrow right on overflow
    Borrow(mm, dd, result.months, Interval::DAYS_PER_MONTH);
    Borrow(dd, result.micros, result.days, Interval::MICROS_PER_DAY);
 
    return result;
}

operator==()

bool duckdb::interval_t::operator== ( const interval_t &  right ) const

inline

                                                          {
        //  Quick equality check
        const auto &left = *this;
        if (left.months == right.months && left.days == right.days && left.micros == right.micros) {
            return true;
        }
 
        int64_t lmonths, ldays, lmicros;
        int64_t rmonths, rdays, rmicros;
        left.Normalize(lmonths, ldays, lmicros);
        right.Normalize(rmonths, rdays, rmicros);
 
        return lmonths == rmonths && ldays == rdays && lmicros == rmicros;
    }

operator!=()

bool duckdb::interval_t::operator!= ( const interval_t &  right ) const

inline

                                                          {
        return !(*this == right);
    }

operator>()

bool duckdb::interval_t::operator> ( const interval_t &  right ) const

inline

                                                         {
        const auto &left = *this;
        int64_t lmonths, ldays, lmicros;
        int64_t rmonths, rdays, rmicros;
        left.Normalize(lmonths, ldays, lmicros);
        right.Normalize(rmonths, rdays, rmicros);
 
        if (lmonths > rmonths) {
            return true;
        } else if (lmonths < rmonths) {
            return false;
        }
        if (ldays > rdays) {
            return true;
        } else if (ldays < rdays) {
            return false;
        }
        return lmicros > rmicros;
    }

operator<()

bool duckdb::interval_t::operator< ( const interval_t &  right ) const

inline

                                                         {
        return right > *this;
    }

operator<=()

bool duckdb::interval_t::operator<= ( const interval_t &  right ) const

inline

                                                          {
        return !(*this > right);
    }

operator>=()

bool duckdb::interval_t::operator>= ( const interval_t &  right ) const

inline

                                                          {
        return !(*this < right);
    }

---

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

• external/duckdb/duckdb.hpp