ort.h

ORACLE访问接口

        2) All input parameters must not be NULL and must be valid.
   DESCRIPTION:
        Get the type code of the type.
   RETURNS:
        The type code of the type.
   NOTES:
        The type descriptor, 'tdo', must be unpinned when the accessed 
        information is no longer needed.
 */

/*----------------------- OCITypeCollTypeCode -------------------------------*/

/* ** OBSOLETE ** */
#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
OCITypeCode OCITypeCollTypeCode(/*_ OCIEnv *env, OCIError *err,
                                  CONST OCIType *tdo _*/);
#else /* ANSI C */
OCITypeCode OCITypeCollTypeCode(    OCIEnv *env, OCIError *err,
                                    CONST OCIType *tdo    );
#endif
/*
   NAME: OCITypeCollTypeCode - OCI Get a Domain Type's Type Code.
   PARAMETERS: 
        env (IN/OUT) - OCI environment handle initialized in object mode
        err (IN/OUT) - error handle. If there is an error, it is
                recorded in 'err' and this function returns OCI_ERROR.
                The error recorded in 'err' can be retrieved by calling
                OCIErrorGet().
        tdo (IN) - pointer to to the type descriptor in the object cache
   REQUIRES:
        1) All type accessors require that the type be pinned before calling 
           any accessor. 
        2) All input parameters must not be NULL and must be valid.
	3) 'tdo' MUST point to a named collection type.
   DESCRIPTION:
        Get the type code of the named collection type. For V8.0, named
        collection types can only be variable length arrays and nested tables.
   RETURNS:
        OCI_TYPECODE_VARRAY for variable length array, and
        OCI_TYPECODE_TABLE for nested tables.
   NOTES:
        The type descriptor, 'tdo', should be unpinned when the accessed 
        information is no longer needed.
 */

/*------------------------- OCITypeVersion ---------------------------------*/

/* ** OBSOLETE ** */
#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
text* OCITypeVersion(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo, 
                       ub4 *v_length _*/);
#else /* ANSI C */
text* OCITypeVersion(    OCIEnv *env, OCIError *err, CONST OCIType *tdo, 
                         ub4 *v_length    );
#endif
/*
   NAME: OCITypeVersion - OCI Get a Type's user-readable VersioN. 
   PARAMETERS: 
        env (IN/OUT) - OCI environment handle initialized in object mode
        err (IN/OUT) - error handle. If there is an error, it is
                recorded in 'err' and this function returns OCI_ERROR.
                The error recorded in 'err' can be retrieved by calling
                OCIErrorGet().
        tdo (IN) - pointer to to the type descriptor in the object cache
        v_length (OUT) - length (in bytes) of the returned user-readable 
               version.  The caller must allocate space for the ub4 before 
               calling this routine.
   REQUIRES:
        1) All type accessors require that the type be pinned before calling 
           any accessor. 
        2) All input parameters must not be NULL and must be valid.
        3) 'v_length' must point to an allocated ub4.
   DESCRIPTION:
        Get the user-readable version of the type.
   RETURNS:
        The user-readable version of the type
   NOTES:
        The type descriptor, 'tdo', must be unpinned when the accessed 
        information is no longer needed.
 */

/*--------------------------- OCITypeAttrs ---------------------------------*/

/* ** OBSOLETE ** */
#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
ub4 OCITypeAttrs(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo _*/);
#else /* ANSI C */
ub4 OCITypeAttrs(    OCIEnv *env, OCIError *err, CONST OCIType *tdo    );
#endif
/*
   NAME: OCITypeAttrs - OCI Get a Type's Number of Attributes. 
   PARAMETERS: 
        env (IN/OUT) - OCI environment handle initialized in object mode
        err (IN/OUT) - error handle. If there is an error, it is
                recorded in 'err' and this function returns OCI_ERROR.
                The error recorded in 'err' can be retrieved by calling
                OCIErrorGet().
        tdo (IN) - pointer to to the type descriptor in the object cache
   REQUIRES:
        1) All type accessors require that the type be pinned before calling 
           any accessor. 
        2) All input parameters must not be NULL and must be valid.
   DESCRIPTION:
        Get the number of attributes in the type.
   RETURNS:
        The number of attributes in the type. 0 for ALL non-ADTs.
   NOTES:
        The type descriptor, 'tdo', must be unpinned when the accessed 
        information is no longer needed.
 */

