connection.c

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

    return con->trs;
}

/* ------------------------------------------------------------------------ *
 * OCI_SetTransaction
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_SetTransaction(OCI_Connection *con, OCI_Transaction *trans)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);
    OCI_CHECK_PTR(OCI_IPC_TRANSACTION, trans, FALSE);

    res = OCI_TransactionStop(con->trs);

    if (res == TRUE)
        con->trs = trans;

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetVersionConnection
 * ------------------------------------------------------------------------ */

 unsigned int OCI_API OCI_GetVersionConnection(OCI_Connection *con)
{
    int v1, v2;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, OCI_UNKNOWN);

    v1 = OCI_GetOCIRuntimeVersion();
    v2 = OCI_GetServerMajorVersion(con);

    OCI_RESULT(TRUE);

    /* return the minimum supported version */

    return (v1 > v2) ? v2 : v1;
}


/* ------------------------------------------------------------------------ *
 * OCI_SetDefaultFormatDate
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_SetDefaultFormatDate(OCI_Connection *con, const mtext *format)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    OCI_FREE(con->fmt_date);

    con->fmt_date = mtsdup(format ? format : OCI_STRING_FORMAT_DATE);

    res = (con->fmt_date != NULL);

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetDefaultFormatDate
 * ------------------------------------------------------------------------ */

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

    OCI_RESULT(TRUE);

    if (con->fmt_date == NULL)
        OCI_SetDefaultFormatDate(con, NULL);

    return (con->fmt_date);
}

/* ------------------------------------------------------------------------ *
 * OCI_SetDefaultFormatNumeric
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_SetDefaultFormatNumeric(OCI_Connection *con, const mtext *format)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    OCI_FREE(con->fmt_num);

    con->fmt_num = mtsdup(format ? format : OCI_STRING_FORMAT_NUM);

    res = (con->fmt_num != NULL);

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetDefaultFormatNumeric
 * ------------------------------------------------------------------------ */

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

    OCI_RESULT(TRUE);

    if (con->fmt_num == NULL) 
        OCI_SetDefaultFormatNumeric(con, NULL);

    return (con->fmt_num);
}

/* ------------------------------------------------------------------------ *
 * OCI_Break
 * ------------------------------------------------------------------------ */

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

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    OCI_CALL2
    (
        res, con, 
        
        OCIBreak((dvoid *) con->cxt, con->err)
    )

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ServerEnableOutput
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ServerEnableOutput(OCI_Connection *con, 
                                       unsigned int bufsize,
                                       unsigned int arrsize,
                                       unsigned int lnsize)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    /* initialize the output buffer on server side */

    if (con->svopt == NULL)
    {
        con->svopt  = (OCI_ServerOutput *) OCI_MemAlloc(OCI_IPC_SERVER_OUPUT,
                                                        sizeof(*con->svopt), 
                                                        1, TRUE);

        res = (con->svopt != NULL);
    }

    /* allocation internal buffer if needed */

    if ((res == TRUE) && (con->svopt->arrbuf == NULL))
    {
        /* check params ranges ( Oracle 10g increased the size of output line */

        if (con->ver_maj > OCI_10 || (con->ver_maj == OCI_10 && con->ver_min >= 2))
        {
            if (lnsize < OCI_OUPUT_LSIZE)
                lnsize = OCI_OUPUT_LSIZE;
            else if (lnsize > OCI_OUPUT_LSIZE_10G)
                lnsize = OCI_OUPUT_LSIZE_10G;      
        }
        else
        {
            if (lnsize > OCI_OUPUT_LSIZE)
                lnsize = OCI_OUPUT_LSIZE;
        }

        con->svopt->arrsize = arrsize;
        con->svopt->lnsize  = lnsize;

        /* allocate internal string (line) array */

        con->svopt->arrbuf = (ub1 *) OCI_MemAlloc(OCI_IPC_STRING,
                                                  (con->svopt->lnsize + 1) * sizeof(dtext),
                                                  con->svopt->arrsize, TRUE
                                                  );

        res = (con->svopt->arrbuf != NULL);
    }

    if (res == TRUE)
    {
        if (con->svopt->stmt == NULL)
            con->svopt->stmt = OCI_StatementCreate(con);
        
        if (con->svopt->stmt != NULL)
        {
            /* enable server ouput */

            res = OCI_Prepare(con->svopt->stmt,  
                              MT("BEGIN DBMS_OUTPUT.ENABLE(:n); END;"));
            
            res = res && OCI_BindUnsignedInt(con->svopt->stmt, MT(":n"), &bufsize);

            if (bufsize == 0)
                res = OCI_SetNull(con->svopt->stmt, 1);

            res = res && OCI_Execute(con->svopt->stmt);
 
            /* prepare the retreival statement call */
  
            con->svopt->cursize = con->svopt->arrsize;

            res = res && OCI_Prepare(con->svopt->stmt, 
                                     MT("BEGIN DBMS_OUTPUT.GET_LINES(:s, :i); END;"));
            
            res = res && OCI_BindArrayOfStrings(con->svopt->stmt,
                                                MT(":s"), 
                                                (dtext *) con->svopt->arrbuf,
                                                con->svopt->lnsize, 
                                                con->svopt->arrsize);

            res = res && OCI_BindUnsignedInt(con->svopt->stmt, 
                                             MT(":i"),
                                             &con->svopt->cursize);
        }
    }

    if (res == FALSE)
        OCI_ServerDisableOutput(con);

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ServerDisableOutput
 * ------------------------------------------------------------------------ */

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

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    if (con->svopt != NULL)
    {
        res = res && OCI_ExecuteStmt(con->svopt->stmt, 
                              MT("BEGIN DBMS_OUTPUT.DISABLE(); END;"));

        res = res && OCI_StatementFree(con->svopt->stmt); 

        OCI_FREE(con->svopt->arrbuf);
        OCI_FREE(con->svopt);
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ServerGetOutput
 * ------------------------------------------------------------------------ */

const dtext * OCI_API OCI_ServerGetOutput(OCI_Connection *con)
{
    boolean res = TRUE;
    dtext *str  = NULL;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);
    OCI_CHECK(con->svopt == NULL, FALSE);

    if (con->svopt->curpos == 0 || con->svopt->curpos >= con->svopt->cursize)
        res = OCI_Execute(con->svopt->stmt);

    if (con->svopt->cursize > 0)
        str = (dtext*) (con->svopt->arrbuf + 
                        (((con->svopt->lnsize + 1) * sizeof(dtext)) * con->svopt->curpos++));

    OCI_RESULT(res);

    return (const dtext *) str;
}



