connection.c

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

            OCI_CALL2
            (
                res, con, 
                
                OCIServerVersion((dvoid *) con->cxt, con->err,
                                 (OraText *) ostr, (ub4) osize,
                                 (ub1) OCI_HTYPE_SVCCTX)
            )

            OCI_GetOutputMetaString(ostr, con->version, &osize);
            OCI_ReleaseMetaString(ostr);

            if (res == TRUE)
            {
                con->version[osize / sizeof(mtext)] = 0;

                /* parse server version string to find the version information */

                for (p = con->version; (p != NULL) && (*p != 0); p++)
                {
                    if (mtisdigit(*p) &&
                        (*(p+1) != 0) &&
                        (*(p+1) == MT('.') || (*(p+2) == MT('.') )))
                    {
                        if (OCI_NB_ARG_VERSION != mtsscanf(p, MT("%d.%d.%d"),
                                                           &con->ver_maj,
                                                           &con->ver_min,
                                                           &con->ver_rev))
                        {
                            /* extracting version info failed ! */

                            con->ver_maj = 0;
                            con->ver_min = 0;
                            con->ver_rev = 0;
                        }

                        break;
                    }
                }
            }
            else
                OCI_FREE(con->version);
        }
    }

    OCI_RESULT(res);

    return con->version;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetServerMajorVersion
 * ------------------------------------------------------------------------ */

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

    if (con->ver_maj == 0)
        OCI_GetVersionServer(con);

    OCI_RESULT(con->ver_maj != OCI_UNKNOWN);

    return con->ver_maj;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetServerMinorVersion
 * ------------------------------------------------------------------------ */

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

    if (con->ver_min == 0)
        OCI_GetVersionServer(con);

    OCI_RESULT(con->ver_min != OCI_UNKNOWN);

    return con->ver_min;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetServerRevisionVersion
 * ------------------------------------------------------------------------ */

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

    if (con->ver_rev == 0)
        OCI_GetVersionServer(con);

    OCI_RESULT(con->ver_rev != OCI_UNKNOWN);

    return con->ver_rev;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetTransaction
 * ------------------------------------------------------------------------ */

OCI_Transaction * OCI_API OCI_GetTransaction(OCI_Connection *con)
{
    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);

    OCI_RESULT(TRUE);

    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 ouput 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;
}