/*------------------------- OCITypeMethods ---------------------------------*/

/* ** OBSOLETE ** */
#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
ub4 OCITypeMethods(/*_ OCIEnv *env, OCIError *err, CONST OCIType *tdo _*/);
#else /* ANSI C */
ub4 OCITypeMethods(    OCIEnv *env, OCIError *err, CONST OCIType *tdo    );
#endif
/*
   NAME: OCITypeMethods - OCI Get a Type's Number of Methods. 
   PARAMETERS: 
        env (IN/OUT) - OCI environment handle initialized in object mode
        err (IN/OUT) - error handle. If there is an error, it is
                recorded in 'err' and this function returns OCI_ERROR.
                The error recorded in 'err' can be retrieved by calling
                OCIErrorGet().
        tdo (IN) - pointer to to the type descriptor in the object cache
   REQUIRES:
        1) All type accessors require that the type be pinned before calling 
           any accessor. 
        2) All input parameters must not be NULL and must be valid.
   DESCRIPTION:
        Get the number of methods in a type.
   RETURNS:
        The number of methods in the type
   NOTES:
        The type descriptor, 'tdo', must be unpinned when the accessed 
        information is no longer needed.
 */


/*--------------------------------------------------------------------------*/
/*                     TYPE ELEMENT INFORMATION ACCESSORS                   */
/*--------------------------------------------------------------------------*/

/*------------------------ OCITypeElemName ---------------------------------*/

/* ** OBSOLETE ** */
#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
text* OCITypeElemName(/*_ OCIEnv *env, OCIError *err, CONST OCITypeElem *elem, 
                        ub4 *n_length _*/);
#else /* ANSI C */
text* OCITypeElemName(    OCIEnv *env, OCIError *err, CONST OCITypeElem *elem, 
                          ub4 *n_length    );
#endif
/*
   NAME: OCITypeElemName - OCI Get an Attribute's NaMe. 
   PARAMETERS: 
        env (IN/OUT) - OCI environment handle initialized in object mode
        err (IN/OUT) - error handle. If there is an error, it is
                recorded in 'err' and this function returns OCI_ERROR.
                The error recorded in 'err' can be retrieved by calling
                OCIErrorGet().
        elem (IN) - pointer to the type element descriptor in the object cache
        n_length (OUT) - length (in bytes) of the returned attribute name.  
               The caller must allocate space for the ub4 before calling this 
               routine.
   REQUIRES:
        1) All type accessors require that the type be pinned before calling 
           any accessor. 
        2) All input parameters must not be NULL and must be valid.
        3) 'n_length' must point to an allocated ub4.
   DESCRIPTION:
        Get the name of the attribute.
   RETURNS:
        the name of the attribute and the length in n_length
   NOTES:
        The type must be unpinned when the accessed information is no 
        longer needed.
 */

/*------------------------ OCITypeElemTypeCode ------------------------------*/

/* ** OBSOLETE ** */
#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
OCITypeCode OCITypeElemTypeCode(/*_ OCIEnv *env, OCIError *err,
                                  CONST OCITypeElem *elem _*/);
#else /* ANSI C */
OCITypeCode OCITypeElemTypeCode(    OCIEnv *env, OCIError *err,
                                    CONST OCITypeElem *elem    );
