Annotation of win32/sql/oracle/include/oci/ort.h, revision 1.1
1.1 ! parser 1: /* @(#)ort.h 1.44 95/07/07 */
! 2:
! 3: /* Copyright (c) Oracle Corporation 1994, 1995, 1996, 1997, 1999. All Rights Reserved. */
! 4:
! 5: /*
! 6: NAME
! 7:
! 8: ORT - ORacle's external open Type interface to the open type manager (OTM)
! 9:
! 10: DESCRIPTION
! 11:
! 12: The open type manager interface includes dynamic type operations to
! 13: create, delete, update, and access types. See the "Functional
! 14: Specification for Oracle Object Call Interface (Objects Project),
! 15: Version 1.0" for a user level description of the OTM. For a more
! 16: detailed description, see the "Component Document for the Open Type
! 17: Manager, Version 1.0".
! 18:
! 19: NOTE: MOST Of the functions in this header file are being desupported.
! 20: Please use the OCIDescribeAny interface as described in oci.h
! 21: instead.
! 22: The OCIType, OCITypeElem, OCITypeMethod abstract types continue
! 23: to be supported. The only two functions that remain to be documented
! 24: are OCITypeArrayByName and OCITypeArrayByRef.
! 25: All obsolete types/functions are marked accordingly below.
! 26:
! 27: RELATED DOCUMENTS
! 28:
! 29: For the functional specification for the OTM, see:
! 30: [1] Kotsovolos, Susan, "Functional Specification for Oracle Object
! 31: Call Interface (Objects Project), Version 1.0", Oracle
! 32: Corporation, February 1995.
! 33: For the internal design of the OTM, see the following:
! 34: [2] Kotsovolos, Susan, "Component Document for the Open Type Manager",
! 35: Oracle Corporation, November 1994.
! 36: [3] Kotsovolos, Susan, "Design for The Open Type Manager, Oracle
! 37: Object Management Subsystem Version 1.0", Oracle Corporation,
! 38: March 1994.
! 39: [4] Kotsovolos, Susan and Tin A. Nguyen, "The Open Type Manager",
! 40: Oracle Corporation, March 1994.
! 41: [5] Kotsovolos, Susan and Tin A. Nguyen, "Schema Evolution",
! 42: Oracle Corporation, March 1994.
! 43: For a description of the types the OTM must support, see:
! 44: [6] Nguyen, Tin A., "The Open Type System", Oracle Corporation,
! 45: February 1994.
! 46:
! 47: INSPECTION STATUS
! 48:
! 49: Inspection date:
! 50: Inspection status:
! 51: Estimated increasing cost defects per page:
! 52: Rule sets:
! 53:
! 54: ACCEPTANCE REVIEW STATUS
! 55:
! 56: Review date:
! 57: Review status:
! 58: Reviewers:
! 59:
! 60:
! 61: **** ALL OBSOLETE FUNCTIONS/TYPES ARE MARKED ACCORDINGLY ***
! 62:
! 63: EXPORT FUNCTIONS
! 64:
! 65: None
! 66:
! 67: PUBLIC DATA STRUCTURES
! 68:
! 69: OCIType - type descriptor in the object cache
! 70: OCITypeElem - type element descriptor in the object cache
! 71: (used for attributes and paramters)
! 72: OCITypeCode - Open Type System type code.
! 73: OCITypeMethod - method descriptor in the object cache
! 74: OCITypeParamMode - parameter modes (ie. IN, IN-OUT etc)
! 75:
! 76: PUBLIC FUNCTIONS
! 77:
! 78: ITERATOR (for OCITypeAttrNext and OCITypeMethodNext)
! 79:
! 80: OCITypeIterNew - ** OBSOLETE ** Create new instance of an iteraton.
! 81: OCITypeIterSet - ** OBSOLETE ** Initialize iterator.
! 82: OCITypeIterFree - ** OBSOLETE ** Free instance of iterator.
! 83:
! 84: TYPE GET
! 85:
! 86: OCITypeByName - ** OBSOLETE ** Get a type by name.
! 87: OCITypeArrayByName - Get an array of types by their names.
! 88: OCITypeByRef - ** OBSOLETE ** Get a type by its CREF.
! 89: OCITypeArrayByRef - Get an array of types by their CREFs.
! 90:
! 91: TYPE ACCESSORS
! 92:
! 93: OCITypeName - ** OBSOLETE ** OCI Get a type's name.
! 94: OCITypeSchema - ** OBSOLETE ** OCI Get a type's schema name.
! 95: OCITypeTypeCode - ** OBSOLETE ** OCI Get a type's type code.
! 96: OCITypeVersion - ** OBSOLETE ** OCI Get a Type's user-readable Version.
! 97: OCITypeAttrs - ** OBSOLETE ** OCI Get a Type's Number of Attributes.
! 98: OCITypeMethods - ** OBSOLETE ** OCI Get a Type's Number of Methods.
! 99:
! 100: TYPE ELEMENT ACCESSORS (they represent attributes/parameters/results)
! 101:
! 102: OCITypeElemName - ** OBSOLETE ** Get a type element's (only for
! 103: attributes) name.
! 104: OCITypeElemType - ** OBSOLETE ** Get a type element's type
! 105: descriptor.
! 106: OCITypeElemTypeCode - ** OBSOLETE ** Get a type element's typecode.
! 107: OCITypeElemParameterizedType - ** OBSOLETE ** Get a type element's
! 108: parameterized type's type descriptor.
! 109: OCITypeElemNumPrec - ** OBSOLETE ** Get a number's precision.
! 110: OCITypeElemNumScale - ** OBSOLETE ** Get a decimal or oracle Number's
! 111: Scale
! 112: OCITypeElemCharSetID - ** OBSOLETE ** Get a fixed or variable length
! 113: string's character set ID.
! 114: OCITypeElemCharSetForm - ** OBSOLETE ** Get a fixed or variable length
! 115: string's character set form (how
! 116: character set information has
! 117: been specified).
! 118: OCITypeElemLength - ** OBSOLETE ** Get a raw, fixed or variable
! 119: length string's length.
! 120: OCITypeElemParamMode - ** OBSOLETE ** Get element's parameter's mode
! 121: (only valid for parameter).
! 122: OCITypeElemDefaultValue - ** OBSOLETE ** Get element's Default Value.
! 123:
! 124: ATTRIBUTE ACCESSORS
! 125:
! 126: OCITypeAttrByName - ** OBSOLETE ** Get an Attribute by Name.
! 127: OCITypeAttrNext - ** OBSOLETE ** Get an Attribute by Iteration.
! 128:
! 129: COLLECTION ACCESSORS
! 130:
! 131: OCITypeCollTypeCode - ** OBSOLETE ** Get a named collection's typecode.
! 132: OCITypeCollElem - ** OBSOLETE ** Get a named collection's element's
! 133: type element information.
! 134: OCITypeCollSize - ** OBSOLETE ** Get a named collection's size in
! 135: number of elements.
! 136:
! 137: METHOD ACCESSORS
! 138:
! 139: OCITypeMethodOverload - ** OBSOLETE ** Get number of overloaded methods
! 140: with the given method name.
! 141: (no direct equivalent for
! 142: OCIDescribe interface)
! 143: OCITypeMethodByName - ** OBSOLETE ** Get one or more methods by name.
! 144: OCITypeMethodNext - ** OBSOLETE ** Iterate to the next method to
! 145: retrieve.
! 146: OCITypeMethodName - ** OBSOLETE ** Get method's name.
! 147: OCITypeMethodEncap - ** OBSOLETE ** Get method's encapsulation level.
! 148: OCITypeMethodFlags - ** OBSOLETE ** et method's flags.
! 149: OCITypeMethodMap - ** OBSOLETE ** Get type's map function.
! 150: OCITypeMethodOrder - ** OBSOLETE ** Get type's order function.
! 151: OCITypeMethodParams - ** OBSOLETE ** Get a method's number of
! 152: parameters.
! 153:
! 154: RESULT ACCESSORS
! 155:
! 156: OCITypeResult - ** OBSOLETE ** OCI Get a method's Result.
! 157:
! 158: See also ATTRIBUTE/PARAMETER/RESULT TYPE ACCESSORS.
! 159:
! 160: PARAMETER ACCESSORS
! 161:
! 162: OCITypeParamByPos - ** OBSOLETE ** Get a Parameter in a method By
! 163: Position.
! 164: OCITypeParamByName - ** OBSOLETE ** Get a Parameter in a method By Name.
! 165: OCITypeParamPos - ** OBSOLETE ** Get a Parameter's PoSition in a
! 166: method.
! 167:
! 168: CALL GRAPHS:
! 169:
! 170: Only type accessors are supported for 8.0.
! 171: ** OBSOLETE ** please use OCIDescribe interface
! 172:
! 173: TYPE ACCESSOR EXAMPLE
! 174:
! 175: CREATE TYPE CAR
! 176: (
! 177: name vstring,
! 178: age number,
! 179: number car_age; /o Oracle number o/
! 180: weight car_weight; /o abstract type o/
! 181:
! 182: PUBLIC:
! 183:
! 184: /o methods o/
! 185: car(orlvs a_name, number an_age, WEIGHT a_weight);
! 186: ~car();
! 187: inline number get_age() const;
! 188:
! 189: /o relative ordering (map) functions o/
! 190: number car_map
! 191: );
! 192:
! 193: /o the following code accesses the type created above o/
! 194:
! 195: ub1 meth_flags;
! 196: ub4 i, j;
! 197: ub4 text_len, position;
! 198: ub4 count;
! 199: ub4 length;
! 200: OCITypeCode typecode;
! 201: OCIRef *attr_ref;
! 202: OCIRef *param_ref;
! 203: OCIType *tdo, new_tdo, final_tdo;
! 204: OCITypeElem *elem;
! 205: OCITypeIter *iterator;
! 206: text (*names)[];
! 207: ub4 lengths[];
! 208: ub4 *positions;
! 209: text *name;
! 210: text name_buffer[M_IDEN];
! 211:
! 212: /o initialize the references o/
! 213: DISCARD orlrini(env, err, (dvoid *)&attr_ref);
! 214: DISCARD orlrini(env, err, (dvoid *)¶m_ref);
! 215:
! 216: /o ----------------- GET INFORMATION ABOUT A TYPE ----------------- o/
! 217:
! 218: /o start a transaction o/
! 219:
! 220: /o Pin the type until the end of the transaction. Pinning the type is
! 221: o required before using any type accessors.
! 222: o/
! 223: if (OCITypeByName(env, err, svc, (text *)0, 0, "CAR", strlen("CAR"),
! 224: OCI_DURATION_TRANS, &car_ref, &car_tdo) != OCI_SUCCESS)
! 225: /o error o/ ;
! 226:
! 227: /o get the type's name o/
! 228: if (!memcmp(OCITypeName(env, err, car_tdo, &text_len), "person",
! 229: text_len))
! 230: /o do something o/ ;
! 231:
! 232: /o get the type's schema name o/
! 233: if (!memcmp(OCITypeSchema(env, err, car_tdo, &text_len), "john",
! 234: text_len))
! 235: /o do something o/ ;
! 236:
! 237: /o get the type code of the type o/
! 238: if (OCITypeTypeCode(env, err, car_tdo) == OCI_TYPECODE_ADT)
! 239: /o do something o/ ;
! 240:
! 241: /o get the type version o/
! 242: if (!memcmp(OCITypeVersion(env, err, car_tdo, &text_len), "1", text_len))
! 243: /o do something o/ ;
! 244:
! 245: /o ------- GET FLATTENED POSITION OF AN ATTRIBUTES IN A TYPE ------- o/
! 246:
! 247: names = malloc(sizeof(text *) * 2);
! 248: names[0] = malloc(strlen("car_weight"));
! 249: names[1] = malloc(strlen("ounces"));
! 250: memcpy(names[0], "car_weight", strlen("car_weight"));
! 251: memcpy(names[1], "ounces", strlen("ounces"));
! 252:
! 253: lengths = malloc(sizeof(ub4) * 2);
! 254: lengths[0] = strlen("car_weight");
! 255: lengths[1] = strlen("ounces");
! 256:
! 257: /o ---------- GET IMMEDIATE ATTRIBUTES IN A TYPE ---------- o/
! 258:
! 259: /o loop through all attributes in the type with iterator o/
! 260: if (OCITypeIterNew(env, err, car_tdo, &iterator) != OCI_SUCCESS)
! 261: /o do something o/
! 262:
! 263: while (OCITypeAttrNext(env, err, iterator, &ado) != OCI_NO_DATA)
! 264: {
! 265: /o get the attribute's name o/
! 266: if (!memcmp(OCITypeElemName(env, err, ado, &text_len),
! 267: "tiger", text_len))
! 268: /o do something o/ ;
! 269:
! 270: /o get the attribute's type descriptor o/
! 271: if (OCITypeElemType(env, err, ado, &tdo) != OCI_SUCCESS)
! 272: /o error o/ ;
! 273:
! 274: /o get the attribute's type code o/
! 275: typecode = OCITypeElemTypeCode(env, err, ado);
! 276:
! 277: switch (typecode)
! 278: {
! 279: /o scalar types o/
! 280: case OCI_TYPECODE_DATE: /o date o/
! 281: case OCI_TYPECODE_SIGNED8: /o byte o/
! 282: case OCI_TYPECODE_SIGNED16: /o short o/
! 283: case OCI_TYPECODE_UNSIGNED8: /o unsigned byte o/
! 284: case OCI_TYPECODE_UNSIGNED16: /o unsigned short o/
! 285: case OCI_TYPECODE_OCTET: /o octet o/
! 286: case OCI_TYPECODE_TABLE: /o nested table o/
! 287: case OCI_TYPECODE_CLOB: /o character lob o/
! 288: case OCI_TYPECODE_BLOB: /o binary lob o/
! 289: case OCI_TYPECODE_CFILE: /o character file object o/
! 290: case OCI_TYPECODE_BFILE: /o binary file object o/
! 291:
! 292: /o do something o/
! 293: break;
! 294:
! 295: /o number types o/
! 296: case OCI_TYPECODE_NUMBER: /o oracle number o/
! 297: case OCI_TYPECODE_DECIMAL: /o decimal o/
! 298: {
! 299: /o get the scale of the number o/
! 300: if (OCITypeElemNumScale(env, err, ado) == 3)
! 301: /o do something o/ ;
! 302: }
! 303: /o fall through to get the precision o/
! 304:
! 305: case OCI_TYPECODE_FLOAT: /o float o/
! 306: case OCI_TYPECODE_SIGNED32: /o long o/
! 307: case OCI_TYPECODE_UNSIGNED32: /o unsigned long o/
! 308: case OCI_TYPECODE_REAL: /o real o/
! 309: case OCI_TYPECODE_DOUBLE: /o double o/
! 310: {
! 311: /o get the precision of the number o/
! 312: if (OCITypeElemNumPrec(env, err, ado) == 2)
! 313: /o do something o/ ;
! 314: }
! 315: break;
! 316:
! 317: /o string types o/
! 318: case OCI_TYPECODE_CHAR: /o fixed length string o/
! 319: case OCI_TYPECODE_VARCHAR2: /o variable length string o/
! 320: case OCI_TYPECODE_RAW: /o raw o/
! 321: {
! 322: /o get the length of the fixed or variable length string o/
! 323: if (OCITypeElemLength(env, err, ado) < 100)
! 324: /o do something o/
! 325: }
! 326: break;
! 327:
! 328: /o parameterized types o/
! 329: case OCI_TYPECODE_REF: /o reference o/
! 330: case OCI_TYPECODE_PTR: /o pointer o/
! 331: {
! 332: /o get the type stored in the parameterized type o/
! 333: if (OCITypeElemParameterizedType(env, err, ado, &tdo)
! 334: != OCI_SUCCESS)
! 335: /o error o/ ;
! 336:
! 337: /o do something o/
! 338: if (OCI_TYPEELEM_IS_REF(OCITypeElemFlags(env, err, ado)))...
! 339: }
! 340: break;
! 341:
! 342: /o domain type o/
! 343: case OCI_TYPECODE_NAMEDCOLLECTION:
! 344: switch (OCITypeCollTypeCode(env, err, tdo))
! 345: {
! 346: case OCI_TYPECODE_VARRAY: /o variable array o/
! 347: ub4 num_elems;
! 348: OCIType *element_type;
! 349:
! 350: /o get the number of elements in the farray or the maximum number
! 351: o of elements in the varray.
! 352: o/
! 353: OCITypeCollSize(env, err, tdo, &num_elems);
! 354:
! 355: /o get the type of the array o/
! 356: OCITypeElemType(env, err, tdo, &element_type);
! 357: }
! 358: break;
! 359:
! 360: case OCI_TYPECODE_TABLE: /o multiset o/
! 361: {
! 362: OCIType *table_type;
! 363:
! 364: /o get the type of the multiset o/
! 365: OCITypeElemType(env, err, tdo, &table_type);
! 366:
! 367: /o do something o/
! 368: }
! 369: }
! 370:
! 371: /o abstract type o/
! 372: case OCI_TYPECODE_ADT: /o abstract data type o/
! 373: {
! 374: /o get the adt information o/
! 375: if (OCITypeElemType(env, err, ado, &tdo) != OCI_SUCCESS)
! 376: /o error o/ ;
! 377:
! 378: /o do something o/
! 379: }
! 380: break;
! 381:
! 382: default:
! 383: DISCARD printf("Error: invalid type code\n");
! 384:
! 385: } /o end of typecode switch o/
! 386:
! 387: } /o end of loop through all attributes in a type o/
! 388:
! 389:
! 390: /o ------------ GET THE IMMEDIATE METHODS OF A TYPE ------------ o/
! 391:
! 392: /o loop through all methods in the type by reusing iterator o/
! 393: if (OCITypeIterSet(env, err, car_tdo, iterator) != OCI_SUCCESS)
! 394: /o do something o/
! 395:
! 396: while (OCITypeMethodNext(env, err, iterator) != OCI_NO_DATA)
! 397: {
! 398: /o get the method's name o/
! 399: if (!memcmp(OCITypeMethodName(env, err, mdo, &text_len), "car",
! 400: text_len))
! 401: /o do something o/ ;
! 402:
! 403: /o get the method's encapsulation o/
! 404: if (OCITypeMethodEncap(env, err, mdo) == OCI_TYPEENCAP_PUBLIC)
! 405: /o do something o/ ;
! 406:
! 407: /o get the method's flags o/
! 408: meth_flags = OCITypeMethodFlags(env, err, mdo);
! 409: if (meth_flags & OCI_TYPEMETHOD_VIRTUAL)
! 410: /o do something o/ ;
! 411:
! 412:
! 413: /o ------------ GET THE PARAMETERS IN A METHOD ------------ o/
! 414:
! 415: /o loop through all parameters in the method o/
! 416: count = OCITypeMethodParams(env, err, mdo);
! 417: for (j = 1; j <= count; j++)
! 418: {
! 419: /o get the parameter information by position o/
! 420: if (OCITypeParamByPos(env, err, mdo, i, &elem) != OCI_SUCCESS)
! 421: /o error o/ ;
! 422:
! 423: /o get the parameter's name o/
! 424: if (!memcmp(OCITypeElemName(env, err, elem, &text_len), "an_age",
! 425: text_len))
! 426: /o do something o/ ;
! 427:
! 428: /o get the parameter's mode o/
! 429: if (OCITypeElemMode(env, err, elem) == OCI_PARAM_OUT)
! 430: /o do something o/ ;
! 431:
! 432: /o get the parameter's required flag o/
! 433: if (ortgprq(env, err, elem))
! 434: /o do something o/ ;
! 435: }
! 436: }
! 437:
! 438: /o get a method by name o/
! 439: if (OCITypeMethodByName(env, err, car_tdo, "car_constructor",
! 440: strlen("car_constructor"), NULLP(OCIRef), &mdo)
! 441: != OCI_SUCCESS)
! 442: /o error o/ ;
! 443:
! 444: /o get a parameter in a method by name o/
! 445: if (OCITypeParamByName(env, err, mdo, "an_age", strlen("an_age"), &elem)
! 446: != OCI_SUCCESS)
! 447: /o error o/ ;
! 448:
! 449: /o get a parameter's typecode o/
! 450: typecode = OCITypeElemTypeCode(env, err, elem);
! 451:
! 452: /o get a parameter's type object o/
! 453: if (OCITypeElemType(env, err, elem, &tdo)) != OCI_SUCCESS)
! 454: /o error o/ ;
! 455:
! 456: /o get a parameter's position in a method o/
! 457: if (ortgpps(env, err, mdo, "an_age", strlen("an_age"),
! 458: &position, NULLP(OCIRef), NULLP(OCITypeElem)) != OCI_SUCCESS)
! 459: /o error o/ ;
! 460:
! 461: /o ------------ GET THE METHOD's RESULT ------------ o/
! 462:
! 463: /o get a method by name o/
! 464: if (OCITypeMethodByName(env, err, car_tdo, "get_age", strlen("get_age"),
! 465: &mdo) != OCI_SUCCESS)
! 466: /o error o/ ;
! 467:
! 468: /o get the typecode of the method's result o/
! 469: typecode = OCITypeElemTypeCode(env, err, mdo);
! 470:
! 471:
! 472: /o ----------------- END ---------------- o/
! 473:
! 474: /o free the references implicitly allocated o/
! 475: DISCARD orlrfre(env, err, (dvoid *)&attr_ref);
! 476: DISCARD orlrfre(env, err, (dvoid *)¶m_ref);
! 477:
! 478: NOTES
! 479:
! 480: MODIFIED
! 481: whe 09/01/99 - 976457:check __cplusplus for C++ code
! 482: cxcheng 05/06/97 - make OCI_TYPE?? test macros return either 1 or 0
! 483: cxcheng 04/22/97 - add comment on desupporting OCIType functions
! 484: skrishna 03/18/97 - fix ifdef for supporting ansi and k&r proto-types
! 485: cxcheng 02/26/97 - fix lint problem with oro names
! 486: cxcheng 02/06/97 - take out short name support except with SLSHORTNAME
! 487: cxcheng 01/15/97 - change prototype of OCITypeElemParameterizedType()
! 488: cxcheng 01/03/97 - replace bit in OCI_TYPEPARAM_IS_REQUIRED with bitwis
! 489: cxcheng 12/31/96 - replace OCI_PARAM_IS_REQUIRED with OCI_TYPEPARAM_IS_
! 490: cxcheng 12/09/96 - add prototype for OCITypeElemExtTypeCode and OCIType
! 491: cxcheng 11/25/96 - add schema name parameter to OCITypeVTInsert()
! 492: cxcheng 11/20/96 - fix prototype for OCITypeByName()
! 493: cxcheng 11/11/96 - fix prototype for OCITypeByName()
! 494: cxcheng 11/05/96 - remove OCITypeElemExtTypeCode and OCITypeCollExtType
! 495: dchatter 10/28/96 - change ortgatyp to be OCITypeArrayByName
! 496: cxcheng 10/25/96 - fix problem with ortgatyp at end
! 497: cxcheng 10/22/96 - add OCITypeByRef and OCITypeArrayByRef
! 498: cxcheng 10/20/96 - remove ortgtyp() from #define section at end
! 499: cxcheng 10/18/96 - rename OCITypeGetArray to OCITypeArrayByName
! 500: cxcheng 10/17/96 - final change to prototype for OCI_TYPEPARAM_IS_REQUI
! 501: cxcheng 10/15/96 - rename OCIEncapLevel and OCIMethodFlag
! 502: cxcheng 10/14/96 - change prototype of OCITypeResult
! 503: mluong 10/11/96 - fix compile error
! 504: jwijaya 10/10/96 - fix bug on OCI_PARAM_IS_REQUIRED
! 505: cxcheng 10/09/96 - more lint and link fixes
! 506: cxcheng 10/08/96 - more lint fixes
! 507: cxcheng 10/07/96 - more changes
! 508: cxcheng 10/04/96 - replace short names with long names
! 509: cxcheng 10/01/96 - change to long names for readability
! 510: cxcheng 09/27/96 - rename ortgatyp() to ortgtya() for lint
! 511: cxcheng 09/20/96 - add ortgatyp() for array get type
! 512: cxcheng 09/18/96 - add array pin and iterator functions
! 513: cxcheng 08/09/96 - add version table calls
! 514: cxcheng 07/22/96 - add OCITypeElemType() to top
! 515: jwijaya 07/03/96 - add ANSI prototypes
! 516: cxcheng 06/28/96 - add OCITypeElemCharSetForm()
! 517: cxcheng 06/26/96 - fix comment on OCITypeParamByPos()/ortgpps()
! 518: cxcheng 06/18/96 - fix comments on OCITypeResult()
! 519: cxcheng 06/17/96 - improve comments
! 520: skrishna 06/03/96 - change OCITypeCollElem() prototype
! 521: vkrishna 05/29/96 - replace OROTCFAR with OROTCCAR
! 522: cxcheng 05/28/96 - fix comments, remove non-beta1 functions
! 523: cxcheng 05/02/96 - fix prototype bugs
! 524: cxcheng 04/29/96 - rename OCITypeElemm() to ortanct()
! 525: cxcheng 04/26/96 - add ortgrbp and ortftyi,
! 526: fix comments and examples
! 527: cxcheng 04/22/96 - big merge to main branch
! 528: cxcheng 04/17/96 - fix syntax
! 529: cxcheng 04/08/96 - change prototype to ortaty()
! 530: skrishna 04/08/96 - change ort*() to take OCIEnv* and OCIError* instead
! 531: of oroenv*
! 532: cxcheng 03/28/96 - add ortslob(), change ortsstr() prototype
! 533: cxcheng 03/13/96 - change alter type interface
! 534: cxcheng 03/11/96 - ORT interface changes
! 535: cxcheng 02/27/96 - correct comments
! 536: jboonleu 02/09/96 - rename oroopd to OCIDuration
! 537: cxcheng 01/19/96 - change ORTCTYVAL to ORTCTYEMB for embedded ADT
! 538: cxcheng 02/14/96 - add more comments
! 539: jboonleu 02/09/96 - rename oroopd to OCIDuration
! 540: cxcheng 02/07/96 - fix comments and examples
! 541: cxcheng 01/19/96 - new ORT interface without korfc's
! 542: cxcheng 01/08/96 - consolidate collection functions
! 543: cxcheng 12/14/95 - remove obsolete ortgcol() and ortrelease()
! 544: jweisz 12/12/95 - merge screwup: ortdth twice
! 545: cxcheng 12/05/95 - change multiset interface for new standard
! 546: skotsovo 12/01/95 - merge from /vobs/rdbms/public/ort.h@@/main/
! 547: st_rdbms_big_dev/st_rdbms_obj/
! 548: st_rdbms_jwijaya_variable_ref
! 549: cxcheng 11/13/95 - add ortaty()/orteaty()
! 550: cxcheng 11/13/95 - add new collection type accessors
! 551: skotsovo 10/30/95 - add 'oid' type b/c extent type uses it.
! 552: skotsovo 10/24/95 - update according to new variable length ref
! 553: cxcheng 10/05/95 - add null support, change prototypes to calls
! 554: cxcheng 10/03/95 - add OCITypeMethodOrder() to get ORDER method
! 555: cxcheng 09/28/95 - add OCITypeElemm() for collection types support
! 556: skotsovo 06/05/95 - add adt_type parameter to ortsab()
! 557: skotsovo 05/10/95 - ifdef'd out ortgafp()
! 558: skotsovo 03/07/95 - update interface to only include release 1
! 559: skotsovo 02/22/95 - add multiset accessors
! 560: skotsovo 02/09/95 - update according to new ots doc
! 561: skotsovo 01/31/95 - add rest of release 1 types
! 562: skotsovo 01/24/95 - categorize sint32, double, and real as number types
! 563: (with precision and scale) instead of scalar types.
! 564: skotsovo 01/12/95 - remove dependency from ortdty interface
! 565: skotsovo 01/03/95 - remove orotyp accessors
! 566: skotsovo 12/12/94 - update comments
! 567: skotsovo 12/05/94 - change OCITypeElemParameterizedTyper interface
! 568: skotsovo 10/26/94 - add type version table
! 569: skotsovo 10/17/94 - fix ortgafp() comments
! 570: skotsovo 10/14/94 - modify ortgafp() parameters
! 571: skotsovo 10/14/94 - add examples
! 572: skotsovo 10/13/94 - add a few new routines
! 573: jwijaya 10/07/94 - add namespace to pin by name
! 574: jwijaya 10/02/94 - connection handle -> connection number
! 575: skotsovo 09/13/94 - modify example to use updated oririni interface
! 576: skotsovo 08/25/94 - change scale to sb1 from sb2
! 577: skotsovo 07/28/94 - add ortbeg() and ortend()
! 578: skotsovo 07/14/94 - add decimal type & call graph
! 579: skotsovo 06/28/94 - subset by removing miscellaneous functions
! 580: skotsovo 06/28/94 - consistently put comments before typedefs
! 581: skotsovo 06/27/94 - modify according to new header file template, add
! 582: more examples, and change ortcty() to return a
! 583: reference to the type
! 584: skotsovo 06/24/94 - add functions to get type information from orotyp
! 585: skotsovo 06/20/94 - finish modifying according to header template
! 586: skotsovo 06/09/94 - modify according to header file template
! 587: skotsovo 06/08/94 - replace s.h with oratypes.h
! 588: skotsovo 05/24/94 - modify comments & update example
! 589: skotsovo 05/23/94 - modify fnt names for create, alter and drop type
! 590: skotsovo 05/18/94 - remove ortdme() -- delete a method
! 591: skotsovo 05/17/94 - add tdo parameter to all type modifiers
! 592: skotsovo 05/11/94 - return text* instead of including it in arglist
! 593: skotsovo 11/16/93 - creation
! 594:
! 595: */
! 596:
! 597: #ifndef ORATYPES
! 598: #include <oratypes.h>
! 599: #endif
! 600: #ifndef ORO_ORACLE
! 601: #include <oro.h>
! 602: #endif
! 603: #ifndef OCI_ORACLE
! 604: #include <oci.h>
! 605: #endif
! 606:
! 607: #ifndef ORT_ORACLE
! 608: #define ORT_ORACLE
! 609:
! 610: /*---------------------------------------------------------------------------*/
! 611: /* SHORT NAMES SUPPORT SECTION */
! 612: /*---------------------------------------------------------------------------*/
! 613:
! 614: #ifdef SLSHORTNAME
! 615:
! 616: /* the following are short names that are only supported on IBM mainframes
! 617: with the SLSHORTNAME defined.
! 618: With this all subsequent long names will actually be substituted with
! 619: the short names here */
! 620:
! 621: #define OCITypeArrayByName ortgatyp
! 622: #define OCITypeAttrByName ortgabn
! 623: #define OCITypeAttrNext ortgabi
! 624: #define OCITypeAttrs ortgtna
! 625: #define OCITypeByRef ortgtbrf
! 626: #define OCITypeCollElem ortgcel
! 627: #define OCITypeCollExtTypeCode ortgcsqt
! 628: #define OCITypeCollSize ortgcne
! 629: #define OCITypeCollTypeCode ortgdttc
! 630: #define OCITypeElem ortado
! 631: #define OCITypeElemCharSetForm ortgscform
! 632: #define OCITypeElemCharSetID ortgscid
! 633: #define OCITypeElemDefaultValue ortgpdv
! 634: #define OCITypeElemExtTypeCode ortgasqt
! 635: #define OCITypeElemLength ortgsl
! 636: #define OCITypeElemName ortganm
! 637: #define OCITypeElemNumPrec ortgnp
! 638: #define OCITypeElemNumScale ortgns
! 639: #define OCITypeElemParamMode ortgpmo
! 640: #define OCITypeElemParameterizedType ortgpa
! 641: #define OCITypeElemType ortgaty
! 642: #define OCITypeElemTypeCode ortgatc
! 643: #define OCITypeIter ortitr
! 644: #define OCITypeIterFree ortifre
! 645: #define OCITypeIterNew ortinew
! 646: #define OCITypeIterSet ortiset
! 647: #define OCITypeMethod ortmdo
! 648: #define OCITypeMethodByName ortgmbn
! 649: #define OCITypeMethodEncap ortgmen
! 650: #define OCITypeMethodFlags ortgmfl
! 651: #define OCITypeMethodMap ortgmmap
! 652: #define OCITypeMethodName ortgmnm
! 653: #define OCITypeMethodNext ortgmbi
! 654: #define OCITypeMethodOrder ortgmor
! 655: #define OCITypeMethodOverload ortgmno
! 656: #define OCITypeMethodParams ortgmnp
! 657: #define OCITypeMethods ortgtnm
! 658: #define OCITypeName ortgtme
! 659: #define OCITypeParamByName ortgpbn
! 660: #define OCITypeParamPos ortgpps
! 661: #define OCITypeSchema ortgtsch
! 662: #define OCITypeTypeCode ortgttc
! 663: #define OCITypeVTInit ortvini
! 664: #define OCITypeVTInsert ortvins
! 665: #define OCITypeVTSelect ortvsel
! 666: #define OCITypeVersion ortgtvn
! 667:
! 668: #endif /* SLSHORTNAME */
! 669:
! 670:
! 671: /*============================*/
! 672: /* PUBLIC TYPES AND CONSTANTS */
! 673: /*============================*/
! 674:
! 675: /*----------------------------- TYPE DESCRIPTION ----------------------------*/
! 676:
! 677: /*
! 678: * OCIType - OCI Type Description Object
! 679: *
! 680: * The contents of an 'OCIType' is private/opaque to clients. Clients just
! 681: * need to declare and pass 'OCIType' pointers in to the type manage
! 682: * functions.
! 683: * The pointer points to the type in the object cache. Thus, clients don't
! 684: * need to allocate space for this type and must NEVER free the pointer to the
! 685: * 'OCIType'.
! 686: */
! 687:
! 688: typedef struct OCIType OCIType;
! 689:
! 690: /*------------------------- TYPE ELEMENT DESCRIPTION ------------------------*/
! 691:
! 692:
! 693: /*
! 694: * OCITypeElem - OCI Type Element object
! 695: *
! 696: * The contents of an 'OCITypeElem' is private/opaque to clients. Clients just
! 697: * need to declare and pass 'OCITypeElem' pointers in to the type manager
! 698: * functions.
! 699: *
! 700: * 'OCITypeElem' objects contains type element information such as the numeric
! 701: * precision for example, for number objects, and the number of elements for
! 702: * arrays.
! 703: * They ARE used to describe type attributes, collection elements,
! 704: * method parameters, and method results. Hence they are pass in or returned
! 705: * by attribute, collection, and method parameter/result accessors.
! 706: */
! 707:
! 708: typedef struct OCITypeElem OCITypeElem;
! 709:
! 710:
! 711: /*--------------------------- METHOD DESCRIPTION ---------------------------*/
! 712:
! 713:
! 714: /*
! 715: * OCITypeMethod - OCI Method Description object
! 716: *
! 717: * The contents of an 'OCITypeMethod' is private/opaque to clients. Clients
! 718: * just need to declare and pass 'OCITypeMethod' pointers in to the type
! 719: * manager functions.
! 720: * The pointer points to the method in the object cache. Thus, clients don't
! 721: * need to allocate space for this type and must NEVER free the pointer to
! 722: * the 'OCITypeMethod'.
! 723: */
! 724:
! 725: typedef struct OCITypeMethod OCITypeMethod;
! 726:
! 727:
! 728: /*--------------------------- TYPE ACCESS ITERATOR --------------------------*/
! 729:
! 730: /*
! 731: * OCITypeIter- OCI Type Iterator
! 732: *
! 733: * The contents of an 'orti' is private/opaque to clients. Clients just
! 734: * need to declare and pass 'orti' pointers in to the type manager functions.
! 735: * The iterator is used to retreive MDO's and ADO's that belong to the TDO
! 736: * one at a time. It needs to be allocated by the 'OCITypeIterNew()' function
! 737: * call and deallocated with the 'OCITypeIterFree()' function call.
! 738: */
! 739:
! 740: typedef struct OCITypeIter OCITypeIter;
! 741:
! 742:
! 743: /*==================*/
! 744: /* PUBLIC FUNCTIONS */
! 745: /*==================*/
! 746:
! 747: /*--------------------------------------------------------------------------*/
! 748: /* ITERATOR */
! 749: /*--------------------------------------------------------------------------*/
! 750:
! 751: /*-----------------------_- OCITypeIterNew ---------------------------------*/
! 752:
! 753: /* ** OBSOLETE ** */
! 754: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 755: sword OCITypeIterNew(/*_ OCIEnv *env, OCIError *err, OCIType *tdo,
! 756: OCITypeIter **iterator _*/);
! 757: #else
! 758: sword OCITypeIterNew( OCIEnv *env, OCIError *err, OCIType *tdo,
! 759: OCITypeIter **iterator );
! 760: #endif
! 761:
! 762: /*
! 763: NAME: OCITypeIterNew - OCI Iterator NEW
! 764: PARAMETERS:
! 765: env (IN/OUT) - OCI environment handle initialized in object mode
! 766: err (IN/OUT) - error handle. If there is an error, it is
! 767: recorded in 'err' and this function returns OCI_ERROR.
! 768: The error recorded in 'err' can be retrieved by calling
! 769: OCIErrorGet().
! 770: tdo (IN) - pointer to the pinned type in the object cache to
! 771: initialize the iterator with
! 772: iterator (OUT) - pointer to the pointer to the new iterator created
! 773: DESCRIPTION:
! 774: Create a new instance of a method/attribute iterator and initalize
! 775: it's values.
! 776: RETURNS:
! 777: OCI_SUCCESS if the function completes successfully.
! 778: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 779: OCI_ERROR if
! 780: 1) any of the required parameters is null.
! 781: 2) error while allocating space for the iterator.
! 782: */
! 783:
! 784: /*------------------------ OCITypeIterSet ---------------------------------*/
! 785:
! 786: /* ** OBSOLETE ** */
! 787: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 788: sword OCITypeIterSet(/*_ OCIEnv *env, OCIError *err, OCIType *tdo,
! 789: OCITypeIter *iterator _*/);
! 790: #else
! 791: sword OCITypeIterSet( OCIEnv *env, OCIError *err, OCIType *tdo,
! 792: OCITypeIter *iterator );
! 793: #endif
! 794:
! 795: /*
! 796: NAME: OCITypeIterSet - OCI Iterator SET
! 797: PARAMETERS:
! 798: env (IN/OUT) - OCI environment handle initialized in object mode
! 799: err (IN/OUT) - error handle. If there is an error, it is
! 800: recorded in 'err' and this function returns OCI_ERROR.
! 801: The error recorded in 'err' can be retrieved by calling
! 802: OCIErrorGet().
! 803: tdo (IN) - pointer to the pinned type in the object cache to
! 804: initialize the iterator with
! 805: iterator (IN/OUT) - pointer to the iterator to set
! 806: DESCRIPTION:
! 807: Initializes the iterator. This is used to reset the state of the
! 808: iterator.
! 809: RETURNS:
! 810: OCI_SUCCESS if the function completes successfully.
! 811: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 812: OCI_ERROR if
! 813: 1) any of the required parameters is null.
! 814: */
! 815:
! 816: /*------------------------ OCITypeIterFree ---------------------------------*/
! 817:
! 818: /* ** OBSOLETE ** */
! 819: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 820: sword OCITypeIterFree(/*_ OCIEnv *env, OCIError *err, OCITypeIter
! 821: *iterator _*/);
! 822: #else
! 823: sword OCITypeIterFree( OCIEnv *env, OCIError *err, OCITypeIter
! 824: *iterator );
! 825: #endif
! 826:
! 827: /*
! 828: NAME: OCITypeIterFree - OCI Iterator FREe
! 829: PARAMETERS:
! 830: env (IN/OUT) - OCI environment handle initialized in object mode
! 831: err (IN/OUT) - error handle. If there is an error, it is
! 832: recorded in 'err' and this function returns OCI_ERROR.
! 833: The error recorded in 'err' can be retrieved by calling
! 834: OCIErrorGet().
! 835: iterator (IN/OUT) - pointer to the iterator to free
! 836: DESCRIPTION:
! 837: Free space allocated for the iterator.
! 838: RETURNS:
! 839: OCI_SUCCESS if the function completes successfully.
! 840: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 841: OCI_ERROR if
! 842: 1) any of the required parameters is null.
! 843: 2) error while freeing the iterator, probably bad iterator pointer.
! 844: */
! 845:
! 846:
! 847: /*--------------------------------------------------------------------------*/
! 848: /* TYPE GET */
! 849: /*--------------------------------------------------------------------------*/
! 850:
! 851: /* ** OBSOLETE ** */
! 852: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 853: sword OCITypeByName(/*_ OCIEnv *env, OCIError *err,
! 854: CONST OCISvcCtx *svc, CONST text *schema_name,
! 855: ub4 s_length, CONST text *type_name,
! 856: ub4 t_length, CONST text *version_name,
! 857: ub4 v_length, OCIDuration pin_duration,
! 858: OCITypeGetOpt get_option, OCIType **tdo _*/);
! 859: #else /* ANSI C */
! 860: sword OCITypeByName( OCIEnv *env, OCIError *err, CONST OCISvcCtx *svc,
! 861: CONST text *schema_name, ub4 s_length,
! 862: CONST text *type_name, ub4 t_length,
! 863: CONST text *version_name, ub4 v_length,
! 864: OCIDuration pin_duration, OCITypeGetOpt get_option,
! 865: OCIType **tdo );
! 866: #endif
! 867: /*
! 868: NAME: OCITypeByName - OCI Get the most current version of an existing TYPe
! 869: by name.
! 870: PARAMETERS:
! 871: env (IN/OUT) - OCI environment handle initialized in object mode
! 872: err (IN/OUT) - error handle. If there is an error, it is
! 873: recorded in 'err' and this function returns OCI_ERROR.
! 874: The error recorded in 'err' can be retrieved by calling
! 875: OCIErrorGet().
! 876: svc (IN) - OCI service handle
! 877: schema_name (IN, optional) - name of schema associated with the
! 878: type. By default, the user's schema name is used.
! 879: s_length (IN) - length of the 'schema_name' parameter
! 880: type_name (IN) - name of the type to get
! 881: t_length (IN) - length of the 'type_name' parameter
! 882: version_name (IN, optional) - user readable version of the type.
! 883: Pass (text *)0 for the most current version.
! 884: v_length (IN) - length of version_name in bytes. Should be 0 if
! 885: the most current version is to be retrieved.
! 886: pin_duration (IN) - pin duration (e.g. until the end of current
! 887: transaction). See 'oro.h' for a description of
! 888: each option.
! 889: get_option (IN) - options for loading the types. It can be one of two
! 890: values:
! 891: OCI_TYPEGET_HEADER for only the header to be loaded, or
! 892: OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
! 893: loaded.
! 894: tdo (OUT) - pointer to the pinned type in the object cache
! 895: DESCRIPTION:
! 896: Get a pointer to a version of the existing type associated
! 897: with schema/type name.
! 898: RETURNS:
! 899: OCI_SUCCESS if the function completes successfully.
! 900: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 901: OCI_ERROR if
! 902: 1) any of the required parameters is null.
! 903: 2) the adt type associated with schema/type name does not exist.
! 904: NOTE:
! 905: Schema and type names are CASE-SENSITIVE. If they have been created
! 906: via SQL, you need to use uppercase names.
! 907: */
! 908:
! 909: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 910: sword
! 911: OCITypeArrayByName(/*_ OCIEnv *env, OCIError *err, CONST OCISvcCtx *svc,
! 912: ub4 array_len, CONST text *schema_name[],
! 913: ub4 s_length[], CONST text *type_name[],
! 914: ub4 t_length[], CONST text *version_name[],
! 915: ub4 v_length[], OCIDuration pin_duration,
! 916: OCITypeGetOpt get_option, OCIType *tdo[] _*/);
! 917: #else /* ANSI C */
! 918: sword OCITypeArrayByName( OCIEnv *env, OCIError *err, CONST OCISvcCtx *svc,
! 919: ub4 array_len,
! 920: CONST text *schema_name[], ub4 s_length[],
! 921: CONST text *type_name[], ub4 t_length[],
! 922: CONST text *version_name[], ub4 v_length[],
! 923: OCIDuration pin_duration,
! 924: OCITypeGetOpt get_option, OCIType *tdo[] );
! 925: #endif
! 926:
! 927: /*
! 928: NAME: OCITypeArrayByName - OCI Get array of TYPes by name.
! 929: PARAMETERS:
! 930: env (IN/OUT) - OCI environment handle initialized in object mode
! 931: err (IN/OUT) - error handle. If there is an error, it is
! 932: recorded in 'err' and this function returns OCI_ERROR.
! 933: The error recorded in 'err' can be retrieved by calling
! 934: OCIErrorGet().
! 935: svc (IN) - OCI service handle
! 936: array_len (IN) - number of schema_name/type_name/version_name entries to
! 937: be retrieved.
! 938: schema_name (IN, optional) - array of schema names associated with the
! 939: types to be retrieved. The array must have array_len
! 940: elements if specified.
! 941: If 0 is supplied, the default schema is assumed, otherwise
! 942: it MUST have array_len number of elements.
! 943: 0 can be supplied for one or more of the entries to indicate
! 944: that the default schema is desired for those entries.
! 945: s_length (IN) - array of schema_name lengths with each entry
! 946: corresponding to the length of the corresponding schema_name
! 947: entry in the schema_name array in bytes.
! 948: The array must either have array_len number of elements or
! 949: it MUST be 0 if schema_name is not specified.
! 950: type_name (IN) - array of the names of the types to retrieve. This
! 951: MUST have array_len number of elements.
! 952: t_length (IN) - array of the lengths of type names in the type_name
! 953: array in bytes.
! 954: version_name (IN) - array of the version names of the types to retrieve
! 955: corresponding. This can be 0 to indicate retrieval of the
! 956: most current versions, or it MUST have array_len number of
! 957: elements.
! 958: If 0 is supplied, the most current version is assumed,
! 959: otherwise it MUST have array_len number of elements.
! 960: 0 can be supplied for one or more of the entries to indicate
! 961: that the current version is desired for those entries.
! 962: v_length (IN) - array of the lengths of version names in the
! 963: version_name array in bytes.
! 964: pin_duration (IN) - pin duration (e.g. until the end of current
! 965: transaction) for the types retreieve. See 'oro.h' for a
! 966: description of each option.
! 967: get_option (IN) - options for loading the types. It can be one of two
! 968: values:
! 969: OCI_TYPEGET_HEADER for only the header to be loaded, or
! 970: OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
! 971: loaded.
! 972: tdo (OUT) - output array for the pointers to each pinned type in the
! 973: object cache. It must have space for array_len pointers.
! 974: Use OCIObjectGetObjectRef() to obtain the CREF to each
! 975: pinned type descriptor.
! 976: DESCRIPTION:
! 977: Get pointers to the existing types associated with the schema/type name
! 978: array. This is similar to OCITypeByName() except that all the TDO's are
! 979: retreived via a single network roundtrip.
! 980: RETURNS:
! 981: OCI_SUCCESS if the function completes successfully.
! 982: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 983: OCI_ERROR if
! 984: 1) any of the required parameters is null.
! 985: 2) one or more adt types associated with a schema/type name entry
! 986: does not exist.
! 987: */
! 988:
! 989: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 990: sword OCITypeByRef(/*_ OCIEnv *env, OCIError *err,
! 991: CONST OCIRef *type_ref, OCIDuration pin_duration,
! 992: OCITypeGetOpt get_option, OCIType **tdo _*/);
! 993: #else /* ANSI C */
! 994: sword OCITypeByRef( OCIEnv *env, OCIError *err,
! 995: CONST OCIRef *type_ref, OCIDuration pin_duration,
! 996: OCITypeGetOpt get_option, OCIType **tdo );
! 997: #endif
! 998:
! 999: /*
! 1000: NAME: OCITypeArrayByRef - OCI Get array of TYPes by REF.
! 1001: PARAMETERS:
! 1002: env (IN/OUT) - OCI environment handle initialized in object mode
! 1003: err (IN/OUT) - error handle. If there is an error, it is
! 1004: recorded in 'err' and this function returns OCI_ERROR.
! 1005: The error recorded in 'err' can be retrieved by calling
! 1006: OCIErrorGet().
! 1007: type_ref (IN) - OCIRef * pointing to the particular version of
! 1008: the type descriptor object to obtain.
! 1009: The array must have array_len elements if specified.
! 1010: pin_duration (IN) - pin duration (e.g. until the end of current
! 1011: transaction) for the type to retreieve. See 'oro.h' for a
! 1012: description of each option.
! 1013: get_option (IN) - options for loading the type. It can be one of two
! 1014: values:
! 1015: OCI_TYPEGET_HEADER for only the header to be loaded, or
! 1016: OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
! 1017: loaded.
! 1018: tdo (OUT) - pointer to the pinned type in the object cache
! 1019: DESCRIPTION:
! 1020: Get pointers to the
! 1021: with the schema/type name array. This is similar to OCITypeByName()
! 1022: except that all the TDO's are retreived via a single network roundtrip.
! 1023: RETURNS:
! 1024: OCI_SUCCESS if the function completes successfully.
! 1025: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 1026: OCI_ERROR if
! 1027: 1) any of the required parameters is null.
! 1028: 2) one or more adt types associated with a schema/type name entry
! 1029: does not exist.
! 1030: */
! 1031:
! 1032: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1033: sword OCITypeArrayByRef(/*_ OCIEnv *env, OCIError *err,
! 1034: ub4 array_len, CONST OCIRef *type_ref[],
! 1035: OCIDuration pin_duration,
! 1036: OCITypeGetOpt get_option, OCIType *tdo[] _*/);
! 1037: #else /* ANSI C */
! 1038: sword OCITypeArrayByRef( OCIEnv *env, OCIError *err,
! 1039: ub4 array_len, CONST OCIRef *type_ref[],
! 1040: OCIDuration pin_duration,
! 1041: OCITypeGetOpt get_option, OCIType *tdo[] );
! 1042: #endif
! 1043:
! 1044: /*
! 1045: NAME: OCITypeArrayByRef - OCI Get array of TYPes by REF.
! 1046: PARAMETERS:
! 1047: env (IN/OUT) - OCI environment handle initialized in object mode
! 1048: err (IN/OUT) - error handle. If there is an error, it is
! 1049: recorded in 'err' and this function returns OCI_ERROR.
! 1050: The error recorded in 'err' can be retrieved by calling
! 1051: OCIErrorGet().
! 1052: array_len (IN) - number of schema_name/type_name/version_name entries to
! 1053: be retrieved.
! 1054: type_ref (IN) - array of OCIRef * pointing to the particular version of
! 1055: the type descriptor object to obtain.
! 1056: The array must have array_len elements if specified.
! 1057: pin_duration (IN) - pin duration (e.g. until the end of current
! 1058: transaction) for the types retreieve. See 'oro.h' for a
! 1059: description of each option.
! 1060: get_option (IN) - options for loading the types. It can be one of two
! 1061: values:
! 1062: OCI_TYPEGET_HEADER for only the header to be loaded, or
! 1063: OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
! 1064: loaded.
! 1065: tdo (OUT) - output array for the pointers to each pinned type in the
! 1066: object cache. It must have space for array_len pointers.
! 1067: Use OCIObjectGetObjectRef() to obtain the CREF to each
! 1068: pinned type descriptor.
! 1069: DESCRIPTION:
! 1070: Get pointers to the
! 1071: with the schema/type name array. This is similar to OCITypeByName()
! 1072: except that all the TDO's are retreived via a single network roundtrip.
! 1073: RETURNS:
! 1074: OCI_SUCCESS if the function completes successfully.
! 1075: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 1076: OCI_ERROR if
! 1077: 1) any of the required parameters is null.
! 1078: 2) one or more adt types associated with a schema/type name entry
! 1079: does not exist.
! 1080: */
! 1081:
! 1082:
! 1083: /*--------------------------------------------------------------------------*/
! 1084: /* TYPE ACCESSORS */
! 1085: /*--------------------------------------------------------------------------*/
! 1086:
! 1087: /*---------------------------- OCITypeName ---------------------------------*/
! 1088:
! 1089: /* ** OBSOLETE ** */
! 1090: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1091: text* OCITypeName(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1092: ub4 *n_length _*/);
! 1093: #else /* ANSI C */
! 1094: text* OCITypeName( OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1095: ub4 *n_length );
! 1096: #endif
! 1097: /*
! 1098: NAME: OCITypeName - ORT Get a Type's naME.
! 1099: PARAMETERS:
! 1100: env (IN/OUT) - OCI environment handle initialized in object mode
! 1101: err (IN/OUT) - error handle. If there is an error, it is
! 1102: recorded in 'err' and this function returns OCI_ERROR.
! 1103: The error recorded in 'err' can be retrieved by calling
! 1104: OCIErrorGet().
! 1105: tdo (IN) - pointer to to the type descriptor in the object cache
! 1106: n_length (OUT) - length (in bytes) of the returned type name. The
! 1107: caller must allocate space for the ub4 before calling this
! 1108: routine.
! 1109: REQUIRES:
! 1110: 1) All type accessors require that the type be pinned before calling
! 1111: any accessor.
! 1112: 2) All input parameters must not be NULL and must be valid.
! 1113: 3) 'n_length' must point to an allocated ub4.
! 1114: DESCRIPTION:
! 1115: Get the name of the type.
! 1116: RETURNS:
! 1117: the name of the type
! 1118: NOTES:
! 1119: The type descriptor, 'tdo', must be unpinned when the accessed
! 1120: information is no longer needed.
! 1121: */
! 1122:
! 1123: /*------------------------ OCITypeSchema ---------------------------------*/
! 1124:
! 1125: /* ** OBSOLETE ** */
! 1126: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1127: text* OCITypeSchema(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1128: ub4 *n_length _*/);
! 1129: #else /* ANSI C */
! 1130: text* OCITypeSchema( OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1131: ub4 *n_length );
! 1132: #endif
! 1133: /*
! 1134: NAME: OCITypeSchema - ORT Get a Type's SCHema name.
! 1135: PARAMETERS:
! 1136: env (IN/OUT) - OCI environment handle initialized in object mode
! 1137: err (IN/OUT) - error handle. If there is an error, it is
! 1138: recorded in 'err' and this function returns OCI_ERROR.
! 1139: The error recorded in 'err' can be retrieved by calling
! 1140: OCIErrorGet().
! 1141: tdo (IN) - pointer to to the type descriptor in the object cache
! 1142: n_length (OUT) - length (in bytes) of the returned schema name. The
! 1143: caller must allocate space for the ub4 before calling this
! 1144: routine.
! 1145: REQUIRES:
! 1146: 1) All type accessors require that the type be pinned before calling
! 1147: any accessor.
! 1148: 2) All input parameters must not be NULL and must be valid.
! 1149: 3) 'n_length' must point to an allocated ub4.
! 1150: DESCRIPTION:
! 1151: Get the schema name of the type.
! 1152: RETURNS:
! 1153: the schema name of the type
! 1154: NOTES:
! 1155: The type descriptor, 'tdo', must be unpinned when the accessed
! 1156: information is no longer needed.
! 1157: */
! 1158:
! 1159: /*------------------------ OCITypeTypeCode ---------------------------------*/
! 1160:
! 1161: /* ** OBSOLETE ** */
! 1162: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1163: OCITypeCode OCITypeTypeCode(/*_ OCIEnv *env, OCIError *err,
! 1164: CONST OCIType *tdo _*/);
! 1165: #else /* ANSI C */
! 1166: OCITypeCode OCITypeTypeCode( OCIEnv *env, OCIError *err,
! 1167: CONST OCIType *tdo );
! 1168: #endif
! 1169: /*
! 1170: NAME: OCITypeTypeCode - OCI Get a Type's Type Code.
! 1171: PARAMETERS:
! 1172: env (IN/OUT) - OCI environment handle initialized in object mode
! 1173: err (IN/OUT) - error handle. If there is an error, it is
! 1174: recorded in 'err' and this function returns OCI_ERROR.
! 1175: The error recorded in 'err' can be retrieved by calling
! 1176: OCIErrorGet().
! 1177: tdo (IN) - pointer to to the type descriptor in the object cache
! 1178: REQUIRES:
! 1179: 1) All type accessors require that the type be pinned before calling
! 1180: any accessor.
! 1181: 2) All input parameters must not be NULL and must be valid.
! 1182: DESCRIPTION:
! 1183: Get the type code of the type.
! 1184: RETURNS:
! 1185: The type code of the type.
! 1186: NOTES:
! 1187: The type descriptor, 'tdo', must be unpinned when the accessed
! 1188: information is no longer needed.
! 1189: */
! 1190:
! 1191: /*----------------------- OCITypeCollTypeCode -------------------------------*/
! 1192:
! 1193: /* ** OBSOLETE ** */
! 1194: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1195: OCITypeCode OCITypeCollTypeCode(/*_ OCIEnv *env, OCIError *err,
! 1196: CONST OCIType *tdo _*/);
! 1197: #else /* ANSI C */
! 1198: OCITypeCode OCITypeCollTypeCode( OCIEnv *env, OCIError *err,
! 1199: CONST OCIType *tdo );
! 1200: #endif
! 1201: /*
! 1202: NAME: OCITypeCollTypeCode - OCI Get a Domain Type's Type Code.
! 1203: PARAMETERS:
! 1204: env (IN/OUT) - OCI environment handle initialized in object mode
! 1205: err (IN/OUT) - error handle. If there is an error, it is
! 1206: recorded in 'err' and this function returns OCI_ERROR.
! 1207: The error recorded in 'err' can be retrieved by calling
! 1208: OCIErrorGet().
! 1209: tdo (IN) - pointer to to the type descriptor in the object cache
! 1210: REQUIRES:
! 1211: 1) All type accessors require that the type be pinned before calling
! 1212: any accessor.
! 1213: 2) All input parameters must not be NULL and must be valid.
! 1214: 3) 'tdo' MUST point to a named collection type.
! 1215: DESCRIPTION:
! 1216: Get the type code of the named collection type. For V8.0, named
! 1217: collection types can only be variable length arrays and nested tables.
! 1218: RETURNS:
! 1219: OCI_TYPECODE_VARRAY for variable length array, and
! 1220: OCI_TYPECODE_TABLE for nested tables.
! 1221: NOTES:
! 1222: The type descriptor, 'tdo', should be unpinned when the accessed
! 1223: information is no longer needed.
! 1224: */
! 1225:
! 1226: /*------------------------- OCITypeVersion ---------------------------------*/
! 1227:
! 1228: /* ** OBSOLETE ** */
! 1229: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1230: text* OCITypeVersion(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1231: ub4 *v_length _*/);
! 1232: #else /* ANSI C */
! 1233: text* OCITypeVersion( OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1234: ub4 *v_length );
! 1235: #endif
! 1236: /*
! 1237: NAME: OCITypeVersion - OCI Get a Type's user-readable VersioN.
! 1238: PARAMETERS:
! 1239: env (IN/OUT) - OCI environment handle initialized in object mode
! 1240: err (IN/OUT) - error handle. If there is an error, it is
! 1241: recorded in 'err' and this function returns OCI_ERROR.
! 1242: The error recorded in 'err' can be retrieved by calling
! 1243: OCIErrorGet().
! 1244: tdo (IN) - pointer to to the type descriptor in the object cache
! 1245: v_length (OUT) - length (in bytes) of the returned user-readable
! 1246: version. The caller must allocate space for the ub4 before
! 1247: calling this routine.
! 1248: REQUIRES:
! 1249: 1) All type accessors require that the type be pinned before calling
! 1250: any accessor.
! 1251: 2) All input parameters must not be NULL and must be valid.
! 1252: 3) 'v_length' must point to an allocated ub4.
! 1253: DESCRIPTION:
! 1254: Get the user-readable version of the type.
! 1255: RETURNS:
! 1256: The user-readable version of the type
! 1257: NOTES:
! 1258: The type descriptor, 'tdo', must be unpinned when the accessed
! 1259: information is no longer needed.
! 1260: */
! 1261:
! 1262: /*--------------------------- OCITypeAttrs ---------------------------------*/
! 1263:
! 1264: /* ** OBSOLETE ** */
! 1265: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1266: ub4 OCITypeAttrs(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo _*/);
! 1267: #else /* ANSI C */
! 1268: ub4 OCITypeAttrs( OCIEnv *env, OCIError *err, CONST OCIType *tdo );
! 1269: #endif
! 1270: /*
! 1271: NAME: OCITypeAttrs - OCI Get a Type's Number of Attributes.
! 1272: PARAMETERS:
! 1273: env (IN/OUT) - OCI environment handle initialized in object mode
! 1274: err (IN/OUT) - error handle. If there is an error, it is
! 1275: recorded in 'err' and this function returns OCI_ERROR.
! 1276: The error recorded in 'err' can be retrieved by calling
! 1277: OCIErrorGet().
! 1278: tdo (IN) - pointer to to the type descriptor in the object cache
! 1279: REQUIRES:
! 1280: 1) All type accessors require that the type be pinned before calling
! 1281: any accessor.
! 1282: 2) All input parameters must not be NULL and must be valid.
! 1283: DESCRIPTION:
! 1284: Get the number of attributes in the type.
! 1285: RETURNS:
! 1286: The number of attributes in the type. 0 for ALL non-ADTs.
! 1287: NOTES:
! 1288: The type descriptor, 'tdo', must be unpinned when the accessed
! 1289: information is no longer needed.
! 1290: */
! 1291:
! 1292: /*------------------------- OCITypeMethods ---------------------------------*/
! 1293:
! 1294: /* ** OBSOLETE ** */
! 1295: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1296: ub4 OCITypeMethods(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo _*/);
! 1297: #else /* ANSI C */
! 1298: ub4 OCITypeMethods( OCIEnv *env, OCIError *err, CONST OCIType *tdo );
! 1299: #endif
! 1300: /*
! 1301: NAME: OCITypeMethods - OCI Get a Type's Number of Methods.
! 1302: PARAMETERS:
! 1303: env (IN/OUT) - OCI environment handle initialized in object mode
! 1304: err (IN/OUT) - error handle. If there is an error, it is
! 1305: recorded in 'err' and this function returns OCI_ERROR.
! 1306: The error recorded in 'err' can be retrieved by calling
! 1307: OCIErrorGet().
! 1308: tdo (IN) - pointer to to the type descriptor in the object cache
! 1309: REQUIRES:
! 1310: 1) All type accessors require that the type be pinned before calling
! 1311: any accessor.
! 1312: 2) All input parameters must not be NULL and must be valid.
! 1313: DESCRIPTION:
! 1314: Get the number of methods in a type.
! 1315: RETURNS:
! 1316: The number of methods in the type
! 1317: NOTES:
! 1318: The type descriptor, 'tdo', must be unpinned when the accessed
! 1319: information is no longer needed.
! 1320: */
! 1321:
! 1322:
! 1323: /*--------------------------------------------------------------------------*/
! 1324: /* TYPE ELEMENT INFORMATION ACCESSORS */
! 1325: /*--------------------------------------------------------------------------*/
! 1326:
! 1327: /*------------------------ OCITypeElemName ---------------------------------*/
! 1328:
! 1329: /* ** OBSOLETE ** */
! 1330: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1331: text* OCITypeElemName(/*_ OCIEnv *env, OCIError *err, CONST OCITypeElem *elem,
! 1332: ub4 *n_length _*/);
! 1333: #else /* ANSI C */
! 1334: text* OCITypeElemName( OCIEnv *env, OCIError *err, CONST OCITypeElem *elem,
! 1335: ub4 *n_length );
! 1336: #endif
! 1337: /*
! 1338: NAME: OCITypeElemName - OCI Get an Attribute's NaMe.
! 1339: PARAMETERS:
! 1340: env (IN/OUT) - OCI environment handle initialized in object mode
! 1341: err (IN/OUT) - error handle. If there is an error, it is
! 1342: recorded in 'err' and this function returns OCI_ERROR.
! 1343: The error recorded in 'err' can be retrieved by calling
! 1344: OCIErrorGet().
! 1345: elem (IN) - pointer to the type element descriptor in the object cache
! 1346: n_length (OUT) - length (in bytes) of the returned attribute name.
! 1347: The caller must allocate space for the ub4 before calling this
! 1348: routine.
! 1349: REQUIRES:
! 1350: 1) All type accessors require that the type be pinned before calling
! 1351: any accessor.
! 1352: 2) All input parameters must not be NULL and must be valid.
! 1353: 3) 'n_length' must point to an allocated ub4.
! 1354: DESCRIPTION:
! 1355: Get the name of the attribute.
! 1356: RETURNS:
! 1357: the name of the attribute and the length in n_length
! 1358: NOTES:
! 1359: The type must be unpinned when the accessed information is no
! 1360: longer needed.
! 1361: */
! 1362:
! 1363: /*------------------------ OCITypeElemTypeCode ------------------------------*/
! 1364:
! 1365: /* ** OBSOLETE ** */
! 1366: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1367: OCITypeCode OCITypeElemTypeCode(/*_ OCIEnv *env, OCIError *err,
! 1368: CONST OCITypeElem *elem _*/);
! 1369: #else /* ANSI C */
! 1370: OCITypeCode OCITypeElemTypeCode( OCIEnv *env, OCIError *err,
! 1371: CONST OCITypeElem *elem );
! 1372: #endif
! 1373: /*
! 1374: NAME: OCITypeElemTypeCode - OCI Get an Attribute's TypeCode.
! 1375: PARAMETERS:
! 1376: env (IN/OUT) - OCI environment handle initialized in object mode
! 1377: err (IN/OUT) - error handle. If there is an error, it is
! 1378: recorded in 'err' and this function returns OCI_ERROR.
! 1379: The error recorded in 'err' can be retrieved by calling
! 1380: OCIErrorGet().
! 1381: elem (IN) - pointer to the type element descriptor in the object cache
! 1382: REQUIRES:
! 1383: 1) All type accessors require that the type be pinned before calling
! 1384: any accessor.
! 1385: 2) All input parameters must not be NULL and must be valid.
! 1386: DESCRIPTION:
! 1387: Get the typecode of an attribute's type.
! 1388: RETURNS:
! 1389: the typecode of the attribute's type. If this is a scalar type, the
! 1390: typecode sufficiently describes the scalar type and no further calls
! 1391: need to be made. Valid scalar types include: OCI_TYPECODE_SIGNED8,
! 1392: OCI_TYPECODE_UNSIGNED8, OCI_TYPECODE_SIGNED16, OCI_TYPECODE_UNSIGNED16,
! 1393: OCI_TYPECODE_SIGNED32, OCI_TYPECODE_UNSIGNED32, OCI_TYPECODE_REAL,
! 1394: OCI_TYPECODE_DOUBLE, OCI_TYPECODE_DATE,
! 1395: OCI_TYPECODE_MLSLABEL, OROTCOID, OCI_TYPECODE_OCTET, or OROTCLOB.
! 1396: This function converts the CREF (stored in the attribute) into a
! 1397: typecode.
! 1398: NOTES:
! 1399: The type must be unpinned when the accessed information is no
! 1400: longer needed.
! 1401: */
! 1402:
! 1403: /*------------------------ OCITypeElemType ---------------------------------*/
! 1404:
! 1405: /* ** OBSOLETE ** */
! 1406: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1407: sword OCITypeElemType(/*_ OCIEnv *env, OCIError *err, CONST OCITypeElem *elem,
! 1408: OCIType **elem_tdo _*/);
! 1409: #else /* ANSI C */
! 1410: sword OCITypeElemType( OCIEnv *env, OCIError *err, CONST OCITypeElem *elem,
! 1411: OCIType **elem_tdo );
! 1412: #endif
! 1413: /*
! 1414: PARAMETERS
! 1415: env (IN/OUT) - OCI environment handle initialized in object mode
! 1416: err (IN/OUT) - error handle. If there is an error, it is
! 1417: recorded in 'err' and this function returns OCI_ERROR.
! 1418: The error recorded in 'err' can be retrieved by calling
! 1419: OCIErrorGet().
! 1420: elem (IN) - pointer to the type element descriptor in the object cache
! 1421: elem_tdo (OUT) - If the function completes successfully, 'elem_tdo'
! 1422: points to the type descriptor (in the object cache) of the type of
! 1423: the element.
! 1424:
! 1425: REQUIRES
! 1426: 1) All type accessors require that the type be pinned before calling
! 1427: any accessor. This can be done by calling 'OCITypeByName()'.
! 1428: 2) if 'elem' is not null, it must point to a valid type element descriptor
! 1429: in the object cache.
! 1430:
! 1431: DESCRIPTION
! 1432: Get the type tdo of the type of this element.
! 1433: RETURNS
! 1434: OCI_SUCCESS if the function completes successfully.
! 1435: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 1436: OCI_ERROR if
! 1437: 1) any of the parameters is null.
! 1438:
! 1439: NOTES
! 1440: The type must be unpinned when the accessed information is no
! 1441: longer needed. This can be done by calling 'OCIObjectUnpin()'.
! 1442: */
! 1443:
! 1444: /*------------------------- OCITypeElemFlags -------------------------------*/
! 1445:
! 1446: /* ** OBSOLETE ** */
! 1447: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1448: ub4 OCITypeElemFlags(/*_ OCIEnv *env, OCIError *err,
! 1449: CONST OCITypeElem *elem _*/);
! 1450: #else /* ANSI C */
! 1451: ub4 OCITypeElemFlags( OCIEnv *env, OCIError *err,
! 1452: CONST OCITypeElem *elem );
! 1453: #endif
! 1454: /*
! 1455: NAME: OCITypeElemFlags - OCI Get a Elem's FLags
! 1456: (inline, constant, virtual, constructor,
! 1457: destructor).
! 1458: PARAMETERS:
! 1459: env (IN/OUT) - OCI environment handle initialized in object mode
! 1460: err (IN/OUT) - error handle. If there is an error, it is
! 1461: recorded in 'err' and this function returns OCI_ERROR.
! 1462: The error recorded in 'err' can be retrieved by calling
! 1463: OCIErrorGet().
! 1464: elem (IN) - pointer to the type element descriptor in the object cache
! 1465: REQUIRES:
! 1466: 1) All type accessors require that the type be pinned before calling
! 1467: any accessor.
! 1468: 2) All input parameters must not be NULL and must be valid.
! 1469: DESCRIPTION:
! 1470: Get the flags of a type element (attribute, parameter).
! 1471: RETURNS:
! 1472: The flags of the type element.
! 1473: NOTES:
! 1474: The flag bits are not externally documented. Use only the macros
! 1475: in the last section (ie. OCI_TYPEPARAM_IS_REQUIRED, and
! 1476: OCI_TYPEELEM_IS_REF) to test for them only. The type must be unpinned
! 1477: when the accessed information is no longer needed.
! 1478: */
! 1479:
! 1480: /*------------------------ OCITypeElemNumPrec ------------------------------*/
! 1481:
! 1482: /* ** OBSOLETE ** */
! 1483: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1484: ub1 OCITypeElemNumPrec(/*_ OCIEnv *env, OCIError *err,
! 1485: CONST OCITypeElem *elem _*/);
! 1486: #else /* ANSI C */
! 1487: ub1 OCITypeElemNumPrec( OCIEnv *env, OCIError *err,
! 1488: CONST OCITypeElem *elem );
! 1489: #endif
! 1490: /*
! 1491: NAME: OCITypeElemNumPrec - Get a Number's Precision. This includes float,
! 1492: decimal, real, double, and oracle number.
! 1493: PARAMETERS:
! 1494: env (IN/OUT) - OCI environment handle initialized in object mode
! 1495: err (IN/OUT) - error handle. If there is an error, it is
! 1496: recorded in 'err' and this function returns OCI_ERROR.
! 1497: The error recorded in 'err' can be retrieved by calling
! 1498: OCIErrorGet().
! 1499: elem (IN) - pointer to the type element descriptor in the object cache
! 1500: REQUIRES:
! 1501: All input parameters must not be NULL and must be valid.
! 1502: DESCRIPTION:
! 1503: Get the precision of a float, decimal, long, unsigned long, real,
! 1504: double, or Oracle number type.
! 1505: RETURNS:
! 1506: the precision of the float, decimal, long, unsigned long, real, double,
! 1507: or Oracle number
! 1508: */
! 1509:
! 1510: /*------------------------- OCITypeElemNumScale -----------------------------*/
! 1511:
! 1512: /* ** OBSOLETE ** */
! 1513: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1514: sb1 OCITypeElemNumScale(/*_ OCIEnv *env, OCIError *err,
! 1515: CONST OCITypeElem *elem _*/);
! 1516: #else /* ANSI C */
! 1517: sb1 OCITypeElemNumScale( OCIEnv *env, OCIError *err,
! 1518: CONST OCITypeElem *elem );
! 1519: #endif
! 1520: /*
! 1521: NAME: OCITypeElemNumScale - Get a decimal or oracle Number's Scale
! 1522: PARAMETERS:
! 1523: env (IN/OUT) - OCI environment handle initialized in object mode
! 1524: err (IN/OUT) - error handle. If there is an error, it is
! 1525: recorded in 'err' and this function returns OCI_ERROR.
! 1526: The error recorded in 'err' can be retrieved by calling
! 1527: OCIErrorGet().
! 1528: elem (IN) - pointer to the type element descriptor in the object cache
! 1529: REQUIRES:
! 1530: All input parameters must not be NULL and must be valid.
! 1531: DESCRIPTION:
! 1532: Get the scale of a decimal, or Oracle number type.
! 1533: RETURNS:
! 1534: the scale of the decimal, or Oracle number
! 1535: */
! 1536:
! 1537: /*------------------------ OCITypeElemLength -------------------------------*/
! 1538:
! 1539: /* ** OBSOLETE ** */
! 1540: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1541: ub4 OCITypeElemLength(/*_ OCIEnv *env, OCIError *err,
! 1542: CONST OCITypeElem *elem _*/);
! 1543: #else /* ANSI C */
! 1544: ub4 OCITypeElemLength( OCIEnv *env, OCIError *err,
! 1545: CONST OCITypeElem *elem );
! 1546: #endif
! 1547: /*
! 1548: NAME: OCITypeElemLength - Get a raw, fixed or variable length String's
! 1549: length in bytes.
! 1550: PARAMETERS:
! 1551: env (IN/OUT) - OCI environment handle initialized in object mode
! 1552: err (IN/OUT) - error handle. If there is an error, it is
! 1553: recorded in 'err' and this function returns OCI_ERROR.
! 1554: The error recorded in 'err' can be retrieved by calling
! 1555: OCIErrorGet().
! 1556: elem (IN) - pointer to the type element descriptor in the object cache
! 1557: REQUIRES:
! 1558: All input parameters must not be NULL and must be valid.
! 1559: DESCRIPTION:
! 1560: Get the length of a raw, fixed or variable length string type.
! 1561: RETURNS:
! 1562: length of the raw, fixed or variable length string
! 1563: */
! 1564:
! 1565: /*----------------------- OCITypeElemCharSetID -----------------------------*/
! 1566:
! 1567: /* ** OBSOLETE ** */
! 1568: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1569: ub2 OCITypeElemCharSetID(/*_ OCIEnv *env, OCIError *err,
! 1570: CONST OCITypeElem *elem _*/);
! 1571: #else /* ANSI C */
! 1572: ub2 OCITypeElemCharSetID( OCIEnv *env, OCIError *err,
! 1573: CONST OCITypeElem *elem );
! 1574: #endif
! 1575: /*
! 1576: NAME: OCITypeElemCharSetID - Get a fixed or variable length String's
! 1577: character set ID
! 1578: PARAMETERS:
! 1579: env (IN/OUT) - OCI environment handle initialized in object mode
! 1580: err (IN/OUT) - error handle. If there is an error, it is
! 1581: recorded in 'err' and this function returns OCI_ERROR.
! 1582: The error recorded in 'err' can be retrieved by calling
! 1583: OCIErrorGet().
! 1584: elem (IN) - pointer to the type element descriptor in the object cache
! 1585: REQUIRES:
! 1586: All input parameters must not be NULL and must be valid.
! 1587: DESCRIPTION:
! 1588: Get the character set ID of a fixed or variable length string type.
! 1589: RETURNS:
! 1590: character set ID of the fixed or variable length string
! 1591: */
! 1592:
! 1593: /*---------------------- OCITypeElemCharSetForm ----------------------------*/
! 1594:
! 1595: /* ** OBSOLETE ** */
! 1596: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1597: ub2 OCITypeElemCharSetForm(/*_ OCIEnv *env, OCIError *err,
! 1598: CONST OCITypeElem *elem _*/);
! 1599: #else /* ANSI C */
! 1600: ub2 OCITypeElemCharSetForm( OCIEnv *env, OCIError *err,
! 1601: CONST OCITypeElem *elem );
! 1602: #endif
! 1603: /*
! 1604: NAME: OCITypeElemCharSetForm - Get a fixed or variable length String's
! 1605: character set specification form.
! 1606: PARAMETERS:
! 1607: env (IN/OUT) - OCI environment handle initialized in object mode
! 1608: err (IN/OUT) - error handle. If there is an error, it is
! 1609: recorded in 'err' and this function returns OCI_ERROR.
! 1610: The error recorded in 'err' can be retrieved by calling
! 1611: OCIErrorGet().
! 1612: elem (IN) - pointer to the attribute information in the object cache
! 1613: REQUIRES:
! 1614: All input parameters must not be NULL and must be valid.
! 1615: DESCRIPTION:
! 1616: Get the character form of a fixed or variable length string type.
! 1617: The character form is an enumerated value that can be one of the
! 1618: 4 values below:
! 1619: SQLCS_IMPLICIT for CHAR, VARCHAR2, CLOB w/o a specified set
! 1620: SQLCS_NCHAR for NCHAR, NCHAR VARYING, NCLOB
! 1621: SQLCS_EXPLICIT for CHAR, etc, with "CHARACTER SET ..." syntax
! 1622: SQLCS_FLEXIBLE for PL/SQL "flexible" parameters
! 1623: RETURNS:
! 1624: character form of the fixed or variable string
! 1625: */
! 1626:
! 1627: /*--------------------- OCITypeElemParameterizedType ------------------------*/
! 1628:
! 1629: /* ** OBSOLETE ** */
! 1630: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1631: sword OCITypeElemParameterizedType(/*_ OCIEnv *env, OCIError *err,
! 1632: CONST OCITypeElem *elem,
! 1633: OCIType **type_stored _*/);
! 1634: #else /* ANSI C */
! 1635: sword OCITypeElemParameterizedType( OCIEnv *env, OCIError *err,
! 1636: CONST OCITypeElem *elem,
! 1637: OCIType **type_stored );
! 1638: #endif
! 1639: /*
! 1640: NAME: OCITypeElemParameterizedType
! 1641: PARAMETERS:
! 1642: env (IN/OUT) - OCI environment handle initialized in object mode
! 1643: err (IN/OUT) - error handle. If there is an error, it is
! 1644: recorded in 'err' and this function returns OCI_ERROR.
! 1645: The error recorded in 'err' can be retrieved by calling
! 1646: OCIErrorGet().
! 1647: elem (IN) - pointer to the type element descriptor in the object cache
! 1648: type_stored (OUT) - If the function completes successfully,
! 1649: and the parameterized type is complex, 'type_stored' is NULL.
! 1650: Otherwise, 'type_stored' points to the type descriptor (in the
! 1651: object cache) of the type that is stored in the parameterized
! 1652: type. The caller must allocate space for the OCIType*
! 1653: before calling this routine and must not write into the space.
! 1654: REQUIRES:
! 1655: All input parameters must be valid.
! 1656: DESCRIPTION:
! 1657: Get a descriptor to the parameter type of a parameterized type.
! 1658: Parameterized types are types of the form:
! 1659: REF T
! 1660: VARRAY (n) OF T
! 1661: etc, where T is the parameter in the parameterized type.
! 1662: Additionally is_ref is set if the parameter is a PTR or REF.
! 1663: For example, it is set for REF T or VARRAY(n) OF REF T.
! 1664: RETURNS:
! 1665: OCI_SUCCESS if the function completes successfully.
! 1666: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 1667: OCI_ERROR if
! 1668: 1) any of the parameters is null.
! 1669: 2) 'type_stored' is not NULL but points to NULL data.
! 1670: NOTES:
! 1671: Complex parameterized types will be in a future release (once
! 1672: typedefs are supported. When setting the parameterized type
! 1673: information, the user must typedef the contents if it's a
! 1674: complex parameterized type. Ex. for varray<varray<car>>, use
! 1675: 'typedef varray<car> varcar' and then use varray<varcar>.
! 1676: */
! 1677:
! 1678: /*----------------------- OCITypeElemExtTypeCode ----------------------------*/
! 1679:
! 1680: /* ** OBSOLETE ** */
! 1681: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1682: OCITypeCode OCITypeElemExtTypeCode(/*_ OCIEnv *env, OCIError *err,
! 1683: CONST OCITypeElem *elem _*/);
! 1684: #else /* ANSI C */
! 1685: OCITypeCode OCITypeElemExtTypeCode( OCIEnv *env, OCIError *err,
! 1686: CONST OCITypeElem *elem );
! 1687: #endif
! 1688: /*
! 1689: NAME: OCITypeElemExtTypeCode - OCI Get an element's SQLT constant.
! 1690: PARAMETERS:
! 1691: env (IN/OUT) - OCI environment handle initialized in object mode
! 1692: err (IN/OUT) - error handle. If there is an error, it is
! 1693: recorded in 'err' and this function returns OCI_ERROR.
! 1694: The error recorded in 'err' can be retrieved by calling
! 1695: OCIErrorGet().
! 1696: elem (IN) - pointer to the type element descriptor in the object cache
! 1697: REQUIRES:
! 1698: 1) All type accessors require that the type be pinned before calling
! 1699: any accessor.
! 1700: 2) All input parameters must not be NULL and must be valid.
! 1701: DESCRIPTION:
! 1702: Get the internal Oracle typecode associated with an attribute's type.
! 1703: This is the actual typecode for the attribute when it gets mapped
! 1704: to a column in the Oracle database.
! 1705: RETURNS:
! 1706: The Oracle typecode associated with the attribute's type.
! 1707: NOTES:
! 1708: The type must be unpinned when the accessed information is no
! 1709: longer needed.
! 1710: */
! 1711:
! 1712: /*--------------------------------------------------------------------------*/
! 1713: /* ATTRIBUTE ACCESSORS */
! 1714: /*--------------------------------------------------------------------------*/
! 1715:
! 1716: /*------------------------ OCITypeAttrByName -------------------------------*/
! 1717:
! 1718: /* ** OBSOLETE ** */
! 1719: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1720: sword OCITypeAttrByName(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1721: CONST text *name, ub4 n_length,
! 1722: OCITypeElem **elem _*/);
! 1723: #else /* ANSI C */
! 1724: sword OCITypeAttrByName( OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1725: CONST text *name, ub4 n_length,
! 1726: OCITypeElem **elem );
! 1727: #endif
! 1728: /*
! 1729: NAME: OCITypeAttrByName - OCI Get an Attribute By Name.
! 1730: PARAMETERS:
! 1731: env (IN/OUT) - OCI environment handle initialized in object mode
! 1732: err (IN/OUT) - error handle. If there is an error, it is
! 1733: recorded in 'err' and this function returns OCI_ERROR.
! 1734: The error recorded in 'err' can be retrieved by calling
! 1735: OCIErrorGet().
! 1736: tdo (IN) - pointer to to the type descriptor in the object cache
! 1737: name (IN) - the attribute's name
! 1738: n_length (IN) - length (in bytes) of the 'name' parameter
! 1739: elem (OUT) - If this function completes successfully, 'elem' points to
! 1740: the selected type element descriptor pertaining to the
! 1741: attributein the object cache.
! 1742: REQUIRES:
! 1743: 1) All type accessors require that the type be pinned before calling
! 1744: any accessor.
! 1745: 2) if 'tdo' is not null, it must point to a valid type descriptor
! 1746: in the object cache.
! 1747: DESCRIPTION:
! 1748: Get an attribute given its name.
! 1749: RETURNS:
! 1750: OCI_SUCCESS if the function completes successfully.
! 1751: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 1752: OCI_ERROR if
! 1753: 1) any of the required parameters is null.
! 1754: 2) the type does not contain an attribute with the input 'name'.
! 1755: 3) 'name' is NULL.
! 1756: NOTES:
! 1757: The type descriptor, 'tdo', must be unpinned when the accessed
! 1758: information is no longer needed.
! 1759: Schema and type names are CASE-SENSITIVE. If they have been created
! 1760: via SQL, you need to use uppercase names.
! 1761: */
! 1762:
! 1763: /*------------------------ OCITypeAttrNext ---------------------------------*/
! 1764:
! 1765: /* ** OBSOLETE ** */
! 1766: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1767: sword OCITypeAttrNext(/*_ OCIEnv *env, OCIError *err, OCITypeIter *iterator,
! 1768: OCITypeElem **elem _*/);
! 1769: #else /* ANSI C */
! 1770: sword OCITypeAttrNext( OCIEnv *env, OCIError *err, OCITypeIter *iterator,
! 1771: OCITypeElem **elem );
! 1772: #endif
! 1773:
! 1774: /*
! 1775: NAME: OCITypeAttrNext - OCI Get an Attribute By Iteration.
! 1776: PARAMETERS:
! 1777: env (IN/OUT) - OCI environment handle initialized in object mode
! 1778: err (IN/OUT) - error handle. If there is an error, it is
! 1779: recorded in 'err' and this function returns OCI_ERROR.
! 1780: The error recorded in 'err' can be retrieved by calling
! 1781: OCIErrorGet().
! 1782: iterator (IN/OUT) - iterator for retrieving the next attribute;
! 1783: see OCITypeIterNew() to initialize iterator.
! 1784: elem (OUT) - If this function completes successfully, 'elem' points to
! 1785: the selected type element descriptor pertaining to the
! 1786: attributein the object cache.
! 1787: REQUIRES:
! 1788: 1) All type accessors require that the type be pinned before calling
! 1789: any accessor.
! 1790: 2) if 'tdo' is not null, it must point to a valid type descriptor
! 1791: in the object cache.
! 1792: DESCRIPTION:
! 1793: Iterate to the next attribute to retrieve.
! 1794: RETURNS:
! 1795: OCI_SUCCESS if the function completes successfully.
! 1796: OCI_NO_DATA if there are no more attributes to iterate on; use
! 1797: OCITypeIterSet() to reset the iterator if necessary.
! 1798: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 1799: OCI_ERROR if
! 1800: 1) any of the required parameters is null.
! 1801: NOTES:
! 1802: The type must be unpinned when the accessed information is no
! 1803: longer needed.
! 1804: */
! 1805:
! 1806: /*--------------------------------------------------------------------------*/
! 1807: /* COLLECTION ACCESSORS */
! 1808: /*--------------------------------------------------------------------------*/
! 1809:
! 1810: /*------------------------ OCITypeCollElem ---------------------------------*/
! 1811:
! 1812: /* ** OBSOLETE ** */
! 1813: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1814: sword OCITypeCollElem(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1815: OCITypeElem **element _*/);
! 1816: #else /* ANSI C */
! 1817: sword OCITypeCollElem( OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1818: OCITypeElem **element );
! 1819: #endif
! 1820: /*
! 1821: NAME: OCITypeCollElem
! 1822: PARAMETERS:
! 1823: env (IN/OUT) - OCI environment handle initialized in object mode
! 1824: err (IN/OUT) - error handle. If there is an error, it is
! 1825: recorded in 'err' and this function returns OCI_ERROR.
! 1826: The error recorded in 'err' can be retrieved by calling
! 1827: OCIErrorGet().
! 1828: tdo (IN) - pointer to the type descriptor in the object cache
! 1829: element (IN/OUT) - If the function completes successfully, this
! 1830: points to the descriptor for the collection's element.
! 1831: It is stored in the same format as an ADT attribute's
! 1832: descriptor.
! 1833: If *element is NULL, OCITypeCollElem() implicitly allocates a
! 1834: new instance of OCITypeElem in the object cache. This instance
! 1835: will be
! 1836: automatically freed at the end of the session, and does not have
! 1837: to be freed explicitly.
! 1838: If *element is not NULL, OCITypeCollElem() assumes that it
! 1839: points to a valid OCITypeElem descriptor and will copy the
! 1840: results into it.
! 1841: REQUIRES:
! 1842: All input parameters must be valid.
! 1843: DESCRIPTION:
! 1844: Get a pointer to the descriptor (OCITypeElem) of the element of an
! 1845: array or the rowtype of a nested table.
! 1846: RETURNS:
! 1847: OCI_SUCCESS if the function completes successfully.
! 1848: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 1849: OCI_ERROR if
! 1850: 1) any of the parameters is null.
! 1851: 2) the type TDO does not point to a valid collection's type.
! 1852: NOTES:
! 1853: Complex parameterized types will be in a future release (once
! 1854: typedefs are supported. When setting the parameterized type
! 1855: information, the user must typedef the contents if it's a
! 1856: complex parameterized type. Ex. for varray<varray<car>>, use
! 1857: 'typedef varray<car> varcar' and then use varray<varcar>.
! 1858: */
! 1859:
! 1860: /*------------------------ OCITypeCollSize ---------------------------------*/
! 1861:
! 1862: /* ** OBSOLETE ** */
! 1863: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1864: sword OCITypeCollSize(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1865: ub4 *num_elems _*/);
! 1866: #else /* ANSI C */
! 1867: sword OCITypeCollSize( OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1868: ub4 *num_elems );
! 1869: #endif
! 1870: /*
! 1871: NAME: OCITypeCollSize - OCI Get a Collection's Number of Elements.
! 1872: PARAMETERS:
! 1873: env (IN/OUT) - OCI environment handle initialized in object mode
! 1874: err (IN/OUT) - error handle. If there is an error, it is
! 1875: recorded in 'err' and this function returns OCI_ERROR.
! 1876: The error recorded in 'err' can be retrieved by calling
! 1877: OCIErrorGet().
! 1878: tdo (IN) - pointer to the type descriptor in the object cache
! 1879: num_elems (OUT) - number of elements in collection
! 1880: REQUIRES:
! 1881: All input parameters must be valid. tdo points to an array type
! 1882: defined as a domain.
! 1883: DESCRIPTION:
! 1884: Get the number of elements stored in a fixed array or the maximum
! 1885: number of elements in a variable array.
! 1886: RETURNS:
! 1887: OCI_SUCCESS if the function completes successfully.
! 1888: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 1889: OCI_ERROR if
! 1890: 1) any of the parameters is null.
! 1891: 2) 'tdo' does not point to a domain with a collection type.
! 1892: NOTES:
! 1893: Complex parameterized types will be in a future release (once
! 1894: typedefs are supported. When setting the parameterized type
! 1895: information, the user must typedef the contents if it's a
! 1896: complex parameterized type. Ex. for varray<varray<car>>, use
! 1897: 'typedef varray<car> varcar' and then use varray<varcar>.
! 1898: */
! 1899:
! 1900: /*------------------------ OCITypeCollExtTypeCode ---------------------------*/
! 1901:
! 1902: /* ** OBSOLETE ** */
! 1903: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1904: sword OCITypeCollExtTypeCode(/*_ OCIEnv *env, OCIError *err,
! 1905: CONST OCIType *tdo, OCITypeCode *sqt_code _*/);
! 1906: #else /* ANSI C */
! 1907: sword OCITypeCollExtTypeCode( OCIEnv *env, OCIError *err,
! 1908: CONST OCIType *tdo, OCITypeCode *sqt_code );
! 1909: #endif
! 1910: /*
! 1911: NAME: ortcsqt - OCI Get a Collection element's DTY constant.
! 1912: PARAMETERS:
! 1913: env (IN/OUT) - OCI environment handle initialized in object mode
! 1914: err (IN/OUT) - error handle. If there is an error, it is
! 1915: recorded in 'err' and this function returns OCI_ERROR.
! 1916: The error recorded in 'err' can be retrieved by calling
! 1917: OCIErrorGet().
! 1918: tdo (IN) - pointer to the type descriptor in the object cache
! 1919: sqt_code (OUT) - SQLT code of type element.
! 1920: REQUIRES:
! 1921: 1) All type accessors require that the type be pinned before calling
! 1922: any accessor.
! 1923: 2) All input parameters must not be NULL and must be valid.
! 1924: DESCRIPTION:
! 1925: Get the SQLT constant associated with an domain's element type.
! 1926: The SQLT codes are defined in <sqldef.h> and are needed for OCI/OOCI
! 1927: use.
! 1928: RETURNS:
! 1929: OCI_SUCCESS if the function completes successfully.
! 1930: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 1931: OCI_ERROR if
! 1932: 1) any of the parameters is null.
! 1933: 2) 'tdo' does not point to a domain with a collection type.
! 1934: NOTES:
! 1935: The type must be unpinned when the accessed information is no
! 1936: longer needed.
! 1937: */
! 1938:
! 1939:
! 1940: /*--------------------------------------------------------------------------*/
! 1941: /* METHOD ACCESSORS */
! 1942: /*--------------------------------------------------------------------------*/
! 1943:
! 1944: /*------------------------- OCITypeMethodOverload --------------------------*/
! 1945:
! 1946: /* ** OBSOLETE ** */
! 1947: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1948: ub4 OCITypeMethodOverload(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1949: CONST text *method_name, ub4 m_length _*/);
! 1950: #else /* ANSI C */
! 1951: ub4 OCITypeMethodOverload( OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1952: CONST text *method_name, ub4 m_length );
! 1953: #endif
! 1954: /*
! 1955: NAME: OCITypeMethodOverload - OCI Get type's Number of Overloaded names
! 1956: for the given method name.
! 1957: PARAMETERS:
! 1958: gp (IN/OUT) - pga environment handle. Any errors are recorded here.
! 1959: tdo (IN) - pointer to to the type descriptor in the object cache
! 1960: method_name (IN) - the method's name
! 1961: m_length (IN) - length (in bytes) of the 'method_name' parameter
! 1962: REQUIRES:
! 1963: 1) All type accessors require that the type be pinned before calling
! 1964: any accessor.
! 1965: 2) if 'tdo' is not null, it must point to a valid type descriptor
! 1966: in the object cache.
! 1967: DESCRIPTION:
! 1968: Overloading of methods implies that more than one method may have the
! 1969: same method name. This routine returns the number of methods that
! 1970: have the given method name. If there are no methods with the input
! 1971: method name, 'num_methods' is 0. The caller uses this information when
! 1972: allocating space for the array of mdo and/or position pointers before
! 1973: calling 'OCITypeMethodByName()' or 'ortgmps()'.
! 1974: RETURNS:
! 1975: The number of methods with the given name. 0 if none contains the
! 1976: name.
! 1977: NOTES:
! 1978: Schema and type names are CASE-SENSITIVE. If they have been created
! 1979: via SQL, you need to use uppercase names.
! 1980: */
! 1981:
! 1982: /*------------------------ OCITypeMethodByName ------------------------------*/
! 1983:
! 1984: /* ** OBSOLETE ** */
! 1985: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 1986: sword OCITypeMethodByName(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1987: CONST text *method_name, ub4 m_length,
! 1988: OCITypeMethod **mdos _*/);
! 1989: #else /* ANSI C */
! 1990: sword OCITypeMethodByName( OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 1991: CONST text *method_name, ub4 m_length,
! 1992: OCITypeMethod **mdos );
! 1993: #endif
! 1994: /*
! 1995: NAME: OCITypeMethodByName - OCI Get one or more Methods with Name.
! 1996: PARAMETERS:
! 1997: env (IN/OUT) - OCI environment handle initialized in object mode
! 1998: err (IN/OUT) - error handle. If there is an error, it is
! 1999: recorded in 'err' and this function returns OCI_ERROR.
! 2000: The error recorded in 'err' can be retrieved by calling
! 2001: OCIErrorGet().
! 2002: tdo (IN) - pointer to to the type descriptor in the object cache
! 2003: method_name (IN) - the methods' name
! 2004: m_length (IN) - length (in bytes) of the 'name' parameter
! 2005: mdos (OUT) - If this function completes successfully, 'mdos' points to
! 2006: the selected methods in the object cache. The caller must
! 2007: allocate space for the array of OCITypeMethod pointers before
! 2008: calling this routine and must not write into the space.
! 2009: The number of OCITypeMethod pointers that will be returned can
! 2010: be obtained by calling 'OCITypeMethodOverload()'.
! 2011: REQUIRES:
! 2012: 1) All type accessors require that the type be pinned before calling
! 2013: any accessor.
! 2014: 2) if 'tdo' is not null, it must point to a valid type descriptor
! 2015: in the object cache.
! 2016: DESCRIPTION:
! 2017: Get one or more methods given the name.
! 2018: RETURNS:
! 2019: OCI_SUCCESS if the function completes successfully.
! 2020: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2021: OCI_ERROR if
! 2022: 1) any of the required parameters is null.
! 2023: 2) No methods in type has name 'name'.
! 2024: 3) 'mdos' is not NULL but points to NULL data.
! 2025: NOTES:
! 2026: The type must be unpinned when the accessed information is no
! 2027: longer needed.
! 2028: Schema and type names are CASE-SENSITIVE. If they have been created
! 2029: via SQL, you need to use uppercase names.
! 2030: */
! 2031:
! 2032: /*------------------------ OCITypeMethodNext --------------------------------*/
! 2033:
! 2034: /* ** OBSOLETE ** */
! 2035: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2036: sword OCITypeMethodNext(/*_ OCIEnv *env, OCIError *err, OCITypeIter *iterator,
! 2037: OCITypeMethod **mdo _*/);
! 2038: #else /* ANSI C */
! 2039: sword OCITypeMethodNext( OCIEnv *env, OCIError *err, OCITypeIter *iterator,
! 2040: OCITypeMethod **mdo );
! 2041: #endif
! 2042:
! 2043: /*
! 2044: NAME: OCITypeMethodNext - OCI Get a Method By Iteration.
! 2045: PARAMETERS:
! 2046: env (IN/OUT) - OCI environment handle initialized in object mode
! 2047: err (IN/OUT) - error handle. If there is an error, it is
! 2048: recorded in 'err' and this function returns OCI_ERROR.
! 2049: The error recorded in 'err' can be retrieved by calling
! 2050: OCIErrorGet().
! 2051: iterator (IN/OUT) - iterator for retrieving the next method;
! 2052: see OCITypeIterNew() to set iterator.
! 2053: mdo (OUT) - If this function completes successfully, 'mdo' points to
! 2054: the selected method descriptor in the object cache. Positions
! 2055: start at 1. The caller must allocate space for the
! 2056: OCITypeMethod* before calling this routine and must not write
! 2057: nto the space.
! 2058: REQUIRES:
! 2059: 1) All type accessors require that the type be pinned before calling
! 2060: any accessor.
! 2061: 2) if 'tdo' is not null, it must point to a valid type descriptor
! 2062: in the object cache.
! 2063: DESCRIPTION:
! 2064: Iterate to the next method to retrieve.
! 2065: RETURNS:
! 2066: OCI_SUCCESS if the function completes successfully.
! 2067: OCI_NO_DATA if there are no more attributes to iterate on; use
! 2068: OCITypeIterSet() to reset the iterator if necessary.
! 2069: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2070: OCI_ERROR if
! 2071: 1) any of the required parameters is null.
! 2072: 2) 'mdo' is not NULL but points to NULL data.
! 2073: NOTES:
! 2074: The type must be unpinned when the accessed information is no
! 2075: longer needed.
! 2076: */
! 2077:
! 2078: /*------------------------ OCITypeMethodName --------------------------------*/
! 2079:
! 2080: /* ** OBSOLETE ** */
! 2081: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2082: text *OCITypeMethodName(/*_ OCIEnv *env, OCIError *err,
! 2083: CONST OCITypeMethod *mdo, ub4 *n_length _*/);
! 2084: #else /* ANSI C */
! 2085: text *OCITypeMethodName( OCIEnv *env, OCIError *err,
! 2086: CONST OCITypeMethod *mdo, ub4 *n_length );
! 2087: #endif
! 2088: /*
! 2089: NAME: OCITypeMethodName - OCI Get a Method's NaMe.
! 2090: PARAMETERS:
! 2091: env (IN/OUT) - OCI environment handle initialized in object mode
! 2092: err (IN/OUT) - error handle. If there is an error, it is
! 2093: recorded in 'err' and this function returns OCI_ERROR.
! 2094: The error recorded in 'err' can be retrieved by calling
! 2095: OCIErrorGet().
! 2096: mdo (IN) - pointer to the method descriptor in the object cache
! 2097: n_length (OUT) - length (in bytes) of the 'name' parameter. The caller
! 2098: must allocate space for the ub4 before calling this routine.
! 2099: REQUIRES:
! 2100: 1) All type accessors require that the type be pinned before calling
! 2101: any accessor.
! 2102: 2) All input parameters must not be NULL and must be valid.
! 2103: DESCRIPTION:
! 2104: Get the (non-unique) real name of the method.
! 2105: RETURNS:
! 2106: the non-unique name of the method or NULL if there is an error.
! 2107: NOTES:
! 2108: The type must be unpinned when the accessed information is no
! 2109: longer needed.
! 2110: */
! 2111:
! 2112: /*------------------------ OCITypeMethodEncap -------------------------------*/
! 2113:
! 2114: /* ** OBSOLETE ** */
! 2115: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2116: OCITypeEncap OCITypeMethodEncap(/*_ OCIEnv *env, OCIError *err,
! 2117: CONST OCITypeMethod *mdo _*/);
! 2118: #else /* ANSI C */
! 2119: OCITypeEncap OCITypeMethodEncap( OCIEnv *env, OCIError *err,
! 2120: CONST OCITypeMethod *mdo );
! 2121: #endif
! 2122: /*
! 2123: NAME: OCITypeMethodEncap - Get a Method's ENcapsulation (private/public).
! 2124: PARAMETERS:
! 2125: env (IN/OUT) - OCI environment handle initialized in object mode
! 2126: err (IN/OUT) - error handle. If there is an error, it is
! 2127: recorded in 'err' and this function returns OCI_ERROR.
! 2128: The error recorded in 'err' can be retrieved by calling
! 2129: OCIErrorGet().
! 2130: mdo (IN) - pointer to the method descriptor in the object cache
! 2131: REQUIRES:
! 2132: 1) All type accessors require that the type be pinned before calling
! 2133: any accessor.
! 2134: 2) All input parameters must not be NULL and must be valid.
! 2135: DESCRIPTION:
! 2136: Get the encapsulation (private, or public) of a method.
! 2137: RETURNS:
! 2138: the encapsulation (private, or public) of the method
! 2139: NOTES:
! 2140: The type must be unpinned when the accessed information is no
! 2141: longer needed.
! 2142: */
! 2143:
! 2144: /*------------------------ OCITypeMethodFlags -------------------------------*/
! 2145:
! 2146: /* ** OBSOLETE ** */
! 2147: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2148: OCITypeMethodFlag OCITypeMethodFlags(/*_ OCIEnv *env, OCIError *err,
! 2149: CONST OCITypeMethod *mdo _*/);
! 2150: #else /* ANSI C */
! 2151: OCITypeMethodFlag OCITypeMethodFlags( OCIEnv *env, OCIError *err,
! 2152: CONST OCITypeMethod *mdo );
! 2153: #endif
! 2154: /*
! 2155: NAME: OCITypeMethodFlags - OCI Get a Method's FLags
! 2156: (inline, constant, virtual, constructor,
! 2157: destructor).
! 2158: PARAMETERS:
! 2159: env (IN/OUT) - OCI environment handle initialized in object mode
! 2160: err (IN/OUT) - error handle. If there is an error, it is
! 2161: recorded in 'err' and this function returns OCI_ERROR.
! 2162: The error recorded in 'err' can be retrieved by calling
! 2163: OCIErrorGet().
! 2164: mdo (IN) - pointer to the method descriptor in the object cache
! 2165: REQUIRES:
! 2166: 1) All type accessors require that the type be pinned before calling
! 2167: any accessor.
! 2168: 2) All input parameters must not be NULL and must be valid.
! 2169: DESCRIPTION:
! 2170: Get the flags (inline, constant, virutal, constructor, destructor) of
! 2171: a method.
! 2172: RETURNS:
! 2173: the flags (inline, constant, virutal, constructor, destructor) of
! 2174: the method
! 2175: NOTES:
! 2176: The type must be unpinned when the accessed information is no
! 2177: longer needed.
! 2178: */
! 2179:
! 2180: /*------------------------ OCITypeMethodMap ---------------------------------*/
! 2181:
! 2182: /* ** OBSOLETE ** */
! 2183: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2184: sword OCITypeMethodMap(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 2185: OCITypeMethod **mdo _*/);
! 2186: #else /* ANSI C */
! 2187: sword OCITypeMethodMap( OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 2188: OCITypeMethod **mdo );
! 2189: #endif
! 2190: /*
! 2191: NAME: OCITypeMethodMap - OCI Get the Method's MAP function.
! 2192: PARAMETERS:
! 2193: env (IN/OUT) - OCI environment handle initialized in object mode
! 2194: err (IN/OUT) - error handle. If there is an error, it is
! 2195: recorded in 'err' and this function returns OCI_ERROR.
! 2196: The error recorded in 'err' can be retrieved by calling
! 2197: OCIErrorGet().
! 2198: tdo (IN) - pointer to to the type descriptor in the object cache
! 2199: mdo (OUT) - If this function completes successfully, and there is a
! 2200: map function for this type, 'mdo' points to the selected method
! 2201: descriptor in the object cache. Otherwise, 'mdo' is null.
! 2202: REQUIRES:
! 2203: 1) All type accessors require that the type be pinned before calling
! 2204: any accessor.
! 2205: 2) All required input parameters must not be NULL and must be valid.
! 2206: DESCRIPTION:
! 2207: A type may have only one map function. 'OCITypeMethodMap()' finds
! 2208: this function, if it exists, and returns a reference and a pointer to
! 2209: the method descriptor in the object cache. If the type does not have a
! 2210: map (relative ordering) function, then 'mdo_ref' and 'mdo' are set
! 2211: to null and an error is returned.
! 2212: RETURNS:
! 2213: OCI_SUCCESS if the function completes successfully.
! 2214: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2215: OCI_ERROR if
! 2216: the type does not contain a map function.
! 2217: NOTES:
! 2218: The type must be unpinned when the accessed information is no
! 2219: longer needed.
! 2220: */
! 2221:
! 2222: /*------------------------ OCITypeMethodOrder -------------------------------*/
! 2223:
! 2224: /* ** OBSOLETE ** */
! 2225: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2226: sword OCITypeMethodOrder(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 2227: OCITypeMethod **mdo _*/);
! 2228: #else /* ANSI C */
! 2229: sword OCITypeMethodOrder( OCIEnv *env, OCIError *err, CONST OCIType *tdo,
! 2230: OCITypeMethod **mdo );
! 2231: #endif
! 2232: /*
! 2233: NAME: OCITypeMethodOrder - OCI Get the Method's ORder function.
! 2234: PARAMETERS:
! 2235: env (IN/OUT) - OCI environment handle initialized in object mode
! 2236: err (IN/OUT) - error handle. If there is an error, it is
! 2237: recorded in 'err' and this function returns OCI_ERROR.
! 2238: The error recorded in 'err' can be retrieved by calling
! 2239: OCIErrorGet().
! 2240: tdo (IN) - pointer to to the type descriptor in the object cache
! 2241: mdo (OUT) - If this function completes successfully, and there is a
! 2242: map function for this type, 'mdo' points to the selected method
! 2243: descriptor in the object cache. Otherwise, 'mdo' is null.
! 2244: REQUIRES:
! 2245: 1) All type accessors require that the type be pinned before calling
! 2246: any accessor.
! 2247: 2) All required input parameters must not be NULL and must be valid.
! 2248: DESCRIPTION:
! 2249: A type may have only one ORder or MAP function. 'OCITypeMethodOrder()'
! 2250: finds this function, if it exists, and returns a ref and a pointer
! 2251: to the method descriptor in the object cache. If the type does not
! 2252: have a map (relative ordering) function, then 'mdo_ref' and 'mdo' are
! 2253: set to null and an error is returned.
! 2254: RETURNS:
! 2255: OCI_SUCCESS if the function completes successfully.
! 2256: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2257: OCI_ERROR if
! 2258: the type does not contain a map function.
! 2259: NOTES:
! 2260: The type must be unpinned when the accessed information is no
! 2261: longer needed.
! 2262: */
! 2263:
! 2264: /*------------------------ OCITypeMethodParams ------------------------------*/
! 2265:
! 2266: /* ** OBSOLETE ** */
! 2267: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2268: ub4 OCITypeMethodParams(/*_ OCIEnv *env, OCIError *err,
! 2269: CONST OCITypeMethod *mdo _*/);
! 2270: #else /* ANSI C */
! 2271: ub4 OCITypeMethodParams( OCIEnv *env, OCIError *err,
! 2272: CONST OCITypeMethod *mdo );
! 2273: #endif
! 2274: /*
! 2275: NAME: OCITypeMethodParams - OCI Get a Method's Number of Parameters.
! 2276: PARAMETERS:
! 2277: env (IN/OUT) - OCI environment handle initialized in object mode
! 2278: err (IN/OUT) - error handle. If there is an error, it is
! 2279: recorded in 'err' and this function returns OCI_ERROR.
! 2280: The error recorded in 'err' can be retrieved by calling
! 2281: OCIErrorGet().
! 2282: mdo (IN) - pointer to the method descriptor in the object cache
! 2283: REQUIRES:
! 2284: 1) All type accessors require that the type be pinned before calling
! 2285: any accessor.
! 2286: 2) All input parameters must not be NULL and must be valid.
! 2287: DESCRIPTION:
! 2288: Get the number of parameters in a method.
! 2289: RETURNS:
! 2290: the number of parameters in the method
! 2291: NOTES:
! 2292: The type must be unpinned when the accessed information is no
! 2293: longer needed.
! 2294: */
! 2295:
! 2296:
! 2297: /*--------------------------------------------------------------------------*/
! 2298: /* RESULT ACCESSORS */
! 2299: /*--------------------------------------------------------------------------*/
! 2300:
! 2301: /*-------------------------- OCITypeResult ---------------------------------*/
! 2302:
! 2303: /* ** OBSOLETE ** */
! 2304: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2305: sword OCITypeResult(/*_ OCIEnv *env, OCIError *err, CONST OCITypeMethod *mdo,
! 2306: OCITypeElem **rdo _*/);
! 2307: #else /* ANSI C */
! 2308: sword OCITypeResult( OCIEnv *env, OCIError *err, CONST OCITypeMethod *mdo,
! 2309: OCITypeElem **elem );
! 2310: #endif
! 2311: /*
! 2312: NAME: OCITypeResult - OCI Get a method's result type descriptor.
! 2313: PARAMETERS:
! 2314: env (IN/OUT) - OCI environment handle initialized in object mode
! 2315: err (IN/OUT) - error handle. If there is an error, it is
! 2316: recorded in 'err' and this function returns OCI_ERROR.
! 2317: The error recorded in 'err' can be retrieved by calling
! 2318: OCIErrorGet().
! 2319: mdo (IN) - pointer to the method descriptor in the object cache
! 2320: elem (OUT) - If this function completes successfully, 'rdo' points to
! 2321: the selected result (parameter) descriptor in the object cache.
! 2322: REQUIRES:
! 2323: 1) All type accessors require that the type be pinned before calling
! 2324: any accessor.
! 2325: 2) 'elem' MUST be the address of an OCITypeElem pointer.
! 2326: DESCRIPTION:
! 2327: Get the result of a method.
! 2328: RETURNS:
! 2329: OCI_SUCCESS if the function completes successfully.
! 2330: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2331: OCI_ERROR if
! 2332: 1) any of the required parameters is null.
! 2333: 2) method returns no results.
! 2334: NOTES:
! 2335: The method must be unpinned when the accessed information is no
! 2336: longer needed.
! 2337: */
! 2338:
! 2339:
! 2340: /*--------------------------------------------------------------------------*/
! 2341: /* PARAMETER ACCESSORS */
! 2342: /*--------------------------------------------------------------------------*/
! 2343:
! 2344: /*------------------------ OCITypeParamByPos -------------------------------*/
! 2345:
! 2346: /* ** OBSOLETE ** */
! 2347: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2348: sword OCITypeParamByPos(/*_ OCIEnv *env, OCIError *err,
! 2349: CONST OCITypeMethod *mdo, ub4 position,
! 2350: OCITypeElem **elem _*/);
! 2351: #else /* ANSI C */
! 2352: sword OCITypeParamByPos( OCIEnv *env, OCIError *err,
! 2353: CONST OCITypeMethod *mdo, ub4 position,
! 2354: OCITypeElem **elem );
! 2355: #endif
! 2356: /*
! 2357: NAME: OCITypeParamByPos - OCI Get a Parameter in a method By Position.
! 2358: PARAMETERS:
! 2359: env (IN/OUT) - OCI environment handle initialized in object mode
! 2360: err (IN/OUT) - error handle. If there is an error, it is
! 2361: recorded in 'err' and this function returns OCI_ERROR.
! 2362: The error recorded in 'err' can be retrieved by calling
! 2363: OCIErrorGet().
! 2364: mdo (IN) - pointer to the method descriptor in the object cache
! 2365: position (IN) - the parameter's position. Positions start at 1.
! 2366: elem (OUT) - If this function completes successfully, 'elem' points to
! 2367: the selected parameter descriptor in the object cache.
! 2368: REQUIRES:
! 2369: 1) All type accessors require that the type be pinned before calling
! 2370: any accessor.
! 2371: DESCRIPTION:
! 2372: Get a parameter given its position in the method. Positions start
! 2373: at 1.
! 2374: RETURNS:
! 2375: OCI_SUCCESS if the function completes successfully.
! 2376: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2377: OCI_ERROR if
! 2378: 1) any of the required parameters is null.
! 2379: 2) 'position' is not >= 1 and <= the number of parameters in the
! 2380: method.
! 2381: NOTES:
! 2382: The type must be unpinned when the accessed information is no
! 2383: longer needed.
! 2384: */
! 2385:
! 2386: /*------------------------ OCITypeParamByName -------------------------------*/
! 2387:
! 2388: /* ** OBSOLETE ** */
! 2389: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2390: sword OCITypeParamByName(/*_ OCIEnv *env, OCIError *err,
! 2391: CONST OCITypeMethod *mdo,
! 2392: CONST text *name, ub4 n_length,
! 2393: OCITypeElem **elem _*/);
! 2394: #else /* ANSI C */
! 2395: sword OCITypeParamByName( OCIEnv *env, OCIError *err,
! 2396: CONST OCITypeMethod *mdo,
! 2397: CONST text *name, ub4 n_length,
! 2398: OCITypeElem **elem );
! 2399: #endif
! 2400: /*
! 2401: NAME: OCITypeParamByName - OCI Get a Parameter in a method By Name.
! 2402: PARAMETERS:
! 2403: env (IN/OUT) - OCI environment handle initialized in object mode
! 2404: err (IN/OUT) - error handle. If there is an error, it is
! 2405: recorded in 'err' and this function returns OCI_ERROR.
! 2406: The error recorded in 'err' can be retrieved by calling
! 2407: OCIErrorGet().
! 2408: mdo (IN) - pointer to the method descriptor in the object cache
! 2409: name (IN) - the parameter's name
! 2410: n_length (IN) - length (in bytes) of the 'name' parameter
! 2411: elem (OUT) - If this function completes successfully, 'elem' points to
! 2412: the selected parameter descriptor in the object cache.
! 2413: REQUIRES:
! 2414: 1) All type accessors require that the type be pinned before calling
! 2415: any accessor.
! 2416: 2) if 'mdo' is not null, it must point to a valid method descriptor
! 2417: in the object cache.
! 2418: DESCRIPTION:
! 2419: Get a parameter given its name.
! 2420: RETURNS:
! 2421: OCI_SUCCESS if the function completes successfully.
! 2422: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2423: OCI_ERROR if
! 2424: 1) any of the required parameters is null.
! 2425: 2) the method does not contain a parameter with the input 'name'.
! 2426: NOTES:
! 2427: The type must be unpinned when the accessed information is no
! 2428: longer needed.
! 2429: */
! 2430:
! 2431: /*------------------------ OCITypeParamPos ---------------------------------*/
! 2432:
! 2433: /* ** OBSOLETE ** */
! 2434: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2435: sword OCITypeParamPos(/*_ OCIEnv *env, OCIError *err,
! 2436: CONST OCITypeMethod *mdo,
! 2437: CONST text *name, ub4 n_length, ub4 *position,
! 2438: OCITypeElem **elem _*/);
! 2439: #else /* ANSI C */
! 2440: sword OCITypeParamPos( OCIEnv *env, OCIError *err,
! 2441: CONST OCITypeMethod *mdo,
! 2442: CONST text *name, ub4 n_length, ub4 *position,
! 2443: OCITypeElem **elem );
! 2444: #endif
! 2445: /*
! 2446: NAME: OCITypeParamPos - OCI Get a parameter's position in a method
! 2447: PARAMETERS:
! 2448: env (IN/OUT) - OCI environment handle initialized in object mode
! 2449: err (IN/OUT) - error handle. If there is an error, it is
! 2450: recorded in 'err' and this function returns OCI_ERROR.
! 2451: The error recorded in 'err' can be retrieved by calling
! 2452: OCIErrorGet().
! 2453: mdo (IN) - pointer to the method descriptor in the object cache
! 2454: name (IN) - the parameter's name
! 2455: n_length (IN) - length (in bytes) of the 'name' parameter
! 2456: position (OUT) - If this function completes successfully, 'position'
! 2457: points to the position of the parameter in the method starting
! 2458: at position 1. position MUST point to space for a ub4.
! 2459: elem (OUT) - If this function completes successfully, and
! 2460: the input 'elem' is not NULL, 'elem' points to the selected
! 2461: parameter descriptor in the object cache.
! 2462: REQUIRES:
! 2463: 1) All type accessors require that the type be pinned before calling
! 2464: any accessor.
! 2465: 2) if 'mdo' is not null, it must point to a valid method descriptor
! 2466: in the object cache.
! 2467: DESCRIPTION:
! 2468: Get the position of a parameter in a method. Positions start at 1.
! 2469: RETURNS:
! 2470: OCI_SUCCESS if the function completes successfully.
! 2471: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2472: OCI_ERROR if
! 2473: 1) any of the parameters is null.
! 2474: 2) the method does not contain a parameter with the input 'name'.
! 2475: NOTES:
! 2476: The type must be unpinned when the accessed information is no
! 2477: longer needed.
! 2478: */
! 2479:
! 2480: /*------------------------ OCITypeParamElemMode -----------------------------*/
! 2481:
! 2482: /* ** OBSOLETE ** */
! 2483: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2484: OCITypeParamMode OCITypeElemParamMode(/*_ OCIEnv *env, OCIError *err,
! 2485: CONST OCITypeElem *elem _*/);
! 2486: #else /* ANSI C */
! 2487: OCITypeParamMode OCITypeElemParamMode( OCIEnv *env, OCIError *err,
! 2488: CONST OCITypeElem *elem );
! 2489: #endif
! 2490: /*
! 2491: NAME: OCITypeElemParamMode - OCI Get a parameter's mode
! 2492: PARAMETERS:
! 2493: env (IN/OUT) - OCI environment handle initialized in object mode
! 2494: err (IN/OUT) - error handle. If there is an error, it is
! 2495: recorded in 'err' and this function returns OCI_ERROR.
! 2496: The error recorded in 'err' can be retrieved by calling
! 2497: OCIErrorGet().
! 2498: elem (IN) - pointer to the parameter descriptor in the object cache
! 2499: (represented by an OCITypeElem)
! 2500: REQUIRES:
! 2501: 1) All type accessors require that the type be pinned before calling
! 2502: any accessor.
! 2503: 2) All input parameters must not be NULL and must be valid.
! 2504: DESCRIPTION:
! 2505: Get the mode (in, out, or in/out) of the parameter.
! 2506: RETURNS:
! 2507: the mode (in, out, or in/out) of the parameter
! 2508: NOTES:
! 2509: The type must be unpinned when the accessed information is no
! 2510: longer needed.
! 2511: */
! 2512:
! 2513: /*------------------------- OCITypeElemDefaultValue -------------------------*/
! 2514:
! 2515: /* ** OBSOLETE ** */
! 2516: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2517: text* OCITypeElemDefaultValue(/*_ OCIEnv *env, OCIError *err,
! 2518: CONST OCITypeElem *elem,
! 2519: ub4 *d_v_length _*/);
! 2520: #else /* ANSI C */
! 2521: text* OCITypeElemDefaultValue( OCIEnv *env, OCIError *err,
! 2522: CONST OCITypeElem *elem,
! 2523: ub4 *d_v_length );
! 2524: #endif
! 2525: /*
! 2526: NAME: OCITypeElemDefaultValue - OCI Get the element's Default Value.
! 2527: PARAMETERS:
! 2528: env (IN/OUT) - OCI environment handle initialized in object mode
! 2529: err (IN/OUT) - error handle. If there is an error, it is
! 2530: recorded in 'err' and this function returns OCI_ERROR.
! 2531: The error recorded in 'err' can be retrieved by calling
! 2532: OCIErrorGet().
! 2533: elem (IN) - pointer to the parameter descriptor in the object cache
! 2534: (represented by an OCITypeElem)
! 2535: d_v_length (OUT) - length (in bytes) of the returned default value.
! 2536: The caller must allocate space for the ub4 before calling this
! 2537: routine.
! 2538: REQUIRES:
! 2539: 1) All type accessors require that the type be pinned before calling
! 2540: any accessor.
! 2541: 2) All input parameters must not be NULL and must be valid.
! 2542: DESCRIPTION:
! 2543: Get the default value in text form (PL/SQL) of an element. For V8.0,
! 2544: this only makes sense for a method parameter.
! 2545: RETURNS:
! 2546: The default value (text) of the parameter.
! 2547: NOTES:
! 2548: The type must be unpinned when the accessed information is no
! 2549: longer needed.
! 2550: */
! 2551:
! 2552:
! 2553: /*--------------------------------------------------------------------------*/
! 2554: /* TYPE VERSION TABLE */
! 2555: /*--------------------------------------------------------------------------*/
! 2556:
! 2557: /* For V8.0, the type version table is meant to be an internal data structure
! 2558: only for Oracle clients for type version maintanence purposes. A more
! 2559: general version of the API may be made public in subsequent releases. */
! 2560:
! 2561:
! 2562: /*--------------------------- OCITypeVTInit --------------------------------*/
! 2563:
! 2564: /* ** OBSOLETE ** */
! 2565: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2566: sword OCITypeVTInit(/*_ OCIEnv *env, OCIError *err _*/);
! 2567: #else /* ANSI C */
! 2568: sword OCITypeVTInit( OCIEnv *env, OCIError *err );
! 2569: #endif
! 2570: /*
! 2571: NAME: OCITypeVTInit - OCI type Version table INItialize
! 2572: PARAMETERS:
! 2573: env (IN/OUT) - OCI environment handle initialized in object mode
! 2574: err (IN/OUT) - error handle. If there is an error, it is
! 2575: recorded in 'err' and this function returns OCI_ERROR.
! 2576: The error recorded in 'err' can be retrieved by calling
! 2577: OCIErrorGet().
! 2578: REQUIRES:
! 2579: none
! 2580: DESCRIPTION:
! 2581: Allocate space for and initialize the type version table and the type
! 2582: version table's index.
! 2583: RETURNS:
! 2584: OCI_SUCCESS if the function completes successfully.
! 2585: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2586: OCI_ERROR if internal errors occurrs during initialization.
! 2587: */
! 2588:
! 2589: /*--------------------------- OCITypeVTInsert -------------------------------*/
! 2590:
! 2591: /* ** OBSOLETE ** */
! 2592: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2593: sword OCITypeVTInsert(/*_ OCIEnv *env, OCIError *err, CONST text *schema_name,
! 2594: ub4 s_n_length, CONST text *type_name,
! 2595: ub4 t_n_length, CONST text *user_version,
! 2596: ub4 u_v_length _*/);
! 2597: #else /* ANSI C */
! 2598: sword OCITypeVTInsert( OCIEnv *env, OCIError *err, CONST text *schema_name,
! 2599: ub4 s_n_length, CONST text *type_name,
! 2600: ub4 t_n_length, CONST text *user_version,
! 2601: ub4 u_v_length );
! 2602: #endif
! 2603: /*
! 2604: NAME: OCITypeVTInsert - OCI type Version table INSert entry.
! 2605: PARAMETERS:
! 2606: env (IN/OUT) - OCI environment handle initialized in object mode
! 2607: err (IN/OUT) - error handle. If there is an error, it is
! 2608: recorded in 'err' and this function returns OCI_ERROR.
! 2609: The error recorded in 'err' can be retrieved by calling
! 2610: OCIErrorGet().
! 2611: schema_name (IN, optional) - name of schema associated with the
! 2612: type. By default, the user's schema name is used.
! 2613: s_n_length (IN) - length of the 'schema_name' parameter
! 2614: type_name (IN) - type name to insert
! 2615: t_n_length (IN) - length (in bytes) of the 'type_name' parameter
! 2616: user_version (IN) - user readable version of the type
! 2617: u_v_length (IN) - length (in bytes) of the 'user_version' parameter
! 2618: REQUIRES:
! 2619: none
! 2620: DESCRIPTION:
! 2621: Insert an entry into the type version table and the type version
! 2622: table's index. The entry's type name and user readable version
! 2623: fields are updated with the input values. All other fields are
! 2624: initialized to null.
! 2625: RETURNS:
! 2626: OCI_SUCCESS if the function completes successfully.
! 2627: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2628: OCI_ERROR if
! 2629: 1) any of the parameters is invalid.
! 2630: 2) an entry for 'type_name' has already been registered in the
! 2631: type version table.
! 2632: */
! 2633:
! 2634: /*------------------------------ OCITypeVTSelect ----------------------------*/
! 2635:
! 2636: /* OCITypeVTSelect - OCI type VERSion table SELECT entry */
! 2637: /* ** OBSOLETE ** */
! 2638: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2639: sword OCITypeVTSelect(/*_ OCIEnv *env, OCIError *err, CONST text *schema_name,
! 2640: ub4 s_n_length, CONST text *type_name,
! 2641: ub4 t_n_length, text **user_version, ub4 *u_v_length,
! 2642: ub2 *version _*/);
! 2643: #else /* ANSI C */
! 2644: sword OCITypeVTSelect( OCIEnv *env, OCIError *err, CONST text *schema_name,
! 2645: ub4 s_n_length, CONST text *type_name,
! 2646: ub4 t_n_length, text **user_version, ub4 *u_v_length,
! 2647: ub2 *version );
! 2648: #endif
! 2649: /*
! 2650: NAME: OCITypeVTSelect - OCI type Version table SELect entry.
! 2651: PARAMETERS:
! 2652: env (IN/OUT) - OCI environment handle initialized in object mode
! 2653: err (IN/OUT) - error handle. If there is an error, it is
! 2654: recorded in 'err' and this function returns OCI_ERROR.
! 2655: The error recorded in 'err' can be retrieved by calling
! 2656: OCIErrorGet().
! 2657: schema_name (IN, optional) - name of schema associated with the
! 2658: type. By default, the user's schema name is used.
! 2659: s_n_length (IN) - length of the 'schema_name' parameter
! 2660: type_name (IN) - type name to select
! 2661: t_n_length (IN) - length (in bytes) of the 'type_name' parameter
! 2662: user_version (OUT, optional) - pointer to user readable version of the
! 2663: type
! 2664: u_v_length (OUT, optional) - length (in bytes) of the 'user_version'
! 2665: parameter
! 2666: version (OUT, optional) - internal type version
! 2667: REQUIRES:
! 2668: All input parameters must not be NULL and must be valid.
! 2669: DESCRIPTION:
! 2670: Select an entry in the type version table by name.
! 2671: RETURNS:
! 2672: OCI_SUCCESS if the function completes successfully.
! 2673: OCI_INVALID_HANDLE if 'env' or 'err' is null.
! 2674: OCI_ERROR if
! 2675: 1) any of the parameters is invalid.
! 2676: 2) an entry with 'type_name' does not exist.
! 2677: */
! 2678:
! 2679: /* Compatibility function - following function prototype retained for
! 2680: compatibility only */
! 2681: #if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
! 2682: sword ortgcty(/*_ OCIEnv *env, OCIError *err, OCIType *coll_tdo,
! 2683: OCIType **collelem_tdo _*/);
! 2684: #else /* ANSI C */
! 2685: sword ortgcty( OCIEnv *env, OCIError *err, OCIType *coll_tdo,
! 2686: OCIType **collelem_tdo );
! 2687: #endif
! 2688:
! 2689:
! 2690: /*=========================*/
! 2691: /* PUBLIC MACROS AND FLAGS */
! 2692: /*=========================*/
! 2693:
! 2694: /*--------------------------------------------------------------------------*/
! 2695: /* TYPE ELEMENT FLAGS */
! 2696: /*--------------------------------------------------------------------------*/
! 2697:
! 2698: #define OCI_TYPEELEM_REF 0x8000 /* element is a REF */
! 2699: #define OCI_TYPEPARAM_REQUIRED 0x0800 /* parameter is required */
! 2700:
! 2701: /* macros to test flags */
! 2702: #define OCI_TYPEELEM_IS_REF(elem_flag) \
! 2703: (((elem_flag) & OCI_TYPEELEM_REF)!=0)
! 2704: #define OCI_TYPEPARAM_IS_REQUIRED(param_flag) \
! 2705: (((param_flag) & OCI_TYPEPARAM_REQUIRED)!=0)
! 2706:
! 2707:
! 2708: #endif /* ORT_ORACLE */
! 2709:
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ort.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / win32 / sql / oracle / include / oci