datetime.c

Go to the documentation of this file.

/* src/interfaces/ecpg/pgtypeslib/datetime.c */
 
#include "postgres_fe.h"
 
#include <time.h>
#include <ctype.h>
#include <limits.h>
 
#include "dt.h"
#include "pgtypes_date.h"
#include "pgtypes_error.h"
#include "pgtypeslib_extern.h"
 
date *
PGTYPESdate_new(void)
{
    date       *result;
 
    result = (date *) pgtypes_alloc(sizeof(date));
    /* result can be NULL if we run out of memory */
    return result;
}
 
void
PGTYPESdate_free(date * d)
{
    free(d);
}
 
date
PGTYPESdate_from_timestamp(timestamp dt)
{
    date        dDate;
 
    dDate = 0;                  /* suppress compiler warning */
 
    if (!TIMESTAMP_NOT_FINITE(dt))
    {
        /* Microseconds to days */
        dDate = (dt / USECS_PER_DAY);
    }
 
    return dDate;
}
 
date
PGTYPESdate_from_asc(char *str, char **endptr)
{
    date        dDate;
    fsec_t      fsec;
    struct tm   tt,
               *tm = &tt;
    int         dtype;
    int         nf;
    char       *field[MAXDATEFIELDS];
    int         ftype[MAXDATEFIELDS];
    char        lowstr[MAXDATELEN + MAXDATEFIELDS];
    char       *realptr;
    char      **ptr = (endptr != NULL) ? endptr : &realptr;
 
    bool        EuroDates = false;
 
    errno = 0;
    if (strlen(str) > MAXDATELEN)
    {
        errno = PGTYPES_DATE_BAD_DATE;
        return INT_MIN;
    }
 
    if (ParseDateTime(str, lowstr, field, ftype, &nf, ptr) != 0 ||
        DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, EuroDates) != 0)
    {
        errno = PGTYPES_DATE_BAD_DATE;
        return INT_MIN;
    }
 
    switch (dtype)
    {
        case DTK_DATE:
            break;
 
        case DTK_EPOCH:
            if (GetEpochTime(tm) < 0)
            {
                errno = PGTYPES_DATE_BAD_DATE;
                return INT_MIN;
            }
            break;
 
        default:
            errno = PGTYPES_DATE_BAD_DATE;
            return INT_MIN;
    }
 
    dDate = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1));
 
    return dDate;
}
 
