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