pgtime.h File Reference

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

Go to the source code of this file.

Data Structures
struct	pg_tm

Macros
#define	TZ_STRLEN_MAX   255

Typedefs
typedef int64	pg_time_t
typedef struct pg_tz	pg_tz
typedef struct pg_tzenum	pg_tzenum

Functions
struct pg_tm *	pg_localtime (const pg_time_t *timep, const pg_tz *tz)
struct pg_tm *	pg_gmtime (const pg_time_t *timep)
int	pg_next_dst_boundary (const pg_time_t *timep, long int *before_gmtoff, int *before_isdst, pg_time_t *boundary, long int *after_gmtoff, int *after_isdst, const pg_tz *tz)
bool	pg_interpret_timezone_abbrev (const char *abbrev, const pg_time_t *timep, long int *gmtoff, int *isdst, const pg_tz *tz)
bool	pg_timezone_abbrev_is_known (const char *abbrev, bool *isfixed, long int *gmtoff, int *isdst, const pg_tz *tz)
const char *	pg_get_next_timezone_abbrev (int *indx, const pg_tz *tz)
bool	pg_get_timezone_offset (const pg_tz *tz, long int *gmtoff)
const char *	pg_get_timezone_name (pg_tz *tz)
bool	pg_tz_acceptable (pg_tz *tz)
size_t	pg_strftime (char *s, size_t maxsize, const char *format, const struct pg_tm *t)
void	pg_timezone_initialize (void)
pg_tz *	pg_tzset (const char *tzname)
pg_tz *	pg_tzset_offset (long gmtoffset)
pg_tzenum *	pg_tzenumerate_start (void)
pg_tz *	pg_tzenumerate_next (pg_tzenum *dir)
void	pg_tzenumerate_end (pg_tzenum *dir)

Variables
PGDLLIMPORT pg_tz *	session_timezone
PGDLLIMPORT pg_tz *	log_timezone

Macro Definition Documentation

TZ_STRLEN_MAX

#define TZ_STRLEN_MAX   255

Definition at line 54 of file pgtime.h.

Typedef Documentation

pg_time_t

typedef int64 pg_time_t

Definition at line 23 of file pgtime.h.

pg_tz

typedef struct pg_tz pg_tz

Definition at line 50 of file pgtime.h.

pg_tzenum

typedef struct pg_tzenum pg_tzenum

Definition at line 51 of file pgtime.h.

Function Documentation

pg_get_next_timezone_abbrev()

const char * pg_get_next_timezone_abbrev ( int *  indx, const pg_tz *  tz  )

extern

Definition at line 1960 of file localtime.c.

{
    const char *result;
    const struct state *sp = &tz->state;
    const char *abbrs;
    int         abbrind;
 
    /* If we're still in range, the result is the current abbrev. */
    abbrs = sp->chars;
    abbrind = *indx;
    if (abbrind < 0 || abbrind >= sp->charcnt)
        return NULL;
    result = abbrs + abbrind;
 
    /* Advance *indx past this abbrev and its trailing null. */
    while (abbrs[abbrind] != '\0')
        abbrind++;
    abbrind++;
    *indx = abbrind;
 
    return result;
}

References state::chars, fb(), result, and pg_tz::state.

Referenced by pg_timezone_abbrevs_zone().

pg_get_timezone_name()

const char * pg_get_timezone_name ( pg_tz *  tz )

extern

Definition at line 2013 of file localtime.c.

{
    if (tz)
        return tz->TZname;
    return NULL;
}

References fb(), and pg_tz::TZname.

Referenced by pg_timezone_names(), show_log_timezone(), show_timezone(), and timetz_at_local().

pg_get_timezone_offset()

bool pg_get_timezone_offset ( const pg_tz *  tz, long int *  gmtoff  )

extern

Definition at line 1989 of file localtime.c.

{
    /*
     * The zone could have more than one ttinfo, if it's historically used
     * more than one abbreviation.  We return true as long as they all have
     * the same gmtoff.
     */
    const struct state *sp;
    int         i;
 
    sp = &tz->state;
    for (i = 1; i < sp->typecnt; i++)
    {
        if (sp->ttis[i].tt_utoff != sp->ttis[0].tt_utoff)
            return false;
    }
    *gmtoff = sp->ttis[0].tt_utoff;
    return true;
}

References fb(), i, pg_tz::state, ttinfo::tt_utoff, and state::ttis.

