root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/libraries/SQLAPI/include/ora_win/orl.h
mtollari 63d98e39cd Patch level : 12.0 no-patch 
Files correlati     : 
Commento            : 
- Creazione nuova cartella per contenere tutte le librerie esterne
- Aggiunta nuova libreria sqlapi per interfacciare campo a vari DB

git-svn-id: svn://10.65.10.50/branches/R_10_00@24149 c028cbd2-c16b-5b4b-a496-9718f37d4682
2017-10-26 09:07:39 +00:00

3634 lines
158 KiB
C
Raw Blame History

/* Copyright (c) 1993, 2006, Oracle. All rights reserved. */
/*
Author: Srinath Krishnaswamy
Date: 11/24/93
Source documents: "Functional Specification for C Language Mapping of
OTS Types, Object Management Subsystem", "Oracle C
Coding Standards version 2.2", and the header file
template
Rule sets: the generic and .h file rule sets
Quality status: not exited
Identification tag: [ one or more letters to identify the .h file ]
Revision code: 11/24/93
NAME
ORL - ORacle's external C Language interface to primitive OTS types
DESCRIPTION
This header file contains C langauge interface to the OTS primitive
types. The interface includes C mapping of OTS primitive types and
the prototype of the pre-defined operations on the primitive types.
***********************************************************************
*** NOTE: The OCI functions for objects requires the ***
*** application to be running in OBJECT mode. That is, during ***
*** process initialization OCIInitialize(), the mode ***
*** specified should be OBJECT mode. ***
** OCIInitialize(OCI_OBJECT, ..); ***
***********************************************************************
RELATED DOCUMENTS
[1] Krishnaswamy, Srinath and Nguyen, Tin A., "Functional Specification
for C Language Mapping of OTS Types, Object Management Subsystem",
March 1994.
[2] Nguyen, Tin A., "The Open Type System", Oracle Corporation,
February 1994.
[3] Klein, Jonathan D., "Large Field Management", Oracle Corporation,
October 1993.
PUBLIC FUNCTIONS
OCI - OCI functions to manipulate Oracle Number, float and decimal
ARITHMETIC
OCINumberInc - OCINumber INCrement (optimized)
OCINumberDec - OCINumber DECrement (optimized)
OCINumberAdd - OCINumber ADD numbers
OCINumberSub - OCINumber SUBtract numbers
OCINumberMul - OCINumber MULtiply numbers
OCINumberDiv - OCINumber DIVide numbers
OCINumberMod - OCINumber MODulo division
OCINumberIntPower - OCINumber integer PoWeR
OCINumberShift - OCINumber decimal ShiFT number
OCINumberNeg - OCINumber NEGate number
OCINumberAbs - OCINumber ABSolute value
OCINumberCeil - OCINumber CEiling of number
OCINumberFloor - OCINumber FLooR of number
OCINumberSqrt - OCINumber SQuare Root of number
OCINumberSign - OCINumber get SIGN of number
NATIVE TYPE CONVERSION
OCINumberToInt - OCINumber convert number TO machine-format Integer
OCINumberFromInt - OCINumber convert machine-format Integer TO Number
OCINumberToReal - OCINumber convert number TO machine-format Real
OCINumberToRealArray - OCINumber convert array of numbers TO
machine-format Real
OCINumberFromReal - OCINumber convert machine-format Real TO Number
TEXT STRING CONVERSION
OCINumberToText - OCINumber convert number TO String
OCINumberFromText - OCINumber convert String TO Number
COMPARISON
OCINumberCmp - OCINumber CoMPare numbers
OCINumberIsZero - OCINumber comparison with ZERo
OCINumberIsInt - OCINumber Is an Integer
ASSIGNMENT
OCINumberAssign - OCINumber ASsiGn number
OCINumberSetZero - OCINumber Set number to Zero value
OCINumberSetPi - OCINumber Set number to Pi
ROUNDING
OCINumberTrunc - OCINumber TRUncate an Oracle number
OCINumberRound - OCINumber ROUnd number
OCINumberPrec - OCINumber round to Precision digits
TRANSCENDENTAL
OCINumberSin - OCINumber SINe
OCINumberArcSin - OCINumber Arc SINe
OCINumberHypSin - OCINumber SiNe Hyperbolic
OCINumberCos - OCINumber COSine
OCINumberArcCos - OCINumber Arc COSine
OCINumberHypCos - OCINumber CoSine Hyperbolic
OCINumberTan - OCINumber TANgent
OCINumberArcTan - OCINumber Arc TANgent
OCINumberArcTan2 - OCINumber Arc TaNgent 2
OCINumberHypTan - OCINumber TaNgent Hyperbolic
OCINumberPower - OCINumber arbitrary Base EXponentiation
OCINumberExp - OCINumber EXPonentiation to base e
OCINumberLn - OCINumber Logarithm Natural
OCINumberLog - OCINumber LOGarithm to arbitrary base
OCIDate - OCI functions to manipulate OCI Date
OCIDateToExternal - OCIDate convert date to external form
OCIDateFromExternal - OCIDate convert external form of date into OCIDate
OCIDateAssign - OCIDate Assignment
OCIDateToText - OCIDate convert date TO String
OCIDateFromText - OCIDate convert String TO Date
OCIDateZoneToZone - OCIDate convert date from one time
Zone TO another Zone
OCIDateCompare - OCIDate CoMPare dates
OCIDateAddMonths - OCIDate ADd or subtract Months
OCIDateAddDays - OCIDate ADd or subtract Days
OCIDateLastDay - OCIDate get date of LaST day of month
OCIDateDaysBetween - OCIDate get number of days BeTWeen two dates
OCIDateNextDay - OCIDate get date of Next DaY
OCIDateCheck - OCIDate CHecK if the given date is valid
OCIDateSysDate - OCIDate get current SYStem date and time
OCIString - OCI String functions to manipulate Variable-length string
OCIStringAssign - OCIString Assign string to string
OCIStringAssignText - OCIString Assign Text string to string
OCIStringResize - OCIString ReSiZe string
OCIStringSize - OCIString get String Size
OCIStringPtr - OCIString get String PoinTeR
OCIStringAllocSize - OCIString get Allocated SiZe
OCIRaw - OCI Raw functions to manipulate variable-length raW
OCIRawAssignRaw - OCIRaw Assign Raw (of type OCIRaw*) to raw
(of type OCIRaw*)
OCIRawResize - OCIRaw Resize raw
OCIRawSize - OCIRaw get Raw Size
OCIRawPtr - OCIRaw get Raw data Pointer
OCIRawAllocSize - OCIRaw get Allocated Size
OCIColl - OCI Collection generic functions. These functions can be
used to manipulate both variable-length array (varray) and
nested table.
OCICollSize - OCIColl return current SIZe of the given collection
(in number of elements)
OCICollMax - OCIColl return the MAXimum number of elements in the
collection (i.e. upper-bound)
OCICollGetElem - OCIColl GET pointer to the element at the given
position
OCICollAssignElem - OCIColl assign to element at given index
OCICollAssign - OCIColl ASsiGn collection; perform deep-copy of source
collection to target collection
OCICollAppend - OCIColl aPPend the given element to the end of the
collection
OCICollTrim - OCIColl trim (delete) the given number of elements
from the end of the collection
OCICollIsLocator - OCIColl indicates whether a collection is locator
based or not.
OCIIterCreate - OCIColl Create an ITerator to scan the collection
elements
OCIIterDelete - OCIColl Delete ITerator
OCIIterInit - OCIColl Initialize ITerator to scan the given collection
OCIIterGetCurrent - OCIColl Iterator based, get CURrent
collection element
OCIIterNext - OCIColl Iterator based, get NeXT collection element
OCIIterPrev - OCIColl Iterator based, get PReVious collection element
OCITable - OCI functions to manipulate nested Table. The OCIColl*() and
OCITable*() functions can be used to manipulate nested table
OCITableDelete(i) - OCITable if element(i) exists then the element is
marked as deleted else the function returns false. So
delete's create "holes".
OCITableExists(i) - OCITable return true iff an element at
position i EXIsts
OCITableFirst - OCITable return the smallest value of i for which
exists(i) is true.
OCITableLast - OCITable return the largest value of i for which
exists(i) is true.
OCITableNext(i) - OCITable return pointer to the smallest position j,
greater than i, such that OCITableExists(j) is true
OCITablePrev(i) - OCITable return pointer to the largest position j,
less than i, such that OCITableExists(j) is true
OCITableSize - OCITable return current SIZe of the given nested table not
including deleted elements
OCIRef - OCI functions to manipulate object Reference
OCIRefClear - OCIRef CLeaR or nullify a ref
OCIRefAssign - OCIRef ASsiGn a ref to another
OCIRefIsEqual - OCIRef compare two refs for EQUality
OCIRefIsNull - OCIRef test if a ref is NULl
OCIRefFromHex - OCIRef convert a Hexadecimal string TO a Ref
OCIRefToHex - OCIRef convert a ref to a Hexadecimal string
OCIRefHexSize - OCIRef get size of buffer in bytes to store hexadecimal
string
OBSOLETE: to be replaced by functions from oci.h:
ORLL - ORL functions to manipulate lob Locators
orllasg - ORLL AsiGn one locator to another
orllequ - ORLL compare two locators for EQUality
orlliini - ORLL Is the locator INItialized?
orllgsz - ORLL Get locator SiZe
orllgcid - ORLL Get Character set ID
NOTE: The following are specific to FILE lobs:
orllsnm - ORLL Set directory alias and file NaMe in the locator
orllgnm - ORLL Get directory alias and file NaMe from the locator
EXAMPLES
Examples are given in the description of each function where
relevant.
NOTES
This file has been subsetted to contain ONLY the routines that will
be in the first release.
QUESTIONS
MODIFIED
bkhaladk 08/01/05 - add defn for OCIBinXmlReposCtx
dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup
srseshad 03/12/03 - convert oci public api to ansi
rpingte 11/21/02 - Add OCICollGetElemArray and OCINumberToRealArray
aahluwal 06/03/02 - bug 2360115
gayyappa 02/01/02 - fix 2210776 : change Dom to DOM
whe 09/25/01 - add OCIXMLType & OCIDomDocument opaque types
bpalaval 02/09/01 - Change text to oratext.
rkasamse 09/20/99 - lint changes
whe 09/01/99 - 976457:check __cplusplus for C++ code
hsbedi 08/11/99 - Add macro
rxgovind 10/14/98 - make non exposed calls (OCIRowType etc) private
rxgovind 06/09/98 - update OCIRowTypeCreate
nmantrav 05/11/98 - add OCIRowTypeGetCount
rxgovind 03/29/98 - add OCIRowType and OCIRowData interfaces
jwijaya 05/06/98 - add OCICollIsLocator
rxgovind 03/18/98 - opaque types: move to kolo.h
etucker 02/02/98 - add comments for Dec and Inc
etucker 01/29/98 - Finish core5 integration
rxgovind 11/11/97 - opaque types
etucker 10/28/97 - add ORLN functions for SDK
cxcheng 07/28/97 - remove OCILobLocator #define
skmishra 05/13/97 - stdcc compatibility changes
skrishna 04/25/97 - rename OCINumber*(): Exp Power TanHyp Zero Init
TanToArc Sqr Truncate and Compare
skotsovo 03/31/97 - remove OCILobLocatorSize
skrishna 03/25/97 - remove orld2i and orldi2d
skrishna 03/18/97 - fix ifdef for supporting ansi and k&r proto-types
cxcheng 02/06/97 - take out short name support except with SLSHORTNAME
skrishna 01/06/97 - update OCITableSize() comments
skrishna 12/27/96 - fix OCIDateGet/OCIDateSet
skrishna 12/12/96 - update OCICollGelElem comments
skrishna 11/07/96 - OCICollGetElem: interface change
skrishna 11/05/96 - add OCIDate Get/Set and OCIDateAssign
cxcheng 10/31/96 - change OCINumberTanHyp to OCINumberHypTan
cxcheng 10/30/96 - #define orll short names to long names
dchatter 10/26/96 - fix some OCI file long names
cxcheng 10/24/96 - remove unnecessary comment in front
cxcheng 10/14/96 - disable long name mapping for LOB functions
skrishna 10/13/96 - continue beautification
skotsovo 10/16/96 - update ocilob names
cxcheng 10/09/96 - add structure members in #define for date/time
cxcheng 10/09/96 - more lint fixes
skrishna 10/09/96 - continue beautification
cxcheng 10/09/96 - more fixes
skrishna 10/09/96 - change fixed-char rep. to orlvstr*
jwijaya 10/08/96 - continue beautification
jwijaya 10/07/96 - beautify
cxcheng 10/07/96 - more changes
cxcheng 10/04/96 - replace short names with long names
skrishna 10/01/96 - orlcsiz, orltsiz: change prototype to take errhdl
skrishna 09/23/96 - fix lint errors
skotsovo 09/23/96 - remove orllmkcur().
jwijaya 09/17/96 - comments on null ref
skrishna 09/19/96 - change orlraw format
skotsovo 09/19/96 - add orlliini and remove orllnul
skrishna 08/14/96 - orlvstr: change format to ub4 followed by text
jboonleu 08/06/96 - update comment
skotsovo 08/08/96 - revert to locators instead of descriptors as input t
jboonleu 07/23/96 - remove orlrcur
skrishna 07/06/96 - add orltsiz
skrishna 07/05/96 - add orld2i and orldi2d
jwijaya 07/03/96 - add ANSI prototypes
skrishna 06/27/96 - document default string format in orlds2d & orld2s
skrishna 06/25/96 - change max date value
skrishna 06/18/96 - modify orld2s() comments
skotsovo 06/13/96 - orll functions take lob descriptors instead of locat
rxgovind 06/05/96 - change prototype of orlrcur to take ocienvh
skrishna 05/30/96 - support collection trimming
skrishna 05/30/96 - remove orlralo/fre and orllalo/fre instead use
orionew/fre
skrishna 05/28/96 - add orlt*() and modify orla*()
skotsovo 05/23/96 - add orlbl typedefs for pro*c
jboonleu 05/14/96 - add orlrcur
rxgovind 05/08/96 - changes for 3gl callbacks
skotsovo 05/01/96 - in orllasg, no need to alloc orlbl*
skrishna 04/21/96 - merge changes from 960418 object branch into big
skrishna 04/17/96 - rename orlrcpy to orlrasg
skrishna 04/12/96 - add orlr2h and orlrh2r functions
skotsovo 04/15/96 - add fnt to make the lob locator current
skrishna 04/08/96 - change orl*() to take ocienvh* and ocierrh* instead
of oroenv*
skotsovo 03/22/96 - add locator functions
skotsovo 03/22/96 - add locator functions
skrishna 02/27/96 - remove mlslabel interface
skotsovo 02/20/96 - remove orlbty and use dty type instead.
skotsovo 02/14/96 - add text file lobs.
skrishna 01/31/96 - update comments of orln2r, orldchk, orlds2d & orld2s
skrishna 01/31/96 - change orld2s() and orln2s() to return string length
skrishna 01/21/96 - remove old raw interface
skrishna 12/14/95 - add raw interface
skotsovo 01/03/96 - change LOB offsets and lengths from ub4 to ubig_ora
to support 64 bit machines.
skotsovo 10/30/95 - add orlblsiz() to get lob locator size
skrishna 10/24/95 - move ref functions from ori and update the ref
functions to support variable-length ref
cxcheng 10/20/95 - add more comments on number versions
cxcheng 10/13/95 - add more number functions
cxcheng 08/29/95 - Support for segmented varrays
cxcheng 08/18/95 - modifiy orlmls structure
skrishna 06/06/95 - rename orln, orld, orlvs and orlva to orlnum,
orldat, orlvstr and orlvary respectively
skrishna 11/15/94 - remove orlnget() function
skrishna 09/20/94 - modify orldbtw() to return number of days only
skrishna 08/24/94 - change format string length type from ub4 to ub1
skrishna 07/19/94 - Rename orln2c & orlnc2n to orln2s & orlns2n
skrishna 06/29/94 - Add blob interface; add examples
skrishna 06/23/94 - Update comments and format
skrishna 05/19/94 - update varray append comments
skrishna 05/05/94 - Subsetting
skrishna 11/24/93 - Creation
*/
#ifndef ORATYPES
#include <oratypes.h>
#endif
#ifndef ORO_ORACLE
#include <oro.h>
#endif
#ifndef ORT_ORACLE
#include <ort.h>
#endif
#ifndef OCI_ORACLE
#include <oci.h>
#endif
#ifndef ORL_ORACLE
#define ORL_ORACLE
/*---------------------------------------------------------------------------*/
/* 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 */
#define OCIArray orlvary
#define OCIColl orlcol
#define OCICollAppend orlcapp
#define OCICollAssign orlcasg
#define OCICollAssignElem orlcase
#define OCICollGetElem orlcget
#define OCICollGetElemArray orlcgeta
#define OCICollMax orlcmax
#define OCICollSize orlcsiz
#define OCICollTrim orlctrm
#define OCICollIsLocator orlcilc
#define OCIDate orldat
#define OCIDateAddDays orldadd
#define OCIDateAddMonths orldadm
#define OCIDateCheck orldchk
#define OCIDateCompare orldcmp
#define OCIDateDD day_orldat
#define OCIDateDaysBetween orldbtw
#define OCIDateFromText orlds2d
#define OCIDateLastDay orldlst
#define OCIDateMM mon_orldat
#define OCIDateNextDay orldndy
#define OCIDateSysDate orldsys
#define OCIDateTime time_orldat
#define OCIDateYYYY gye_orldat
#define OCIDateZoneToZone orldz2z
#define OCIIter orlcitr
#define OCIIterCreate orlccit
#define OCIIterDelete orlcdit
#define OCIIterGetCurrent orlcicur
#define OCIIterInit orlciit
#define OCIIterNext orlcinxt
#define OCIIterPrev orlciprv
#define OCINumber orlnum
#define OCINumberAbs orlnabs
#define OCINumberAdd orlnadd
#define OCINumberArcCos orlnacos
#define OCINumberArcSin orlnasin
#define OCINumberArcTan orlnatan
#define OCINumberAssign orlnasg
#define OCINumberCeil orlncel
#define OCINumberCos orlncos
#define OCINumberDiv orlndiv
#define OCINumberPower orlnbex
#define OCINumberFloor orlnflr
#define OCINumberFromInt orlni2n
#define OCINumberFromReal orlnr2n
#define OCINumberFromText orlns2n
#define OCINumberHypCos orlncsh
#define OCINumberHypSin orlnsnh
#define OCINumberSetZero orlnini
#define OCINumberSetPi orlnspi
#define OCINumberInc orlninc
#define OCINumberDec orlndec
#define OCINumberIntPower orlnpwr
#define OCINumberLn orlnln
#define OCINumberLog orlnlog
#define OCINumberMod orlnmod
#define OCINumberMul orlnmul
#define OCINumberNeg orlnneg
#define OCINumberPart orlnpart
#define OCINumberExp orlnexp
#define OCINumberRound orlnrou
#define OCINumberPrec orlnpre
#define OCINumberShift orlnsft
#define OCINumberSign orlnsgn
#define OCINumberSin orlnsin
#define OCINumberSqrt orlnsqr
#define OCINumberSub orlnsub
#define OCINumberTan orlntan
#define OCINumberHypTan orlntnh
#define OCINumberArcTan2 orlnatn2
#define OCINumberToInt orln2i
#define OCINumberToReal orln2r
#define OCINumberToRealArray orln2ra
#define OCINumberToText orln2s
#define OCINumberTrunc orlntru
#define OCINumberCmp orlncmp
#define OCINumberIsZero orlnzer
#define OCINumberIsInt orlnint
#define OCIRaw orlraw
#define OCIRawAllocSize orlwasz
#define OCIRawAssignBytes orlwabr
#define OCIRawAssignRaw orlwarr
#define OCIRawPtr orlwgrp
#define OCIRawResize orlwrsz
#define OCIRawSize orlwgsz
#define OCIRefAssign orlrasg
#define OCIRefClear orlrclr
#define OCIRefFromHex orlrh2r
#define OCIRefHexSize orlrhsz
#define OCIRefIsEqual orlrequ
#define OCIRefIsNull orlrnul
#define OCIRefToHex orlr2h
#define OCIString orlvstr
#define OCIStringAllocSize orlvasz
#define OCIStringAssign orlvass
#define OCIStringAssignText orlvats
#define OCIStringPtr orlvgsp
#define OCIStringResize orlvrsz
#define OCIStringSize orlvgsz
#define OCITable orltbl
#define OCITableDelete orltdel
#define OCITableExists orltexi
#define OCITableFirst orltfst
#define OCITableLast orltlst
#define OCITableNext orltnxt
#define OCITablePrev orltprv
#define OCITableSize orltsiz
#define OCITime orldtm
#define OCITimeHH orldtmhh
#define OCITimeMI orldtmmm
#define OCITimeSS orldtmss
#define OCI_LOBMODE_READONLY ORLBMORO
#define OCI_LOBMODE_READWRITE ORLBMORW
#endif /* SLSHORTNAME */
/*****************************************************************************/
/* NUMBER/FLOAT/DECIMAL TYPE */
/*****************************************************************************/
#define OCI_NUMBER_SIZE 22
struct OCINumber
{
ub1 OCINumberPart[OCI_NUMBER_SIZE];
};
typedef struct OCINumber OCINumber;
/*
* OCINumber - OCI Number mapping in c
*
* The OTS types: NUMBER, NUMERIC, INT, SHORTINT, REAL, DOUBLE PRECISION,
* FLOAT and DECIMAL are represented by OCINumber.
* The contents of OCINumber is opaque to clients.
*
* For binding variables of type OCINumber in OCI calls (OCIBindByName(),
* OCIBindByPos(), and OCIDefineByPos()) use the type code SQLT_VNU.
*/
/*
EXAMPLE
The following example shows how to manipulate an attribute of type
oracle number.
struct person
{
OCINumber sal;
};
typedef struct person person;
OCIError *err;
person* joe;
person* tom;
person* debbie;
OCINumber *joesal;
OCINumber *tomsal;
OCINumber *debsal;
sword status;
int inum;
double dnum;
OCINumber ornum;
char buffer[21];
ub4 buflen;
sword result;
/o See oci.h for an example of how to initialize OCIError.
o For this example, assume the OCIEnv and OCIError has been
o initialized.
o/
/o Pin joe, tom and debbie person objects in the object cache. See ori.h
o for an example on pinning objects. For this example, assume that
o joe, tom and debbie are pointing to pinned objects.
o/
joesal = &joe->sal;
tomsal = &tom->sal;
debsal = &debbie->sal;
/o initialize joe's salary to be $12,000 o/
inum = 12000;
status = OCINumberFromInt(err, &inum, sizeof(inum), OCI_NUMBER_SIGNED,
joesal);
if (status != OCI_SUCCESS)
/o goto to handle error from OCINumberFromInt o/;
/o initialize tom's salary to be same as joe o/
OCINumberAssign(err, joesal, tomsal);
/o initialize debbie's salary to be 20% more than joe's o/
dnum = 1.2;
status = OCINumberFromReal(err, &dnum, sizeof(double), &ornum);
if (status != OCI_SUCCESS)
/o goto to handle error from OCINumberFromReal o/;
status = OCINumberMul(err, joesal, &ornum, debsal);
if (status != OCI_SUCCESS) /o goto to handle error from OCINumberMul o/;
/o give tom a 50% raise o/
dnum = 1.5;
status = OCINumberFromReal(err, &dnum, sizeof(double), &ornum);
if (status != OCI_SUCCESS)
/o goto to handle error from OCINumberFromReal o/;
status = OCINumberMul(err, tomsal, &ornum, tomsal);
if (status != OCI_SUCCESS) /o goto to handle error from OCINumberMul o/;
/o double joe's salary o/
status = OCINumberAdd(err, joesal, joesal, joesal);
if (status != OCI_SUCCESS) /o goto to handle error from OCINumberAdd o/;
/o get joe's salary in integer o/
status = OCINumberToInt(err, joesal, sizeof(inum), OCI_NUMBER_SIGNED,
&inum);
if (status != OCI_SUCCESS)/o goto to handle error from OCINumberToInt o/;
/o inum is set to 24000 o/
/o get debbie's salary in double o/
status = OCINumberToReal(err, debsal, sizeof(dnum), &dnum);
if (status != OCI_SUCCESS)/o goto to handle error from OCINumberToReal o/;
/o dnum is set to 14400 o/
/o print tom's salary as DEM0001`8000.00 o/
buflen = sizeof(buffer);
status = OCINumberToText(err, tomsal, "C0999G9999D99", 13,
"NLS_NUMERIC_CHARACTERS='.`' NLS_ISO_CURRENCY='Germany'", 54,
&buflen, buffer);
if (status != OCI_SUCCESS)/o goto to handle error from OCINumberToText o/;
printf("tom's salary = %s\n", buffer);
/o compare joe and tom's salary o/
status = OCINumberCmp(err, joesal, tomsal, &result);
if (status != OCI_SUCCESS) /o goto to handle error from OCINumberCmp o/;
/o result is positive o/
/o read debbie's new salary from string o/
status = OCINumberFromText(err, "48`000.00", 9, "99G999D99", 9,
"NLS_NUMERIC_CHARACTERS='.`'", 27, debsal);
if (status != OCI_SUCCESS)
/o goto to handle error from OCINumberFromText o/;
/o debbie's salary is now 48000.00 o/
*/
/*----------------------------- OCINumberInc --------------------------------*/
sword OCINumberInc( OCIError *err, OCINumber *number );
/*
NAME: OCINumberInc - OCINumber INCrement numbers
PARAMETERS:
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().
number (IN/OUT) a positive Oracle number to be incremented
DESCRIPTION:
Increment Oracle number in place. It is assumed that the input is
an integer between 0 and 100^21-2. If the is input too large, it will
be treated as 0 - the result will be an Oracle number 1. If the input
is not a positive integer, the result will be unpredictable.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*----------------------------- OCINumberDec --------------------------------*/
sword OCINumberDec( OCIError *err, OCINumber *number );
/*
NAME: OCINumberDec - OCINumber DECrement numbers
PARAMETERS:
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().
number (IN/OUT) - a positive Oracle number to be decremented
DESCRIPTION:
Decrement Oracle number in place. It is assumed that the input is an
integer between 1 and 100^21-2. If the input is too large, it will be
treated as 1 - the result will be an Oracle number 0. If the input is
not a positive integer, the result will be unpredictable.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*-------------------------- OCINumberSetZero -------------------------------*/
void OCINumberSetZero( OCIError *err, OCINumber *num );
/*
NAME: OCINumberSetZero - OCINumber Set number to Zero value
PARAMETERS:
err (IN/OUT) - pointer to OCI error handle
num (OUT) - set to zero value
DESCRIPTION:
Initialize the given number to value 0.
*/
/*--------------------------- OCINumberSetPi --------------------------------*/
void OCINumberSetPi( OCIError *err, OCINumber *num );
/*
NAME: OCINumberSetPi - OCINumber Set number to Pi
err (IN/OUT) - pointer to OCI error handle
num (OUT) - set to zero value
DESCRIPTION:
Initialize the given number to value Pi.
*/
/*----------------------------- OCINumberAdd --------------------------------*/
sword OCINumberAdd( OCIError *err, const OCINumber *number1,
const OCINumber *number2, OCINumber *result );
/*
NAME: OCINumberAdd - OCINumber ADD numbers
PARAMETERS:
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().
number1, number2 (IN) - numbers to be added
result (OUT) - result of adding 'number1' with 'number2'
DESCRIPTION:
Add 'number1' with 'number2' and return result in 'result'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*----------------------------- OCINumberSub --------------------------------*/
sword OCINumberSub( OCIError *err, const OCINumber *number1,
const OCINumber *number2, OCINumber *result );
/*
NAME: OCINumberSub - OCINumber SUBtract numbers
PARAMETERS:
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().
number1, number2 (IN) - 'number2' subtracted from 'number1'
result (OUT) - subtraction result
DESCRIPTION:
Subtract 'number2' from 'number1' and return result in 'result'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*----------------------------- OCINumberMul --------------------------------*/
sword OCINumberMul( OCIError *err, const OCINumber *number1,
const OCINumber *number2, OCINumber *result );
/*
NAME: OCINumberMul - OCINumber MULtiply numbers
PARAMETERS:
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().
number1, number2 (IN) - numbers to be multiplied
result (OUT) - multiplication result
DESCRIPTION:
Multiply 'number1' with 'number2' and return result in 'result'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*----------------------------- OCINumberDiv --------------------------------*/
sword OCINumberDiv( OCIError *err, const OCINumber *number1,
const OCINumber *number2, OCINumber *result );
/*
NAME: OCINumberDiv - OCINumber DIVide numbers
PARAMETERS:
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().
number1 (IN) - pointer to the numerator
number2 (IN) - pointer to the denominator
result (OUT) - division result
DESCRIPTION:
Divide 'number1' by 'number2' and return result in 'result'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
underflow errorr
overflow errorr
divide by zero errorr
*/
/*----------------------------- OCINumberMod --------------------------------*/
sword OCINumberMod( OCIError *err, const OCINumber *number1,
const OCINumber *number2, OCINumber *result );
/*
NAME: OCINumberMod - OCINumber MODulous
PARAMETERS:
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().
number1 (IN) - pointer to the numerator
number2 (IN) - pointer to the denominator
result (OUT) - remainder of the result
DESCRIPTION:
Finds the remainder of the division of two Oracle numbers.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
divide by zero errorr
*/
/*------------------------ OCINumberIntPower --------------------------------*/
sword OCINumberIntPower( OCIError *err, const OCINumber *base,
const sword exp, OCINumber *result );
/*
NAME: OCINumberIntPower - OCINumber takes an arbitary base to an arbitary
integer PoWeR
PARAMETERS:
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().
base (IN) - base of the exponentiation
exp (IN) - exponent to which the base is to be raised
result (OUT) - output of exponentiation
DESCRIPTION:
Takes an arbitary base to an arbitary integer power.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*-------------------------- OCINumberShift ---------------------------------*/
sword OCINumberShift( OCIError *err, const OCINumber *number,
const sword nDig, OCINumber *result );
/*
NAME: OCINumberShift - OCINumber multiplies by a power of 10.
PARAMETERS:
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().
number (IN) - Oracle Number to be shifted.
nDig (IN) - number of decimal places to shift.
result (OUT) - shift result.
DESCRIPTION:
Multiplies number by 10^NDig and sets product to the result.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*----------------------------- OCINumberNeg --------------------------------*/
sword OCINumberNeg( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberNeg - OCINumber NEGate number
PARAMETERS:
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().
number (IN) - number to be negated
result (OUT) - will contain negated value of 'number'
DESCRIPTION:
Negates an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*------------------------- OCINumberToText ---------------------------------*/
sword OCINumberToText( OCIError *err, const OCINumber *number,
const oratext *fmt, ub4 fmt_length,
const oratext *nls_params, ub4 nls_p_length,
ub4 *buf_size, oratext *buf );
/*
NAME: OCINumberToText - OCINumber convert number TO String
PARAMETERS:
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().
number (IN) - Oracle number to be converted
fmt (IN) - conversion format
fmt_length (IN) - length of the 'fmt' parameter
nls_params (IN) - nls format specification, if null string
i.e. (oratext *)0, then the default parameters for the
session is used
nls_p_length (IN) - length of the 'nls_params' parameter
buf_size (IN/OUT) - size of the buffer must be passed as input by
the caller, this function will return the length of the
resulting string in bytes via this parameter. The length
does not include the terminating null ('\0').
buf (OUT) - buffer into which the converted string is placed. The
resulting string is null terminated.
DESCRIPTION:
Converts the given number to a character string
according to the specified format. Refer to "TO_NUMBER" conversion
function described in "Oracle SQL Language Reference Manual" for a
description of format and NLS parameters.
The converted number string is stored in the buffer 'buf', up to
a max of '*buf_size' bytes. Length of the resulting string is
returned via 'buf_size'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number' or 'buf' is null
buffer too small
invalid format
invalid nls format
number to text translation for the given format causes overflow
*/
/*-------------------------- OCINumberFromText ------------------------------*/
sword OCINumberFromText( OCIError *err, const oratext *str,
ub4 str_length, const oratext *fmt, ub4 fmt_length,
const oratext *nls_params, ub4 nls_p_length,
OCINumber *number );
/*
NAME: OCINumberFromText - OCINumber convert String TO Number
PARAMETERS:
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().
str (IN) - input string to be converted to Oracle number
str_length (IN) - size of the input string
fmt (IN) - conversion format
fmt_length (IN) - length of the 'fmt' parameter
nls_params (IN) - nls format specification, if null string
i.e. (oratext *)0, then the default parameters for the
session is used
nls_p_length (IN) - length of the 'nls_params' parameter
number (OUT) - given string converted to number
DESCRIPTION:
Converts the given string to a number
according to the specified format. Refer to "TO_NUMBER" conversion
function described in "Oracle SQL Language Reference Manual" for a
description of format and NLS parameters.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number' or 'str' is null
'str_length' is 0
invalid format
invalid nls format
invalid input string
*/
/*-------------------------- OCINumberToInt ---------------------------------*/
#define OCI_NUMBER_UNSIGNED 0 /* Unsigned type -- ubX */
#define OCI_NUMBER_SIGNED 2 /* Signed type -- sbX */
sword OCINumberToInt( OCIError *err, const OCINumber *number,
uword rsl_length, uword rsl_flag, void *rsl );
/*
NAME: OCINumberToInt - OCINumber convert number TO Integer
PARAMETERS:
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().
number (IN) - number to be converted
rsl_length (IN) - size of the desired result
rsl_s_flag (IN) - flag denoting the desired sign of the output; valid
values are OCI_NUMBER_UNSIGNED, OCI_NUMBER_SIGNED
rsl (OUT) - pointer to space for the result
DESCRIPTION:
Native type conversion function.
Converts the given Oracle number into an xbx (e.g. ub2, ub4, sb2 etc.)
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number' or 'rsl' is null
integer value of 'number' is too big -- overflow
integer value of 'number' is too small -- underflow
invalid sign flag value ('rsl_s_flag')
*/
/*--------------------------- OCINumberFromInt ------------------------------*/
sword OCINumberFromInt( OCIError *err, const void *inum, uword inum_length,
uword inum_s_flag, OCINumber *number );
/*
NAME: OCINumberFromInt - OCINumber convert Integer TO Number
PARAMETERS:
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().
inum (IN) - pointer to the integer to be converted
inum_length (IN) - size of the integer
inum_s_flag (IN) - flag that designates the sign of the integer; valid
values are OCI_NUMBER_UNSIGNED, OCI_NUMBER_SIGNED
number (OUT) - given integer converted to Oracle number
DESCRIPTION:
Native type conversion function. Converts any Oracle standard
machine-native integer type (xbx) to an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number' or 'inum' is null
integer too BIG -- the number is too large to fit into an Oracle
number
invalid sign flag value ('inum_s_flag')
*/
/*------------------------- OCINumberToReal ---------------------------------*/
sword OCINumberToReal( OCIError *err, const OCINumber *number,
uword rsl_length, void *rsl );
/*
NAME: OCINumberToReal - OCINumber convert number TO Real
PARAMETERS:
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().
number (IN) - number to be converted
rsl_length (IN) - is the size of the desired result,
sizeof( float | double | long double)
rsl (OUT) - pointer to space for storing the result
DESCRIPTION:
Native type conversion function. Converts an Oracle number into a
machine-native real type. This function only converts numbers up to
LDBL_DIG, DBL_DIG, or FLT_DIG digits of precision and removes
trailing zeroes. The above constants are defined in float.h
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number' or 'rsl' is null
'rsl_length' is 0
*/
/*------------------------- OCINumberToRealArray ----------------------------*/
sword OCINumberToRealArray( OCIError *err, const OCINumber **number,
uword elems, uword rsl_length, void *rsl );
/*
NAME: OCINumberToRealArray - OCINumber convert array of numbers TO Real
PARAMETERS:
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().
number (IN) - Pointer to array of number to be converted
elems (IN) - Upper bound of number array
rsl_length (IN) - is the size of the desired result,
sizeof( float | double | long double)
rsl (OUT) - pointer to array of space for storing the result
DESCRIPTION:
Native type conversion function. Converts an Oracle number into a
machine-native real type. This function only converts numbers up to
LDBL_DIG, DBL_DIG, or FLT_DIG digits of precision and removes
trailing zeroes. The above constants are defined in float.h
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number' or 'rsl' is null
'rsl_length' is 0
*/
/*-------------------------- OCINumberFromReal ------------------------------*/
sword OCINumberFromReal( OCIError *err, const void *rnum,
uword rnum_length, OCINumber *number );
/*
NAME: OCINumberFromReal - OCINumber convert Real TO Number
PARAMETERS:
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().
rnum (IN) - pointer to the floating point number to be converted
rnum_length (IN) - size of the desired result, i.e.
sizeof({float | double | long double})
number (OUT) - given float converted to Oracle number
DESCRIPTION:
Native type conversion function. Converts a machine-native floating
point type to an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number' or 'rnum' is null
'rnum_length' is 0
*/
/*----------------------------- OCINumberCmp --------------------------------*/
sword OCINumberCmp( OCIError *err, const OCINumber *number1,
const OCINumber *number2, sword *result );
/*
NAME: OCINumberCmp - OCINumber CoMPare numbers
PARAMETERS:
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().
number1, number2 (IN) - numbers to be compared
result (OUT) - 0 if equal, negative if number1 < number2,
positive if number1 > number2
DESCRIPTION:
The function OCINumberCmp compares two numbers.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number1' or 'number2' or 'result' is null
*/
/*---------------------------- OCINumberSign --------------------------------*/
sword OCINumberSign( OCIError *err, const OCINumber *number,
sword *result );
/*
NAME: OCINumberSign - OCINumber obtains SiGN of an Oracle number
PARAMETERS:
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().
number (IN) - number whose sign is returned
result (OUT) - 0 if number == 0, -1 if number < 0,
1 if number > 0
DESCRIPTION:
Obtains sign of an Oracle number
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number' or 'result' is null
*/
/*---------------------------- OCINumberIsZero ------------------------------*/
sword OCINumberIsZero( OCIError *err, const OCINumber *number,
boolean *result );
/*
NAME: OCINumberIsZero - OCINumber comparison with ZERo
PARAMETERS:
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().
number (IN) - numbers to be compared
result (OUT) - set to TRUE if equal to zero else FALSE
DESCRIPTION:
Test if the given number is equal to zero.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number' or 'result' is null
*/
/*---------------------------- OCINumberIsInt -------------------------------*/
sword OCINumberIsInt( OCIError *err, const OCINumber *number,
boolean *result );
/*
NAME: OCINumberIsInt - OCINumber Is Integer value.
PARAMETERS:
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().
number (IN) - number to be tested
result (OUT) - set to TRUE if integer value else FALSE
DESCRIPTION:
Test if the given number is an integer value.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'number' or 'result' is null
*/
/*-------------------------- OCINumberAssign --------------------------------*/
sword OCINumberAssign( OCIError *err, const OCINumber *from,
OCINumber *to );
/*
NAME: OCINumberAssign - OCINumber ASsiGn number
PARAMETERS:
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().
from (IN) - number to be assigned
to (OUT) - number copied into
DESCRIPTION:
Assign number 'from' to 'to'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'from' or 'to' is null
*/
/*----------------------------- OCINumberAbs --------------------------------*/
sword OCINumberAbs( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberAbs - OCINumber compute ABSolute value
PARAMETERS:
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().
number (IN) - input number
result (OUT) - output which will contain the absolue value of the
input number
DESCRIPTION:
Computes the absolute value of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*---------------------------- OCINumberCeil --------------------------------*/
sword OCINumberCeil( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberCeil - OCINumber compute the CEiL value of an Oracle number
PARAMETERS:
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().
number (IN) - input number
result (OUT) - output which will contain the ceil value of the
input number
DESCRIPTION:
Computes the ceil value of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*--------------------------- OCINumberFloor --------------------------------*/
sword OCINumberFloor( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberFloor - OCINumber compute the FLooR value of an Oracle number
PARAMETERS:
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().
number (IN) - input number
result (OUT) - output which will contain the floor value of the
input number
DESCRIPTION:
Computes the floor value of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*----------------------------- OCINumberSqrt -------------------------------*/
sword OCINumberSqrt( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberSqrt - OCINumber compute the SQuare Root of an Oracle number
PARAMETERS:
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().
number (IN) - input number
result (OUT) - output which will contain the square root of the
input number
DESCRIPTION:
Computes the square root of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
'number' is negative
*/
/*--------------------------- OCINumberTrunc --------------------------------*/
sword OCINumberTrunc( OCIError *err, const OCINumber *number,
sword decplace, OCINumber *result );
/*
NAME: OCINumberTrunc - OCINumber TRUncate an Oracle number at a
specified decimal place
PARAMETERS:
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().
number (IN) - input number
decplace (IN) - number of decimal digits to the right of the
decimal point to truncate at. Negative values are allowed.
result (OUT) - output of truncation
DESCRIPTION:
Truncate an Oracle number at a specified decimal place
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*----------------------------- OCINumberPower ------------------------------*/
sword OCINumberPower( OCIError *err, const OCINumber *base,
const OCINumber *number, OCINumber *result );
/*
NAME: OCINumberPower - OCINumber takes an arbitary Base to an
arbitary Power
PARAMETERS:
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().
base (IN) - base of the exponentiation
number (IN) - exponent to which the base is to be raised
result (OUT) - output of exponentiation
DESCRIPTION:
Takes an arbitary base to an arbitary power.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*--------------------------- OCINumberRound --------------------------------*/
sword OCINumberRound( OCIError *err, const OCINumber *number,
sword decplace, OCINumber *result );
/*
NAME: OCINumberRound - OCINumber ROUnds an Oracle number to a specified
decimal place
PARAMETERS:
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().
number (IN) - round this number and return result in 'result'
decplace (IN) - number of decimal digits to the right of the
decimal point to round to. Negative values are allowed.
result (OUT) - output of rounding
DESCRIPTION:
Rounds an Oracle number to a specified decimal place
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*--------------------------- OCINumberPrec ---------------------------------*/
sword OCINumberPrec( OCIError *err, const OCINumber *number,
sword nDigs, OCINumber *result );
/*
NAME: OCINumberPrec - Rounds an Oracle number to a specified number of
decimal digits.
PARAMETERS:
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().
number (IN) - number for which to set precision.
nDig (IN) - number of decimal digits desired in the result.
result (OUT) - result.
DESCRIPTION:
Performs a floating point round with respect to the number
of digits.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*----------------------------- OCINumberSin --------------------------------*/
sword OCINumberSin( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberSin - OCINumber takes the SINe of an Oracle number
PARAMETERS:
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().
number (IN) - argument of the sine in radians
result (OUT) - result of the sine
DESCRIPTION:
Takes the sine in radians of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*-------------------------- OCINumberArcSin --------------------------------*/
sword OCINumberArcSin( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberArcSin - OCINumber takes the Arc SINe of an Oracle number
PARAMETERS:
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().
number (IN) - argument of the arc sine
result (OUT) - result of the arc sine in radians
DESCRIPTION:
Takes the arc sine in radians of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
'number' is < -1 or 'number' is > 1.
*/
/*-------------------------- OCINumberHypSin --------------------------------*/
sword OCINumberHypSin( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberHypSin - OCINumber takes the SiNe Hyperbolic of an
Oracle number
PARAMETERS:
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().
number (IN) - argument of the sine hyperbolic
result (OUT) - result of the sine hyperbolic
DESCRIPTION:
Takes the hyperbolic sine of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
NOTES:
An Oracle number overflow causes an unpredictable result value.
*/
/*----------------------------- OCINumberCos --------------------------------*/
sword OCINumberCos( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberCos - OCINumber takes the COSine of an Oracle number
PARAMETERS:
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().
number (IN) - argument of the cosine in radians
result (OUT) - result of the cosine
DESCRIPTION:
Takes the cosine in radians of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*-------------------------- OCINumberArcCos --------------------------------*/
sword OCINumberArcCos( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberArcCos - OCINumber takes the Arc COSine of an Oracle number
PARAMETERS:
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().
number (IN) - argument of the arc cosine
result (OUT) - result of the arc cosine in radians
DESCRIPTION:
Takes the arc cosine in radians of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
'number' is < -1 or 'number' is > 1.
*/
/*-------------------------- OCINumberHypCos --------------------------------*/
sword OCINumberHypCos( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberHypCos - OCINumber takes the CoSine Hyperbolic of an
Oracle number
PARAMETERS:
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().
number (IN) - argument of the cosine hyperbolic
result (OUT) - result of the cosine hyperbolic
DESCRIPTION:
Takes the hyperbolic cosine of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
NOTES:
An Oracle number overflow causes an unpredictable result value.
*/
/*----------------------------- OCINumberTan --------------------------------*/
sword OCINumberTan( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberTan - OCINumber takes the TANgent of an Oracle number
PARAMETERS:
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().
number (IN) - argument of the tangent in radians
result (OUT) - result of the tangent
DESCRIPTION:
Takes the tangent in radians of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*-------------------------- OCINumberArcTan --------------------------------*/
sword OCINumberArcTan( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberArcTan - OCINumber takes the Arc TANgent of an Oracle number
PARAMETERS:
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().
number (IN) - argument of the arc tangent
result (OUT) - result of the arc tangent in radians
DESCRIPTION:
Takes the arc tangent in radians of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*------------------------ OCINumberArcTan2 ---------------------------------*/
sword OCINumberArcTan2( OCIError *err, const OCINumber *number1,
const OCINumber *number2, OCINumber *result );
/*
NAME: OCINumberArcTan2 - OCINumber takes the ATan2 of 2 Oracle numbers
PARAMETERS:
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().
number1 (IN) - first argument of atan2(y,x) function which
corresponds to 'y' parameter in the function
number2 (IN) - second argument of atan2(y,x) function which
corresponds to 'x' parameter in the function
result (OUT) - result of the atan2() in radians
DESCRIPTION:
Takes the atan2(number1, number2).
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
'number2' is 0
*/
/*----------------------------- OCINumberHypTan -----------------------------*/
sword OCINumberHypTan( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberHypTan - OCINumber takes the TaNgent Hyperbolic of an Oracle
number
PARAMETERS:
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().
number (IN) - argument of the tangent hyperbolic
result (OUT) - result of the tangent hyperbolic
DESCRIPTION:
Takes the hyperbolic tangent of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
NOTES:
An Oracle number overflow causes an unpredictable result value.
*/
/*--------------------------- OCINumberExp ----------------------------------*/
sword OCINumberExp( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberExp - OCINumber EXPonential
PARAMETERS:
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().
number (IN) - e raised to this Oracle number power
result (OUT) - output of exponentiation
DESCRIPTION:
Raises e to the specified Oracle number power
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
*/
/*----------------------------- OCINumberLn ---------------------------------*/
sword OCINumberLn( OCIError *err, const OCINumber *number,
OCINumber *result );
/*
NAME: OCINumberLn - OCINumber Logarithm Natural
PARAMETERS:
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().
number (IN) - logarithm of this number is computed
result (OUT) - logarithm result
DESCRIPTION:
Takes the logarithm of the given Oracle number with respect
to the given base.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
'number' is <= 0
*/
/*----------------------------- OCINumberLog --------------------------------*/
sword OCINumberLog( OCIError *err, const OCINumber *base,
const OCINumber *number, OCINumber *result );
/*
NAME: OCINumberLog - OCINumber LOGarithm any base
PARAMETERS:
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().
base (IN) - base of the logarithm
number (IN) - opearnd
result (OUT) - logarithm result
DESCRIPTION:
Takes the logarithm with the specified base of an Oracle number.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
any of the number arguments is null
'number' is <= 0
'base' is <= 0
*/
/*****************************************************************************/
/* ORACLE DATE TYPE */
/*****************************************************************************/
struct OCITime
{
ub1 OCITimeHH; /* hours; range is 0 <= hours <=23 */
ub1 OCITimeMI; /* minutes; range is 0 <= minutes <= 59 */
ub1 OCITimeSS; /* seconds; range is 0 <= seconds <= 59 */
};
typedef struct OCITime OCITime;
/*
* OCITime - OCI TiMe portion of date
*
* This structure should be treated as an opaque structure as the format
* of this structure may change. Use OCIDateGetTime/OCIDateSetTime
* to manipulate time portion of OCIDate.
*/
struct OCIDate
{
sb2 OCIDateYYYY; /* gregorian year; range is -4712 <= year <= 9999 */
ub1 OCIDateMM; /* month; range is 1 <= month < 12 */
ub1 OCIDateDD; /* day; range is 1 <= day <= 31 */
OCITime OCIDateTime; /* time */
};
typedef struct OCIDate OCIDate;
/*
* OCIDate - OCI oracle Date representation in C
*
* OCIDate represents the C mapping of Oracle date.
*
* This structure should be treated as an opaque structure as the format
* of this structure may change. Use OCIDateGetDate/OCIDateSetDate
* to access/initialize OCIDate.
*
* For binding variables of type OCIDate in OCI calls (OCIBindByName(),
* OCIBindByPos(), and OCIDefineByPos()) use the type code SQLT_ODT.
*/
/*
EXAMPLE
The following example shows how to manipulate an attribute of type
oracle date.
#define FMT "Month dd, YYYY, HH:MI A.M."
#define LANG "American"
struct person
{
OCIDate start_date;
};
typedef struct person person;
OCIError *err;
person *joe;
sword status; /o error status o/
/o See oci.h for an example of how to initialize OCIError.
o For this example, assume the OCIEnv and OCIError has been
o initialized.
o/
/o Pin joe person object in the object cache. See ori.h
o for an example on pinning objects. For this example, assume that
o joe is pointing to the pinned object.
o/
/o set the start date of joe o/
OCIDateSetTime(&joe->start_date, 8, 0, 0);
OCIDateSetDate(&joe->start_date, 1990, 10, 5);
/o check if the date is valid o/
uword invalid;
if (OCIDateCheck(err, &joe->start_date, &invalid) != OCI_SUCCESS)
/o error handling code o/
if (invalid)
/o error handling code o/
/o convert date for display purposes o/
char str[100];
ub4 strlen = sizeof(str);
if (OCIDateToText(err, &joe->start_date, FMT, sizeof(FMT)-1, LANG,
sizeof(LANG)-1, &strlen, str) != OCI_SUCCESS)
/o error handling code o/
*/
/*--------------------------- OCIDateGetTime --------------------------------*/
/* void OCIDateGetTime(/o_ const OCIDate *date, ub1 *hour, ub1 *min,
ub1 *sec _o/); */
#define OCIDateGetTime(date, hour, min, sec) \
{ \
*hour = (date)->OCIDateTime.OCITimeHH; \
*min = (date)->OCIDateTime.OCITimeMI; \
*sec = (date)->OCIDateTime.OCITimeSS; \
}
/*
NAME: OCIDateGetTime - OCIDate Get Time portion of date
PARAMETERS:
date (IN) - Oracle date whose time data is retrieved
hour (OUT) - hour value returned
min (OUT) - minute value returned
sec (OUT) - second value returned
DESCRIPTION:
Return time inforamtion stored in the given date. The time
information returned is: hour, minute and seconds.
RETURNS:
NONE
*/
/*--------------------------- OCIDateGetDate --------------------------------*/
/* void OCIDateGetDate(/o_ const OCIDate *date, sb2 *year, ub1 *month,
ub1 *day _o/); */
#define OCIDateGetDate(date, year, month, day) \
{ \
*year = (date)->OCIDateYYYY; \
*month = (date)->OCIDateMM; \
*day = (date)->OCIDateDD; \
}
/*
NAME: OCIDateGetDate - OCIDate Get Date (year, month, day) portion of date
PARAMETERS:
date (IN) - Oracle date whose year, month, day data is retrieved
year (OUT) - year value returned
month (OUT) - month value returned
day (OUT) - day value returned
DESCRIPTION:
Return year, month, day inforamtion stored in the given date.
RETURNS:
NONE
*/
/*--------------------------- OCIDateSetTime --------------------------------*/
/* void OCIDateSetTime(/o_ OCIDate *date, ub1 hour, ub1 min,
ub1 sec _o/); */
#define OCIDateSetTime(date, hour, min, sec) \
{ \
(date)->OCIDateTime.OCITimeHH = hour; \
(date)->OCIDateTime.OCITimeMI = min; \
(date)->OCIDateTime.OCITimeSS = sec; \
}
/*
NAME: OCIDateSetTime - OCIDate Set Time portion of date
PARAMETERS:
date (OUT) - Oracle date whose time data is set
hour (IN) - hour value to be set
min (IN) - minute value to be set
sec (IN) - second value to be set
DESCRIPTION:
Set the date with the given time inforamtion.
RETURNS:
NONE
*/
/*--------------------------- OCIDateSetDate --------------------------------*/
/* void OCIDateSetDate(/o_ OCIDate *date, sb2 year, ub1 month, ub1 day _o/); */
#define OCIDateSetDate(date, year, month, day) \
{ \
(date)->OCIDateYYYY = year; \
(date)->OCIDateMM = month; \
(date)->OCIDateDD = day; \
}
/*
NAME: OCIDateSetDate - OCIDate Set Date (year, month, day) portion of date
PARAMETERS:
date (IN) - Oracle date whose year, month, day data is set
year (OUT) - year value to be set
month (OUT) - month value to be set
day (OUT) - day value to be set
DESCRIPTION:
Set the date with the given year, month, day inforamtion.
RETURNS:
NONE
*/
/*--------------------------- OCIDateAssign ---------------------------------*/
sword OCIDateAssign( OCIError *err, const OCIDate *from,
OCIDate *to );
/*
NAME: OCIDateAssign - OCIDate Assignment
PARAMETERS:
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().
from (IN) - date to be assigned
to (OUT) - lhs of assignment
DESCRIPTION:
Performs date assignment.
RETURNS:
OCI_SUCCESS
*/
/*--------------------------- OCIDateToText ---------------------------------*/
sword OCIDateToText( OCIError *err, const OCIDate *date,
const oratext *fmt, ub1 fmt_length,
const oratext *lang_name, ub4 lang_length,
ub4 *buf_size, oratext *buf );
/*
NAME: OCIDateToText - OCIDate convert date TO String
PARAMETERS:
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().
date (IN) - Oracle date to be converted
fmt (IN) - conversion format, if null string pointer (oratext*)0, then
the date is converted to a character string in the
date format "DD-MON-YY".
fmt_length (IN) - length of the 'fmt' parameter
lang_name (IN) - specifies the language in which the names and
abbreviations of months and days are returned;
default language of session is used if 'lang_name'
is null i.e. (oratext *)0
lang_length (IN) - length of the 'nls_params' parameter
buf_size (IN/OUT) - size of the buffer; size of the resulting string
is returned via this parameter
buf (OUT) - buffer into which the converted string is placed
DESCRIPTION:
Converts the given date to a string according to the specified format.
Refer to "TO_DATE" conversion function described in
"Oracle SQL Language Reference Manual" for a description of format
and NLS arguments. The converted null-terminated date string is
stored in the buffer 'buf'.
An error is reported upon overflow, e.g. trying to convert a number
of value 10 using format '9' causes an overflow.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
buffer too small
invalid format
unknown language
overflow error
*/
/*---------------------------- OCIDateFromText ------------------------------*/
sword OCIDateFromText( OCIError *err, const oratext *date_str,
ub4 d_str_length, const oratext *fmt, ub1 fmt_length,
const oratext *lang_name, ub4 lang_length,
OCIDate *date );
/*
NAME: OCIDateFromText - OCIDate convert String TO Date
PARAMETERS:
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().
date_str (IN) - input string to be converted to Oracle date
d_str_length (IN) - size of the input string, if the length is -1
then 'date_str' is treated as a null terminated string
fmt (IN) - conversion format; if 'fmt' is a null pointer, then
the string is expected to be in 'DD-MON-YY' format.
fmt_length (IN) - length of the 'fmt' parameter
lang_name (IN) - language in which the names and abbreviations of
days and months are specified, if null i.e. (oratext *)0,
the default language of session is used,
lang_length (IN) - length of the 'lang_name' parameter
date (OUT) - given string converted to date
DESCRIPTION:
Converts the given string to Oracle date
according to the specified format. Refer to "TO_DATE" conversion
function described in "Oracle SQL Language Reference Manual" for a
description of format.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
invalid format
unknown language
invalid input string
<to be discovered>
*/
/*----------------------------- OCIDateCompare ------------------------------*/
sword OCIDateCompare( OCIError *err, const OCIDate *date1,
const OCIDate *date2, sword *result );
/*
NAME: OCIDateCompare - OCIDate CoMPare dates
PARAMETERS:
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().
date1, date2 (IN) - dates to be compared
result (OUT) - comparison result, 0 if equal, -1 if date1 < date2,
1 if date1 > date2
DESCRIPTION:
The function OCIDateCompare compares two dates. It returns -1 if date1
is smaller than date2, 0 if they are equal, and 1 if date1 is greater
than date2.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
invalid date
<to be discovered>
*/
/*------------------------- OCIDateAddMonths --------------------------------*/
sword OCIDateAddMonths( OCIError *err, const OCIDate *date, sb4 num_months,
OCIDate *result );
/*
NAME: OCIDateAddMonths - OCIDate ADd or subtract Months
PARAMETERS:
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().
date (IN) - 'num_months' added or subtracted from 'date'
num_months (IN) - number of months to be added or subtracted
(a negative value will be subtracted)
result (IN/OUT) - result of adding or subtracting to 'date'
DESCRIPTION:
The function OCIDateAddDays adds or subtracts num_months from the
date 'date'.
If the input 'date' is the last day of a month, then
appropriate adjustments are made to ensure that the output date is
also the last day of the month. For example, Feb. 28 + 1 month =
March 31, and November 30 - 3 months = August 31. Otherwise the
'result' date has the same day component as 'date'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
invalid date
<to be discovered>
*/
/*--------------------------- OCIDateAddDays --------------------------------*/
sword OCIDateAddDays( OCIError *err, const OCIDate *date, sb4 num_days,
OCIDate *result );
/*
NAME: OCIDateAddDays - OCIDate ADd or subtract Days
PARAMETERS:
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().
date (IN) - 'num_days' added or subtracted from 'date'
num_days (IN) - number of days to be added or subtracted
(a negative value will be subtracted)
result (IN/OUT) - result of adding or subtracting to 'date'
DESCRIPTION:
The function OCIDateAddDays adds or subtracts num_days from the
date 'date'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
invalid date
<to be discovered>
*/
/*--------------------------- OCIDateLastDay --------------------------------*/
sword OCIDateLastDay( OCIError *err, const OCIDate *date,
OCIDate *last_day );
/*
NAME: OCIDateLastDay - OCIDate get date of the LaST day of the month
PARAMETERS:
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().
date (IN) - input date
last_day (OUT) - last day of the month in date 'date'
DESCRIPTION:
The function OCIDateLastDay returns the date of the last day of the
month in date 'date'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
invalid date
<to be discovered>
*/
/*----------------------- OCIDateDaysBetween --------------------------------*/
sword OCIDateDaysBetween( OCIError *err, const OCIDate *date1,
const OCIDate *date2, sb4 *num_days );
/*
NAME: OCIDateDaysBetween - OCIDate get number of days BeTWeen two dates
PARAMETERS:
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().
date1, date2 (IN) - input dates
num_days (OUT) - number of days between date1 and date2
DESCRIPTION:
The function OCIDateDaysBetween returns the number of days between
date1 and date2. The time is ignored in this computation.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
invalid date
<to be discovered>
*/
/*------------------------ OCIDateZoneToZone --------------------------------*/
sword OCIDateZoneToZone( OCIError *err, const OCIDate *date1,
const oratext *zon1,
ub4 zon1_length, const oratext *zon2,
ub4 zon2_length, OCIDate *date2 );
/*
NAME: OCIDateZoneToZone - OCIDate convert date from one Zone TO another Zone
PARAMETERS:
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().
date1 (IN) - date to be converted
zon1 (IN) - zone of input date
zon1_length (IN) - length in bytes of string 'zon1'
zon2 (IN) - zone to be converted to
zon2_length (IN) - length in bytes of string 'zon2'
date2 (OUT) - converted date (in 'zon2')
DESCRIPTION:
Converts date from one time zone to another. Given date 'date1'
in time zone 'zon1' returns date 'date2' in time zone 'zon2'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
invlid date
invald input time zone
invald output time zone
<to be discovered>
*/
/*--------------------------- OCIDateNextDay --------------------------------*/
sword OCIDateNextDay( OCIError *err, const OCIDate *date,
const oratext *day_p, ub4 day_length,
OCIDate *next_day );
/*
NAME: OCIDateNextDay - OCIDate get date of Next DaY
PARAMETERS:
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().
date (IN) - returned date should be later than this date
day (IN) - first day of week named by this is returned
day_length (IN) - length in bytes of string 'day'
next_day (OUT) - first day of the week named by 'day' later than 'date'
DESCRIPTION:
Returns the date of the first day of the
week named by 'day' that is later than date 'date'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
invalid date
invalid day
<to be discovered>
*/
/*----------------------------- OCIDateCheck --------------------------------*/
/* Listing of error bits used by OCIDateCheck() */
#define OCI_DATE_INVALID_DAY 0x1 /* Bad DAy */
#define OCI_DATE_DAY_BELOW_VALID 0x2 /* Bad DAy Low/high bit (1=low)*/
#define OCI_DATE_INVALID_MONTH 0x4 /* Bad MOnth */
#define OCI_DATE_MONTH_BELOW_VALID 0x8 /* Bad MOnth Low/high bit (1=low)*/
#define OCI_DATE_INVALID_YEAR 0x10 /* Bad YeaR */
#define OCI_DATE_YEAR_BELOW_VALID 0x20 /* Bad YeaR Low/high bit (1=low)*/
#define OCI_DATE_INVALID_HOUR 0x40 /* Bad HouR */
#define OCI_DATE_HOUR_BELOW_VALID 0x80 /* Bad HouR Low/high bit (1=low)*/
#define OCI_DATE_INVALID_MINUTE 0x100 /* Bad MiNute */
#define OCI_DATE_MINUTE_BELOW_VALID 0x200
/* Bad MiNute Low/high bit (1=low)*/
#define OCI_DATE_INVALID_SECOND 0x400 /* Bad SeCond */
#define OCI_DATE_SECOND_BELOW_VALID 0x800
/* bad second Low/high bit (1=low)*/
#define OCI_DATE_DAY_MISSING_FROM_1582 0x1000
/* Day is one of those "missing" from 1582 */
#define OCI_DATE_YEAR_ZERO 0x2000 /* Year may not equal zero */
#define OCI_DATE_INVALID_FORMAT 0x8000 /* Bad date format input */
sword OCIDateCheck( OCIError *err, const OCIDate *date, uword *valid );
/*
NAME: OCIDateCheck - OCIDate CHecK if the given date is valid
PARAMETERS:
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().
date (IN) - date to be checked
valid (OUT) - returns zero for a valid date, otherwise
the ORed combination of all error bits specified below:
Macro name Bit number Error
---------- ---------- -----
OCI_DATE_INVALID_DAY 0x1 Bad day
OCI_DATE_DAY_BELOW_VALID 0x2 Bad DAy Low/high bit (1=low)
OCI_DATE_INVALID_MONTH 0x4 Bad MOnth
OCI_DATE_MONTH_BELOW_VALID 0x8 Bad MOnth Low/high bit (1=low)
OCI_DATE_INVALID_YEAR 0x10 Bad YeaR
OCI_DATE_YEAR_BELOW_VALID 0x20 Bad YeaR Low/high bit (1=low)
OCI_DATE_INVALID_HOUR 0x40 Bad HouR
OCI_DATE_HOUR_BELOW_VALID 0x80 Bad HouR Low/high bit (1=low)
OCI_DATE_INVALID_MINUTE 0x100 Bad MiNute
OCI_DATE_MINUTE_BELOW_VALID 0x200 Bad MiNute Low/high bit (1=low)
OCI_DATE_INVALID_SECOND 0x400 Bad SeCond
OCI_DATE_SECOND_BELOW_VALID 0x800 bad second Low/high bit (1=low)
OCI_DATE_DAY_MISSING_FROM_1582 0x1000 Day is one of those "missing"
from 1582
OCI_DATE_YEAR_ZERO 0x2000 Year may not equal zero
OCI_DATE_INVALID_FORMAT 0x8000 Bad date format input
So, for example, if the date passed in was 2/0/1990 25:61:10 in
(month/day/year hours:minutes:seconds format), the erroor returned
would be OCI_DATE_INVALID_DAY | OCI_DATE_DAY_BELOW_VALID |
OCI_DATE_INVALID_HOUR | OCI_DATE_INVALID_MINUTE
DESCRIPTION:
Check if the given date is valid.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
'date' and 'valid' pointers are NULL pointers
*/
/*--------------------------- OCIDateSysDate --------------------------------*/
sword OCIDateSysDate( OCIError *err, OCIDate *sys_date );
/*
NAME: OCIDateSysDate - OCIDate get current SYStem date and time
PARAMETERS:
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().
sys_date (OUT) - current system date and time
DESCRIPTION:
Returns the current system date and time.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'err' is NULL.
OCI_ERROR if
<to be discovered>
*/
/*****************************************************************************/
/* FIXED-LENGTH STRING - CHAR (N) */
/*****************************************************************************/
/*
* An ADT attribute declared as "x CHAR(n)" is mapped to "OCIString *x;".
* The representation of OCIString * is shown below.
*/
/*****************************************************************************/
/* VARIABLE-LENGTH STRING */
/*****************************************************************************/
/*
* The variable-length string is represented in C as a pointer to OCIString
* structure. The OCIString structure is opaque to the user. Functions are
* provided to allow the user to manipulate a variable-length string.
*
* A variable-length string can be declared as:
*
* OCIString *vstr;
*
* For binding variables of type OCIString* in OCI calls (OCIBindByName(),
* OCIBindByPos() and OCIDefineByPos()) use the external type code SQLT_VST.
*/
typedef struct OCIString OCIString;
/*-------------------------- OCIStringAssign --------------------------------*/
sword OCIStringAssign( OCIEnv *env, OCIError *err, const OCIString *rhs,
OCIString **lhs );
/*
NAME: OCIStringAssign - OCIString Assign String to String
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().
rhs (IN) - RHS of the assignment, the type of rhs is also OCIString
lhs (IN/OUT) - LHS of the assignment
DESCRIPTION:
Assign 'rhs' string to 'lhs' string. The 'lhs' string may be
resized depending upon the size of the 'rhs'. The assigned string is
null-terminated. The 'length' field will not include the extra byte
needed for null termination.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
out of space error
*/
/*---------------------- OCIStringAssignText --------------------------------*/
sword OCIStringAssignText( OCIEnv *env, OCIError *err, const oratext *rhs,
ub4 rhs_len, OCIString **lhs );
/*
NAME: OCIStringAssignText - OCIString Assign Text string to String
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().
rhs (IN) - RHS of the assignment, the type of rhs is a text string
rhs_len (IN) - length of the 'rhs' string
lhs (IN/OUT) - LHS of the assignment
DESCRIPTION:
Assign 'rhs' string to 'lhs' string. The 'lhs' string may be
resized depending upon the size of the 'rhs'. The assigned string is
null-terminated. The 'length' field will not include the extra byte
needed for null termination.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
out of space error
*/
/*-------------------------- OCIStringResize --------------------------------*/
sword OCIStringResize( OCIEnv *env, OCIError *err, ub4 new_size,
OCIString **str );
/*
NAME: OCIStringResize - OCIString ReSiZe string memory
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().
new_size (IN) - new memory size of the string in bytes
str (IN/OUT) - allocated memory for the string is freed from the
OOCI heap
DESCRIPTION:
This function resizes the memory of the given variable-length string in
the object cache. The contents of the string are NOT preserved.
This function may allocate the string in a new memory region in
which case the original memory occupied by the given string will
be freed. If the input string is null (str == NULL), then this
function will allocate memory for the string.
If the new_size is 0, then this function frees the memory occupied
by 'str' and a null pointer value is returned.
NOTE: The caller must compute 'new_size' taking into account space
for the null character ('\0').
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
out of space error
*/
/*---------------------------- OCIStringSize --------------------------------*/
ub4 OCIStringSize( OCIEnv *env, const OCIString *vs );
/*
NAME: OCIStringSize - OCIString Get String siZe
PARAMETERS:
env(IN) - pointer to OCI environment handle
vs (IN) - string whose size is returned
DESCRIPTION:
Return the size of the given string.
RETURNS:
size of the string in bytes is returned
*/
/*----------------------------- OCIStringPtr --------------------------------*/
oratext *OCIStringPtr( OCIEnv *env, const OCIString *vs );
/*
NAME: OCIStringPtr - OCIString Get String Pointer
PARAMETERS:
env(IN) - pointer to OCI environment handle
vs (IN) - pointer to the text of this string is returned
DESCRIPTION:
Return the pointer to the text of the given string.
RETURNS:
pointer to the text of the string is returned
*/
/*----------------------- OCIStringAllocSize --------------------------------*/
sword OCIStringAllocSize( OCIEnv *env, OCIError *err, const OCIString *vs,
ub4 *allocsize );
/*
NAME: OCIStringAllocSize - OCIString get Allocated SiZe of string memory
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().
vs (IN) - string whose allocated size in bytes is returned
allocsize (OUT) - allocated size of string memory in bytes is returned
DESCRIPTION:
Return the allocated size of the string memory in bytes. The
allocated size is >= actual string size.
REQUIRES:
vs is a non-null pointer
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR on error
*/
/*****************************************************************************/
/* VARIABLE-LENGTH RAW */
/*****************************************************************************/
/*
* The variable-length raw is represented in C as a pointer to OCIRaw
* structure. The OCIRaw structure is opaque to the user. Functions are
* provided to allow the user to manipulate a variable-length raw.
*
* A variable-length raw can be declared as:
*
* OCIRaw *raw;
*
* For binding variables of type OCIRaw* in OCI calls (OCIBindByName(),
* OCIBindByPos() and OCIDefineByPos()) use the external type code SQLT_LVB.
*/
typedef struct OCIRaw OCIRaw;
/*-------------------------- OCIRawAssignRaw --------------------------------*/
sword OCIRawAssignRaw( OCIEnv *env, OCIError *err, const OCIRaw *rhs,
OCIRaw **lhs );
/*
NAME: OCIRawAssignRaw - OCIRaw Assign Raw (of type OCIRaw*) to
Raw (of type OCIRaw*)
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().
rhs (IN) - RHS of the assignment, the type of rhs is also OCIRaw
lhs (IN/OUT) - LHS of the assignment
DESCRIPTION:
Assign 'rhs' raw to 'lhs' raw. The 'lhs' raw may be
resized depending upon the size of the 'rhs'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
out of space error
*/
/*------------------------ OCIRawAssignBytes --------------------------------*/
sword OCIRawAssignBytes( OCIEnv *env, OCIError *err, const ub1 *rhs,
ub4 rhs_len, OCIRaw **lhs );
/*
NAME: OCIRawAssignBytes - OCIRaw Assign raw Bytes (of type ub1*) to Raw
(of type OCIRaw*)
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().
rhs (IN) - RHS of the assignment, the type of rhs is ub1 *
rhs_len (IN) - length of the 'rhs' raw
lhs (IN/OUT) - LHS of the assignment
DESCRIPTION:
Assign 'rhs' raw to 'lhs' raw. The 'lhs' raw may be
resized depending upon the size of the 'rhs'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
out of space error
*/
/*---------------------------- OCIRawResize ---------------------------------*/
sword OCIRawResize( OCIEnv *env, OCIError *err, ub4 new_size,
OCIRaw **raw );
/*
NAME: OCIRawResize - OCIRaw ReSiZe memory of variable-length raw
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().
new_size (IN) - new size of the raw data in bytes
raw (IN) - variable-length raw pointer; the raw is
resized to 'new_size'
DESCRIPTION:
This function resizes the memory of the given variable-length raw in
the object cache.
The previous contents of the raw are NOT preserved.
This function may allocate the raw in a new memory region in
which case the original memory occupied by the given raw will
be freed. If the input raw is null (raw == NULL), then this
function will allocate memory for the raw data.
If the new_size is 0, then this function frees the memory occupied
by 'raw' and a null pointer value is returned.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
out of space error
*/
/*------------------------------- OCIRawSize --------------------------------*/
ub4 OCIRawSize( OCIEnv * env, const OCIRaw *raw );
/*
NAME: OCIRawSize - OCIRaw Get Raw siZe
PARAMETERS:
env (IN) - pointer to OCI environment handle
raw (INT) - raw whose size is returned
DESCRIPTION:
Return the size of the given raw.
RETURNS:
size of the raw in bytes is returned
*/
/*--------------------------------- OCIRawPtr -------------------------------*/
ub1 *OCIRawPtr( OCIEnv * env, const OCIRaw *raw );
/*
NAME: OCIRawPtr - OCIRaw Get Raw data Pointer
PARAMETERS:
env (IN) - pointer to OCI environment handle
raw (IN) - pointer to the data of this raw is returned
DESCRIPTION:
Return the pointer to the data of the given raw.
RETURNS:
pointer to the data of the raw is returned
*/
/*------------------------------ OCIRawAllocSize ----------------------------*/
sword OCIRawAllocSize( OCIEnv *env, OCIError *err, const OCIRaw *raw,
ub4 *allocsize );
/*
NAME: OCIRawAllocSize - OCIRaw get Allocated SiZe of raw memory 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().
raw (IN) - raw whose allocated size in bytes is returned
allocsize (OUT) - allocated size of raw memory in bytes is returned
DESCRIPTION:
Return the allocated size of the raw memory in bytes. The
allocated size is >= actual raw size.
REQUIRES:
raw is a non-null pointer
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR upon error
*/
/*****************************************************************************/
/* OBJECT REFERENCE OPERATIONS */
/*****************************************************************************/
/*
* See the definition of OCIRef in oro.h.
*
* For binding variables of type OCIRef* in OCI calls (OCIBindByName(),
* OCIBindByPos() and OCIDefineByPos()) use the code SQLT_REF.
*
*/
/*---------------------------- OCIRefClear ----------------------------------*/
void OCIRefClear( OCIEnv *env, OCIRef *ref );
/*
NAME: OCIRefClear - OCIRef CLeaR or nullify a ref
PARAMETERS:
env (IN) - pointer to OCI environment handle
ref (IN/OUT) - ref to clear
DESCRIPTION:
Clear or nullify the given ref. A ref is considered to be a null ref
if it does not contain a valid OID (and thus doesn't point to an
object). Logically, a null ref is a dangling ref.
Note that a null ref is still a valid SQL value and is not SQL-ly null.
It can be used as a valid non-null constant ref value for NOT NULL
column or attribute of a row in a table.
If a null pointer value is passed as a ref,
then this function is a no-op.
*/
/*--------------------------- OCIRefAssign ----------------------------------*/
sword OCIRefAssign( OCIEnv *env, OCIError *err, const OCIRef *source,
OCIRef **target );
/*
NAME: OCIRefAssign - OCIRef CoPY a ref to another
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().
source (IN) - ref to copy from
target (IN/OUT) - ref to copy to
DESCRIPTION:
Copy 'source' ref to 'target' ref; both then reference the same
object. If the target ref pointer is null (i.e. *target == NULL)
then the copy function will allocate memory for the target ref
in OOCI heap prior to the copy.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
1) out of memory
*/
/*-------------------------- OCIRefIsEqual ----------------------------------*/
boolean OCIRefIsEqual( OCIEnv *env, const OCIRef *x, const OCIRef *y );
/*
NAME: OCIRefIsEqual - OCIRef compare two refs for EQUality
PARAMETERS:
env (IN) - pointer to OCI environment handle
x (IN) - ref to compare
y (IN) - ref to compare
DESCRIPTION:
Compare the given refs for equality.
Two refs are equal if and only if:
- they are both referencing the same persistent object, or
- they are both referencing the same transient object.
NOTE THAT TWO NULL REFS ARE CONSIDERED NOT EQUAL BY THIS FUNCTION.
RETURNS:
TRUE if the two refs are equal
FALSE if the two refs are not equal, or X is NULL, or Y is NULL
*/
/*--------------------------- OCIRefIsNull ----------------------------------*/
boolean OCIRefIsNull( OCIEnv *env, const OCIRef *ref );
/*
NAME: OCIRefIsNull - OCIRef test if a ref is NULl
PARAMETERS:
env (IN) - pointer to OCI environment handle
ref (IN) - ref to test for null
DESCRIPTION:
Return TRUE if the given ref is null; otherwise, return FALSE.
A ref is null if and only if:
- it is supposed to be referencing a persistent object, but
its OID is null, or
- it is supposed to be referencing a transient object, but it is
currently not pointing to an object.
A ref is a dangling ref if the object that it points to does not
exist.
RETURNS:
TRUE if the given ref is NULL
FALSE if the given ref is not NULL
*/
/*-------------------------- OCIRefHexSize ----------------------------------*/
ub4 OCIRefHexSize( OCIEnv *env, const OCIRef *ref );
/*
NAME: OCIRefHexSize - OCIRef Hexadecimal buffer SiZe in bytes
PARAMETERS:
env (IN) - pointer to OCI environment handle
ref (IN) - ref whose size in hexadecimal representation in bytes is
returned
DESCRIPTION:
Return the size of the buffer in bytes required for the hexadecimal
representation of the ref. A buffer of at-least this size must be
passed to ref-to-hex (OCIRefToHex) conversion function.
RETURNS:
size of hexadecimal representation of ref
*/
/*-------------------------- OCIRefFromHex ---------------------------------*/
sword OCIRefFromHex( OCIEnv *env, OCIError *err, const OCISvcCtx *svc,
const oratext *hex, ub4 length, OCIRef **ref );
/*
NAME:
OCIRefFromHex - OCIRef convert a Hexadecimal string TO a 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().
svc (IN) - OCI service context handle; if the resulting ref is
initialized with this service context
hex (IN) - hexadecimal string (that was produced by 'OCIRefToHex()"
previously) to be convert into a ref
length (IN) - length of the hexadecimal string
ref (IN/OUT) - ref is initialized with the given value ('hex').
If *ref is null, then space for the ref is allocated in the
object cache, otherwise the memory occupied by the given ref
is re-used.
DESCRIPTION:
Convert the given hexadecimal string into a ref. This function
ensures that the resulting ref is well formed. It does NOT ensure
that the object pointed to by the resulting ref exists or not.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
*/
/*--------------------------- OCIRefToHex -----------------------------------*/
sword OCIRefToHex( OCIEnv *env, OCIError *err, const OCIRef *ref,
oratext *hex, ub4 *hex_length );
/*
NAME:
OCIRefToHex - OCIRef convert ref to a Hexadecimal string
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().
ref (IN) - ref to be converted into a hexadecimal string; if the
ref is a null ref (i.e. OCIRefIsNull(ref) == TRUE) then
a zero hex_length value is returned
hex (OUT) - buffer that is large enough to contain the resulting
hexadecimal string; the contents of the string is opaque
to the caller
hex_length (IN/OUT) - on input specifies the size of the 'hex' buffer,
on output specifies the actual size of the hexadecimal
string being returned in 'hex'
DESCRIPTION:
Convert the given ref into a hexadecimal string, and return the length
of the string. The resulting string is opaque to the caller.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
the given buffer is not big enough to hold the resulting string
*/
/*****************************************************************************/
/* COLLECTION FUNCTIONS */
/*****************************************************************************/
/*
The generic collection is represented by the type 'OCIColl'. The following
operations OCIColl*() are provided on a generic collection:
- get current size of collection
- get upper bound of collection
- get pointer to an element given its index
- set element at given index (assign element)
- append an element
- trim the given number of elements from the end of the collection
- collection assignment
The following iterator based scanning functions are also provided on a
generic collection. These functions make use of an iterator which is
defined to be of type OCIIter.
- create an iterator for scanning collection
- destroy iterator
- reset iterator to the beginning of collection
- get pointer to current element pointed by iterator
- get pointer to next element
- get pointer to previous element
The collections variable-length array (varray) and nested table
are sub-types of generic collection. This means that the OCIColl*()
functions can also be used to manipulate varray and nested table.
The varray is represented by OCIArray type and nested table by OCITable.
Besides OCIColl*() functions no additional functions are provided for
manipulating varrays. The OCIColl*() functions are a complete set of
functions to manipulate varrays.
Besides OCIColl*() functions, the following functions OCITable*() can be
used to manipulate nested table. The OCITable*() functions operate on
nested tables only and should not be used on a varray.
- delete an element at index i. Note that the position
ordinals of the remaining elements of the table is not changed by the
delete operation. So delete creates "holes" in the table.
- check if an element exists at the given index i
- return the smallest value of i for which exists(i) is true
- return the largest value of i for which exists(i) is true
- return pointer to the smallest position j, greater than i, such that
OCITableExists(j) is true
- return pointer to the largest position j, less than i, such that
OCITableExists(j) is true
For binding variables of type OCIColl* or OCITable* in OCI calls
(OCIBindByName(), OCIBindByPos() and OCIDefineByPos()) use the external
type code SQLT_NTY.
*/
/* OCIColl - generic collection type */
typedef struct OCIColl OCIColl;
/* OCIArray - varray collection type */
typedef OCIColl OCIArray;
/* OCITable - nested table collection type */
typedef OCIColl OCITable;
/* OCIIter - collection iterator */
typedef struct OCIIter OCIIter;
/*----------------------------- OCICollSize ---------------------------------*/
sword OCICollSize( OCIEnv *env, OCIError *err, const OCIColl *coll,
sb4 *size );
/*
NAME: OCICollSize - OCIColl return current SIZe of the given collection
PARAMETERS:
env(IN) - pointer to OCI environment handle
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().
coll (IN) - collection whose number of elements is returned
size (OUT) - current number of elements in the collection
DESCRIPTION:
Returns the current number of elements in the given collection.
For collections of type nested table wherein 'delete element'
operation is allowed, the count returned by OCICollSize() will
NOT be decremented upon deleting elements. For example:
OCICollSize(...);
// assume 'size' returned is equal to 5
OCITableDelete(...); // delete one element
OCICollSize(...);
// 'size' returned will still be 5
To get the count minus the deleted elements use OCITableSize().
Continuing the above example,
OCITableSize(...)
// 'size' returned will be equal to 4
Note, a trim operation (OCICollTrim) will decrement the count
by the number of trimmed elements. Continuing the above example,
OCICollTrim(..,1..); // trim one element
OCICollSize(...);
// 'size' returned will be equal to 4
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
error during loading of collection into object cache
any of the input parameters is null
*/
/*------------------------------ OCICollMax ---------------------------------*/
sb4 OCICollMax( OCIEnv *env, const OCIColl *coll );
/*
NAME: OCICollMax - OCIColl return MAXimum size (upper-bound) of the
given collection (in number of elements)
PARAMETERS:
env(IN) - pointer to OCI environment handle
coll (IN) - collection whose upper-bound in number of elements
is returned
DESCRIPTION:
Returns the max number of elements that the given collection can hold.
A value 0 indicates that the collection has no upper-bound.
REQUIRES:
coll must point to a valid collection descriptor
RETURNS:
upper-bound of the given collection
*/
/*-------------------------- OCICollGetElem ---------------------------------*/
sword OCICollGetElem( OCIEnv *env, OCIError *err, const OCIColl *coll,
sb4 index, boolean *exists, void **elem,
void **elemind );
/*
NAME: OCICollGetElem - OCIColl GET pointer to the element at the given index
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().
coll (IN) - pointer to the element in this collection is returned
index (IN) - index of the element whose pointer is returned
exists (OUT) - set to FALSE if element at the specified index does
not exist else TRUE
elem (OUT) - address of the desired element is returned
elemind (OUT) [optional] - address of the null indicator information
is returned; if (elemind == NULL) then the null indicator
information will NOT be returned
DESCRIPTION:
Get the address of the element at the given position. Optionally
this function also returns the address of the element's null indicator
information.
The following table describes for each collection element type
what the corresponding element pointer type is. The element pointer
is returned via the 'elem' parameter of OCICollGetElem().
Element Type *elem is set to
----------------------- ---------------
Oracle Number (OCINumber) OCINumber*
Date (OCIDate) OCIDate*
Variable-length string (OCIString*) OCIString**
Variable-length raw (OCIRaw*) OCIRaw**
object reference (OCIRef*) OCIRef**
lob locator (OCILobLocator*) OCILobLocator**
object type (e.g. person) person*
The element pointer returned by OCICollGetElem() is in a form
such that it can not only be used to access the
element data but also is in a form that can be used as the target
(i.e left-hand-side) of an assignment statement.
For example, assume the user is iterating over the elements of
a collection whose element type is object reference (OCIRef*). A call
to OCICollGetElem() returns pointer to a reference handle
(i.e. OCIRef**). After getting, the pointer to the collection
element, the user may wish to modify it by assigning a new reference.
This can be accomplished via the ref assignment function shown below:
sword OCIRefAssign( OCIEnv *env, OCIError *err, const OCIRef *source,
OCIRef **target );
Note that the 'target' parameter of OCIRefAssign() is of type
'OCIRef**'. Hence OCICollGetElem() returns 'OCIRef**'.
If '*target == NULL' a new ref will be allocated by OCIRefAssign()
and returned via the 'target' parameter.
Similarly, if the collection element was of type string (OCIString*),
OCICollGetElem() returns pointer to string handle
(i.e. OCIString**). If a new string is assigned, via
OCIStringAssign() or OCIStringAssignText() the type of the target
must be 'OCIString **'.
If the collection element is of type Oracle number, OCICollGetElem()
returns OCINumber*. The prototype of OCINumberAssign() is shown below:
sword OCINumberAssign(OCIError *err, const OCINumber *from,
OCINumber *to);
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
*/
/*------------------------- OCICollGetElemArray -----------------------------*/
sword OCICollGetElemArray( OCIEnv *env, OCIError *err, const OCIColl *coll,
sb4 index, boolean *exists, void **elem,
void **elemind, uword *nelems);
/*
NAME: OCICollGetElemArray - OCIColl GET pointers to elements from given index
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().
coll (IN) - pointers to the elements in this collection is returned
index (IN) - starting index of the element
exists (OUT) - set to FALSE if element at the specified index does
not exist else TRUE
elem (OUT) - address of the desired elements is returned
elemind (OUT) [optional] - address of the null indicators information
is returned; if (elemind == NULL) then the null indicator
information will NOT be returned
nelems(IN/OUT) - Upper bound of elem and/or elemind array
DESCRIPTION:
Get the address of the elements from the given position. Optionally
this function also returns the address of the element's null indicator
information.
The following table describes for each collection element type
what the corresponding element pointer type is. The element pointer
is returned via the 'elem' parameter of OCICollGetElem().
Element Type *elem is set to
----------------------- ---------------
Oracle Number (OCINumber) OCINumber*
Date (OCIDate) OCIDate*
Variable-length string (OCIString*) OCIString**
Variable-length raw (OCIRaw*) OCIRaw**
object reference (OCIRef*) OCIRef**
lob locator (OCILobLocator*) OCILobLocator**
object type (e.g. person) person*
The element pointer returned by OCICollGetElem() is in a form
such that it can not only be used to access the
element data but also is in a form that can be used as the target
(i.e left-hand-side) of an assignment statement.
For example, assume the user is iterating over the elements of
a collection whose element type is object reference (OCIRef*). A call
to OCICollGetElem() returns pointer to a reference handle
(i.e. OCIRef**). After getting, the pointer to the collection
element, the user may wish to modify it by assigning a new reference.
This can be accomplished via the ref assignment function shown below:
sword OCIRefAssign( OCIEnv *env, OCIError *err, const OCIRef *source,
OCIRef **target );
Note that the 'target' parameter of OCIRefAssign() is of type
'OCIRef**'. Hence OCICollGetElem() returns 'OCIRef**'.
If '*target == NULL' a new ref will be allocated by OCIRefAssign()
and returned via the 'target' parameter.
Similarly, if the collection element was of type string (OCIString*),
OCICollGetElem() returns pointer to string handle
(i.e. OCIString**). If a new string is assigned, via
OCIStringAssign() or OCIStringAssignText() the type of the target
must be 'OCIString **'.
If the collection element is of type Oracle number, OCICollGetElem()
returns OCINumber*. The prototype of OCINumberAssign() is shown below:
sword OCINumberAssign(OCIError *err, const OCINumber *from,
OCINumber *to);
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
*/
/*----------------------- OCICollAssignElem ---------------------------------*/
sword OCICollAssignElem( OCIEnv *env, OCIError *err, sb4 index,
const void *elem,
const void *elemind, OCIColl *coll );
/*
NAME: OCICollAssignElem - OCIColl ASsign Element
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().
index (IN) - index of the element whose is assigned to
elem (IN) - element which is assigned from (source element)
elemind (IN) [optional] - pointer to the element's null indicator
information; if (elemind == NULL) then the null indicator
information of the assigned element will be set to non-null.
coll (IN/OUT) - collection to be updated
DESCRIPTION:
Assign the given element value 'elem' to the element at coll[index].
If the collection is of type nested table, the element at the given
index may not exist (i.e. may have been deleted). In this case, the
given element is inserted at index 'index'.
Otherwise, the element at index 'index' is updated with the value
of 'elem'.
Note that the given element is deep-copied and
'elem' is strictly an input parameter.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
out of memory error
given index is out of bounds of the given collection
*/
/*--------------------------- OCICollAssign ---------------------------------*/
sword OCICollAssign( OCIEnv *env, OCIError *err, const OCIColl *rhs,
OCIColl *lhs );
/*
NAME: OCICollAssign - OCIColl ASsiGn collection
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().
rhs (IN) - collection to be assigned from
lhs (OUT) - collection to be assigned to
DESCRIPTION:
Assign 'rhs' to 'lhs'. The 'lhs' collection may be decreased or
increased depending upon the size of 'rhs'. If the 'lhs' contains
any elements then the elements will be deleted prior to the
assignment. This function performs a deep-copy. The memory for the
elements comes from the object cache.
An error is returned if the element types of the lhs and rhs
collections do not match. Also, an error is returned if the
upper-bound of the lhs collection is less than the current number of
elements in the rhs collection.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
out of memory error
type mis-match of lhs and rhs collections
upper-bound of lhs collection is less than the current number of
elements in the rhs collection
*/
/*--------------------------- OCICollAppend ---------------------------------*/
sword OCICollAppend( OCIEnv *env, OCIError *err, const void *elem,
const void *elemind, OCIColl *coll );
/*
NAME: OCICollAppend - OCIColl APPend collection
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 element which is appended to the end
of the given collection
elemind (IN) [optional] - pointer to the element's null indicator
information; if (elemind == NULL) then the null indicator
information of the appended element will be set to non-null.
coll (IN/OUT) - updated collection
DESCRIPTION:
Append the given element to the end of the given collection.
Appending an element is equivalent to:
- increasing the size of the collection by 1 element
- updating (deep-copying) the last element's data with the given
element's data
Note that the pointer to the given element 'elem' will not be saved
by this function. So 'elem' is strictly an input parameter.
An error is returned if the current size of the collection
is equal to the max size (upper-bound) of the collection prior to
appending the element.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
out of memory error
current size of collection == max size of the collection
*/
/*----------------------------- OCICollTrim ---------------------------------*/
sword OCICollTrim( OCIEnv *env, OCIError *err, sb4 trim_num,
OCIColl *coll );
/*
NAME: OCICollTrim - OCIColl Trim elements from the end of the collection
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().
trim_num (IN) - number of elements to trim
coll (IN/OUT) - 'trim_num' of elements are removed (freed) from the
end of the collection
DESCRIPTION:
Trim the collection by the given number of elements. The elements are
removed from the end of the collection.
An error is returned if the 'trim_num' is greater than the current
size of the collection.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
'trim_num' is greater than the current size of the collection.
*/
/*--------------------------- OCICollIsLocator ------------------------------*/
sword OCICollIsLocator(OCIEnv *env, OCIError *err, const OCIColl *coll,
boolean *result );
/*
Name: OCICollIsLocator - OCIColl indicates whether a collection is locator
based or not.
Parameters:
env(IN) - pointer to OCI environment handle
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().
coll (IN) - collection item.
result (OUT) - TRUE if the collection item is a locator, FALSE
otherwise
Description:
Returns TRUE in the result OUT parameter if the collection item is a
locator, otherwise returns FALSE.
Returns:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
*/
/*---------------------------- OCIIterCreate --------------------------------*/
sword OCIIterCreate( OCIEnv *env, OCIError *err, const OCIColl *coll,
OCIIter **itr );
/*
NAME: OCIIterCreate - OCIColl Create an ITerator to scan the collection
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().
coll (IN) - collection which will be scanned; the different
collection types are varray and nested table
itr (OUT) - address to the allocated collection iterator is
returned by this function
DESCRIPTION:
Create an iterator to scan the elements of the collection. The
iterator is created in the object cache. The iterator is initialized
to point to the beginning of the collection.
If the next function (OCIIterNext) is called immediately
after creating the iterator then the first element of the collection
is returned.
If the previous function (OCIIterPrev) is called immediately after
creating the iterator then "at beginning of collection" error is
returned.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
out of memory error
*/
/*----------------------------- OCIIterDelete ------------------------------*/
sword OCIIterDelete( OCIEnv *env, OCIError *err, OCIIter **itr );
/*
NAME: OCIIterDelete - OCIColl Delete ITerator
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().
itr (IN/OUT) - the allocated collection iterator is destroyed and
the 'itr' is set to NULL prior to returning
DESCRIPTION:
Delete the iterator which was previously created by a call to
OCIIterCreate.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
to be discovered
*/
/*----------------------------- OCIIterInit ---------------------------------*/
sword OCIIterInit( OCIEnv *env, OCIError *err, const OCIColl *coll,
OCIIter *itr );
/*
NAME: OCIIterInit - OCIColl Initialize ITerator to scan the given
collection
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().
coll (IN) - collection which will be scanned; the different
collection types are varray and nested table
itr (IN/OUT) - pointer to an allocated collection iterator
DESCRIPTION:
Initializes the given iterator to point to the beginning of the
given collection. This function can be used to:
a. reset an iterator to point back to the beginning of the collection
b. reuse an allocated iterator to scan a different collection
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
*/
/*------------------------ OCIIterGetCurrent --------------------------------*/
sword OCIIterGetCurrent( OCIEnv *env, OCIError *err, const OCIIter *itr,
void **elem, void **elemind );
/*
NAME: OCIIterGetCurrent - OCIColl Iterator based, get CURrent collection
element
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().
itr (IN) - iterator which points to the current element
elem (OUT) - address of the element pointed by the iterator is returned
elemind (OUT) [optional] - address of the element's null indicator
information is returned; if (elemind == NULL) then the null
indicator information will NOT be returned
DESCRIPTION:
Returns pointer to the current element and its corresponding null
information.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
*/
/*------------------------------ OCIIterNext --------------------------------*/
sword OCIIterNext( OCIEnv *env, OCIError *err, OCIIter *itr,
void **elem, void **elemind, boolean *eoc );
/*
NAME: OCIIterNext - OCIColl Iterator based, get NeXT collection element
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().
itr (IN/OUT) - iterator is updated to point to the next element
elem (OUT) - after updating the iterator to point to the next element,
address of the element is returned
elemind (OUT) [optional] - address of the element's null indicator
information is returned; if (elemind == NULL) then the null
indicator information will NOT be returned
eoc (OUT) - TRUE if iterator is at End Of Collection (i.e. next
element does not exist) else FALSE
DESCRIPTION:
Returns pointer to the next element and its corresponding null
information. The iterator is updated to point to the next element.
If the iterator is pointing to the last element of the collection
prior to executing this function, then calling this function will
set eoc flag to TRUE. The iterator will be left unchanged in this
situation.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
*/
/*------------------------------ OCIIterPrev --------------------------------*/
sword OCIIterPrev( OCIEnv *env, OCIError *err, OCIIter *itr,
void **elem, void **elemind, boolean *boc );
/*
NAME: OCIIterPrev - OCIColl Iterator based, get PReVious collection element
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().
itr (IN/OUT) - iterator is updated to point to the previous
element
elem (OUT) - after updating the iterator to point to the previous
element, address of the element is returned
elemind (OUT) [optional] - address of the element's null indicator
information is returned; if (elemind == NULL) then the null
indicator information will NOT be returned
boc (OUT) - TRUE if iterator is at Beginning Of Collection (i.e.
previous element does not exist) else FALSE.
DESCRIPTION:
Returns pointer to the previous element and its corresponding null
information. The iterator is updated to point to the previous element.
If the iterator is pointing to the first element of the collection
prior to executing this function, then calling this function will
set 'boc' to TRUE. The iterator will be left unchanged in this
situation.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
*/
/*****************************************************************************/
/* FUNCTIONS WHICH OPERATE ONLY ON NESTED TABLE OCITable*() */
/*****************************************************************************/
/*---------------------------- OCITableSize ---------------------------------*/
sword OCITableSize( OCIEnv *env, OCIError *err, const OCITable *tbl,
sb4 *size);
/*
NAME: OCITableSize - OCITable return current SIZe of the given
nested table (not including deleted elements)
PARAMETERS:
env(IN) - pointer to OCI environment handle
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().
tbl (IN) - nested table whose number of elements is returned
size (OUT) - current number of elements in the nested table. The count
does not include deleted elements.
DESCRIPTION:
Returns the count of elements in the given nested table.
The count returned by OCITableSize() will be decremented upon
deleting elements from the nested table. So, this count DOES NOT
includes any "holes" created by deleting elements.
For example:
OCITableSize(...);
// assume 'size' returned is equal to 5
OCITableDelete(...); // delete one element
OCITableSize(...);
// 'size' returned will be equal to 4
To get the count plus the count of deleted elements use
OCICollSize(). Continuing the above example,
OCICollSize(...)
// 'size' returned will still be equal to 5
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
error during loading of nested table into object cache
any of the input parameters is null
*/
/*---------------------- OCITableExists ---------------------------------*/
sword OCITableExists( OCIEnv *env, OCIError *err, const OCITable *tbl,
sb4 index, boolean *exists );
/*
NAME: OCITableExists - OCITable test whether element at the given index
EXIsts
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().
tbl (IN) - table in which the given index is checked
index (IN) - index of the element which is checked for existence
exists (OUT) - set to TRUE if element at given 'index' exists
else set to FALSE
DESCRIPTION:
Test whether an element exists at the given 'index'.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
*/
/*--------------------------- OCITableDelete -------------------------------*/
sword OCITableDelete( OCIEnv *env, OCIError *err, sb4 index,
OCITable *tbl );
/*
NAME: OCITableDelete - OCITable DELete element at the specified index
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().
index (IN) - index of the element which must be deleted
tbl (IN) - table whose element is deleted
DESCRIPTION:
Delete the element at the given 'index'. Note that the position
ordinals of the remaining elements of the table is not changed by the
delete operation. So delete creates "holes" in the table.
An error is returned if the element at the specified 'index' has
been previously deleted.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
any of the input parameters is null
given index is not valid
*/
/*--------------------------- OCITableFirst ---------------------------------*/
sword OCITableFirst( OCIEnv *env, OCIError *err, const OCITable *tbl,
sb4 *index );
/*
NAME: OCITableFirst - OCITable return FirST index of table
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().
tbl (IN) - table which is scanned
index (OUT) - first index of the element which exists in the given
table is returned
DESCRIPTION:
Return the first index of the element which exists in the given
table.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
table is empty
*/
/*---------------------------- OCITableLast ---------------------------------*/
sword OCITableLast( OCIEnv *env, OCIError *err, const OCITable *tbl,
sb4 *index );
/*
NAME: OCITableFirst - OCITable return LaST index of table
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().
tbl (IN) - table which is scanned
index (OUT) - last index of the element which exists in the given
table is returned
DESCRIPTION:
Return the last index of the element which exists in the given
table.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
table is empty
*/
/*---------------------------- OCITableNext ---------------------------------*/
sword OCITableNext( OCIEnv *env, OCIError *err, sb4 index,
const OCITable *tbl, sb4 *next_index,
boolean *exists );
/*
NAME: OCITableNext - OCITable return NeXT available index of table
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().
index (IN) - starting at 'index' the index of the next element
which exists is returned
tbl (IN) - table which is scanned
next_index (OUT) - index of the next element which exists
is returned
exists (OUT) - FALSE if no next index available else TRUE
DESCRIPTION:
Return the smallest position j, greater than 'index', such that
exists(j) is TRUE.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
no next index available
*/
/*---------------------------- OCITablePrev ---------------------------------*/
sword OCITablePrev( OCIEnv *env, OCIError *err, sb4 index,
const OCITable *tbl, sb4 *prev_index,
boolean *exists );
/*
NAME: OCITablePrev - OCITable return PReVious available index of table
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().
index (IN) - starting at 'index' the index of the previous element
which exists is returned
tbl (IN) - table which is scanned
prev_index (OUT) - index of the previous element which exists
is returned
exists (OUT) - FALSE if no next index available else TRUE
DESCRIPTION:
Return the largest position j, less than 'index', such that
exists(j) is TRUE.
RETURNS:
OCI_SUCCESS if the function completes successfully.
OCI_INVALID_HANDLE if 'env' or 'err' is NULL.
OCI_ERROR if
no previous index available
*/
/*------------------------ OCINumberToLnx -----------------------------------*/
/* void OCINumberToLnx(/o_ OCINumber *num _o/); */
#define OCINumberToLnx(num) ((lnxnum_t *)num)
/*
NAME: OCINumberToLnx
PARAMETERS:
num (IN) - OCINumber to convert ;
DESCRIPTION:
Converts OCINumber to its internal lnx format
This is not to be used in Public interfaces , but
has been provided due to special requirements from
SQLPLUS development group as they require to call
Core funtions directly .
*/
/* OCI representation of XMLType */
typedef struct OCIXMLType OCIXMLType;
/* OCI representation of OCIDomDocument */
typedef struct OCIDOMDocument OCIDOMDocument;
/* OCI representation for the Binary XML repository context */
typedef struct OCIBinXmlReposCtx OCIBinXmlReposCtx;
#endif /* ORL_ORACLE */
Reference in New Issue View Git Blame Copy Permalink