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 |
Macros | |
| #define | MAXTZLEN 10 |
| #define | USE_POSTGRES_DATES 0 |
| #define | USE_ISO_DATES 1 |
| #define | USE_SQL_DATES 2 |
| #define | USE_GERMAN_DATES 3 |
| #define | INTSTYLE_POSTGRES 0 |
| #define | INTSTYLE_POSTGRES_VERBOSE 1 |
| #define | INTSTYLE_SQL_STANDARD 2 |
| #define | INTSTYLE_ISO_8601 3 |
| #define | INTERVAL_FULL_RANGE (0x7FFF) |
| #define | INTERVAL_MASK(b) (1 << (b)) |
| #define | MAX_INTERVAL_PRECISION 6 |
| #define | DTERR_BAD_FORMAT (-1) |
| #define | DTERR_FIELD_OVERFLOW (-2) |
| #define | DTERR_MD_FIELD_OVERFLOW (-3) /* triggers hint about DateStyle */ |
| #define | DTERR_INTERVAL_OVERFLOW (-4) |
| #define | DTERR_TZDISP_OVERFLOW (-5) |
| #define | DAGO "ago" |
| #define | DCURRENT "current" |
| #define | EPOCH "epoch" |
| #define | INVALID "invalid" |
| #define | EARLY "-infinity" |
| #define | LATE "infinity" |
| #define | NOW "now" |
| #define | TODAY "today" |
| #define | TOMORROW "tomorrow" |
| #define | YESTERDAY "yesterday" |
| #define | ZULU "zulu" |
| #define | DMICROSEC "usecond" |
| #define | DMILLISEC "msecond" |
| #define | DSECOND "second" |
| #define | DMINUTE "minute" |
| #define | DHOUR "hour" |
| #define | DDAY "day" |
| #define | DWEEK "week" |
| #define | DMONTH "month" |
| #define | DQUARTER "quarter" |
| #define | DYEAR "year" |
| #define | DDECADE "decade" |
| #define | DCENTURY "century" |
| #define | DMILLENNIUM "millennium" |
| #define | DA_D "ad" |
| #define | DB_C "bc" |
| #define | DTIMEZONE "timezone" |
| #define | AM 0 |
| #define | PM 1 |
| #define | HR24 2 |
| #define | AD 0 |
| #define | BC 1 |
| #define | RESERV 0 |
| #define | MONTH 1 |
| #define | YEAR 2 |
| #define | DAY 3 |
| #define | JULIAN 4 |
| #define | TZ 5 /* fixed-offset timezone abbreviation */ |
| #define | DTZ 6 /* fixed-offset timezone abbrev, DST */ |
| #define | DYNTZ 7 /* dynamic timezone abbr (unimplemented) */ |
| #define | IGNORE_DTF 8 |
| #define | AMPM 9 |
| #define | HOUR 10 |
| #define | MINUTE 11 |
| #define | SECOND 12 |
| #define | MILLISECOND 13 |
| #define | MICROSECOND 14 |
| #define | DOY 15 |
| #define | DOW 16 |
| #define | UNITS 17 |
| #define | ADBC 18 |
| #define | AGO 19 |
| #define | ABS_BEFORE 20 |
| #define | ABS_AFTER 21 |
| #define | ISODATE 22 |
| #define | ISOTIME 23 |
| #define | DTZMOD 28 /* "DST" as a separate word */ |
| #define | UNKNOWN_FIELD 31 |
| #define | DTK_NUMBER 0 |
| #define | DTK_STRING 1 |
| #define | DTK_DATE 2 |
| #define | DTK_TIME 3 |
| #define | DTK_TZ 4 |
| #define | DTK_AGO 5 |
| #define | DTK_SPECIAL 6 |
| #define | DTK_EARLY 9 |
| #define | DTK_LATE 10 |
| #define | DTK_EPOCH 11 |
| #define | DTK_NOW 12 |
| #define | DTK_YESTERDAY 13 |
| #define | DTK_TODAY 14 |
| #define | DTK_TOMORROW 15 |
| #define | DTK_ZULU 16 |
| #define | DTK_DELTA 17 |
| #define | DTK_SECOND 18 |
| #define | DTK_MINUTE 19 |
| #define | DTK_HOUR 20 |
| #define | DTK_DAY 21 |
| #define | DTK_WEEK 22 |
| #define | DTK_MONTH 23 |
| #define | DTK_QUARTER 24 |
| #define | DTK_YEAR 25 |
| #define | DTK_DECADE 26 |
| #define | DTK_CENTURY 27 |
| #define | DTK_MILLENNIUM 28 |
| #define | DTK_MILLISEC 29 |
| #define | DTK_MICROSEC 30 |
| #define | DTK_JULIAN 31 |
| #define | DTK_DOW 32 |
| #define | DTK_DOY 33 |
| #define | DTK_TZ_HOUR 34 |
| #define | DTK_TZ_MINUTE 35 |
| #define | DTK_ISOYEAR 36 |
| #define | DTK_ISODOW 37 |
| #define | DTK_M(t) (0x01 << (t)) |
| #define | DTK_ALL_SECS_M (DTK_M(SECOND) | DTK_M(MILLISECOND) | DTK_M(MICROSECOND)) |
| #define | DTK_DATE_M (DTK_M(YEAR) | DTK_M(MONTH) | DTK_M(DAY)) |
| #define | DTK_TIME_M (DTK_M(HOUR) | DTK_M(MINUTE) | DTK_M(SECOND)) |
| #define | MAXDATELEN 128 |
| #define | MAXDATEFIELDS 25 |
| #define | TOKMAXLEN 10 |
| #define | FMODULO(t, q, u) |
| #define | TMODULO(t, q, u) |
| #define | DAYS_PER_YEAR 365.25 /* assumes leap year every four years */ |
| #define | MONTHS_PER_YEAR 12 |
| #define | DAYS_PER_MONTH 30 /* assumes exactly 30 days per month */ |
| #define | HOURS_PER_DAY 24 /* assume no daylight savings time changes */ |
| #define | SECS_PER_YEAR (36525 * 864) /* avoid floating-point computation */ |
| #define | SECS_PER_DAY 86400 |
| #define | SECS_PER_HOUR 3600 |
| #define | SECS_PER_MINUTE 60 |
| #define | MINS_PER_HOUR 60 |
| #define | USECS_PER_DAY INT64CONST(86400000000) |
| #define | USECS_PER_HOUR INT64CONST(3600000000) |
| #define | USECS_PER_MINUTE INT64CONST(60000000) |
| #define | USECS_PER_SEC INT64CONST(1000000) |
| #define | isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0)) |
| #define | JULIAN_MINYEAR (-4713) |
| #define | JULIAN_MINMONTH (11) |
| #define | JULIAN_MINDAY (24) |
| #define | JULIAN_MAXYEAR (5874898) |
| #define | JULIAN_MAXMONTH (6) |
| #define | JULIAN_MAXDAY (3) |
| #define | IS_VALID_JULIAN(y, m, d) |
| #define | MIN_TIMESTAMP INT64CONST(-211813488000000000) |
| #define | END_TIMESTAMP INT64CONST(9223371331200000000) |
| #define | IS_VALID_TIMESTAMP(t) (MIN_TIMESTAMP <= (t) && (t) < END_TIMESTAMP) |
| #define | UTIME_MINYEAR (1901) |
| #define | UTIME_MINMONTH (12) |
| #define | UTIME_MINDAY (14) |
| #define | UTIME_MAXYEAR (2038) |
| #define | UTIME_MAXMONTH (01) |
| #define | UTIME_MAXDAY (18) |
| #define | IS_VALID_UTIME(y, m, d) |
| #define | DT_NOBEGIN (-INT64CONST(0x7fffffffffffffff) - 1) |
| #define | DT_NOEND (INT64CONST(0x7fffffffffffffff)) |
| #define | TIMESTAMP_NOBEGIN(j) do {(j) = DT_NOBEGIN;} while (0) |
| #define | TIMESTAMP_NOEND(j) do {(j) = DT_NOEND;} while (0) |
| #define | TIMESTAMP_IS_NOBEGIN(j) ((j) == DT_NOBEGIN) |
| #define | TIMESTAMP_IS_NOEND(j) ((j) == DT_NOEND) |
| #define | TIMESTAMP_NOT_FINITE(j) (TIMESTAMP_IS_NOBEGIN(j) || TIMESTAMP_IS_NOEND(j)) |
Typedefs | |
| typedef int32 | fsec_t |
Functions | |
| int | DecodeInterval (char **field, int *ftype, int nf, int *dtype, struct tm *tm, fsec_t *fsec) |
| int | DecodeTime (char *str, int *tmask, struct tm *tm, fsec_t *fsec) |
| void | EncodeDateTime (struct tm *tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str, bool EuroDates) |
| void | EncodeInterval (struct tm *tm, fsec_t fsec, int style, char *str) |
| int | tm2timestamp (struct tm *tm, fsec_t fsec, int *tzp, timestamp *result) |
| int | DecodeUnits (int field, char *lowtoken, int *val) |
| bool | CheckDateTokenTables (void) |
| void | EncodeDateOnly (struct tm *tm, int style, char *str, bool EuroDates) |
| int | GetEpochTime (struct tm *tm) |
| int | ParseDateTime (char *timestr, char *lowstr, char **field, int *ftype, int *numfields, char **endstr) |
| int | DecodeDateTime (char **field, int *ftype, int nf, int *dtype, struct tm *tm, fsec_t *fsec, bool EuroDates) |
| void | j2date (int jd, int *year, int *month, int *day) |
| void | GetCurrentDateTime (struct tm *tm) |
| int | date2j (int y, int m, int d) |
| void | TrimTrailingZeros (char *str) |
| void | dt2time (double jd, int *hour, int *min, int *sec, fsec_t *fsec) |
| int | PGTYPEStimestamp_defmt_scan (char **str, char *fmt, timestamp *d, int *year, int *month, int *day, int *hour, int *minute, int *second, int *tz) |
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
| #define DAYS_PER_MONTH 30 /* assumes exactly 30 days per month */ |
◆ DAYS_PER_YEAR
| #define DAYS_PER_YEAR 365.25 /* assumes leap year every four years */ |
◆ 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
| #define DTERR_MD_FIELD_OVERFLOW (-3) /* triggers hint about DateStyle */ |
◆ 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 | |||
| ) |
◆ HOUR
◆ HOURS_PER_DAY
| #define HOURS_PER_DAY 24 /* assume no daylight savings time changes */ |
◆ HR24
◆ IGNORE_DTF
◆ INTERVAL_FULL_RANGE
◆ INTERVAL_MASK
◆ INTSTYLE_ISO_8601
◆ INTSTYLE_POSTGRES
◆ INTSTYLE_POSTGRES_VERBOSE
◆ INTSTYLE_SQL_STANDARD
◆ INVALID
◆ IS_VALID_JULIAN
| #define IS_VALID_JULIAN | ( | y, | |
| m, | |||
| d | |||
| ) |
Value:
(((y) > JULIAN_MINYEAR || \
((y) < JULIAN_MAXYEAR || \
◆ IS_VALID_TIMESTAMP
| #define IS_VALID_TIMESTAMP | ( | t | ) | (MIN_TIMESTAMP <= (t) && (t) < END_TIMESTAMP) |
◆ IS_VALID_UTIME
| #define IS_VALID_UTIME | ( | y, | |
| m, | |||
| d | |||
| ) |
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
| #define TIMESTAMP_IS_NOBEGIN | ( | j | ) | ((j) == DT_NOBEGIN) |
◆ TIMESTAMP_IS_NOEND
◆ TIMESTAMP_NOBEGIN
| #define TIMESTAMP_NOBEGIN | ( | j | ) | do {(j) = DT_NOBEGIN;} while (0) |
◆ 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
◆ 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()
| bool CheckDateTokenTables | ( | void | ) |
Definition at line 4933 of file datetime.c.
4934{
4935 bool ok = true;
4936
4939
4942 return ok;
4943}
static bool CheckDateTokenTable(const char *tablename, const datetkn *base, int nel)
Definition: datetime.c:4901
Assert(PointerIsAligned(start, uint64))
References Assert(), CheckDateTokenTable(), date2j(), datetktbl, deltatktbl, POSTGRES_EPOCH_JDATE, szdatetktbl, szdeltatktbl, and UNIX_EPOCH_JDATE.
Referenced by PostmasterMain().
◆ date2j()
| int date2j | ( | int | y, |
| int | m, | ||
| int | d | ||
| ) |
Definition at line 296 of file datetime.c.
297{
298 int julian;
299 int century;
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;
314 julian += year / 4 - century + century / 4;
315 julian += 7834 * month / 256 + day;
316
317 return julian;
318} /* date2j() */
References y.
Referenced by CheckDateTokenTables(), date2isoweek(), date2isoyear(), date2isoyearday(), date_in(), DCH_to_char(), DecodeDateTime(), DecodeNumber(), DetermineTimeZoneOffsetInternal(), 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(), 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{
1785 int fmask = 0,
1786 tmask,
1787 type;
1788 int ptype = 0; /* "prefix type" for ISO y2001m02d04 format */
1792 bool haveTextMonth = false;
1793 bool is2digits = false;
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 */
1809 if (tzp != NULL)
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 {
1824 char *cp;
1825 int jday;
1826
1827 if (tzp == NULL)
1828 return -1;
1829
1831 if (*cp != '-')
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... */
1853 if (tzp == NULL)
1854 return -1;
1855
1857 {
1858 char *cp;
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;
1882 *cp = '\0';
1883
1884 /*
1885 * Then read the rest of the field as a concatenated
1886 * time
1887 */
1889 &tmask, tm, fsec, &is2digits)) < 0)
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
1929 if (tzp == NULL)
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 {
1962 char *cp;
1964
1966
1967 /*
1968 * only a few kinds are allowed to have an embedded
1969 * decimal
1970 */
1971 if (*cp == '.')
1972 switch (ptype)
1973 {
1977 break;
1978 default:
1979 return 1;
1980 break;
1981 }
1982 else if (*cp != '\0')
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
2029 if (*cp == '.')
2030 {
2031 double frac;
2032
2033 frac = strtod(cp, &cp);
2034 if (*cp != '\0')
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 ***/
2050 tmask = DTK_DATE_M;
2052 /* fractional Julian Day? */
2053 if (*cp == '.')
2054 {
2055 double time;
2056
2057 time = strtod(cp, &cp);
2058 if (*cp != '\0')
2059 return -1;
2060
2061 tmask |= DTK_TIME_M;
2063 }
2064 break;
2065
2067 /* previous field was "t" for ISO time */
2069 &tmask, tm, fsec, &is2digits)) < 0)
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 {
2086 char *cp;
2087 int flen;
2088
2089 flen = strlen(field[i]);
2091
2092 /* Embedded decimal and no date yet? */
2094 {
2096 return -1;
2097 }
2098 /* embedded decimal and several digits before? */
2099 else if (cp != NULL && flen - strlen(cp) > 2)
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 */
2107 &tmask, tm, fsec, &is2digits)) < 0)
2108 return -1;
2109 }
2110 else if (flen > 4)
2111 {
2113 &tmask, tm, fsec, &is2digits)) < 0)
2114 return -1;
2115 }
2116 /* otherwise it is a single date/time field... */
2118 &tmask, tm, fsec, &is2digits, EuroDates) != 0)
2119 return -1;
2120 }
2121 break;
2122
2127 continue;
2128
2131 {
2134 {
2137 *dtype = DTK_DATE;
2139 break;
2140
2142 tmask = DTK_DATE_M;
2143 *dtype = DTK_DATE;
2150 break;
2151
2153 tmask = DTK_DATE_M;
2154 *dtype = DTK_DATE;
2159 break;
2160
2162 tmask = DTK_DATE_M;
2163 *dtype = DTK_DATE;
2170 break;
2171
2174 *dtype = DTK_DATE;
2178 if (tzp != NULL)
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 }
2200 haveTextMonth = true;
2202 break;
2203
2205
2206 /*
2207 * daylight savings time modifier (solves "MET DST"
2208 * syntax)
2209 */
2212 if (tzp == NULL)
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 */
2225 if (tzp == NULL)
2226 return -1;
2227 *tzp = -val;
2229 break;
2230
2233 if (tzp == NULL)
2234 return -1;
2235 *tzp = -val;
2237 break;
2238
2240 break;
2241
2243 mer = val;
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
2295 if (tmask & fmask)
2296 return -1;
2297 fmask |= tmask;
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 }
2308 else if (is2digits)
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 @171 value
int strtoint(const char *restrict str, char **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, 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{
331 bool is_before = false;
332 char *cp;
333 int fmask = 0,
334 tmask,
335 type;
337 int dterr;
339 double fval;
340
341 *dtype = DTK_DELTA;
344
345 /* read through list backwards to pick up units before values */
347 {
349 {
352 &tmask, tm, fsec);
353 if (dterr)
354 return dterr;
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 */
374 &tmask, tm, fsec) == 0)
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;
436 if (errno == ERANGE)
438
439 if (*cp == '-')
440 {
441 /* SQL "years-months" syntax */
442 int val2;
443
444 val2 = strtoint(cp + 1, &cp, 10);
447 if (*cp != '\0')
451 val2 = -val2;
453 fval = 0;
454 }
455 else if (*cp == '.')
456 {
457 errno = 0;
458 fval = strtod(cp, &cp);
459 if (*cp != '\0' || errno != 0)
461
463 fval = -fval;
464 }
465 else if (*cp == '\0')
466 fval = 0;
467 else
469
470 tmask = 0; /* DTK_M(type); */
471
473 {
475 *fsec += rint(val + fval);
477 break;
478
480 *fsec += rint((val + fval) * 1000);
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
495 tmask = DTK_ALL_SECS_M;
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
564 tmask = 0; /* DTK_M(type); */
566 {
569 break;
570
572 is_before = true;
574 break;
575
578 *dtype = val;
579 break;
580
581 default:
583 }
584 break;
585
586 default:
588 }
589
590 if (tmask & fmask)
592 fmask |= tmask;
593 }
594
595 /* ensure that at least one time field has been found */
596 if (fmask == 0)
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 */
628 bool more_signs = false;
629
631 {
633 {
634 more_signs = true;
635 break;
636 }
637 }
638
639 if (!more_signs)
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 */
663 if (is_before)
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, 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{
1439 char *cp;
1440
1441 *tmask = DTK_TIME_M;
1442
1444 if (*cp != ':')
1445 return -1;
1446 str = cp + 1;
1448 if (*cp == '\0')
1449 {
1451 *fsec = 0;
1452 }
1453 else if (*cp != ':')
1454 return -1;
1455 else
1456 {
1457 str = cp + 1;
1459 if (*cp == '\0')
1460 *fsec = 0;
1461 else if (*cp == '.')
1462 {
1463 char fstr[7];
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 */
1479 *fsec = strtoint(fstr, &cp, 10);
1480 if (*cp != '\0')
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, i, str, strtoint(), tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, and USECS_PER_SEC.
Referenced by DecodeDateTime().
◆ DecodeUnits()
| int DecodeUnits | ( | int | field, |
| char * | lowtoken, | ||
| int * | val | ||
| ) |
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;
548 if (tp == NULL)
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, szdeltatktbl, TOKMAXLEN, type, datetkn::type, UNKNOWN_FIELD, val, and datetkn::value.
◆ dt2time()
| void dt2time | ( | double | jd, |
| int * | hour, | ||
| int * | min, | ||
| int * | sec, | ||
| fsec_t * | fsec | ||
| ) |
Definition at line 1068 of file dt_common.c.
1069{
1070 int64 time;
1071
1072 time = jd;
1073 *hour = time / USECS_PER_HOUR;
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 USECS_PER_HOUR, USECS_PER_MINUTE, and USECS_PER_SEC.
Referenced by DecodeDateTime().
◆ EncodeDateOnly()
| void EncodeDateOnly | ( | struct tm * | tm, |
| int | style, | ||
| char * | str, | ||
| bool | EuroDates | ||
| ) |
Definition at line 669 of file dt_common.c.
670{
672
673 switch (style)
674 {
676 /* compatible with ISO date formats */
680 else
683 break;
684
686 /* compatible with Oracle/Ingres date formats */
687 if (EuroDates)
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 */
709 if (EuroDates)
711 else
715 else
717 break;
718 }
719}
References Assert(), 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 */
763 print_tz = false;
764
765 switch (style)
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
789 if (print_tz)
790 {
791 hour = -(tz / SECS_PER_HOUR);
793 if (min != 0)
795 else
797 }
798 break;
799
801 /* Compatible with Oracle/Ingres date formats */
802
803 if (EuroDates)
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
834 if (print_tz)
835 {
836 if (tzn)
838 else
839 {
840 hour = -(tz / SECS_PER_HOUR);
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
874 if (print_tz)
875 {
876 if (tzn)
878 else
879 {
880 hour = -(tz / SECS_PER_HOUR);
882 if (min != 0)
884 else
886 }
887 }
888 break;
889
891 default:
892 /* Backward-compatible with traditional Postgres abstime dates */
893
896
899
900 if (EuroDates)
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
924 if (print_tz)
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 */
936 hour = -(tz / SECS_PER_HOUR);
938 if (min != 0)
940 else
942 }
943 }
944 break;
945 }
946}
References date2j(), days, 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{
768 bool is_before = false;
769 bool is_zero = true;
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 */
777 switch (style)
778 {
779 /* SQL Standard interval format */
781 {
782 bool has_negative = year < 0 || mon < 0 ||
783 mday < 0 || hour < 0 ||
784 min < 0 || sec < 0 || fsec < 0;
785 bool has_positive = year > 0 || mon > 0 ||
786 mday > 0 || hour > 0 ||
787 min > 0 || sec > 0 || fsec > 0;
788 bool has_year_month = year != 0 || mon != 0;
789 bool has_day_time = mday != 0 || hour != 0 ||
790 min != 0 || sec != 0 || fsec != 0;
791 bool has_day = mday != 0;
792 bool sql_standard_value = !(has_negative && has_positive) &&
793 !(has_year_month && has_day_time);
794
795 /*
796 * SQL Standard wants only 1 "<sign>" preceding the whole
797 * interval ... but can't do that if mixed signs.
798 */
799 if (has_negative && sql_standard_value)
800 {
801 *cp++ = '-';
802 year = -year;
803 mon = -mon;
804 mday = -mday;
805 hour = -hour;
806 min = -min;
807 sec = -sec;
808 fsec = -fsec;
809 }
810
811 if (!has_negative && !has_positive)
812 {
814 }
815 else if (!sql_standard_value)
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 */
822 char year_sign = (year < 0 || mon < 0) ? '-' : '+';
823 char day_sign = (mday < 0) ? '-' : '+';
824 char sec_sign = (hour < 0 || min < 0 ||
825 sec < 0 || fsec < 0) ? '-' : '+';
826
828 year_sign, abs(year), abs(mon),
829 day_sign, abs(mday),
830 sec_sign, abs(hour), abs(min));
831 cp += strlen(cp);
833 }
834 else if (has_year_month)
835 {
837 }
838 else if (has_day)
839 {
841 cp += strlen(cp);
843 }
844 else
845 {
847 cp += strlen(cp);
849 }
850 }
851 break;
852
853 /* ISO 8601 "time-intervals by duration only" */
855 /* special-case zero to avoid printing nothing */
856 if (year == 0 && mon == 0 && mday == 0 &&
857 hour == 0 && min == 0 && sec == 0 && fsec == 0)
858 {
860 break;
861 }
862 *cp++ = 'P';
866 if (hour != 0 || min != 0 || sec != 0 || fsec != 0)
867 *cp++ = 'T';
870 if (sec != 0 || fsec != 0)
871 {
872 if (sec < 0 || fsec < 0)
873 *cp++ = '-';
875 cp += strlen(cp);
876 *cp++ = 'S';
877 *cp = '\0';
878 }
879 break;
880
881 /* Compatible with postgresql < 8.4 when DateStyle = 'iso' */
886 if (is_zero || hour != 0 || min != 0 || sec != 0 || fsec != 0)
887 {
888 bool minus = (hour < 0 || min < 0 || sec < 0 || fsec < 0);
889
891 is_zero ? "" : " ",
892 (minus ? "-" : (is_before ? "+" : "")),
893 abs(hour), abs(min));
894 cp += strlen(cp);
896 }
897 break;
898
899 /* Compatible with postgresql < 8.4 when DateStyle != 'iso' */
901 default:
902 strcpy(cp, "@");
903 cp++;
909 if (sec != 0 || fsec != 0)
910 {
911 *cp++ = ' ';
912 if (sec < 0 || (sec == 0 && fsec < 0))
913 {
914 if (is_zero)
915 is_before = true;
916 else if (!is_before)
917 *cp++ = '-';
918 }
919 else if (is_before)
920 *cp++ = '-';
922 cp += strlen(cp);
923 /* We output "ago", not negatives, so use abs(). */
925 (abs(sec) != 1 || fsec != 0) ? "s" : "");
926 is_zero = false;
927 }
928 /* identically zero? then put in a unitless zero... */
929 if (is_zero)
930 strcat(cp, " 0");
931 if (is_before)
932 strcat(cp, " ago");
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(), 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()
| void GetCurrentDateTime | ( | struct tm * | tm | ) |
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(), and tm.
Referenced by DecodeDateTime().
◆ GetEpochTime()
| int GetEpochTime | ( | struct tm * | tm | ) |
Definition at line 949 of file dt_common.c.
950{
953 time_t epoch = 0;
954
955 t0 = gmtime_r(&epoch, &tmbuf);
956
957 if (t0)
958 {
965
966 return 0;
967 }
968
969 return -1;
970} /* GetEpochTime() */
References epoch, 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()
| void j2date | ( | int | jd, |
| int * | year, | ||
| int * | month, | ||
| int * | day | ||
| ) |
Definition at line 321 of file datetime.c.
322{
323 unsigned int julian;
324 unsigned int quad;
325 unsigned int extra;
327
328 julian = jd;
329 julian += 32044;
330 quad = julian / 146097;
331 extra = (julian - quad * 146097) * 4 + 3;
332 julian += 60 + quad * 3 + extra / 146097;
333 quad = julian / 1461;
334 julian -= quad * 1461;
335 y = julian * 4 / 1461;
336 julian = ((y != 0) ? ((julian + 305) % 365) : ((julian + 306) % 366))
337 + 123;
338 y += quad * 4;
339 *year = y - 4800;
340 quad = julian * 2141 / 65536;
341 *day = julian - 7834 * quad / 256;
342 *month = (quad + 10) % MONTHS_PER_YEAR + 1;
343} /* j2date() */
References MONTHS_PER_YEAR, and y.
Referenced by date2timestamptz_safe(), date_out(), 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(), 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{
1603 int nf = 0;
1604 char *lp = lowstr;
1605
1606 *endstr = timestr;
1607 /* outer loop through fields */
1608 while (*(*endstr) != '\0')
1609 {
1610 /* Record start of current field */
1612 return -1;
1613 field[nf] = lp;
1614
1615 /* leading digit? then date or time */
1616 if (isdigit((unsigned char) *(*endstr)))
1617 {
1618 *lp++ = *(*endstr)++;
1619 while (isdigit((unsigned char) *(*endstr)))
1620 *lp++ = *(*endstr)++;
1621
1622 /* time field? */
1623 if (*(*endstr) == ':')
1624 {
1625 ftype[nf] = DTK_TIME;
1626 *lp++ = *(*endstr)++;
1627 while (isdigit((unsigned char) *(*endstr)) ||
1628 (*(*endstr) == ':') || (*(*endstr) == '.'))
1629 *lp++ = *(*endstr)++;
1630 }
1631 /* date field? allow embedded text month */
1632 else if (*(*endstr) == '-' || *(*endstr) == '/' || *(*endstr) == '.')
1633 {
1634 /* save delimiting character to use later */
1635 char *dp = (*endstr);
1636
1637 *lp++ = *(*endstr)++;
1638 /* second field is all digits? then no embedded text month */
1639 if (isdigit((unsigned char) *(*endstr)))
1640 {
1642 while (isdigit((unsigned char) *(*endstr)))
1643 *lp++ = *(*endstr)++;
1644
1645 /*
1646 * insist that the delimiters match to get a three-field
1647 * date.
1648 */
1649 if (*(*endstr) == *dp)
1650 {
1651 ftype[nf] = DTK_DATE;
1652 *lp++ = *(*endstr)++;
1653 while (isdigit((unsigned char) *(*endstr)) || (*(*endstr) == *dp))
1654 *lp++ = *(*endstr)++;
1655 }
1656 }
1657 else
1658 {
1659 ftype[nf] = DTK_DATE;
1660 while (isalnum((unsigned char) *(*endstr)) || (*(*endstr) == *dp))
1662 }
1663 }
1664
1665 /*
1666 * otherwise, number only and will determine year, month, day, or
1667 * concatenated fields later...
1668 */
1669 else
1670 ftype[nf] = DTK_NUMBER;
1671 }
1672 /* Leading decimal point? Then fractional seconds... */
1673 else if (*(*endstr) == '.')
1674 {
1675 *lp++ = *(*endstr)++;
1676 while (isdigit((unsigned char) *(*endstr)))
1677 *lp++ = *(*endstr)++;
1678
1679 ftype[nf] = DTK_NUMBER;
1680 }
1681
1682 /*
1683 * text? then date string, month, day of week, special, or timezone
1684 */
1685 else if (isalpha((unsigned char) *(*endstr)))
1686 {
1687 ftype[nf] = DTK_STRING;
1689 while (isalpha((unsigned char) *(*endstr)))
1691
1692 /*
1693 * Full date string with leading text month? Could also be a POSIX
1694 * time zone...
1695 */
1696 if (*(*endstr) == '-' || *(*endstr) == '/' || *(*endstr) == '.')
1697 {
1698 char *dp = (*endstr);
1699
1700 ftype[nf] = DTK_DATE;
1701 *lp++ = *(*endstr)++;
1702 while (isdigit((unsigned char) *(*endstr)) || *(*endstr) == *dp)
1703 *lp++ = *(*endstr)++;
1704 }
1705 }
1706 /* skip leading spaces */
1707 else if (isspace((unsigned char) *(*endstr)))
1708 {
1709 (*endstr)++;
1710 continue;
1711 }
1712 /* sign? then special or numeric timezone */
1713 else if (*(*endstr) == '+' || *(*endstr) == '-')
1714 {
1715 *lp++ = *(*endstr)++;
1716 /* soak up leading whitespace */
1717 while (isspace((unsigned char) *(*endstr)))
1718 (*endstr)++;
1719 /* numeric timezone? */
1720 if (isdigit((unsigned char) *(*endstr)))
1721 {
1722 ftype[nf] = DTK_TZ;
1723 *lp++ = *(*endstr)++;
1724 while (isdigit((unsigned char) *(*endstr)) ||
1725 (*(*endstr) == ':') || (*(*endstr) == '.'))
1726 *lp++ = *(*endstr)++;
1727 }
1728 /* special? */
1729 else if (isalpha((unsigned char) *(*endstr)))
1730 {
1731 ftype[nf] = DTK_SPECIAL;
1733 while (isalpha((unsigned char) *(*endstr)))
1735 }
1736 /* otherwise something wrong... */
1737 else
1738 return -1;
1739 }
1740 /* ignore punctuation but use as delimiter */
1741 else if (ispunct((unsigned char) *(*endstr)))
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 */
1751 *lp++ = '\0';
1752 nf++;
1753 }
1754
1755 *numfields = nf;
1756
1757 return 0;
1758} /* ParseDateTime() */
References DTK_DATE, DTK_NUMBER, DTK_SPECIAL, DTK_STRING, DTK_TIME, DTK_TZ, 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{
2527 int scan_type;
2528
2529 char *pstr,
2530 *pfmt,
2531 *tmp;
2535
2536 pfmt = fmt;
2537 pstr = *str;
2538
2539 while (*pfmt)
2540 {
2541 err = 0;
2542 while (*pfmt == ' ')
2543 pfmt++;
2544 while (*pstr == ' ')
2545 pstr++;
2546 if (*pfmt != '%')
2547 {
2548 if (*pfmt == *pstr)
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++;
2563 switch (*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++;
2645 scan_type = PGTYPES_TYPE_UINT;
2647 *year = scan_val.uint_val * 100;
2648 break;
2649 case 'd':
2650 case 'e':
2651 pfmt++;
2652 scan_type = PGTYPES_TYPE_UINT;
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;
2666 strcpy(tmp, "%m/%d/%y");
2667 strcat(tmp, pfmt);
2669 free(tmp);
2671 case 'm':
2672 pfmt++;
2673 scan_type = PGTYPES_TYPE_UINT;
2675 *month = scan_val.uint_val;
2676 break;
2677 case 'y':
2678 case 'g': /* XXX difference to y (ISO) */
2679 pfmt++;
2680 scan_type = PGTYPES_TYPE_UINT;
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++;
2695 scan_type = PGTYPES_TYPE_UINT;
2697 *year = scan_val.uint_val;
2698 break;
2699 case 'H':
2700 case 'I':
2701 case 'k':
2702 case 'l':
2703 pfmt++;
2704 scan_type = PGTYPES_TYPE_UINT;
2706 *hour += scan_val.uint_val;
2707 break;
2708 case 'j':
2709 pfmt++;
2710 scan_type = PGTYPES_TYPE_UINT;
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++;
2721 scan_type = PGTYPES_TYPE_UINT;
2723 *minute = scan_val.uint_val;
2724 break;
2725 case 'n':
2726 pfmt++;
2727 if (*pstr == '\n')
2728 pstr++;
2729 else
2730 err = 1;
2731 break;
2732 case 'p':
2733 err = 1;
2734 pfmt++;
2735 if (strncmp(pstr, "am", 2) == 0)
2736 {
2737 *hour += 0;
2738 err = 0;
2739 pstr += 2;
2740 }
2741 if (strncmp(pstr, "a.m.", 4) == 0)
2742 {
2743 *hour += 0;
2744 err = 0;
2745 pstr += 4;
2746 }
2747 if (strncmp(pstr, "pm", 2) == 0)
2748 {
2749 *hour += 12;
2750 err = 0;
2751 pstr += 2;
2752 }
2753 if (strncmp(pstr, "p.m.", 4) == 0)
2754 {
2755 *hour += 12;
2756 err = 0;
2757 pstr += 4;
2758 }
2759 break;
2760 case 'P':
2761 err = 1;
2762 pfmt++;
2763 if (strncmp(pstr, "AM", 2) == 0)
2764 {
2765 *hour += 0;
2766 err = 0;
2767 pstr += 2;
2768 }
2769 if (strncmp(pstr, "A.M.", 4) == 0)
2770 {
2771 *hour += 0;
2772 err = 0;
2773 pstr += 4;
2774 }
2775 if (strncmp(pstr, "PM", 2) == 0)
2776 {
2777 *hour += 12;
2778 err = 0;
2779 pstr += 2;
2780 }
2781 if (strncmp(pstr, "P.M.", 4) == 0)
2782 {
2783 *hour += 12;
2784 err = 0;
2785 pstr += 4;
2786 }
2787 break;
2788 case 'r':
2789 pfmt++;
2791 if (!tmp)
2792 return 1;
2793 strcpy(tmp, "%I:%M:%S %p");
2794 strcat(tmp, pfmt);
2796 free(tmp);
2798 case 'R':
2799 pfmt++;
2801 if (!tmp)
2802 return 1;
2803 strcpy(tmp, "%H:%M");
2804 strcat(tmp, pfmt);
2806 free(tmp);
2808 case 's':
2809 pfmt++;
2810 scan_type = PGTYPES_TYPE_UINT_LONG;
2812 /* number of seconds in scan_val.luint_val */
2813 {
2816 time_t et = (time_t) scan_val.luint_val;
2817
2818 tms = gmtime_r(&et, &tmbuf);
2819
2820 if (tms)
2821 {
2822 *year = tms->tm_year + 1900;
2823 *month = tms->tm_mon + 1;
2824 *day = tms->tm_mday;
2825 *hour = tms->tm_hour;
2826 *minute = tms->tm_min;
2827 *second = tms->tm_sec;
2828 }
2829 else
2830 err = 1;
2831 }
2832 break;
2833 case 'S':
2834 pfmt++;
2835 scan_type = PGTYPES_TYPE_UINT;
2837 *second = scan_val.uint_val;
2838 break;
2839 case 't':
2840 pfmt++;
2841 if (*pstr == '\t')
2842 pstr++;
2843 else
2844 err = 1;
2845 break;
2846 case 'T':
2847 pfmt++;
2849 if (!tmp)
2850 return 1;
2851 strcpy(tmp, "%H:%M:%S");
2852 strcat(tmp, pfmt);
2854 free(tmp);
2856 case 'u':
2857 pfmt++;
2858 scan_type = PGTYPES_TYPE_UINT;
2860 if (scan_val.uint_val < 1 || scan_val.uint_val > 7)
2861 err = 1;
2862 break;
2863 case 'U':
2864 pfmt++;
2865 scan_type = PGTYPES_TYPE_UINT;
2867 if (scan_val.uint_val > 53)
2868 err = 1;
2869 break;
2870 case 'V':
2871 pfmt++;
2872 scan_type = PGTYPES_TYPE_UINT;
2874 if (scan_val.uint_val < 1 || scan_val.uint_val > 53)
2875 err = 1;
2876 break;
2877 case 'w':
2878 pfmt++;
2879 scan_type = PGTYPES_TYPE_UINT;
2881 if (scan_val.uint_val > 6)
2882 err = 1;
2883 break;
2884 case 'W':
2885 pfmt++;
2886 scan_type = PGTYPES_TYPE_UINT;
2888 if (scan_val.uint_val > 53)
2889 err = 1;
2890 break;
2891 case 'x':
2892 case 'X':
2893 /* XXX */
2894 break;
2895 case 'Y':
2896 pfmt++;
2897 scan_type = PGTYPES_TYPE_UINT;
2899 *year = scan_val.uint_val;
2900 break;
2901 case 'z':
2902 pfmt++;
2903 scan_type = PGTYPES_TYPE_STRING_MALLOCED;
2906 {
2908 free(scan_val.str_val);
2909 }
2910 break;
2911 case 'Z':
2912 pfmt++;
2913 scan_type = PGTYPES_TYPE_STRING_MALLOCED;
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 }
2933 free(scan_val.str_val);
2934 }
2935 break;
2936 case '+':
2937 /* XXX */
2938 break;
2939 case '%':
2940 pfmt++;
2941 if (*pstr == '%')
2942 pstr++;
2943 else
2944 err = 1;
2945 break;
2946 default:
2947 err = 1;
2948 }
2949 }
2951 {
2952 if (*second < 0)
2953 *second = 0;
2954 if (*minute < 0)
2955 *minute = 0;
2956 if (*hour < 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 }
2979 if (*minute > 59)
2980 {
2981 err = 1;
2982 *minute = 0;
2983 }
2984 if (*hour > 24 || /* test for > 24:00:00 */
2985 (*hour == 24 && (*minute > 0 || *second > 0)))
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(), free, isleap, j, un_fmt_comb::luint_val, 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, un_fmt_comb::str_val, 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, un_fmt_comb::uint_val, and datetkn::value.
Referenced by PGTYPEStimestamp_defmt_asc(), and PGTYPEStimestamp_defmt_scan().
◆ tm2timestamp()
Definition at line 41 of file timestamp.c.
42{
43 int dDate;
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;
55 if (tzp != NULL)
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(), 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()
| void TrimTrailingZeros | ( | char * | str | ) |
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}
Referenced by AppendSeconds(), and EncodeDateTime().
Variable Documentation
◆ day_tab
|
extern |
Definition at line 75 of file datetime.c.
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.
Referenced by AdjustDays(), brin_minmax_multi_distance_interval(), date_mii(), date_pli(), DCH_from_char(), DCH_to_char(), dttofmtasc_replace(), EncodeDateTime(), interval_cmp_value(), make_interval(), PGTYPEStimestamp_defmt_scan(), and PrintTiming().
◆ months
|
extern |
Definition at line 81 of file datetime.c.
Referenced by DCH_from_char(), DCH_to_char(), dttofmtasc_replace(), 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.
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().
