| TerraLib 4.1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files
- Examples

- File List
- File Members

E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/drivers/Oracle/OCI/include/orl.h
Go to the documentation of this file.

    00001 /* Copyright (c) 1993, 2003, Oracle Corporation.  All rights reserved.  */
    00002
    00003 /*
    00004   Author:             Srinath Krishnaswamy
    00005   Date:               11/24/93
    00006   Source documents:   "Functional Specification for C Language Mapping of
    00007                       OTS Types, Object Management Subsystem", "Oracle C
    00008                       Coding Standards version 2.2", and the header file
    00009                       template
    00010   Rule sets:          the generic and .h file rule sets
    00011   Quality status:     not exited
    00012   Identification tag: [ one or more letters to identify the .h file ]
    00013   Revision code:      11/24/93
    00014
    00015   NAME
    00016
    00017     ORL - ORacle's external C Language interface to primitive OTS types
    00018
    00019   DESCRIPTION
    00020
    00021     This header file contains C langauge interface to the OTS primitive
    00022     types. The interface includes C mapping of OTS primitive types and
    00023     the prototype of the pre-defined operations on the primitive types.
    00024
    00025     ***********************************************************************
    00026     *** NOTE: The OCI functions for objects requires the                ***
    00027     ***       application to be running in OBJECT mode. That is, during ***
    00028     ***       process initialization OCIInitialize(), the mode          ***
    00029     ***       specified should be OBJECT mode.                          ***
    00030     **                OCIInitialize(OCI_OBJECT, ..);                    ***
    00031     ***********************************************************************
    00032
    00033   RELATED DOCUMENTS
    00034
    00035     [1] Krishnaswamy, Srinath and Nguyen, Tin A., "Functional Specification
    00036         for C Language Mapping of OTS Types, Object Management Subsystem",
    00037         March 1994.
    00038     [2] Nguyen, Tin A., "The Open Type System", Oracle Corporation,
    00039         February 1994.
    00040     [3] Klein, Jonathan D., "Large Field Management", Oracle Corporation,
    00041         October 1993.
    00042
    00043   PUBLIC FUNCTIONS
    00044
    00045     OCI - OCI functions to manipulate Oracle Number, float and decimal
    00046       ARITHMETIC
    00047         OCINumberInc - OCINumber INCrement (optimized)
    00048         OCINumberDec - OCINumber DECrement (optimized)
    00049         OCINumberAdd - OCINumber ADD numbers
    00050         OCINumberSub - OCINumber SUBtract numbers
    00051         OCINumberMul - OCINumber MULtiply numbers
    00052         OCINumberDiv - OCINumber DIVide numbers
    00053         OCINumberMod - OCINumber MODulo division
    00054         OCINumberIntPower - OCINumber integer PoWeR
    00055         OCINumberShift - OCINumber decimal ShiFT number
    00056         OCINumberNeg - OCINumber NEGate number
    00057         OCINumberAbs - OCINumber ABSolute value
    00058         OCINumberCeil - OCINumber CEiling of number
    00059         OCINumberFloor - OCINumber FLooR of number
    00060         OCINumberSqrt - OCINumber SQuare Root of number
    00061         OCINumberSign - OCINumber get SIGN of number
    00062       NATIVE TYPE CONVERSION
    00063         OCINumberToInt  - OCINumber convert number TO machine-format Integer
    00064         OCINumberFromInt - OCINumber convert machine-format Integer TO Number
    00065         OCINumberToReal  - OCINumber convert number TO machine-format Real
    00066         OCINumberToRealArray  - OCINumber convert array of numbers TO
    00067                                 machine-format Real
    00068         OCINumberFromReal - OCINumber convert machine-format Real TO Number
    00069       TEXT STRING CONVERSION
    00070         OCINumberToText  - OCINumber convert number TO String
    00071         OCINumberFromText - OCINumber convert String TO Number
    00072       COMPARISON
    00073         OCINumberCmp - OCINumber CoMPare numbers
    00074         OCINumberIsZero - OCINumber comparison with ZERo
    00075         OCINumberIsInt - OCINumber Is an Integer
    00076       ASSIGNMENT
    00077         OCINumberAssign - OCINumber ASsiGn number
    00078         OCINumberSetZero - OCINumber Set number to Zero value
    00079         OCINumberSetPi - OCINumber Set number to Pi
    00080       ROUNDING
    00081         OCINumberTrunc - OCINumber TRUncate an Oracle number
    00082         OCINumberRound - OCINumber ROUnd number
    00083         OCINumberPrec - OCINumber round to Precision digits
    00084       TRANSCENDENTAL
    00085         OCINumberSin - OCINumber SINe
    00086         OCINumberArcSin - OCINumber Arc SINe
    00087         OCINumberHypSin - OCINumber SiNe Hyperbolic
    00088         OCINumberCos - OCINumber COSine
    00089         OCINumberArcCos - OCINumber Arc COSine
    00090         OCINumberHypCos - OCINumber CoSine Hyperbolic
    00091         OCINumberTan - OCINumber TANgent
    00092         OCINumberArcTan - OCINumber Arc TANgent
    00093         OCINumberArcTan2 - OCINumber Arc TaNgent 2
    00094         OCINumberHypTan - OCINumber TaNgent Hyperbolic
    00095         OCINumberPower - OCINumber arbitrary Base EXponentiation
    00096         OCINumberExp - OCINumber EXPonentiation to base e
    00097         OCINumberLn  - OCINumber Logarithm Natural
    00098         OCINumberLog - OCINumber LOGarithm to arbitrary base
    00099
    00100     OCIDate - OCI functions to manipulate OCI Date
    00101       OCIDateToExternal - OCIDate convert date to external form
    00102       OCIDateFromExternal - OCIDate convert external form of date into OCIDate
    00103       OCIDateAssign - OCIDate Assignment
    00104       OCIDateToText  - OCIDate convert date TO String
    00105       OCIDateFromText - OCIDate convert String TO Date
    00106       OCIDateZoneToZone - OCIDate convert date from one time
    00107                         Zone TO another Zone
    00108       OCIDateCompare - OCIDate CoMPare dates
    00109       OCIDateAddMonths - OCIDate ADd or subtract Months
    00110       OCIDateAddDays - OCIDate ADd or subtract Days
    00111       OCIDateLastDay - OCIDate get date of LaST day of month
    00112       OCIDateDaysBetween - OCIDate get number of days BeTWeen two dates
    00113       OCIDateNextDay - OCIDate get date of Next DaY
    00114       OCIDateCheck - OCIDate CHecK if the given date is valid
    00115       OCIDateSysDate - OCIDate get current SYStem date and time
    00116
    00117     OCIString - OCI String functions to manipulate Variable-length string
    00118       OCIStringAssign - OCIString Assign string to string
    00119       OCIStringAssignText - OCIString Assign Text string to string
    00120       OCIStringResize - OCIString ReSiZe string
    00121       OCIStringSize - OCIString get String Size
    00122       OCIStringPtr - OCIString get String PoinTeR
    00123       OCIStringAllocSize - OCIString get Allocated SiZe
    00124
    00125     OCIRaw - OCI Raw functions to manipulate variable-length raW
    00126       OCIRawAssignRaw - OCIRaw Assign Raw (of type OCIRaw*) to raw
    00127                         (of type OCIRaw*)
    00128       OCIRawResize - OCIRaw Resize raw
    00129       OCIRawSize - OCIRaw get Raw Size
    00130       OCIRawPtr  - OCIRaw get Raw data Pointer
    00131       OCIRawAllocSize - OCIRaw get Allocated Size
    00132
    00133     OCIColl - OCI Collection generic functions. These functions can be
    00134                 used to manipulate both variable-length array (varray) and
    00135                 nested table.
    00136       OCICollSize  - OCIColl return current SIZe of the given collection
    00137                 (in number of elements)
    00138       OCICollMax  - OCIColl return the MAXimum number of elements in the
    00139                 collection (i.e. upper-bound)
    00140       OCICollGetElem  - OCIColl GET pointer to the element at the given
    00141                 position
    00142       OCICollAssignElem  - OCIColl assign to element at given index
    00143       OCICollAssign  - OCIColl ASsiGn collection; perform deep-copy of source
    00144                 collection to target collection
    00145       OCICollAppend  - OCIColl aPPend the given element to the end of the
    00146                 collection
    00147       OCICollTrim  - OCIColl trim (delete) the given number of elements
    00148                 from the end of the collection
    00149       OCICollIsLocator - OCIColl indicates whether a collection is locator
    00150                          based or not.
    00151       OCIIterCreate  - OCIColl Create an ITerator to scan the collection
    00152                 elements
    00153       OCIIterDelete  - OCIColl Delete ITerator
    00154       OCIIterInit  - OCIColl Initialize ITerator to scan the given collection
    00155       OCIIterGetCurrent - OCIColl Iterator based, get CURrent
    00156                 collection element
    00157       OCIIterNext - OCIColl Iterator based, get NeXT collection element
    00158       OCIIterPrev - OCIColl Iterator based, get PReVious collection element
    00159
    00160       OCITable - OCI functions to manipulate nested Table. The OCIColl*() and
    00161                 OCITable*() functions can be used to manipulate nested table
    00162       OCITableDelete(i) - OCITable if element(i) exists then the element is
    00163                 marked as deleted else the function returns false. So
    00164                 delete's create "holes".
    00165       OCITableExists(i) - OCITable return true iff an element at
    00166                 position i EXIsts
    00167       OCITableFirst  - OCITable return the smallest value of i for which
    00168                 exists(i) is true.
    00169       OCITableLast  - OCITable return the largest value of i for which
    00170                 exists(i) is true.
    00171       OCITableNext(i) - OCITable return pointer to the smallest position j,
    00172                 greater than i, such that OCITableExists(j) is true
    00173       OCITablePrev(i) - OCITable return pointer to the largest position j,
    00174                 less than i, such that OCITableExists(j) is true
    00175       OCITableSize - OCITable return current SIZe of the given nested table not
    00176                 including deleted elements
    00177
    00178     OCIRef - OCI functions to manipulate object Reference
    00179       OCIRefClear  - OCIRef CLeaR or nullify a ref
    00180       OCIRefAssign  - OCIRef ASsiGn a ref to another
    00181       OCIRefIsEqual  - OCIRef compare two refs for EQUality
    00182       OCIRefIsNull  - OCIRef test if a ref is NULl
    00183       OCIRefFromHex  - OCIRef convert a Hexadecimal string TO a Ref
    00184       OCIRefToHex   - OCIRef convert a ref to a Hexadecimal string
    00185       OCIRefHexSize  - OCIRef get size of buffer in bytes to store hexadecimal
    00186                 string
    00187
    00188   OBSOLETE: to be replaced by functions from oci.h:
    00189
    00190     ORLL - ORL functions to manipulate lob Locators
    00191       orllasg   - ORLL AsiGn one locator to another
    00192       orllequ   - ORLL compare two locators for EQUality
    00193       orlliini  - ORLL Is the locator INItialized?
    00194       orllgsz   - ORLL Get locator SiZe
    00195       orllgcid  - ORLL Get Character set ID
    00196
    00197       NOTE: The following are specific to FILE lobs:
    00198
    00199       orllsnm - ORLL Set directory alias and file NaMe in the locator
    00200       orllgnm - ORLL Get directory alias and file NaMe from the locator
    00201
    00202   EXAMPLES
    00203
    00204     Examples are given in the description of each function where
    00205     relevant.
    00206
    00207   NOTES
    00208
    00209     This file has been subsetted to contain ONLY the routines that will
    00210     be in the first release.
    00211
    00212   QUESTIONS
    00213
    00214   MODIFIED
    00215     srseshad   03/12/03 - convert oci public api to ansi
    00216     rpingte    11/21/02 - Add OCICollGetElemArray and OCINumberToRealArray
    00217     aahluwal   06/03/02 - bug 2360115
    00218     gayyappa   02/01/02 - fix 2210776 : change Dom to DOM
    00219     whe        09/25/01 - add OCIXMLType & OCIDomDocument opaque types
    00220     bpalaval   02/09/01   - Change text to oratext.
    00221     rkasamse   09/20/99 -   lint changes
    00222     whe        09/01/99 -   976457:check __cplusplus for C++ code
    00223     hsbedi     08/11/99 -   Add macro
    00224     rxgovind   10/14/98 -  make non exposed calls (OCIRowType etc) private
    00225     rxgovind   06/09/98 -  update OCIRowTypeCreate
    00226     nmantrav   05/11/98 -  add OCIRowTypeGetCount
    00227     rxgovind   03/29/98 -  add OCIRowType and OCIRowData interfaces
    00228     jwijaya    05/06/98  - add OCICollIsLocator
    00229     rxgovind   03/18/98 -  opaque types: move to kolo.h
    00230     etucker    02/02/98 -  add comments for Dec and Inc
    00231     etucker    01/29/98 -  Finish core5 integration
    00232     rxgovind   11/11/97 -  opaque types
    00233     etucker    10/28/97 -  add ORLN functions for SDK
    00234     cxcheng    07/28/97 -  remove OCILobLocator #define
    00235     skmishra   05/13/97 -  stdcc compatibility changes
    00236     skrishna   04/25/97 -  rename OCINumber*(): Exp Power TanHyp Zero Init
    00237                            TanToArc Sqr Truncate and Compare
    00238     skotsovo   03/31/97 -  remove OCILobLocatorSize
    00239     skrishna   03/25/97 -  remove orld2i and orldi2d
    00240     skrishna   03/18/97 -  fix ifdef for supporting ansi and k&r proto-types
    00241     cxcheng    02/06/97 -  take out short name support except with SLSHORTNAME
    00242     skrishna   01/06/97 -  update OCITableSize() comments
    00243     skrishna   12/27/96 -  fix OCIDateGet/OCIDateSet
    00244     skrishna   12/12/96 -  update OCICollGelElem comments
    00245     skrishna   11/07/96 -  OCICollGetElem: interface change
    00246     skrishna   11/05/96 -  add OCIDate Get/Set and OCIDateAssign
    00247     cxcheng    10/31/96 -  change OCINumberTanHyp to OCINumberHypTan
    00248     cxcheng    10/30/96 -  #define orll short names to long names
    00249     dchatter   10/26/96 -  fix some OCI file long names
    00250     cxcheng    10/24/96 -  remove unnecessary comment in front
    00251     cxcheng    10/14/96 -  disable long name mapping for LOB functions
    00252     skrishna   10/13/96 -  continue beautification
    00253     skotsovo   10/16/96 -  update ocilob names
    00254     cxcheng    10/09/96 -  add structure members in #define for date/time
    00255     cxcheng    10/09/96 -  more lint fixes
    00256     skrishna   10/09/96 -  continue beautification
    00257     cxcheng    10/09/96 -  more fixes
    00258     skrishna   10/09/96 -  change fixed-char rep. to orlvstr*
    00259     jwijaya    10/08/96 -  continue beautification
    00260     jwijaya    10/07/96 -  beautify
    00261     cxcheng    10/07/96 -  more changes
    00262     cxcheng    10/04/96 -  replace short names with long names
    00263     skrishna   10/01/96 -  orlcsiz, orltsiz: change prototype to take errhdl
    00264     skrishna   09/23/96 -  fix lint errors
    00265     skotsovo   09/23/96 -  remove orllmkcur().
    00266     jwijaya    09/17/96 -  comments on null ref
    00267     skrishna   09/19/96 -  change orlraw format
    00268     skotsovo   09/19/96 -  add orlliini and remove orllnul
    00269     skrishna   08/14/96 -  orlvstr: change format to ub4 followed by text
    00270     jboonleu   08/06/96 -  update comment
    00271     skotsovo   08/08/96 -  revert to locators instead of descriptors as input t
    00272     jboonleu   07/23/96 -  remove orlrcur
    00273     skrishna   07/06/96 -  add orltsiz
    00274     skrishna   07/05/96 -  add orld2i and orldi2d
    00275     jwijaya    07/03/96 -  add ANSI prototypes
    00276     skrishna   06/27/96 -  document default string format in orlds2d & orld2s
    00277     skrishna   06/25/96 -  change max date value
    00278     skrishna   06/18/96 -  modify orld2s() comments
    00279     skotsovo   06/13/96 -  orll functions take lob descriptors instead of locat
    00280     rxgovind   06/05/96 -  change prototype of orlrcur to take ocienvh
    00281     skrishna   05/30/96 -  support collection trimming
    00282     skrishna   05/30/96 -  remove orlralo/fre and orllalo/fre instead use
    00283                            orionew/fre
    00284     skrishna   05/28/96 -  add orlt*() and modify orla*()
    00285     skotsovo   05/23/96 -  add orlbl typedefs for pro*c
    00286     jboonleu   05/14/96 -  add orlrcur
    00287     rxgovind   05/08/96 -  changes for 3gl callbacks
    00288     skotsovo   05/01/96 -  in orllasg, no need to alloc orlbl*
    00289     skrishna   04/21/96 -  merge changes from 960418 object branch into big
    00290     skrishna   04/17/96 -  rename orlrcpy to orlrasg
    00291     skrishna   04/12/96 -  add orlr2h and orlrh2r functions
    00292     skotsovo   04/15/96 -  add fnt to make the lob locator current
    00293     skrishna   04/08/96 -  change orl*() to take ocienvh* and ocierrh* instead
    00294                            of oroenv*
    00295     skotsovo   03/22/96 -  add locator functions
    00296     skotsovo   03/22/96 -  add locator functions
    00297     skrishna   02/27/96 -  remove mlslabel interface
    00298     skotsovo   02/20/96 -  remove orlbty and use dty type instead.
    00299     skotsovo   02/14/96 -  add text file lobs.
    00300     skrishna   01/31/96 -  update comments of orln2r, orldchk, orlds2d & orld2s
    00301     skrishna   01/31/96 -  change orld2s() and orln2s() to return string length
    00302     skrishna   01/21/96 -  remove old raw interface
    00303     skrishna   12/14/95 -  add raw interface
    00304     skotsovo   01/03/96 -  change LOB offsets and lengths from ub4 to ubig_ora
    00305                            to support 64 bit machines.
    00306     skotsovo   10/30/95 -  add orlblsiz() to get lob locator size
    00307     skrishna   10/24/95 -  move ref functions from ori and update the ref
    00308                            functions to support variable-length ref
    00309     cxcheng    10/20/95 -  add more comments on number versions
    00310     cxcheng    10/13/95 -  add more number functions
    00311     cxcheng    08/29/95 -  Support for segmented varrays
    00312     cxcheng    08/18/95 -  modifiy orlmls structure
    00313     skrishna   06/06/95 -  rename orln, orld, orlvs and orlva to orlnum,
    00314                            orldat, orlvstr and orlvary respectively
    00315     skrishna   11/15/94 -  remove orlnget() function
    00316     skrishna   09/20/94 -  modify orldbtw() to return number of days only
    00317     skrishna   08/24/94 -  change format string length type from ub4 to ub1
    00318     skrishna   07/19/94 -  Rename orln2c & orlnc2n to orln2s & orlns2n
    00319     skrishna   06/29/94 -  Add blob interface; add examples
    00320     skrishna   06/23/94 -  Update comments and format
    00321     skrishna   05/19/94 -  update varray append comments
    00322     skrishna    05/05/94 -  Subsetting
    00323     skrishna    11/24/93 -  Creation
    00324 */
    00325
    00326 #ifndef ORATYPES
    00327 #include <oratypes.h>
    00328 #endif
    00329
    00330 #ifndef ORO_ORACLE
    00331 #include <oro.h>
    00332 #endif
    00333
    00334 #ifndef ORT_ORACLE
    00335 #include <ort.h>
    00336 #endif
    00337
    00338 #ifndef OCI_ORACLE
    00339 #include <oci.h>
    00340 #endif
    00341
    00342 #ifndef ORL_ORACLE
    00343 #define ORL_ORACLE
    00344
    00345 /*---------------------------------------------------------------------------*/
    00346 /*                         SHORT NAMES SUPPORT SECTION                       */
    00347 /*---------------------------------------------------------------------------*/
    00348
    00349 #ifdef SLSHORTNAME
    00350
    00351 /* the following are short names that are only supported on IBM mainframes
    00352    with the SLSHORTNAME defined.
    00353    With this all subsequent long names will actually be substituted with
    00354    the short names here */
    00355
    00356 #define OCIArray                        orlvary
    00357 #define OCIColl                         orlcol
    00358 #define OCICollAppend                   orlcapp
    00359 #define OCICollAssign                   orlcasg
    00360 #define OCICollAssignElem               orlcase
    00361 #define OCICollGetElem                  orlcget
    00362 #define OCICollGetElemArray             orlcgeta
    00363 #define OCICollMax                      orlcmax
    00364 #define OCICollSize                     orlcsiz
    00365 #define OCICollTrim                     orlctrm
    00366 #define OCICollIsLocator                orlcilc
    00367 #define OCIDate                         orldat
    00368 #define OCIDateAddDays                  orldadd
    00369 #define OCIDateAddMonths                orldadm
    00370 #define OCIDateCheck                    orldchk
    00371 #define OCIDateCompare                  orldcmp
    00372 #define OCIDateDD                       day_orldat
    00373 #define OCIDateDaysBetween              orldbtw
    00374 #define OCIDateFromText                 orlds2d
    00375 #define OCIDateLastDay                  orldlst
    00376 #define OCIDateMM                       mon_orldat
    00377 #define OCIDateNextDay                  orldndy
    00378 #define OCIDateSysDate                  orldsys
    00379 #define OCIDateTime                     time_orldat
    00380 #define OCIDateYYYY                     gye_orldat
    00381 #define OCIDateZoneToZone               orldz2z
    00382 #define OCIIter                         orlcitr
    00383 #define OCIIterCreate                   orlccit
    00384 #define OCIIterDelete                   orlcdit
    00385 #define OCIIterGetCurrent               orlcicur
    00386 #define OCIIterInit                     orlciit
    00387 #define OCIIterNext                     orlcinxt
    00388 #define OCIIterPrev                     orlciprv
    00389 #define OCINumber                       orlnum
    00390 #define OCINumberAbs                    orlnabs
    00391 #define OCINumberAdd                    orlnadd
    00392 #define OCINumberArcCos                 orlnacos
    00393 #define OCINumberArcSin                 orlnasin
    00394 #define OCINumberArcTan                 orlnatan
    00395 #define OCINumberAssign                 orlnasg
    00396 #define OCINumberCeil                   orlncel
    00397 #define OCINumberCos                    orlncos
    00398 #define OCINumberDiv                    orlndiv
    00399 #define OCINumberPower                  orlnbex
    00400 #define OCINumberFloor                  orlnflr
    00401 #define OCINumberFromInt                orlni2n
    00402 #define OCINumberFromReal               orlnr2n
    00403 #define OCINumberFromText               orlns2n
    00404 #define OCINumberHypCos                 orlncsh
    00405 #define OCINumberHypSin                 orlnsnh
    00406 #define OCINumberSetZero                orlnini
    00407 #define OCINumberSetPi                  orlnspi
    00408 #define OCINumberInc                    orlninc
    00409 #define OCINumberDec                    orlndec
    00410 #define OCINumberIntPower               orlnpwr
    00411 #define OCINumberLn                     orlnln
    00412 #define OCINumberLog                    orlnlog
    00413 #define OCINumberMod                    orlnmod
    00414 #define OCINumberMul                    orlnmul
    00415 #define OCINumberNeg                    orlnneg
    00416 #define OCINumberPart                   orlnpart
    00417 #define OCINumberExp                    orlnexp
    00418 #define OCINumberRound                  orlnrou
    00419 #define OCINumberPrec                   orlnpre
    00420 #define OCINumberShift                  orlnsft
    00421 #define OCINumberSign                   orlnsgn
    00422 #define OCINumberSin                    orlnsin
    00423 #define OCINumberSqrt                   orlnsqr
    00424 #define OCINumberSub                    orlnsub
    00425 #define OCINumberTan                    orlntan
    00426 #define OCINumberHypTan                 orlntnh
    00427 #define OCINumberArcTan2                orlnatn2
    00428 #define OCINumberToInt                  orln2i
    00429 #define OCINumberToReal                 orln2r
    00430 #define OCINumberToRealArray            orln2ra
    00431 #define OCINumberToText                 orln2s
    00432 #define OCINumberTrunc                  orlntru
    00433 #define OCINumberCmp                    orlncmp
    00434 #define OCINumberIsZero                 orlnzer
    00435 #define OCINumberIsInt                  orlnint
    00436 #define OCIRaw                          orlraw
    00437 #define OCIRawAllocSize                 orlwasz
    00438 #define OCIRawAssignBytes               orlwabr
    00439 #define OCIRawAssignRaw                 orlwarr
    00440 #define OCIRawPtr                       orlwgrp
    00441 #define OCIRawResize                    orlwrsz
    00442 #define OCIRawSize                      orlwgsz
    00443 #define OCIRefAssign                    orlrasg
    00444 #define OCIRefClear                     orlrclr
    00445 #define OCIRefFromHex                   orlrh2r
    00446 #define OCIRefHexSize                   orlrhsz
    00447 #define OCIRefIsEqual                   orlrequ
    00448 #define OCIRefIsNull                    orlrnul
    00449 #define OCIRefToHex                     orlr2h
    00450 #define OCIString                       orlvstr
    00451 #define OCIStringAllocSize              orlvasz
    00452 #define OCIStringAssign                 orlvass
    00453 #define OCIStringAssignText             orlvats
    00454 #define OCIStringPtr                    orlvgsp
    00455 #define OCIStringResize                 orlvrsz
    00456 #define OCIStringSize                   orlvgsz
    00457 #define OCITable                        orltbl
    00458 #define OCITableDelete                  orltdel
    00459 #define OCITableExists                  orltexi
    00460 #define OCITableFirst                   orltfst
    00461 #define OCITableLast                    orltlst
    00462 #define OCITableNext                    orltnxt
    00463 #define OCITablePrev                    orltprv
    00464 #define OCITableSize                    orltsiz
    00465 #define OCITime                         orldtm
    00466 #define OCITimeHH                       orldtmhh
    00467 #define OCITimeMI                       orldtmmm
    00468 #define OCITimeSS                       orldtmss
    00469 #define OCI_LOBMODE_READONLY            ORLBMORO
    00470 #define OCI_LOBMODE_READWRITE           ORLBMORW
    00471
    00472 #endif                                                        /* SLSHORTNAME */
    00473
    00474 /*****************************************************************************/
    00475 /*                         NUMBER/FLOAT/DECIMAL TYPE                         */
    00476 /*****************************************************************************/
    00477
    00478 #define OCI_NUMBER_SIZE 22
    00479 struct OCINumber
    00480 {
    00481   ub1 OCINumberPart[OCI_NUMBER_SIZE];
    00482 };
    00483 typedef struct OCINumber OCINumber;
    00484
    00485 /*
    00486  * OCINumber - OCI Number mapping in c
    00487  *
    00488  * The OTS types: NUMBER, NUMERIC, INT, SHORTINT, REAL, DOUBLE PRECISION,
    00489  * FLOAT and DECIMAL are represented by OCINumber.
    00490  * The contents of OCINumber is opaque to clients.
    00491  *
    00492  * For binding variables of type OCINumber in OCI calls (OCIBindByName(),
    00493  * OCIBindByPos(), and OCIDefineByPos()) use the type code SQLT_VNU.
    00494  */
    00495
    00496 /*
    00497    EXAMPLE
    00498
    00499    The following example shows how to manipulate an attribute of type
    00500    oracle number.
    00501
    00502      struct person
    00503      {
    00504        OCINumber sal;
    00505      };
    00506      typedef struct person person;
    00507
    00508      OCIError *err;
    00509      person* joe;
    00510      person* tom;
    00511      person* debbie;
    00512      OCINumber  *joesal;
    00513      OCINumber  *tomsal;
    00514      OCINumber *debsal;
    00515      sword   status;
    00516      int     inum;
    00517      double  dnum;
    00518      OCINumber ornum;
    00519      char    buffer[21];
    00520      ub4     buflen;
    00521      sword   result;
    00522
    00523      /o See oci.h for an example of how to initialize OCIError.
    00524       o For this example, assume the OCIEnv and OCIError has been
    00525       o initialized.
    00526       o/
    00527
    00528      /o Pin joe, tom and debbie person objects in the object cache. See ori.h
    00529       o for an example on pinning objects. For this example, assume that
    00530       o joe, tom and debbie are pointing to pinned objects.
    00531       o/
    00532      joesal = &joe->sal;
    00533      tomsal = &tom->sal;
    00534      debsal = &debbie->sal;
    00535
    00536      /o initialize joe's salary to be $12,000 o/
    00537      inum = 12000;
    00538      status = OCINumberFromInt(err, &inum, sizeof(inum), OCI_NUMBER_SIGNED,
    00539                                joesal);
    00540      if (status != OCI_SUCCESS)
    00541                               /o goto to handle error from OCINumberFromInt o/;
    00542
    00543      /o initialize tom's salary to be same as joe o/
    00544      OCINumberAssign(err, joesal, tomsal);
    00545
    00546      /o initialize debbie's salary to be 20% more than joe's o/
    00547      dnum = 1.2;
    00548      status = OCINumberFromReal(err, &dnum, sizeof(double), &ornum);
    00549      if (status != OCI_SUCCESS)
    00550                             /o goto to handle error from OCINumberFromReal o/;
    00551      status = OCINumberMul(err, joesal, &ornum, debsal);
    00552      if (status != OCI_SUCCESS)  /o goto to handle error from OCINumberMul o/;
    00553
    00554      /o give tom a 50% raise o/
    00555      dnum = 1.5;
    00556      status = OCINumberFromReal(err, &dnum, sizeof(double), &ornum);
    00557      if (status != OCI_SUCCESS)
    00558                             /o goto to handle error from OCINumberFromReal o/;
    00559      status = OCINumberMul(err, tomsal, &ornum, tomsal);
    00560      if (status != OCI_SUCCESS)  /o goto to handle error from OCINumberMul o/;
    00561
    00562      /o double joe's salary o/
    00563      status = OCINumberAdd(err, joesal, joesal, joesal);
    00564      if (status != OCI_SUCCESS)  /o goto to handle error from OCINumberAdd o/;
    00565
    00566      /o get joe's salary in integer o/
    00567      status = OCINumberToInt(err, joesal, sizeof(inum), OCI_NUMBER_SIGNED,
    00568                              &inum);
    00569      if (status != OCI_SUCCESS)/o goto to handle error from OCINumberToInt o/;
    00570      /o inum is set to 24000 o/
    00571
    00572      /o get debbie's salary in double o/
    00573      status = OCINumberToReal(err, debsal, sizeof(dnum), &dnum);
    00574      if (status != OCI_SUCCESS)/o goto to handle error from OCINumberToReal o/;
    00575      /o dnum is set to 14400 o/
    00576
    00577      /o print tom's salary as DEM0001`8000.00 o/
    00578      buflen = sizeof(buffer);
    00579      status = OCINumberToText(err, tomsal, "C0999G9999D99", 13,
    00580                  "NLS_NUMERIC_CHARACTERS='.`' NLS_ISO_CURRENCY='Germany'", 54,
    00581                  &buflen, buffer);
    00582      if (status != OCI_SUCCESS)/o goto to handle error from OCINumberToText o/;
    00583      printf("tom's salary = %s\n", buffer);
    00584
    00585      /o compare joe and tom's salary o/
    00586      status = OCINumberCmp(err, joesal, tomsal, &result);
    00587      if (status != OCI_SUCCESS)  /o goto to handle error from OCINumberCmp o/;
    00588      /o result is positive o/
    00589
    00590      /o read debbie's new salary from string o/
    00591      status = OCINumberFromText(err, "48`000.00", 9, "99G999D99", 9,
    00592                       "NLS_NUMERIC_CHARACTERS='.`'", 27, debsal);
    00593      if (status != OCI_SUCCESS)
    00594                             /o goto to handle error from OCINumberFromText o/;
    00595      /o debbie's salary is now 48000.00 o/
    00596
    00597 */
    00598
    00599 /*----------------------------- OCINumberInc --------------------------------*/
    00600
    00601 sword OCINumberInc(    OCIError *err, OCINumber *number    );
    00602 /*
    00603    NAME: OCINumberInc - OCINumber INCrement numbers
    00604    PARAMETERS:
    00605         err (IN/OUT) - error handle. If there is an error, it is
    00606                 recorded in 'err' and this function returns OCI_ERROR.
    00607                 The error recorded in 'err' can be retrieved by calling
    00608                 OCIErrorGet().
    00609         number (IN/OUT) a positive Oracle number to be incremented
    00610    DESCRIPTION:
    00611         Increment Oracle number in place. It is assumed that the input is
    00612         an integer between 0 and 100^21-2. If the is input too large, it will
    00613         be treated as 0 - the result will be an Oracle number 1. If the input
    00614         is not a positive integer, the result will be unpredictable.
    00615    RETURNS:
    00616         OCI_SUCCESS if the function completes successfully.
    00617         OCI_INVALID_HANDLE if 'err' is NULL.
    00618         OCI_ERROR if
    00619           any of the number arguments is null
    00620  */
    00621
    00622 /*----------------------------- OCINumberDec --------------------------------*/
    00623
    00624 sword OCINumberDec(    OCIError *err, OCINumber *number    );
    00625 /*
    00626    NAME: OCINumberDec - OCINumber DECrement numbers
    00627    PARAMETERS:
    00628         err (IN/OUT) - error handle. If there is an error, it is
    00629                 recorded in 'err' and this function returns OCI_ERROR.
    00630                 The error recorded in 'err' can be retrieved by calling
    00631                 OCIErrorGet().
    00632         number (IN/OUT) - a positive Oracle number to be decremented
    00633    DESCRIPTION:
    00634         Decrement Oracle number in place. It is assumed that the input is an
    00635         integer between 1 and 100^21-2. If the input is too large, it will be
    00636         treated as 1 - the result will be an Oracle number 0. If the input is
    00637         not a positive integer, the result will be unpredictable.
    00638    RETURNS:
    00639         OCI_SUCCESS if the function completes successfully.
    00640         OCI_INVALID_HANDLE if 'err' is NULL.
    00641         OCI_ERROR if
    00642           any of the number arguments is null
    00643  */
    00644
    00645 /*-------------------------- OCINumberSetZero -------------------------------*/
    00646
    00647 void OCINumberSetZero(    OCIError *err, OCINumber *num    );
    00648 /*
    00649    NAME: OCINumberSetZero - OCINumber Set number to Zero value
    00650    PARAMETERS:
    00651         err (IN/OUT) - pointer to OCI error handle
    00652         num (OUT) - set to zero value
    00653    DESCRIPTION:
    00654         Initialize the given number to value 0.
    00655  */
    00656
    00657 /*--------------------------- OCINumberSetPi --------------------------------*/
    00658
    00659 void OCINumberSetPi(    OCIError *err, OCINumber *num    );
    00660 /*
    00661    NAME: OCINumberSetPi - OCINumber Set number to Pi
    00662         err (IN/OUT) - pointer to OCI error handle
    00663         num (OUT) - set to zero value
    00664    DESCRIPTION:
    00665         Initialize the given number to value Pi.
    00666  */
    00667
    00668 /*----------------------------- OCINumberAdd --------------------------------*/
    00669
    00670 sword OCINumberAdd(    OCIError *err, CONST OCINumber *number1,
    00671                        CONST OCINumber *number2, OCINumber *result    );
    00672 /*
    00673    NAME: OCINumberAdd - OCINumber ADD numbers
    00674    PARAMETERS:
    00675         err (IN/OUT) - error handle. If there is an error, it is
    00676                 recorded in 'err' and this function returns OCI_ERROR.
    00677                 The error recorded in 'err' can be retrieved by calling
    00678                 OCIErrorGet().
    00679         number1, number2 (IN) - numbers to be added
    00680         result (OUT) - result of adding 'number1' with 'number2'
    00681    DESCRIPTION:
    00682         Add 'number1' with 'number2' and return result in 'result'.
    00683    RETURNS:
    00684         OCI_SUCCESS if the function completes successfully.
    00685         OCI_INVALID_HANDLE if 'err' is NULL.
    00686         OCI_ERROR if
    00687           any of the number arguments is null
    00688  */
    00689
    00690 /*----------------------------- OCINumberSub --------------------------------*/
    00691
    00692 sword OCINumberSub(    OCIError *err, CONST OCINumber *number1,
    00693                        CONST OCINumber *number2, OCINumber *result    );
    00694 /*
    00695    NAME: OCINumberSub - OCINumber SUBtract numbers
    00696    PARAMETERS:
    00697         err (IN/OUT) - error handle. If there is an error, it is
    00698                 recorded in 'err' and this function returns OCI_ERROR.
    00699                 The error recorded in 'err' can be retrieved by calling
    00700                 OCIErrorGet().
    00701         number1, number2 (IN) - 'number2' subtracted from 'number1'
    00702         result (OUT) - subtraction result
    00703    DESCRIPTION:
    00704         Subtract 'number2' from 'number1' and return result in 'result'.
    00705    RETURNS:
    00706         OCI_SUCCESS if the function completes successfully.
    00707         OCI_INVALID_HANDLE if 'err' is NULL.
    00708         OCI_ERROR if
    00709           any of the number arguments is null
    00710  */
    00711
    00712 /*----------------------------- OCINumberMul --------------------------------*/
    00713
    00714 sword OCINumberMul(    OCIError *err, CONST OCINumber *number1,
    00715                        CONST OCINumber *number2, OCINumber *result    );
    00716 /*
    00717    NAME: OCINumberMul - OCINumber MULtiply numbers
    00718    PARAMETERS:
    00719         err (IN/OUT) - error handle. If there is an error, it is
    00720                 recorded in 'err' and this function returns OCI_ERROR.
    00721                 The error recorded in 'err' can be retrieved by calling
    00722                 OCIErrorGet().
    00723         number1, number2 (IN) - numbers to be multiplied
    00724         result (OUT) - multiplication result
    00725    DESCRIPTION:
    00726         Multiply 'number1' with 'number2' and return result in 'result'.
    00727    RETURNS:
    00728         OCI_SUCCESS if the function completes successfully.
    00729         OCI_INVALID_HANDLE if 'err' is NULL.
    00730         OCI_ERROR if
    00731           any of the number arguments is null
    00732  */
    00733
    00734 /*----------------------------- OCINumberDiv --------------------------------*/
    00735
    00736 sword OCINumberDiv(    OCIError *err, CONST OCINumber *number1,
    00737                        CONST OCINumber *number2, OCINumber *result    );
    00738 /*
    00739    NAME: OCINumberDiv - OCINumber DIVide numbers
    00740    PARAMETERS:
    00741         err (IN/OUT) - error handle. If there is an error, it is
    00742                 recorded in 'err' and this function returns OCI_ERROR.
    00743                 The error recorded in 'err' can be retrieved by calling
    00744                 OCIErrorGet().
    00745         number1 (IN) - pointer to the numerator
    00746         number2 (IN) - pointer to the denominator
    00747         result (OUT) - division result
    00748    DESCRIPTION:
    00749         Divide 'number1' by 'number2' and return result in 'result'.
    00750    RETURNS:
    00751         OCI_SUCCESS if the function completes successfully.
    00752         OCI_INVALID_HANDLE if 'err' is NULL.
    00753         OCI_ERROR if
    00754           any of the number arguments is null
    00755           underflow errorr
    00756           overflow errorr
    00757           divide by zero errorr
    00758  */
    00759
    00760 /*----------------------------- OCINumberMod --------------------------------*/
    00761
    00762 sword OCINumberMod(    OCIError *err, CONST OCINumber *number1,
    00763                        CONST OCINumber *number2, OCINumber *result    );
    00764 /*
    00765    NAME: OCINumberMod - OCINumber MODulous
    00766    PARAMETERS:
    00767         err (IN/OUT) - error handle. If there is an error, it is
    00768                 recorded in 'err' and this function returns OCI_ERROR.
    00769                 The error recorded in 'err' can be retrieved by calling
    00770                 OCIErrorGet().
    00771         number1 (IN) - pointer to the numerator
    00772         number2 (IN) - pointer to the denominator
    00773         result (OUT) - remainder of the result
    00774    DESCRIPTION:
    00775         Finds the remainder of the division of two Oracle numbers.
    00776    RETURNS:
    00777         OCI_SUCCESS if the function completes successfully.
    00778         OCI_INVALID_HANDLE if 'err' is NULL.
    00779         OCI_ERROR if
    00780           any of the number arguments is null
    00781           divide by zero errorr
    00782  */
    00783
    00784 /*------------------------ OCINumberIntPower --------------------------------*/
    00785
    00786 sword OCINumberIntPower(    OCIError *err, CONST OCINumber *base,
    00787                             CONST sword exp, OCINumber *result    );
    00788 /*
    00789    NAME: OCINumberIntPower - OCINumber takes an arbitary base to an arbitary
    00790                              integer PoWeR
    00791    PARAMETERS:
    00792         err (IN/OUT) - error handle. If there is an error, it is
    00793                 recorded in 'err' and this function returns OCI_ERROR.
    00794                 The error recorded in 'err' can be retrieved by calling
    00795                 OCIErrorGet().
    00796         base (IN) - base of the exponentiation
    00797         exp (IN) - exponent to which the base is to be raised
    00798         result (OUT) - output of exponentiation
    00799    DESCRIPTION:
    00800         Takes an arbitary base to an arbitary integer power.
    00801    RETURNS:
    00802         OCI_SUCCESS if the function completes successfully.
    00803         OCI_INVALID_HANDLE if 'err' is NULL.
    00804         OCI_ERROR if
    00805           any of the number arguments is null
    00806  */
    00807
    00808 /*-------------------------- OCINumberShift ---------------------------------*/
    00809
    00810 sword OCINumberShift(    OCIError *err, CONST OCINumber *number,
    00811                             CONST sword nDig, OCINumber *result    );
    00812 /*
    00813    NAME: OCINumberShift - OCINumber multiplies by a power of 10.
    00814
    00815    PARAMETERS:
    00816         err (IN/OUT) - error handle. If there is an error, it is
    00817                 recorded in 'err' and this function returns OCI_ERROR.
    00818                 The error recorded in 'err' can be retrieved by calling
    00819                 OCIErrorGet().
    00820         number (IN) - Oracle Number to be shifted.
    00821         nDig   (IN) - number of decimal places to shift.
    00822         result (OUT) - shift result.
    00823    DESCRIPTION:
    00824         Multiplies number by 10^NDig and sets product to the result.
    00825    RETURNS:
    00826         OCI_SUCCESS if the function completes successfully.
    00827         OCI_INVALID_HANDLE if 'err' is NULL.
    00828         OCI_ERROR if
    00829           any of the number arguments is null
    00830  */
    00831
    00832 /*----------------------------- OCINumberNeg --------------------------------*/
    00833
    00834 sword OCINumberNeg(    OCIError *err, CONST OCINumber *number,
    00835                        OCINumber *result    );
    00836 /*
    00837    NAME: OCINumberNeg - OCINumber NEGate number
    00838    PARAMETERS:
    00839         err (IN/OUT) - error handle. If there is an error, it is
    00840                 recorded in 'err' and this function returns OCI_ERROR.
    00841                 The error recorded in 'err' can be retrieved by calling
    00842                 OCIErrorGet().
    00843         number (IN) - number to be negated
    00844         result (OUT) - will contain negated value of 'number'
    00845    DESCRIPTION:
    00846         Negates an Oracle number.
    00847    RETURNS:
    00848         OCI_SUCCESS if the function completes successfully.
    00849         OCI_INVALID_HANDLE if 'err' is NULL.
    00850         OCI_ERROR if
    00851           any of the number arguments is null
    00852  */
    00853
    00854 /*------------------------- OCINumberToText ---------------------------------*/
    00855
    00856 sword OCINumberToText(    OCIError *err, CONST OCINumber *number,
    00857                           CONST oratext *fmt, ub4 fmt_length,
    00858                           CONST oratext *nls_params, ub4 nls_p_length,
    00859                           ub4 *buf_size, oratext *buf    );
    00860 /*
    00861    NAME: OCINumberToText - OCINumber convert number TO String
    00862    PARAMETERS:
    00863         err (IN/OUT) - error handle. If there is an error, it is
    00864                 recorded in 'err' and this function returns OCI_ERROR.
    00865                 The error recorded in 'err' can be retrieved by calling
    00866                 OCIErrorGet().
    00867         number (IN) - Oracle number to be converted
    00868         fmt (IN) - conversion format
    00869         fmt_length (IN) - length of the 'fmt' parameter
    00870         nls_params (IN) - nls format specification, if null string
    00871                 i.e. (oratext *)0, then the default parameters for the
    00872                 session is used
    00873         nls_p_length (IN) - length of the 'nls_params' parameter
    00874         buf_size (IN/OUT) - size of the buffer must be passed as input by
    00875                 the caller, this function will return the length of the
    00876                 resulting string in bytes via this parameter. The length
    00877                 does not include the terminating null ('\0').
    00878         buf (OUT) - buffer into which the converted string is placed. The
    00879                 resulting string is null terminated.
    00880    DESCRIPTION:
    00881         Converts the given number to a character string
    00882         according to the specified format. Refer to "TO_NUMBER" conversion
    00883         function described in "Oracle SQL Language Reference Manual" for a
    00884         description of format and NLS parameters.
    00885         The converted number string is stored in the buffer 'buf', up to
    00886         a max of '*buf_size' bytes. Length of the resulting string is
    00887         returned via 'buf_size'.
    00888    RETURNS:
    00889         OCI_SUCCESS if the function completes successfully.
    00890         OCI_INVALID_HANDLE if 'err' is NULL.
    00891         OCI_ERROR if
    00892           'number' or 'buf' is null
    00893           buffer too small
    00894           invalid format
    00895           invalid nls format
    00896           number to text translation for the given format causes overflow
    00897  */
    00898
    00899 /*-------------------------- OCINumberFromText ------------------------------*/
    00900
    00901 sword OCINumberFromText(    OCIError *err, CONST oratext *str,
    00902                           ub4 str_length, CONST oratext *fmt, ub4 fmt_length,
    00903                           CONST oratext *nls_params, ub4 nls_p_length,
    00904                           OCINumber *number    );
    00905 /*
    00906    NAME: OCINumberFromText - OCINumber convert String TO Number
    00907    PARAMETERS:
    00908         err (IN/OUT) - error handle. If there is an error, it is
    00909                 recorded in 'err' and this function returns OCI_ERROR.
    00910                 The error recorded in 'err' can be retrieved by calling
    00911                 OCIErrorGet().
    00912         str (IN) - input string to be converted to Oracle number
    00913         str_length (IN) - size of the input string
    00914         fmt (IN) - conversion format
    00915         fmt_length (IN) - length of the 'fmt' parameter
    00916         nls_params (IN) - nls format specification, if null string
    00917                 i.e. (oratext *)0, then the default parameters for the
    00918                 session is used
    00919         nls_p_length (IN) - length of the 'nls_params' parameter
    00920         number (OUT) - given string converted to number
    00921    DESCRIPTION:
    00922         Converts the given string to a number
    00923         according to the specified format. Refer to "TO_NUMBER" conversion
    00924         function described in "Oracle SQL Language Reference Manual" for a
    00925         description of format and NLS parameters.
    00926    RETURNS:
    00927         OCI_SUCCESS if the function completes successfully.
    00928         OCI_INVALID_HANDLE if 'err' is NULL.
    00929         OCI_ERROR if
    00930           'number' or 'str' is null
    00931           'str_length' is 0
    00932           invalid format
    00933           invalid nls format
    00934           invalid input string
    00935  */
    00936
    00937 /*-------------------------- OCINumberToInt ---------------------------------*/
    00938
    00939 #define OCI_NUMBER_UNSIGNED 0                        /* Unsigned type -- ubX */
    00940 #define OCI_NUMBER_SIGNED   2                          /* Signed type -- sbX */
    00941
    00942 sword OCINumberToInt(    OCIError *err, CONST OCINumber *number,
    00943                          uword rsl_length, uword rsl_flag, dvoid *rsl    );
    00944 /*
    00945    NAME: OCINumberToInt - OCINumber convert number TO Integer
    00946    PARAMETERS:
    00947         err (IN/OUT) - error handle. If there is an error, it is
    00948                 recorded in 'err' and this function returns OCI_ERROR.
    00949                 The error recorded in 'err' can be retrieved by calling
    00950                 OCIErrorGet().
    00951         number (IN) - number to be converted
    00952         rsl_length (IN) - size of the desired result
    00953         rsl_s_flag (IN) - flag denoting the desired sign of the output; valid
    00954                 values are OCI_NUMBER_UNSIGNED, OCI_NUMBER_SIGNED
    00955         rsl (OUT) - pointer to space for the result
    00956    DESCRIPTION:
    00957         Native type conversion function.
    00958         Converts the given Oracle number into an xbx (e.g. ub2, ub4, sb2 etc.)
    00959    RETURNS:
    00960         OCI_SUCCESS if the function completes successfully.
    00961         OCI_INVALID_HANDLE if 'err' is NULL.
    00962         OCI_ERROR if
    00963           'number' or 'rsl' is null
    00964           integer value of 'number' is too big -- overflow
    00965           integer value of 'number' is too small -- underflow
    00966           invalid sign flag value ('rsl_s_flag')
    00967  */
    00968
    00969 /*--------------------------- OCINumberFromInt ------------------------------*/
    00970
    00971 sword OCINumberFromInt(    OCIError *err, CONST dvoid *inum, uword inum_length,
    00972                          uword inum_s_flag, OCINumber *number    );
    00973 /*
    00974    NAME: OCINumberFromInt - OCINumber convert Integer TO Number
    00975    PARAMETERS:
    00976         err (IN/OUT) - error handle. If there is an error, it is
    00977                 recorded in 'err' and this function returns OCI_ERROR.
    00978                 The error recorded in 'err' can be retrieved by calling
    00979                 OCIErrorGet().
    00980         inum (IN) - pointer to the integer to be converted
    00981         inum_length (IN) - size of the integer
    00982         inum_s_flag (IN) - flag that designates the sign of the integer; valid
    00983                 values are OCI_NUMBER_UNSIGNED, OCI_NUMBER_SIGNED
    00984         number (OUT) - given integer converted to Oracle number
    00985    DESCRIPTION:
    00986         Native type conversion function. Converts any Oracle standard
    00987         machine-native integer type (xbx) to an Oracle number.
    00988    RETURNS:
    00989         OCI_SUCCESS if the function completes successfully.
    00990         OCI_INVALID_HANDLE if 'err' is NULL.
    00991         OCI_ERROR if
    00992           'number' or 'inum' is null
    00993           integer too BIG -- the number is too large to fit into an Oracle
    00994                 number
    00995           invalid sign flag value ('inum_s_flag')
    00996  */
    00997
    00998 /*------------------------- OCINumberToReal ---------------------------------*/
    00999
    01000 sword OCINumberToReal(    OCIError *err, CONST OCINumber *number,
    01001                           uword rsl_length, dvoid *rsl    );
    01002 /*
    01003    NAME: OCINumberToReal - OCINumber convert number TO Real
    01004    PARAMETERS:
    01005         err (IN/OUT) - error handle. If there is an error, it is
    01006                 recorded in 'err' and this function returns OCI_ERROR.
    01007                 The error recorded in 'err' can be retrieved by calling
    01008                 OCIErrorGet().
    01009         number (IN) - number to be converted
    01010         rsl_length (IN) - is the size of the desired result,
    01011                 sizeof( float | double | long double)
    01012         rsl (OUT) - pointer to space for storing the result
    01013    DESCRIPTION:
    01014         Native type conversion function. Converts an Oracle number into a
    01015         machine-native real type. This function only converts numbers up to
    01016         LDBL_DIG, DBL_DIG, or FLT_DIG digits of precision and removes
    01017         trailing zeroes. The above constants are defined in float.h
    01018    RETURNS:
    01019         OCI_SUCCESS if the function completes successfully.
    01020         OCI_INVALID_HANDLE if 'err' is NULL.
    01021         OCI_ERROR if
    01022           'number' or 'rsl' is null
    01023           'rsl_length' is 0
    01024  */
    01025
    01026 /*------------------------- OCINumberToRealArray ----------------------------*/
    01027
    01028 sword OCINumberToRealArray(  OCIError *err, CONST OCINumber **number,
    01029                              uword elems, uword rsl_length, dvoid *rsl    );
    01030 /*
    01031    NAME: OCINumberToRealArray - OCINumber convert array of numbers TO Real
    01032    PARAMETERS:
    01033         err (IN/OUT) - error handle. If there is an error, it is
    01034                 recorded in 'err' and this function returns OCI_ERROR.
    01035                 The error recorded in 'err' can be retrieved by calling
    01036                 OCIErrorGet().
    01037         number (IN) - Pointer to array of number to be converted
    01038         elems (IN) - Upper bound of number array
    01039         rsl_length (IN) - is the size of the desired result,
    01040                                           sizeof( float | double | long double)
    01041         rsl (OUT) - pointer to array of space for storing the result
    01042    DESCRIPTION:
    01043         Native type conversion function. Converts an Oracle number into a
    01044         machine-native real type. This function only converts numbers up to
    01045         LDBL_DIG, DBL_DIG, or FLT_DIG digits of precision and removes
    01046         trailing zeroes. The above constants are defined in float.h
    01047    RETURNS:
    01048         OCI_SUCCESS if the function completes successfully.
    01049         OCI_INVALID_HANDLE if 'err' is NULL.
    01050         OCI_ERROR if
    01051           'number' or 'rsl' is null
    01052           'rsl_length' is 0
    01053  */
    01054
    01055 /*-------------------------- OCINumberFromReal ------------------------------*/
    01056
    01057 sword OCINumberFromReal(    OCIError *err, CONST dvoid *rnum,
    01058                             uword rnum_length, OCINumber *number    );
    01059 /*
    01060    NAME: OCINumberFromReal - OCINumber convert Real TO Number
    01061    PARAMETERS:
    01062         err (IN/OUT) - error handle. If there is an error, it is
    01063                 recorded in 'err' and this function returns OCI_ERROR.
    01064                 The error recorded in 'err' can be retrieved by calling
    01065                 OCIErrorGet().
    01066         rnum (IN) - pointer to the floating point number to be converted
    01067         rnum_length (IN) - size of the desired result, i.e.
    01068                 sizeof({float | double | long double})
    01069         number (OUT) - given float converted to Oracle number
    01070    DESCRIPTION:
    01071         Native type conversion function. Converts a machine-native floating
    01072         point type to an Oracle number.
    01073    RETURNS:
    01074         OCI_SUCCESS if the function completes successfully.
    01075         OCI_INVALID_HANDLE if 'err' is NULL.
    01076         OCI_ERROR if
    01077           'number' or 'rnum' is null
    01078           'rnum_length' is 0
    01079  */
    01080
    01081 /*----------------------------- OCINumberCmp --------------------------------*/
    01082
    01083 sword OCINumberCmp(    OCIError *err, CONST OCINumber *number1,
    01084                        CONST OCINumber *number2, sword *result    );
    01085 /*
    01086    NAME: OCINumberCmp - OCINumber CoMPare numbers
    01087    PARAMETERS:
    01088         err (IN/OUT) - error handle. If there is an error, it is
    01089                 recorded in 'err' and this function returns OCI_ERROR.
    01090                 The error recorded in 'err' can be retrieved by calling
    01091                 OCIErrorGet().
    01092         number1, number2 (IN) - numbers to be compared
    01093         result (OUT) - 0 if equal, negative if number1 < number2,
    01094                 positive if number1 > number2
    01095    DESCRIPTION:
    01096         The function OCINumberCmp compares two numbers.
    01097    RETURNS:
    01098         OCI_SUCCESS if the function completes successfully.
    01099         OCI_INVALID_HANDLE if 'err' is NULL.
    01100         OCI_ERROR if
    01101             'number1' or 'number2' or 'result' is null
    01102  */
    01103
    01104 /*---------------------------- OCINumberSign --------------------------------*/
    01105
    01106 sword OCINumberSign(    OCIError *err, CONST OCINumber *number,
    01107                         sword *result    );
    01108 /*
    01109    NAME: OCINumberSign - OCINumber obtains SiGN of an Oracle number
    01110    PARAMETERS:
    01111         err (IN/OUT) - error handle. If there is an error, it is
    01112                 recorded in 'err' and this function returns OCI_ERROR.
    01113                 The error recorded in 'err' can be retrieved by calling
    01114                 OCIErrorGet().
    01115         number (IN) - number whose sign is returned
    01116         result (OUT) - 0 if number == 0, -1 if number < 0,
    01117                 1 if number > 0
    01118    DESCRIPTION:
    01119         Obtains sign of an Oracle number
    01120    RETURNS:
    01121         OCI_SUCCESS if the function completes successfully.
    01122         OCI_INVALID_HANDLE if 'err' is NULL.
    01123         OCI_ERROR if
    01124             'number' or 'result' is null
    01125  */
    01126
    01127 /*---------------------------- OCINumberIsZero ------------------------------*/
    01128
    01129 sword OCINumberIsZero(    OCIError *err, CONST OCINumber *number,
    01130                           boolean *result    );
    01131 /*
    01132    NAME: OCINumberIsZero - OCINumber comparison with ZERo
    01133    PARAMETERS:
    01134         err (IN/OUT) - error handle. If there is an error, it is
    01135                 recorded in 'err' and this function returns OCI_ERROR.
    01136                 The error recorded in 'err' can be retrieved by calling
    01137                 OCIErrorGet().
    01138         number (IN) - numbers to be compared
    01139         result (OUT) - set to TRUE if equal to zero else FALSE
    01140    DESCRIPTION:
    01141         Test if the given number is equal to zero.
    01142    RETURNS:
    01143         OCI_SUCCESS if the function completes successfully.
    01144         OCI_INVALID_HANDLE if 'err' is NULL.
    01145         OCI_ERROR if
    01146             'number' or 'result' is null
    01147  */
    01148
    01149 /*---------------------------- OCINumberIsInt -------------------------------*/
    01150
    01151 sword OCINumberIsInt(    OCIError *err, CONST OCINumber *number,
    01152                           boolean *result    );
    01153 /*
    01154    NAME: OCINumberIsInt - OCINumber Is Integer value.
    01155    PARAMETERS:
    01156         err (IN/OUT) - error handle. If there is an error, it is
    01157                 recorded in 'err' and this function returns OCI_ERROR.
    01158                 The error recorded in 'err' can be retrieved by calling
    01159                 OCIErrorGet().
    01160         number (IN) - number to be tested
    01161         result (OUT) - set to TRUE if integer value else FALSE
    01162    DESCRIPTION:
    01163         Test if the given number is an integer value.
    01164    RETURNS:
    01165         OCI_SUCCESS if the function completes successfully.
    01166         OCI_INVALID_HANDLE if 'err' is NULL.
    01167         OCI_ERROR if
    01168             'number' or 'result' is null
    01169  */
    01170
    01171 /*-------------------------- OCINumberAssign --------------------------------*/
    01172
    01173 sword OCINumberAssign(    OCIError *err, CONST OCINumber *from,
    01174                           OCINumber *to    );
    01175 /*
    01176    NAME: OCINumberAssign - OCINumber ASsiGn number
    01177    PARAMETERS:
    01178         err (IN/OUT) - error handle. If there is an error, it is
    01179                 recorded in 'err' and this function returns OCI_ERROR.
    01180                 The error recorded in 'err' can be retrieved by calling
    01181                 OCIErrorGet().
    01182         from (IN) - number to be assigned
    01183         to (OUT) - number copied into
    01184    DESCRIPTION:
    01185         Assign number 'from' to 'to'.
    01186    RETURNS:
    01187         OCI_SUCCESS if the function completes successfully.
    01188         OCI_INVALID_HANDLE if 'err' is NULL.
    01189         OCI_ERROR if
    01190           'from' or 'to' is null
    01191  */
    01192
    01193 /*----------------------------- OCINumberAbs --------------------------------*/
    01194
    01195 sword OCINumberAbs(    OCIError *err, CONST OCINumber *number,
    01196                        OCINumber *result    );
    01197 /*
    01198    NAME: OCINumberAbs - OCINumber compute ABSolute value
    01199    PARAMETERS:
    01200         err (IN/OUT) - error handle. If there is an error, it is
    01201                 recorded in 'err' and this function returns OCI_ERROR.
    01202                 The error recorded in 'err' can be retrieved by calling
    01203                 OCIErrorGet().
    01204         number (IN) - input number
    01205         result (OUT) - output which will contain the absolue value of the
    01206                 input number
    01207    DESCRIPTION:
    01208         Computes the absolute value of an Oracle number.
    01209    RETURNS:
    01210         OCI_SUCCESS if the function completes successfully.
    01211         OCI_INVALID_HANDLE if 'err' is NULL.
    01212         OCI_ERROR if
    01213           any of the number arguments is null
    01214  */
    01215
    01216 /*---------------------------- OCINumberCeil --------------------------------*/
    01217
    01218 sword OCINumberCeil(    OCIError *err, CONST OCINumber *number,
    01219                         OCINumber *result    );
    01220 /*
    01221    NAME: OCINumberCeil - OCINumber compute the CEiL value of an Oracle number
    01222    PARAMETERS:
    01223         err (IN/OUT) - error handle. If there is an error, it is
    01224                 recorded in 'err' and this function returns OCI_ERROR.
    01225                 The error recorded in 'err' can be retrieved by calling
    01226                 OCIErrorGet().
    01227         number (IN) - input number
    01228         result (OUT) - output which will contain the ceil value of the
    01229                 input number
    01230    DESCRIPTION:
    01231         Computes the ceil value of an Oracle number.
    01232    RETURNS:
    01233         OCI_SUCCESS if the function completes successfully.
    01234         OCI_INVALID_HANDLE if 'err' is NULL.
    01235         OCI_ERROR if
    01236           any of the number arguments is null
    01237  */
    01238
    01239 /*--------------------------- OCINumberFloor --------------------------------*/
    01240
    01241 sword OCINumberFloor(    OCIError *err, CONST OCINumber *number,
    01242                          OCINumber *result    );
    01243 /*
    01244    NAME: OCINumberFloor - OCINumber compute the FLooR value of an Oracle number
    01245    PARAMETERS:
    01246         err (IN/OUT) - error handle. If there is an error, it is
    01247                 recorded in 'err' and this function returns OCI_ERROR.
    01248                 The error recorded in 'err' can be retrieved by calling
    01249                 OCIErrorGet().
    01250         number (IN) - input number
    01251         result (OUT) - output which will contain the floor value of the
    01252                 input number
    01253    DESCRIPTION:
    01254         Computes the floor value of an Oracle number.
    01255    RETURNS:
    01256         OCI_SUCCESS if the function completes successfully.
    01257         OCI_INVALID_HANDLE if 'err' is NULL.
    01258         OCI_ERROR if
    01259           any of the number arguments is null
    01260  */
    01261
    01262 /*----------------------------- OCINumberSqrt -------------------------------*/
    01263
    01264 sword OCINumberSqrt(    OCIError *err, CONST OCINumber *number,
    01265                        OCINumber *result    );
    01266 /*
    01267    NAME: OCINumberSqrt - OCINumber compute the SQuare Root of an Oracle number
    01268    PARAMETERS:
    01269         err (IN/OUT) - error handle. If there is an error, it is
    01270                 recorded in 'err' and this function returns OCI_ERROR.
    01271                 The error recorded in 'err' can be retrieved by calling
    01272                 OCIErrorGet().
    01273         number (IN) - input number
    01274         result (OUT) - output which will contain the square root of the
    01275                 input number
    01276    DESCRIPTION:
    01277         Computes the square root of an Oracle number.
    01278    RETURNS:
    01279         OCI_SUCCESS if the function completes successfully.
    01280         OCI_INVALID_HANDLE if 'err' is NULL.
    01281         OCI_ERROR if
    01282           any of the number arguments is null
    01283           'number' is negative
    01284  */
    01285
    01286 /*--------------------------- OCINumberTrunc --------------------------------*/
    01287
    01288 sword OCINumberTrunc(    OCIError *err, CONST OCINumber *number,
    01289                          sword decplace, OCINumber *result    );
    01290 /*
    01291    NAME: OCINumberTrunc - OCINumber TRUncate an Oracle number at a
    01292                           specified decimal place
    01293    PARAMETERS:
    01294         err (IN/OUT) - error handle. If there is an error, it is
    01295                 recorded in 'err' and this function returns OCI_ERROR.
    01296                 The error recorded in 'err' can be retrieved by calling
    01297                 OCIErrorGet().
    01298         number (IN) - input number
    01299         decplace (IN) - number of decimal digits to the right of the
    01300                 decimal point to truncate at. Negative values are allowed.
    01301         result (OUT) - output of truncation
    01302    DESCRIPTION:
    01303         Truncate an Oracle number at a specified decimal place
    01304    RETURNS:
    01305         OCI_SUCCESS if the function completes successfully.
    01306         OCI_INVALID_HANDLE if 'err' is NULL.
    01307         OCI_ERROR if
    01308           any of the number arguments is null
    01309  */
    01310
    01311 /*----------------------------- OCINumberPower ------------------------------*/
    01312
    01313 sword OCINumberPower(    OCIError *err, CONST OCINumber *base,
    01314                          CONST OCINumber *number, OCINumber *result    );
    01315 /*
    01316    NAME: OCINumberPower - OCINumber takes an arbitary Base to an
    01317                           arbitary Power
    01318    PARAMETERS:
    01319         err (IN/OUT) - error handle. If there is an error, it is
    01320                 recorded in 'err' and this function returns OCI_ERROR.
    01321                 The error recorded in 'err' can be retrieved by calling
    01322                 OCIErrorGet().
    01323         base (IN) - base of the exponentiation
    01324         number (IN) - exponent to which the base is to be raised
    01325         result (OUT) - output of exponentiation
    01326    DESCRIPTION:
    01327         Takes an arbitary base to an arbitary power.
    01328    RETURNS:
    01329         OCI_SUCCESS if the function completes successfully.
    01330         OCI_INVALID_HANDLE if 'err' is NULL.
    01331         OCI_ERROR if
    01332           any of the number arguments is null
    01333  */
    01334
    01335 /*--------------------------- OCINumberRound --------------------------------*/
    01336
    01337 sword OCINumberRound(    OCIError *err, CONST OCINumber *number,
    01338                          sword decplace, OCINumber *result    );
    01339 /*
    01340    NAME: OCINumberRound - OCINumber ROUnds an Oracle number to a specified
    01341                   decimal place
    01342    PARAMETERS:
    01343         err (IN/OUT) - error handle. If there is an error, it is
    01344                 recorded in 'err' and this function returns OCI_ERROR.
    01345                 The error recorded in 'err' can be retrieved by calling
    01346                 OCIErrorGet().
    01347         number (IN) - round this number and return result in 'result'
    01348         decplace (IN) - number of decimal digits to the right of the
    01349                 decimal point to round to. Negative values are allowed.
    01350         result (OUT) - output of rounding
    01351    DESCRIPTION:
    01352         Rounds an Oracle number to a specified decimal place
    01353    RETURNS:
    01354         OCI_SUCCESS if the function completes successfully.
    01355         OCI_INVALID_HANDLE if 'err' is NULL.
    01356         OCI_ERROR if
    01357           any of the number arguments is null
    01358  */
    01359
    01360 /*--------------------------- OCINumberPrec ---------------------------------*/
    01361
    01362 sword OCINumberPrec(    OCIError *err, CONST OCINumber *number,
    01363                          eword nDigs, OCINumber *result    );
    01364 /*
    01365    NAME: OCINumberPrec - Rounds an Oracle number to a specified number of
    01366                          decimal digits.
    01367    PARAMETERS:
    01368         err (IN/OUT) - error handle. If there is an error, it is
    01369                 recorded in 'err' and this function returns OCI_ERROR.
    01370                 The error recorded in 'err' can be retrieved by calling
    01371                 OCIErrorGet().
    01372         number (IN) - number for which to set precision.
    01373         nDig   (IN) - number of decimal digits desired in the result.
    01374         result (OUT) - result.
    01375    DESCRIPTION:
    01376         Performs a floating point round with respect to the number
    01377         of digits.
    01378    RETURNS:
    01379         OCI_SUCCESS if the function completes successfully.
    01380         OCI_INVALID_HANDLE if 'err' is NULL.
    01381         OCI_ERROR if
    01382           any of the number arguments is null
    01383  */
    01384
    01385 /*----------------------------- OCINumberSin --------------------------------*/
    01386
    01387 sword OCINumberSin(    OCIError *err, CONST OCINumber *number,
    01388                        OCINumber *result    );
    01389 /*
    01390    NAME: OCINumberSin - OCINumber takes the SINe of an Oracle number
    01391    PARAMETERS:
    01392         err (IN/OUT) - error handle. If there is an error, it is
    01393                 recorded in 'err' and this function returns OCI_ERROR.
    01394                 The error recorded in 'err' can be retrieved by calling
    01395                 OCIErrorGet().
    01396         number (IN) - argument of the sine in radians
    01397         result (OUT) - result of the sine
    01398    DESCRIPTION:
    01399         Takes the sine in radians of an Oracle number.
    01400    RETURNS:
    01401         OCI_SUCCESS if the function completes successfully.
    01402         OCI_INVALID_HANDLE if 'err' is NULL.
    01403         OCI_ERROR if
    01404           any of the number arguments is null
    01405  */
    01406
    01407 /*-------------------------- OCINumberArcSin --------------------------------*/
    01408
    01409 sword OCINumberArcSin(    OCIError *err, CONST OCINumber *number,
    01410                           OCINumber *result    );
    01411 /*
    01412    NAME: OCINumberArcSin - OCINumber takes the Arc SINe of an Oracle number
    01413    PARAMETERS:
    01414         err (IN/OUT) - error handle. If there is an error, it is
    01415                 recorded in 'err' and this function returns OCI_ERROR.
    01416                 The error recorded in 'err' can be retrieved by calling
    01417                 OCIErrorGet().
    01418         number (IN) - argument of the arc sine
    01419         result (OUT) - result of the arc sine in radians
    01420    DESCRIPTION:
    01421         Takes the arc sine in radians of an Oracle number.
    01422    RETURNS:
    01423         OCI_SUCCESS if the function completes successfully.
    01424         OCI_INVALID_HANDLE if 'err' is NULL.
    01425         OCI_ERROR if
    01426           any of the number arguments is null
    01427           'number' is < -1 or 'number' is > 1.
    01428  */
    01429
    01430 /*-------------------------- OCINumberHypSin --------------------------------*/
    01431
    01432 sword OCINumberHypSin(    OCIError *err, CONST OCINumber *number,
    01433                           OCINumber *result    );
    01434 /*
    01435    NAME: OCINumberHypSin - OCINumber takes the SiNe Hyperbolic of an
    01436                            Oracle number
    01437    PARAMETERS:
    01438         err (IN/OUT) - error handle. If there is an error, it is
    01439                 recorded in 'err' and this function returns OCI_ERROR.
    01440                 The error recorded in 'err' can be retrieved by calling
    01441                 OCIErrorGet().
    01442         number (IN) - argument of the sine hyperbolic
    01443         result (OUT) - result of the sine hyperbolic
    01444    DESCRIPTION:
    01445         Takes the hyperbolic sine of an Oracle number.
    01446    RETURNS:
    01447         OCI_SUCCESS if the function completes successfully.
    01448         OCI_INVALID_HANDLE if 'err' is NULL.
    01449         OCI_ERROR if
    01450           any of the number arguments is null
    01451    NOTES:
    01452         An Oracle number overflow causes an unpredictable result value.
    01453  */
    01454
    01455 /*----------------------------- OCINumberCos --------------------------------*/
    01456
    01457 sword OCINumberCos(    OCIError *err, CONST OCINumber *number,
    01458                        OCINumber *result    );
    01459 /*
    01460    NAME: OCINumberCos - OCINumber takes the COSine of an Oracle number
    01461    PARAMETERS:
    01462         err (IN/OUT) - error handle. If there is an error, it is
    01463                 recorded in 'err' and this function returns OCI_ERROR.
    01464                 The error recorded in 'err' can be retrieved by calling
    01465                 OCIErrorGet().
    01466         number (IN) - argument of the cosine in radians
    01467         result (OUT) - result of the cosine
    01468    DESCRIPTION:
    01469         Takes the cosine in radians of an Oracle number.
    01470    RETURNS:
    01471         OCI_SUCCESS if the function completes successfully.
    01472         OCI_INVALID_HANDLE if 'err' is NULL.
    01473         OCI_ERROR if
    01474           any of the number arguments is null
    01475  */
    01476
    01477 /*-------------------------- OCINumberArcCos --------------------------------*/
    01478
    01479 sword OCINumberArcCos(    OCIError *err, CONST OCINumber *number,
    01480                           OCINumber *result    );
    01481 /*
    01482    NAME: OCINumberArcCos - OCINumber takes the Arc COSine of an Oracle number
    01483    PARAMETERS:
    01484         err (IN/OUT) - error handle. If there is an error, it is
    01485                 recorded in 'err' and this function returns OCI_ERROR.
    01486                 The error recorded in 'err' can be retrieved by calling
    01487                 OCIErrorGet().
    01488         number (IN) - argument of the arc cosine
    01489         result (OUT) - result of the arc cosine in radians
    01490    DESCRIPTION:
    01491         Takes the arc cosine in radians of an Oracle number.
    01492    RETURNS:
    01493         OCI_SUCCESS if the function completes successfully.
    01494         OCI_INVALID_HANDLE if 'err' is NULL.
    01495         OCI_ERROR if
    01496           any of the number arguments is null
    01497           'number' is < -1 or 'number' is > 1.
    01498  */
    01499
    01500 /*-------------------------- OCINumberHypCos --------------------------------*/
    01501
    01502 sword OCINumberHypCos(    OCIError *err, CONST OCINumber *number,
    01503                           OCINumber *result    );
    01504 /*
    01505    NAME: OCINumberHypCos - OCINumber takes the CoSine Hyperbolic of an
    01506                            Oracle number
    01507    PARAMETERS:
    01508         err (IN/OUT) - error handle. If there is an error, it is
    01509                 recorded in 'err' and this function returns OCI_ERROR.
    01510                 The error recorded in 'err' can be retrieved by calling
    01511                 OCIErrorGet().
    01512         number (IN) - argument of the cosine hyperbolic
    01513         result (OUT) - result of the cosine hyperbolic
    01514    DESCRIPTION:
    01515         Takes the hyperbolic cosine of an Oracle number.
    01516    RETURNS:
    01517         OCI_SUCCESS if the function completes successfully.
    01518         OCI_INVALID_HANDLE if 'err' is NULL.
    01519         OCI_ERROR if
    01520           any of the number arguments is null
    01521    NOTES:
    01522         An Oracle number overflow causes an unpredictable result value.
    01523  */
    01524
    01525 /*----------------------------- OCINumberTan --------------------------------*/
    01526
    01527 sword OCINumberTan(    OCIError *err, CONST OCINumber *number,
    01528                        OCINumber *result    );
    01529 /*
    01530    NAME: OCINumberTan - OCINumber takes the TANgent of an Oracle number
    01531    PARAMETERS:
    01532         err (IN/OUT) - error handle. If there is an error, it is
    01533                 recorded in 'err' and this function returns OCI_ERROR.
    01534                 The error recorded in 'err' can be retrieved by calling
    01535                 OCIErrorGet().
    01536         number (IN) - argument of the tangent in radians
    01537         result (OUT) - result of the tangent
    01538    DESCRIPTION:
    01539         Takes the tangent in radians of an Oracle number.
    01540    RETURNS:
    01541         OCI_SUCCESS if the function completes successfully.
    01542         OCI_INVALID_HANDLE if 'err' is NULL.
    01543         OCI_ERROR if
    01544           any of the number arguments is null
    01545  */
    01546
    01547 /*-------------------------- OCINumberArcTan --------------------------------*/
    01548
    01549 sword OCINumberArcTan(    OCIError *err, CONST OCINumber *number,
    01550                           OCINumber *result    );
    01551 /*
    01552    NAME: OCINumberArcTan - OCINumber takes the Arc TANgent of an Oracle number
    01553    PARAMETERS:
    01554         err (IN/OUT) - error handle. If there is an error, it is
    01555                 recorded in 'err' and this function returns OCI_ERROR.
    01556                 The error recorded in 'err' can be retrieved by calling
    01557                 OCIErrorGet().
    01558         number (IN) - argument of the arc tangent
    01559         result (OUT) - result of the arc tangent in radians
    01560    DESCRIPTION:
    01561         Takes the arc tangent in radians of an Oracle number.
    01562    RETURNS:
    01563         OCI_SUCCESS if the function completes successfully.
    01564         OCI_INVALID_HANDLE if 'err' is NULL.
    01565         OCI_ERROR if
    01566           any of the number arguments is null
    01567  */
    01568
    01569 /*------------------------ OCINumberArcTan2 ---------------------------------*/
    01570
    01571 sword OCINumberArcTan2(    OCIError *err, CONST OCINumber *number1,
    01572                            CONST OCINumber *number2, OCINumber *result    );
    01573 /*
    01574    NAME: OCINumberArcTan2 - OCINumber takes the ATan2 of 2 Oracle numbers
    01575    PARAMETERS:
    01576         err (IN/OUT) - error handle. If there is an error, it is
    01577                 recorded in 'err' and this function returns OCI_ERROR.
    01578                 The error recorded in 'err' can be retrieved by calling
    01579                 OCIErrorGet().
    01580         number1 (IN) - first argument of atan2(y,x) function which
    01581                 corresponds to 'y' parameter in the function
    01582         number2 (IN) - second argument of atan2(y,x) function which
    01583                 corresponds to 'x' parameter in the function
    01584         result (OUT) - result of the atan2() in radians
    01585    DESCRIPTION:
    01586         Takes the atan2(number1, number2).
    01587    RETURNS:
    01588         OCI_SUCCESS if the function completes successfully.
    01589         OCI_INVALID_HANDLE if 'err' is NULL.
    01590         OCI_ERROR if
    01591           any of the number arguments is null
    01592           'number2' is 0
    01593  */
    01594
    01595 /*----------------------------- OCINumberHypTan -----------------------------*/
    01596
    01597 sword OCINumberHypTan(    OCIError *err, CONST OCINumber *number,
    01598                           OCINumber *result    );
    01599 /*
    01600    NAME: OCINumberHypTan - OCINumber takes the TaNgent Hyperbolic of an Oracle
    01601                            number
    01602    PARAMETERS:
    01603         err (IN/OUT) - error handle. If there is an error, it is
    01604                 recorded in 'err' and this function returns OCI_ERROR.
    01605                 The error recorded in 'err' can be retrieved by calling
    01606                 OCIErrorGet().
    01607         number (IN) - argument of the tangent hyperbolic
    01608         result (OUT) - result of the tangent hyperbolic
    01609    DESCRIPTION:
    01610         Takes the hyperbolic tangent of an Oracle number.
    01611    RETURNS:
    01612         OCI_SUCCESS if the function completes successfully.
    01613         OCI_INVALID_HANDLE if 'err' is NULL.
    01614         OCI_ERROR if
    01615           any of the number arguments is null
    01616    NOTES:
    01617         An Oracle number overflow causes an unpredictable result value.
    01618  */
    01619
    01620 /*--------------------------- OCINumberExp ----------------------------------*/
    01621
    01622 sword OCINumberExp(    OCIError *err, CONST OCINumber *number,
    01623                        OCINumber *result    );
    01624 /*
    01625    NAME: OCINumberExp - OCINumber EXPonential
    01626    PARAMETERS:
    01627         err (IN/OUT) - error handle. If there is an error, it is
    01628                 recorded in 'err' and this function returns OCI_ERROR.
    01629                 The error recorded in 'err' can be retrieved by calling
    01630                 OCIErrorGet().
    01631         number (IN) - e raised to this Oracle number power
    01632         result (OUT) - output of exponentiation
    01633    DESCRIPTION:
    01634         Raises e to the specified Oracle number power
    01635    RETURNS:
    01636         OCI_SUCCESS if the function completes successfully.
    01637         OCI_INVALID_HANDLE if 'err' is NULL.
    01638         OCI_ERROR if
    01639           any of the number arguments is null
    01640  */
    01641
    01642 /*----------------------------- OCINumberLn ---------------------------------*/
    01643
    01644 sword OCINumberLn(    OCIError *err, CONST OCINumber *number,
    01645                       OCINumber *result    );
    01646 /*
    01647    NAME: OCINumberLn - OCINumber Logarithm Natural
    01648    PARAMETERS:
    01649         err (IN/OUT) - error handle. If there is an error, it is
    01650                 recorded in 'err' and this function returns OCI_ERROR.
    01651                 The error recorded in 'err' can be retrieved by calling
    01652                 OCIErrorGet().
    01653         number (IN) - logarithm of this number is computed
    01654         result (OUT) - logarithm result
    01655    DESCRIPTION:
    01656         Takes the logarithm of the given Oracle number with respect
    01657         to the given base.
    01658    RETURNS:
    01659         OCI_SUCCESS if the function completes successfully.
    01660         OCI_INVALID_HANDLE if 'err' is NULL.
    01661         OCI_ERROR if
    01662           any of the number arguments is null
    01663           'number' is <= 0
    01664  */
    01665
    01666 /*----------------------------- OCINumberLog --------------------------------*/
    01667
    01668 sword OCINumberLog(    OCIError *err, CONST OCINumber *base,
    01669                        CONST OCINumber *number, OCINumber *result    );
    01670 /*
    01671    NAME: OCINumberLog - OCINumber LOGarithm any base
    01672    PARAMETERS:
    01673         err (IN/OUT) - error handle. If there is an error, it is
    01674                 recorded in 'err' and this function returns OCI_ERROR.
    01675                 The error recorded in 'err' can be retrieved by calling
    01676                 OCIErrorGet().
    01677         base (IN) - base of the logarithm
    01678         number (IN) - opearnd
    01679         result (OUT) - logarithm result
    01680    DESCRIPTION:
    01681         Takes the logarithm with the specified base of an Oracle number.
    01682    RETURNS:
    01683         OCI_SUCCESS if the function completes successfully.
    01684         OCI_INVALID_HANDLE if 'err' is NULL.
    01685         OCI_ERROR if
    01686           any of the number arguments is null
    01687           'number' is <= 0
    01688           'base' is <= 0
    01689  */
    01690
    01691 /*****************************************************************************/
    01692 /*                             ORACLE DATE TYPE                              */
    01693 /*****************************************************************************/
    01694
    01695 struct OCITime
    01696 {
    01697   ub1 OCITimeHH;                          /* hours; range is 0 <= hours <=23 */
    01698   ub1 OCITimeMI;                     /* minutes; range is 0 <= minutes <= 59 */
    01699   ub1 OCITimeSS;                     /* seconds; range is 0 <= seconds <= 59 */
    01700 };
    01701 typedef struct OCITime OCITime;
    01702
    01703 /*
    01704  * OCITime - OCI TiMe portion of date
    01705  *
    01706  * This structure should be treated as an opaque structure as the format
    01707  * of this structure may change. Use OCIDateGetTime/OCIDateSetTime
    01708  * to manipulate time portion of OCIDate.
    01709  */
    01710
    01711 struct OCIDate
    01712 {
    01713   sb2 OCIDateYYYY;         /* gregorian year; range is -4712 <= year <= 9999 */
    01714   ub1 OCIDateMM;                          /* month; range is 1 <= month < 12 */
    01715   ub1 OCIDateDD;                             /* day; range is 1 <= day <= 31 */
    01716   OCITime OCIDateTime;                                               /* time */
    01717 };
    01718 typedef struct OCIDate OCIDate;
    01719
    01720 /*
    01721  * OCIDate - OCI oracle Date representation in C
    01722  *
    01723  * OCIDate represents the C mapping of Oracle date.
    01724  *
    01725  * This structure should be treated as an opaque structure as the format
    01726  * of this structure may change. Use OCIDateGetDate/OCIDateSetDate
    01727  * to access/initialize OCIDate.
    01728  *
    01729  * For binding variables of type OCIDate in OCI calls (OCIBindByName(),
    01730  * OCIBindByPos(), and OCIDefineByPos()) use the type code SQLT_ODT.
    01731  */
    01732
    01733 /*
    01734    EXAMPLE
    01735
    01736    The following example shows how to manipulate an attribute of type
    01737    oracle date.
    01738
    01739      #define FMT "Month dd, YYYY, HH:MI A.M."
    01740      #define LANG "American"
    01741
    01742      struct person
    01743      {
    01744        OCIDate start_date;
    01745      };
    01746      typedef struct person person;
    01747
    01748      OCIError *err;
    01749      person *joe;
    01750      sword status;                                           /o error status o/
    01751
    01752      /o See oci.h for an example of how to initialize OCIError.
    01753       o For this example, assume the OCIEnv and OCIError has been
    01754       o initialized.
    01755       o/
    01756
    01757      /o Pin joe person object in the object cache. See ori.h
    01758       o for an example on pinning objects. For this example, assume that
    01759       o joe is pointing to the pinned object.
    01760       o/
    01761
    01762      /o set the start date of joe o/
    01763      OCIDateSetTime(&joe->start_date, 8, 0, 0);
    01764      OCIDateSetDate(&joe->start_date, 1990, 10, 5);
    01765
    01766      /o check if the date is valid o/
    01767      uword invalid;
    01768      if (OCIDateCheck(err, &joe->start_date, &invalid) != OCI_SUCCESS)
    01769        /o error handling code o/
    01770      if (invalid)
    01771        /o error handling code o/
    01772
    01773      /o convert date for display purposes o/
    01774      char str[100];
    01775      ub4 strlen = sizeof(str);
    01776      if (OCIDateToText(err, &joe->start_date, FMT, sizeof(FMT)-1, LANG,
    01777                 sizeof(LANG)-1, &strlen, str) != OCI_SUCCESS)
    01778        /o error handling code o/
    01779
    01780  */
    01781
    01782 /*--------------------------- OCIDateGetTime --------------------------------*/
    01783 /* void OCIDateGetTime(/o_ CONST OCIDate *date, ub1 *hour, ub1 *min,
    01784                            ub1 *sec _o/); */
    01785 #define OCIDateGetTime(date, hour, min, sec) \
    01786   { \
    01787      *hour = (date)->OCIDateTime.OCITimeHH; \
    01788      *min = (date)->OCIDateTime.OCITimeMI; \
    01789      *sec = (date)->OCIDateTime.OCITimeSS; \
    01790   }
    01791 /*
    01792    NAME: OCIDateGetTime - OCIDate Get Time portion of date
    01793    PARAMETERS:
    01794         date (IN) - Oracle date whose time data is retrieved
    01795         hour (OUT) - hour value returned
    01796         min (OUT) - minute value returned
    01797         sec (OUT) - second value returned
    01798    DESCRIPTION:
    01799         Return time inforamtion stored in the given date. The time
    01800         information returned is: hour, minute and seconds.
    01801    RETURNS:
    01802         NONE
    01803  */
    01804
    01805 /*--------------------------- OCIDateGetDate --------------------------------*/
    01806 /* void OCIDateGetDate(/o_ CONST OCIDate *date, sb2 *year, ub1 *month,
    01807                            ub1 *day _o/); */
    01808 #define OCIDateGetDate(date, year, month, day) \
    01809   { \
    01810      *year = (date)->OCIDateYYYY; \
    01811      *month = (date)->OCIDateMM; \
    01812      *day = (date)->OCIDateDD; \
    01813   }
    01814 /*
    01815    NAME: OCIDateGetDate - OCIDate Get Date (year, month, day) portion of date
    01816    PARAMETERS:
    01817         date (IN) - Oracle date whose year, month, day data is retrieved
    01818         year (OUT) - year value returned
    01819         month (OUT) - month value returned
    01820         day (OUT) - day value returned
    01821    DESCRIPTION:
    01822         Return year, month, day inforamtion stored in the given date.
    01823    RETURNS:
    01824         NONE
    01825  */
    01826
    01827 /*--------------------------- OCIDateSetTime --------------------------------*/
    01828 /* void OCIDateSetTime(/o_ OCIDate *date, ub1 hour, ub1 min,
    01829                            ub1 sec _o/); */
    01830 #define OCIDateSetTime(date, hour, min, sec) \
    01831   { \
    01832      (date)->OCIDateTime.OCITimeHH = hour; \
    01833      (date)->OCIDateTime.OCITimeMI = min; \
    01834      (date)->OCIDateTime.OCITimeSS = sec; \
    01835   }
    01836 /*
    01837    NAME: OCIDateSetTime - OCIDate Set Time portion of date
    01838    PARAMETERS:
    01839         date (OUT) - Oracle date whose time data is set
    01840         hour (IN) - hour value to be set
    01841         min (IN) - minute value to be set
    01842         sec (IN) - second value to be set
    01843    DESCRIPTION:
    01844         Set the date with the given time inforamtion.
    01845    RETURNS:
    01846         NONE
    01847  */
    01848
    01849 /*--------------------------- OCIDateSetDate --------------------------------*/
    01850 /* void OCIDateSetDate(/o_ OCIDate *date, sb2 year, ub1 month, ub1 day _o/); */
    01851 #define OCIDateSetDate(date, year, month, day) \
    01852   { \
    01853      (date)->OCIDateYYYY = year; \
    01854      (date)->OCIDateMM = month; \
    01855      (date)->OCIDateDD = day; \
    01856   }
    01857 /*
    01858    NAME: OCIDateSetDate - OCIDate Set Date (year, month, day) portion of date
    01859    PARAMETERS:
    01860         date (IN) - Oracle date whose year, month, day data is set
    01861         year (OUT) - year value to be set
    01862         month (OUT) - month value to be set
    01863         day (OUT) - day value to be set
    01864    DESCRIPTION:
    01865         Set the date with the given year, month, day inforamtion.
    01866    RETURNS:
    01867         NONE
    01868  */
    01869
    01870 /*--------------------------- OCIDateAssign ---------------------------------*/
    01871
    01872 sword OCIDateAssign(    OCIError *err, CONST OCIDate *from,
    01873                         OCIDate *to    );
    01874 /*
    01875    NAME: OCIDateAssign - OCIDate Assignment
    01876    PARAMETERS:
    01877         err (IN/OUT) - error handle. If there is an error, it is
    01878                 recorded in 'err' and this function returns OCI_ERROR.
    01879                 The error recorded in 'err' can be retrieved by calling
    01880                 OCIErrorGet().
    01881         from (IN) - date to be assigned
    01882         to (OUT) - lhs of assignment
    01883    DESCRIPTION:
    01884         Performs date assignment.
    01885    RETURNS:
    01886         OCI_SUCCESS
    01887  */
    01888
    01889 /*--------------------------- OCIDateToText ---------------------------------*/
    01890
    01891 sword OCIDateToText(    OCIError *err, CONST OCIDate *date,
    01892                         CONST oratext *fmt, ub1 fmt_length,
    01893                         CONST oratext *lang_name, ub4 lang_length,
    01894                         ub4 *buf_size, oratext *buf    );
    01895 /*
    01896    NAME: OCIDateToText - OCIDate convert date TO String
    01897    PARAMETERS:
    01898         err (IN/OUT) - error handle. If there is an error, it is
    01899                 recorded in 'err' and this function returns OCI_ERROR.
    01900                 The error recorded in 'err' can be retrieved by calling
    01901                 OCIErrorGet().
    01902         date (IN) - Oracle date to be converted
    01903         fmt (IN) - conversion format, if null string pointer (oratext*)0, then
    01904                 the date is converted to a character string in the
    01905                 date format "DD-MON-YY".
    01906         fmt_length (IN) - length of the 'fmt' parameter
    01907         lang_name (IN) - specifies the language in which the names and
    01908                 abbreviations of months and days are returned;
    01909                 default language of session is used if 'lang_name'
    01910                 is null i.e. (oratext *)0
    01911         lang_length (IN) - length of the 'nls_params' parameter
    01912         buf_size (IN/OUT) - size of the buffer; size of the resulting string
    01913                 is returned via this parameter
    01914         buf (OUT) - buffer into which the converted string is placed
    01915    DESCRIPTION:
    01916         Converts the given date to a string according to the specified format.
    01917         Refer to "TO_DATE" conversion function described in
    01918         "Oracle SQL Language Reference Manual" for a description of format
    01919         and NLS arguments. The converted null-terminated date string is
    01920         stored in the buffer 'buf'.
    01921
    01922         An error is reported upon overflow, e.g. trying to convert a number
    01923         of value 10 using format '9' causes an overflow.
    01924    RETURNS:
    01925         OCI_SUCCESS if the function completes successfully.
    01926         OCI_INVALID_HANDLE if 'err' is NULL.
    01927         OCI_ERROR if
    01928           buffer too small
    01929           invalid format
    01930           unknown language
    01931           overflow error
    01932  */
    01933
    01934 /*---------------------------- OCIDateFromText ------------------------------*/
    01935
    01936 sword OCIDateFromText(    OCIError *err, CONST oratext *date_str,
    01937                         ub4 d_str_length, CONST oratext *fmt, ub1 fmt_length,
    01938                         CONST oratext *lang_name, ub4 lang_length,
    01939                         OCIDate *date    );
    01940 /*
    01941    NAME: OCIDateFromText - OCIDate convert String TO Date
    01942    PARAMETERS:
    01943         err (IN/OUT) - error handle. If there is an error, it is
    01944                 recorded in 'err' and this function returns OCI_ERROR.
    01945                 The error recorded in 'err' can be retrieved by calling
    01946                 OCIErrorGet().
    01947         date_str (IN) - input string to be converted to Oracle date
    01948         d_str_length (IN) - size of the input string, if the length is -1
    01949                 then 'date_str' is treated as a null terminated  string
    01950         fmt (IN) - conversion format; if 'fmt' is a null pointer, then
    01951                 the string is expected to be in 'DD-MON-YY' format.
    01952         fmt_length (IN) - length of the 'fmt' parameter
    01953         lang_name (IN) - language in which the names and abbreviations of
    01954                 days and months are specified, if null i.e. (oratext *)0,
    01955                 the default language of session is used,
    01956         lang_length (IN) - length of the 'lang_name' parameter
    01957         date (OUT) - given string converted to date
    01958    DESCRIPTION:
    01959         Converts the given string to Oracle date
    01960         according to the specified format. Refer to "TO_DATE" conversion
    01961         function described in "Oracle SQL Language Reference Manual" for a
    01962         description of format.
    01963    RETURNS:
    01964         OCI_SUCCESS if the function completes successfully.
    01965         OCI_INVALID_HANDLE if 'err' is NULL.
    01966         OCI_ERROR if
    01967           invalid format
    01968           unknown language
    01969           invalid input string
    01970           <to be discovered>
    01971  */
    01972
    01973 /*----------------------------- OCIDateCompare ------------------------------*/
    01974
    01975 sword OCIDateCompare(    OCIError *err, CONST OCIDate *date1,
    01976                      CONST OCIDate *date2, sword *result    );
    01977 /*
    01978    NAME: OCIDateCompare - OCIDate CoMPare dates
    01979    PARAMETERS:
    01980         err (IN/OUT) - error handle. If there is an error, it is
    01981                 recorded in 'err' and this function returns OCI_ERROR.
    01982                 The error recorded in 'err' can be retrieved by calling
    01983                 OCIErrorGet().
    01984         date1, date2 (IN) - dates to be compared
    01985         result (OUT) - comparison result, 0 if equal, -1 if date1 < date2,
    01986                 1 if date1 > date2
    01987    DESCRIPTION:
    01988         The function OCIDateCompare compares two dates. It returns -1 if date1
    01989         is smaller than date2, 0 if they are equal, and 1 if date1 is greater
    01990         than date2.
    01991    RETURNS:
    01992         OCI_SUCCESS if the function completes successfully.
    01993         OCI_INVALID_HANDLE if 'err' is NULL.
    01994         OCI_ERROR if
    01995           invalid date
    01996           <to be discovered>
    01997  */
    01998
    01999 /*------------------------- OCIDateAddMonths --------------------------------*/
    02000
    02001 sword OCIDateAddMonths(    OCIError *err, CONST OCIDate *date, sb4 num_months,
    02002                            OCIDate *result    );
    02003 /*
    02004    NAME: OCIDateAddMonths - OCIDate ADd or subtract Months
    02005    PARAMETERS:
    02006         err (IN/OUT) - error handle. If there is an error, it is
    02007                 recorded in 'err' and this function returns OCI_ERROR.
    02008                 The error recorded in 'err' can be retrieved by calling
    02009                 OCIErrorGet().
    02010         date (IN) - 'num_months' added or subtracted from 'date'
    02011         num_months (IN) - number of months to be added or subtracted
    02012                 (a negative value will be subtracted)
    02013         result (IN/OUT) - result of adding or subtracting to 'date'
    02014    DESCRIPTION:
    02015         The function OCIDateAddDays adds or subtracts num_months from the
    02016         date 'date'.
    02017           If the input 'date' is the last day of a month, then
    02018         appropriate adjustments are made to ensure that the output date is
    02019         also the last day of the month. For example, Feb. 28 + 1 month =
    02020         March 31, and November 30 - 3 months = August 31. Otherwise the
    02021         'result' date has the same day component as 'date'.
    02022    RETURNS:
    02023         OCI_SUCCESS if the function completes successfully.
    02024         OCI_INVALID_HANDLE if 'err' is NULL.
    02025         OCI_ERROR if
    02026           invalid date
    02027           <to be discovered>
    02028  */
    02029
    02030 /*--------------------------- OCIDateAddDays --------------------------------*/
    02031
    02032 sword OCIDateAddDays(    OCIError *err, CONST OCIDate *date, sb4 num_days,
    02033                          OCIDate *result    );
    02034 /*
    02035    NAME: OCIDateAddDays - OCIDate ADd or subtract Days
    02036    PARAMETERS:
    02037         err (IN/OUT) - error handle. If there is an error, it is
    02038                 recorded in 'err' and this function returns OCI_ERROR.
    02039                 The error recorded in 'err' can be retrieved by calling
    02040                 OCIErrorGet().
    02041         date (IN) - 'num_days' added or subtracted from 'date'
    02042         num_days (IN) - number of days to be added or subtracted
    02043                 (a negative value will be subtracted)
    02044         result (IN/OUT) - result of adding or subtracting to 'date'
    02045    DESCRIPTION:
    02046         The function OCIDateAddDays adds or subtracts num_days from the
    02047         date 'date'.
    02048    RETURNS:
    02049         OCI_SUCCESS if the function completes successfully.
    02050         OCI_INVALID_HANDLE if 'err' is NULL.
    02051         OCI_ERROR if
    02052           invalid date
    02053           <to be discovered>
    02054  */
    02055
    02056 /*--------------------------- OCIDateLastDay --------------------------------*/
    02057
    02058 sword OCIDateLastDay(    OCIError *err, CONST OCIDate *date,
    02059                          OCIDate *last_day    );
    02060 /*
    02061    NAME: OCIDateLastDay - OCIDate get date of the LaST day of the month
    02062    PARAMETERS:
    02063         err (IN/OUT) - error handle. If there is an error, it is
    02064                 recorded in 'err' and this function returns OCI_ERROR.
    02065                 The error recorded in 'err' can be retrieved by calling
    02066                 OCIErrorGet().
    02067         date (IN) - input date
    02068         last_day (OUT) - last day of the month in date 'date'
    02069    DESCRIPTION:
    02070         The function OCIDateLastDay returns the date of the last day of the
    02071         month in date 'date'.
    02072    RETURNS:
    02073         OCI_SUCCESS if the function completes successfully.
    02074         OCI_INVALID_HANDLE if 'err' is NULL.
    02075         OCI_ERROR if
    02076           invalid date
    02077           <to be discovered>
    02078  */
    02079
    02080 /*----------------------- OCIDateDaysBetween --------------------------------*/
    02081
    02082 sword OCIDateDaysBetween(    OCIError *err, CONST OCIDate *date1,
    02083                              CONST OCIDate *date2, sb4 *num_days    );
    02084 /*
    02085    NAME: OCIDateDaysBetween - OCIDate get number of days BeTWeen two dates
    02086    PARAMETERS:
    02087         err (IN/OUT) - error handle. If there is an error, it is
    02088                 recorded in 'err' and this function returns OCI_ERROR.
    02089                 The error recorded in 'err' can be retrieved by calling
    02090                 OCIErrorGet().
    02091         date1, date2 (IN) - input dates
    02092         num_days (OUT) - number of days between date1 and date2
    02093    DESCRIPTION:
    02094         The function OCIDateDaysBetween returns the number of days between
    02095         date1 and date2. The time is ignored in this computation.
    02096    RETURNS:
    02097         OCI_SUCCESS if the function completes successfully.
    02098         OCI_INVALID_HANDLE if 'err' is NULL.
    02099         OCI_ERROR if
    02100           invalid date
    02101           <to be discovered>
    02102  */
    02103
    02104 /*------------------------ OCIDateZoneToZone --------------------------------*/
    02105
    02106 sword OCIDateZoneToZone(    OCIError *err, CONST OCIDate *date1,
    02107                             CONST oratext *zon1,
    02108                             ub4 zon1_length, CONST oratext *zon2,
    02109                             ub4 zon2_length, OCIDate *date2    );
    02110 /*
    02111    NAME: OCIDateZoneToZone - OCIDate convert date from one Zone TO another Zone
    02112    PARAMETERS:
    02113         err (IN/OUT) - error handle. If there is an error, it is
    02114                 recorded in 'err' and this function returns OCI_ERROR.
    02115                 The error recorded in 'err' can be retrieved by calling
    02116                 OCIErrorGet().
    02117         date1 (IN) - date to be converted
    02118         zon1 (IN) - zone of input date
    02119         zon1_length (IN) - length in bytes of string 'zon1'
    02120         zon2 (IN) - zone to be converted to
    02121         zon2_length (IN) - length in bytes of string 'zon2'
    02122         date2 (OUT) - converted date (in 'zon2')
    02123    DESCRIPTION:
    02124         Converts date from one time zone to another. Given date 'date1'
    02125         in time zone 'zon1' returns date 'date2' in time zone 'zon2'.
    02126    RETURNS:
    02127         OCI_SUCCESS if the function completes successfully.
    02128         OCI_INVALID_HANDLE if 'err' is NULL.
    02129         OCI_ERROR if
    02130           invlid date
    02131           invald input time zone
    02132           invald output time zone
    02133           <to be discovered>
    02134  */
    02135
    02136 /*--------------------------- OCIDateNextDay --------------------------------*/
    02137
    02138 sword OCIDateNextDay(    OCIError *err, CONST OCIDate *date,
    02139                          CONST oratext *day_p, ub4 day_length,
    02140                          OCIDate *next_day    );
    02141 /*
    02142    NAME: OCIDateNextDay - OCIDate get date of Next DaY
    02143    PARAMETERS:
    02144         err (IN/OUT) - error handle. If there is an error, it is
    02145                 recorded in 'err' and this function returns OCI_ERROR.
    02146                 The error recorded in 'err' can be retrieved by calling
    02147                 OCIErrorGet().
    02148         date (IN) - returned date should be later than this date
    02149         day (IN) - first day of week named by this is returned
    02150         day_length (IN) - length in bytes of string 'day'
    02151         next_day (OUT) - first day of the week named by 'day' later than 'date'
    02152    DESCRIPTION:
    02153         Returns the date of the first day of the
    02154         week named by 'day' that is later than date 'date'.
    02155    RETURNS:
    02156         OCI_SUCCESS if the function completes successfully.
    02157         OCI_INVALID_HANDLE if 'err' is NULL.
    02158         OCI_ERROR if
    02159           invalid date
    02160           invalid day
    02161           <to be discovered>
    02162  */
    02163
    02164 /*----------------------------- OCIDateCheck --------------------------------*/
    02165
    02166 /* Listing of error bits used by OCIDateCheck() */
    02167 #define OCI_DATE_INVALID_DAY            0x1                       /* Bad DAy */
    02168 #define OCI_DATE_DAY_BELOW_VALID        0x2   /* Bad DAy Low/high bit (1=low)*/
    02169 #define OCI_DATE_INVALID_MONTH          0x4                     /* Bad MOnth */
    02170 #define OCI_DATE_MONTH_BELOW_VALID      0x8 /* Bad MOnth Low/high bit (1=low)*/
    02171 #define OCI_DATE_INVALID_YEAR           0x10                     /* Bad YeaR */
    02172 #define OCI_DATE_YEAR_BELOW_VALID       0x20 /* Bad YeaR Low/high bit (1=low)*/
    02173 #define OCI_DATE_INVALID_HOUR           0x40                     /* Bad HouR */
    02174 #define OCI_DATE_HOUR_BELOW_VALID       0x80 /* Bad HouR Low/high bit (1=low)*/
    02175 #define OCI_DATE_INVALID_MINUTE         0x100                  /* Bad MiNute */
    02176 #define OCI_DATE_MINUTE_BELOW_VALID     0x200
    02177                                            /* Bad MiNute Low/high bit (1=low)*/
    02178 #define OCI_DATE_INVALID_SECOND         0x400                  /* Bad SeCond */
    02179 #define OCI_DATE_SECOND_BELOW_VALID     0x800
    02180                                            /* bad second Low/high bit (1=low)*/
    02181 #define OCI_DATE_DAY_MISSING_FROM_1582  0x1000
    02182                                   /* Day is one of those "missing" from 1582 */
    02183 #define OCI_DATE_YEAR_ZERO              0x2000    /* Year may not equal zero */
    02184 #define OCI_DATE_INVALID_FORMAT         0x8000      /* Bad date format input */
    02185
    02186 sword OCIDateCheck(    OCIError *err, CONST OCIDate *date, uword *valid    );
    02187 /*
    02188    NAME: OCIDateCheck - OCIDate CHecK if the given date is valid
    02189    PARAMETERS:
    02190         err (IN/OUT) - error handle. If there is an error, it is
    02191                 recorded in 'err' and this function returns OCI_ERROR.
    02192                 The error recorded in 'err' can be retrieved by calling
    02193                 OCIErrorGet().
    02194         date (IN) - date to be checked
    02195         valid (OUT) -  returns zero for a valid date, otherwise
    02196                 the ORed combination of all error bits specified below:
    02197
    02198    Macro name                   Bit number      Error
    02199    ----------                   ----------      -----
    02200    OCI_DATE_INVALID_DAY         0x1             Bad day
    02201    OCI_DATE_DAY_BELOW_VALID     0x2             Bad DAy Low/high bit (1=low)
    02202    OCI_DATE_INVALID_MONTH       0x4             Bad MOnth
    02203    OCI_DATE_MONTH_BELOW_VALID   0x8             Bad MOnth Low/high bit (1=low)
    02204    OCI_DATE_INVALID_YEAR        0x10            Bad YeaR
    02205    OCI_DATE_YEAR_BELOW_VALID    0x20            Bad YeaR Low/high bit (1=low)
    02206    OCI_DATE_INVALID_HOUR        0x40            Bad HouR
    02207    OCI_DATE_HOUR_BELOW_VALID    0x80            Bad HouR Low/high bit (1=low)
    02208    OCI_DATE_INVALID_MINUTE      0x100           Bad MiNute
    02209    OCI_DATE_MINUTE_BELOW_VALID  0x200           Bad MiNute Low/high bit (1=low)
    02210    OCI_DATE_INVALID_SECOND      0x400           Bad SeCond
    02211    OCI_DATE_SECOND_BELOW_VALID  0x800           bad second Low/high bit (1=low)
    02212    OCI_DATE_DAY_MISSING_FROM_1582 0x1000        Day is one of those "missing"
    02213                                                 from 1582
    02214    OCI_DATE_YEAR_ZERO           0x2000          Year may not equal zero
    02215    OCI_DATE_INVALID_FORMAT      0x8000          Bad date format input
    02216
    02217    So, for example, if the date passed in was 2/0/1990 25:61:10 in
    02218    (month/day/year hours:minutes:seconds format), the erroor returned
    02219    would be OCI_DATE_INVALID_DAY | OCI_DATE_DAY_BELOW_VALID |
    02220    OCI_DATE_INVALID_HOUR | OCI_DATE_INVALID_MINUTE
    02221
    02222    DESCRIPTION:
    02223         Check if the given date is valid.
    02224    RETURNS:
    02225         OCI_SUCCESS if the function completes successfully.
    02226         OCI_INVALID_HANDLE if 'err' is NULL.
    02227         OCI_ERROR if
    02228           'date' and 'valid' pointers are NULL pointers
    02229  */
    02230
    02231 /*--------------------------- OCIDateSysDate --------------------------------*/
    02232
    02233 sword OCIDateSysDate(    OCIError *err, OCIDate *sys_date    );
    02234 /*
    02235    NAME: OCIDateSysDate - OCIDate get current SYStem date and time
    02236    PARAMETERS:
    02237         err (IN/OUT) - error handle. If there is an error, it is
    02238                 recorded in 'err' and this function returns OCI_ERROR.
    02239                 The error recorded in 'err' can be retrieved by calling
    02240                 OCIErrorGet().
    02241         sys_date (OUT) - current system date and time
    02242    DESCRIPTION:
    02243         Returns the current system date and time.
    02244    RETURNS:
    02245         OCI_SUCCESS if the function completes successfully.
    02246         OCI_INVALID_HANDLE if 'err' is NULL.
    02247         OCI_ERROR if
    02248           <to be discovered>
    02249  */
    02250
    02251 /*****************************************************************************/
    02252 /*                  FIXED-LENGTH STRING - CHAR (N)                           */
    02253 /*****************************************************************************/
    02254
    02255 /*
    02256  * An ADT attribute declared as "x CHAR(n)" is mapped to "OCIString *x;".
    02257  * The representation of OCIString * is shown below.
    02258  */
    02259
    02260 /*****************************************************************************/
    02261 /*                  VARIABLE-LENGTH STRING                                   */
    02262 /*****************************************************************************/
    02263
    02264 /*
    02265  * The variable-length string is represented in C as a pointer to OCIString
    02266  * structure. The OCIString structure is opaque to the user. Functions are
    02267  * provided to allow the user to manipulate a variable-length string.
    02268  *
    02269  * A variable-length string can be declared as:
    02270  *
    02271  * OCIString *vstr;
    02272  *
    02273  * For binding variables of type OCIString* in OCI calls (OCIBindByName(),
    02274  * OCIBindByPos() and OCIDefineByPos()) use the external type code SQLT_VST.
    02275  */
    02276 typedef struct OCIString OCIString;
    02277
    02278 /*-------------------------- OCIStringAssign --------------------------------*/
    02279
    02280 sword OCIStringAssign(    OCIEnv *env, OCIError *err, CONST OCIString *rhs,
    02281                           OCIString **lhs    );
    02282 /*
    02283    NAME: OCIStringAssign - OCIString Assign String to String
    02284    PARAMETERS:
    02285         env (IN/OUT) - OCI environment handle initialized in object mode.
    02286         err (IN/OUT) - error handle. If there is an error, it is
    02287                 recorded in 'err' and this function returns OCI_ERROR.
    02288                 The error recorded in 'err' can be retrieved by calling
    02289                 OCIErrorGet().
    02290         rhs (IN) - RHS of the assignment, the type of rhs is also OCIString
    02291         lhs (IN/OUT) - LHS of the assignment
    02292    DESCRIPTION:
    02293         Assign 'rhs' string to 'lhs' string. The 'lhs' string may be
    02294         resized depending upon the size of the 'rhs'. The assigned string is
    02295         null-terminated. The 'length' field will not include the extra byte
    02296         needed for null termination.
    02297    RETURNS:
    02298         OCI_SUCCESS if the function completes successfully.
    02299         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02300         OCI_ERROR if
    02301           out of space error
    02302  */
    02303
    02304 /*---------------------- OCIStringAssignText --------------------------------*/
    02305
    02306 sword OCIStringAssignText(    OCIEnv *env, OCIError *err, CONST oratext *rhs,
    02307                               ub4 rhs_len, OCIString **lhs    );
    02308 /*
    02309    NAME: OCIStringAssignText - OCIString Assign Text string to String
    02310    PARAMETERS:
    02311         env (IN/OUT) - OCI environment handle initialized in object mode.
    02312         err (IN/OUT) - error handle. If there is an error, it is
    02313                 recorded in 'err' and this function returns OCI_ERROR.
    02314                 The error recorded in 'err' can be retrieved by calling
    02315                 OCIErrorGet().
    02316         rhs (IN) - RHS of the assignment, the type of rhs is a text string
    02317         rhs_len (IN) - length of the 'rhs' string
    02318         lhs (IN/OUT) - LHS of the assignment
    02319    DESCRIPTION:
    02320         Assign 'rhs' string to 'lhs' string. The 'lhs' string may be
    02321         resized depending upon the size of the 'rhs'. The assigned string is
    02322         null-terminated. The 'length' field will not include the extra byte
    02323         needed for null termination.
    02324    RETURNS:
    02325         OCI_SUCCESS if the function completes successfully.
    02326         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02327         OCI_ERROR if
    02328           out of space error
    02329  */
    02330
    02331 /*-------------------------- OCIStringResize --------------------------------*/
    02332
    02333 sword OCIStringResize(    OCIEnv *env, OCIError *err, ub4 new_size,
    02334                           OCIString **str    );
    02335 /*
    02336    NAME: OCIStringResize - OCIString ReSiZe string memory
    02337    PARAMETERS:
    02338         env (IN/OUT) - OCI environment handle initialized in object mode.
    02339         err (IN/OUT) - error handle. If there is an error, it is
    02340                 recorded in 'err' and this function returns OCI_ERROR.
    02341                 The error recorded in 'err' can be retrieved by calling
    02342                 OCIErrorGet().
    02343         new_size (IN) - new memory size of the string in bytes
    02344         str (IN/OUT) - allocated memory for the string is freed from the
    02345                 OOCI heap
    02346    DESCRIPTION:
    02347         This function resizes the memory of the given variable-length string in
    02348         the object cache. The contents of the string are NOT preserved.
    02349         This function may allocate the string in a new memory region in
    02350         which case the original memory occupied by the given string will
    02351         be freed. If the input string is null (str == NULL), then this
    02352         function will allocate memory for the string.
    02353
    02354         If the new_size is 0, then this function frees the memory occupied
    02355         by 'str' and a null pointer value is returned.
    02356
    02357         NOTE: The caller must compute 'new_size' taking into account space
    02358         for the null character ('\0').
    02359    RETURNS:
    02360         OCI_SUCCESS if the function completes successfully.
    02361         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02362         OCI_ERROR if
    02363           out of space error
    02364  */
    02365
    02366 /*---------------------------- OCIStringSize --------------------------------*/
    02367
    02368 ub4 OCIStringSize(    OCIEnv *env, CONST OCIString *vs    );
    02369 /*
    02370    NAME: OCIStringSize - OCIString Get String siZe
    02371    PARAMETERS:
    02372         env(IN) - pointer to OCI environment handle
    02373         vs (IN) - string whose size is returned
    02374    DESCRIPTION:
    02375         Return the size of the given string.
    02376    RETURNS:
    02377         size of the string in bytes is returned
    02378  */
    02379
    02380 /*----------------------------- OCIStringPtr --------------------------------*/
    02381
    02382 oratext *OCIStringPtr(    OCIEnv *env, CONST OCIString *vs    );
    02383 /*
    02384    NAME: OCIStringPtr - OCIString Get String Pointer
    02385    PARAMETERS:
    02386         env(IN) - pointer to OCI environment handle
    02387         vs (IN) - pointer to the text of this string is returned
    02388    DESCRIPTION:
    02389         Return the pointer to the text of the given string.
    02390    RETURNS:
    02391         pointer to the text of the string is returned
    02392  */
    02393
    02394 /*----------------------- OCIStringAllocSize --------------------------------*/
    02395
    02396 sword OCIStringAllocSize(    OCIEnv *env, OCIError *err, CONST OCIString *vs,
    02397                              ub4 *allocsize    );
    02398 /*
    02399    NAME: OCIStringAllocSize - OCIString get Allocated SiZe of string memory
    02400                               in bytes
    02401    PARAMETERS:
    02402         env (IN/OUT) - OCI environment handle initialized in object mode.
    02403         err (IN/OUT) - error handle. If there is an error, it is
    02404                 recorded in 'err' and this function returns OCI_ERROR.
    02405                 The error recorded in 'err' can be retrieved by calling
    02406                 OCIErrorGet().
    02407         vs (IN) - string whose allocated size in bytes is returned
    02408         allocsize (OUT) - allocated size of string memory in bytes is returned
    02409    DESCRIPTION:
    02410         Return the allocated size of the string memory in bytes. The
    02411         allocated size is >= actual string size.
    02412    REQUIRES:
    02413         vs is a non-null pointer
    02414    RETURNS:
    02415         OCI_SUCCESS if the function completes successfully.
    02416         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02417         OCI_ERROR on error
    02418  */
    02419
    02420 /*****************************************************************************/
    02421 /*                       VARIABLE-LENGTH RAW                                 */
    02422 /*****************************************************************************/
    02423
    02424 /*
    02425  * The variable-length raw is represented in C as a pointer to OCIRaw
    02426  * structure. The OCIRaw structure is opaque to the user. Functions are
    02427  * provided to allow the user to manipulate a variable-length raw.
    02428  *
    02429  * A variable-length raw can be declared as:
    02430  *
    02431  * OCIRaw *raw;
    02432  *
    02433  * For binding variables of type OCIRaw* in OCI calls (OCIBindByName(),
    02434  * OCIBindByPos() and OCIDefineByPos()) use the external type code SQLT_LVB.
    02435  */
    02436 typedef struct OCIRaw OCIRaw;
    02437
    02438 /*-------------------------- OCIRawAssignRaw --------------------------------*/
    02439
    02440 sword OCIRawAssignRaw(    OCIEnv *env, OCIError *err, CONST OCIRaw *rhs,
    02441                           OCIRaw **lhs    );
    02442 /*
    02443    NAME: OCIRawAssignRaw - OCIRaw Assign Raw (of type OCIRaw*) to
    02444                    Raw (of type OCIRaw*)
    02445    PARAMETERS:
    02446         env (IN/OUT) - OCI environment handle initialized in object mode.
    02447         err (IN/OUT) - error handle. If there is an error, it is
    02448                 recorded in 'err' and this function returns OCI_ERROR.
    02449                 The error recorded in 'err' can be retrieved by calling
    02450                 OCIErrorGet().
    02451         rhs (IN) - RHS of the assignment, the type of rhs is also OCIRaw
    02452         lhs (IN/OUT) - LHS of the assignment
    02453    DESCRIPTION:
    02454         Assign 'rhs' raw to 'lhs' raw. The 'lhs' raw may be
    02455         resized depending upon the size of the 'rhs'.
    02456    RETURNS:
    02457         OCI_SUCCESS if the function completes successfully.
    02458         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02459         OCI_ERROR if
    02460           out of space error
    02461  */
    02462
    02463 /*------------------------ OCIRawAssignBytes --------------------------------*/
    02464
    02465 sword OCIRawAssignBytes(    OCIEnv *env, OCIError *err, CONST ub1 *rhs,
    02466                             ub4 rhs_len, OCIRaw **lhs    );
    02467 /*
    02468    NAME: OCIRawAssignBytes - OCIRaw Assign raw Bytes (of type ub1*) to Raw
    02469                    (of type OCIRaw*)
    02470    PARAMETERS:
    02471         env (IN/OUT) - OCI environment handle initialized in object mode.
    02472         err (IN/OUT) - error handle. If there is an error, it is
    02473                 recorded in 'err' and this function returns OCI_ERROR.
    02474                 The error recorded in 'err' can be retrieved by calling
    02475                 OCIErrorGet().
    02476         rhs (IN) - RHS of the assignment, the type of rhs is ub1 *
    02477         rhs_len (IN) - length of the 'rhs' raw
    02478         lhs (IN/OUT) - LHS of the assignment
    02479    DESCRIPTION:
    02480         Assign 'rhs' raw to 'lhs' raw. The 'lhs' raw may be
    02481         resized depending upon the size of the 'rhs'.
    02482    RETURNS:
    02483         OCI_SUCCESS if the function completes successfully.
    02484         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02485         OCI_ERROR if
    02486           out of space error
    02487  */
    02488
    02489 /*---------------------------- OCIRawResize ---------------------------------*/
    02490
    02491 sword OCIRawResize(    OCIEnv *env, OCIError *err, ub4 new_size,
    02492                        OCIRaw **raw    );
    02493 /*
    02494    NAME: OCIRawResize - OCIRaw ReSiZe memory of variable-length raw
    02495    PARAMETERS:
    02496         env (IN/OUT) - OCI environment handle initialized in object mode.
    02497         err (IN/OUT) - error handle. If there is an error, it is
    02498                 recorded in 'err' and this function returns OCI_ERROR.
    02499                 The error recorded in 'err' can be retrieved by calling
    02500                 OCIErrorGet().
    02501         new_size (IN) - new size of the raw data in bytes
    02502         raw (IN) - variable-length raw pointer; the raw is
    02503                 resized to 'new_size'
    02504    DESCRIPTION:
    02505         This function resizes the memory of the given variable-length raw in
    02506         the object cache.
    02507         The previous contents of the raw are NOT preserved.
    02508         This function may allocate the raw in a new memory region in
    02509         which case the original memory occupied by the given raw will
    02510         be freed. If the input raw is null (raw == NULL), then this
    02511         function will allocate memory for the raw data.
    02512
    02513         If the new_size is 0, then this function frees the memory occupied
    02514         by 'raw' and a null pointer value is returned.
    02515    RETURNS:
    02516         OCI_SUCCESS if the function completes successfully.
    02517         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02518         OCI_ERROR if
    02519           out of space error
    02520  */
    02521
    02522 /*------------------------------- OCIRawSize --------------------------------*/
    02523
    02524 ub4 OCIRawSize(    OCIEnv * env, CONST OCIRaw *raw    );
    02525 /*
    02526    NAME: OCIRawSize - OCIRaw Get Raw siZe
    02527    PARAMETERS:
    02528         env (IN)  - pointer to OCI environment handle
    02529         raw (INT) - raw whose size is returned
    02530    DESCRIPTION:
    02531         Return the size of the given raw.
    02532    RETURNS:
    02533         size of the raw in bytes is returned
    02534  */
    02535
    02536 /*--------------------------------- OCIRawPtr -------------------------------*/
    02537 ub1 *OCIRawPtr(    OCIEnv * env, CONST OCIRaw *raw    );
    02538 /*
    02539    NAME: OCIRawPtr - OCIRaw Get Raw data Pointer
    02540    PARAMETERS:
    02541         env (IN) - pointer to OCI environment handle
    02542         raw (IN) - pointer to the data of this raw is returned
    02543    DESCRIPTION:
    02544         Return the pointer to the data of the given raw.
    02545    RETURNS:
    02546         pointer to the data of the raw is returned
    02547  */
    02548
    02549 /*------------------------------ OCIRawAllocSize ----------------------------*/
    02550
    02551 sword OCIRawAllocSize(    OCIEnv *env, OCIError *err, CONST OCIRaw *raw,
    02552                           ub4 *allocsize    );
    02553 /*
    02554    NAME: OCIRawAllocSize - OCIRaw get Allocated SiZe of raw memory in bytes
    02555    PARAMETERS:
    02556         env (IN/OUT) - OCI environment handle initialized in object mode.
    02557         err (IN/OUT) - error handle. If there is an error, it is
    02558                 recorded in 'err' and this function returns OCI_ERROR.
    02559                 The error recorded in 'err' can be retrieved by calling
    02560                 OCIErrorGet().
    02561         raw (IN) - raw whose allocated size in bytes is returned
    02562         allocsize (OUT) - allocated size of raw memory in bytes is returned
    02563    DESCRIPTION:
    02564         Return the allocated size of the raw memory in bytes. The
    02565         allocated size is >= actual raw size.
    02566    REQUIRES:
    02567         raw is a non-null pointer
    02568    RETURNS:
    02569         OCI_SUCCESS if the function completes successfully.
    02570         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02571         OCI_ERROR upon error
    02572  */
    02573
    02574 /*****************************************************************************/
    02575 /*                     OBJECT REFERENCE OPERATIONS                           */
    02576 /*****************************************************************************/
    02577
    02578 /*
    02579  * See the definition of OCIRef in oro.h.
    02580  *
    02581  * For binding variables of type OCIRef* in OCI calls (OCIBindByName(),
    02582  * OCIBindByPos() and OCIDefineByPos()) use the code SQLT_REF.
    02583  *
    02584  */
    02585
    02586 /*---------------------------- OCIRefClear ----------------------------------*/
    02587 void OCIRefClear(    OCIEnv *env, OCIRef *ref    );
    02588 /*
    02589    NAME: OCIRefClear - OCIRef CLeaR or nullify a ref
    02590    PARAMETERS:
    02591         env (IN)     - pointer to OCI environment handle
    02592         ref (IN/OUT) - ref to clear
    02593    DESCRIPTION:
    02594         Clear or nullify the given ref. A ref is considered to be a null ref
    02595         if it does not contain a valid OID (and thus doesn't point to an
    02596         object). Logically, a null ref is a dangling ref.
    02597
    02598         Note that a null ref is still a valid SQL value and is not SQL-ly null.
    02599         It can be used as a valid non-null constant ref value for NOT NULL
    02600         column or attribute of a row in a table.
    02601
    02602         If a null pointer value is passed as a ref,
    02603         then this function is a no-op.
    02604  */
    02605
    02606 /*--------------------------- OCIRefAssign ----------------------------------*/
    02607 sword OCIRefAssign(    OCIEnv *env, OCIError *err, CONST OCIRef *source,
    02608                        OCIRef **target    );
    02609 /*
    02610    NAME: OCIRefAssign - OCIRef CoPY a ref to another
    02611    PARAMETERS:
    02612         env (IN/OUT) - OCI environment handle initialized in object mode.
    02613         err (IN/OUT) - error handle. If there is an error, it is
    02614                 recorded in 'err' and this function returns OCI_ERROR.
    02615                 The error recorded in 'err' can be retrieved by calling
    02616                 OCIErrorGet().
    02617         source (IN) - ref to copy from
    02618         target (IN/OUT) - ref to copy to
    02619    DESCRIPTION:
    02620         Copy 'source' ref to 'target' ref; both then reference the same
    02621         object. If the target ref pointer is null (i.e. *target == NULL)
    02622         then the copy function will allocate memory for the target ref
    02623         in OOCI heap prior to the copy.
    02624    RETURNS:
    02625         OCI_SUCCESS if the function completes successfully.
    02626         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02627         OCI_ERROR if
    02628           1) out of memory
    02629  */
    02630
    02631 /*-------------------------- OCIRefIsEqual ----------------------------------*/
    02632 boolean OCIRefIsEqual(    OCIEnv *env, CONST OCIRef *x, CONST OCIRef *y    );
    02633 /*
    02634    NAME: OCIRefIsEqual - OCIRef compare two refs for EQUality
    02635    PARAMETERS:
    02636         env (IN) - pointer to OCI environment handle
    02637         x (IN)   - ref to compare
    02638         y (IN)   - ref to compare
    02639    DESCRIPTION:
    02640         Compare the given refs for equality.
    02641         Two refs are equal if and only if:
    02642           - they are both referencing the same persistent object, or
    02643           - they are both referencing the same transient object.
    02644
    02645         NOTE THAT TWO NULL REFS ARE CONSIDERED NOT EQUAL BY THIS FUNCTION.
    02646    RETURNS:
    02647         TRUE if the two refs are equal
    02648         FALSE if the two refs are not equal, or X is NULL, or Y is NULL
    02649  */
    02650
    02651 /*--------------------------- OCIRefIsNull ----------------------------------*/
    02652 boolean OCIRefIsNull(    OCIEnv *env, CONST OCIRef *ref    );
    02653 /*
    02654    NAME: OCIRefIsNull - OCIRef test if a ref is NULl
    02655    PARAMETERS:
    02656         env (IN) - pointer to OCI environment handle
    02657         ref (IN) - ref to test for null
    02658    DESCRIPTION:
    02659         Return TRUE if the given ref is null; otherwise, return FALSE.
    02660         A ref is null if and only if:
    02661         - it is supposed to be referencing a persistent object, but
    02662           its OID is null, or
    02663         - it is supposed to be referencing a transient object, but it is
    02664           currently not pointing to an object.
    02665         A ref is a dangling ref if the object that it points to does not
    02666         exist.
    02667    RETURNS:
    02668         TRUE if the given ref is NULL
    02669         FALSE if the given ref is not NULL
    02670  */
    02671
    02672 /*-------------------------- OCIRefHexSize ----------------------------------*/
    02673 ub4 OCIRefHexSize(    OCIEnv *env, CONST OCIRef *ref    );
    02674 /*
    02675    NAME: OCIRefHexSize - OCIRef Hexadecimal buffer SiZe in bytes
    02676    PARAMETERS:
    02677         env (IN) - pointer to OCI environment handle
    02678         ref (IN) - ref whose size in hexadecimal representation in bytes is
    02679                 returned
    02680    DESCRIPTION:
    02681         Return the size of the buffer in bytes required for the hexadecimal
    02682         representation of the ref. A buffer of at-least this size must be
    02683         passed to ref-to-hex (OCIRefToHex) conversion function.
    02684    RETURNS:
    02685         size of hexadecimal representation of ref
    02686  */
    02687
    02688 /*-------------------------- OCIRefFromHex ---------------------------------*/
    02689 sword OCIRefFromHex(    OCIEnv *env, OCIError *err, CONST OCISvcCtx *svc,
    02690                         CONST oratext *hex, ub4 length, OCIRef **ref    );
    02691 /*
    02692    NAME:
    02693         OCIRefFromHex - OCIRef convert a Hexadecimal string TO a Ref
    02694    PARAMETERS:
    02695         env (IN/OUT) - OCI environment handle initialized in object mode
    02696         err (IN/OUT) - error handle. If there is an error, it is
    02697                 recorded in 'err' and this function returns OCI_ERROR.
    02698                 The error recorded in 'err' can be retrieved by
    02699                 calling OCIErrorGet().
    02700         svc (IN) - OCI service context handle; if the resulting ref is
    02701                 initialized with this service context
    02702         hex (IN) - hexadecimal string (that was produced by 'OCIRefToHex()"
    02703                 previously) to be convert into a ref
    02704         length (IN) - length of the hexadecimal string
    02705         ref (IN/OUT) - ref is initialized with the given value ('hex').
    02706                 If *ref is null, then space for the ref is allocated in the
    02707                 object cache, otherwise the memory occupied by the given ref
    02708                 is re-used.
    02709    DESCRIPTION:
    02710         Convert the given hexadecimal string into a ref. This function
    02711         ensures that the resulting ref is well formed. It does NOT ensure
    02712         that the object pointed to by the resulting ref exists or not.
    02713    RETURNS:
    02714         OCI_SUCCESS if the function completes successfully.
    02715         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02716         OCI_ERROR if
    02717  */
    02718
    02719 /*--------------------------- OCIRefToHex -----------------------------------*/
    02720 sword OCIRefToHex(    OCIEnv *env, OCIError *err, CONST OCIRef *ref,
    02721                       oratext *hex, ub4 *hex_length    );
    02722 /*
    02723    NAME:
    02724         OCIRefToHex - OCIRef convert ref to a Hexadecimal string
    02725    PARAMETERS:
    02726         env (IN/OUT) - OCI environment handle initialized in object mode
    02727         err (IN/OUT) - error handle. If there is an error, it is
    02728                 recorded in 'err' and this function returns OCI_ERROR.
    02729                 The error recorded in 'err' can be retrieved by
    02730                 calling OCIErrorGet().
    02731         ref (IN) - ref to be converted into a hexadecimal string; if the
    02732                 ref is a null ref (i.e. OCIRefIsNull(ref) == TRUE) then
    02733                 a zero hex_length value is returned
    02734         hex (OUT) - buffer that is large enough to contain the resulting
    02735                 hexadecimal string; the contents of the string is opaque
    02736                 to the caller
    02737         hex_length (IN/OUT) - on input specifies the size of the 'hex' buffer,
    02738                 on output specifies the actual size of the hexadecimal
    02739                 string being returned in 'hex'
    02740    DESCRIPTION:
    02741         Convert the given ref into a hexadecimal string, and return the length
    02742         of the string. The resulting string is opaque to the caller.
    02743    RETURNS:
    02744         OCI_SUCCESS if the function completes successfully.
    02745         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02746         OCI_ERROR if
    02747           the given buffer is not big enough to hold the resulting string
    02748  */
    02749
    02750
    02751 /*****************************************************************************/
    02752 /*                          COLLECTION FUNCTIONS                             */
    02753 /*****************************************************************************/
    02754
    02755 /*
    02756    The generic collection is represented by the type 'OCIColl'. The following
    02757    operations OCIColl*() are provided on a generic collection:
    02758      - get current size of collection
    02759      - get upper bound of collection
    02760      - get pointer to an element given its index
    02761      - set element at given index (assign element)
    02762      - append an element
    02763      - trim the given number of elements from the end of the collection
    02764      - collection assignment
    02765
    02766    The following iterator based scanning functions are also provided on a
    02767    generic collection. These functions make use of an iterator which is
    02768    defined to be of type OCIIter.
    02769
    02770      - create an iterator for scanning collection
    02771      - destroy iterator
    02772      - reset iterator to the beginning of collection
    02773      - get pointer to current element pointed by iterator
    02774      - get pointer to next element
    02775      - get pointer to previous element
    02776
    02777    The collections variable-length array (varray) and nested table
    02778    are sub-types of generic collection. This means that the OCIColl*()
    02779    functions can also be used to manipulate varray and nested table.
    02780
    02781    The varray is represented by OCIArray type and nested table by OCITable.
    02782    Besides OCIColl*() functions no additional functions are provided for
    02783    manipulating varrays. The OCIColl*() functions are a complete set of
    02784    functions to manipulate varrays.
    02785
    02786    Besides OCIColl*() functions, the following functions OCITable*() can be
    02787    used to manipulate nested table. The OCITable*() functions operate on
    02788    nested tables only and should not be used on a varray.
    02789
    02790      - delete an element at index i. Note that the position
    02791        ordinals of the remaining elements of the table is not changed by the
    02792        delete operation. So delete creates "holes" in the table.
    02793      - check if an element exists at the given index i
    02794      - return the smallest value of i for which exists(i) is true
    02795      - return the largest value of i for which exists(i) is true
    02796      - return pointer to the smallest position j, greater than i, such that
    02797        OCITableExists(j) is true
    02798      - return pointer to the largest position j, less than i, such that
    02799        OCITableExists(j) is true
    02800
    02801    For binding variables of type OCIColl* or OCITable* in OCI calls
    02802    (OCIBindByName(), OCIBindByPos() and OCIDefineByPos()) use the external
    02803    type code SQLT_NTY.
    02804  */
    02805
    02806 /* OCIColl - generic collection type */
    02807 typedef struct OCIColl OCIColl;
    02808
    02809 /* OCIArray - varray collection type */
    02810 typedef OCIColl OCIArray;
    02811
    02812 /* OCITable - nested table collection type */
    02813 typedef OCIColl OCITable;
    02814
    02815 /* OCIIter - collection iterator */
    02816 typedef struct OCIIter OCIIter;
    02817
    02818 /*----------------------------- OCICollSize ---------------------------------*/
    02819
    02820 sword OCICollSize( OCIEnv *env, OCIError *err, CONST OCIColl *coll,
    02821                    sb4 *size );
    02822 /*
    02823    NAME: OCICollSize - OCIColl return current SIZe of the given collection
    02824    PARAMETERS:
    02825         env(IN) - pointer to OCI environment handle
    02826         err (IN/OUT) - error handle. If there is an error, it is
    02827                 recorded in 'err' and this function returns OCI_ERROR.
    02828                 The error recorded in 'err' can be retrieved by calling
    02829                 OCIErrorGet().
    02830         coll (IN) - collection whose number of elements is returned
    02831         size (OUT) - current number of elements in the collection
    02832    DESCRIPTION:
    02833           Returns the current number of elements in the given collection.
    02834
    02835           For collections of type nested table wherein 'delete element'
    02836           operation is allowed, the count returned by OCICollSize() will
    02837           NOT be decremented upon deleting elements. For example:
    02838
    02839             OCICollSize(...);
    02840             // assume 'size' returned is equal to 5
    02841             OCITableDelete(...); // delete one element
    02842             OCICollSize(...);
    02843             // 'size' returned will still be 5
    02844
    02845           To get the count minus the deleted elements use OCITableSize().
    02846           Continuing the above example,
    02847
    02848             OCITableSize(...)
    02849             // 'size' returned will be equal to 4
    02850
    02851           Note, a trim operation (OCICollTrim) will decrement the count
    02852           by the number of trimmed elements. Continuing the above example,
    02853
    02854             OCICollTrim(..,1..); // trim one element
    02855             OCICollSize(...);
    02856             // 'size' returned will be equal to 4
    02857    RETURNS:
    02858         OCI_SUCCESS if the function completes successfully.
    02859         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02860         OCI_ERROR if
    02861           error during loading of collection into object cache
    02862           any of the input parameters is null
    02863  */
    02864
    02865 /*------------------------------ OCICollMax ---------------------------------*/
    02866
    02867 sb4 OCICollMax(    OCIEnv *env, CONST OCIColl *coll    );
    02868 /*
    02869    NAME: OCICollMax - OCIColl return MAXimum size (upper-bound) of the
    02870                    given collection (in number of elements)
    02871    PARAMETERS:
    02872         env(IN) - pointer to OCI environment handle
    02873         coll (IN) - collection whose upper-bound in number of elements
    02874                 is returned
    02875    DESCRIPTION:
    02876         Returns the max number of elements that the given collection can hold.
    02877         A value 0 indicates that the collection has no upper-bound.
    02878    REQUIRES:
    02879         coll must point to a valid collection descriptor
    02880    RETURNS:
    02881         upper-bound of the given collection
    02882  */
    02883
    02884 /*-------------------------- OCICollGetElem ---------------------------------*/
    02885
    02886 sword OCICollGetElem(    OCIEnv *env, OCIError *err, CONST OCIColl *coll,
    02887                          sb4 index, boolean *exists, dvoid **elem,
    02888                          dvoid **elemind    );
    02889 /*
    02890    NAME: OCICollGetElem - OCIColl GET pointer to the element at the given index
    02891    PARAMETERS:
    02892         env (IN/OUT) - OCI environment handle initialized in object mode.
    02893         err (IN/OUT) - error handle. If there is an error, it is
    02894                 recorded in 'err' and this function returns OCI_ERROR.
    02895                 The error recorded in 'err' can be retrieved by calling
    02896                 OCIErrorGet().
    02897         coll (IN) - pointer to the element in this collection is returned
    02898         index (IN) - index of the element whose pointer is returned
    02899         exists (OUT) - set to FALSE if element at the specified index does
    02900                 not exist else TRUE
    02901         elem (OUT) - address of the desired element is returned
    02902         elemind (OUT) [optional] - address of the null indicator information
    02903                 is returned; if (elemind == NULL) then the null indicator
    02904                 information will NOT be returned
    02905    DESCRIPTION:
    02906         Get the address of the element at the given position. Optionally
    02907         this function also returns the address of the element's null indicator
    02908         information.
    02909
    02910         The following table describes for each collection element type
    02911         what the corresponding element pointer type is. The element pointer
    02912         is returned via the 'elem' parameter of OCICollGetElem().
    02913
    02914            Element Type                       *elem is set to
    02915         -----------------------               ---------------
    02916          Oracle Number (OCINumber)              OCINumber*
    02917          Date (OCIDate)                         OCIDate*
    02918          Variable-length string (OCIString*)    OCIString**
    02919          Variable-length raw (OCIRaw*)          OCIRaw**
    02920          object reference (OCIRef*)             OCIRef**
    02921          lob locator (OCILobLocator*)           OCILobLocator**
    02922          object type (e.g. person)              person*
    02923
    02924         The element pointer returned by OCICollGetElem() is in a form
    02925         such that it can not only be used to access the
    02926         element data but also is in a form that can be used as the target
    02927         (i.e left-hand-side) of an assignment statement.
    02928
    02929         For example, assume the user is iterating over the elements of
    02930         a collection whose element type is object reference (OCIRef*). A call
    02931         to OCICollGetElem() returns pointer to a reference handle
    02932         (i.e. OCIRef**). After getting, the pointer to the collection
    02933         element, the user may wish to modify it by assigning a new reference.
    02934         This can be accomplished via the ref assignment function shown below:
    02935
    02936         sword OCIRefAssign( OCIEnv *env, OCIError *err, CONST OCIRef *source,
    02937                             OCIRef **target );
    02938
    02939         Note that the 'target' parameter of OCIRefAssign() is of type
    02940         'OCIRef**'. Hence OCICollGetElem() returns 'OCIRef**'.
    02941         If '*target == NULL' a new ref will be allocated by OCIRefAssign()
    02942         and returned via the 'target' parameter.
    02943
    02944         Similarly, if the collection element was of type string (OCIString*),
    02945         OCICollGetElem() returns pointer to string handle
    02946         (i.e. OCIString**). If a new string is assigned, via
    02947         OCIStringAssign() or OCIStringAssignText() the type of the target
    02948         must be 'OCIString **'.
    02949
    02950         If the collection element is of type Oracle number, OCICollGetElem()
    02951         returns OCINumber*. The prototype of OCINumberAssign() is shown below:
    02952
    02953         sword OCINumberAssign(OCIError *err, CONST OCINumber *from,
    02954                               OCINumber *to);
    02955    RETURNS:
    02956         OCI_SUCCESS if the function completes successfully.
    02957         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    02958         OCI_ERROR if
    02959           any of the input parameters is null
    02960  */
    02961
    02962 /*------------------------- OCICollGetElemArray -----------------------------*/
    02963
    02964 sword OCICollGetElemArray(  OCIEnv *env, OCIError *err, CONST OCIColl *coll,
    02965                             sb4 index, boolean *exists, dvoid **elem,
    02966                             dvoid **elemind, uword *nelems);
    02967 /*
    02968    NAME: OCICollGetElemArray - OCIColl GET pointers to elements from given index
    02969    PARAMETERS:
    02970         env (IN/OUT) - OCI environment handle initialized in object mode.
    02971         err (IN/OUT) - error handle. If there is an error, it is
    02972                 recorded in 'err' and this function returns OCI_ERROR.
    02973                 The error recorded in 'err' can be retrieved by calling
    02974                 OCIErrorGet().
    02975         coll (IN) - pointers to the elements in this collection is returned
    02976         index (IN) - starting index of the element
    02977         exists (OUT) - set to FALSE if element at the specified index does
    02978                 not exist else TRUE
    02979         elem (OUT) - address of the desired elements is returned
    02980         elemind (OUT) [optional] - address of the null indicators information
    02981                 is returned; if (elemind == NULL) then the null indicator
    02982                 information will NOT be returned
    02983         nelems(IN/OUT) - Upper bound of elem and/or elemind array
    02984    DESCRIPTION:
    02985         Get the address of the elements from the given position. Optionally
    02986         this function also returns the address of the element's null indicator
    02987         information.
    02988
    02989         The following table describes for each collection element type
    02990         what the corresponding element pointer type is. The element pointer
    02991         is returned via the 'elem' parameter of OCICollGetElem().
    02992
    02993            Element Type                       *elem is set to
    02994         -----------------------               ---------------
    02995          Oracle Number (OCINumber)              OCINumber*
    02996          Date (OCIDate)                         OCIDate*
    02997          Variable-length string (OCIString*)    OCIString**
    02998          Variable-length raw (OCIRaw*)          OCIRaw**
    02999          object reference (OCIRef*)             OCIRef**
    03000          lob locator (OCILobLocator*)           OCILobLocator**
    03001          object type (e.g. person)              person*
    03002
    03003         The element pointer returned by OCICollGetElem() is in a form
    03004         such that it can not only be used to access the
    03005         element data but also is in a form that can be used as the target
    03006         (i.e left-hand-side) of an assignment statement.
    03007
    03008         For example, assume the user is iterating over the elements of
    03009         a collection whose element type is object reference (OCIRef*). A call
    03010         to OCICollGetElem() returns pointer to a reference handle
    03011         (i.e. OCIRef**). After getting, the pointer to the collection
    03012         element, the user may wish to modify it by assigning a new reference.
    03013         This can be accomplished via the ref assignment function shown below:
    03014
    03015         sword OCIRefAssign( OCIEnv *env, OCIError *err, CONST OCIRef *source,
    03016                             OCIRef **target );
    03017
    03018         Note that the 'target' parameter of OCIRefAssign() is of type
    03019         'OCIRef**'. Hence OCICollGetElem() returns 'OCIRef**'.
    03020         If '*target == NULL' a new ref will be allocated by OCIRefAssign()
    03021         and returned via the 'target' parameter.
    03022
    03023         Similarly, if the collection element was of type string (OCIString*),
    03024         OCICollGetElem() returns pointer to string handle
    03025         (i.e. OCIString**). If a new string is assigned, via
    03026         OCIStringAssign() or OCIStringAssignText() the type of the target
    03027         must be 'OCIString **'.
    03028
    03029         If the collection element is of type Oracle number, OCICollGetElem()
    03030         returns OCINumber*. The prototype of OCINumberAssign() is shown below:
    03031
    03032         sword OCINumberAssign(OCIError *err, CONST OCINumber *from,
    03033                               OCINumber *to);
    03034    RETURNS:
    03035         OCI_SUCCESS if the function completes successfully.
    03036         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03037         OCI_ERROR if
    03038           any of the input parameters is null
    03039  */
    03040
    03041 /*----------------------- OCICollAssignElem ---------------------------------*/
    03042
    03043 sword OCICollAssignElem(    OCIEnv *env, OCIError *err, sb4 index,
    03044                             CONST dvoid *elem,
    03045                             CONST dvoid *elemind, OCIColl *coll    );
    03046 /*
    03047    NAME: OCICollAssignElem - OCIColl ASsign Element
    03048    PARAMETERS:
    03049         env (IN/OUT) - OCI environment handle initialized in object mode.
    03050         err (IN/OUT) - error handle. If there is an error, it is
    03051                 recorded in 'err' and this function returns OCI_ERROR.
    03052                 The error recorded in 'err' can be retrieved by calling
    03053                 OCIErrorGet().
    03054         index (IN) - index of the element whose is assigned to
    03055         elem (IN) - element which is assigned from (source element)
    03056         elemind (IN) [optional] - pointer to the element's null indicator
    03057                 information; if (elemind == NULL) then the null indicator
    03058                 information of the assigned element will be set to non-null.
    03059         coll (IN/OUT) - collection to be updated
    03060    DESCRIPTION:
    03061         Assign the given element value 'elem' to the element at coll[index].
    03062         If the collection is of type nested table, the element at the given
    03063         index may not exist (i.e. may have been deleted). In this case, the
    03064         given element is inserted at index 'index'.
    03065         Otherwise, the element at index 'index' is updated with the value
    03066         of 'elem'.
    03067
    03068         Note that the given element is deep-copied and
    03069         'elem' is strictly an input parameter.
    03070    RETURNS:
    03071         OCI_SUCCESS if the function completes successfully.
    03072         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03073         OCI_ERROR if
    03074           any of the input parameters is null
    03075           out of memory error
    03076           given index is out of bounds of the given collection
    03077  */
    03078
    03079 /*--------------------------- OCICollAssign ---------------------------------*/
    03080
    03081 sword OCICollAssign(    OCIEnv *env, OCIError *err, CONST OCIColl *rhs,
    03082                         OCIColl *lhs    );
    03083 /*
    03084    NAME: OCICollAssign - OCIColl ASsiGn collection
    03085    PARAMETERS:
    03086         env (IN/OUT) - OCI environment handle initialized in object mode.
    03087         err (IN/OUT) - error handle. If there is an error, it is
    03088                 recorded in 'err' and this function returns OCI_ERROR.
    03089                 The error recorded in 'err' can be retrieved by calling
    03090                 OCIErrorGet().
    03091         rhs (IN) - collection to be assigned from
    03092         lhs (OUT) - collection to be assigned to
    03093    DESCRIPTION:
    03094         Assign 'rhs' to 'lhs'. The 'lhs' collection may be decreased or
    03095         increased depending upon the size of 'rhs'. If the 'lhs' contains
    03096         any elements then the elements will be deleted prior to the
    03097         assignment. This function performs a deep-copy. The memory for the
    03098         elements comes from the object cache.
    03099
    03100         An error is returned if the element types of the lhs and rhs
    03101         collections do not match. Also, an error is returned if the
    03102         upper-bound of the lhs collection is less than the current number of
    03103         elements in the rhs collection.
    03104    RETURNS:
    03105         OCI_SUCCESS if the function completes successfully.
    03106         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03107         OCI_ERROR if
    03108           any of the input parameters is null
    03109           out of memory error
    03110           type mis-match of lhs and rhs collections
    03111           upper-bound of lhs collection is less than the current number of
    03112           elements in the rhs collection
    03113  */
    03114
    03115 /*--------------------------- OCICollAppend ---------------------------------*/
    03116
    03117 sword OCICollAppend(    OCIEnv *env, OCIError *err, CONST dvoid *elem,
    03118                         CONST dvoid *elemind, OCIColl *coll    );
    03119 /*
    03120    NAME: OCICollAppend - OCIColl APPend collection
    03121    PARAMETERS:
    03122         env (IN/OUT) - OCI environment handle initialized in object mode.
    03123         err (IN/OUT) - error handle. If there is an error, it is
    03124                 recorded in 'err' and this function returns OCI_ERROR.
    03125                 The error recorded in 'err' can be retrieved by calling
    03126                 OCIErrorGet().
    03127         elem (IN) - pointer to the element which is appended to the end
    03128                 of the given collection
    03129         elemind (IN) [optional] - pointer to the element's null indicator
    03130                 information; if (elemind == NULL) then the null indicator
    03131                 information of the appended element will be set to non-null.
    03132         coll (IN/OUT) - updated collection
    03133    DESCRIPTION:
    03134         Append the given element to the end of the given collection.
    03135         Appending an element is equivalent to:
    03136           - increasing the size of the collection by 1 element
    03137           - updating (deep-copying) the last element's data with the given
    03138             element's data
    03139
    03140         Note that the pointer to the given element 'elem' will not be saved
    03141         by this function. So 'elem' is strictly an input parameter.
    03142         An error is returned if the current size of the collection
    03143         is equal to the max size (upper-bound) of the collection prior to
    03144         appending the element.
    03145    RETURNS:
    03146         OCI_SUCCESS if the function completes successfully.
    03147         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03148         OCI_ERROR if
    03149           any of the input parameters is null
    03150           out of memory error
    03151           current size of collection == max size of the collection
    03152  */
    03153
    03154 /*----------------------------- OCICollTrim ---------------------------------*/
    03155
    03156 sword OCICollTrim(    OCIEnv *env, OCIError *err, sb4 trim_num,
    03157                       OCIColl *coll    );
    03158 /*
    03159    NAME: OCICollTrim - OCIColl Trim elements from the end of the collection
    03160    PARAMETERS:
    03161         env (IN/OUT) - OCI environment handle initialized in object mode.
    03162         err (IN/OUT) - error handle. If there is an error, it is
    03163                 recorded in 'err' and this function returns OCI_ERROR.
    03164                 The error recorded in 'err' can be retrieved by calling
    03165                 OCIErrorGet().
    03166         trim_num (IN) - number of elements to trim
    03167         coll (IN/OUT) - 'trim_num' of elements are removed (freed) from the
    03168                 end of the collection
    03169    DESCRIPTION:
    03170         Trim the collection by the given number of elements. The elements are
    03171         removed from the end of the collection.
    03172
    03173         An error is returned if the 'trim_num' is greater than the current
    03174         size of the collection.
    03175    RETURNS:
    03176         OCI_SUCCESS if the function completes successfully.
    03177         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03178         OCI_ERROR if
    03179           any of the input parameters is null
    03180           'trim_num' is greater than the current size of the collection.
    03181  */
    03182
    03183 /*--------------------------- OCICollIsLocator ------------------------------*/
    03184
    03185 sword OCICollIsLocator(OCIEnv *env, OCIError *err, CONST OCIColl *coll,
    03186                        boolean *result );
    03187 /*
    03188 Name: OCICollIsLocator - OCIColl indicates whether a collection is locator
    03189                          based or not.
    03190 Parameters:
    03191         env(IN) - pointer to OCI environment handle
    03192         err (IN/OUT) - error handle. If there is an error, it is
    03193                 recorded in 'err' and this function returns OCI_ERROR.
    03194                 The error recorded in 'err' can be retrieved by calling
    03195                 OCIErrorGet().
    03196         coll (IN) - collection item.
    03197         result (OUT) - TRUE if the collection item is a locator, FALSE
    03198                        otherwise
    03199 Description:
    03200         Returns TRUE in the result OUT parameter if the collection item is a
    03201         locator, otherwise returns FALSE.
    03202 Returns:
    03203         OCI_SUCCESS if the function completes successfully.
    03204         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03205 */
    03206
    03207 /*---------------------------- OCIIterCreate --------------------------------*/
    03208
    03209 sword OCIIterCreate(    OCIEnv *env, OCIError *err, CONST OCIColl *coll,
    03210                         OCIIter **itr    );
    03211 /*
    03212    NAME: OCIIterCreate - OCIColl Create an ITerator to scan the collection
    03213                       elements
    03214    PARAMETERS:
    03215         env (IN/OUT) - OCI environment handle initialized in object mode.
    03216         err (IN/OUT) - error handle. If there is an error, it is
    03217                 recorded in 'err' and this function returns OCI_ERROR.
    03218                 The error recorded in 'err' can be retrieved by calling
    03219                 OCIErrorGet().
    03220         coll (IN) - collection which will be scanned; the different
    03221                 collection types are varray and nested table
    03222         itr (OUT) - address to the allocated collection iterator is
    03223                 returned by this function
    03224    DESCRIPTION:
    03225         Create an iterator to scan the elements of the collection. The
    03226         iterator is created in the object cache. The iterator is initialized
    03227         to point to the beginning of the collection.
    03228
    03229         If the next function (OCIIterNext) is called immediately
    03230         after creating the iterator then the first element of the collection
    03231         is returned.
    03232         If the previous function (OCIIterPrev) is called immediately after
    03233         creating the iterator then "at beginning of collection" error is
    03234         returned.
    03235    RETURNS:
    03236         OCI_SUCCESS if the function completes successfully.
    03237         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03238         OCI_ERROR if
    03239           any of the input parameters is null
    03240           out of memory error
    03241  */
    03242
    03243 /*----------------------------- OCIIterDelete ------------------------------*/
    03244
    03245 sword OCIIterDelete(    OCIEnv *env, OCIError *err, OCIIter **itr    );
    03246 /*
    03247    NAME: OCIIterDelete - OCIColl Delete ITerator
    03248    PARAMETERS:
    03249         env (IN/OUT) - OCI environment handle initialized in object mode.
    03250         err (IN/OUT) - error handle. If there is an error, it is
    03251                 recorded in 'err' and this function returns OCI_ERROR.
    03252                 The error recorded in 'err' can be retrieved by calling
    03253                 OCIErrorGet().
    03254         itr (IN/OUT) - the allocated collection iterator is destroyed and
    03255                 the 'itr' is set to NULL prior to returning
    03256    DESCRIPTION:
    03257         Delete the iterator which was previously created by a call to
    03258         OCIIterCreate.
    03259    RETURNS:
    03260         OCI_SUCCESS if the function completes successfully.
    03261         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03262         OCI_ERROR if
    03263           any of the input parameters is null
    03264           to be discovered
    03265  */
    03266
    03267 /*----------------------------- OCIIterInit ---------------------------------*/
    03268
    03269 sword OCIIterInit(    OCIEnv *env, OCIError *err, CONST OCIColl *coll,
    03270                       OCIIter *itr    );
    03271 /*
    03272    NAME: OCIIterInit - OCIColl Initialize ITerator to scan the given
    03273                    collection
    03274    PARAMETERS:
    03275         env (IN/OUT) - OCI environment handle initialized in object mode.
    03276         err (IN/OUT) - error handle. If there is an error, it is
    03277                 recorded in 'err' and this function returns OCI_ERROR.
    03278                 The error recorded in 'err' can be retrieved by calling
    03279                 OCIErrorGet().
    03280         coll (IN) - collection which will be scanned; the different
    03281                 collection types are varray and nested table
    03282         itr (IN/OUT) - pointer to an allocated  collection iterator
    03283    DESCRIPTION:
    03284         Initializes the given iterator to point to the beginning of the
    03285         given collection. This function can be used to:
    03286
    03287         a. reset an iterator to point back to the beginning of the collection
    03288         b. reuse an allocated iterator to scan a different collection
    03289    RETURNS:
    03290         OCI_SUCCESS if the function completes successfully.
    03291         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03292         OCI_ERROR if
    03293           any of the input parameters is null
    03294  */
    03295
    03296 /*------------------------ OCIIterGetCurrent --------------------------------*/
    03297
    03298 sword OCIIterGetCurrent(    OCIEnv *env, OCIError *err, CONST OCIIter *itr,
    03299                             dvoid **elem, dvoid **elemind    );
    03300 /*
    03301    NAME: OCIIterGetCurrent - OCIColl Iterator based, get CURrent collection
    03302                     element
    03303    PARAMETERS:
    03304         env (IN/OUT) - OCI environment handle initialized in object mode.
    03305         err (IN/OUT) - error handle. If there is an error, it is
    03306                 recorded in 'err' and this function returns OCI_ERROR.
    03307                 The error recorded in 'err' can be retrieved by calling
    03308                 OCIErrorGet().
    03309         itr (IN) - iterator which points to the current element
    03310         elem (OUT) - address of the element pointed by the iterator is returned
    03311         elemind (OUT) [optional] - address of the element's null indicator
    03312                 information is returned; if (elemind == NULL) then the null
    03313                 indicator information will NOT be returned
    03314    DESCRIPTION:
    03315         Returns pointer to the current element and its corresponding null
    03316         information.
    03317    RETURNS:
    03318         OCI_SUCCESS if the function completes successfully.
    03319         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03320         OCI_ERROR if
    03321           any of the input parameters is null
    03322  */
    03323
    03324 /*------------------------------ OCIIterNext --------------------------------*/
    03325
    03326 sword OCIIterNext(    OCIEnv *env, OCIError *err, OCIIter *itr,
    03327                       dvoid **elem, dvoid **elemind, boolean *eoc    );
    03328 /*
    03329    NAME: OCIIterNext - OCIColl Iterator based, get NeXT collection element
    03330    PARAMETERS:
    03331         env (IN/OUT) - OCI environment handle initialized in object mode.
    03332         err (IN/OUT) - error handle. If there is an error, it is
    03333                 recorded in 'err' and this function returns OCI_ERROR.
    03334                 The error recorded in 'err' can be retrieved by calling
    03335                 OCIErrorGet().
    03336         itr (IN/OUT) - iterator is updated to point to the next element
    03337         elem (OUT) - after updating the iterator to point to the next element,
    03338                 address of the element is returned
    03339         elemind (OUT) [optional] - address of the element's null indicator
    03340                 information is returned; if (elemind == NULL) then the null
    03341                 indicator information will NOT be returned
    03342         eoc (OUT) - TRUE if iterator is at End Of Collection (i.e. next
    03343                 element does not exist) else FALSE
    03344    DESCRIPTION:
    03345         Returns pointer to the next element and its corresponding null
    03346         information. The iterator is updated to point to the next element.
    03347
    03348         If the iterator is pointing to the last element of the collection
    03349         prior to executing this function, then calling this function will
    03350         set eoc flag to TRUE. The iterator will be left unchanged in this
    03351         situation.
    03352    RETURNS:
    03353         OCI_SUCCESS if the function completes successfully.
    03354         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03355         OCI_ERROR if
    03356           any of the input parameters is null
    03357  */
    03358
    03359 /*------------------------------ OCIIterPrev --------------------------------*/
    03360
    03361 sword OCIIterPrev(    OCIEnv *env, OCIError *err, OCIIter *itr,
    03362                       dvoid **elem, dvoid **elemind, boolean *boc    );
    03363 /*
    03364    NAME: OCIIterPrev - OCIColl Iterator based, get PReVious collection element
    03365    PARAMETERS:
    03366         env (IN/OUT) - OCI environment handle initialized in object mode.
    03367         err (IN/OUT) - error handle. If there is an error, it is
    03368                 recorded in 'err' and this function returns OCI_ERROR.
    03369                 The error recorded in 'err' can be retrieved by calling
    03370                 OCIErrorGet().
    03371         itr (IN/OUT) - iterator is updated to point to the previous
    03372                 element
    03373         elem (OUT) - after updating the iterator to point to the previous
    03374                 element, address of the element is returned
    03375         elemind (OUT) [optional] - address of the element's null indicator
    03376                 information is returned; if (elemind == NULL) then the null
    03377                 indicator information will NOT be returned
    03378         boc (OUT) - TRUE if iterator is at Beginning Of Collection (i.e.
    03379                 previous element does not exist) else FALSE.
    03380    DESCRIPTION:
    03381         Returns pointer to the previous element and its corresponding null
    03382         information. The iterator is updated to point to the previous element.
    03383
    03384         If the iterator is pointing to the first element of the collection
    03385         prior to executing this function, then calling this function will
    03386         set 'boc' to TRUE. The iterator will be left unchanged in this
    03387         situation.
    03388    RETURNS:
    03389         OCI_SUCCESS if the function completes successfully.
    03390         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03391         OCI_ERROR if
    03392           any of the input parameters is null
    03393  */
    03394
    03395 /*****************************************************************************/
    03396 /*           FUNCTIONS WHICH OPERATE ONLY ON NESTED TABLE OCITable*()        */
    03397 /*****************************************************************************/
    03398
    03399 /*---------------------------- OCITableSize ---------------------------------*/
    03400
    03401 sword OCITableSize( OCIEnv *env, OCIError *err, CONST OCITable *tbl,
    03402                     sb4 *size);
    03403 /*
    03404    NAME: OCITableSize - OCITable return current SIZe of the given
    03405                    nested table (not including deleted elements)
    03406    PARAMETERS:
    03407         env(IN) - pointer to OCI environment handle
    03408         err (IN/OUT) - error handle. If there is an error, it is
    03409                 recorded in 'err' and this function returns OCI_ERROR.
    03410                 The error recorded in 'err' can be retrieved by calling
    03411                 OCIErrorGet().
    03412         tbl (IN) - nested table whose number of elements is returned
    03413         size (OUT) - current number of elements in the nested table. The count
    03414                 does not include deleted elements.
    03415    DESCRIPTION:
    03416         Returns the count of elements in the given nested table.
    03417
    03418         The count returned by OCITableSize() will be decremented upon
    03419         deleting elements from the nested table. So, this count DOES NOT
    03420         includes any "holes" created by deleting elements.
    03421         For example:
    03422
    03423             OCITableSize(...);
    03424             // assume 'size' returned is equal to 5
    03425             OCITableDelete(...); // delete one element
    03426             OCITableSize(...);
    03427             // 'size' returned will be equal to 4
    03428
    03429         To get the count plus the count of deleted elements use
    03430         OCICollSize(). Continuing the above example,
    03431
    03432             OCICollSize(...)
    03433             // 'size' returned will still be equal to 5
    03434    RETURNS:
    03435         OCI_SUCCESS if the function completes successfully.
    03436         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03437         OCI_ERROR if
    03438           error during loading of nested table into object cache
    03439           any of the input parameters is null
    03440  */
    03441
    03442 /*---------------------- OCITableExists ---------------------------------*/
    03443
    03444 sword OCITableExists(    OCIEnv *env, OCIError *err, CONST OCITable *tbl,
    03445                              sb4 index, boolean *exists    );
    03446 /*
    03447    NAME: OCITableExists - OCITable test whether element at the given index
    03448                     EXIsts
    03449    PARAMETERS:
    03450         env (IN/OUT) - OCI environment handle initialized in object mode.
    03451         err (IN/OUT) - error handle. If there is an error, it is
    03452                 recorded in 'err' and this function returns OCI_ERROR.
    03453                 The error recorded in 'err' can be retrieved by calling
    03454                 OCIErrorGet().
    03455         tbl (IN) - table in which the given index is checked
    03456         index (IN) - index of the element which is checked for existence
    03457         exists (OUT) - set to TRUE if element at given 'index' exists
    03458                 else set to FALSE
    03459    DESCRIPTION:
    03460         Test whether an element exists at the given 'index'.
    03461    RETURNS:
    03462         OCI_SUCCESS if the function completes successfully.
    03463         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03464         OCI_ERROR if
    03465           any of the input parameters is null
    03466  */
    03467
    03468 /*--------------------------- OCITableDelete -------------------------------*/
    03469
    03470 sword OCITableDelete(    OCIEnv *env, OCIError *err, sb4 index,
    03471                       OCITable *tbl    );
    03472 /*
    03473    NAME: OCITableDelete - OCITable DELete element at the specified index
    03474    PARAMETERS:
    03475         env (IN/OUT) - OCI environment handle initialized in object mode.
    03476         err (IN/OUT) - error handle. If there is an error, it is
    03477                 recorded in 'err' and this function returns OCI_ERROR.
    03478                 The error recorded in 'err' can be retrieved by calling
    03479                 OCIErrorGet().
    03480         index (IN) - index of the element which must be deleted
    03481         tbl (IN) - table whose element is deleted
    03482    DESCRIPTION:
    03483         Delete the element at the given 'index'. Note that the position
    03484         ordinals of the remaining elements of the table is not changed by the
    03485         delete operation. So delete creates "holes" in the table.
    03486
    03487         An error is returned if the element at the specified 'index' has
    03488         been previously deleted.
    03489    RETURNS:
    03490         OCI_SUCCESS if the function completes successfully.
    03491         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03492         OCI_ERROR if
    03493           any of the input parameters is null
    03494           given index is not valid
    03495  */
    03496
    03497 /*--------------------------- OCITableFirst ---------------------------------*/
    03498
    03499 sword OCITableFirst(    OCIEnv *env, OCIError *err, CONST OCITable *tbl,
    03500                         sb4 *index     );
    03501 /*
    03502    NAME: OCITableFirst - OCITable return FirST index of table
    03503    PARAMETERS:
    03504         env (IN/OUT) - OCI environment handle initialized in object mode.
    03505         err (IN/OUT) - error handle. If there is an error, it is
    03506                 recorded in 'err' and this function returns OCI_ERROR.
    03507                 The error recorded in 'err' can be retrieved by calling
    03508                 OCIErrorGet().
    03509         tbl (IN) - table which is scanned
    03510         index (OUT) - first index of the element which exists in the given
    03511                 table is returned
    03512    DESCRIPTION:
    03513         Return the first index of the element which exists in the given
    03514         table.
    03515    RETURNS:
    03516         OCI_SUCCESS if the function completes successfully.
    03517         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03518         OCI_ERROR if
    03519           table is empty
    03520  */
    03521
    03522 /*---------------------------- OCITableLast ---------------------------------*/
    03523
    03524 sword OCITableLast(    OCIEnv *env, OCIError *err, CONST OCITable *tbl,
    03525                        sb4 *index     );
    03526 /*
    03527    NAME: OCITableFirst - OCITable return LaST index of table
    03528    PARAMETERS:
    03529         env (IN/OUT) - OCI environment handle initialized in object mode.
    03530         err (IN/OUT) - error handle. If there is an error, it is
    03531                 recorded in 'err' and this function returns OCI_ERROR.
    03532                 The error recorded in 'err' can be retrieved by calling
    03533                 OCIErrorGet().
    03534         tbl (IN) - table which is scanned
    03535         index (OUT) - last index of the element which exists in the given
    03536                 table is returned
    03537    DESCRIPTION:
    03538         Return the last index of the element which exists in the given
    03539         table.
    03540    RETURNS:
    03541         OCI_SUCCESS if the function completes successfully.
    03542         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03543         OCI_ERROR if
    03544           table is empty
    03545  */
    03546
    03547 /*---------------------------- OCITableNext ---------------------------------*/
    03548
    03549 sword OCITableNext(    OCIEnv *env, OCIError *err, sb4 index,
    03550                        CONST OCITable *tbl, sb4 *next_index,
    03551                        boolean *exists    );
    03552 /*
    03553    NAME: OCITableNext - OCITable return NeXT available index of table
    03554    PARAMETERS:
    03555         env (IN/OUT) - OCI environment handle initialized in object mode.
    03556         err (IN/OUT) - error handle. If there is an error, it is
    03557                 recorded in 'err' and this function returns OCI_ERROR.
    03558                 The error recorded in 'err' can be retrieved by calling
    03559                 OCIErrorGet().
    03560         index (IN) - starting at 'index' the index of the next element
    03561                 which exists is returned
    03562         tbl (IN) - table which is scanned
    03563         next_index (OUT) - index of the next element which exists
    03564                 is returned
    03565         exists (OUT) - FALSE if no next index available else TRUE
    03566    DESCRIPTION:
    03567         Return the smallest position j, greater than 'index', such that
    03568         exists(j) is TRUE.
    03569    RETURNS:
    03570         OCI_SUCCESS if the function completes successfully.
    03571         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03572         OCI_ERROR if
    03573           no next index available
    03574  */
    03575
    03576 /*---------------------------- OCITablePrev ---------------------------------*/
    03577
    03578 sword OCITablePrev(    OCIEnv *env, OCIError *err, sb4 index,
    03579                        CONST OCITable *tbl, sb4 *prev_index,
    03580                        boolean *exists    );
    03581 /*
    03582    NAME: OCITablePrev - OCITable return PReVious available index of table
    03583    PARAMETERS:
    03584         env (IN/OUT) - OCI environment handle initialized in object mode.
    03585         err (IN/OUT) - error handle. If there is an error, it is
    03586                 recorded in 'err' and this function returns OCI_ERROR.
    03587                 The error recorded in 'err' can be retrieved by calling
    03588                 OCIErrorGet().
    03589         index (IN) - starting at 'index' the index of the previous element
    03590                 which exists is returned
    03591         tbl (IN) - table which is scanned
    03592         prev_index (OUT) - index of the previous element which exists
    03593                 is returned
    03594         exists (OUT) - FALSE if no next index available else TRUE
    03595    DESCRIPTION:
    03596         Return the largest position j, less than 'index', such that
    03597         exists(j) is TRUE.
    03598    RETURNS:
    03599         OCI_SUCCESS if the function completes successfully.
    03600         OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
    03601         OCI_ERROR if
    03602           no previous index available
    03603  */
    03604
    03605 /*------------------------ OCINumberToLnx -----------------------------------*/
    03606 /* void OCINumberToLnx(/o_ OCINumber *num _o/); */
    03607
    03608 #define OCINumberToLnx(num) ((lnxnum_t *)num)
    03609
    03610 /*
    03611    NAME:   OCINumberToLnx
    03612    PARAMETERS:
    03613            num (IN) - OCINumber to convert ;
    03614    DESCRIPTION:
    03615            Converts OCINumber to its internal lnx format
    03616            This is not to be used in Public interfaces , but
    03617            has been provided due to special requirements from
    03618            SQLPLUS development group as they require to call
    03619            Core funtions directly .
    03620 */
    03621
    03622 /* OCI representation of XMLType */
    03623 typedef struct OCIXMLType OCIXMLType;
    03624
    03625 /* OCI representation of OCIDomDocument */
    03626 typedef struct OCIDOMDocument OCIDOMDocument;
    03627
    03628 #endif /* ORL_ORACLE */

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines