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

    00001 /* @(#)ort.h    1.44 95/07/07 */
    00002
    00003 /* Copyright (c) 1994, 2003, Oracle Corporation.  All rights reserved.  */
    00004
    00005 /*
    00006   NAME
    00007
    00008     ORT - ORacle's external open Type interface to the open type manager (OTM)
    00009
    00010   DESCRIPTION
    00011
    00012     The open type manager interface includes dynamic type operations to
    00013     create, delete, update, and access types.  See the "Functional
    00014     Specification for Oracle Object Call Interface (Objects Project),
    00015     Version 1.0" for a user level description of the OTM.  For a more
    00016     detailed description, see the "Component Document for the Open Type
    00017     Manager, Version 1.0".
    00018
    00019     NOTE: MOST Of the functions in this header file are being desupported.
    00020           Please use the OCIDescribeAny interface as described in oci.h
    00021           instead.
    00022           The OCIType, OCITypeElem, OCITypeMethod abstract types continue
    00023           to be supported. The only two functions that remain to be documented
    00024           are OCITypeArrayByName and OCITypeArrayByRef.
    00025           All obsolete types/functions are marked accordingly below.
    00026
    00027   RELATED DOCUMENTS
    00028
    00029     For the functional specification for the OTM, see:
    00030         [1] Kotsovolos, Susan, "Functional Specification for Oracle Object
    00031             Call Interface (Objects Project), Version 1.0", Oracle
    00032             Corporation, February 1995.
    00033     For the internal design of the OTM, see the following:
    00034         [2] Kotsovolos, Susan, "Component Document for the Open Type Manager",
    00035             Oracle Corporation, November 1994.
    00036         [3] Kotsovolos, Susan, "Design for The Open Type Manager, Oracle
    00037             Object Management Subsystem Version 1.0", Oracle Corporation,
    00038             March 1994.
    00039         [4] Kotsovolos, Susan and Tin A. Nguyen, "The Open Type Manager",
    00040             Oracle Corporation, March 1994.
    00041         [5] Kotsovolos, Susan and Tin A. Nguyen, "Schema Evolution",
    00042             Oracle Corporation, March 1994.
    00043     For a description of the types the OTM must support, see:
    00044         [6] Nguyen, Tin A., "The Open Type System", Oracle Corporation,
    00045             February 1994.
    00046
    00047   INSPECTION STATUS
    00048
    00049     Inspection date:
    00050     Inspection status:
    00051     Estimated increasing cost defects per page:
    00052     Rule sets:
    00053
    00054   ACCEPTANCE REVIEW STATUS
    00055
    00056     Review date:
    00057     Review status:
    00058     Reviewers:
    00059
    00060
    00061   **** ALL OBSOLETE FUNCTIONS/TYPES ARE MARKED ACCORDINGLY ***
    00062
    00063   EXPORT FUNCTIONS
    00064
    00065     None
    00066
    00067   PUBLIC DATA STRUCTURES
    00068
    00069       OCIType - type descriptor in the object cache
    00070       OCITypeElem - type element descriptor in the object cache
    00071             (used for attributes and paramters)
    00072       OCITypeCode  - Open Type System type code.
    00073       OCITypeMethod - method descriptor in the object cache
    00074       OCITypeParamMode - parameter modes (ie. IN, IN-OUT etc)
    00075
    00076   PUBLIC FUNCTIONS
    00077
    00078     ITERATOR (for OCITypeAttrNext and OCITypeMethodNext)
    00079
    00080       OCITypeIterNew  - ** OBSOLETE ** Create new instance of an iteraton.
    00081       OCITypeIterSet  - ** OBSOLETE ** Initialize iterator.
    00082       OCITypeIterFree - ** OBSOLETE ** Free instance of iterator.
    00083
    00084     TYPE GET
    00085
    00086       OCITypeByName      - ** OBSOLETE ** Get a type by name.
    00087       OCITypeArrayByName - Get an array of types by their names.
    00088       OCITypeByRef       - ** OBSOLETE ** Get a type by its CREF.
    00089       OCITypeArrayByRef  - Get an array of types by their CREFs.
    00090
    00091     TYPE ACCESSORS
    00092
    00093       OCITypeName     - ** OBSOLETE ** OCI Get a type's name.
    00094       OCITypeSchema   - ** OBSOLETE ** OCI Get a type's schema name.
    00095       OCITypeTypeCode - ** OBSOLETE ** OCI Get a type's type code.
    00096       OCITypeVersion  - ** OBSOLETE ** OCI Get a Type's user-readable Version.
    00097       OCITypeAttrs    - ** OBSOLETE ** OCI Get a Type's Number of Attributes.
    00098       OCITypeMethods  - ** OBSOLETE ** OCI Get a Type's Number of Methods.
    00099
    00100     TYPE ELEMENT ACCESSORS (they represent attributes/parameters/results)
    00101
    00102       OCITypeElemName      - ** OBSOLETE ** Get a type element's (only for
    00103                                 attributes) name.
    00104       OCITypeElemType      - ** OBSOLETE ** Get a type element's type
    00105                                 descriptor.
    00106       OCITypeElemTypeCode  - ** OBSOLETE ** Get a type element's typecode.
    00107       OCITypeElemParameterizedType - ** OBSOLETE ** Get a type element's
    00108                                         parameterized type's type descriptor.
    00109       OCITypeElemNumPrec   - ** OBSOLETE ** Get a number's precision.
    00110       OCITypeElemNumScale  - ** OBSOLETE ** Get a decimal or oracle Number's
    00111                                             Scale
    00112       OCITypeElemCharSetID - ** OBSOLETE ** Get a fixed or variable length
    00113                                             string's character set ID.
    00114       OCITypeElemCharSetForm - ** OBSOLETE ** Get a fixed or variable length
    00115                                               string's character set form (how
    00116                                               character set information has
    00117                                               been specified).
    00118       OCITypeElemLength    - ** OBSOLETE ** Get a raw, fixed or variable
    00119                                             length string's length.
    00120       OCITypeElemParamMode - ** OBSOLETE ** Get element's parameter's mode
    00121                                             (only valid for parameter).
    00122       OCITypeElemDefaultValue - ** OBSOLETE ** Get element's Default Value.
    00123
    00124     ATTRIBUTE ACCESSORS
    00125
    00126       OCITypeAttrByName - ** OBSOLETE ** Get an Attribute by Name.
    00127       OCITypeAttrNext   - ** OBSOLETE ** Get an Attribute by Iteration.
    00128
    00129     COLLECTION ACCESSORS
    00130
    00131       OCITypeCollTypeCode - ** OBSOLETE ** Get a named collection's typecode.
    00132       OCITypeCollElem     - ** OBSOLETE ** Get a named collection's element's
    00133                                type element information.
    00134       OCITypeCollSize     - ** OBSOLETE ** Get a named collection's size in
    00135                                number of elements.
    00136
    00137     METHOD ACCESSORS
    00138
    00139       OCITypeMethodOverload - ** OBSOLETE ** Get number of overloaded methods
    00140                                              with the given method name.
    00141                                              (no direct equivalent for
    00142                                               OCIDescribe interface)
    00143       OCITypeMethodByName   - ** OBSOLETE ** Get one or more methods by name.
    00144       OCITypeMethodNext     - ** OBSOLETE ** Iterate to the next method to
    00145                                              retrieve.
    00146       OCITypeMethodName     - ** OBSOLETE ** Get method's name.
    00147       OCITypeMethodEncap    - ** OBSOLETE ** Get method's encapsulation level.
    00148       OCITypeMethodFlags    - ** OBSOLETE ** et method's flags.
    00149       OCITypeMethodMap      - ** OBSOLETE ** Get type's map function.
    00150       OCITypeMethodOrder    - ** OBSOLETE ** Get type's order function.
    00151       OCITypeMethodParams   - ** OBSOLETE ** Get a method's number of
    00152                                              parameters.
    00153
    00154     RESULT ACCESSORS
    00155
    00156       OCITypeResult - ** OBSOLETE ** OCI Get a method's Result.
    00157
    00158       See also ATTRIBUTE/PARAMETER/RESULT TYPE ACCESSORS.
    00159
    00160     PARAMETER ACCESSORS
    00161
    00162       OCITypeParamByPos  - ** OBSOLETE ** Get a Parameter in a method By
    00163                                           Position.
    00164       OCITypeParamByName - ** OBSOLETE ** Get a Parameter in a method By Name.
    00165       OCITypeParamPos    - ** OBSOLETE ** Get a Parameter's PoSition in a
    00166                                           method.
    00167
    00168   CALL GRAPHS:
    00169
    00170   Only type accessors are supported for 8.0.
    00171   ** OBSOLETE ** please use OCIDescribe interface
    00172
    00173   TYPE ACCESSOR EXAMPLE
    00174
    00175       CREATE TYPE CAR
    00176       (
    00177         name   vstring,
    00178         age    number,
    00179           number   car_age;                           /o Oracle number o/
    00180           weight   car_weight;                        /o abstract type o/
    00181
    00182         PUBLIC:
    00183
    00184           /o methods o/
    00185           car(orlvs a_name, number an_age, WEIGHT a_weight);
    00186           ~car();
    00187           inline number get_age() const;
    00188
    00189           /o relative ordering (map) functions o/
    00190           number car_map
    00191       );
    00192
    00193       /o the following code accesses the type created above o/
    00194
    00195       ub1      meth_flags;
    00196       ub4      i, j;
    00197       ub4      text_len, position;
    00198       ub4      count;
    00199       ub4      length;
    00200       OCITypeCode    typecode;
    00201       OCIRef  *attr_ref;
    00202       OCIRef  *param_ref;
    00203       OCIType  *tdo, new_tdo, final_tdo;
    00204       OCITypeElem  *elem;
    00205       OCITypeIter  *iterator_ort;
    00206       oratext   (*names)[];
    00207       ub4      lengths[];
    00208       ub4     *positions;
    00209       oratext    *name;
    00210       oratext     name_buffer[M_IDEN];
    00211
    00212       /o initialize the references o/
    00213       DISCARD orlrini(env, err, (dvoid *)&attr_ref);
    00214       DISCARD orlrini(env, err, (dvoid *)&param_ref);
    00215
    00216       /o ----------------- GET INFORMATION ABOUT A TYPE ----------------- o/
    00217
    00218       /o start a transaction o/
    00219
    00220       /o Pin the type until the end of the transaction.  Pinning the type is
    00221        o required before using any type accessors.
    00222        o/
    00223       if (OCITypeByName(env, err, svc, (oratext *)0, 0, "CAR", strlen("CAR"),
    00224                   OCI_DURATION_TRANS, &car_ref, &car_tdo) != OCI_SUCCESS)
    00225         /o error o/ ;
    00226
    00227       /o get the type's name o/
    00228       if (!memcmp(OCITypeName(env, err, car_tdo, &text_len), "person",
    00229                               text_len))
    00230         /o do something o/ ;
    00231
    00232       /o get the type's schema name o/
    00233       if (!memcmp(OCITypeSchema(env, err, car_tdo, &text_len), "john",
    00234                   text_len))
    00235         /o do something o/ ;
    00236
    00237       /o get the type code of the type o/
    00238       if (OCITypeTypeCode(env, err, car_tdo) == OCI_TYPECODE_ADT)
    00239         /o do something o/ ;
    00240
    00241       /o get the type version o/
    00242       if (!memcmp(OCITypeVersion(env, err, car_tdo, &text_len), "1", text_len))
    00243          /o do something o/  ;
    00244
    00245       /o ------- GET FLATTENED POSITION OF AN ATTRIBUTES IN A TYPE ------- o/
    00246
    00247       names = malloc(sizeof(oratext *) * 2);
    00248       names[0] = malloc(strlen("car_weight"));
    00249       names[1] = malloc(strlen("ounces"));
    00250       memcpy(names[0], "car_weight", strlen("car_weight"));
    00251       memcpy(names[1], "ounces", strlen("ounces"));
    00252
    00253       lengths = malloc(sizeof(ub4) * 2);
    00254       lengths[0] = strlen("car_weight");
    00255       lengths[1] = strlen("ounces");
    00256
    00257       /o ---------- GET IMMEDIATE ATTRIBUTES IN A TYPE ---------- o/
    00258
    00259       /o loop through all attributes in the type with iterator o/
    00260       if (OCITypeIterNew(env, err, car_tdo, &iterator_ort) != OCI_SUCCESS)
    00261         /o do something o/
    00262
    00263       while (OCITypeAttrNext(env, err, iterator_ort, &ado) != OCI_NO_DATA)
    00264       {
    00265         /o get the attribute's name o/
    00266         if (!memcmp(OCITypeElemName(env, err, ado, &text_len),
    00267                                     "tiger", text_len))
    00268           /o do something o/  ;
    00269
    00270         /o get the attribute's type descriptor o/
    00271         if (OCITypeElemType(env, err, ado, &tdo) != OCI_SUCCESS)
    00272           /o error o/ ;
    00273
    00274         /o get the attribute's type code o/
    00275         typecode = OCITypeElemTypeCode(env, err, ado);
    00276
    00277         switch (typecode)
    00278         {
    00279         /o scalar types o/
    00280         case OCI_TYPECODE_DATE:                                     /o date o/
    00281         case OCI_TYPECODE_SIGNED8:                                  /o byte o/
    00282         case OCI_TYPECODE_SIGNED16:                                /o short o/
    00283         case OCI_TYPECODE_UNSIGNED8:                       /o unsigned byte o/
    00284         case OCI_TYPECODE_UNSIGNED16:                     /o unsigned short o/
    00285         case OCI_TYPECODE_OCTET:                                   /o octet o/
    00286         case OCI_TYPECODE_TABLE:                            /o nested table o/
    00287         case OCI_TYPECODE_CLOB:                            /o character lob o/
    00288         case OCI_TYPECODE_BLOB:                               /o binary lob o/
    00289         case OCI_TYPECODE_CFILE:                   /o character file object o/
    00290         case OCI_TYPECODE_BFILE:                      /o binary file object o/
    00291
    00292           /o do something o/
    00293           break;
    00294
    00295         /o number types o/
    00296         case OCI_TYPECODE_NUMBER:                          /o oracle number o/
    00297         case OCI_TYPECODE_DECIMAL:                               /o decimal o/
    00298           {
    00299             /o get the scale of the number o/
    00300             if (OCITypeElemNumScale(env, err, ado) == 3)
    00301               /o do something o/ ;
    00302           }
    00303           /o fall through to get the precision o/
    00304
    00305         case OCI_TYPECODE_FLOAT:                                   /o float o/
    00306         case OCI_TYPECODE_SIGNED32:                                 /o long o/
    00307         case OCI_TYPECODE_UNSIGNED32:                      /o unsigned long o/
    00308         case OCI_TYPECODE_REAL:                                     /o real o/
    00309         case OCI_TYPECODE_DOUBLE:                                 /o double o/
    00310           {
    00311             /o get the precision of the number o/
    00312             if (OCITypeElemNumPrec(env, err, ado) == 2)
    00313               /o do something o/ ;
    00314           }
    00315           break;
    00316
    00317         /o string types o/
    00318         case OCI_TYPECODE_CHAR:                      /o fixed length string o/
    00319         case OCI_TYPECODE_VARCHAR2:               /o variable length string o/
    00320         case OCI_TYPECODE_RAW:                                       /o raw o/
    00321           {
    00322             /o get the length of the fixed or variable length string o/
    00323             if (OCITypeElemLength(env, err, ado) < 100)
    00324               /o do something o/
    00325           }
    00326           break;
    00327
    00328         /o parameterized types o/
    00329         case OCI_TYPECODE_REF:                          /o reference o/
    00330         case OCI_TYPECODE_PTR:                            /o pointer o/
    00331           {
    00332             /o get the type stored in the parameterized type o/
    00333             if (OCITypeElemParameterizedType(env, err, ado, &tdo)
    00334                  != OCI_SUCCESS)
    00335               /o error o/ ;
    00336
    00337             /o do something o/
    00338             if (OCI_TYPEELEM_IS_REF(OCITypeElemFlags(env, err, ado)))...
    00339           }
    00340           break;
    00341
    00342         /o domain type o/
    00343         case OCI_TYPECODE_NAMEDCOLLECTION:
    00344           switch (OCITypeCollTypeCode(env, err, tdo))
    00345           {
    00346           case OCI_TYPECODE_VARRAY:                   /o variable array o/
    00347             ub4   num_elems;
    00348             OCIType *element_type;
    00349
    00350             /o get the number of elements in the farray or the maximum number
    00351              o of elements in the varray.
    00352              o/
    00353             OCITypeCollSize(env, err, tdo, &num_elems);
    00354
    00355             /o get the type of the array o/
    00356             OCITypeElemType(env, err, tdo, &element_type);
    00357           }
    00358           break;
    00359
    00360           case OCI_TYPECODE_TABLE:                         /o multiset o/
    00361           {
    00362             OCIType *table_type;
    00363
    00364             /o get the type of the multiset o/
    00365             OCITypeElemType(env, err, tdo, &table_type);
    00366
    00367             /o do something o/
    00368           }
    00369         }
    00370
    00371         /o abstract type o/
    00372         case OCI_TYPECODE_ADT:                 /o abstract data type o/
    00373           {
    00374             /o get the adt information o/
    00375             if (OCITypeElemType(env, err, ado, &tdo) != OCI_SUCCESS)
    00376               /o error o/ ;
    00377
    00378             /o do something o/
    00379           }
    00380           break;
    00381
    00382         default:
    00383           DISCARD printf("Error:  invalid type code\n");
    00384
    00385         } /o end of typecode switch o/
    00386
    00387       } /o end of loop through all attributes in a type o/
    00388
    00389
    00390       /o ------------ GET THE IMMEDIATE METHODS OF A TYPE ------------ o/
    00391
    00392       /o loop through all methods in the type by reusing iterator o/
    00393       if (OCITypeIterSet(env, err, car_tdo, iterator_ort) != OCI_SUCCESS)
    00394         /o do something o/
    00395
    00396       while (OCITypeMethodNext(env, err, iterator_ort) != OCI_NO_DATA)
    00397       {
    00398         /o get the method's name o/
    00399         if (!memcmp(OCITypeMethodName(env, err, mdo, &text_len), "car",
    00400                     text_len))
    00401           /o do something o/  ;
    00402
    00403         /o get the method's encapsulation o/
    00404         if (OCITypeMethodEncap(env, err, mdo) == OCI_TYPEENCAP_PUBLIC)
    00405           /o do something o/  ;
    00406
    00407         /o get the method's flags o/
    00408         meth_flags = OCITypeMethodFlags(env, err, mdo);
    00409         if (meth_flags & OCI_TYPEMETHOD_VIRTUAL)
    00410           /o do something o/  ;
    00411
    00412
    00413         /o ------------ GET THE PARAMETERS IN A METHOD ------------ o/
    00414
    00415         /o loop through all parameters in the method o/
    00416         count = OCITypeMethodParams(env, err, mdo);
    00417         for (j = 1; j <= count; j++)
    00418         {
    00419           /o get the parameter information by position o/
    00420           if (OCITypeParamByPos(env, err, mdo, i, &elem) != OCI_SUCCESS)
    00421             /o error o/ ;
    00422
    00423           /o get the parameter's name o/
    00424           if (!memcmp(OCITypeElemName(env, err, elem, &text_len), "an_age",
    00425                       text_len))
    00426             /o do something o/ ;
    00427
    00428           /o get the parameter's mode o/
    00429           if (OCITypeElemMode(env, err, elem) == OCI_PARAM_OUT)
    00430             /o do something o/ ;
    00431
    00432           /o get the parameter's required flag o/
    00433           if (ortgprq(env, err, elem))
    00434             /o do something o/ ;
    00435         }
    00436       }
    00437
    00438       /o get a method by name o/
    00439       if (OCITypeMethodByName(env, err, car_tdo, "car_constructor",
    00440                               strlen("car_constructor"), NULLP(OCIRef), &mdo)
    00441                               != OCI_SUCCESS)
    00442         /o error o/ ;
    00443
    00444       /o get a parameter in a method by name o/
    00445       if (OCITypeParamByName(env, err, mdo, "an_age", strlen("an_age"), &elem)
    00446                   != OCI_SUCCESS)
    00447         /o error o/ ;
    00448
    00449       /o get a parameter's typecode o/
    00450       typecode = OCITypeElemTypeCode(env, err, elem);
    00451
    00452       /o get a parameter's type object o/
    00453       if (OCITypeElemType(env, err, elem, &tdo)) != OCI_SUCCESS)
    00454         /o error o/ ;
    00455
    00456       /o get a parameter's position in a method o/
    00457       if (ortgpps(env, err, mdo, "an_age", strlen("an_age"),
    00458                   &position, NULLP(OCIRef), NULLP(OCITypeElem)) != OCI_SUCCESS)
    00459         /o error o/ ;
    00460
    00461       /o ------------ GET THE METHOD's RESULT ------------ o/
    00462
    00463       /o get a method by name o/
    00464       if (OCITypeMethodByName(env, err, car_tdo, "get_age", strlen("get_age"),
    00465                   &mdo) != OCI_SUCCESS)
    00466         /o error o/ ;
    00467
    00468       /o get the typecode of the method's result o/
    00469       typecode = OCITypeElemTypeCode(env, err, mdo);
    00470
    00471
    00472       /o ----------------- END ---------------- o/
    00473
    00474       /o free the references implicitly allocated o/
    00475       DISCARD orlrfre(env, err, (dvoid *)&attr_ref);
    00476       DISCARD orlrfre(env, err, (dvoid *)&param_ref);
    00477
    00478   NOTES
    00479
    00480   MODIFIED
    00481     srseshad   03/12/03  - convert oci public api to ansi
    00482     aahluwal   06/03/02  - bug 2360115
    00483     skabraha   04/16/02  - fix compiler warnings
    00484     rkasamse   03/02/01  - do not use iterator : keyword in MSVB
    00485     bpalaval   02/09/01  - Change text to oratext.
    00486     rxgovind   01/31/00  - add OCIType interfaces for transient types
    00487     whe        09/01/99 -  976457:check __cplusplus for C++ code
    00488     cxcheng    05/06/97 -  make OCI_TYPE?? test macros return either 1 or 0
    00489     cxcheng    04/22/97 -  add comment on desupporting OCIType functions
    00490     skrishna   03/18/97 -  fix ifdef for supporting ansi and k&r proto-types
    00491     cxcheng    02/26/97 -  fix lint problem with oro names
    00492     cxcheng    02/06/97 -  take out short name support except with SLSHORTNAME
    00493     cxcheng    01/15/97 -  change prototype of OCITypeElemParameterizedType()
    00494     cxcheng    01/03/97 -  replace bit in OCI_TYPEPARAM_IS_REQUIRED with bitwis
    00495     cxcheng    12/31/96 -  replace OCI_PARAM_IS_REQUIRED with OCI_TYPEPARAM_IS_
    00496     cxcheng    12/09/96 -  add prototype for OCITypeElemExtTypeCode and OCIType
    00497     cxcheng    11/25/96 -  add schema name parameter to OCITypeVTInsert()
    00498     cxcheng    11/20/96 -  fix prototype for OCITypeByName()
    00499     cxcheng    11/11/96 -  fix prototype for OCITypeByName()
    00500     cxcheng    11/05/96 -  remove OCITypeElemExtTypeCode and OCITypeCollExtType
    00501     dchatter   10/28/96 -  change ortgatyp to be OCITypeArrayByName
    00502     cxcheng    10/25/96 -  fix problem with ortgatyp at end
    00503     cxcheng    10/22/96 -  add OCITypeByRef and OCITypeArrayByRef
    00504     cxcheng    10/20/96 -  remove ortgtyp() from #define section at end
    00505     cxcheng    10/18/96 -  rename OCITypeGetArray to OCITypeArrayByName
    00506     cxcheng    10/17/96 -  final change to prototype for OCI_TYPEPARAM_IS_REQUI
    00507     cxcheng    10/15/96 -  rename OCIEncapLevel and OCIMethodFlag
    00508     cxcheng    10/14/96 -  change prototype of OCITypeResult
    00509     mluong     10/11/96 -  fix compile error
    00510     jwijaya    10/10/96 -  fix bug on OCI_PARAM_IS_REQUIRED
    00511     cxcheng    10/09/96 -  more lint and link fixes
    00512     cxcheng    10/08/96 -  more lint fixes
    00513     cxcheng    10/07/96 -  more changes
    00514     cxcheng    10/04/96 -  replace short names with long names
    00515     cxcheng    10/01/96 -  change to long names for readability
    00516     cxcheng    09/27/96 -  rename ortgatyp() to ortgtya() for lint
    00517     cxcheng    09/20/96 -  add ortgatyp() for array get type
    00518     cxcheng    09/18/96 -  add array pin and iterator functions
    00519     cxcheng    08/09/96 -  add version table calls
    00520     cxcheng    07/22/96 -  add OCITypeElemType() to top
    00521     jwijaya    07/03/96 -  add ANSI prototypes
    00522     cxcheng    06/28/96 -  add OCITypeElemCharSetForm()
    00523     cxcheng    06/26/96 -  fix comment on OCITypeParamByPos()/ortgpps()
    00524     cxcheng    06/18/96 -  fix comments on OCITypeResult()
    00525     cxcheng    06/17/96 -  improve comments
    00526     skrishna   06/03/96 -  change OCITypeCollElem() prototype
    00527     vkrishna   05/29/96 -  replace OROTCFAR with OROTCCAR
    00528     cxcheng    05/28/96 -  fix comments, remove non-beta1 functions
    00529     cxcheng    05/02/96 -  fix prototype bugs
    00530     cxcheng    04/29/96 -  rename OCITypeElemm() to ortanct()
    00531     cxcheng    04/26/96 -  add ortgrbp and ortftyi,
    00532                            fix comments and examples
    00533     cxcheng    04/22/96 -  big merge to main branch
    00534     cxcheng    04/17/96 -  fix syntax
    00535     cxcheng    04/08/96 -  change prototype to ortaty()
    00536     skrishna   04/08/96 -  change ort*() to take OCIEnv* and OCIError* instead
    00537                            of oroenv*
    00538     cxcheng    03/28/96 -  add ortslob(), change ortsstr() prototype
    00539     cxcheng    03/13/96 -  change alter type interface
    00540     cxcheng    03/11/96 -  ORT interface changes
    00541     cxcheng    02/27/96 -  correct comments
    00542     jboonleu   02/09/96 -  rename oroopd to OCIDuration
    00543     cxcheng    01/19/96 -  change ORTCTYVAL to ORTCTYEMB for embedded ADT
    00544     cxcheng    02/14/96 -  add more comments
    00545     jboonleu   02/09/96 -  rename oroopd to OCIDuration
    00546     cxcheng    02/07/96 -  fix comments and examples
    00547     cxcheng    01/19/96 -  new ORT interface without korfc's
    00548     cxcheng    01/08/96 -  consolidate collection functions
    00549     cxcheng    12/14/95 -  remove obsolete ortgcol() and ortrelease()
    00550     jweisz     12/12/95 -  merge screwup: ortdth twice
    00551     cxcheng    12/05/95 -  change multiset interface for new standard
    00552     skotsovo   12/01/95 -  merge from /vobs/rdbms/public/ort.h@@/main/
    00553                            st_rdbms_big_dev/st_rdbms_obj/
    00554                            st_rdbms_jwijaya_variable_ref
    00555     cxcheng    11/13/95 -  add ortaty()/orteaty()
    00556     cxcheng    11/13/95 -  add new collection type accessors
    00557     skotsovo   10/30/95 -  add 'oid' type b/c extent type uses it.
    00558     skotsovo   10/24/95 -  update according to new variable length ref
    00559     cxcheng    10/05/95 -  add null support, change prototypes to calls
    00560     cxcheng    10/03/95 -  add OCITypeMethodOrder() to get ORDER method
    00561     cxcheng    09/28/95 -  add OCITypeElemm() for collection types support
    00562     skotsovo   06/05/95 -  add adt_type parameter to ortsab()
    00563     skotsovo   05/10/95 -  ifdef'd out ortgafp()
    00564     skotsovo   03/07/95 -  update interface to only include release 1
    00565     skotsovo   02/22/95 -  add multiset accessors
    00566     skotsovo   02/09/95 -  update according to new ots doc
    00567     skotsovo   01/31/95 -  add rest of release 1 types
    00568     skotsovo   01/24/95 -  categorize sint32, double, and real as number types
    00569                            (with precision and scale) instead of scalar types.
    00570     skotsovo   01/12/95 -  remove dependency from ortdty interface
    00571     skotsovo   01/03/95 -  remove orotyp accessors
    00572     skotsovo   12/12/94 -  update comments
    00573     skotsovo   12/05/94 -  change OCITypeElemParameterizedTyper interface
    00574     skotsovo   10/26/94 -  add type version table
    00575     skotsovo   10/17/94 -  fix ortgafp() comments
    00576     skotsovo   10/14/94 -  modify ortgafp() parameters
    00577     skotsovo   10/14/94 -  add examples
    00578     skotsovo   10/13/94 -  add a few new routines
    00579     jwijaya    10/07/94 -  add namespace to pin by name
    00580     jwijaya    10/02/94 -  connection handle -> connection number
    00581     skotsovo   09/13/94 -  modify example to use updated oririni interface
    00582     skotsovo   08/25/94 -  change scale to sb1 from sb2
    00583     skotsovo   07/28/94 -  add ortbeg() and ortend()
    00584     skotsovo   07/14/94 -  add decimal type & call graph
    00585     skotsovo   06/28/94 -  subset by removing miscellaneous functions
    00586     skotsovo   06/28/94 -  consistently put comments before typedefs
    00587     skotsovo   06/27/94 -  modify according to new header file template, add
    00588                            more examples, and change ortcty() to return a
    00589                            reference to the type
    00590     skotsovo   06/24/94 -  add functions to get type information from orotyp
    00591     skotsovo   06/20/94 -  finish modifying according to header template
    00592     skotsovo   06/09/94 -  modify according to header file template
    00593     skotsovo   06/08/94 -  replace s.h with oratypes.h
    00594     skotsovo   05/24/94 -  modify comments & update example
    00595     skotsovo   05/23/94 -  modify fnt names for create, alter and drop type
    00596     skotsovo   05/18/94 -  remove ortdme() -- delete a method
    00597     skotsovo   05/17/94 -  add tdo parameter to all type modifiers
    00598     skotsovo   05/11/94 -  return text* instead of including it in arglist
    00599     skotsovo   11/16/93 -  creation
    00600
    00601 */
    00602
    00603 #ifndef ORATYPES
    00604 #include <oratypes.h>
    00605 #endif
    00606 #ifndef ORO_ORACLE
    00607 #include <oro.h>
    00608 #endif
    00609 #ifndef OCI_ORACLE
    00610 #include <oci.h>
    00611 #endif
    00612
    00613 #ifndef ORT_ORACLE
    00614 #define ORT_ORACLE
    00615
    00616 /*---------------------------------------------------------------------------*/
    00617 /*                         SHORT NAMES SUPPORT SECTION                       */
    00618 /*---------------------------------------------------------------------------*/
    00619
    00620 #ifdef SLSHORTNAME
    00621
    00622 /* the following are short names that are only supported on IBM mainframes
    00623    with the SLSHORTNAME defined.
    00624    With this all subsequent long names will actually be substituted with
    00625    the short names here */
    00626
    00627 #define OCITypeArrayByName              ortgatyp
    00628 #define OCITypeAttrByName               ortgabn
    00629 #define OCITypeAttrNext                 ortgabi
    00630 #define OCITypeAttrs                    ortgtna
    00631 #define OCITypeByRef                    ortgtbrf
    00632 #define OCITypeCollElem                 ortgcel
    00633 #define OCITypeCollExtTypeCode          ortgcsqt
    00634 #define OCITypeCollSize                 ortgcne
    00635 #define OCITypeCollTypeCode             ortgdttc
    00636 #define OCITypeElem                     ortado
    00637 #define OCITypeElemCharSetForm          ortgscform
    00638 #define OCITypeElemCharSetID            ortgscid
    00639 #define OCITypeElemDefaultValue         ortgpdv
    00640 #define OCITypeElemExtTypeCode          ortgasqt
    00641 #define OCITypeElemLength               ortgsl
    00642 #define OCITypeElemName                 ortganm
    00643 #define OCITypeElemNumPrec              ortgnp
    00644 #define OCITypeElemNumScale             ortgns
    00645 #define OCITypeElemParamMode            ortgpmo
    00646 #define OCITypeElemParameterizedType    ortgpa
    00647 #define OCITypeElemType                 ortgaty
    00648 #define OCITypeElemTypeCode             ortgatc
    00649 #define OCITypeIter                     ortitr
    00650 #define OCITypeIterFree                 ortifre
    00651 #define OCITypeIterNew                  ortinew
    00652 #define OCITypeIterSet                  ortiset
    00653 #define OCITypeMethod                   ortmdo
    00654 #define OCITypeMethodByName             ortgmbn
    00655 #define OCITypeMethodEncap              ortgmen
    00656 #define OCITypeMethodFlags              ortgmfl
    00657 #define OCITypeMethodMap                ortgmmap
    00658 #define OCITypeMethodName               ortgmnm
    00659 #define OCITypeMethodNext               ortgmbi
    00660 #define OCITypeMethodOrder              ortgmor
    00661 #define OCITypeMethodOverload           ortgmno
    00662 #define OCITypeMethodParams             ortgmnp
    00663 #define OCITypeMethods                  ortgtnm
    00664 #define OCITypeName                     ortgtme
    00665 #define OCITypeParamByName              ortgpbn
    00666 #define OCITypeParamPos                 ortgpps
    00667 #define OCITypeSchema                   ortgtsch
    00668 #define OCITypeTypeCode                 ortgttc
    00669 #define OCITypeVTInit                   ortvini
    00670 #define OCITypeVTInsert                 ortvins
    00671 #define OCITypeVTSelect                 ortvsel
    00672 #define OCITypeVersion                  ortgtvn
    00673
    00674 #endif                                                        /* SLSHORTNAME */
    00675
    00676
    00677 /*============================*/
    00678 /* PUBLIC TYPES AND CONSTANTS */
    00679 /*============================*/
    00680
    00681 /*----------------------------- TYPE DESCRIPTION ----------------------------*/
    00682
    00683 /*
    00684  * OCIType - OCI Type Description Object
    00685  *
    00686  * The contents of an 'OCIType' is private/opaque to clients.  Clients just
    00687  * need to declare and pass 'OCIType' pointers in to the type manage
    00688  * functions.
    00689  * The pointer points to the type in the object cache.  Thus, clients don't
    00690  * need to allocate space for this type and must NEVER free the pointer to the
    00691  * 'OCIType'.
    00692  */
    00693
    00694 typedef struct OCIType OCIType;
    00695
    00696 /*------------------------- TYPE ELEMENT DESCRIPTION ------------------------*/
    00697
    00698
    00699 /*
    00700  * OCITypeElem - OCI Type Element object
    00701  *
    00702  * The contents of an 'OCITypeElem' is private/opaque to clients. Clients just
    00703  * need to declare and pass 'OCITypeElem' pointers in to the type manager
    00704  * functions.
    00705  *
    00706  * 'OCITypeElem' objects contains type element information such as the numeric
    00707  * precision for example, for number objects, and the number of elements for
    00708  * arrays.
    00709  * They ARE used to describe type attributes, collection elements,
    00710  * method parameters, and method results. Hence they are pass in or returned
    00711  * by attribute, collection, and method parameter/result accessors.
    00712  */
    00713
    00714 typedef struct OCITypeElem OCITypeElem;
    00715
    00716
    00717 /*--------------------------- METHOD DESCRIPTION ---------------------------*/
    00718
    00719
    00720 /*
    00721  * OCITypeMethod - OCI Method Description object
    00722  *
    00723  * The contents of an 'OCITypeMethod' is private/opaque to clients.  Clients
    00724  * just need to declare and pass 'OCITypeMethod' pointers in to the type
    00725  * manager functions.
    00726  * The pointer points to the method in the object cache.  Thus, clients don't
    00727  * need to allocate space for this type and must NEVER free the pointer to
    00728  * the 'OCITypeMethod'.
    00729  */
    00730
    00731 typedef struct OCITypeMethod OCITypeMethod;
    00732
    00733
    00734 /*--------------------------- TYPE ACCESS ITERATOR --------------------------*/
    00735
    00736 /*
    00737  * OCITypeIter- OCI Type Iterator
    00738  *
    00739  * The contents of an 'orti' is private/opaque to clients.  Clients just
    00740  * need to declare and pass 'orti' pointers in to the type manager functions.
    00741  * The iterator is used to retreive MDO's and ADO's that belong to the TDO
    00742  * one at a time. It needs to be allocated by the 'OCITypeIterNew()' function
    00743  * call and deallocated with the 'OCITypeIterFree()' function call.
    00744  */
    00745
    00746 typedef struct OCITypeIter OCITypeIter;
    00747
    00748
    00749 /*==================*/
    00750 /* PUBLIC FUNCTIONS */
    00751 /*==================*/
    00752
    00753 /*--------------------------------------------------------------------------*/
    00754 /*                                  ITERATOR                                */
    00755 /*--------------------------------------------------------------------------*/
    00756
    00757 /*-----------------------_- OCITypeIterNew ---------------------------------*/
    00758
    00759 /* ** OBSOLETE ** */
    00760 sword OCITypeIterNew(    OCIEnv *env, OCIError *err, OCIType *tdo,
    00761                          OCITypeIter **iterator_ort    );
    00762
    00763 /*
    00764   NAME: OCITypeIterNew - OCI Iterator NEW
    00765   PARAMETERS:
    00766        env (IN/OUT) - OCI environment handle initialized in object mode
    00767        err (IN/OUT) - error handle. If there is an error, it is
    00768                 recorded in 'err' and this function returns OCI_ERROR.
    00769                 The error recorded in 'err' can be retrieved by calling
    00770                 OCIErrorGet().
    00771        tdo (IN) - pointer to the pinned type in the object cache to
    00772                 initialize the iterator with
    00773        iterator_ort (OUT) - pointer to the pointer to the new iterator created
    00774   DESCRIPTION:
    00775        Create a new instance of a method/attribute iterator and initalize
    00776        it's values.
    00777   RETURNS:
    00778         OCI_SUCCESS if the function completes successfully.
    00779         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    00780         OCI_ERROR if
    00781            1) any of the required parameters is null.
    00782            2) error while allocating space for the iterator.
    00783 */
    00784
    00785 /*------------------------ OCITypeIterSet ---------------------------------*/
    00786
    00787 /* ** OBSOLETE ** */
    00788 sword OCITypeIterSet(    OCIEnv *env, OCIError *err, OCIType *tdo,
    00789                   OCITypeIter *iterator_ort    );
    00790
    00791 /*
    00792   NAME: OCITypeIterSet - OCI Iterator SET
    00793   PARAMETERS:
    00794        env (IN/OUT) - OCI environment handle initialized in object mode
    00795        err (IN/OUT) - error handle. If there is an error, it is
    00796                 recorded in 'err' and this function returns OCI_ERROR.
    00797                 The error recorded in 'err' can be retrieved by calling
    00798                 OCIErrorGet().
    00799        tdo (IN) - pointer to the pinned type in the object cache to
    00800                 initialize the iterator with
    00801        iterator_ort (IN/OUT) - pointer to the iterator to set
    00802   DESCRIPTION:
    00803        Initializes the iterator. This is used to reset the state of the
    00804        iterator.
    00805   RETURNS:
    00806         OCI_SUCCESS if the function completes successfully.
    00807         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    00808         OCI_ERROR if
    00809            1) any of the required parameters is null.
    00810 */
    00811
    00812 /*------------------------ OCITypeIterFree ---------------------------------*/
    00813
    00814 /* ** OBSOLETE ** */
    00815 sword OCITypeIterFree(    OCIEnv *env, OCIError *err, OCITypeIter
    00816                           *iterator_ort    );
    00817
    00818 /*
    00819   NAME: OCITypeIterFree - OCI Iterator FREe
    00820   PARAMETERS:
    00821        env (IN/OUT) - OCI environment handle initialized in object mode
    00822        err (IN/OUT) - error handle. If there is an error, it is
    00823                 recorded in 'err' and this function returns OCI_ERROR.
    00824                 The error recorded in 'err' can be retrieved by calling
    00825                 OCIErrorGet().
    00826        iterator_ort (IN/OUT) - pointer to the iterator to free
    00827   DESCRIPTION:
    00828        Free space allocated for the iterator.
    00829   RETURNS:
    00830         OCI_SUCCESS if the function completes successfully.
    00831         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    00832         OCI_ERROR if
    00833            1) any of the required parameters is null.
    00834            2) error while freeing the iterator, probably bad iterator pointer.
    00835 */
    00836
    00837
    00838 /*--------------------------------------------------------------------------*/
    00839 /*                                  TYPE GET                                */
    00840 /*--------------------------------------------------------------------------*/
    00841
    00842 /* ** OBSOLETE ** */
    00843 sword OCITypeByName(    OCIEnv *env, OCIError *err, CONST OCISvcCtx *svc,
    00844                         CONST oratext *schema_name, ub4 s_length,
    00845                         CONST oratext *type_name, ub4 t_length,
    00846                         CONST oratext *version_name, ub4 v_length,
    00847                         OCIDuration pin_duration, OCITypeGetOpt get_option,
    00848                         OCIType **tdo    );
    00849 /*
    00850   NAME: OCITypeByName - OCI Get the most current version of an existing TYPe
    00851                   by name.
    00852   PARAMETERS:
    00853        env (IN/OUT) - OCI environment handle initialized in object mode
    00854        err (IN/OUT) - error handle. If there is an error, it is
    00855                 recorded in 'err' and this function returns OCI_ERROR.
    00856                 The error recorded in 'err' can be retrieved by calling
    00857                 OCIErrorGet().
    00858        svc (IN) - OCI service handle
    00859        schema_name (IN, optional) - name of schema associated with the
    00860                   type.  By default, the user's schema name is used.
    00861        s_length (IN) - length of the 'schema_name' parameter
    00862        type_name (IN) - name of the type to get
    00863        t_length (IN) - length of the 'type_name' parameter
    00864        version_name (IN, optional) - user readable version of the type.
    00865                   Pass (oratext *)0 for the most current version.
    00866        v_length (IN) - length of version_name in bytes. Should be 0 if
    00867                   the most current version is to be retrieved.
    00868        pin_duration (IN) - pin duration (e.g. until the end of current
    00869                   transaction).  See 'oro.h' for a description of
    00870                   each option.
    00871        get_option (IN) - options for loading the types. It can be one of two
    00872                    values:
    00873                   OCI_TYPEGET_HEADER for only the header to be loaded, or
    00874                   OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
    00875                     loaded.
    00876        tdo (OUT) - pointer to the pinned type in the object cache
    00877   DESCRIPTION:
    00878        Get a pointer to a version of the existing type associated
    00879        with schema/type name.
    00880   RETURNS:
    00881         OCI_SUCCESS if the function completes successfully.
    00882         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    00883         OCI_ERROR if
    00884            1) any of the required parameters is null.
    00885            2) the adt type associated with schema/type name does not exist.
    00886   NOTE:
    00887        Schema and type names are CASE-SENSITIVE. If they have been created
    00888        via SQL, you need to use uppercase names.
    00889 */
    00890
    00891 sword OCITypeArrayByName(    OCIEnv *env, OCIError *err, CONST OCISvcCtx *svc,
    00892                              ub4 array_len,
    00893                              CONST oratext *schema_name[], ub4 s_length[],
    00894                              CONST oratext *type_name[], ub4 t_length[],
    00895                              CONST oratext *version_name[], ub4 v_length[],
    00896                              OCIDuration pin_duration,
    00897                              OCITypeGetOpt get_option, OCIType **tdo    );
    00898
    00899 /*
    00900   NAME: OCITypeArrayByName - OCI Get array of TYPes by name.
    00901   PARAMETERS:
    00902        env (IN/OUT) - OCI environment handle initialized in object mode
    00903        err (IN/OUT) - error handle. If there is an error, it is
    00904                 recorded in 'err' and this function returns OCI_ERROR.
    00905                 The error recorded in 'err' can be retrieved by calling
    00906                 OCIErrorGet().
    00907        svc (IN) - OCI service handle
    00908        array_len (IN) - number of schema_name/type_name/version_name entries to
    00909                   be retrieved.
    00910        schema_name (IN, optional) - array of schema names associated with the
    00911                   types to be retrieved.  The array must have array_len
    00912                   elements if specified.
    00913                   If 0 is supplied, the default schema is assumed, otherwise
    00914                   it MUST have array_len number of elements.
    00915                   0 can be supplied for one or more of the entries to indicate
    00916                   that the default schema is desired for those entries.
    00917        s_length (IN) - array of schema_name lengths with each entry
    00918                   corresponding to the length of the corresponding schema_name
    00919                   entry in the schema_name array in bytes.
    00920                   The array must either have array_len number of elements or
    00921                   it MUST be 0 if schema_name is not specified.
    00922        type_name (IN) - array of the names of the types to retrieve. This
    00923                   MUST have array_len number of elements.
    00924        t_length (IN) - array of the lengths of type names in the type_name
    00925                   array in bytes.
    00926        version_name (IN) - array of the version names of the types to retrieve
    00927                   corresponding. This can be 0 to indicate retrieval of the
    00928                   most current versions, or it MUST have array_len number of
    00929                   elements.
    00930                   If 0 is supplied, the most current version is assumed,
    00931                   otherwise it MUST have array_len number of elements.
    00932                   0 can be supplied for one or more of the entries to indicate
    00933                   that the current version is desired for those entries.
    00934        v_length (IN) - array of the lengths of version names in the
    00935                   version_name array in bytes.
    00936        pin_duration (IN) - pin duration (e.g. until the end of current
    00937                   transaction) for the types retreieve.  See 'oro.h' for a
    00938                   description of each option.
    00939        get_option (IN) - options for loading the types. It can be one of two
    00940                    values:
    00941                   OCI_TYPEGET_HEADER for only the header to be loaded, or
    00942                   OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
    00943                     loaded.
    00944        tdo (OUT) - output array for the pointers to each pinned type in the
    00945                   object cache. It must have space for array_len pointers.
    00946                   Use OCIObjectGetObjectRef() to obtain the CREF to each
    00947                   pinned type descriptor.
    00948   DESCRIPTION:
    00949        Get pointers to the existing types associated with the schema/type name
    00950        array. This is similar to OCITypeByName() except that all the TDO's are
    00951        retreived via a single network roundtrip.
    00952   RETURNS:
    00953         OCI_SUCCESS if the function completes successfully.
    00954         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    00955         OCI_ERROR if
    00956            1) any of the required parameters is null.
    00957            2) one or more adt types associated with a schema/type name entry
    00958               does not exist.
    00959 */
    00960
    00961 sword   OCITypeByRef(    OCIEnv *env, OCIError *err,
    00962                          CONST OCIRef *type_ref, OCIDuration pin_duration,
    00963                          OCITypeGetOpt get_option, OCIType **tdo    );
    00964
    00965 /*
    00966   NAME: OCITypeArrayByRef - OCI Get array of TYPes by REF.
    00967   PARAMETERS:
    00968        env (IN/OUT) - OCI environment handle initialized in object mode
    00969        err (IN/OUT) - error handle. If there is an error, it is
    00970                 recorded in 'err' and this function returns OCI_ERROR.
    00971                 The error recorded in 'err' can be retrieved by calling
    00972                 OCIErrorGet().
    00973        type_ref (IN) - OCIRef * pointing to the particular version of
    00974                   the type descriptor object to obtain.
    00975                   The array must have array_len elements if specified.
    00976        pin_duration (IN) - pin duration (e.g. until the end of current
    00977                   transaction) for the type to retreieve.  See 'oro.h' for a
    00978                   description of each option.
    00979        get_option (IN) - options for loading the type. It can be one of two
    00980                    values:
    00981                   OCI_TYPEGET_HEADER for only the header to be loaded, or
    00982                   OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
    00983                     loaded.
    00984        tdo (OUT) - pointer to the pinned type in the object cache
    00985   DESCRIPTION:
    00986        Get pointers to the
    00987        with the schema/type name array. This is similar to OCITypeByName()
    00988        except that all the TDO's are retreived via a single network roundtrip.
    00989   RETURNS:
    00990         OCI_SUCCESS if the function completes successfully.
    00991         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    00992         OCI_ERROR if
    00993            1) any of the required parameters is null.
    00994            2) one or more adt types associated with a schema/type name entry
    00995               does not exist.
    00996 */
    00997
    00998 sword   OCITypeArrayByRef(    OCIEnv *env, OCIError *err,
    00999                               ub4 array_len, CONST OCIRef **type_ref,
    01000                               OCIDuration pin_duration,
    01001                               OCITypeGetOpt get_option, OCIType **tdo    );
    01002
    01003 /*
    01004   NAME: OCITypeArrayByRef - OCI Get array of TYPes by REF.
    01005   PARAMETERS:
    01006        env (IN/OUT) - OCI environment handle initialized in object mode
    01007        err (IN/OUT) - error handle. If there is an error, it is
    01008                 recorded in 'err' and this function returns OCI_ERROR.
    01009                 The error recorded in 'err' can be retrieved by calling
    01010                 OCIErrorGet().
    01011        array_len (IN) - number of schema_name/type_name/version_name entries to
    01012                   be retrieved.
    01013        type_ref (IN) - array of OCIRef * pointing to the particular version of
    01014                   the type descriptor object to obtain.
    01015                   The array must have array_len elements if specified.
    01016        pin_duration (IN) - pin duration (e.g. until the end of current
    01017                   transaction) for the types retreieve.  See 'oro.h' for a
    01018                   description of each option.
    01019        get_option (IN) - options for loading the types. It can be one of two
    01020                    values:
    01021                   OCI_TYPEGET_HEADER for only the header to be loaded, or
    01022                   OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
    01023                     loaded.
    01024        tdo (OUT) - output array for the pointers to each pinned type in the
    01025                   object cache. It must have space for array_len pointers.
    01026                   Use OCIObjectGetObjectRef() to obtain the CREF to each
    01027                   pinned type descriptor.
    01028   DESCRIPTION:
    01029        Get pointers to the
    01030        with the schema/type name array. This is similar to OCITypeByName()
    01031        except that all the TDO's are retreived via a single network roundtrip.
    01032   RETURNS:
    01033         OCI_SUCCESS if the function completes successfully.
    01034         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    01035         OCI_ERROR if
    01036            1) any of the required parameters is null.
    01037            2) one or more adt types associated with a schema/type name entry
    01038               does not exist.
    01039 */
    01040
    01041
    01042 /*--------------------------------------------------------------------------*/
    01043 /*                              TYPE ACCESSORS                              */
    01044 /*--------------------------------------------------------------------------*/
    01045
    01046 /*---------------------------- OCITypeName ---------------------------------*/
    01047
    01048 /* ** OBSOLETE ** */
    01049 oratext* OCITypeName(    OCIEnv *env, OCIError *err, CONST OCIType *tdo,
    01050                       ub4 *n_length    );
    01051 /*
    01052    NAME: OCITypeName -  ORT Get a Type's naME.
    01053    PARAMETERS:
    01054         env (IN/OUT) - OCI environment handle initialized in object mode
    01055         err (IN/OUT) - error handle. If there is an error, it is
    01056                 recorded in 'err' and this function returns OCI_ERROR.
    01057                 The error recorded in 'err' can be retrieved by calling
    01058                 OCIErrorGet().
    01059         tdo (IN) - pointer to to the type descriptor in the object cache
    01060         n_length (OUT) - length (in bytes) of the returned type name.  The
    01061                caller must allocate space for the ub4 before calling this
    01062                routine.
    01063    REQUIRES:
    01064         1) All type accessors require that the type be pinned before calling
    01065            any accessor.
    01066         2) All input parameters must not be NULL and must be valid.
    01067         3) 'n_length' must point to an allocated ub4.
    01068    DESCRIPTION:
    01069         Get the name of the type.
    01070    RETURNS:
    01071         the name of the type
    01072    NOTES:
    01073         The type descriptor, 'tdo', must be unpinned when the accessed
    01074         information is no longer needed.
    01075  */
    01076
    01077 /*------------------------ OCITypeSchema ---------------------------------*/
    01078
    01079 /* ** OBSOLETE ** */
    01080 oratext* OCITypeSchema(    OCIEnv *env, OCIError *err, CONST OCIType *tdo,
    01081                    ub4 *n_length    );
    01082 /*
    01083    NAME: OCITypeSchema -  ORT Get a Type's SCHema name.
    01084    PARAMETERS:
    01085         env (IN/OUT) - OCI environment handle initialized in object mode
    01086         err (IN/OUT) - error handle. If there is an error, it is
    01087                 recorded in 'err' and this function returns OCI_ERROR.
    01088                 The error recorded in 'err' can be retrieved by calling
    01089                 OCIErrorGet().
    01090         tdo (IN) - pointer to to the type descriptor in the object cache
    01091         n_length (OUT) - length (in bytes) of the returned schema name.  The
    01092                caller must allocate space for the ub4 before calling this
    01093                routine.
    01094    REQUIRES:
    01095         1) All type accessors require that the type be pinned before calling
    01096            any accessor.
    01097         2) All input parameters must not be NULL and must be valid.
    01098         3) 'n_length' must point to an allocated ub4.
    01099    DESCRIPTION:
    01100         Get the schema name of the type.
    01101    RETURNS:
    01102         the schema name of the type
    01103    NOTES:
    01104         The type descriptor, 'tdo', must be unpinned when the accessed
    01105         information is no longer needed.
    01106  */
    01107
    01108 /*------------------------ OCITypeTypeCode ---------------------------------*/
    01109
    01110 /* ** OBSOLETE ** */
    01111 OCITypeCode OCITypeTypeCode(    OCIEnv *env, OCIError *err,
    01112                                 CONST OCIType *tdo    );
    01113 /*
    01114    NAME: OCITypeTypeCode - OCI Get a Type's Type Code.
    01115    PARAMETERS:
    01116         env (IN/OUT) - OCI environment handle initialized in object mode
    01117         err (IN/OUT) - error handle. If there is an error, it is
    01118                 recorded in 'err' and this function returns OCI_ERROR.
    01119                 The error recorded in 'err' can be retrieved by calling
    01120                 OCIErrorGet().
    01121         tdo (IN) - pointer to to the type descriptor in the object cache
    01122    REQUIRES:
    01123         1) All type accessors require that the type be pinned before calling
    01124            any accessor.
    01125         2) All input parameters must not be NULL and must be valid.
    01126    DESCRIPTION:
    01127         Get the type code of the type.
    01128    RETURNS:
    01129         The type code of the type.
    01130    NOTES:
    01131         The type descriptor, 'tdo', must be unpinned when the accessed
    01132         information is no longer needed.
    01133  */
    01134
    01135 /*----------------------- OCITypeCollTypeCode -------------------------------*/
    01136
    01137 /* ** OBSOLETE ** */
    01138 OCITypeCode OCITypeCollTypeCode(    OCIEnv *env, OCIError *err,
    01139                                     CONST OCIType *tdo    );
    01140 /*
    01141    NAME: OCITypeCollTypeCode - OCI Get a Domain Type's Type Code.
    01142    PARAMETERS:
    01143         env (IN/OUT) - OCI environment handle initialized in object mode
    01144         err (IN/OUT) - error handle. If there is an error, it is
    01145                 recorded in 'err' and this function returns OCI_ERROR.
    01146                 The error recorded in 'err' can be retrieved by calling
    01147                 OCIErrorGet().
    01148         tdo (IN) - pointer to to the type descriptor in the object cache
    01149    REQUIRES:
    01150         1) All type accessors require that the type be pinned before calling
    01151            any accessor.
    01152         2) All input parameters must not be NULL and must be valid.
    01153         3) 'tdo' MUST point to a named collection type.
    01154    DESCRIPTION:
    01155         Get the type code of the named collection type. For V8.0, named
    01156         collection types can only be variable length arrays and nested tables.
    01157    RETURNS:
    01158         OCI_TYPECODE_VARRAY for variable length array, and
    01159         OCI_TYPECODE_TABLE for nested tables.
    01160    NOTES:
    01161         The type descriptor, 'tdo', should be unpinned when the accessed
    01162         information is no longer needed.
    01163  */
    01164
    01165 /*------------------------- OCITypeVersion ---------------------------------*/
    01166
    01167 /* ** OBSOLETE ** */
    01168 oratext* OCITypeVersion(    OCIEnv *env, OCIError *err, CONST OCIType *tdo,
    01169                          ub4 *v_length    );
    01170 /*
    01171    NAME: OCITypeVersion - OCI Get a Type's user-readable VersioN.
    01172    PARAMETERS:
    01173         env (IN/OUT) - OCI environment handle initialized in object mode
    01174         err (IN/OUT) - error handle. If there is an error, it is
    01175                 recorded in 'err' and this function returns OCI_ERROR.
    01176                 The error recorded in 'err' can be retrieved by calling
    01177                 OCIErrorGet().
    01178         tdo (IN) - pointer to to the type descriptor in the object cache
    01179         v_length (OUT) - length (in bytes) of the returned user-readable
    01180                version.  The caller must allocate space for the ub4 before
    01181                calling this routine.
    01182    REQUIRES:
    01183         1) All type accessors require that the type be pinned before calling
    01184            any accessor.
    01185         2) All input parameters must not be NULL and must be valid.
    01186         3) 'v_length' must point to an allocated ub4.
    01187    DESCRIPTION:
    01188         Get the user-readable version of the type.
    01189    RETURNS:
    01190         The user-readable version of the type
    01191    NOTES:
    01192         The type descriptor, 'tdo', must be unpinned when the accessed
    01193         information is no longer needed.
    01194  */
    01195
    01196 /*--------------------------- OCITypeAttrs ---------------------------------*/
    01197
    01198 /* ** OBSOLETE ** */
    01199 ub4 OCITypeAttrs(    OCIEnv *env, OCIError *err, CONST OCIType *tdo    );
    01200 /*
    01201    NAME: OCITypeAttrs - OCI Get a Type's Number of Attributes.
    01202    PARAMETERS:
    01203         env (IN/OUT) - OCI environment handle initialized in object mode
    01204         err (IN/OUT) - error handle. If there is an error, it is
    01205                 recorded in 'err' and this function returns OCI_ERROR.
    01206                 The error recorded in 'err' can be retrieved by calling
    01207                 OCIErrorGet().
    01208         tdo (IN) - pointer to to the type descriptor in the object cache
    01209    REQUIRES:
    01210         1) All type accessors require that the type be pinned before calling
    01211            any accessor.
    01212         2) All input parameters must not be NULL and must be valid.
    01213    DESCRIPTION:
    01214         Get the number of attributes in the type.
    01215    RETURNS:
    01216         The number of attributes in the type. 0 for ALL non-ADTs.
    01217    NOTES:
    01218         The type descriptor, 'tdo', must be unpinned when the accessed
    01219         information is no longer needed.
    01220  */
    01221
    01222 /*------------------------- OCITypeMethods ---------------------------------*/
    01223
    01224 /* ** OBSOLETE ** */
    01225 ub4 OCITypeMethods(    OCIEnv *env, OCIError *err, CONST OCIType *tdo    );
    01226 /*
    01227    NAME: OCITypeMethods - OCI Get a Type's Number of Methods.
    01228    PARAMETERS:
    01229         env (IN/OUT) - OCI environment handle initialized in object mode
    01230         err (IN/OUT) - error handle. If there is an error, it is
    01231                 recorded in 'err' and this function returns OCI_ERROR.
    01232                 The error recorded in 'err' can be retrieved by calling
    01233                 OCIErrorGet().
    01234         tdo (IN) - pointer to to the type descriptor in the object cache
    01235    REQUIRES:
    01236         1) All type accessors require that the type be pinned before calling
    01237            any accessor.
    01238         2) All input parameters must not be NULL and must be valid.
    01239    DESCRIPTION:
    01240         Get the number of methods in a type.
    01241    RETURNS:
    01242         The number of methods in the type
    01243    NOTES:
    01244         The type descriptor, 'tdo', must be unpinned when the accessed
    01245         information is no longer needed.
    01246  */
    01247
    01248
    01249 /*--------------------------------------------------------------------------*/
    01250 /*                     TYPE ELEMENT INFORMATION ACCESSORS                   */
    01251 /*--------------------------------------------------------------------------*/
    01252
    01253 /*------------------------ OCITypeElemName ---------------------------------*/
    01254
    01255 /* ** OBSOLETE ** */
    01256 oratext* OCITypeElemName(    OCIEnv *env, OCIError *err,
    01257                            CONST OCITypeElem *elem, ub4 *n_length    );
    01258 /*
    01259    NAME: OCITypeElemName - OCI Get an Attribute's NaMe.
    01260    PARAMETERS:
    01261         env (IN/OUT) - OCI environment handle initialized in object mode
    01262         err (IN/OUT) - error handle. If there is an error, it is
    01263                 recorded in 'err' and this function returns OCI_ERROR.
    01264                 The error recorded in 'err' can be retrieved by calling
    01265                 OCIErrorGet().
    01266         elem (IN) - pointer to the type element descriptor in the object cache
    01267         n_length (OUT) - length (in bytes) of the returned attribute name.
    01268                The caller must allocate space for the ub4 before calling this
    01269                routine.
    01270    REQUIRES:
    01271         1) All type accessors require that the type be pinned before calling
    01272            any accessor.
    01273         2) All input parameters must not be NULL and must be valid.
    01274         3) 'n_length' must point to an allocated ub4.
    01275    DESCRIPTION:
    01276         Get the name of the attribute.
    01277    RETURNS:
    01278         the name of the attribute and the length in n_length
    01279    NOTES:
    01280         The type must be unpinned when the accessed information is no
    01281         longer needed.
    01282  */
    01283
    01284 /*------------------------ OCITypeElemTypeCode ------------------------------*/
    01285
    01286 /* ** OBSOLETE ** */
    01287 OCITypeCode OCITypeElemTypeCode(    OCIEnv *env, OCIError *err,
    01288                                     CONST OCITypeElem *elem    );
    01289 /*
    01290    NAME: OCITypeElemTypeCode - OCI Get an Attribute's TypeCode.
    01291    PARAMETERS:
    01292         env (IN/OUT) - OCI environment handle initialized in object mode
    01293         err (IN/OUT) - error handle. If there is an error, it is
    01294                 recorded in 'err' and this function returns OCI_ERROR.
    01295                 The error recorded in 'err' can be retrieved by calling
    01296                 OCIErrorGet().
    01297         elem (IN) - pointer to the type element descriptor in the object cache
    01298    REQUIRES:
    01299         1) All type accessors require that the type be pinned before calling
    01300            any accessor.
    01301         2) All input parameters must not be NULL and must be valid.
    01302    DESCRIPTION:
    01303         Get the typecode of an attribute's type.
    01304    RETURNS:
    01305         the typecode of the attribute's type.  If this is a scalar type, the
    01306         typecode sufficiently describes the scalar type and no further calls
    01307         need to be made.  Valid scalar types include: OCI_TYPECODE_SIGNED8,
    01308         OCI_TYPECODE_UNSIGNED8, OCI_TYPECODE_SIGNED16, OCI_TYPECODE_UNSIGNED16,
    01309         OCI_TYPECODE_SIGNED32, OCI_TYPECODE_UNSIGNED32, OCI_TYPECODE_REAL,
    01310         OCI_TYPECODE_DOUBLE, OCI_TYPECODE_DATE,
    01311         OCI_TYPECODE_MLSLABEL, OROTCOID, OCI_TYPECODE_OCTET, or OROTCLOB.
    01312         This function converts the CREF (stored in the attribute) into a
    01313         typecode.
    01314    NOTES:
    01315        The type must be unpinned when the accessed information is no
    01316        longer needed.
    01317  */
    01318
    01319 /*------------------------ OCITypeElemType ---------------------------------*/
    01320
    01321 /* ** OBSOLETE ** */
    01322 sword OCITypeElemType(    OCIEnv *env, OCIError *err, CONST OCITypeElem *elem,
    01323                           OCIType **elem_tdo    );
    01324 /*
    01325   PARAMETERS
    01326      env (IN/OUT) - OCI environment handle initialized in object mode
    01327      err (IN/OUT) - error handle. If there is an error, it is
    01328              recorded in 'err' and this function returns OCI_ERROR.
    01329              The error recorded in 'err' can be retrieved by calling
    01330              OCIErrorGet().
    01331      elem (IN) - pointer to the type element descriptor in the object cache
    01332      elem_tdo (OUT) - If the function completes successfully, 'elem_tdo'
    01333             points to the type descriptor (in the object cache) of the type of
    01334             the element.
    01335
    01336   REQUIRES
    01337      1) All type accessors require that the type be pinned before calling
    01338         any accessor.  This can be done by calling 'OCITypeByName()'.
    01339      2) if 'elem' is not null, it must point to a valid type element descriptor
    01340         in the object cache.
    01341
    01342   DESCRIPTION
    01343      Get the type tdo of the type of this element.
    01344   RETURNS
    01345      OCI_SUCCESS if the function completes successfully.
    01346      OCI_INVALID_HANDLE if 'env' or 'err' is null.
    01347      OCI_ERROR if
    01348          1) any of the parameters is null.
    01349
    01350   NOTES
    01351      The type must be unpinned when the accessed information is no
    01352      longer needed.  This can be done by calling 'OCIObjectUnpin()'.
    01353  */
    01354
    01355 /*------------------------- OCITypeElemFlags -------------------------------*/
    01356
    01357 /* ** OBSOLETE ** */
    01358 ub4 OCITypeElemFlags(    OCIEnv *env, OCIError *err,
    01359                          CONST OCITypeElem *elem    );
    01360 /*
    01361    NAME: OCITypeElemFlags - OCI Get a Elem's FLags
    01362                               (inline, constant, virtual, constructor,
    01363                               destructor).
    01364    PARAMETERS:
    01365         env (IN/OUT) - OCI environment handle initialized in object mode
    01366         err (IN/OUT) - error handle. If there is an error, it is
    01367                 recorded in 'err' and this function returns OCI_ERROR.
    01368                 The error recorded in 'err' can be retrieved by calling
    01369                 OCIErrorGet().
    01370         elem (IN) - pointer to the type element descriptor in the object cache
    01371    REQUIRES:
    01372         1) All type accessors require that the type be pinned before calling
    01373            any accessor.
    01374         2) All input parameters must not be NULL and must be valid.
    01375    DESCRIPTION:
    01376         Get the flags of a type element (attribute, parameter).
    01377    RETURNS:
    01378         The flags of the type element.
    01379    NOTES:
    01380         The flag bits are not externally documented. Use only the macros
    01381         in the last section (ie. OCI_TYPEPARAM_IS_REQUIRED, and
    01382         OCI_TYPEELEM_IS_REF) to test for them only. The type must be unpinned
    01383         when the accessed information is no longer needed.
    01384  */
    01385
    01386 /*------------------------ OCITypeElemNumPrec ------------------------------*/
    01387
    01388 /* ** OBSOLETE ** */
    01389 ub1 OCITypeElemNumPrec(    OCIEnv *env, OCIError *err,
    01390                            CONST OCITypeElem *elem    );
    01391 /*
    01392    NAME: OCITypeElemNumPrec - Get a Number's Precision.  This includes float,
    01393                               decimal, real, double, and oracle number.
    01394    PARAMETERS:
    01395         env (IN/OUT) - OCI environment handle initialized in object mode
    01396         err (IN/OUT) - error handle. If there is an error, it is
    01397                 recorded in 'err' and this function returns OCI_ERROR.
    01398                 The error recorded in 'err' can be retrieved by calling
    01399                 OCIErrorGet().
    01400         elem (IN) - pointer to the type element descriptor in the object cache
    01401    REQUIRES:
    01402         All input parameters must not be NULL and must be valid.
    01403    DESCRIPTION:
    01404         Get the precision of a float, decimal, long, unsigned long, real,
    01405         double, or Oracle number type.
    01406    RETURNS:
    01407         the precision of the float, decimal, long, unsigned long, real, double,
    01408         or Oracle number
    01409  */
    01410
    01411 /*------------------------- OCITypeElemNumScale -----------------------------*/
    01412
    01413 /* ** OBSOLETE ** */
    01414 sb1 OCITypeElemNumScale(    OCIEnv *env, OCIError *err,
    01415                             CONST OCITypeElem *elem    );
    01416 /*
    01417    NAME: OCITypeElemNumScale - Get a decimal or oracle Number's Scale
    01418    PARAMETERS:
    01419         env (IN/OUT) - OCI environment handle initialized in object mode
    01420         err (IN/OUT) - error handle. If there is an error, it is
    01421                 recorded in 'err' and this function returns OCI_ERROR.
    01422                 The error recorded in 'err' can be retrieved by calling
    01423                 OCIErrorGet().
    01424         elem (IN) - pointer to the type element descriptor in the object cache
    01425    REQUIRES:
    01426         All input parameters must not be NULL and must be valid.
    01427    DESCRIPTION:
    01428         Get the scale of a decimal, or Oracle number type.
    01429    RETURNS:
    01430         the scale of the decimal, or Oracle number
    01431  */
    01432
    01433 /*------------------------ OCITypeElemLength -------------------------------*/
    01434
    01435 /* ** OBSOLETE ** */
    01436 ub4 OCITypeElemLength(    OCIEnv *env, OCIError *err,
    01437                           CONST OCITypeElem *elem    );
    01438 /*
    01439    NAME: OCITypeElemLength - Get a raw, fixed or variable length String's
    01440                              length in bytes.
    01441    PARAMETERS:
    01442         env (IN/OUT) - OCI environment handle initialized in object mode
    01443         err (IN/OUT) - error handle. If there is an error, it is
    01444                 recorded in 'err' and this function returns OCI_ERROR.
    01445                 The error recorded in 'err' can be retrieved by calling
    01446                 OCIErrorGet().
    01447         elem (IN) - pointer to the type element descriptor in the object cache
    01448    REQUIRES:
    01449         All input parameters must not be NULL and must be valid.
    01450    DESCRIPTION:
    01451         Get the length of a raw, fixed or variable length string type.
    01452    RETURNS:
    01453         length of the raw, fixed or variable length string
    01454  */
    01455
    01456 /*----------------------- OCITypeElemCharSetID -----------------------------*/
    01457
    01458 /* ** OBSOLETE ** */
    01459 ub2 OCITypeElemCharSetID(    OCIEnv *env, OCIError *err,
    01460                              CONST OCITypeElem *elem    );
    01461 /*
    01462    NAME: OCITypeElemCharSetID - Get a fixed or variable length String's
    01463                                 character set ID
    01464    PARAMETERS:
    01465         env (IN/OUT) - OCI environment handle initialized in object mode
    01466         err (IN/OUT) - error handle. If there is an error, it is
    01467                 recorded in 'err' and this function returns OCI_ERROR.
    01468                 The error recorded in 'err' can be retrieved by calling
    01469                 OCIErrorGet().
    01470         elem (IN) - pointer to the type element descriptor in the object cache
    01471    REQUIRES:
    01472         All input parameters must not be NULL and must be valid.
    01473    DESCRIPTION:
    01474         Get the character set ID of a fixed or variable length string type.
    01475    RETURNS:
    01476         character set ID of the fixed or variable length string
    01477  */
    01478
    01479 /*---------------------- OCITypeElemCharSetForm ----------------------------*/
    01480
    01481 /* ** OBSOLETE ** */
    01482 ub2 OCITypeElemCharSetForm(    OCIEnv *env, OCIError *err,
    01483                                CONST OCITypeElem *elem    );
    01484 /*
    01485    NAME: OCITypeElemCharSetForm - Get a fixed or variable length String's
    01486                                   character set specification form.
    01487    PARAMETERS:
    01488         env (IN/OUT) - OCI environment handle initialized in object mode
    01489         err (IN/OUT) - error handle. If there is an error, it is
    01490                 recorded in 'err' and this function returns OCI_ERROR.
    01491                 The error recorded in 'err' can be retrieved by calling
    01492                 OCIErrorGet().
    01493         elem (IN) - pointer to the attribute information in the object cache
    01494    REQUIRES:
    01495         All input parameters must not be NULL and must be valid.
    01496    DESCRIPTION:
    01497         Get the character form of a fixed or variable length string type.
    01498         The character form is an enumerated value that can be one of the
    01499         4 values below:
    01500                SQLCS_IMPLICIT for CHAR, VARCHAR2, CLOB w/o a specified set
    01501                SQLCS_NCHAR    for NCHAR, NCHAR VARYING, NCLOB
    01502                SQLCS_EXPLICIT for CHAR, etc, with "CHARACTER SET ..." syntax
    01503                SQLCS_FLEXIBLE for PL/SQL "flexible" parameters
    01504    RETURNS:
    01505         character form of the fixed or variable string
    01506  */
    01507
    01508 /*--------------------- OCITypeElemParameterizedType ------------------------*/
    01509
    01510 /* ** OBSOLETE ** */
    01511 sword OCITypeElemParameterizedType(    OCIEnv *env, OCIError *err,
    01512                                        CONST OCITypeElem *elem,
    01513                                        OCIType **type_stored    );
    01514 /*
    01515    NAME: OCITypeElemParameterizedType
    01516    PARAMETERS:
    01517         env (IN/OUT) - OCI environment handle initialized in object mode
    01518         err (IN/OUT) - error handle. If there is an error, it is
    01519                 recorded in 'err' and this function returns OCI_ERROR.
    01520                 The error recorded in 'err' can be retrieved by calling
    01521                 OCIErrorGet().
    01522         elem (IN) - pointer to the type element descriptor in the object cache
    01523         type_stored (OUT) - If the function completes successfully,
    01524                and the parameterized type is complex, 'type_stored' is NULL.
    01525                Otherwise, 'type_stored' points to the type descriptor (in the
    01526                object cache) of the type that is stored in the parameterized
    01527                type.  The caller must allocate space for the OCIType*
    01528                before calling this routine and must not write into the space.
    01529    REQUIRES:
    01530         All input parameters must be valid.
    01531    DESCRIPTION:
    01532         Get a descriptor to the parameter type of a parameterized type.
    01533         Parameterized types are types of the form:
    01534           REF T
    01535           VARRAY (n) OF T
    01536         etc, where T is the parameter in the parameterized type.
    01537         Additionally is_ref is set if the parameter is a PTR or REF.
    01538         For example, it is set for REF T or VARRAY(n) OF REF T.
    01539    RETURNS:
    01540         OCI_SUCCESS if the function completes successfully.
    01541         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    01542         OCI_ERROR if
    01543             1) any of the parameters is null.
    01544             2) 'type_stored' is not NULL but points to NULL data.
    01545    NOTES:
    01546         Complex parameterized types will be in a future release (once
    01547         typedefs are supported.  When setting the parameterized type
    01548         information, the user must typedef the contents if it's a
    01549         complex parameterized type.  Ex. for varray<varray<car>>, use
    01550         'typedef varray<car> varcar' and then use varray<varcar>.
    01551  */
    01552
    01553 /*----------------------- OCITypeElemExtTypeCode ----------------------------*/
    01554
    01555 /* ** OBSOLETE ** */
    01556 OCITypeCode OCITypeElemExtTypeCode(    OCIEnv *env, OCIError *err,
    01557                                        CONST OCITypeElem *elem    );
    01558 /*
    01559    NAME: OCITypeElemExtTypeCode - OCI Get an element's SQLT constant.
    01560    PARAMETERS:
    01561         env (IN/OUT) - OCI environment handle initialized in object mode
    01562         err (IN/OUT) - error handle. If there is an error, it is
    01563                 recorded in 'err' and this function returns OCI_ERROR.
    01564                 The error recorded in 'err' can be retrieved by calling
    01565                 OCIErrorGet().
    01566         elem (IN) - pointer to the type element descriptor in the object cache
    01567    REQUIRES:
    01568         1) All type accessors require that the type be pinned before calling
    01569            any accessor.
    01570         2) All input parameters must not be NULL and must be valid.
    01571    DESCRIPTION:
    01572         Get the internal Oracle typecode associated with an attribute's type.
    01573         This is the actual typecode for the attribute when it gets mapped
    01574         to a column in the Oracle database.
    01575    RETURNS:
    01576         The Oracle typecode associated with the attribute's type.
    01577    NOTES:
    01578         The type must be unpinned when the accessed information is no
    01579         longer needed.
    01580  */
    01581
    01582 /*--------------------------------------------------------------------------*/
    01583 /*                           ATTRIBUTE ACCESSORS                            */
    01584 /*--------------------------------------------------------------------------*/
    01585
    01586 /*------------------------ OCITypeAttrByName -------------------------------*/
    01587
    01588 /* ** OBSOLETE ** */
    01589 sword OCITypeAttrByName(    OCIEnv *env, OCIError *err, CONST OCIType *tdo,
    01590                             CONST oratext *name, ub4 n_length,
    01591                             OCITypeElem **elem    );
    01592 /*
    01593    NAME: OCITypeAttrByName - OCI Get an Attribute By Name.
    01594    PARAMETERS:
    01595         env (IN/OUT) - OCI environment handle initialized in object mode
    01596         err (IN/OUT) - error handle. If there is an error, it is
    01597                 recorded in 'err' and this function returns OCI_ERROR.
    01598                 The error recorded in 'err' can be retrieved by calling
    01599                 OCIErrorGet().
    01600         tdo (IN) - pointer to to the type descriptor in the object cache
    01601         name (IN) - the attribute's name
    01602         n_length (IN) - length (in bytes) of the 'name' parameter
    01603         elem (OUT) - If this function completes successfully, 'elem' points to
    01604                the selected type element descriptor pertaining to the
    01605                attributein the object cache.
    01606    REQUIRES:
    01607         1) All type accessors require that the type be pinned before calling
    01608            any accessor.
    01609         2) if 'tdo' is not null, it must point to a valid type descriptor
    01610            in the object cache.
    01611    DESCRIPTION:
    01612         Get an attribute given its name.
    01613    RETURNS:
    01614         OCI_SUCCESS if the function completes successfully.
    01615         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    01616         OCI_ERROR if
    01617             1) any of the required parameters is null.
    01618             2) the type does not contain an attribute with the input 'name'.
    01619             3) 'name' is NULL.
    01620    NOTES:
    01621         The type descriptor, 'tdo', must be unpinned when the accessed
    01622         information is no longer needed.
    01623         Schema and type names are CASE-SENSITIVE. If they have been created
    01624         via SQL, you need to use uppercase names.
    01625  */
    01626
    01627 /*------------------------ OCITypeAttrNext ---------------------------------*/
    01628
    01629 /* ** OBSOLETE ** */
    01630 sword OCITypeAttrNext(    OCIEnv *env, OCIError *err,
    01631                         OCITypeIter *iterator_ort, OCITypeElem **elem    );
    01632
    01633 /*
    01634    NAME: OCITypeAttrNext - OCI Get an Attribute By Iteration.
    01635    PARAMETERS:
    01636         env (IN/OUT) - OCI environment handle initialized in object mode
    01637         err (IN/OUT) - error handle. If there is an error, it is
    01638                 recorded in 'err' and this function returns OCI_ERROR.
    01639                 The error recorded in 'err' can be retrieved by calling
    01640                 OCIErrorGet().
    01641         iterator_ort (IN/OUT) - iterator for retrieving the next attribute;
    01642                see OCITypeIterNew() to initialize iterator.
    01643         elem (OUT) - If this function completes successfully, 'elem' points to
    01644                the selected type element descriptor pertaining to the
    01645                attributein the object cache.
    01646    REQUIRES:
    01647         1) All type accessors require that the type be pinned before calling
    01648             any accessor.
    01649         2) if 'tdo' is not null, it must point to a valid type descriptor
    01650            in the object cache.
    01651    DESCRIPTION:
    01652         Iterate to the next attribute to retrieve.
    01653    RETURNS:
    01654         OCI_SUCCESS if the function completes successfully.
    01655         OCI_NO_DATA if there are no more attributes to iterate on; use
    01656             OCITypeIterSet() to reset the iterator if necessary.
    01657         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    01658         OCI_ERROR if
    01659             1) any of the required parameters is null.
    01660    NOTES:
    01661         The type must be unpinned when the accessed information is no
    01662         longer needed.
    01663  */
    01664
    01665 /*--------------------------------------------------------------------------*/
    01666 /*                           COLLECTION ACCESSORS                           */
    01667 /*--------------------------------------------------------------------------*/
    01668
    01669 /*------------------------ OCITypeCollElem ---------------------------------*/
    01670
    01671 /* ** OBSOLETE ** */
    01672 sword OCITypeCollElem(    OCIEnv *env, OCIError *err, CONST OCIType *tdo,
    01673                           OCITypeElem **element    );
    01674 /*
    01675    NAME: OCITypeCollElem
    01676    PARAMETERS:
    01677         env (IN/OUT) - OCI environment handle initialized in object mode
    01678         err (IN/OUT) - error handle. If there is an error, it is
    01679                 recorded in 'err' and this function returns OCI_ERROR.
    01680                 The error recorded in 'err' can be retrieved by calling
    01681                 OCIErrorGet().
    01682         tdo (IN) - pointer to the type descriptor in the object cache
    01683         element (IN/OUT) - If the function completes successfully, this
    01684                points to the descriptor for the collection's element.
    01685                It is stored in the same format as an ADT attribute's
    01686                descriptor.
    01687                If *element is NULL, OCITypeCollElem() implicitly allocates a
    01688                new instance of OCITypeElem in the object cache. This instance
    01689                will be
    01690                automatically freed at the end of the session, and does not have
    01691                to be freed explicitly.
    01692                If *element is not NULL, OCITypeCollElem() assumes that it
    01693                points to a valid OCITypeElem descriptor and will copy the
    01694                results into it.
    01695    REQUIRES:
    01696         All input parameters must be valid.
    01697    DESCRIPTION:
    01698         Get a pointer to the descriptor (OCITypeElem) of the element of an
    01699         array or the rowtype of a nested table.
    01700    RETURNS:
    01701         OCI_SUCCESS if the function completes successfully.
    01702         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    01703         OCI_ERROR if
    01704             1) any of the parameters is null.
    01705             2) the type TDO does not point to a valid collection's type.
    01706    NOTES:
    01707         Complex parameterized types will be in a future release (once
    01708         typedefs are supported.  When setting the parameterized type
    01709         information, the user must typedef the contents if it's a
    01710         complex parameterized type.  Ex. for varray<varray<car>>, use
    01711         'typedef varray<car> varcar' and then use varray<varcar>.
    01712  */
    01713
    01714 /*------------------------ OCITypeCollSize ---------------------------------*/
    01715
    01716 /* ** OBSOLETE ** */
    01717 sword OCITypeCollSize(    OCIEnv *env, OCIError *err, CONST OCIType *tdo,
    01718                           ub4 *num_elems    );
    01719 /*
    01720    NAME: OCITypeCollSize - OCI Get a Collection's Number of Elements.
    01721    PARAMETERS:
    01722         env (IN/OUT) - OCI environment handle initialized in object mode
    01723         err (IN/OUT) - error handle. If there is an error, it is
    01724                 recorded in 'err' and this function returns OCI_ERROR.
    01725                 The error recorded in 'err' can be retrieved by calling
    01726                 OCIErrorGet().
    01727         tdo (IN) - pointer to the type descriptor in the object cache
    01728         num_elems (OUT) - number of elements in collection
    01729    REQUIRES:
    01730         All input parameters must be valid. tdo points to an array type
    01731         defined as a domain.
    01732    DESCRIPTION:
    01733         Get the number of elements stored in a fixed array or the maximum
    01734         number of elements in a variable array.
    01735    RETURNS:
    01736         OCI_SUCCESS if the function completes successfully.
    01737         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    01738         OCI_ERROR if
    01739             1) any of the parameters is null.
    01740             2) 'tdo' does not point to a domain with a collection type.
    01741    NOTES:
    01742         Complex parameterized types will be in a future release (once
    01743         typedefs are supported.  When setting the parameterized type
    01744         information, the user must typedef the contents if it's a
    01745         complex parameterized type.  Ex. for varray<varray<car>>, use
    01746         'typedef varray<car> varcar' and then use varray<varcar>.
    01747  */
    01748
    01749 /*------------------------ OCITypeCollExtTypeCode ---------------------------*/
    01750
    01751 /* ** OBSOLETE ** */
    01752 sword OCITypeCollExtTypeCode(    OCIEnv *env, OCIError *err,
    01753                                CONST OCIType *tdo, OCITypeCode *sqt_code    );
    01754 /*
    01755    NAME: ortcsqt - OCI Get a Collection element's DTY constant.
    01756    PARAMETERS:
    01757         env (IN/OUT) - OCI environment handle initialized in object mode
    01758         err (IN/OUT) - error handle. If there is an error, it is
    01759                 recorded in 'err' and this function returns OCI_ERROR.
    01760                 The error recorded in 'err' can be retrieved by calling
    01761                 OCIErrorGet().
    01762         tdo (IN) - pointer to the type descriptor in the object cache
    01763         sqt_code (OUT) - SQLT code of type element.
    01764    REQUIRES:
    01765         1) All type accessors require that the type be pinned before calling
    01766            any accessor.
    01767         2) All input parameters must not be NULL and must be valid.
    01768    DESCRIPTION:
    01769         Get the SQLT constant associated with an domain's element type.
    01770         The SQLT codes are defined in <sqldef.h> and are needed for OCI/OOCI
    01771         use.
    01772    RETURNS:
    01773         OCI_SUCCESS if the function completes successfully.
    01774         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    01775         OCI_ERROR if
    01776             1) any of the parameters is null.
    01777             2) 'tdo' does not point to a domain with a collection type.
    01778    NOTES:
    01779         The type must be unpinned when the accessed information is no
    01780         longer needed.
    01781  */
    01782
    01783
    01784 /*--------------------------------------------------------------------------*/
    01785 /*                             METHOD ACCESSORS                             */
    01786 /*--------------------------------------------------------------------------*/
    01787
    01788 /*------------------------- OCITypeMethodOverload --------------------------*/
    01789
    01790 /* ** OBSOLETE ** */
    01791 ub4 OCITypeMethodOverload(    OCIEnv *env, OCIError *err, CONST OCIType *tdo,
    01792                               CONST oratext *method_name, ub4 m_length    );
    01793 /*
    01794    NAME: OCITypeMethodOverload - OCI Get type's Number of Overloaded names
    01795                                  for the given method name.
    01796    PARAMETERS:
    01797         gp (IN/OUT) - pga environment handle.  Any errors are recorded here.
    01798         tdo (IN) - pointer to to the type descriptor in the object cache
    01799         method_name (IN) - the method's name
    01800         m_length (IN) - length (in bytes) of the 'method_name' parameter
    01801    REQUIRES:
    01802         1) All type accessors require that the type be pinned before calling
    01803            any accessor.
    01804         2) if 'tdo' is not null, it must point to a valid type descriptor
    01805            in the object cache.
    01806    DESCRIPTION:
    01807         Overloading of methods implies that more than one method may have the
    01808         same method name.  This routine returns the number of methods that
    01809         have the given method name.  If there are no methods with the input
    01810         method name, 'num_methods' is 0.  The caller uses this information when
    01811         allocating space for the array of mdo and/or position pointers before
    01812         calling 'OCITypeMethodByName()' or 'ortgmps()'.
    01813    RETURNS:
    01814         The number of methods with the given name. 0 if none contains the
    01815         name.
    01816    NOTES:
    01817         Schema and type names are CASE-SENSITIVE. If they have been created
    01818         via SQL, you need to use uppercase names.
    01819  */
    01820
    01821 /*------------------------ OCITypeMethodByName ------------------------------*/
    01822
    01823 /* ** OBSOLETE ** */
    01824 sword OCITypeMethodByName(    OCIEnv *env, OCIError *err, CONST OCIType *tdo,
    01825                               CONST oratext *method_name, ub4 m_length,
    01826                               OCITypeMethod **mdos    );
    01827 /*
    01828    NAME: OCITypeMethodByName - OCI Get one or more Methods with Name.
    01829    PARAMETERS:
    01830         env (IN/OUT) - OCI environment handle initialized in object mode
    01831         err (IN/OUT) - error handle. If there is an error, it is
    01832                 recorded in 'err' and this function returns OCI_ERROR.
    01833                 The error recorded in 'err' can be retrieved by calling
    01834                 OCIErrorGet().
    01835         tdo (IN) - pointer to to the type descriptor in the object cache
    01836         method_name (IN) - the methods' name
    01837         m_length (IN) - length (in bytes) of the 'name' parameter
    01838         mdos (OUT) - If this function completes successfully, 'mdos' points to
    01839                 the selected methods in the object cache.  The caller must
    01840                 allocate space for the array of OCITypeMethod pointers before
    01841                 calling this routine and must not write into the space.
    01842                 The number of OCITypeMethod pointers that will be returned can
    01843                 be obtained by calling 'OCITypeMethodOverload()'.
    01844    REQUIRES:
    01845         1) All type accessors require that the type be pinned before calling
    01846            any accessor.
    01847         2) if 'tdo' is not null, it must point to a valid type descriptor
    01848            in the object cache.
    01849    DESCRIPTION:
    01850         Get one or more methods given the name.
    01851    RETURNS:
    01852         OCI_SUCCESS if the function completes successfully.
    01853         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    01854         OCI_ERROR if
    01855             1) any of the required parameters is null.
    01856             2) No methods in type has name 'name'.
    01857             3) 'mdos' is not NULL but points to NULL data.
    01858    NOTES:
    01859         The type must be unpinned when the accessed information is no
    01860         longer needed.
    01861         Schema and type names are CASE-SENSITIVE. If they have been created
    01862         via SQL, you need to use uppercase names.
    01863  */
    01864
    01865 /*------------------------ OCITypeMethodNext --------------------------------*/
    01866
    01867 /* ** OBSOLETE ** */
    01868 sword OCITypeMethodNext(    OCIEnv *env, OCIError *err,
    01869                             OCITypeIter *iterator_ort,
    01870                             OCITypeMethod **mdo   );
    01871
    01872 /*
    01873    NAME: OCITypeMethodNext - OCI Get a Method By Iteration.
    01874    PARAMETERS:
    01875         env (IN/OUT) - OCI environment handle initialized in object mode
    01876         err (IN/OUT) - error handle. If there is an error, it is
    01877                 recorded in 'err' and this function returns OCI_ERROR.
    01878                 The error recorded in 'err' can be retrieved by calling
    01879                 OCIErrorGet().
    01880         iterator_ort (IN/OUT) - iterator for retrieving the next method;
    01881                see OCITypeIterNew() to set iterator.
    01882         mdo (OUT) - If this function completes successfully, 'mdo' points to
    01883                the selected method descriptor in the object cache.  Positions
    01884                start at 1.  The caller must allocate space for the
    01885                OCITypeMethod* before calling this routine and must not write
    01886                nto the space.
    01887    REQUIRES:
    01888          1) All type accessors require that the type be pinned before calling
    01889             any accessor.
    01890         2) if 'tdo' is not null, it must point to a valid type descriptor
    01891            in the object cache.
    01892    DESCRIPTION:
    01893         Iterate to the next method to retrieve.
    01894    RETURNS:
    01895         OCI_SUCCESS if the function completes successfully.
    01896         OCI_NO_DATA if there are no more attributes to iterate on; use
    01897             OCITypeIterSet() to reset the iterator if necessary.
    01898         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    01899         OCI_ERROR if
    01900             1) any of the required parameters is null.
    01901             2) 'mdo' is not NULL but points to NULL data.
    01902    NOTES:
    01903         The type must be unpinned when the accessed information is no
    01904         longer needed.
    01905  */
    01906
    01907 /*------------------------ OCITypeMethodName --------------------------------*/
    01908
    01909 /* ** OBSOLETE ** */
    01910 oratext *OCITypeMethodName(    OCIEnv *env, OCIError *err,
    01911                             CONST OCITypeMethod *mdo, ub4 *n_length    );
    01912 /*
    01913    NAME: OCITypeMethodName - OCI Get a Method's NaMe.
    01914    PARAMETERS:
    01915         env (IN/OUT) - OCI environment handle initialized in object mode
    01916         err (IN/OUT) - error handle. If there is an error, it is
    01917                 recorded in 'err' and this function returns OCI_ERROR.
    01918                 The error recorded in 'err' can be retrieved by calling
    01919                 OCIErrorGet().
    01920         mdo (IN) - pointer to the method descriptor in the object cache
    01921         n_length (OUT) - length (in bytes) of the 'name' parameter.  The caller
    01922                must allocate space for the ub4 before calling this routine.
    01923    REQUIRES:
    01924         1) All type accessors require that the type be pinned before calling
    01925            any accessor.
    01926         2) All input parameters must not be NULL and must be valid.
    01927    DESCRIPTION:
    01928         Get the (non-unique) real name of the method.
    01929    RETURNS:
    01930         the non-unique name of the method or NULL if there is an error.
    01931    NOTES:
    01932         The type must be unpinned when the accessed information is no
    01933         longer needed.
    01934  */
    01935
    01936 /*------------------------ OCITypeMethodEncap -------------------------------*/
    01937
    01938 /* ** OBSOLETE ** */
    01939 OCITypeEncap OCITypeMethodEncap(    OCIEnv *env, OCIError *err,
    01940                                     CONST OCITypeMethod *mdo    );
    01941 /*
    01942    NAME: OCITypeMethodEncap - Get a Method's ENcapsulation (private/public).
    01943    PARAMETERS:
    01944         env (IN/OUT) - OCI environment handle initialized in object mode
    01945         err (IN/OUT) - error handle. If there is an error, it is
    01946                 recorded in 'err' and this function returns OCI_ERROR.
    01947                 The error recorded in 'err' can be retrieved by calling
    01948                 OCIErrorGet().
    01949         mdo (IN) - pointer to the method descriptor in the object cache
    01950    REQUIRES:
    01951         1) All type accessors require that the type be pinned before calling
    01952            any accessor.
    01953         2) All input parameters must not be NULL and must be valid.
    01954    DESCRIPTION:
    01955         Get the encapsulation (private, or public) of a method.
    01956    RETURNS:
    01957         the encapsulation (private, or public) of the method
    01958    NOTES:
    01959         The type must be unpinned when the accessed information is no
    01960         longer needed.
    01961  */
    01962
    01963 /*------------------------ OCITypeMethodFlags -------------------------------*/
    01964
    01965 /* ** OBSOLETE ** */
    01966 OCITypeMethodFlag OCITypeMethodFlags(    OCIEnv *env, OCIError *err,
    01967                                          CONST OCITypeMethod *mdo    );
    01968 /*
    01969    NAME: OCITypeMethodFlags - OCI Get a Method's FLags
    01970                               (inline, constant, virtual, constructor,
    01971                               destructor).
    01972    PARAMETERS:
    01973         env (IN/OUT) - OCI environment handle initialized in object mode
    01974         err (IN/OUT) - error handle. If there is an error, it is
    01975                 recorded in 'err' and this function returns OCI_ERROR.
    01976                 The error recorded in 'err' can be retrieved by calling
    01977                 OCIErrorGet().
    01978         mdo (IN) - pointer to the method descriptor in the object cache
    01979    REQUIRES:
    01980         1) All type accessors require that the type be pinned before calling
    01981            any accessor.
    01982         2) All input parameters must not be NULL and must be valid.
    01983    DESCRIPTION:
    01984         Get the flags (inline, constant, virutal, constructor, destructor) of
    01985         a method.
    01986    RETURNS:
    01987         the flags (inline, constant, virutal, constructor, destructor) of
    01988         the method
    01989    NOTES:
    01990         The type must be unpinned when the accessed information is no
    01991         longer needed.
    01992  */
    01993
    01994 /*------------------------ OCITypeMethodMap ---------------------------------*/
    01995
    01996 /* ** OBSOLETE ** */
    01997 sword OCITypeMethodMap(    OCIEnv *env, OCIError *err, CONST OCIType *tdo,
    01998                            OCITypeMethod **mdo    );
    01999 /*
    02000    NAME: OCITypeMethodMap - OCI Get the Method's MAP function.
    02001    PARAMETERS:
    02002         env (IN/OUT) - OCI environment handle initialized in object mode
    02003         err (IN/OUT) - error handle. If there is an error, it is
    02004                 recorded in 'err' and this function returns OCI_ERROR.
    02005                 The error recorded in 'err' can be retrieved by calling
    02006                 OCIErrorGet().
    02007         tdo (IN) - pointer to to the type descriptor in the object cache
    02008         mdo (OUT) - If this function completes successfully, and there is a
    02009                map function for this type, 'mdo' points to the selected method
    02010                descriptor in the object cache.  Otherwise, 'mdo' is null.
    02011    REQUIRES:
    02012         1) All type accessors require that the type be pinned before calling
    02013            any accessor.
    02014         2) All required input parameters must not be NULL and must be valid.
    02015    DESCRIPTION:
    02016         A type may have only one map function.  'OCITypeMethodMap()' finds
    02017         this function, if it exists, and returns a reference and a pointer to
    02018         the method descriptor in the object cache.  If the type does not have a
    02019         map (relative ordering) function, then 'mdo_ref' and 'mdo' are set
    02020         to null and an error is returned.
    02021    RETURNS:
    02022         OCI_SUCCESS if the function completes successfully.
    02023         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    02024         OCI_ERROR if
    02025             the type does not contain a map function.
    02026    NOTES:
    02027         The type must be unpinned when the accessed information is no
    02028         longer needed.
    02029  */
    02030
    02031 /*------------------------ OCITypeMethodOrder -------------------------------*/
    02032
    02033 /* ** OBSOLETE ** */
    02034 sword OCITypeMethodOrder(    OCIEnv *env, OCIError *err, CONST OCIType *tdo,
    02035                              OCITypeMethod **mdo    );
    02036 /*
    02037    NAME: OCITypeMethodOrder - OCI Get the Method's ORder function.
    02038    PARAMETERS:
    02039         env (IN/OUT) - OCI environment handle initialized in object mode
    02040         err (IN/OUT) - error handle. If there is an error, it is
    02041                 recorded in 'err' and this function returns OCI_ERROR.
    02042                 The error recorded in 'err' can be retrieved by calling
    02043                 OCIErrorGet().
    02044         tdo (IN) - pointer to to the type descriptor in the object cache
    02045         mdo (OUT) - If this function completes successfully, and there is a
    02046                map function for this type, 'mdo' points to the selected method
    02047                descriptor in the object cache.  Otherwise, 'mdo' is null.
    02048    REQUIRES:
    02049         1) All type accessors require that the type be pinned before calling
    02050            any accessor.
    02051         2) All required input parameters must not be NULL and must be valid.
    02052    DESCRIPTION:
    02053         A type may have only one ORder or MAP function. 'OCITypeMethodOrder()'
    02054         finds this function, if it exists, and returns a ref and a pointer
    02055         to the method descriptor in the object cache.  If the type does not
    02056         have a map (relative ordering) function, then 'mdo_ref' and 'mdo' are
    02057         set to null and an error is returned.
    02058    RETURNS:
    02059         OCI_SUCCESS if the function completes successfully.
    02060         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    02061         OCI_ERROR if
    02062             the type does not contain a map function.
    02063    NOTES:
    02064         The type must be unpinned when the accessed information is no
    02065         longer needed.
    02066  */
    02067
    02068 /*------------------------ OCITypeMethodParams ------------------------------*/
    02069
    02070 /* ** OBSOLETE ** */
    02071 ub4 OCITypeMethodParams(    OCIEnv *env, OCIError *err,
    02072                             CONST OCITypeMethod *mdo    );
    02073 /*
    02074    NAME: OCITypeMethodParams - OCI Get a Method's Number of Parameters.
    02075    PARAMETERS:
    02076         env (IN/OUT) - OCI environment handle initialized in object mode
    02077         err (IN/OUT) - error handle. If there is an error, it is
    02078                 recorded in 'err' and this function returns OCI_ERROR.
    02079                 The error recorded in 'err' can be retrieved by calling
    02080                 OCIErrorGet().
    02081         mdo (IN) - pointer to the method descriptor in the object cache
    02082    REQUIRES:
    02083         1) All type accessors require that the type be pinned before calling
    02084            any accessor.
    02085         2) All input parameters must not be NULL and must be valid.
    02086    DESCRIPTION:
    02087         Get the number of parameters in a method.
    02088    RETURNS:
    02089         the number of parameters in the method
    02090    NOTES:
    02091         The type must be unpinned when the accessed information is no
    02092         longer needed.
    02093  */
    02094
    02095
    02096 /*--------------------------------------------------------------------------*/
    02097 /*                             RESULT ACCESSORS                             */
    02098 /*--------------------------------------------------------------------------*/
    02099
    02100 /*-------------------------- OCITypeResult ---------------------------------*/
    02101
    02102 /* ** OBSOLETE ** */
    02103 sword OCITypeResult(    OCIEnv *env, OCIError *err, CONST OCITypeMethod *mdo,
    02104                         OCITypeElem **elem    );
    02105 /*
    02106    NAME: OCITypeResult - OCI Get a method's result type descriptor.
    02107    PARAMETERS:
    02108         env (IN/OUT) - OCI environment handle initialized in object mode
    02109         err (IN/OUT) - error handle. If there is an error, it is
    02110                 recorded in 'err' and this function returns OCI_ERROR.
    02111                 The error recorded in 'err' can be retrieved by calling
    02112                 OCIErrorGet().
    02113         mdo (IN) - pointer to the method descriptor in the object cache
    02114         elem (OUT) - If this function completes successfully, 'rdo' points to
    02115                the selected result (parameter) descriptor in the object cache.
    02116    REQUIRES:
    02117         1) All type accessors require that the type be pinned before calling
    02118            any accessor.
    02119         2) 'elem' MUST be the address of an OCITypeElem pointer.
    02120    DESCRIPTION:
    02121         Get the result of a method.
    02122    RETURNS:
    02123         OCI_SUCCESS if the function completes successfully.
    02124         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    02125         OCI_ERROR if
    02126             1) any of the required parameters is null.
    02127             2) method returns no results.
    02128    NOTES:
    02129         The method must be unpinned when the accessed information is no
    02130         longer needed.
    02131  */
    02132
    02133
    02134 /*--------------------------------------------------------------------------*/
    02135 /*                           PARAMETER ACCESSORS                            */
    02136 /*--------------------------------------------------------------------------*/
    02137
    02138 /*------------------------ OCITypeParamByPos -------------------------------*/
    02139
    02140 /* ** OBSOLETE ** */
    02141 sword OCITypeParamByPos(    OCIEnv *env, OCIError *err,
    02142                             CONST OCITypeMethod *mdo, ub4 position,
    02143                             OCITypeElem **elem    );
    02144 /*
    02145    NAME: OCITypeParamByPos - OCI Get a Parameter in a method By Position.
    02146    PARAMETERS:
    02147         env (IN/OUT) - OCI environment handle initialized in object mode
    02148         err (IN/OUT) - error handle. If there is an error, it is
    02149                 recorded in 'err' and this function returns OCI_ERROR.
    02150                 The error recorded in 'err' can be retrieved by calling
    02151                 OCIErrorGet().
    02152         mdo (IN) - pointer to the method descriptor in the object cache
    02153         position (IN) - the parameter's position.  Positions start at 1.
    02154         elem (OUT) - If this function completes successfully, 'elem' points to
    02155                the selected parameter descriptor in the object cache.
    02156    REQUIRES:
    02157         1) All type accessors require that the type be pinned before calling
    02158            any accessor.
    02159    DESCRIPTION:
    02160         Get a parameter given its position in the method.  Positions start
    02161         at 1.
    02162    RETURNS:
    02163         OCI_SUCCESS if the function completes successfully.
    02164         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    02165         OCI_ERROR if
    02166             1) any of the required parameters is null.
    02167             2) 'position' is not >= 1 and <= the number of parameters in the
    02168                method.
    02169    NOTES:
    02170         The type must be unpinned when the accessed information is no
    02171         longer needed.
    02172  */
    02173
    02174 /*------------------------ OCITypeParamByName -------------------------------*/
    02175
    02176 /* ** OBSOLETE ** */
    02177 sword OCITypeParamByName(    OCIEnv *env, OCIError *err,
    02178                              CONST OCITypeMethod *mdo,
    02179                              CONST oratext *name, ub4 n_length,
    02180                              OCITypeElem **elem    );
    02181 /*
    02182    NAME: OCITypeParamByName - OCI Get a Parameter in a method By Name.
    02183    PARAMETERS:
    02184         env (IN/OUT) - OCI environment handle initialized in object mode
    02185         err (IN/OUT) - error handle. If there is an error, it is
    02186                 recorded in 'err' and this function returns OCI_ERROR.
    02187                 The error recorded in 'err' can be retrieved by calling
    02188                 OCIErrorGet().
    02189         mdo (IN) - pointer to the method descriptor in the object cache
    02190         name (IN) - the parameter's name
    02191         n_length (IN) - length (in bytes) of the 'name' parameter
    02192         elem (OUT) - If this function completes successfully, 'elem' points to
    02193                the selected parameter descriptor in the object cache.
    02194    REQUIRES:
    02195         1) All type accessors require that the type be pinned before calling
    02196            any accessor.
    02197         2) if 'mdo' is not null, it must point to a valid method descriptor
    02198            in the object cache.
    02199    DESCRIPTION:
    02200         Get a parameter given its name.
    02201    RETURNS:
    02202         OCI_SUCCESS if the function completes successfully.
    02203         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    02204         OCI_ERROR if
    02205             1) any of the required parameters is null.
    02206             2) the method does not contain a parameter with the input 'name'.
    02207    NOTES:
    02208         The type must be unpinned when the accessed information is no
    02209         longer needed.
    02210  */
    02211
    02212 /*------------------------ OCITypeParamPos ---------------------------------*/
    02213
    02214 /* ** OBSOLETE ** */
    02215 sword OCITypeParamPos(    OCIEnv *env, OCIError *err,
    02216                           CONST OCITypeMethod *mdo,
    02217                           CONST oratext *name, ub4 n_length, ub4 *position,
    02218                           OCITypeElem **elem    );
    02219 /*
    02220    NAME: OCITypeParamPos - OCI Get a parameter's position in a method
    02221    PARAMETERS:
    02222         env (IN/OUT) - OCI environment handle initialized in object mode
    02223         err (IN/OUT) - error handle. If there is an error, it is
    02224                 recorded in 'err' and this function returns OCI_ERROR.
    02225                 The error recorded in 'err' can be retrieved by calling
    02226                 OCIErrorGet().
    02227         mdo (IN) - pointer to the method descriptor in the object cache
    02228         name (IN) - the parameter's name
    02229         n_length (IN) - length (in bytes) of the 'name' parameter
    02230         position (OUT) - If this function completes successfully, 'position'
    02231                points to the position of the parameter in the method starting
    02232                at position 1. position MUST point to space for a ub4.
    02233         elem (OUT) - If this function completes successfully, and
    02234                the input 'elem' is not NULL, 'elem' points to the selected
    02235                parameter descriptor in the object cache.
    02236    REQUIRES:
    02237         1) All type accessors require that the type be pinned before calling
    02238            any accessor.
    02239         2) if 'mdo' is not null, it must point to a valid method descriptor
    02240            in the object cache.
    02241    DESCRIPTION:
    02242         Get the position of a parameter in a method.  Positions start at 1.
    02243    RETURNS:
    02244         OCI_SUCCESS if the function completes successfully.
    02245         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    02246         OCI_ERROR if
    02247             1) any of the parameters is null.
    02248             2) the method does not contain a parameter with the input 'name'.
    02249    NOTES:
    02250         The type must be unpinned when the accessed information is no
    02251         longer needed.
    02252  */
    02253
    02254 /*------------------------ OCITypeParamElemMode -----------------------------*/
    02255
    02256 /* ** OBSOLETE ** */
    02257 OCITypeParamMode OCITypeElemParamMode(    OCIEnv *env, OCIError *err,
    02258                                           CONST OCITypeElem *elem    );
    02259 /*
    02260    NAME: OCITypeElemParamMode - OCI Get a parameter's mode
    02261    PARAMETERS:
    02262         env (IN/OUT) - OCI environment handle initialized in object mode
    02263         err (IN/OUT) - error handle. If there is an error, it is
    02264                 recorded in 'err' and this function returns OCI_ERROR.
    02265                 The error recorded in 'err' can be retrieved by calling
    02266                 OCIErrorGet().
    02267         elem (IN) - pointer to the parameter descriptor in the object cache
    02268                 (represented by an OCITypeElem)
    02269    REQUIRES:
    02270         1) All type accessors require that the type be pinned before calling
    02271            any accessor.
    02272         2) All input parameters must not be NULL and must be valid.
    02273    DESCRIPTION:
    02274         Get the mode (in, out, or in/out) of the parameter.
    02275    RETURNS:
    02276         the mode (in, out, or in/out) of the parameter
    02277    NOTES:
    02278         The type must be unpinned when the accessed information is no
    02279         longer needed.
    02280  */
    02281
    02282 /*------------------------- OCITypeElemDefaultValue -------------------------*/
    02283
    02284 /* ** OBSOLETE ** */
    02285 oratext* OCITypeElemDefaultValue(    OCIEnv *env, OCIError *err,
    02286                                   CONST OCITypeElem *elem,
    02287                                   ub4 *d_v_length    );
    02288 /*
    02289    NAME: OCITypeElemDefaultValue - OCI Get the element's Default Value.
    02290    PARAMETERS:
    02291         env (IN/OUT) - OCI environment handle initialized in object mode
    02292         err (IN/OUT) - error handle. If there is an error, it is
    02293                 recorded in 'err' and this function returns OCI_ERROR.
    02294                 The error recorded in 'err' can be retrieved by calling
    02295                 OCIErrorGet().
    02296         elem (IN) - pointer to the parameter descriptor in the object cache
    02297                 (represented by an OCITypeElem)
    02298         d_v_length (OUT) - length (in bytes) of the returned default value.
    02299                The caller must allocate space for the ub4 before calling this
    02300                routine.
    02301    REQUIRES:
    02302         1) All type accessors require that the type be pinned before calling
    02303            any accessor.
    02304         2) All input parameters must not be NULL and must be valid.
    02305    DESCRIPTION:
    02306         Get the default value in text form (PL/SQL) of an element. For V8.0,
    02307         this only makes sense for a method parameter.
    02308    RETURNS:
    02309         The default value (text) of the parameter.
    02310    NOTES:
    02311         The type must be unpinned when the accessed information is no
    02312         longer needed.
    02313  */
    02314
    02315
    02316 /*--------------------------------------------------------------------------*/
    02317 /*                           TYPE VERSION TABLE                             */
    02318 /*--------------------------------------------------------------------------*/
    02319
    02320 /* For V8.0, the type version table is meant to be an internal data structure
    02321    only for Oracle clients for type version maintanence purposes. A more
    02322    general version of the API may be made public in subsequent releases. */
    02323
    02324
    02325 /*--------------------------- OCITypeVTInit --------------------------------*/
    02326
    02327 /* ** OBSOLETE ** */
    02328 sword OCITypeVTInit(    OCIEnv *env, OCIError *err    );
    02329 /*
    02330    NAME: OCITypeVTInit - OCI type Version table INItialize
    02331    PARAMETERS:
    02332         env (IN/OUT) - OCI environment handle initialized in object mode
    02333         err (IN/OUT) - error handle. If there is an error, it is
    02334                 recorded in 'err' and this function returns OCI_ERROR.
    02335                 The error recorded in 'err' can be retrieved by calling
    02336                 OCIErrorGet().
    02337    REQUIRES:
    02338         none
    02339    DESCRIPTION:
    02340         Allocate space for and initialize the type version table and the type
    02341         version table's index.
    02342    RETURNS:
    02343         OCI_SUCCESS if the function completes successfully.
    02344         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    02345         OCI_ERROR if internal errors occurrs during initialization.
    02346  */
    02347
    02348 /*--------------------------- OCITypeVTInsert -------------------------------*/
    02349
    02350 /* ** OBSOLETE ** */
    02351 sword OCITypeVTInsert(    OCIEnv *env, OCIError *err,
    02352                           CONST oratext *schema_name, ub4 s_n_length,
    02353                           CONST oratext *type_name, ub4 t_n_length,
    02354                           CONST oratext *user_version, ub4 u_v_length    );
    02355 /*
    02356    NAME: OCITypeVTInsert - OCI type Version table INSert entry.
    02357    PARAMETERS:
    02358         env (IN/OUT) - OCI environment handle initialized in object mode
    02359         err (IN/OUT) - error handle. If there is an error, it is
    02360                 recorded in 'err' and this function returns OCI_ERROR.
    02361                 The error recorded in 'err' can be retrieved by calling
    02362                 OCIErrorGet().
    02363         schema_name (IN, optional) - name of schema associated with the
    02364                   type.  By default, the user's schema name is used.
    02365         s_n_length (IN) - length of the 'schema_name' parameter
    02366         type_name (IN) - type name to insert
    02367         t_n_length (IN) - length (in bytes) of the 'type_name' parameter
    02368         user_version (IN) - user readable version of the type
    02369         u_v_length (IN) - length (in bytes) of the 'user_version' parameter
    02370    REQUIRES:
    02371         none
    02372    DESCRIPTION:
    02373         Insert an entry into the type version table and the type version
    02374         table's index.  The entry's type name and user readable version
    02375         fields are updated with the input values.  All other fields are
    02376         initialized to null.
    02377    RETURNS:
    02378         OCI_SUCCESS if the function completes successfully.
    02379         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    02380         OCI_ERROR if
    02381             1) any of the parameters is invalid.
    02382             2) an entry for 'type_name' has already been registered in the
    02383                type version table.
    02384  */
    02385
    02386 /*------------------------------ OCITypeVTSelect ----------------------------*/
    02387
    02388 /* OCITypeVTSelect - OCI type VERSion table SELECT entry */
    02389 /* ** OBSOLETE ** */
    02390 sword OCITypeVTSelect(    OCIEnv *env, OCIError *err,
    02391                           CONST oratext *schema_name, ub4 s_n_length,
    02392                           CONST oratext *type_name, ub4 t_n_length,
    02393                           oratext **user_version, ub4 *u_v_length,
    02394                         ub2 *version );
    02395 /*
    02396    NAME: OCITypeVTSelect - OCI type Version table SELect entry.
    02397    PARAMETERS:
    02398         env (IN/OUT) - OCI environment handle initialized in object mode
    02399         err (IN/OUT) - error handle. If there is an error, it is
    02400                 recorded in 'err' and this function returns OCI_ERROR.
    02401                 The error recorded in 'err' can be retrieved by calling
    02402                 OCIErrorGet().
    02403         schema_name (IN, optional) - name of schema associated with the
    02404                   type.  By default, the user's schema name is used.
    02405         s_n_length (IN) - length of the 'schema_name' parameter
    02406         type_name (IN) - type name to select
    02407         t_n_length (IN) - length (in bytes) of the 'type_name' parameter
    02408         user_version (OUT, optional) - pointer to user readable version of the
    02409                  type
    02410         u_v_length (OUT, optional) - length (in bytes) of the 'user_version'
    02411                  parameter
    02412         version (OUT, optional) - internal type version
    02413    REQUIRES:
    02414         All input parameters must not be NULL and must be valid.
    02415    DESCRIPTION:
    02416         Select an entry in the type version table by name.
    02417    RETURNS:
    02418         OCI_SUCCESS if the function completes successfully.
    02419         OCI_INVALID_HANDLE if 'env' or 'err' is null.
    02420         OCI_ERROR if
    02421             1) any of the parameters is invalid.
    02422             2) an entry with 'type_name' does not exist.
    02423  */
    02424
    02425 /* Compatibility function - following function prototype retained for
    02426    compatibility only */
    02427 sword ortgcty(    OCIEnv *env, OCIError *err, OCIType *coll_tdo,
    02428                   OCIType **collelem_tdo    );
    02429
    02430 /*---------------------------------------------------------------------------*/
    02431 /*               Transient Type Construction functions                       */
    02432 /*---------------------------------------------------------------------------*/
    02433
    02434 sword OCITypeBeginCreate(OCISvcCtx *svchp, OCIError *errhp, OCITypeCode tc,
    02435                          OCIDuration dur, OCIType **type);
    02436 /*
    02437    NAME: OCITypeBeginCreate - OCI Type Begin Creation of a transient type.
    02438    REMARKS
    02439        Begins the construction process for a transient type. The type will be
    02440        anonymous (no name). To create a persistent named type, the CREATE TYPE
    02441        statement should be used from SQL. Transient types have no identity.
    02442        They are pure values.
    02443    PARAMETERS:
    02444        svchp (IN)       - The OCI Service Context.
    02445        errhp (IN/OUT)   - The OCI error handle. If there is an error, it is
    02446                           recorded in errhp and this function returns
    02447                           OCI_ERROR. Diagnostic information can be obtained by
    02448                           calling OCIErrorGet().
    02449        tc               - The TypeCode for the type. The Typecode could
    02450                           correspond to a User Defined Type or a Built-in type.
    02451                           Currently, the permissible values for User Defined
    02452                           Types are OCI_TYPECODE_OBJECT for an Object Type
    02453                           (structured), OCI_TYPECODE_VARRAY for a VARRAY
    02454                           collection type or OCI_TYPECODE_TABLE for a nested
    02455                           table collection type. For Object types,
    02456                           OCITypeAddAttr() needs to be called to add each of
    02457                           the attribute types. For Collection types,
    02458                           OCITypeSetCollection() needs to be called.
    02459                           Subsequently, OCITypeEndCreate() needs to be called
    02460                           to finish the creation process.
    02461                           The permissible values for Built-in type codes are
    02462                           specified in the user manual. Additional information
    02463                           on built-ins if any (like precision, scale for
    02464                           numbers, character set info for VARCHAR2s etc.) must
    02465                           be set with a subsequent call to OCITypeSetBuiltin().
    02466                           Subsequently OCITypeEndCreate() needs to be called
    02467                           to finish the creation process.
    02468        dur              - The allocation duration for the Type. Could be a
    02469                           predefined or a user defined duration.
    02470        type(OUT)        - The OCIType (Type Descriptor) that is being
    02471                           constructed.
    02472   RETURNS:
    02473         OCI_SUCCESS if the function completes successfully.
    02474         OCI_ERROR on error.
    02475 */
    02476
    02477
    02478 sword OCITypeSetCollection(OCISvcCtx *svchp, OCIError *errhp, OCIType *type,
    02479                            OCIParam *collelem_info, ub4 coll_count);
    02480 /*
    02481    NAME: OCITypeSetCollection - OCI Type Set Collection information
    02482    REMARKS :
    02483        Set Collection type information. This call can be called only if the
    02484        OCIType has been constructed with a collection typecode.
    02485    PARAMETERS:
    02486        svchp (IN)      -  The OCI Service Context.
    02487        errhp (IN/OUT)  -  The OCI error handle. If there is an error, it is
    02488                           recorded in errhp and this function returns
    02489                           OCI_ERROR. Diagnostic information can be obtained by
    02490                           calling OCIErrorGet().
    02491        type(IN OUT)    -  The OCIType (Type Descriptor) that is being
    02492                           constructed.
    02493        collelem_info   -  collelem_info provides information on the collection
    02494                           element. It is obtained by allocating an OCIParam
    02495                           (parameter handle) and setting type information in
    02496                           the OCIParam using OCIAttrSet() calls.
    02497        coll_count      -  The count of elements in the collection. Pass 0 for
    02498                           a nested table (unbounded).
    02499   RETURNS:
    02500         OCI_SUCCESS if the function completes successfully.
    02501         OCI_ERROR on error.
    02502 */
    02503
    02504 sword OCITypeSetBuiltin(OCISvcCtx *svchp, OCIError *errhp, OCIType *type,
    02505                         OCIParam *builtin_info);
    02506 /*
    02507    NAME: OCITypeSetBuiltin - OCI Type Set Builtin information.
    02508    REMARKS:
    02509        Set Built-in type information. This call can be called only if the
    02510        OCIType has been constructed with a built-in typecode
    02511        (OCI_TYPECODE_NUMBER etc.).
    02512    PARAMETERS:
    02513        svchp (IN)       - The OCI Service Context.
    02514        errhp (IN/OUT)   - The OCI error handle. If there is an error, it is
    02515                           recorded in errhp and this function returns
    02516                           OCI_ERROR. Diagnostic information can be obtained by
    02517                           calling OCIErrorGet().
    02518        type(IN OUT)     - The OCIType (Type Descriptor) that is being
    02519                           constructed.
    02520        builtin_info     - builtin_info provides information on the built-in
    02521                           (like precision, scale, charater set etc.). It is
    02522                           obtained by allocating an OCIParam (parameter handle)
    02523                           and setting type information in the OCIParam using
    02524                            OCIAttrSet() calls.
    02525   RETURNS:
    02526         OCI_SUCCESS if the function completes successfully.
    02527         OCI_ERROR on error.
    02528 */
    02529
    02530 sword OCITypeAddAttr(OCISvcCtx *svchp, OCIError *errhp, OCIType *type,
    02531                      CONST oratext *a_name, ub4 a_length,
    02532                      OCIParam *attr_info);
    02533 /*
    02534    NAME: OCITypeAddAttr - OCI Type Add Attribute to an Object Type.
    02535    REMARKS:
    02536        Adds an attribute to an Object type (that was constructed earlier with
    02537        typecode OCI_TYPECODE_OBJECT).
    02538    PARAMETERS:
    02539        svchp (IN)       - The OCI Service Context
    02540        errhp (IN/OUT)   - The OCI error handle. If there is an error, it is
    02541                           recorded in errhp and this function returns
    02542                           OCI_ERROR. Diagnostic information can be obtained by
    02543                           calling OCIErrorGet().
    02544        type (IN/OUT)    - The Type description that is being constructed.
    02545        a_name(IN)       - Optional. gives the name of the attribute.
    02546        a_length         - Optional. gives length of attribute name.
    02547        attr_info        - Information on the attribute. It is obtained by
    02548                           allocating an OCIParam (parameter handle) and setting
    02549                           type information in the OCIParam using OCIAttrSet()
    02550                           calls.
    02551   RETURNS:
    02552         OCI_SUCCESS if the function completes successfully.
    02553         OCI_ERROR on error.
    02554 */
    02555
    02556 sword OCITypeEndCreate(OCISvcCtx *svchp, OCIError *errhp, OCIType *type);
    02557 /*
    02558    NAME: OCITypeEndCreate - OCI Type End Creation
    02559    REMARKS:
    02560        Finishes construction of a type description.Subsequently, only access
    02561        will be allowed.
    02562    PARAMETERS:
    02563        svchp (IN)       - The OCI Service Context
    02564        errhp (IN/OUT)   - The OCI error handle. If there is an error, it is
    02565                           recorded in errhp and this function returns
    02566                           OCI_ERROR. Diagnostic information can be obtained by
    02567                           calling OCIErrorGet().
    02568        type (IN/OUT)    - The Type description that is being constructed.
    02569    RETURNS:
    02570         OCI_SUCCESS if the function completes successfully.
    02571         OCI_ERROR on error.
    02572 */
    02573
    02574 /*=========================*/
    02575 /* PUBLIC MACROS AND FLAGS */
    02576 /*=========================*/
    02577
    02578 /*--------------------------------------------------------------------------*/
    02579 /*                          TYPE ELEMENT FLAGS                              */
    02580 /*--------------------------------------------------------------------------*/
    02581
    02582 #define OCI_TYPEELEM_REF        0x8000                   /* element is a REF */
    02583 #define OCI_TYPEPARAM_REQUIRED  0x0800              /* parameter is required */
    02584
    02585 /* macros to test flags */
    02586 #define OCI_TYPEELEM_IS_REF(elem_flag) \
    02587   (((elem_flag) & OCI_TYPEELEM_REF)!=0)
    02588 #define OCI_TYPEPARAM_IS_REQUIRED(param_flag) \
    02589   (((param_flag) & OCI_TYPEPARAM_REQUIRED)!=0)
    02590
    02591
    02592 #endif /* ORT_ORACLE */
    02593

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines