paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-05-06 05:32:38 +02:00
Code Issues Packages Projects Releases Wiki Activity
ad0ac6ef1f
fpc/packages/base/oracle/ort.inc
joost 3574454490 + update of oracle bindings 
git-svn-id: trunk@2540 -
2006-02-12 17:44:14 +00:00

2677 lines
127 KiB
PHP
Raw Blame History

{
Automatically converted by H2Pas 1.0.0 from ort.h
The following command line parameters were used:
-p
-D
-l
jojo.so
ort.h
}
{ @(#)ort.h 1.44 95/07/07 }
{ Copyright (c) 1994, 2003, Oracle Corporation. All rights reserved. }
{
NAME
ORT - ORacle's external open Type interface to the open type manager (OTM)
DESCRIPTION
The open type manager interface includes dynamic type operations to
create, delete, update, and access types. See the "Functional
Specification for Oracle Object Call Interface (Objects Project),
Version 1.0" for a user level description of the OTM. For a more
detailed description, see the "Component Document for the Open Type
Manager, Version 1.0".
NOTE: MOST Of the functions in this header file are being desupported.
Please use the OCIDescribeAny interface as described in oci.h
instead.
The OCIType, OCITypeElem, OCITypeMethod abstract types continue
to be supported. The only two functions that remain to be documented
are OCITypeArrayByName and OCITypeArrayByRef.
All obsolete types/functions are marked accordingly below.
RELATED DOCUMENTS
For the functional specification for the OTM, see:
[1] Kotsovolos, Susan, "Functional Specification for Oracle Object
Call Interface (Objects Project), Version 1.0", Oracle
Corporation, February 1995.
For the internal design of the OTM, see the following:
[2] Kotsovolos, Susan, "Component Document for the Open Type Manager",
Oracle Corporation, November 1994.
[3] Kotsovolos, Susan, "Design for The Open Type Manager, Oracle
Object Management Subsystem Version 1.0", Oracle Corporation,
March 1994.
[4] Kotsovolos, Susan and Tin A. Nguyen, "The Open Type Manager",
Oracle Corporation, March 1994.
[5] Kotsovolos, Susan and Tin A. Nguyen, "Schema Evolution",
Oracle Corporation, March 1994.
For a description of the types the OTM must support, see:
[6] Nguyen, Tin A., "The Open Type System", Oracle Corporation,
February 1994.
INSPECTION STATUS
Inspection date:
Inspection status:
Estimated increasing cost defects per page:
Rule sets:
ACCEPTANCE REVIEW STATUS
Review date:
Review status:
Reviewers:
**** ALL OBSOLETE FUNCTIONS/TYPES ARE MARKED ACCORDINGLY ***
EXPORT FUNCTIONS
None
PUBLIC DATA STRUCTURES
OCIType - type descriptor in the object cache
OCITypeElem - type element descriptor in the object cache
(used for attributes and paramters)
OCITypeCode - Open Type System type code.
OCITypeMethod - method descriptor in the object cache
OCITypeParamMode - parameter modes (ie. IN, IN-OUT etc)
PUBLIC FUNCTIONS
ITERATOR (for OCITypeAttrNext and OCITypeMethodNext)
OCITypeIterNew - ** OBSOLETE ** Create new instance of an iteraton.
OCITypeIterSet - ** OBSOLETE ** Initialize iterator.
OCITypeIterFree - ** OBSOLETE ** Free instance of iterator.
TYPE GET
OCITypeByName - ** OBSOLETE ** Get a type by name.
OCITypeArrayByName - Get an array of types by their names.
OCITypeByRef - ** OBSOLETE ** Get a type by its CREF.
OCITypeArrayByRef - Get an array of types by their CREFs.
TYPE ACCESSORS
OCITypeName - ** OBSOLETE ** OCI Get a type's name.
OCITypeSchema - ** OBSOLETE ** OCI Get a type's schema name.
OCITypeTypeCode - ** OBSOLETE ** OCI Get a type's type code.
OCITypeVersion - ** OBSOLETE ** OCI Get a Type's user-readable Version.
OCITypeAttrs - ** OBSOLETE ** OCI Get a Type's Number of Attributes.
OCITypeMethods - ** OBSOLETE ** OCI Get a Type's Number of Methods.
TYPE ELEMENT ACCESSORS (they represent attributes/parameters/results)
OCITypeElemName - ** OBSOLETE ** Get a type element's (only for
attributes) name.
OCITypeElemType - ** OBSOLETE ** Get a type element's type
descriptor.
OCITypeElemTypeCode - ** OBSOLETE ** Get a type element's typecode.
OCITypeElemParameterizedType - ** OBSOLETE ** Get a type element's
parameterized type's type descriptor.
OCITypeElemNumPrec - ** OBSOLETE ** Get a number's precision.
OCITypeElemNumScale - ** OBSOLETE ** Get a decimal or oracle Number's
Scale
OCITypeElemCharSetID - ** OBSOLETE ** Get a fixed or variable length
string's character set ID.
OCITypeElemCharSetForm - ** OBSOLETE ** Get a fixed or variable length
string's character set form (how
character set information has
been specified).
OCITypeElemLength - ** OBSOLETE ** Get a raw, fixed or variable
length string's length.
OCITypeElemParamMode - ** OBSOLETE ** Get element's parameter's mode
(only valid for parameter).
OCITypeElemDefaultValue - ** OBSOLETE ** Get element's Default Value.
ATTRIBUTE ACCESSORS
OCITypeAttrByName - ** OBSOLETE ** Get an Attribute by Name.
OCITypeAttrNext - ** OBSOLETE ** Get an Attribute by Iteration.
COLLECTION ACCESSORS
OCITypeCollTypeCode - ** OBSOLETE ** Get a named collection's typecode.
OCITypeCollElem - ** OBSOLETE ** Get a named collection's element's
type element information.
OCITypeCollSize - ** OBSOLETE ** Get a named collection's size in
number of elements.
METHOD ACCESSORS
OCITypeMethodOverload - ** OBSOLETE ** Get number of overloaded methods
with the given method name.
(no direct equivalent for
OCIDescribe interface)
OCITypeMethodByName - ** OBSOLETE ** Get one or more methods by name.
OCITypeMethodNext - ** OBSOLETE ** Iterate to the next method to
retrieve.
OCITypeMethodName - ** OBSOLETE ** Get method's name.
OCITypeMethodEncap - ** OBSOLETE ** Get method's encapsulation level.
OCITypeMethodFlags - ** OBSOLETE ** et method's flags.
OCITypeMethodMap - ** OBSOLETE ** Get type's map function.
OCITypeMethodOrder - ** OBSOLETE ** Get type's order function.
OCITypeMethodParams - ** OBSOLETE ** Get a method's number of
parameters.
RESULT ACCESSORS
OCITypeResult - ** OBSOLETE ** OCI Get a method's Result.
See also ATTRIBUTE/PARAMETER/RESULT TYPE ACCESSORS.
PARAMETER ACCESSORS
OCITypeParamByPos - ** OBSOLETE ** Get a Parameter in a method By
Position.
OCITypeParamByName - ** OBSOLETE ** Get a Parameter in a method By Name.
OCITypeParamPos - ** OBSOLETE ** Get a Parameter's PoSition in a
method.
CALL GRAPHS:
Only type accessors are supported for 8.0.
** OBSOLETE ** please use OCIDescribe interface
TYPE ACCESSOR EXAMPLE
CREATE TYPE CAR
(
name vstring,
age number,
number car_age; /o Oracle number o/
weight car_weight; /o abstract type o/
PUBLIC:
/o methods o/
car(orlvs a_name, number an_age, WEIGHT a_weight);
~car();
inline number get_age() const;
/o relative ordering (map) functions o/
number car_map
);
/o the following code accesses the type created above o/
ub1 meth_flags;
ub4 i, j;
ub4 text_len, position;
ub4 count;
ub4 length;
OCITypeCode typecode;
OCIRef *attr_ref;
OCIRef *param_ref;
OCIType *tdo, new_tdo, final_tdo;
OCITypeElem *elem;
OCITypeIter *iterator_ort;
oratext (*names)[];
ub4 lengths[];
ub4 *positions;
oratext *name;
oratext name_buffer[M_IDEN];
/o initialize the references o/
DISCARD orlrini(env, err, (dvoid *)&attr_ref);
DISCARD orlrini(env, err, (dvoid *)&param_ref);
/o ----------------- GET INFORMATION ABOUT A TYPE ----------------- o/
/o start a transaction o/
/o Pin the type until the end of the transaction. Pinning the type is
o required before using any type accessors.
o/
if (OCITypeByName(env, err, svc, (oratext *)0, 0, "CAR", strlen("CAR"),
OCI_DURATION_TRANS, &car_ref, &car_tdo) != OCI_SUCCESS)
/o error o/ ;
/o get the type's name o/
if (!memcmp(OCITypeName(env, err, car_tdo, &text_len), "person",
text_len))
/o do something o/ ;
/o get the type's schema name o/
if (!memcmp(OCITypeSchema(env, err, car_tdo, &text_len), "john",
text_len))
/o do something o/ ;
/o get the type code of the type o/
if (OCITypeTypeCode(env, err, car_tdo) == OCI_TYPECODE_ADT)
/o do something o/ ;
/o get the type version o/
if (!memcmp(OCITypeVersion(env, err, car_tdo, &text_len), "1", text_len))
/o do something o/ ;
/o ------- GET FLATTENED POSITION OF AN ATTRIBUTES IN A TYPE ------- o/
names = malloc(sizeof(oratext *) * 2);
names[0] = malloc(strlen("car_weight"));
names[1] = malloc(strlen("ounces"));
memcpy(names[0], "car_weight", strlen("car_weight"));
memcpy(names[1], "ounces", strlen("ounces"));
lengths = malloc(sizeof(ub4) * 2);
lengths[0] = strlen("car_weight");
lengths[1] = strlen("ounces");
/o ---------- GET IMMEDIATE ATTRIBUTES IN A TYPE ---------- o/
/o loop through all attributes in the type with iterator o/
if (OCITypeIterNew(env, err, car_tdo, &iterator_ort) != OCI_SUCCESS)
/o do something o/
while (OCITypeAttrNext(env, err, iterator_ort, &ado) != OCI_NO_DATA)
/o get the attribute's name o/
if (!memcmp(OCITypeElemName(env, err, ado, &text_len),
"tiger", text_len))
/o do something o/ ;
/o get the attribute's type descriptor o/
if (OCITypeElemType(env, err, ado, &tdo) != OCI_SUCCESS)
/o error o/ ;
/o get the attribute's type code o/
typecode = OCITypeElemTypeCode(env, err, ado);
switch (typecode)
/o scalar types o/
case OCI_TYPECODE_DATE: /o date o/
case OCI_TYPECODE_SIGNED8: /o byte o/
case OCI_TYPECODE_SIGNED16: /o short o/
case OCI_TYPECODE_UNSIGNED8: /o unsigned byte o/
case OCI_TYPECODE_UNSIGNED16: /o unsigned short o/
case OCI_TYPECODE_OCTET: /o octet o/
case OCI_TYPECODE_TABLE: /o nested table o/
case OCI_TYPECODE_CLOB: /o character lob o/
case OCI_TYPECODE_BLOB: /o binary lob o/
case OCI_TYPECODE_CFILE: /o character file object o/
case OCI_TYPECODE_BFILE: /o binary file object o/
/o do something o/
break;
/o number types o/
case OCI_TYPECODE_NUMBER: /o oracle number o/
case OCI_TYPECODE_DECIMAL: /o decimal o/
/o get the scale of the number o/
if (OCITypeElemNumScale(env, err, ado) == 3)
/o do something o/ ;
/o fall through to get the precision o/
case OCI_TYPECODE_FLOAT: /o float o/
case OCI_TYPECODE_SIGNED32: /o long o/
case OCI_TYPECODE_UNSIGNED32: /o unsigned long o/
case OCI_TYPECODE_REAL: /o real o/
case OCI_TYPECODE_DOUBLE: /o double o/
/o get the precision of the number o/
if (OCITypeElemNumPrec(env, err, ado) == 2)
/o do something o/ ;
break;
/o string types o/
case OCI_TYPECODE_CHAR: /o fixed length string o/
case OCI_TYPECODE_VARCHAR2: /o variable length string o/
case OCI_TYPECODE_RAW: /o raw o/
/o get the length of the fixed or variable length string o/
if (OCITypeElemLength(env, err, ado) < 100)
/o do something o/
break;
/o parameterized types o/
case OCI_TYPECODE_REF: /o reference o/
case OCI_TYPECODE_PTR: /o pointer o/
/o get the type stored in the parameterized type o/
if (OCITypeElemParameterizedType(env, err, ado, &tdo)
!= OCI_SUCCESS)
/o error o/ ;
/o do something o/
if (OCI_TYPEELEM_IS_REF(OCITypeElemFlags(env, err, ado)))...
break;
/o domain type o/
case OCI_TYPECODE_NAMEDCOLLECTION:
switch (OCITypeCollTypeCode(env, err, tdo))
case OCI_TYPECODE_VARRAY: /o variable array o/
ub4 num_elems;
OCIType *element_type;
/o get the number of elements in the farray or the maximum number
o of elements in the varray.
o/
OCITypeCollSize(env, err, tdo, &num_elems);
/o get the type of the array o/
OCITypeElemType(env, err, tdo, &element_type);
break;
case OCI_TYPECODE_TABLE: /o multiset o/
OCIType *table_type;
/o get the type of the multiset o/
OCITypeElemType(env, err, tdo, &table_type);
/o do something o/
/o abstract type o/
case OCI_TYPECODE_ADT: /o abstract data type o/
/o get the adt information o/
if (OCITypeElemType(env, err, ado, &tdo) != OCI_SUCCESS)
/o error o/ ;
/o do something o/
break;
default:
DISCARD printf("Error: invalid type code\n");
/o end of typecode switch o/
/o end of loop through all attributes in a type o/
/o ------------ GET THE IMMEDIATE METHODS OF A TYPE ------------ o/
/o loop through all methods in the type by reusing iterator o/
if (OCITypeIterSet(env, err, car_tdo, iterator_ort) != OCI_SUCCESS)
/o do something o/
while (OCITypeMethodNext(env, err, iterator_ort) != OCI_NO_DATA)
/o get the method's name o/
if (!memcmp(OCITypeMethodName(env, err, mdo, &text_len), "car",
text_len))
/o do something o/ ;
/o get the method's encapsulation o/
if (OCITypeMethodEncap(env, err, mdo) == OCI_TYPEENCAP_PUBLIC)
/o do something o/ ;
/o get the method's flags o/
meth_flags = OCITypeMethodFlags(env, err, mdo);
if (meth_flags & OCI_TYPEMETHOD_VIRTUAL)
/o do something o/ ;
/o ------------ GET THE PARAMETERS IN A METHOD ------------ o/
/o loop through all parameters in the method o/
count = OCITypeMethodParams(env, err, mdo);
for (j = 1; j <= count; j++)
/o get the parameter information by position o/
if (OCITypeParamByPos(env, err, mdo, i, &elem) != OCI_SUCCESS)
/o error o/ ;
/o get the parameter's name o/
if (!memcmp(OCITypeElemName(env, err, elem, &text_len), "an_age",
text_len))
/o do something o/ ;
/o get the parameter's mode o/
if (OCITypeElemMode(env, err, elem) == OCI_PARAM_OUT)
/o do something o/ ;
/o get the parameter's required flag o/
if (ortgprq(env, err, elem))
/o do something o/ ;
/o get a method by name o/
if (OCITypeMethodByName(env, err, car_tdo, "car_constructor",
strlen("car_constructor"), NULLP(OCIRef), &mdo)
!= OCI_SUCCESS)
/o error o/ ;
/o get a parameter in a method by name o/
if (OCITypeParamByName(env, err, mdo, "an_age", strlen("an_age"), &elem)
!= OCI_SUCCESS)
/o error o/ ;
/o get a parameter's typecode o/
typecode = OCITypeElemTypeCode(env, err, elem);
/o get a parameter's type object o/
if (OCITypeElemType(env, err, elem, &tdo)) != OCI_SUCCESS)
/o error o/ ;
/o get a parameter's position in a method o/
if (ortgpps(env, err, mdo, "an_age", strlen("an_age"),
&position, NULLP(OCIRef), NULLP(OCITypeElem)) != OCI_SUCCESS)
/o error o/ ;
/o ------------ GET THE METHOD's RESULT ------------ o/
/o get a method by name o/
if (OCITypeMethodByName(env, err, car_tdo, "get_age", strlen("get_age"),
&mdo) != OCI_SUCCESS)
/o error o/ ;
/o get the typecode of the method's result o/
typecode = OCITypeElemTypeCode(env, err, mdo);
/o ----------------- END ---------------- o/
/o free the references implicitly allocated o/
DISCARD orlrfre(env, err, (dvoid *)&attr_ref);
DISCARD orlrfre(env, err, (dvoid *)&param_ref);
NOTES
MODIFIED
srseshad 03/12/03 - convert oci public api to ansi
aahluwal 06/03/02 - bug 2360115
skabraha 04/16/02 - fix compiler warnings
rkasamse 03/02/01 - do not use iterator : keyword in MSVB
bpalaval 02/09/01 - Change text to oratext.
rxgovind 01/31/00 - add OCIType interfaces for transient types
whe 09/01/99 - 976457:check __cplusplus for C++ code
cxcheng 05/06/97 - make OCI_TYPE?? test macros return either 1 or 0
cxcheng 04/22/97 - add comment on desupporting OCIType functions
skrishna 03/18/97 - fix ifdef for supporting ansi and k&r proto-types
cxcheng 02/26/97 - fix lint problem with oro names
cxcheng 02/06/97 - take out short name support except with SLSHORTNAME
cxcheng 01/15/97 - change prototype of OCITypeElemParameterizedType()
cxcheng 01/03/97 - replace bit in OCI_TYPEPARAM_IS_REQUIRED with bitwis
cxcheng 12/31/96 - replace OCI_PARAM_IS_REQUIRED with OCI_TYPEPARAM_IS_
cxcheng 12/09/96 - add prototype for OCITypeElemExtTypeCode and OCIType
cxcheng 11/25/96 - add schema name parameter to OCITypeVTInsert()
cxcheng 11/20/96 - fix prototype for OCITypeByName()
cxcheng 11/11/96 - fix prototype for OCITypeByName()
cxcheng 11/05/96 - remove OCITypeElemExtTypeCode and OCITypeCollExtType
dchatter 10/28/96 - change ortgatyp to be OCITypeArrayByName
cxcheng 10/25/96 - fix problem with ortgatyp at end
cxcheng 10/22/96 - add OCITypeByRef and OCITypeArrayByRef
cxcheng 10/20/96 - remove ortgtyp() from #define section at end
cxcheng 10/18/96 - rename OCITypeGetArray to OCITypeArrayByName
cxcheng 10/17/96 - final change to prototype for OCI_TYPEPARAM_IS_REQUI
cxcheng 10/15/96 - rename OCIEncapLevel and OCIMethodFlag
cxcheng 10/14/96 - change prototype of OCITypeResult
mluong 10/11/96 - fix compile error
jwijaya 10/10/96 - fix bug on OCI_PARAM_IS_REQUIRED
cxcheng 10/09/96 - more lint and link fixes
cxcheng 10/08/96 - more lint fixes
cxcheng 10/07/96 - more changes
cxcheng 10/04/96 - replace short names with long names
cxcheng 10/01/96 - change to long names for readability
cxcheng 09/27/96 - rename ortgatyp() to ortgtya() for lint
cxcheng 09/20/96 - add ortgatyp() for array get type
cxcheng 09/18/96 - add array pin and iterator functions
cxcheng 08/09/96 - add version table calls
cxcheng 07/22/96 - add OCITypeElemType() to top
jwijaya 07/03/96 - add ANSI prototypes
cxcheng 06/28/96 - add OCITypeElemCharSetForm()
cxcheng 06/26/96 - fix comment on OCITypeParamByPos()/ortgpps()
cxcheng 06/18/96 - fix comments on OCITypeResult()
cxcheng 06/17/96 - improve comments
skrishna 06/03/96 - change OCITypeCollElem() prototype
vkrishna 05/29/96 - replace OROTCFAR with OROTCCAR
cxcheng 05/28/96 - fix comments, remove non-beta1 functions
cxcheng 05/02/96 - fix prototype bugs
cxcheng 04/29/96 - rename OCITypeElemm() to ortanct()
cxcheng 04/26/96 - add ortgrbp and ortftyi,
fix comments and examples
cxcheng 04/22/96 - big merge to main branch
cxcheng 04/17/96 - fix syntax
cxcheng 04/08/96 - change prototype to ortaty()
skrishna 04/08/96 - change ort*() to take OCIEnv* and OCIError* instead
of oroenv*
cxcheng 03/28/96 - add ortslob(), change ortsstr() prototype
cxcheng 03/13/96 - change alter type interface
cxcheng 03/11/96 - ORT interface changes
cxcheng 02/27/96 - correct comments
jboonleu 02/09/96 - rename oroopd to OCIDuration
cxcheng 01/19/96 - change ORTCTYVAL to ORTCTYEMB for embedded ADT
cxcheng 02/14/96 - add more comments
jboonleu 02/09/96 - rename oroopd to OCIDuration
cxcheng 02/07/96 - fix comments and examples
cxcheng 01/19/96 - new ORT interface without korfc's
cxcheng 01/08/96 - consolidate collection functions
cxcheng 12/14/95 - remove obsolete ortgcol() and ortrelease()
jweisz 12/12/95 - merge screwup: ortdth twice
cxcheng 12/05/95 - change multiset interface for new standard
skotsovo 12/01/95 - merge from /vobs/rdbms/public/ort.h@@/main/
st_rdbms_big_dev/st_rdbms_obj/
st_rdbms_jwijaya_variable_ref
cxcheng 11/13/95 - add ortaty()/orteaty()
cxcheng 11/13/95 - add new collection type accessors
skotsovo 10/30/95 - add 'oid' type b/c extent type uses it.
skotsovo 10/24/95 - update according to new variable length ref
cxcheng 10/05/95 - add null support, change prototypes to calls
cxcheng 10/03/95 - add OCITypeMethodOrder() to get ORDER method
cxcheng 09/28/95 - add OCITypeElemm() for collection types support
skotsovo 06/05/95 - add adt_type parameter to ortsab()
skotsovo 05/10/95 - ifdef'd out ortgafp()
skotsovo 03/07/95 - update interface to only include release 1
skotsovo 02/22/95 - add multiset accessors
skotsovo 02/09/95 - update according to new ots doc
skotsovo 01/31/95 - add rest of release 1 types
skotsovo 01/24/95 - categorize sint32, double, and real as number types
(with precision and scale) instead of scalar types.
skotsovo 01/12/95 - remove dependency from ortdty interface
skotsovo 01/03/95 - remove orotyp accessors
skotsovo 12/12/94 - update comments
skotsovo 12/05/94 - change OCITypeElemParameterizedTyper interface
skotsovo 10/26/94 - add type version table
skotsovo 10/17/94 - fix ortgafp() comments
skotsovo 10/14/94 - modify ortgafp() parameters
skotsovo 10/14/94 - add examples
skotsovo 10/13/94 - add a few new routines
jwijaya 10/07/94 - add namespace to pin by name
jwijaya 10/02/94 - connection handle -> connection number
skotsovo 09/13/94 - modify example to use updated oririni interface
skotsovo 08/25/94 - change scale to sb1 from sb2
skotsovo 07/28/94 - add ortbeg() and ortend()
skotsovo 07/14/94 - add decimal type & call graph
skotsovo 06/28/94 - subset by removing miscellaneous functions
skotsovo 06/28/94 - consistently put comments before typedefs
skotsovo 06/27/94 - modify according to new header file template, add
more examples, and change ortcty() to return a
reference to the type
skotsovo 06/24/94 - add functions to get type information from orotyp
skotsovo 06/20/94 - finish modifying according to header template
skotsovo 06/09/94 - modify according to header file template
skotsovo 06/08/94 - replace s.h with oratypes.h
skotsovo 05/24/94 - modify comments & update example
skotsovo 05/23/94 - modify fnt names for create, alter and drop type
skotsovo 05/18/94 - remove ortdme() -- delete a method
skotsovo 05/17/94 - add tdo parameter to all type modifiers
skotsovo 05/11/94 - return text* instead of including it in arglist
skotsovo 11/16/93 - creation
}
{$ifndef ORO_ORACLE}
{ $include <oro.h>}
{$endif}
{--------------------------------------------------------------------------- }
{ SHORT NAMES SUPPORT SECTION }
{--------------------------------------------------------------------------- }
{$ifdef SLSHORTNAME}
{ the following are short names that are only supported on IBM mainframes
with the SLSHORTNAME defined.
With this all subsequent long names will actually be substituted with
the short names here }
const
OCITypeArrayByName = ortgatyp;
OCITypeAttrByName = ortgabn;
OCITypeAttrNext = ortgabi;
OCITypeAttrs = ortgtna;
OCITypeByRef = ortgtbrf;
OCITypeCollElem = ortgcel;
OCITypeCollExtTypeCode = ortgcsqt;
OCITypeCollSize = ortgcne;
OCITypeCollTypeCode = ortgdttc;
OCITypeElem = ortado;
OCITypeElemCharSetForm = ortgscform;
OCITypeElemCharSetID = ortgscid;
OCITypeElemDefaultValue = ortgpdv;
OCITypeElemExtTypeCode = ortgasqt;
OCITypeElemLength = ortgsl;
OCITypeElemName = ortganm;
OCITypeElemNumPrec = ortgnp;
OCITypeElemNumScale = ortgns;
OCITypeElemParamMode = ortgpmo;
OCITypeElemParameterizedType = ortgpa;
OCITypeElemType = ortgaty;
OCITypeElemTypeCode = ortgatc;
OCITypeIter = ortitr;
OCITypeIterFree = ortifre;
OCITypeIterNew = ortinew;
OCITypeIterSet = ortiset;
OCITypeMethod = ortmdo;
OCITypeMethodByName = ortgmbn;
OCITypeMethodEncap = ortgmen;
OCITypeMethodFlags = ortgmfl;
OCITypeMethodMap = ortgmmap;
OCITypeMethodName = ortgmnm;
OCITypeMethodNext = ortgmbi;
OCITypeMethodOrder = ortgmor;
OCITypeMethodOverload = ortgmno;
OCITypeMethodParams = ortgmnp;
OCITypeMethods = ortgtnm;
OCITypeName = ortgtme;
OCITypeParamByName = ortgpbn;
OCITypeParamPos = ortgpps;
OCITypeSchema = ortgtsch;
OCITypeTypeCode = ortgttc;
OCITypeVTInit = ortvini;
OCITypeVTInsert = ortvins;
OCITypeVTSelect = ortvsel;
OCITypeVersion = ortgtvn;
{$endif}
{ SLSHORTNAME }
{============================ } { PUBLIC TYPES AND CONSTANTS }
{============================ }
{----------------------------- TYPE DESCRIPTION ---------------------------- }
{
* OCIType - OCI Type Description Object
*
* The contents of an 'OCIType' is private/opaque to clients. Clients just
* need to declare and pass 'OCIType' pointers in to the type manage
* functions.
* The pointer points to the type in the object cache. Thus, clients don't
* need to allocate space for this type and must NEVER free the pointer to the
* 'OCIType'.
}
type
POCIType = pointer;
{------------------------- TYPE ELEMENT DESCRIPTION ------------------------ }
{
* OCITypeElem - OCI Type Element object
*
* The contents of an 'OCITypeElem' is private/opaque to clients. Clients just
* need to declare and pass 'OCITypeElem' pointers in to the type manager
* functions.
*
* 'OCITypeElem' objects contains type element information such as the numeric
* precision for example, for number objects, and the number of elements for
* arrays.
* They ARE used to describe type attributes, collection elements,
* method parameters, and method results. Hence they are pass in or returned
* by attribute, collection, and method parameter/result accessors.
}
POCITypeElem = pointer;
{--------------------------- METHOD DESCRIPTION --------------------------- }
{
* OCITypeMethod - OCI Method Description object
*
* The contents of an 'OCITypeMethod' is private/opaque to clients. Clients
* just need to declare and pass 'OCITypeMethod' pointers in to the type
* manager functions.
* The pointer points to the method in the object cache. Thus, clients don't
* need to allocate space for this type and must NEVER free the pointer to
* the 'OCITypeMethod'.
}
POCITypeMethod = pointer;
{--------------------------- TYPE ACCESS ITERATOR -------------------------- }
{
* OCITypeIter- OCI Type Iterator
*
* The contents of an 'orti' is private/opaque to clients. Clients just
* need to declare and pass 'orti' pointers in to the type manager functions.
* The iterator is used to retreive MDO's and ADO's that belong to the TDO
* one at a time. It needs to be allocated by the 'OCITypeIterNew()' function
* call and deallocated with the 'OCITypeIterFree()' function call.
}
POCITypeIter = pointer;
{================== }
{ PUBLIC FUNCTIONS }
{================== }
{-------------------------------------------------------------------------- }
{ ITERATOR }
{-------------------------------------------------------------------------- }
{-----------------------_- OCITypeIterNew --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeIterNew(env:POCIEnv; err:POCIError; tdo:POCIType; var iterator_ort:POCITypeIter):sword;cdecl;external ocilib name 'OCITypeIterNew';
{$ELSE}
var OCITypeIterNew : function (env:POCIEnv; err:POCIError; tdo:POCIType; var iterator_ort:POCITypeIter):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeIterNew - OCI Iterator NEW
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to the pinned type in the object cache to
initialize the iterator with
iterator_ort (OUT) - pointer to the pointer to the new iterator created
DESCRIPTION:
Create a new instance of a method/attribute iterator and initalize
it's values.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) error while allocating space for the iterator.
}
{------------------------ OCITypeIterSet --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeIterSet(env:POCIEnv; err:POCIError; tdo:POCIType; iterator_ort:POCITypeIter):sword;cdecl;external ocilib name 'OCITypeIterSet';
{$ELSE}
OCITypeIterSet : function (env:POCIEnv; err:POCIError; tdo:POCIType; iterator_ort:POCITypeIter):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeIterSet - OCI Iterator SET
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to the pinned type in the object cache to
initialize the iterator with
iterator_ort (IN/OUT) - pointer to the iterator to set
DESCRIPTION:
Initializes the iterator. This is used to reset the state of the
iterator.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
}
{------------------------ OCITypeIterFree --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeIterFree(env:POCIEnv; err:POCIError; iterator_ort:POCITypeIter):sword;cdecl;external ocilib name 'OCITypeIterFree';
{$ELSE}
OCITypeIterFree : function (env:POCIEnv; err:POCIError; iterator_ort:POCITypeIter):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeIterFree - OCI Iterator FREe
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
iterator_ort (IN/OUT) - pointer to the iterator to free
DESCRIPTION:
Free space allocated for the iterator.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) error while freeing the iterator, probably bad iterator pointer.
}
{-------------------------------------------------------------------------- }
{ TYPE GET }
{-------------------------------------------------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeByName(env:POCIEnv; err:POCIError; svc:POCISvcCtx; schema_name:Poratext; s_length:ub4;
type_name:Poratext; t_length:ub4; version_name:Poratext; v_length:ub4; pin_duration:OCIDuration;
get_option:OCITypeGetOpt;var tdo:POCIType):sword;cdecl;external ocilib name 'OCITypeByName';
{$ELSE}
OCITypeByName : function (env:POCIEnv; err:POCIError; svc:POCISvcCtx; schema_name:Poratext; s_length:ub4;
type_name:Poratext; t_length:ub4; version_name:Poratext; v_length:ub4; pin_duration:OCIDuration;
get_option:OCITypeGetOpt;var tdo:POCIType):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeByName - OCI Get the most current version of an existing TYPe
by name.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
svc (IN) - OCI service handle
schema_name (IN, optional) - name of schema associated with the
type. By default, the user's schema name is used.
s_length (IN) - length of the 'schema_name' parameter
type_name (IN) - name of the type to get
t_length (IN) - length of the 'type_name' parameter
version_name (IN, optional) - user readable version of the type.
Pass (oratext *)0 for the most current version.
v_length (IN) - length of version_name in bytes. Should be 0 if
the most current version is to be retrieved.
pin_duration (IN) - pin duration (e.g. until the end of current
transaction). See 'oro.h' for a description of
each option.
get_option (IN) - options for loading the types. It can be one of two
values:
OCI_TYPEGET_HEADER for only the header to be loaded, or
OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
loaded.
tdo (OUT) - pointer to the pinned type in the object cache
DESCRIPTION:
Get a pointer to a version of the existing type associated
with schema/type name.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) the adt type associated with schema/type name does not exist.
NOTE:
Schema and type names are CASE-SENSITIVE. If they have been created
via SQL, you need to use uppercase names.
}
{$IFNDEF LinkDynamically}
function OCITypeArrayByName(env:POCIEnv; err:POCIError; svc:POCISvcCtx; array_len:ub4; schema_name:array of Poratext;
s_length:array of ub4; type_name:array of Poratext; t_length:array of ub4; version_name:array of Poratext; v_length:array of ub4;
pin_duration:OCIDuration; get_option:OCITypeGetOpt; var tdo:POCIType):sword;cdecl;external ocilib name 'OCITypeArrayByName';
{$ELSE}
OCITypeArrayByName : function (env:POCIEnv; err:POCIError; svc:POCISvcCtx; array_len:ub4; schema_name:array of Poratext;
s_length:array of ub4; type_name:array of Poratext; t_length:array of ub4; version_name:array of Poratext; v_length:array of ub4;
pin_duration:OCIDuration; get_option:OCITypeGetOpt; var tdo:POCIType):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeArrayByName - OCI Get array of TYPes by name.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
svc (IN) - OCI service handle
array_len (IN) - number of schema_name/type_name/version_name entries to
be retrieved.
schema_name (IN, optional) - array of schema names associated with the
types to be retrieved. The array must have array_len
elements if specified.
If 0 is supplied, the default schema is assumed, otherwise
it MUST have array_len number of elements.
0 can be supplied for one or more of the entries to indicate
that the default schema is desired for those entries.
s_length (IN) - array of schema_name lengths with each entry
corresponding to the length of the corresponding schema_name
entry in the schema_name array in bytes.
The array must either have array_len number of elements or
it MUST be 0 if schema_name is not specified.
type_name (IN) - array of the names of the types to retrieve. This
MUST have array_len number of elements.
t_length (IN) - array of the lengths of type names in the type_name
array in bytes.
version_name (IN) - array of the version names of the types to retrieve
corresponding. This can be 0 to indicate retrieval of the
most current versions, or it MUST have array_len number of
elements.
If 0 is supplied, the most current version is assumed,
otherwise it MUST have array_len number of elements.
0 can be supplied for one or more of the entries to indicate
that the current version is desired for those entries.
v_length (IN) - array of the lengths of version names in the
version_name array in bytes.
pin_duration (IN) - pin duration (e.g. until the end of current
transaction) for the types retreieve. See 'oro.h' for a
description of each option.
get_option (IN) - options for loading the types. It can be one of two
values:
OCI_TYPEGET_HEADER for only the header to be loaded, or
OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
loaded.
tdo (OUT) - output array for the pointers to each pinned type in the
object cache. It must have space for array_len pointers.
Use OCIObjectGetObjectRef() to obtain the CREF to each
pinned type descriptor.
DESCRIPTION:
Get pointers to the existing types associated with the schema/type name
array. This is similar to OCITypeByName() except that all the TDO's are
retreived via a single network roundtrip.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) one or more adt types associated with a schema/type name entry
does not exist.
}
{$IFNDEF LinkDynamically}
function OCITypeByRef(env:POCIEnv; err:POCIError; type_ref:POCIRef; pin_duration:OCIDuration; get_option:OCITypeGetOpt;
var tdo:POCIType):sword;cdecl;external ocilib name 'OCITypeByRef';
{$ELSE}
OCITypeByRef : function (env:POCIEnv; err:POCIError; type_ref:POCIRef; pin_duration:OCIDuration; get_option:OCITypeGetOpt;
var tdo:POCIType):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeArrayByRef - OCI Get array of TYPes by REF.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
type_ref (IN) - OCIRef * pointing to the particular version of
the type descriptor object to obtain.
The array must have array_len elements if specified.
pin_duration (IN) - pin duration (e.g. until the end of current
transaction) for the type to retreieve. See 'oro.h' for a
description of each option.
get_option (IN) - options for loading the type. It can be one of two
values:
OCI_TYPEGET_HEADER for only the header to be loaded, or
OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
loaded.
tdo (OUT) - pointer to the pinned type in the object cache
DESCRIPTION:
Get pointers to the
with the schema/type name array. This is similar to OCITypeByName()
except that all the TDO's are retreived via a single network roundtrip.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) one or more adt types associated with a schema/type name entry
does not exist.
}
{$IFNDEF LinkDynamically}
function OCITypeArrayByRef(env:POCIEnv; err:POCIError; array_len:ub4; var type_ref:POCIRef; pin_duration:OCIDuration;
get_option:OCITypeGetOpt; var tdo:POCIType):sword;cdecl;external ocilib name 'OCITypeArrayByRef';
{$ELSE}
OCITypeArrayByRef : function (env:POCIEnv; err:POCIError; array_len:ub4; var type_ref:POCIRef; pin_duration:OCIDuration;
get_option:OCITypeGetOpt; var tdo:POCIType):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeArrayByRef - OCI Get array of TYPes by REF.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
array_len (IN) - number of schema_name/type_name/version_name entries to
be retrieved.
type_ref (IN) - array of OCIRef * pointing to the particular version of
the type descriptor object to obtain.
The array must have array_len elements if specified.
pin_duration (IN) - pin duration (e.g. until the end of current
transaction) for the types retreieve. See 'oro.h' for a
description of each option.
get_option (IN) - options for loading the types. It can be one of two
values:
OCI_TYPEGET_HEADER for only the header to be loaded, or
OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be
loaded.
tdo (OUT) - output array for the pointers to each pinned type in the
object cache. It must have space for array_len pointers.
Use OCIObjectGetObjectRef() to obtain the CREF to each
pinned type descriptor.
DESCRIPTION:
Get pointers to the
with the schema/type name array. This is similar to OCITypeByName()
except that all the TDO's are retreived via a single network roundtrip.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) one or more adt types associated with a schema/type name entry
does not exist.
}
{-------------------------------------------------------------------------- }
{ TYPE ACCESSORS }
{-------------------------------------------------------------------------- }
{---------------------------- OCITypeName --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeName(env:POCIEnv; err:POCIError; tdo:POCIType; n_length:Pub4):Poratext;cdecl;external ocilib name 'OCITypeName';
{$ELSE}
OCITypeName : function (env:POCIEnv; err:POCIError; tdo:POCIType; n_length:Pub4):Poratext;cdecl;
{$ENDIF}
{
NAME: OCITypeName - ORT Get a Type's naME.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
n_length (OUT) - length (in bytes) of the returned type name. The
caller must allocate space for the ub4 before calling this
routine.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
3) 'n_length' must point to an allocated ub4.
DESCRIPTION:
Get the name of the type.
RETURNS:
the name of the type
NOTES:
The type descriptor, 'tdo', must be unpinned when the accessed
information is no longer needed.
}
{------------------------ OCITypeSchema --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeSchema(env:POCIEnv; err:POCIError; tdo:POCIType; n_length:Pub4):Poratext;cdecl;external ocilib name 'OCITypeSchema';
{$ELSE}
OCITypeSchema : function (env:POCIEnv; err:POCIError; tdo:POCIType; n_length:Pub4):Poratext;cdecl;
{$ENDIF}
{
NAME: OCITypeSchema - ORT Get a Type's SCHema name.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
n_length (OUT) - length (in bytes) of the returned schema name. The
caller must allocate space for the ub4 before calling this
routine.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
3) 'n_length' must point to an allocated ub4.
DESCRIPTION:
Get the schema name of the type.
RETURNS:
the schema name of the type
NOTES:
The type descriptor, 'tdo', must be unpinned when the accessed
information is no longer needed.
}
{------------------------ OCITypeTypeCode --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeTypeCode(env:POCIEnv; err:POCIError; tdo:POCIType):OCITypeCode;cdecl;external ocilib name 'OCITypeTypeCode';
{$ELSE}
OCITypeTypeCode : function (env:POCIEnv; err:POCIError; tdo:POCIType):OCITypeCode;cdecl;
{$ENDIF}
{
NAME: OCITypeTypeCode - OCI Get a Type's Type Code.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the type code of the type.
RETURNS:
The type code of the type.
NOTES:
The type descriptor, 'tdo', must be unpinned when the accessed
information is no longer needed.
}
{----------------------- OCITypeCollTypeCode ------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeCollTypeCode(env:POCIEnv; err:POCIError; tdo:POCIType):OCITypeCode;cdecl;external ocilib name 'OCITypeCollTypeCode';
{$ELSE}
OCITypeCollTypeCode : function (env:POCIEnv; err:POCIError; tdo:POCIType):OCITypeCode;cdecl;
{$ENDIF}
{
NAME: OCITypeCollTypeCode - OCI Get a Domain Type's Type Code.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
3) 'tdo' MUST point to a named collection type.
DESCRIPTION:
Get the type code of the named collection type. For V8.0, named
collection types can only be variable length arrays and nested tables.
RETURNS:
OCI_TYPECODE_VARRAY for variable length array, and
OCI_TYPECODE_TABLE for nested tables.
NOTES:
The type descriptor, 'tdo', should be unpinned when the accessed
information is no longer needed.
}
{------------------------- OCITypeVersion --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeVersion(env:POCIEnv; err:POCIError; tdo:POCIType; v_length:Pub4):Poratext;cdecl;external ocilib name 'OCITypeVersion';
{$ELSE}
OCITypeVersion : function (env:POCIEnv; err:POCIError; tdo:POCIType; v_length:Pub4):Poratext;cdecl;
{$ENDIF}
{
NAME: OCITypeVersion - OCI Get a Type's user-readable VersioN.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
v_length (OUT) - length (in bytes) of the returned user-readable
version. The caller must allocate space for the ub4 before
calling this routine.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
3) 'v_length' must point to an allocated ub4.
DESCRIPTION:
Get the user-readable version of the type.
RETURNS:
The user-readable version of the type
NOTES:
The type descriptor, 'tdo', must be unpinned when the accessed
information is no longer needed.
}
{--------------------------- OCITypeAttrs --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeAttrs(env:POCIEnv; err:POCIError; tdo:POCIType):ub4;cdecl;external ocilib name 'OCITypeAttrs';
{$ELSE}
OCITypeAttrs : function (env:POCIEnv; err:POCIError; tdo:POCIType):ub4;cdecl;
{$ENDIF}
{
NAME: OCITypeAttrs - OCI Get a Type's Number of Attributes.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the number of attributes in the type.
RETURNS:
The number of attributes in the type. 0 for ALL non-ADTs.
NOTES:
The type descriptor, 'tdo', must be unpinned when the accessed
information is no longer needed.
}
{------------------------- OCITypeMethods --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeMethods(env:POCIEnv; err:POCIError; tdo:POCIType):ub4;cdecl;external ocilib name 'OCITypeMethods';
{$ELSE}
OCITypeMethods : function (env:POCIEnv; err:POCIError; tdo:POCIType):ub4;cdecl;
{$ENDIF}
{
NAME: OCITypeMethods - OCI Get a Type's Number of Methods.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the number of methods in a type.
RETURNS:
The number of methods in the type
NOTES:
The type descriptor, 'tdo', must be unpinned when the accessed
information is no longer needed.
}
{-------------------------------------------------------------------------- }
{ TYPE ELEMENT INFORMATION ACCESSORS }
{-------------------------------------------------------------------------- }
{------------------------ OCITypeElemName --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemName(env:POCIEnv; err:POCIError; elem:POCITypeElem; n_length:Pub4):Poratext;cdecl;external ocilib name 'OCITypeElemName';
{$ELSE}
OCITypeElemName : function (env:POCIEnv; err:POCIError; elem:POCITypeElem; n_length:Pub4):Poratext;cdecl;
{$ENDIF}
{
NAME: OCITypeElemName - OCI Get an Attribute's NaMe.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the type element descriptor in the object cache
n_length (OUT) - length (in bytes) of the returned attribute name.
The caller must allocate space for the ub4 before calling this
routine.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
3) 'n_length' must point to an allocated ub4.
DESCRIPTION:
Get the name of the attribute.
RETURNS:
the name of the attribute and the length in n_length
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeElemTypeCode ------------------------------ }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemTypeCode(env:POCIEnv; err:POCIError; elem:POCITypeElem):OCITypeCode;cdecl;external ocilib name 'OCITypeElemTypeCode';
{$ELSE}
OCITypeElemTypeCode : function (env:POCIEnv; err:POCIError; elem:POCITypeElem):OCITypeCode;cdecl;
{$ENDIF}
{
NAME: OCITypeElemTypeCode - OCI Get an Attribute's TypeCode.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the type element descriptor in the object cache
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the typecode of an attribute's type.
RETURNS:
the typecode of the attribute's type. If this is a scalar type, the
typecode sufficiently describes the scalar type and no further calls
need to be made. Valid scalar types include: OCI_TYPECODE_SIGNED8,
OCI_TYPECODE_UNSIGNED8, OCI_TYPECODE_SIGNED16, OCI_TYPECODE_UNSIGNED16,
OCI_TYPECODE_SIGNED32, OCI_TYPECODE_UNSIGNED32, OCI_TYPECODE_REAL,
OCI_TYPECODE_DOUBLE, OCI_TYPECODE_DATE,
OCI_TYPECODE_MLSLABEL, OROTCOID, OCI_TYPECODE_OCTET, or OROTCLOB.
This function converts the CREF (stored in the attribute) into a
typecode.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeElemType --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemType(env:POCIEnv; err:POCIError; elem:POCITypeElem; var elem_tdo:POCIType):sword;cdecl;external ocilib name 'OCITypeElemType';
{$ELSE}
OCITypeElemType : function (env:POCIEnv; err:POCIError; elem:POCITypeElem; var elem_tdo:POCIType):sword;cdecl;
{$ENDIF}
{
PARAMETERS
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the type element descriptor in the object cache
elem_tdo (OUT) - If the function completes successfully, 'elem_tdo'
points to the type descriptor (in the object cache) of the type of
the element.
REQUIRES
1) All type accessors require that the type be pinned before calling
any accessor. This can be done by calling 'OCITypeByName()'.
2) if 'elem' is not null, it must point to a valid type element descriptor
in the object cache.
DESCRIPTION
Get the type tdo of the type of this element.
RETURNS
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the parameters is null.
NOTES
The type must be unpinned when the accessed information is no
longer needed. This can be done by calling 'OCIObjectUnpin()'.
}
{------------------------- OCITypeElemFlags ------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemFlags(env:POCIEnv; err:POCIError; elem:POCITypeElem):ub4;cdecl;external ocilib name 'OCITypeElemFlags';
{$ELSE}
OCITypeElemFlags : function (env:POCIEnv; err:POCIError; elem:POCITypeElem):ub4;cdecl;
{$ENDIF}
{
NAME: OCITypeElemFlags - OCI Get a Elem's FLags
(inline, constant, virtual, constructor,
destructor).
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the type element descriptor in the object cache
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the flags of a type element (attribute, parameter).
RETURNS:
The flags of the type element.
NOTES:
The flag bits are not externally documented. Use only the macros
in the last section (ie. OCI_TYPEPARAM_IS_REQUIRED, and
OCI_TYPEELEM_IS_REF) to test for them only. The type must be unpinned
when the accessed information is no longer needed.
}
{------------------------ OCITypeElemNumPrec ------------------------------ }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemNumPrec(env:POCIEnv; err:POCIError; elem:POCITypeElem):ub1;cdecl;external ocilib name 'OCITypeElemNumPrec';
{$ELSE}
OCITypeElemNumPrec : function (env:POCIEnv; err:POCIError; elem:POCITypeElem):ub1;cdecl;
{$ENDIF}
{
NAME: OCITypeElemNumPrec - Get a Number's Precision. This includes float,
decimal, real, double, and oracle number.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the type element descriptor in the object cache
REQUIRES:
All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the precision of a float, decimal, long, unsigned long, real,
double, or Oracle number type.
RETURNS:
the precision of the float, decimal, long, unsigned long, real, double,
or Oracle number
}
{------------------------- OCITypeElemNumScale ----------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemNumScale(env:POCIEnv; err:POCIError; elem:POCITypeElem):sb1;cdecl;external ocilib name 'OCITypeElemNumScale';
{$ELSE}
OCITypeElemNumScale : function (env:POCIEnv; err:POCIError; elem:POCITypeElem):sb1;cdecl;
{$ENDIF}
{
NAME: OCITypeElemNumScale - Get a decimal or oracle Number's Scale
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the type element descriptor in the object cache
REQUIRES:
All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the scale of a decimal, or Oracle number type.
RETURNS:
the scale of the decimal, or Oracle number
}
{------------------------ OCITypeElemLength ------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemLength(env:POCIEnv; err:POCIError; elem:POCITypeElem):ub4;cdecl;external ocilib name 'OCITypeElemLength';
{$ELSE}
OCITypeElemLength : function (env:POCIEnv; err:POCIError; elem:POCITypeElem):ub4;cdecl;
{$ENDIF}
{
NAME: OCITypeElemLength - Get a raw, fixed or variable length String's
length in bytes.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the type element descriptor in the object cache
REQUIRES:
All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the length of a raw, fixed or variable length string type.
RETURNS:
length of the raw, fixed or variable length string
}
{----------------------- OCITypeElemCharSetID ----------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemCharSetID(env:POCIEnv; err:POCIError; elem:POCITypeElem):ub2;cdecl;external ocilib name 'OCITypeElemCharSetID';
{$ELSE}
OCITypeElemCharSetID : function (env:POCIEnv; err:POCIError; elem:POCITypeElem):ub2;cdecl;
{$ENDIF}
{
NAME: OCITypeElemCharSetID - Get a fixed or variable length String's
character set ID
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the type element descriptor in the object cache
REQUIRES:
All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the character set ID of a fixed or variable length string type.
RETURNS:
character set ID of the fixed or variable length string
}
{---------------------- OCITypeElemCharSetForm ---------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemCharSetForm(env:POCIEnv; err:POCIError; elem:POCITypeElem):ub2;cdecl;external ocilib name 'OCITypeElemCharSetForm';
{$ELSE}
OCITypeElemCharSetForm : function (env:POCIEnv; err:POCIError; elem:POCITypeElem):ub2;cdecl;
{$ENDIF}
{
NAME: OCITypeElemCharSetForm - Get a fixed or variable length String's
character set specification form.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the attribute information in the object cache
REQUIRES:
All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the character form of a fixed or variable length string type.
The character form is an enumerated value that can be one of the
4 values below:
SQLCS_IMPLICIT for CHAR, VARCHAR2, CLOB w/o a specified set
SQLCS_NCHAR for NCHAR, NCHAR VARYING, NCLOB
SQLCS_EXPLICIT for CHAR, etc, with "CHARACTER SET ..." syntax
SQLCS_FLEXIBLE for PL/SQL "flexible" parameters
RETURNS:
character form of the fixed or variable string
}
{--------------------- OCITypeElemParameterizedType ------------------------ }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemParameterizedType(env:POCIEnv; err:POCIError; elem:POCITypeElem; var type_stored:POCIType):sword;cdecl;external ocilib name 'OCITypeElemParameterizedType';
{$ELSE}
OCITypeElemParameterizedType : function (env:POCIEnv; err:POCIError; elem:POCITypeElem; var type_stored:POCIType):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeElemParameterizedType
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the type element descriptor in the object cache
type_stored (OUT) - If the function completes successfully,
and the parameterized type is complex, 'type_stored' is NULL.
Otherwise, 'type_stored' points to the type descriptor (in the
object cache) of the type that is stored in the parameterized
type. The caller must allocate space for the OCIType*
before calling this routine and must not write into the space.
REQUIRES:
All input parameters must be valid.
DESCRIPTION:
Get a descriptor to the parameter type of a parameterized type.
Parameterized types are types of the form:
REF T
VARRAY (n) OF T
etc, where T is the parameter in the parameterized type.
Additionally is_ref is set if the parameter is a PTR or REF.
For example, it is set for REF T or VARRAY(n) OF REF T.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the parameters is null.
2) 'type_stored' is not NULL but points to NULL data.
NOTES:
Complex parameterized types will be in a future release (once
typedefs are supported. When setting the parameterized type
information, the user must typedef the contents if it's a
complex parameterized type. Ex. for varray<varray<car>>, use
'typedef varray<car> varcar' and then use varray<varcar>.
}
{----------------------- OCITypeElemExtTypeCode ---------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemExtTypeCode(env:POCIEnv; err:POCIError; elem:POCITypeElem):OCITypeCode;cdecl;external ocilib name 'OCITypeElemExtTypeCode';
{$ELSE}
OCITypeElemExtTypeCode : function (env:POCIEnv; err:POCIError; elem:POCITypeElem):OCITypeCode;cdecl;
{$ENDIF}
{
NAME: OCITypeElemExtTypeCode - OCI Get an element's SQLT constant.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the type element descriptor in the object cache
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the internal Oracle typecode associated with an attribute's type.
This is the actual typecode for the attribute when it gets mapped
to a column in the Oracle database.
RETURNS:
The Oracle typecode associated with the attribute's type.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{-------------------------------------------------------------------------- }
{ ATTRIBUTE ACCESSORS }
{-------------------------------------------------------------------------- }
{------------------------ OCITypeAttrByName ------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeAttrByName(env:POCIEnv; err:POCIError; tdo:POCIType; name:Poratext; n_length:ub4;
var elem:POCITypeElem):sword;cdecl;external ocilib name 'OCITypeAttrByName';
{$ELSE}
OCITypeAttrByName : function (env:POCIEnv; err:POCIError; tdo:POCIType; name:Poratext; n_length:ub4;
var elem:POCITypeElem):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeAttrByName - OCI Get an Attribute By Name.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
name (IN) - the attribute's name
n_length (IN) - length (in bytes) of the 'name' parameter
elem (OUT) - If this function completes successfully, 'elem' points to
the selected type element descriptor pertaining to the
attributein the object cache.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) if 'tdo' is not null, it must point to a valid type descriptor
in the object cache.
DESCRIPTION:
Get an attribute given its name.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) the type does not contain an attribute with the input 'name'.
3) 'name' is NULL.
NOTES:
The type descriptor, 'tdo', must be unpinned when the accessed
information is no longer needed.
Schema and type names are CASE-SENSITIVE. If they have been created
via SQL, you need to use uppercase names.
}
{------------------------ OCITypeAttrNext --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeAttrNext(env:POCIEnv; err:POCIError; iterator_ort:POCITypeIter; var elem:POCITypeElem):sword;cdecl;external ocilib name 'OCITypeAttrNext';
{$ELSE}
OCITypeAttrNext : function (env:POCIEnv; err:POCIError; iterator_ort:POCITypeIter; var elem:POCITypeElem):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeAttrNext - OCI Get an Attribute By Iteration.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
iterator_ort (IN/OUT) - iterator for retrieving the next attribute;
see OCITypeIterNew() to initialize iterator.
elem (OUT) - If this function completes successfully, 'elem' points to
the selected type element descriptor pertaining to the
attributein the object cache.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) if 'tdo' is not null, it must point to a valid type descriptor
in the object cache.
DESCRIPTION:
Iterate to the next attribute to retrieve.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_NO_DATA if there are no more attributes to iterate on; use
OCITypeIterSet() to reset the iterator if necessary.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{-------------------------------------------------------------------------- }
{ COLLECTION ACCESSORS }
{-------------------------------------------------------------------------- }
{------------------------ OCITypeCollElem --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeCollElem(env:POCIEnv; err:POCIError; tdo:POCIType; var element:POCITypeElem):sword;cdecl;external ocilib name 'OCITypeCollElem';
{$ELSE}
OCITypeCollElem : function (env:POCIEnv; err:POCIError; tdo:POCIType; var element:POCITypeElem):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeCollElem
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to the type descriptor in the object cache
element (IN/OUT) - If the function completes successfully, this
points to the descriptor for the collection's element.
It is stored in the same format as an ADT attribute's
descriptor.
If *element is NULL, OCITypeCollElem() implicitly allocates a
new instance of OCITypeElem in the object cache. This instance
will be
automatically freed at the end of the session, and does not have
to be freed explicitly.
If *element is not NULL, OCITypeCollElem() assumes that it
points to a valid OCITypeElem descriptor and will copy the
results into it.
REQUIRES:
All input parameters must be valid.
DESCRIPTION:
Get a pointer to the descriptor (OCITypeElem) of the element of an
array or the rowtype of a nested table.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the parameters is null.
2) the type TDO does not point to a valid collection's type.
NOTES:
Complex parameterized types will be in a future release (once
typedefs are supported. When setting the parameterized type
information, the user must typedef the contents if it's a
complex parameterized type. Ex. for varray<varray<car>>, use
'typedef varray<car> varcar' and then use varray<varcar>.
}
{------------------------ OCITypeCollSize --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeCollSize(env:POCIEnv; err:POCIError; tdo:POCIType; num_elems:Pub4):sword;cdecl;external ocilib name 'OCITypeCollSize';
{$ELSE}
OCITypeCollSize : function (env:POCIEnv; err:POCIError; tdo:POCIType; num_elems:Pub4):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeCollSize - OCI Get a Collection's Number of Elements.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to the type descriptor in the object cache
num_elems (OUT) - number of elements in collection
REQUIRES:
All input parameters must be valid. tdo points to an array type
defined as a domain.
DESCRIPTION:
Get the number of elements stored in a fixed array or the maximum
number of elements in a variable array.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the parameters is null.
2) 'tdo' does not point to a domain with a collection type.
NOTES:
Complex parameterized types will be in a future release (once
typedefs are supported. When setting the parameterized type
information, the user must typedef the contents if it's a
complex parameterized type. Ex. for varray<varray<car>>, use
'typedef varray<car> varcar' and then use varray<varcar>.
}
{------------------------ OCITypeCollExtTypeCode --------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeCollExtTypeCode(env:POCIEnv; err:POCIError; tdo:POCIType; sqt_code:POCITypeCode):sword;cdecl;external ocilib name 'OCITypeCollExtTypeCode';
{$ELSE}
OCITypeCollExtTypeCode : function (env:POCIEnv; err:POCIError; tdo:POCIType; sqt_code:POCITypeCode):sword;cdecl;
{$ENDIF}
{
NAME: ortcsqt - OCI Get a Collection element's DTY constant.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to the type descriptor in the object cache
sqt_code (OUT) - SQLT code of type element.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the SQLT constant associated with an domain's element type.
The SQLT codes are defined in <sqldef.h> and are needed for OCI/OOCI
use.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the parameters is null.
2) 'tdo' does not point to a domain with a collection type.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{-------------------------------------------------------------------------- }
{ METHOD ACCESSORS }
{-------------------------------------------------------------------------- }
{------------------------- OCITypeMethodOverload -------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeMethodOverload(env:POCIEnv; err:POCIError; tdo:POCIType; method_name:Poratext; m_length:ub4):ub4;cdecl;external ocilib name 'OCITypeMethodOverload';
{$ELSE}
OCITypeMethodOverload : function (env:POCIEnv; err:POCIError; tdo:POCIType; method_name:Poratext; m_length:ub4):ub4;cdecl;
{$ENDIF}
{
NAME: OCITypeMethodOverload - OCI Get type's Number of Overloaded names
for the given method name.
PARAMETERS:
gp (IN/OUT) - pga environment handle. Any errors are recorded here.
tdo (IN) - pointer to to the type descriptor in the object cache
method_name (IN) - the method's name
m_length (IN) - length (in bytes) of the 'method_name' parameter
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) if 'tdo' is not null, it must point to a valid type descriptor
in the object cache.
DESCRIPTION:
Overloading of methods implies that more than one method may have the
same method name. This routine returns the number of methods that
have the given method name. If there are no methods with the input
method name, 'num_methods' is 0. The caller uses this information when
allocating space for the array of mdo and/or position pointers before
calling 'OCITypeMethodByName()' or 'ortgmps()'.
RETURNS:
The number of methods with the given name. 0 if none contains the
name.
NOTES:
Schema and type names are CASE-SENSITIVE. If they have been created
via SQL, you need to use uppercase names.
}
{------------------------ OCITypeMethodByName ------------------------------ }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeMethodByName(env:POCIEnv; err:POCIError; tdo:POCIType; method_name:Poratext; m_length:ub4;
var mdos:POCITypeMethod):sword;cdecl;external ocilib name 'OCITypeMethodByName';
{$ELSE}
OCITypeMethodByName : function (env:POCIEnv; err:POCIError; tdo:POCIType; method_name:Poratext; m_length:ub4;
var mdos:POCITypeMethod):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeMethodByName - OCI Get one or more Methods with Name.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
method_name (IN) - the methods' name
m_length (IN) - length (in bytes) of the 'name' parameter
mdos (OUT) - If this function completes successfully, 'mdos' points to
the selected methods in the object cache. The caller must
allocate space for the array of OCITypeMethod pointers before
calling this routine and must not write into the space.
The number of OCITypeMethod pointers that will be returned can
be obtained by calling 'OCITypeMethodOverload()'.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) if 'tdo' is not null, it must point to a valid type descriptor
in the object cache.
DESCRIPTION:
Get one or more methods given the name.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) No methods in type has name 'name'.
3) 'mdos' is not NULL but points to NULL data.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
Schema and type names are CASE-SENSITIVE. If they have been created
via SQL, you need to use uppercase names.
}
{------------------------ OCITypeMethodNext -------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeMethodNext(env:POCIEnv; err:POCIError; iterator_ort:POCITypeIter; var mdo:POCITypeMethod):sword;cdecl;external ocilib name 'OCITypeMethodNext';
{$ELSE}
OCITypeMethodNext : function (env:POCIEnv; err:POCIError; iterator_ort:POCITypeIter; var mdo:POCITypeMethod):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeMethodNext - OCI Get a Method By Iteration.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
iterator_ort (IN/OUT) - iterator for retrieving the next method;
see OCITypeIterNew() to set iterator.
mdo (OUT) - If this function completes successfully, 'mdo' points to
the selected method descriptor in the object cache. Positions
start at 1. The caller must allocate space for the
OCITypeMethod* before calling this routine and must not write
nto the space.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) if 'tdo' is not null, it must point to a valid type descriptor
in the object cache.
DESCRIPTION:
Iterate to the next method to retrieve.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_NO_DATA if there are no more attributes to iterate on; use
OCITypeIterSet() to reset the iterator if necessary.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) 'mdo' is not NULL but points to NULL data.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeMethodName -------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeMethodName(env:POCIEnv; err:POCIError; mdo:POCITypeMethod; n_length:Pub4):Poratext;cdecl;external ocilib name 'OCITypeMethodName';
{$ELSE}
OCITypeMethodName : function (env:POCIEnv; err:POCIError; mdo:POCITypeMethod; n_length:Pub4):Poratext;cdecl;
{$ENDIF}
{
NAME: OCITypeMethodName - OCI Get a Method's NaMe.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
mdo (IN) - pointer to the method descriptor in the object cache
n_length (OUT) - length (in bytes) of the 'name' parameter. The caller
must allocate space for the ub4 before calling this routine.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the (non-unique) real name of the method.
RETURNS:
the non-unique name of the method or NULL if there is an error.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeMethodEncap ------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeMethodEncap(env:POCIEnv; err:POCIError; mdo:POCITypeMethod):OCITypeEncap;cdecl;external ocilib name 'OCITypeMethodName';
{$ELSE}
OCITypeMethodEncap : function (env:POCIEnv; err:POCIError; mdo:POCITypeMethod):OCITypeEncap;cdecl;
{$ENDIF}
{
NAME: OCITypeMethodEncap - Get a Method's ENcapsulation (private/public).
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
mdo (IN) - pointer to the method descriptor in the object cache
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the encapsulation (private, or public) of a method.
RETURNS:
the encapsulation (private, or public) of the method
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeMethodFlags ------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeMethodFlags (env:POCIEnv; err:POCIError; mdo:POCITypeMethod):OCITypeMethodFlag;cdecl;external ocilib name 'OCITypeMethodEncap';
{$ELSE}
OCITypeMethodFlags : function (env:POCIEnv; err:POCIError; mdo:POCITypeMethod):OCITypeMethodFlag;cdecl;
{$ENDIF}
{
NAME: OCITypeMethodFlags - OCI Get a Method's FLags
(inline, constant, virtual, constructor,
destructor).
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
mdo (IN) - pointer to the method descriptor in the object cache
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the flags (inline, constant, virutal, constructor, destructor) of
a method.
RETURNS:
the flags (inline, constant, virutal, constructor, destructor) of
the method
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeMethodMap --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeMethodMap(env:POCIEnv; err:POCIError; tdo:POCIType; var mdo:POCITypeMethod):sword;cdecl;external ocilib name 'OCITypeMethodMap';
{$ELSE}
OCITypeMethodMap : function (env:POCIEnv; err:POCIError; tdo:POCIType; var mdo:POCITypeMethod):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeMethodMap - OCI Get the Method's MAP function.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
mdo (OUT) - If this function completes successfully, and there is a
map function for this type, 'mdo' points to the selected method
descriptor in the object cache. Otherwise, 'mdo' is null.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All required input parameters must not be NULL and must be valid.
DESCRIPTION:
A type may have only one map function. 'OCITypeMethodMap()' finds
this function, if it exists, and returns a reference and a pointer to
the method descriptor in the object cache. If the type does not have a
map (relative ordering) function, then 'mdo_ref' and 'mdo' are set
to null and an error is returned.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
the type does not contain a map function.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeMethodOrder ------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeMethodOrder(env:POCIEnv; err:POCIError; tdo:POCIType; var mdo:POCITypeMethod):sword;cdecl;external ocilib name 'OCITypeMethodOrder';
{$ELSE}
OCITypeMethodOrder : function (env:POCIEnv; err:POCIError; tdo:POCIType; var mdo:POCITypeMethod):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeMethodOrder - OCI Get the Method's ORder function.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
tdo (IN) - pointer to to the type descriptor in the object cache
mdo (OUT) - If this function completes successfully, and there is a
map function for this type, 'mdo' points to the selected method
descriptor in the object cache. Otherwise, 'mdo' is null.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All required input parameters must not be NULL and must be valid.
DESCRIPTION:
A type may have only one ORder or MAP function. 'OCITypeMethodOrder()'
finds this function, if it exists, and returns a ref and a pointer
to the method descriptor in the object cache. If the type does not
have a map (relative ordering) function, then 'mdo_ref' and 'mdo' are
set to null and an error is returned.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
the type does not contain a map function.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeMethodParams ------------------------------ }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeMethodParams(env:POCIEnv; err:POCIError; mdo:POCITypeMethod):ub4;cdecl;external ocilib name 'OCITypeMethodParams';
{$ELSE}
OCITypeMethodParams : function (env:POCIEnv; err:POCIError; mdo:POCITypeMethod):ub4;cdecl;
{$ENDIF}
{
NAME: OCITypeMethodParams - OCI Get a Method's Number of Parameters.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
mdo (IN) - pointer to the method descriptor in the object cache
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the number of parameters in a method.
RETURNS:
the number of parameters in the method
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{-------------------------------------------------------------------------- }
{ RESULT ACCESSORS }
{-------------------------------------------------------------------------- }
{-------------------------- OCITypeResult --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeResult(env:POCIEnv; err:POCIError; mdo:POCITypeMethod; var elem:POCITypeElem):sword;cdecl;external ocilib name 'OCITypeResult';
{$ELSE}
OCITypeResult : function (env:POCIEnv; err:POCIError; mdo:POCITypeMethod; var elem:POCITypeElem):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeResult - OCI Get a method's result type descriptor.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
mdo (IN) - pointer to the method descriptor in the object cache
elem (OUT) - If this function completes successfully, 'rdo' points to
the selected result (parameter) descriptor in the object cache.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) 'elem' MUST be the address of an OCITypeElem pointer.
DESCRIPTION:
Get the result of a method.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) method returns no results.
NOTES:
The method must be unpinned when the accessed information is no
longer needed.
}
{-------------------------------------------------------------------------- }
{ PARAMETER ACCESSORS }
{-------------------------------------------------------------------------- }
{------------------------ OCITypeParamByPos ------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeParamByPos(env:POCIEnv; err:POCIError; mdo:POCITypeMethod; position:ub4; var elem:POCITypeElem):sword;cdecl;external ocilib name 'OCITypeParamByPos';
{$ELSE}
OCITypeParamByPos : function (env:POCIEnv; err:POCIError; mdo:POCITypeMethod; position:ub4; var elem:POCITypeElem):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeParamByPos - OCI Get a Parameter in a method By Position.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
mdo (IN) - pointer to the method descriptor in the object cache
position (IN) - the parameter's position. Positions start at 1.
elem (OUT) - If this function completes successfully, 'elem' points to
the selected parameter descriptor in the object cache.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
DESCRIPTION:
Get a parameter given its position in the method. Positions start
at 1.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) 'position' is not >= 1 and <= the number of parameters in the
method.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeParamByName ------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeParamByName(env:POCIEnv; err:POCIError; mdo:POCITypeMethod; name:Poratext; n_length:ub4;
var elem:POCITypeElem):sword;cdecl;external ocilib name 'OCITypeParamByName';
{$ELSE}
OCITypeParamByName : function (env:POCIEnv; err:POCIError; mdo:POCITypeMethod; name:Poratext; n_length:ub4;
var elem:POCITypeElem):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeParamByName - OCI Get a Parameter in a method By Name.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
mdo (IN) - pointer to the method descriptor in the object cache
name (IN) - the parameter's name
n_length (IN) - length (in bytes) of the 'name' parameter
elem (OUT) - If this function completes successfully, 'elem' points to
the selected parameter descriptor in the object cache.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) if 'mdo' is not null, it must point to a valid method descriptor
in the object cache.
DESCRIPTION:
Get a parameter given its name.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the required parameters is null.
2) the method does not contain a parameter with the input 'name'.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeParamPos --------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeParamPos(env:POCIEnv; err:POCIError; mdo:POCITypeMethod; name:Poratext; n_length:ub4;
position:Pub4; var elem:POCITypeElem):sword;cdecl;external ocilib name 'OCITypeParamPos';
{$ELSE}
OCITypeParamPos : function (env:POCIEnv; err:POCIError; mdo:POCITypeMethod; name:Poratext; n_length:ub4;
position:Pub4; var elem:POCITypeElem):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeParamPos - OCI Get a parameter's position in a method
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
mdo (IN) - pointer to the method descriptor in the object cache
name (IN) - the parameter's name
n_length (IN) - length (in bytes) of the 'name' parameter
position (OUT) - If this function completes successfully, 'position'
points to the position of the parameter in the method starting
at position 1. position MUST point to space for a ub4.
elem (OUT) - If this function completes successfully, and
the input 'elem' is not NULL, 'elem' points to the selected
parameter descriptor in the object cache.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) if 'mdo' is not null, it must point to a valid method descriptor
in the object cache.
DESCRIPTION:
Get the position of a parameter in a method. Positions start at 1.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the parameters is null.
2) the method does not contain a parameter with the input 'name'.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------ OCITypeParamElemMode ----------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemParamMode(env:POCIEnv; err:POCIError; elem:POCITypeElem):OCITypeParamMode;cdecl;external ocilib name 'OCITypeElemParamMode';
{$ELSE}
OCITypeElemParamMode : function (env:POCIEnv; err:POCIError; elem:POCITypeElem):OCITypeParamMode;cdecl;
{$ENDIF}
{
NAME: OCITypeElemParamMode - OCI Get a parameter's mode
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the parameter descriptor in the object cache
(represented by an OCITypeElem)
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the mode (in, out, or in/out) of the parameter.
RETURNS:
the mode (in, out, or in/out) of the parameter
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{------------------------- OCITypeElemDefaultValue ------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeElemDefaultValue(env:POCIEnv; err:POCIError; elem:POCITypeElem; d_v_length:Pub4):Poratext;cdecl;external ocilib name 'OCITypeElemDefaultValue';
{$ELSE}
OCITypeElemDefaultValue : function (env:POCIEnv; err:POCIError; elem:POCITypeElem; d_v_length:Pub4):Poratext;cdecl;
{$ENDIF}
{
NAME: OCITypeElemDefaultValue - OCI Get the element's Default Value.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
elem (IN) - pointer to the parameter descriptor in the object cache
(represented by an OCITypeElem)
d_v_length (OUT) - length (in bytes) of the returned default value.
The caller must allocate space for the ub4 before calling this
routine.
REQUIRES:
1) All type accessors require that the type be pinned before calling
any accessor.
2) All input parameters must not be NULL and must be valid.
DESCRIPTION:
Get the default value in text form (PL/SQL) of an element. For V8.0,
this only makes sense for a method parameter.
RETURNS:
The default value (text) of the parameter.
NOTES:
The type must be unpinned when the accessed information is no
longer needed.
}
{-------------------------------------------------------------------------- }
{ TYPE VERSION TABLE }
{-------------------------------------------------------------------------- }
{ For V8.0, the type version table is meant to be an internal data structure
only for Oracle clients for type version maintanence purposes. A more
general version of the API may be made public in subsequent releases. }
{--------------------------- OCITypeVTInit -------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeVTInit(env:POCIEnv; err:POCIError):sword;cdecl;external ocilib name 'OCITypeVTInit';
{$ELSE}
OCITypeVTInit : function (env:POCIEnv; err:POCIError):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeVTInit - OCI type Version table INItialize
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
REQUIRES:
none
DESCRIPTION:
Allocate space for and initialize the type version table and the type
version table's index.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if internal errors occurrs during initialization.
}
{--------------------------- OCITypeVTInsert ------------------------------- }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeVTInsert(env:POCIEnv; err:POCIError; schema_name:Poratext; s_n_length:ub4; type_name:Poratext;
t_n_length:ub4; user_version:Poratext; u_v_length:ub4):sword;cdecl;external ocilib name 'OCITypeVTInsert';
{$ELSE}
OCITypeVTInsert : function (env:POCIEnv; err:POCIError; schema_name:Poratext; s_n_length:ub4; type_name:Poratext;
t_n_length:ub4; user_version:Poratext; u_v_length:ub4):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeVTInsert - OCI type Version table INSert entry.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
schema_name (IN, optional) - name of schema associated with the
type. By default, the user's schema name is used.
s_n_length (IN) - length of the 'schema_name' parameter
type_name (IN) - type name to insert
t_n_length (IN) - length (in bytes) of the 'type_name' parameter
user_version (IN) - user readable version of the type
u_v_length (IN) - length (in bytes) of the 'user_version' parameter
REQUIRES:
none
DESCRIPTION:
Insert an entry into the type version table and the type version
table's index. The entry's type name and user readable version
fields are updated with the input values. All other fields are
initialized to null.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the parameters is invalid.
2) an entry for 'type_name' has already been registered in the
type version table.
}
{------------------------------ OCITypeVTSelect ---------------------------- }
{ OCITypeVTSelect - OCI type VERSion table SELECT entry }
{ ** OBSOLETE ** }
{$IFNDEF LinkDynamically}
function OCITypeVTSelect(env:POCIEnv; err:POCIError; schema_name:Poratext; s_n_length:ub4; type_name:Poratext;
t_n_length:ub4; var user_version:Poratext; u_v_length:Pub4; version:Pub2):sword;cdecl;external ocilib name 'OCITypeVTSelect';
{$ELSE}
OCITypeVTSelect : function (env:POCIEnv; err:POCIError; schema_name:Poratext; s_n_length:ub4; type_name:Poratext;
t_n_length:ub4; var user_version:Poratext; u_v_length:Pub4; version:Pub2):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeVTSelect - OCI type Version table SELect entry.
PARAMETERS:
env (IN/OUT) - OCI environment handle initialized in object mode
err (IN/OUT) - error handle. If there is an error, it is
recorded in 'err' and this function returns OCI_ERROR.
The error recorded in 'err' can be retrieved by calling
OCIErrorGet().
schema_name (IN, optional) - name of schema associated with the
type. By default, the user's schema name is used.
s_n_length (IN) - length of the 'schema_name' parameter
type_name (IN) - type name to select
t_n_length (IN) - length (in bytes) of the 'type_name' parameter
user_version (OUT, optional) - pointer to user readable version of the
type
u_v_length (OUT, optional) - length (in bytes) of the 'user_version'
parameter
version (OUT, optional) - internal type version
REQUIRES:
All input parameters must not be NULL and must be valid.
DESCRIPTION:
Select an entry in the type version table by name.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is null.
OCI_ERROR if
1) any of the parameters is invalid.
2) an entry with 'type_name' does not exist.
}
{ Compatibility function - following function prototype retained for
compatibility only }
{$IFNDEF LinkDynamically}
function ortgcty(env:POCIEnv; err:POCIError; coll_tdo:POCIType; var collelem_tdo:POCIType):sword;cdecl;external ocilib name 'ortgcty';
{$ELSE}
ortgcty : function (env:POCIEnv; err:POCIError; coll_tdo:POCIType; var collelem_tdo:POCIType):sword;cdecl;
{$ENDIF}
{--------------------------------------------------------------------------- }
{ Transient Type Construction functions }
{--------------------------------------------------------------------------- }
{$IFNDEF LinkDynamically}
function OCITypeBeginCreate(svchp:POCISvcCtx; errhp:POCIError; tc:OCITypeCode; dur:OCIDuration; var _type:POCIType):sword;cdecl;external ocilib name 'OCITypeBeginCreate';
{$ELSE}
OCITypeBeginCreate : function (svchp:POCISvcCtx; errhp:POCIError; tc:OCITypeCode; dur:OCIDuration; var _type:POCIType):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeBeginCreate - OCI Type Begin Creation of a transient type.
REMARKS
Begins the construction process for a transient type. The type will be
anonymous (no name). To create a persistent named type, the CREATE TYPE
statement should be used from SQL. Transient types have no identity.
They are pure values.
PARAMETERS:
svchp (IN) - The OCI Service Context.
errhp (IN/OUT) - The OCI error handle. If there is an error, it is
recorded in errhp and this function returns
OCI_ERROR. Diagnostic information can be obtained by
calling OCIErrorGet().
tc - The TypeCode for the type. The Typecode could
correspond to a User Defined Type or a Built-in type.
Currently, the permissible values for User Defined
Types are OCI_TYPECODE_OBJECT for an Object Type
(structured), OCI_TYPECODE_VARRAY for a VARRAY
collection type or OCI_TYPECODE_TABLE for a nested
table collection type. For Object types,
OCITypeAddAttr() needs to be called to add each of
the attribute types. For Collection types,
OCITypeSetCollection() needs to be called.
Subsequently, OCITypeEndCreate() needs to be called
to finish the creation process.
The permissible values for Built-in type codes are
specified in the user manual. Additional information
on built-ins if any (like precision, scale for
numbers, character set info for VARCHAR2s etc.) must
be set with a subsequent call to OCITypeSetBuiltin().
Subsequently OCITypeEndCreate() needs to be called
to finish the creation process.
dur - The allocation duration for the Type. Could be a
predefined or a user defined duration.
type(OUT) - The OCIType (Type Descriptor) that is being
constructed.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_ERROR on error.
}
{$IFNDEF LinkDynamically}
function OCITypeSetCollection(svchp:POCISvcCtx; errhp:POCIError; _type:POCIType; collelem_info:POCIParam; coll_count:ub4):sword;cdecl;external ocilib name 'OCITypeSetCollection';
{$ELSE}
OCITypeSetCollection : function (svchp:POCISvcCtx; errhp:POCIError; _type:POCIType; collelem_info:POCIParam; coll_count:ub4):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeSetCollection - OCI Type Set Collection information
REMARKS :
Set Collection type information. This call can be called only if the
OCIType has been constructed with a collection typecode.
PARAMETERS:
svchp (IN) - The OCI Service Context.
errhp (IN/OUT) - The OCI error handle. If there is an error, it is
recorded in errhp and this function returns
OCI_ERROR. Diagnostic information can be obtained by
calling OCIErrorGet().
type(IN OUT) - The OCIType (Type Descriptor) that is being
constructed.
collelem_info - collelem_info provides information on the collection
element. It is obtained by allocating an OCIParam
(parameter handle) and setting type information in
the OCIParam using OCIAttrSet() calls.
coll_count - The count of elements in the collection. Pass 0 for
a nested table (unbounded).
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_ERROR on error.
}
{$IFNDEF LinkDynamically}
function OCITypeSetBuiltin(svchp:POCISvcCtx; errhp:POCIError; _type:POCIType; builtin_info:POCIParam):sword;cdecl;external ocilib name 'OCITypeSetBuiltin';
{$ELSE}
OCITypeSetBuiltin : function (svchp:POCISvcCtx; errhp:POCIError; _type:POCIType; builtin_info:POCIParam):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeSetBuiltin - OCI Type Set Builtin information.
REMARKS:
Set Built-in type information. This call can be called only if the
OCIType has been constructed with a built-in typecode
(OCI_TYPECODE_NUMBER etc.).
PARAMETERS:
svchp (IN) - The OCI Service Context.
errhp (IN/OUT) - The OCI error handle. If there is an error, it is
recorded in errhp and this function returns
OCI_ERROR. Diagnostic information can be obtained by
calling OCIErrorGet().
type(IN OUT) - The OCIType (Type Descriptor) that is being
constructed.
builtin_info - builtin_info provides information on the built-in
(like precision, scale, charater set etc.). It is
obtained by allocating an OCIParam (parameter handle)
and setting type information in the OCIParam using
OCIAttrSet() calls.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_ERROR on error.
}
{$IFNDEF LinkDynamically}
function OCITypeAddAttr(svchp:POCISvcCtx; errhp:POCIError; _type:POCIType; a_name:Poratext; a_length:ub4;
attr_info:POCIParam):sword;cdecl;external ocilib name 'OCITypeAddAttr';
{$ELSE}
OCITypeAddAttr : function (svchp:POCISvcCtx; errhp:POCIError; _type:POCIType; a_name:Poratext; a_length:ub4;
attr_info:POCIParam):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeAddAttr - OCI Type Add Attribute to an Object Type.
REMARKS:
Adds an attribute to an Object type (that was constructed earlier with
typecode OCI_TYPECODE_OBJECT).
PARAMETERS:
svchp (IN) - The OCI Service Context
errhp (IN/OUT) - The OCI error handle. If there is an error, it is
recorded in errhp and this function returns
OCI_ERROR. Diagnostic information can be obtained by
calling OCIErrorGet().
type (IN/OUT) - The Type description that is being constructed.
a_name(IN) - Optional. gives the name of the attribute.
a_length - Optional. gives length of attribute name.
attr_info - Information on the attribute. It is obtained by
allocating an OCIParam (parameter handle) and setting
type information in the OCIParam using OCIAttrSet()
calls.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_ERROR on error.
}
{$IFNDEF LinkDynamically}
function OCITypeEndCreate(svchp:POCISvcCtx; errhp:POCIError; _type:POCIType):sword;cdecl;external ocilib name 'OCITypeEndCreate';
{$ELSE}
OCITypeEndCreate : function (svchp:POCISvcCtx; errhp:POCIError; _type:POCIType):sword;cdecl;
{$ENDIF}
{
NAME: OCITypeEndCreate - OCI Type End Creation
REMARKS:
Finishes construction of a type description.Subsequently, only access
will be allowed.
PARAMETERS:
svchp (IN) - The OCI Service Context
errhp (IN/OUT) - The OCI error handle. If there is an error, it is
recorded in errhp and this function returns
OCI_ERROR. Diagnostic information can be obtained by
calling OCIErrorGet().
type (IN/OUT) - The Type description that is being constructed.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_ERROR on error.
}
{========================= }
{ PUBLIC MACROS AND FLAGS }
{========================= }
{-------------------------------------------------------------------------- }
{ TYPE ELEMENT FLAGS }
{-------------------------------------------------------------------------- }
{ element is a REF }
const
OCI_TYPEELEM_REF = $8000;
{ parameter is required }
OCI_TYPEPARAM_REQUIRED = $0800;
{ macros to test flags }
// function OCI_TYPEELEM_IS_REF(elem_flag : longint) : longint;
// function OCI_TYPEPARAM_IS_REQUIRED(param_flag : longint) : longint;
{implementation
function OCI_TYPEELEM_IS_REF(elem_flag : longint) : longint;
begin
// OCI_TYPEELEM_IS_REF:=(elem_flag(@(OCI_TYPEELEM_REF)))<>0;
end;
function OCI_TYPEPARAM_IS_REQUIRED(param_flag : longint) : longint;
begin
// OCI_TYPEPARAM_IS_REQUIRED:=(param_flag(@(OCI_TYPEPARAM_REQUIRED)))<>0;
end;
end.}
Reference in New Issue View Git Blame Copy Permalink