Referenced by DecodeTimeOnly(), and TimestampTimestampTzRequiresRewrite().

pg_gmtime()

struct pg_tm * pg_gmtime ( const pg_time_t *  timep )

extern

Definition at line 1333 of file localtime.c.

{
    return gmtsub(timep, 0, &tm);
}

References fb(), gmtsub(), and tm.

Referenced by AddFileToBackupManifest(), and GetEpochTime().

pg_interpret_timezone_abbrev()

bool pg_interpret_timezone_abbrev ( const char *  abbrev, const pg_time_t *  timep, long int *  gmtoff, int *  isdst, const pg_tz *  tz  )

extern

Definition at line 1767 of file localtime.c.

{
    const struct state *sp;
    const char *abbrs;
    const struct ttinfo *ttisp;
    int         abbrind;
    int         cutoff;
    int         i;
    const pg_time_t t = *timep;
 
    sp = &tz->state;
 
    /*
     * Locate the abbreviation in the zone's abbreviation list.  We assume
     * there are not duplicates in the list.
     */
    abbrs = sp->chars;
    abbrind = 0;
    while (abbrind < sp->charcnt)
    {
        if (strcmp(abbrev, abbrs + abbrind) == 0)
            break;
        while (abbrs[abbrind] != '\0')
            abbrind++;
        abbrind++;
    }
    if (abbrind >= sp->charcnt)
        return false;           /* not there! */
 
    /*
     * Unlike pg_next_dst_boundary, we needn't sweat about extrapolation
     * (goback/goahead zones).  Finding the newest or oldest meaning of the
     * abbreviation should get us what we want, since extrapolation would just
     * be repeating the newest or oldest meanings.
     *
     * Use binary search to locate the first transition > cutoff time.  (Note
     * that sp->timecnt could be zero, in which case this loop does nothing
     * and only the defaulttype entry will be checked.)
     */
    {
        int         lo = 0;
        int         hi = sp->timecnt;
 
        while (lo < hi)
        {
            int         mid = (lo + hi) >> 1;
 
            if (t < sp->ats[mid])
                hi = mid;
            else
                lo = mid + 1;
        }
        cutoff = lo;
    }
 
    /*
     * Scan backwards to find the latest interval using the given abbrev
     * before the cutoff time.
     */
    for (i = cutoff - 1; i >= 0; i--)
    {
        ttisp = &sp->ttis[sp->types[i]];
        if (ttisp->tt_desigidx == abbrind)
        {
            *gmtoff = ttisp->tt_utoff;
            *isdst = ttisp->tt_isdst;
            return true;
        }
    }
 
    /*
     * Not found yet; check the defaulttype, which is notionally the era
     * before any of the entries in sp->types[].
     */
    ttisp = &sp->ttis[0];
    if (ttisp->tt_desigidx == abbrind)
    {
        *gmtoff = ttisp->tt_utoff;
        *isdst = ttisp->tt_isdst;
        return true;
    }
 
    /*
     * Not there, so scan forwards to find the first one after the cutoff.
     */
    for (i = cutoff; i < sp->timecnt; i++)
    {
        ttisp = &sp->ttis[sp->types[i]];
        if (ttisp->tt_desigidx == abbrind)
        {
            *gmtoff = ttisp->tt_utoff;
            *isdst = ttisp->tt_isdst;
            return true;
        }
    }
 
    return false;               /* hm, not actually used in any interval? */
}

References charcnt, state::chars, fb(), i, and pg_tz::state.

Referenced by DetermineTimeZoneAbbrevOffsetInternal(), and pg_timezone_abbrevs_zone().

pg_localtime()

struct pg_tm * pg_localtime ( const pg_time_t *  timep, const pg_tz *  tz  )

extern

Definition at line 1289 of file localtime.c.

{
    return localsub(&tz->state, timep, &tm);
}

References fb(), localsub(), pg_tz::state, and tm.

Referenced by build_backup_content(), get_formatted_log_time(), get_formatted_start_time(), log_status_format(), logfile_getname(), pg_tz_acceptable(), score_timezone(), set_next_rotation_time(), str_time(), timeofday(), and timestamp2tm().

pg_next_dst_boundary()

int pg_next_dst_boundary ( const pg_time_t *  timep, long int *  before_gmtoff, int *  before_isdst, pg_time_t *  boundary, long int *  after_gmtoff, int *  after_isdst, const pg_tz *  tz  )

extern

