Annotation of win32/sql/oracle/include/oci/ort.h, revision 1.1.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