oci_api.h

oci的源码,可以在任何平台上编译,相当方便实用

/*
   +----------------------------------------------------------------------+   
   |                                                                      |
   |                     OCILIB - C Driver for Oracle                     |
   |                                                                      |
   |                      (C Wrapper for Oracle OCI)                      |
   |                                                                      |
   +----------------------------------------------------------------------+
   |                      Website : http://ocilib.net                     |
   +----------------------------------------------------------------------+
   |               Copyright (c) 2007-2009 Vincent ROGIER                 |
   +----------------------------------------------------------------------+
   | This library is free software; you can redistribute it and/or        |
   | modify it under the terms of the GNU Library General Public          |
   | License as published by the Free Software Foundation; either         |
   | version 2 of the License, or (at your option) any later version.     |
   |                                                                      |
   | This library is distributed in the hope that it will be useful,      |
   | but WITHOUT ANY WARRANTY; without even the implied warranty of       |
   | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    |
   | Library General Public License for more details.                     |
   |                                                                      |
   | You should have received a copy of the GNU Library General Public    |
   | License along with this library; if not, write to the Free           |
   | Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.   |
   +----------------------------------------------------------------------+
   |          Author: Vincent ROGIER <[e-mail]>             |
   +----------------------------------------------------------------------+ 

   +----------------------------------------------------------------------+   
   |                          IMPORTANT NOTICE                            |
   +----------------------------------------------------------------------+
   |                                                                      |
   | THIS FILE CONTAINS CONSTANTS AND STRUCTURES DECLARATIONS THAT WERE   |
   | PICKED UP FROM ORACLE PUBLIC HEADER FILES.                           |
   |                                                                      |
   | SO THE CONTENT OF THIS FILE IS UNDER ORACLE COPYRIGHT AND THE        |
   | DECLARATIONS REPRODUCED HERE ARE ORIGINALLY WRITTEN BY ORACLE        | 
   | CORPORATION.                                                         |
   |                                                                      |
   | THE AUTHOR OF OCILIB LIBRARY HAS NOT WRITTEN THE CONTENT OF THIS     |
   | FILE AND HAS PARTIALLY INTEGRATED SOME ORACLE OCI DEFINITONS TO      |
   | ALLOW COMPILATION OF THIS OPEN SOURCE LIBRARY WITHOUT HAVING         |
   | ORACLE PRODUCTS INSTALLED ON DEVELOPMENT ENVIRONMENTS                |
   |                                                                      |
   +----------------------------------------------------------------------+
*/

/* ------------------------------------------------------------------------ *
 * $Id: oci_api.h, v 3.2.0 2009/04/20 00:00 Vince $
 * ------------------------------------------------------------------------ */

#ifndef OCILIB_OCI_API_H_INCLUDED 
#define OCILIB_OCI_API_H_INCLUDED 

#include "oci_defs.h"

/* ************************************************************************ *
 *                         PUBLIC OCI API PROTOTYPES
 * ************************************************************************ */

typedef sword (*OCIENVCREATE) 
(
    OCIEnv **envhpp,
    ub4 mode, 
    void *ctxp,
    void *(*malocfp)(void *ctxp, size_t size),
    void *(*ralocfp)(void *ctxp, void *memptr, size_t newsize),
    void  (*mfreefp)(void *ctxp, void *memptr),
    size_t xtramem_sz,
    void **usrmempp
);

typedef sword (*OCIHANDLEALLOC) 
(
    const void *parenth,
    void **hndlpp,
    const ub4 type,
    const size_t xtramem_sz,
    void **usrmempp
);

typedef sword (*OCIHANDLEFREE) 
(
    void *hndlp, 
    const ub4 type
);


typedef sword (*OCIDESCRIPTORALLOC)
(
    const void *parenth, 
    void **descpp, 
    const ub4 type, 
    const size_t xtramem_sz,
    void **usrmempp
);

