C:/Users/vincent/Data/Perso/dev/ocilib/ocilib/src/interval.c

00001 /*
00002    +----------------------------------------------------------------------+   
00003    |                                                                      |
00004    |                     OCILIB - C Driver for Oracle                     |
00005    |                                                                      |
00006    |                      (C Wrapper for Oracle OCI)                      |
00007    |                                                                      |
00008    +----------------------------------------------------------------------+
00009    |                      Website : http://www.ocilib.net                 |
00010    +----------------------------------------------------------------------+
00011    |               Copyright (c) 2007-2009 Vincent ROGIER                 |
00012    +----------------------------------------------------------------------+
00013    | This library is free software; you can redistribute it and/or        |
00014    | modify it under the terms of the GNU Lesser General Public           |
00015    | License as published by the Free Software Foundation; either         |
00016    | version 2 of the License, or (at your option) any later version.     |
00017    |                                                                      |
00018    | This library is distributed in the hope that it will be useful,      |
00019    | but WITHOUT ANY WARRANTY; without even the implied warranty of       |
00020    | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    |
00021    | Lesser General Public License for more details.                      |
00022    |                                                                      |
00023    | You should have received a copy of the GNU Lesser General Public     |
00024    | License along with this library; if not, write to the Free           |
00025    | Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.   |
00026    +----------------------------------------------------------------------+
00027    |          Author: Vincent ROGIER <vince.rogier@gmail.com>             |
00028    +----------------------------------------------------------------------+ 
00029 */
00030 
00031 /* ------------------------------------------------------------------------ *
00032  * $Id: interval.c, v 3.4.0 2009-07-30 17:40 Vince $
00033  * ------------------------------------------------------------------------ */
00034 
00035 #include "ocilib_internal.h"
00036 
00037 /* ************************************************************************ *
00038  *                             PRIVATE FUNCTIONS
00039  * ************************************************************************ */
00040 
00041 /* ------------------------------------------------------------------------ *
00042  *                         OCI_Interval functions
00043  * ------------------------------------------------------------------------ */
00044 
00045 OCI_Interval * OCI_IntervalInit(OCI_Connection *con, OCI_Interval **pitv,
00046                                 OCIInterval *buffer, ub4 type)
00047 {
00048     OCI_Interval *itv = NULL;
00049 
00050 #if OCI_VERSION_COMPILE >= OCI_9_0
00051 
00052     boolean res       = TRUE;
00053 
00054     OCI_CHECK(pitv == NULL, NULL);
00055 
00056     if (*pitv == NULL)
00057         *pitv = (OCI_Interval *) OCI_MemAlloc(OCI_IPC_INTERVAL, sizeof(*itv), 1, TRUE);
00058 
00059     if (*pitv != NULL)
00060     {
00061         itv = *pitv;
00062     
00063         itv->con    = con;
00064         itv->handle = buffer;
00065         itv->type   = type;
00066 
00067         /* get the right error handle */
00068 
00069         if (con != NULL)
00070             itv->err = con->err;
00071         else
00072             itv->err = OCILib.err;
00073        
00074         /* allocate buffer if needed */
00075         
00076         if (itv != NULL && itv->handle == NULL)
00077         {
00078             ub4 htype = 0;
00079 
00080             itv->hstate = OCI_OBJECT_ALLOCATED;
00081 
00082             if (itv->type == OCI_INTERVAL_YM)
00083                 htype = OCI_DTYPE_INTERVAL_YM;
00084             else if (itv->type == OCI_INTERVAL_DS)
00085                 htype = OCI_DTYPE_INTERVAL_DS;
00086 
00087             res = (OCI_SUCCESS == OCI_DescriptorAlloc((dvoid  *) OCILib.env, 
00088                                                       (dvoid **) (void *) &itv->handle,
00089                                                       (ub4     ) htype, (size_t) 0, 
00090                                                       (dvoid **) NULL));
00091         }
00092         else
00093             itv->hstate = OCI_OBJECT_FETCHED_CLEAN;
00094     }
00095     else
00096         res = FALSE;
00097 
00098     /* check for failure */
00099 
00100     if (res == FALSE)
00101     {
00102         OCI_IntervalFree(itv);
00103         itv = NULL;
00104     }
00105 
00106 #else
00107 
00108     OCI_NOT_USED(con);
00109     OCI_NOT_USED(pitv);
00110     OCI_NOT_USED(type);
00111     OCI_NOT_USED(buffer);
00112 
00113 #endif
00114 
00115     return itv;
00116 }
00117 
00118 /* ************************************************************************ *
00119  *                            PUBLIC FUNCTIONS
00120  * ************************************************************************ */
00121 
00122 /* ------------------------------------------------------------------------ *
00123  * OCI_IntervalCreate
00124  * ------------------------------------------------------------------------ */
00125 
00126 OCI_Interval * OCI_API OCI_IntervalCreate(OCI_Connection *con, unsigned int type)
00127 {
00128     OCI_Interval *itv = NULL;
00129 
00130     OCI_CHECK_INITIALIZED(NULL);
00131 
00132     OCI_CHECK_INTERVAL_ENABLED(con, NULL);
00133 
00134 #if OCI_VERSION_COMPILE >= OCI_9_0
00135 
00136     itv = OCI_IntervalInit(con, &itv, NULL, type);
00137 
00138 #else
00139 
00140     OCI_NOT_USED(type);
00141 
00142 #endif
00143 
00144     OCI_RESULT(itv != NULL);
00145 
00146     return itv;
00147 }
00148 
00149 /* ------------------------------------------------------------------------ *
00150  * OCI_IntervalFree
00151  * ------------------------------------------------------------------------ */
00152 
00153 boolean OCI_API OCI_IntervalFree(OCI_Interval *itv)
00154 {
00155     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv, FALSE);
00156     
00157     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00158 
00159 #if OCI_VERSION_COMPILE >= OCI_9_0
00160 
00161     OCI_CHECK_OBJECT_FETCHED(itv, FALSE);
00162 
00163     if (itv->hstate == OCI_OBJECT_ALLOCATED)
00164     {
00165         ub4 htype = 0;
00166 
00167         if (itv->type == OCI_INTERVAL_YM)
00168             htype = OCI_DTYPE_INTERVAL_YM;
00169         else if (itv->type == OCI_INTERVAL_DS)
00170             htype = OCI_DTYPE_INTERVAL_DS;
00171 
00172         OCI_DescriptorFree((dvoid *) itv->handle, htype);
00173     }
00174 
00175     OCI_FREE(itv);
00176    
00177 #endif
00178    
00179    OCI_RESULT(TRUE);
00180 
00181    return TRUE;
00182 }
00183 
00184 /* ------------------------------------------------------------------------ *
00185  * OCI_IntervalGetType
00186  * ------------------------------------------------------------------------ */
00187 
00188 unsigned int OCI_API OCI_IntervalGetType(OCI_Interval *itv)
00189 {
00190     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv, OCI_UNKNOWN);
00191 
00192     OCI_CHECK_INTERVAL_ENABLED(itv->con, OCI_UNKNOWN);
00193 
00194     OCI_RESULT(TRUE);
00195 
00196     return itv->type;
00197 }
00198 
00199 /* ------------------------------------------------------------------------ *
00200  * OCI_IntervalAssign
00201  * ------------------------------------------------------------------------ */
00202 
00203 boolean OCI_API OCI_IntervalAssign(OCI_Interval *itv,  OCI_Interval *itv_src)
00204 {
00205     boolean res = TRUE;
00206 
00207     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv,     FALSE);
00208     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv_src, FALSE);
00209     
00210     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00211 
00212 #if OCI_VERSION_COMPILE >= OCI_9_0
00213 
00214     OCI_CALL4
00215     (
00216         res, itv->err, itv->con,
00217         
00218         OCIIntervalAssign((dvoid *) OCILib.env, itv->err,
00219                           itv_src->handle, itv->handle)
00220     )
00221    
00222 #endif
00223 
00224     OCI_RESULT(res);
00225    
00226     return res;
00227 }
00228 
00229 /* ------------------------------------------------------------------------ *
00230  * OCI_IntervalCheck
00231  * ------------------------------------------------------------------------ */
00232 
00233 int OCI_API OCI_IntervalCheck(OCI_Interval *itv)
00234 {
00235     ub4 value   = (ub4) OCI_ERROR;
00236     boolean res = TRUE;
00237 
00238     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv, OCI_ERROR);
00239     
00240     OCI_CHECK_INTERVAL_ENABLED(itv->con, OCI_ERROR);
00241 
00242 #if OCI_VERSION_COMPILE >= OCI_9_0
00243 
00244     OCI_CALL4
00245     (
00246         res, itv->err, itv->con, 
00247         
00248         OCIIntervalCheck((dvoid *) OCILib.env, itv->err, itv->handle, &value)
00249     )
00250 
00251 
00252 #endif
00253 
00254     OCI_RESULT(res);
00255    
00256     return (int) value;
00257 
00258 }
00259 
00260 /* ------------------------------------------------------------------------ *
00261  * OCI_IntervalCompare
00262  * ----------------------------------------------------------------------- */
00263 
00264 int OCI_API OCI_IntervalCompare(OCI_Interval *itv, OCI_Interval *itv2)
00265 {
00266     sword value = OCI_ERROR;
00267     boolean res = TRUE;
00268 
00269     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv,  value);
00270     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv2, value);
00271     
00272     OCI_CHECK_INTERVAL_ENABLED(itv->con, value);
00273 
00274 #if OCI_VERSION_COMPILE >= OCI_9_0
00275 
00276     OCI_CALL4
00277     (
00278         res, itv->err, itv->con,
00279         
00280         OCIIntervalCompare((dvoid *) OCILib.env, itv->err, itv2->handle, 
00281                            itv2->handle, &value)
00282     )
00283 
00284 #endif
00285 
00286     OCI_RESULT(res);
00287 
00288     return (int) value;
00289 }
00290 
00291 /* ------------------------------------------------------------------------ *
00292  * OCI_IntervalFromText
00293  * ------------------------------------------------------------------------ */
00294 
00295 boolean OCI_API OCI_IntervalFromText(OCI_Interval *itv, const mtext * str)
00296 {
00297     boolean res = TRUE;
00298     void *ostr  = NULL;
00299     int  osize  = -1;
00300 
00301     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv, FALSE);
00302     OCI_CHECK_PTR(OCI_IPC_STRING, str, FALSE);
00303     
00304     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00305 
00306 #if OCI_VERSION_COMPILE >= OCI_9_0
00307 
00308     ostr = OCI_GetInputMetaString(str, &osize);
00309  
00310     OCI_CALL4
00311     (
00312         res, itv->err, itv->con,
00313         
00314         OCIIntervalFromText((dvoid *) OCILib.env, itv->err, (OraText *) ostr, 
00315                             (size_t) osize, itv->handle)
00316     )
00317     
00318     OCI_ReleaseMetaString(ostr);
00319 
00320 #else
00321 
00322     OCI_NOT_USED(str);
00323     OCI_NOT_USED(ostr);
00324     OCI_NOT_USED(osize);    
00325 
00326 #endif
00327 
00328    OCI_RESULT(res);
00329 
00330    
00331    return res;
00332 }
00333 
00334 /* ------------------------------------------------------------------------ *
00335  * OCI_IntervalToText
00336  * ------------------------------------------------------------------------ */
00337 
00338 boolean OCI_API OCI_IntervalToText(OCI_Interval *itv, int leading_prec,
00339                                     int fraction_prec, int size, mtext *str)
00340 {
00341     boolean res = TRUE;
00342     void *ostr  = NULL;
00343     int osize   = size * sizeof(mtext);
00344 
00345     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv, FALSE);
00346     OCI_CHECK_PTR(OCI_IPC_STRING, str, FALSE);
00347  
00348     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00349  
00350     /* init output buffer in case of OCI failure */
00351     
00352     str[0] = 0;
00353 
00354 #if OCI_VERSION_COMPILE >= OCI_9_0
00355 
00356     ostr = OCI_GetInputMetaString(str, &osize);
00357  
00358     OCI_CALL4
00359     (
00360         res, itv->err, itv->con,
00361         
00362         OCIIntervalToText((dvoid *) OCILib.env, itv->err,
00363                           (OCIInterval *) itv->handle,
00364                           (ub1) leading_prec, (ub1) fraction_prec,
00365                           (OraText *) ostr, (size_t) osize, 
00366                           (size_t *) &osize)
00367     )
00368  
00369     OCI_GetOutputMetaString(ostr, str, &osize);
00370     OCI_ReleaseMetaString(ostr);
00371 
00372     /* set null string terminator */
00373 
00374     str[osize/sizeof(mtext)] = 0;
00375 
00376 #else
00377 
00378     OCI_NOT_USED(str);
00379     OCI_NOT_USED(ostr);
00380     OCI_NOT_USED(size);    
00381     OCI_NOT_USED(osize);    
00382     OCI_NOT_USED(leading_prec);    
00383     OCI_NOT_USED(fraction_prec);    
00384 
00385 #endif
00386 
00387     OCI_RESULT(res);
00388    
00389     return res;
00390 }
00391 
00392 /* ------------------------------------------------------------------------ *
00393  * OCI_IntervalFromTimeZone
00394  * ------------------------------------------------------------------------ */
00395 
00396 boolean OCI_API OCI_IntervalFromTimeZone(OCI_Interval *itv, const mtext * str)
00397 {
00398     boolean res = TRUE;
00399     void *ostr  = NULL;
00400     int osize   = -1;
00401 
00402     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv, FALSE);
00403     OCI_CHECK_PTR(OCI_IPC_STRING, str, FALSE);
00404     
00405     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00406 
00407 #if OCI_VERSION_COMPILE >= OCI_9_0
00408 
00409     ostr = OCI_GetInputMetaString(str, &osize);
00410   
00411     OCI_CALL4
00412     (
00413         res, itv->err, itv->con,
00414         
00415         OCIIntervalFromTZ((dvoid *) OCILib.env, itv->err,  (OraText *) ostr,
00416                           (size_t) osize, itv->handle)
00417     )
00418 
00419     OCI_ReleaseMetaString(ostr);
00420 
00421 #else
00422 
00423     OCI_NOT_USED(str);
00424     OCI_NOT_USED(ostr);
00425     OCI_NOT_USED(osize);    
00426 
00427 #endif
00428 
00429     OCI_RESULT(res);
00430 
00431     return res;
00432 }
00433 
00434 /* ------------------------------------------------------------------------ *
00435  * OCI_IntervalGetDaySecond
00436  * ------------------------------------------------------------------------ */
00437 
00438 boolean OCI_API OCI_IntervalGetDaySecond(OCI_Interval *itv, int *day, int *hour,
00439                                          int *min, int *sec, int *fsec)
00440 {
00441     boolean res = TRUE;
00442 
00443     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv, FALSE);
00444     OCI_CHECK_PTR(OCI_IPC_INT, hour, FALSE);
00445     OCI_CHECK_PTR(OCI_IPC_INT, min , FALSE);
00446     OCI_CHECK_PTR(OCI_IPC_INT, sec,  FALSE);
00447     OCI_CHECK_PTR(OCI_IPC_INT, fsec, FALSE);
00448 
00449     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00450 
00451     *day  = 0;
00452     *hour = 0;
00453     *min  = 0;
00454     *sec  = 0;
00455     *fsec = 0;
00456 
00457 #if OCI_VERSION_COMPILE >= OCI_9_0
00458 
00459     OCI_CALL4
00460     (
00461         res, itv->err, itv->con,
00462         
00463         OCIIntervalGetDaySecond((dvoid *) OCILib.env, itv->err,
00464                                 (sb4 *) day, (sb4 *) hour, (sb4 *) min,
00465                                 (sb4 *) sec, (sb4 *) fsec, itv->handle)
00466     )
00467     
00468 #else
00469 
00470     OCI_NOT_USED(day);
00471     OCI_NOT_USED(hour);
00472     OCI_NOT_USED(min);    
00473     OCI_NOT_USED(sec);    
00474     OCI_NOT_USED(fsec);    
00475 
00476 #endif
00477 
00478     OCI_RESULT(res);
00479 
00480     return res;
00481 }
00482 
00483 /* ------------------------------------------------------------------------ *
00484  * OCI_IntervalGetYearMonth
00485  * ------------------------------------------------------------------------ */
00486 
00487 boolean OCI_API OCI_IntervalGetYearMonth(OCI_Interval *itv, int *year, int *month)
00488 {
00489     boolean res = FALSE;
00490 
00491     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv, FALSE);
00492     OCI_CHECK_PTR(OCI_IPC_INT, year,  FALSE);
00493     OCI_CHECK_PTR(OCI_IPC_INT, month, FALSE);
00494  
00495     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00496 
00497     *year  = 0;
00498     *month = 0;
00499 
00500 #if OCI_VERSION_COMPILE >= OCI_9_0
00501 
00502     OCI_CALL4
00503     (
00504         res, itv->err, itv->con,
00505         
00506         OCIIntervalGetYearMonth((dvoid *) OCILib.env, itv->err,
00507                                 (sb4 *) year, (sb4 *) month, itv->handle)
00508     )
00509     
00510 #else
00511 
00512     OCI_NOT_USED(year);
00513     OCI_NOT_USED(month);
00514 
00515 #endif
00516 
00517     OCI_RESULT(res);
00518 
00519     return res;
00520 }
00521 
00522 /* ------------------------------------------------------------------------ *
00523  * OCI_IntervalSetDaySecond
00524  * ------------------------------------------------------------------------ */
00525 
00526 boolean OCI_API OCI_IntervalSetDaySecond(OCI_Interval *itv, int day,int hour,
00527                                          int min, int sec, int fsec)
00528 {
00529     boolean res = TRUE;
00530 
00531     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv, FALSE);
00532     
00533     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00534 
00535 #if OCI_VERSION_COMPILE >= OCI_9_0
00536 
00537     OCI_CALL4
00538     (
00539         res, itv->err, itv->con,
00540         
00541         OCIIntervalSetDaySecond((dvoid *) OCILib.env, itv->err,
00542                                 (sb4) day, (sb4) hour, (sb4) min,
00543                                 (sb4) sec, (sb4) fsec, itv->handle)
00544     )
00545     
00546 #else
00547 
00548     OCI_NOT_USED(day);
00549     OCI_NOT_USED(hour);
00550     OCI_NOT_USED(min);    
00551     OCI_NOT_USED(sec);    
00552     OCI_NOT_USED(fsec);    
00553 
00554 #endif
00555 
00556     OCI_RESULT(res);
00557 
00558     return res;
00559 }
00560 
00561 /* ------------------------------------------------------------------------ *
00562  * OCI_IntervalSetYearMonth
00563  * ------------------------------------------------------------------------ */
00564 
00565 boolean OCI_API OCI_IntervalSetYearMonth(OCI_Interval *itv, int year, int month)
00566 {
00567     boolean res = TRUE;
00568 
00569     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv, FALSE);
00570     
00571     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00572 
00573 #if OCI_VERSION_COMPILE >= OCI_9_0
00574 
00575     OCI_CALL4
00576     (
00577         res, itv->err, itv->con,
00578         
00579         OCIIntervalSetYearMonth((dvoid *) OCILib.env, itv->err,
00580                                 (sb4) year, (sb4) month, itv->handle)
00581     )
00582     
00583 #else
00584 
00585     OCI_NOT_USED(year);
00586     OCI_NOT_USED(month);
00587 
00588 #endif
00589 
00590     OCI_RESULT(res);
00591 
00592     return res;
00593 }
00594 
00595 /* ------------------------------------------------------------------------ *
00596  * OCI_IntervalAdd
00597  * ------------------------------------------------------------------------ */
00598 
00599 boolean OCI_API OCI_IntervalAdd(OCI_Interval *itv, OCI_Interval *itv2)
00600 {
00601     boolean res = FALSE;
00602 
00603     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv,  FALSE);
00604     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv2, FALSE);
00605 
00606     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00607 
00608 #if OCI_VERSION_COMPILE >= OCI_9_0
00609 
00610     OCI_CALL4
00611     (
00612         res, itv->err, itv->con,
00613         
00614         OCIIntervalAdd((dvoid *) OCILib.env, itv->err,
00615                                   itv->handle, itv2->handle, itv->handle)
00616     )
00617 
00618 #endif
00619 
00620     OCI_RESULT(res);
00621 
00622     return res;
00623 }
00624 
00625 /* ------------------------------------------------------------------------ *
00626  * OCI_IntervalSubtract
00627  * ------------------------------------------------------------------------ */
00628 
00629 boolean OCI_API OCI_IntervalSubtract(OCI_Interval *itv, OCI_Interval *itv2)
00630 {
00631     boolean res = FALSE;
00632 
00633     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv,  FALSE);
00634     OCI_CHECK_PTR(OCI_IPC_INTERVAL, itv2, FALSE);
00635     
00636     OCI_CHECK_INTERVAL_ENABLED(itv->con, FALSE);
00637 
00638 #if OCI_VERSION_COMPILE >= OCI_9_0
00639 
00640     OCI_CALL4
00641     (
00642         res, itv->err, itv->con,
00643         
00644         OCIIntervalSubtract((dvoid *) OCILib.env, itv->err,
00645                                       itv->handle, itv2->handle, itv->handle)
00646     )
00647 
00648 #endif
00649 
00650     OCI_RESULT(res);
00651 
00652     return res;
00653 }

Generated on Thu Jul 30 17:41:52 2009 for OCILIB (C Driver for Oracle) by  doxygen 1.5.4