timestamp.c

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

boolean OCI_API OCI_TimestampGetDate(OCI_Timestamp *tmsp, int *year, int *month,
                                     int *day)
{
    boolean res = TRUE;
    sb2 yr = 0;
    ub1 mt = 0;
    ub1 dy = 0;

    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp, 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);

    OCI_CHECK_TIMESTAMP_ENABLED(tmsp->con, FALSE);

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

#if OCI_VERSION_COMPILE >= OCI_9

    OCI_CALL4
    (
        res, tmsp->err, tmsp->con,
        
        OCIDateTimeGetDate((dvoid *) OCILib.env, tmsp->err, tmsp->handle,
                           &yr, &mt, &dy)
    )

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

#else

    OCI_NOT_USED(year);
    OCI_NOT_USED(month);
    OCI_NOT_USED(day);
    OCI_NOT_USED(yr);
    OCI_NOT_USED(mt);
    OCI_NOT_USED(dy);

#endif

   OCI_RESULT(res);

   return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_TimestampGetTime
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_TimestampGetTime(OCI_Timestamp *tmsp, int *hour, int *min,
                                    int *sec, int *fsec)
{
    boolean res = TRUE;

    ub1 hr = 0;
    ub1 mn = 0;
    ub1 sc = 0;
    ub4 fs = 0;

    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp, 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);
    OCI_CHECK_PTR(OCI_IPC_INT, fsec, FALSE);

    OCI_CHECK_TIMESTAMP_ENABLED(tmsp->con, FALSE);

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

#if OCI_VERSION_COMPILE >= OCI_9

    OCI_CALL4
    (
        res, tmsp->err, tmsp->con,
        
        OCIDateTimeGetTime((dvoid *) OCILib.env, tmsp->err, tmsp->handle,
                           &hr, &mn, &sc, &fs)
    )

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

#else

    OCI_NOT_USED(hour);
    OCI_NOT_USED(min);
    OCI_NOT_USED(sec);
    OCI_NOT_USED(fsec);
    OCI_NOT_USED(hr);
    OCI_NOT_USED(mn);
    OCI_NOT_USED(sc);
    OCI_NOT_USED(fs);

#endif

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_TimestampGetDateTime
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_TimestampGetDateTime(OCI_Timestamp *tmsp, int *year, 
                                         int *month, int *day, int *hour, 
                                         int *min, int *sec, int *fsec)
{
    return (OCI_TimestampGetDate(tmsp, year, month, day) &&
            OCI_TimestampGetTime(tmsp, hour, min, sec, fsec));
}

/* ------------------------------------------------------------------------ *
 * OCI_TimestampGetTimeZoneName
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_TimestampGetTimeZoneName(OCI_Timestamp *tmsp, int size,
                                             mtext *str)
{
    boolean res = TRUE;
    void *ostr  = NULL;
    int osize   = size*sizeof(mtext);

    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp, FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, str, FALSE);

    OCI_CHECK_TIMESTAMP_ENABLED(tmsp->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    ostr = OCI_GetInputMetaString(str, &osize);

    OCI_CALL4
    (
        res, tmsp->err, tmsp->con,
        
        OCIDateTimeGetTimeZoneName((dvoid *) OCILib.env, tmsp->err, tmsp->handle,
                                   (ub1*) ostr, (ub4*) &osize)
    )

    OCI_GetOutputMetaString(ostr, str, &osize);

    OCI_ReleaseMetaString(ostr);

    /* set null string terminator */

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

#else

    OCI_NOT_USED(str);
    OCI_NOT_USED(size);
    OCI_NOT_USED(ostr);
    OCI_NOT_USED(osize);