typedef sword (*OCIDESCRIPTORFREE)
(
    void *descp, 
    const ub4 type
);

typedef sword (*OCIENVINIT) 
(
    OCIEnv **envp, ub4 mode, 
    size_t xtramem_sz,
    void **usrmempp
);

typedef sword (*OCISERVERATTACH) 
(
    OCIServer *srvhp, 
    OCIError *errhp,
    const OraText *dblink,
    sb4 dblink_len, 
    ub4 mode
);

typedef sword (*OCISERVERDETACH) 
(
    OCIServer *srvhp,
    OCIError *errhp, 
    ub4 mode
);

typedef sword (*OCISESSIONBEGIN)  
(
    OCISvcCtx *svchp,
    OCIError *errhp,
    OCISession *usrhp,
    ub4 credt,
    ub4 mode
);

typedef sword (*OCISESSIONEND)  
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCISession *usrhp, 
    ub4 mode
);

typedef sword (*OCIPASSWORDCHANGE)
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    CONST OraText *user_name, 
    ub4 usernm_len, 
    CONST OraText *opasswd,
    ub4 opasswd_len, 
    CONST OraText *npasswd,
    ub4 npasswd_len,
    ub4 mode
);

typedef sword (*OCISTMTPREPARE) 
(
    OCIStmt *stmtp,
    OCIError *errhp, 
    const OraText *stmt,
    ub4 stmt_len, 
    ub4 language,
    ub4 mode
);

typedef sword (*OCIBINDBYPOS) 
(
    OCIStmt *stmtp,
    OCIBind **bindp,
    OCIError *errhp,
    ub4 position, 
    void *valuep, 
    sb4 value_sz,
    ub2 dty, 
    void *indp, 
    ub2 *alenp, 
    ub2 *rcodep,
    ub4 maxarr_len, 
    ub4 *curelep, 
    ub4 mode
);

typedef sword (*OCIBINDBYNAME)   
(
    OCIStmt *stmtp, 
    OCIBind **bindp, 
    OCIError *errhp,
    const OraText *placeholder, 
    sb4 placeh_len, 
    void *valuep, 
    sb4 value_sz, 
    ub2 dty, 
    void *indp, 
    ub2 *alenp, 
    ub2 *rcodep, 
    ub4 maxarr_len, 
    ub4 *curelep, 
    ub4 mode
);

typedef sword (*OCIBINDDYNAMIC)
(
    OCIBind *bindp, 
    OCIError *errhp, 
    dvoid *ictxp,                         
    sb4 (*icbfp)(dvoid *ictxp, OCIBind *bindp, ub4 iter,  ub4 index, 
                 dvoid **bufpp, ub4 *alenp, ub1 *piecep, dvoid **indp),
    dvoid *octxp,                          
    sb4 (*ocbfp)(dvoid *octxp, OCIBind *bindp, ub4 iter, ub4 index, 
                 dvoid **bufpp, ub4 **alenp,   ub1 *piecep, dvoid **indp,
                 ub2 **rcodep)
 );

typedef sword (*OCIBINDOBJECT)
(
    OCIBind *bindp, 
    OCIError *errhp, 
    CONST OCIType *type, 
    dvoid **pgvpp, 
    ub4 *pvszsp,
    dvoid **indpp, 
    ub4 *indszp
);

typedef sword (*OCISTMTGETPIECEINFO)   
(
    OCIStmt *stmtp,
    OCIError *errhp, 
    void **hndlpp,
    ub4 *typep,
    ub1 *in_outp, 
    ub4 *iterp, 
    ub4 *idxp, 
    ub1 *piecep
);

typedef sword (*OCISTMTSETPIECEINFO) 
(
    void *hndlp, 
    ub4 type, 
    OCIError *errhp, 
    const void *bufp, 
    ub4 *alenp, 
    ub1 piece, 
    const void *indp, 
    ub2 *rcodep
);

