#include <cstdint>
#include <ctime>
#include "../Shared/funcannotations.h"

Include dependency graph for ExtractFromTime.h:

This graph shows which files directly or indirectly include this file:

Enumerations
enum	ExtractField { kYEAR, kQUARTER, kMONTH, kDAY, kHOUR, kMINUTE, kSECOND, kMILLISECOND, kMICROSECOND, kNANOSECOND, kDOW, kISODOW, kDOY, kEPOCH, kQUARTERDAY, kWEEK }

Functions
DEVICE int32_t	extract_dow (const int64_t lcltime)

DEVICE tm	gmtime_r_newlib (const int64_t lcltime, tm &res)

DEVICE NEVER_INLINE int64_t	ExtractFromTime (ExtractField field, const int64_t timeval)

Variables
static constexpr int64_t	kNanoSecsPerSec = 1000000000

static constexpr int64_t	kMicroSecsPerSec = 1000000

static constexpr int64_t	kMilliSecsPerSec = 1000

static constexpr int64_t	kSecsPerMin = 60

static constexpr int64_t	kMinsPerHour = 60

static constexpr int64_t	kHoursPerDay = 24

static constexpr int64_t	kSecPerHour = 3600

static constexpr int64_t	kSecsPerDay = 86400

static constexpr int64_t	kSecsPerQuarterDay = 21600

static constexpr int32_t	kDaysPerWeek = 7

static constexpr int32_t	kMonsPerYear = 12

static constexpr int64_t	kSecsPerHalfDay = 43200

static constexpr int64_t	kMinsPerMonth = 43200

static constexpr int32_t	kYearBase = 1900

static constexpr int32_t	kEpochAdjustedDays = 11017

static constexpr int32_t	kEpochAdjustedYears = 2000

static constexpr int32_t	kEpochAdjustedWDay = 3

static constexpr int64_t	kDaysPer400Years = 146097

static constexpr int64_t	kDaysPer100Years = 36524

static constexpr int32_t	kDaysPer4Years = 3 * 365 + 366

static constexpr int32_t	kDaysPerYear = 365

static constexpr int32_t	kDaysInJanuary = 31

static constexpr int32_t	kDaysInFebruary = 28

static constexpr uint32_t	kSecondsPerNonLeapYear = 31536000

static constexpr uint32_t	kSecondsPer4YearCycle = 126230400

static constexpr uint32_t	kUSecsPerDay = 86400

static constexpr uint32_t	kEpochOffsetYear1900 = 2208988800

static constexpr uint32_t	kSecsJanToMar1900 = 5097600

Enumeration Type Documentation

enum ExtractField

Enumerator
kYEAR
kQUARTER
kMONTH
kDAY
kHOUR
kMINUTE
kSECOND
kMILLISECOND
kMICROSECOND
kNANOSECOND
kDOW
kISODOW
kDOY
kEPOCH
kQUARTERDAY
kWEEK

Definition at line 69 of file ExtractFromTime.h.

                   {
   kYEAR,
   kQUARTER,
   kMONTH,
   kDAY,
   kHOUR,
   kMINUTE,
   kSECOND,
   kMILLISECOND,
   kMICROSECOND,
   kNANOSECOND,
   kDOW,
   kISODOW,
   kDOY,
   kEPOCH,
   kQUARTERDAY,
   kWEEK
 };

Function Documentation

DEVICE int32_t extract_dow ( const int64_t lcltime )

Definition at line 63 of file ExtractFromTime.cpp.

References kDaysPerWeek, kEpochAdjustedDays, kEpochAdjustedWDay, and kSecsPerDay.

Referenced by DateTruncate(), and ExtractFromTime().

                                                   {
   int64_t days, rem;
   int32_t weekday;
   days = lcltime / kSecsPerDay - kEpochAdjustedDays;
   rem = lcltime % kSecsPerDay;
   if (rem < 0) {
     rem += kSecsPerDay;
     --days;
   }
 
   if ((weekday = ((kEpochAdjustedWDay + days) % kDaysPerWeek)) < 0) {
     weekday += kDaysPerWeek;
   }
   return weekday;
 }

