date.c

oci的源码,可以在任何平台上编译,相当方便实用

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_DateGetDate
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateGetDate(OCI_Date *date, int *year, int *month, int *day)
{
    sb2 yr = 0;
    ub1 mt = 0;
    ub1 dy = 0;

    OCI_CHECK_PTR(OCI_IPC_DATE, date,  FALSE);
    OCI_CHECK_PTR(OCI_IPC_INT, year,  FALSE);
    OCI_CHECK_PTR(OCI_IPC_INT, month, FALSE);
    OCI_CHECK_PTR(OCI_IPC_INT, day,   FALSE);

    *year  = 0;
    *month = 0;
    *day   = 0;

    OCIDateGetDate(date->handle, &yr, &mt, &dy);

    *year  = (int) yr;
    *month = (int) mt;
    *day   = (int) dy;

    OCI_RESULT(TRUE);

    return TRUE;
}

/* ------------------------------------------------------------------------ *
 * OCI_DateGetTime
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateGetTime(OCI_Date *date, int *hour, int *min, int *sec)
{
    ub1 hr = 0;
    ub1 mn = 0;
    ub1 sc = 0;

    OCI_CHECK_PTR(OCI_IPC_DATE, date, FALSE);
    OCI_CHECK_PTR(OCI_IPC_INT, hour, FALSE);
    OCI_CHECK_PTR(OCI_IPC_INT, min , FALSE);
    OCI_CHECK_PTR(OCI_IPC_INT, sec,  FALSE);

    *hour = 0;
    *min  = 0;
    *sec  = 0;

    OCIDateGetTime(date->handle, &hr, &mn, &sc);

    *hour = (int) hr;
    *min  = (int) mn;
    *sec  = (int) sc;

    OCI_RESULT(TRUE);

    return TRUE;
}

/* ------------------------------------------------------------------------ *
 * OCI_DateGetDateTime
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateGetDateTime(OCI_Date *date, int *year, int *month, 
                                    int *day, int *hour, int *min, int *sec)
{
    return (OCI_DateGetDate(date, year, month, day) &&
            OCI_DateGetTime(date, hour, min, sec));
}

/* ------------------------------------------------------------------------ *
 * OCI_DateLastDay
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateLastDay(OCI_Date *date)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_DATE, date, FALSE);

    OCI_CALL4
    (
        res, date->err, date->con, 
        
        OCIDateLastDay(date->err, date->handle, date->handle)
    )

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_DateNextDay
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateNextDay(OCI_Date *date, const mtext *day)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_DATE, date, FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, day,  FALSE);

    OCI_CALL4
    (
        res, date->err, date->con, 
        
        OCIDateNextDay(date->err, date->handle, (oratext *) day,
                       (ub4) mtextsize(day), date->handle)
    )

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_DateSetDate
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateSetDate(OCI_Date *date, int year, int month, int day)
{
    OCI_CHECK_PTR(OCI_IPC_DATE, date, FALSE);

    OCIDateSetDate(date->handle, (sb2) year, (ub1) month, (ub1) day);

    OCI_RESULT(TRUE);

    return TRUE;
}

/* ------------------------------------------------------------------------ *
 * OCI_DateSetTime
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateSetTime(OCI_Date *date, int hour, int min, int sec)
{
    OCI_CHECK_PTR(OCI_IPC_DATE, date, FALSE);

    OCIDateSetTime(date->handle, (ub1) hour, (ub1) min, (ub1) sec);

    OCI_RESULT(TRUE);

    return TRUE;
}

/* ------------------------------------------------------------------------ *
 * OCI_DateSetDateTime
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateSetDateTime(OCI_Date *date, int year, int month, 
                                    int day, int hour, int min, int sec)
{
    return (OCI_DateSetDate(date, year, month, day) &&
            OCI_DateSetTime(date, hour, min, sec));
}

/* ------------------------------------------------------------------------ *
 * OCI_DateSysDate
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateSysDate(OCI_Date *date)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_DATE, date, FALSE);

    OCI_CALL4
    (
        res, date->err, date->con, 
        
        OCIDateSysDate(date->err, date->handle)
    )

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_DateToText
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateToText(OCI_Date *date, const mtext *fmt, int size, 
                               mtext *str)
{
    void *ostr1 = NULL;
    void *ostr2 = NULL;
    int  osize1 = size*sizeof(mtext);
    int  osize2 = -1;
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_DATE, date,  FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, str, FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, fmt, FALSE);

    /* init output buffer in case of OCI failure */
 
    str[0] = 0;

    ostr1 = OCI_GetInputMetaString(str, &osize1);
    ostr2 = OCI_GetInputMetaString(fmt, &osize2);

    OCI_CALL4
    (
        res, date->err, date->con, 
        
        OCIDateToText(date->err, date->handle, (oratext *) ostr2, 
                      (ub1) osize2, (oratext *) NULL, (ub4) 0,
                      (ub4*) &osize1, (oratext *) ostr1)
    )

    OCI_GetOutputMetaString(ostr1, str, &osize1);

    OCI_ReleaseMetaString(ostr1);
    OCI_ReleaseMetaString(ostr2);

    /* set null string terminator*/

    str[osize1/sizeof(mtext)] = 0;

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_DateZoneToZone
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateZoneToZone(OCI_Date *date, const mtext *zone1, 
                                   const mtext *zone2)
{
    void *ostr1 = NULL;
    void *ostr2 = NULL;
    int osize1  = -1;
    int osize2  = -1;
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_DATE, date,    FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, zone1, FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, zone2, FALSE);

    ostr1 = OCI_GetInputMetaString(zone1, &osize1);
    ostr2 = OCI_GetInputMetaString(zone2, &osize2);
   
    OCI_CALL4
    (
        res, date->err, date->con, 
        
        OCIDateZoneToZone(date->err, date->handle,
                          (oratext *) ostr1, (ub4) osize1,
                          (oratext *) ostr2, (ub4) osize2,
                          date->handle)
    )

    OCI_ReleaseMetaString(ostr1);
    OCI_ReleaseMetaString(ostr2);

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_DateToCTime
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateToCTime(OCI_Date *date, struct tm *ptm, time_t *pt)
{
    time_t time = -1;
    struct tm t;

    OCI_CHECK_PTR(OCI_IPC_DATE, date, FALSE);

    t.tm_year  = date->handle->OCIDateYYYY - 1900;
    t.tm_mon   = date->handle->OCIDateMM - 1;
    t.tm_mday  = date->handle->OCIDateDD;

    t.tm_hour  = date->handle->OCIDateTime.OCITimeHH;
    t.tm_min   = date->handle->OCIDateTime.OCITimeMI;
    t.tm_sec   = date->handle->OCIDateTime.OCITimeSS;

    t.tm_wday  = 0;
    t.tm_yday  = 0;
    t.tm_isdst = -1;

    time = mktime(&t);

    if (ptm != NULL)
        memcpy(ptm, &t, sizeof(t));

    if (pt != NULL)
        *pt = time;

    OCI_RESULT(TRUE);

    return (time != -1);
}

/* ------------------------------------------------------------------------ *
 * OCI_DateFromCTime
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_DateFromCTime(OCI_Date *date, struct tm *ptm, time_t t)
{
    OCI_CHECK_PTR(OCI_IPC_DATE, date, FALSE);

    if (ptm == NULL && t == 0)
        OCI_ExceptionNullPointer(OCI_IPC_TM);

    if (ptm == NULL)
        ptm = localtime(&t);

    date->handle->OCIDateYYYY = (sb2) ptm->tm_year + 1900;
    date->handle->OCIDateMM   = (ub1) ptm->tm_mon  + 1;
    date->handle->OCIDateDD   = (ub1) ptm->tm_mday;

    date->handle->OCIDateTime.OCITimeHH = (ub1) ptm->tm_hour;
    date->handle->OCIDateTime.OCITimeMI = (ub1) ptm->tm_min;
    date->handle->OCIDateTime.OCITimeSS = (ub1) ptm->tm_sec;

    OCI_RESULT(TRUE);

    return TRUE;
}