typedef sword (*OCISTMTEXECUTE) 
(
    OCISvcCtx *svchp,
    OCIStmt *stmtp,
    OCIError *errhp, 
    ub4 iters, 
    ub4 rowoff,
    const OCISnapshot *snap_in, 
    OCISnapshot *snap_out,
    ub4 mode
);

typedef sword (*OCIDEFINEBYPOS) 
(
    OCIStmt *stmtp, 
    OCIDefine **defnp, 
    OCIError *errhp,
    ub4 position, 
    void *valuep, 
    sb4 value_sz, 
    ub2 dty,
    void *indp, 
    ub2 *rlenp, 
    ub2 *rcodep, 
    ub4 mode
);

typedef sword (*OCIDEFINEOBJECT)
(
    OCIDefine *defnp,
    OCIError *errhp,
    CONST OCIType *type,
    dvoid **pgvpp,
    ub4 *pvszsp,
    dvoid **indpp,
    ub4 *indszp 
);

typedef sword (*OCISTMTFETCH ) 
(
    OCIStmt *stmtp, 
    OCIError *errhp,
    ub4 nrows, 
    ub2 orientation, 
    ub4 mode
);

typedef sword (*OCISTMTFETCH2 ) 
(
    OCIStmt *stmtp, 
    OCIError *errhp,
    ub4 nrows, 
    ub2 orientation, 
    sb4 fetchOffset,
    ub4 mode
);

typedef sword (*OCIPARAMGET)
(
    const void *hndlp,
    ub4 htype,
    OCIError *errhp, 
    void **parmdpp, 
    ub4 pos
);

typedef sword (*OCIPARAMSET)
(
    void *hdlp, 
    ub4 htyp,
    OCIError *errhp, 
    const void *dscp,
    ub4 dtyp, 
    ub4 pos
);

typedef sword (*OCITRANSSTART) 
(
    OCISvcCtx *svchp,
    OCIError *errhp, 
    uword timeout,
    ub4 flags
);

typedef sword (*OCITRANSDETACH)
(
    OCISvcCtx    *svchp, 
    OCIError     *errhp,
    ub4          flags
);

typedef sword (*OCITRANSPREPARE)
(
    OCISvcCtx    *svchp, 
    OCIError     *errhp,
    ub4          flags
);

typedef sword (*OCITRANSFORGET)
(
    OCISvcCtx     *svchp, 
    OCIError      *errhp,
    ub4           flags
);

typedef sword (*OCITRANSCOMMIT) 
(
    OCISvcCtx *svchp, 
    OCIError *errhp,
    ub4 flags
);

typedef sword (*OCITRANSROLLBACK)
(
    OCISvcCtx *svchp, 
    OCIError *errhp,
    ub4 flags
);

typedef sword (*OCIERRORGET) 
(
    void *hndlp,
    ub4 recordno,
    OraText *sqlstate,
    sb4 *errcodep,
    OraText *bufp,
    ub4 bufsiz,
    ub4 type
);

typedef sword (*OCILOBCREATETEMPORARY)
(
    OCISvcCtx          *svchp,
    OCIError           *errhp,
    OCILobLocator      *locp,
    ub2                 csid,
    ub1                 csfrm,
    ub1                 lobtype,
    boolean             cache,
    OCIDuration         duration
);

typedef sword (*OCILOBFREETEMPORARY)
(
    OCISvcCtx *svchp,
    OCIError *errhp,
    OCILobLocator *locp
);

typedef sword (*OCILOBISTEMPORARY)
(
    OCIEnv *envp,
    OCIError *errhp,
    OCILobLocator *locp,
    boolean *is_temporary
);

typedef sword (*OCILOBAPPEND)
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCILobLocator *dst_locp,
    OCILobLocator *src_locp
);

