duckdb::IntervalToStringCast Struct Reference

Static Public Member Functions
static void	FormatSignedNumber (int64_t value, char buffer[], idx_t &length)
static void	FormatTwoDigits (int64_t value, char buffer[], idx_t &length)
static void	FormatIntervalValue (int32_t value, char buffer[], idx_t &length, const char *name, idx_t name_len)
static idx_t	Format (interval_t interval, char buffer[])

Member Function Documentation

FormatSignedNumber()

static void duckdb::IntervalToStringCast::FormatSignedNumber ( int64_t  value, char  buffer[], idx_t &  length  )

inlinestatic

                                                                                {
        int sign = -(value < 0);
        auto unsigned_value = NumericCast<uint64_t>((value ^ sign) - sign);
        length += NumericCast<idx_t>(NumericHelper::UnsignedLength<uint64_t>(unsigned_value) - sign);
        auto endptr = buffer + length;
        endptr = NumericHelper::FormatUnsigned<uint64_t>(unsigned_value, endptr);
        if (sign) {
            *--endptr = '-';
        }
    }

FormatTwoDigits()

static void duckdb::IntervalToStringCast::FormatTwoDigits ( int64_t  value, char  buffer[], idx_t &  length  )

inlinestatic

                                                                             {
        TimeToStringCast::FormatTwoDigits(buffer + length, UnsafeNumericCast<int32_t>(value));
        length += 2;
    }

FormatIntervalValue()

static void duckdb::IntervalToStringCast::FormatIntervalValue ( int32_t  value, char  buffer[], idx_t &  length, const char *  name, idx_t  name_len  )

inlinestatic

                                                                                                                   {
        if (value == 0) {
            return;
        }
        if (length != 0) {
            // space if there is already something in the buffer
            buffer[length++] = ' ';
        }
        FormatSignedNumber(value, buffer, length);
        // append the name together with a potential "s" (for plurals)
        memcpy(buffer + length, name, name_len);
        length += name_len;
        if (value != 1 && value != -1) {
            buffer[length++] = 's';
        }
    }

Format()

static idx_t duckdb::IntervalToStringCast::Format ( interval_t  interval, char  buffer[]  )

inlinestatic

Formats an interval to a buffer, the buffer should be >=70 characters years: 17 characters (max value: "-2147483647 years") months: 9 (max value: "12 months") days: 16 characters (max value: "-2147483647 days") time: 24 characters (max value: -2562047788:00:00.123456) spaces between all characters (+3 characters) Total: 70 characters Returns the length of the interval

                                                            {
        idx_t length = 0;
        if (interval.months != 0) {
            int32_t years = interval.months / 12;
            int32_t months = interval.months - years * 12;
            // format the years and months
            FormatIntervalValue(years, buffer, length, " year", 5);
            FormatIntervalValue(months, buffer, length, " month", 6);
        }
        if (interval.days != 0) {
            // format the days
            FormatIntervalValue(interval.days, buffer, length, " day", 4);
        }
        if (interval.micros != 0) {
            if (length != 0) {
                // space if there is already something in the buffer
                buffer[length++] = ' ';
            }
            int64_t micros = interval.micros;
            if (micros < 0) {
                // negative time: append negative sign
                buffer[length++] = '-';
            } else {
                micros = -micros;
            }
            int64_t hour = -(micros / Interval::MICROS_PER_HOUR);
            micros += hour * Interval::MICROS_PER_HOUR;
            int64_t min = -(micros / Interval::MICROS_PER_MINUTE);
            micros += min * Interval::MICROS_PER_MINUTE;
            int64_t sec = -(micros / Interval::MICROS_PER_SEC);
            micros += sec * Interval::MICROS_PER_SEC;
            micros = -micros;
 
            if (hour < 10) {
                buffer[length++] = '0';
            }
            FormatSignedNumber(hour, buffer, length);
            buffer[length++] = ':';
            FormatTwoDigits(min, buffer, length);
            buffer[length++] = ':';
            FormatTwoDigits(sec, buffer, length);
            if (micros != 0) {
                buffer[length++] = '.';
                auto trailing_zeros = TimeToStringCast::FormatMicros(NumericCast<int32_t>(micros), buffer + length);
                length += NumericCast<idx_t>(6 - trailing_zeros);
            }
        } else if (length == 0) {
            // empty interval: default to 00:00:00
            memcpy(buffer, "00:00:00", 8); // NOLINT
            return 8;
        }
        return length;
    }

Here is the call graph for this function:

---

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

• external/duckdb/duckdb.cpp