/* ------------------------------------------------------------------------ *
 * OCI_SetTrace
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_SetTrace(OCI_Connection *con, unsigned int trace, 
                             const mtext *value)
{
    boolean res = TRUE;
    mtext *str  = NULL;

#if OCI_VERSION_COMPILE >= OCI_10
    ub4 attrib  = 0;
#endif

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);

    /* allocate trace info structure only if trace functions are used */

    if (con->trace == NULL)
    {
        con->trace = (OCI_TraceInfo *) OCI_MemAlloc(OCI_IPC_TRACE_INFO, 
                                                    sizeof(*con->trace), 
                                                    1, TRUE);
        res = (con->trace != NULL);
    }

    /* set trace properties */

    if (con->trace != NULL)
    {
        switch (trace)
        {
            case OCI_TRC_IDENTITY:

#if OCI_VERSION_COMPILE >= OCI_10

                attrib = OCI_ATTR_CLIENT_IDENTIFIER;

#endif
                con->trace->identifier[0] = 0;

                mtsncat(con->trace->identifier, value,
                        msizeof(con->trace->identifier));

                str = con->trace->identifier;
                
                break;
 
            case OCI_TRC_MODULE:

 #if OCI_VERSION_COMPILE >= OCI_10

                attrib = OCI_ATTR_MODULE;

#endif
                con->trace->module[0] = 0;

                mtsncat(con->trace->module, value, msizeof(con->trace->module));

                str = con->trace->module;
                
                break;

            case OCI_TRC_ACTION:

#if OCI_VERSION_COMPILE >= OCI_10

                attrib = OCI_ATTR_ACTION;

#endif
                con->trace->action[0] = 0;

                mtsncat(con->trace->action, value, msizeof(con->trace->action));

                str = con->trace->action;
                
                break;

            case OCI_TRC_DETAIL:

#if OCI_VERSION_COMPILE >= OCI_10

                attrib = OCI_ATTR_CLIENT_INFO;

#endif
                con->trace->info[0] = 0;

                mtsncat(con->trace->info, value,  msizeof(con->trace->info));

                str = con->trace->info;
                
                break;

            default:

                res = FALSE;
        }
    }

#if OCI_VERSION_COMPILE >= OCI_10

    /* On success, we give the value to Oracle to record it in system session view */

    if (res == TRUE)
    {
        void *ostr  = NULL;
        int osize   = -1;

        ostr  = OCI_GetInputMetaString(str, &osize);

        if (str == NULL)
            osize = 0;

        OCI_CALL2
        (
            res, con,
            
            OCIAttrSet((dvoid *) con->ses, (ub4) OCI_HTYPE_SESSION, 
                       (dvoid *) ostr, (ub4) osize, attrib, con->err)
        )

        OCI_ReleaseMetaString(ostr);
    }

#endif

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_TraceGet
 * ------------------------------------------------------------------------ */

const mtext * OCI_API OCI_GetTrace(OCI_Connection *con, unsigned int trace)
{
    const mtext *str = NULL;
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);

    if (con->trace != NULL)
    {
        switch (trace)
        {
            case OCI_TRC_IDENTITY:

                str = con->trace->identifier;
                break;

            case OCI_TRC_MODULE:

                str = con->trace->module;
                break;

            case OCI_TRC_ACTION:

                str = con->trace->action;
                break;

            case OCI_TRC_DETAIL:

                str = con->trace->info;
                break;

            default:

                res = FALSE;
        }
    }

    OCI_RESULT(res);

    return str;
}