typedef sword (*OCILOBCOPY)
(
    OCISvcCtx *svchp,
    OCIError *errhp, 
    OCILobLocator *dst_locp,
    OCILobLocator *src_locp, 
    ub4 amount,
    ub4 dst_offset, 
    ub4 src_offset
);

typedef sword (*OCILOBREAD)  
(
    OCISvcCtx *svchp,
    OCIError *errhp,
    OCILobLocator *locp,
    ub4 *amtp, 
    ub4 offset, 
    void *bufp,
    ub4 bufl, 
    void *ctxp, 
    sb4 (*cbfp)(void *ctxp, const void *bufp, ub4 len, ub1 piece),
    ub2 csid,
    ub1 csfrm
);

typedef sword (*OCILOBTRIM) 
(
    OCISvcCtx *svchp,
    OCIError *errhp, 
    OCILobLocator *locp,
    ub4 newlen
);

typedef sword (*OCILOBERASE)
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCILobLocator *locp,
    ub4 *amount, 
    ub4 offset
);

typedef sword (*OCILOBWRITE)  
(
    OCISvcCtx *svchp, 
    OCIError *errhp,
    OCILobLocator *locp,
    ub4 *amtp, 
    ub4 offset, 
    void *bufp, 
    ub4 buflen, 
    ub1 piece,
    void *ctxp, 
    sb4 (*cbfp)(void *ctxp, void *bufp, ub4 *len,  ub1 *piece),
    ub2 csid,
    ub1 csfrm
);

typedef sword (*OCILOBGETLENGTH)  
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCILobLocator *locp,
    ub4 *lenp
);

typedef sword (*OCILOBOPEN)
( 
    OCISvcCtx *svchp,
    OCIError *errhp,
    OCILobLocator *locp,
    ub1 mode
);

typedef sword (*OCILOBCLOSE)
(
    OCISvcCtx *svchp,
    OCIError *errhp,
    OCILobLocator *locp 
);

typedef sword (*OCILOBLOCATORASSIGN)
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    CONST OCILobLocator *src_locp, 
    OCILobLocator **dst_locpp
);

typedef sword (*OCILOBASSIGN)
(
    OCIEnv *envhp, 
    OCIError *errhp, 
    CONST OCILobLocator *src_locp, 
    OCILobLocator **dst_locpp
);

#ifdef ORAXB8_DEFINED

typedef sword (*OCILOBCOPY2)
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCILobLocator *dst_locp,                
    OCILobLocator *src_locp,
    oraub8 amount, 
    oraub8 dst_offset, 
    oraub8 src_offset
);

typedef sword (*OCILOBERASE2)
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCILobLocator *locp,
    oraub8 *amount, 
    oraub8 offset
);

typedef sword (*OCILOBGETLENGTH2)
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCILobLocator *locp, 
    oraub8 *lenp
);

typedef sword (*OCILOBLOADFROMFILE2)
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCILobLocator *dst_locp,
    OCILobLocator *src_filep, 
    oraub8 amount, 
    oraub8 dst_offset, 
    oraub8 src_offset
);

typedef sword (*OCILOBREAD2)
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCILobLocator *locp,
    oraub8 *byte_amtp, 
    oraub8 *char_amtp, 
    oraub8 offset,
    dvoid *bufp, 
    oraub8 bufl,
    ub1 piece, 
    dvoid *ctxp,
    sb4 (*cbfp)(dvoid *ctxp, CONST dvoid *bufp, oraub8 len, ub1 piece, 
                dvoid **changed_bufpp, oraub8 *changed_lenp),
    ub2 csid, 
    ub1 csfrm
);

typedef sword (*OCILOBTRIM2) 
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCILobLocator *locp,
    oraub8 newlen
);

typedef sword (*OCILOBWRITE2) 
(
    OCISvcCtx *svchp, 
    OCIError *errhp, 
    OCILobLocator *locp,
    oraub8 *byte_amtp, 
    oraub8 *char_amtp, 
    oraub8 offset,
    dvoid *bufp,