char *
PGTYPESdate_to_asc(date dDate)
{
    struct tm   tt,
               *tm = &tt;
    char        buf[MAXDATELEN + 1];
    int         DateStyle = 1;
    bool        EuroDates = false;
 
    j2date(dDate + date2j(2000, 1, 1), &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
    EncodeDateOnly(tm, DateStyle, buf, EuroDates);
    return pgtypes_strdup(buf);
}
 
void
PGTYPESdate_julmdy(date jd, int *mdy)
{
    int         y,
                m,
                d;
 
    j2date((int) (jd + date2j(2000, 1, 1)), &y, &m, &d);
    mdy[0] = m;
    mdy[1] = d;
    mdy[2] = y;
}
 
void
PGTYPESdate_mdyjul(int *mdy, date * jdate)
{
    /* month is mdy[0] */
    /* day   is mdy[1] */
    /* year  is mdy[2] */
 
    *jdate = (date) (date2j(mdy[2], mdy[0], mdy[1]) - date2j(2000, 1, 1));
}
 
int
PGTYPESdate_dayofweek(date dDate)
{
    /*
     * Sunday:  0 Monday:      1 Tuesday:     2 Wednesday:   3 Thursday: 4
     * Friday:      5 Saturday:    6
     */
    return (int) (dDate + date2j(2000, 1, 1) + 1) % 7;
}
 
void
PGTYPESdate_today(date * d)
{
    struct tm   ts;
 
    GetCurrentDateTime(&ts);
    if (errno == 0)
        *d = date2j(ts.tm_year, ts.tm_mon, ts.tm_mday) - date2j(2000, 1, 1);
}
 
#define PGTYPES_DATE_NUM_MAX_DIGITS     20  /* should suffice for most
                                             * years... */
 
#define PGTYPES_FMTDATE_DAY_DIGITS_LZ       1   /* LZ means "leading zeroes" */
#define PGTYPES_FMTDATE_DOW_LITERAL_SHORT   2
#define PGTYPES_FMTDATE_MONTH_DIGITS_LZ     3
#define PGTYPES_FMTDATE_MONTH_LITERAL_SHORT 4
#define PGTYPES_FMTDATE_YEAR_DIGITS_SHORT   5
#define PGTYPES_FMTDATE_YEAR_DIGITS_LONG    6
 
int
PGTYPESdate_fmt_asc(date dDate, const char *fmtstring, char *outbuf)
{
    static struct
    {
        char       *format;
        int         component;
    }           mapping[] =
    {
        /*
         * format items have to be sorted according to their length, since the
         * first pattern that matches gets replaced by its value
         */
        {
            "ddd", PGTYPES_FMTDATE_DOW_LITERAL_SHORT
        },
        {
            "dd", PGTYPES_FMTDATE_DAY_DIGITS_LZ
        },
        {
            "mmm", PGTYPES_FMTDATE_MONTH_LITERAL_SHORT
        },
        {
            "mm", PGTYPES_FMTDATE_MONTH_DIGITS_LZ
        },
        {
            "yyyy", PGTYPES_FMTDATE_YEAR_DIGITS_LONG
        },
        {
            "yy", PGTYPES_FMTDATE_YEAR_DIGITS_SHORT
        },
        {
            NULL, 0
        }
    };
 
    union un_fmt_comb replace_val;
    int         replace_type;
 
    int         i;
    int         dow;
    char       *start_pattern;
    struct tm   tm;
 
    /* copy the string over */
    strcpy(outbuf, fmtstring);
 
    /* get the date */
    j2date(dDate + date2j(2000, 1, 1), &(tm.tm_year), &(tm.tm_mon), &(tm.tm_mday));
    dow = PGTYPESdate_dayofweek(dDate);
 
    for (i = 0; mapping[i].format != NULL; i++)
    {
        while ((start_pattern = strstr(outbuf, mapping[i].format)) != NULL)
        {
            switch (mapping[i].component)
            {
                case PGTYPES_FMTDATE_DOW_LITERAL_SHORT:
                    replace_val.str_val = pgtypes_date_weekdays_short[dow];
                    replace_type = PGTYPES_TYPE_STRING_CONSTANT;
                    break;
                case PGTYPES_FMTDATE_DAY_DIGITS_LZ:
                    replace_val.uint_val = tm.tm_mday;
                    replace_type = PGTYPES_TYPE_UINT_2_LZ;
                    break;
                case PGTYPES_FMTDATE_MONTH_LITERAL_SHORT:
                    replace_val.str_val = months[tm.tm_mon - 1];
                    replace_type = PGTYPES_TYPE_STRING_CONSTANT;
                    break;
                case PGTYPES_FMTDATE_MONTH_DIGITS_LZ:
                    replace_val.uint_val = tm.tm_mon;
                    replace_type = PGTYPES_TYPE_UINT_2_LZ;
                    break;
                case PGTYPES_FMTDATE_YEAR_DIGITS_LONG:
                    replace_val.uint_val = tm.tm_year;
                    replace_type = PGTYPES_TYPE_UINT_4_LZ;
                    break;
                case PGTYPES_FMTDATE_YEAR_DIGITS_SHORT:
                    replace_val.uint_val = tm.tm_year % 100;
                    replace_type = PGTYPES_TYPE_UINT_2_LZ;
                    break;
                default:
 
                    /*
                     * should not happen, set something anyway
                     */
                    replace_val.str_val = " ";
                    replace_type = PGTYPES_TYPE_STRING_CONSTANT;
            }
            switch (replace_type)
            {
                case PGTYPES_TYPE_STRING_MALLOCED:
                case PGTYPES_TYPE_STRING_CONSTANT:
                    memcpy(start_pattern, replace_val.str_val,
                           strlen(replace_val.str_val));
                    if (replace_type == PGTYPES_TYPE_STRING_MALLOCED)
                        free(replace_val.str_val);
                    break;
                case PGTYPES_TYPE_UINT:
                    {
                        char       *t = pgtypes_alloc(PGTYPES_DATE_NUM_MAX_DIGITS);
 
                        if (!t)
                            return -1;
                        snprintf(t, PGTYPES_DATE_NUM_MAX_DIGITS,
                                 "%u", replace_val.uint_val);
                        memcpy(start_pattern, t, strlen(t));
                        free(t);
                    }
                    break;
                case PGTYPES_TYPE_UINT_2_LZ:
                    {
                        char       *t = pgtypes_alloc(PGTYPES_DATE_NUM_MAX_DIGITS);
 
                        if (!t)
                            return -1;
                        snprintf(t, PGTYPES_DATE_NUM_MAX_DIGITS,
                                 "%02u", replace_val.uint_val);
                        memcpy(start_pattern, t, strlen(t));
                        free(t);
                    }
                    break;
                case PGTYPES_TYPE_UINT_4_LZ:
                    {
                        char       *t = pgtypes_alloc(PGTYPES_DATE_NUM_MAX_DIGITS);
 
                        if (!t)
                            return -1;
                        snprintf(t, PGTYPES_DATE_NUM_MAX_DIGITS,
                                 "%04u", replace_val.uint_val);
                        memcpy(start_pattern, t, strlen(t));
                        free(t);
                    }
                    break;
                default:
 
                    /*
                     * doesn't happen (we set replace_type to
                     * PGTYPES_TYPE_STRING_CONSTANT in case of an error above)
                     */
                    break;
            }
        }
    }
    return 0;
}
 
 
/*
 * PGTYPESdate_defmt_asc
 *
 * function works as follows:
 *   - first we analyze the parameters
 *   - if this is a special case with no delimiters, add delimiters
 *   - find the tokens. First we look for numerical values. If we have found
 *     less than 3 tokens, we check for the months' names and thereafter for
 *     the abbreviations of the months' names.
 *   - then we see which parameter should be the date, the month and the
 *     year and from these values we calculate the date
 */
 
#define PGTYPES_DATE_MONTH_MAXLENGTH        20  /* probably even less  :-) */
int
PGTYPESdate_defmt_asc(date * d, const char *fmt, const char *str)
{
    /*
     * token[2] = { 4,6 } means that token 2 starts at position 4 and ends at
     * (including) position 6
     */
    int         token[3][2];
    int         token_values[3] = {-1, -1, -1};
    char       *fmt_token_order;
    char       *fmt_ystart,
               *fmt_mstart,
               *fmt_dstart;
    unsigned int i;
    int         reading_digit;
    int         token_count;
    char       *str_copy;
    struct tm   tm;
 
    tm.tm_year = tm.tm_mon = tm.tm_mday = 0;    /* keep compiler quiet */
 
    if (!d || !str || !fmt)
    {
        errno = PGTYPES_DATE_ERR_EARGS;
        return -1;
    }
 
    /* analyze the fmt string */
    fmt_ystart = strstr(fmt, "yy");
    fmt_mstart = strstr(fmt, "mm");
    fmt_dstart = strstr(fmt, "dd");
 
    if (!fmt_ystart || !fmt_mstart || !fmt_dstart)
    {
        errno = PGTYPES_DATE_ERR_EARGS;
        return -1;
    }
 
    if (fmt_ystart < fmt_mstart)
    {
        /* y m */
        if (fmt_dstart < fmt_ystart)
        {
            /* d y m */
            fmt_token_order = "dym";
        }
        else if (fmt_dstart > fmt_mstart)
        {
            /* y m d */
            fmt_token_order = "ymd";
        }
        else
        {
            /* y d m */
            fmt_token_order = "ydm";
        }
    }
    else
    {
        /* fmt_ystart > fmt_mstart */
        /* m y */
        if (fmt_dstart < fmt_mstart)
        {
            /* d m y */
            fmt_token_order = "dmy";
        }
        else if (fmt_dstart > fmt_ystart)
        {
            /* m y d */
            fmt_token_order = "myd";
        }
        else
        {
            /* m d y */
            fmt_token_order = "mdy";
        }
    }
 
    /*
     * handle the special cases where there is no delimiter between the
     * digits. If we see this:
     *
     * only digits, 6 or 8 bytes then it might be ddmmyy and ddmmyyyy (or
     * similar)
     *
     * we reduce it to a string with delimiters and continue processing
     */
 
    /* check if we have only digits */
    reading_digit = 1;
    for (i = 0; str[i]; i++)
    {
        if (!isdigit((unsigned char) str[i]))
        {
            reading_digit = 0;
            break;
        }
    }
    if (reading_digit)
    {
        int         frag_length[3];
        int         target_pos;
 
        i = strlen(str);
        if (i != 8 && i != 6)
        {
            errno = PGTYPES_DATE_ERR_ENOSHORTDATE;
            return -1;
        }
        /* okay, this really is the special case */
 
        /*
         * as long as the string, one additional byte for the terminator and 2
         * for the delimiters between the 3 fields
         */
        str_copy = pgtypes_alloc(strlen(str) + 1 + 2);
        if (!str_copy)
            return -1;
 
        /* determine length of the fragments */
        if (i == 6)
        {
            frag_length[0] = 2;
            frag_length[1] = 2;
            frag_length[2] = 2;
        }
        else
        {
            if (fmt_token_order[0] == 'y')
            {
                frag_length[0] = 4;
                frag_length[1] = 2;
                frag_length[2] = 2;
            }
            else if (fmt_token_order[1] == 'y')
            {
                frag_length[0] = 2;
                frag_length[1] = 4;
                frag_length[2] = 2;
            }
            else
            {
                frag_length[0] = 2;
                frag_length[1] = 2;
                frag_length[2] = 4;
            }
        }
        target_pos = 0;
 
        /*
         * XXX: Here we could calculate the positions of the tokens and save
         * the for loop down there where we again check with isdigit() for
         * digits.
         */
        for (i = 0; i < 3; i++)
        {
            int         start_pos = 0;
 
            if (i >= 1)
                start_pos += frag_length[0];
            if (i == 2)
                start_pos += frag_length[1];
 
            strncpy(str_copy + target_pos, str + start_pos,
                    frag_length[i]);
            target_pos += frag_length[i];
            if (i != 2)
            {
                str_copy[target_pos] = ' ';
                target_pos++;
            }
        }
        str_copy[target_pos] = '\0';
    }
    else
    {
        str_copy = pgtypes_strdup(str);
        if (!str_copy)
            return -1;
 
        /* convert the whole string to lower case */
        for (i = 0; str_copy[i]; i++)
            str_copy[i] = (char) pg_tolower((unsigned char) str_copy[i]);
    }
 
    /* look for numerical tokens */
    reading_digit = 0;
    token_count = 0;
    for (i = 0; i < strlen(str_copy); i++)
    {
        if (!isdigit((unsigned char) str_copy[i]) && reading_digit)
        {
            /* the token is finished */
            token[token_count][1] = i - 1;
            reading_digit = 0;
            token_count++;
        }
        else if (isdigit((unsigned char) str_copy[i]) && !reading_digit)
        {
            /* we have found a token */
            token[token_count][0] = i;
            reading_digit = 1;
        }
    }
 
    /*
     * we're at the end of the input string, but maybe we are still reading a
     * number...
     */
    if (reading_digit)
    {
        token[token_count][1] = i - 1;
        token_count++;
    }
 
 
    if (token_count < 2)
    {
        /*
         * not all tokens found, no way to find 2 missing tokens with string
         * matches
         */
        free(str_copy);
        errno = PGTYPES_DATE_ERR_ENOSHORTDATE;
        return -1;
    }
 
    if (token_count != 3)
    {
        /*
         * not all tokens found but we may find another one with string
         * matches by testing for the months names and months abbreviations
         */
        char       *month_lower_tmp = pgtypes_alloc(PGTYPES_DATE_MONTH_MAXLENGTH);
        char       *start_pos;
        int         j;
        int         offset;
        int         found = 0;
        char      **list;
 
        if (!month_lower_tmp)
        {
            /* free variables we alloc'ed before */
            free(str_copy);
            return -1;
        }
        list = pgtypes_date_months;
        for (i = 0; list[i]; i++)
        {
            for (j = 0; j < PGTYPES_DATE_MONTH_MAXLENGTH; j++)
            {
                month_lower_tmp[j] = (char) pg_tolower((unsigned char) list[i][j]);
                if (!month_lower_tmp[j])
                {
                    /* properly terminated */
                    break;
                }
            }
            if ((start_pos = strstr(str_copy, month_lower_tmp)))
            {
                offset = start_pos - str_copy;
 
                /*
                 * sort the new token into the numeric tokens, shift them if
                 * necessary
                 */
                if (offset < token[0][0])
                {
                    token[2][0] = token[1][0];
                    token[2][1] = token[1][1];
                    token[1][0] = token[0][0];
                    token[1][1] = token[0][1];
                    token_count = 0;
                }
                else if (offset < token[1][0])
                {
                    token[2][0] = token[1][0];
                    token[2][1] = token[1][1];
                    token_count = 1;
                }
                else
                    token_count = 2;
                token[token_count][0] = offset;
                token[token_count][1] = offset + strlen(month_lower_tmp) - 1;
 
                /*
                 * the value is the index of the month in the array of months
                 * + 1 (January is month 0)
                 */
                token_values[token_count] = i + 1;
                found = 1;
                break;
            }
 
            /*
             * evil[tm] hack: if we read the pgtypes_date_months and haven't
             * found a match, reset list to point to months (abbreviations)
             * and reset the counter variable i
             */
            if (list == pgtypes_date_months)
            {
                if (list[i + 1] == NULL)
                {
                    list = months;
                    i = -1;
                }
            }
        }
        if (!found)
        {
            free(month_lower_tmp);
            free(str_copy);
            errno = PGTYPES_DATE_ERR_ENOTDMY;
            return -1;
        }
 
        /*
         * here we found a month. token[token_count] and
         * token_values[token_count] reflect the month's details.
         *
         * only the month can be specified with a literal. Here we can do a
         * quick check if the month is at the right position according to the
         * format string because we can check if the token that we expect to
         * be the month is at the position of the only token that already has
         * a value. If we wouldn't check here we could say "December 4 1990"
         * with a fmt string of "dd mm yy" for 12 April 1990.
         */
        if (fmt_token_order[token_count] != 'm')
        {
            /* deal with the error later on */
            token_values[token_count] = -1;
        }
        free(month_lower_tmp);
    }
 
    /* terminate the tokens with ASCII-0 and get their values */
    for (i = 0; i < 3; i++)
    {
        *(str_copy + token[i][1] + 1) = '\0';
        /* A month already has a value set, check for token_value == -1 */
        if (token_values[i] == -1)
        {
            errno = 0;
            token_values[i] = strtol(str_copy + token[i][0], (char **) NULL, 10);
            /* strtol sets errno in case of an error */
            if (errno)
                token_values[i] = -1;
        }
        if (fmt_token_order[i] == 'd')
            tm.tm_mday = token_values[i];
        else if (fmt_token_order[i] == 'm')
            tm.tm_mon = token_values[i];
        else if (fmt_token_order[i] == 'y')
            tm.tm_year = token_values[i];
    }
    free(str_copy);
 
    if (tm.tm_mday < 1 || tm.tm_mday > 31)
    {
        errno = PGTYPES_DATE_BAD_DAY;
        return -1;
    }
 
    if (tm.tm_mon < 1 || tm.tm_mon > MONTHS_PER_YEAR)
    {
        errno = PGTYPES_DATE_BAD_MONTH;
        return -1;
    }
 
    if (tm.tm_mday == 31 && (tm.tm_mon == 4 || tm.tm_mon == 6 || tm.tm_mon == 9 || tm.tm_mon == 11))
    {
        errno = PGTYPES_DATE_BAD_DAY;
        return -1;
    }
 
    if (tm.tm_mon == 2 && tm.tm_mday > 29)
    {
        errno = PGTYPES_DATE_BAD_DAY;
        return -1;
    }
 
    *d = date2j(tm.tm_year, tm.tm_mon, tm.tm_mday) - date2j(2000, 1, 1);
 
    return 0;
}