Definition at line 1634 of file localtime.c.

{
    const struct state *sp;
    const struct ttinfo *ttisp;
    int         i;
    int         j;
    const pg_time_t t = *timep;
 
    sp = &tz->state;
    if (sp->timecnt == 0)
    {
        /* non-DST zone, use the defaulttype (now always 0) */
        ttisp = &sp->ttis[0];
        *before_gmtoff = ttisp->tt_utoff;
        *before_isdst = ttisp->tt_isdst;
        return 0;
    }
    if ((sp->goback && t < sp->ats[0]) ||
        (sp->goahead && t > sp->ats[sp->timecnt - 1]))
    {
        /* For values outside the transition table, extrapolate */
        pg_time_t   newt = t;
        pg_time_t   seconds;
        pg_time_t   tcycles;
        int64       icycles;
        int         result;
 
        if (t < sp->ats[0])
            seconds = sp->ats[0] - t;
        else
            seconds = t - sp->ats[sp->timecnt - 1];
        --seconds;
        tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
        ++tcycles;
        icycles = tcycles;
        if (tcycles - icycles >= 1 || icycles - tcycles >= 1)
            return -1;
        seconds = icycles;
        seconds *= YEARSPERREPEAT;
        seconds *= AVGSECSPERYEAR;
        if (t < sp->ats[0])
            newt += seconds;
        else
            newt -= seconds;
        if (newt < sp->ats[0] ||
            newt > sp->ats[sp->timecnt - 1])
            return -1;          /* "cannot happen" */
 
        result = pg_next_dst_boundary(&newt, before_gmtoff,
                                      before_isdst,
                                      boundary,
                                      after_gmtoff,
                                      after_isdst,
                                      tz);
        if (t < sp->ats[0])
            *boundary -= seconds;
        else
            *boundary += seconds;
        return result;
    }
 
    if (t >= sp->ats[sp->timecnt - 1])
    {
        /* No known transition > t, so use last known segment's type */
        i = sp->types[sp->timecnt - 1];
        ttisp = &sp->ttis[i];
        *before_gmtoff = ttisp->tt_utoff;
        *before_isdst = ttisp->tt_isdst;
        return 0;
    }
    if (t < sp->ats[0])
    {
        /* For "before", use the defaulttype (now always 0) */
        ttisp = &sp->ttis[0];
        *before_gmtoff = ttisp->tt_utoff;
        *before_isdst = ttisp->tt_isdst;
        *boundary = sp->ats[0];
        /* And for "after", use the first segment's type */
        i = sp->types[0];
        ttisp = &sp->ttis[i];
        *after_gmtoff = ttisp->tt_utoff;
        *after_isdst = ttisp->tt_isdst;
        return 1;
    }
    /* Else search to find the boundary following t */
    {
        int         lo = 1;
        int         hi = sp->timecnt - 1;
 
        while (lo < hi)
        {
            int         mid = (lo + hi) >> 1;
 
            if (t < sp->ats[mid])
                hi = mid;
            else
                lo = mid + 1;
        }
        i = lo;
    }
    j = sp->types[i - 1];
    ttisp = &sp->ttis[j];
    *before_gmtoff = ttisp->tt_utoff;
    *before_isdst = ttisp->tt_isdst;
    *boundary = sp->ats[i];
    j = sp->types[i];
    ttisp = &sp->ttis[j];
    *after_gmtoff = ttisp->tt_utoff;
    *after_isdst = ttisp->tt_isdst;
    return 1;
}

References AVGSECSPERYEAR, fb(), i, j, pg_next_dst_boundary(), result, pg_tz::state, ttinfo::tt_utoff, state::ttis, and YEARSPERREPEAT.

Referenced by DetermineTimeZoneOffsetInternal(), and pg_next_dst_boundary().

pg_strftime()

size_t pg_strftime ( char *  s, size_t  maxsize, const char *  format, const struct pg_tm *  t  )

extern

Definition at line 129 of file strftime.c.

{
    char       *p;
    int         saved_errno = errno;
    enum warn   warn = IN_NONE;
 
    p = _fmt(format, t, s, s + maxsize, &warn);
    if (!p)
    {
        errno = EOVERFLOW;
        if (maxsize > 0)
            *s = '\0';
        return 0;
    }
    if (p == s + maxsize)
    {
        errno = ERANGE;
        if (maxsize > 0)
            *s = '\0';
        return 0;
    }
    *p = '\0';
    errno = saved_errno;
    return p - s;
}