#endif

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_TimestampGetTimeZoneOffset
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_TimestampGetTimeZoneOffset(OCI_Timestamp *tmsp,
                                              int *hour, int *min)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp, FALSE);
    OCI_CHECK_PTR(OCI_IPC_INT, hour, FALSE);
    OCI_CHECK_PTR(OCI_IPC_INT, min, FALSE);

    OCI_CHECK_TIMESTAMP_ENABLED(tmsp->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    OCI_CALL4
    (
        res, tmsp->err, tmsp->con,
        
        OCIDateTimeGetTimeZoneOffset((dvoid *) OCILib.env, tmsp->err,
                                     tmsp->handle, (sb1*) hour, (sb1*) min)
    )

#else

    OCI_NOT_USED(hour);
    OCI_NOT_USED(min);

#endif

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_TimestampIntervalAdd
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_TimestampIntervalAdd(OCI_Timestamp *tmsp, OCI_Interval *itv)
{
    boolean res  = TRUE;
    OCI_Timestamp *tmp = NULL;

    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp, FALSE);
    OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv,  FALSE);

    OCI_CHECK_TIMESTAMP_ENABLED(tmsp->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    /* OCIDateTimeIntervalAdd() fails if timestamps is not OCI_TIMESTAMP_TZ */

    if ((res == TRUE) && (tmsp->type != OCI_TIMESTAMP_TZ))    
    {
        tmp = OCI_TimestampCreate(tmsp->con, OCI_TIMESTAMP_TZ);

        res = OCI_TimestampConvert(tmp, tmsp);
    }
    else
        tmp = tmsp;

    OCI_CALL4
    (
        res, tmsp->err, tmsp->con,
        
        OCIDateTimeIntervalAdd((dvoid *) OCILib.env, tmp->err, tmp->handle,
                               itv->handle, tmp->handle)
    )

    /* converting back */

    if ((res == TRUE) && (tmsp->type != OCI_TIMESTAMP_TZ))    
    {
        res = OCI_TimestampConvert(tmsp, tmp);

        OCI_TimestampFree(tmp);
    }

#else

    OCI_NOT_USED(tmp);

#endif

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_TimestampIntervalSub
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_TimestampIntervalSub(OCI_Timestamp *tmsp,
                                         OCI_Interval *itv)
{
    boolean res  = TRUE;
    OCI_Timestamp *tmp = NULL;

    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp, FALSE);
    OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv,  FALSE);

    OCI_CHECK_TIMESTAMP_ENABLED(tmsp->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    /* OCIDateTimeIntervalSub() fails if timestamps is not OCI_TIMESTAMP_TZ */

    if ((res == TRUE) && (tmsp->type != OCI_TIMESTAMP_TZ))    
    {
        tmp = OCI_TimestampCreate(tmsp->con, OCI_TIMESTAMP_TZ);

        res = OCI_TimestampConvert(tmp, tmsp);
    }
    else
        tmp = tmsp;

    OCI_CALL4
    (
        res, tmsp->err, tmsp->con,
        
        OCIDateTimeIntervalSub((dvoid *) OCILib.env, tmp->err, tmp->handle, 
                               itv->handle, tmp->handle)
    )

    /* converting back */

    if ((res == TRUE) && (tmsp->type != OCI_TIMESTAMP_TZ))    
    {
        res = OCI_TimestampConvert(tmsp, tmp);

        OCI_TimestampFree(tmp);
    }

#else

    OCI_NOT_USED(tmp);

#endif

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_TimestampSubtract
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_TimestampSubtract(OCI_Timestamp *tmsp, OCI_Timestamp *tmsp2,
                                     OCI_Interval *itv)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp,  FALSE);
    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp2, FALSE);
    OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv,   FALSE);

    OCI_CHECK_TIMESTAMP_ENABLED(tmsp->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    OCI_CALL4
    (
        res, tmsp->err, tmsp->con,
        
        OCIDateTimeSubtract((dvoid *) OCILib.env, tmsp->err, tmsp->handle,
                             tmsp2->handle, itv->handle)
    )

#endif

   OCI_RESULT(res);

   return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_TimestampSysTimeStamp
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_TimestampSysTimeStamp(OCI_Timestamp *tmsp)
{
    boolean res = TRUE;
    OCI_Timestamp *tmp  = NULL;
    OCIDateTime *handle = NULL;

    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp, FALSE);
 
    OCI_CHECK_TIMESTAMP_ENABLED(tmsp->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    /* Filling a timestamp handle of type OCI_TIMESTAMP with 
       OCIDateTimeSysTimeStamp() can lead later to an error ORA-01483 when
       binding the given timestamp to some SQL Statement (Oracle BUG).
       The only way to avoid that is to pass to OCIDateTimeSysTimeStamp() 
       a timestamp handle of type OCI_TIMESTAMP_TZ and convert it back to
       OCI_TIMESTAMP if needed
    */

    if ((res == TRUE) && (tmsp->type == OCI_TIMESTAMP))    
    {
        tmp = OCI_TimestampCreate(tmsp->con, OCI_TIMESTAMP_TZ);

        handle = tmp->handle;
    }
    else
        handle = tmsp->handle;

    OCI_CALL4
    (
        res, tmsp->err, tmsp->con,
        
        OCIDateTimeSysTimeStamp((dvoid *) OCILib.env, tmsp->err, handle)
    )

    if ((res == TRUE) && (tmsp->type == OCI_TIMESTAMP))    
    {
        res = OCI_TimestampConvert(tmsp, tmp);

        OCI_TimestampFree(tmp);
    }

#else

    OCI_NOT_USED(tmp);

#endif

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_TimestampToCTime
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_TimestampToCTime(OCI_Timestamp *tmsp, struct tm *ptm,
                                     time_t *pt)
{
    boolean res = TRUE;
    time_t time = -1;
    int msec    = 0;
    struct tm t;

    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp, FALSE);

    OCI_CHECK_TIMESTAMP_ENABLED(tmsp->con, FALSE);

    res = OCI_TimestampGetDateTime(tmsp, &t.tm_year, &t.tm_mon, &t.tm_mday,
                                         &t.tm_hour, &t.tm_min, &t.tm_sec, 
                                         &msec);


    if (res == TRUE)
    {
        t.tm_year -= 1900;
        t.tm_mon  -= 1;
        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(res);

    return (time != -1);
}

/* ------------------------------------------------------------------------ *
 * OCI_TimestampFromCTime
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_TimestampFromCTime(OCI_Timestamp *tmsp, struct tm *ptm,
                                       time_t t)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_TIMESTAMP, tmsp, FALSE);

    OCI_CHECK_TIMESTAMP_ENABLED(tmsp->con, FALSE);

    if (ptm == NULL && t == 0)
        return FALSE;

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

    res =  OCI_TimestampConstruct(tmsp, 
                                  ptm->tm_year + 1900,
                                  ptm->tm_mon  + 1,
                                  ptm->tm_mday,
                                  ptm->tm_hour,
                                  ptm->tm_min,
                                  ptm->tm_sec,
                                  (int) 0,
                                  (const mtext *) NULL);

    OCI_RESULT(res);

    return res;
}