#endif
/*
   NAME: OCITypeElemTypeCode - OCI Get an Attribute's TypeCode. 
   PARAMETERS: 
        env (IN/OUT) - OCI environment handle initialized in object mode
        err (IN/OUT) - error handle. If there is an error, it is
                recorded in 'err' and this function returns OCI_ERROR.
                The error recorded in 'err' can be retrieved by calling
                OCIErrorGet().
        elem (IN) - pointer to the type element descriptor in the object cache
   REQUIRES:
        1) All type accessors require that the type be pinned before calling 
           any accessor. 
        2) All input parameters must not be NULL and must be valid.
   DESCRIPTION:
        Get the typecode of an attribute's type.
   RETURNS:
        the typecode of the attribute's type.  If this is a scalar type, the 
        typecode sufficiently describes the scalar type and no further calls 
        need to be made.  Valid scalar types include: OCI_TYPECODE_SIGNED8,
        OCI_TYPECODE_UNSIGNED8, OCI_TYPECODE_SIGNED16, OCI_TYPECODE_UNSIGNED16,
        OCI_TYPECODE_SIGNED32, OCI_TYPECODE_UNSIGNED32, OCI_TYPECODE_REAL,
        OCI_TYPECODE_DOUBLE, OCI_TYPECODE_DATE,
        OCI_TYPECODE_MLSLABEL, OROTCOID, OCI_TYPECODE_OCTET, or OROTCLOB.
        This function converts the CREF (stored in the attribute) into a
        typecode.
   NOTES:
       The type must be unpinned when the accessed information is no 
       longer needed.
 */

/*------------------------ OCITypeElemType ---------------------------------*/

/* ** OBSOLETE ** */
#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
sword OCITypeElemType(/*_ OCIEnv *env, OCIError *err, CONST OCITypeElem *elem, 
                          OCIType **elem_tdo _*/);
#else /* ANSI C */
sword OCITypeElemType(    OCIEnv *env, OCIError *err, CONST OCITypeElem *elem, 
                          OCIType **elem_tdo    );
#endif
/*
  PARAMETERS
     env (IN/OUT) - OCI environment handle initialized in object mode
     err (IN/OUT) - error handle. If there is an error, it is
             recorded in 'err' and this function returns OCI_ERROR.
             The error recorded in 'err' can be retrieved by calling
             OCIErrorGet().
     elem (IN) - pointer to the type element descriptor in the object cache
     elem_tdo (OUT) - If the function completes successfully, 'elem_tdo'
            points to the type descriptor (in the object cache) of the type of
            the element.

  REQUIRES
     1) All type accessors require that the type be pinned before calling
        any accessor.  This can be done by calling 'OCITypeByName()'.
     2) if 'elem' is not null, it must point to a valid type element descriptor
        in the object cache.

  DESCRIPTION
     Get the type tdo of the type of this element.
  RETURNS
     OCI_SUCCESS if the function completes successfully.
     OCI_INVALID_HANDLE if 'env' or 'err' is null. 
     OCI_ERROR if
         1) any of the parameters is null.

  NOTES
     The type must be unpinned when the accessed information is no
     longer needed.  This can be done by calling 'OCIObjectUnpin()'.
 */

/*------------------------- OCITypeElemFlags -------------------------------*/

/* ** OBSOLETE ** */
#if !defined(__STDC__) && !defined(__cplusplus) /* K&R C - not ANSI C */
ub4 OCITypeElemFlags(/*_ OCIEnv *env, OCIError *err,
                         CONST OCITypeElem *elem _*/);
#else /* ANSI C */
ub4 OCITypeElemFlags(    OCIEnv *env, OCIError *err,
                         CONST OCITypeElem *elem    );
#endif
/*
   NAME: OCITypeElemFlags - OCI Get a Elem's FLags
                              (inline, constant, virtual, constructor,
                              destructor). 
   PARAMETERS: 
        env (IN/OUT) - OCI environment handle initialized in object mode
        err (IN/OUT) - error handle. If there is an error, it is
                recorded in 'err' and this function returns OCI_ERROR.
                The error recorded in 'err' can be retrieved by calling
                OCIErrorGet().
        elem (IN) - pointer to the type element descriptor in the object cache
   REQUIRES:
        1) All type accessors require that the type be pinned before calling 
           any accessor. 
        2) All input parameters must not be NULL and must be valid.
   DESCRIPTION:
        Get the flags of a type element (attribute, parameter).
   RETURNS:
        The flags of the type element.