• Main Page
  • Modules
  • Data Structures
  • Files
  • File List

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

Generated on Sun Oct 24 2010 22:02:54 for OCILIB (C Driver for Oracle) by  doxygen 1.7.1