statement.c

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

        bnd->buf.sizelen = sizeof(ub2);

        /* if we bind an OCI_Long or any outut bind, we need to change the 
           execution mode to provide data at execute time */

        if (bnd->type == OCI_CDT_LONG)
        {
            stmt->long_size = size;
            exec_mode       = OCI_DATA_AT_EXEC;
        }
        else if (bnd->mode == OCI_BIND_OUTPUT)
        {
            exec_mode = OCI_DATA_AT_EXEC;
        }
    }

   /* OCI binding */

    if (res == TRUE)
    {
        if (stmt->bind_mode == OCI_BIND_BY_POS)
        {
            int index = (int) mtstol(&bnd->name[1], NULL, 10);

            OCI_CALL1
            (
                res, stmt->con, stmt,
                
                OCIBindByPos(stmt->stmt, (OCIBind **) &bnd->buf.handle,
                             stmt->con->err, (ub4) index, (void *) bnd->buf.data,
                             bnd->size, bnd->code, bnd->buf.inds,  bnd->plsizes, 
                             bnd->plrcds, (ub4) (is_pltbl == TRUE ? nbelem : 0),
                             pnbelem, exec_mode)
            )
        }
        else
        {
            void * ostr = NULL;
            int osize   = -1;

            ostr = OCI_GetInputMetaString(bnd->name, &osize);

            OCI_CALL1
            (
                res, stmt->con, stmt,
                
                OCIBindByName(stmt->stmt, (OCIBind **) &bnd->buf.handle,
                              stmt->con->err, (OraText *) ostr, (sb4) osize, 
                              (void *) bnd->buf.data, bnd->size, bnd->code,
                              bnd->buf.inds, bnd->plsizes, bnd->plrcds, 
                              (ub4) (is_pltbl == TRUE ? nbelem : 0),
                              pnbelem, exec_mode)
            )
            
            OCI_ReleaseMetaString(ostr);
        }

        if (code == SQLT_NTY)
        {                                          
            OCI_CALL1
            (
                res, stmt->con, stmt,
                
                OCIBindObject((OCIBind *) bnd->buf.handle, stmt->con->err, 
                              (OCIType *) extra, (void **) bnd->buf.data,
                              (ub4 *) NULL, (void **) NULL,
                              (ub4 *) bnd->buf.inds)
            )
        }

        if (bnd->mode == OCI_BIND_OUTPUT)
        {
            /* register output placeholder */

            OCI_CALL1
            (
                res, stmt->con, stmt,
                              
                OCIBindDynamic((OCIBind *) bnd->buf.handle, stmt->con->err,
                               (dvoid *) bnd, OCI_ProcInBind,
                               (dvoid *) bnd, OCI_ProcOutBind)
            )
        }

        /* setup national charset from flag if needded */

        if (
            (
                (bnd->type    == OCI_CDT_LOB) &&
                (bnd->subtype == OCI_NCLOB)
            )
#ifdef OCI_USERDATA_UNICODE        
            || 
            (
                (bnd->type          == OCI_CDT_TEXT) && 
                (stmt->con->ver_maj >= OCI_9)        &&
                (bnd->plsizes       == NULL)
            )
#endif
           )
        {
            ub1 csfrm = SQLCS_NCHAR;

            OCI_CALL1
            (
                res, stmt->con, stmt,
                              
                OCIAttrSet((dvoid *) bnd->buf.handle, (ub4) OCI_HTYPE_BIND,
                           (dvoid *) &csfrm, (ub4) sizeof(csfrm),
                           (ub4) OCI_ATTR_CHARSET_FORM,  bnd->stmt->con->err)
            )
        }

#ifdef OCI_CHARSET_MIXED

        /* setup Unicode mode for user data in mixed builds */
        
        {

            ub2 csid = OCI_UTF16ID;

            OCI_CALL1
            (
                res, stmt->con, stmt,
                              
                OCIAttrSet((dvoid *) bnd->buf.handle, (ub4) OCI_HTYPE_BIND,
                           (dvoid *) &csid,  (ub4) sizeof(csid),
                           (ub4) OCI_ATTR_CHARSET_ID,  stmt->con->err)
            )
        }

#endif

    }

    /* on success, add the bind handle to the bind array */

    if (res == TRUE)
    {
        stmt->binds[stmt->nb_binds++] = bnd;

        /* this will allow resultset creation for statement with 
           returning clause */
        
        if (bnd->mode == OCI_BIND_OUTPUT)
            stmt->nb_outbinds++;
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_FetchIntoUserVariables
 * ------------------------------------------------------------------------ */

boolean OCI_FetchIntoUserVariables(OCI_Statement *stmt, va_list args)
{
    OCI_Resultset *rs = NULL;
    boolean res = FALSE;
    int i, n;

    /* get resultset */

    rs  = OCI_GetResultset(stmt);

    /* fetch data */

    if (rs != NULL)
        res = OCI_FetchNext(rs);

    if (res == TRUE)
    {
        /* loop on column list for updating user given placeholders */

        for (i = 1, n = OCI_GetColumnCount(rs); i <= n && res == TRUE; i++)
        {
            OCI_Column *col = OCI_GetColumn(rs, i);

            int type = va_arg(args, int);

            switch (type)
            {
                case OCI_ARG_SHORT:
                {
                    short src, *dst;

                    src = OCI_GetShort(rs, i);
                    dst = va_arg(args, short *);
                    
                    if (dst != NULL)
                        *dst = src;

                    break;        
                }
                case OCI_ARG_USHORT:
                {
                   unsigned short src, *dst;

                    src = OCI_GetUnsignedShort(rs, i);
                    dst = va_arg(args, unsigned short *);
                    
                    if (dst != NULL)
                        *dst = src;

                    break;        
                }
                case OCI_ARG_INT:
                {
                    int src, *dst;

                    src = OCI_GetInt(rs, i);
                    dst = va_arg(args, int *);
                                    
                    if (dst != NULL)
                        *dst = src;

                    break;        
                }
                case OCI_ARG_UINT:
                {
                   unsigned int src, *dst;

                    src = OCI_GetUnsignedInt(rs, i);
                    dst = va_arg(args, unsigned int *);
                    
                    if (dst != NULL)
                        *dst = src;

                    break;        
                }
                case OCI_ARG_BIGINT:
                {
                    big_int src, *dst;

                    src = OCI_GetBigInt(rs, i);
                    dst = va_arg(args, big_int *);
                    
                    if (dst != NULL)
                        *dst = src;

                    break;        
                }
                case OCI_ARG_BIGUINT:
                {
                   big_uint src, *dst;

                    src = OCI_GetUnsignedBigInt(rs, i);
                    dst = va_arg(args, big_uint *);
                    
                    if (dst != NULL)
                        *dst = src;

                    break;        
                }
                case OCI_ARG_DOUBLE:
                {
                    double src, *dst;

                    src = OCI_GetDouble(rs, i);
                    dst = va_arg(args, double *);
                    
                    if (dst != NULL)
                        *dst = src;

                    break;
                }
                case OCI_ARG_DATETIME:
                {
                    OCI_Date *src, *dst;

                    src = OCI_GetDate(rs, i);
                    dst = (OCI_Date *) va_arg(args, OCI_Date *);

                    if (src != NULL && dst != NULL)
                        res = OCI_DateAssign(dst, src);

                    break;
                }
                case OCI_ARG_TEXT:
                {
                    const dtext *src;
                    dtext *dst;

                    src = OCI_GetString(rs, i);
                    dst = va_arg(args, dtext *);
                    
                    if (dst != NULL)
                        dst[0] = 0;

                    if (dst != NULL && src != NULL)
                        dtscat(dst, src);

                    break;
                }
                case OCI_ARG_RAW:
                {
                    OCI_GetRaw(rs, i, va_arg(args, dtext *), col->bufsize);
                    break;
                }
                case OCI_ARG_LOB:
                {
                    OCI_Lob *src, *dst;

                    src = OCI_GetLob(rs, i);
                    dst = (OCI_Lob *) va_arg(args, OCI_Lob *);

                    if (src != NULL && dst != NULL)
                        res = OCI_LobAssign(dst, src);

                    break;
                }
                case OCI_ARG_FILE:
                {
                    OCI_File *src, *dst;

                    src = OCI_GetFile(rs, i);
                    dst = (OCI_File *) va_arg(args, OCI_File *);

                    if (src != NULL && dst != NULL)
                        res = OCI_FileAssign(dst, src);

                    break;
                }
                case OCI_ARG_TIMESTAMP:
                {
                    OCI_Timestamp *src, *dst;

                    src = OCI_GetTimestamp(rs, i);
                    dst = (OCI_Timestamp *) va_arg(args, OCI_Timestamp *);

                    if (src != NULL && dst != NULL)
                        res = OCI_TimestampAssign(dst, src);

                    break;
                }
                case OCI_ARG_INTERVAL:
                {
                    OCI_Interval *src, *dst;

                    src = OCI_GetInterval(rs, i);
                    dst = (OCI_Interval *) va_arg(args, OCI_Interval *);

                    if (src != NULL && dst != NULL)
                        res =OCI_IntervalAssign(dst, src);

                    break;
                }
                default:
                {
                    OCI_ExceptionMappingArgument(stmt->con, stmt, type);

                    res = FALSE;

                    break;
                }
            }
        }
    }

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_StatementInit
 * ------------------------------------------------------------------------ */

OCI_Statement * OCI_StatementInit(OCI_Connection *con, OCI_Statement **pstmt,
                                  OCIStmt *handle, OCI_Define *def)
{
    OCI_Statement * stmt = NULL;
    boolean res = TRUE;

    OCI_CHECK(pstmt == NULL, NULL);

    if (*pstmt == NULL)
        *pstmt = (OCI_Statement *) OCI_MemAlloc(OCI_IPC_STATEMENT, sizeof(*stmt),
                                              1, TRUE);

    if (*pstmt != NULL)
    {
        stmt = *pstmt;

        stmt->con           = con;
        stmt->stmt          = handle;

        stmt->exec_mode     = OCI_DEFAULT;
        stmt->long_size     = OCI_SIZE_LONG;
        stmt->bind_mode     = OCI_BIND_BY_NAME;
        stmt->long_mode     = OCI_LONG_EXPLICIT;

        /* reset statement */

        OCI_StatementReset(stmt);

        if (def == NULL)
        {
            /* allocate handle for non fetched lob (temporay lob) */

            stmt->hstate = OCI_OBJECT_ALLOCATED;

            /* allocate handle */

            res = (OCI_SUCCESS == OCI_HandleAlloc((dvoid *) OCILib.env, 
                                                  (dvoid **) (void *) &stmt->stmt,
                                                  (ub4) OCI_HTYPE_STMT, 
                                                  (size_t) 0, (dvoid **) NULL));
        }
        else
        {
            stmt->hstate = OCI_OBJECT_FETCHED_CLEAN;
            stmt->status = OCI_STMT_EXECUTED;
            stmt->type   = OCI_CST_SELECT;
         
            /* not really perfect, but better than nothing */

            if (def->col.name != NULL)
                stmt->sql = mtsdup(def->col.name);