Here is the caller graph for this function:

DEVICE NEVER_INLINE int64_t ExtractFromTime	(	ExtractField	field,
		const int64_t	timeval
	)

Definition at line 247 of file ExtractFromTime.cpp.

References extract_dow(), extract_hour(), extract_microsecond(), extract_millisecond(), extract_minute(), extract_month_fast(), extract_nanosecond(), extract_quarter_fast(), extract_quarterday(), extract_second(), extract_year_fast(), gmtime_r_newlib(), kDAY, kDOW, kDOY, kEPOCH, kEpochOffsetYear1900, kHOUR, kISODOW, kMICROSECOND, kMILLISECOND, kMINUTE, kMONTH, kNANOSECOND, kQUARTER, kQUARTERDAY, kSECOND, kWEEK, and kYEAR.

Referenced by ExtractFromTimeNullable(), getExpressionRange(), and DateTimeTranslator::getExtractFromTimeConstantValue().

                                                                               {
   // We have fast paths for the 5 fields below - do not need to do full gmtime
   switch (field) {
     case kEPOCH:
       return timeval;
     case kQUARTERDAY:
       return extract_quarterday(timeval);
     case kHOUR:
       return extract_hour(timeval);
     case kMINUTE:
       return extract_minute(timeval);
     case kSECOND:
       return extract_second(timeval);
     case kMILLISECOND:
       return extract_millisecond(timeval);
     case kMICROSECOND:
       return extract_microsecond(timeval);
     case kNANOSECOND:
       return extract_nanosecond(timeval);
     case kDOW:
       return extract_dow(timeval);
     case kISODOW: {
       int64_t dow = extract_dow(timeval);
       return (dow == 0 ? 7 : dow);
     }
     case kMONTH: {
       if (timeval >= 0L && timeval <= UINT32_MAX - kEpochOffsetYear1900) {
         return extract_month_fast(timeval);
       }
       break;
     }
     case kQUARTER: {
       if (timeval >= 0L && timeval <= UINT32_MAX - kEpochOffsetYear1900) {
         return extract_quarter_fast(timeval);
       }
       break;
     }
     case kYEAR: {
       if (timeval >= 0L && timeval <= UINT32_MAX - kEpochOffsetYear1900) {
         return extract_year_fast(timeval);
       }
       break;
     }
     default:
       break;
   }
 
   tm tm_struct;
   gmtime_r_newlib(timeval, tm_struct);
   switch (field) {
     case kYEAR:
       return 1900 + tm_struct.tm_year;
     case kQUARTER:
       return (tm_struct.tm_mon) / 3 + 1;
     case kMONTH:
       return tm_struct.tm_mon + 1;
     case kDAY:
       return tm_struct.tm_mday;
     case kDOY:
       return tm_struct.tm_yday + 1;
     case kWEEK: {
       int32_t doy = tm_struct.tm_yday;         // numbered from 0
       int32_t dow = extract_dow(timeval) + 1;  // use Sunday 1 - Saturday 7
       int32_t week = (doy / 7) + 1;
       // now adjust for offset at start of year
       //      S M T W T F S
       // doy      0 1 2 3 4
       // doy  5 6
       // mod  5 6 0 1 2 3 4
       // dow  1 2 3 4 5 6 7
       // week 2 2 1 1 1 1 1
       if (dow > (doy % 7)) {
         return week;
       }
       return week + 1;
     }
     default:
 #ifdef __CUDACC__
       return -1;
 #else
       abort();
 #endif
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE tm gmtime_r_newlib	(	const int64_t	lcltime,
		tm &	res
	)

Definition at line 150 of file ExtractFromTime.cpp.

References kDaysInFebruary, kDaysInJanuary, kDaysPer100Years, kDaysPer400Years, kDaysPer4Years, kDaysPerWeek, kDaysPerYear, kEpochAdjustedDays, kEpochAdjustedWDay, kEpochAdjustedYears, kMonsPerYear, kSecPerHour, kSecsPerDay, kSecsPerMin, kYearBase, and run_benchmark_import::res.

Referenced by DateTruncate(), and ExtractFromTime().

                                                           {
   const int32_t month_lengths[2][kMonsPerYear] = {
       {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
       {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
   int64_t days, rem;
   int32_t year, month, yearday, weekday;
   int32_t years400, years100, years4, remainingyears;
   int32_t yearleap;
   const int32_t* ip;
 
   days = lcltime / kSecsPerDay - kEpochAdjustedDays;
   rem = lcltime % kSecsPerDay;
   if (rem < 0) {
     rem += kSecsPerDay;
     --days;
   }
 
   /* compute hour, min, and sec */
   res.tm_hour = static_cast<int32_t>(rem / kSecPerHour);
   rem %= kSecPerHour;
   res.tm_min = static_cast<int32_t>(rem / kSecsPerMin);
   res.tm_sec = static_cast<int32_t>(rem % kSecsPerMin);
 
   /* compute day of week */
   if ((weekday = ((kEpochAdjustedWDay + days) % kDaysPerWeek)) < 0) {
     weekday += kDaysPerWeek;
   }
   res.tm_wday = weekday;
 
   /* compute year & day of year */
   years400 = static_cast<int32_t>(days / kDaysPer400Years);
   days -= years400 * kDaysPer400Years;
   /* simplify by making the values positive */
   if (days < 0) {
     days += kDaysPer400Years;
     --years400;
   }
 
   years100 = static_cast<int32_t>(days / kDaysPer100Years);
   if (years100 == 4) { /* required for proper day of year calculation */
     --years100;
   }
   days -= years100 * kDaysPer100Years;
   years4 = days / kDaysPer4Years;
   days -= years4 * kDaysPer4Years;
   remainingyears = days / kDaysPerYear;
   if (remainingyears == 4) { /* required for proper day of year calculation */
     --remainingyears;
   }
   days -= remainingyears * kDaysPerYear;
 
   year =
       kEpochAdjustedYears + years400 * 400 + years100 * 100 + years4 * 4 + remainingyears;
 
   /* If remainingyears is zero, it means that the years were completely
    * "consumed" by modulo calculations by 400, 100 and 4, so the year is:
    * 1. a multiple of 4, but not a multiple of 100 or 400 - it's a leap year,
    * 2. a multiple of 4 and 100, but not a multiple of 400 - it's not a leap
    * year,
    * 3. a multiple of 4, 100 and 400 - it's a leap year.
    * If years4 is non-zero, it means that the year is not a multiple of 100 or
    * 400 (case 1), so it's a leap year. If years100 is zero (and years4 is zero
    * - due to short-circuiting), it means that the year is a multiple of 400
    * (case 3), so it's also a leap year. */
   yearleap = remainingyears == 0 && (years4 != 0 || years100 == 0);
 
   /* adjust back to 1st January */
   yearday = days + kDaysInJanuary + kDaysInFebruary + yearleap;
   if (yearday >= kDaysPerYear + yearleap) {
     yearday -= kDaysPerYear + yearleap;
     ++year;
   }
   res.tm_yday = yearday;
   res.tm_year = year - kYearBase;
 
   /* Because "days" is the number of days since 1st March, the additional leap
    * day (29th of February) is the last possible day, so it doesn't matter much
    * whether the year is actually leap or not. */
   ip = month_lengths[1];
   month = 2;
   while (days >= ip[month]) {
     days -= ip[month];
     if (++month >= kMonsPerYear) {
       month = 0;
     }
   }
   res.tm_mon = month;
   res.tm_mday = days + 1;
 
   res.tm_isdst = 0;
 
   return res;
 }