duckdb::TimeToStringCast Struct Reference

Static Public Member Functions
static int32_t	FormatMicros (int32_t microseconds, char micro_buffer[])
	Format microseconds to a buffer of length 6. Returns the number of trailing zeros.
static idx_t	MicrosLength (int32_t micros, char micro_buffer[])
static idx_t	Length (int32_t time[], char micro_buffer[])
static void	FormatTwoDigits (char *ptr, int32_t value)
static void	Format (char *data, idx_t length, int32_t hour, int32_t minute, int32_t second, int32_t microsecond, char micro_buffer[])
static void	Format (char *data, idx_t length, int32_t time[], char micro_buffer[])

Member Function Documentation

FormatMicros()

static int32_t duckdb::TimeToStringCast::FormatMicros ( int32_t  microseconds, char  micro_buffer[]  )

inlinestatic

Format microseconds to a buffer of length 6. Returns the number of trailing zeros.

                                                                           {
        char *endptr = micro_buffer + 6;
        endptr = NumericHelper::FormatUnsigned<int32_t>(microseconds, endptr);
        while (endptr > micro_buffer) {
            *--endptr = '0';
        }
        idx_t trailing_zeros = 0;
        for (idx_t i = 5; i > 0; i--) {
            if (micro_buffer[i] != '0') {
                break;
            }
            trailing_zeros++;
        }
        return UnsafeNumericCast<int32_t>(trailing_zeros);
    }

Here is the caller graph for this function:

MicrosLength()

static idx_t duckdb::TimeToStringCast::MicrosLength ( int32_t  micros, char  micro_buffer[]  )

inlinestatic

                                                                   {
        // format is HH:MM:DD.MS
        // microseconds come after the time with a period separator
        idx_t length;
        if (micros == 0) {
            // no microseconds
            // format is HH:MM:DD
            length = 8;
        } else {
            length = 15;
            // for microseconds, we truncate any trailing zeros (i.e. "90000" becomes ".9")
            // first write the microseconds to the microsecond buffer
            // we write backwards and pad with zeros to the left
            // now we figure out how many digits we need to include by looking backwards
            // and checking how many zeros we encounter
            length -= NumericCast<idx_t>(FormatMicros(micros, micro_buffer));
        }
        return length;
    }

Length()

static idx_t duckdb::TimeToStringCast::Length ( int32_t  time[], char  micro_buffer[]  )

inlinestatic

                                                             {
        return MicrosLength(time[3], micro_buffer);
    }

FormatTwoDigits()

static void duckdb::TimeToStringCast::FormatTwoDigits ( char *  ptr, int32_t  value  )

inlinestatic

                                                          {
        D_ASSERT(value >= 0 && value <= 99);
        if (value < 10) {
            ptr[0] = '0';
            ptr[1] = UnsafeNumericCast<char>('0' + value);
        } else {
            auto index = UnsafeNumericCast<unsigned>(value * 2);
            ptr[0] = duckdb_fmt::internal::data::digits[index];
            ptr[1] = duckdb_fmt::internal::data::digits[index + 1];
        }
    }

Format() [1/2]

static void duckdb::TimeToStringCast::Format ( char *  data, idx_t  length, int32_t  hour, int32_t  minute, int32_t  second, int32_t  microsecond, char  micro_buffer[]  )

inlinestatic

                                            {
        // first write hour, month and day
        FormatTwoDigits(data, hour);
        data[2] = ':';
        FormatTwoDigits(data + 3, minute);
        data[5] = ':';
        FormatTwoDigits(data + 6, second);
        if (length > 8) {
            // write the micro seconds at the end
            data[8] = '.';
            memcpy(data + 9, micro_buffer, length - 9);
        }
    }

Format() [2/2]

static void duckdb::TimeToStringCast::Format ( char *  data, idx_t  length, int32_t  time[], char  micro_buffer[]  )

inlinestatic

                                                                                      {
        Format(data, length, time[0], time[1], time[2], time[3], micro_buffer);
    }

---

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

• external/duckdb/duckdb.cpp