References _fmt(), EOVERFLOW, fb(), format, and IN_NONE.

Referenced by AddFileToBackupManifest(), build_backup_content(), get_formatted_log_time(), get_formatted_start_time(), log_status_format(), logfile_getname(), str_time(), and timeofday().

pg_timezone_abbrev_is_known()

bool pg_timezone_abbrev_is_known ( const char *  abbrev, bool *  isfixed, long int *  gmtoff, int *  isdst, const pg_tz *  tz  )

extern

Definition at line 1885 of file localtime.c.

{
    bool        result = false;
    const struct state *sp = &tz->state;
    const char *abbrs;
    int         abbrind;
 
    /*
     * Locate the abbreviation in the zone's abbreviation list.  We assume
     * there are not duplicates in the list.
     */
    abbrs = sp->chars;
    abbrind = 0;
    while (abbrind < sp->charcnt)
    {
        if (strcmp(abbrev, abbrs + abbrind) == 0)
            break;
        while (abbrs[abbrind] != '\0')
            abbrind++;
        abbrind++;
    }
    if (abbrind >= sp->charcnt)
        return false;           /* definitely not there */
 
    /*
     * Scan the ttinfo array to find uses of the abbreviation.
     */
    for (int i = 0; i < sp->typecnt; i++)
    {
        const struct ttinfo *ttisp = &sp->ttis[i];
 
        if (ttisp->tt_desigidx == abbrind)
        {
            if (!result)
            {
                /* First usage */
                *isfixed = true;    /* for the moment */
                *gmtoff = ttisp->tt_utoff;
                *isdst = ttisp->tt_isdst;
                result = true;
            }
            else
            {
                /* Second or later usage, does it match? */
                if (*gmtoff != ttisp->tt_utoff ||
                    *isdst != ttisp->tt_isdst)
                {
                    *isfixed = false;
                    break;      /* no point in looking further */
                }
            }
        }
    }
 
    return result;
}

References charcnt, state::chars, fb(), i, result, pg_tz::state, and ttinfo::tt_utoff.

Referenced by TimeZoneAbbrevIsKnown().

pg_timezone_initialize()

void pg_timezone_initialize ( void  )

extern

Definition at line 341 of file pgtz.c.

{
    /*
     * We may not yet know where PGSHAREDIR is (in particular this is true in
     * an EXEC_BACKEND subprocess).  So use "GMT", which pg_tzset forces to be
     * interpreted without reference to the filesystem.  This corresponds to
     * the bootstrap default for these variables in guc_parameters.dat,
     * although in principle it could be different.
     */
    session_timezone = pg_tzset("GMT");
    log_timezone = session_timezone;
}

References log_timezone, pg_tzset(), and session_timezone.

Referenced by InitializeGUCOptions().

pg_tz_acceptable()

bool pg_tz_acceptable ( pg_tz *  tz )

extern

Definition at line 2028 of file localtime.c.

