orl.h

将对Oracle数据库读写操作的OCI进行封装。不但具有普通数据的读取操作

sword OCINumberInc(/*_ OCIError *err, OCINumber *number _*/);
#else /* ANSI C */
sword OCINumberInc(    OCIError *err, OCINumber *number    );
#endif
/*
   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 --------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
sword OCINumberDec(/*_ OCIError *err, OCINumber *number _*/);
#else /* ANSI C */
sword OCINumberDec(    OCIError *err, OCINumber *number    );
#endif
/*
   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 -------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
void OCINumberSetZero(/*_ OCIError *err, OCINumber *num _*/); 
#else /* ANSI C */
void OCINumberSetZero(    OCIError *err, OCINumber *num    );
#endif
/*
   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 --------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
void OCINumberSetPi(/*_ OCIError *err, OCINumber *num _*/); 
#else /* ANSI C */
void OCINumberSetPi(    OCIError *err, OCINumber *num    );
#endif
/*
   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 --------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
sword OCINumberAdd(/*_ OCIError *err, CONST OCINumber *number1, 
                       CONST OCINumber *number2, OCINumber *result _*/);
#else /* ANSI C */
sword OCINumberAdd(    OCIError *err, CONST OCINumber *number1, 
                       CONST OCINumber *number2, OCINumber *result    );
#endif
/*
   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 --------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
sword OCINumberSub(/*_ OCIError *err, CONST OCINumber *number1, 
                       CONST OCINumber *number2, OCINumber *result _*/);
#else /* ANSI C */
sword OCINumberSub(    OCIError *err, CONST OCINumber *number1, 
                       CONST OCINumber *number2, OCINumber *result    );
#endif
/*
   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 --------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
sword OCINumberMul(/*_ OCIError *err, CONST OCINumber *number1, 
                       CONST OCINumber *number2, OCINumber *result _*/);
#else /* ANSI C */
sword OCINumberMul(    OCIError *err, CONST OCINumber *number1, 
                       CONST OCINumber *number2, OCINumber *result    );
#endif
/*
   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 --------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
sword OCINumberDiv(/*_ OCIError *err, CONST OCINumber *number1, 
                       CONST OCINumber *number2, OCINumber *result _*/);
#else /* ANSI C */
sword OCINumberDiv(    OCIError *err, CONST OCINumber *number1, 
                       CONST OCINumber *number2, OCINumber *result    );
#endif
/*
   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 --------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
sword OCINumberMod(/*_ OCIError *err, CONST OCINumber *number1, 
                       CONST OCINumber *number2, OCINumber *result _*/);
#else /* ANSI C */
sword OCINumberMod(    OCIError *err, CONST OCINumber *number1, 
                       CONST OCINumber *number2, OCINumber *result    );
#endif
/*
   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 --------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
sword OCINumberIntPower(/*_ OCIError *err, CONST OCINumber *base,
                            CONST sword exp, OCINumber *result _*/);
#else /* ANSI C */
sword OCINumberIntPower(    OCIError *err, CONST OCINumber *base,
                            CONST sword exp, OCINumber *result    );
#endif
/*
   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 ---------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
sword OCINumberShift(/*_ OCIError *err, CONST OCINumber *number,
                            CONST sword nDig, OCINumber *result _*/);
#else /* ANSI C */
sword OCINumberShift(    OCIError *err, CONST OCINumber *number,
                            CONST sword nDig, OCINumber *result    );
#endif
/*
   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 --------------------------------*/

#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
sword OCINumberNeg(/*_ OCIError *err, CONST OCINumber *number,
                       OCINumber *result _*/);
#else /* ANSI C */
sword OCINumberNeg(    OCIError *err, CONST OCINumber *number,
                       OCINumber *result    );
#endif
/*
   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().