| 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/ocikp.h
Go to the documentation of this file.

    00001 /*
    00002  * $Header$
    00003  */
    00004 /* Copyright (c) 1996, 2002, Oracle Corporation.  All rights reserved.  */
    00005
    00006 /* NOTE:  See 'header_template.doc' in the 'doc' dve under the 'forms'
    00007       directory for the header file template that includes instructions.
    00008 */
    00009
    00010 /*
    00011    NAME
    00012      ocikp.h - Prototypes of V8 OCI functions in K&R style
    00013
    00014    DESCRIPTION
    00015      defines the prototypes of V8 OCI functions in K&R style
    00016
    00017    RELATED DOCUMENTS
    00018
    00019    INSPECTION STATUS
    00020      Inspection date:
    00021      Inspection status:
    00022      Estimated increasing cost defects per page:
    00023      Rule sets:
    00024
    00025    ACCEPTANCE REVIEW STATUS
    00026      Review date:
    00027      Review status:
    00028      Reviewers:
    00029
    00030    PUBLIC FUNCTION(S)
    00031      <list of external functions declared/defined - with one-line descriptions>
    00032
    00033    PRIVATE FUNCTION(S)
    00034      <list of static functions defined in .c file - with one-line descriptions>
    00035
    00036    EXAMPLES
    00037
    00038    NOTES
    00039      <other useful comments, qualifications, etc.>
    00040
    00041    MODIFIED   (MM/DD/YY)
    00042    sichandr    02/12/02 - fix OCIXMLTypeExists
    00043    gayyappa    02/01/02 - fix 2210776 : change Dom to DOM
    00044    sichandr    10/24/01 - OCISvcCtx for XMLType create routines
    00045    schandir    09/24/01 - Add prototypes for Stmt Caching
    00046    abande      09/04/01 - Add Prototypes for Session Pooling Methods
    00047    stakeda     09/24/01 - add OCINlsCharSetConvert and
    00048                           OCINlsEnvironmentVariableGet.
    00049    whe         08/28/01 - add OCIEnvNlsCreate
    00050    wzhang      08/22/01 - Add OCINlsCharSetNameToId.
    00051    whe         10/05/01 - add prototype for OCIXMLType functions
    00052    mdmehta     04/06/01 - Bug 1683763, OCIDateTimeToText: buf_size to ub4*
    00053    schandir    12/12/00 - modify the ociconnectionpoolcreate() interface.
    00054    porangas    12/04/00 - Forward merge bug#974710 to 9i
    00055    gtarora     11/30/00 - fix comment for OCILobIsTemporary
    00056    akatti      11/07/00 - [1198379]:add OCIRowidToChar
    00057    bpalaval    10/15/00 - Forward merge 892654.
    00058    kmohan      09/18/00 - add OCILogon2
    00059    etucker     07/28/00 - add OCIIntervalFromTZ
    00060    vjayaram    07/18/00 - add connection pooling changes
    00061    etucker     07/13/00 - add dls apis for oci
    00062    hmasaki     07/05/00 - fix 1230846: forward merge into 8.2
    00063    mbastawa    06/05/00 - add OCIStmtFetch2
    00064    rxgovind    06/07/00 - update OCIAnyData interfaces
    00065    rxgovind    05/04/00 - add OCIAnyDataSet interfaces
    00066    rkasamse    05/01/00 - add ocianydata i/f
    00067    slari       09/01/99 - remove OCIEnvCallback
    00068    slari       08/23/99 - add OCIUcb in user callback functions
    00069    whe         09/01/99 - 976457:check __cplusplus for C++ code
    00070    dsaha       07/07/99 - Add OCIFEnvCreate for forms
    00071   vyanaman    06/21/99 - Change OCI DateTime/Interval APIs.
    00072    esoyleme    07/01/99 - expose MTS performance enhancements
    00073    whe         06/14/99 - bug727872:add CONST to match definitions
    00074    kkarun      02/23/99 - Fix OCIDateTime APIs
    00075    jiyang      12/07/98 - Add comments for OCI_NLS_DUAL_CURRENCY
    00076    aroy        12/01/98 - add OCIEnvCreate
    00077    slari       11/23/98 - use ORASTDARG
    00078    slari       11/22/98 - use arglist in OCIUserCallback
    00079    slari       11/21/98 - replace ellipsis by arglist in OCIUserCallback
    00080    thchang     10/20/98 - correct comment on OCILobCreateTemporary
    00081    sgollapu    09/30/98 - Fix bug 725473
    00082    slari       09/08/98 - allow envh to receive error info also in CallbackReg/
    00083    lchidamb    07/07/98 - change comments
    00084    aroy        08/04/98 - add OCITerminate calls
    00085    sgollapu    06/30/98 - Add OCISubscription* prototypes
    00086    nramakri    06/25/98 - remove CONST from some OCIPickler APIs
    00087    jiyang      06/22/98 - Fix a lint error
    00088    nmallava    06/08/98 - ociistemporary -> envhp
    00089    jhasenbe    05/27/98 - Remove definitions for U-Calls (Unicode)
    00090    nmallava    05/18/98 - correct comment
    00091    sgollapu    05/19/98 - Change text to OraText
    00092    aroy        04/20/98 - merge forward 8.0.5 -> 8.1.3
    00093    nbhatt      05/14/98 - aq listen call
    00094    vyanaman    04/19/98 - system timestamp
    00095    kkarun      04/17/98 - Add more Interval functions
    00096    vyanaman    04/16/98 - Add get/set TZ
    00097    kkarun      04/13/98 - add datetime prototypes
    00098    rkasamse    04/13/98 - change OCIEnv* to dvoid* for context/memory cart serv
    00099    rkasamse    04/15/98 - chage pickler cart interface
    00100    slari       03/20/98 - change proto of OCIUserCallback
    00101    slari       02/17/98 - add OCIEnvCallback
    00102    jiyang      04/02/98 - Accept both env and user handles for NLS
    00103    nmallava    04/09/98 - OCILobLocatorAssign
    00104    nmallava    04/07/98 - fix compiler warnings
    00105    jhasenbe    04/06/98 - Add new interfaces for Unicode support
    00106    skabraha    03/24/98 - fixing prototype mismatch
    00107    tsaulys     03/20/98 - use environment or session handle
    00108    rkasamse    03/20/98 - remove prototypes for OCIMemoryDuration* functions
    00109    nmallava    03/17/98 - add interfaces
    00110    nmallava    03/16/98 - add open/close apis
    00111    nmallava    03/10/98 - add temporary lobs apis
    00112    sgollapu    07/10/97 - Add OCIReset
    00113    sgollapu    02/09/98 - OCI non-blocking
    00114    nramakri    01/16/98 - remove #ifdef NEVER clause for OCIExtract
    00115    rmurthy     01/08/98 - OCIContextGenerateKey: change ub1 to ub4
    00116    ewaugh      01/02/98 - remove VAFP from OCIFormatString prototype
    00117    ewaugh      12/18/97 - Turn type wrappers into functions.
    00118    rtaranto    12/17/97 - Resolve merge conflicts
    00119    jiyang      11/13/97 - Add NLS service for cartridge
    00120    rhwu        12/02/97 - add OCI Thread
    00121    nramakri    12/15/97 - move to core4
    00122    nramakri    12/11/97 - modify OCIExtract prototype
    00123    ewaugh      12/10/97 - add OCIFormat prototypes
    00124    skabraha    12/02/97 - adding OCIFile functions
    00125    nramakri    11/12/97 - add OCIExtract prototypes
    00126    rkasamse    11/21/97 - add prototypes for memory cartridge services and cont
    00127    rkasamse    11/03/97 - Add pickler cartridge service interfaces
    00128    tanguyen    08/19/97 -
    00129    schandra    06/25/97 - AQ OCI interface
    00130    bnainani    07/21/97 - add prototypes for Oracle XA extensions
    00131    rtaranto    05/20/97 - remove OCILobLocatorSize (again)
    00132    esoyleme    05/13/97 - move failover callback prototype
    00133    skmishra    05/06/97 - stdc compiler fixes
    00134    skmishra    04/23/97 - Provide C++ compatibility
    00135    skotsovo    04/21/97 - make lob parameter names consistent
    00136    rwhitman    04/16/97 - Fix LOB prototypes - Olint OCI 8.0.3
    00137    ramkrish    04/15/97 - Add free flag to OCILobFlushBuffer
    00138    cxcheng     04/09/97 - change objnamp from CONST text* to dvoid*
    00139    cxcheng     04/08/97 - fix prototype for OCIDescribeAny
    00140    skotsovo    03/31/97 - remove OCILobLocatorSize
    00141    skotsovo    03/27/97 - add OCILobLoadFromFile
    00142    sgollapu    03/26/97 - Change OCIDescribeAny prototype
    00143    skotsovo    03/26/97 - add svchp to ocienablebuffering
    00144    skotsovo    03/26/97 - change OCILobFlushBuffers to OCILobFlushBuffer
    00145    skotsovo    03/18/97 - add interface for lob buffering.
    00146    dchatter    01/13/97 - fix comments on LOB calls
    00147    aroy        01/10/97 - remove ocilobfilecreate delete
    00148    sgollapu    12/27/96 - Correct OCILogon prototype
    00149    dchatter    01/04/97 - comments to describe the functions
    00150    sgollapu    11/25/96 - Change OCILobFileIsExistent
    00151    schandra    11/18/96 - Remove xa.h include
    00152    sgollapu    11/09/96 - Change prototype of OCIDescribeAny
    00153    dchatter    11/01/96 - lint error
    00154    dchatter    10/31/96 - delete CONST from lob write cb fn
    00155    dchatter    10/30/96 - more changes
    00156    dchatter    10/26/96 - lob/file long name corrections
    00157    slari       10/16/96 - delete unused calls
    00158    rwessman    10/29/96 - Fixed OCISecurityGetIdentity prototype
    00159    sgollapu    10/22/96 - Add OCILogon and OCILogoff prototypes
    00160    rwessman    10/16/96 - Added cryptographic and digital signature functions
    00161    rxgovind    10/07/96 - add oci file calls
    00162    skotsovo    09/20/96 - in OCILobGetLength(), remove the 'isnull' parameter.
    00163    skotsovo    10/01/96 - move orl lob fnts to oci
    00164    skotsovo    09/20/96 - in OCILobGetLength(), remove the 'isnull' parameter.
    00165    aroy        08/29/96 - change prototype for Nchar Lob support
    00166    dchatter    08/21/96 - OCIResultSetToStmt prototype change
    00167    sthakur     08/14/96 - add OCIParamSet
    00168    schandra    06/17/96 - Convert XA to use new OCI
    00169    aroy        07/17/96 - terminology change: OCILobLocator => OCILobLocator
    00170    dchatter    07/01/96 - drop prototypes not in beta1
    00171    dchatter    06/29/96 - OCIParamGet prototype change
    00172    dchatter    06/19/96 - add OCISvcCtxBreak, OCILdaToSvcCtx
    00173    slari       06/12/96 - inlcude oratypes.h instead of s.h
    00174    schandra    05/31/96 - remove client DBID parameters from OCITransStart
    00175    asurpur     06/05/96 - Changing the prototype for OCIPasswordChange
    00176    dchatter    05/30/96 - change OCIStmtGetBind prototype
    00177    schandra    05/29/96 - Add timeout parameter to OCITransDetach
    00178    slari       05/30/96 - add OCIBindDynamic/OCIDefineDynamic
    00179    slari       05/28/96 - fix gpi/spi protos
    00180    slari       05/28/96 - change proto for OCIParamGet
    00181    jbellemo    05/23/96 - remove ociisc
    00182    schandra    05/15/96 - Remove ocitgti type
    00183    schandra    04/18/96 - OCITransCommitt -> OCITransCommit
    00184    schandra    03/27/96 - V8OCI - add transaction related calls
    00185    dchatter    04/01/96 - change return types to sword to be compatible with oo
    00186    dchatter    03/21/96 - add oci2lda conversion routines
    00187    aroy        03/12/96 - change parameter order for lob functions
    00188    dchatter    03/08/96 - minor parameter renaming for lob calls
    00189    slari       03/14/96 - change proto of OCITransRollback
    00190    slari       03/12/96 - remove ocidqry
    00191    slari       03/01/96 - change proto for OCIInitialize
    00192    slari       02/07/96 - update prototypes
    00193    slari       02/06/96 - add OCITransCommit()
    00194    slari       02/02/96 - ociisc: rm dblink info
    00195    dchatter    01/08/96 - V8 OCI K&R prototype file
    00196    dchatter    01/08/96 - Creation
    00197
    00198 */
    00199
    00200 #ifndef OCIKP_ORACLE
    00201 # define OCIKP_ORACLE
    00202
    00203 # ifndef ORATYPES
    00204 #  include <oratypes.h>
    00205 # endif
    00206
    00207 #ifndef ORASTDARG
    00208 #include <stdarg.h>
    00209 #define ORASTDARG
    00210 #endif
    00211
    00212 #ifndef OCIDFN
    00213 #include <ocidfn.h>
    00214 #endif
    00215
    00216 #ifndef NZT_ORACLE
    00217 #include <nzt.h>
    00218 #endif /* NZT_ORACLE */
    00219
    00220 #ifndef OCI_ORACLE
    00221 #include <oci.h>
    00222 #endif
    00223
    00224 #ifndef ORT_ORACLE
    00225 #include <ort.h>
    00226 #endif
    00227
    00228 /*---------------------------------------------------------------------------
    00229                      PUBLIC TYPES AND CONSTANTS
    00230   ---------------------------------------------------------------------------*/
    00231
    00232 /*---------------------------------------------------------------------------
    00233                      PRIVATE TYPES AND CONSTANTS
    00234   ---------------------------------------------------------------------------*/
    00235
    00236
    00237 /*---------------------------------------------------------------------------
    00238                            PUBLIC FUNCTIONS
    00239   ---------------------------------------------------------------------------*/
    00240
    00241 /*------------------Oracle Version 8 Call Interface--------------------------*/
    00242
    00243
    00244 /*****************************************************************************
    00245                               DESCRIPTION
    00246 ******************************************************************************
    00247 Note: the descriptions of the functions are alphabetically arranged. Please
    00248 maintain the arrangement when adding a new function description. The actual
    00249 prototypes are below this comment section and donot follow any alphabetical
    00250 ordering.
    00251
    00252
    00253 --------------------------------OCIAttrGet------------------------------------
    00254
    00255 OCIAttrGet()
    00256 Name
    00257 OCI Attribute Get
    00258 Purpose
    00259 This call is used to get a particular attribute of a handle.
    00260 Syntax
    00261 sword OCIAttrGet ( CONST dvoid    *trgthndlp,
    00262                  ub4            trghndltyp,
    00263                  dvoid          *attributep,
    00264                  ub4            *sizep,
    00265                  ub4            attrtype,
    00266                  OCIError       *errhp );
    00267 Comments
    00268 This call is used to get a particular attribute of a handle.
    00269 See Appendix B,  "Handle Attributes",  for a list of handle types and their
    00270 readable attributes.
    00271 Parameters
    00272 trgthndlp (IN) - is the pointer to a handle type.
    00273 trghndltyp (IN) - is the handle type.
    00274 attributep (OUT) - is a pointer to the storage for an attribute value. The
    00275 attribute value is filled in.
    00276 sizep (OUT) - is the size of the attribute value.
    00277 This can be passed in as NULL for most parameters as the size is well known.
    00278 For OraText* parameters, a pointer to a ub4 must be passed in to get the length
    00279 of the string.
    00280 attrtype (IN) - is the type of attribute.
    00281 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    00282 diagnostic information in the event of an error.
    00283 Related Functions
    00284 OCIAttrSet()
    00285
    00286 --------------------------------OCIAttrSet------------------------------------
    00287
    00288
    00289 OCIAttrSet()
    00290 Name
    00291 OCI Attribute Set
    00292 Purpose
    00293 This call is used to set a particular attribute of a handle or a descriptor.
    00294 Syntax
    00295 sword OCIAttrSet ( dvoid       *trgthndlp,
    00296                  ub4         trghndltyp,
    00297                  dvoid       *attributep,
    00298                  ub4         size,
    00299                  ub4         attrtype,
    00300                  OCIError    *errhp );
    00301 Comments
    00302 This call is used to set a particular attribute of a handle or a descriptor.
    00303 See Appendix B for a list of handle types and their writeable attributes.
    00304 Parameters
    00305 trghndlp (IN/OUT) - the pointer to a handle type whose attribute gets
    00306 modified.
    00307 trghndltyp (IN/OUT) - is the handle type.
    00308 attributep (IN) - a pointer to an attribute value.
    00309 The attribute value is copied into the target handle. If the attribute value
    00310 is a pointer, then only the pointer is copied, not the contents of the pointer.
    00311 size (IN) - is the size of an attribute value. This can be passed in as 0 for
    00312 most attributes as the size is already known by the OCI library. For OraText*
    00313 attributes, a ub4 must be passed in set to the length of the string.
    00314 attrtype (IN) - the type of attribute being set.
    00315 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    00316 diagnostic information in the event of an error.
    00317 Related Functions
    00318 OCIAttrGet()
    00319
    00320
    00321
    00322 --------------------------------OCIBindArrayOfStruct--------------------------
    00323
    00324
    00325
    00326 OCIBindArrayOfStruct()
    00327 Name
    00328 OCI Bind for Array of Structures
    00329 Purpose
    00330 This call sets up the skip parameters for a static array bind.
    00331 Syntax
    00332 sword OCIBindArrayOfStruct ( OCIBind     *bindp,
    00333                            OCIError    *errhp,
    00334                            ub4         pvskip,
    00335                            ub4         indskip,
    00336                            ub4         alskip,
    00337                            ub4         rcskip );
    00338 Comments
    00339 This call sets up the skip parameters necessary for a static array bind.
    00340 This call follows a call to OCIBindByName() or OCIBindByPos(). The bind
    00341 handle returned by that initial bind call is used as a parameter for the
    00342 OCIBindArrayOfStruct() call.
    00343 For information about skip parameters, see the section "Arrays of Structures"
    00344 on page 4-16.
    00345 Parameters
    00346 bindp (IN) - the handle to a bind structure.
    00347 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    00348 diagnostic information in the event of an error.
    00349 pvskip (IN) - skip parameter for the next data value.
    00350 indskip (IN) - skip parameter for the next indicator value or structure.
    00351 alskip (IN) - skip parameter for the next actual length value.
    00352 rcskip (IN) - skip parameter for the next column-level return code value.
    00353 Related Functions
    00354 OCIAttrGet()
    00355
    00356
    00357 --------------------------------OCIBindByName---------------------------------
    00358
    00359
    00360 OCIBindByName()
    00361 Name
    00362 OCI Bind by Name
    00363 Purpose
    00364 Creates an association between a program variable and a placeholder in a SQL
    00365 statement or PL/SQL block.
    00366 Syntax
    00367 sword OCIBindByName (
    00368               OCIStmt       *stmtp,
    00369               OCIBind       **bindp,
    00370               OCIError      *errhp,
    00371               CONST OraText    *placeholder,
    00372               sb4           placeh_len,
    00373               dvoid         *valuep,
    00374               sb4           value_sz,
    00375               ub2           dty,
    00376               dvoid         *indp,
    00377               ub2           *alenp,
    00378               ub2           *rcodep,
    00379               ub4           maxarr_len,
    00380               ub4           *curelep,
    00381               ub4           mode );
    00382 Description
    00383 This call is used to perform a basic bind operation. The bind creates an
    00384 association between the address of a program variable and a placeholder in a
    00385 SQL statement or PL/SQL block. The bind call also specifies the type of data
    00386 which is being bound, and may also indicate the method by which data will be
    00387 provided at runtime.
    00388 This function also implicitly allocates the bind handle indicated by the bindp
    00389 parameter.
    00390 Data in an OCI application can be bound to placeholders statically or
    00391 dynamically. Binding is static when all the IN bind data and the OUT bind
    00392 buffers are well-defined just before the execute. Binding is dynamic when the
    00393 IN bind data and the OUT bind buffers are provided by the application on
    00394 demand at execute time to the client library. Dynamic binding is indicated by
    00395 setting the mode parameter of this call to OCI_DATA_AT_EXEC.
    00396 Related Functions: For more information about dynamic binding, see
    00397 the section "Runtime Data Allocation and Piecewise Operations" on
    00398 page 5-16.
    00399 Both OCIBindByName() and OCIBindByPos() take as a parameter a bind handle,
    00400 which is implicitly allocated by the bind call A separate bind handle is
    00401 allocated for each placeholder the application is binding.
    00402 Additional bind calls may be required to specify particular attributes
    00403 necessary when binding certain data types or handling input data in certain
    00404 ways:
    00405 If arrays of structures are being utilized, OCIBindArrayOfStruct() must
    00406 be called to set up the necessary skip parameters.
    00407 If data is being provided dynamically at runtime, and the application
    00408 will be using user-defined callback functions, OCIBindDynamic() must
    00409 be called to register the callbacks.
    00410 If a named data type is being bound, OCIBindObject() must be called to
    00411 specify additional necessary information.
    00412 Parameters
    00413 stmth (IN/OUT) - the statement handle to the SQL or PL/SQL statement
    00414 being processed.
    00415 bindp (IN/OUT) - a pointer to a pointer to a bind handle which is implicitly
    00416 allocated by this call.  The bind handle  maintains all the bind information for
    00417 this particular input value. The handle is feed implicitly when the statement
    00418 handle is deallocated.
    00419 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    00420 diagnostic information in the event of an error.
    00421 placeholder (IN) - the placeholder attributes are specified by name if ocibindn()
    00422 is being called.
    00423 placeh_len (IN) - the length of the placeholder name specified in placeholder.
    00424 valuep (IN/OUT) - a pointer to a data value or an array of data values of the
    00425 type specified in the dty parameter. An array of data values can be specified
    00426 for mapping into a PL/SQL table or for providing data for SQL multiple-row
    00427 operations. When an array of bind values is provided, this is called an array
    00428 bind in OCI terms. Additional attributes of the array bind (not bind to a
    00429 column of ARRAY type) are set up in OCIBindArrayOfStruct() call.
    00430 For a REF, named data type  bind, the valuep parameter is used only for IN
    00431 bind data. The pointers to OUT buffers are set in the pgvpp parameter
    00432 initialized by OCIBindObject(). For named data type and REF binds, the bind
    00433 values are unpickled into the Object Cache. The OCI object navigational calls
    00434 can then be used to navigate the objects and the refs in the Object Cache.
    00435 If the OCI_DATA_AT_EXEC mode is specified in the mode parameter, valuep
    00436 is ignored for all data types. OCIBindArrayOfStruct() cannot be used and
    00437 OCIBindDynamic() must be invoked to provide callback functions if desired.
    00438 value_sz (IN) - the size of a data value. In the case of an array bind, this is the
    00439 maximum size of any element possible with the actual sizes being specified in
    00440 the alenp parameter.
    00441 If the OCI_DATA_AT_EXEC mode is specified, valuesz defines the maximum
    00442 size of the data that can be ever provided at runtime for data types other than
    00443 named data types or REFs.
    00444 dty (IN) - the data type of the value(s) being bound. Named data types
    00445 (SQLT_NTY) and REFs (SQLT_REF) are valid only if the application has been
    00446 initialized in object mode. For named data types, or REFs, additional calls
    00447 must be made with the bind handle to set up the datatype-specific attributes.
    00448 indp (IN/OUT) - pointer to an indicator variable or array. For scalar data
    00449 types, this is a pointer to sb2 or an array of sb2s. For named data types,
    00450 this pointer is ignored and the actual pointer to the indicator structure or
    00451 an array of indicator structures is initialized by OCIBindObject().
    00452 Ignored for dynamic binds.
    00453 See the section "Indicator Variables" on page 2-43 for more information about
    00454 indicator variables.
    00455 alenp (IN/OUT) - pointer to array of actual lengths of array elements. Each
    00456 element in alenp is the length of the data in the corresponding element in the
    00457 bind value array before and after the execute. This parameter is ignored for
    00458 dynamic binds.
    00459 rcodep (OUT) - pointer to array of column level return codes. This parameter
    00460 is ignored for dynamic binds.
    00461 maxarr_len (IN) - the maximum possible number of elements of type dty in a
    00462 PL/SQL binds. This parameter is not required for non-PL/SQL binds. If
    00463 maxarr_len is non-zero, then either OCIBindDynamic() or
    00464 OCIBindArrayOfStruct() can be invoked to set up additional bind attributes.
    00465 curelep(IN/OUT) - a pointer to the actual number of elements. This parameter
    00466 is only required for PL/SQL binds.
    00467 mode (IN) - the valid modes for this parameter are:
    00468 OCI_DEFAULT. This is default mode.
    00469 OCI_DATA_AT_EXEC. When this mode is selected, the value_sz
    00470 parameter defines the maximum size of the data that can be ever
    00471 provided at runtime. The application must be ready to provide the OCI
    00472 library runtime IN data buffers at any time and any number of times.
    00473 Runtime data is provided in one of the two ways:
    00474 callbacks using a user-defined function which must be registered
    00475 with a subsequent call to OCIBindDynamic().
    00476 a polling mechanism using calls supplied by the OCI. This mode
    00477 is assumed if no callbacks are defined.
    00478 For more information about using the OCI_DATA_AT_EXEC mode, see
    00479 the section "Runtime Data Allocation and Piecewise Operations" on
    00480 page 5-16.
    00481 When the allocated buffers are not required any more, they should be
    00482 freed by the client.
    00483 Related Functions
    00484 OCIBindDynamic(), OCIBindObject(), OCIBindArrayOfStruct(), OCIAttrGet()
    00485
    00486
    00487 -------------------------------OCIBindByPos----------------------------------
    00488
    00489
    00490 OCIBindByPos()
    00491 Name
    00492 OCI Bind by Position
    00493 Purpose
    00494 Creates an association between a program variable and a placeholder in a SQL
    00495 statement or PL/SQL block.
    00496 Syntax
    00497 sword OCIBindByPos (
    00498               OCIStmt      *stmtp,
    00499               OCIBind      **bindp,
    00500               OCIError     *errhp,
    00501               ub4          position,
    00502               dvoid        *valuep,
    00503               sb4          value_sz,
    00504               ub2          dty,
    00505               dvoid        *indp,
    00506               ub2          *alenp,
    00507               ub2          *rcodep,
    00508               ub4          maxarr_len,
    00509               ub4          *curelep,
    00510               ub4          mode);
    00511
    00512 Description
    00513 This call is used to perform a basic bind operation. The bind creates an
    00514 association between the address of a program variable and a placeholder in a
    00515 SQL statement or PL/SQL block. The bind call also specifies the type of data
    00516 which is being bound, and may also indicate the method by which data will be
    00517 provided at runtime.
    00518 This function also implicitly allocates the bind handle indicated by the bindp
    00519 parameter.
    00520 Data in an OCI application can be bound to placeholders statically or
    00521 dynamically. Binding is static when all the IN bind data and the OUT bind
    00522 buffers are well-defined just before the execute. Binding is dynamic when the
    00523 IN bind data and the OUT bind buffers are provided by the application on
    00524 demand at execute time to the client library. Dynamic binding is indicated by
    00525 setting the mode parameter of this call to OCI_DATA_AT_EXEC.
    00526 Related Functions: For more information about dynamic binding, see
    00527 the section "Runtime Data Allocation and Piecewise Operations" on
    00528 page 5-16
    00529 Both OCIBindByName() and OCIBindByPos() take as a parameter a bind handle,
    00530 which is implicitly allocated by the bind call A separate bind handle is
    00531 allocated for each placeholder the application is binding.
    00532 Additional bind calls may be required to specify particular attributes
    00533 necessary when binding certain data types or handling input data in certain
    00534 ways:
    00535 If arrays of structures are being utilized, OCIBindArrayOfStruct() must
    00536 be called to set up the necessary skip parameters.
    00537 If data is being provided dynamically at runtime, and the application
    00538 will be using user-defined callback functions, OCIBindDynamic() must
    00539 be called to register the callbacks.
    00540 If a named data type is being bound, OCIBindObject() must be called to
    00541 specify additional necessary information.
    00542 Parameters
    00543 stmth (IN/OUT) - the statement handle to the SQL or PL/SQL statement
    00544 being processed.
    00545 bindp (IN/OUT) - a pointer to a pointer to a bind handle which is implicitly
    00546 allocated by this call.  The bind handle  maintains all the bind information for
    00547 this particular input value. The handle is feed implicitly when the statement
    00548 handle is deallocated.
    00549 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    00550 diagnostic information in the event of an error.
    00551 position (IN) - the placeholder attributes are specified by position if ocibindp()
    00552 is being called.
    00553 valuep (IN/OUT) - a pointer to a data value or an array of data values of the
    00554 type specified in the dty parameter. An array of data values can be specified
    00555 for mapping into a PL/SQL table or for providing data for SQL multiple-row
    00556 operations. When an array of bind values is provided, this is called an array
    00557 bind in OCI terms. Additional attributes of the array bind (not bind to a
    00558 column of ARRAY type) are set up in OCIBindArrayOfStruct() call.
    00559 For a REF, named data type  bind, the valuep parameter is used only for IN
    00560 bind data. The pointers to OUT buffers are set in the pgvpp parameter
    00561 initialized by OCIBindObject(). For named data type and REF binds, the bind
    00562 values are unpickled into the Object Cache. The OCI object navigational calls
    00563 can then be used to navigate the objects and the refs in the Object Cache.
    00564 If the OCI_DATA_AT_EXEC mode is specified in the mode parameter, valuep
    00565 is ignored for all data types. OCIBindArrayOfStruct() cannot be used and
    00566 OCIBindDynamic() must be invoked to provide callback functions if desired.
    00567 value_sz (IN) - the size of a data value. In the case of an array bind, this is the
    00568 maximum size of any element possible with the actual sizes being specified in
    00569 the alenp parameter.
    00570 If the OCI_DATA_AT_EXEC mode is specified, valuesz defines the maximum
    00571 size of the data that can be ever provided at runtime for data types other than
    00572 named data types or REFs.
    00573 dty (IN) - the data type of the value(s) being bound. Named data types
    00574 (SQLT_NTY) and REFs (SQLT_REF) are valid only if the application has been
    00575 initialized in object mode. For named data types, or REFs, additional calls
    00576 must be made with the bind handle to set up the datatype-specific attributes.
    00577 indp (IN/OUT) - pointer to an indicator variable or array. For scalar data
    00578 types, this is a pointer to sb2 or an array of sb2s. For named data types,
    00579 this pointer is ignored and the actual pointer to the indicator structure or
    00580 an array of indicator structures is initialized by OCIBindObject(). Ignored
    00581 for dynamic binds.
    00582 See the section "Indicator Variables" on page 2-43 for more information about
    00583 indicator variables.
    00584 alenp (IN/OUT) - pointer to array of actual lengths of array elements. Each
    00585 element in alenp is the length of the data in the corresponding element in the
    00586 bind value array before and after the execute. This parameter is ignored for
    00587 dynamic binds.
    00588 rcodep (OUT) - pointer to array of column level return codes. This parameter
    00589 is ignored for dynamic binds.
    00590 maxarr_len (IN) - the maximum possible number of elements of type dty in a
    00591 PL/SQL binds. This parameter is not required for non-PL/SQL binds. If
    00592 maxarr_len is non-zero, then either OCIBindDynamic() or
    00593 OCIBindArrayOfStruct() can be invoked to set up additional bind attributes.
    00594 curelep(IN/OUT) - a pointer to the actual number of elements. This parameter
    00595 is only required for PL/SQL binds.
    00596 mode (IN) - the valid modes for this parameter are:
    00597 OCI_DEFAULT. This is default mode.
    00598 OCI_DATA_AT_EXEC. When this mode is selected, the value_sz
    00599 parameter defines the maximum size of the data that can be ever
    00600 provided at runtime. The application must be ready to provide the OCI
    00601 library runtime IN data buffers at any time and any number of times.
    00602 Runtime data is provided in one of the two ways:
    00603 callbacks using a user-defined function which must be registered
    00604 with a subsequent call to OCIBindDynamic() .
    00605 a polling mechanism using calls supplied by the OCI. This mode
    00606 is assumed if no callbacks are defined.
    00607 For more information about using the OCI_DATA_AT_EXEC mode, see
    00608 the section "Runtime Data Allocation and Piecewise Operations" on
    00609 page 5-16.
    00610 When the allocated buffers are not required any more, they should be
    00611 freed by the client.
    00612 Related Functions
    00613 OCIBindDynamic(), OCIBindObject(), OCIBindArrayOfStruct(), OCIAttrGet()
    00614
    00615
    00616
    00617 -------------------------------OCIBindDynamic---------------------------------
    00618
    00619
    00620 OCIBindDynamic()
    00621 Name
    00622 OCI Bind Dynamic Attributes
    00623 Purpose
    00624 This call is used to register user callbacks for dynamic data allocation.
    00625 Syntax
    00626 sword OCIBindDynamic( OCIBind     *bindp,
    00627                     OCIError    *errhp,
    00628                     dvoid       *ictxp,
    00629                     OCICallbackInBind         (icbfp)(
    00630                                 dvoid            *ictxp,
    00631                                 OCIBind          *bindp,
    00632                                 ub4              iter,
    00633                                 ub4              index,
    00634                                 dvoid            **bufpp,
    00635                                 ub4              *alenp,
    00636                                 ub1              *piecep,
    00637                                 dvoid            **indp ),
    00638                     dvoid       *octxp,
    00639                     OCICallbackOutBind         (ocbfp)(
    00640                                 dvoid            *octxp,
    00641                                 OCIBind          *bindp,
    00642                                 ub4              iter,
    00643                                 ub4              index,
    00644                                 dvoid            **bufp,
    00645                                 ub4              **alenpp,
    00646                                 ub1              *piecep,
    00647                                 dvoid            **indpp,
    00648                                 ub2              **rcodepp)   );
    00649 Comments
    00650 This call is used to register user-defined callback functions for providing data
    00651 for an UPDATE or INSERT if OCI_DATA_AT_EXEC mode was specified in a
    00652 previous call to OCIBindByName() or OCIBindByPos().
    00653 The callback function pointers must return OCI_CONTINUE if it the call is
    00654 successful. Any return code other than OCI_CONTINUE signals that the client
    00655 wishes to abort processing immediately.
    00656 For more information about the OCI_DATA_AT_EXEC mode, see the section
    00657 "Runtime Data Allocation and Piecewise Operations" on page 5-16.
    00658 Parameters
    00659 bindp (IN/OUT) - a bind handle returned by a call to OCIBindByName() or
    00660 OCIBindByPos().
    00661 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    00662 diagnostic information in the event of an error.
    00663 ictxp (IN) - the context pointer required by the call back function icbfp.
    00664 icbfp (IN) - the callback function which returns a pointer to the IN bind
    00665 value or piece at run time. The callback takes in the following parameters.
    00666 ictxp (IN/OUT) - the context pointer for this callback function.
    00667 bindp (IN) - the bind handle passed in to uniquely identify this bind
    00668 variable.
    00669 iter (IN) - 1-based execute iteration value.
    00670 index (IN) - index of the current array, for an array bind. 1 based not
    00671 greater than curele parameter of the bind call.
    00672 index (IN) - index of the current array, for an array bind. This parameter
    00673 is 1-based, and may not be greater than curele parameter of the bind call.
    00674 bufpp (OUT) - the pointer to the buffer.
    00675 piecep (OUT) - which piece of the bind value. This can be one of the
    00676 following values - OCI_ONE_PIECE, OCI_FIRST_PIECE,
    00677 OCI_NEXT_PIECE and OCI_LAST_PIECE.
    00678 indp (OUT) - contains the indicator value. This is apointer to either an
    00679 sb2 value or a pointer to an indicator structure for binding named data
    00680 types.
    00681 indszp (OUT) - contains the indicator value size. A pointer containing
    00682 the size of either an sb2 or an indicator structure pointer.
    00683 octxp (IN) - the context pointer required by the callback function ocbfp.
    00684 ocbfp (IN) - the callback function which returns a pointer to the OUT bind
    00685 value or piece at run time. The callback takes in the following parameters.
    00686 octxp (IN/OUT) - the context pointer for this call back function.
    00687 bindp (IN) - the bind handle passed in to uniquely identify this bind
    00688 variable.
    00689 iter (IN) - 1-based execute iteration value.
    00690 index (IN) - index of the current array, for an array bind. This parameter
    00691 is 1-based, and must not be greater than curele parameter of the bind call.
    00692 bufpp (OUT) - a pointer to a buffer to write the bind value/piece.
    00693 buflp (OUT) - returns the buffer size.
    00694 alenpp (OUT) - a pointer to a storage for OCI to fill in the size of the bind
    00695 value/piece after it has been read.
    00696 piecep (IN/OUT) - which piece of the bind value. It will be set by the
    00697 library to be one of the following values - OCI_ONE_PIECE or
    00698 OCI_NEXT_PIECE. The callback function can leave it unchanged or set
    00699 it to OCI_FIRST_PIECE or OCI_LAST_PIECE. By default -
    00700 OCI_ONE_PIECE.
    00701 indpp (OUT) - returns a pointer to contain the indicator value which
    00702 either an sb2 value or a pointer to an indicator structure for named data
    00703 types.
    00704 indszpp (OUT) - returns a pointer to return the size of the indicator
    00705 value which is either size of an sb2 or size of an indicator structure.
    00706 rcodepp (OUT) - returns a pointer to contains the return code.
    00707 Related Functions
    00708 OCIAttrGet()
    00709
    00710
    00711
    00712 ---------------------------------OCIBindObject--------------------------------
    00713
    00714
    00715 OCIBindObject()
    00716 Name
    00717 OCI Bind Object
    00718 Purpose
    00719 This function sets up additional attributes which are required for a named
    00720 data type (object)  bind.
    00721 Syntax
    00722 sword OCIBindObject ( OCIBind          *bindp,
    00723                     OCIError         *errhp,
    00724                     CONST OCIType    *type,
    00725                     dvoid            **pgvpp,
    00726                     ub4              *pvszsp,
    00727                     dvoid            **indpp,
    00728                     ub4              *indszp, );
    00729 Comments
    00730 This function sets up additional attributes which binding a named data type
    00731 or a REF. An error will be returned if this function is called when the OCI
    00732 environment has been initialized in non-object mode.
    00733 This call takes as a paramter a type descriptor object (TDO) of datatype
    00734 OCIType for the named data type being defined.  The TDO can be retrieved
    00735 with a call to OCITypeByName().
    00736 If the OCI_DATA_AT_EXEC mode was specified in ocibindn() or ocibindp(), the
    00737 pointers to the IN buffers are obtained either using the callback icbfp
    00738 registered in the OCIBindDynamic() call or by the OCIStmtSetPieceInfo() call.
    00739 The buffers are dynamically allocated for the OUT data and the pointers to
    00740 these buffers are returned either by calling ocbfp() registered by the
    00741 OCIBindDynamic() or by setting the pointer to the buffer in the buffer passed
    00742 in by OCIStmtSetPieceInfo() called when OCIStmtExecute() returned
    00743 OCI_NEED_DATA. The memory of these client library- allocated buffers must be
    00744 freed when not in use anymore by using the OCIObjectFreee() call.
    00745 Parameters
    00746 bindp ( IN/OUT) - the bind handle returned by the call to OCIBindByName()
    00747 or OCIBindByPos().
    00748 errhp ( IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    00749 diagnostic information in the event of an error.
    00750 type ( IN) - points to the TDO which describes the type of the program
    00751 variable being bound. Retrieved by calling OCITypeByName().
    00752 pgvpp ( IN/OUT) - points to a pointer to the program variable buffer. For an
    00753 array, pgvpp points to an array of pointers. When the bind variable is also an
    00754 OUT variable, the OUT Named Data Type value or REF is allocated
    00755 (unpickled) in the Object Cache, and a pointer to the value or REF is returned,
    00756 At the end of execute, when all OUT values have been received, pgvpp points
    00757 to an array of pointer(s) to these newly allocated named data types in the
    00758 object cache.
    00759 pgvpp is ignored if the OCI_DATA_AT_EXEC mode is set. Then the Named
    00760 Data Type buffers are requested at runtime. For static array binds, skip
    00761 factors may be specified using the OCIBindArrayOfStruct() call. The skip
    00762 factors are used to compute the address of the next pointer to the value, the
    00763 indicator structure and their sizes.
    00764 pvszsp ( IN/OUT) - points to the size of the program variable. The size of the
    00765 named data type is not required on input. For an array, pvszsp is an array of
    00766 ub4s. On return, for OUT bind variables, this points to size(s) of the Named
    00767 Data Types and REFs received. pvszsp is ignored if the OCI_DATA_AT_EXEC
    00768 mode is set. Then the size of the buffer is taken at runtime.
    00769 indpp ( IN/OUT) - points to a pointer to the program variable buffer
    00770 containing the parallel indicator structure. For an array, points to an array of
    00771 pointers. When the bind variable is also an OUT bind variable, memory is
    00772 allocated in the object cache, to store the unpickled OUT indicator values. At
    00773 the end of the execute when all OUT values have been received, indpp points
    00774 to the pointer(s) to these newly allocated indicator structure(s).
    00775 indpp is ignored if the OCI_DATA_AT_EXEC mode is set. Then the indicator
    00776 is requested at runtime.
    00777 indszp ( IN/OUT) - points to the size of the IN indicator structure program
    00778 variable. For an array, it is an array of sb2s. On return for OUT bind variables,
    00779 this points to size(s) of the received OUT indicator structures.
    00780 indszp is ignored if the OCI_DATA_AT_EXEC mode is set. Then the indicator
    00781 size is requested at runtime.
    00782 Related Functions
    00783 OCIAttrGet()
    00784
    00785
    00786
    00787 ----------------------------------OCIBreak------------------------------------
    00788
    00789
    00790
    00791 OCIBreak()
    00792 Name
    00793 OCI Break
    00794 Purpose
    00795 This call performs an immediate (asynchronous) abort of any currently
    00796 executing OCI function that is associated with a server .
    00797 Syntax
    00798 sword OCIBreak ( dvoid      *hndlp,
    00799                  OCIError   *errhp);
    00800 Comments
    00801 This call performs an immediate (asynchronous) abort of any currently
    00802 executing OCI function that is associated with a server. It is normally used
    00803 to stop a long-running OCI call being processed on the server.
    00804 This call can take either the service context handle or the server context
    00805 handle as a parameter to identify the function to be aborted.
    00806 Parameters
    00807 hndlp (IN) - the service context handle or the server context handle.
    00808 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    00809 diagnostic information in the event of an error.
    00810 Related Functions
    00811
    00812 -----------------------------OCIConnectionPoolCreate --------------------------
    00813 Name:
    00814 OCIConnectionPoolCreate
    00815
    00816 Purpose:
    00817 Initializes the Connection Pool
    00818
    00819 Syntax:
    00820 OCIConnectionPoolCreate (OCIEnv *envhp, OCIError *errhp, OCICPool *poolhp,
    00821                          OraText **poolName, sb4 *poolNameLen,
    00822                          CONST Oratext *dblink, sb4 dblinkLen,
    00823                          ub4 connMin, ub4 connMax, ub4 connIncr,
    00824                          CONST OraText *poolUsername, sb4 poolUserLen,
    00825                          CONST OraText *poolPassword, sb4 poolPassLen, ub4 mode)
    00826 Comments:
    00827 This call is used to create a connection pool. conn_min connections
    00828 to the database are started on calling OCIConnectionPoolCreate.
    00829
    00830 Parameters:
    00831 envhp (IN/OUT)  - A pointer to the environment where the Conencton Pool
    00832                   is to be created
    00833 errhp (IN/OUT)  - An error handle which can be passed to OCIErrorGet().
    00834 poolhp (IN/OUT) - An uninitialiazed pool handle.
    00835 poolName (OUT) - The connection pool name.
    00836 poolNameLen (OUT) - The length of the connection pool name
    00837 dblink (IN/OUT) - Specifies the database(server) to connect. This will also
    00838                   be used as the default pool name.
    00839 dblinkLen (IN)  - The length of the string pointed to by dblink.
    00840 connMin (IN)    - Specifies the minimum number of connections in the
    00841                   Connection Pool at any instant.
    00842                   connMin number of connections are started when
    00843                   OCIConnectionPoolCreate() is called.
    00844 connMax (IN)    - Specifies the maximum number of connections that can be
    00845                   opened to the database. Once this value is reached, no
    00846                   more connections are opened.
    00847 connIncr (IN)   - Allows application to set the next increment for
    00848                   connections to be opened to the database if the current
    00849                   number of connections are less than conn_max.
    00850 poolUsername (IN/OUT) - Connection pooling requires an implicit proxy
    00851                          session and this attribute provides a username
    00852                          for that session.
    00853 poolUserLen (IN) - This represents the length of pool_username.
    00854 poolPassword (IN/OUT) - The password for the parameter pool_username passed
    00855                         above.
    00856 poolPassLen (IN) - This represents the length of pool_password.
    00857
    00858 mode (IN) - The modes supported are OCI_DEFAULT and OCI_REINITIALIZE
    00859
    00860 Related Functions
    00861 OCIConnectionPoolDestroy()
    00862 ---------------------------------------------------------------------------
    00863
    00864 ----------------------------OCIConnectionPoolDestroy-------------------------
    00865 Name:
    00866 OCIConnectionPoolDestroy
    00867
    00868 Purpose:
    00869 Destroys the Connection Pool.
    00870
    00871 Syntax:
    00872 OCIConnectionPoolDestroy (OCICPool *poolhp, OCIError *errhp, ub4 mode)
    00873
    00874 Comments:
    00875 On calling OCIConnectionPoolDestroy, all the open connections in the pool
    00876 are closed and the pool is destroyed.
    00877
    00878 Parameters:
    00879 poolhp (IN/OUT) - An uninitialiazed pool handle.
    00880 errhp (IN/OUT)  - An error handle which can be passed to OCIErrorGet().
    00881 mode (IN)       - Currently, OCIConnectionPoolDestroy() will support only
    00882                   the OCI_DEFAULT mode.
    00883
    00884 Related Functions:
    00885 OCIConnectionPoolCreate()
    00886
    00887 -----------------------------------------------------------------------------
    00888 ----------------------------OCISessionPoolCreate-----------------------------
    00889 Name:
    00890 OCISessionPoolCreate
    00891
    00892 Purpose:
    00893 Creates the sessions in the session pool.
    00894
    00895 Syntax:
    00896 sword OCISessionPoolCreate (OCIEnv *envhp, OCIError *errhp, OCISpool *spoolhp,
    00897                       OraText **poolName, ub4 *poolNameLen,
    00898                       CONST OraText *connStr, ub4 connStrLen,
    00899                       ub4 sessMin, ub4 sessMax, ub4 sessIncr,
    00900                       OraText *userid,  ub4 useridLen,
    00901                       OraText *password, ub4 passwordLen,
    00902                       ub4 mode)
    00903
    00904 Comments:
    00905 When OCISessionPoolCreate is called, a session pool is initialized for
    00906 the associated environment and the database specified by the
    00907 connStr parameter. This pool is named uniquely and the name
    00908 is returned to the user in the poolname parameter.
    00909
    00910 Parameters:
    00911 envhp (IN/OUT) - A pointer to the environment handle in which the session
    00912                  pool needs to be created.
    00913 errhp (IN/OUT) - An error handle which can be passed to OCIErrorGet().
    00914 spoolhp (IN/OUT) - A pointer to the session pool handle that is created.
    00915 poolName (OUT) - Session pool name returned to the user.
    00916 poolNameLen (OUT) - Length of the PoolName
    00917 connStr (IN) - The TNS alias of the database to connect to.
    00918 connStrLen (IN) - Length of the connStr.
    00919 sessMin (IN) - Specifies the minimum number of sessions in the Session Pool.
    00920                These are the number of sessions opened in the beginning, if
    00921                in Homogeneous mode. Else, the parameter is ignored.
    00922 sessMax (IN) - Specifies the maximum number of sessions in the Session Pool.
    00923                Once this value is reached, no more sessions are opened,
    00924                unless the OCI_ATTR_SPOOL_FORCEGET is set.
    00925 userid (IN) - Specifies the userid with which to start up the sessions.
    00926 useridLen (IN) - Length of userid.
    00927 password (IN) - Specifies the password for the corresponding userid.
    00928 passwordLen (IN) - Specifies the length of the password
    00929 mode(IN) - May be OCI_DEFAULT, OCI_SPC_SPOOL_REINITIALIZE, or
    00930            OCI_SPC_SPOOL_HOMOGENEOUS.
    00931
    00932 Returns:
    00933 SUCCESS - If pool could be allocated and created successfully.
    00934 ERROR - If above conditions could not be met.
    00935
    00936 Related Functions:
    00937 OCISessionPoolDestroy()
    00938 -----------------------------------------------------------------------------
    00939 -----------------------------OCISessionPoolDestroy---------------------------
    00940 Name:
    00941 OCISessionPoolDestroy
    00942
    00943 Purpose:
    00944 Terminates all the sessions in the session pool.
    00945
    00946 Syntax:
    00947 sword OCISessionPoolDestroy (OCISPool *spoolhp, OCIError *errhp, ub4 mode)
    00948
    00949 Comments:
    00950 spoolhp (IN/OUT) - The pool handle of the session pool to be destroyed.
    00951 errhp (IN/OUT) - An error handle which can be passed to OCIErrorGet().
    00952 mode (IN) - Currently only OCI_DEFAULT mode is supported.
    00953
    00954 Returns:
    00955 SUCCESS - All the sessions could be closed.
    00956 ERROR - If the above condition is not met.
    00957
    00958 Related Functions:
    00959 OCISessionPoolCreate()
    00960 -----------------------------------------------------------------------------
    00961 -------------------------------OCISessionGet---------------------------------
    00962 Name:
    00963 OCISessionGet
    00964
    00965 Purpose:
    00966 Get a session. This could be from a session pool, connection pool or
    00967 a new standalone session.
    00968
    00969 Syntax:
    00970 sword OCISessionGet(OCIenv *envhp, OCIError *errhp, OCISvcCtx **svchp,
    00971                     OCIAuthInfo *authhp,
    00972                     OraText *poolName, ub4 poolName_len,
    00973                     CONST OraText *tagInfo, ub4 tagInfo_len,
    00974                     OraText **retTagInfo, ub4 *retTagInfo_len,
    00975                     boolean *found,
    00976                     ub4 mode)
    00977
    00978 Comments:
    00979 envhp (IN/OUT) - OCI environment handle.
    00980 errhp (IN/OUT) - OCI error handle to be passed to OCIErrorGet().
    00981 svchp (IN/OUT) - Address of an OCI service context pointer. This will be
    00982                  filled with a server and session handle, attached to the
    00983                  pool.
    00984 authhp (IN/OUT) - OCI Authentication Information handle.
    00985 poolName (IN) - This indicates the session/connection pool to get the
    00986                 session/connection from in the OCI_SPOOL/OCI_CPOOL mode.
    00987                 In the OCI_DEFAULT mode it refers to the connect string.
    00988 poolName_len (IN) - length of poolName.
    00989 tagInfo (IN) - indicates the tag of the session that the user wants. If the
    00990                    user wants a default session, he must specify a NULL here.
    00991                    Only used for Session Pooling.
    00992 tagInfo_len (IN) - the length of tagInfo.
    00993 retTagInfo (OUT) - This indicates the type of session that is returned to
    00994                    the user. Only used for Session Pooling.
    00995 retTagInfo_len (OUT) - the length of retTagInfo.
    00996 found (OUT) - set to true if the user gets a session he had requested, else
    00997               set to false. Only used for Session Pooling.
    00998 mode (IN) - The supported modes are OCI_DEFAULT, OCI_CRED_PROXY and
    00999             OCI_GET_SPOOL_MATCHANY, OCI_SPOOL and OCI_CPOOL. OCI_SPOOL and
    01000             OCI_CPOOL are mutually exclusive.
    01001
    01002 Returns:
    01003 SUCCESS -  if a session was successfully returned into svchp.
    01004 SUCCESS_WITH_INFO - if a session was successfully returned into svchp and the
    01005                     total number of sessions > maxsessions. Only valid for
    01006                     Session Pooling.
    01007 ERROR - If a session could not be retrieved.
    01008
    01009 Related Functions:
    01010 OCISessionRelease()
    01011 -----------------------------------------------------------------------------
    01012 ---------------------------OCISessionRelease---------------------------------
    01013 Name:
    01014 OCISessionRelease
    01015
    01016 Purpose:
    01017 Release the session.
    01018
    01019 Syntax:
    01020 sword OCISessionRelease ( OCISvcCtx *svchp, OCIError *errhp,
    01021                           OraText *tag, ub4 tag_len,
    01022                           ub4 mode);
    01023
    01024 Comments:
    01025 svchp (IN/OUT) - The service context associated with the session/connection.
    01026 errhp (IN/OUT) - OCI error handle to be passed to OCIErrorGet().
    01027 tag (IN) - Only used for Session Pooling.
    01028            This parameter will be ignored unless mode OCI_RLS_SPOOL_RETAG is
    01029            specified. In this case, the session is labelled with this tag and
    01030            returned to the pool. If this is NULL, then the session is untagged.
    01031 tag_len (IN) - Length of the tag. This is ignored unless mode
    01032                OCI_RLS_SPOOL_RETAG is set.
    01033 mode (IN) - The supported modes are OCI_DEFAULT, OCI_RLS_SPOOL_DROPSESS,
    01034             OCI_RLS_SPOOL_RETAG. The last 2 are only valid for Session Pooling.
    01035             When OCI_RLS_SPOOL_DROPSESS is specified, the session
    01036             will be removed from the session pool. If OCI_RLS_SPOOL_RETAG is
    01037             set, the tag on the session will be altered. If this mode is not
    01038             set, the tag and tag_len parameters will be ignored.
    01039
    01040 Returns:
    01041 ERROR - If the session could not be released successfully.
    01042 SUCCESS - In all other cases.
    01043
    01044 Related Functions:
    01045 OCISessionGet().
    01046
    01047 -----------------------------------------------------------------------------
    01048 ------------------------------OCIDateTimeAssign --------------------------
    01049 sword OCIDateTimeAssign(dvoid *hndl, OCIError *err, CONST OCIDateTime *from,
    01050                                   OCIDateTime *to);
    01051 NAME: OCIDateTimeAssign - OCIDateTime Assignment
    01052 PARAMETERS:
    01053 hndl (IN) - Session/Env handle.
    01054 err (IN/OUT) - error handle. If there is an error, it is
    01055                 recorded in 'err' and this function returns OCI_ERROR.
    01056                 The error recorded in 'err' can be retrieved by calling
    01057                 OCIErrorGet().
    01058 from (IN) - datetime to be assigned
    01059 to (OUT) - lhs of assignment
    01060 DESCRIPTION:
    01061         Performs date assignment. The type of the output will be same as that
    01062            of input
    01063
    01064 ------------------------------OCIDateTimeCheck--------------------
    01065 sword OCIDateTimeCheck(dvoid *hndl, OCIError *err, CONST OCIDateTime *date,
    01066                        ub4 *valid );
    01067 NAME: OCIDateTimeCheck - OCIDateTime CHecK if the given date is valid
    01068 PARAMETERS:
    01069 hndl (IN) - Session/Env handle.
    01070 err (IN/OUT) - error handle. If there is an error, it is
    01071                 recorded in 'err' and this function returns OCI_ERROR.
    01072                 The error recorded in 'err' can be retrieved by calling
    01073                 OCIErrorGet().
    01074 date (IN) - date to be checked
    01075 type (IN) - type of the input datetime(OCI_DATE, OCI_TIME,
    01076                                             OCI_TIMESTAMP,        OCI_TZTIMESTAMP, OCI_TZTIME)
    01077 valid (OUT) -  returns zero for a valid date, otherwise
    01078                       the ORed combination of all error bits specified below:
    01079    Macro name                   Bit number      Error
    01080    ----------                   ----------      -----
    01081    OCI_DATE_INVALID_DAY         0x1             Bad day
    01082    OCI_DATE_DAY_BELOW_VALID     0x2             Bad DAy Low/high bit (1=low)
    01083    OCI_DATE_INVALID_MONTH       0x4             Bad MOnth
    01084    OCI_DATE_MONTH_BELOW_VALID   0x8             Bad MOnth Low/high bit (1=low)
    01085    OCI_DATE_INVALID_YEAR        0x10            Bad YeaR
    01086    OCI_DATE_YEAR_BELOW_VALID    0x20            Bad YeaR Low/high bit (1=low)
    01087    OCI_DATE_INVALID_HOUR        0x40            Bad HouR
    01088    OCI_DATE_HOUR_BELOW_VALID    0x80            Bad HouR Low/high bit (1=low)
    01089    OCI_DATE_INVALID_MINUTE      0x100           Bad MiNute
    01090    OCI_DATE_MINUTE_BELOW_VALID   0x200           Bad MiNute Low/high bit (1=low)
    01091    OCI_DATE_INVALID_SECOND      0x400           Bad SeCond
    01092    OCI_DATE_SECOND_BELOW_VALID  0x800           bad second Low/high bit (1=low)
    01093    OCI_DATE_DAY_MISSING_FROM_1582 0x1000        Day is one of those "missing"
    01094                                                 from 1582
    01095    OCI_DATE_YEAR_ZERO           0x2000          Year may not equal zero
    01096    OCI_DATE_INVALID_TIMEZONE    0x4000          Bad Timezone
    01097    OCI_DATE_INVALID_FORMAT      0x8000          Bad date format input
    01098
    01099    So, for example, if the date passed in was 2/0/1990 25:61:10 in
    01100    (month/day/year hours:minutes:seconds format), the error returned
    01101    would be OCI_DATE_INVALID_DAY | OCI_DATE_DAY_BELOW_VALID |
    01102    OCI_DATE_INVALID_HOUR | OCI_DATE_INVALID_MINUTE
    01103
    01104 DESCRIPTION:
    01105            Check if the given date is valid.
    01106 RETURNS:
    01107         OCI_SUCCESS if the function completes successfully.
    01108         OCI_INVALID_HANDLE if 'err' is NULL.
    01109         OCI_ERROR if
    01110              'date' and 'valid' pointers are NULL pointers
    01111
    01112 ------------------------------- OCIDateTimeCompare-------------------------
    01113 sword OCIDateTimeCompare(dvoid *hndl, OCIError *err, CONST OCIDateTime *date1,
    01114                      CONST OCIDateTime *date2,  sword *result );
    01115 NAME: OCIDateTimeCompare - OCIDateTime CoMPare dates
    01116 PARAMETERS:
    01117 hndl (IN) - Session/Env handle.
    01118 err (IN/OUT) - error handle. If there is an error, it is
    01119                 recorded in 'err' and this function returns OCI_ERROR.
    01120                 The error recorded in 'err' can be retrieved by calling
    01121                 OCIErrorGet().
    01122 date1, date2 (IN) - dates to be compared
    01123 type (IN)  - Type of datetime to be compared. Both input datetimes
    01124                                  should be of same type.(OCI_DATE, OCI_TIME,
    01125                                             OCI_TIMESTAMP, OCI_TZTIMESTAMP, OCI_TZTIME)
    01126 result (OUT) - comparison result, 0 if equal, -1 if date1 < date2,
    01127                       1 if date1 > date2
    01128 DESCRIPTION:
    01129 The function OCIDateCompare compares two dates. It returns -1 if
    01130 date1 is smaller than date2, 0 if they are equal, and 1 if date1 is
    01131 greater than date2.
    01132 RETURNS:
    01133        OCI_SUCCESS if the function completes successfully.
    01134         OCI_INVALID_HANDLE if 'err' is NULL.
    01135         OCI_ERROR if
    01136              invalid date
    01137              input dates are not mutually comparable
    01138
    01139 ------------------------------OCIDateTimeConvert----------------------
    01140 sword OCIDateTimeConvert(dvoid *hndl, OCIError *err, OCIDateTime *indate,
    01141                                             OCIDateTime *outdate);
    01142 NAME: OCIDateTimeConvert - Conversion between different DATETIME types
    01143 PARAMETERS:
    01144 hndl (IN) - Session/Env handle.
    01145 err (IN/OUT) - error handle. If there is an error, it is
    01146                 recorded in 'err' and this function returns OCI_ERROR.
    01147                 The error recorded in 'err' can be retrieved by calling
    01148                 OCIErrorGet().
    01149 indate (IN) - pointer to input date
    01150 outdate (OUT) - pointer to output datetime
    01151 DESCRIPTION: Converts one datetime type to another. The result type is
    01152        the type of the 'outdate' descriptor.
    01153 RETURNS:
    01154         OCI_SUCCESS if the function completes successfully.
    01155         OCI_INVALID_HANDLE if 'err' is NULL.
    01156            OCI_ERROR if
    01157                conversion not possible.
    01158
    01159 ---------------------------- OCIDateTimeFromText-----------------------
    01160 sword OCIDateTimeFromText(dvoid *hndl, OCIError *err, CONST OraText *date_str,
    01161                      size_t d_str_length, CONST OraText *fmt, ub1 fmt_length,
    01162                      CONST OraText *lang_name, size_t lang_length,
    01163                      OCIDateTime *date );
    01164 NAME: OCIDateTimeFromText - OCIDateTime convert String FROM Date
    01165 PARAMETERS:
    01166 hndl (IN) - Session/Env handle. If Session Handle is passed, the
    01167                           conversion takes place in session NLS_LANGUAGE and
    01168                           session NLS_CALENDAR, otherwise the default is used.
    01169 err (IN/OUT) - error handle. If there is an error, it is
    01170                 recorded in 'err' and this function returns OCI_ERROR.
    01171                 The error recorded in 'err' can be retrieved by calling
    01172                 OCIErrorGet().
    01173 date_str (IN) - input string to be converted to Oracle date
    01174 d_str_length (IN) - size of the input string, if the length is -1
    01175                       then 'date_str' is treated as a null terminated  string
    01176 fmt (IN) - conversion format; if 'fmt' is a null pointer, then
    01177                 the string is expected to be in the default format for
    01178                       the datetime type.
    01179 fmt_length (IN) - length of the 'fmt' parameter
    01180 lang_name (IN) - language in which the names and abbreviations of
    01181                    days and months are specified, if null i.e. (OraText *)0,
    01182                       the default language of session is used,
    01183 lang_length (IN) - length of the 'lang_name' parameter
    01184 date (OUT) - given string converted to date
    01185 DESCRIPTION:
    01186            Converts the given string to Oracle datetime type set in the
    01187         OCIDateTime descriptor according to the specified format. Refer to
    01188         "TO_DATE" conversion function described in "Oracle SQL Language
    01189         Reference Manual" for a description of format.
    01190 RETURNS:
    01191         OCI_SUCCESS if the function completes successfully.
    01192         OCI_INVALID_HANDLE if 'err' is NULL.
    01193         OCI_ERROR if
    01194              invalid format
    01195              unknown language
    01196              invalid input string
    01197
    01198 --------------------------- OCIDateTimeGetDate-------------------------
    01199 void OCIDateTimeGetDate(dvoid *hndl, OCIError *err,  CONST OCIDateTime *date,
    01200                        sb2 *year, ub1 *month, ub1 *day );
    01201 NAME: OCIDateTimeGetDate - OCIDateTime Get Date (year, month, day)
    01202                                             portion of DATETIME.
    01203 PARAMETERS:
    01204 hndl (IN) - Session/Env handle.
    01205 err (IN/OUT) - error handle. If there is an error, it is
    01206                 recorded in 'err' and this function returns OCI_ERROR.
    01207                 The error recorded in 'err' can be retrieved by calling
    01208                 OCIErrorGet().
    01209 datetime (IN) - Pointer to OCIDateTime
    01210 year      (OUT) - year value
    01211 month     (OUT) - month value
    01212 day       (OUT) - day value
    01213
    01214 --------------------------- OCIDateTimeGetTime ------------------------
    01215 void OCIDateTimeGetTime(dvoid *hndl, OCIError *err, OCIDateTime *datetime,
    01216                        ub1 *hour, ub1 *min, ub1 *sec, ub4 *fsec);
    01217 NAME: OCIDateTimeGetTime - OCIDateTime Get Time (hour, min, second,
    01218                                  fractional second)  of DATETIME.
    01219 PARAMETERS:
    01220 hndl (IN) - Session/Env handle.
    01221 err (IN/OUT) - error handle. If there is an error, it is
    01222                 recorded in 'err' and this function returns OCI_ERROR.
    01223                 The error recorded in 'err' can be retrieved by calling
    01224                 OCIErrorGet().
    01225 datetime (IN) - Pointer to OCIDateTime
    01226 hour      (OUT) - hour value
    01227 min       (OUT) - minute value
    01228 sec       (OUT) - second value
    01229 fsec      (OUT) - Fractional Second value
    01230
    01231 --------------------------- OCIDateTimeGetTimeZoneOffset ----------------------
    01232 sword OCIDateTimeGetTimeZoneOffset(dvoid *hndl,OCIError *err,CONST
    01233               OCIDateTime *datetime,sb1 *hour,sb1  *minute);
    01234
    01235 NAME: OCIDateTimeGetTimeZoneOffset - OCIDateTime Get TimeZone (hour, minute)
    01236                          portion of DATETIME.
    01237 PARAMETERS:
    01238 hndl (IN) - Session/Env handle.
    01239 err (IN/OUT) - error handle. If there is an error, it is
    01240                 recorded in 'err' and this function returns OCI_ERROR.
    01241                 The error recorded in 'err' can be retrieved by calling
    01242                 OCIErrorGet().
    01243 datetime (IN) - Pointer to OCIDateTime
    01244 hour      (OUT) - TimeZone Hour value
    01245 minute     (OUT) - TimeZone Minute value
    01246
    01247
    01248 ------------------------------OCIDateTimeIntervalAdd----------------------
    01249 sword OCIDateTimeIntervalAdd(dvoid *hndl, OCIError *err, OCIDateTime *datetime,
    01250             OCIInterval *inter, OCIDateTime *outdatetime);
    01251 NAME: OCIDateTimeIntervalAdd - Adds an interval to datetime
    01252 PARAMETERS:
    01253 hndl (IN) - Session/Env handle.
    01254 err (IN/OUT) - error handle. If there is an error, it is
    01255                 recorded in 'err' and this function returns OCI_ERROR.
    01256                 The error recorded in 'err' can be retrieved by calling
    01257                 OCIErrorGet().
    01258 datetime (IN) - pointer to input datetime
    01259 inter    (IN) - pointer to interval
    01260 outdatetime (IN) - pointer to output datetime. The output datetime
    01261                                             will be of same type as input datetime
    01262 DESCRIPTION:
    01263            Adds an interval to a datetime to produce a resulting datetime
    01264 RETURNS:
    01265         OCI_SUCCESS if the function completes successfully.
    01266         OCI_INVALID_HANDLE if 'err' is NULL.
    01267            OCI_ERROR if:
    01268                       resulting date is before Jan 1, -4713
    01269                       resulting date is after Dec 31, 9999
    01270
    01271 ------------------------------OCIDateTimeIntervalSub----------------------
    01272 sword OCIDateTimeIntervalSub(dvoid *hndl, OCIError *err, OCIDateTime *datetime,
    01273             OCIInterval *inter, OCIDateTime *outdatetime);
    01274 NAME: OCIDateTimeIntervalSub - Subtracts an interval from a datetime
    01275 PARAMETERS:
    01276 hndl (IN) - Session/Env handle.
    01277 err (IN/OUT) - error handle. If there is an error, it is
    01278                 recorded in 'err' and this function returns OCI_ERROR.
    01279                 The error recorded in 'err' can be retrieved by calling
    01280                 OCIErrorGet().
    01281 datetime (IN) - pointer to input datetime
    01282 inter    (IN) - pointer to interval
    01283 outdatetime (IN) - pointer to output datetime. The output datetime
    01284                                             will be of same type as input datetime
    01285 DESCRIPTION:
    01286            Subtracts an interval from a datetime and stores the result in a
    01287            datetime
    01288 RETURNS:
    01289         OCI_SUCCESS if the function completes successfully.
    01290         OCI_INVALID_HANDLE if 'err' is NULL.
    01291            OCI_ERROR if:
    01292                       resulting date is before Jan 1, -4713
    01293                       resulting date is after Dec 31, 9999
    01294
    01295 --------------------------- OCIDateTimeConstruct-------------------------
    01296 sword OCIDateTimeConstruct(dvoid  *hndl,OCIError *err,OCIDateTime *datetime,
    01297                sb2 year,ub1 month,ub1 day,ub1 hour,ub1 min,ub1 sec,ub4 fsec,
    01298                OraText  *timezone,size_t timezone_length);
    01299
    01300    NAME: OCIDateTimeConstruct - Construct an OCIDateTime. Only the relevant
    01301        fields for the OCIDateTime descriptor types are used.
    01302    PARAMETERS:
    01303         hndl (IN) - Session/Env handle.
    01304         err (IN/OUT) - error handle. If there is an error, it is
    01305                 recorded in 'err' and this function returns OCI_ERROR.
    01306                 The error recorded in 'err' can be retrieved by calling
    01307                 OCIErrorGet().
    01308         datetime (IN) - Pointer to OCIDateTime
    01309         year      (IN) - year value
    01310         month     (IN) - month value
    01311         day       (IN) - day value
    01312         hour      (IN) - hour value
    01313         min       (IN) - minute value
    01314         sec       (IN) - second value
    01315         fsec      (IN) - Fractional Second value
    01316         timezone  (IN) - Timezone string
    01317         timezone_length(IN) - Length of timezone string
    01318 DESCRIPTION:
    01319        Constructs a DateTime descriptor. The type of the datetime is the
    01320        type of the OCIDateTime descriptor. Only the relevant fields based
    01321        on the type are used. For Types with timezone, the date and time
    01322        fields are assumed to be in the local time of the specified timezone.
    01323        If timezone is not specified, then session default timezone is
    01324        assumed.
    01325 RETURNS:
    01326         OCI_SUCCESS if the function completes successfully.
    01327         OCI_ERROR if datetime is not valid.
    01328 --------------------------- OCIDateTimeSysTimeStamp---------------------
    01329 sword OCIDateTimeSysTimeStamp(dvoid *hndl, OCIError *err,
    01330               OCIDateTime *sys_date );
    01331
    01332 NAME: OCIDateTimeSysTimeStamp - Returns system date/time as a TimeStamp with
    01333                       timezone
    01334 PARAMETERS:
    01335 hndl (IN) - Session/Env handle.
    01336 err (IN/OUT) - error handle. If there is an error, it is
    01337                 recorded in 'err' and this function returns OCI_ERROR.
    01338                 The error recorded in 'err' can be retrieved by calling
    01339                 OCIErrorGet().
    01340 sys_date (OUT) - Pointer to output timestamp
    01341
    01342 DESCRIPTION:
    01343         Gets the system current date and time as a timestamp with timezone
    01344 RETURNS:
    01345         OCI_SUCCESS if the function completes successfully.
    01346         OCI_INVALID_HANDLE if 'err' is NULL.
    01347
    01348
    01349 ------------------------------OCIDateTimeSubtract-----------------------
    01350 sword OCIDateTimeSubtract(dvoid *hndl, OCIError *err, OCIDateTime *indate1,
    01351                       OCIDateTime *indate2, OCIInterval *inter);
    01352 NAME: OCIDateTimeSubtract - subtracts two datetimes to return an interval
    01353 PARAMETERS:
    01354 hndl (IN) - Session/Env handle.
    01355 err (IN/OUT) - error handle. If there is an error, it is
    01356                 recorded in 'err' and this function returns OCI_ERROR.
    01357                 The error recorded in 'err' can be retrieved by calling
    01358                 OCIErrorGet().
    01359 indate1(IN) - pointer to subtrahend
    01360 indate2(IN) - pointer to minuend
    01361 inter  (OUT) - pointer to output interval
    01362 DESCRIPTION:
    01363            Takes two datetimes as input and stores their difference in an
    01364         interval. The type of the result interval is the type of the
    01365         'inter' descriptor.
    01366 RETURNS:
    01367         OCI_SUCCESS if the function completes successfully.
    01368         OCI_INVALID_HANDLE if 'err' is NULL.
    01369            OCI_ERROR if
    01370               datetimes are not comparable.
    01371
    01372 --------------------------- OCIDateTimeToText--------------------------
    01373 sword OCIDateTimeToText(dvoid *hndl, OCIError *err, CONST OCIDateTime *date,
    01374                         CONST OraText *fmt, ub1 fmt_length, ub1 fsprec,
    01375                         CONST OraText *lang_name, size_t lang_length,
    01376                         ub4 *buf_size, OraText *buf );
    01377 NAME: OCIDateTimeToText - OCIDateTime convert date TO String
    01378 PARAMETERS:
    01379 hndl (IN) - Session/Env handle. If Session Handle is passed, the
    01380                           conversion takes place in session NLS_LANGUAGE and
    01381                           session NLS_CALENDAR, otherwise the default is used.
    01382 err (IN/OUT) - error handle. If there is an error, it is
    01383                 recorded in 'err' and this function returns OCI_ERROR.
    01384                 The error recorded in 'err' can be retrieved by calling
    01385                 OCIErrorGet().
    01386 date (IN) - Oracle datetime to be converted
    01387 fmt (IN) - conversion format, if null string pointer (OraText*)0, then
    01388                 the date is converted to a character string in the
    01389                 default format for that type.
    01390 fmt_length (IN) - length of the 'fmt' parameter
    01391 fsprec (IN) - specifies the fractional second precision in which the
    01392                fractional seconds is returned.
    01393 lang_name (IN) - specifies the language in which the names and
    01394                    abbreviations of months and days are returned;
    01395                    default language of session is used if 'lang_name'
    01396                       is null i.e. (OraText *)0
    01397 lang_length (IN) - length of the 'nls_params' parameter
    01398 buf_size (IN/OUT) - size of the buffer; size of the resulting string
    01399                 is returned via this parameter
    01400 buf (OUT) - buffer into which the converted string is placed
    01401 DESCRIPTION:
    01402         Converts the given date to a string according to the specified format.
    01403         Refer to "TO_DATE" conversion function described in
    01404         "Oracle SQL Language Reference Manual" for a description of format
    01405         and NLS arguments. The converted null-terminated date string is
    01406         stored in the buffer 'buf'.
    01407 RETURNS:
    01408         OCI_SUCCESS if the function completes successfully.
    01409         OCI_INVALID_HANDLE if 'err' is NULL.
    01410         OCI_ERROR if
    01411              buffer too small
    01412              invalid format
    01413              unknown language
    01414           overflow error
    01415
    01416 ----------------------------OCIDateTimeGetTimeZoneName------------------------
    01417 sword OCIDateTimeGetTimeZoneName(dvoid *hndl,
    01418                                  OCIError *err,
    01419                                  CONST OCIDateTime *datetime,
    01420                                  ub1 *buf,
    01421                                  ub4 *buflen);
    01422 NAME OCIDateTimeGetTimeZoneName - OCI DateTime Get the Time Zone Name
    01423 PARAMETERS:
    01424 hndl (IN)      - Session/Env handle.
    01425 err (IN/OUT)   - error handle. If there is an error, it is
    01426                  recorded in 'err' and this function returns OCI_ERROR.
    01427                  The error recorded in 'err' can be retrieved by calling
    01428                  OCIErrorGet().
    01429 datetime (IN)   - Pointer to an OCIDateTime.
    01430 buf (OUT)       - User allocated storage for name string.
    01431 buflen (IN/OUT) - length of buf on input, length of name on out
    01432 DESCRIPTION:
    01433         Returns either the timezone region name or the absolute hour and minute
    01434         offset. If the DateTime was created with a region id then the region
    01435         name will be returned in the buf.  If the region id is zero, then the
    01436         hour and minute offset is returned as "[-]HH:MM".
    01437 RETURNS:
    01438        OCI_SUCCESS if the function completes successfully.
    01439        OCI_INVALID_HANDLE if 'err' is NULL.
    01440        OCI_ERROR if
    01441          buffer too small
    01442          error retrieving timezone data
    01443          invalid region
    01444          invalid LdiDateTime type
    01445
    01446 ----------------------------OCIDateTimeFromArray-------------------------------
    01447 sword OCIDateTimeFromArray(dvoid *hndl,
    01448                          OCIError *err,
    01449                          ub1 *inarray,
    01450                          ub4 len
    01451                          ub1 type
    01452                          OCIDateTime *datetime,
    01453                          OCIInterval *reftz,
    01454                          ub1 fsprec);
    01455 NAME OCIDateTimeFromArray - OCI DateTime convert From Array format
    01456 PARAMETERS:
    01457 hndl (IN)      - Session/Env handle.
    01458 err (IN/OUT)   - error handle. If there is an error, it is
    01459                  recorded in 'err' and this function returns OCI_ERROR.
    01460                  The error recorded in 'err' can be retrieved by calling
    01461                  OCIErrorGet().
    01462 inarray (IN)   - Pointer to input array representtion of DateTime
    01463 len (IN)       - len of inarray.
    01464 type (IN)      - One of SQLT_DATE, SQLT_TIME, SQLT_TIME_TZ, SQLT_TIMESTAMP,
    01465                  SQLT_TIMESTAMP_TZ, or SQLT_TIMESTAMP_LTZ.
    01466 datetime (OUT) - Pointer to the result OCIDateTime.
    01467 reftz (IN)     - timezone interval used with SQLT_TIMESTAMP_LTZ.
    01468 fsprec (IN)    - fractionl seconds digits of precision (0-9).
    01469 DESCRIPTION:
    01470         Returns a pointer to an OCIDateTime of type type converted from
    01471         the inarray.
    01472 RETURNS:
    01473        OCI_SUCCESS if the function completes successfully.
    01474        OCI_INVALID_HANDLE if 'err' is NULL.
    01475        OCI_ERROR if
    01476          buffer too small
    01477          error retrieving timezone data
    01478          invalid region
    01479          invalid LdiDateTime type
    01480
    01481 -----------------------------OCIDateTimeToArray------------------------------
    01482 sword OCIDateTimeToArray(dvoid *hndl,
    01483                          OCIError *err,
    01484                          CONST OCIDateTime *datetime,
    01485                          CONST OCIInterval *reftz,
    01486                          ub1 *outarray,
    01487                          ub4 len,
    01488                          ub1 fsprec);
    01489 NAME OCIDateTimeToArray - OCI DateTime convert To Array format
    01490 PARAMETERS:
    01491 hndl (IN)      - Session/Env handle.
    01492 err (IN/OUT)   - error handle. If there is an error, it is
    01493                  recorded in 'err' and this function returns OCI_ERROR.
    01494                  The error recorded in 'err' can be retrieved by calling
    01495                  OCIErrorGet().
    01496 datetime (IN)  - Pointer to the OCIDateTime to convert.
    01497 reftz (IN)     - Interval defining the timezone for SQLT_TIMESTAMP_LTZ.
    01498 outarray (OUT) - result array.
    01499 len (IN)       - length of outarray.
    01500 fsprec (IN)    - number of fractional seconds digits.
    01501 DESCRIPTION:
    01502         Returns an array representing the input DateTime descriptor.
    01503 RETURNS:
    01504        OCI_SUCCESS if the function completes successfully.
    01505        OCI_INVALID_HANDLE if 'err' is NULL.
    01506        OCI_ERROR if
    01507          buffer too small
    01508          error retrieving timezone data
    01509          invalid region
    01510          invalid LdiDateTime type
    01511
    01512 ----------------------------------OCIRowidToChar-----------------------------
    01513 Name
    01514 OCIRowidToChar
    01515
    01516 Purpose
    01517 Converts physical/logical (universal) ROWID to chracter extended (Base 64)
    01518 representation into user provided buffer outbfp of length outbflp. After
    01519 execution outbflp contains amount of bytes converted.In case of truncation
    01520 error, outbflp contains required size to make this conversion successful
    01521 and returns ORA-1405.
    01522
    01523 Syntax
    01524 sword OCIRowidToChar( OCIRowid *rowidDesc,
    01525                       OraText *outbfp,
    01526                       ub2 *outbflp,
    01527                       OCIError *errhp)
    01528
    01529 Comments
    01530 After this conversion, ROWID in character format can be bound using
    01531 OCIBindByPos or OCIBindByName call and used to query a row at a
    01532 desired ROWID.
    01533
    01534 Parameters
    01535 rowidDesc (IN)   - rowid DESCriptor which is allocated from OCIDescritorAlloc
    01536                    and populated by a prior SQL statement execution
    01537 outbfp (OUT)     - pointer to the buffer where converted rowid in character
    01538                    representation is stored after successful execution.
    01539 outbflp (IN/OUT) - pointer to output buffer length variable.
    01540                    Before execution (IN mode) *outbflp contains the size of
    01541                    outbfp, after execution (OUT mode) *outbflp contains amount
    01542                    of bytes converted. In an event of truncation during
    01543                    conversion *outbflp contains the required length to make
    01544                    conversion successful.
    01545 errhp (IN/OUT)   - an error handle which can be passed to OCIErrorGet() for
    01546                    diagnostic information in the event of an error.
    01547
    01548 ------------------------------OCIDefineArrayOfStruct--------------------------
    01549
    01550
    01551 OCIDefineArrayOfStruct()
    01552 Name
    01553 OCI Define for Array of Structures
    01554 Purpose
    01555 This call specifies additional attributes necessary for a static array define.
    01556 Syntax
    01557 sword OCIDefineArrayOfStruct ( OCIDefine   *defnp,
    01558                              OCIError    *errhp,
    01559                              ub4         pvskip,
    01560                              ub4         indskip,
    01561                              ub4         rlskip,
    01562                              ub4         rcskip );
    01563 Comments
    01564 This call specifies additional attributes necessary for an array define, used in
    01565 an array of structures (multi-row, multi-column) fetch.
    01566 For more information about skip parameters, see the section "Skip Parameters"
    01567 on page 4-17.
    01568 Parameters
    01569 defnp (IN) - the handle to the define structure which was returned by a call
    01570 to OCIDefineByPos().
    01571 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    01572 diagnostic information in the event of an error.
    01573 pvskip (IN) - skip parameter for the next data value.
    01574 indskip (IN) - skip parameter for the next indicator location.
    01575 rlskip (IN) - skip parameter for the next return length value.
    01576 rcskip (IN) - skip parameter for the next return code.
    01577 Related Functions
    01578 OCIAttrGet()
    01579
    01580
    01581
    01582
    01583
    01584 OCIDefineByPos()
    01585 Name
    01586 OCI Define By Position
    01587 Purpose
    01588 Associates an item in a select-list with the type and output data buffer.
    01589 Syntax
    01590 sb4 OCIDefineByPos (
    01591               OCIStmt     *stmtp,
    01592               OCIDefine   **defnp,
    01593               OCIError    *errhp,
    01594               ub4         position,
    01595               dvoid       *valuep,
    01596               sb4         value_sz,
    01597               ub2         dty,
    01598               dvoid       *indp,
    01599               ub2         *rlenp,
    01600               ub2         *rcodep,
    01601               ub4         mode );
    01602 Comments
    01603 This call defines an output buffer which will receive data retreived from
    01604 Oracle. The define is a local step which is necessary when a SELECT statement
    01605 returns data to your OCI application.
    01606 This call also implicitly allocates the define handle for the select-list item.
    01607 Defining attributes of a column for a fetch is done in one or more calls. The
    01608 first call is to OCIDefineByPos(), which defines the minimal attributes
    01609 required to specify the fetch.
    01610 This call takes as a parameter a define handle, which must have been
    01611 previously allocated with a call to OCIHandleAlloc().
    01612 Following the call to OCIDefineByPos() additional define calls may be
    01613 necessary for certain data types or fetch modes:
    01614 A call to OCIDefineArrayOfStruct() is necessary to set up skip parameters
    01615 for an array fetch of multiple columns.
    01616 A call to OCIDefineObject() is necessary to set up the appropriate
    01617 attributes of a named data type fetch. In this case the data buffer pointer
    01618 in ocidefn() is ignored.
    01619 Both OCIDefineArrayOfStruct() and OCIDefineObject() must be called
    01620 after ocidefn() in order to fetch multiple rows with a column of named
    01621 data types.
    01622 For a LOB define, the buffer pointer must be a lob locator of type
    01623 OCILobLocator , allocated by the OCIDescAlloc() call. LOB locators, and not
    01624 LOB values, are always returned for a LOB column. LOB values can then be
    01625 fetched using OCI LOB calls on the fetched locator.
    01626 For NCHAR (fixed and varying length), the buffer pointer must point to an
    01627 array of bytes sufficient for holding the required NCHAR characters.
    01628 Nested table columns are defined and fetched like any other named data type.
    01629 If the mode parameter is this call is set to OCI_DYNAMIC_FETCH, the client
    01630 application can fetch data dynamically at runtime.
    01631 Runtime data can be provided in one of two ways:
    01632 callbacks using a user-defined function which must be registered with a
    01633 subsequent call to OCIDefineDynamic(). When the client library needs a
    01634 buffer to return the fetched data, the callback will be invoked and the
    01635 runtime buffers provided will return a piece or the whole data.
    01636 a polling mechanism using calls supplied by the OCI. This mode is
    01637 assumed if no callbacks are defined. In this case, the fetch call returns the
    01638 OCI_NEED_DATA error code, and a piecewise polling method is used
    01639 to provide the data.
    01640 Related Functions: For more information about using the
    01641 OCI_DYNAMIC_FETCH mode, see the section "Runtime Data
    01642 Allocation and Piecewise Operations" on page 5-16 of Volume 1..
    01643 For more information about the define step, see the section "Defining"
    01644 on page 2-30.
    01645 Parameters
    01646 stmtp (IN) - a handle to the requested SQL query operation.
    01647 defnp (IN/OUT) - a pointer to a pointer to a define handle which is implicitly
    01648 allocated by this call.  This handle is used to  store the define information
    01649 for this column.
    01650 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    01651 diagnostic information in the event of an error.
    01652 position (IN) - the position of this value in the select list. Positions are
    01653 1-based and are numbered from left to right. For example, in the SELECT
    01654 statement
    01655 SELECT empno, ssn, mgrno FROM employees;
    01656 empno is at position 1, ssn is at position 2, and mgrno is at position 3.
    01657 valuep (IN/OUT) - a pointer to a buffer or an array of buffers of the type
    01658 specified in the dty parameter. A number of buffers can be specified when
    01659 results for more than one row are desired in a single fetch call.
    01660 value_sz (IN) - the size of each valuep buffer in bytes. If the data is stored
    01661 internally in VARCHAR2 format, the number of characters desired, if different
    01662 from the buffer size in bytes, may be additionally specified by the using
    01663 OCIAttrSet().
    01664 In an NLS conversion environment, a truncation error will be generated if the
    01665 number of bytes specified is insufficient to handle the number of characters
    01666 desired.
    01667 dty (IN) - the data type. Named data type (SQLT_NTY) and REF (SQLT_REF)
    01668 are valid only if the environment has been intialized with in object mode.
    01669 indp - pointer to an indicator variable or array. For scalar data types,
    01670 pointer to sb2 or an array of sb2s. Ignored for named data types. For named
    01671 data types, a pointer to a named data type indicator structure or an array of
    01672 named data type indicator structures is associated by a subsequent
    01673 OCIDefineObject() call.
    01674 See the section "Indicator Variables" on page 2-43 for more information about
    01675 indicator variables.
    01676 rlenp (IN/OUT) - pointer to array of length of data fetched. Each element in
    01677 rlenp is the length of the data in the corresponding element in the row after
    01678 the fetch.
    01679 rcodep (OUT) - pointer to array of column-level return codes
    01680 mode (IN) - the valid modes are:
    01681 OCI_DEFAULT. This is the default mode.
    01682 OCI_DYNAMIC_FETCH. For applications requiring dynamically
    01683 allocated data at the time of fetch, this mode must be used. The user may
    01684 additionally call OCIDefineDynamic() to set up a callback function that
    01685 will be invoked to receive the dynamically allocated buffers and to set
    01686 up the memory allocate/free callbacks and the context for the callbacks.
    01687 valuep and value_sz are ignored in this mode.
    01688 Related Functions
    01689 OCIDefineArrayOfStruct(), OCIDefineDynamic(), OCIDefineObject()
    01690
    01691
    01692
    01693
    01694 OCIDefineDynamic()
    01695 Name
    01696 OCI Define Dynamic Fetch Attributes
    01697 Purpose
    01698 This call is used to set the additional attributes required if the
    01699 OCI_DYNAMIC_FETCH mode was selected in OCIDefineByPos().
    01700 Syntax
    01701 sword OCIDefineDynamic( OCIDefine   *defnp,
    01702                       OCIError    *errhp,
    01703                       dvoid       *octxp,
    01704                       OCICallbackDefine (ocbfp)(
    01705                                   dvoid             *octxp,
    01706                                   OCIDefine         *defnp,
    01707                                   ub4               iter,
    01708                                   dvoid             **bufpp,
    01709                                   ub4               **alenpp,
    01710                                   ub1               *piecep,
    01711                                   dvoid             **indpp,
    01712                                   ub2               **rcodep)  );
    01713 Comments
    01714 This call is used to set the additional attributes required if the
    01715 OCI_DYNAMIC_FETCH mode has been selected in a call to
    01716 OCIDefineByPos().
    01717 When the OCI_DYNAMIC_FETCH mode is selected, buffers will be
    01718 dynamically allocated for REF, and named data type, values to receive the
    01719 data. The pointers to these buffers will be returned.
    01720 If OCI_DYNAMIC_FETCH mode was selected, and the call to
    01721 OCIDefineDynamic() is skipped, then the application can fetch data piecewise
    01722 using OCI calls.
    01723 For more information about OCI_DYNAMIC_FETCH mode, see the section
    01724 "Runtime Data Allocation and Piecewise Operations" on page 5-16.
    01725 Parameters
    01726 defnp (IN/OUT) - the handle to a define structure returned by a call to
    01727 OCIDefineByPos().
    01728 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    01729 diagnostic information in the event of an error.
    01730 octxp (IN) - points to a context for the callback function.
    01731 ocbfp (IN) - points to a callback function. This is invoked at runtime to get
    01732 a pointer to the buffer into which the fetched data or a piece of it will be
    01733 retreived. The callback also specifies the indicator, the return code and the
    01734 lengths of the data piece and indicator. The callback has the following
    01735 parameters:
    01736 octxp (IN) - a context pointer passed as an argument to all the callback
    01737 functions.
    01738 defnp (IN) - the define handle.
    01739 iter (IN) - which row of this current fetch.
    01740 bufpp (OUT) - returns a pointer to a buffer to store the column value, ie.
    01741 *bufp points to some appropriate storage for the column value.
    01742 alenpp (OUT) - returns a pointer to the length of the buffer. *alenpp
    01743 contains the size of the buffer after return from callback. Gets set to
    01744 actual data size after fetch.
    01745 piecep (IN/OUT) - returns a piece value, as follows:
    01746 The IN value can be OCI_ONE_PIECE, OCI_FIRST_PIECE or
    01747 OCI_NEXT_PIECE.
    01748 The OUT value can be OCI_ONE_PIECE if the IN value was
    01749 OCI_ONE_PIECE.
    01750 The OUT value can be OCI_ONE_PIECE or OCI_FIRST_PIECE if
    01751 the IN value was OCI_FIRST_PIECE.
    01752 The OUT value can only be OCI_NEXT_PIECE or
    01753 OCI_LAST_PIECE if the IN value was OCI_NEXT_PIECE.
    01754 indpp (IN) - indicator variable pointer
    01755 rcodep (IN) - return code variable pointer
    01756 Related Functions
    01757 OCIAttrGet()
    01758 OCIDefineObject()
    01759
    01760
    01761
    01762
    01763 OCIDefineObject()
    01764 Name
    01765 OCI Define Named Data Type attributes
    01766 Purpose
    01767 Sets up additional attributes necessary for a Named Data Type define.
    01768 Syntax
    01769 sword OCIDefineObject ( OCIDefine       *defnp,
    01770                       OCIError        *errhp,
    01771                       CONST OCIType   *type,
    01772                       dvoid           **pgvpp,
    01773                       ub4             *pvszsp,
    01774                       dvoid           **indpp,
    01775                       ub4             *indszp );
    01776 Comments
    01777 This call sets up additional attributes necessary for a Named Data Type define.An error will be returned if this function is called when the OCI environment
    01778 has been initialized in non-Object mode.
    01779 This call takes as a paramter a type descriptor object (TDO) of datatype
    01780 OCIType for the named data type being defined.  The TDO can be retrieved
    01781 with a call to OCITypeByName().
    01782 See the description of OCIInitialize() on page 13 - 43 for more information
    01783 about initializing the OCI process environment.
    01784 Parameters
    01785 defnp (IN/OUT) - a define handle previously allocated in a call to
    01786 OCIDefineByPos().
    01787 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    01788 diagnostic information in the event of an error.
    01789 type (IN, optional) - points to the Type Descriptor Object (TDO) which
    01790 describes the type of the program variable. Only used for program variables
    01791 of type SQLT_NTY. This parameter is optional, and may be passed as NULL
    01792 if it is not being used.
    01793 pgvpp (IN/OUT) - points to a pointer to a program variable buffer. For an
    01794 array, pgvpp points to an array of pointers. Memory for the fetched named data
    01795 type instance(s) is dynamically allocated in the object cache. At the end of the
    01796 fetch when all the values have been received, pgvpp points to the pointer(s) to
    01797 these newly allocated named data type instance(s). The application must call
    01798 OCIObjectMarkDel() to deallocate the named data type instance(s) when they
    01799 are no longer needed.
    01800 pvszsp (IN/OUT) - points to the size of the program variable. For an array, it
    01801 is an array of ub4s. On return points to the size(s) of unpickled fetched
    01802 values.
    01803 indpp (IN/OUT) - points to a pointer to the program variable buffer
    01804 containing the parallel indicator structure. For an array, points to an array
    01805 of pointers. Memory is allocated to store the indicator structures in the
    01806 object cache. At the end of the fetch when all values have been received,
    01807 indpp points to the pointer(s) to these newly allocated indicator structure(s).
    01808 indszp (IN/OUT) - points to the size(s) of the indicator structure program
    01809 variable. For an array, it is an array of ub4s. On return points to the size(s)
    01810 of the unpickled fetched indicator values.
    01811 Related Functions
    01812 OCIAttrGet()
    01813
    01814
    01815
    01816 OCIDescAlloc()
    01817 Name
    01818 OCI Get DESCriptor or lob locator
    01819 Purpose
    01820 Allocates storage to hold certain data types. The descriptors can be used as
    01821 bind or define variables.
    01822 Syntax
    01823 sword OCIDescAlloc ( CONST dvoid   *parenth,
    01824                    dvoid         **descpp,
    01825                    ub4           type,
    01826                    size_t        xtramem_sz,
    01827                    dvoid         **usrmempp);
    01828 Comments
    01829 Returns a pointer to an allocated and initialized structure, corresponding to
    01830 the type specified in type. A non-NULL descriptor or LOB locator is returned
    01831 on success. No diagnostics are available on error.
    01832 This call returns OCI_SUCCESS if successful, or OCI_INVALID_HANDLE if
    01833 an out-of-memory error occurs.
    01834 Parameters
    01835 parenth (IN) - an environment handle.
    01836 descpp (OUT) - returns a descriptor or LOB locator of desired type.
    01837 type (IN) - specifies the type of descriptor or LOB locator to be allocated.
    01838 The specific types are:
    01839 OCI_DTYPE_SNAP - specifies generation of snapshot descriptor of C
    01840 type - OCISnapshot
    01841 OCI_DTYPE_LOB - specifies generation of a LOB data type locator of C
    01842 type - OCILobLocator
    01843 OCI_DTYPE_RSET - specifies generation of a descriptor of C type
    01844 OCIResult that references a result set (a number of rows as a result of a
    01845 query). This descriptor is bound to a bind variable of data type
    01846 SQLT_RSET (result set). The descriptor has to be converted into a
    01847 statement handle using a function - OCIResultSetToStmt() - which can
    01848 then be passed to OCIDefineByPos() and OCIStmtFetch() to retrieve the
    01849 rows of the result set.
    01850 OCI_DTYPE_ROWID - specifies generation of a ROWID descriptor of C
    01851 type OCIRowid.
    01852 OCI_DTYPE_COMPLEXOBJECTCOMP - specifies generation of a
    01853 complex object retrieval descriptor of C type
    01854 OCIComplexObjectComp.
    01855 xtramemsz (IN) - specifies an amount of user memory to be allocated for use
    01856 by the application.
    01857 usrmempp (OUT) - returns a pointer to the user memory of size xtramemsz
    01858 allocated by the call for the user.
    01859 Related Functions
    01860 OCIDescFree()
    01861
    01862
    01863
    01864
    01865 OCIDescFree()
    01866 Name
    01867 OCI Free DESCriptor
    01868 Purpose
    01869 Deallocates a previously allocated descriptor.
    01870 Syntax
    01871 sword OCIDescFree ( dvoid    *descp,
    01872                   ub4      type);
    01873 Comments
    01874 This call frees up storage associated with the descriptor, corresponding to the
    01875 type specified in type. Returns OCI_SUCCESS or OCI_INVALID_HANDLE.
    01876 All descriptors must be explicitly deallocated. OCI will not deallocate a
    01877 descriptor if the environment handle is deallocated.
    01878 Parameters
    01879 descp (IN) - an allocated descriptor.
    01880 type (IN) - specifies the type of storage to be freed. The specific types are:
    01881 OCI_DTYPE_SNAP - snapshot descriptor
    01882 OCI_DTYPE_LOB - a LOB data type descriptor
    01883 OCI_DTYPE_RSET - a descriptor that references a result set (a number
    01884 of rows as a result of a query).
    01885 OCI_DTYPE_ROWID - a ROWID descriptor
    01886 OCI_DTYPE_COMPLEXOBJECTCOMP - a complex object retrieval
    01887 descriptor
    01888 Related Functions
    01889 OCIDescAlloc()
    01890
    01891
    01892
    01893 OCIDescribeAny()
    01894 Name
    01895 OCI DeSCribe Any
    01896 Purpose
    01897 Describes existing schema objects.
    01898 Syntax
    01899 sword OCIDescribeAny ( OCISvcCtx     *svchp,
    01900                      OCIError      *errhp,
    01901                      dvoid         *objptr,
    01902                      ub4           objptr_len,
    01903                            ub1           objptr_typ,
    01904                      ub1           info_level,
    01905                            ub1           objtype,
    01906                      OCIDesc       *dschp );
    01907 Comments
    01908 This is a generic describe call that describes existing schema objects: tables,
    01909 views, synonyms, procedures, functions, packages, sequences, and types. As a
    01910 result of this call, the describe handle is populated with the object-specific
    01911 attributes which can be obtained through an OCIAttrGet() call.
    01912 An OCIParamGet() on the describe handle returns a parameter descriptor for a
    01913 specified position. Parameter positions begin with 1. Calling OCIAttrGet() on
    01914 the parameter descriptor returns the specific attributes of a stored procedure
    01915 or function parameter or a table column descriptor as the case may be.
    01916 These subsequent calls do not need an extra round trip to the server because
    01917 the entire schema object description cached on the client side by
    01918 OCIDescribeAny(). Calling OCIAttrGet() on the describe handle can also return
    01919 the total number of positions.
    01920 See the section "Describing" on page 2-33 for more information about describe
    01921 operations.
    01922 Parameters
    01923 TO BE UPDATED
    01924 svchp (IN/OUT) - a service context handle.
    01925 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    01926 diagnostic information in the event of an error.
    01927 objptr (IN) - the name of the object (a null-terminated string) to be
    01928 described. Only procedure or function names are valid when connected to an
    01929 Oracle7 Server.
    01930 objptr_len (IN) - the length of the string. Must be non-zero.
    01931 objptr_typ (IN) - Must be OCI_OTYPE_NAME, OCI_OTYPE_REF, or OCI_OTYPE_PTR.
    01932 info_level (IN) - reserved for future extensions. Pass OCI_DEFAULT.
    01933 objtype (IN/OUT) - Object type.
    01934 dschp (IN/OUT) - a describe handle that is populated with describe
    01935 information about the object after the call.
    01936 Related Functions
    01937 OCIAttrGet()
    01938
    01939
    01940
    01941 OCIEnvCreate()
    01942 Name
    01943 OCI ENVironment CREATE
    01944 Purpose
    01945 This function creates and initializes an environment for the rest of
    01946 the OCI functions to work under.  This call is a replacement for both
    01947 the OCIInitialize and OCIEnvInit calls.
    01948 Syntax
    01949 sword OCIEnvCreate  ( OCIEnv        **envhpp,
    01950                       ub4           mode,
    01951                       dvoid         *ctxp,
    01952                       dvoid         *(*malocfp)
    01953                                     (dvoid *ctxp,
    01954                                         size_t size),
    01955                       dvoid         *(*ralocfp)
    01956                                     (dvoid *ctxp,
    01957                                        dvoid *memptr,
    01958                                        size_t newsize),
    01959                       void          (*mfreefp)
    01960                                     (dvoid *ctxp,
    01961                                        dvoid *memptr))
    01962                       size_t        xtramemsz,
    01963                       dvoid         **usrmempp );
    01964
    01965 Comments
    01966 This call creates an environment for all the OCI calls using the modes
    01967 specified by the user. This call can be used instead of the two calls
    01968 OCIInitialize and OCIEnvInit. This function returns an environment handle
    01969 which is then used by the remaining OCI functions. There can be multiple
    01970 environments in OCI each with its own environment modes.  This function
    01971 also performs any process level initialization if required by any mode.
    01972 For example if the user wants to initialize an environment as OCI_THREADED,
    01973 then all libraries that are used by OCI are also initialized in the
    01974 threaded mode.
    01975
    01976 This call should be invoked before anny other OCI call and should be used
    01977 instead of the OCIInitialize and OCIEnvInit calls. This is the recommended
    01978 call, although OCIInitialize and OCIEnvInit calls will still be supported
    01979 for backward compatibility.
    01980
    01981 envpp (OUT) - a pointer to a handle to the environment.
    01982 mode (IN) - specifies initialization of the mode. The valid modes are:
    01983 OCI_DEFAULT - default mode.
    01984 OCI_THREADED - threaded environment. In this mode, internal data
    01985 structures are protected from concurrent accesses by multiple threads.
    01986 OCI_OBJECT - will use navigational object interface.
    01987 ctxp (IN) - user defined context for the memory call back routines.
    01988 malocfp (IN) - user-defined memory allocation function. If mode is
    01989 OCI_THREADED, this memory allocation routine must be thread safe.
    01990 ctxp - context pointer for the user-defined memory allocation function.
    01991 size - size of memory to be allocated by the user-defined memory
    01992 allocation function
    01993 ralocfp (IN) - user-defined memory re-allocation function. If mode is
    01994 OCI_THREADED, this memory allocation routine must be thread safe.
    01995 ctxp - context pointer for the user-defined memory reallocation
    01996 function.
    01997 memp - pointer to memory block
    01998 newsize - new size of memory to be allocated
    01999 mfreefp (IN) - user-defined memory free function. If mode is
    02000 OCI_THREADED, this memory free routine must be thread safe.
    02001 ctxp - context pointer for the user-defined memory free function.
    02002 memptr - pointer to memory to be freed
    02003 xtramemsz (IN) - specifies the amount of user memory to be allocated.
    02004 usrmempp (OUT) - returns a pointer to the user memory of size xtramemsz
    02005 allocated by the call for the user.
    02006
    02007 Example
    02008
    02009 Related Functions
    02010 OCIInitialize, OCIEnvInit
    02011
    02012
    02013 OCIEnvNlsCreate()
    02014 Name
    02015 OCI ENVironment CREATE with NLS info
    02016 Purpose
    02017 This function does almost everything OCIEnvCreate does, plus enabling setting
    02018 of charset and ncharset programmatically, except OCI_UTF16 mode.
    02019 Syntax
    02020 sword OCIEnvNlsCreate(OCIEnv        **envhpp,
    02021                       ub4           mode,
    02022                       dvoid         *ctxp,
    02023                       dvoid         *(*malocfp)
    02024                                     (dvoid *ctxp,
    02025                                         size_t size),
    02026                       dvoid         *(*ralocfp)
    02027                                     (dvoid *ctxp,
    02028                                        dvoid *memptr,
    02029                                        size_t newsize),
    02030                       void          (*mfreefp)
    02031                                     (dvoid *ctxp,
    02032                                        dvoid *memptr),
    02033                       size_t        xtramemsz,
    02034                       dvoid         **usrmempp,
    02035                       ub2           charset,
    02036                       ub2           ncharset)
    02037 Comments
    02038 The parameters have the same meaning as the ones in OCIEnvCreate().
    02039 The charset and ncharset must be both zero or non-zero.
    02040 When charset or ncharset is non-zero, the corresponding character set will
    02041 be used to replace the ones specified in NLS_LANG or NLS_NCHAR. Moreover,
    02042 OCI_UTF16ID is allowed to be set as charset and ncharset.
    02043 On the other hand, OCI_UTF16 mode is deprecated with this function.
    02044 Applications can achieve the same effects by setting
    02045 both charset and ncharset as OCI_UTF16ID.
    02046
    02047
    02048 OCIEnvInit()
    02049 Name
    02050 OCI INITialize environment
    02051 Purpose
    02052 This call initializes the OCI environment handle.
    02053 Syntax
    02054 sword OCIEnvInit ( OCIEnv    **envp,
    02055                  ub4       mode,
    02056                  size_t    xtramemsz,
    02057                  dvoid     **usrmempp );
    02058 Comments
    02059 Initializes the OCI environment handle. No changes are done on an initialized
    02060 handle. If OCI_ERROR or OCI_SUCCESS_WITH_INFO is returned, the
    02061 environment handle can be used to obtain ORACLE specific errors and
    02062 diagnostics.
    02063 This call is processed locally, without a server round-trip.
    02064 Parameters
    02065 envpp (OUT) - a pointer to a handle to the environment.
    02066 mode (IN) - specifies initialization of an environment mode. The only valid
    02067 mode is OCI_DEFAULT for default mode
    02068 xtramemsz (IN) - specifies the amount of user memory to be allocated.
    02069 usrmempp (OUT) - returns a pointer to the user memory of size xtramemsz
    02070 allocated by the call for the user.
    02071 Example
    02072 See the description of OCISessionBegin() on page 13-84 for an example showing
    02073 the use of OCIEnvInit().
    02074 Related Functions
    02075
    02076
    02077
    02078
    02079 OCIErrorGet()
    02080 Name
    02081 OCI Get Diagnostic Record
    02082 Purpose
    02083 Returns an error message in the buffer provided and an ORACLE error.
    02084 Syntax
    02085 sword OCIErrorGet ( dvoid      *hndlp,
    02086                   ub4        recordno,
    02087                   OraText       *sqlstate,
    02088                   ub4        *errcodep,
    02089                   OraText       *bufp,
    02090                   ub4        bufsiz,
    02091                   ub4        type );
    02092 Comments
    02093 Returns an error message in the buffer provided and an ORACLE error.
    02094 Currently does not support SQL state. This call can be called a multiple
    02095 number of times if there are more than one diagnostic record for an error.
    02096 The error handle is originally allocated with a call to OCIHandleAlloc().
    02097 Parameters
    02098 hndlp (IN) - the error handle, in most cases, or the environment handle (for
    02099 errors on OCIEnvInit(), OCIHandleAlloc()).
    02100 recordno (IN) - indicates the status record from which the application seeks
    02101 info. Starts from 1.
    02102 sqlstate (OUT) - Not supported in Version 8.0.
    02103 errcodep (OUT) - an ORACLE Error is returned.
    02104 bufp (OUT) - the error message text is returned.
    02105 bufsiz (IN) - the size of the buffer provide to get the error message.
    02106 type (IN) - the type of the handle.
    02107 Related Functions
    02108 OCIHandleAlloc()
    02109
    02110 OCIExtractInit
    02111 Name
    02112 OCI Extract Initialize
    02113 Purpose
    02114 This function initializes the parameter manager.
    02115 Syntax
    02116 sword OCIExtractInit(dvoid *hndl, OCIError *err);
    02117 Comments
    02118 It must be called before calling any other parameter manager routine. The NLS
    02119 information is stored inside the parameter manager context and used in
    02120 subsequent calls to OCIExtract routines.
    02121 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    02122 Parameters
    02123 hndl (IN/OUT) - The OCI environment or session handle.
    02124 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02125                err and this function returns OCI_ERROR. Diagnostic information
    02126                can be obtained by calling OCIErrorGet().
    02127 Related Functions
    02128 OCIExtractTerm()
    02129
    02130 OCIExtractTerm
    02131 Name
    02132 OCI Extract Terminate
    02133 Purpose
    02134 This function releases all dynamically allocated storage and may perform
    02135 other internal bookkeeping functions.
    02136 Syntax
    02137 sword OCIExtractTerm(dvoid *hndl, OCIError *err);
    02138 Comments
    02139 It must be called when the parameter manager is no longer being used.
    02140 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    02141 Parameters
    02142 hndl (IN/OUT) - The OCI environment or session handle.
    02143 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02144                err and this function returns OCI_ERROR. Diagnostic information
    02145                can be obtained by calling OCIErrorGet().
    02146 Related Functions
    02147 OCIExtractInit()
    02148
    02149 OCIExtractReset
    02150 Name
    02151 OCI Extract Reset
    02152 Purpose
    02153 The memory currently used for parameter storage, key definition storage, and
    02154 parameter value lists is freed and the structure is reinitialized.
    02155 Syntax
    02156 sword OCIExtractReset(dvoid *hndl, OCIError *err);
    02157 Comments
    02158 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    02159 Parameters
    02160 hndl (IN/OUT) - The OCI environment or session handle.
    02161 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02162                err and this function returns OCI_ERROR. Diagnostic information
    02163                can be obtained by calling OCIErrorGet().
    02164 Related Functions
    02165
    02166 OCIExtractSetNumKeys
    02167 Name
    02168 OCI Extract Set Number of Keys
    02169 Purpose
    02170 Informs the parameter manager of the number of keys that will be registered.
    02171 Syntax
    02172 sword OCIExtractSetNumKeys(dvoid *hndl, OCIError *err, uword numkeys);
    02173 Comments
    02174 This routine must be called prior to the first call of OCIExtractSetKey().
    02175 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    02176 Parameters
    02177 hndl (IN/OUT) - The OCI environment or session handle.
    02178 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02179                err and this function returns OCI_ERROR. Diagnostic information
    02180                can be obtained by calling OCIErrorGet().
    02181 numkeys (IN) - The number of keys that will be registered with
    02182                OCIExtractSetKey().
    02183 Related Functions
    02184 OCIExtractSetKey()
    02185
    02186 OCIExtractSetKey
    02187 Name
    02188 OCI Extract Set Key definition
    02189 Purpose
    02190 Registers information about a key with the parameter manager.
    02191 Syntax
    02192 sword OCIExtractSetKey(dvoid *hndl, OCIError *err, CONST OraText *name, ub1 type,
    02193                        ub4 flag, CONST dvoid *defval, CONST sb4 *intrange,
    02194                        CONST OraText *CONST *strlist);
    02195 Comments
    02196 This routine must be called after calling OCIExtractSetKey() and before
    02197 calling OCIExtractFromFile() or OCIExtractFromStr().
    02198 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    02199 Parameters
    02200 hndl (IN/OUT) - The OCI environment or session handle.
    02201 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02202                err and this function returns OCI_ERROR. Diagnostic information
    02203                can be obtained by calling OCIErrorGet().
    02204 name (IN) - The name of the key.
    02205 type (IN) - The type of the key (OCI_EXTRACT_TYPE_INTEGER,
    02206             OCI_EXTRACT_TYPE_OCINUM, OCI_EXTRACT_TYPE_STRING, or
    02207             OCI_EXTRACT_TYPE_BOOLEAN).
    02208 flag (IN) - Set to OCI_EXTRACT_MULTIPLE if the key can take multiple values
    02209             or 0 otherwise.
    02210 defval (IN) - Set to the default value for the key.  May be NULL if there is
    02211                no default.  A string default must be a (text*) type, an
    02212                integer default must be an (sb4*) type, and a boolean default
    02213                must be a (ub1*) type.
    02214 intrange (IN) - Starting and ending values for the allowable range of integer
    02215                 values.  May be NULL if the key is not an integer type or if
    02216                 all integer values are acceptable.
    02217 strlist (IN) - List of all acceptable text strings for the key.  May be NULL
    02218                if the key is not a string type or if all text values are
    02219                acceptable.
    02220 Related Functions
    02221 OCIExtractSetNumKeys()
    02222
    02223 OCIExtractFromFile
    02224 Name
    02225 OCI Extract parameters From File
    02226 Purpose
    02227 The keys and their values in the given file are processed.
    02228 Syntax
    02229 sword OCIExtractFromFile(dvoid *hndl, OCIError *err, ub4 flag, OraText *filename);
    02230 Comments
    02231 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    02232 Parameters
    02233 hndl (IN/OUT) - The OCI environment or session handle.
    02234 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02235                err and this function returns OCI_ERROR. Diagnostic information
    02236                can be obtained by calling OCIErrorGet().
    02237 flag (IN) - Zero or has one or more of the following bits set:
    02238            OCI_EXTRACT_CASE_SENSITIVE, OCI_EXTRACT_UNIQUE_ABBREVS, or
    02239            OCI_EXTRACT_APPEND_VALUES.
    02240 filename (IN) - Null-terminated filename string.
    02241 Related Functions
    02242
    02243 OCIExtractFromStr
    02244 Name
    02245 OCI Extract parameters From String
    02246 Purpose
    02247 The keys and their values in the given string are processed.
    02248 Syntax
    02249 sword OCIExtractFromStr(dvoid *hndl, OCIError *err, ub4 flag, OraText *input);
    02250 Comments
    02251 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    02252 Parameters
    02253 hndl (IN/OUT) - The OCI environment or session handle.
    02254 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02255                err and this function returns OCI_ERROR. Diagnostic information
    02256                can be obtained by calling OCIErrorGet().
    02257 flag (IN) - Zero or has one or more of the following bits set:
    02258            OCI_EXTRACT_CASE_SENSITIVE, OCI_EXTRACT_UNIQUE_ABBREVS, or
    02259            OCI_EXTRACT_APPEND_VALUES.
    02260 input (IN) - Null-terminated input string.
    02261 Related Functions
    02262
    02263 OCIExtractToInt
    02264 Name
    02265 OCI Extract To Integer
    02266 Purpose
    02267 Gets the integer value for the specified key.
    02268 Syntax
    02269 sword OCIExtractToInt(dvoid *hndl, OCIError *err, OraText *keyname, uword valno,
    02270                       sb4 *retval);
    02271 Comments
    02272 The valno'th value (starting with 0) is returned.
    02273 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, OCI_NO_DATA, or OCI_ERROR.
    02274 OCI_NO_DATA means that there is no valno'th value for this key.
    02275 Parameters
    02276 hndl (IN) - The OCI environment or session handle.
    02277 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02278                err and this function returns OCI_ERROR. Diagnostic information
    02279                can be obtained by calling OCIErrorGet().
    02280 keyname (IN) - Key name.
    02281 valno (IN) - Which value to get for this key.
    02282 retval (OUT) - The actual integer value.
    02283 Related Functions
    02284
    02285 OCIExtractToBool
    02286 Name
    02287 OCI Extract To Boolean
    02288 Purpose
    02289 Gets the boolean value for the specified key.
    02290 Syntax
    02291 sword OCIExtractToBool(dvoid *hndl, OCIError *err, OraText *keyname, uword valno,
    02292                        ub1 *retval);
    02293 Comments
    02294 The valno'th value (starting with 0) is returned.
    02295 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, OCI_NO_DATA, or OCI_ERROR.
    02296 OCI_NO_DATA means that there is no valno'th value for this key.
    02297 Parameters
    02298 hndl (IN) - The OCI environment or session handle.
    02299 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02300                err and this function returns OCI_ERROR. Diagnostic information
    02301                can be obtained by calling OCIErrorGet().
    02302 keyname (IN) - Key name.
    02303 valno (IN) - Which value to get for this key.
    02304 retval (OUT) - The actual boolean value.
    02305 Related Functions
    02306
    02307 OCIExtractToStr
    02308 Name
    02309 OCI Extract To String
    02310 Purpose
    02311 Gets the string value for the specified key.
    02312 Syntax
    02313 sword OCIExtractToStr(dvoid *hndl, OCIError *err, OraText *keyname, uword valno,
    02314                       OraText *retval, uword buflen);
    02315 Comments
    02316 The valno'th value (starting with 0) is returned.
    02317 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, OCI_NO_DATA, or OCI_ERROR.
    02318 OCI_NO_DATA means that there is no valno'th value for this key.
    02319 Parameters
    02320 hndl (IN) - The OCI environment or session handle.
    02321 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02322                err and this function returns OCI_ERROR. Diagnostic information
    02323                can be obtained by calling OCIErrorGet().
    02324 keyname (IN) - Key name.
    02325 valno (IN) - Which value to get for this key.
    02326 retval (OUT) - The actual null-terminated string value.
    02327 buflen (IN) - The length of the buffer for retval.
    02328 Related Functions
    02329
    02330 Note: The following OCIExtract functions are unavailable in this release
    02331
    02332 OCIExtractToOCINum
    02333 Name
    02334 OCI Extract To OCI Number
    02335 Purpose
    02336 Gets the OCINumber value for the specified key.
    02337 Syntax
    02338 sword OCIExtractToOCINum(dvoid *hndl, OCIError *err, OraText *keyname,
    02339                          uword valno, OCINumber *retval);
    02340 Comments
    02341 The valno'th value (starting with 0) is returned.
    02342 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, OCI_NO_DATA, or OCI_ERROR.
    02343 OCI_NO_DATA means that there is no valno'th value for this key.
    02344 Parameters
    02345 hndl (IN) - The OCI environment or session handle.
    02346 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02347                err and this function returns OCI_ERROR. Diagnostic information
    02348                can be obtained by calling OCIErrorGet().
    02349 keyname (IN) - Key name.
    02350 valno (IN) - Which value to get for this key.
    02351 retval (OUT) - The actual OCINumber value.
    02352 Related Functions
    02353
    02354 OCIExtractToList
    02355 Name
    02356 OCI Extract To parameter List
    02357 Purpose
    02358 Generates a list of parameters from the parameter structures that are stored
    02359 in memory.
    02360 Syntax
    02361 sword OCIExtractToList(dvoid *hndl, OCIError *err, uword *numkeys);
    02362 Comments
    02363 Must be called before OCIExtractValues() is called.
    02364 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    02365 Parameters
    02366 hndl (IN) - The OCI environment or session handle.
    02367 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02368                err and this function returns OCI_ERROR. Diagnostic information
    02369                can be obtained by calling OCIErrorGet().
    02370 numkeys (OUT) - Number of distinct keys stored in memory.
    02371 Related Functions
    02372 OCIExtractFromList()
    02373
    02374 OCIExtractFromList
    02375 Name
    02376 OCI Extract From parameter List
    02377 Purpose
    02378 Generates a list of values for the a parameter in the parameter list.
    02379 Syntax
    02380 sword OCIExtractFromList(dvoid *hndl, OCIError *err, uword index, OraText *name,
    02381                          ub1 *type, uword *numvals, dvoid ***values);
    02382 Comments
    02383 Parameters are specified by an index. OCIExtractToList() must be called prior
    02384 to calling this routine to generate the parameter list from the parameter
    02385 structures that are stored in memory.
    02386 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    02387 Parameters
    02388 hndl (IN) - The OCI environment or session handle.
    02389 err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    02390                err and this function returns OCI_ERROR. Diagnostic information
    02391                can be obtained by calling OCIErrorGet().
    02392 name (OUT) - Name of the key for the current parameter.
    02393 type (OUT) - Type of the current parameter (OCI_EXTRACT_TYPE_STRING,
    02394              OCI_EXTRACT_TYPE_INTEGER, OCI_EXTRACT_TYPE_OCINUM, or
    02395              OCI_EXTRACT_TYPE_BOOLEAN)
    02396 numvals (OUT) - Number of values for this parameter.
    02397 values (OUT) - The values for this parameter.
    02398 Related Functions
    02399 OCIExtractToList()
    02400
    02401
    02402 ************************  OCIFileClose() ***********************************
    02403
    02404 Name
    02405  OCIFileClose - Oracle Call Interface FILE i/o CLOSE
    02406
    02407 Purpose
    02408  Close a previously opened file.
    02409
    02410 Syntax
    02411  sword OCIFileClose ( dvoid             *hndl,
    02412                             OCIError          *err,
    02413                       OCIFileObject     *filep )
    02414
    02415 Comments
    02416  This function will close a previously opened file. If the function succeeds
    02417  then OCI_SUCCESS will be returned, else OCI_ERROR.
    02418
    02419 Parameters
    02420  hndl  (IN) - the OCI environment or session handle.
    02421  err (OUT) - the OCI error handle
    02422  filep (IN) - the OCIFile file object
    02423
    02424 Related Functions
    02425  OCIFileOpen.
    02426
    02427
    02428
    02429 ********************* OCIFileExists() **************************************
    02430
    02431 Name
    02432  OCIFileExists - Oracle Call Interface FILE i/o EXIST
    02433
    02434 Purpose
    02435  Check to see if the file exists.
    02436
    02437 Syntax
    02438  sword OCIFileExists ( dvoid           *hndl,
    02439                             OCIError         *err,
    02440                       OraText          *filename,
    02441                       OraText          *path,
    02442                       ub1              *flag )
    02443
    02444 Comments
    02445  This function will set the flag to TRUE if the file exists else it will
    02446  be set to FALSE.
    02447  The function will return OCI_ERROR if any error is encountered, else
    02448  it will return OCI_ERROR.
    02449
    02450 Parameters
    02451  hndl(IN) - OCI environment or session handleenv
    02452  err(OUT) - OCI error handle
    02453  filename(IN) - filename
    02454  path(IN) - path of the file
    02455  flag(OUT) - whether the file exists or not
    02456
    02457 Related Functions.
    02458  None.
    02459
    02460
    02461  **************************** OCIFileFlush() ******************************
    02462
    02463
    02464 Name
    02465  OCIFileFlush - Oracle Call Interface File i/o FLUSH
    02466
    02467 Purpose
    02468  Flush the buffers associated with the file to the disk.
    02469
    02470 Syntax
    02471  sword OCIFileFlush ( dvoid             *hndl,
    02472                             OCIError          *err,
    02473                       OCIFileObject     *filep )
    02474
    02475 Comments
    02476  The function will return OCI_ERROR if any error is encountered, else
    02477  it will return OCI_ERROR.
    02478
    02479 Parameters
    02480  hndl (IN) - the OCI environment or session handle.
    02481  err (OUT) - the OCI error handle
    02482  filep (IN) - the OCIFile file object
    02483
    02484 Related Functions
    02485  OCIFileOpen, OCIFileWrite
    02486
    02487
    02488
    02489  *************************** OCIFileGetLength() ****************************
    02490
    02491 Name
    02492  OCIFileGetLength - Oracle Call Interface FILE i/o GET file LENGTH
    02493
    02494 Purpose
    02495  Get the length of a file.
    02496
    02497 Syntax
    02498  OCIFileGetLength(dvoid           *hndl,
    02499                      OCIError        *err,
    02500                   OraText         *filename,
    02501                   OraText         *path,
    02502                   ubig_ora        *lenp )
    02503
    02504 Comments
    02505  The length of the file will be returned in lenp.
    02506  The function will return OCI_ERROR if any error is encountered, else
    02507  it will return OCI_ERROR.
    02508
    02509 Parameters
    02510  hndl (IN) - the OCI environment or session handle.
    02511  err (OUT) - the OCI error handle.  If  there is an error, it is recorded
    02512  in err and this function returns OCI_ERROR.  Diagnostic information can be
    02513  obtained by calling OCIErrorGet().
    02514  filename (IN) - file name.
    02515  path (IN) - path of the file.
    02516  lenp (OUT) - On output, it is the length of the file in bytes.
    02517  is the number of bytes in the file.
    02518
    02519 Related Functions
    02520  None.
    02521
    02522
    02523
    02524 ******************************** OCIFileInit() *****************************
    02525
    02526 Name
    02527  OCIFileInit - Oracle Call Interface FILE i/o INITialize
    02528
    02529 Purpose
    02530  Initialize the OCI File I/O package and create the OCIFile context.
    02531
    02532 Syntax
    02533  sword OCIFileInit ( dvoid *hndl,
    02534                      OCIError *err)
    02535
    02536 Comments
    02537  This function should be called before any of the OCIFile functions are
    02538  used.
    02539  The function will return OCI_ERROR if any error is encountered, else
    02540  it will return OCI_ERROR.
    02541
    02542 Parameters
    02543  hndl(IN) - OCI environment or session handle.
    02544  err(OUT) - OCI error structure.
    02545
    02546 Related Functions
    02547  OCIFileTerm
    02548
    02549
    02550
    02551 ********************************* OCIFileOpen() *****************************
    02552
    02553 Name
    02554  OCIFileOpen - Oracle Call Interface File i/o OPEN
    02555
    02556 Purpose
    02557      Open a file.
    02558
    02559 Syntax
    02560  sword OCIFileOpen ( dvoid               *hndl,
    02561                         OCIError            *err,
    02562                      OCIFileObject      **filep,
    02563                      OraText             *filename,
    02564                      OraText             *path,
    02565                      ub4                  mode,
    02566                      ub4                  create,
    02567                      ub4                  type )
    02568
    02569 Comments
    02570  OCIFileOpen returns a handle to the open file in filep if the file is
    02571  successfully opened.
    02572  If one wants to use the standard file objects (stdin, stdout & stderr)
    02573  then OCIFileOpen whould be called with the type filed containing the
    02574  appropriate type (see the parameter type). If any of the standard files
    02575  are specified then filename, path, mode and create are ignored.
    02576  The function will return OCI_ERROR if any error is encountered, else
    02577  it will return OCI_ERROR.
    02578
    02579 Parameters
    02580  hndl (OUT) - the OCI environment or session handle.
    02581  err (OUT) - the OCI error handle.  If  there is an error, it is recorded
    02582  in err and this function returns OCI_ERROR.  Diagnostic information can be
    02583  obtained by calling OCIErrorGet().
    02584  filep (OUT) - the file object to be returned.
    02585  filename (IN) - file name (NULL terminated string).
    02586  path (IN) - path of the file (NULL terminated string).
    02587  mode - mode in which to open the file (valid modes are OCI_FILE_READONLY,
    02588  OCI_FILE_WRITEONLY, OCI_FILE_READ_WRITE).
    02589  create - should the file be created if it does not exist. Valid values
    02590  are:
    02591      OCI_FILE_TRUNCATE - create a file regardless of whether or not it exists.
    02592                         If the file already exists overwrite it.
    02593      OCI_FILE_EXCL - fail if the file exists, else create.
    02594      OCI_FILE_EXIST - open it if it exists, else fail.
    02595      OCI_FILE_CREATE - open the file if it exists, and create it if it doesn't.
    02596      OCI_FILE_APPEND - set the file pointer to the end of the file prior to
    02597                       writing(this flag can be OR'ed with OCI_FILE_EXIST or
    02598                       OCI_FILE_CREATE).
    02599 type - file type. Valid values are OCI_FILE_TEXT, OCI_FILE_BIN,
    02600        OCI_FILE_STDIN, OCI_FILE_STDOUT and OCI_FILE_STDERR.
    02601        If any of the standard files are specified then filename, path, mode
    02602        and create are ignored.
    02603
    02604 Related Functions.
    02605  OCIFileClose
    02606
    02607
    02608
    02609 ************************** OCIFileRead() ************************************
    02610
    02611 Name
    02612  OCIFileRead - Oracle Call Interface FILE i/o READ
    02613
    02614 Purpose
    02615  Read from a file into a buffer.
    02616
    02617 Syntax
    02618  sword OCIFileRead ( dvoid            *hndl,
    02619                 OCIError         *err,
    02620                      OCIFileObject    *filep,
    02621                      dvoid            *bufp,
    02622                      ub4               bufl,
    02623                      ub4              *bytesread )
    02624
    02625 Comments
    02626  Upto bufl bytes from the file will be read into bufp. The user should
    02627  allocate memory for the buffer.
    02628  The number of bytes read would be in bytesread.
    02629  The function will return OCI_ERROR if any error is encountered, else
    02630  it will return OCI_ERROR.
    02631
    02632 Parameters
    02633  hndl (IN) - the OCI environment or session handle.
    02634  err (OUT) - the OCI error handle.  If  there is an error, it is recorded
    02635  in err and this function returns OCI_ERROR.  Diagnostic information can be
    02636  obtained by calling OCIErrorGet().
    02637  filep (IN/OUT) - a File Object that uniquely references the file.
    02638  bufp (IN) - the pointer to a buffer into which the data will be read. The
    02639  length of the allocated memory is assumed to be bufl.
    02640  bufl - the length of the buffer in bytes.
    02641  bytesread (OUT) - the number of bytes read.
    02642
    02643 Related Functions
    02644  OCIFileOpen, OCIFileSeek, OCIFileWrite
    02645
    02646
    02647
    02648 ****************************** OCIFileSeek() ******************************
    02649
    02650 Name
    02651  OCIFileSeek - Oracle Call Interface FILE i/o SEEK
    02652
    02653 Purpose
    02654  Perfom a seek to a byte position.
    02655
    02656 Syntax
    02657  sword OCIFileSeek ( dvoid           *hndl,
    02658                 OCIError        *err,
    02659                      OCIFileObject   *filep,
    02660                      uword            origin,
    02661                      ubig_ora         offset,
    02662                      sb1              dir)
    02663
    02664 Comments
    02665  The function will return OCI_ERROR if any error is encountered, else
    02666  it will return OCI_ERROR.
    02667
    02668 Parameters
    02669  hndl (IN) - the OCI environment or session handle.
    02670  err (OUT) - the OCI error handle.  If  there is an error, it is recorded
    02671  in err and this function returns OCI_ERROR.  Diagnostic information can be
    02672  obtained by calling OCIErrorGet().
    02673  filep (IN/OUT) - a file handle that uniquely references the file.
    02674  origin - The starting point we want to seek from. NOTE: The starting
    02675  point may be OCI_FILE_SEEK_BEGINNING (beginning), OCI_FILE_SEEK_CURRENT
    02676  (current position), or OCI_FILE_SEEK_END (end of file).
    02677  offset - The number of bytes from the origin we want to start reading from.
    02678  dir - The direction we want to go from the origin. NOTE: The direction
    02679  can be either OCI_FILE_FORWARD or OCI_FILE_BACKWARD.
    02680
    02681 Related Function
    02682  OCIFileOpen, OCIFileRead, OCIFileWrite
    02683
    02684
    02685
    02686 *************************** OCIFileTerm() **********************************
    02687
    02688 Name
    02689  OCIFileTerm - Oracle Call Interface FILE i/o TERMinate
    02690
    02691 Purpose
    02692  Terminate the OCI File I/O package and destroy the OCI File context.
    02693
    02694 Syntax
    02695  sword OCIFileTerm ( dvoid *hndl,
    02696                      OCIError *err )
    02697
    02698 Comments
    02699  After this function has been called no OCIFile function should be used.
    02700  The function will return OCI_ERROR if any error is encountered, else
    02701  it will return OCI_ERROR.
    02702
    02703 Parameters
    02704  hndl(IN) - OCI environment or session handle.
    02705  err(OUT) - OCI error structure.
    02706
    02707 Related Functions
    02708  OCIFileInit
    02709
    02710
    02711 ********************************* OCIFileWrite() ****************************
    02712
    02713 Name
    02714  OCIFileWrite - Oracle Call Interface FILE i/o WRITE
    02715
    02716 Purpose
    02717   Write data from buffer into a file.
    02718
    02719 Syntax
    02720  sword OCIFileWrite ( dvoid            *hndl,
    02721                             OCIError         *err,
    02722                       OCIFileObject    *filep,
    02723                       dvoid            *bufp,
    02724                       ub4               buflen
    02725                       ub4              *byteswritten )
    02726
    02727 Comments
    02728  The number of bytes written will be in *byteswritten.
    02729  The function will return OCI_ERROR if any error is encountered, else
    02730  it will return OCI_ERROR.
    02731
    02732 Parameters
    02733  hndl (IN) - the OCI environment or session handle.
    02734  err (OUT) - the OCI error handle.  If  there is an error, it is recorded
    02735  in err and this function returns OCI_ERROR.  Diagnostic information can be
    02736  obtained by calling OCIErrorGet().
    02737  filep (IN/OUT) - a file handle that uniquely references the file.
    02738  bufp (IN) - the pointer to a buffer from which the data will be written.
    02739  The length of the allocated memory is assumed to be the value passed
    02740  in bufl.
    02741  bufl - the length of the buffer in bytes.
    02742  byteswritten (OUT) - the number of bytes written.
    02743
    02744 Related Functions
    02745  OCIFileOpen, OCIFileSeek, OCIFileRead
    02746
    02747
    02748
    02749 OCIHandleAlloc()
    02750 Name
    02751 OCI Get HaNDLe
    02752 Purpose
    02753 This call returns a pointer to an allocated and initialized handle.
    02754 Syntax
    02755 sword OCIHandleAlloc ( CONST dvoid   *parenth,
    02756                      dvoid         **hndlpp,
    02757                      ub4           type,
    02758                      size_t        xtramem_sz,
    02759                      dvoid         **usrmempp);
    02760 Comments
    02761 Returns a pointer to an allocated and initialized structure, corresponding to
    02762 the type specified in type. A non-NULL handle is returned on success. Bind
    02763 handle and define handles are allocated with respect to a statement handle. All
    02764 other handles are allocated with respect to an environment handle which is
    02765 passed in as a parent handle.
    02766 No diagnostics are available on error. This call returns OCI_SUCCESS if
    02767 successful, or OCI_INVALID_HANDLE if an out-of-memory error occurs.
    02768 Handles must be allocated using OCIHandleAlloc() before they can be passed
    02769 into an OCI call.
    02770 Parameters
    02771 parenth (IN) - an environment or a statement handle.
    02772 hndlpp (OUT) - returns a handle to a handle type.
    02773 type (IN) - specifies the type of handle to be allocated. The specific types
    02774 are:
    02775 OCI_HTYPE_ERROR - specifies generation of an error report handle of
    02776 C type OCIError
    02777 OCI_HTYPE_SVCCTX - specifies generation of a service context handle
    02778 of C type OCISvcCtx
    02779 OCI_HTYPE_STMT - specifies generation of a statement (application
    02780 request) handle of C type OCIStmt
    02781 OCI_HTYPE_BIND - specifies generation of a bind information handle
    02782 of C type OCIBind
    02783 OCI_HTYPE_DEFINE - specifies generation of a column definition
    02784 handle of C type OCIDefine
    02785 OCI_HTYPE_DESCRIBE  - specifies generation of a select list
    02786 description handle of C type OCIDesc
    02787 OCI_HTYPE_SERVER - specifies generation of a server context handle
    02788 of C type OCIServer
    02789 OCI_HTYPE_SESSION - specifies generation of an authentication
    02790 context handle of C type OCISession
    02791 OCI_HTYPE_TRANS - specifies generation of a transaction context
    02792 handle of C type OCITrans
    02793 OCI_HTYPE_COMPLEXOBJECT - specifies generation of a complex
    02794 object retrieval handle of C type OCIComplexObject
    02795 OCI_HTYPE_SECURITY - specifies generation of a security handle of C
    02796 type OCISecurity
    02797 xtramem_sz (IN) - specifies an amount of user memory to be allocated.
    02798 usrmempp (OUT) - returns a pointer to the user memory of size xtramemsz
    02799 allocated by the call for the user.
    02800 Related Functions
    02801 OCIHandleFree()
    02802
    02803
    02804
    02805 OCIHandleFree()
    02806 Name
    02807 OCI Free HaNDLe
    02808 Purpose
    02809 This call explicitly deallocates a handle.
    02810 Syntax
    02811 sword OCIHandleFree ( dvoid     *hndlp,
    02812                     ub4       type);
    02813 Comments
    02814 This call frees up storage associated with a handle, corresponding to the type
    02815 specified in the type parameter.
    02816 This call returns either OCI_SUCCESS or OCI_INVALID_HANDLE.
    02817 All handles must be explicitly deallocated. OCI will not deallocate a child
    02818 handle if the parent is deallocated.
    02819 Parameters
    02820 hndlp (IN) - an opaque pointer to some storage.
    02821 type (IN) - specifies the type of storage to be allocated. The specific types are:
    02822 OCI_HTYPE_ENV - an environment handle
    02823 OCI_HTYPE_ERROR - an error report handle
    02824 OCI_HTYPE_SVCCTX - a service context handle
    02825 OCI_HTYPE_STMT - a statement (application request) handle
    02826 OCI_HTYPE_BIND - a bind information handle
    02827 OCI_HTYPE_DEFINE - a column definition handle
    02828 OCI_HTYPE_DESCRIBE  - a select list description handle
    02829 OCI_HTYPE_SERVER - a server handle
    02830 OCI_HTYPE_SESSION - a user authentication handle
    02831 OCI_HTYPE_TRANS - a transaction handle
    02832 OCI_HTYPE_COMPLEXOBJECT - a complex object retrieval handle
    02833 OCI_HTYPE_SECURITY - a security handle
    02834 Related Functions
    02835 OCIHandleAlloc()
    02836
    02837
    02838
    02839
    02840 OCIInitialize()
    02841 Name
    02842 OCI Process Initialize
    02843 Purpose
    02844 Initializes the OCI process environment.
    02845 Syntax
    02846 sword OCIInitialize ( ub4           mode,
    02847                     CONST dvoid   *ctxp,
    02848                     CONST dvoid   *(*malocfp)
    02849                                   ( dvoid *ctxp,
    02850                                     size_t size ),
    02851                     CONST dvoid   *(*ralocfp)
    02852                                   ( dvoid *ctxp,
    02853                                     dvoid *memp,
    02854                                     size_t newsize ),
    02855                     CONST void    (*mfreefp)
    02856                                   ( dvoid *ctxp,
    02857                                     dvoid *memptr ));
    02858 Comments
    02859 This call initializes the OCI process environment.
    02860 OCIInitialize() must be invoked before any other OCI call.
    02861 Parameters
    02862 mode (IN) - specifies initialization of the mode. The valid modes are:
    02863 OCI_DEFAULT - default mode.
    02864 OCI_THREADED - threaded environment. In this mode, internal data
    02865 structures are protected from concurrent accesses by multiple threads.
    02866 OCI_OBJECT - will use navigational object interface.
    02867 ctxp (IN) - user defined context for the memory call back routines.
    02868 malocfp (IN) - user-defined memory allocation function. If mode is
    02869 OCI_THREADED, this memory allocation routine must be thread safe.
    02870 ctxp - context pointer for the user-defined memory allocation function.
    02871 size - size of memory to be allocated by the user-defined memory
    02872 allocation function
    02873 ralocfp (IN) - user-defined memory re-allocation function. If mode is
    02874 OCI_THREADED, this memory allocation routine must be thread safe.
    02875 ctxp - context pointer for the user-defined memory reallocation
    02876 function.
    02877 memp - pointer to memory block
    02878 newsize - new size of memory to be allocated
    02879 mfreefp (IN) - user-defined memory free function. If mode is
    02880 OCI_THREADED, this memory free routine must be thread safe.
    02881 ctxp - context pointer for the user-defined memory free function.
    02882 memptr - pointer to memory to be freed
    02883 Example
    02884 See the description of OCIStmtPrepare() on page 13-96 for an example showing
    02885 the use of OCIInitialize().
    02886 Related Functions
    02887
    02888
    02889 --------------------------------OCITerminate------------------------------------
    02890
    02891 OCITerminate()
    02892 Name
    02893 OCI process Terminate
    02894 Purpose
    02895 Do cleanup before process termination
    02896 Syntax
    02897 sword OCITerminate ( ub4           mode);
    02898
    02899 Comments
    02900 This call performs  OCI related clean up before the OCI process terminates.
    02901 If the process is running in shared mode then the OCI process is disconnected
    02902 from the shared memory subsystem.
    02903
    02904 OCITerminate() should be the last OCI call in any process.
    02905
    02906 Parameters
    02907 mode (IN) - specifies different termination modes.
    02908
    02909 OCI_DEFAULT - default mode.
    02910
    02911 Example
    02912
    02913 Related Functions
    02914 OCIInitialize()
    02915
    02916  ---------------------- OCIIntervalAssign --------------------
    02917 void OCIIntervalAssign(dvoid *hndl, OCIError *err, CONST OCIInterval *inpinter,
    02918                                  OCIInterval *outinter );
    02919
    02920   DESCRIPTION
    02921     Copies one interval to another to create a replica
    02922   PARAMETERS
    02923      hndl (IN) - Session/Env handle.
    02924     err (IN/OUT) - error handle. If there is an error, it is
    02925                 recorded in 'err' and this function returns OCI_ERROR.
    02926                 The error recorded in 'err' can be retrieved by calling
    02927                 OCIErrorGet().
    02928     (IN)  inpinter - Input Interval
    02929     (OUT) outinter - Output Interval
    02930   RETURNS
    02931      OCI_INVALID_HANDLE if 'err' is NULL.
    02932      OCI_SUCCESS otherwise
    02933
    02934  ---------------------- OCIIntervalCheck --------------------
    02935 sword OCIIntervalCheck(dvoid *hndl, OCIError *err, CONST OCIInterval *interval,
    02936                                   ub4 *valid );
    02937
    02938   DESCRIPTION
    02939     Checks the validity of an interval
    02940   PARAMETERS
    02941      hndl (IN) - Session/Env handle.
    02942     err (IN/OUT) - error handle. If there is an error, it is
    02943                 recorded in 'err' and this function returns OCI_ERROR.
    02944                 The error recorded in 'err' can be retrieved by calling
    02945                 OCIErrorGet().
    02946     (IN)  interval - Interval to be checked
    02947     (OUT) valid     - Zero if the interval is valid, else returns an Ored
    02948            combination of the following codes.
    02949
    02950    Macro name                   Bit number      Error
    02951    ----------                   ----------      -----
    02952    OCI_INTER_INVALID_DAY         0x1           Bad day
    02953    OCI_INTER_DAY_BELOW_VALID     0x2           Bad DAy Low/high bit (1=low)
    02954    OCI_INTER_INVALID_MONTH       0x4           Bad MOnth
    02955    OCI_INTER_MONTH_BELOW_VALID   0x8           Bad MOnth Low/high bit (1=low)
    02956    OCI_INTER_INVALID_YEAR        0x10          Bad YeaR
    02957    OCI_INTER_YEAR_BELOW_VALID    0x20          Bad YeaR Low/high bit (1=low)
    02958    OCI_INTER_INVALID_HOUR        0x40          Bad HouR
    02959    OCI_INTER_HOUR_BELOW_VALID    0x80          Bad HouR Low/high bit (1=low)
    02960    OCI_INTER_INVALID_MINUTE      0x100         Bad MiNute
    02961    OCI_INTER_MINUTE_BELOW_VALID   0x200         Bad MiNute Low/high bit(1=low)
    02962    OCI_INTER_INVALID_SECOND      0x400         Bad SeCond
    02963    OCI_INTER_SECOND_BELOW_VALID  0x800         bad second Low/high bit(1=low)
    02964    OCI_INTER_INVALID_FRACSEC     0x1000        Bad Fractional second
    02965    OCI_INTER_FRACSEC_BELOW_VALID 0x2000        Bad fractional second Low/High
    02966
    02967
    02968   RETURNS
    02969     OCI_SUCCESS if interval is okay
    02970     OCI_INVALID_HANDLE if 'err' is NULL.
    02971
    02972  ---------------------- OCIIntervalCompare --------------------
    02973 sword OCIIntervalCompare(dvoid *hndl, OCIError *err, OCIInterval *inter1,
    02974                                  OCIInterval *inter2, sword *result );
    02975
    02976   DESCRIPTION
    02977            Compares two intervals, returns 0 if equal, -1 if inter1 < inter2,
    02978            1 if inter1 > inter2
    02979   PARAMETERS
    02980      hndl (IN) - Session/Env handle.
    02981      err (IN/OUT) - error handle. If there is an error, it is
    02982                 recorded in 'err' and this function returns OCI_ERROR.
    02983                 The error recorded in 'err' can be retrieved by calling
    02984                 OCIErrorGet().
    02985      inter1  (IN)   - Interval to be compared
    02986      inter2  (IN)   - Interval to be compared
    02987      result  (OUT)  -            comparison result, 0 if equal, -1 if inter1 < inter2,
    02988                       1 if inter1 > inter2
    02989
    02990   RETURNS
    02991      OCI_SUCCESS on success
    02992      OCI_INVALID_HANDLE if 'err' is NULL.
    02993      OCI_ERROR if
    02994            the two input datetimes are not mutually comparable.
    02995
    02996 ---------------------- OCIIntervalDivide --------------------
    02997 sword OCIIntervalDivide(dvoid *hndl, OCIError *err, OCIInterval *dividend,
    02998                       OCINumber *divisor, OCIInterval *result );
    02999
    03000   DESCRIPTION
    03001      Divides an interval by an Oracle Number to produce an interval
    03002   PARAMETERS
    03003            hndl (IN) - Session/Env handle.
    03004      err (IN/OUT) - error handle. If there is an error, it is
    03005                 recorded in 'err' and this function returns OCI_ERROR.
    03006                 The error recorded in 'err' can be retrieved by calling
    03007                 OCIErrorGet().
    03008      dividend  (IN)   - Interval to be divided
    03009      divisor   (IN)   - Oracle Number dividing `dividend'
    03010      result    (OUT)  - resulting interval (dividend / divisor)
    03011   RETURNS
    03012      OCI_SUCCESS on success
    03013      OCI_INVALID_HANDLE if 'err' is NULL.
    03014
    03015  ---------------------- OCIIntervalFromNumber --------------------
    03016 sword OCIIntervalFromNumber(dvoid *hndl, OCIError *err,
    03017                OCIInterval *inter, OCINumber *number);
    03018   DESCRIPTION
    03019     Converts an interval to an Oracle Number
    03020   PARAMETERS
    03021      hndl (IN) - Session/Env handle.
    03022     err (IN/OUT) - error handle. If there is an error, it is
    03023                 recorded in 'err' and this function returns OCI_ERROR.
    03024                 The error recorded in 'err' can be retrieved by calling
    03025                 OCIErrorGet().
    03026     (OUT)  interval - Interval to be converted
    03027     (IN) number - Oracle number result  (in years for YEARMONTH interval
    03028                      and in days for DAYSECOND)
    03029   RETURNS
    03030     OCI_SUCCESS on success
    03031     OCI_INVALID_HANDLE if 'err' is NULL.
    03032     OCI_ERROR on error.
    03033   NOTES
    03034     Fractional portions of the date (for instance, minutes and seconds if
    03035     the unit chosen is hours) will be included in the Oracle number produced.
    03036     Excess precision will be truncated.
    03037
    03038  ---------------------- OCIIntervalFromText --------------------
    03039 sword OCIIntervalFromText(dvoid *hndl, OCIError *err, CONST OraText *inpstring,
    03040                       size_t str_len, OCIInterval *result );
    03041
    03042   DESCRIPTION
    03043     Given an interval string produce the interval represented by the string.
    03044     The type of the interval is the type of the 'result' descriptor.
    03045   PARAMETERS
    03046
    03047      hndl (IN) - Session/Env handle.
    03048      err (IN/OUT) - error handle. If there is an error, it is
    03049                 recorded in 'err' and this function returns OCI_ERROR.
    03050                 The error recorded in 'err' can be retrieved by calling
    03051                 OCIErrorGet().
    03052     (IN)  inpstring - Input string
    03053     (IN)  str_len - Length of input string
    03054     (OUT) result - Resultant interval
    03055   RETURNS
    03056     OCI_SUCCESS on success
    03057     OCI_INVALID_HANDLE if 'err' is NULL.
    03058     OCI_ERROR if
    03059            there are too many fields in the literal string
    03060            the year is out of range (-4713 to 9999)
    03061            if the month is out of range (1 to 12)
    03062            if the day of month is out of range (1 to 28...31)
    03063            if hour is not in range (0 to 23)
    03064            if hour is not in range (0 to 11)
    03065            if minute is not in range (0 to 59)
    03066            if seconds in minute not in range (0 to 59)
    03067            if seconds in day not in range (0 to 86399)
    03068            if the interval is invalid
    03069
    03070  ---------------------- OCIIntervalGetDaySecond --------------------
    03071
    03072   DESCRIPTION
    03073      Gets values of day second interval
    03074   PARAMETERS
    03075            hndl (IN) - Session/Env handle.
    03076         err (IN/OUT) - error handle. If there is an error, it is
    03077                 recorded in 'err' and this function returns OCI_ERROR.
    03078                 The error recorded in 'err' can be retrieved by calling
    03079                 OCIErrorGet().
    03080         day     (OUT) - number of days
    03081         hour    (OUT) - number of hours
    03082         min     (OUT) - number of mins
    03083         sec     (OUT) - number of secs
    03084         fsec    (OUT) - number of fractional seconds
    03085            result     (IN)  - resulting interval
    03086   RETURNS
    03087            OCI_SUCCESS on success
    03088         OCI_INVALID_HANDLE if 'err' is NULL.
    03089
    03090  ---------------------- OCIIntervalGetYearMonth --------------------
    03091
    03092   DESCRIPTION
    03093      Gets year month from an interval
    03094   PARAMETERS
    03095            hndl (IN) - Session/Env handle.
    03096         err (IN/OUT) - error handle. If there is an error, it is
    03097                 recorded in 'err' and this function returns OCI_ERROR.
    03098                 The error recorded in 'err' can be retrieved by calling
    03099                 OCIErrorGet().
    03100            year    (OUT)   - year value
    03101            month   (OUT)   - month value
    03102            result     (IN)  - resulting interval
    03103   RETURNS
    03104            OCI_SUCCESS on success
    03105         OCI_INVALID_HANDLE if 'err' is NULL.
    03106
    03107
    03108 ---------------------- OCIIntervalAdd --------------------
    03109 sword OCIIntervalAdd(dvoid *hndl, OCIError *err, OCIInterval *addend1,
    03110                                  OCIInterval *addend2, OCIInterval *result );
    03111 NAME OCIIntervalAdd - Adds two intervals
    03112 PARAMETERS
    03113 hndl (IN) - Session/Env handle.
    03114 err (IN/OUT) - error handle. If there is an error, it is
    03115                 recorded in 'err' and this function returns OCI_ERROR.
    03116                 The error recorded in 'err' can be retrieved by calling
    03117                 OCIErrorGet().
    03118 addend1  (IN)   - Interval to be added
    03119 addend2  (IN)   - Interval to be added
    03120 result   (OUT)  - resulting interval (addend1 + addend2)
    03121 DESCRIPTION
    03122      Adds two intervals to produce a resulting interval
    03123 RETURNS
    03124      OCI_SUCCESS on success
    03125      OCI_ERROR if:
    03126            the two input intervals are not mutually comparable.
    03127            the resulting year would go above SB4MAXVAL
    03128            the resulting year would go below SB4MINVAL
    03129      OCI_INVALID_HANDLE if 'err' is NULL.
    03130 NOTES
    03131      The two input intervals must be mutually comparable
    03132
    03133  ---------------------- OCIIntervalSubtract --------------------
    03134 sword OCIIntervalSubtract(dvoid *hndl, OCIError *err, OCIInterval *minuend,
    03135                                      OCIInterval *subtrahend, OCIInterval *result );
    03136 NAME - OCIIntervalSubtract - subtracts two intervals
    03137 PARAMETERS
    03138 hndl (IN) - Session/Env handle.
    03139 err (IN/OUT) - error handle. If there is an error, it is
    03140                 recorded in 'err' and this function returns OCI_ERROR.
    03141                 The error recorded in 'err' can be retrieved by calling
    03142                 OCIErrorGet().
    03143 minuend    (IN)   - interval to be subtracted from
    03144 subtrahend (IN)   - interval subtracted from minuend
    03145 result     (OUT)  - resulting interval (minuend - subtrahend)
    03146 DESCRIPTION
    03147      Subtracts two intervals and stores the result in an interval
    03148 RETURNS
    03149            OCI_SUCCESS on success
    03150         OCI_INVALID_HANDLE if 'err' is NULL.
    03151            OCI_ERROR if:
    03152               the two input intervals are not mutually comparable.
    03153               the resulting leading field would go below SB4MINVAL
    03154               the resulting leading field would go above SB4MAXVAL
    03155
    03156 ---------------------- OCIIntervalMultiply --------------------
    03157 sword OCIIntervalMultiply(dvoid *hndl, OCIError *err, CONST OCIInterval *inter,
    03158                                  OCINumber *nfactor, OCIInterval *result );
    03159
    03160   DESCRIPTION
    03161      Multiplies an interval by an Oracle Number to produce an interval
    03162   PARAMETERS
    03163            hndl (IN) - Session/Env handle.
    03164      err (IN/OUT) - error handle. If there is an error, it is
    03165                 recorded in 'err' and this function returns OCI_ERROR.
    03166                 The error recorded in 'err' can be retrieved by calling
    03167                 OCIErrorGet().
    03168      ifactor  (IN)   - Interval to be multiplied
    03169      nfactor  (IN)   - Oracle Number to be multiplied
    03170      result   (OUT)  - resulting interval (ifactor * nfactor)
    03171   RETURNS
    03172      OCI_SUCCESS on success
    03173      OCI_INVALID_HANDLE if 'err' is NULL.
    03174      OCI_ERROR if:
    03175            the resulting year would go above SB4MAXVAL
    03176            the resulting year would go below SB4MINVAL
    03177
    03178
    03179  ---------------------- OCIIntervalSetDaySecond --------------------
    03180
    03181   DESCRIPTION
    03182      Sets day second interval
    03183   PARAMETERS
    03184            hndl (IN) - Session/Env handle.
    03185         err (IN/OUT) - error handle. If there is an error, it is
    03186                 recorded in 'err' and this function returns OCI_ERROR.
    03187                 The error recorded in 'err' can be retrieved by calling
    03188                 OCIErrorGet().
    03189         day     (IN) - number of days
    03190         hour    (IN) - number of hours
    03191         min     (IN) - number of mins
    03192         sec     (IN) - number of secs
    03193         fsec    (IN) - number of fractional seconds
    03194            result     (OUT)  - resulting interval
    03195   RETURNS
    03196            OCI_SUCCESS on success
    03197         OCI_INVALID_HANDLE if 'err' is NULL.
    03198
    03199  ---------------------- OCIIntervalSetYearMonth --------------------
    03200
    03201   DESCRIPTION
    03202      Sets year month interval
    03203   PARAMETERS
    03204            hndl (IN) - Session/Env handle.
    03205         err (IN/OUT) - error handle. If there is an error, it is
    03206                 recorded in 'err' and this function returns OCI_ERROR.
    03207                 The error recorded in 'err' can be retrieved by calling
    03208                 OCIErrorGet().
    03209            year    (IN)   - year value
    03210            month   (IN)   - month value
    03211            result     (OUT)  - resulting interval
    03212   RETURNS
    03213            OCI_SUCCESS on success
    03214         OCI_INVALID_HANDLE if 'err' is NULL.
    03215
    03216
    03217  ---------------------- OCIIntervalToNumber --------------------
    03218 sword OCIIntervalToNumber(dvoid *hndl, OCIError *err, CONST OCIInterval *inter,
    03219                                  OCINumber *number, uword units );
    03220
    03221   DESCRIPTION
    03222     Converts an interval to an Oracle Number
    03223   PARAMETERS
    03224      hndl (IN) - Session/Env handle.
    03225     err (IN/OUT) - error handle. If there is an error, it is
    03226                 recorded in 'err' and this function returns OCI_ERROR.
    03227                 The error recorded in 'err' can be retrieved by calling
    03228                 OCIErrorGet().
    03229     (IN)  interval - Interval to be converted
    03230     (OUT) number - Oracle number result   (in years for YEARMONTH interval
    03231                      and in days for DAYSECOND)
    03232   RETURNS
    03233     OCI_INVALID_HANDLE if 'err' is NULL.
    03234     OCI_SUCCESS on success
    03235   NOTES
    03236     Fractional portions of the date (for instance, minutes and seconds if
    03237     the unit chosen is hours) will be included in the Oracle number produced.
    03238     Excess precision will be truncated.
    03239
    03240  ---------------------- OCIIntervalToText --------------------
    03241 sword OCIIntervalToText( dvoid *hndl, OCIError *err, CONST OCIInterval *inter,
    03242                         ub1 lfprec, ub1 fsprec, OraText *buffer,
    03243                         size_t buflen, size_t *resultlen );
    03244
    03245   DESCRIPTION
    03246     Given an interval, produces a string representing the interval.
    03247   PARAMETERS
    03248      hndl (IN) - Session/Env handle.
    03249     err (IN/OUT) - error handle. If there is an error, it is
    03250                 recorded in 'err' and this function returns OCI_ERROR.
    03251                 The error recorded in 'err' can be retrieved by calling
    03252                 OCIErrorGet().
    03253     (IN)  interval - Interval to be converted
    03254     (IN)  lfprec  - Leading field precision. Number of digits used to
    03255                 represent the leading field.
    03256     (IN)  fsprec  - Fractional second precision of the interval. Number of
    03257                 digits used to represent the fractional seconds.
    03258     (OUT) buffer - buffer to hold result
    03259     (IN)  buflen - length of above buffer
    03260     (OUT) resultlen - length of result placed into buffer
    03261
    03262   RETURNS
    03263     OCI_SUCCESS on success
    03264     OCI_INVALID_HANDLE if 'err' is NULL.
    03265     OCI_ERROR
    03266            if the buffer is not large enough to hold the result
    03267   NOTES
    03268     The interval literal will be output as `year' or `[year-]month' for
    03269     YEAR-MONTH intervals and as `seconds' or `minutes[:seconds]' or
    03270     `hours[:minutes[:seconds]]' or `days[ hours[:minutes[:seconds]]]' for
    03271     DAY-TIME intervals (where optional fields are surrounded by brackets).
    03272
    03273  ----------------------- OCIIntervalFromTZ ---------------------
    03274 sword OCIIntervalFromTZ(dvoid *hndl, OCIError *err, CONST oratext *inpstring,
    03275                                  size_t str_len, OCIInterval *results );
    03276
    03277   DESCRIPTION
    03278     Returns am OCIInmterval of type OCI_DTYPE_INTERVAL_DS with the region id
    03279     set and the current region offset or an absolute offset with the region id
    03280     set to 0.
    03281   PARAMETERS
    03282     hndl (IN) - Session/Env handle.
    03283     err (IN/OUT) - error handle. If there is an error, it is
    03284                 recorded in 'err' and this function returns OCI_ERROR.
    03285                 The error recorded in 'err' can be retrieved by calling
    03286                 OCIErrorGet().
    03287     inpstring (IN) - pointer to the input string
    03288     str_len (IN) - inpstring length
    03289     result - Output Interval
    03290   RETURNS
    03291      OCI_SUCCESS on success
    03292      OCI_INVALID_HANDLE if 'err' is NULL.
    03293      OCI_ERROR on error
    03294         Bad interval type
    03295         Timezone errors
    03296   NOTES
    03297      The input string must be of the form [+/-]TZH:TZM or 'TZR [TZD]'
    03298
    03299 OCILdaToSvcCtx()
    03300 Name
    03301 OCI toggle version 7 Lda_Def to SerVice context handle
    03302 Purpose
    03303 Converts a V7 Lda_Def to a V8 service context handle.
    03304 Syntax
    03305 sword OCILdaToSvcCtx ( OCISvcCtx  **svchpp,
    03306                      OCIError   *errhp,
    03307                      Lda_Def    *ldap );
    03308 Comments
    03309 Converts a V7 Lda_Def to a V8 service context handle. The action of this call
    03310 can be reversed by passing the resulting service context handle to the
    03311 OCISvcCtxToLda() function.
    03312 Parameters
    03313 svchpp (IN/OUT) - the service context handle.
    03314 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03315 diagnostic information in the event of an error.
    03316 ldap (IN/OUT) - the V7 logon data area returned by OCISvcCtxToLda() from
    03317 this service context.
    03318 Related Functions
    03319 OCISvcCtxToLda()
    03320
    03321
    03322
    03323
    03324 OCILobAppend()
    03325
    03326 Name
    03327 OCI Lob APpend
    03328
    03329 Purpose
    03330 Appends a LOB value at the end of another LOB.
    03331
    03332 Syntax
    03333 sword OCILobAppend ( OCISvcCtx        *svchp,
    03334                    OCIError         *errhp,
    03335                    OCILobLocator    *dst_locp,
    03336                    OCILobLocator    *src_locp );
    03337 Comments
    03338 Appends a LOB value at the end of LOB. The data is
    03339 copied from the source to the destination at the end of the destination. The
    03340 source and the destination must already exist. The destination LOB is
    03341 extended to accommodate the newly written data.
    03342
    03343 It is an error to extend the destination LOB beyond the maximum length
    03344 allowed or to try to copy from a NULL LOB.
    03345
    03346 Parameters
    03347 svchp (IN) - the service context handle.
    03348 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03349 diagnostic information in the event of an error.
    03350 dst_locp (IN/OUT) - a locator uniquely referencing the destination LOB.
    03351 src_locp (IN/OUT) - a locator uniquely referencing the source LOB.
    03352
    03353 Related Functions
    03354 OCILobTrim()
    03355 OCIErrorGet()
    03356 OCILobWrite()
    03357 OCILobCopy()
    03358
    03359
    03360
    03361
    03362
    03363 OCILobAssign()
    03364
    03365 Name
    03366 OCI Lob ASsiGn
    03367
    03368 Purpose
    03369 Assigns one LOB/FILE locator to another.
    03370
    03371 Syntax
    03372 sword OCILobAssign ( OCIEnv                *envhp,
    03373                      OCIError              *errhp,
    03374                      CONST OCILobLocator   *src_locp,
    03375                      OCILobLocator         **dst_locpp );
    03376
    03377 Comments
    03378 Assign source locator to destination locator.  After the assignment, both
    03379 locators refer to the same LOB data.  For internal LOBs, the source locator's
    03380 LOB data gets copied to the destination locator's LOB data only when the
    03381 destination locator gets stored in the table.  Therefore, issuing a flush of
    03382 the object containing the destination locator will copy the LOB data. For FILEs
    03383 only the locator that refers to the OS file is copied to the table. The OS file
    03384 is not copied.
    03385
    03386 Parameters
    03387 envhp (IN/OUT) - OCI environment handle initialized in object mode.
    03388 errhp (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    03389 errhp and this function returns OCI_ERROR. Diagnostic information can be
    03390 obtained by calling OCIErrorGet().
    03391 src_locp (IN) - LOB locator to copy from.
    03392 dst_locpp (IN/OUT) - LOB locator to copy to.  The caller must allocate space
    03393 for the OCILobLocator by calling OCIDescriptorAlloc().
    03394 Note: The only difference between this and OCILobLocatorAssign is that this
    03395 takes an environment handle whereas OCILobLocatorAssign takes an OCI service
    03396 handle
    03397
    03398 See also
    03399 OCIErrorGet()
    03400 OCILobIsEqual()
    03401 OCILobLocatorIsInit()
    03402 OCILobLocatorAssign()
    03403
    03404
    03405
    03406 OCILobCharSetForm()
    03407
    03408 Name
    03409 OCI Lob Get Character Set Form
    03410
    03411 Purpose
    03412 Gets the LOB locator's character set fpr,, if any.
    03413
    03414 Syntax
    03415 sword OCILobCharSetForm ( OCIEnv                    *envhp,
    03416                           OCIError                  *errhp,
    03417                           CONST OCILobLocator       *locp,
    03418                           ub1                       *csfrm );
    03419
    03420 Comments
    03421 Returns the character set form of the input LOB locator in the csfrm output
    03422 parameter.
    03423
    03424 Parameters
    03425 envhp (IN/OUT) - OCI environment handle initialized in object mode.
    03426 errhp (IN/OUT) - error handle. The OCI error handle. If there is an error, it
    03427 is recorded in err and this function returns OCI_ERROR. Diagnostic information
    03428 can be obtained by calling OCIErrorGet().
    03429 locp (IN) - LOB locator for which to get the character set form.
    03430 csfrm(OUT) - character set form of the input LOB locator.  If the input
    03431 locator is for a BLOB or a BFILE, csfrm is set to 0 since there is no concept
    03432 of a character set for binary LOBs/FILEs.  The caller must allocate space for
    03433 the csfrm (ub1) and not write into the space.
    03434 See also
    03435 OCIErrorGet(), OCILobCharSetId(), OCILobLocatorIsInit
    03436
    03437
    03438
    03439
    03440 OCILobCharSetId()
    03441
    03442 Name
    03443 OCI Lob get Character Set IDentifier
    03444
    03445 Purpose
    03446 Gets the LOB locator's character set ID, if any.
    03447
    03448 Syntax
    03449 sword OCILobCharSetId ( OCIEnv                    *envhp,
    03450                         OCIError                  *errhp,
    03451                         CONST OCILobLocator       *locp,
    03452                         ub2                       *csid );
    03453
    03454 Comments
    03455 Returns the character set ID of the input LOB locator in the cid output
    03456 parameter.
    03457
    03458 Parameters
    03459 envhp (IN/OUT) - OCI environment handle initialized in object mode.
    03460 errhp (IN/OUT) - error handle. The OCI error handle. If there is an error, it
    03461 is recorded in err and this function returns OCI_ERROR. Diagnostic information
    03462 can be obtained by calling OCIErrorGet().
    03463 locp (IN) - LOB locator for which to get the character set ID.
    03464 csid (OUT) - character set ID of the input LOB locator.  If the input locator
    03465 is for a BLOB or a BFILE, csid is set to 0 since there is no concept of a
    03466 character set for binary LOBs/FILEs.  The caller must allocate space for the character set id of type ub2 and not write into the space.
    03467
    03468 See also
    03469 OCIErrorGet(), OCILobCharSetForm(), OCILobLocatorIsInit()
    03470
    03471
    03472
    03473
    03474 OCILobCopy()
    03475
    03476 Name
    03477 OCI Lob Copy
    03478
    03479 Purpose
    03480 Copies a portion of a LOB value into another LOB value.
    03481
    03482 Syntax
    03483 sword OCILobCopy ( OCISvcCtx        *svchp,
    03484                    OCIError         *errhp,
    03485                    OCILobLocator    *dst_locp,
    03486                    OCILobLocator    *src_locp,
    03487                    ub4              amount,
    03488                    ub4              dst_offset,
    03489                    ub4              src_offset );
    03490
    03491 Comments
    03492 Copies a portion of a LOB value into another LOB as specified. The data
    03493 is copied from the source to the destination. The source (src_locp) and the
    03494 destination (dlopb) LOBs must already exist.
    03495 If the data already exists at the destination's start position, it is
    03496 overwritten with the source data. If the destination's start position is
    03497 beyond the end of the current data, a hole is created from the end of the data
    03498 to the beginning of the newly written data from the source. The destination
    03499 LOB is extended to accommodate the newly written data if it extends
    03500 beyond the current length of the destination LOB.
    03501 It is an error to extend the destination LOB beyond the maximum length
    03502 allowed or to try to copy from a NULL LOB.
    03503 Parameters
    03504 svchp (IN) - the service context handle.
    03505 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03506 diagnostic information in the event of an error.
    03507 dst_locp (IN/OUT) - a locator uniquely referencing the destination LOB.
    03508 src_locp (IN/OUT) - a locator uniquely referencing the source LOB.
    03509 amount (IN) - the number of character or bytes, as appropriate, to be copied.
    03510 dst_offset (IN) - this is the absolute offset for the destination LOB.
    03511 For character LOBs it is the number of characters from the beginning of the
    03512 LOB at which to begin writing. For binary LOBs it is the number of bytes from
    03513 the beginning of the lob from which to begin reading. The offset starts at 1.
    03514 src_offset (IN) - this is the absolute offset for the source LOB.
    03515 For character LOBs it is the number of characters from the beginning of the
    03516 LOB, for binary LOBs it is the number of bytes. Starts at 1.
    03517
    03518 See Also
    03519 OCIErrorGet(), OCILobAppend(), OCILobWrite(), OCILobTrim()
    03520
    03521 OCILobCreateTemporary()
    03522
    03523 Name
    03524 OCI Lob Create Temporary
    03525
    03526 Purpose
    03527 Create a Temporary Lob
    03528
    03529 Syntax
    03530 sword OCILobCreateTemporary(OCISvcCtx          *svchp,
    03531                             OCIError           *errhp,
    03532                             OCILobLocator      *locp,
    03533                             ub2                 csid,
    03534                             ub1                 csfrm,
    03535                             ub1                 lobtype,
    03536                             boolean             cache,
    03537                             OCIDuration         duration);
    03538
    03539
    03540 Comments
    03541 svchp (IN) - the service context handle.
    03542 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03543 diagnostic information in the event of an error.
    03544 locp (IN/OUT) - a locator which points to the temporary Lob
    03545 csid (IN) - the character set id
    03546 csfrm(IN) - the character set form
    03547 lobtype (IN) - the lob type - one of the three constants OCI_TEMP_BLOB,
    03548                OCI_TEMP_CLOB and OCI_TEMP_NCLOB
    03549 cache(IN)-  TRUE if the temporary LOB goes through the cache; FALSE, if not.
    03550 duration(IN)- duration of the temporary LOB; Can be a valid duration id or one
    03551               of the values: OCI_DURATION_SESSION, OCI_DURATION_CALL
    03552                  Note: OCI_DURATION_TRANSACTION is not supported in 8.1.
    03553 Related functions
    03554 OCILobFreeTemporary()
    03555 OCILobIsTemporary()
    03556
    03557 OCILobDisableBuffering()
    03558
    03559 Name
    03560 OCI Lob Disable Buffering
    03561
    03562 Purpose
    03563 Disable lob buffering for the input locator.
    03564
    03565
    03566 Syntax
    03567 sword OCILobDisableBuffering ( OCISvcCtx      *svchp,
    03568                                OCIError       *errhp,
    03569                                OCILobLocator  *locp);
    03570
    03571 Comments
    03572
    03573 Disable lob buffering for the input locator.  The next time data is
    03574 read/written from/to the lob through the input locator, the lob
    03575 buffering subsystem is *not* used.
    03576
    03577 Parameters
    03578 svchp (IN) - the service context handle.
    03579 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03580 diagnostic information in the event of an error.
    03581 locp (IN/OUT) - a locator uniquely referencing the LOB.
    03582
    03583 Related Functions
    03584 OCILobEnableBuffering()
    03585 OCIErrorGet()
    03586 OCILobFlush()
    03587
    03588
    03589
    03590
    03591 OCILobEnableBuffering()
    03592
    03593 Name
    03594 OCI Lob Enable Buffering
    03595
    03596 Purpose
    03597 Enable lob buffering for the input locator.
    03598
    03599
    03600 Syntax
    03601 sword OCILobEnableBuffering ( OCISvcCtx      *svchp,
    03602                               OCIError       *errhp,
    03603                               OCILobLocator  *locp);
    03604
    03605 Comments
    03606
    03607 Enable lob buffering for the input locator.  The next time data is
    03608 read/written from/to the lob through the input locator, the lob
    03609 buffering subsystem is used.
    03610
    03611 Once lob buffering is enabled for a locator, if that locator is passed to
    03612 one of the following routines, an error is returned:
    03613         OCILobCopy, OCILobAppend, OCILobErase, OCILobGetLength, OCILobTrim
    03614
    03615 Parameters
    03616 svchp (IN) - the service context handle.
    03617 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03618 diagnostic information in the event of an error.
    03619 locp (IN/OUT) - a locator uniquely referencing the LOB.
    03620
    03621 Related Functions
    03622 OCILobDisableBuffering()
    03623 OCIErrorGet()
    03624 OCILobWrite()
    03625 OCILobRead()
    03626 OCILobFlush()
    03627
    03628
    03629
    03630
    03631 OCILobErase()
    03632
    03633 Name
    03634 OCI Lob ERase
    03635
    03636 Purpose
    03637 Erases a specified portion of the LOB data starting at a specified offset.
    03638
    03639 Syntax
    03640 sword OCILobErase ( OCISvcCtx       *svchp,
    03641                   OCIError        *errhp,
    03642                   OCILobLocator   *locp,
    03643                   ub4             *amount,
    03644                   ub4             offset );
    03645
    03646 Comments
    03647 Erases a specified portion of the LOB data starting at a specified offset.
    03648 The actual number of characters/bytes erased is returned. The actual number
    03649 of characters/bytes and the requested number of characters/bytes will differ
    03650 if the end of the LOB data is reached before erasing the requested number of
    03651 characters/bytes.
    03652 If a section of data from the middle of the LOB data is erased, a hole is
    03653 created. When data from that hole is read, 0's are returned. If the LOB is
    03654 NULL, this routine will indicate that 0 characters/bytes were erased.
    03655
    03656 Parameters
    03657 svchp (IN) - the service context handle.
    03658 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03659 diagnostic information in the event of an error.
    03660 locp (IN/OUT) - the LOB for which to erase a section of data.
    03661 amount (IN/OUT) - On IN, the number of characters/bytes to erase. On OUT,
    03662 the actual number of characters/bytes erased.
    03663 offset (IN) - absolute offset from the beginning of the LOB data from which to
    03664 start erasing data. Starts at 1.
    03665
    03666 See Also
    03667 OCIErrorGet(), OCILobRead(), OCILobWrite()
    03668
    03669
    03670
    03671
    03672 OCILobFileClose()
    03673
    03674 Name
    03675 OCI Lob File CLoSe
    03676
    03677 Purpose
    03678 Closes a previously opened FILE.
    03679
    03680 Syntax
    03681 sword OCILobFileClose ( OCISvcCtx            *svchp,
    03682                         OCIError             *errhp,
    03683                         OCILobLocator        *filep );
    03684
    03685 Comments
    03686 Closes a previously opened FILE. It is an error if this function is called for
    03687 an internal LOB. No error is returned if the FILE exists but is not opened.
    03688 Parameters
    03689 svchp (IN) - the service context handle.
    03690 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03691 diagnostic information in the event of an error.
    03692 filep (IN/OUT) - a pointer to a FILE locator to be closed.
    03693
    03694 See Also
    03695 OCIErrorGet(), OCILobFileOpen(), OCILobFileCloseAll(), OCILobFileIsOpen(),
    03696 OCILobFileExists(), CREATE DIRECTORY DDL
    03697
    03698
    03699
    03700
    03701
    03702
    03703 OCILobFileCloseAll()
    03704
    03705 Name
    03706 OCI LOB FILE Close All
    03707
    03708 Purpose
    03709 Closes all open FILEs on a given service context.
    03710
    03711 Syntax
    03712 sword OCILobFileCLoseAll ( OCISvcCtx *svchp,
    03713                            OCIError  *errhp );
    03714
    03715 Comments
    03716 Closes all open FILEs on a given service context.
    03717
    03718 Parameters
    03719 svchp (IN) - the service context handle.
    03720 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03721 diagnostic information in the event of an error.
    03722
    03723 See also
    03724 OCILobFileClose(),
    03725 OCIErrorGet(), OCILobFileOpen(), OCILobFileIsOpen(),
    03726 OCILobFileExists(), CREATE DIRECTORY DDL
    03727
    03728
    03729
    03730
    03731
    03732
    03733 OCILobFileExists()
    03734
    03735 Name
    03736 OCI LOB FILE exists
    03737
    03738 Purpose
    03739 Tests to see if the FILE exists on the server
    03740
    03741 Syntax
    03742 sword OCILobFileExists ( OCISvcCtx     *svchp,
    03743                          OCIError      *errhp,
    03744                          OCILobLocator *filep,
    03745                          boolean       *flag );
    03746
    03747 Comments
    03748 Checks to see if a FILE exists for on the server.
    03749
    03750 Parameters
    03751 svchp (IN) - the OCI service context handle.
    03752 errhp (IN/OUT) - error handle. The OCI error handle. If there is an error,
    03753 it is recorded in err and this function returns OCI_ERROR. Diagnostic
    03754 information can be obtained by calling OCIErrorGet().
    03755 filep (IN) - pointer to the FILE locator that refers to the file.
    03756 flag (OUT) - returns TRUE if the FILE exists; FALSE if it does not.
    03757
    03758 See also
    03759 OCIErrorGet, CREATE DIRECTORY (DDL)
    03760
    03761
    03762
    03763
    03764 OCILobFileGetName()
    03765
    03766 Name
    03767 OCI LOB FILE Get file Name
    03768
    03769 Purpose
    03770 Gets the FILE locator's directory alias and file name.
    03771
    03772 Syntax
    03773 sword OCILobFileGetName ( OCIEnv                   *envhp,
    03774                           OCIError                 *errhp,
    03775                           CONST OCILobLocator      *filep,
    03776                           OraText                     *dir_alias,
    03777                           ub2                      *d_length,
    03778                           OraText                     *filename,
    03779                           ub2                      *f_length );
    03780
    03781 Comments
    03782 Returns the directory alias and file name associated with this file locator.
    03783
    03784 Parameters
    03785 envhp (IN/OUT) - OCI environment handle initialized in object mode.
    03786 errhp (IN/OUT) -The OCI error handle. If there is an error, it is recorded in
    03787 errhp and this function returns OCI_ERROR. Diagnostic information can be
    03788 obtained by calling OCIErrorGet().
    03789 filep (IN) - FILE locator for which to get the directory alias and file name.
    03790 dir_alias (OUT) - buffer into which the directory alias name is placed. The
    03791 caller must allocate enough space for the directory alias name and must not
    03792 write into the space.
    03793 d_length (IN/OUT)
    03794         - IN: length of the input dir_alias string;
    03795         - OUT: length of the returned dir_alias string.
    03796 filename (OUT) - buffer into which the file name is placed. The caller must
    03797 allocate enough space for the file name and must not write into the space.
    03798 f_length (IN/OUT)
    03799         - IN: length of the input filename string;
    03800          - OUT: lenght of the returned filename string.
    03801
    03802 See also
    03803 OCILobFileSetName(), OCIErrorGet()
    03804
    03805
    03806
    03807
    03808 OCILobFileIsOpen()
    03809
    03810 Name
    03811 OCI LOB FILE Is Open?
    03812
    03813 Purpose
    03814 Tests to see if the FILE is open
    03815
    03816 Syntax
    03817 sword OCILobFileIsOpen ( OCISvcCtx *svchp,
    03818                          OCIError  *errhp,
    03819                          OCILobLocator *filep,
    03820                          boolean       *flag );
    03821
    03822 Comments
    03823 Checks to see if the FILE on the server is open for a given LobLocator.
    03824
    03825 Parameters
    03826 svchp (IN) - the OCI service context handle.
    03827 errhp (IN/OUT) - error handle. The OCI error handle. If there is an error, it
    03828 is recorded in err and this function returns OCI_ERROR. Diagnostic information
    03829 can be obtained by calling OCIErrorGet().
    03830 filep (IN) - pointer to the FILE locator being examined. If the input file
    03831 locator was never passed to OCILobFileOpen(), the file is considered not to
    03832 be opened by this locator. However, a different locator may have opened the
    03833 file. More than one file opens can be performed on the same file using
    03834 different locators.
    03835 flag (OUT) - returns TRUE if the FILE is opened using this locator; FALSE if
    03836 it is not.
    03837
    03838 See also
    03839 OCIErrorGet, OCILobFileOpen, OCILobFileClose, OCILobFileCloseAll, CREATE
    03840 DIRECTORY SQL command
    03841
    03842
    03843 OCILobFileOpen()
    03844
    03845 Name
    03846 OCI LOB FILE open
    03847
    03848 Purpose
    03849 Opens a FILE for read-only access
    03850
    03851 Syntax
    03852 sword OCILobFileOpen ( OCISvcCtx            *svchp,
    03853                      OCIError             *errhp,
    03854                      OCILobLocator        *filep,
    03855                      ub1                  mode );
    03856
    03857 Comments
    03858 Opens a FILE. The FILE can be opened for read-only access only. FILEs may not
    03859 be written to throough ORACLE.
    03860
    03861 Parameters
    03862 svchp (IN) - the service context handle.
    03863 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03864 diagnostic information in the event of an error.
    03865 filep (IN/OUT) - the FILE to open. Error if the locator does not refer to a
    03866 FILE.
    03867 mode (IN) - mode in which to open the file. The only valid mode is read-only -
    03868 OCI_FILE_READONLY.
    03869
    03870 See Also
    03871 OCILobFileClose, OCIErrorGet, OCILobFileCloseAll, OCILobFileIsOpen,
    03872 OCILobFileSetName, CREATE DIRECTORY
    03873
    03874
    03875
    03876
    03877 OCILobFileSetName()
    03878
    03879 Name
    03880 OCI Lob File Set NaMe
    03881
    03882 Purpose
    03883 Sets directory alias and file name in the FILE locator.
    03884
    03885 Syntax
    03886 sword OCILobFileSetName ( OCIEnv             *envhp,
    03887                           OCIError           *errhp,
    03888                           OCILobLocator      **filepp,
    03889                           OraText               *dir_alias,
    03890                           ub2                d_length,
    03891                           OraText               *filename,
    03892                           ub2                f_length );
    03893 Comments
    03894 Sets the directory alias and file name in the LOB file locator.
    03895 Parameters
    03896 envhp (IN/OUT) - OCI environment handle initialized in object mode.
    03897 errhp (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    03898 errhp and this function returns OCI_ERROR. Diagnostic information can be
    03899 obtained by calling OCIErrorGet().
    03900 filepp (IN/OUT) - FILE locator for which to set the directory alias name.
    03901 The caller must have already allocated space for the locator by
    03902 calling OCIDescriptorAlloc().
    03903 dir_alias (IN) - buffer that contains the directory alias name to set in the
    03904 locator.
    03905 d_length (IN) - length of the input dir_alias parameter.
    03906 filename (IN) - buffer that contains the file name is placed.
    03907 f_length (IN) - length of the input filename parameter.
    03908 See also
    03909 OCILobFileGetName, OCIErrorGet, CREATE DIRECTORY
    03910
    03911
    03912
    03913
    03914 OCILobFlushBuffer()
    03915
    03916 Name
    03917 OCI Lob Flush all Buffers for this lob.
    03918
    03919 Purpose
    03920 Flush/write all buffers for this lob to the server.
    03921
    03922
    03923 Syntax
    03924 sword OCILobFlushBuffer ( OCISvcCtx       *svchp,
    03925                           OCIError        *errhp,
    03926                           OCILobLocator   *locp,
    03927                           ub4              flag);
    03928
    03929 Comments
    03930
    03931 Flushes all buffers, associated with the lob referenced by the input
    03932 locator, to the server.  This routine will actually write the data in
    03933 the buffer to the lob in the database.  Lob buffering must have been
    03934 enabled for the input lob locator.
    03935
    03936 This routine, by default, does not free the buffer resources for
    03937 reallocation to another buffered LOB operation. However, if you
    03938 want to free the buffer explicitly, you can set the flag parameter
    03939 to OCI_LOB_BUFFER_FREE.
    03940
    03941 Parameters
    03942 svchp (IN/OUT) - the service context handle.
    03943 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03944 diagnostic information in the event of an error.
    03945 locp (IN/OUT) - a locator uniquely referencing the LOB.
    03946 flag    (IN)     - to indicate if the buffer resources need to be freed
    03947                    after a flush. Default value is OCI_LOB_BUFFER_NOFREE.
    03948                    Set it to OCI_LOB_BUFFER_FREE if you want the buffer
    03949                    resources to be freed.
    03950
    03951 Related Functions
    03952 OCILobEnableBuffering()
    03953 OCILobDisableBuffering()
    03954 OCIErrorGet()
    03955 OCILobWrite()
    03956 OCILobRead()
    03957
    03958 OCILobFreeTemporary()
    03959
    03960 Name
    03961 OCI Lob Free Temporary
    03962
    03963 Purpose
    03964 Free a temporary LOB
    03965
    03966 Syntax
    03967 sword OCILobFreeTemporary(OCISvcCtx          *svchp,
    03968                           OCIError           *errhp,
    03969                           OCILobLocator      *locp,
    03970
    03971 Comments
    03972   Frees the contents of the temporary Lob this locator is pointing to. Note
    03973   that the locator itself is not freed until a OCIDescriptorFree is done.
    03974
    03975 Parameters
    03976 svchp (IN/OUT) - the service context handle.
    03977 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    03978 diagnostic information in the event of an error.
    03979 locp (IN/OUT) - a locator uniquely referencing the LOB
    03980
    03981 Related functions
    03982 OCILobCreateTemporary()
    03983 OCILobIsTemporary()
    03984
    03985 Name
    03986 OCI Lob/File Get Chunk Size
    03987
    03988 Purpose
    03989 When creating the table, the user can specify the chunking factor, which can
    03990 be a multiple of Oracle blocks. This corresponds to the chunk size used by the
    03991 LOB data layer when accessing/modifying the LOB value. Part of the chunk is
    03992 used to store system-related information and the rest stores the LOB value.
    03993 This function returns the amount of space used in the LOB chunk to store
    03994 the LOB value.
    03995
    03996 Syntax
    03997 sword OCILobGetChunkSize ( OCISvcCtx      *svchp,
    03998                            OCIError       *errhp,
    03999                            OCILobLocator  *locp,
    04000                            ub4            *chunksizep );
    04001
    04002 Comments
    04003  Performance will be improved if the user issues read/write
    04004 requests using a multiple of this chunk size. For writes, there is an added
    04005 benefit since LOB chunks are versioned and, if all writes are done on chunk
    04006 basis, no extra/excess versioning is done nor duplicated. Users could batch
    04007 up the write until they have enough for a chunk instead of issuing several
    04008 write calls for the same chunk.
    04009
    04010 Parameters
    04011 svchp (IN) - the service context handle.
    04012 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04013 diagnostic information in the event of an error.
    04014 locp (IN/OUT) - a LOB locator that uniquely references the LOB. For internal
    04015 LOBs, this locator must be a locator that was obtained from the server
    04016 specified by svchp. For FILEs, this locator can be initialized by a Select or
    04017 OCILobFileSetName.
    04018 chunksizep (OUT) - On output, it is the length of the LOB if not NULL - for
    04019 character LOBs it is the number of characters, for binary LOBs it is the
    04020 number of bytes in the LOB.
    04021
    04022 Related Functions
    04023
    04024
    04025 OCILobGetLength()
    04026
    04027 Name
    04028 OCI Lob/File Length
    04029
    04030 Purpose
    04031 Gets the length of a LOB/FILE.
    04032
    04033 Syntax
    04034 sword OCILobGetLength ( OCISvcCtx      *svchp,
    04035                         OCIError       *errhp,
    04036                         OCILobLocator  *locp,
    04037                         ub4            *lenp );
    04038
    04039 Comments
    04040 Gets the length of a LOB/FILE. If the LOB/FILE is NULL, the length is
    04041 undefined.
    04042
    04043 Parameters
    04044 svchp (IN) - the service context handle.
    04045 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04046 diagnostic information in the event of an error.
    04047 locp (IN/OUT) - a LOB locator that uniquely references the LOB. For internal
    04048 LOBs, this locator must be a locator that was obtained from the server
    04049 specified by svchp. For FILEs, this locator can be initialized by a Select or
    04050 OCILobFileSetName.
    04051 lenp (OUT) - On output, it is the length of the LOB if not NULL - for
    04052 character LOBs it is the number of characters, for binary LOBs it is the
    04053 number of bytes in the LOB.
    04054
    04055 Related Functions
    04056 OCIErrorGet, OCIFileSetName
    04057
    04058
    04059
    04060
    04061 OCILobIsEqual()
    04062
    04063 Name
    04064
    04065 OCI Lob Is Equal
    04066
    04067 Purpose
    04068 Compares two LOB locators for equality.
    04069
    04070 Syntax
    04071 sword OCILobIsEqual ( OCIEnv                  *envhp,
    04072                       CONST OCILobLocator     *x,
    04073                       CONST OCILobLocator     *y,
    04074                       boolean                 *is_equal );
    04075
    04076 Comments
    04077 Compares the given LOB locators for equality.  Two LOB locators are equal if
    04078 and only if they both refer to the same LOB data.
    04079 Two NULL locators are considered not equal by this function.
    04080 Parameters
    04081 envhp (IN) - the OCI environment handle.
    04082 x (IN) - LOB locator to compare.
    04083 y (IN) - LOB locator to compare.
    04084 is_equal (OUT) - TRUE, if the LOB locators are equal; FALSE if they are not.
    04085
    04086 See also
    04087 OCILobAssign, OCILobLocatorIsInit
    04088 OCILobLocatorAssign()
    04089 OCILobIsTemporary()
    04090
    04091 Name
    04092
    04093 OCI Lob Is Temporary
    04094
    04095 Purpose
    04096   Tests if this locator points to a temporary LOB
    04097
    04098 Syntax
    04099 sword OCILobIsTemporary(OCIEnv            *envp,
    04100                         OCIError          *errhp,
    04101                         OCILobLocator     *locp,
    04102                         boolean           *is_temporary);
    04103
    04104 Comments
    04105 Tests the locator to determine if it points to a temporary LOB.
    04106 If so, is_temporary is set to TRUE. If not, is_temporary is set
    04107 to FALSE.
    04108
    04109 Parameters
    04110 envp (IN) - the environment handle.
    04111 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04112 diagnostic information in the event of an error.
    04113 locp (IN) - the locator to test for temporary LOB
    04114 is_temporary(OUT) - TRUE, if the LOB locator points to a temporary LOB;
    04115                     FALSE, if not.
    04116
    04117 See Also
    04118 OCILobCreateTemporary, OCILobFreeTemporary
    04119
    04120
    04121
    04122 OCILobLoadFromFile()
    04123
    04124 Name
    04125 OCI Lob Load From File
    04126
    04127 Purpose
    04128 Load/copy all or a portion of the file into an internal LOB.
    04129
    04130 Syntax
    04131 sword OCILobLoadFromFile ( OCISvcCtx        *svchp,
    04132                            OCIError         *errhp,
    04133                            OCILobLocator    *dst_locp,
    04134                            OCILobLocator    *src_filep,
    04135                            ub4              amount,
    04136                            ub4              dst_offset,
    04137                            ub4              src_offset );
    04138
    04139 Comments
    04140 Loads/copies a portion or all of a file value into an internal LOB as
    04141 specified.  The data is copied from the source file to the destination
    04142 internal LOB (BLOB/CLOB).  No character set conversions are performed
    04143 when copying the bfile data to a clob/nclob.  The bfile data must already
    04144 be in the same character set as the clob/nclob in the database.  No
    04145 error checking is performed to verify this.
    04146 The source (src_filep) and the destination (dlopb) LOBs must already exist.
    04147 If the data already exists at the destination's start position, it is
    04148 overwritten with the source data. If the destination's start position is
    04149 beyond the end of the current data, a hole is created from the end of the data
    04150 to the beginning of the newly written data from the source. The destination
    04151 LOB is extended to accommodate the newly written data if it extends
    04152 beyond the current length of the destination LOB.
    04153 It is an error to extend the destination LOB beyond the maximum length
    04154 allowed or to try to copy from a NULL LOB.
    04155 Parameters
    04156 svchp (IN) - the service context handle.
    04157 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04158 diagnostic information in the event of an error.
    04159 dst_locp (IN/OUT) - a locator uniquely referencing the destination internal
    04160 LOB which may be of type blob, clob, or nclob.
    04161 src_filep (IN/OUT) - a locator uniquely referencing the source BFILE.
    04162 amount (IN) - the number of bytes to be copied.
    04163 dst_offset (IN) - this is the absolute offset for the destination LOB.
    04164 For character LOBs it is the number of characters from the beginning of the
    04165 LOB at which to begin writing. For binary LOBs it is the number of bytes from
    04166 the beginning of the lob from which to begin reading. The offset starts at 1.
    04167 src_offset (IN) - this is the absolute offset for the source BFILE.  It is the
    04168 number of bytes from the beginning of the LOB.  The offset starts at 1.
    04169
    04170 See Also
    04171 OCIErrorGet(), OCILobAppend(), OCILobWrite(), OCILobTrim(), OCILobCopy()
    04172
    04173
    04174 Name
    04175 OCI Lob LOCATOR ASsiGn
    04176
    04177 Purpose
    04178 Assigns one LOB/FILE locator to another.
    04179
    04180 Syntax
    04181 sword OCILobLocatorAssign ( OCISvcCtx             *svchp,
    04182                             OCIError              *errhp,
    04183                             CONST OCILobLocator   *src_locp,
    04184                             OCILobLocator         **dst_locpp );
    04185
    04186 Comments
    04187 Assign source locator to destination locator.  After the assignment, both
    04188 locators refer to the same LOB data.  For internal LOBs, the source locator's
    04189 LOB data gets copied to the destination locator's LOB data only when the
    04190 destination locator gets stored in the table.  Therefore, issuing a flush of
    04191 the object containing the destination locator will copy the LOB data. For
    04192 FILEs only the locator that refers to the OS file is copied to the table. The
    04193 OS file is not copied.
    04194 Note : the only difference between this and OCILobAssign is that this takes
    04195 a OCI service handle pointer instead of a OCI environment handle pointer
    04196
    04197 Parameters
    04198 svchp (IN/OUT) - OCI service handle initialized in object mode.
    04199 errhp (IN/OUT) - The OCI error handle. If there is an error, it is recorded
    04200 in errhp and this function returns OCI_ERROR. Diagnostic information can be
    04201 obtained by calling OCIErrorGet().
    04202 src_locp (IN) - LOB locator to copy from.
    04203 dst_locpp (IN/OUT) - LOB locator to copy to.  The caller must allocate space
    04204 for the OCILobLocator by calling OCIDescriptorAlloc().
    04205
    04206 See also
    04207 OCIErrorGet()
    04208 OCILobIsEqual()
    04209 OCILobLocatorIsInit()
    04210 OCILobAssign()
    04211
    04212
    04213 OCILobLocatorIsInit()
    04214
    04215 Name
    04216 OCI LOB locator is initialized?
    04217
    04218 Purpose
    04219 Tests to see if a given LOB locator is initialized.
    04220
    04221 Syntax
    04222 sword OCILobLocatorIsInit ( OCIEnv   *envhp,
    04223                             OCIError *errhp,
    04224                             CONST OCILobLocator *locp,
    04225                             boolean *is_initialized );
    04226
    04227 Comments
    04228 Tests to see if a given LOB locator is initialized.
    04229
    04230 Parameters
    04231 envhp (IN/OUT) - OCI environment handle initialized in object mode.
    04232 errhp (IN/OUT) - error handle. The OCI error handle. If there is an error, it
    04233 is recorded in err and this function returns OCI_ERROR. Diagnostic information
    04234 can be obtained by calling OCIErrorGet().
    04235 locp (IN) - the LOB locator being tested
    04236 is_initialized (OUT) - returns TRUE if the given LOB locator is initialized;
    04237 FALSE if it is not.
    04238
    04239 See also
    04240 OCIErrorGet, OCILobIsEqual
    04241
    04242
    04243 OCILobOpen()
    04244
    04245 Name
    04246 OCI Lob Open
    04247 Purpose
    04248  Open an internal LOB or BFILE locator.
    04249 Syntax
    04250 sword OCILobOpen( OCISvcCtx      *svchp,
    04251                   OCIError       *errhp,
    04252                   OCILobLocator  *locp,
    04253                   ub1             mode);
    04254
    04255 Comments
    04256 Opens an internal LOB or a Bfile. A LOB can be opened only once in a
    04257 transaction. A LOB opened in a transaction has to be closed before
    04258 committing the transaction. Otherwise, the transaction is rolled back.
    04259 A LOB cannot be opened in read_write mode without starting a transaction.
    04260
    04261 Parameters
    04262 svchp (IN/OUT) - the service context handle.
    04263 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04264 diagnostic information in the event of an error.
    04265 locp (IN/OUT) - a LOB locator that uniquely references a LOB.
    04266 mode(IN) - mode can be OCI_LOB_READONLY, OCI_LOB_READWRITE
    04267
    04268 Related functions
    04269 OCILobClose(), OCIIsLobOpen()
    04270
    04271 OCILobRead()
    04272
    04273 Name
    04274 OCI Lob/File ReaD
    04275
    04276 Purpose
    04277 Reads a portion of a LOB/FILE as specified by the call into a buffer.
    04278
    04279 Syntax
    04280 sword OCILobRead ( OCISvcCtx       *svchp,
    04281                    OCIError        *errhp,
    04282                    OCILobLocator   *locp,
    04283                    ub4             offset,
    04284                    ub4             *amtp,
    04285                    dvoid           *bufp,
    04286                    ub4             bufl,
    04287                    dvoid           *ctxp,
    04288                    OCICallbackLobRead (cbfp)
    04289                                    (
    04290                                     dvoid         *ctxp,
    04291                                     CONST dvoid   *bufp,
    04292                                     ub4           len,
    04293                                     ub1           piece )
    04294                    ub2             csid,
    04295                    ub1             csfrm );
    04296
    04297 Comments
    04298 Reads a portion of a LOB/FILE as specified by the call into a buffer. Data read
    04299 from a hole is returned as 0s. It is an error to try to read from a NULL LOB/
    04300 FILE. The OS FILE must already exist on the server and must have been opened
    04301 using the input locator. Oracle must hav epermission to read the OS file and
    04302 user must have read permission on the directory object.
    04303
    04304 Parameters
    04305 svchp (IN/OUT) - the service context handle.
    04306 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04307 diagnostic information in the event of an error.
    04308 locp (IN/OUT) - a LOB locator that uniquely references a LOB.
    04309 offset (IN) - On input, it is the absolute offset, for character LOBs in the
    04310 number of characters from the beginning of the LOB, for binary LOBs it is the
    04311 number of bytes. Starts from 1.
    04312 amtp (IN/OUT) - On input, the number of character or bytes to be read. On
    04313 output, the actual number of bytes or characters read.
    04314 If the amount of bytes to be read is larger than the buffer length it is
    04315 assumed that the LOB is being read in a streamed mode. On input if this value
    04316 is 0, then the data shall be read in streamed mode from the LOB until the end
    04317 of LOB. If the data is read in pieces, *amtp always contains the length of the last piece read.
    04318 If a callback function is defined, then this callback function will be invoked
    04319 each time bufl bytes are read off the pipe. Each piece will be written into
    04320 bufp.
    04321 If the callback function is not defined, then OCI_NEED_DATA error code will
    04322 be returned. The application must invoke the LOB read over and over again to
    04323 read more pieces of the LOB until the OCI_NEED_DATA error code is not
    04324 returned. The buffer pointer and the length can be different in each call
    04325 if the pieces are being read into different sizes and location.
    04326 bufp (IN) - the pointer to a buffer into which the piece will be read. The
    04327 length of the allocated memory is assumed to be bufl.
    04328 bufl (IN) - the length of the buffer in octets.
    04329 ctxp (IN) - the context for the call back function. Can be NULL.
    04330 cbfp (IN) - a callback that may be registered to be called for each piece. If
    04331 this is NULL, then OCI_NEED_DATA will be returned for each piece.
    04332 The callback function must return OCI_CONTINUE for the read to continue.
    04333 If any other error code is returned, the LOB read is aborted.
    04334   ctxp (IN) - the context for the call back function. Can be NULL.
    04335   bufp (IN) - a buffer pointer for the piece.
    04336   len (IN) - the length of length of current piece in bufp.
    04337   piece (IN) - which piece - OCI_FIRST_PIECE, OCI_NEXT_PIECE or
    04338   OCI_LAST_PIECE.
    04339 csid - the character set ID of the buffer data
    04340 csfrm - the character set form of the buffer data
    04341
    04342 Related Functions
    04343 OCIErrorGet, OCILobWrite, OCILobFileOpen, OCILobFileSetName, CREATE DIRECTORY
    04344
    04345
    04346
    04347
    04348 OCILobTrim()
    04349
    04350 Name
    04351
    04352 OCI Lob  Trim
    04353
    04354 Purpose
    04355 Trims the lob value to a shorter length
    04356
    04357 Syntax
    04358 sword OCILobTrim ( OCISvcCtx       *svchp,
    04359                  OCIError        *errhp,
    04360                  OCILobLocator   *locp,
    04361                  ub4             newlen );
    04362
    04363 Comments
    04364 Truncates LOB data to a specified shorter length.
    04365
    04366 Parameters
    04367 svchp (IN) - the service context handle.
    04368 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04369 diagnostic information in the event of an error.
    04370 locp (IN/OUT) - a LOB locator that uniquely references the LOB. This locator
    04371 must be a locator that was obtained from the server specified by svchp.
    04372 newlen (IN) - the new length of the LOB data, which must be less than or equal
    04373 to the current length.
    04374
    04375 Related Functions
    04376 OCIErrorGet, OCILobWrite, OCiLobErase, OCILobAppend, OCILobCopy
    04377
    04378
    04379
    04380
    04381
    04382 OCILobWrite()
    04383
    04384 Name
    04385 OCI Lob Write
    04386
    04387 Purpose
    04388 Writes a buffer into a LOB
    04389
    04390 Syntax
    04391 sword OCILobWrite ( OCISvcCtx       *svchp,
    04392                     OCIError        *errhp,
    04393                     OCILobLocator   *locp,
    04394                     ub4             offset,
    04395                     ub4             *amtp,
    04396                     dvoid           *bufp,
    04397                     ub4             buflen,
    04398                     ub1             piece,
    04399                     dvoid           *ctxp,
    04400                     OCICallbackLobWrite   (cbfp)
    04401                                     (
    04402                                     dvoid    *ctxp,
    04403                                     dvoid    *bufp,
    04404                                     ub4      *lenp,
    04405                                     ub1      *piecep )
    04406                     ub2             csid
    04407                     ub1             csfrm );
    04408
    04409
    04410 Comments
    04411 Writes a buffer into a LOB as specified. If LOB data already exists
    04412 it is overwritten with the data stored in the buffer.
    04413 The buffer can be written to the LOB in a single piece with this call, or
    04414 it can be provided piecewise using callbacks or a standard polling method.
    04415 If this value of the piece parameter is OCI_FIRST_PIECE, data must be
    04416 provided through callbacks or polling.
    04417 If a callback function is defined in the cbfp parameter, then this callback
    04418 function will be invoked to get the next piece after a piece is written to the
    04419 pipe. Each piece will be written from bufp.
    04420 If no callback function is defined, then OCILobWrite() returns the
    04421 OCI_NEED_DATA error code. The application must all OCILobWrite() again
    04422 to write more pieces of the LOB. In this mode, the buffer pointer and the
    04423 length can be different in each call if the pieces are of different sizes and
    04424 from different locations. A piece value of OCI_LAST_PIECE terminates the
    04425 piecewise write.
    04426
    04427 Parameters
    04428 svchp (IN/OUT) - the service context handle.
    04429 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04430 diagnostic information in the event of an error.
    04431 locp (IN/OUT) - a LOB locator that uniquely references a LOB.
    04432 offset (IN) - On input, it is the absolute offset, for character LOBs in
    04433 the number of characters from the beginning of the LOB, for binary LOBs it
    04434 is the number of bytes. Starts at 1.
    04435 bufp (IN) - the pointer to a buffer from which the piece will be written. The
    04436 length of the allocated memory is assumed to be the value passed in bufl. Even
    04437 if the data is being written in pieces, bufp must contain the first piece of
    04438 the LOB when this call is invoked.
    04439 bufl (IN) - the length of the buffer in bytes.
    04440 Note: This parameter assumes an 8-bit byte. If your platform uses a
    04441 longer byte, the value of bufl must be adjusted accordingly.
    04442 piece (IN) - which piece of the buffer is being written. The default value for
    04443 this parameter is OCI_ONE_PIECE, indicating the buffer will be written in a
    04444 single piece.
    04445 The following other values are also possible for piecewise or callback mode:
    04446 OCI_FIRST_PIECE, OCI_NEXT_PIECE and OCI_LAST_PIECE.
    04447 amtp (IN/OUT) - On input, takes the number of character or bytes to be
    04448 written. On output, returns the actual number of bytes or characters written.
    04449 If the data is written in pieces, *amtp will contain the total length of the
    04450 pieces written at the end of the call (last piece written) and is undefined in
    04451 between.
    04452 (Note it is different from the piecewise read case)
    04453 ctxp (IN) - the context for the call back function. Can be NULL.
    04454 cbfp (IN) - a callback that may be registered to be called for each piece in a
    04455 piecewise write. If this is NULL, the standard polling method will be used.
    04456 The callback function must return OCI_CONTINUE for the write to continue.
    04457 If any other error code is returned, the LOB write is aborted. The
    04458 callback takes the following parameters:
    04459   ctxp (IN) - the context for the call back function. Can be NULL.
    04460   bufp (IN/OUT) - a buffer pointer for the piece.
    04461   lenp (IN/OUT) - the length of the buffer (in octets) and the length of
    04462   current piece in bufp (out octets).
    04463   piecep (OUT) - which piece - OCI_NEXT_PIECE or OCI_LAST_PIECE.
    04464 csid - the character set ID of the buffer data
    04465 csfrm - the character set form of the buffer data
    04466 Related Functions
    04467
    04468
    04469
    04470
    04471
    04472
    04473 OCILobWriteAppend()
    04474
    04475 Name
    04476 OCI Lob Write Append
    04477
    04478 Purpose
    04479 Writes data to the end of a LOB value. This call provides the ability
    04480 to get the length of the data and append it to the end of the LOB in
    04481 a single round trip to the server.
    04482
    04483
    04484 Syntax
    04485 sword OCILobWriteAppend ( OCISvcCtx       *svchp,
    04486                     OCIError        *errhp,
    04487                     OCILobLocator   *locp,
    04488                     ub4             *amtp,
    04489                     dvoid           *bufp,
    04490                     ub4             buflen,
    04491                     ub1             piece,
    04492                     dvoid           *ctxp,
    04493                     OCICallbackLobWrite   (cbfp)
    04494                                     (
    04495                                     dvoid    *ctxp,
    04496                                     dvoid    *bufp,
    04497                                     ub4      *lenp,
    04498                                     ub1      *piecep )
    04499                     ub2             csid
    04500                     ub1             csfrm );
    04501
    04502
    04503 Comments
    04504 Writes a buffer to the end of a LOB as specified. If LOB data already exists
    04505 it is overwritten with the data stored in the buffer.
    04506 The buffer can be written to the LOB in a single piece with this call, or
    04507 it can be provided piecewise using callbacks or a standard polling method.
    04508 If this value of the piece parameter is OCI_FIRST_PIECE, data must be
    04509 provided through callbacks or polling.
    04510 If a callback function is defined in the cbfp parameter, then this callback
    04511 function will be invoked to get the next piece after a piece is written to the
    04512 pipe. Each piece will be written from bufp.
    04513 If no callback function is defined, then OCILobWriteAppend() returns the
    04514 OCI_NEED_DATA error code. The application must all OCILobWriteAppend() again
    04515 to write more pieces of the LOB. In this mode, the buffer pointer and the
    04516 length can be different in each call if the pieces are of different sizes and
    04517 from different locations. A piece value of OCI_LAST_PIECE terminates the
    04518 piecewise write.
    04519
    04520 Parameters
    04521 svchp (IN/OUT) - the service context handle.
    04522 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04523 diagnostic information in the event of an error.
    04524 locp (IN/OUT) - a LOB locator that uniquely references a LOB.
    04525 offset (IN) - On input, it is the absolute offset, for character LOBs in
    04526 the number of characters from the beginning of the LOB, for binary LOBs it
    04527 is the number of bytes. Starts at 1.
    04528 bufp (IN) - the pointer to a buffer from which the piece will be written. The
    04529 length of the allocated memory is assumed to be the value passed in bufl. Even
    04530 if the data is being written in pieces, bufp must contain the first piece of
    04531 the LOB when this call is invoked.
    04532 bufl (IN) - the length of the buffer in bytes.
    04533 Note: This parameter assumes an 8-bit byte. If your platform uses a
    04534 longer byte, the value of bufl must be adjusted accordingly.
    04535 piece (IN) - which piece of the buffer is being written. The default value for
    04536 this parameter is OCI_ONE_PIECE, indicating the buffer will be written in a
    04537 single piece.
    04538 The following other values are also possible for piecewise or callback mode:
    04539 OCI_FIRST_PIECE, OCI_NEXT_PIECE and OCI_LAST_PIECE.
    04540 amtp (IN/OUT) - On input, takes the number of character or bytes to be
    04541 written. On output, returns the actual number of bytes or characters written.
    04542 If the data is written in pieces, *amtp will contain the total length of the
    04543 pieces written at the end of the call (last piece written) and is undefined in
    04544 between.
    04545 (Note it is different from the piecewise read case)
    04546 ctxp (IN) - the context for the call back function. Can be NULL.
    04547 cbfp (IN) - a callback that may be registered to be called for each piece in a
    04548 piecewise write. If this is NULL, the standard polling method will be used.
    04549 The callback function must return OCI_CONTINUE for the write to continue.
    04550 If any other error code is returned, the LOB write is aborted. The
    04551 callback takes the following parameters:
    04552   ctxp (IN) - the context for the call back function. Can be NULL.
    04553   bufp (IN/OUT) - a buffer pointer for the piece.
    04554   lenp (IN/OUT) - the length of the buffer (in octets) and the length of
    04555   current piece in bufp (out octets).
    04556   piecep (OUT) - which piece - OCI_NEXT_PIECE or OCI_LAST_PIECE.
    04557 csid - the character set ID of the buffer data
    04558 csfrm - the character set form of the buffer data
    04559 Related Functions
    04560
    04561
    04562
    04563
    04564
    04565 OCILogoff()
    04566 Name
    04567 OCI simplified Logoff
    04568 Purpose
    04569 This function is used to terminate a session created with OCILogon() or
    04570 OCILogon2().
    04571 Syntax
    04572 sword OCILogoff ( OCISvcCtx      *svchp
    04573                    OCIError       *errhp );
    04574 Comments
    04575 This call is used to terminate a session which was created with OCILogon() or
    04576 OCILogon2().
    04577 This call implicitly deallocates the server, authentication, and service
    04578 context handles.
    04579 Note: For more information on logging on and off in an application,
    04580 refer to the section "Application Initialization, Connection, and
    04581 Authorization" on page 2-16.
    04582 Parameters
    04583 svchp (IN) - the service context handle which was used in the call to
    04584 OCILogon() or OCILogon2().
    04585 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04586 diagnostic information in the event of an error.
    04587 See Also
    04588 OCILogon(), OCILogon2().
    04589
    04590
    04591
    04592
    04593
    04594
    04595 OCILogon()
    04596 Name
    04597 OCI Service Context Logon
    04598 Purpose
    04599 This function is used to create a simple logon session.
    04600 Syntax
    04601 sword OCILogon ( OCIEnv          *envhp,
    04602                        OCIError        *errhp,
    04603                        OCISvcCtx       *svchp,
    04604                        CONST OraText      *username,
    04605                        ub4             uname_len,
    04606                        CONST OraText      *password,
    04607                        ub4             passwd_len,
    04608                        CONST OraText      *dbname,
    04609                        ub4             dbname_len );
    04610 Comments
    04611 This function is used to create a simple logon session for an application.
    04612 Note: Users requiring more complex session (e.g., TP monitor
    04613 applications) should refer to the section "Application Initialization,
    04614 Connection, and Authorization" on page 2-16.
    04615 This call allocates the error and service context handles which are passed to
    04616 it. This call also implicitly allocates server and authentication handles
    04617 associated with the session.  These handles can be retrieved by calling
    04618 OCIAttrGet() on the service context handle.
    04619 Parameters
    04620 envhp (IN) - the OCI environment handle.
    04621 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04622 diagnostic information in the event of an error.
    04623 svchp (OUT) - the service context pointer.
    04624 username (IN) - the username.
    04625 uname_len (IN) - the length of username.
    04626 password (IN) - the user's password.
    04627 passwd_len (IN) - the length of password.
    04628 dbname (IN) - the name of the database to connect to.
    04629 dbname_len (IN) - the length of dbname.
    04630 See Also
    04631 OCILogoff()
    04632
    04633
    04634
    04635
    04636
    04637 OCILogon2()
    04638 Name
    04639 OCI Service Context Logon
    04640 Purpose
    04641 This function is used to create a logon session in connection pooling mode.
    04642 Syntax
    04643 sword OCILogon2 ( OCIEnv          *envhp,
    04644                        OCIError        *errhp,
    04645                        OCISvcCtx       **svchp,
    04646                        CONST OraText      *username,
    04647                        ub4             uname_len,
    04648                        CONST OraText      *password,
    04649                        ub4             passwd_len,
    04650                        CONST OraText      *dbname,
    04651                        ub4             dbname_len,
    04652                        ub4             mode);
    04653 Comments
    04654 This function is used to create a simple logon session for an application in
    04655 Connection Pooling mode. The valid values for mode are currently OCI_POOL and
    04656 OCI_DEFAULT. Call to this function with OCI_DEFAULT mode is equivalent to
    04657 OCILogon() call.
    04658 This call allocates the error and service context handles which are passed to
    04659 it. This call also implicitly allocates server and authentication handles
    04660 associated with the session.  These handles can be retrieved by calling
    04661 OCIAttrGet() on the service context handle. This call assumes that
    04662 OCIConnectionPoolCreate() has already been called for the same dbname.
    04663 Parameters
    04664 envhp (IN) - the OCI environment handle.
    04665 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04666 diagnostic information in the event of an error.
    04667 svchp (OUT) - the service context pointer.
    04668 username (IN) - the username.
    04669 uname_len (IN) - the length of username.
    04670 password (IN) - the user's password. If this is null, it is assumed that a
    04671                 proxy session has to be created and the required grants on
    04672                 the database are already done.
    04673 passwd_len (IN) - the length of password.
    04674 dbname (IN) - the name of the database to connect to.
    04675 dbname_len (IN) - the length of dbname.
    04676 mode (IN) - the mode for doing the server attach. Should be OCI_POOL for
    04677             using Connection Pooling.
    04678
    04679
    04680 See Also
    04681 OCILogoff()
    04682
    04683
    04684
    04685
    04686
    04687 OCIMemoryFree()
    04688 Name
    04689 OCI FREE Memory
    04690 Purpose
    04691 Frees up storage associated with the pointer.
    04692 Syntax
    04693 void OCIMemoryFree ( CONST OCIStmt   *stmhp,
    04694                      dvoid           *memptr);
    04695 Comments
    04696 Frees up dynamically allocated data pointers associated with the pointer using
    04697 either the default memory free function or the registered memory free
    04698 function, as the case may be.
    04699 A user-defined memory free function can be registered during the initial call
    04700 to OCIInitialize().
    04701 This call is always successful.
    04702 Parameters
    04703 stmhp (IN) - statement handle which returned this data buffer.
    04704 memptr (IN) - pointer to data allocated by the client library.
    04705 Related Functions
    04706 OCIInitialize()
    04707
    04708
    04709
    04710
    04711
    04712 OCIParamGet()
    04713 Name
    04714 OCI Get PARaMeter
    04715 Purpose
    04716 Returns a descriptor of a parameter specified by position in the describe
    04717 handle or statement handle.
    04718 Syntax
    04719 sword OCIParamGet ( CONST dvoid       *hndlp,
    04720                   ub4         htype,
    04721                   OCIError    *errhp,
    04722                   dvoid    **parmdpp,
    04723                   ub4         pos );
    04724 Comments
    04725 This call returns a descriptor of a parameter specified by position in the
    04726 describe handle or statement handle. Parameter descriptors are always
    04727 allocated internally by the OCI library. They are read-only.
    04728 OCI_NO_DATA may be returned if there are no parameter descriptors for this
    04729 position.
    04730 See Appendix B for more detailed information about parameter descriptor
    04731 attributes.
    04732 Parameters
    04733 hndlp (IN) - a statement handle or describe handle. The OCIParamGet()
    04734 function will return a parameter descriptor for this handle.
    04735 htype (IN) - the type of the handle passed in the handle parameter. Valid
    04736 types are OCI_HTYPE_DESCRIBE, for a describe handle OCI_HTYPE_STMT, for a
    04737 statement handle
    04738 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04739 diagnostic information in the event of an error.
    04740 parmdpp (OUT) - a descriptor of the parameter at the position given in the pos
    04741 parameter.
    04742 pos (IN) - position number in the statement handle or describe handle. A
    04743 parameter descriptor will be returned for this position.
    04744 Note: OCI_NO_DATA may be returned if there are no parameter
    04745 descriptors for this position.
    04746 Related Functions
    04747 OCIAttrGet(), OCIAttrSet()
    04748
    04749
    04750
    04751
    04752
    04753 OCIParamSet()
    04754 Name
    04755 OCI Parameter Set in handle
    04756 Purpose
    04757 Used to set a complex object retrieval descriptor into a complex object
    04758 retrieval handle.
    04759 Syntax
    04760 sword   OCIParamGet ( dvoid *hndlp,
    04761                        ub4 htyp,
    04762                       OCIError *errhp,
    04763                       CONST dvoid *dscp,
    04764                       ub4 dtyp,
    04765                       ub4 pos );
    04766 Comments
    04767 This call sets a given complex object retrieval descriptor into a complex
    04768 object retrieval handle.
    04769 The handle must have been previously allocated using OCIHandleAlloc(), and
    04770 the descriptor must have been previously allocated using OCIDescAlloc().
    04771 Attributes of the descriptor are set using OCIAttrSet().
    04772 Parameters
    04773 hndlp (IN/OUT) - handle pointer.
    04774 htype (IN) - handle type.
    04775 errhp (IN/OUT) - error handle.
    04776 dscp (IN) - complex object retrieval descriptor pointer.
    04777 dtyp (IN) -
    04778 pos (IN) - position number.
    04779 See Also
    04780
    04781
    04782
    04783
    04784
    04785 OCIPasswordChange()
    04786 Name
    04787 OCI Change PassWord
    04788 Purpose
    04789 This call allows the password of an account to be changed.
    04790 Syntax
    04791 sword OCIPasswordChange ( OCISvcCtx     *svchp,
    04792                         OCIError      *errhp,
    04793                         CONST OraText    *user_name,
    04794                         ub4           usernm_len,
    04795                         CONST OraText    *opasswd,
    04796                         ub4           opasswd_len,
    04797                         CONST OraText    *npasswd,
    04798                         sb4           npasswd_len,
    04799                         ub4           mode);
    04800 Comments
    04801 This call allows the password of an account to be changed. This call is
    04802 similar to OCISessionBegin() with the following differences:
    04803 If the user authentication is already established, it authenticates
    04804 the account using the old password and then changes the
    04805 password to the new password
    04806 If the user authentication is not established, it establishes a user
    04807 authentication and authenticates the account using the old
    04808 password, then changes the password to the new password.
    04809 This call is useful when the password of an account is expired and
    04810 OCISessionBegin() returns an error or warning which indicates that the
    04811 password has expired.
    04812 Parameters
    04813 svchp (IN/OUT) - a handle to a service context. The service context handle
    04814 must be initialized and have a server context handle associated with it.
    04815 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    04816 diagnostic information in the event of an error.
    04817 user_name (IN) - specifies the user name. It points to a character string,
    04818 whose length is specified in usernm_len. This parameter must be NULL if the
    04819 service context has been initialized with an authentication handle.
    04820 usernm_len (IN) - the length of the user name string specified in user_name.
    04821 For a valid user name string, usernm_len must be non-zero.
    04822 opasswd (IN) - specifies the user's old password. It points to a character
    04823 string, whose length is specified in opasswd_len .
    04824 opasswd_len (IN) - the length of the old password string specified in opasswd.
    04825 For a valid password string, opasswd_len must be non-zero.
    04826 npasswd (IN) - specifies the user's new password. It points to a character
    04827 string, whose length is specified in npasswd_len which must be non-zero for a
    04828 valid password string. If the password complexity verification routine is
    04829 specified in the user's profile to verify the new password's complexity, the
    04830 new password must meet the complexity requirements of the verification
    04831 function.
    04832 npasswd_len (IN)  - then length of the new password string specified in
    04833 npasswd. For a valid password string, npasswd_len must be non-zero.
    04834 mode - pass as OCI_DEFAULT.
    04835 Related Functions
    04836 OCISessionBegin()
    04837
    04838
    04839 ----------------------------------OCIReset------------------------------------
    04840
    04841
    04842 OCIReset()
    04843 Name
    04844 OCI Reset
    04845 Purpose
    04846 Resets the interrupted asynchronous operation and protocol. Must be called
    04847 if a OCIBreak call had been issued while a non-blocking operation was in
    04848 progress.
    04849 Syntax
    04850 sword OCIReset ( dvoid      *hndlp,
    04851                  OCIError   *errhp);
    04852 Comments
    04853 This call is called in non-blocking mode ONLY. Resets the interrupted
    04854 asynchronous operation and protocol. Must be called if a OCIBreak call
    04855 had been issued while a non-blocking operation was in progress.
    04856 Parameters
    04857 hndlp (IN) - the service context handle or the server context handle.
    04858 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    04859 diagnostic information in the event of an error.
    04860 Related Functions
    04861
    04862
    04863 OCIResultSetToStmt()
    04864 Name
    04865 OCI convert Result Set to Statement Handle
    04866 Purpose
    04867 Converts a descriptor to statement handle for fetching rows.
    04868 Syntax
    04869 sword OCIResultSetToStmt ( OCIResult     *rsetdp,
    04870                          OCIError      *errhp );
    04871 Comments
    04872 Converts a descriptor to statement handle for fetching rows.
    04873 A result set descriptor can be allocated with a call to OCIDescAlloc().
    04874 Parameters
    04875 rsetdp (IN/OUT) - a result set descriptor pointer.
    04876 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04877 diagnostic information in the event of an error.
    04878 Related Functions
    04879 OCIDescAlloc()
    04880
    04881
    04882
    04883
    04884 OCIServerAttach()
    04885 Name
    04886 OCI ATtaCH to server
    04887 Purpose
    04888 Creates an access path to a data source for OCI operations.
    04889 Syntax
    04890 sword OCIServerAttach ( OCIServer    *srvhp,
    04891                       OCIError     *errhp,
    04892                       CONST OraText   *dblink,
    04893                       sb4          dblink_len,
    04894                       ub4          mode);
    04895 Comments
    04896 This call is used to create an association between an OCI application and a
    04897 particular server.
    04898 This call initializes a server context handle, which must have been previously
    04899 allocated with a call to OCIHandleAlloc().
    04900 The server context handle initialized by this call can be associated with a
    04901 service context through a call to OCIAttrSet(). Once that association has been
    04902 made, OCI operations can be performed against the server.
    04903 If an application is operating against multiple servers, multiple server
    04904 context handles can be maintained. OCI operations are performed against
    04905 whichever server context is currently associated with the service context.
    04906 Parameters
    04907 srvhp (IN/OUT) - an uninitialized server context handle, which gets
    04908 initialized by this call. Passing in an initialized server handle causes an
    04909 error.
    04910 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04911 diagnostic information in the event of an error.
    04912 dblink (IN) - specifies the database (server) to use. This parameter points to
    04913 a character string which specifies a connect string or a service point. If the
    04914 connect string is NULL, then this call attaches to the default host. The length
    04915 of connstr is specified in connstr_len. The connstr pointer may be freed by the
    04916 caller on return.
    04917 dblink_len (IN) - the length of the string pointed to by connstr. For a valid
    04918 connect string name or alias, connstr_len must be non-zero.
    04919 mode (IN) - specifies the various modes of operation.  For release 8.0, pass as
    04920 OCI_DEFAULT - in this mode, calls made to the server on this server context
    04921 are made in blocking mode.
    04922 Example
    04923 See the description of OCIStmtPrepare() on page 13-96 for an example showing
    04924 the use of OCIServerAttach().
    04925 Related Functions
    04926 OCIServerDetach()
    04927
    04928
    04929
    04930 OCIServerDetach()
    04931 Name
    04932 OCI DeTaCH server
    04933 Purpose
    04934 Deletes an access to a data source for OCI operations.
    04935 Syntax
    04936 sword OCIServerDetach ( OCIServer   *svrhp,
    04937                       OCIError    *errhp,
    04938                       ub4         mode);
    04939 Comments
    04940 This call deletes an access to data source for OCI operations, which was
    04941 established by a call to OCIServerAttach().
    04942 Parameters
    04943 srvhp (IN) - a handle to an initialized server context, which gets reset to
    04944 uninitialized state. The handle is not de-allocated.
    04945 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    04946 diagnostic information in the event of an error.
    04947 mode (IN) - specifies the various modes of operation. The only valid mode is
    04948 OCI_DEFAULT for the default mode.
    04949 Related Functions
    04950 OCIServerAttach()
    04951
    04952
    04953
    04954 OCIServerVersion()
    04955 Name
    04956 OCI VERSion
    04957 Purpose
    04958 Returns the version string of the Oracle server.
    04959 Syntax
    04960 sword OCIServerVersion ( dvoid        *hndlp,
    04961                        OCIError     *errhp,
    04962                        OraText         *bufp,
    04963                        ub4          bufsz
    04964                        ub1          hndltype );
    04965 Comments
    04966 This call returns the version string of the Oracle server.
    04967 For example, the following might be returned as the version string if your
    04968 application is running against a 7.3.2 server:
    04969 Oracle7 Server Release 7.3.2.0.0 - Production Release
    04970 PL/SQL Release 2.3.2.0.0 - Production
    04971 CORE Version 3.5.2.0.0 - Production
    04972 TNS for SEQUENT DYNIX/ptx: Version 2.3.2.0.0 - Production
    04973 NLSRTL Version 3.2.2.0.0 - Production
    04974
    04975 Parameters
    04976 hndlp (IN) - the service context handle or the server context handle.
    04977 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    04978 diagnostic information in the event of an error.
    04979 bufp (IN) - the buffer in which the version information is returned.
    04980 bufsz (IN) - the length of the buffer.
    04981 hndltype (IN) - the type of handle passed to the function.
    04982 Related Functions
    04983
    04984
    04985
    04986
    04987
    04988 OCISessionBegin()
    04989 Name
    04990 OCI Session Begin and authenticate user
    04991 Purpose
    04992 Creates a user authentication and begins a user session for a given server.
    04993 Syntax
    04994 sword OCISessionBegin ( OCISvcCtx     *svchp,
    04995                       OCIError      *errhp,
    04996                       OCISession    *usrhp,
    04997                       ub4           credt,
    04998                       ub4           mode);
    04999
    05000 Comments
    05001 For Oracle8, OCISessionBegin() must be called for any given server handle
    05002 before requests can be made against it. Also, OCISessionBegin() only supports
    05003 authenticating the user for access to the Oracle server specified by the
    05004 server handle in the service context. In other words, after OCIServerAttach()
    05005 is called to initialize a server handle, OCISessionBegin() must be called to
    05006 authenticate the user for that given server.
    05007 When OCISessionBegin() is called for the first time for the given server
    05008 handle, the initialized authentication handle is called a primary
    05009 authentication context. A primary authentication context may not be created
    05010 with the OCI_MIGRATE mode. Also, only one primary authentication context can
    05011 be created for a given server handle and the primary authentication context c
    05012 an only ever be used with that server handle. If the primary authentication
    05013 context is set in a service handle with a different server handle, then an
    05014 error will result.
    05015 After OCISessionBegin() has been called for the server handle, and the primary
    05016 authentication context is set in the service handle, OCISessionBegin() may be
    05017 called again to initialize another authentication handle with different (or
    05018 the same) credentials. When OCISessionBegin() is called with a service handle
    05019 set with a primary authentication context, the returned authentication context
    05020 in authp is called a user authentication context. As many user authentication
    05021 contexts may be initialized as desired.
    05022 User authentication contexts may be created with the OCI_MIGRATE mode.
    05023 If the OCI_MIGRATE mode is not specified, then the user authentication
    05024 context can only ever be used with the same server handle set in svchp. If
    05025 OCI_MIGRATE mode is specified, then the user authentication may be set
    05026 with different server handles. However, the user authentication context is
    05027 restricted to use with only server handles which resolve to the same database
    05028 instance and that have equivalent primary authentication contexts. Equivalent
    05029 authentication contexts are those which were authenticated as the same
    05030 database user.
    05031 OCI_SYSDBA, OCI_SYSOPER, and OCI_PRELIM_AUTH may only be used
    05032 with a primary authentication context.
    05033 To provide credentials for a call to OCISessionBegin(), one of two methods are
    05034 supported. The first is to provide a valid username and password pair for
    05035 database authentication in the user authentication handle passed to
    05036 OCISessionBegin(). This involves using OCIAttrSet() to set the
    05037 OCI_ATTR_USERNAME and OCI_ATTR_PASSWORD attributes on the
    05038 authentication handle. Then OCISessionBegin() is called with
    05039 OCI_CRED_RDBMS.
    05040 Note: When the authentication handle is terminated using
    05041 OCISessionEnd(), the username and password attributes remain
    05042 unchanged and thus can be re-used in a future call to OCISessionBegin().
    05043 Otherwise, they must be reset to new values before the next
    05044 OCISessionBegin() call.
    05045 The second type of credentials supported are external credentials. No
    05046 attributes need to be set on the authentication handle before calling
    05047 OCISessionBegin(). The credential type is OCI_CRED_EXT. This is equivalent
    05048 to the Oracle7 `connect /' syntax. If values have been set for
    05049 OCI_ATTR_USERNAME and OCI_ATTR_PASSWORD, then these are
    05050 ignored if OCI_CRED_EXT is used.
    05051 Parameters
    05052 svchp (IN) - a handle to a service context. There must be a valid server
    05053 handle set in svchp.
    05054 errhp (IN) - an error handle to the retrieve diagnostic information.
    05055 usrhp (IN/OUT) - a handle to an authentication context, which is initialized
    05056 by this call.
    05057 credt (IN) - specifies the type of credentials to use for authentication.
    05058 Valid values for credt are:
    05059 OCI_CRED_RDBMS - authenticate using a database username and
    05060 password pair as credentials. The attributes OCI_ATTR_USERNAME
    05061 and OCI_ATTR_PASSWORD should be set on the authentication
    05062 context before this call.
    05063 OCI_CRED_EXT - authenticate using external credentials. No username
    05064 or password is provided.
    05065 mode (IN) - specifies the various modes of operation. Valid modes are:
    05066 OCI_DEFAULT - in this mode, the authentication context returned may
    05067 only ever be set with the same server context specified in svchp. This
    05068 establishes the primary authentication context.
    05069 OCI_MIGRATE - in this mode, the new authentication context may be
    05070 set in a service handle with a different server handle. This mode
    05071 establishes the user authentication context.
    05072 OCI_SYSDBA - in this mode, the user is authenticated for SYSDBA
    05073 access.
    05074 OCI_SYSOPER - in this mode, the user is authenticated for SYSOPER
    05075 access.
    05076 OCI_PRELIM_AUTH - this mode may only be used with OCI_SYSDBA
    05077 or OCI_SYSOPER to authenticate for certain administration tasks.
    05078 Related Functions
    05079 OCISessionEnd()
    05080
    05081
    05082
    05083
    05084
    05085
    05086 OCISessionEnd()
    05087 Name
    05088 OCI Terminate user Authentication Context
    05089 Purpose
    05090 Terminates a user authentication context created by OCISessionBegin()
    05091 Syntax
    05092 sword OCISessionEnd ( OCISvcCtx       *svchp,
    05093                     OCIError        *errhp,
    05094                     OCISession      *usrhp,
    05095                     ub4             mode);
    05096
    05097 Comments
    05098 The user security context associated with the service context is invalidated
    05099 by this call. Storage for the authentication context is not freed. The
    05100 transaction specified by the service context is implicitly committed. The
    05101 transaction handle, if explicitly allocated, may be freed if not being used.
    05102 Resources allocated on the server for this user are freed.
    05103 The authentication handle may be reused in a new call to OCISessionBegin().
    05104 Parameters
    05105 svchp (IN/OUT) - the service context handle. There must be a valid server
    05106 handle and user authentication handle associated with svchp.
    05107 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    05108 diagnostic information in the event of an error.
    05109 usrhp (IN) - de-authenticate this user. If this parameter is passed as NULL, the
    05110 user in the service context handle is de-authenticated.
    05111 mode (IN) - the only valid mode is OCI_DEFAULT.
    05112 Example
    05113 In this example, an authentication context is destroyed.
    05114 Related Functions
    05115 OCISessionBegin()
    05116
    05117
    05118
    05119
    05120 OCIStmtExecute()
    05121 Name
    05122 OCI EXECute
    05123 Purpose
    05124 This call associates an application request with a server.
    05125 Syntax
    05126 sword OCIStmtExecute ( OCISvcCtx           *svchp,
    05127                      OCIStmt             *stmtp,
    05128                      OCIError            *errhp,
    05129                      ub4                 iters,
    05130                      ub4                 rowoff,
    05131                      CONST OCISnapshot   *snap_in,
    05132                      OCISnapshot         *snap_out,
    05133                      ub4                 mode );
    05134 Comments
    05135 This function  is used to execute a prepared SQL statement.
    05136 Using an execute call, the application associates a request with a server. On
    05137 success, OCI_SUCCESS is returned.
    05138 If a SELECT statement is executed, the description of the select list follows
    05139 implicitly as a response. This description is buffered on the client side for
    05140 describes, fetches and define type conversions. Hence it is optimal to
    05141 describe a select list only after an execute.
    05142 Also for SELECT statements, some results are available implicitly. Rows will
    05143 be received and buffered at the end of the execute. For queries with small row
    05144 count, a prefetch causes memory to be released in the server if the end of
    05145 fetch is reached, an optimization that may result in memory usage reduction.
    05146 Set attribute call has been defined to set the number of rows to be prefetched
    05147 per result set.
    05148 For SELECT statements, at the end of the execute, the statement handle
    05149 implicitly maintains a reference to the service context on which it is
    05150 executed. It is the user's responsibility to maintain the integrity of the
    05151 service context. If the attributes of a service context is changed for
    05152 executing some operations on this service context, the service context must
    05153 be restored to have the same attributes, that a statement was executed with,
    05154 prior to a fetch on the statement handle. The implicit reference is maintained
    05155 until the statement handle is freed or the fetch is cancelled or an end of
    05156 fetch condition is reached.
    05157 Note: If output variables are defined for a SELECT statement before a
    05158 call to OCIStmtExecute(), the number of rows specified by iters will be
    05159 fetched directly into the defined output buffers and additional rows
    05160 equivalent to the prefetch count will be prefetched. If there are no
    05161 additional rows, then the fetch is complete without calling
    05162 OCIStmtFetch().
    05163 The execute call will return errors if the statement has bind data types that
    05164 are not supported in an Oracle7 server.
    05165 Parameters
    05166 svchp (IN/OUT) - service context handle.
    05167 stmtp (IN/OUT) - an statement handle - defines the statement and the
    05168 associated data to be executed at the server. It is invalid to pass in a
    05169 statement handle that has bind of data types only supported in release 8.0
    05170 when srvchp points to an Oracle7 server.
    05171 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    05172 diagnostic information in the event of an error. If the statement is being
    05173 batched and it is successful, then this handle will contain this particular
    05174 statement execution specific errors returned from the server when the batch is
    05175 flushed.
    05176 iters (IN) - the number of times this statement is executed for non-Select
    05177 statements. For Select statements, if iters is non-zero, then defines must
    05178 have been done for the statement handle. The execution fetches iters rows into
    05179 these predefined buffers and prefetches more rows depending upon the prefetch
    05180 row count. This function returns an error if iters=0 for non-SELECT
    05181 statements.
    05182 rowoff (IN) - the index from which the data in an array bind is relevant for
    05183 this multiple row execution.
    05184 snap_in (IN) - this parameter is optional. if supplied, must point to a
    05185 snapshot descriptor of type OCI_DTYPE_SNAP.  The contents of this descriptor
    05186 must be obtained from the snap_out parameter of a previous call.  The
    05187 descriptor is ignored if the SQL is not a SELECT.  This facility allows
    05188 multiple service contexts to ORACLE to see the same consistent snapshot of the
    05189 database's committed data.  However, uncommitted data in one context is not
    05190 visible to another context even using the same snapshot.
    05191 snap_out (OUT) - this parameter optional. if supplied, must point to a
    05192 descriptor of type OCI_DTYPE_SNAP. This descriptor is filled in with an
    05193 opaque representation which is the current ORACLE "system change
    05194 number" suitable as a snap_in input to a subsequent call to OCIStmtExecute().
    05195 This descriptor should not be used any longer than necessary in order to avoid
    05196 "snapshot too old" errors.
    05197 mode (IN) - The modes are:
    05198 If OCI_DEFAULT_MODE, the default mode, is selected, the request is
    05199 immediately executed. Error handle contains diagnostics on error if any.
    05200 OCI_EXACT_FETCH - if the statement is a SQL SELECT, this mode is
    05201 only valid if the application has set the prefetch row count prior to this
    05202 call. In this mode, the OCI library will get up to the number of rows
    05203 specified (i.e., prefetch row count plus iters). If the number of rows
    05204 returned by the query is greater than this value, OCI_ERROR will be
    05205 returned with ORA-01422 as the implementation specific error in a
    05206 diagnostic record. If the number of rows returned by the query is
    05207 smaller than the prefetch row count, OCI_SUCCESS_WITH_INFO will
    05208 be returned with ORA-01403 as the implementation specific error. The
    05209 prefetch buffer size is ignored and the OCI library tries to allocate all the
    05210 space required to contain the prefetched rows. The exact fetch semantics
    05211 apply to only the top level rows. No more rows can be fetched for this
    05212 query at the end of the call.
    05213 OCI_KEEP_FETCH_STATE - the result set rows (not yet fetched) of this
    05214 statement executed in this transaction will be maintained when the
    05215 transaction is detached for migration. By default, a query is cancelled
    05216 when a transaction is detached for migration. This mode is the default
    05217 mode when connected to a V7 server.
    05218 Related Functions
    05219 OCIStmtPrepare()
    05220
    05221
    05222
    05223
    05224
    05225 OCIStmtFetch()
    05226 Name
    05227 OCI FetCH
    05228 Purpose
    05229 Fetches rows from a query.
    05230 Syntax
    05231 sword OCIStmtFetch ( OCIStmt     *stmtp,
    05232                    OCIError    *errhp,
    05233                    ub4         nrows,
    05234                    ub2         orientation,
    05235                    ub4         mode);
    05236 Comments
    05237 The fetch call is a local call, if prefetched rows suffice. However, this is
    05238 transparent to the application. If LOB columns are being read, LOB locators
    05239 are fetched for subsequent LOB operations to be performed on these locators.
    05240 Prefetching is turned off if LONG columns are involved.
    05241 A fetch with nrows set to 0 rows effectively cancels the fetch for this
    05242 statement.
    05243 Parameters
    05244 stmtp (IN) - a statement (application request) handle.
    05245 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    05246 diagnostic information in the event of an error.
    05247 nrows (IN) - number of rows to be fetched from the current position.
    05248 orientation (IN) - for release 8.0, the only acceptable value is
    05249 OCI_FETCH_NEXT, which is also the default value.
    05250 mode (IN) - for release 8.0, beta-1, the following mode is defined.
    05251 OCI_DEFAULT - default mode
    05252 OCI_EOF_FETCH - indicates that it is the last fetch from the result set.
    05253 If nrows is non-zero, setting this mode effectively cancels fetching after
    05254 retrieving nrows, otherwise it cancels fetching immediately.
    05255 Related Functions
    05256 OCIAttrGet()
    05257
    05258
    05259 OCIStmtFetch2()
    05260 Name
    05261 OCI FetCH2
    05262 Purpose
    05263 Fetches rows from a query.
    05264 Syntax
    05265 sword OCIStmtFetch2 ( OCIStmt     *stmtp,
    05266                    OCIError    *errhp,
    05267                    ub4         nrows,
    05268                    ub2         orientation,
    05269                    ub4         scrollOffset,
    05270                    ub4         mode);
    05271 Comments
    05272 The fetch call works similar to the OCIStmtFetch call with the
    05273 addition of the fetchOffset parameter. It can be used on any
    05274 statement handle, whether it is scrollable or not. For a
    05275 non-scrollable statement handle, the only acceptable value
    05276 will be OCI_FETCH_NEXT, and the fetchOffset parameter will be
    05277 ignored. Applications are encouraged to use this new call.
    05278
    05279 A fetchOffset with OCI_FETCH_RELATIVE is equivalent to
    05280 OCI_FETCH_CURRENT with a value of 0, is equivalent to
    05281 OCI_FETCH_NEXT with a value of 1, and equivalent to
    05282 OCI_FETCH_PRIOR with a value of -1. Note that the range of
    05283 accessible rows is [1,OCI_ATTR_ROW_COUNT] beyond which an
    05284 error could be raised if sufficient rows do not exist in
    05285
    05286 The fetch call is a local call, if prefetched rows suffice. However, this is
    05287 transparent to the application. If LOB columns are being read, LOB locators
    05288 are fetched for subsequent LOB operations to be performed on these locators.
    05289 Prefetching is turned off if LONG columns are involved.
    05290 A fetch with nrows set to 0 rows effectively cancels the fetch for this
    05291 statement.
    05292 Parameters
    05293 stmtp (IN) - a statement (application request) handle.
    05294 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    05295 diagnostic information in the event of an error.
    05296 nrows (IN) - number of rows to be fetched from the current position.
    05297 It defaults to 1 for orientation OCI_FETCH_LAST.
    05298 orientation (IN) -  The acceptable values are as follows, with
    05299 OCI_FETCH_NEXT being the default value.
    05300 OCI_FETCH_CURRENT gets the current row,
    05301 OCI_FETCH_NEXT gets the next row from the current position,
    05302 OCI_FETCH_FIRST gets the first row in the result set,
    05303 OCI_FETCH_LAST gets the last row in the result set,
    05304 OCI_FETCH_PRIOR gets the previous row from the current row in the result set,
    05305 OCI_FETCH_ABSOLUTE will fetch the row number (specified by fetchOffset
    05306 parameter) in the result set using absolute positioning,
    05307 OCI_FETCH_RELATIVE will fetch the row number (specified by fetchOffset
    05308 parameter) in the result set using relative positioning.
    05309 scrollOffset(IN) - offset used with the OCI_FETCH_ABSOLUTE and
    05310 OCI_FETCH_RELATIVE orientation parameters only. It specify
    05311 the new current position for scrollable result set. It is
    05312 ignored for non-scrollable result sets.
    05313 mode (IN) - for release 8.0, beta-1, the following mode is defined.
    05314 OCI_DEFAULT - default mode
    05315 OCI_EOF_FETCH - indicates that it is the last fetch from the result set.
    05316 If nrows is non-zero, setting this mode effectively cancels fetching after
    05317 retrieving nrows, otherwise it cancels fetching immediately.
    05318 Related Functions
    05319 OCIAttrGet()
    05320
    05321
    05322 OCIStmtGetBindInfo()
    05323 Name
    05324 OCI Get Bind Parameters
    05325 Purpose
    05326 Gets the bind and indicator variable names.
    05327 Syntax
    05328 sword OCIStmtGetBindInfo ( OCIStmt      *stmtp,
    05329                      OCIError     *errhp,
    05330                      ub4          size,
    05331                      ub4          startloc,
    05332                      sb4          *found,
    05333                      OraText         *bvnp[],
    05334                      ub1          bvnl[],
    05335                      OraText         *invp[],
    05336                      ub1          inpl[],
    05337                      ub1          dupl[],
    05338                      OCIBind      *hndl[] );
    05339
    05340 Comments
    05341 Gets the bind and indicator variable names. It returns the information for all
    05342 the bind variables (even the duplicate ones) and sets the found parameter to
    05343 the total number of bind variables and not just the number of distinct bind
    05344 variables.
    05345 The statement must have been prepared with a call to OCIStmtPrepare() prior
    05346 to this call.
    05347 This call is processed locally.
    05348 Parameters
    05349 stmtp (IN) - the statement handle.
    05350 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    05351 diagnostic information in the event of an error.
    05352 size (IN) - the number of elements in each array.
    05353 startloc (IN) - position of the  bind variable at which to start getting  bind
    05354 information.
    05355 found (IN) - abs(found) gives the total number of bind variables in the
    05356 statement irrespective of the start position. Positive value if the number of
    05357 bind variables returned is less than the size provided, otherwise negative.
    05358 bvnp (OUT) - array of pointers to hold bind variable names.
    05359 bvnl (OUT) - array to hold the length of the each bvnp element.
    05360 invp (OUT) - array of pointers to hold indicator variable names.
    05361 inpl (OUT) - array of pointers to hold the length of the each invp element.
    05362 dupl (OUT) - an array whose element value is 0 or 1 depending on whether the
    05363 bind position is duplicate of another.
    05364 hndl  (OUT) - an array which returns the bind handle if binds have been done
    05365 for the bind position. No handle is returned for duplicates.
    05366 Related Functions
    05367 OCIStmtPrepare()
    05368
    05369
    05370
    05371 OCIStmtGetPieceInfo()
    05372 Name
    05373 OCI Get Piece Information
    05374 Purpose
    05375 Returns piece information for a piecewise operation.
    05376 Syntax
    05377 sword OCIStmtGetPieceInfo( CONST OCIStmt  *stmtp,
    05378                          OCIError       *errhp,
    05379                          dvoid          **hndlpp,
    05380                          ub4            *typep,
    05381                          ub1            *in_outp,
    05382                          ub4            *iterp,
    05383                          ub4            *idxp,
    05384                          ub1            *piecep );
    05385
    05386 Comments
    05387 When an execute/fetch call returns OCI_NEED_DATA to get/return a
    05388 dynamic bind/define value or piece, OCIStmtGetPieceInfo() returns the
    05389 relevant information: bind/define handle, iteration or index number and
    05390 which piece.
    05391 See the section "Runtime Data Allocation and Piecewise Operations" on page
    05392 5-16 for more information about using OCIStmtGetPieceInfo().
    05393 Parameters
    05394 stmtp (IN) - the statement when executed returned OCI_NEED_DATA.
    05395 errhp (OUT) - an error handle which can be passed to OCIErrorGet() for
    05396 diagnostic information in the event of an error.
    05397 hndlpp (OUT) - returns a pointer to the bind or define handle of the bind or
    05398 define whose runtime data is required or is being provided.
    05399 typep (OUT) - the type of the handle pointed to by hndlpp: OCI_HTYPE_BIND
    05400 (for a bind handle) or OCI_HTYPE_DEFINE (for a define handle).
    05401 in_outp (OUT) - returns OCI_PARAM_IN if the data is required for an IN bind
    05402 value. Returns OCI_PARAM_OUT if the data is available as an OUT bind
    05403 variable or a define position value.
    05404 iterp (OUT) - returns the row number of a multiple row operation.
    05405 idxp (OUT) - the index of an array element of a PL/SQL array bind operation.
    05406 piecep (OUT) - returns one of the following defined values -
    05407 OCI_ONE_PIECE, OCI_FIRST_PIECE, OCI_NEXT_PIECE and
    05408 OCI_LAST_PIECE. The default value is always OCI_ONE_PIECE.
    05409 Related Functions
    05410 OCIAttrGet(), OCIAttrGet(), OCIStmtExecute(), OCIStmtFetch(),
    05411 OCIStmtSetPieceInfo()
    05412
    05413
    05414
    05415
    05416 OCIStmtPrepare()
    05417 Name
    05418 OCI Statement REQuest
    05419 Purpose
    05420 This call defines the SQL/PLSQL statement to be executed.
    05421 Syntax
    05422 sword OCIStmtPrepare ( OCIStmt      *stmtp,
    05423                      OCIError     *errhp,
    05424                      CONST OraText   *stmt,
    05425                      ub4          stmt_len,
    05426                      ub4          language,
    05427                      ub4          mode);
    05428 Comments
    05429 This call is used to prepare a SQL or PL/SQL statement for execution. The
    05430 OCIStmtPrepare() call defines an application request.
    05431 This is a purely local call. Data values for this statement initialized in
    05432 subsequent bind calls will be stored in a bind handle which will hang off this
    05433 statement handle.
    05434 This call does not create an association between this statement handle and any
    05435 particular server.
    05436 See the section "Preparing Statements" on page 2-21 for more information
    05437 about using this call.
    05438 Parameters
    05439 stmtp (IN) - a statement handle.
    05440 errhp (IN) - an error handle to retrieve diagnostic information.
    05441 stmt (IN) - SQL or PL/SQL statement to be executed. Must be a null-
    05442 terminated string. The pointer to the text of the statement must be available
    05443 as long as the statement is executed.
    05444 stmt_len (IN) - length of the statement. Must not be zero.
    05445 language (IN) - V7, V8, or native syntax. Possible values are:
    05446 OCI_V7_SYNTAX - V7 ORACLE parsing syntax
    05447 OCI_V8_SYNTAX - V8 ORACLE parsing syntax
    05448 OCI_NTV_SYNTAX - syntax depending upon the version of the server.
    05449 mode (IN) - the only defined mode is OCI_DEFAULT for default mode.
    05450 Example
    05451 This example demonstrates the use of OCIStmtPrepare(), as well as the OCI
    05452 application initialization calls.
    05453 Related Functions
    05454 OCIAttrGet(), OCIStmtExecute()
    05455
    05456
    05457 OCIStmtPrepare2()
    05458 Name
    05459 OCI Statement REQuest with (a) early binding to svchp and/or
    05460 (b) stmt caching
    05461 Purpose
    05462 This call defines the SQL/PLSQL statement to be executed.
    05463 Syntax
    05464 sword OCIStmtPrepare2 ( OCISvcCtx *svchp,
    05465                      OCIStmt      **stmtp,
    05466                      OCIError     *errhp,
    05467                      CONST OraText   *stmt,
    05468                      ub4          stmt_len,
    05469                      CONST OraText *key,
    05470                      ub4          key_len,
    05471                      ub4          language,
    05472                      ub4          mode);
    05473 Comments
    05474 This call is used to prepare a SQL or PL/SQL statement for execution. The
    05475 OCIStmtPrepare() call defines an application request.
    05476 This is a purely local call. Data values for this statement initialized in
    05477 subsequent bind calls will be stored in a bind handle which will hang off this
    05478 statement handle.
    05479 This call creates an association between the statement handle and a service
    05480 context. It differs from OCIStmtPrepare in that respect. It also supports
    05481 stmt caching. The stmt will automatically be cached if the authp of the stmt
    05482 has enabled stmt caching.
    05483 Parameters
    05484 svchp (IN) - the service context handle that contains the session that
    05485              this stmt handle belongs to.
    05486 stmtp (OUT) - an unallocated stmt handle must be pased in. An allocated
    05487               and prepared  statement handle will be returned.
    05488 errhp (IN) - an error handle to retrieve diagnostic information.
    05489 stmt (IN) - SQL or PL/SQL statement to be executed. Must be a null-
    05490             terminated string. The pointer to the OraText of the statement
    05491             must be available as long as the statement is executed.
    05492 stmt_len (IN) - length of the statement. Must not be zero.
    05493 key (IN) - This is only Valid for OCI Stmt Caching. It indicates the
    05494            key to search with. It thus optimizes the search in the cache.
    05495 key_len (IN) - the length of the key. This, too, is onlly valid for stmt
    05496                caching.
    05497 language (IN) - V7, V8, or native syntax. Possible values are:
    05498 OCI_V7_SYNTAX - V7 ORACLE parsing syntax
    05499 OCI_V8_SYNTAX - V8 ORACLE parsing syntax
    05500 OCI_NTV_SYNTAX - syntax depending upon the version of the server.
    05501 mode (IN) - the defined modes are OCI_DEFAULT and OCI_PREP2_CACHE_SEARCHONLY.
    05502 Example
    05503 Related Functions
    05504 OCIStmtExecute(), OCIStmtRelease()
    05505
    05506
    05507 OCIStmtRelease()
    05508 Name
    05509 OCI Statement Release. This call is used to relesae the stmt that
    05510 was retreived using OCIStmtPrepare2(). If the stmt is release
    05511 using this call, OCIHandleFree() must not be called on the stmt
    05512 handle.
    05513 Purpose
    05514 This call releases the statement obtained by OCIStmtPrepare2
    05515 Syntax
    05516 sword OCIStmtRelease ( OCIStmt      *stmtp,
    05517                      OCIError     *errhp,
    05518                      cONST OraText *key,
    05519                      ub4          key_len,
    05520                      ub4          mode);
    05521 Comments
    05522 This call is used to release a handle obtained via OCIStmtPrepare2().
    05523 It also frees the memory associated with the handle.
    05524 This is a purely local call.
    05525 Parameters
    05526 stmtp (IN/OUT) - The statement handle to be released/freed.
    05527 errhp (IN) - an error handle to retrieve diagnostic information.
    05528 key (IN) - This is only Valid for OCI Stmt Caching. It indicates the
    05529            key to tag the stmt with.
    05530 key_len (IN) - the length of the key. This, too, is only valid for stmt
    05531                caching.
    05532 mode (IN) - the defined modes are OCI_DEFAULT for default mode and
    05533             OCI_STRLS_CACHE_DELETE (only used for Stmt Caching).
    05534 Example
    05535 Related Functions
    05536 OCIStmtExecute(), OCIStmtPrepare2()
    05537
    05538
    05539 OCIStmtSetPieceInfo()
    05540 Name
    05541 OCI Set Piece Information
    05542 Purpose
    05543 Sets piece information for a piecewise operation.
    05544 Syntax
    05545 sword OCIStmtSetPieceInfo ( dvoid             *hndlp,
    05546                           ub4               type,
    05547                           OCIError          *errhp,
    05548                           CONST dvoid       *bufp,
    05549                           ub4               *alenp,
    05550                           ub1               piece,
    05551                           CONST dvoid       *indp,
    05552                           ub2               *rcodep );
    05553 Comments
    05554 When an execute call returns OCI_NEED_DATA to get a dynamic IN/OUT
    05555 bind value or piece, OCIStmtSetPieceInfo() sets the piece information: the
    05556 buffer, the length, the indicator and which piece is currently being processed.
    05557 For more information about using OCIStmtSetPieceInfo() see the section
    05558 "Runtime Data Allocation and Piecewise Operations" on page 5-16.
    05559 Parameters
    05560 hndlp (IN/OUT) - the bind/define handle.
    05561 type (IN) - type of the handle.
    05562 errhp (OUT) - an error handle which can be passed to OCIErrorGet() for
    05563 diagnostic information in the event of an error.
    05564 bufp (IN/OUT) - bufp is a pointer to a storage containing the data value or
    05565 the piece when it is an IN bind variable, otherwise bufp is a pointer to
    05566 storage for getting a piece or a value for OUT binds and define variables. For
    05567 named data types or REFs, a pointer to the object or REF is returned.
    05568 alenp (IN/OUT) - the length of the piece or the value.
    05569 piece (IN) - the piece parameter. The following are valid values:
    05570 OCI_ONE_PIECE, OCI_FIRST_PIECE, OCI_NEXT_PIECE, or
    05571 OCI_LAST_PIECE.
    05572 The default value is OCI_ONE_PIECE. This parameter is used for IN bind
    05573 variables only.
    05574 indp (IN/OUT) - indicator. A pointer to a sb2 value or pointer to an indicator
    05575 structure for named data types (SQLT_NTY) and REFs (SQLT_REF), i.e., *indp
    05576 is either an sb2 or a dvoid * depending upon the data type.
    05577 rcodep (IN/OUT) - return code.
    05578 Related Functions
    05579 OCIAttrGet(), OCIAttrGet(), OCIStmtExecute(), OCIStmtFetch(),
    05580 OCIStmtGetPieceInfo()
    05581
    05582
    05583 OCIFormatInit
    05584 Name
    05585 OCIFormat Package Initialize
    05586 Purpose
    05587 Initializes the OCIFormat package.
    05588 Syntax
    05589 sword OCIFormatInit(dvoid *hndl, OCIError *err);
    05590 Comments
    05591 This routine must be called before calling any other OCIFormat routine.
    05592 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    05593 Parameters
    05594 hndl (IN/OUT) - OCI environment or session handle
    05595 err (IN/OUT) - OCI error handle
    05596 Related Functions
    05597 OCIFormatTerm()
    05598
    05599
    05600 OCIFormatString
    05601 Name
    05602 OCIFormat Package Format String
    05603 Purpose
    05604 Writes a text string into the supplied text buffer using the argument
    05605 list submitted to it and in accordance with the format string given.
    05606 Syntax
    05607 sword OCIFormatString(dvoid *hndl, OCIError *err, text *buffer,
    05608                       sbig_ora bufferLength, sbig_ora *returnLength,
    05609                       CONST OraText *formatString, ...);
    05610 Comments
    05611 The first call to this routine must be preceded by a call to the
    05612 OCIFormatInit routine that initializes the OCIFormat package
    05613 for use.  When this routine is no longer needed then terminate
    05614 the OCIFormat package by a call to the OCIFormatTerm routine.
    05615 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    05616 Parameters
    05617 hndl         (IN/OUT) - OCI environment or session handle
    05618 err          (IN/OUT) - OCI error handle
    05619 buffer       (OUT)    - text buffer for the string
    05620 bufferLength (IN)     - length of the text buffer
    05621 returnLength (OUT)    - length of the formatted string
    05622 formatString (IN)     - format specification string
    05623 ...          (IN)     - variable argument list
    05624 Related Functions
    05625
    05626
    05627 OCIFormatTerm
    05628 Name
    05629 OCIFormat Package Terminate
    05630 Purpose
    05631 Terminates the OCIFormat package.
    05632 Syntax
    05633 sword OCIFormatTerm(dvoid *hndl, OCIError *err);
    05634 Comments
    05635 It must be called after the OCIFormat package is no longer being used.
    05636 Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    05637 Parameters
    05638 hndl (IN/OUT) - OCI environment or session handle
    05639 err (IN/OUT) - OCI error handle
    05640 Related Functions
    05641 OCIFormatInit()
    05642
    05643
    05644 OCIFormatTUb1
    05645 Name
    05646 OCIFormat Package ub1 Type
    05647 Purpose
    05648 Return the type value for the ub1 type.
    05649 Syntax
    05650 sword OCIFormatTUb1(void);
    05651 Comments
    05652 None
    05653 Parameters
    05654 None
    05655 Related Functions
    05656 None
    05657
    05658
    05659 OCIFormatTUb2
    05660 Name
    05661 OCIFormat Package ub2 Type
    05662 Purpose
    05663 Return the type value for the ub2 type.
    05664 Syntax
    05665 sword OCIFormatTUb2(void);
    05666 Comments
    05667 None
    05668 Parameters
    05669 None
    05670 Related Functions
    05671 None
    05672
    05673
    05674 OCIFormatTUb4
    05675 Name
    05676 OCIFormat Package ub4 Type
    05677 Purpose
    05678 Return the type value for the ub4 type.
    05679 Syntax
    05680 sword OCIFormatTUb4(void);
    05681 Comments
    05682 None
    05683 Parameters
    05684 None
    05685 Related Functions
    05686 None
    05687
    05688
    05689 OCIFormatTUword
    05690 Name
    05691 OCIFormat Package uword Type
    05692 Purpose
    05693 Return the type value for the uword type.
    05694 Syntax
    05695 sword OCIFormatTUword(void);
    05696 Comments
    05697 None
    05698 Parameters
    05699 None
    05700 Related Functions
    05701 None
    05702
    05703
    05704 OCIFormatTUbig_ora
    05705 Name
    05706 OCIFormat Package ubig_ora Type
    05707 Purpose
    05708 Return the type value for the ubig_ora type.
    05709 Syntax
    05710 sword OCIFormatTUbig_ora(void);
    05711 Comments
    05712 None
    05713 Parameters
    05714 None
    05715 Related Functions
    05716 None
    05717
    05718
    05719 OCIFormatTSb1
    05720 Name
    05721 OCIFormat Package sb1 Type
    05722 Purpose
    05723 Return the type value for the sb1 type.
    05724 Syntax
    05725 sword OCIFormatTSb1(void);
    05726 Comments
    05727 None
    05728 Parameters
    05729 None
    05730 Related Functions
    05731 None
    05732
    05733
    05734 OCIFormatTSb2
    05735 Name
    05736 OCIFormat Package sb2 Type
    05737 Purpose
    05738 Return the type value for the sb2 type.
    05739 Syntax
    05740 sword OCIFormatTSb2(void);
    05741 Comments
    05742 None
    05743 Parameters
    05744 None
    05745 Related Functions
    05746 None
    05747
    05748
    05749 OCIFormatTSb4
    05750 Name
    05751 OCIFormat Package sb4 Type
    05752 Purpose
    05753 Return the type value for the sb4 type.
    05754 Syntax
    05755 sword OCIFormatTSb4(void);
    05756 Comments
    05757 None
    05758 Parameters
    05759 None
    05760 Related Functions
    05761 None
    05762
    05763
    05764 OCIFormatTSword
    05765 Name
    05766 OCIFormat Package sword Type
    05767 Purpose
    05768 Return the type value for the sword type.
    05769 Syntax
    05770 sword OCIFormatTSword(void);
    05771 Comments
    05772 None
    05773 Parameters
    05774 None
    05775 Related Functions
    05776 None
    05777
    05778
    05779 OCIFormatTSbig_ora
    05780 Name
    05781 OCIFormat Package sbig_ora Type
    05782 Purpose
    05783 Return the type value for the sbig_ora type.
    05784 Syntax
    05785 sword OCIFormatTSbig_ora(void);
    05786 Comments
    05787 None
    05788 Parameters
    05789 None
    05790 Related Functions
    05791 None
    05792
    05793
    05794 OCIFormatTEb1
    05795 Name
    05796 OCIFormat Package eb1 Type
    05797 Purpose
    05798 Return the type value for the eb1 type.
    05799 Syntax
    05800 sword OCIFormatTEb1(void);
    05801 Comments
    05802 None
    05803 Parameters
    05804 None
    05805 Related Functions
    05806 None
    05807
    05808
    05809 OCIFormatTEb2
    05810 Name
    05811 OCIFormat Package eb2 Type
    05812 Purpose
    05813 Return the type value for the eb2 type.
    05814 Syntax
    05815 sword OCIFormatTEb2(void);
    05816 Comments
    05817 None
    05818 Parameters
    05819 None
    05820 Related Functions
    05821 None
    05822
    05823
    05824 OCIFormatTEb4
    05825 Name
    05826 OCIFormat Package eb4 Type
    05827 Purpose
    05828 Return the type value for the eb4 type.
    05829 Syntax
    05830 sword OCIFormatTEb4(void);
    05831 Comments
    05832 None
    05833 Parameters
    05834 None
    05835 Related Functions
    05836 None
    05837
    05838
    05839 OCIFormatTEword
    05840 Name
    05841 OCIFormat Package eword Type
    05842 Purpose
    05843 Return the type value for the eword type.
    05844 Syntax
    05845 sword OCIFormatTEword(void);
    05846 Comments
    05847 None
    05848 Parameters
    05849 None
    05850 Related Functions
    05851 None
    05852
    05853
    05854 OCIFormatTChar
    05855 Name
    05856 OCIFormat Package text Type
    05857 Purpose
    05858 Return the type value for the text type.
    05859 Syntax
    05860 sword OCIFormatTChar(void);
    05861 Comments
    05862 None
    05863 Parameters
    05864 None
    05865 Related Functions
    05866 None
    05867
    05868
    05869 OCIFormatTText
    05870 Name
    05871 OCIFormat Package *text Type
    05872 Purpose
    05873 Return the type value for the *text type.
    05874 Syntax
    05875 sword OCIFormatTText(void);
    05876 Comments
    05877 None
    05878 Parameters
    05879 None
    05880 Related Functions
    05881 None
    05882
    05883
    05884 OCIFormatTDouble
    05885 Name
    05886 OCIFormat Package double Type
    05887 Purpose
    05888 Return the type value for the double type.
    05889 Syntax
    05890 sword OCIFormatTDouble(void);
    05891 Comments
    05892 None
    05893 Parameters
    05894 None
    05895 Related Functions
    05896 None
    05897
    05898
    05899 OCIFormatDvoid
    05900 Name
    05901 OCIFormat Package dvoid Type
    05902 Purpose
    05903 Return the type value for the dvoid type.
    05904 Syntax
    05905 sword OCIFormatTDvoid(void);
    05906 Comments
    05907 None
    05908 Parameters
    05909 None
    05910 Related Functions
    05911 None
    05912
    05913
    05914 OCIFormatTEnd
    05915 Name
    05916 OCIFormat Package end Type
    05917 Purpose
    05918 Return the list terminator's "type".
    05919 Syntax
    05920 sword OCIFormatTEnd(void);
    05921 Comments
    05922 None
    05923 Parameters
    05924 None
    05925 Related Functions
    05926 None
    05927
    05928
    05929 OCISvcCtxToLda()
    05930 Name
    05931 OCI toggle SerVice context handle to Version 7 Lda_Def
    05932 Purpose
    05933 Toggles between a V8 service context handle and a V7 Lda_Def.
    05934 Syntax
    05935 sword OCISvcCtxToLda ( OCISvcCtx    *srvhp,
    05936                      OCIError     *errhp,
    05937                      Lda_Def      *ldap );
    05938 Comments
    05939 Toggles between an Oracle8 service context handle and an Oracle7 Lda_Def.
    05940 This function can only be called after a service context has been properly
    05941 initialized.
    05942 Once the service context has been translated to an Lda_Def, it can be used in
    05943 release 7.x OCI calls (e.g., obindps(), ofen()).
    05944 Note: If there are multiple service contexts which share the same server
    05945 handle, only one can be in V7 mode at any time.
    05946 The action of this call can be reversed by passing the resulting Lda_Def to
    05947 the OCILdaToSvcCtx() function.
    05948 Parameters
    05949 svchp (IN/OUT) - the service context handle.
    05950 errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for
    05951 diagnostic information in the event of an error.
    05952 ldap (IN/OUT) - a Logon Data Area for V7-style OCI calls which is initialized
    05953 by this call.
    05954 Related Functions
    05955 OCILdaToSvcCtx()
    05956
    05957
    05958
    05959
    05960 OCITransCommit()
    05961 Name
    05962 OCI TX (transaction) CoMmit
    05963 Purpose
    05964 Commits the transaction associated with a specified service context.
    05965 Syntax
    05966 sword OCITransCommit ( OCISvcCtx    *srvcp,
    05967                      OCIError     *errhp,
    05968                      ub4          flags );
    05969 Comments
    05970 The transaction currently associated with the service context is committed. If
    05971 it is a distributed transaction that the server cannot commit, this call
    05972 additionally retrieves the state of the transaction from the database to be
    05973 returned to the user in the error handle.
    05974 If the application has defined multiple transactions, this function operates
    05975 on the transaction currently associated with the service context. If the
    05976 application is working with only the implicit local transaction created when
    05977 database changes are made, that implicit transaction is committed.
    05978 If the application is running in the object mode, then the modified or updated
    05979 objects in the object cache for this transaction are also committed.
    05980 The flags parameter is used for one-phase commit optimization in distributed
    05981 transactions. If the transaction is non-distributed, the flags parameter is
    05982 ignored, and OCI_DEFAULT can be passed as its value. OCI applications
    05983 managing global transactions should pass a value of
    05984 OCI_TRANS_TWOPHASE to the flags parameter for a two-phase commit. The
    05985 default is one-phase commit.
    05986 Under normal circumstances, OCITransCommit() returns with a status
    05987 indicating that the transaction has either been committed or rolled back. With
    05988 distributed transactions, it is possible that the transaction is now in-doubt
    05989 (i.e., neither committed nor aborted). In this case, OCITransCommit()
    05990 attempts to retrieve the status of the transaction from the server.
    05991 The status is returned.
    05992 Parameters
    05993 srvcp (IN) - the service context handle.
    05994 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    05995 diagnostic information in the event of an error.
    05996 flags -see the "Comments" section above.
    05997 Related Functions
    05998 OCITransRollback()
    05999
    06000
    06001
    06002
    06003 OCITransDetach()
    06004 Name
    06005 OCI TX (transaction) DeTach
    06006 Purpose
    06007 Detaches a transaction.
    06008 Syntax
    06009 sword OCITransDetach ( OCISvcCtx    *srvcp,
    06010                      OCIError     *errhp,
    06011                      ub4          flags);
    06012 Comments
    06013 Detaches a global transaction from the service context handle. The transaction
    06014 currently attached to the service context handle becomes inactive at the end
    06015 of this call. The transaction may be resumed later by calling OCITransStart(),
    06016 specifying  a flags value of OCI_TRANS_RESUME.
    06017 When a transaction is detached, the value which was specified in the timeout
    06018 parameter of OCITransStart() when the transaction was started is used to
    06019 determine the amount of time the branch can remain inactive before being
    06020 deleted by the server's PMON process.
    06021 Note: The transaction can be resumed by a different process than the one
    06022 that detached it, provided that the transaction has the same
    06023 authorization.
    06024 Parameters
    06025 srvcp (IN) - the service context handle.
    06026 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    06027 diagnostic information in the event of an error.
    06028 flags (IN) - you must pass a value of OCI_DEFAULT for this parameter.
    06029 Related Functions
    06030 OCITransStart()
    06031
    06032
    06033
    06034 OCITransForget()
    06035 Name
    06036 OCI TX (transaction) ForGeT
    06037 Purpose
    06038 Causes the server to forget a heuristically completed global transaction.
    06039 Syntax
    06040 sword OCITransForget ( OCISvcCtx     *svchp,
    06041                      OCIError      *errhp,
    06042                      ub4           flags);
    06043
    06044 Comments
    06045
    06046 Forgets a heuristically completed global transaction. The server deletes the
    06047 status of the transaction from the system's pending transaction table.
    06048 The XID of the transaction to be forgotten is set as an attribute of the
    06049 transaction handle (OCI_ATTR_XID).
    06050 Parameters
    06051 srvcp (IN) - the service context handle - the transaction is rolled back.
    06052 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    06053 diagnostic information in the event of an error.
    06054 flags (IN) - you must pass OCI_DEFAULT for this parameter.
    06055 Related Functions
    06056 OCITransCommit(), OCITransRollback()
    06057
    06058
    06059
    06060 OCITransMultiPrepare()
    06061 Name
    06062 OCI Trans(action) Multi-Branch Prepare
    06063 Purpose
    06064 Prepares a transaction with multiple branches in a single call.
    06065 Syntax
    06066 sword OCITransMultiPrepare ( OCISvcCtx    *svchp,
    06067                              ub4           numBranches,
    06068                              OCITrans     **txns,
    06069                              OCIError     **errhp);
    06070
    06071 Comments
    06072
    06073 Prepares the specified global transaction for commit.
    06074 This call is valid only for distributed transactions.
    06075 This call is an advanced performance feature intended for use only in
    06076 situations where the caller is responsible for preparing all the branches
    06077 in a transaction.
    06078 Parameters
    06079 srvcp (IN) - the service context handle.
    06080 numBranches (IN) - This is the number of branches expected. It is also the
    06081 array size for the next two parameters.
    06082 txns (IN) - This is the array of transaction handles for the branches to
    06083 prepare. They should all have the OCI_ATTR_XID set. The global transaction
    06084 ID should be the same.
    06085 errhp (IN) - This is the array of error handles. If OCI_SUCCESS is not
    06086 returned, then these will indicate which branches received which errors.
    06087 Related Functions
    06088 OCITransPrepare()
    06089
    06090
    06091 OCITransPrepare()
    06092 Name
    06093 OCI TX (transaction) PREpare
    06094 Purpose
    06095 Prepares a transaction for commit.
    06096 Syntax
    06097 sword OCITransPrepare ( OCISvcCtx    *svchp,
    06098                       OCIError     *errhp,
    06099                       ub4          flags);
    06100
    06101 Comments
    06102
    06103 Prepares the specified global transaction for commit.
    06104 This call is valid only for distributed transactions.
    06105 The call returns OCI_SUCCESS_WITH_INFO if the transaction has not made
    06106 any changes. The error handle will indicate that the transaction is read-only.
    06107 The flag parameter is not currently used.
    06108 Parameters
    06109 srvcp (IN) - the service context handle.
    06110 errhp (IN) - an error handle which can be passed to OCIErrorGet() for
    06111 diagnostic information in the event of an error.
    06112 flags (IN) - you must pass OCI_DEFAULT for this parameter.
    06113 Related Functions
    06114 OCITransCommit(), OCITransForget()
    06115
    06116
    06117
    06118
    06119 OCITransRollback()
    06120 Name
    06121 OCI TX (transaction) RoLlback
    06122 Purpose
    06123 Rolls back the current transaction.
    06124 Syntax
    06125 sword OCITransRollback ( dvoid        *svchp,
    06126                        OCIError     *errhp,
    06127                        ub4          flags );
    06128 Comments
    06129 The current transaction- defined as the set of statements executed since the
    06130 last OCITransCommit() or since OCISessionBegin()-is rolled back.
    06131 If the application is running under object mode then the modified or updated
    06132 objects in the object cache for this transaction are also rolled back.
    06133 An error is returned if an attempt is made to roll back a global transaction
    06134 that is not currently active.
    06135 Parameters
    06136 svchp (IN) - a service context handle. The transaction currently set in the
    06137 service context handle is rolled back.
    06138 errhp -(IN) - an error handle which can be passed to OCIErrorGet() for
    06139 diagnostic information in the event of an error.
    06140 flags - you must pass a value of OCI_DEFAULT for this parameter.
    06141 Related Functions
    06142 OCITransCommit()
    06143
    06144
    06145
    06146
    06147 OCITransStart()
    06148 Name
    06149 OCI TX (transaction) STart
    06150 Purpose
    06151 Sets the beginning of a transaction.
    06152 Syntax
    06153 sword OCITransStart ( OCISvcCtx    *svchp,
    06154                     OCIError     *errhp,
    06155                     uword        timeout,
    06156                     ub4          flags);
    06157
    06158 Comments
    06159 This function sets the beginning of a global or serializable transaction. The
    06160 transaction context currently associated with the service context handle is
    06161 initialized at the end of the call if the flags parameter specifies that a new
    06162 transaction should be started.
    06163 The XID of the transaction is set as an attribute of the transaction handle
    06164 (OCI_ATTR_XID)
    06165 Parameters
    06166 svchp (IN/OUT) - the service context handle. The transaction context in the
    06167 service context handle is initialized at the end of the call if the flag
    06168 specified a new transaction to be started.
    06169 errhp (IN/OUT) - The OCI error handle. If there is an error, it is recorded in
    06170 err and this function returns OCI_ERROR. Diagnostic information can be
    06171 obtained by calling OCIErrorGet().
    06172 timeout (IN) - the time, in seconds, to wait for a transaction to become
    06173 available for resumption when OCI_TRANS_RESUME is specified. When
    06174 OCI_TRANS_NEW is specified, this value is stored and may be used later by
    06175 OCITransDetach().
    06176 flags (IN) - specifies whether a new transaction is being started or an
    06177 existing transaction is being resumed. Also specifies serializiability or
    06178 read-only status. More than a single value can be specified. By default,
    06179 a read/write transaction is started. The flag values are:
    06180 OCI_TRANS_NEW - starts a new transaction branch. By default starts a
    06181 tightly coupled and migratable branch.
    06182 OCI_TRANS_TIGHT - explicitly specifies a tightly coupled branch
    06183 OCI_TRANS_LOOSE - specifies a loosely coupled branch
    06184 OCI_TRANS_RESUME - resumes an existing transaction branch.
    06185 OCI_TRANS_READONLY - start a readonly transaction
    06186 OCI_TRANS_SERIALIZABLE - start a serializable transaction
    06187 Related Functions
    06188 OCITransDetach()
    06189
    06190
    06191 ******************************************************************************/
    06192
    06193 /*****************************************************************************
    06194                          ACTUAL PROTOTYPE DECLARATIONS
    06195 ******************************************************************************/
    06196 /*-----------------------Dynamic Callback Function Pointers------------------*/
    06197 typedef sb4 (*OCICallbackInBind)(/*_ dvoid *ictxp, OCIBind *bindp, ub4 iter,
    06198                                    ub4 index, dvoid **bufpp, ub4 *alenp,
    06199                                    ub1 *piecep, dvoid **indp _*/);
    06200
    06201 typedef sb4 (*OCICallbackOutBind)(/*_ dvoid *octxp, OCIBind *bindp, ub4 iter,
    06202                                     ub4 index, dvoid **bufpp, ub4 **alenp,
    06203                                     ub1 *piecep, dvoid **indp,
    06204                                     ub2 **rcodep _*/);
    06205
    06206 typedef sb4 (*OCICallbackDefine)(/*_ dvoid *octxp, OCIDefine *defnp, ub4 iter,
    06207                                    dvoid **bufpp, ub4 **alenp, ub1 *piecep,
    06208                                    dvoid **indp, ub2 **rcodep _*/);
    06209
    06210 typedef sword (*OCIUserCallback)(/*_ dvoid *ctxp, dvoid *hndlp, ub4 type,
    06211                                      ub4 fcode, ub4 when, sword returnCode,
    06212                                      sb4 *errnop, va_list arglist _*/);
    06213
    06214 typedef sword (*OCIEnvCallbackType)(/*_ OCIEnv *env, ub4 mode,
    06215                                        size_t xtramem_sz, dvoid *usrmemp,
    06216                                        OCIUcb *ucbDesc _*/);
    06217
    06218 typedef sb4 (*OCICallbackLobRead)(/*_ dvoid *ctxp,
    06219                                       CONST dvoid *bufp,
    06220                                       ub4 len,
    06221                                       ub1 piece _*/);
    06222
    06223 /*
    06224  * Called multiple times when the data is being read from the pipe
    06225  * ctxp (IN) - is the context passed in by the user in OCILobRead call
    06226  * bufp (IN) - the buffer containing the read data
    06227  * len  (IN) - the length of the data in the buffer that is relevant
    06228  * piece (IN) - one of the following, OCI_FIRST_PIECE, OCI_NEXT_PIECE
    06229  */
    06230
    06231 typedef sb4 (*OCICallbackLobWrite)(/*_ dvoid *ctxp,
    06232                                        dvoid *bufp,
    06233                                        ub4 *lenp,
    06234                                        ub1 *piece _*/);
    06235
    06236 /*
    06237  * Called multiple times when the data is being written to the pipe
    06238  * ctxp (IN) - is the context passed in by the user in OCILobRead call
    06239  * bufp (IN/OUT) - the buffer into which the data to be written is copied
    06240  * lenp  (OUT) - the length of the data in the buffer that is relevant
    06241  * piece (OUT) - one of the following, OCI_NEXT_PIECE or OCI_LAST_PIECE
    06242  */
    06243
    06244 /*--------------------------Failover Callback Structure ---------------------*/
    06245 typedef sb4 (*OCICallbackFailover)(/*_ dvoid *svcctx, dvoid *envctx,
    06246                                        dvoid *fo_ctx, ub4 fo_type,
    06247                                        ub4 fo_event _*/);
    06248 /* Called at failover time if client has registered it. */
    06249 typedef struct
    06250 {
    06251   OCICallbackFailover callback_function;
    06252   dvoid *fo_ctx;
    06253 }
    06254 OCIFocbkStruct;
    06255
    06256
    06257
    06258 sword   OCIInitialize(/*_ ub4 mode, dvoid *ctxp,
    06259                           dvoid *(*malocfp)(dvoid *ctxp, size_t size),
    06260                           dvoid *(*ralocfp)(dvoid *ctxp, dvoid *memptr,
    06261                                             size_t newsize),
    06262                           void (*mfreefp)(dvoid *ctxp, dvoid *memptr) _*/);
    06263
    06264 sword   OCITerminate(ub4 mode);
    06265
    06266 sword   OCIEnvCreate (/*_ OCIEnv **envp, ub4 mode, dvoid *ctxp,
    06267                  dvoid *(*malocfp)(dvoid *ctxp, size_t size),
    06268                  dvoid *(*ralocfp)(dvoid *ctxp, dvoid *memptr, size_t newsize),
    06269                  void   (*mfreefp)(dvoid *ctxp, dvoid *memptr),
    06270                  size_t xtramem_sz, dvoid **usrmempp _*/);
    06271
    06272 sword   OCIEnvNlsCreate (/*_ OCIEnv **envp, ub4 mode, dvoid *ctxp,
    06273                  dvoid *(*malocfp)(dvoid *ctxp, size_t size),
    06274                  dvoid *(*ralocfp)(dvoid *ctxp, dvoid *memptr, size_t newsize),
    06275                  void   (*mfreefp)(dvoid *ctxp, dvoid *memptr),
    06276                  size_t xtramem_sz, dvoid **usrmempp,
    06277                  ub2 charset, ub2 ncharset _*/);
    06278
    06279 sword   OCIFEnvCreate (/*_ OCIEnv **envp, ub4 mode, dvoid *ctxp,
    06280                  dvoid *(*malocfp)(dvoid *ctxp, size_t size),
    06281                  dvoid *(*ralocfp)(dvoid *ctxp, dvoid *memptr, size_t newsize),
    06282                  void   (*mfreefp)(dvoid *ctxp, dvoid *memptr),
    06283                  size_t xtramem_sz, dvoid **usrmempp, dvoid *fupg _*/);
    06284
    06285 sword   OCIHandleAlloc(/*_ CONST dvoid *parenth, dvoid **hndlpp,
    06286                            CONST ub4 type, CONST size_t xtramem_sz,
    06287                            dvoid **usrmempp _*/);
    06288
    06289 sword   OCIHandleFree(/*_ dvoid *hndlp, CONST ub4 type _*/);
    06290
    06291 sword   OCIDescriptorAlloc(/*_ CONST dvoid *parenth, dvoid **descpp,
    06292                                CONST ub4 type, CONST size_t xtramem_sz,
    06293                                dvoid **usrmempp _*/);
    06294
    06295 sword   OCIDescriptorFree(/*_ dvoid *descp, CONST ub4 type _*/);
    06296
    06297 sword   OCIEnvInit(/*_ OCIEnv **envp, ub4 mode,
    06298                        size_t xtramem_sz, dvoid **usrmempp _*/);
    06299
    06300 sword   OCIServerAttach(/*_ OCIServer *srvhp, OCIError *errhp,
    06301                             CONST OraText *dblink, sb4 dblink_len,
    06302                             ub4 mode _*/);
    06303
    06304 sword   OCIServerDetach(/*_ OCIServer *srvhp, OCIError *errhp, ub4 mode _*/);
    06305
    06306 sword   OCISessionBegin(/*_ OCISvcCtx *svchp, OCIError *errhp,
    06307                             OCISession *usrhp, ub4 credt, ub4 mode _*/);
    06308
    06309 sword   OCISessionEnd(/*_ OCISvcCtx *svchp, OCIError *errhp,
    06310                           OCISession *usrhp, ub4 mode _*/);
    06311
    06312 sword OCILogon       (/*_ OCIEnv *envhp, OCIError *errhp, OCISvcCtx **svchp,
    06313                                  CONST OraText *username, ub4 uname_len,
    06314                                  CONST OraText *password, ub4 passwd_len,
    06315                                  CONST OraText *dbname, ub4 dbname_len _*/);
    06316
    06317 sword OCILogon2       (/*_ OCIEnv *envhp, OCIError *errhp, OCISvcCtx **svchp,
    06318                         CONST OraText *username, ub4 uname_len,
    06319                         CONST OraText *password, ub4 passwd_len,
    06320                         CONST OraText *dbname, ub4 dbname_len,
    06321                         ub4 mode _*/);
    06322
    06323 sword OCILogoff      (/*_ OCISvcCtx *svchp, OCIError *errhp _*/);
    06324
    06325 sword OCIPasswordChange (/*_ OCISvcCtx *svchp, OCIError *errhp,
    06326                            CONST OraText *user_name, ub4 usernm_len,
    06327                            CONST OraText *opasswd, ub4 opasswd_len,
    06328                            CONST OraText *npasswd, ub4 npasswd_len,
    06329                             ub4 mode _*/);
    06330
    06331 sword   OCIStmtPrepare(/*_ OCIStmt *stmtp, OCIError *errhp, CONST OraText *stmt,
    06332                            ub4 stmt_len, ub4 language, ub4 mode _*/);
    06333
    06334 sword OCIStmtPrepare2 (/*_ OCISvcCtx *svchp, OCIStmt **stmtp, OCIError *errhp,
    06335                      CONST OraText *stmt, ub4 stmt_len, CONST OraText *key,
    06336                      ub4 key_len, ub4 language, ub4 mode _*/);
    06337
    06338 sword OCIStmtRelease (/*_ OCIStmt *stmtp, OCIError *errhp, CONST OraText *key,
    06339                        ub4 key_len, ub4 mode _*/);
    06340
    06341 #if !defined(__STDC__) && !defined(__cplusplus)
    06342 sword OCIBindByPos   (/*_ OCIStmt *stmtp, OCIBind **bindp, OCIError *errhp,
    06343                                  ub4 position, dvoid *valuep, sb4 value_sz,
    06344                                  ub2 dty, dvoid *indp, ub2 *alenp, ub2 *rcodep,
    06345                                  ub4 maxarr_len, ub4 *curelep, ub4 mode _*/);
    06346 #endif /* __STDC__ */
    06347
    06348 #if !defined(__STDC__) && !defined(__cplusplus)
    06349 sword OCIBindByName  (/*_ OCIStmt *stmtp, OCIBind **bindp, OCIError *errhp,
    06350                                  CONST OraText *placeholder, sb4 placeh_len,
    06351                         dvoid *valuep, sb4 value_sz, ub2 dty,
    06352                         dvoid *indp, ub2 *alenp, ub2 *rcodep,
    06353                         ub4 maxarr_len, ub4 *curelep, ub4 mode _*/);
    06354 #endif /* __STDC__ */
    06355
    06356 sword   OCIBindObject(/*_ OCIBind *bindp, OCIError *errhp,
    06357                           CONST OCIType *type, dvoid **pgvpp,
    06358                           ub4 *pvszsp, dvoid **indpp, ub4 *indszp _*/);
    06359
    06360 sword   OCIBindDynamic(/*_ OCIBind *bindp, OCIError *errhp,
    06361                            dvoid *ictxp, OCICallbackInBind icbfp,
    06362                            dvoid *octxp, OCICallbackOutBind ocbfp _*/);
    06363
    06364 sword   OCIBindArrayOfStruct(/*_ OCIBind *bindp, OCIError *errhp, ub4 pvskip,
    06365                                  ub4 indskip, ub4 alskip, ub4 rcskip _*/);
    06366
    06367 sword   OCIStmtGetPieceInfo(/*_ OCIStmt *stmtp, OCIError *errhp,
    06368                                 dvoid **hndlpp, ub4 *typep, ub1 *in_outp,
    06369                                 ub4 *iterp, ub4 *idxp, ub1 *piecep _*/);
    06370
    06371 #if !defined(__STDC__) && !defined(__cplusplus)
    06372 sword   OCIStmtSetPieceInfo(/*_ dvoid *hndlp, ub4 type, OCIError *errhp,
    06373                                 CONST dvoid *bufp, ub4 *alenp, ub1 piece,
    06374                                 CONST dvoid *indp, ub2 *rcodep _*/);
    06375 #endif /* __STDC__ */
    06376
    06377 sword   OCIStmtExecute(/*_ OCISvcCtx *svchp, OCIStmt *stmtp, OCIError *errhp,
    06378                            ub4 iters, ub4 rowoff, CONST OCISnapshot *snap_in,
    06379                            OCISnapshot *snap_out, ub4 mode _*/);
    06380
    06381 #if !defined(__STDC__) && !defined(__cplusplus)
    06382 sword OCIDefineByPos (/*_ OCIStmt *stmtp, OCIDefine **defnp, OCIError *errhp,
    06383                                  ub4 position, dvoid *valuep, sb4 value_sz, ub2 dty,
    06384                                  dvoid *indp, ub2 *rlenp, ub2 *rcodep, ub4 mode _*/);
    06385 #endif /* __STDC__ */
    06386
    06387 sword   OCIDefineObject(/*_ OCIDefine *defnp, OCIError *errhp,
    06388                             CONST OCIType *type, dvoid **pgvpp,
    06389                             ub4 *pvszsp, dvoid **indpp, ub4 *indszp _*/);
    06390
    06391 sword   OCIDefineDynamic(/*_ OCIDefine *defnp, OCIError *errhp,
    06392                              dvoid *octxp, OCICallbackDefine ocbfp _*/);
    06393
    06394 sword   OCIDefineArrayOfStruct(/*_ OCIDefine *defnp, OCIError *errhp,
    06395                                  ub4 pvskip, ub4 indskip, ub4 rlskip,
    06396                                  ub4 rcskip _*/);
    06397
    06398 #if !defined(__STDC__) && !defined(__cplusplus)
    06399 sword   OCIStmtFetch(/*_ OCIStmt *stmtp, OCIError *errhp,
    06400                          ub4 nrows, ub2 orientation, ub4 mode _*/);
    06401 #endif /* __STDC__ */
    06402
    06403 #if !defined(__STDC__) && !defined(__cplusplus)
    06404 sword   OCIStmtFetch2(/*_ OCIStmt *stmtp, OCIError *errhp,
    06405                          ub4 nrows, ub2 orientation, sb4 scrollOffset, ub4 mode _*/);
    06406 #endif /* __STDC__ */
    06407
    06408 sword   OCIStmtGetBindInfo(/*_ OCIStmt *stmtp, OCIError *errhp, ub4 size,
    06409                                ub4 startloc, sb4 *found,
    06410                                OraText *bvnp[], ub1 bvnl[], OraText *invp[],
    06411                                ub1 inpl[], ub1 dupl[], OCIBind *hndl[] _*/);
    06412
    06413 #if !defined(__STDC__) && !defined(__cplusplus)
    06414 sword   OCIDescribeAny(/*_ OCISvcCtx *svchp, OCIError *errhp,
    06415                            dvoid *objptr, ub4 objnm_len, ub1 objptr_typ,
    06416                            ub1 info_level, ub1 objtyp, OCIDescribe *dschp _*/);
    06417 #endif /* __STDC__ */
    06418
    06419 sword   OCIParamGet(/*_ CONST dvoid *hndlp, ub4 htype, OCIError *errhp,
    06420                         dvoid **parmdpp, ub4 pos _*/);
    06421
    06422 sword   OCIParamSet(/*_ dvoid *hdlp, ub4 htyp, OCIError *errhp,
    06423                         CONST dvoid *dscp, ub4 dtyp, ub4 pos _*/);
    06424
    06425 sword   OCITransStart(/*_ OCISvcCtx *svchp, OCIError *errhp,
    06426                           uword timeout, ub4 flags _*/);
    06427
    06428 sword   OCITransDetach(/*_ OCISvcCtx *svchp, OCIError *errhp, ub4 flags _*/);
    06429
    06430 sword   OCITransCommit(/*_ OCISvcCtx *svchp, OCIError *errhp, ub4 flags _*/);
    06431
    06432 sword   OCITransRollback(/*_ OCISvcCtx *svchp, OCIError *errhp, ub4 flags _*/);
    06433
    06434 sword   OCITransPrepare (/*_ OCISvcCtx *svchp, OCIError *errhp, ub4 flags _*/);
    06435
    06436 sword   OCITransMultiPrepare (/*_ OCISvcCtx *svchp, ub4 numBranches,
    06437                                   OCITrans **txns, OCIError **errhp _*/);
    06438
    06439 sword   OCITransForget ( /*_ OCISvcCtx *svchp, OCIError *errhp, ub4 flags _*/);
    06440
    06441 sword   OCIErrorGet   ( /*_ dvoid *hndlp, ub4 recordno, OraText *sqlstate,
    06442                                      sb4 *errcodep, OraText *bufp, ub4 bufsiz,
    06443                                      ub4 type _*/ );
    06444
    06445 sword   OCILobAppend  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06446                             OCILobLocator *dst_locp,
    06447                             OCILobLocator *src_locp _*/ );
    06448
    06449 sword   OCILobAssign  ( /*_ OCIEnv *envhp, OCIError *errhp,
    06450                             CONST OCILobLocator *src_locp,
    06451                             OCILobLocator **dst_locpp _*/ );
    06452
    06453 sword   OCILobCharSetForm  ( /*_ OCIEnv *envhp, OCIError *errhp,
    06454                                  CONST OCILobLocator *locp,
    06455                                  ub1 *csfrm _*/ );
    06456
    06457 sword   OCILobCharSetId ( /*_ OCIEnv *envhp, OCIError *errhp,
    06458                               CONST OCILobLocator *locp, ub2 *csid _*/ );
    06459
    06460 sword   OCILobCopy  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06461                           OCILobLocator *dst_locp,
    06462                                 OCILobLocator *src_locp,
    06463                           ub4 amount, ub4 dst_offset,
    06464                           ub4 src_offset _*/ );
    06465
    06466 #if !defined(__STDC__) && !defined(__cplusplus)
    06467 sword OCILobCreateTemporary(/*_ OCISvcCtx          *svchp,
    06468                             OCIError           *errhp,
    06469                             OCILobLocator      *locp,
    06470                             ub2                 csid,
    06471                             ub1                 csfrm,
    06472                             ub1                 lobtype,
    06473                             boolean             cache,
    06474                             OCIDuration         duration _*/);
    06475 #endif /* __STDC__ */
    06476
    06477 sword OCILobClose( /*_ OCISvcCtx        *svchp,
    06478                        OCIError         *errhp,
    06479                        OCILobLocator    *locp _*/);
    06480
    06481
    06482 sword   OCILobDisableBuffering ( /*_ OCISvcCtx      *svchp,
    06483                                      OCIError       *errhp,
    06484                                      OCILobLocator  *locp _*/ );
    06485
    06486 sword   OCILobEnableBuffering ( /*_ OCISvcCtx      *svchp,
    06487                                     OCIError       *errhp,
    06488                                     OCILobLocator  *locp _*/ );
    06489
    06490 sword   OCILobErase  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06491                            OCILobLocator *locp,
    06492                            ub4 *amount, ub4 offset _*/ );
    06493
    06494 sword   OCILobFileClose  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06495                                OCILobLocator *filep _*/ );
    06496
    06497 sword   OCILobFileCloseAll (/*_ OCISvcCtx *svchp, OCIError *errhp _*/);
    06498
    06499 sword   OCILobFileExists   (/*_ OCISvcCtx *svchp, OCIError *errhp,
    06500                                        OCILobLocator *filep,
    06501                                        boolean *flag _*/);
    06502
    06503 sword   OCILobFileGetName  ( /*_ OCIEnv *envhp, OCIError *errhp,
    06504                                  CONST OCILobLocator *filep,
    06505                                  OraText *dir_alias, ub2 *d_length,
    06506                                  OraText *filename, ub2 *f_length _*/ );
    06507
    06508 sword   OCILobFileIsOpen  (/*_ OCISvcCtx *svchp, OCIError *errhp,
    06509                                OCILobLocator *filep,
    06510                                boolean *flag _*/);
    06511
    06512 #if !defined(__STDC__) && !defined(__cplusplus)
    06513 sword   OCILobFileOpen  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06514                             OCILobLocator *filep, ub1 mode _*/ );
    06515 #endif /* __STDC__ */
    06516
    06517 #if !defined(__STDC__) && !defined(__cplusplus)
    06518 sword   OCILobFileSetName  ( /*_ OCIEnv *envhp, OCIError *errhp,
    06519                                  OCILobLocator **filepp,
    06520                                  CONST OraText *dir_alias, ub2 d_length,
    06521                                  CONST OraText *filename, ub2 f_length _*/ );
    06522 #endif /* __STDC__ */
    06523
    06524 sword   OCILobFlushBuffer ( /*_ OCISvcCtx       *svchp,
    06525                                 OCIError        *errhp,
    06526                                 OCILobLocator   *locp,
    06527                                 ub4              flag _*/ );
    06528
    06529 sword OCILobFreeTemporary(/*_ OCISvcCtx          *svchp,
    06530                               OCIError           *errhp,
    06531                               OCILobLocator      *locp _*/);
    06532
    06533
    06534 sword OCILobGetChunkSize(/*_ OCISvcCtx         *svchp,
    06535                              OCIError          *errhp,
    06536                              OCILobLocator     *locp,
    06537                              ub4               *chunksizep _*/);
    06538
    06539 sword   OCILobGetLength  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06540                                OCILobLocator *locp,
    06541                                      ub4 *lenp _*/ );
    06542
    06543 sword   OCILobIsEqual  ( /*_ OCIEnv *envhp, CONST OCILobLocator *x,
    06544                              CONST OCILobLocator *y, boolean *is_equal _*/ );
    06545
    06546 sword OCILobIsOpen(/*_ OCISvcCtx     *svchp,
    06547                        OCIError      *errhp,
    06548                        OCILobLocator *locp,
    06549                        boolean       *flag _*/);
    06550
    06551 sword OCILobIsTemporary(/*_ OCIEnv            *envp,
    06552                             OCIError          *errhp,
    06553                             OCILobLocator     *locp,
    06554                             boolean           *is_temporary _*/);
    06555
    06556 sword   OCILobLoadFromFile  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06557                                   OCILobLocator *dst_locp,
    06558                                      OCILobLocator *src_filep,
    06559                                   ub4 amount, ub4 dst_offset,
    06560                                   ub4 src_offset _*/ );
    06561
    06562 sword   OCILobLocatorAssign  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06563                             CONST OCILobLocator *src_locp,
    06564                             OCILobLocator **dst_locpp _*/ );
    06565
    06566
    06567 sword   OCILobLocatorIsInit ( /*_ OCIEnv *envhp, OCIError *errhp,
    06568                                 CONST OCILobLocator *locp,
    06569                                 boolean *is_initialized _*/ );
    06570 #if !defined(__STDC__) && !defined(__cplusplus)
    06571 sword   OCILobOpen(/*_ OCISvcCtx        *svchp,
    06572                        OCIError         *errhp,
    06573                        OCILobLocator    *locp,
    06574                        ub1               mode _*/);
    06575 #endif /* __STDC__ */
    06576
    06577 #if !defined(__STDC__) && !defined(__cplusplus)
    06578 sword   OCILobRead  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06579                           OCILobLocator *locp,
    06580                           ub4 *amtp, ub4 offset, dvoid *bufp, ub4 bufl,
    06581                           dvoid *ctxp,
    06582                           sb4 (*cbfp)( dvoid *ctxp,
    06583                                        CONST dvoid *bufp,
    06584                                        ub4 len,
    06585                                        ub1 piece),
    06586                           ub2 csid, ub1 csfrm _*/ );
    06587 #endif /* __STDC__ */
    06588
    06589 sword   OCILobTrim  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06590                           OCILobLocator *locp,
    06591                           ub4 newlen _*/ );
    06592
    06593 #if !defined(__STDC__) && !defined(__cplusplus)
    06594 sword   OCILobWrite  ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06595                          OCILobLocator *locp,
    06596                          ub4 *amtp, ub4 offset, dvoid *bufp, ub4 buflen,
    06597                          ub1 piece, dvoid *ctxp,
    06598                          sb4 (*cbfp)(dvoid *ctxp,
    06599                                      dvoid *bufp,
    06600                                      ub4 *len,
    06601                                      ub1 *piece),
    06602                          ub2 csid, ub1 csfrm _*/ );
    06603 #endif /* __STDC__ */
    06604
    06605 #if !defined(__STDC__) && !defined(__cplusplus)
    06606 sword OCILobWriteAppend(/*_
    06607 OCISvcCtx         *svchp,
    06608 OCIError          *errhp,
    06609 OCILobLocator     *lobp,
    06610 ub4              *amtp,
    06611 dvoid            *bufp,
    06612 ub4               bufl,
    06613 ub1               piece,
    06614 dvoid            *ctxp,
    06615 sb4             (*cbfp)(dvoid  *ctxp,
    06616                         dvoid  *bufp,
    06617                         ub4    *len,
    06618                         ub1    *piece),
    06619 ub2               csid,
    06620 ub1               csfrm _*/);
    06621 #endif /* __STDC__ */
    06622
    06623 sword   OCIBreak ( /*_ dvoid *hndlp, OCIError *errhp _*/ );
    06624
    06625 sword   OCIReset ( /*_ dvoid *hndlp, OCIError *errhp _*/ );
    06626
    06627 #if !defined(__STDC__) && !defined(__cplusplus)
    06628 sword   OCIServerVersion  ( /*_ dvoid *hndlp, OCIError *errhp, OraText *bufp,
    06629                                 ub4 bufsz, ub1 hndltype _*/ );
    06630
    06631 sword   OCIServerRelease  ( /*_ dvoid *hndlp, OCIError *errhp, OraText *bufp,
    06632                                 ub4 bufsz, ub1 hndltype, ub4 *version _*/ );
    06633
    06634 #endif /* __STDC__ */
    06635
    06636 sword   OCIAttrGet ( /*_ CONST dvoid *trgthndlp, ub4 trghndltyp,
    06637                          dvoid *attributep, ub4 *sizep, ub4 attrtype,
    06638                          OCIError *errhp _*/ );
    06639
    06640 sword   OCIAttrSet ( /*_ dvoid *trgthndlp, ub4 trghndltyp, dvoid *attributep,
    06641                          ub4 size, ub4 attrtype, OCIError *errhp _*/ );
    06642
    06643 sword   OCISvcCtxToLda ( /*_ OCISvcCtx *svchp, OCIError *errhp,
    06644                              Lda_Def *ldap _*/ );
    06645
    06646 sword   OCILdaToSvcCtx ( /*_ OCISvcCtx **svchpp, OCIError *errhp,
    06647                              Lda_Def *ldap _*/ );
    06648
    06649 sword   OCIResultSetToStmt ( /*_ OCIResult *rsetdp, OCIError *errhp _*/ );
    06650
    06651
    06652 sword      OCIUserCallbackRegister(/*_ dvoid *hndlp, ub4 type, dvoid *ehndlp,
    06653                                     OCIUserCallback callback, dvoid *ctxp,
    06654                                     ub4 fcode, ub4 when, OCIUcb *ucbDesc _*/);
    06655
    06656 sword      OCIUserCallbackGet(/*_ dvoid *hndlp, ub4 type, dvoid *ehndlp,
    06657                                ub4 fcode, ub4 when, OCIUserCallback *callbackp,
    06658                                dvoid **ctxpp, OCIUcb *ucbDesc _*/);
    06659
    06660 sword   OCISharedLibInit(/*_ dvoid *metaCtx, dvoid *libCtx, ub4 argfmt,
    06661                              sword argc, dvoid *argv[],
    06662                              OCIEnvCallbackType envCallback _*/);
    06663
    06664 sword   OCISecurityInitialize (/*_ OCISecurity *osshandle,
    06665                                  OCIError *error_handle _*/);
    06666
    06667 sword   OCISecurityTerminate (/*_ OCISecurity *osshandle,
    06668                                             OCIError *error_handle _*/);
    06669
    06670 sword OCISecurityOpenWallet(/*_ OCISecurity *osshandle,
    06671                                        OCIError *error_handle,
    06672                                        size_t wrllen,
    06673                                        OraText *wallet_resource_locator,
    06674                                        size_t pwdlen,
    06675                                        OraText *password,
    06676                                        nzttWallet *wallet _*/);
    06677
    06678 sword OCISecurityCloseWallet(/*_ OCISecurity *osshandle,
    06679                                         OCIError *error_handle,
    06680                                         nzttWallet *wallet _*/);
    06681
    06682 sword OCISecurityCreateWallet(/*_ OCISecurity *osshandle,
    06683                                             OCIError *error_handle,
    06684                                             size_t wrllen,
    06685                                             OraText *wallet_resource_locator,
    06686                                             size_t pwdlen,
    06687                                             OraText *password,
    06688                                             nzttWallet *wallet _*/);
    06689
    06690 sword OCISecurityDestroyWallet(/*_ OCISecurity *osshandle,
    06691                                              OCIError *error_handle,
    06692                                              size_t wrllen,
    06693                                              OraText *wallet_resource_locator,
    06694                                              size_t pwdlen,
    06695                                              OraText *password _*/);
    06696
    06697 sword OCISecurityStorePersona(/*_ OCISecurity *osshandle,
    06698                                             OCIError *error_handle,
    06699                                             nzttPersona **persona,
    06700                                             nzttWallet *wallet _*/);
    06701
    06702 sword OCISecurityOpenPersona(/*_ OCISecurity *osshandle,
    06703                                         OCIError *error_handle,
    06704                                         nzttPersona *persona _*/);
    06705
    06706 sword OCISecurityClosePersona(/*_ OCISecurity *osshandle,
    06707                                             OCIError *error_handle,
    06708                                             nzttPersona *persona _*/);
    06709
    06710 sword OCISecurityRemovePersona(/*_ OCISecurity *osshandle,
    06711                                              OCIError *error_handle,
    06712                                              nzttPersona **persona _*/);
    06713
    06714 sword OCISecurityCreatePersona(/*_ OCISecurity *osshandle,
    06715                                              OCIError *error_handle,
    06716                                              nzttIdentType identity_type,
    06717                                              nzttCipherType cipher_type,
    06718                                              nzttPersonaDesc *desc,
    06719                                              nzttPersona **persona _*/);
    06720
    06721 sword OCISecuritySetProtection(/*_ OCISecurity *osshandle,
    06722                                              OCIError *error_handle,
    06723                                              nzttPersona *persona,
    06724                                              nzttcef crypto_engine_function,
    06725                                              nztttdufmt data_unit_format,
    06726                                              nzttProtInfo *protection_info _*/);
    06727
    06728 sword OCISecurityGetProtection(/*_ OCISecurity *osshandle,
    06729                                              OCIError *error_handle,
    06730                                              nzttPersona *persona,
    06731                                              nzttcef crypto_engine_function,
    06732                                              nztttdufmt * data_unit_format_ptr,
    06733                                              nzttProtInfo *protection_info _*/);
    06734
    06735 sword OCISecurityRemoveIdentity(/*_ OCISecurity *osshandle,
    06736                                               OCIError *error_handle,
    06737                                               nzttIdentity **identity_ptr _*/);
    06738
    06739 sword OCISecurityCreateIdentity(/*_ OCISecurity *osshandle,
    06740                                               OCIError *error_handle,
    06741                                               nzttIdentType type,
    06742                                               nzttIdentityDesc *desc,
    06743                                               nzttIdentity **identity_ptr _*/);
    06744
    06745 sword OCISecurityAbortIdentity(/*_ OCISecurity *osshandle,
    06746                                              OCIError *error_handle,
    06747                                              nzttIdentity **identity_ptr _*/);
    06748
    06749 sword OCISecurityFreeIdentity(/*_ OCISecurity *osshandle,
    06750                                               OCIError *error_handle,
    06751                                               nzttIdentity **identity_ptr _*/);
    06752
    06753 sword OCISecurityStoreTrustedIdentity(/*_ OCISecurity *osshandle,
    06754                                                        OCIError *error_handle,
    06755                                                        nzttIdentity **identity_ptr,
    06756                                                        nzttPersona *persona _*/);
    06757
    06758 sword OCISecuritySign(/*_ OCISecurity *osshandle,
    06759                                  OCIError *error_handle,
    06760                                  nzttPersona *persona,
    06761                                  nzttces signature_state,
    06762                                  size_t input_length,
    06763                                  ub1 *input,
    06764                                  nzttBufferBlock *buffer_block _*/);
    06765
    06766 sword OCISecuritySignExpansion(/*_ OCISecurity *osshandle,
    06767                                              OCIError *error_handle,
    06768                                              nzttPersona *persona,
    06769                                              size_t inputlen,
    06770                                              size_t *signature_length _*/);
    06771
    06772 sword OCISecurityVerify(/*_ OCISecurity *osshandle,
    06773                                    OCIError *error_handle,
    06774                                    nzttPersona *persona,
    06775                                    nzttces signature_state,
    06776                                    size_t siglen,
    06777                                    ub1 *signature,
    06778                                    nzttBufferBlock *extracted_message,
    06779                                    boolean *verified,
    06780                                    boolean *validated,
    06781                                    nzttIdentity **signing_party_identity _*/);
    06782
    06783 sword OCISecurityValidate(/*_ OCISecurity *osshandle,
    06784                                      OCIError *error_handle,
    06785                                      nzttPersona *persona,
    06786                                      nzttIdentity *identity,
    06787                                      boolean *validated _*/);
    06788
    06789 sword OCISecuritySignDetached(/*_ OCISecurity *osshandle,
    06790                                             OCIError *error_handle,
    06791                                             nzttPersona *persona,
    06792                                             nzttces signature_state,
    06793                                             size_t input_length,
    06794                                             ub1 * input,
    06795                                             nzttBufferBlock *signature _*/);
    06796
    06797 sword OCISecuritySignDetExpansion(/*_ OCISecurity *osshandle,
    06798                                                 OCIError    *error_handle,
    06799                                                 nzttPersona *persona,
    06800                                                 size_t       input_length,
    06801                                                 size_t *required_buffer_length _*/);
    06802
    06803 sword OCISecurityVerifyDetached(/*_ OCISecurity *osshandle,
    06804                                               OCIError *error_handle,
    06805                                               nzttPersona *persona,
    06806                                               nzttces signature_state,
    06807                                               size_t data_length,
    06808                                               ub1 *data,
    06809                                               size_t siglen,
    06810                                               ub1 *signature,
    06811                                               boolean *verified,
    06812                                               boolean *validated,
    06813                                               nzttIdentity **signing_party_identity _*/);
    06814
    06815 sword OCISecurity_PKEncrypt(/*_ OCISecurity *osshandle,
    06816                                        OCIError *error_handle,
    06817                                        nzttPersona *persona,
    06818                                        size_t number_of_recipients,
    06819                                        nzttIdentity *recipient_list,
    06820                                        nzttces encryption_state,
    06821                                        size_t input_length,
    06822                                        ub1 *input,
    06823                                        nzttBufferBlock *encrypted_data _*/);
    06824
    06825 sword OCISecurityPKEncryptExpansion(/*_ OCISecurity *osshandle,
    06826                                                   OCIError *error_handle,
    06827                                                   nzttPersona *persona,
    06828                                                   size_t number_recipients,
    06829                                                   size_t input_length,
    06830                                                   size_t *buffer_length_required _*/);
    06831
    06832 sword OCISecurityPKDecrypt(/*_ OCISecurity *osshandle,
    06833                                       OCIError *error_handle,
    06834                                       nzttPersona *persona,
    06835                                       nzttces encryption_state,
    06836                                       size_t input_length,
    06837                                       ub1 *input,
    06838                                       nzttBufferBlock *encrypted_data _*/);
    06839
    06840 sword OCISecurityEncrypt(/*_ OCISecurity *osshandle,
    06841                                     OCIError *error_handle,
    06842                                     nzttPersona *persona,
    06843                                     nzttces encryption_state,
    06844                                     size_t input_length,
    06845                                     ub1 *input,
    06846                                     nzttBufferBlock *encrypted_data _*/);
    06847
    06848 sword OCISecurityEncryptExpansion(/*_ OCISecurity *osshandle,
    06849                                                 OCIError *error_handle,
    06850                                                 nzttPersona *persona,
    06851                                                 size_t input_length,
    06852                                                 size_t *encrypted_data_length _*/);
    06853
    06854 sword OCISecurityDecrypt(/*_ OCISecurity *osshandle,
    06855                                     OCIError *error_handle,
    06856                                     nzttPersona *persona,
    06857                                     nzttces decryption_state,
    06858                                     size_t input_length,
    06859                                     ub1 *input,
    06860                                     nzttBufferBlock *decrypted_data _*/);
    06861
    06862 sword OCISecurityEnvelope(/*_ OCISecurity *osshandle,
    06863                                      OCIError *error_handle,
    06864                                      nzttPersona *persona,
    06865                                      size_t number_of_recipients,
    06866                                      nzttIdentity *identity,
    06867                                      nzttces encryption_state,
    06868                                      size_t input_length,
    06869                                      ub1 *input,
    06870                                      nzttBufferBlock *enveloped_data _*/);
    06871
    06872 sword OCISecurityDeEnvelope(/*_ OCISecurity *osshandle,
    06873                                 OCIError *error_handle,
    06874                                 nzttPersona *persona,
    06875                                 nzttces decryption_state,
    06876                                 size_t input_length,
    06877                                 ub1 *input,
    06878                                 nzttBufferBlock *output_message,
    06879                                 boolean *verified,
    06880                                 boolean *validated,
    06881                                 nzttIdentity **sender_identity _*/);
    06882
    06883 sword OCISecurityKeyedHash(/*_ OCISecurity *osshandle,
    06884                                       OCIError *error_handle,
    06885                                       nzttPersona *persona,
    06886                                       nzttces hash_state,
    06887                                       size_t input_length,
    06888                                       ub1 *input,
    06889                                       nzttBufferBlock *keyed_hash _*/);
    06890
    06891 sword OCISecurityKeyedHashExpansion(/*_ OCISecurity *osshandle,
    06892                                                   OCIError *error_handle,
    06893                                                   nzttPersona *persona,
    06894                                                   size_t input_length,
    06895                                                   size_t *required_buffer_length _*/);
    06896
    06897 sword OCISecurityHash(/*_ OCISecurity *osshandle,
    06898                                  OCIError *error_handle,
    06899                                  nzttPersona *persona,
    06900                                  nzttces hash_state,
    06901                                  size_t input,
    06902                                  ub1 *input_length,
    06903                                  nzttBufferBlock *hash _*/);
    06904
    06905 sword OCISecurityHashExpansion(/*_ OCISecurity *osshandle,
    06906                                              OCIError *error_handle,
    06907                                              nzttPersona *persona,
    06908                                              size_t input_length,
    06909                                              size_t *required_buffer_length _*/);
    06910
    06911 sword OCISecuritySeedRandom(/*_ OCISecurity *osshandle,
    06912                                        OCIError *error_handle,
    06913                                        nzttPersona *persona,
    06914                                        size_t seed_length,
    06915                                        ub1 *seed _*/);
    06916
    06917 sword OCISecurityRandomBytes(/*_ OCISecurity *osshandle,
    06918                                         OCIError *error_handle,
    06919                                         nzttPersona *persona,
    06920                                         size_t number_of_bytes_desired,
    06921                                         nzttBufferBlock *random_bytes _*/);
    06922
    06923 sword OCISecurityRandomNumber(/*_ OCISecurity *osshandle,
    06924                                             OCIError *error_handle,
    06925                                             nzttPersona *persona,
    06926                                             uword *random_number_ptr _*/);
    06927
    06928 sword OCISecurityInitBlock(/*_ OCISecurity *osshandle,
    06929                                       OCIError *error_handle,
    06930                                       nzttBufferBlock *buffer_block _*/);
    06931
    06932 sword OCISecurityReuseBlock(/*_ OCISecurity *osshandle,
    06933                                        OCIError *error_handle,
    06934                                        nzttBufferBlock *buffer_block _*/);
    06935
    06936 sword OCISecurityPurgeBlock(/*_ OCISecurity *osshandle,
    06937                                        OCIError *error_handle,
    06938                                        nzttBufferBlock *buffer_block _*/);
    06939
    06940 sword OCISecuritySetBlock(/*_ OCISecurity *osshandle,
    06941                                      OCIError *error_handle,
    06942                                      uword flags_to_set,
    06943                                      size_t buffer_length,
    06944                                      size_t used_buffer_length,
    06945                                      ub1 *buffer,
    06946                                      nzttBufferBlock *buffer_block _*/);
    06947
    06948 sword OCISecurityGetIdentity(/*_ OCISecurity  *osshandle,
    06949                                         OCIError       *error_handle,
    06950                                         size_t          namelen,
    06951                                         OraText           *distinguished_name,
    06952                                         nzttIdentity  **identity _*/);
    06953
    06954 sword OCIAQEnq(/*_ OCISvcCtx *svchp, OCIError *errhp, OraText *queue_name,
    06955                      OCIAQEnqOptions *enqopt, OCIAQMsgProperties *msgprop,
    06956                      OCIType *payload_tdo,dvoid **payload, dvoid **payload_ind,
    06957                            OCIRaw **msgid, ub4 flags _*/);
    06958
    06959 sword OCIAQDeq(/*_ OCISvcCtx *svchp, OCIError *errhp, OraText *queue_name,
    06960                            OCIAQDeqOptions *deqopt, OCIAQMsgProperties *msgprop,
    06961                      OCIType *payload_tdo,dvoid **payload, dvoid **payload_ind,
    06962                            OCIRaw **msgid, ub4 flags _*/);
    06963
    06964 sword OCIAQListen(/*_ OCISvcCtx *svchp, OCIError *errhp,
    06965                             OCIAQAgent **agent_list, ub4 num_agents,
    06966                             sb4 wait, OCIAQAgent **agent,
    06967                             ub4 flags _*/);
    06968
    06969 sword OCIExtractInit(/*_ dvoid *hndl, OCIError *err _*/);
    06970
    06971 sword OCIExtractTerm(/*_ dvoid *hndl, OCIError *err _*/);
    06972
    06973 sword OCIExtractReset(/*_ dvoid *hndl, OCIError *err _*/);
    06974
    06975 sword OCIExtractSetNumKeys(/*_ dvoid *hndl, OCIError *err, uword numkeys _*/);
    06976
    06977 sword OCIExtractSetKey(/*_ dvoid *hndl, OCIError *err, CONST OraText *name,
    06978                            ub1 type, ub4 flag, CONST dvoid *defval,
    06979                            CONST sb4 *intrange,
    06980                            CONST OraText *CONST *strlist _*/);
    06981
    06982 sword OCIExtractFromFile(/*_ dvoid *hndl, OCIError *err, ub4 flag,
    06983                              OraText *filename _*/);
    06984
    06985 sword OCIExtractFromStr(/*_ dvoid *hndl, OCIError *err, ub4 flag,
    06986                                OraText *input _*/);
    06987
    06988 sword OCIExtractToInt(/*_ dvoid *hndl, OCIError *err, OraText *keyname,
    06989                           uword valno, sb4 *retval _*/);
    06990
    06991 sword OCIExtractToBool(/*_ dvoid *hndl, OCIError *err, OraText *keyname,
    06992                            uword valno, ub1 *retval _*/);
    06993
    06994 sword OCIExtractToStr(/*_ dvoid *hndl, OCIError *err, OraText *keyname,
    06995                           uword valno, OraText *retval, uword buflen _*/);
    06996
    06997 sword OCIExtractToOCINum(/*_ dvoid *hndl, OCIError *err, OraText *keyname,
    06998                              uword valno, OCINumber *retval _*/);
    06999
    07000 sword OCIExtractToList(/*_ dvoid *hndl, OCIError *err, uword *numkeys _*/);
    07001
    07002 sword OCIExtractFromList(/*_ dvoid *hndl, OCIError *err, uword index,
    07003                              OraText **name, ub1 *type, uword *numvals,
    07004                              dvoid ***values _*/);
    07005
    07006 /* Memory Related Service Interfaces */
    07007
    07008 sword OCIMemoryAlloc(/*_ dvoid *hdl, OCIError *err, dvoid **mem,
    07009                       OCIDuration dur, ub4 size, ub4 flags _*/);
    07010
    07011 sword OCIMemoryResize(/*_ dvoid *hdl, OCIError *err, dvoid **mem,
    07012                         ub4 newsize, ub4 flags _*/);
    07013
    07014 sword OCIMemoryFree(/*_ dvoid *hdl, OCIError *err, dvoid *mem _*/);
    07015
    07016 sword OCIContextSetValue(/*_ dvoid *hdl, OCIError *err, OCIDuration duration,
    07017                         ub1 *key, ub1 keylen, dvoid *ctx_value _*/);
    07018
    07019 sword OCIContextGetValue(/*_ dvoid *hdl, OCIError *err, ub1 *key,
    07020                         ub1 keylen, dvoid **ctx_value _*/);
    07021
    07022 sword OCIContextClearValue(/*_ dvoid *hdl, OCIError *err, ub1 *key,
    07023                         ub1 keylen _*/);
    07024
    07025 sword OCIContextGenerateKey(/*_ dvoid *hdl, OCIError *err, ub4 *key _*/);
    07026
    07027 sword OCIMemorySetCurrentIDs(/*_ dvoid *hdl, OCIError *err,
    07028         ub4 curr_session_id, ub4 curr_trans_id, ub4 curr_stmt_id _*/);
    07029
    07030 sword OCIPicklerTdsCtxInit(/*_ OCIEnv *env, OCIError *err,
    07031                                  OCIPicklerTdsCtx **tdsc _*/);
    07032
    07033 sword OCIPicklerTdsCtxFree(/*_ OCIEnv *env, OCIError *err,
    07034                                  OCIPicklerTdsCtx *tdsc _*/);
    07035
    07036 sword OCIPicklerTdsInit(/*_ OCIEnv *env, OCIError *err, OCIPicklerTdsCtx *tdsc,
    07037                                  OCIPicklerTds **tdsh _*/);
    07038
    07039 sword OCIPicklerTdsFree(/*_ OCIEnv *env, OCIError *err,
    07040                                  OCIPicklerTds *tdsh _*/);
    07041
    07042 sword OCIPicklerTdsCreateElementNumber(/*_ OCIEnv *env, OCIError *err,
    07043                                            OCIPicklerTds *tdsh, ub1 prec,
    07044                                            sb1 scale,
    07045                                            OCIPicklerTdsElement *elt _*/);
    07046
    07047 sword OCIPicklerTdsCreateElementChar(/*_ OCIEnv *env, OCIError *err,
    07048                                          OCIPicklerTds *tdsh, ub2 len,
    07049                                          OCIPicklerTdsElement *elt _*/);
    07050
    07051 sword OCIPicklerTdsCreateElementVarchar(/*_ OCIEnv *env, OCIError *err,
    07052                                             OCIPicklerTds *tdsh, ub2 len,
    07053                                             OCIPicklerTdsElement *elt _*/);
    07054
    07055 sword OCIPicklerTdsCreateElementRaw(/*_ OCIEnv *env, OCIError *err,
    07056                                         OCIPicklerTds *tdsh, ub2 len,
    07057                                         OCIPicklerTdsElement *elt _*/);
    07058
    07059 sword OCIPicklerTdsCreateElement(/*_ OCIEnv *env, OCIError *err,
    07060                                 OCIPicklerTds *tdsh, OCITypeCode dty,
    07061                                             OCIPicklerTdsElement *elt _*/);
    07062
    07063 sword OCIPicklerTdsAddAttr(/*_ OCIEnv *env, OCIError *err,
    07064                                OCIPicklerTds *tdsh,
    07065                                OCIPicklerTdsElement elt _*/);
    07066
    07067 sword OCIPicklerTdsGenerate(/*_ OCIEnv *env, OCIError *err,
    07068                                 OCIPicklerTds *tdsh _*/);
    07069
    07070 sword OCIPicklerTdsGetAttr(/*_ OCIEnv *env, OCIError *err,
    07071                                 CONST OCIPicklerTds *tdsh, ub1  attrno,
    07072                                 OCITypeCode *typ, ub2  *len _*/);
    07073
    07074 sword OCIPicklerFdoInit(/*_ OCIEnv *env, OCIError *err,
    07075                                 OCIPicklerFdo **fdoh _*/);
    07076
    07077 sword OCIPicklerFdoFree(/*_ OCIEnv *env, OCIError *err,
    07078                                 OCIPicklerFdo *fdoh _*/);
    07079
    07080 sword OCIPicklerImageInit(/*_ OCIEnv *env, OCIError *err,
    07081                               OCIPicklerFdo *fdoh, OCIPicklerTds *tdsh,
    07082                               OCIPicklerImage **imgh _*/);
    07083
    07084 sword OCIPicklerImageFree(/*_ OCIEnv *env, OCIError *err,
    07085                                 OCIPicklerImage *imgh _*/);
    07086
    07087 sword OCIPicklerImageAddScalar(/*_ OCIEnv *env, OCIError *err,
    07088                                    OCIPicklerImage *imgh, dvoid *scalar,
    07089                                    ub4 len _*/);
    07090
    07091 sword OCIPicklerImageAddNullScalar(/*_ OCIEnv *env, OCIError *err,
    07092                                 OCIPicklerImage *imgh _*/);
    07093
    07094 sword OCIPicklerImageGenerate(/*_ OCIEnv *env, OCIError *err,
    07095                                 OCIPicklerImage *imgh _*/);
    07096
    07097 sword OCIPicklerImageGetScalarSize(/*_ OCIEnv *env, OCIError *err,
    07098                                 OCIPicklerImage *imgh,
    07099                                             ub4  attrno, ub4  *size _*/);
    07100
    07101 sword OCIPicklerImageGetScalar(/*_ OCIEnv *env, OCIError *err,
    07102                                 OCIPicklerImage *imgh, ub4  attrno,
    07103                                             dvoid *buf, ub4  *len, OCIInd *ind _*/);
    07104
    07105 sword OCIPicklerImageCollBegin(/*_ OCIEnv *env, OCIError *err,
    07106                 OCIPicklerImage *imgh, CONST OCIPicklerTds *colltdsh _*/);
    07107
    07108 sword OCIPicklerImageCollAddScalar(/*_  OCIEnv *env, OCIError *err,
    07109                 OCIPicklerImage *imgh, dvoid *scalar,
    07110                 ub4 buflen, OCIInd ind _*/);
    07111
    07112 sword OCIPicklerImageCollEnd(/*_ OCIEnv *env, OCIError *err,
    07113                 OCIPicklerImage *imgh _*/);
    07114
    07115 /* should take svcctx for locator stuff */
    07116 sword OCIPicklerImageCollBeginScan(/*_ OCIEnv *env, OCIError *err,
    07117                 OCIPicklerImage *imgh, CONST OCIPicklerTds *coll_tdsh,
    07118                 ub4 attrnum, ub4 startidx, OCIInd *ind _*/);
    07119
    07120 sword OCIPicklerImageCollGetScalarSize(/*_ OCIEnv *env, OCIError *err,
    07121                 CONST OCIPicklerTds *coll_tdsh, ub4 *size _*/);
    07122
    07123 sword OCIPicklerImageCollGetScalar(/*_ OCIEnv *env, OCIError *err,
    07124                                        OCIPicklerImage *imgh, dvoid *buf,
    07125                                        ub4 *buflen, OCIInd *ind _*/);
    07126
    07127 sword OCIAnyDataGetType(/*_ OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata,
    07128         OCITypeCode *tc, OCIType **type _*/);
    07129
    07130 sword OCIAnyDataIsNull(/*_ OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata,
    07131         boolean *isnull _*/);
    07132
    07133 sword OCIAnyDataConvert(/*_ OCISvcCtx *svchp, OCIError *errhp, OCITypeCode tc,
    07134         OCIType *type, OCIDuration dur, dvoid *ind, dvoid *data_val,
    07135         ub4 len, OCIAnyData **sdata _*/);
    07136
    07137 sword OCIAnyDataBeginCreate(/*_ OCISvcCtx *svchp, OCIError *errhp, OCITypeCode tc,
    07138         OCIType *type, OCIDuration dur, OCIAnyData **sdata _*/);
    07139
    07140 sword OCIAnyDataDestroy(/*_ OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata _*/);
    07141
    07142 sword OCIAnyDataAttrSet(/*_ OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata,
    07143         OCITypeCode tc, OCIType *type, dvoid *ind, dvoid *attr_val,
    07144         ub4 length, boolean is_any _*/);
    07145
    07146 sword OCIAnyDataCollAddElem(/*_ OCISvcCtx *svchp, OCIError *errhp,
    07147         OCIAnyData *sdata, OCITypeCode tc, OCIType *type, dvoid *ind,
    07148         dvoid *attr_val, ub4 length, boolean is_any, boolean last_elem _*/);
    07149
    07150 sword OCIAnyDataEndCreate(/*_ OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata _*/);
    07151
    07152 sword OCIAnyDataAccess(/*_ OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata,
    07153         OCITypeCode tc, OCIType *type, dvoid *ind, dvoid **attr_val,
    07154         ub4 *length _*/);
    07155
    07156 sword OCIAnyDataGetCurrAttrNum(/*_ OCISvcCtx *svchp, OCIError *errhp,
    07157                       OCIAnyData *sdata, ub4 *attrnum _*/);
    07158
    07159 sword OCIAnyDataAttrGet(/*_ OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata,
    07160   OCITypeCode tc, OCIType *type, dvoid *ind, dvoid **attr_val,
    07161         ub4 *length, boolean is_any _*/);
    07162
    07163 sword OCIAnyDataCollGetElem(/*_ OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata,
    07164   OCITypeCode tc, OCIType *type, dvoid *ind, dvoid **celem_val,
    07165         ub4 *length, boolean is_any _*/);
    07166
    07167 sword OCIFormatInit(/*_ dvoid *hndl, OCIError *err _*/);
    07168
    07169 sword OCIFormatString(/*_ dvoid *hndl, OCIError *err, OraText *buffer,
    07170                           sbig_ora bufferLength, sbig_ora *returnLength,
    07171                           CONST OraText *formatString, ... _*/);
    07172
    07173 sword OCIFormatTerm(/*_ dvoid *hndl, OCIError *err _*/);
    07174
    07175 sword OCIFormatTUb1(/*_ void _*/);
    07176 sword OCIFormatTUb2(/*_ void _*/);
    07177 sword OCIFormatTUb4(/*_ void _*/);
    07178 sword OCIFormatTUword(/*_ void _*/);
    07179 sword OCIFormatTUbig_ora(/*_ void _*/);
    07180 sword OCIFormatTSb1(/*_ void _*/);
    07181 sword OCIFormatTSb2(/*_ void _*/);
    07182 sword OCIFormatTSb4(/*_ void _*/);
    07183 sword OCIFormatTSword(/*_ void _*/);
    07184 sword OCIFormatTSbig_ora(/*_ void _*/);
    07185 sword OCIFormatTEb1(/*_ void _*/);
    07186 sword OCIFormatTEb2(/*_ void _*/);
    07187 sword OCIFormatTEb4(/*_ void _*/);
    07188 sword OCIFormatTEword(/*_ void _*/);
    07189 sword OCIFormatTChar(/*_ void _*/);
    07190 sword OCIFormatTText(/*_ void _*/);
    07191 sword OCIFormatTDouble(/*_ void _*/);
    07192 sword OCIFormatTDvoid(/*_ void _*/);
    07193 sword OCIFormatTEnd(/*_ void _*/);
    07194
    07195 sword OCIFileClose (/*_ dvoid  *hndl, OCIError *err, OCIFileObject *filep _*/);
    07196
    07197
    07198 sword OCIFileExists (/*_ dvoid  *hndl, OCIError *err, OraText *filename,
    07199                      OraText *path, ub1 *flag _*/ );
    07200
    07201 sword OCIFileFlush(/*_ dvoid *hndl, OCIError *err, OCIFileObject *filep _*/ );
    07202
    07203 sword OCIFileGetLength(/*_ dvoid *hndl, OCIError *err, OraText *filename,
    07204                         OraText *path, ubig_ora *lenp _*/ );
    07205
    07206 sword OCIFileInit (/*_ dvoid *hndl, OCIError *err _*/);
    07207
    07208 sword OCIFileOpen (/*_ dvoid *hndl, OCIError *err, OCIFileObject **filep,
    07209                     OraText *filename, OraText *path, ub4 mode, ub4 create,
    07210                     ub4 type _*/);
    07211
    07212 sword OCIFileRead (/*_ dvoid *hndl, OCIError *err, OCIFileObject *filep,
    07213                     dvoid *bufp, ub4 bufl, ub4 *bytesread _*/);
    07214
    07215 sword OCIFileSeek (/*_ dvoid *hndl, OCIError *err, OCIFileObject *filep,
    07216                      uword origin, ubig_ora offset, sb1 dir _*/);
    07217
    07218 sword OCIFileTerm (/*_ dvoid *hndl, OCIError *err _*/);
    07219
    07220 sword OCIFileWrite (/*_ dvoid *hndl, OCIError *err, OCIFileObject   *filep,
    07221                      dvoid *bufp, ub4 buflen, ub4 *byteswritten _*/);
    07222
    07223
    07224 /*-------------------------- Extensions to XA interface ---------------------*/
    07225 /* ------------------------- xaosvch ----------------------------------------*/
    07226 /*
    07227    NAME
    07228      xaosvch  -  XA Oracle get SerViCe Handle
    07229    DESCRIPTION
    07230      Given a database name return the service handle that is used by the
    07231      XA library
    07232    NOTE
    07233      This macro has been provided for backward compatibilty with 8.0.2
    07234 */
    07235 OCISvcCtx *xaosvch(/*_ OraText *dbname _*/);
    07236
    07237 /* ------------------------- xaoSvcCtx --------------------------------------*/
    07238 /*
    07239    NAME
    07240      xaoSvcCtx  -  XA Oracle get SerViCe ConTeXt
    07241    DESCRIPTION
    07242      Given a database name return the service handle that is used by the
    07243      XA library
    07244    NOTE
    07245      This routine has been provided for APs to get access to the service
    07246      handle that XA library uses. Without this routine APs must use SQLLIB
    07247      routine sqlld2 to get access to the Logon data area registered by the
    07248      XA library
    07249 */
    07250 OCISvcCtx *xaoSvcCtx(/*_ OraText *dbname _*/);
    07251
    07252 /* ------------------------- xaoEnv -----------------------------------------*/
    07253 /*
    07254    NAME
    07255      xaoEnv  -  XA Oracle get ENvironment Handle
    07256    DESCRIPTION
    07257      Given a database name return the environment handle that is used by the
    07258      XA library
    07259    NOTE
    07260      This routine has been provided for APs to get access to the environment
    07261      handle that XA library uses. Without this routine APs must use SQLLIB
    07262      routine sqlld2 to get access to the Logon data area registered by the
    07263      XA library
    07264 */
    07265 OCIEnv *xaoEnv(/*_ OraText *dbname _*/);
    07266
    07267 /* ------------------------- xaosterr ---------------------------------------*/
    07268 /*
    07269    NAME
    07270      xaosterr  -  XA Oracle get xa STart ERRor code
    07271    DESCRIPTION
    07272      Given an oracle error code return the XA error code
    07273  */
    07274 int xaosterr(/*_ OCISvcCtx *svch, sb4 error _*/);
    07275 /*-------------------------- End Extensions ---------------------------------*/
    07276
    07277 /*---------------------- Extensions to NLS cartridge service ----------------*/
    07278 /* ----------------------- OCINlsGetInfo ------------------------------------*/
    07279 /*
    07280    NAME
    07281      OCINlsGetInfo - Get NLS info from OCI environment handle
    07282    REMARKS
    07283      This function generates language information specified by item from OCI
    07284      environment handle envhp into an array pointed to by buf within size
    07285      limitation as buflen.
    07286    RETURNS
    07287      OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR on wrong item.
    07288    envhp(IN/OUT)
    07289      OCI environment handle.
    07290    errhp(IN/OUT)
    07291      The OCI error handle. If there is an error, it is record in errhp and
    07292      this function returns a NULL pointer. Diagnostic information can be
    07293      obtained by calling OCIErrorGet().
    07294    buf(OUT)
    07295      Pointer to the destination buffer.
    07296    buflen(IN)
    07297      The size of destination buffer. The maximum length for each information
    07298      is 32 bytes.
    07299    item(IN)
    07300      It specifies to get which item in OCI environment handle and can be one
    07301      of following values:
    07302        OCI_NLS_DAYNAME1 : Native name for Monday.
    07303        OCI_NLS_DAYNAME2 : Native name for Tuesday.
    07304        OCI_NLS_DAYNAME3 : Native name for Wednesday.
    07305        OCI_NLS_DAYNAME4 : Native name for Thursday.
    07306        OCI_NLS_DAYNAME5 : Native name for Friday.
    07307        OCI_NLS_DAYNAME6 : Native name for for Saturday.
    07308        OCI_NLS_DAYNAME7 : Native name for for Sunday.
    07309        OCI_NLS_ABDAYNAME1 : Native abbreviated name for Monday.
    07310        OCI_NLS_ABDAYNAME2 : Native abbreviated name for Tuesday.
    07311        OCI_NLS_ABDAYNAME3 : Native abbreviated name for Wednesday.
    07312        OCI_NLS_ABDAYNAME4 : Native abbreviated name for Thursday.
    07313        OCI_NLS_ABDAYNAME5 : Native abbreviated name for Friday.
    07314        OCI_NLS_ABDAYNAME6 : Native abbreviated name for for Saturday.
    07315        OCI_NLS_ABDAYNAME7 : Native abbreviated name for for Sunday.
    07316        OCI_NLS_MONTHNAME1 : Native name for January.
    07317        OCI_NLS_MONTHNAME2 : Native name for February.
    07318        OCI_NLS_MONTHNAME3 : Native name for March.
    07319        OCI_NLS_MONTHNAME4 : Native name for April.
    07320        OCI_NLS_MONTHNAME5 : Native name for May.
    07321        OCI_NLS_MONTHNAME6 : Native name for June.
    07322        OCI_NLS_MONTHNAME7 : Native name for July.
    07323        OCI_NLS_MONTHNAME8 : Native name for August.
    07324        OCI_NLS_MONTHNAME9 : Native name for September.
    07325        OCI_NLS_MONTHNAME10 : Native name for October.
    07326        OCI_NLS_MONTHNAME11 : Native name for November.
    07327        OCI_NLS_MONTHNAME12 : Native name for December.
    07328        OCI_NLS_ABMONTHNAME1 : Native abbreviated name for January.
    07329        OCI_NLS_ABMONTHNAME2 : Native abbreviated name for February.
    07330        OCI_NLS_ABMONTHNAME3 : Native abbreviated name for March.
    07331        OCI_NLS_ABMONTHNAME4 : Native abbreviated name for April.
    07332        OCI_NLS_ABMONTHNAME5 : Native abbreviated name for May.
    07333        OCI_NLS_ABMONTHNAME6 : Native abbreviated name for June.
    07334        OCI_NLS_ABMONTHNAME7 : Native abbreviated name for July.
    07335        OCI_NLS_ABMONTHNAME8 : Native abbreviated name for August.
    07336        OCI_NLS_ABMONTHNAME9 : Native abbreviated name for September.
    07337        OCI_NLS_ABMONTHNAME10 : Native abbreviated name for October.
    07338        OCI_NLS_ABMONTHNAME11 : Native abbreviated name for November.
    07339        OCI_NLS_ABMONTHNAME12 : Native abbreviated name for December.
    07340        OCI_NLS_YES : Native string for affirmative response.
    07341        OCI_NLS_NO : Native negative response.
    07342        OCI_NLS_AM : Native equivalent string of AM.
    07343        OCI_NLS_PM : Native equivalent string of PM.
    07344        OCI_NLS_AD : Native equivalent string of AD.
    07345        OCI_NLS_BC : Native equivalent string of BC.
    07346        OCI_NLS_DECIMAL : decimal character.
    07347        OCI_NLS_GROUP : group separator.
    07348        OCI_NLS_DEBIT : Native symbol of debit.
    07349        OCI_NLS_CREDIT : Native sumbol of credit.
    07350        OCI_NLS_DATEFORMAT : Oracle date format.
    07351        OCI_NLS_INT_CURRENCY: International currency symbol.
    07352        OCI_NLS_LOC_CURRENCY : Locale currency symbol.
    07353        OCI_NLS_LANGUAGE : Language name.
    07354        OCI_NLS_ABLANGUAGE : Abbreviation for language name.
    07355        OCI_NLS_TERRITORY : Territory name.
    07356        OCI_NLS_CHARACTER_SET : Character set name.
    07357        OCI_NLS_LINGUISTIC : Linguistic name.
    07358        OCI_NLS_CALENDAR : Calendar name.
    07359        OCI_NLS_DUAL_CURRENCY : Dual currency symbol.
    07360 */
    07361 sword OCINlsGetInfo(/*_ dvoid *envhp, OCIError *errhp, OraText *buf,
    07362                     size_t buflen, ub2 item _*/);
    07363
    07364 /* ----------------------- OCINlsNumericInfoGet ----------------------------*/
    07365 /*
    07366    NAME
    07367      OCINlsNumericInfoGet - Get NLS numeric info from OCI environment handle
    07368    REMARKS
    07369      This function generates numeric language information specified by item
    07370      from OCI environment handle envhp into an output number variable.
    07371    RETURNS
    07372      OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR on wrong item.
    07373    envhp(IN/OUT)
    07374      OCI environment handle. If handle invalid, returns OCI_INVALID_HANDLE.
    07375    errhp(IN/OUT)
    07376      The OCI error handle. If there is an error, it is record in errhp and
    07377      this function returns a NULL pointer. Diagnostic information can be
    07378      obtained by calling OCIErrorGet().
    07379    val(OUT)
    07380      Pointer to the output number variable. On OCI_SUCCESS return, it will
    07381      contain the requested NLS numeric info.
    07382    item(IN)
    07383      It specifies to get which item in OCI environment handle and can be one
    07384      of following values:
    07385        OCI_NLS_CHARSET_MAXBYTESZ : Maximum character byte size for OCI
    07386                                    environment or session handle charset
    07387        OCI_NLS_CHARSET_FIXEDWIDTH: Character byte size for fixed-width charset;
    07388                                    0 for variable-width charset
    07389 */
    07390 sword OCINlsNumericInfoGet(/*_ dvoid *envhp, OCIError *errhp, sb4 *val,
    07391                            ub2 item _*/);
    07392
    07393 /* ----------------------- OCINlsCharSetNameToId -----------------------------*/
    07394 /*
    07395    NAME
    07396      OCINlsCharSetNameToId - Get Oracle charset id given Oracle charset name
    07397    REMARKS
    07398      This function will get the Oracle character set id corresponding to
    07399      the given Oracle character set name.
    07400    RETURNS
    07401      Oracle character set id for the given Oracle character set name if
    07402      character set name and OCI handle are valid; otherwise returns 0.
    07403    envhp(IN/OUT)
    07404      OCI environment handle.
    07405    name(IN)
    07406      Pointer to a null-terminated Oracle character set name whose id
    07407      will be returned.
    07408 */
    07409 ub2 OCINlsCharSetNameToId(/*_ dvoid *envhp, const oratext *name _*/);
    07410
    07411 /* ----------------------- OCINlsCharSetIdToName -----------------------------*/
    07412 /*
    07413    NAME
    07414      OCINlsCharSetIdToName - Get Oracle charset name given Oracle charset id
    07415    REMARKS
    07416      This function will get the Oracle character set name corresponding to
    07417      the given Oracle character set id.
    07418    RETURNS
    07419      OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    07420    envhp(IN/OUT)
    07421      OCI environment handle. If handle invalid, returns OCI_INVALID_HANDLE.
    07422    buf(OUT)
    07423      Pointer to the destination buffer. On OCI_SUCCESS return, it will contain
    07424      the null-terminated string for character set name.
    07425    buflen(IN)
    07426      Size of destination buffer. Recommended size is OCI_NLS_MAXBUFSZ for
    07427      guarantee to store an Oracle character set name. If it's smaller than
    07428      the length of the character set name, the function will return OCI_ERROR.
    07429    id(IN)
    07430      Oracle character set id.
    07431 */
    07432 sword OCINlsCharSetIdToName(/*_ dvoid *envhp, oratext *buf, size_t buflen,
    07433                             ub2 id _*/);
    07434
    07435 /* ----------------------- OCINlsNameMap ------------------------------------*/
    07436 /*
    07437    NAME
    07438      OCINlsNameMap - Map NLS naming from Oracle to other standards and vice
    07439                      versa
    07440    REMARKS
    07441      This function will map NLS naming from Oracle to other standards (such
    07442      as ISO, IANA) and vice versa.
    07443    RETURNS
    07444      OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR
    07445    envhp(IN/OUT)
    07446      OCI environment handle. If handle invalid, returns OCI_INVALID_HANDLE.
    07447    buf(OUT)
    07448      Pointer to the destination buffer. On OCI_SUCCESS return, it will
    07449      contain null-terminated string for requested mapped name.
    07450    buflen(IN)
    07451      The size of destination buffer. Recommended size is OCI_NLS_MAXBUFSZ
    07452      for guarantee to store an NLS name. If it is smaller than the length
    07453      of the name, the function will return OCI_ERROR.
    07454    srcbuf(IN)
    07455      Pointer to null-terminated NLS name. If it is not a valid name in its
    07456      define scope, the function will return OCI_ERROR.
    07457    flag(IN)
    07458      It specifies name mapping direction and can take the following values:
    07459        OCI_NLS_CS_IANA_TO_ORA : Map character set name from IANA to Oracle
    07460        OCI_NLS_CS_ORA_TO_IANA : Map character set name from Oracle to IANA
    07461        OCI_NLS_LANG_ISO_TO_ORA : Map language name from ISO to Oracle
    07462        OCI_NLS_LANG_ORA_TO_ISO : Map language name from Oracle to ISO
    07463        OCI_NLS_TERR_ISO_TO_ORA : Map territory name from ISO to Oracle
    07464        OCI_NLS_TERR_ORA_TO_ISO : Map territory name from Oracle to ISO
    07465        OCI_NLS_TERR_ISO3_TO_ORA : Map territory name from 3-letter ISO
    07466                                   abbreviation to Oracle
    07467        OCI_NLS_TERR_ORA_TO_ISO3 : Map territory name from Oracle to 3-letter
    07468                                   ISO abbreviation
    07469 */
    07470 sword OCINlsNameMap(/*_ dvoid *envhp, oratext *buf, size_t buflen,
    07471                     const oratext *srcbuf, ub4 flag _*/);
    07472
    07473 /* -------------------- OCIMultiByteToWideChar ------------------------------*/
    07474 /*
    07475    NAME
    07476      OCIMultiByteToWideChar - Convert a null terminated multibyte string into
    07477                               wchar
    07478    REMARKS
    07479      This routine converts an entire null-terminated string into the wchar
    07480      format. The wchar output buffer will be null-terminated.
    07481    RETURNS
    07482      OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR
    07483    envhp(IN/OUT)
    07484      OCI environment handle to determine the character set of string.
    07485    dst (OUT)
    07486      Destination buffer for wchar.
    07487    src (IN)
    07488      Source string to be converted.
    07489    rsize (OUT)
    07490      Number of characters converted including null-terminator.
    07491      If it is a NULL pointer, no number return
    07492 */
    07493 sword OCIMultiByteToWideChar(/*_ dvoid *envhp, OCIWchar *dst,
    07494                             CONST OraText *src, size_t *rsize _*/);
    07495
    07496
    07497 /* --------------------- OCIMultiByteInSizeToWideChar -----------------------*/
    07498 /*
    07499    NAME
    07500      OCIMultiByteInSizeToWideChar - Convert a mulitbyte string in length into
    07501                                     wchar
    07502    REMARKS
    07503      This routine converts part of string into the wchar format. It will
    07504      convert as many complete characters as it can until it reaches output
    07505      buffer size or input buffer size or it reaches a null-terminator in
    07506      source string. The output buffer will be null-terminated if space permits.
    07507      If dstsz is zero, this function will only return number of characters not
    07508      including ending null terminator for converted string.
    07509    RETURNS
    07510      OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR
    07511    envhp(IN/OUT)
    07512      OCI environment handle to determine the character set of string.
    07513    dst (OUT)
    07514      Pointer to a destination buffer for wchar. It can be NULL pointer when
    07515      dstsz is zero.
    07516    dstsz(IN)
    07517      Destination buffer size in character. If it is zero, this function just
    07518      returns number of characters will be need for the conversion.
    07519    src (IN)
    07520      Source string to be converted.
    07521    srcsz(IN)
    07522      Length of source string in byte.
    07523    rsize(OUT)
    07524      Number of characters written into destination buffer, or number of
    07525      characters for converted string is dstsz is zero.
    07526      If it is NULL pointer, nothing to return.
    07527 */
    07528 sword OCIMultiByteInSizeToWideChar(/*_ dvoid *envhp, OCIWchar *dst,
    07529                                   size_t dstsz, CONST OraText *src,
    07530                                   size_t srcsz, size_t *rsize _*/);
    07531
    07532
    07533 /* ---------------------- OCIWideCharToMultiByte ----------------------------*/
    07534 /*
    07535    NAME
    07536      OCIWideCharToMultiByte - Convert a null terminated wchar string into
    07537                               multibyte
    07538    REMARKS
    07539      This routine converts an entire null-terminated wide character string into
    07540      multi-byte string. The output buffer will be null-terminated.
    07541    RETURNS
    07542      OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR
    07543    envhp(IN/OUT)
    07544      OCI environment handle to determine the character set of string.
    07545    dst (OUT)
    07546      Destination buffer for multi-byte string.
    07547    src (IN)
    07548      Source wchar string to be converted.
    07549    rsize (OUT)
    07550      Number of bytes written into the destination buffer.
    07551      If it is NULL pointer, nothing to return.
    07552 */
    07553 sword OCIWideCharToMultiByte(/*_ dvoid *envhp, OraText *dst,
    07554                             CONST OCIWchar *src, size_t *rsize _*/);
    07555
    07556
    07557 /* ---------------------- OCIWideCharInSizeToMultiByte ----------------------*/
    07558 /*
    07559    NAME
    07560      OCIWideCharInSizeToMultiByte - Convert a wchar string in length into
    07561                                     mulitbyte
    07562    REMARKS
    07563      This routine converts part of wchar string into the multi-byte format.
    07564      It will convert as many complete characters as it can until it reaches
    07565      output buffer size or input buffer size or it reaches a null-terminator
    07566      in source string. The output buffer will be null-terminated if space
    07567      permits. If dstsz is zero, the function just returns the size of byte not
    07568      including ending null-terminator need to store the converted string.
    07569    RETURNS
    07570      OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR
    07571    envhp(IN/OUT)
    07572      OCI environment handle to determine the character set of string.
    07573    dst (OUT)
    07574      Destination buffer for multi-byte. It can be NULL pointer if dstsz is zero.
    07575    dstsz(IN)
    07576      Destination buffer size in byte. If it is zero, it just returns the size
    07577      of bytes need for converted string.
    07578    src (IN)
    07579      Source wchar string to be converted.
    07580    srcsz(IN)
    07581      Length of source string in character.
    07582    rsize(OUT)
    07583      Number of bytes written into destination buffer, or number of bytes need
    07584      to store the converted string if dstsz is zero.
    07585      If it is NULL pointer, nothing to return.
    07586 */
    07587 sword OCIWideCharInSizeToMultiByte(/*_ dvoid *envhp, OraText *dst,
    07588                                     size_t dstsz, CONST OCIWchar *src,
    07589                                     size_t srcsz, size_t *rsize _*/);
    07590
    07591
    07592
    07593 /* ----------------------- OCIWideCharIsAlnum -------------------------------*/
    07594 /*
    07595    NAME
    07596      OCIWideCharIsAlnum - test whether wc is a letter or decimal digit
    07597    REMARKS
    07598      It tests whether wc is a letter or decimal digit.
    07599    RETURNS
    07600      TRUE or FLASE.
    07601    envhp(IN/OUT)
    07602      OCI environment handle to determine the character set .
    07603    wc(IN)
    07604      Wchar for testing.
    07605 */
    07606 boolean OCIWideCharIsAlnum(/*_ dvoid *envhp, OCIWchar wc _*/);
    07607
    07608
    07609 /* ----------------------- OCIWideCharIsAlpha -------------------------------*/
    07610 /*
    07611    NAME
    07612      OCIWideCharIsAlpha - test whether wc is an alphabetic letter
    07613    REMARKS
    07614      It tests whether wc is an alphabetic letter
    07615    RETURNS
    07616      TRUE or FLASE.
    07617    envhp(IN/OUT)
    07618      OCI environment handle to determine the character set .
    07619    wc(IN)
    07620      Wchar for testing.
    07621 */
    07622 boolean OCIWideCharIsAlpha(/*_ dvoid *envhp, OCIWchar wc _*/);
    07623
    07624
    07625 /* --------------------- OCIWideCharIsCntrl ---------------------------------*/
    07626 /*
    07627    NAME
    07628      OCIWideCharIsCntrl - test whether wc is a control character
    07629    REMARKS
    07630      It tests whether wc is a control character.
    07631    RETURNS
    07632      TRUE or FLASE.
    07633    envhp(IN/OUT)
    07634      OCI environment handle to determine the character set .
    07635    wc(IN)
    07636      Wchar for testing.
    07637 */
    07638 boolean OCIWideCharIsCntrl(/*_ dvoid *envhp, OCIWchar wc _*/);
    07639
    07640
    07641 /* ----------------------- OCIWideCharIsDigit -------------------------------*/
    07642 /*
    07643    NAME
    07644      OCIWideCharIsDigit - test whether wc is a decimal digit character
    07645    REMARKS
    07646      It tests whether wc is a decimal digit character.
    07647    RETURNS
    07648      TRUE or FLASE.
    07649    envhp(IN/OUT)
    07650      OCI environment handle to determine the character set .
    07651    wc(IN)
    07652      Wchar for testing.
    07653 */
    07654 boolean OCIWideCharIsDigit(/*_ dvoid *envhp, OCIWchar wc _*/);
    07655
    07656
    07657 /* ----------------------- OCIWideCharIsGraph -------------------------------*/
    07658 /*
    07659    NAME
    07660      OCIWideCharIsGraph - test whether wc is a graph character
    07661    REMARKS
    07662      It tests whether wc is a graph character. A graph character is character
    07663      with a visible representation and normally includes alphabetic letter,
    07664      decimal digit, and punctuation.
    07665    RETURNS
    07666      TRUE or FLASE.
    07667    envhp(IN/OUT)
    07668      OCI environment handle to determine the character set .
    07669    wc(IN)
    07670      Wchar for testing.
    07671 */
    07672 boolean OCIWideCharIsGraph(/*_ dvoid *envhp, OCIWchar wc _*/);
    07673
    07674
    07675 /* ----------------------- OCIWideCharIsLower -------------------------------*/
    07676 /*
    07677    NAME
    07678      OCIWideCharIsLower - test whether wc is a lowercase letter
    07679    REMARKS
    07680      It tests whether wc is a lowercase letter.
    07681    RETURNS
    07682      TRUE or FLASE.
    07683    envhp(IN/OUT)
    07684      OCI environment handle to determine the character set .
    07685    wc(IN)
    07686      Wchar for testing.
    07687 */
    07688 boolean OCIWideCharIsLower(/*_ dvoid *envhp, OCIWchar wc _*/);
    07689
    07690
    07691 /* ----------------------- OCIWideCharIsPrint -------------------------------*/
    07692 /*
    07693    NAME
    07694      OCIWideCharIsPrint - test whether wc is a printable character
    07695    REMARKS
    07696      It tests whether wc is a printable character.
    07697    RETURNS
    07698      TRUE or FLASE.
    07699    envhp(IN/OUT)
    07700      OCI environment handle to determine the character set .
    07701    wc(IN)
    07702      Wchar for testing.
    07703 */
    07704 boolean OCIWideCharIsPrint(/*_ dvoid *envhp, OCIWchar wc _*/);
    07705
    07706
    07707 /* ----------------------- OCIWideCharIsPunct -------------------------------*/
    07708 /*
    07709    NAME
    07710      OCIWideCharIsPunct - test whether wc is a punctuation character
    07711    REMARKS
    07712      It tests whether wc is a punctuation character.
    07713    RETURNS
    07714      TRUE or FLASE.
    07715    envhp(IN/OUT)
    07716      OCI environment handle to determine the character set .
    07717    wc(IN)
    07718      Wchar for testing.
    07719 */
    07720 boolean OCIWideCharIsPunct(/*_ dvoid *envhp, OCIWchar wc _*/);
    07721
    07722
    07723 /* ----------------------- OCIWideCharIsSpace -------------------------------*/
    07724 /*
    07725    NAME
    07726      OCIWideCharIsSpace - test whether wc is a space character
    07727    REMARKS
    07728      It tests whether wc is a space character. A space character only causes
    07729      white space in displayed text(for example, space, tab, carriage return,
    07730      newline, vertical tab or form feed).
    07731    RETURNS
    07732      TRUE or FLASE.
    07733    envhp(IN/OUT)
    07734      OCI environment handle to determine the character set .
    07735    wc(IN)
    07736      Wchar for testing.
    07737 */
    07738 boolean OCIWideCharIsSpace(/*_ dvoid *envhp, OCIWchar wc _*/);
    07739
    07740
    07741 /* ----------------------- OCIWideCharIsUpper -------------------------------*/
    07742 /*
    07743    NAME
    07744      OCIWideCharIsUpper - test whether wc is a uppercase letter
    07745    REMARKS
    07746      It tests whether wc is a uppercase letter.
    07747    RETURNS
    07748      TRUE or FLASE.
    07749    envhp(IN/OUT)
    07750      OCI environment handle to determine the character set .
    07751    wc(IN)
    07752      Wchar for testing.
    07753 */
    07754 boolean OCIWideCharIsUpper(/*_ dvoid *envhp, OCIWchar wc _*/);
    07755
    07756
    07757 /*----------------------- OCIWideCharIsXdigit -------------------------------*/
    07758 /*
    07759    NAME
    07760      OCIWideCharIsXdigit - test whether wc is a hexadecimal digit
    07761    REMARKS
    07762      It tests whether wc is a hexadecimal digit ( 0-9, A-F, a-f ).
    07763    RETURNS
    07764      TRUE or FLASE.
    07765    envhp(IN/OUT)
    07766      OCI environment handle to determine the character set .
    07767    wc(IN)
    07768      Wchar for testing.
    07769 */
    07770 boolean OCIWideCharIsXdigit(/*_ dvoid *envhp, OCIWchar wc _*/);
    07771
    07772
    07773 /* --------------------- OCIWideCharIsSingleByte ----------------------------*/
    07774 /*
    07775    NAME
    07776      OCIWideCharIsSingleByte - test whether wc is a single-byte character
    07777    REMARKS
    07778      It tests whether wc is a single-byte character when converted into
    07779      multi-byte.
    07780    RETURNS
    07781      TRUE or FLASE.
    07782    envhp(IN/OUT)
    07783      OCI environment handle to determine the character set .
    07784    wc(IN)
    07785      Wchar for testing.
    07786 */
    07787 boolean OCIWideCharIsSingleByte(/*_ dvoid *envhp, OCIWchar wc _*/);
    07788
    07789
    07790 /* ----------------------- OCIWideCharToLower -------------------------------*/
    07791 /*
    07792    NAME
    07793      OCIWideCharToLower - Convert a wchar into the lowercase
    07794    REMARKS
    07795      If there is a lower-case character mapping for wc in the specified locale,
    07796      it will return the lower-case in wchar, else return wc itself.
    07797    RETURNS
    07798      A wchar
    07799    envhp(IN/OUT)
    07800      OCI environment handle to determine the character set .
    07801    wc(IN)
    07802      Wchar for lowercase mapping.
    07803 */
    07804 OCIWchar OCIWideCharToLower(/*_ dvoid *envhp, OCIWchar wc _*/);
    07805
    07806
    07807 /* ----------------------- OCIWideCharToUpper -------------------------------*/
    07808 /*
    07809    NAME
    07810      OCIWideCharToUpper - Convert a wchar into the uppercase
    07811    REMARKS
    07812      If there is a upper-case character mapping for wc in the specified locale,
    07813      it will return the upper-case in wchar, else return wc itself.
    07814    RETURNS
    07815      A wchar
    07816    envhp(IN/OUT)
    07817      OCI environment handle to determine the character set .
    07818    wc(IN)
    07819      Wchar for uppercase mapping.
    07820 */
    07821 OCIWchar OCIWideCharToUpper(/*_ dvoid *envhp, OCIWchar wc _*/);
    07822
    07823
    07824 /* ----------------------- OCIWideCharStrcmp --------------------------------*/
    07825 /*
    07826    NAME
    07827      OCIWideCharStrcmp - compare two null terminated wchar string
    07828    REMARKS
    07829      It compares two wchar string in binary ( based on wchar encoding value ),
    07830      linguistic, or case-insensitive.
    07831    RETURNS
    07832      0, if wstr1 == wstr2.
    07833      Positive, if wstr1 > wstr2.
    07834      Negative, if wstr1 < wstr2.
    07835    envhp(IN/OUT)
    07836      OCI environment handle to determine the character set.
    07837    wstr1(IN)
    07838      Pointer to a null-terminated wchar string.
    07839    wstr2(IN)
    07840      Pointer to a null-terminated wchar string.
    07841    flag(IN)
    07842      It is used to decide the comparison method. It can be taken one of the
    07843      following values:
    07844        OCI_NLS_BINARY : for the binary comparison, this is default value.
    07845        OCI_NLS_LINGUISTIC : for linguistic comparison specified in the locale.
    07846      This flag can be ORed with OCI_NLS_CASE_INSENSITIVE for case-insensitive
    07847      comparison.
    07848 */
    07849 int OCIWideCharStrcmp(/*_ dvoid *envhp, CONST OCIWchar *wstr1,
    07850                 CONST OCIWchar *wstr2, int flag _*/);
    07851
    07852
    07853 /* ----------------------- OCIWideCharStrncmp -------------------------------*/
    07854 /*
    07855    NAME
    07856      OCIWideCharStrncmp - compare twe wchar string in length
    07857    REMARKS
    07858      This function is similar to OCIWideCharStrcmp(), except that at most len1
    07859      characters from wstr1 and len2 characters from wstr1 are compared. The
    07860      null-terminator will be taken into the comparison.
    07861    RETURNS
    07862      0, if wstr1 = wstr2
    07863      Positive, if wstr1 > wstr2
    07864      Negative, if wstr1 < wstr2
    07865    envhp(IN/OUT)
    07866      OCI environment handle to determine the character set .
    07867    wstr1(IN)
    07868      Pointer to the first wchar string
    07869    len1(IN)
    07870      The length for the first string for comparison
    07871    wstr2(IN)
    07872      Pointer to the second wchar string
    07873    len2(IN)
    07874      The length for the second string for comparison.
    07875    flag(IN)
    07876      It is used to decide the comparison method. It can be taken one of the
    07877      following values:
    07878        OCI_NLS_BINARY : for the binary comparison, this is default value.
    07879        OCI_NLS_LINGUISTIC : for linguistic comparison specified in the locale.
    07880      This flag can be ORed with OCI_NLS_CASE_INSENSITIVE for case-insensitive
    07881      comparison.
    07882 */
    07883 int OCIWideCharStrncmp(/*_ dvoid *envhp, CONST OCIWchar *wstr1, size_t len1,
    07884                  CONST OCIWchar *wstr2, size_t len2, int flag _*/);
    07885
    07886
    07887 /* ----------------------- OCIWideCharStrcat --------------------------------*/
    07888 /*
    07889    NAME
    07890      OCIWideCharStrcat - concatenate two wchar strings
    07891    REMARKS
    07892      This function appends a copy of the wchar string pointed to by wsrcstr,
    07893      including the null-terminator to the end of wchar string pointed to by
    07894      wdststr. It returns the number of character in the result string not
    07895      including the ending null-terminator.
    07896    RETURNS
    07897      number of characters in the result string not including the ending
    07898      null-terminator.
    07899    envhp(IN/OUT)
    07900      OCI environment handle to determine the character set .
    07901    wdststr(IN/OUT)
    07902      Pointer to the destination wchar string for appending.
    07903    wsrcstr(IN)
    07904      Pointer to the source wchar string to append.
    07905 */
    07906 size_t OCIWideCharStrcat(/*_ dvoid *envhp, OCIWchar *wdststr,
    07907                          CONST OCIWchar *wsrcstr _*/);
    07908
    07909
    07910 /* ----------------------- OCIWideCharStrchr --------------------------------*/
    07911 /*
    07912    NAME
    07913      OCIWideCharStrchr - Search the first occurrence of wchar in a wchar string
    07914    REMARKS
    07915      This function searchs for the first occurrence of wc in the wchar string
    07916      pointed to by wstr. It returns a pointer to the whcar if successful, or
    07917      a null pointer.
    07918    RETURNS
    07919      wchar pointer if successful, otherwise a null pointer.
    07920    envhp(IN/OUT)
    07921      OCI environment handle to determine the character set .
    07922    wstr(IN)
    07923      Pointer to the wchar string to search
    07924    wc(IN)
    07925      Wchar to search for.
    07926 */
    07927 OCIWchar *OCIWideCharStrchr(/*_ dvoid *envhp, CONST OCIWchar *wstr,
    07928                             OCIWchar wc _*/);
    07929
    07930
    07931 /* ----------------------- OCIWideCharStrcpy --------------------------------*/
    07932 /*
    07933    NAME
    07934      OCIWideCharStrcpy - copy a wchar string
    07935    REMARKS
    07936      This function copies the wchar string pointed to by wsrcstr, including the
    07937      null-terminator, into the array pointed to by wdststr. It returns the
    07938      number of character copied not including the ending null-terminator.
    07939    RETURNS
    07940      number of characters copied not including the ending null-terminator.
    07941    envhp(IN/OUT)
    07942      OCI environment handle to determine the character set .
    07943    wdststr(OUT)
    07944      Pointer to the destination wchar buffer.
    07945    wsrcstr(IN)
    07946      Pointer to the source wchar string.
    07947 */
    07948 size_t OCIWideCharStrcpy(/*_ dvoid *envhp, OCIWchar *wdststr,
    07949                          CONST OCIWchar *wsrcstr _*/);
    07950
    07951
    07952 /* ----------------------- OCIWideCharStrlen --------------------------------*/
    07953 /*
    07954    NAME
    07955      OCIWideCharStrlen - Return number of character in a wchar string
    07956    REMARKS
    07957      This function computes the number of characters in the wchar string
    07958      pointed to by wstr, not including the null-terminator, and returns
    07959     this number.
    07960    RETURNS
    07961      number of characters not including ending null-terminator.
    07962    envhp(IN/OUT)
    07963      OCI environment handle to determine the character set .
    07964    wstr(IN)
    07965      Pointer to the source wchar string.
    07966 */
    07967 size_t OCIWideCharStrlen(/*_ dvoid *envhp, CONST OCIWchar *wstr _*/);
    07968
    07969
    07970 /* ----------------------- OCIWideCharStrncat -------------------------------*/
    07971 /*
    07972    NAME
    07973      OCIWideCharStrncat - Concatenate wchar string in length
    07974    REMARKS
    07975      This function is similar to OCIWideCharStrcat(), except that at most n
    07976      characters from wsrcstr are appended to wdststr. Note that the
    07977      null-terminator in wsrcstr will stop appending. wdststr will be
    07978      null-terminated..
    07979    RETURNS
    07980      Number of characters in the result string not including the ending
    07981      null-terminator.
    07982    envhp(IN/OUT)
    07983      OCI environment handle to determine the character set .
    07984    wdststr(IN/OUT)
    07985      Pointer to the destination wchar string for appending.
    07986    wsrcstr(IN)
    07987      Pointer to the source wchar string to append.
    07988    n(IN)
    07989      Number of characters from wsrcstr to append.
    07990 */
    07991 size_t OCIWideCharStrncat(/*_ dvoid *envhp, OCIWchar *wdststr,
    07992                           CONST OCIWchar *wsrcstr, size_t n _*/);
    07993
    07994
    07995 /* ----------------------- OCIWideCharStrncpy -------------------------------*/
    07996 /*
    07997    NAME
    07998      OCIWideCharStrncpy - Copy wchar string in length
    07999    REMARKS
    08000      This function is similar to OCIWideCharStrcpy(), except that at most n
    08001      characters are copied from the array pointed to by wsrcstr to the array
    08002      pointed to by wdststr. Note that the null-terminator in wdststr will
    08003      stop coping and result string will be null-terminated.
    08004    RETURNS
    08005      number of characters copied not including the ending null-terminator.
    08006    envhp(IN/OUT)
    08007      OCI environment handle to determine the character set .
    08008    wdststr(OUT)
    08009      Pointer to the destination wchar buffer.
    08010    wsrcstr(IN)
    08011      Pointer to the source wchar string.
    08012    n(IN)
    08013      Number of characters from wsrcstr to copy.
    08014 */
    08015 size_t OCIWideCharStrncpy(/*_ dvoid *envhp, OCIWchar *wdststr,
    08016                           CONST OCIWchar *wsrcstr, size_t n _*/);
    08017
    08018
    08019 /* ----------------------- OCIWideCharStrrchr -------------------------------*/
    08020 /*
    08021    NAME
    08022      OCIWideCharStrrchr - search the last occurrence of a wchar in wchar string
    08023    REMARKS
    08024      This function searchs for the last occurrence of wc in the wchar string
    08025      pointed to by wstr. It returns a pointer to the whcar if successful, or
    08026      a null pointer.
    08027    RETURNS
    08028      wchar pointer if successful, otherwise a null pointer.
    08029    envhp(IN/OUT)
    08030      OCI environment handle to determine the character set .
    08031    wstr(IN)
    08032      Pointer to the wchar string to search
    08033    wc(IN)
    08034      Wchar to search for.
    08035 */
    08036 OCIWchar *OCIWideCharStrrchr(/*_ dvoid *envhp, CONST OCIWchar *wstr,
    08037                              OCIWchar wc _*/);
    08038
    08039
    08040 /* --------------------- OCIWideCharStrCaseConversion -----------------------*/
    08041 /*
    08042    NAME
    08043      OCIWideCharStrCaseConversion - convert a wchar string into lowercase or
    08044                                     uppercase
    08045    REMARKS
    08046      This function convert the wide char string pointed to by wsrcstr into the
    08047      uppercase or lowercase specified by flag and copies the result into the
    08048      array pointed to by wdststr. The result string will be null-terminated.
    08049    RETURNS
    08050      number of characters for result string not including null-terminator.
    08051    envhp(IN/OUT)
    08052      OCI environment handle.
    08053    wdststr(OUT)
    08054      Pointer to destination array.
    08055    wsrcstr(IN)
    08056      Pointer to source string.
    08057    flag(IN)
    08058      Specify the case to convert:
    08059        OCI_NLS_UPPERCASE : convert to uppercase.
    08060        OCI_NLS_LOWERCASE: convert to lowercase.
    08061      This flag can be ORed with OCI_NLS_LINGUISTIC to specify that the
    08062      linguistic setting in the locale will be used for case conversion.
    08063 */
    08064 size_t OCIWideCharStrCaseConversion(/*_ dvoid *envhp, OCIWchar *wdststr,
    08065                                     CONST OCIWchar *wsrcstr, ub4 flag _*/);
    08066
    08067
    08068 /*---------------------- OCIWideCharDisplayLength ---------------------------*/
    08069 /*
    08070    NAME
    08071      OCIWideCharDisplayLength - Calculate the display length for a wchar
    08072    REMARKS
    08073      This function determines the number of column positions required for wc
    08074      in display. It returns number of column positions, or 0 if wc is
    08075      null-terminator.
    08076    RETURNS
    08077      Number of display positions.
    08078    envhp(IN/OUT)
    08079      OCI environment handle to determine the character set .
    08080    wc(IN)
    08081      Wchar character.
    08082 */
    08083 size_t OCIWideCharDisplayLength(/*_ dvoid *envhp, OCIWchar wc  _*/);
    08084
    08085
    08086 /*---------------------- OCIWideCharMultiByteLength -------------------------*/
    08087 /*
    08088    NAME
    08089      OCIWideCharMultiByteLength - Determine byte size in multi-byte encoding
    08090    REMARKS
    08091      This function determines the number of byte required for wc in multi-byte
    08092      encoding. It returns number of bytes in multi-byte for wc.
    08093    RETURNS
    08094      Number of bytes.
    08095    envhp(IN/OUT)
    08096      OCI environment handle to determine the character set .
    08097    wc(IN)
    08098      Wchar character.
    08099 */
    08100 size_t OCIWideCharMultiByteLength(/*_ dvoid *envhp, OCIWchar wc _*/);
    08101
    08102
    08103 /* ----------------------- OCIMultiByteStrcmp -------------------------------*/
    08104 /*
    08105    NAME
    08106      OCIMultiByteStrcmp - Compare two multi-byte strings
    08107    REMARKS
    08108      It compares two multi-byte strings in binary ( based on encoding value ),
    08109      linguistic, or case-insensitive.
    08110    RETURNS
    08111      0, if str1 == str2.
    08112      Positive, if str1 > str2.
    08113      Negative, if str1 < str2.
    08114    envhp(IN/OUT)
    08115      OCI environment handle to determine the character set.
    08116    str1(IN)
    08117      Pointer to a null-terminated string.
    08118    str2(IN)
    08119      Pointer to a null-terminated string.
    08120    flag(IN)
    08121      It is used to decide the comparison method. It can be taken one of the
    08122      following values:
    08123        OCI_NLS_BINARY: for the binary comparison, this is default value.
    08124        OCI_NLS_LINGUISTIC: for linguistic comparison specified in the locale.
    08125      This flag can be ORed with OCI_NLS_CASE_INSENSITIVE for case-insensitive
    08126      comparison.
    08127 */
    08128 int OCIMultiByteStrcmp(/*_ dvoid *envhp, CONST OraText *str1,
    08129                        CONST OraText *str2, int flag _*/);
    08130
    08131
    08132 /*----------------------- OCIMultiByteStrncmp -------------------------------*/
    08133 /*
    08134    NAME
    08135      OCIMultiByteStrncmp - compare two strings in length
    08136    REMARKS
    08137      This function is similar to OCIMultiBytestrcmp(), except that at most len1 bytes
    08138      from str1 and len2 bytes from str2 are compared. The null-terminator will
    08139      be taken into the comparison.
    08140    RETURNS
    08141      0, if str1 = str2
    08142      Positive, if str1 > str2
    08143      Negative, if str1 < str2
    08144    envhp(IN/OUT)
    08145      OCI environment handle to determine the character set.
    08146    str1(IN)
    08147      Pointer to the first string
    08148    len1(IN)
    08149      The length for the first string for comparison
    08150    str2(IN)
    08151      Pointer to the second string
    08152    len2(IN)
    08153      The length for the second string for comparison.
    08154    flag(IN)
    08155      It is used to decide the comparison method. It can be taken one of the
    08156      following values:
    08157        OCI_NLS_BINARY: for the binary comparison, this is default value.
    08158        OCI_NLS_LINGUISTIC: for linguistic comparison specified in the locale.
    08159      This flag can be ORed with OCI_NLS_CASE_INSENSITIVE for case-insensitive
    08160      comparison.
    08161 */
    08162 int OCIMultiByteStrncmp(/*_ dvoid *envhp, CONST OraText *str1, size_t len1,
    08163                         OraText *str2, size_t len2, int flag _*/);
    08164
    08165
    08166 /*----------------------- OCIMultiByteStrcat --------------------------------*/
    08167 /*
    08168    NAME
    08169      OCIMultiByteStrcat - concatenate multibyte strings
    08170    REMARKS
    08171      This function appends a copy of the multi-byte string pointed to by
    08172      srcstr, including the null-terminator to the end of string pointed to by
    08173      dststr. It returns the number of bytes in the result string not including
    08174      the ending null-terminator.
    08175    RETURNS
    08176      number of bytes in the result string not including the ending
    08177      null-terminator.
    08178    envhp(IN/OUT)
    08179      Pointer to OCI environment handle
    08180    dststr(IN/OUT)
    08181      Pointer to the destination multi-byte string for appending.
    08182    srcstr(IN)
    08183      Pointer to the source string to append.
    08184 */
    08185 size_t OCIMultiByteStrcat(/*_ dvoid *envhp, OraText *dststr,
    08186                           CONST OraText *srcstr _*/);
    08187
    08188
    08189 /*------------------------- OCIMultiByteStrcpy ------------------------------*/
    08190 /*
    08191    NAME
    08192      OCIMultiByteStrcpy - copy multibyte string
    08193    REMARKS
    08194      This function copies the multi-byte string pointed to by srcstr,
    08195      including the null-terminator, into the array pointed to by dststr. It
    08196      returns the number of bytes copied not including the ending
    08197      null-terminator.
    08198    RETURNS
    08199      number of bytes copied not including the ending null-terminator.
    08200    envhp(IN/OUT)
    08201      Pointer to the OCI environment handle.
    08202    srcstr(OUT)
    08203      Pointer to the destination buffer.
    08204    dststr(IN)
    08205      Pointer to the source multi-byte string.
    08206 */
    08207 size_t OCIMultiByteStrcpy(/*_ dvoid *envhp, OraText *dststr,
    08208                           CONST OraText *srcstr _*/);
    08209
    08210
    08211 /*----------------------- OCIMultiByteStrlen --------------------------------*/
    08212 /*
    08213    NAME
    08214      OCIMultiByteStrlen - Calculate multibyte string length
    08215    REMARKS
    08216      This function computes the number of bytes in the multi-byte string
    08217      pointed to by str, not including the null-terminator, and returns this
    08218      number.
    08219    RETURNS
    08220      number of bytes not including ending null-terminator.
    08221    str(IN)
    08222      Pointer to the source multi-byte string.
    08223 */
    08224 size_t OCIMultiByteStrlen(/*_ dvoid *envhp, CONST OraText *str _*/);
    08225
    08226
    08227 /*----------------------- OCIMultiByteStrncat -------------------------------*/
    08228 /*
    08229    NAME
    08230      OCIMultiByteStrncat - concatenate string in length
    08231    REMARKS
    08232      This function is similar to OCIMultiBytestrcat(), except that at most n
    08233      bytes from srcstr are appended to dststr. Note that the null-terminator in
    08234      srcstr will stop appending and the function will append as many character
    08235      as possible within n bytes. dststr will be null-terminated.
    08236    RETURNS
    08237      Number of bytes in the result string not including the ending
    08238      null-terminator.
    08239    envhp(IN/OUT)
    08240      Pointer to OCI environment handle.
    08241    srcstr(IN/OUT)
    08242      Pointer to the destination multi-byte string for appending.
    08243    dststr(IN)
    08244      Pointer to the source multi-byte string to append.
    08245    n(IN)
    08246      Number of bytes from srcstr to append.
    08247 */
    08248 size_t OCIMultiByteStrncat(/*_ dvoid *envhp, OraText *dststr,
    08249                            CONST OraText *srcstr, size_t n _*/);
    08250
    08251
    08252 /*----------------------- OCIMultiByteStrncpy -------------------------------*/
    08253 /*
    08254    NAME
    08255      OCIMultiByteStrncpy - copy multibyte string in length
    08256    REMARKS
    08257      This function is similar to OCIMultiBytestrcpy(), except that at most n
    08258      bytes are copied from the array pointed to by srcstr to the array pointed
    08259      to by dststr. Note that the null-terminator in srcstr will stop coping and
    08260      the function will copy as many character as possible within n bytes. The
    08261      result string will be null-terminated.
    08262    RETURNS
    08263      number of bytes copied not including the ending null-terminator.
    08264    envhp(IN/OUT)
    08265      Pointer to a OCI environment handle.
    08266    dststr(IN)
    08267      Pointer to the source multi-byte string.
    08268    srcstr(OUT)
    08269      Pointer to the destination buffer.
    08270    n(IN)
    08271      Number of bytes from srcstr to copy.
    08272 */
    08273 size_t OCIMultiByteStrncpy(/*_ dvoid *envhp, OraText *dststr,
    08274                            CONST OraText *srcstr, size_t n _*/);
    08275
    08276
    08277 /*----------------------- OCIMultiByteStrnDisplayLength ---------------------*/
    08278 /*
    08279    NAME
    08280      OCIMultiByteStrnDisplayLength - calculate the display length for a
    08281                                      multibyt string
    08282    REMARKS
    08283      This function returns the number of display positions occupied by the
    08284      complete characters within the range of n bytes.
    08285    RETURNS
    08286      number of display positions.
    08287    envhp(IN/OUT)
    08288      OCI environment handle.
    08289    str(IN)
    08290      Pointer to a multi-byte string.
    08291    n(IN)
    08292      Number of bytes to examine.
    08293 */
    08294 size_t OCIMultiByteStrnDisplayLength(/*_ dvoid *envhp, CONST OraText *str1,
    08295                                      size_t n _*/);
    08296
    08297
    08298 /*---------------------- OCIMultiByteStrCaseConversion  ---------------------*/
    08299 /*
    08300    NAME
    08301      OCIMultiByteStrCaseConversion
    08302    REMARKS
    08303      This function convert the multi-byte string pointed to by srcstr into the
    08304      uppercase or lowercase specified by flag and copies the result into the
    08305      array pointed to by dststr. The result string will be null-terminated.
    08306    RETURNS
    08307      number of bytes for result string not including null-terminator.
    08308    envhp(IN/OUT)
    08309      OCI environment handle.
    08310    dststr(OUT)
    08311      Pointer to destination array.
    08312    srcstr(IN)
    08313      Pointer to source string.
    08314    flag(IN)
    08315      Specify the case to convert:
    08316        OCI_NLS_UPPERCASE: convert to uppercase.
    08317        OCI_NLS_LOWERCASE: convert to lowercase.
    08318      This flag can be ORed with OCI_NLS_LINGUISTIC to specify that the
    08319      linguistic setting in the locale will be used for case conversion.
    08320 */
    08321 size_t OCIMultiByteStrCaseConversion(/*_ dvoid *envhp, OraText *dststr,
    08322                                      CONST OraText *srcstr, ub4 flag _*/);
    08323
    08324
    08325 /*------------------------- OCICharSetToUnicode -----------------------------*/
    08326 /*
    08327    NAME
    08328      OCICharSetToUnicode - convert multibyte string into Unicode as UCS2
    08329    REMARKS
    08330      This function converts a multi-byte string pointed to by src to Unicode
    08331      into the array pointed to by dst. The conversion will stop when it reach
    08332      to the source limitation or destination limitation.
    08333      The function will return number of characters converted into Unicode.
    08334      If dstlen is zero, it will just return the number of characters for the
    08335      result without real conversion.
    08336    RETURNS
    08337      OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR
    08338    envhp(IN/OUT)
    08339      Pointer to an OCI environment handle
    08340    dst(OUT)
    08341      Pointer to a destination buffer
    08342    dstlen(IN)
    08343      Size of destination buffer in character
    08344    src(IN)
    08345      Pointer to multi-byte source string.
    08346    srclen(IN)
    08347      Size of source string in bytes.
    08348    rsize(OUT)
    08349      Number of characters converted.
    08350      If it is a NULL pointer, nothing to return.
    08351 */
    08352 sword OCICharSetToUnicode(/*_ dvoid *envhp, ub2 *dst, size_t dstlen,
    08353                         CONST OraText *src, size_t  srclen, size_t *rsize _*/);
    08354
    08355
    08356 /*------------------------- OCIUnicodeToCharSet -----------------------------*/
    08357 /*
    08358    NAME
    08359      OCIUnicodeToCharSet - convert Unicode into multibyte
    08360    REMARKS
    08361      This function converts a Unicode string pointed to by src to multi-byte
    08362      into the array pointed to by dst. The conversion will stop when it reach
    08363      to the source limitation or destination limitation. The function will
    08364      return number of bytes converted into multi-byte. If dstlen is zero, it
    08365      will just return the number of bytes for the result without real
    08366      conversion. If a Unicode character is not convertible for the character
    08367      set specified in OCI environment handle, a replacement character will be
    08368      used for it. In this case, OCICharSetConversionIsReplacementUsed() will
    08369      return ture.
    08370    RETURNS
    08371      OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR
    08372    envhp(IN/OUT)
    08373      Pointer to an OCI environment handle.
    08374    dst(OUT)
    08375      Pointer to a destination buffer.
    08376    dstlen(IN)
    08377      Size of destination buffer in byte.
    08378    src(IN)
    08379      Pointer to a Unicode string.
    08380    srclen(IN)
    08381      Size of source string in characters.
    08382    rsize(OUT)
    08383      Number of bytes converted.
    08384      If it is a NULL pointer, nothing to return.
    08385 */
    08386 sword OCIUnicodeToCharSet(/*_ dvoid *envhp, OraText *dst, size_t dstlen,
    08387                            CONST ub2 *src, size_t srclen, size_t *rsize _*/);
    08388
    08389
    08390 /*----------------------- OCINlsCharSetConvert ------------------------------*/
    08391 /*
    08392    NAME
    08393      OCINlsCharSetConvert - convert between any two character set.
    08394    REMARKS
    08395      This function converts a string pointed to by src in the character set
    08396      specified with srcid to the array pointed to by dst in the character set
    08397      specified with dstid. The conversion will stop when it reaches the source
    08398      limitation or destination limitation. The function will return the number
    08399      of bytes converted into the destination buffer. Even though either source
    08400      or destination character set id is OCI_UTF16ID, given and return data
    08401      length will be represented with the byte length as this function is
    08402      intended for generic purpose. Note the conversion will not stop at null
    08403      data.
    08404      To get character set id from name, OCINlsCharSetNameToId can be used.
    08405      To check if derived data in the destination buffer contains any
    08406      replacement character resulting from conversion failure,
    08407      OCICharSetConversionIsReplacementUsed can be used to get the status.
    08408      Data alignment should be guaranteed by a caller. For example, UTF-16 data
    08409      should be aligned to ub2 type.
    08410
    08411    RETURNS
    08412      OCI_SUCCESS or OCI_ERROR.
    08413    errhp(IN/OUT)
    08414      OCI error handle. If there is an error, it is recorded in errhp and this
    08415      function returns a NULL pointer. Diagnostic information can be obtained
    08416      by calling OCIErrorGet().
    08417    dstid(IN)
    08418      Character set id for the destination buffer.
    08419    dstp(OUT)
    08420      Pointer to the destination buffer.
    08421    dstlen(IN)
    08422      The maximum byte size of destination buffer.
    08423    srcid(IN)
    08424      Character set id for the source buffer.
    08425    srcp(IN)
    08426      Pointer to the source buffer.
    08427    srclen(IN)
    08428      The length byte size of source buffer.
    08429    rsize(OUT)
    08430      The number of characters converted. If it is a NULL pointer, nothing to
    08431      return.
    08432 */
    08433 sword OCINlsCharSetConvert(/*_ dvoid *envhp, OCIError *errhp,
    08434                         ub2 dstid, dvoid *dstp, size_t dstlen,
    08435                         ub2 srcid, CONST dvoid *srcp, size_t srclen,
    08436                         size_t *rsize _*/);
    08437
    08438 /* ------------------- OCICharsetConversionIsReplacementUsed ----------------*/
    08439 /*
    08440    NAME
    08441      OCICharsetConversionIsReplacementUsed - chech if replacement is used in
    08442                                              conversion
    08443    REMARKS
    08444      This function indicates whether or not the replacement character was used
    08445      for nonconvertible characters in character set conversion in last invoke
    08446      of OCICharsetUcs2ToMb().
    08447    RETURNS
    08448      TRUE is the replacement character was used in last OCICharsetUcs2ToMb()
    08449      invoking, else FALSE.
    08450    envhp(IN/OUT)
    08451      OCI environment handle. This should be the first handle passed to
    08452      OCICharsetUcs2ToMb().
    08453 */
    08454 boolean OCICharSetConversionIsReplacementUsed(/*_ dvoid *envhp _*/);
    08455
    08456 /*------------------- OCINlsEnvironmentVariableGet -----------------*/
    08457 /*
    08458    NAME
    08459      OCINlsEnvironmentVariableGet - get a value of NLS environment variable.
    08460
    08461    DESCRIPTION
    08462      This function retrieves a value of NLS environment variable to the buffer
    08463      pointed to by val. Data type is determined by the parameter specified by
    08464      item. Either numeric data or string data can be retrieved.
    08465
    08466    RETURNS
    08467      OCI_SUCCESS or OCI_ERROR.
    08468
    08469    PARAMETERS
    08470    valp(OUT) -
    08471      Pointer to the buffer.
    08472    size(IN) -
    08473      Size of the buffer. This argument is only applicable to string data type,
    08474      but not to numerical data, in such case, it is ignored.
    08475    item(IN) -
    08476      NLS item value, which can be one of following values:
    08477        OCI_NLS_CHARSET_ID  - NLS_LANG character set id in ub2 data type.
    08478        OCI_NLS_NCHARSET_ID - NLS_NCHAR character set id in ub2 data type.
    08479    charset(IN) -
    08480      Character set id for retrieved string data. If it is 0, NLS_LANG will be
    08481      used. OCI_UTF16ID is a valid id. In case of numeric data, this argument
    08482      is ignored.
    08483    rsize(OUT) -
    08484      Size of return value.
    08485
    08486    NOTE
    08487      This functions is mainly used for retrieving character set id from either
    08488      NLS_LANG or NLS_NCHAR environment variables. If NLS_LANG is not set,
    08489      the default character set id is returned.
    08490      For future extension, the buffer is capable for storing other data types.
    08491 */
    08492 sword OCINlsEnvironmentVariableGet(/*_ dvoid  *valp, size_t size, ub2 item,
    08493                                    ub2 charset, size_t *rsize _*/);
    08494
    08495
    08496 /*------------------------- OCIMessageOpen ----------------------------------*/
    08497 /*
    08498    NAME
    08499      OCIMessageOpen - open a locale message file
    08500    REMARKS
    08501      This function opens a message handle for facility of product in a language
    08502      pointed to by envhp. It first try to open the message file corresponding
    08503      to envhp for the facility. If it successes, it will use that file to
    08504      initialize a message handle, else it will use the default message file
    08505      which is for American language for the facility. The function return a
    08506      pointer pointed to a message handle into msghp parameter.
    08507    RETURNS
    08508      OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR
    08509    envhp(IN/OUT)
    08510      A pointer to OCI environment handle for message language.
    08511    errhp(IN/OUT)
    08512      The OCI error handle. If there is an error, it is record in errhp and this
    08513      function returns a NULL pointer. Diagnostic information can be obtained by
    08514      calling OCIErrorGet().
    08515    msghp(OUT)
    08516      a message handle for return
    08517    product(IN)
    08518      A pointer to a product name. Product name is used to locate the directory
    08519      for message in a system dependent way. For example, in Solaris, the
    08520      directory of message files for the product `rdbms' is
    08521      `${ORACLE_HOME}/rdbms'.
    08522    facility(IN)
    08523      A pointer to a facility name in the product. It is used to construct a
    08524      message file name. A message file name follows the conversion with
    08525      facility as prefix. For example, the message file name for facility
    08526      `img' in American language will be `imgus.msb' where `us' is the
    08527      abbreviation of American language and `msb' as message binary file
    08528      extension.
    08529    dur(IN)
    08530      Duration for memory allocation for the return message handle. It can be
    08531      the following values:
    08532         OCI_DURATION_CALL
    08533         OCI_DURATION_STATEMENT
    08534         OCI_DURATION_SESSION
    08535         OCI_DURATION_TRANSACTION
    08536      For the detail description, please refer to Memory Related Service
    08537      Interfaces section.
    08538 */
    08539 sword OCIMessageOpen(/*_ dvoid *envhp, OCIError *errhp, OCIMsg **msghp,
    08540                       CONST OraText *product, CONST OraText *facility,
    08541                       OCIDuration dur _*/);
    08542
    08543
    08544 /*------------------------- OCIMessageGet -----------------------------------*/
    08545 /*
    08546    NAME
    08547      OCIMessageGet - get a locale message from a message handle
    08548    REMARKS
    08549      This function will get message with message number identified by msgno and
    08550      if buflen is not zero, the function will copy the message into the buffer
    08551      pointed to by msgbuf. If buflen is zero, the message will be copied into
    08552      a message buffer inside the message handle pointed to by msgh. For both
    08553      cases. it will return the pointer to the null-terminated message string.
    08554      If it cannot get the message required, it will return a NULL pointer.
    08555    RETURNS
    08556      A pointer to a null-terminated message string on success, otherwise a NULL
    08557      pointer.
    08558    msgh(IN/OUT)
    08559      Pointer to a message handle which was previously opened by OCIMessageOpen().
    08560    msgno(IN)
    08561      The message number for getting message.
    08562    msgbuf(OUT)
    08563      Pointer to a destination buffer to the message retrieved. If buflen is
    08564      zero, it can be NULL pointer.
    08565    buflen(IN)
    08566      The size of the above destination buffer.
    08567 */
    08568 OraText *OCIMessageGet(/*_ OCIMsg *msgh, ub4 msgno, OraText *msgbuf,
    08569                         size_t buflen _*/);
    08570
    08571
    08572 /*------------------------- OCIMessageClose ---------------------------------*/
    08573 /*
    08574    NAME
    08575      OCIMessageClose - close a message handle
    08576    REMARKS
    08577      This function closes a message handle pointed to by msgh and frees any
    08578      memory associated with this handle.
    08579    RETURNS
    08580      OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR
    08581    envhp(IN/OUT)
    08582      A pointer to OCI environment handle for message language.
    08583    errhp(IN/OUT)
    08584      The OCI error handle. If there is an error, it is record in errhp and this
    08585      function returns a NULL pointer. Diagnostic information can be obtained by
    08586      calling OCIErrorGet().
    08587    msghp(IN/OUT)
    08588      A pointer to a message handle which was previously opened by
    08589      OCIMessageOpen().
    08590 */
    08591 sword OCIMessageClose(/*_ dvoid *envhp, OCIError *errhp, OCIMsg *msghp _*/);
    08592
    08593 /*--------------- End of Extensions to NLS cartridge service ----------------*/
    08594
    08595 /*----------------- Extensions to OCI Thread interface ---------------------*/
    08596 /*****************************************************************************
    08597                               DESCRIPTION
    08598 ******************************************************************************
    08599 1 Threads Interface
    08600
    08601 The OCIThread package provides a number of commonly used threading
    08602 primitives for use by Oracle customers.  It offers a portable interface to
    08603 threading capabilities native to various platforms.  It does not implement
    08604 threading on platforms which do not have native threading capability.
    08605
    08606 OCIThread does not provide a portable implementation of multithreaded
    08607 facilities.  It only serves as a set of portable covers for native
    08608 multithreaded facilities.  Therefore, platforms that do not have native
    08609 support for multi-threading will only be able to support a limited
    08610 implementation of OCIThread.  As a result, products that rely on all of
    08611 OCIThread's functionality will not port to all platforms.  Products that must
    08612 port to all platforms must use only a subset of OCIThread's functionality.
    08613 This issue is discussed further in later sections of this document.
    08614
    08615 The OCIThread API is split into four main parts.  Each part is described
    08616 briefly here.  The following subsections describe each in greater detail.
    08617
    08618  1. Initialization and Termination Calls
    08619
    08620      These calls deal with the initialization and termination of OCIThread.
    08621      Initialization of OCIThread initializes the OCIThread context which is
    08622      a member of the OCI environment or session handle.  This context is
    08623      required for other OCIThread calls.
    08624
    08625  2. Passive Threading Primitives
    08626
    08627      The passive threading primitives include primitives to manipulate mutual
    08628      exclusion (mutex) locks, thread ID's, and thread-specific data keys.
    08629
    08630      The reason that these primitives are described as 'passive' is that while
    08631      their specifications allow for the existence of multiple threads, they do
    08632      not require it.  This means that it is possible for these primitives to
    08633      be implemented according to specification in both single-threaded and
    08634      multi-threaded environments.
    08635
    08636      As a result, OCIThread clients that use only these primitives will not
    08637      require the existence of multiple threads in order to work correctly,
    08638      i.e., they will be able to work in single-threaded environments without
    08639      branching code.
    08640
    08641  3. Active Threading Primitives
    08642
    08643      Active threading primitives include primitives dealing with the creation,
    08644      termination, and other manipulation of threads.
    08645
    08646      The reason that these primitives are described as 'active' is that they
    08647      can only be used in true multi-threaded environments.  Their
    08648      specifications explicitly require that it be possible to have multiple
    08649      threads.  If you need to determine at runtime whether or not you are in a
    08650      multi-threaded environment, call OCIThreadIsMulti() before calling an
    08651      OCIThread active primitive.
    08652
    08653
    08654 1.1 Initialization & Termination
    08655 ==================================
    08656
    08657 The types and functions described in this section are associated with the
    08658 initialization and termination of the OCIThread package.  OCIThread must
    08659 be properly initialized before any of its functionality can be used.
    08660 OCIThread's process initialization function, 'OCIThreadProcessInit()',
    08661 must be called with care; see below.
    08662
    08663 The observed behavior of the initialization and termination functions is the
    08664 same regardless of whether OCIThread is in single-threaded or multi-threaded
    08665 environment.  It is OK to call the initialization functions from both generic
    08666 and operating system specific (OSD) code.
    08667
    08668 1.1.1 Types
    08669
    08670   OCIThreadContext - OCIThread Context
    08671   -------------------------------------
    08672
    08673     Most calls to OCIThread functions take the OCI environment or session
    08674     handle as a parameter.  The OCIThread context is part of the OCI
    08675     environment or session handle and it must be initialized by calling
    08676     'OCIThreadInit()'.  Termination of the OCIThread context occurs by calling
    08677     'OCIThreadTerm()'.
    08678
    08679     The OCIThread context is a private data structure.  Clients must NEVER
    08680     attempt to examine the contents of the context.
    08681
    08682 1.1.2  OCIThreadProcessInit
    08683
    08684   OCIThreadProcessInit - OCIThread Process INITialization
    08685   --------------------------------------------------------
    08686
    08687     Description
    08688
    08689       This function should be called to perform OCIThread process
    08690       initialization.
    08691
    08692     Prototype
    08693
    08694       void OCIThreadProcessInit();
    08695
    08696     Returns
    08697
    08698       Nothing.
    08699
    08700     Notes
    08701
    08702       Whether or not this function needs to be called depends on how OCI
    08703       Thread is going to be used.
    08704
    08705         * In a single-threaded application, calling this function is optional.
    08706           If it is called at all, the first call to it must occur before calls
    08707           to any other OCIThread functions.  Subsequent calls can be made
    08708           without restriction; they will not have any effect.
    08709
    08710         * In a multi-threaded application, this function MUST be called.  The
    08711           first call to it MUST occur 'strictly before' any other OCIThread
    08712           calls; i.e., no other calls to OCIThread functions (including other
    08713           calls to this one) can be concurrent with the first call.
    08714           Subsequent calls to this function can be made without restriction;
    08715           they will not have any effect.
    08716
    08717
    08718 1.1.3 OCIThreadInit
    08719
    08720   OCIThreadInit - OCIThread INITialize
    08721   -------------------------------------
    08722
    08723     Description
    08724
    08725       This initializes OCIThread context.
    08726
    08727     Prototype
    08728
    08729       sword OCIThreadInit(dvoid *hndl, OCIError *err);
    08730
    08731         hndl(IN/OUT): The OCI environment or session handle.
    08732
    08733         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    08734                      is returned, the error is recorded in err and diagnostic
    08735                      information can be obtained by calling OCIErrorGet().
    08736
    08737     Returns
    08738
    08739       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    08740
    08741     Notes
    08742
    08743       It is illegal for OCIThread clients to try an examine the memory
    08744       pointed to by the returned pointer.
    08745
    08746       It is safe to make concurrent calls to 'OCIThreadInit()'.  Unlike
    08747       'OCIThreadProcessInit()',  there is no need to have a first call
    08748       that occurs before all the others.
    08749
    08750       The first time 'OCIThreadInit()' is called, it initilaizes the OCI
    08751       Thread context.  It also saves a pointer to the context in some system
    08752       dependent manner.  Subsequent calls to 'OCIThreadInit()' will return
    08753       the same context.
    08754
    08755       Each call to 'OCIThreadInit()' must eventually be matched by a call to
    08756       'OCIThreadTerm()'.
    08757
    08758   OCIThreadTerm - OCIThread TERMinate
    08759   ------------------------------------
    08760
    08761     Description
    08762
    08763       This should be called to release the OCIThread context.  It should be
    08764       called exactly once for each call made to 'OCIThreadInit()'.
    08765
    08766     Prototype
    08767
    08768       sword OCIThreadTerm(dvoid *hndl, OCIError *err);
    08769
    08770         hndl(IN/OUT): The OCI environment or session handle.
    08771
    08772         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    08773                      is returned, the error is recorded in err and diagnostic
    08774                      information can be obtained by calling OCIErrorGet().
    08775
    08776     Returns
    08777
    08778       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    08779
    08780     Notes
    08781
    08782       It is safe to make concurrent calls to 'OCIThreadTerm()'.
    08783
    08784       'OCIThreadTerm()' will not do anything until it has been called as
    08785       many times as 'OCIThreadInit()' has been called.  When that happens,
    08786       it terminates the OCIThread layer and frees the memory allocated for
    08787       the context.  Once this happens, the context should not be re-used.
    08788       It will be necessary to obtain a new one by calling 'OCIThreadInit()'.
    08789
    08790
    08791   OCIThreadIsMulti - OCIThread Is Multi-Threaded?
    08792   ------------------------------------------------
    08793
    08794     Description
    08795
    08796       This tells the caller whether the application is running in a
    08797       multi-threaded environment or a single-threaded environment.
    08798
    08799     Prototype
    08800       boolean OCIThreadIsMulti(void);
    08801
    08802     Returns
    08803
    08804       TRUE if the environment is multi-threaded;
    08805       FALSE if the environment is single-threaded.
    08806
    08807
    08808 1.2 Passive Threading Primitives
    08809 ==================================
    08810
    08811 1.2.1 Types
    08812
    08813 The passive threading primitives deal with the manipulation of mutex,
    08814 thread ID's, and thread-specific data.  Since the specifications of these
    08815 primitives do not require the existence of multiple threads, they can be
    08816 used both on multithreaded and single-threaded platforms.
    08817
    08818 1.2.1.1  OCIThreadMutex - OCIThread Mutual Exclusion Lock
    08819 -----------------------------------------------------------
    08820
    08821   The type 'OCIThreadMutex' is used to represent a mutual exclusion lock
    08822   (mutex).  A mutex is typically used for one of two purposes: (i) to
    08823   ensure that only one thread accesses a given set of data at a time, or
    08824   (ii) to ensure that only one thread executes a given critical section of
    08825   code at a time.
    08826
    08827   Mutexes pointer can be declared as parts of client structures or as
    08828   stand-alone variables.  Before they can be used, they must be initialized
    08829   using 'OCIThreadMutexInit()'.  Once they are no longer needed, they must be
    08830   destroyed using 'OCIThreadMutexDestroy()'.  A mutex pointer must NOT be
    08831   used after it is destroyed.
    08832
    08833   A thread can acquire a mutex by using either 'OCIThreadMutexAcquire()' or
    08834   'OCIThreadMutexTry()'.  They both ensure that only one thread at a time is
    08835   allowed to hold a given mutex.  A thread that holds a mutex can release it
    08836   by calling 'OCIThreadMutexRelease()'.
    08837
    08838
    08839 1.2.1.2  OCIThreadKey - OCIThread Key for Thread-Specific Data
    08840 ----------------------------------------------------------------
    08841
    08842   A key can be thought of as a process-wide variable that has a
    08843   thread-specific value.  What this means is that all the threads in a
    08844   process can use any given key.  However, each thread can examine or modify
    08845   that key independently of the other threads.  The value that a thread sees
    08846   when it examines the key will always be the same as the value that it last
    08847   set for the key.  It will not see any values set for the key by the other
    08848   threads.
    08849
    08850   The type of the value held by a key is a 'dvoid *' generic pointer.
    08851
    08852   Keys can be created using 'OCIThreadKeyInit()'.  When a key is created, its
    08853   value is initialized to 'NULL' for all threads.
    08854
    08855   A thread can set a key's value using 'OCIThreadKeySet()'.  A thread can
    08856   get a key's value using 'OCIThreadKeyGet()'.
    08857
    08858   The OCIThread key functions will save and retrieve data SPECIFIC TO THE
    08859   THREAD.  When clients maintain a pool of threads and assign the threads to
    08860   different tasks, it *may not* be appropriate for a task to use OCIThread
    08861   key functions to save data associated with it.  Here is a scenario of how
    08862   things can fail: A thread is assigned to execute the initialization of a
    08863   task.  During the initialization, the task stored some data related to it
    08864   in the thread using OCIThread key functions.  After the initialization,
    08865   the thread is returned back to the threads pool.  Later, the threads pool
    08866   manager assigned another thread to perform some operations on the task,
    08867   and the task needs to retrieve those data it stored earlier in
    08868   initialization.  Since the task is running in another thread, it will not
    08869   be able to retrieve the same data back!  Applications that use thread
    08870   pools should be aware of this and be cautious when using OCIThread key
    08871   functions.
    08872
    08873
    08874 1.2.1.3  OCIThreadKeyDestFunc - OCIThread Key Destructor Function Type
    08875 ------------------------------------------------------------------------
    08876
    08877   This is the type of a pointer to a key's destructor routine.  Keys can be
    08878   associated with a destructor routine when they are created (see
    08879   'OCIThreadKeyInit()').
    08880
    08881   A key's destructor routine will be called whenever a thread that has a
    08882   non-NULL value for the key terminates.
    08883
    08884   The destructor routine returns nothing and takes one parameter.  The
    08885   parameter will be the value that was set for key when the thread
    08886   terminated.
    08887
    08888   The destructor routine is guaranteed to be called on a thread's value
    08889   in the key after the termination of the thread and before process
    08890   termination.  No more precise guarantee can be made about the timing
    08891   of the destructor routine call; thus no code in the process may assume
    08892   any post-condition of the destructor routine.  In particular, the
    08893   destructor is not guaranteed to execute before a join call on the
    08894   terminated thread returns.
    08895
    08896
    08897 1.2.1.4  OCIThreadId - OCIThread Thread ID
    08898 --------------------------------------------
    08899
    08900   Type 'OCIThreadId' is the type that will be used to identify a thread.
    08901   At any given time, no two threads will ever have the same 'OCIThreadId'.
    08902   However, 'OCIThreadId' values can be recycled; i.e., once a thread dies,
    08903   a new thread may be created that has the same 'OCIThreadId' as the one
    08904   that died.  In particular, the thread ID must uniquely identify a thread
    08905   T within a process, and it must be consistent and valid in all threads U
    08906   of the process for which it can be guaranteed that T is running
    08907   concurrently with U.  The thread ID for a thread T must be retrievable
    08908   within thread T.  This will be done via OCIThreadIdGet().
    08909
    08910   The 'OCIThreadId' type supports the concept of a NULL thread ID: the NULL
    08911   thread ID will never be the same as the ID of an actual thread.
    08912
    08913
    08914
    08915 1.2.2 Function prototypes for passive primitives
    08916 --------------------------------------------------
    08917
    08918 1.2.2.1 Mutex functions
    08919 -------------------------
    08920
    08921   OCIThreadMutexInit - OCIThread MuteX Initialize
    08922   -----------------------------------------------
    08923
    08924     Description
    08925
    08926       This allocate and initializes a mutex.  All mutexes must be
    08927       initialized prior to use.
    08928
    08929     Prototype
    08930
    08931       sword OCIThreadMutexInit(dvoid *hndl, OCIError *err,
    08932                                OCIThreadMutex **mutex);
    08933
    08934         hndl(IN/OUT): The OCI environment or session handle.
    08935
    08936         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    08937                      is returned, the error is recorded in err and diagnostic
    08938                      information can be obtained by calling OCIErrorGet().
    08939
    08940         mutex(OUT):  The mutex to initialize.
    08941
    08942     Returns
    08943
    08944       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    08945
    08946     Notes
    08947
    08948       Multiple threads must not initialize the same mutex simultaneously.
    08949       Also, a mutex must not be reinitialized until it has been destroyed (see
    08950       'OCIThreadMutexDestroy()').
    08951
    08952   OCIThreadMutexDestroy - OCIThread MuteX Destroy
    08953   -----------------------------------------------
    08954
    08955     Description
    08956
    08957       This destroys and deallocate a mutex.  Each mutex must be destroyed
    08958       once it is no longer needed.
    08959
    08960     Prototype
    08961
    08962       sword OCIThreadMutexDestroy(dvoid *hndl, OCIError *err,
    08963                                   OCIThreadMutex **mutex);
    08964
    08965         hndl(IN/OUT): The OCI environment or session handle.
    08966
    08967         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    08968                      is returned, the error is recorded in err and diagnostic
    08969                      information can be obtained by calling OCIErrorGet().
    08970
    08971         mutex(IN/OUT):   The mutex to destroy.
    08972
    08973     Returns
    08974
    08975       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    08976
    08977     Notes
    08978
    08979       It is not legal to destroy a mutex that is uninitialized or is currently
    08980       held by a thread.  The destruction of a mutex must not occur concurrently
    08981       with any other operations on the mutex.  A mutex must not be used after
    08982       it has been destroyed.
    08983
    08984
    08985   OCIThreadMutexAcquire - OCIThread MuteX Acquire
    08986   -----------------------------------------------
    08987
    08988     Description
    08989
    08990       This acquires a mutex for the thread in which it is called.  If the mutex
    08991       is held by another thread, the calling thread is blocked until it can
    08992       acquire the mutex.
    08993
    08994     Prototype
    08995
    08996      sword OCIThreadMutexAcquire(dvoid *hndl, OCIError *err,
    08997                                  OCIThreadMutex *mutex);
    08998
    08999         hndl(IN/OUT): The OCI environment or session handle.
    09000
    09001         err(IN/OUT): The OCI error handle.  If there is an error, it is
    09002                      recorded in err and this function returns OCI_ERROR.
    09003                      Diagnostic information can be obtained by calling
    09004                      OCIErrorGet().
    09005
    09006         mutex(IN/OUT):   The mutex to acquire.
    09007
    09008     Returns
    09009
    09010       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09011
    09012     Notes
    09013
    09014       It is illegal to attempt to acquire an uninitialized mutex.
    09015
    09016       This function's behavior is undefined if it is used by a thread to
    09017       acquire a mutex that is already held by that thread.
    09018
    09019
    09020
    09021   OCIThreadMutexRelease - OCIThread MuteX Release
    09022   -----------------------------------------------
    09023
    09024     Description
    09025
    09026       This releases a mutex.  If there are any threads blocked on the mutex,
    09027       one of them will acquire it and become unblocked.
    09028
    09029     Prototype
    09030
    09031       sword OCIThreadMutexRelease(dvoid *hndl, OCIError *err,
    09032                                   OCIThreadMutex *mutex);
    09033
    09034         hndl(IN/OUT): The OCI environment or session handle.
    09035
    09036         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09037                      is returned, the error is recorded in err and diagnostic
    09038                      information can be obtained by calling OCIErrorGet().
    09039
    09040         mutex(IN/OUT):   The mutex to release.
    09041
    09042     Returns
    09043
    09044       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09045
    09046     Notes
    09047
    09048       It is illegal to attempt to release an uninitialized mutex.  It is also
    09049       illegal for a thread to release a mutex that it does not hold.
    09050
    09051
    09052   OCIThreadKeyInit - OCIThread KeY Initialize
    09053   -------------------------------------------
    09054
    09055     Description
    09056
    09057       This creates a key.  Each call to this routine allocate and generates
    09058       a new key that is distinct from all other keys.
    09059
    09060     Prototype
    09061
    09062       sword OCIThreadKeyInit(dvoid *hndl, OCIError *err, OCIThreadKey **key,
    09063                              OCIThreadKeyDestFunc destFn);
    09064
    09065         hndl(IN/OUT): The OCI environment or session handle.
    09066
    09067         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09068                      is returned, the error is recorded in err and diagnostic
    09069                      information can be obtained by calling OCIErrorGet().
    09070
    09071         key(OUT):    The 'OCIThreadKey' in which to create the new key.
    09072
    09073         destFn(IN):  The destructor for the key.  NULL is permitted.
    09074
    09075     Returns
    09076
    09077       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09078
    09079     Notes
    09080
    09081       Once this function executes successfully, a pointer to an allocated and
    09082       initialized key is return.  That key can be used with 'OCIThreadKeyGet()'
    09083       and 'OCIThreadKeySet()'.  The initial value of the key will be 'NULL' for
    09084       all threads.
    09085
    09086       It is illegal for this function to be called more than once to create the
    09087       same key (i.e., to be called more than once with the same value for the
    09088       'key' parameter).
    09089
    09090       If the 'destFn' parameter is not NULL, the routine pointed to by 'destFn'
    09091       will be called whenever a thread that has a non-NULL value for the key
    09092       terminates.  The routine will be called with one parameter.  The
    09093       parameter will be the key's value for the thread at the time at which the
    09094       thread terminated.
    09095       If the key does not need a destructor function, pass NULL for 'destFn'.
    09096
    09097
    09098   OCIThreadKeyDestroy - OCIThread KeY DESTROY
    09099   -------------------------------------------
    09100
    09101    Description
    09102
    09103      Destroy and deallocate the key pointed to by 'key'.
    09104
    09105     Prototype
    09106
    09107       sword OCIThreadKeyDestroy(dvoid *hndl, OCIError *err,
    09108                                 OCIThreadKey **key);
    09109
    09110         hndl(IN/OUT): The OCI environment or session handle.
    09111
    09112         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09113                      is returned, the error is recorded in err and diagnostic
    09114                      information can be obtained by calling OCIErrorGet().
    09115
    09116         key(IN/OUT):  The 'OCIThreadKey' in which to destroy the key.
    09117
    09118     Returns
    09119
    09120       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09121
    09122     Notes
    09123
    09124       This is different from the destructor function callback passed to the
    09125       key create routine.  This new destroy function 'OCIThreadKeyDestroy' is
    09126       used to terminate any resources OCI THREAD acquired when it created
    09127       'key'.  [The 'OCIThreadKeyDestFunc' callback type is a key VALUE
    09128       destructor; it does in no way operate on the key itself.]
    09129
    09130       This must be called once the user has finished using the key.  Not
    09131       calling the key destroy function may result in memory leaks.
    09132
    09133
    09134
    09135
    09136 1.2.2.2 Thread Key operations
    09137 -------------------------------
    09138
    09139   OCIThreadKeyGet - OCIThread KeY Get value
    09140   -----------------------------------------
    09141
    09142     Description
    09143
    09144       This gets the calling thread's current value for a key.
    09145
    09146     Prototype
    09147
    09148       sword OCIThreadKeyGet(dvoid *hndl, OCIError *err, OCIThreadKey *key,
    09149                             dvoid **pValue);
    09150
    09151         hndl(IN/OUT): The OCI environment or session handle.
    09152
    09153         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09154                      is returned, the error is recorded in err and diagnostic
    09155                      information can be obtained by calling OCIErrorGet().
    09156
    09157         key(IN):          The key.
    09158
    09159         pValue(IN/OUT):   The location in which to place the thread-specific
    09160                           key value.
    09161
    09162     Returns
    09163
    09164       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09165
    09166     Notes
    09167
    09168       It is illegal to use this function on a key that has not been created
    09169       using 'OCIThreadKeyInit()'.
    09170
    09171       If the calling thread has not yet assigned a value to the key, 'NULL' is
    09172       placed in the location pointed to by 'pValue'.
    09173
    09174
    09175   OCIThreadKeySet - OCIThread KeY Set value
    09176   -----------------------------------------
    09177
    09178     Description
    09179
    09180       This sets the calling thread's value for a key.
    09181
    09182     Prototype
    09183
    09184       sword OCIThreadKeySet(dvoid *hndl, OCIError *err, OCIThreadKey *key,
    09185                             dvoid *value);
    09186
    09187         hndl(IN/OUT): The OCI environment or session handle.
    09188
    09189         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09190                      is returned, the error is recorded in err and diagnostic
    09191                      information can be obtained by calling OCIErrorGet().
    09192
    09193         key(IN/OUT): The key.
    09194
    09195         value(IN):   The thread-specific value to set in the key.
    09196
    09197     Returns
    09198
    09199       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09200
    09201     Notes
    09202
    09203       It is illegal to use this function on a key that has not been created
    09204       using 'OCIThreadKeyInit()'.
    09205
    09206 1.2.2.3  Thread Id
    09207 --------------------
    09208
    09209   OCIThreadIdInit - OCIThread Thread Id INITialize
    09210   --------------------------------------------------
    09211
    09212     Description
    09213
    09214       Allocate and initialize the thread id 'tid'.
    09215
    09216     Prototype
    09217
    09218       sword OCIThreadIdInit(dvoid *hndl, OCIError *err, OCIThreadId **tid);
    09219
    09220         hndl(IN/OUT): The OCI environment or session handle.
    09221
    09222         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09223                      is returned, the error is recorded in err and diagnostic
    09224                      information can be obtained by calling OCIErrorGet().
    09225
    09226         tid (OUT):   Pointer to the thread ID to initialize.
    09227
    09228     Returns
    09229
    09230       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09231
    09232
    09233   OCIThreadIdDestroy - OCIThread Thread Id DESTROY
    09234   --------------------------------------------------
    09235
    09236     Description
    09237
    09238       Destroy and deallocate the thread id 'tid'.
    09239
    09240     Prototype
    09241
    09242       sword OCIThreadIdDestroy(dvoid *hndl, OCIError *err, OCIThreadId **tid);
    09243
    09244         hndl(IN/OUT): The OCI environment or session handle.
    09245
    09246         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09247                      is returned, the error is recorded in err and diagnostic
    09248                      information can be obtained by calling OCIErrorGet().
    09249
    09250         tid(IN/OUT):        Pointer to the thread ID to destroy.
    09251
    09252     Returns
    09253
    09254       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09255
    09256     Note
    09257
    09258       'tid' should be initialized by OCIThreadIdInit().
    09259
    09260
    09261   OCIThreadIdSet - OCIThread Thread Id Set
    09262   -----------------------------------------
    09263
    09264     Description
    09265
    09266       This sets one 'OCIThreadId' to another.
    09267
    09268     Prototype
    09269
    09270       sword OCIThreadIdSet(dvoid *hndl, OCIError *err,
    09271                            OCIThreadId *tidDest,
    09272                            OCIThreadId *tidSrc);
    09273
    09274         hndl(IN/OUT): The OCI environment or session handle.
    09275
    09276         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09277                      is returned, the error is recorded in err and diagnostic
    09278                      information can be obtained by calling OCIErrorGet().
    09279
    09280         tidDest(OUT):   This should point to the location of the 'OCIThreadId'
    09281                         to be set to.
    09282
    09283         tidSrc(IN):     This should point to the 'OCIThreadId' to set from.
    09284
    09285     Returns
    09286
    09287       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09288
    09289     Notes
    09290
    09291       'tid' should be initialized by OCIThreadIdInit().
    09292
    09293
    09294   OCIThreadIdSetNull - OCIThread Thread Id Set Null
    09295   ---------------------------------------------------------
    09296
    09297     Description
    09298
    09299       This sets the NULL thread ID to a given 'OCIThreadId'.
    09300
    09301     Prototype
    09302
    09303       sword OCIThreadIdSetNull(dvoid *hndl, OCIError *err,
    09304                                OCIThreadId *tid);
    09305
    09306         hndl(IN/OUT): The OCI environment or session handle.
    09307
    09308         err(IN/OUT): The OCI error handle.  If there is an error, it is
    09309                      recorded in err and this function returns OCI_ERROR.
    09310                      Diagnostic information can be obtained by calling
    09311                      OCIErrorGet().
    09312
    09313         tid(OUT):    This should point to the 'OCIThreadId' in which to put
    09314                      the NULL thread ID.
    09315
    09316     Returns
    09317
    09318       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09319
    09320     Notes
    09321
    09322       'tid' should be initialized by OCIThreadIdInit().
    09323
    09324
    09325   OCIThreadIdGet - OCIThread Thread Id Get
    09326   ------------------------------------------
    09327
    09328     Description
    09329
    09330       This retrieves the 'OCIThreadId' of the thread in which it is called.
    09331
    09332     Prototype
    09333
    09334       sword OCIThreadIdGet(dvoid *hndl, OCIError *err,
    09335                            OCIThreadId *tid);
    09336
    09337         hndl(IN/OUT): The OCI environment or session handle.
    09338
    09339         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09340                      is returned, the error is recorded in err and diagnostic
    09341                      information can be obtained by calling OCIErrorGet().
    09342
    09343         tid(OUT):    This should point to the location in which to place the
    09344                      ID of the calling thread.
    09345
    09346     Returns
    09347
    09348       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09349
    09350     Notes
    09351
    09352       'tid' should be initialized by OCIThreadIdInit().
    09353
    09354       When OCIThread is used in a single-threaded environment,
    09355       OCIThreadIdGet() will always place the same value in the location
    09356       pointed to by 'tid'.  The exact value itself is not important.  The
    09357       important thing is that it is not the same as the NULL thread ID and
    09358       that it is always the same value.
    09359
    09360
    09361   OCIThreadIdSame - OCIThread Thread Ids Same?
    09362   ----------------------------------------------
    09363
    09364     Description
    09365
    09366       This determines whether or not two 'OCIThreadId's represent the same
    09367       thread.
    09368
    09369     Prototype
    09370
    09371       sword OCIThreadIdSame(dvoid *hndl, OCIError *err,
    09372                             OCIThreadId *tid1, OCIThreadId *tid2,
    09373                             boolean *result);
    09374
    09375         hndl(IN/OUT): The OCI environment or session handle.
    09376
    09377         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09378                      is returned, the error is recorded in err and diagnostic
    09379                      information can be obtained by calling OCIErrorGet().
    09380
    09381         tid1(IN):   Pointer to the first 'OCIThreadId'.
    09382
    09383         tid2(IN):   Pointer to the second 'OCIThreadId'.
    09384
    09385            result(IN/OUT): Pointer to the result.
    09386
    09387     Returns
    09388
    09389       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09390
    09391     Notes
    09392
    09393       If 'tid1' and 'tid2' represent the same thread, 'result' is set to TRUE.
    09394       Otherwise, 'result' is set to FALSE.
    09395
    09396       'result' is set to TRUE if both 'tid1' and 'tid2' are the NULL thread ID.
    09397
    09398       'ti1d' and 'tid2' should be initialized by OCIThreadIdInit().
    09399
    09400
    09401   OCIThreadIdNull - OCIThread Thread Id NULL?
    09402   ---------------------------------------------
    09403
    09404     Description
    09405
    09406       This determines whether or not a given 'OCIThreadId' is the NULL thread
    09407       ID.
    09408
    09409     Prototype
    09410
    09411       sword OCIThreadIdNull(dvoid *hndl, OCIError *err,
    09412                             OCIThreadId *tid,
    09413                             boolean *result);
    09414
    09415         hndl(IN/OUT): The OCI environment or session handle.
    09416
    09417         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09418                      is returned, the error is recorded in err and diagnostic
    09419                      information can be obtained by calling OCIErrorGet().
    09420
    09421         tid(IN):    Pointer to the 'OCIThreadId' to check.
    09422
    09423            result(IN/OUT): Pointer to the result.
    09424
    09425     Returns
    09426
    09427       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09428
    09429     Notes
    09430
    09431       If 'tid' is the NULL thread ID, 'result' is set to TRUE.  Otherwise,
    09432       'result' is set to FALSE.
    09433
    09434       'tid' should be initialized by OCIThreadIdInit().
    09435
    09436
    09437 1.3 Active Threading Primitives
    09438 =================================
    09439
    09440 The active threading primitives deal with the manipulation of actual
    09441 threads.  Because the specifications of most of these primitives require
    09442 that it be possible to have multiple threads, they work correctly only in
    09443 the enabled OCIThread; In the disabled OCIThread, they always return
    09444 failure.  The exception is OCIThreadHandleGet(); it may be called in a
    09445 single-threaded environment, in which case it will have no effect.
    09446
    09447 Active primitives should only be called by code running in a multi-threaded
    09448 environment.  You can call OCIThreadIsMulti() to determine whether the
    09449 environment is multi-threaded or single-threaded.
    09450
    09451
    09452 1.3.1  Types
    09453 --------------
    09454
    09455 1.3.1.1    OCIThreadHandle - OCIThread Thread Handle
    09456 ------------------------------------------------------
    09457
    09458   Type 'OCIThreadHandle' is used to manipulate a thread in the active
    09459   primitives:  OCIThreadJoin()and OCIThreadClose().  A thread handle opened by
    09460   OCIThreadCreate() must be closed in a matching call to
    09461   OCIThreadClose().  A thread handle is invalid after the call to
    09462   OCIThreadClose().
    09463
    09464   The distinction between a thread ID and a thread handle in OCIThread usage
    09465   follows the distinction between the thread ID and the thread handle on
    09466   Windows NT.  On many platforms, the underlying native types are the same.
    09467
    09468
    09469 1.3.2  Functions
    09470 ------------------
    09471
    09472   OCIThreadHndInit - OCIThread HaNDle Initialize
    09473   ----------------------------------------------
    09474
    09475     Description
    09476
    09477       Allocate and initialize the thread handle.
    09478
    09479     Prototype
    09480
    09481       sword OCIThreadHndInit(dvoid *hndl, OCIError *err,
    09482                              OCIThreadHandle **thnd);
    09483
    09484         hndl(IN/OUT): The OCI environment or session handle.
    09485
    09486         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09487                      is returned, the error is recorded in err and diagnostic
    09488                      information can be obtained by calling OCIErrorGet().
    09489
    09490         thnd(OUT):   The address of pointer to the thread handle to initialize.
    09491
    09492     Returns
    09493
    09494       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09495
    09496
    09497   OCIThreadHndDestroy - OCIThread HaNDle Destroy
    09498   ----------------------------------------------
    09499
    09500     Description
    09501
    09502       Destroy and deallocate the thread handle.
    09503
    09504     Prototype
    09505
    09506       sword OCIThreadHndDestroy(dvoid *hndl, OCIError *err,
    09507                                 OCIThreadHandle **thnd);
    09508
    09509         hndl(IN/OUT): The OCI environment or session handle.
    09510
    09511         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09512                      is returned, the error is recorded in err and diagnostic
    09513                      information can be obtained by calling OCIErrorGet().
    09514
    09515         thnd(IN/OUT):  The address of pointer to the thread handle to destroy.
    09516
    09517     Returns
    09518
    09519       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09520
    09521     Notes
    09522
    09523       'thnd' should be initialized by OCIThreadHndInit().
    09524
    09525
    09526   OCIThreadCreate - OCIThread Thread Create
    09527   -----------------------------------------
    09528
    09529     Description
    09530
    09531       This creates a new thread.
    09532
    09533     Prototype
    09534
    09535       sword OCIThreadCreate(dvoid *hndl, OCIError *err,
    09536                             void (*start)(dvoid *), dvoid *arg,
    09537                             OCIThreadId *tid, OCIThreadHandle *tHnd);
    09538
    09539         hndl(IN/OUT): The OCI environment or session handle.
    09540
    09541         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09542                      is returned, the error is recorded in err and diagnostic
    09543                      information can be obtained by calling OCIErrorGet().
    09544
    09545         start(IN):    The function in which the new thread should begin
    09546                       execution.
    09547
    09548         arg(IN):      The argument to give the function pointed to by 'start'.
    09549
    09550         tid(IN/OUT):  If not NULL, gets the ID for the new thread.
    09551
    09552         tHnd(IN/OUT): If not NULL, gets the handle for the new thread.
    09553
    09554     Returns
    09555
    09556       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09557
    09558     Notes
    09559
    09560       The new thread will start by executing a call to the function pointed
    09561       to by 'start' with the argument given by 'arg'.  When that function
    09562       returns, the new thread will terminate.  The function should not
    09563       return a value and should accept one parameter, a 'dvoid *'.
    09564
    09565       The call to OCIThreadCreate() must be matched by a call to
    09566       OCIThreadClose() if and only if tHnd is non-NULL.
    09567
    09568       If tHnd is NULL, a thread ID placed in *tid will not be valid in the
    09569       calling thread because the timing of the spawned thread's termination
    09570       is unknown.
    09571
    09572       'tid' should be initialized by OCIThreadIdInit().
    09573
    09574       'thnd' should be initialized by OCIThreadHndInit().
    09575
    09576
    09577
    09578   OCIThreadJoin - OCIThread Thread Join
    09579   -------------------------------------
    09580
    09581     Description
    09582
    09583       This function allows the calling thread to 'join' with another thread.
    09584       It blocks the caller until the specified thread terminates.
    09585
    09586     Prototype
    09587
    09588       sword OCIThreadJoin(dvoid *hndl, OCIError *err, OCIThreadHandle *tHnd);
    09589
    09590         hndl(IN/OUT): The OCI environment or session handle.
    09591
    09592         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09593                      is returned, the error is recorded in err and diagnostic
    09594                      information can be obtained by calling OCIErrorGet().
    09595
    09596         tHnd(IN):    The 'OCIThreadHandle' of the thread to join with.
    09597
    09598     Returns
    09599
    09600       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09601
    09602     Notes
    09603
    09604       'thnd' should be initialized by OCIThreadHndInit().
    09605
    09606       The result of multiple threads all trying to join with the same thread is
    09607       undefined.
    09608
    09609
    09610   OCIThreadClose - OCIThread Thread Close
    09611   ---------------------------------------
    09612
    09613    Description
    09614
    09615      This function should be called to close a thread handle.
    09616
    09617    Prototype
    09618
    09619      sword OCIThreadClose(dvoid *hndl, OCIError *err, OCIThreadHandle *tHnd);
    09620
    09621         hndl(IN/OUT): The OCI environment or session handle.
    09622
    09623         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09624                      is returned, the error is recorded in err and diagnostic
    09625                      information can be obtained by calling OCIErrorGet().
    09626
    09627         tHnd(IN/OUT):    The OCIThread thread handle to close.
    09628
    09629    Returns
    09630
    09631       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09632
    09633    Notes
    09634
    09635       'thnd' should be initialized by OCIThreadHndInit().
    09636
    09637       Both thread handle and the thread ID that was returned by the same call
    09638       to OCIThreadCreate() are invalid after the call to OCIThreadClose().
    09639
    09640
    09641
    09642   OCIThreadHandleGet - OCIThread Thread Get Handle
    09643   ------------------------------------------------
    09644
    09645     Description
    09646
    09647       Retrieve the 'OCIThreadHandle' of the thread in which it is called.
    09648
    09649     Prototype
    09650
    09651       sword OCIThreadHandleGet(dvoid *hndl, OCIError *err,
    09652                                OCIThreadHandle *tHnd);
    09653
    09654         hndl(IN/OUT): The OCI environment or session handle.
    09655
    09656         err(IN/OUT): The OCI error handle.  If there is an error and OCI_ERROR
    09657                      is returned, the error is recorded in err and diagnostic
    09658                      information can be obtained by calling OCIErrorGet().
    09659
    09660         tHnd(IN/OUT):      If not NULL, the location to place the thread
    09661                            handle for the thread.
    09662
    09663      Returns
    09664
    09665       OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE.
    09666
    09667     Notes
    09668
    09669       'thnd' should be initialized by OCIThreadHndInit().
    09670
    09671       The thread handle 'tHnd' retrieved by this function must be closed
    09672       with OCIThreadClose() and destroyed by OCIThreadHndDestroy() after it
    09673       is used.
    09674
    09675
    09676
    09677
    09678 1.4 Using OCIThread
    09679 =====================
    09680
    09681 This section summarizes some of the more important details relating to the use
    09682 of OCIThread.
    09683
    09684   * Process initialization
    09685
    09686     OCIThread only requires that the process initialization function
    09687     ('OCIThreadProcessInit()') be called when OCIThread is being used in a
    09688     multi-threaded application.  Failing to call 'OCIThreadProcessInit()' in
    09689     a single-threaded application is not an error.
    09690
    09691   * OCIThread initialization
    09692
    09693     Separate calls to 'OCIThreadInit()' will all return the same OCIThread
    09694     context.
    09695
    09696     Also, remember that each call to 'OCIThreadInit()' must eventually be
    09697     matched by a call to 'OCIThreadTerm()'.
    09698
    09699   * Active vs. Passive Threading primitives
    09700
    09701     OCIThread client code written without using any active primitives can be
    09702     compiled and used without change on both single-threaded and
    09703     multi-threaded platforms.
    09704
    09705     OCIThread client code written using active primitives will only work
    09706     correctly on multi-threaded platforms.  In order to write a version of the
    09707     same application to run on single-threaded platform, it is necessary to
    09708     branch the your code, whether by branching versions of the source file or
    09709     by branching at runtime with the OCIThreadIsMulti() call.
    09710 ******************************************************************************/
    09711
    09712 /*****************************************************************************
    09713                          ACTUAL PROTOTYPE DECLARATIONS
    09714 ******************************************************************************/
    09715
    09716 void OCIThreadProcessInit(/*_ _*/);
    09717
    09718 sword OCIThreadInit(/*_ dvoid *hndl, OCIError *err _*/);
    09719
    09720 sword OCIThreadTerm(/*_ dvoid *hndl, OCIError *err _*/);
    09721
    09722 boolean OCIThreadIsMulti(/*_ void _*/);
    09723
    09724 sword OCIThreadMutexInit(/*_ dvoid *hndl, OCIError *err,
    09725                              OCIThreadMutex **mutex _*/);
    09726
    09727 sword OCIThreadMutexDestroy(/*_ dvoid *hndl, OCIError *err,
    09728                                 OCIThreadMutex **mutex _*/);
    09729
    09730 sword OCIThreadMutexAcquire(/*_ dvoid *hndl, OCIError *err,
    09731                                 OCIThreadMutex *mutex _*/);
    09732
    09733 sword OCIThreadMutexRelease(/*_ dvoid *hndl, OCIError *err,
    09734                                 OCIThreadMutex *mutex _*/);
    09735
    09736 sword OCIThreadKeyInit(/*_ dvoid *hndl, OCIError *err, OCIThreadKey **key,
    09737                            OCIThreadKeyDestFunc destFn _*/);
    09738
    09739 sword OCIThreadKeyDestroy(/*_ dvoid *hndl, OCIError *err,
    09740                               OCIThreadKey **key _*/);
    09741
    09742 sword OCIThreadKeyGet(/*_ dvoid *hndl, OCIError *err, OCIThreadKey *key,
    09743                           dvoid **pValue _*/);
    09744
    09745 sword OCIThreadKeySet(/*_ dvoid *hndl, OCIError *err, OCIThreadKey *key,
    09746                           dvoid *value _*/);
    09747
    09748 sword OCIThreadIdInit(/*_ dvoid *hndl, OCIError *err, OCIThreadId **tid _*/);
    09749
    09750 sword OCIThreadIdDestroy(/*_ dvoid *hndl, OCIError *err,
    09751                              OCIThreadId **tid _*/);
    09752
    09753 sword OCIThreadIdSet(/*_ dvoid *hndl, OCIError *err,
    09754                          OCIThreadId *tidDest, OCIThreadId *tidSrc _*/);
    09755
    09756 sword OCIThreadIdSetNull(/*_ dvoid *hndl, OCIError *err, OCIThreadId *tid _*/);
    09757
    09758 sword OCIThreadIdGet(/*_ dvoid *hndl, OCIError *err, OCIThreadId *tid _*/);
    09759
    09760 sword OCIThreadIdSame(/*_ dvoid *hndl, OCIError *err,
    09761                           OCIThreadId *tid1, OCIThreadId *tid2,
    09762                           boolean *result _*/);
    09763
    09764 sword OCIThreadIdNull(/*_ dvoid *hndl, OCIError *err,
    09765                           OCIThreadId *tid, boolean *result _*/);
    09766
    09767 sword OCIThreadHndInit(/*_ dvoid *hndl, OCIError *err,
    09768                            OCIThreadHandle **thnd _*/);
    09769
    09770 sword OCIThreadHndDestroy(/*_ dvoid *hndl, OCIError *err,
    09771                               OCIThreadHandle **thnd _*/);
    09772
    09773 sword OCIThreadCreate(/*_ dvoid *hndl, OCIError *err,
    09774                           void (*start)(dvoid *), dvoid *arg,
    09775                           OCIThreadId *tid, OCIThreadHandle *tHnd _*/);
    09776
    09777 sword OCIThreadJoin(/*_ dvoid *hndl, OCIError *err, OCIThreadHandle *tHnd _*/);
    09778
    09779 sword OCIThreadClose(/*_ dvoid *hndl, OCIError *err,
    09780                          OCIThreadHandle *tHnd _*/);
    09781
    09782 sword OCIThreadHandleGet(/*_ dvoid *hndl, OCIError *err,
    09783                              OCIThreadHandle *tHnd _*/);
    09784 /*----------------- End OCI Thread interface Extensions ---------------------*/
    09785
    09786 /*--------------- Begin OCI Client Notification Interfaces ------------------*/
    09787
    09788 typedef ub4 (*OCISubscriptionNotify)(/*_ dvoid *ctx, OCISubscription *subscrhp,
    09789                                          dvoid *pay, ub4 payl,
    09790                                          dvoid *desc, ub4 mode _*/);
    09791
    09792 sword OCISubscriptionRegister (/*_ OCISvcCtx *svchp,
    09793                               OCISubscription **subscrhpp, ub2 count,
    09794                               OCIError *errhp, ub4 mode _*/);
    09795
    09796 sword OCISubscriptionPost (/*_ OCISvcCtx *svchp, OCISubscription **subscrhpp,
    09797                                ub2 count, OCIError *errhp, ub4 mode _*/);
    09798
    09799 sword OCISubscriptionUnRegister (/*_ OCISvcCtx *svchp,
    09800                                 OCISubscription *subscrhp, OCIError *errhp,
    09801                                 ub4 mode _*/);
    09802
    09803 sword OCISubscriptionDisable (/*_ OCISubscription *subscrhp,
    09804                                   OCIError *errhp, ub4 mode _*/);
    09805
    09806 sword OCISubscriptionEnable (/*_ OCISubscription *subscrhp,
    09807                                  OCIError *errhp, ub4 mode _*/);
    09808
    09809 /*------------------- End OCI Client Notification Interfaces ----------------*/
    09810
    09811 /*----------------- Extensions to Datetime interfaces -----------------------*/
    09812
    09813 sword OCIDateTimeGetTime(/*_ dvoid *hndl, OCIError *err,
    09814                                     OCIDateTime *datetime, ub1 *hour, ub1 *min,
    09815                                     ub1 *sec, ub4 *fsec_*/);
    09816
    09817 sword OCIDateTimeGetDate(/*_dvoid *hndl, OCIError *err,
    09818                                     CONST OCIDateTime *date,
    09819                                     sb2 *year, ub1 *month, ub1 *day _*/);
    09820
    09821 sword OCIDateTimeGetTimeZoneOffset(/*_ dvoid *hndl,OCIError *err,
    09822                   CONST OCIDateTime   *datetime,sb1 *hour,sb1 *minute _*/);
    09823
    09824 sword OCIDateTimeConstruct(/*_ dvoid  *hndl,OCIError *err,
    09825                OCIDateTime *datetime,
    09826                sb2 yr,ub1 mnth,ub1 dy,ub1 hr,ub1 mm,ub1 ss,ub4 fsec,
    09827                OraText  *timezone,size_t timezone_length _*/);
    09828
    09829 sword OCIDateTimeSysTimeStamp(/*_ dvoid *hndl, OCIError *err,
    09830                               OCIDateTime *sys_date _*/);
    09831
    09832 sword OCIDateTimeAssign(/*_dvoid *hndl, OCIError *err, CONST OCIDateTime *from,
    09833                                   OCIDateTime *to_*/);
    09834
    09835 sword OCIDateTimeToText(/*_ dvoid *hndl, OCIError *err,
    09836                   CONST OCIDateTime *date, CONST OraText *fmt,
    09837                   ub1 fmt_length, ub1 fsprec, CONST OraText *lang_name,
    09838                   size_t lang_length,
    09839                   ub4 *buf_size, OraText *buf _*/);
    09840
    09841 sword OCIDateTimeFromText(/*_ dvoid *hndl, OCIError *err, CONST OraText *dstr,
    09842                      size_t d_str_length, CONST OraText *fmt, ub1 fmt_length,
    09843                      CONST OraText *lang_name, size_t lang_length,
    09844                      OCIDateTime *date _*/);
    09845
    09846 sword OCIDateTimeCompare(/*_ dvoid *hndl, OCIError *err,
    09847                      CONST OCIDateTime *date1, CONST OCIDateTime *date2,
    09848                      sword *result _*/);
    09849
    09850 sword OCIDateTimeCheck(/*_ dvoid *hndl, OCIError *err, CONST OCIDateTime *date,
    09851                        ub4 *valid _*/);
    09852
    09853 sword OCIDateTimeConvert(/*_ dvoid *hndl, OCIError *err, OCIDateTime *indate,
    09854                       OCIDateTime *outdate_*/);
    09855
    09856 sword OCIDateTimeSubtract(/*_ dvoid *hndl, OCIError *err, OCIDateTime *indate1,
    09857         OCIDateTime *indate2,     OCIInterval *inter_*/);
    09858
    09859 sword OCIDateTimeIntervalAdd(/*_ dvoid *hndl, OCIError *err,
    09860                         OCIDateTime *datetime, OCIInterval *inter,
    09861                         OCIDateTime *outdatetime_*/);
    09862
    09863 sword OCIDateTimeIntervalSub(/*_ dvoid *hndl, OCIError *err,
    09864                         OCIDateTime *datetime, OCIInterval *inter,
    09865                         OCIDateTime *outdatetime_*/);
    09866
    09867 sword OCIIntervalSubtract(/*_ dvoid *hndl, OCIError *err,
    09868        OCIInterval *minuend, OCIInterval *subtrahend, OCIInterval *result _*/);
    09869
    09870 sword OCIIntervalAdd(/*_ dvoid *hndl, OCIError *err, OCIInterval *addend1,
    09871                                  OCIInterval *addend2, OCIInterval *result _*/);
    09872
    09873 sword OCIIntervalMultiply(/*_ dvoid *hndl, OCIError *err,
    09874                         CONST OCIInterval *ifactor, OCINumber *nfactor,
    09875                         OCIInterval *result _*/);
    09876
    09877 sword OCIIntervalDivide(/*_ dvoid *hndl, OCIError *err, OCIInterval *dividend,
    09878                       OCINumber *divisor, OCIInterval *result _*/);
    09879
    09880 sword OCIIntervalCompare(/*_ dvoid *hndl, OCIError *err, OCIInterval *inter1,
    09881                                  OCIInterval *inter2, sword *result _*/);
    09882
    09883 sword OCIIntervalFromNumber(/*_ dvoid *hndl, OCIError *err,
    09884               OCIInterval *interval, OCINumber *number _*/);
    09885
    09886 sword OCIIntervalFromText(/*_dvoid *hndl, OCIError *err, CONST OraText *inpstr,
    09887                       size_t str_len, OCIInterval *result _*/);
    09888
    09889 sword OCIIntervalToText(/*_  dvoid *hndl, OCIError *err,
    09890                      CONST OCIInterval *interval, ub1 lfprec, ub1 fsprec,
    09891                      OraText *buffer, size_t buflen, size_t *resultlen _*/);
    09892
    09893 sword OCIIntervalToNumber(/*_ dvoid *hndl, OCIError *err,
    09894               CONST OCIInterval *interval, OCINumber *number _*/);
    09895
    09896 sword OCIIntervalCheck(/*_dvoid *hndl, OCIError *err, CONST OCIInterval *inter,
    09897                                   ub4 *valid _*/);
    09898
    09899 sword OCIIntervalAssign(/*_ dvoid *hndl, OCIError *err,
    09900                   CONST OCIInterval *inpinter, OCIInterval *outinter _*/);
    09901
    09902 sword OCIIntervalSetYearMonth(/*_dvoid *hndl, OCIError *err, sb4 yr, sb4 mnth,
    09903                         OCIInterval *result _*/);
    09904
    09905 sword OCIIntervalGetYearMonth(/*_dvoid *hndl, OCIError *err, sb4 *yr, sb4 *mnt,
    09906                         CONST OCIInterval *result _*/);
    09907
    09908 sword OCIIntervalSetDaySecond(/*_dvoid *hndl, OCIError *err, sb4 dy, sb4 hr,
    09909                         sb4 mm, sb4 ss, sb4 fsec, OCIInterval *result _*/);
    09910
    09911 sword OCIIntervalGetDaySecond(/*_dvoid *hndl, OCIError *err, sb4 *dy, sb4 *hr,
    09912                    sb4 *mm, sb4 *ss, sb4 *fsec, CONST OCIInterval *result _*/);
    09913
    09914 sword OCIDateTimeToArray(/*_dvoid *hndl, OCIError *err,
    09915                          CONST OCIDateTime *datetime, CONST OCIInterval *reftz,
    09916                          ub1 *outarray, ub4 len, ub1 fsprec _*/);
    09917
    09918 sword OCIDateTimeFromArray(/*_dvoid *hndl, OCIError *err, ub1 *inarray,
    09919                            ub4 len, ub1 type, OCIDateTime *datetime,
    09920                            CONST OCIInterval *reftz, ub1 fsprec _*/);
    09921
    09922 sword OCIDateTimeGetTimeZoneName(/*_dvoid *hndl, OCIError *err,
    09923                                  CONST OCIDateTime *datetime,
    09924                                  ub1 *buf, ub4 *buflen _*/);
    09925
    09926 sword OCIIntervalFromTZ(/*_ dvoid *hndl, OCIError *err,
    09927                         CONST oratext *inpstring, size_t str_len,
    09928                         OCIInterval *result _*/);
    09929
    09930 /*----------------- End Datetime interface Extensions -----------------------*/
    09931
    09932 /*------------------------ OCIAnyDataSet interfaces -------------------------*/
    09933
    09934 /*
    09935    NAME
    09936      OCIAnyDataSetBeginCreate - OCIAnyDataSet Begin Creation
    09937    PARAMETERS
    09938      svchp (IN/OUT) - The OCI service context.
    09939      errhp (IN/OUT) - The OCI error handle. If there is an error, it is
    09940                       recorded in errhp and this function returns OCI_ERROR.
    09941                       Diagnostic information can be obtained by calling
    09942                       OCIErrorGet().
    09943      typecode       - typecode corresponding to the OCIAnyDataSet.
    09944      type (IN)      - type corresponding to the OCIAnyDataSet. If the typecode
    09945                       corresponds to a built-in type (OCI_TYPECODE_NUMBER etc.)
    09946                       , this parameter can be NULL. It should be non NULL for
    09947                       user defined types (OCI_TYPECODE_OBJECT,
    09948                       OCI_TYPECODE_REF, collection types etc.)
    09949      dur (IN)       - duration for which OCIAnyDataSet is allocated.
    09950      data_set (OUT) - Initialized OCIAnyDataSet.
    09951      RETURNS        - error code
    09952    NOTES
    09953      This call allocates an OCIAnyDataSet for the duration of dur and
    09954      initializes it with the type information. The OCIAnyDataSet can hold
    09955      multiple instances of the given type. For performance reasons, the
    09956      OCIAnyDataSet will end up pointing to the passed in OCIType parameter.
    09957      It is the responsibility of the caller to ensure that the OCIType is
    09958      longer lived (has allocation duration >= the duration of the OCIAnyData
    09959      if the OCIType is a transient one, allocation/pin duration >= duration of
    09960      the OCIAnyData if the OCIType is a persistent one).
    09961
    09962 */
    09963 sword OCIAnyDataSetBeginCreate(/*_ OCISvcCtx *svchp, OCIError *errhp,
    09964      OCITypeCode typecode, CONST OCIType *type, OCIDuration dur,
    09965      OCIAnyDataSet ** data_set _*/);
    09966
    09967 /*
    09968    NAME
    09969      OCIAnyDataSetDestroy  - OCIAnyDataSet Destroy
    09970    DESCRIPTION
    09971      This call frees the OCIAnyDataSet allocated using
    09972      OCIAnyDataSetBeginCreate().
    09973    RETURNS
    09974      error code.
    09975    PARAMETERS
    09976      svchp (IN/OUT)    - The OCI service context.
    09977      errhp (IN/OUT)    - The OCI Error handle.
    09978      data_set (IN/OUT) - OCIAnyDataSet to be freed.
    09979 */
    09980 sword OCIAnyDataSetDestroy(/*_ OCISvcCtx *svchp, OCIError *errhp,
    09981      OCIAnyDataSet *data_set _*/);
    09982
    09983 /*
    09984    NAME
    09985      OCIAnyDataSetAddInstance - OCIAnyDataSet Add an instance
    09986    DESCRIPTION
    09987      This call adds a new skeleton instance to the OCIAnyDataSet and all the
    09988      attributes of the instance are set to NULL. It returns this skeleton
    09989      instance through the OCIAnyData parameter which can be constructed
    09990      subsequently by invoking the OCIAnyData API.
    09991    RETURNS
    09992      error code.
    09993    PARAMETERS
    09994      svchp (IN/OUT)      - The OCI service context.
    09995      errhp (IN/OUT)      - The OCI Error handle.
    09996      data_set (IN/OUT)   - OCIAnyDataSet to which a new instance is added.
    09997      data (IN/OUT)       - OCIAnyData corresponding to the newly added
    09998                            instance. If (*data) is NULL, a new OCIAnyData will
    09999                            be allocated for same duration as the OCIAnyDataSet.
    10000                            If (*data) is not NULL, it will get reused. This
    10001                            OCIAnyData can be subseqently constructed using the
    10002                            OCIAnyDataConvert() call or it can be constructed
    10003                            piece-wise using the OCIAnyDataAttrSet and
    10004                            OCIAnyDataCollAddElem calls.
    10005    NOTES
    10006      No Destruction of the old value is done here. It is the responsibility of
    10007      the caller to destroy the old value pointed to by (*data) and set (*data)
    10008      to a null pointer before beginning to make a sequence of this call. No
    10009      deep copying (of OCIType information nor the data part.) is done in the
    10010      returned OCIAnyData. This OCIAnyData cannot be used beyond the allocation
    10011      duration of the OCIAnyDataSet (it is like a reference into the
    10012      OCIAnyDataSet). The returned OCIAnyData can be reused on subsequent calls
    10013      to this function, to sequentially add new data instances to the
    10014      OCIAnyDataSet.
    10015 */
    10016 sword OCIAnyDataSetAddInstance(/*_ OCISvcCtx *svchp, OCIError *errhp,
    10017      OCIAnyDataSet *data_set, OCIAnyData **data _*/);
    10018
    10019 /*
    10020    NAME
    10021      OCIAnyDataSetEndCreate - OCIAnyDataSet End Creation process.
    10022    DESCRIPTION
    10023      This call marks the end of OCIAnyDataSet creation. It should be called
    10024      after constructing all of its instance(s).
    10025    RETURNS
    10026      error code.
    10027    PARAMETERS
    10028      svchp (IN/OUT)        - The OCI service context.
    10029      errhp (IN/OUT)        - The OCI error handle. If there is an error, it is
    10030                              recorded in errhp and this function returns
    10031                              OCI_ERROR. Diagnostic information can be obtained
    10032                              by calling OCIErrorGet().
    10033      data_set (IN/OUT)     - OCIAnyDataSet that has been fully constructed.
    10034 */
    10035 sword OCIAnyDataSetEndCreate(/*_ OCISvcCtx *svchp, OCIError *errhp,
    10036      OCIAnyDataSet *data_set _*/);
    10037
    10038 /*
    10039    NAME
    10040      OCIAnyDataSetGetType - OCIAnyDataSet Get Type of an OCIAnyDataSet
    10041    DESCRIPTION
    10042      Gets the Type corresponding to an OCIAnyDataSet. It returns the actual
    10043      pointer to the type maintained inside an OCIAnyDataSet. No copying is
    10044      done for performance reasons. The client is responsible for not using
    10045      this type once the OCIAnyDataSet is freed (or its duration ends).
    10046    RETURNS
    10047      error code.
    10048    PARAMETERS
    10049      svchp (IN/OUT)      - The OCI service context.
    10050      errhp (IN/OUT)      - The OCI Error handle.
    10051      data_set (IN)       - Initialized OCIAnyDataSet.
    10052      tc (OUT)            - The typecode of the type.
    10053      type (OUT)          - The type corresponding to the OCIAnyDataSet. This
    10054                            could be null if the OCIAnyData corresponds to a
    10055                            built-in type.
    10056 */
    10057 sword OCIAnyDataSetGetType (/*_ OCISvcCtx *svchp, OCIError *errhp,
    10058      OCIAnyDataSet *data_set, OCITypeCode *tc, OCIType **type _*/);
    10059
    10060 /*
    10061   NAME
    10062     OCIAnyDataSetGetCount - OCIAnyDataSet Get Count of instances.
    10063   DESCRIPTION
    10064     This call gets the number of instances in the OCIAnyDataSet.
    10065   RETURNS
    10066     error code.
    10067   PARAMETERS
    10068     svchp (IN/OUT)      - OCI Service Context
    10069     errhp (IN/OUT)      - OCI Error handle
    10070     data_set (IN)       - Well formed OCIAnyDataSet.
    10071     count (OUT)         - number of instances in OCIAnyDataSet
    10072 */
    10073 sword OCIAnyDataSetGetCount(/*_ OCISvcCtx *svchp, OCIError *errhp,
    10074      OCIAnyDataSet *data_set, ub4 *count _*/);
    10075
    10076 /*
    10077   NAME
    10078     OCIAnyDataSetGetInstance - OCIAnyDataSet Get next instance.
    10079   DESCRIPTION
    10080     Only sequential access to the instances in an OCIAnyDataSet is allowed.
    10081     This call returns the OCIAnyData corresponding to an instance at the
    10082     current position and updates the current position. Subsequently, the
    10083     OCIAnyData access routines may be used to access the instance.
    10084   RETURNS
    10085     error code. Returns OCI_NO_DATA if the current position is at the end of
    10086     the set, OCI_SUCCESS otherwise.
    10087   PARAMETERS
    10088     svchp (IN/OUT)      - OCI Service Context
    10089     errhp (IN/OUT)      - OCI Error handle
    10090     data_set (IN)       - Well formed OCIAnyDataSet
    10091     data (IN/OUT)       - OCIAnyData corresponding to the instance. If (*data)
    10092                           is NULL, a new OCIAnyData will be allocated for same
    10093                           duration as the OCIAnyDataSet. If (*data) is not NULL
    10094                           , it will get reused. This OCIAnyData can be
    10095                           subsequently accessed using the OCIAnyDataAccess()
    10096                           call or piece-wise by using the OCIAnyDataAttrGet()
    10097                           call.
    10098   NOTE
    10099     No Destruction of the old value is done here. It is the responsibility of
    10100     the caller to destroy the old value pointed to by (*data) and set (*data)
    10101     to a null pointer before beginning to make a sequence of this call. No deep
    10102     copying (of OCIType information nor the data part.) is done in the returned
    10103     OCIAnyData. This OCIAnyData cannot be used beyond the allocation duration
    10104     of the OCIAnyDataSet (it is like a reference into the OCIAnyDataSet). The
    10105     returned OCIAnyData can be reused on subsequent calls to this function to
    10106     sequentially access the OCIAnyDataSet.
    10107 */
    10108 sword OCIAnyDataSetGetInstance(/*_ OCISvcCtx *svchp, OCIError *errhp,
    10109      OCIAnyDataSet *data_set, OCIAnyData **data _*/);
    10110
    10111 /*--------------------- End of OCIAnyDataSet interfaces ---------------------*/
    10112
    10113 /*--------------------- Connection Pooling prototypes -----------------------*/
    10114 sword OCIConnectionPoolCreate(/*_ OCIEnv *envhp, OCIError *errhp,
    10115                               OCICPool *poolhp,
    10116                               OraText **poolName, sb4 *poolNameLen,
    10117                               CONST OraText *dblink, sb4 dblinkLen,
    10118                               ub4 connMin, ub4 connMax, ub4 connIncr,
    10119                               CONST OraText *poolUserName, sb4 poolUserLen,
    10120                               CONST OraText *poolPassword, sb4 poolPassLen,
    10121                               ub4 mode _*/);
    10122
    10123 sword OCIConnectionPoolDestroy(/*_ OCICPool *poolhp,
    10124                                OCIError *errhp, ub4 mode _*/);
    10125
    10126 /*----------------- End of Connection Pooling prototypes --------------------*/
    10127
    10128 /*-------------------- Session Pooling prototypes ---------------------------*/
    10129
    10130 sword OCISessionPoolCreate (/*_ OCIEnv *envhp, OCIError *errhp,
    10131                               OCISPool *spoolhp,
    10132                               OraText **poolName, ub4 *poolNameLen,
    10133                               CONST OraText *connStr, ub4 connStrLen,
    10134                               ub4 sessMin, ub4 sessMax, ub4 sessIncr,
    10135                               OraText *userid, ub4 useridLen,
    10136                               OraText *password, ub4 passwordLen,
    10137                               ub4 mode _*/);
    10138
    10139 sword OCISessionPoolDestroy (/*_ OCISPool *spoolhp,
    10140                                OCIError *errhp,
    10141                                ub4 mode _*/);
    10142
    10143 sword OCISessionGet (/*_ OCIEnv *envhp, OCIError *errhp, OCISvcCtx **svchp,
    10144                        OCIAuthInfo *authhp,
    10145                        OraText *poolName, ub4 poolName_len,
    10146                        CONST OraText *tagInfo, ub4 tagInfo_len,
    10147                        OraText **retTagInfo, ub4 *retTagInfo_len,
    10148                        boolean *found, ub4 mode _*/);
    10149
    10150 sword OCISessionRelease (/*_ OCISvcCtx *svchp, OCIError *errhp,
    10151                          OraText *tag, ub4 tag_len,
    10152                          ub4 mode _*/);
    10153
    10154 /*-------------------- End Session Pooling prototypes -----------------------*/
    10155
    10156 sword  OCIXMLTypeNew(/*_ OCISvcCtx *svchp, OCIError *errhp, OCIDuration dur,
    10157                      OraText *elname, ub4 elname_Len,
    10158                      OraText *schemaURL, ub4 schemaURL_Len,
    10159                      OCIXMLType **retInstance _*/);
    10160
    10161 sword  OCIXMLTypeCreateFromSrc(/*_ OCISvcCtx *svchp, OCIError *errhp,
    10162                      OCIDuration dur, ub1 src_type, dvoid *src_ptr,
    10163                      sb4 ind, OCIXMLType **retInstance _*/);
    10164
    10165 sword OCIXMLTypeExtract(/*_ OCIError *errhp,
    10166               OCIXMLType *doc, OCIDuration dur,
    10167               OraText *xpathexpr, ub4 xpathexpr_Len,
    10168               OraText *nsmap, ub4 nsmap_Len,
    10169               OCIXMLType **retDoc _*/);
    10170
    10171 sword OCIXMLTypeTransform(/*_ OCIError *errhp, OCIDuration dur,
    10172                OCIXMLType *doc, OCIXMLType *xsldoc,
    10173                OCIXMLType **retDoc _*/);
    10174
    10175 sword OCIXMLTypeExists(/*_ OCIError *errhp, OCIXMLType *doc,
    10176                  OraText *xpathexpr, ub4 xpathexpr_Len,
    10177                  OraText *nsmap, ub4 nsmap_Len,
    10178                  boolean *retval _*/);
    10179
    10180 sword OCIXMLTypeIsSchemaBased(/*_ OCIError *errhp,
    10181                               OCIXMLType *doc, boolean *retval _*/);
    10182
    10183 sword OCIXMLTypeGetSchema(/*_ OCIError *errhp, OCIXMLType *doc,
    10184              OCIXMLType **schemadoc,
    10185              OraText **schemaURL, ub4 *schemaURL_Len,
    10186              OraText **rootelem, ub4 *rootelem_Len _*/);
    10187
    10188 sword OCIXMLTypeValidate(/*_ OCIError *errhp, OCIXMLType *doc,
    10189                    OraText *schemaURL, ub4 schemaURL_Len, boolean *retval _*/);
    10190
    10191 sword OCIXMLTypeGetDOM(/*_ OCIError *errhp, OCIXMLType *doc, OCIDuration dur,
    10192                        OCIDOMDocument **retDom _*/);
    10193
    10194 sword OCIXMLTypeGetFromDOM(/*_ OCIError *errhp, OCIDOMDocument *domdoc,
    10195                            OCIXMLType **retXMLType _*/);
    10196
    10197 sword OCIDOMFree(/*_ OCIError *errhp, OCIDOMDocument *domdoc _*/);
    10198
    10199 /*---------------------------------------------------------------------------
    10200   PRIVATE FUNCTIONS
    10201   ---------------------------------------------------------------------------*/
    10202
    10203 /* these calls are deprecated and should not be used */
    10204 #ifdef NEVER
    10205 #if !defined(__STDC__) && !defined(__cplusplus)
    10206 sword   OCIStmtBindByPos (/*_ OCIStmt *stmtp, OCIBind *bindp, OCIError *errhp,
    10207                      ub4 position, dvoid *valuep, sb4 value_sz, ub2 dty,
    10208                      dvoid *indp, ub2 *alenp, ub2 *rcodep,
    10209                      ub4 maxarr_len, ub4 *curelep, ub4 mode _*/);
    10210
    10211 sword   OCIStmtBindByName(/*_ OCIStmt *stmtp, OCIBind *bindp, OCIError *errhp,
    10212                     CONST OraText *placeholder, sb4 placeh_len, dvoid *valuep,
    10213                     sb4 value_sz, ub2 dty, dvoid *indp, ub2 *alenp,
    10214                     ub2 *rcodep, ub4 maxarr_len, ub4 *curelep, ub4 mode _*/);
    10215
    10216 sword   ocidefn(/*_ OCIStmt *stmtp, OCIDefine *defnp, OCIError *errhp,
    10217                     ub4 position, dvoid *valuep, sb4 value_sz, ub2 dty,
    10218                     dvoid *indp, ub2 *rlenp, ub2 *rcodep, ub4 mode _*/);
    10219
    10220 #endif /* __STDC__ */
    10221 #endif /* NEVER */
    10222
    10223 #endif                                                              /* ocikp */

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines