element.c

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

 * OCI_ElemGetRaw
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_ElemGetRaw(OCI_Elem *elem, void *value, unsigned int len)
{
    boolean res = FALSE;

    if (elem->handle != NULL)
    {
        OCIRaw *raw = *(OCIRaw **) elem->handle;
        ub4 raw_len = 0;
    
        OCI_CALL2
        (
            res, elem->con, 
            
            OCIRawAllocSize(OCILib.env, elem->con->err, raw, (ub4*) &raw_len)
        )

        if (res == TRUE)
        {
            if (len > raw_len)
                len = raw_len;

            memcpy(value, OCIRawPtr(OCILib.env, raw), len);
        }
    }

    OCI_RESULT(res);

    return len; 
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetDate
 * ------------------------------------------------------------------------ */

OCI_Date * OCI_API  OCI_ElemGetDate(OCI_Elem *elem)
{
    OCI_Date *date = NULL;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);

    if (elem->col->type == OCI_CDT_DATETIME)
    {
        date = OCI_DateInit(elem->con, (OCI_Date **) &elem->obj, 
                            (OCIDate* ) elem->handle , FALSE, FALSE);
    }

    OCI_RESULT(date != NULL);

    return date;
}
/* ------------------------------------------------------------------------ *
 * OCI_ElemGetTimeStamp
 * ------------------------------------------------------------------------ */

OCI_Timestamp * OCI_API  OCI_ElemGetTimeStamp(OCI_Elem *elem)
{
    OCI_Timestamp *tmsp = NULL;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);

    if (elem->col->type == OCI_CDT_TIMESTAMP)
    {
        tmsp = OCI_TimestampInit(elem->con, (OCI_Timestamp **) &elem->obj, 
                            (OCIDateTime *) elem->handle, elem->col->subtype);
    }

    OCI_RESULT(tmsp != NULL);

    return tmsp;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetInterval
 * ------------------------------------------------------------------------ */

OCI_Interval * OCI_API OCI_ElemGetInterval(OCI_Elem *elem)
{
    OCI_Interval *itv = NULL;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);

    if (elem->col->type == OCI_CDT_INTERVAL)
    {
        itv = OCI_IntervalInit(elem->con, (OCI_Interval **) &elem->obj, 
                               (OCIInterval *) elem->handle, elem->col->subtype);
    }

    OCI_RESULT(itv != NULL);

    return itv;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetLob
 * ------------------------------------------------------------------------ */

OCI_Lob * OCI_API  OCI_ElemGetLob(OCI_Elem *elem)
{
    OCI_Lob *lob = NULL;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);

    if (elem->col->type == OCI_CDT_LOB)
    {
        OCILobLocator *loc = *(OCILobLocator **) elem->handle;
        
        lob = OCI_LobInit(elem->con, (OCI_Lob **) &elem->obj, loc,
                          elem->col->subtype);
    }

    OCI_RESULT(lob != NULL);

    return lob;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetFile
 * ------------------------------------------------------------------------ */

OCI_File * OCI_API  OCI_ElemGetFile(OCI_Elem *elem)
{
    OCI_File *file = NULL;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);

    if (elem->col->type == OCI_CDT_FILE)
    {
        OCILobLocator *loc = *(OCILobLocator **) elem->handle;

        file = OCI_FileInit(elem->con, (OCI_File **) &elem->obj, loc, 
                            elem->col->subtype);
    }


    OCI_RESULT(file != NULL);

    return file;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetObject
 * ------------------------------------------------------------------------ */

OCI_Object * OCI_API OCI_ElemGetObject(OCI_Elem *elem)
{
    OCI_Object *obj = NULL;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);

    if (elem->col->type == OCI_CDT_OBJECT)
    {
        obj = OCI_ObjectInit(elem->con, (OCI_Object **) &elem->obj,
                             (void *) elem->handle, elem->col->nty);

    }

    OCI_RESULT(obj != NULL);

    return obj;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetColl
 * ------------------------------------------------------------------------ */

OCI_Coll * OCI_API OCI_ElemGetColl(OCI_Elem *elem)
{
    OCI_Coll *coll = NULL;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);

    if (elem->col->type == OCI_CDT_COLLECTION)
    {
        coll = OCI_CollInit(elem->con, (OCI_Coll **) &elem->obj, 
                            elem->handle, NULL);
    }

    OCI_RESULT(coll != NULL);

    return coll;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetShort
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetShort(OCI_Elem *elem, short value)
{
    return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value), 
                             (uword) OCI_NUM_SHORT);
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetUnsignedShort
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetUnsignedShort(OCI_Elem *elem, unsigned short value)
{
    return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value), 
                             (uword) OCI_NUM_USHORT);
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetInt(OCI_Elem *elem, int value)
{
    return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value), 
                             (uword) OCI_NUM_INT);
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetUnsignedInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetUnsignedInt(OCI_Elem *elem, unsigned int value)
{
    return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value), 
                             (uword) OCI_NUM_UINT);
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetBigInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetBigInt(OCI_Elem *elem, big_int value)
{
    return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value), 
                             (uword) OCI_NUM_BIGINT);
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetUnsignedBigIn
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetUnsignedBigInt(OCI_Elem *elem, big_uint value)
{
    return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value), 
                             (uword) OCI_NUM_BIGUINT);
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetDouble
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetDouble(OCI_Elem *elem, double value)
{
    return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value), 
                             (uword) OCI_NUM_DOUBLE);
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetString
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetString(OCI_Elem *elem, const dtext *value)
{
    boolean res  = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);

    if (value == NULL)
    {
        res = OCI_ElemSetNull(elem);
    }
    else if (elem->col->type == OCI_CDT_TEXT)
    {
        OCIString **str = (OCIString **) elem->handle;

        res = OCI_StringToStringPtr(str, elem->con->err, (void *) value, 
                                    &elem->buf, &elem->buflen);
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetRaw
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetRaw(OCI_Elem *elem, void* value, unsigned int len)
{
    boolean res  = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
  
    if (value == NULL)
    {
        res = OCI_ElemSetNull(elem);
    }
    else
    {
        OCI_CHECK_MIN(elem->con, NULL, len, 1, FALSE);                                  

        OCI_CALL2
        (
            res, elem->con, 
            
            OCIRawAssignBytes(OCILib.env, elem->con->err, (ub1*) value,
                              len, (OCIRaw **) elem->handle)
        )
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemIsNull
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemIsNull(OCI_Elem *elem)
{
    boolean res  = FALSE;
    boolean null = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);

    if (elem->ind != NULL)
    {     
        if (*elem->ind == OCI_IND_NULL)
            null = TRUE;
        res = TRUE;
    }

    OCI_RESULT(res);

    return null;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetNull
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetNull(OCI_Elem *elem)
{
    boolean res = FALSE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);

    if (elem->ind != NULL)
    {
        *elem->ind = -1;
        res = TRUE;
    }

    OCI_RESULT(res);
   
    return res;
}