Loading...
Searching...
No Matches
dt.h File Reference
Include dependency graph for dt.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Data Structures | |
| struct | datetkn |
Typedefs | |
| typedef int32 | fsec_t |
Variables | |
| char * | pgtypes_date_weekdays_short [] |
| char * | pgtypes_date_months [] |
| char * | months [] |
| char * | days [] |
| const int | day_tab [2][13] |
Macro Definition Documentation
◆ ABS_AFTER
◆ ABS_BEFORE
◆ AD
◆ ADBC
◆ AGO
◆ AM
◆ AMPM
◆ BC
◆ DA_D
◆ DAGO
◆ DAY
◆ DAYS_PER_MONTH
◆ DAYS_PER_YEAR
◆ DB_C
◆ DCENTURY
◆ DCURRENT
◆ DDAY
◆ DDECADE
◆ DHOUR
◆ DMICROSEC
◆ DMILLENNIUM
◆ DMILLISEC
◆ DMINUTE
◆ DMONTH
◆ DOW
◆ DOY
◆ DQUARTER
◆ DSECOND
◆ DT_NOBEGIN
| #define DT_NOBEGIN (-INT64CONST(0x7fffffffffffffff) - 1) |
◆ DT_NOEND
| #define DT_NOEND (INT64CONST(0x7fffffffffffffff)) |
◆ DTERR_BAD_FORMAT
◆ DTERR_FIELD_OVERFLOW
◆ DTERR_INTERVAL_OVERFLOW
◆ DTERR_MD_FIELD_OVERFLOW
◆ DTERR_TZDISP_OVERFLOW
◆ DTIMEZONE
◆ DTK_AGO
◆ DTK_ALL_SECS_M
| #define DTK_ALL_SECS_M (DTK_M(SECOND) | DTK_M(MILLISECOND) | DTK_M(MICROSECOND)) |
◆ DTK_CENTURY
◆ DTK_DATE
◆ DTK_DATE_M
◆ DTK_DAY
◆ DTK_DECADE
◆ DTK_DELTA
◆ DTK_DOW
◆ DTK_DOY
◆ DTK_EARLY
◆ DTK_EPOCH
◆ DTK_HOUR
◆ DTK_ISODOW
◆ DTK_ISOYEAR
◆ DTK_JULIAN
◆ DTK_LATE
◆ DTK_M
◆ DTK_MICROSEC
◆ DTK_MILLENNIUM
◆ DTK_MILLISEC
◆ DTK_MINUTE
◆ DTK_MONTH
◆ DTK_NOW
◆ DTK_NUMBER
◆ DTK_QUARTER
◆ DTK_SECOND
◆ DTK_SPECIAL
◆ DTK_STRING
◆ DTK_TIME
◆ DTK_TIME_M
◆ DTK_TODAY
◆ DTK_TOMORROW
◆ DTK_TZ
◆ DTK_TZ_HOUR
◆ DTK_TZ_MINUTE
◆ DTK_WEEK
◆ DTK_YEAR
◆ DTK_YESTERDAY
◆ DTK_ZULU
◆ DTZ
◆ DTZMOD
◆ DWEEK
◆ DYEAR
◆ DYNTZ
◆ EARLY
◆ END_TIMESTAMP
| #define END_TIMESTAMP INT64CONST(9223371331200000000) |
◆ EPOCH
◆ FMODULO
| #define FMODULO | ( | t, | |
| q, | |||
| u | |||
| ) |
Value:
do { \
} while(0)
◆ HOUR
◆ HOURS_PER_DAY
◆ HR24
◆ IGNORE_DTF
◆ INTERVAL_FULL_RANGE
◆ INTERVAL_MASK
◆ INTSTYLE_ISO_8601
◆ INTSTYLE_POSTGRES
◆ INTSTYLE_POSTGRES_VERBOSE
◆ INTSTYLE_SQL_STANDARD
◆ INVALID
◆ IS_VALID_JULIAN
Value:
(((y) > JULIAN_MINYEAR || \
((y) < JULIAN_MAXYEAR || \
◆ IS_VALID_TIMESTAMP
| #define IS_VALID_TIMESTAMP | ( | t | ) | (MIN_TIMESTAMP <= (t) && (t) < END_TIMESTAMP) |
◆ IS_VALID_UTIME
Value:
((((y) > UTIME_MINYEAR) \
|| (((m) == UTIME_MINMONTH) && ((d) >= UTIME_MINDAY))))) \
&& (((y) < UTIME_MAXYEAR) \
|| (((m) == UTIME_MAXMONTH) && ((d) <= UTIME_MAXDAY))))))
◆ isleap
◆ ISODATE
◆ ISOTIME
◆ JULIAN
◆ JULIAN_MAXDAY
◆ JULIAN_MAXMONTH
◆ JULIAN_MAXYEAR
◆ JULIAN_MINDAY
◆ JULIAN_MINMONTH
◆ JULIAN_MINYEAR
◆ LATE
◆ MAX_INTERVAL_PRECISION
◆ MAXDATEFIELDS
◆ MAXDATELEN
◆ MAXTZLEN
◆ MICROSECOND
◆ MILLISECOND
◆ MIN_TIMESTAMP
| #define MIN_TIMESTAMP INT64CONST(-211813488000000000) |
◆ MINS_PER_HOUR
◆ MINUTE
◆ MONTH
◆ MONTHS_PER_YEAR
◆ NOW
◆ PM
◆ RESERV
◆ SECOND
◆ SECS_PER_DAY
◆ SECS_PER_HOUR
◆ SECS_PER_MINUTE
◆ SECS_PER_YEAR
| #define SECS_PER_YEAR (36525 * 864) /* avoid floating-point computation */ |
◆ TIMESTAMP_IS_NOBEGIN
◆ TIMESTAMP_IS_NOEND
◆ TIMESTAMP_NOBEGIN
◆ TIMESTAMP_NOEND
◆ TIMESTAMP_NOT_FINITE
| #define TIMESTAMP_NOT_FINITE | ( | j | ) | (TIMESTAMP_IS_NOBEGIN(j) || TIMESTAMP_IS_NOEND(j)) |
◆ TMODULO
| #define TMODULO | ( | t, | |
| q, | |||
| u | |||
| ) |
◆ TODAY
◆ TOKMAXLEN
◆ TOMORROW
◆ TZ
| #define TZ 5 /* fixed-offset timezone abbreviation */ |
◆ UNITS
◆ UNKNOWN_FIELD
◆ USE_GERMAN_DATES
◆ USE_ISO_DATES
◆ USE_POSTGRES_DATES
◆ USE_SQL_DATES
◆ USECS_PER_DAY
| #define USECS_PER_DAY INT64CONST(86400000000) |
◆ USECS_PER_HOUR
| #define USECS_PER_HOUR INT64CONST(3600000000) |
◆ USECS_PER_MINUTE
| #define USECS_PER_MINUTE INT64CONST(60000000) |
◆ USECS_PER_SEC
| #define USECS_PER_SEC INT64CONST(1000000) |
◆ UTIME_MAXDAY
◆ UTIME_MAXMONTH
◆ UTIME_MAXYEAR
◆ UTIME_MINDAY
◆ UTIME_MINMONTH
◆ UTIME_MINYEAR
◆ YEAR
◆ YESTERDAY
◆ ZULU
Typedef Documentation
◆ fsec_t
Function Documentation
◆ CheckDateTokenTables()
Definition at line 4933 of file datetime.c.
4934{
4936
4939
4943}
static bool CheckDateTokenTable(const char *tablename, const datetkn *base, int nel)
Definition datetime.c:4901
References Assert, CheckDateTokenTable(), date2j(), datetktbl, deltatktbl, fb(), POSTGRES_EPOCH_JDATE, szdatetktbl, szdeltatktbl, and UNIX_EPOCH_JDATE.
Referenced by PostmasterMain().
◆ date2j()
Definition at line 296 of file datetime.c.
297{
300
301 if (month > 2)
302 {
303 month += 1;
304 year += 4800;
305 }
306 else
307 {
308 month += 13;
309 year += 4799;
310 }
311
312 century = year / 100;
313 julian = year * 365 - 32167;
315 julian += 7834 * month / 256 + day;
316
318} /* date2j() */
Referenced by CheckDateTokenTables(), date2isoweek(), date2isoyear(), date2isoyearday(), date_in(), DCH_to_char(), DecodeDateTime(), DecodeDateTime(), DecodeNumber(), DetermineTimeZoneOffsetInternal(), EncodeDateTime(), EncodeDateTime(), extract_date(), GetSQLCurrentDate(), isoweek2j(), make_date(), make_timestamp_internal(), parse_datetime(), PGTYPESdate_dayofweek(), PGTYPESdate_defmt_asc(), PGTYPESdate_fmt_asc(), PGTYPESdate_from_asc(), PGTYPESdate_julmdy(), PGTYPESdate_mdyjul(), PGTYPESdate_to_asc(), PGTYPESdate_today(), timestamp2date_safe(), timestamp2tm(), timestamp_part_common(), timestamp_pl_interval(), timestamp_to_char(), timestamptz2date_safe(), timestamptz_part_common(), timestamptz_pl_interval_internal(), timestamptz_to_char(), tm2timestamp(), tm2timestamp(), to_date(), and ValidateDate().
◆ DecodeDateTime()
| int DecodeDateTime | ( | char ** | field, |
| int * | ftype, | ||
| int | nf, | ||
| int * | dtype, | ||
| struct tm * | tm, | ||
| fsec_t * | fsec, | ||
| bool | EuroDates | ||
| ) |
Definition at line 1782 of file dt_common.c.
1784{
1786 tmask,
1787 type;
1788 int ptype = 0; /* "prefix type" for ISO y2001m02d04 format */
1794 bool bc = false;
1795 int t = 0;
1796 int *tzp = &t;
1797
1798 /***
1799 * We'll insist on at least all of the date fields, but initialize the
1800 * remaining fields in case they are not set later...
1801 ***/
1802 *dtype = DTK_DATE;
1806 *fsec = 0;
1807 /* don't know daylight savings time status apriori */
1810 *tzp = 0;
1811
1813 {
1815 {
1817 /***
1818 * Integral julian day with attached time zone?
1819 * All other forms with JD will be separated into
1820 * distinct fields, so we handle just this case here.
1821 ***/
1823 {
1826
1828 return -1;
1829
1832 return -1;
1833
1835 /* Get the time zone from the end of the string */
1837 return -1;
1838
1840 ptype = 0;
1841 break;
1842 }
1843 /***
1844 * Already have a date? Then this might be a POSIX time
1845 * zone with an embedded dash (e.g. "PST-3" == "EST") or
1846 * a run-together time with trailing time zone (e.g. hhmmss-zz).
1847 * - thomas 2001-12-25
1848 ***/
1850 || (ptype != 0))
1851 {
1852 /* No time zone accepted? Then quit... */
1854 return -1;
1855
1857 {
1859
1860 if (ptype != 0)
1861 {
1862 /* Sanity check; should not fail this test */
1864 return -1;
1865 ptype = 0;
1866 }
1867
1868 /*
1869 * Starts with a digit but we already have a time
1870 * field? Then we are in trouble with a date and time
1871 * already...
1872 */
1874 return -1;
1875
1877 return -1;
1878
1879 /* Get the time zone from the end of the string */
1881 return -1;
1883
1884 /*
1885 * Then read the rest of the field as a concatenated
1886 * time
1887 */
1890 return -1;
1891
1892 /*
1893 * modify tmask after returning from
1894 * DecodeNumberField()
1895 */
1897 }
1898 else
1899 {
1901 return -1;
1902
1905 }
1906 }
1908 return -1;
1909 break;
1910
1913 return -1;
1914
1915 /*
1916 * Check upper limit on hours; other limits checked in
1917 * DecodeTime()
1918 */
1919 /* test for > 24:00:00 */
1922 return -1;
1923 break;
1924
1926 {
1927 int tz;
1928
1930 return -1;
1931
1933 return -1;
1934
1935 /*
1936 * Already have a time zone? Then maybe this is the second
1937 * field of a POSIX time: EST+3 (equivalent to PST)
1938 */
1942 {
1943 *tzp -= tz;
1944 tmask = 0;
1945 }
1946 else
1947 {
1948 *tzp = tz;
1950 }
1951 }
1952 break;
1953
1955
1956 /*
1957 * Was this an "ISO date" with embedded field labels? An
1958 * example is "y2001m02d04" - thomas 2001-02-04
1959 */
1960 if (ptype != 0)
1961 {
1964
1966
1967 /*
1968 * only a few kinds are allowed to have an embedded
1969 * decimal
1970 */
1972 switch (ptype)
1973 {
1977 break;
1978 default:
1979 return 1;
1980 break;
1981 }
1983 return -1;
1984
1985 switch (ptype)
1986 {
1990 break;
1991
1993
1994 /*
1995 * already have a month and hour? then assume
1996 * minutes
1997 */
2000 {
2003 }
2004 else
2005 {
2008 }
2009 break;
2010
2014 break;
2015
2019 break;
2020
2024 break;
2025
2030 {
2032
2035 return -1;
2036 *fsec = frac * 1000000;
2037 }
2038 break;
2039
2043 return -1;
2044 break;
2045
2047 /***
2048 * previous field was a label for "julian date"?
2049 ***/
2052 /* fractional Julian Day? */
2054 {
2055 double time;
2056
2059 return -1;
2060
2063 }
2064 break;
2065
2067 /* previous field was "t" for ISO time */
2070 return -1;
2071
2073 return -1;
2074 break;
2075
2076 default:
2077 return -1;
2078 break;
2079 }
2080
2081 ptype = 0;
2082 *dtype = DTK_DATE;
2083 }
2084 else
2085 {
2088
2091
2092 /* Embedded decimal and no date yet? */
2094 {
2096 return -1;
2097 }
2098 /* embedded decimal and several digits before? */
2100 {
2101 /*
2102 * Interpret as a concatenated date or time Set the
2103 * type field to allow decoding other fields later.
2104 * Example: 20011223 or 040506
2105 */
2108 return -1;
2109 }
2111 {
2114 return -1;
2115 }
2116 /* otherwise it is a single date/time field... */
2119 return -1;
2120 }
2121 break;
2122
2127 continue;
2128
2131 {
2134 {
2137 *dtype = DTK_DATE;
2139 break;
2140
2143 *dtype = DTK_DATE;
2150 break;
2151
2154 *dtype = DTK_DATE;
2159 break;
2160
2163 *dtype = DTK_DATE;
2170 break;
2171
2174 *dtype = DTK_DATE;
2179 *tzp = 0;
2180 break;
2181
2182 default:
2183 *dtype = val;
2184 }
2185
2186 break;
2187
2189
2190 /*
2191 * already have a (numeric) month? then see if we can
2192 * substitute...
2193 */
2196 {
2199 }
2202 break;
2203
2205
2206 /*
2207 * daylight savings time modifier (solves "MET DST"
2208 * syntax)
2209 */
2213 return -1;
2214 *tzp -= val;
2215 break;
2216
2218
2219 /*
2220 * set mask for TZ here _or_ check for DTZ later when
2221 * getting default timezone
2222 */
2226 return -1;
2227 *tzp = -val;
2229 break;
2230
2234 return -1;
2235 *tzp = -val;
2237 break;
2238
2240 break;
2241
2244 break;
2245
2248 break;
2249
2252 break;
2253
2255 tmask = 0;
2256 ptype = val;
2257 break;
2258
2260
2261 /*
2262 * This is a filler field "t" indicating that the next
2263 * field is time. Try to verify that this is sensible.
2264 */
2265 tmask = 0;
2266
2267 /* No preceding date? Then quit... */
2269 return -1;
2270
2271 /***
2272 * We will need one of the following fields:
2273 * DTK_NUMBER should be hhmmss.fff
2274 * DTK_TIME should be hh:mm:ss.fff
2275 * DTK_DATE should be hhmmss-zz
2276 ***/
2281 return -1;
2282
2283 ptype = val;
2284 break;
2285
2286 default:
2287 return -1;
2288 }
2289 break;
2290
2291 default:
2292 return -1;
2293 }
2294
2296 return -1;
2298 }
2299
2300 /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */
2301 if (bc)
2302 {
2305 else
2306 return -1;
2307 }
2309 {
2314 }
2315
2317 return -1;
2322
2323 /* do additional checking for full date specs... */
2325 {
2328
2329 /*
2330 * check for valid day of month and month, now that we know for sure
2331 * the month and year...
2332 */
2333 if (tm->tm_mon < 1 || tm->tm_mday < 1 || tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon - 1])
2334 return -1;
2335
2336 /*
2337 * backend tried to find local timezone here but we don't use the
2338 * result afterwards anyway so we only check for this error: daylight
2339 * savings time modifier but no standard timezone?
2340 */
2341 if ((fmask & DTK_DATE_M) == DTK_DATE_M && tzp != NULL && !(fmask & DTK_M(TZ)) && (fmask & DTK_M(DTZMOD)))
2342 return -1;
2343 }
2344
2345 return 0;
2346} /* DecodeDateTime() */
int DecodeTime(char *str, int *tmask, struct tm *tm, fsec_t *fsec)
Definition dt_common.c:1437
static int DecodeNumber(int flen, char *str, int fmask, int *tmask, struct tm *tm, fsec_t *fsec, bool *is2digits, bool EuroDates)
Definition dt_common.c:1199
static int DecodeSpecial(int field, char *lowtoken, int *val)
Definition dt_common.c:635
static int DecodeNumberField(int len, char *str, int fmask, int *tmask, struct tm *tm, fsec_t *fsec, bool *is2digits)
Definition dt_common.c:1089
void dt2time(double jd, int *hour, int *min, int *sec, fsec_t *fsec)
Definition dt_common.c:1068
static int DecodeDate(char *str, int fmask, int *tmask, struct tm *tm, bool EuroDates)
Definition dt_common.c:1308
static struct @172 value
int strtoint(const char *pg_restrict str, char **pg_restrict endptr, int base)
Definition string.c:50
References ADBC, AM, AMPM, BC, date2j(), DAY, day_tab, DecodeDate(), DecodeNumber(), DecodeNumberField(), DecodePosixTimezone(), DecodeSpecial(), DecodeTime(), DecodeTimezone(), DOW, dt2time(), DTK_DATE, DTK_DATE_M, DTK_DAY, DTK_HOUR, DTK_JULIAN, DTK_M, DTK_MINUTE, DTK_MONTH, DTK_NOW, DTK_NUMBER, DTK_SECOND, DTK_SPECIAL, DTK_STRING, DTK_TIME, DTK_TIME_M, DTK_TODAY, DTK_TOMORROW, DTK_TZ, DTK_YEAR, DTK_YESTERDAY, DTK_ZULU, DTZ, DTZMOD, fb(), GetCurrentDateTime(), HOUR, HR24, i, IGNORE_DTF, isleap, ISOTIME, j2date(), MINUTE, MONTH, PM, RESERV, SECOND, strtoint(), tm, pg_tm::tm_hour, pg_tm::tm_isdst, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_wday, pg_tm::tm_year, type, TZ, UNITS, USECS_PER_DAY, val, value, and YEAR.
◆ DecodeInterval()
| int DecodeInterval | ( | char ** | field, |
| int * | ftype, | ||
| int | nf, | ||
| int * | dtype, | ||
| struct tm * | tm, | ||
| fsec_t * | fsec | ||
| ) |
Definition at line 326 of file interval.c.
328{
334 tmask,
335 type;
339 double fval;
340
341 *dtype = DTK_DELTA;
344
345 /* read through list backwards to pick up units before values */
347 {
349 {
356 break;
357
359
360 /*
361 * Timezone is a token with a leading sign character and at
362 * least one digit; there could be ':', '.', '-' embedded in
363 * it as well.
364 */
366
367 /*
368 * Try for hh:mm or hh:mm:ss. If not, fall through to
369 * DTK_NUMBER case, which can handle signed float numbers and
370 * signed year-month values.
371 */
375 {
377 {
378 /* flip the sign on all fields */
382 *fsec = -(*fsec);
383 }
384
385 /*
386 * Set the next type to be a day, if units are not
387 * specified. This handles the case of '1 +02:03' since we
388 * are reading right to left.
389 */
392 break;
393 }
394 /* FALL THROUGH */
395
399 {
400 /* use typmod to decide what rightmost field is */
402 {
405 break;
409 break;
412 break;
418 break;
422 break;
427 break;
428 default:
430 break;
431 }
432 }
433
434 errno = 0;
438
440 {
441 /* SQL "years-months" syntax */
443
453 fval = 0;
454 }
456 {
457 errno = 0;
461
463 fval = -fval;
464 }
466 fval = 0;
467 else
469
471
473 {
477 break;
478
482 break;
483
486 *fsec += rint(fval * 1000000);
487
488 /*
489 * If any subseconds were specified, consider this
490 * microsecond and millisecond input as well.
491 */
492 if (fval == 0)
494 else
496 break;
497
502 break;
503
509 break;
510
515 break;
516
521 break;
522
527 break;
528
533 break;
534
539 break;
540
545 break;
546
551 break;
552
553 default:
555 }
556 break;
557
562 continue;
563
566 {
569 break;
570
574 break;
575
578 *dtype = val;
579 break;
580
581 default:
583 }
584 break;
585
586 default:
588 }
589
593 }
594
595 /* ensure that at least one time field has been found */
598
599 /* ensure fractional seconds are fractional */
600 if (*fsec != 0)
601 {
602 int sec;
603
604 sec = *fsec / USECS_PER_SEC;
605 *fsec -= sec * USECS_PER_SEC;
607 }
608
609 /*----------
610 * The SQL standard defines the interval literal
611 * '-1 1:00:00'
612 * to mean "negative 1 days and negative 1 hours", while Postgres
613 * traditionally treats this as meaning "negative 1 days and positive
614 * 1 hours". In SQL_STANDARD intervalstyle, we apply the leading sign
615 * to all fields if there are no other explicit signs.
616 *
617 * We leave the signs alone if there are additional explicit signs.
618 * This protects us against misinterpreting postgres-style dump output,
619 * since the postgres-style output code has always put an explicit sign on
620 * all fields following a negative field. But note that SQL-spec output
621 * is ambiguous and can be misinterpreted on load! (So it's best practice
622 * to dump in postgres style, not SQL style.)
623 *----------
624 */
626 {
627 /* Check for additional explicit signs */
629
631 {
633 {
635 break;
636 }
637 }
638
640 {
641 /*
642 * Rather than re-determining which field was field[0], just force
643 * 'em all negative.
644 */
645 if (*fsec > 0)
646 *fsec = -(*fsec);
659 }
660 }
661
662 /* finally, AGO negates everything */
664 {
665 *fsec = -(*fsec);
672 }
673
674 return 0;
675}
static int DecodeTime(char *str, int fmask, int range, int *tmask, struct pg_tm *tm, fsec_t *fsec)
Definition datetime.c:2725
static void AdjustFractDays(double frac, struct tm *tm, fsec_t *fsec, int scale)
Definition interval.c:41
static void AdjustFractSeconds(double frac, struct tm *tm, fsec_t *fsec, int scale)
Definition interval.c:23
static struct cvec * range(struct vars *v, chr a, chr b, int cases)
Definition regc_locale.c:412
References AdjustFractDays(), AdjustFractSeconds(), AGO, Assert, ClearPgTm(), DAY, DAYS_PER_MONTH, DecodeTime(), DecodeUnits(), DTERR_BAD_FORMAT, DTERR_FIELD_OVERFLOW, DTK_ALL_SECS_M, DTK_CENTURY, DTK_DATE, DTK_DATE_M, DTK_DAY, DTK_DECADE, DTK_DELTA, DTK_HOUR, DTK_M, DTK_MICROSEC, DTK_MILLENNIUM, DTK_MILLISEC, DTK_MINUTE, DTK_MONTH, DTK_NUMBER, DTK_SECOND, DTK_SPECIAL, DTK_STRING, DTK_TIME, DTK_TIME_M, DTK_TZ, DTK_WEEK, DTK_YEAR, fb(), HOUR, i, IGNORE_DTF, INTERVAL_FULL_RANGE, INTERVAL_MASK, IntervalStyle, INTSTYLE_POSTGRES_VERBOSE, INTSTYLE_SQL_STANDARD, MICROSECOND, MILLISECOND, MINUTE, MONTH, MONTHS_PER_YEAR, range(), RESERV, SECOND, SECS_PER_DAY, SECS_PER_HOUR, SECS_PER_MINUTE, strtoint(), tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, type, TZ, UNITS, USECS_PER_SEC, val, and YEAR.
Referenced by PGTYPESinterval_from_asc().
◆ DecodeTime()
Definition at line 1437 of file dt_common.c.
1438{
1440
1442
1445 return -1;
1449 {
1451 *fsec = 0;
1452 }
1454 return -1;
1455 else
1456 {
1460 *fsec = 0;
1462 {
1465
1466 cp++;
1467
1468 /*
1469 * OK, we have at most six digits to care about. Let's construct a
1470 * string with those digits, zero-padded on the right, and then do
1471 * the conversion to an integer.
1472 *
1473 * XXX This truncates the seventh digit, unlike rounding it as the
1474 * backend does.
1475 */
1481 return -1;
1482 }
1483 else
1484 return -1;
1485 }
1486
1487 /* do a sanity check */
1490 return -1;
1491
1492 return 0;
1493} /* DecodeTime() */
References DTK_TIME_M, fb(), i, str, strtoint(), tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, and USECS_PER_SEC.
Referenced by DecodeDateTime().
◆ DecodeUnits()
Definition at line 536 of file dt_common.c.
537{
540
541 /* use strncmp so that we match truncated tokens */
544 tp = deltacache[field];
545 else
547 deltacache[field] = tp;
549 {
551 *val = 0;
552 }
553 else
554 {
557 }
558
560} /* DecodeUnits() */
static const datetkn * datebsearch(const char *key, const datetkn *base, unsigned int nel)
Definition dt_common.c:502
Definition datetime.h:208
Definition oauth-curl.c:192
References datebsearch(), deltacache, deltatktbl, fb(), szdeltatktbl, TOKMAXLEN, type, datetkn::type, UNKNOWN_FIELD, val, and datetkn::value.
◆ dt2time()
Definition at line 1068 of file dt_common.c.
1069{
1070 int64 time;
1071
1072 time = jd;
1074 time -= (*hour) * USECS_PER_HOUR;
1075 *min = time / USECS_PER_MINUTE;
1076 time -= (*min) * USECS_PER_MINUTE;
1077 *sec = time / USECS_PER_SEC;
1078 *fsec = time - (*sec * USECS_PER_SEC);
1079} /* dt2time() */
References fb(), USECS_PER_HOUR, USECS_PER_MINUTE, and USECS_PER_SEC.
Referenced by DecodeDateTime().
◆ EncodeDateOnly()
Definition at line 669 of file dt_common.c.
670{
672
674 {
676 /* compatible with ISO date formats */
680 else
683 break;
684
686 /* compatible with Oracle/Ingres date formats */
689 else
693 else
695 break;
696
698 /* German-style date format */
702 else
704 break;
705
707 default:
708 /* traditional date-only style for Postgres */
711 else
715 else
717 break;
718 }
719}
References Assert, fb(), MONTHS_PER_YEAR, sprintf, str, tm, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_year, USE_GERMAN_DATES, USE_ISO_DATES, USE_POSTGRES_DATES, and USE_SQL_DATES.
◆ EncodeDateTime()
| void EncodeDateTime | ( | struct tm * | tm, |
| fsec_t | fsec, | ||
| bool | print_tz, | ||
| int | tz, | ||
| const char * | tzn, | ||
| int | style, | ||
| char * | str, | ||
| bool | EuroDates | ||
| ) |
Definition at line 753 of file dt_common.c.
754{
755 int day,
756 hour,
757 min;
758
759 /*
760 * Negative tm_isdst means we have no valid time zone translation.
761 */
764
766 {
768 /* Compatible with ISO-8601 date formats */
769
773
774 /*
775 * Print fractional seconds if any. The field widths here should
776 * be at least equal to MAX_TIMESTAMP_PRECISION.
777 */
778 if (fsec != 0)
779 {
782 }
783 else
785
788
790 {
793 if (min != 0)
795 else
797 }
798 break;
799
801 /* Compatible with Oracle/Ingres date formats */
802
805 else
807
811
812 /*
813 * Print fractional seconds if any. The field widths here should
814 * be at least equal to MAX_TIMESTAMP_PRECISION.
815 */
816 if (fsec != 0)
817 {
820 }
821 else
823
826
827 /*
828 * Note: the uses of %.*s in this function would be risky if the
829 * timezone names ever contain non-ASCII characters, since we are
830 * not being careful to do encoding-aware clipping. However, all
831 * TZ abbreviations in the IANA database are plain ASCII.
832 */
833
835 {
836 if (tzn)
838 else
839 {
842 if (min != 0)
844 else
846 }
847 }
848 break;
849
851 /* German variant on European style */
852
854
858
859 /*
860 * Print fractional seconds if any. The field widths here should
861 * be at least equal to MAX_TIMESTAMP_PRECISION.
862 */
863 if (fsec != 0)
864 {
867 }
868 else
870
873
875 {
876 if (tzn)
878 else
879 {
882 if (min != 0)
884 else
886 }
887 }
888 break;
889
891 default:
892 /* Backward-compatible with traditional Postgres abstime dates */
893
896
899
902 else
904
906
907 /*
908 * Print fractional seconds if any. The field widths here should
909 * be at least equal to MAX_TIMESTAMP_PRECISION.
910 */
911 if (fsec != 0)
912 {
915 }
916 else
918
923
925 {
926 if (tzn)
928 else
929 {
930 /*
931 * We have a time zone, but no string version. Use the
932 * numeric form, but be sure to include a leading space to
933 * avoid formatting something which would be rejected by
934 * the date/time parser later. - thomas 2001-10-19
935 */
938 if (min != 0)
940 else
942 }
943 }
944 break;
945 }
946}
References date2j(), days, fb(), MAXTZLEN, MINS_PER_HOUR, months, SECS_PER_HOUR, sprintf, str, tm, pg_tm::tm_hour, pg_tm::tm_isdst, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_wday, pg_tm::tm_year, TrimTrailingZeros(), USE_GERMAN_DATES, USE_ISO_DATES, USE_POSTGRES_DATES, and USE_SQL_DATES.
◆ EncodeInterval()
Definition at line 759 of file interval.c.
760{
770
771 /*
772 * The sign of year and month are guaranteed to match, since they are
773 * stored internally as "month". But we'll need to check for is_before and
774 * is_zero when determining the signs of day and hour/minute/seconds
775 * fields.
776 */
778 {
779 /* SQL Standard interval format */
781 {
784 min < 0 || sec < 0 || fsec < 0;
787 min > 0 || sec > 0 || fsec > 0;
790 min != 0 || sec != 0 || fsec != 0;
794
795 /*
796 * SQL Standard wants only 1 "<sign>" preceding the whole
797 * interval ... but can't do that if mixed signs.
798 */
800 {
802 year = -year;
803 mon = -mon;
806 min = -min;
807 sec = -sec;
808 fsec = -fsec;
809 }
810
812 {
814 }
816 {
817 /*
818 * For non sql-standard interval values, force outputting
819 * the signs to avoid ambiguities with intervals with
820 * mixed sign components.
821 */
825 sec < 0 || fsec < 0) ? '-' : '+';
826
833 }
835 {
837 }
839 {
843 }
844 else
845 {
849 }
850 }
851 break;
852
853 /* ISO 8601 "time-intervals by duration only" */
855 /* special-case zero to avoid printing nothing */
857 hour == 0 && min == 0 && sec == 0 && fsec == 0)
858 {
860 break;
861 }
870 if (sec != 0 || fsec != 0)
871 {
872 if (sec < 0 || fsec < 0)
878 }
879 break;
880
881 /* Compatible with postgresql < 8.4 when DateStyle = 'iso' */
887 {
889
896 }
897 break;
898
899 /* Compatible with postgresql < 8.4 when DateStyle != 'iso' */
901 default:
903 cp++;
909 if (sec != 0 || fsec != 0)
910 {
912 if (sec < 0 || (sec == 0 && fsec < 0))
913 {
918 }
923 /* We output "ago", not negatives, so use abs(). */
927 }
928 /* identically zero? then put in a unitless zero... */
933 break;
934 }
935}
static char * AddISO8601IntPart(char *cp, int value, char units)
Definition interval.c:723
static char * AddPostgresIntPart(char *cp, int value, const char *units, bool *is_zero, bool *is_before)
Definition interval.c:700
static void AppendSeconds(char *cp, int sec, fsec_t fsec, int precision, bool fillzeros)
Definition interval.c:733
static char * AddVerboseIntPart(char *cp, int value, const char *units, bool *is_zero, bool *is_before)
Definition interval.c:680
References AddISO8601IntPart(), AddPostgresIntPart(), AddVerboseIntPart(), AppendSeconds(), fb(), INTSTYLE_ISO_8601, INTSTYLE_POSTGRES, INTSTYLE_POSTGRES_VERBOSE, INTSTYLE_SQL_STANDARD, MAX_INTERVAL_PRECISION, sprintf, str, tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, and pg_tm::tm_year.
Referenced by PGTYPESinterval_to_asc().
◆ GetCurrentDateTime()
Definition at line 1060 of file dt_common.c.
1061{
1062 int tz;
1063
1065}
static void abstime2tm(AbsoluteTime _time, int *tzp, struct tm *tm, char **tzn)
Definition dt_common.c:973
References abstime2tm(), fb(), and tm.
Referenced by DecodeDateTime().
◆ GetEpochTime()
Definition at line 949 of file dt_common.c.
950{
954
956
958 {
965
966 return 0;
967 }
968
969 return -1;
970} /* GetEpochTime() */
References epoch, fb(), tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, and pg_tm::tm_year.
◆ j2date()
Definition at line 321 of file datetime.c.
322{
325 unsigned int extra;
327
329 julian += 32044;
337 + 123;
339 *year = y - 4800;
343} /* j2date() */
References fb(), MONTHS_PER_YEAR, and y.
Referenced by date2timestamptz_safe(), date_out(), DecodeDateTime(), DecodeDateTime(), DecodeNumber(), DecodeTimeOnly(), do_to_timestamp(), executeDateTimeMethod(), extract_date(), isoweek2date(), isoweekdate2date(), JsonEncodeDateTime(), map_sql_value_to_xml_value(), PGTYPESdate_fmt_asc(), PGTYPESdate_julmdy(), PGTYPESdate_to_asc(), timestamp2tm(), timestamp2tm(), timestamp_pl_interval(), timestamptz_pl_interval_internal(), and ValidateDate().
◆ ParseDateTime()
| int ParseDateTime | ( | char * | timestr, |
| char * | lowstr, | ||
| char ** | field, | ||
| int * | ftype, | ||
| int * | numfields, | ||
| char ** | endstr | ||
| ) |
Definition at line 1600 of file dt_common.c.
1602{
1605
1607 /* outer loop through fields */
1609 {
1610 /* Record start of current field */
1612 return -1;
1614
1615 /* leading digit? then date or time */
1617 {
1618 *lp++ = *(*endstr)++;
1620 *lp++ = *(*endstr)++;
1621
1622 /* time field? */
1624 {
1626 *lp++ = *(*endstr)++;
1629 *lp++ = *(*endstr)++;
1630 }
1631 /* date field? allow embedded text month */
1633 {
1634 /* save delimiting character to use later */
1636
1637 *lp++ = *(*endstr)++;
1638 /* second field is all digits? then no embedded text month */
1640 {
1643 *lp++ = *(*endstr)++;
1644
1645 /*
1646 * insist that the delimiters match to get a three-field
1647 * date.
1648 */
1650 {
1652 *lp++ = *(*endstr)++;
1654 *lp++ = *(*endstr)++;
1655 }
1656 }
1657 else
1658 {
1662 }
1663 }
1664
1665 /*
1666 * otherwise, number only and will determine year, month, day, or
1667 * concatenated fields later...
1668 */
1669 else
1671 }
1672 /* Leading decimal point? Then fractional seconds... */
1674 {
1675 *lp++ = *(*endstr)++;
1677 *lp++ = *(*endstr)++;
1678
1680 }
1681
1682 /*
1683 * text? then date string, month, day of week, special, or timezone
1684 */
1686 {
1691
1692 /*
1693 * Full date string with leading text month? Could also be a POSIX
1694 * time zone...
1695 */
1697 {
1699
1701 *lp++ = *(*endstr)++;
1703 *lp++ = *(*endstr)++;
1704 }
1705 }
1706 /* skip leading spaces */
1708 {
1709 (*endstr)++;
1710 continue;
1711 }
1712 /* sign? then special or numeric timezone */
1714 {
1715 *lp++ = *(*endstr)++;
1716 /* soak up leading whitespace */
1718 (*endstr)++;
1719 /* numeric timezone? */
1721 {
1723 *lp++ = *(*endstr)++;
1726 *lp++ = *(*endstr)++;
1727 }
1728 /* special? */
1730 {
1735 }
1736 /* otherwise something wrong... */
1737 else
1738 return -1;
1739 }
1740 /* ignore punctuation but use as delimiter */
1742 {
1743 (*endstr)++;
1744 continue;
1745 }
1746 /* otherwise, something is not right... */
1747 else
1748 return -1;
1749
1750 /* force in a delimiter after each field */
1752 nf++;
1753 }
1754
1756
1757 return 0;
1758} /* ParseDateTime() */
References DTK_DATE, DTK_NUMBER, DTK_SPECIAL, DTK_STRING, DTK_TIME, DTK_TZ, fb(), MAXDATEFIELDS, and pg_tolower().
◆ PGTYPEStimestamp_defmt_scan()
| int PGTYPEStimestamp_defmt_scan | ( | char ** | str, |
| char * | fmt, | ||
| timestamp * | d, | ||
| int * | year, | ||
| int * | month, | ||
| int * | day, | ||
| int * | hour, | ||
| int * | minute, | ||
| int * | second, | ||
| int * | tz | ||
| ) |
Definition at line 2521 of file dt_common.c.
2525{
2528
2530 *pfmt,
2531 *tmp;
2535
2538
2540 {
2541 err = 0;
2543 pfmt++;
2545 pstr++;
2547 {
2549 {
2550 pfmt++;
2551 pstr++;
2552 }
2553 else
2554 {
2555 /* Error: no match */
2556 err = 1;
2558 }
2559 continue;
2560 }
2561 /* here *pfmt equals '%' */
2562 pfmt++;
2564 {
2565 case 'a':
2566 pfmt++;
2567
2568 /*
2569 * we parse the day and see if it is a week day but we do not
2570 * check if the week day really matches the date
2571 */
2572 err = 1;
2573 j = 0;
2575 {
2578 {
2579 /* found it */
2580 err = 0;
2582 break;
2583 }
2584 j++;
2585 }
2586 break;
2587 case 'A':
2588 /* see note above */
2589 pfmt++;
2590 err = 1;
2591 j = 0;
2593 {
2595 {
2596 /* found it */
2597 err = 0;
2599 break;
2600 }
2601 j++;
2602 }
2603 break;
2604 case 'b':
2605 case 'h':
2606 pfmt++;
2607 err = 1;
2608 j = 0;
2610 {
2612 {
2613 /* found it */
2614 err = 0;
2616 *month = j + 1;
2617 break;
2618 }
2619 j++;
2620 }
2621 break;
2622 case 'B':
2623 /* see note above */
2624 pfmt++;
2625 err = 1;
2626 j = 0;
2628 {
2630 {
2631 /* found it */
2632 err = 0;
2634 *month = j + 1;
2635 break;
2636 }
2637 j++;
2638 }
2639 break;
2640 case 'c':
2641 /* XXX */
2642 break;
2643 case 'C':
2644 pfmt++;
2647 *year = scan_val.uint_val * 100;
2648 break;
2649 case 'd':
2650 case 'e':
2651 pfmt++;
2654 *day = scan_val.uint_val;
2655 break;
2656 case 'D':
2657
2658 /*
2659 * we have to concatenate the strings in order to be able to
2660 * find the end of the substitution
2661 */
2662 pfmt++;
2664 if (!tmp)
2665 return 1;
2669 free(tmp);
2671 case 'm':
2672 pfmt++;
2675 *month = scan_val.uint_val;
2676 break;
2677 case 'y':
2678 case 'g': /* XXX difference to y (ISO) */
2679 pfmt++;
2682 if (*year < 0)
2683 {
2684 /* not yet set */
2685 *year = scan_val.uint_val;
2686 }
2687 else
2688 *year += scan_val.uint_val;
2689 if (*year < 100)
2690 *year += 1900;
2691 break;
2692 case 'G':
2693 /* XXX difference to %V (ISO) */
2694 pfmt++;
2697 *year = scan_val.uint_val;
2698 break;
2699 case 'H':
2700 case 'I':
2701 case 'k':
2702 case 'l':
2703 pfmt++;
2707 break;
2708 case 'j':
2709 pfmt++;
2712
2713 /*
2714 * XXX what should we do with that? We could say that it's
2715 * sufficient if we have the year and the day within the year
2716 * to get at least a specific day.
2717 */
2718 break;
2719 case 'M':
2720 pfmt++;
2724 break;
2725 case 'n':
2726 pfmt++;
2728 pstr++;
2729 else
2730 err = 1;
2731 break;
2732 case 'p':
2733 err = 1;
2734 pfmt++;
2736 {
2737 *hour += 0;
2738 err = 0;
2739 pstr += 2;
2740 }
2742 {
2743 *hour += 0;
2744 err = 0;
2745 pstr += 4;
2746 }
2748 {
2749 *hour += 12;
2750 err = 0;
2751 pstr += 2;
2752 }
2754 {
2755 *hour += 12;
2756 err = 0;
2757 pstr += 4;
2758 }
2759 break;
2760 case 'P':
2761 err = 1;
2762 pfmt++;
2764 {
2765 *hour += 0;
2766 err = 0;
2767 pstr += 2;
2768 }
2770 {
2771 *hour += 0;
2772 err = 0;
2773 pstr += 4;
2774 }
2776 {
2777 *hour += 12;
2778 err = 0;
2779 pstr += 2;
2780 }
2782 {
2783 *hour += 12;
2784 err = 0;
2785 pstr += 4;
2786 }
2787 break;
2788 case 'r':
2789 pfmt++;
2791 if (!tmp)
2792 return 1;
2796 free(tmp);
2798 case 'R':
2799 pfmt++;
2801 if (!tmp)
2802 return 1;
2806 free(tmp);
2808 case 's':
2809 pfmt++;
2812 /* number of seconds in scan_val.luint_val */
2813 {
2817
2819
2821 {
2822 *year = tms->tm_year + 1900;
2823 *month = tms->tm_mon + 1;
2824 *day = tms->tm_mday;
2827 *second = tms->tm_sec;
2828 }
2829 else
2830 err = 1;
2831 }
2832 break;
2833 case 'S':
2834 pfmt++;
2837 *second = scan_val.uint_val;
2838 break;
2839 case 't':
2840 pfmt++;
2842 pstr++;
2843 else
2844 err = 1;
2845 break;
2846 case 'T':
2847 pfmt++;
2849 if (!tmp)
2850 return 1;
2854 free(tmp);
2856 case 'u':
2857 pfmt++;
2861 err = 1;
2862 break;
2863 case 'U':
2864 pfmt++;
2868 err = 1;
2869 break;
2870 case 'V':
2871 pfmt++;
2875 err = 1;
2876 break;
2877 case 'w':
2878 pfmt++;
2882 err = 1;
2883 break;
2884 case 'W':
2885 pfmt++;
2889 err = 1;
2890 break;
2891 case 'x':
2892 case 'X':
2893 /* XXX */
2894 break;
2895 case 'Y':
2896 pfmt++;
2899 *year = scan_val.uint_val;
2900 break;
2901 case 'z':
2902 pfmt++;
2906 {
2909 }
2910 break;
2911 case 'Z':
2912 pfmt++;
2916 {
2917 /*
2918 * XXX use DecodeSpecial instead? Do we need strcasecmp
2919 * here?
2920 */
2921 err = 1;
2923 {
2926 scan_val.str_val) == 0)
2927 {
2929 err = 0;
2930 break;
2931 }
2932 }
2934 }
2935 break;
2936 case '+':
2937 /* XXX */
2938 break;
2939 case '%':
2940 pfmt++;
2942 pstr++;
2943 else
2944 err = 1;
2945 break;
2946 default:
2947 err = 1;
2948 }
2949 }
2951 {
2952 if (*second < 0)
2953 *second = 0;
2955 *minute = 0;
2957 *hour = 0;
2958 if (*day < 0)
2959 {
2960 err = 1;
2961 *day = 1;
2962 }
2963 if (*month < 0)
2964 {
2965 err = 1;
2966 *month = 1;
2967 }
2968 if (*year < 0)
2969 {
2970 err = 1;
2971 *year = 1970;
2972 }
2973
2974 if (*second > 59)
2975 {
2976 err = 1;
2977 *second = 0;
2978 }
2980 {
2981 err = 1;
2982 *minute = 0;
2983 }
2986 {
2987 err = 1;
2988 *hour = 0;
2989 }
2991 {
2992 err = 1;
2993 *month = 1;
2994 }
2996 {
2998 err = 1;
2999 }
3000
3007
3009 }
3011}
int tm2timestamp(struct pg_tm *tm, fsec_t fsec, int *tzp, Timestamp *result)
Definition timestamp.c:2006
int PGTYPEStimestamp_defmt_scan(char **str, char *fmt, timestamp *d, int *year, int *month, int *day, int *hour, int *minute, int *second, int *tz)
Definition dt_common.c:2521
static int pgtypes_defmt_scan(union un_fmt_comb *scan_val, int scan_type, char **pstr, char *pfmt)
Definition dt_common.c:2459
Definition pgtypeslib_extern.h:26
References datetktbl, day_tab, days, DecodeTimezone(), DTZ, err(), fb(), free, isleap, j, months, MONTHS_PER_YEAR, pg_strcasecmp(), pgtypes_alloc(), pgtypes_date_months, pgtypes_date_weekdays_short, pgtypes_defmt_scan(), PGTYPES_TYPE_STRING_MALLOCED, PGTYPES_TYPE_UINT, PGTYPES_TYPE_UINT_LONG, PGTYPEStimestamp_defmt_scan(), str, szdatetktbl, tm, tm2timestamp(), pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, type, TZ, and datetkn::value.
Referenced by PGTYPEStimestamp_defmt_asc(), and PGTYPEStimestamp_defmt_scan().
◆ tm2timestamp()
Definition at line 41 of file timestamp.c.
42{
44 int64 time;
45
46 /* Prevent overflow in Julian-day routines */
48 return -1;
49
53 pg_add_s64_overflow(*result, time, result)))
54 return -1;
56 *result = dt2local(*result, -(*tzp));
57
58 /* final range check catches just-out-of-range timestamps */
60 return -1;
61
62 return 0;
63} /* tm2timestamp() */
static bool pg_mul_s64_overflow(int64 a, int64 b, int64 *result)
Definition int.h:293
static bool pg_add_s64_overflow(int64 a, int64 b, int64 *result)
Definition int.h:235
static int64 time2t(const int hour, const int min, const int sec, const fsec_t fsec)
Definition timestamp.c:21
References date2j(), dt2local(), fb(), IS_VALID_JULIAN, IS_VALID_TIMESTAMP, pg_add_s64_overflow(), pg_mul_s64_overflow(), time2t(), tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, unlikely, and USECS_PER_DAY.
◆ TrimTrailingZeros()
Definition at line 722 of file dt_common.c.
723{
725
726 /* chop off trailing zeros... but leave at least 2 fractional digits */
728 {
729 len--;
731 }
732}
References fb(), len, and str.
Referenced by AppendSeconds(), and EncodeDateTime().
Variable Documentation
◆ day_tab
Definition at line 75 of file datetime.c.
76{
77 {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0},
78 {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0}
79};
Referenced by DecodeDateTime(), PGTYPEStimestamp_add_interval(), PGTYPEStimestamp_defmt_scan(), timestamp_age(), timestamp_pl_interval(), timestamptz_age(), timestamptz_pl_interval_internal(), and ValidateDate().
◆ days
|
extern |
Definition at line 84 of file datetime.c.
84 {"Sunday", "Monday", "Tuesday", "Wednesday",
Referenced by AdjustDays(), brin_minmax_multi_distance_interval(), date_mii(), date_pli(), DCH_from_char(), DCH_to_char(), dttofmtasc_replace(), EncodeDateTime(), EncodeDateTime(), interval_cmp_value(), make_interval(), PGTYPEStimestamp_defmt_scan(), and PrintTiming().
◆ months
|
extern |
Definition at line 81 of file datetime.c.
81 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
Referenced by DCH_from_char(), DCH_to_char(), dttofmtasc_replace(), EncodeDateTime(), EncodeDateTime(), make_interval(), PGTYPESdate_defmt_asc(), PGTYPESdate_fmt_asc(), and PGTYPEStimestamp_defmt_scan().
◆ pgtypes_date_months
|
extern |
Definition at line 499 of file dt_common.c.
499{"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December", NULL};
Referenced by dttofmtasc_replace(), PGTYPESdate_defmt_asc(), and PGTYPEStimestamp_defmt_scan().
◆ pgtypes_date_weekdays_short
|
extern |
Definition at line 497 of file dt_common.c.
Referenced by dttofmtasc_replace(), PGTYPESdate_fmt_asc(), and PGTYPEStimestamp_defmt_scan().