{
    struct pg_tm *tt;
    pg_time_t   time2000;
 
    /*
     * To detect leap-second timekeeping, run pg_localtime for what should be
     * GMT midnight, 2000-01-01.  Insist that the tm_sec value be zero; any
     * other result has to be due to leap seconds.
     */
    time2000 = (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY;
    tt = pg_localtime(&time2000, tz);
    if (!tt || tt->tm_sec != 0)
        return false;
 
    return true;
}

References fb(), pg_localtime(), POSTGRES_EPOCH_JDATE, SECS_PER_DAY, and UNIX_EPOCH_JDATE.

Referenced by check_log_timezone(), check_timezone(), pg_tzenumerate_next(), score_timezone(), and validate_zone().

pg_tzenumerate_end()

void pg_tzenumerate_end ( pg_tzenum *  dir )

extern

Definition at line 394 of file pgtz.c.

{
    while (dir->depth >= 0)
    {
        FreeDir(dir->dirdesc[dir->depth]);
        pfree(dir->dirname[dir->depth]);
        dir->depth--;
    }
    pfree(dir);
}

References pg_tzenum::depth, pg_tzenum::dirdesc, pg_tzenum::dirname, FreeDir(), and pfree().

Referenced by pg_timezone_names().

pg_tzenumerate_next()

pg_tz * pg_tzenumerate_next ( pg_tzenum *  dir )

extern

Definition at line 406 of file pgtz.c.

{
    while (dir->depth >= 0)
    {
        struct dirent *direntry;
        char        fullname[MAXPGPATH * 2];
 
        direntry = ReadDir(dir->dirdesc[dir->depth], dir->dirname[dir->depth]);
 
        if (!direntry)
        {
            /* End of this directory */
            FreeDir(dir->dirdesc[dir->depth]);
            pfree(dir->dirname[dir->depth]);
            dir->depth--;
            continue;
        }
 
        if (direntry->d_name[0] == '.')
            continue;
 
        snprintf(fullname, sizeof(fullname), "%s/%s",
                 dir->dirname[dir->depth], direntry->d_name);
 
        if (get_dirent_type(fullname, direntry, true, ERROR) == PGFILETYPE_DIR)
        {
            /* Step into the subdirectory */
            if (dir->depth >= MAX_TZDIR_DEPTH - 1)
                ereport(ERROR,
                        (errmsg_internal("timezone directory stack overflow")));
            dir->depth++;
            dir->dirname[dir->depth] = pstrdup(fullname);
            dir->dirdesc[dir->depth] = AllocateDir(fullname);
            if (!dir->dirdesc[dir->depth])
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not open directory \"%s\": %m",
                                fullname)));
 
            /* Start over reading in the new directory */
            continue;
        }
 
        /*
         * Load this timezone using pg_tzload() not pg_tzset(), so we don't
         * fill the cache.  Also, don't ask for the canonical spelling: we
         * already know it, and pg_open_tzfile's way of finding it out is
         * pretty inefficient.
         */
        if (!pg_tzload(fullname + dir->baselen, NULL, &dir->tz.state))
        {
            /* Zone could not be loaded, ignore it */
            continue;
        }
 
        if (!pg_tz_acceptable(&dir->tz))
        {
            /* Ignore leap-second zones */
            continue;
        }
 
        /* OK, return the canonical zone name spelling. */
        strlcpy(dir->tz.TZname, fullname + dir->baselen,
                sizeof(dir->tz.TZname));
 
        /* Timezone loaded OK. */
        return &dir->tz;
    }
 
    /* Nothing more found */
    return NULL;
}

References AllocateDir(), pg_tzenum::baselen, pg_tzenum::depth, pg_tzenum::dirdesc, pg_tzenum::dirname, ereport, errcode_for_file_access(), errmsg, errmsg_internal(), ERROR, fb(), FreeDir(), get_dirent_type(), MAX_TZDIR_DEPTH, MAXPGPATH, pfree(), pg_tz_acceptable(), pg_tzload(), PGFILETYPE_DIR, pstrdup(), ReadDir(), snprintf, pg_tz::state, strlcpy(), pg_tzenum::tz, and pg_tz::TZname.

Referenced by pg_timezone_names().

pg_tzenumerate_start()

pg_tzenum * pg_tzenumerate_start ( void  )

extern

Definition at line 377 of file pgtz.c.

{
    pg_tzenum  *ret = palloc0_object(pg_tzenum);
    char       *startdir = pstrdup(pg_TZDIR());
 
    ret->baselen = strlen(startdir) + 1;
    ret->depth = 0;
    ret->dirname[0] = startdir;
    ret->dirdesc[0] = AllocateDir(startdir);
    if (!ret->dirdesc[0])
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open directory \"%s\": %m", startdir)));
    return ret;
}

References AllocateDir(), pg_tzenum::baselen, pg_tzenum::depth, pg_tzenum::dirdesc, pg_tzenum::dirname, ereport, errcode_for_file_access(), errmsg, ERROR, fb(), palloc0_object, pg_TZDIR(), and pstrdup().

Referenced by pg_timezone_names().

pg_tzset()

pg_tz * pg_tzset ( const char *  tzname )

extern

Definition at line 224 of file pgtz.c.

