object.c

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

/*
   +----------------------------------------------------------------------+   
   |                                                                      |
   |                     OCILIB - C Driver for Oracle                     |
   |                                                                      |
   |                      (C Wrapper for Oracle OCI)                      |
   |                                                                      |
   +----------------------------------------------------------------------+
   |                      Website : http://ocilib.net                     |
   +----------------------------------------------------------------------+
   |               Copyright (c) 2007-2008 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]>             |
   +----------------------------------------------------------------------+ 
*/

/* ------------------------------------------------------------------------ *
 * $Id: object.c, v 3.0.0 2008/10/09 09:54 Vince $
 * ------------------------------------------------------------------------ */

#include "ocilib_internal.h"

/* ------------------------------------------------------------------------ *
 * OCI_ObjectInit
 * ------------------------------------------------------------------------ */

OCI_Object * OCI_ObjectInit(OCI_Connection *con, OCI_Object **pobj,
                            void *handle, OCI_Schema *schema)
{
    OCI_Object * obj = NULL;
    boolean res      = TRUE;
    
    OCI_CHECK(pobj == NULL, NULL);

    if (*pobj == NULL)
        *pobj = (OCI_Object *) OCI_MemAlloc(OCI_IPC_OBJECT, sizeof(*obj), 
                                          1, TRUE);

    if (*pobj != NULL)
    {
        obj = *pobj;

        obj->con    = con;
        obj->handle = handle;
        obj->nty    = schema; 

        obj->objs = (void **) OCI_MemAlloc(OCI_IPC_BUFF_ARRAY, sizeof(void *),
                                           schema->nb_cols, TRUE);

        res = (obj->objs != NULL);

        if ((res == TRUE) && (obj->handle == NULL))
        {
            /* allocates handle for non fetched object */

            obj->hstate = OCI_OBJECT_ALLOCATED;

            OCI_CALL2
            (
                res, obj->con, 
                
                OCI_ObjectNew(OCILib.env,  con->err, con->cxt, 
                              (OCITypeCode) SQLT_NTY, obj->nty->tdo,
                              (dvoid *) NULL, 
                              (OCIDuration) OCI_DURATION_SESSION,
                              (boolean) TRUE, 
                              (dvoid **) &obj->handle)
           )
        }
        else
            obj->hstate = OCI_OBJECT_FETCHED_CLEAN;
    }

    /* check for failure */

    if (res == FALSE)
    {
        OCI_ObjectFree(obj);
        obj = NULL;
    }

    return obj;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetIndex
 * ------------------------------------------------------------------------ */

int OCI_ObjectGetIndex(OCI_Object *obj, const mtext *attr, int type)
{
    int res = -1;
    ub2 i;
 
    OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, -1);
    OCI_CHECK_PTR(OCI_IPC_STRING, attr, -1);

    for (i = 0; i < obj->nty->nb_cols; i++)
    {
        OCI_Column *col = &obj->nty->cols[i];

        if (col->type == type  &&  mtscasecmp(col->name, attr) == 0)
        {
           res = (int) i;
           break;
        }
    }

    if (res == -1)
        OCI_ExceptionAttributeNotFound(obj->con, attr);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetAttr
 * ------------------------------------------------------------------------ */

boolean OCI_ObjectGetAttr(OCI_Object *obj, const mtext *attr, void ** p_value,
                          OCIInd* p_ind,  OCIType **p_tdo)
{
    boolean res = TRUE;

    void *ostr = NULL;
    int osize  = -1;

    ostr = OCI_GetInputMetaString(attr, &osize);

    OCI_CALL2
    (
        res, obj->con,
        
        OCIObjectGetAttr(OCILib.env, obj->con->err,  (dvoid *) obj->handle, 
                        (dvoid *) NULL,  (OCIType *) obj->nty->tdo,
                        (CONST oratext **) &ostr,  (ub4 *) &osize, 
                        (ub4) 1, (ub4 *) NULL, (ub4) 0, (OCIInd *) p_ind, 
                        (dvoid **) NULL, (dvoid **) p_value, (OCIType **) p_tdo)
    )

    OCI_ReleaseMetaString(ostr);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectSetAttr
 * ------------------------------------------------------------------------ */

boolean OCI_ObjectSetAttr(OCI_Object *obj, const mtext *attr, void * value, 
                          OCIInd ind)
{
    boolean res = TRUE;

    void *ostr = NULL;
    int osize  = -1;

    ostr = OCI_GetInputMetaString(attr, &osize);

    OCI_CALL2
    (
        res, obj->con,
        
        OCIObjectSetAttr(OCILib.env, obj->con->err, (dvoid *) obj->handle, 
                        (dvoid *) NULL, (OCIType *) obj->nty->tdo,
                        (CONST oratext**) &ostr, (ub4 *) &osize,
                        (ub4) 1, (ub4 *) NULL, (ub4) 0, (OCIInd) ind, 
                        (dvoid *) NULL, (dvoid *) value)
    )

    OCI_ReleaseMetaString(ostr);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectSetNumber
 * ------------------------------------------------------------------------ */

boolean OCI_ObjectSetNumber(OCI_Object *obj, const mtext *attr, 
                            void *value, uword size, uword flag)
{
    boolean res = FALSE;
        
    OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
            
    if (OCI_ObjectGetIndex(obj, attr, OCI_CDT_NUMERIC) >= 0)
    {
        OCINumber num;
     
        res = OCI_NumberSet(obj->con, &num, value, size, flag) &&
              OCI_ObjectSetAttr(obj, attr, (void *) &num, 0);
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetNumber
 * ------------------------------------------------------------------------ */

boolean OCI_ObjectGetNumber(OCI_Object *obj, const mtext *attr, void *value, 
                            uword size, uword flag)
{
    boolean res = FALSE;
    
    OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
    
    if (OCI_ObjectGetIndex(obj, attr, OCI_CDT_NUMERIC) >= 0)
    {
        OCIInd ind      = 0;
        OCIType *tdo    = NULL;
        OCINumber *num  = NULL;

        if (OCI_ObjectGetAttr(obj, attr, (void **) &num, &ind, &tdo) && num)
        {
            res = OCI_NumberGet(obj->con, num, value, size, flag);
        }
    }
    else if (OCI_ObjectGetIndex(obj, attr, OCI_CDT_TEXT) >= 0)
    {
        const mtext *fmt = OCI_GetDefaultFormatNumeric(obj->con);
        ub4 fmt_size     = (ub4) mtslen(fmt);
        dtext *data      = (dtext *) OCI_ObjectGetString(obj, attr);

        res = OCI_NumberGetFromStr(obj->con, value, size, flag, data, 
                                   (int) dtslen(data),  fmt, fmt_size);
    }

    OCI_RESULT(res);

    return FALSE;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectCreate
 * ------------------------------------------------------------------------ */

OCI_Object * OCI_API OCI_ObjectCreate(OCI_Connection *con, OCI_Schema *schema)
{
    OCI_Object *obj = NULL;

    OCI_CHECK_INITIALIZED(NULL);

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);
    OCI_CHECK_PTR(OCI_IPC_SCHEMA, schema, NULL);

    obj = OCI_ObjectInit(con, &obj, NULL, schema);

    OCI_RESULT(obj != NULL);

    return obj;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectFree
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectFree(OCI_Object *obj)
{
    OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);

    OCI_CHECK_OBJECT_FETCHED(obj, FALSE);

    /* if the object has sub-objects that have been fetched, we need to free
       these objects */

    if (obj->objs != NULL)
    {
        ub2 i;

        for (i = 0; i < obj->nty->nb_cols; i++)
        {
            if (obj->objs[i] != NULL)
            {
               ((OCI_Datatype *) obj->objs[i])->hstate = OCI_OBJECT_FETCHED_DIRTY;

                switch (obj->nty->cols[i].type)
                {
                    case OCI_CDT_DATETIME:

                        OCI_DateFree((OCI_Date *) obj->objs[i]);
                        break;

                    case OCI_CDT_LOB:

                        OCI_LobFree((OCI_Lob *) obj->objs[i]);
                        break;

                    case OCI_CDT_FILE:

                        OCI_FileFree((OCI_File *) obj->objs[i]);
                        break;

                    case OCI_CDT_OBJECT:

                        OCI_ObjectFree((OCI_Object *) obj->objs[i]);
                        break;

                    case OCI_CDT_COLLECTION:

                        OCI_CollFree((OCI_Coll *) obj->objs[i]);;
                        break;

                    case OCI_CDT_TIMESTAMP:

                        OCI_TimestampFree((OCI_Timestamp *) obj->objs[i]);
                        break;

                    case OCI_CDT_INTERVAL:

                        OCI_IntervalFree((OCI_Interval *) obj->objs[i]);
                        break;
                }
            }
        }

        OCI_FREE(obj->objs);
    }

    if (obj->hstate == OCI_OBJECT_ALLOCATED)
    {
        OCI_OCIObjectFree(OCILib.env, obj->con->err,  obj->handle, 
                          OCI_OBJECTFREE_NONULL);
    }

    OCI_FREE(obj->buf);
    OCI_FREE(obj);

    OCI_RESULT(TRUE);

    return TRUE;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetInt
 * ------------------------------------------------------------------------ */

short OCI_API OCI_ObjectGetShort(OCI_Object *obj, const mtext *attr)
{
    short value = 0;

    OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_SHORT);
    
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetUnsignedInt
 * ------------------------------------------------------------------------ */

unsigned short OCI_API OCI_ObjectGetUnsignedShort(OCI_Object *obj,
                                                  const mtext *attr)
{
    unsigned short value = 0;

    OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_USHORT);

    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetInt
 * ------------------------------------------------------------------------ */

int OCI_API OCI_ObjectGetInt(OCI_Object *obj, const mtext *attr)
{
    int value = 0;

    OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_INT);
    
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetUnsignedInt
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_ObjectGetUnsignedInt(OCI_Object *obj, const mtext *attr)
{
    unsigned int value = 0;

    OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_UINT);

    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetBigInt
 * ------------------------------------------------------------------------ */

big_int OCI_API OCI_ObjectGetBigInt(OCI_Object *obj, const mtext *attr)
{
    big_int value = 0;

    OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_BIGINT);
    
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetUnsignedBigInt
 * ------------------------------------------------------------------------ */

big_uint OCI_API OCI_ObjectGetUnsignedBigInt(OCI_Object *obj, const mtext *attr)
{
    big_uint value = 0;

    OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_BIGUINT);
    
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetDouble
 * ------------------------------------------------------------------------ */

double OCI_API OCI_ObjectGetDouble(OCI_Object *obj, const mtext *attr)
{   
    double value = 0.0;

    OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_DOUBLE);
    
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetString
 * ------------------------------------------------------------------------ */

const dtext * OCI_API OCI_ObjectGetString(OCI_Object *obj, const mtext *attr)
{
    const dtext *str  = NULL;
    boolean res       = FALSE;
    int index         = OCI_ObjectGetIndex(obj, attr, OCI_CDT_TEXT);
      
    if (index >= 0)
    {
        OCIInd ind        = 0;
        OCIType *tdo      = NULL;
        OCIString **value = NULL;
        
        res = OCI_ObjectGetAttr(obj, attr, (void **) &value, &ind, &tdo);

        if ((res == TRUE) && (value != NULL))
        {     
            str = (dtext *) OCI_StringFromStringPtr(*value, &obj->buf, &obj->buflen);