element.c

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

    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);
     OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_RAW, 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_ElemSetDate
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetDate(OCI_Elem *elem, OCI_Date *value)
{
    boolean res  = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_DATETIME, FALSE);
  
    if (value == NULL)
    {
        res = OCI_ElemSetNull(elem);
    }
    else
    {
        OCI_Date *date  = (OCI_Date *) elem->obj;
        OCIDate *handle = (OCIDate *) elem->handle; 

        if (date == NULL)
        {
            date = OCI_DateInit(elem->con, (OCI_Date **) &elem->obj, 
                                handle, TRUE, FALSE);
        }

        if (date != NULL)
        {
            res = OCI_DateAssign(date, value);
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetTimestamp
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetTimestamp(OCI_Elem *elem, OCI_Timestamp *value)
{
    boolean res  = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_TIMESTAMP, FALSE);
  
    if (value == NULL)
    {
        res = OCI_ElemSetNull(elem);
    }
    else
    {
        OCI_Timestamp *tmsp = (OCI_Timestamp *) elem->obj;
        OCIDateTime *handle = (OCIDateTime   *) elem->handle; 

        if (tmsp == NULL)
        {
            tmsp = OCI_TimestampInit(elem->con, (OCI_Timestamp **) &elem->obj,
                                     handle, elem->typinf->cols[0].subtype);
        }

        if (tmsp != NULL)
        {
            res = OCI_TimestampAssign(tmsp, value);
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetInterval
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetInterval(OCI_Elem *elem, OCI_Interval *value)
{
    boolean res  = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_INTERVAL, FALSE);
 
    if (value == NULL)
    {
        res = OCI_ElemSetNull(elem);
    }
    else
    {
        OCI_Interval *itv   = (OCI_Interval *) elem->obj;
        OCIInterval *handle = (OCIInterval  *) elem->handle;

        if (itv == NULL)
        {
            itv = OCI_IntervalInit(elem->con, (OCI_Interval **) &elem->obj,
                                   handle, elem->typinf->cols[0].subtype);
        }

        if (itv != NULL)
        {
            res = OCI_IntervalAssign(itv, value);
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetColl
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetColl(OCI_Elem *elem, OCI_Coll *value)
{
    boolean res  = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_COLLECTION, FALSE);
  
    if (value == NULL)
    {
        res = OCI_ElemSetNull(elem);
    }
    else
    {
        OCI_Coll *coll  = (OCI_Coll *) elem->obj;
        OCIColl *handle = (OCIColl  *) elem->handle; 

        if (coll == NULL)
        {
            coll = OCI_CollInit(elem->con, (OCI_Coll **) &elem->obj,
                                handle, elem->typinf->cols[0].typinf);
        }

        if (coll != NULL)
        {
            res = OCI_CollAssign(coll, value);
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetObject
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetObject(OCI_Elem *elem, OCI_Object *value)
{
    boolean res  = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_OBJECT, FALSE);
  
    if (value == NULL)
    {
        res = OCI_ElemSetNull(elem);
    }
    else
    {
        OCI_Object *obj = (OCI_Object *) elem->obj;
        void *handle    = elem->handle;

        if (obj == NULL)
        {
            obj = OCI_ObjectInit(elem->con, (OCI_Object **) &elem->obj,
                                 handle, elem->typinf->cols[0].typinf, NULL, -1, TRUE);
        }

        if (obj != NULL)
        {
            elem->handle = obj->handle;

            res = OCI_ObjectAssign(obj, value);
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetLob
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetLob(OCI_Elem *elem, OCI_Lob *value)
{
    boolean res  = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_LOB, FALSE);
  
    if (value == NULL)
    {
        res = OCI_ElemSetNull(elem);
    }
    else
    {
        OCI_Lob *lob = (OCI_Lob *) elem->obj;
        OCILobLocator *handle = *(OCILobLocator **) elem->handle;

        if (lob == NULL)
        {
            lob = OCI_LobInit(elem->con, (OCI_Lob **) &elem->obj,
                              handle, elem->typinf->cols[0].subtype);
        }

        if (lob != NULL)
        {
            res = OCI_LobAssign(lob, value);
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetFile
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetFile(OCI_Elem *elem, OCI_File *value)
{
    boolean res  = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_FILE, FALSE);
  
    if (value == NULL)
    {
        res = OCI_ElemSetNull(elem);
    }
    else
    {
        OCI_File *file =  (OCI_File *) elem->obj;
        OCILobLocator *handle = *(OCILobLocator **) elem->handle;

        if (file == NULL)
        {
            file = OCI_FileInit(elem->con, (OCI_File **) &elem->obj,
                                handle, elem->typinf->cols[0].subtype);
        }

        if (file != NULL)
        {
            res = OCI_FileAssign(file, value);
        }
    }

    OCI_RESULT(res);

    return res;
}


/* ------------------------------------------------------------------------ *
 * OCI_ElemSetRef
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemSetRef(OCI_Elem *elem, OCI_Ref *value)
{
    boolean res  = TRUE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_REF, FALSE);
  
    if (value == NULL)
    {
        res = OCI_ElemSetNull(elem);
    }
    else
    {
        OCI_Ref *ref    =  (OCI_Ref *) elem->obj;
        OCIRef * handle = *(OCIRef **) elem->handle;

        if (ref == NULL)
        {
            ref = OCI_RefInit(elem->con,elem->typinf->cols[0].typinf, 
                              (OCI_Ref **) &elem->obj, handle);
        }

        if (ref != NULL)
        {
            res = OCI_RefAssign(ref, value);
        }
    }

    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) = OCI_IND_NULL;
        res = TRUE;
    }

    OCI_RESULT(res);
   
    return res;
}