{
    pg_tz_cache *tzp;
    struct state tzstate;
    char        uppername[TZ_STRLEN_MAX + 1];
    char        canonname[TZ_STRLEN_MAX + 1];
    char       *p;
 
    if (strlen(tzname) > TZ_STRLEN_MAX)
        return NULL;            /* not going to fit */
 
    if (!timezone_cache)
        if (!init_timezone_hashtable())
            return NULL;
 
    /*
     * Upcase the given name to perform a case-insensitive hashtable search.
     * (We could alternatively downcase it, but we prefer upcase so that we
     * can get consistently upcased results from pg_tzload() in case the name
     * is a POSIX-style timezone spec.)
     */
    p = uppername;
    while (*tzname)
        *p++ = pg_toupper((unsigned char) *tzname++);
    *p = '\0';
 
    tzp = (pg_tz_cache *) hash_search(timezone_cache,
                                      uppername,
                                      HASH_FIND,
                                      NULL);
    if (tzp)
    {
        /* Timezone found in cache, nothing more to do */
        return &tzp->tz;
    }
 
    /*
     * Let the IANA tzdb code interpret the time zone name.
     */
    if (!pg_tzload(uppername, canonname, &tzstate))
    {
        if (strcmp(uppername, "GMT") == 0)
        {
            /* This really, really should not happen ... */
            elog(ERROR, "could not initialize GMT time zone");
        }
        /* Unknown timezone. Fail our call instead of loading GMT! */
        return NULL;
    }
 
    /* Save timezone in the cache */
    tzp = (pg_tz_cache *) hash_search(timezone_cache,
                                      uppername,
                                      HASH_ENTER,
                                      NULL);
 
    /* hash_search already copied uppername into the hash key */
    strcpy(tzp->tz.TZname, canonname);
    memcpy(&tzp->tz.state, &tzstate, sizeof(tzstate));
 
    return &tzp->tz;
}

References elog, ERROR, fb(), HASH_ENTER, HASH_FIND, hash_search(), init_timezone_hashtable(), memcpy(), pg_toupper(), pg_tzload(), pg_tz::state, timezone_cache, pg_tz_cache::tz, TZ_STRLEN_MAX, and pg_tz::TZname.

Referenced by check_log_timezone(), check_timezone(), DecodeDateTime(), DecodeTimeOnly(), DecodeTimezoneName(), FetchDynamicTimeZone(), pg_timezone_initialize(), and pg_tzset_offset().

pg_tzset_offset()

pg_tz * pg_tzset_offset ( long  gmtoffset )

extern

Definition at line 300 of file pgtz.c.

{
    long        absoffset = (gmtoffset < 0) ? -gmtoffset : gmtoffset;
    char        offsetstr[64];
    char        tzname[128];
 
    snprintf(offsetstr, sizeof(offsetstr),
             "%02ld", absoffset / SECS_PER_HOUR);
    absoffset %= SECS_PER_HOUR;
    if (absoffset != 0)
    {
        snprintf(offsetstr + strlen(offsetstr),
                 sizeof(offsetstr) - strlen(offsetstr),
                 ":%02ld", absoffset / SECS_PER_MINUTE);
        absoffset %= SECS_PER_MINUTE;
        if (absoffset != 0)
            snprintf(offsetstr + strlen(offsetstr),
                     sizeof(offsetstr) - strlen(offsetstr),
                     ":%02ld", absoffset);
    }
    if (gmtoffset > 0)
        snprintf(tzname, sizeof(tzname), "<-%s>+%s",
                 offsetstr, offsetstr);
    else
        snprintf(tzname, sizeof(tzname), "<+%s>-%s",
                 offsetstr, offsetstr);
 
    return pg_tzset(tzname);
}

References fb(), pg_tzset(), SECS_PER_HOUR, SECS_PER_MINUTE, and snprintf.

Referenced by check_timezone(), and DecodeTimezoneNameToTz().

Variable Documentation

log_timezone

PGDLLIMPORT pg_tz* log_timezone

extern

Definition at line 31 of file pgtz.c.

Referenced by assign_log_timezone(), build_backup_content(), get_formatted_log_time(), get_formatted_start_time(), log_status_format(), logfile_getname(), pg_timezone_initialize(), set_next_rotation_time(), show_log_timezone(), and str_time().

session_timezone

PGDLLIMPORT pg_tz* session_timezone

extern

Definition at line 28 of file pgtz.c.

Referenced by assign_timezone(), date2timestamptz_safe(), DecodeDateTime(), DecodeTimeOnly(), DecodeTimezoneAbbrev(), DecodeTimezoneAbbrevPrefix(), executeDateTimeMethod(), generate_series_timestamptz_internal(), GetCurrentTimeUsec(), pg_timezone_abbrevs_zone(), pg_timezone_initialize(), show_timezone(), time_timetz(), timeofday(), timestamp2timestamptz_safe(), timestamp2tm(), TimestampTimestampTzRequiresRewrite(), timestamptz_pl_interval_internal(), timestamptz_trunc(), timetz_at_local(), and to_timestamp().