Oracle9i Globalization Support Guide Release 1 (9.0.1) Part Number A90236-02 |
|
This chapter contains information useful for OCI programming, including:
Many OCI NLS functions accept either the environment handle or the user session handle. The OCI environment handle is associated with the client NLS environment and initialized with the client NLS settings (environment variables). This environment does not change when ALTER
SESSION
statements are issued to the server. The character set associated with the environment handle is the client character set. The OCI session handle (returned by OCISessionBegin
) is associated with the server session environment. Its NLS settings change when the session environment is modified with ALTER
SESSION
. The character set associated with the session handle is the database character set.
Note that the OCI session handle does not have any NLS settings associated with it until the first transaction begins in the session. SELECT
statements do not begin a transaction.
An Oracle locale consists of language, territory, and character set definitions. The locale determines conventions such as native day and month names, as well as date, time, number, and currency formats. An internationalized application obeys a user's locale setting and cultural conventions. For example, in a German locale setting, users expect to see day and month names in German.
Using environment handles, you can retrieve the following information:
sword OCINlsGetInfo(dvoid *hndl, OCIError *errhp, OraText *buf, size_t buflen, ub2 item)
This function generates language information specified by item from OCI environment or user session handle hndl
into an array pointed to by buf
within a size limitation as buflen
. If the Unicode mode is enabled, then text data is returned in UTF-16.
OCI_SUCCESS
, OCI_INVALID_HANDLE
, or OCI_ERROR
on wrong items
When calling OCINlsGetInfo
(), you need to allocate the buffer to store the returned information for the particular language. The buffer size varies, depending on which item you are querying and what encoding you are using to store the information. Developers should not need to know how many bytes it takes to store "January" in Japanese using JA16SJIS encoding. That is exactly what OCI_NLS_MAXBUFSZ
is used for; it guarantees that the OCI_NLS_MAXBUFSZ
is big enough to hold the largest item returned by OCINlsGetInfo
(). This guarantees that the largest item returned by OCINlsGetInfo
() will fit in the buffer.
The following is a simple case of retrieving information and checking for errors.
sword MyPrintLinguisticName(envhp, errhp) OCIEnv *envhp; OCIError *errhp; { OraText infoBuf[OCI_NLS_MAXBUFSZ]; sword ret; ret = OCINlsGetInfo(envhp, /* environment handle */ errhp, /* error handle */ infoBuf, /* destination buffer */ (size_t) OCI_NLS_MAXBUFSZ, /* buffer size */ (ub2) OCI_NLS_LINGUISTIC_NAME); /* item */ if (ret != OCI_SUCCESS) { checkerr(errhp, ret, OCI_HTYPE_ERROR); ret = OCI_ERROR; } else { printf("NLS linguistic: %s\n", infoBuf); } return(ret); }
Two types of data structure are supported for string manipulation: multibyte string and wide character string. Multibyte strings are in native Oracle character set encoding and functions operated on them take the string as a whole unit. Wide character string wchar
functions provide more flexibility in string manipulation and support character-based and string-based operations.
The wide character datatype is Oracle-specific and not to be confused with the wchar_t
defined by the ANSI/ISO C standard. The Oracle wide character is always 4 bytes in all platforms, while wchar_t
is depends on the implementation and the platform. The idea of the Oracle wide character is to normalize multibyte character to have a fixed-width encoding for easy processing. This way, round-trip conversion between the Oracle wide character set and the native character set is guaranteed.
The string manipulation can be classified into the following categories:
Table 8-2 OCI String Manipulation Calls
sword OCIMultiByteToWideChar(dvoid *hndl, OCIWchar *dst, CONST OraText *src, size_t *rsize);
This routine converts an entire NULL
-terminated string into the wchar
format. The wchar
output buffer will be NULL
-terminated.
OCI_SUCCESS
, OCI_INVALID_HANDLE
or OCI_ERROR
sword OCIMultiByteInSizeToWideChar(dvoid *hndl, OCIWchar *dst, size_t dstsz, CONST OraText *src, size_t srcsz, size_t *rsize)
This routine converts part of a string into the wchar
format. It will convert as many complete characters as it can until it reaches the output buffer size or input buffer size or it reaches a NULL
-terminator in source string. The output buffer will be NULL
-terminated if space permits. If dstsz
is zero, then this function will only return the number of characters not including the ending NULL
terminator needed for converted string.
OCI_SUCCESS
, OCI_INVALID_HANDLE
or OCI_ERROR
sword OCIWideCharToMultiByte(dvoid *hndl, OraText *dst, CONST OCIWchar *src, size_t *rsize)
This routine converts an entire NULL
-terminated wide character string into a multibyte string. The output buffer will be NULL
-terminated.
OCI_SUCCESS
, OCI_INVALID_HANDLE
or OCI_ERROR
sword OCIWideCharInSizeToMultiByte(dvoid *hndl, OraText *dst, size_t dstsz, CONST OCIWchar *src, size_t srcsz, size_t *rsize)
This routine converts part of wchar
string into the multibyte format. It will convert as many complete characters as it can until it reaches the output buffer size, the input buffer size, or it reaches a NULL
-terminator in source string. The output buffer will be NULL
-terminated if space permits. If dstsz
is zero, the function just returns the size of byte not including the ending NULL
-terminator needed to store the converted string.
OCI_SUCCESS
, OCI_INVALID_HANDLE
or OCI_ERROR
OCIWchar OCIWideCharToLower(dvoid *hndl, OCIWchar wc)
If there is an upper-case character mapping for wc
in the specified locale, it will return the lower-case in wchar
, else return wc itself.
A wchar
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
OCIWchar OCIWideCharToUpper(dvoid *hndl, OCIWchar wc)
If there is a uppercase character mapping for wc
in the specified locale, then it will return the uppercase character in wchar
.Otherwise, it will return the wc
itself.
A wchar
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
int OCIWideCharStrcmp(dvoid *hndl, CONST OCIWchar *wstr1, CONST OCIWchar *wstr2, int flag)
It compares two wchar
strings in binary (based on wchar
encoding value), linguistic, or case-insensitive.
wstr1 == wstr2
wstr1 > wstr2
wstr1 < wstr2
Table 8-9 OCIWideCharStrcmp Keywords/Parameters
int OCIWideCharStrncmp(dvoid *hndl, CONST OCIWchar *wstr1, size_t len1, CONST OCIWchar *wstr2, size_t len2, int flag)
This function is similar to OCIWideCharStrcmp
(), except that at most len1
characters from wstr1
and len2
characters from wstr1 are compared. The NULL
-terminator will be taken into the comparison.
wstr1 = wstr2
wstr1 > wstr2
wstr1 < wstr2
Table 8-10 OCIWideCharStrncmp Keywords/Parameters
size_t OCIWideCharStrcat(dvoid *hndl, OCIWchar *wdststr, CONST OCIWchar *wsrcstr)
This function appends a copy of the wchar string pointed to by wsrcstr
, including the NULL
-terminator to the end of wchar
string pointed to by wdststr
.
The number of characters in the result string, not including the ending NULL
-terminator.
OCIWchar *OCIWideCharStrchr(dvoid *hndl, CONST OCIWchar *wstr, OCIWchar wc)
This function searches for the first occurrence of wc
in the wchar
string pointed to by wstr
.
A wchar
pointer if successful, otherwise a NULL
pointer
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
Pointer to the |
|
|
size_t OCIWideCharStrcpy(dvoid *hndl, OCIWchar *wdststr, CONST OCIWchar *wsrcstr)
This function copies the wchar
string pointed to by wsrcstr
, including the NULL
-terminator, into the array pointed to by wdststr
.
The number of characters copied not including the ending NULL
-terminator.
size_t OCIWideCharStrlen(dvoid *hndl, CONST OCIWchar *wstr)
This function computes the number of characters in the wchar
string pointed to by wstr
, not including the NULL
-terminator, and returns this number.
The number of characters not including ending NULL
-terminator.
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
Pointer to the source |
size_t OCIWideCharStrncat(dvoid *hndl, OCIWchar *wdststr, CONST OCIWchar *wsrcstr, size_t n)
This function is similar to OCIWideCharStrcat
(), except that at most n characters from wsrcstr
are appended to wdststr
. Note that the NULL
-terminator in wsrcstr
will stop appending. wdststr
will be NULL
-terminated.
The number of characters in the result string, not including the ending NULL
-terminator.
size_t OCIWideCharStrncpy(dvoid *hndl, OCIWchar *wdststr, CONST OCIWchar *wsrcstr, size_t n)
This function is similar to OCIWideCharStrcpy
(), except that at most n
characters are copied from the array pointed to by wsrcstr
to the array pointed to by wdststr
. Note that the NULL
-terminator in wdststr
will stop coping and result string will be NULL
-terminated.
The number of characters copied not including the ending NULL
-terminator.
OCIWchar *OCIWideCharStrrchr(dvoid *hndl, CONST OCIWchar *wstr, OCIWchar wc)
This function searches for the last occurrence of wc
in the wchar
string pointed to by wstr
. It returns a pointer to the wchar
if successful, or a NULL
pointer.
wchar
pointer if successful, otherwise a NULL
pointer
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
Pointer to the |
|
|
size_t OCIWideCharStrCaseConversion(dvoid *hndl, OCIWchar *wdststr, CONST OCIWchar*wsrcstr, ub4 flag)
This function converts the wide char
string pointed to by wsrcstr
into the uppercase or lowercase specified by the flag and copies the result into the array pointed to by wdststr
. The result string will be NULL
-terminated.
The number of characters for the result string, not including NULL
-terminator
size_t OCIWideCharDisplayLength(dvoid *hndl, OCIWchar wc)
This function determines the number of column positions required for wc
in display. It returns the number of column positions, or 0 if wc
is the NULL
-terminator.
The number of display positions.
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
size_t OCIWideCharMultiByteLen(dvoid *hndl, OCIWchar wc)
This function determines the number of byte required for wc
in multibyte encoding. It returns the number of bytes in multibyte for wc
.
The number of bytes.
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
int OCIMultiByteStrcmp(dvoid *hndl, CONST OraText *str1, CONST OraText *str2, int flag)
It compares two multibyte strings in binary (based on encoding value), linguistic, or case-insensitive.
str1 == str2
str1 > str2
str1 < str2
Table 8-21 OCIMultiByteStrcmp Keywords/Parameters
int OCIMultiByteStrncmp(dvoid *hndl, CONST OraText *str1, size_t len1, OraText *str2, size_t len2, int flag)
This function is similar to OCIMultiByteStrcmp
(), except that at most len1
bytes from str1
and len2
bytes from str2
are compared. The NULL
-terminator will be taken into the comparison.
str1
= str2
str1
> str2
str1
< str2
Table 8-22 OCIMultiByteStrncmp Keywords/Parameters
size_t OCIMultiByteStrcat(dvoid *hndl, OraText *dststr, CONST OraText *srcstr)
This function appends a copy of the multibyte string pointed to by srcstr
, including the NULL
-terminator to the end of string pointed to by dststr
. It returns the number of bytes in the result string not including the ending NULL
-terminator.
The number of bytes in the result string, not including the ending NULL
-terminator
size_t OCIMultiByteStrcpy(dvoid *hndl, OraText *dststr, CONST OraText *srcstr)
This function copies the multibyte string pointed to by srcstr
, including the NULL
-terminator, into the array pointed to by dststr
. It returns the number of bytes copied, not including the ending NULL
-terminator.
The number of bytes copied, not including the ending NULL
-terminator
Keyword/Parameter | Meaning |
---|---|
|
Pointer to the OCI environment or user session handle |
|
Pointer to the destination buffer |
|
Pointer to the source multibyte string |
size_t OCIMultiByteStrlen(dvoid *hndl, CONST OraText *str)
This function computes the number of bytes in the multibyte string pointed to by str
, not including the NULL
-terminator, and returns this number.
The number of bytes not including ending NULL
-terminator
Keyword/Parameter | Meaning |
---|---|
|
Pointer to the OCI environment or user session handle |
|
Pointer to the source multibyte string |
size_t OCIMultiByteStrncat(dvoid *hndl, OraText *dststr, CONST OraText *srcstr, size_t n)
This function is similar to OCIMultiByteStrcat
(), except that at most n
bytes from srcstr are appended to dststr
. Note that the NULL
-terminator in srcstr
will stop appending and the function will append as many character as possible within n
bytes. dststr
will be NULL
-terminated.
The number of bytes in the result string, not including the ending NULL
-terminator.
size_t OCIMultiByteStrncpy(dvoid *hndl, OraText *dststr, CONST OraText *srcstr, size_t n)
This function is similar to OCIMultiByteStrcpy
(), except that at most n
bytes are copied from the array pointed to by srcstr to the array pointed to by dststr
. Note that the NULL
-terminator in srcstr
will stop coping and the function will copy as many character as possible within n
bytes. The result string will be NULL
-terminated.
The number of bytes copied not including the ending NULL
-terminator
size_t OCIMultiByteStrnDisplayLength(dvoid *hndl, CONST OraText *str1, size_t n)
This function returns the number of display positions occupied by the complete characters within the range of n
bytes.
The number of display positions.
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle |
|
Pointer to a multibyte string |
|
The number of bytes to examine |
size_t OCIMultiByteStrCaseConversion(dvoid *hndl, OraText *dststr, CONST OraText *srcstr, ub4 flag)
This function convert the multibyte string pointed to by srcstr
into the uppercase or lowercase specified by flag and copies the result into the array pointed to by dststr
. The result string will be NULL
-terminated.
The number of bytes for result string, not including NULL
-terminator
The following is a simple case of handling string manipulation.
size_t MyConvertMultiByteToWideChar(envhp, dstBuf, dstSize, srcStr) OCIEnv *envhp; OCIWchar *dstBuf; size_t dstSize; OraText *srcStr; /* null terminated source string */ { sword ret; size_t dstLen = 0; size_t srcLen; /* get length of source string */ srcLen = OCIMultiByteStrlen(envhp, srcStr); ret = OCIMultiByteInSizeToWideChar(envhp, /* environment handle */ dstBuf, /* destination buffer */ dstSize, /* destination buffer size */ srcStr, /* source string */ srcLen, /* length of source string */ &dstLen); /* pointer to destination length */ if (ret != OCI_SUCCESS) { checkerr(envhp, ret, OCI_HTYPE_ENV); } return(dstLen); }
The Oracle Call Interface offers many function calls for classifying characters.
boolean OCIWideCharIsAlnum(dvoid *hndl, OCIWchar wc)
It tests whether wc
is a letter or decimal digit.
TRUE
or FALSE
.
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsAlpha(dvoid *hndl, OCIWchar wc)
It tests whether wc
is an alphabetic letter.
TRUE
or FALSE
.
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsCntrl(dvoid *hndl, OCIWchar wc)
It tests whether wc
is a control character.
TRUE
or FALSE
.
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsDigit(dvoid *hndl, OCIWchar wc)
It tests whether wc
is a decimal digit character.
TRUE
or FALSE
.
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsGraph(dvoid *hndl, OCIWchar wc)
It tests whether wc
is a graph character. A graph character is character with a visible representation and normally includes an alphabetic letter, decimal digit, and punctuation.
TRUE
or FALSE
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsLower(dvoid *hndl, OCIWchar wc)
It tests whether wc
is a lowercase letter.
TRUE
or FALSE
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsPrint(dvoid *hndl, OCIWchar wc)
It tests whether wc
is a printable character.
TRUE
or FALSE
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsPunct(dvoid *hndl, OCIWchar wc)
It tests whether wc
is a punctuation character.
TRUE
or FALSE
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsSpace(dvoid *hndl, OCIWchar wc)
It tests whether wc
is a space character. A space character only causes white space in displayed text (for example, space, tab, carriage return, newline, vertical tab or form feed).
TRUE
or FALSE
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsUpper(dvoid *hndl, OCIWchar wc)
It tests whether wc
is an uppercase letter.
TRUE
or FALSE
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsXdigit(dvoid *hndl, OCIWchar wc)
It tests whether wc
is a hexadecimal digit (0-9, A-F, a-f).
TRUE
or FALSE
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
boolean OCIWideCharIsSingleByte(dvoid *hndl, OCIWchar wc)
It tests whether wc
is a single-byte character when converted into multibyte.
TRUE
or FALSE
Keyword/Parameter | Meaning |
---|---|
|
OCI environment or user session handle to determine the character set |
|
|
/* Character classification sample code */ boolean MyIsNumberWideCharString(envhp, srcStr) OCIEnv *envhp; OCIWchar *srcStr; /* wide char source string */ { OCIWchar *pstr = srcStr; /* define and init pointer */ boolean status = TRUE; /* define and init status variable */ /* Check input */ if (pstr == (OCIWchar*) NULL) return(FALSE); if (*pstr == (OCIWchar) NULL) return(FALSE); /* check each character for digit */ do { if (OCIWideCharIsDigit(envhp, *pstr) != TRUE) { status = FALSE; break; /* non decimal digit character */ } } while ( *++pstr != (OCIWchar) NULL); return(status); }
Conversion between Oracle character set and Unicode (16-bit, fixed-width Unicode encoding) is supported. Replacement characters are used if there a character has no mapping from Unicode to the Oracle character set. Therefore, conversion back to the original character set is not always possible.
sword OCICharSetToUnicode(dvoid *hndl, ub2 *dst, size_t dstlen, CONST OraText *src, size_t srclen, size_t *rsize)
This function converts a multibyte string pointed to by src
to Unicode into the array pointed to by dst
. The conversion will stop when it reaches the source limitation or destination limitation. The function will return the number of characters converted into Unicode. If dstlen
is zero, it will just return the number of characters into rsize
for the result without real conversion.
OCI_SUCCESS
, OCI_INVALID_HANDLE
or OCI_ERROR
sword OCIUnicodeToCharSet(dvoid *hndl, OraText *dst, size_t dstlen, CONST ub2 *src, size_t srclen, size_t *rsize)
This function converts a Unicode string pointed to by src
to multibyte into the array pointed to by dst
. The conversion will stop when it reach to the source limitation or destination limitation. The function will return the number of bytes converted into multibyte. If dstlen
is zero, it will just return the number of bytes into rsize
for the result without real conversion.
If a Unicode character is not convertible for the character set specified in OCI environment or user session handle, a replacement character will be used for it. In this case, OCICharsetConversionIsReplacementUsed
() will return true.
OCI_SUCCESS
, OCI_INVALID_HANDLE
or OCI_ERROR
boolean OCICharSetConversionIsReplacementUsed(dvoid *hndl)
This function indicates whether the replacement character was used for nonconvertible characters in character set conversion in the last invocation of OCICharSetToUnicode
().
TRUE
if the replacement character was used when OCICharsetConv
() was last invoked, else FALSE
.
Keyword/Parameter | Meaning |
---|---|
|
Pointer to an OCI environment or user session handle |
Conversion between the Oracle character set and Unicode (16-bit, fixed-width Unicode encoding) is supported. Replacement characters are used if there is no mapping for a character from Unicode to the Oracle character set. thus, conversion back to the original character set is not always possible.
The following is a simple conversion into Unicode:
size_t MyConvertMultiByteToUnicode(envhp, dstBuf, dstSize, srcStr) OCIEnv *envhp; ub2 *dstBuf; size_t dstSize; OraText *srcStr; { sword ret; size_t dstLen = 0; size_t srcLen; /* get length of source string */ srcLen = OCIMultiByteStrlen(envhp, srcStr); ret = OCICharSetToUnicode(envhp, /* environment handle */ dstBuf, /* destination buffer */ dstSize, /* size of destination buffer */ srcStr, /* source string */ srcLen, /* length of source string */ &dstLen); /* pointer to destination length */ if (ret != OCI_SUCCESS) { checkerr(envhp, ret, OCI_HTYPE_ENV); } return(dstLen); }
The user message API provides a simple interface for cartridge developers to retrieve their own messages as well as Oracle messages.
sword OCIMessageOpen(dvoid *hndl, OCIError *errhp, OCIMsg **msghp, CONST OraText *product, CONST OraText *facility, OCIDuration dur)
This function opens a message-handling facility in a language pointed to by hndl
. It first tries to open the message file corresponding to hndl
for the facility. If it succeeds, it will use that file to initialize a message handle. Otherwise it will use the default message file, whose language is AMERICAN
. The function returns a pointer pointed to a message handle into the msghp
parameter. If the Unicode mode is enabled, then the text parameters must be in UTF-16.
OCI_SUCCESS
, OCI_INVALID_HANDLE
or OCI_ERROR
OraText *OCIMessageGet(OCIMsg *msgh, ub4 msgno, OraText *msgbuf, size_t buflen)
This function will get a message with the message number identified by msgno
. If buflen
is not zero, then the function will copy the message into the buffer pointed to by msgbuf
. If buflen
is zero, then the message will be copied into a message buffer inside the message handle pointed to by msgh
. For both cases. it will return the pointer to the NULL
-terminated message string. If it cannot get the requested message, then it will return a NULL
pointer. If the Unicode mode is enabled, then the message is returned in UTF-16.
If successful, a pointer to a NULL
-terminated message string on success. Otherwise a NULL
pointer
sword OCIMessageClose(dvoid *hndl, OCIError *errhp, OCIMsg *msgh)
This function closes a message handle pointed to by msgh
and frees any memory associated with this handle.
OCI_SUCCESS
, OCI_INVALID_HANDLE
or OCI_ERROR
The lmsgen utility converts text-based message files (.msg
) into binary format (.msb
).
LMSGENtext_file
product
facility
[language
]
where
text file
is a message text fileproduct
is the name of the productfacility
is the name of the facility
[language
] is the optional message language in
<language
>_<territory
>.<character set
> format
This is required if the message file is not tagged properly with language.
# CHARACTER_SET_NAME= Japanese_Japan.JA16EUC
<message #>, <warning level #>, <message text>
/ Copyright (c) 1988 by the Oracle Corporation. All rights reserved. / This is a testing us7ascii message file # CHARACTER_SET_NAME= american_america.us7ascii / 00000, 00000, "Export terminated unsuccessfully\n" 00003, 00000, "no storage definition found for segment(%lu, %lu)"
This example retrieves messages from a .msb
message file. The following settings are used:
product = $HOME/myApp facility = imp Language = American language
Based on the above setting, the $HOME/myApp/mesg/impus.msb
message file will be used.
Lmsgen
converts the message file (impus.msg
) into binary format (impus.msb
).
The following is a portion of the text message file called impus.msg
:
... 00128,2, "Duplicate entry %s found in %s" ...
/* Assume that the OCI
environment or user session handle, product, facility and
cache size are all initialized properly. */
...
OCIMsg msghnd; /* message handle */
/* initialize a message handle for retrieving messages from impus.msg*/
err = OCIMessageOpen(hndl,errhp, &msghnd, prod,fac,OCI_DURATION_SESSION);
if (err != OCI_SUCCESS)
/* error handling */
...
/* retrieve the message with message number = 128 */
msgptr = OCIMessageGet(msghnd, 128, msgbuf, sizeof(msgbuf));
/* do something with the message, such as display it */
...
/* close the message handle when we has no more message to retrieve */
OCIMessageClose(hndl, errhp, msghnd);
|
Copyright © 1996-2001, Oracle Corporation. All Rights Reserved. |
|