connection.c

ORACLE编程的好东西,纯C写的OCI封装.很好用,支持数据池.

 * ------------------------------------------------------------------------ */

boolean OCI_ConnectionLogOff(OCI_Connection *con)
{
    boolean res = TRUE;

    OCI_CHECK(con == NULL, FALSE);
    OCI_CHECK(con->cstate != OCI_CONN_LOGGED, FALSE);

    /* free all statements */
    
    OCI_ListForEach(con->stmts, (boolean (*)(void *)) OCI_StatementClose);
    OCI_ListClear(con->stmts);

    /* free all transactions */
    
    OCI_ListForEach(con->trsns, (boolean (*)(void *)) OCI_TransactionClose);
    OCI_ListClear(con->trsns);

    /* free all schema objects */
    
    OCI_ListForEach(con->sobjs, (boolean (*)(void *)) OCI_SchemaClose);
    OCI_ListClear(con->sobjs);

   /* close any server files not explicitly closed - no check of return code */
   
    if (con->nb_files > 0)
    {
        OCILobFileCloseAll(con->cxt, con->err);
    }

    /* close session */
   
    if ((con->cxt != NULL) && (con->err != NULL) && (con->ses != NULL))
    {
         OCI_CALL2
         (
            res, con, 
            
            OCISessionEnd(con->cxt, con->err, con->ses, (ub4) OCI_DEFAULT)
         )
    }

    /* update internal status */

    if (res == TRUE)
    {
        con->cstate = OCI_CONN_ATTACHED;

        if (OCILib.ver_runtime < OCI_9 && con->pool != NULL)
            con->pool->nb_busy--;
    }

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ConnectionClose
 * ------------------------------------------------------------------------ */

boolean OCI_ConnectionClose(OCI_Connection *con)
{
    OCI_CHECK(con == NULL, FALSE);

    /* clear server output ressources */

    OCI_ServerDisableOutput(con);

    /* lofoff and detatch form server */

    OCI_ConnectionLogOff(con);
    OCI_ConnectionDetach(con);
    OCI_ConnectionDeallocate(con);

    /* free internal lists */

    OCI_ListFree(con->stmts);
    OCI_ListFree(con->trsns);
    OCI_ListFree(con->sobjs);

    if (con->pool == NULL)
    {
        /* free strings */
        
        OCI_FREE(con->db);
        OCI_FREE(con->user);
        OCI_FREE(con->pwd);
    }


    OCI_FREE(con->fmt_date);
    OCI_FREE(con->fmt_num);
    OCI_FREE(con->version);

    con->stmts = NULL;
    con->trsns = NULL;
    con->sobjs = NULL;

    return TRUE;
}

/* ************************************************************************ *
 *                             PUBLIC FUNCTIONS
 * ************************************************************************ */

/* ------------------------------------------------------------------------ *
 * OCI_ConnectionCreate
 * ------------------------------------------------------------------------ */

OCI_Connection * OCI_API OCI_ConnectionCreate(const mtext *db, 
                                              const mtext *user,
                                              const mtext *pwd,
                                              unsigned int mode)
{
    OCI_Connection * con;
    
    /* let's be sure OCI_Initialize() has been called */

    OCI_CHECK_INITIALIZED(NULL);

    con = OCI_ConnectionAllocate(NULL, db, user, pwd, mode);

    if (con != NULL)
    {
        if (OCI_ConnectionAttach(con) == FALSE ||
            OCI_ConnectionLogon(con)  == FALSE)
        {
            OCI_ConnectionFree(con);
            con = NULL;
        }
    }

    OCI_RESULT(con != NULL);

    return con;
}

/* ------------------------------------------------------------------------ *
 * OCI_ConnectionFree
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ConnectionFree(OCI_Connection *con)
{
    boolean res    = TRUE;
    OCI_Error *err = NULL;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    /* clear connection reference from current error object */
    
    err = OCI_ErrorGet(FALSE);

    if (err != NULL && err->con == con)
        err->con = NULL;
        
   
    if (con->pool != NULL)
    {
        res = OCI_ConnectionLogOff(con);
    
        if (OCILib.ver_runtime >= OCI_9)
            OCI_ConnectionDetach(con);
    }
    else
    {
        res = OCI_ConnectionClose(con);
        OCI_ListRemove(OCILib.cons, con);
        OCI_FREE(con);
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_Commit
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_Commit(OCI_Connection *con)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    OCI_CALL2
    (
        res, con, 
        
        OCITransCommit(con->cxt, con->err, (ub4) OCI_DEFAULT)
    )

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_Rollback
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_Rollback(OCI_Connection *con)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    OCI_CALL2
    (
        res, con, 
        
        OCITransRollback(con->cxt, con->err, (ub4) OCI_DEFAULT)
    )

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_SetAutoCommit
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_SetAutoCommit(OCI_Connection *con, boolean enable)
{
    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    OCI_RESULT(TRUE);

    con->autocom = enable;

    return TRUE;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetAutoCommit
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_GetAutoCommit(OCI_Connection *con)
{
    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    OCI_RESULT(TRUE);

    return con->autocom;
}

/* ------------------------------------------------------------------------ *
 * OCI_IsConnected
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_IsConnected(OCI_Connection *con)
{
    boolean res = FALSE;
    ub4 status  = 0;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    OCI_CALL2
    (
        res, con, 
        
        OCIAttrGet((dvoid **) con->svr, (ub4) OCI_HTYPE_SERVER,
                   (dvoid *) &status, (ub4 *) NULL, 
                   (ub4) OCI_ATTR_SERVER_STATUS, con->err)

    )

    OCI_RESULT(res);

    return (status == OCI_SERVER_NORMAL);
}

/* ------------------------------------------------------------------------ *
 * OCI_GetUserData
 * ------------------------------------------------------------------------ */

void * OCI_API OCI_GetUserData(OCI_Connection *con)
{
    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    OCI_RESULT(TRUE);

    return con->usrdata;  
}

/* ------------------------------------------------------------------------ *
 * OCI_SetSetData
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_SetUserData(OCI_Connection *con, void * data)
{
    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    OCI_RESULT(TRUE);

    con->usrdata = data;  

    return TRUE;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetDatabase
 * ------------------------------------------------------------------------ */

const mtext * OCI_API OCI_GetDatabase(OCI_Connection *con)
{
    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);

    OCI_RESULT(TRUE);

    return (const mtext *) con->db;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetUserName
 * ------------------------------------------------------------------------ */

const mtext * OCI_API OCI_GetUserName(OCI_Connection *con)
{
    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);

    OCI_RESULT(TRUE);

    return (const mtext *) con->user;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetPassword
 * ------------------------------------------------------------------------ */

const mtext * OCI_API OCI_GetPassword(OCI_Connection *con)
{
    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);

    OCI_RESULT(TRUE);

    return (const mtext *) con->pwd;
}

/* ------------------------------------------------------------------------ *
 * OCI_SetPassword
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_SetPassword(OCI_Connection *con, const mtext *password)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, password, FALSE);

    OCI_CALL2
    (
        res, con, 
        
        OCIPasswordChange(con->cxt, con->err, 
                          (OraText *) con->user, (ub4) mtextsize(con->user),
                          (OraText *) con->pwd,  (ub4) mtextsize(con->pwd),
                          (OraText *) password,  (ub4) mtextsize(password),
                          (ub4) OCI_DEFAULT)
    )

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetSessionMode
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_GetSessionMode(OCI_Connection *con)
{
    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, OCI_UNKNOWN);

    OCI_RESULT(TRUE);

    return con->mode;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetVersionServer
 * ------------------------------------------------------------------------ */

const mtext * OCI_API OCI_GetVersionServer(OCI_Connection *con)
{
    boolean res = FALSE;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);

    if (con->version == NULL)
    {
        con->version = (mtext *) OCI_MemAlloc(OCI_IPC_STRING, sizeof(mtext), 
                                              OCI_SIZE_BUFFER + 1, FALSE);

        if (con->version != NULL)
        {
            int osize  = OCI_SIZE_BUFFER * sizeof(mtext);
            void *ostr = NULL;
            mtext *p   = NULL;

            res  = TRUE;

            ostr = OCI_GetInputMetaString(con->version, &osize);