object.c

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

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectSetInterval
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectSetInterval(OCI_Object *obj, const mtext *attr,
                                      OCI_Interval *value)
{
    boolean res = FALSE;

    if (value == NULL)
    {
        res = OCI_ObjectSetNull(obj, attr);
    }
    else
    {
        int index = OCI_ObjectGetIndex(obj, attr, OCI_CDT_INTERVAL);

        if (index >= 0)
        {
            OCI_Interval *itv = (OCI_Interval *) obj->objs[index];

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

            if (itv != NULL)
            {
                res = (OCI_IntervalAssign(itv, value) &&
                       OCI_ObjectSetAttr(obj, attr, (void *) itv->handle,
                                         OCI_IND_NOTNULL));
            }
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectSetColl
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectSetColl(OCI_Object *obj, const mtext *attr,
                                  OCI_Coll *value)
{
    boolean res = FALSE;

    if (value == NULL)
    {
        res = OCI_ObjectSetNull(obj, attr);
    }
    else
    {
        int index = OCI_ObjectGetIndex(obj, attr, OCI_CDT_COLLECTION);

        if (index >= 0)
        {
            OCI_Coll *coll = (OCI_Coll *) obj->objs[index];

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

            if (coll != NULL)
            {
                res = (OCI_CollAssign(coll, value) &&
                       OCI_ObjectSetAttr(obj, attr, (void *) coll->handle,
                                         OCI_IND_NOTNULL));
            }
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectSetObject
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectSetObject(OCI_Object *obj, const mtext *attr,
                                    OCI_Object *value)
{
    boolean res = FALSE;

    if (value == NULL)
    {
        res = OCI_ObjectSetNull(obj, attr);
    }
    else
    {
        int index = OCI_ObjectGetIndex(obj, attr, OCI_CDT_OBJECT);

        if (index >= 0)
        {
            OCI_Object *obj2 = (OCI_Object *) obj->objs[index];

            if (obj2 == NULL)
            {
                obj2 = OCI_ObjectInit(obj->con, (OCI_Object **) &obj->objs[index],
                                     NULL, obj->typinf->cols[index].typinf,
                                     obj->tab_ind, index, FALSE);
            }

            if (obj2 != NULL)
            {
                res = (OCI_ObjectAssign(obj2, value) &&
                       OCI_ObjectSetAttr(obj, attr, (void *) obj2->handle,
                                         OCI_IND_NOTNULL));
            }
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectSetLob
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectSetLob(OCI_Object *obj, const mtext *attr,
                                  OCI_Lob *value)
{
    boolean res = FALSE;

    if (value == NULL)
    {
        res = OCI_ObjectSetNull(obj, attr);
    }
    else
    {
        int index = OCI_ObjectGetIndex(obj, attr, OCI_CDT_LOB);

        if (index >= 0)
        {
            OCI_Lob *lob = (OCI_Lob *) obj->objs[index];

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

            if (lob != NULL)
            {
                res = (OCI_LobAssign(lob, value) &&
                       OCI_ObjectSetAttr(obj, attr,  (void *) lob->handle,
                       OCI_IND_NOTNULL));
            }
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectSetFile
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectSetFile(OCI_Object *obj, const mtext *attr,
                                  OCI_File *value)
{
    boolean res = FALSE;

    if (value == NULL)
    {
        res = OCI_ObjectSetNull(obj, attr);
    }
    else
    {
        int index = OCI_ObjectGetIndex(obj, attr, OCI_CDT_FILE);

        if (index >= 0)
        {
            OCI_File *file =  (OCI_File *) obj->objs[index];

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

            if (file != NULL)
            {
                res = (OCI_FileAssign(file, value) &&
                       OCI_ObjectSetAttr(obj, attr,  (void *) file->handle,
                                         OCI_IND_NOTNULL));
            }
        }
    }

    OCI_RESULT(res);

    return res;
}


/* ------------------------------------------------------------------------ *
 * OCI_ObjectSetRef
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectSetRef(OCI_Object *obj, const mtext *attr, OCI_Ref *value)
{
    boolean res = FALSE;

    if (value == NULL)
    {
        res = OCI_ObjectSetNull(obj, attr);
    }
    else
    {
        int index = OCI_ObjectGetIndex(obj, attr, OCI_CDT_REF);

        if (index >= 0)
        {
            OCI_Ref *ref = (OCI_Ref *) obj->objs[index];

            if (ref == NULL)
            {
                ref = OCI_RefInit(obj->con, NULL, (OCI_Ref **) &obj->objs[index],
                                  NULL);
            }

            if (ref != NULL)
            {
                res = (OCI_RefAssign(ref, value) &&
                       OCI_ObjectSetAttr(obj, attr, (void *) ref->handle,
                                         OCI_IND_NOTNULL));
            }
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectSetNull
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectSetNull(OCI_Object *obj, const mtext *attr)
{
    boolean res = TRUE;
    int index;

    OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, attr, FALSE);

    index = OCI_ObjectGetIndex(obj, attr, -1);

    if (index >= 0)
    {
        res = OCI_ObjectSetAttr(obj, attr, NULL, OCI_IND_NULL);
    }
    else
        res = FALSE;

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectIsNull
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectIsNull(OCI_Object *obj, const mtext *attr)
{
    boolean res = FALSE;
    boolean ret = TRUE;
    int index   = 0;

    OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, attr, FALSE);

    index = OCI_ObjectGetIndex(obj, attr, -1);

    if (index >= 0)
    {
        OCIInd ind     = OCI_IND_NULL;
        OCIType *tdo   = NULL;
        void *value    = NULL;

        res = OCI_ObjectGetAttr(obj, attr, (void **) &value, &ind, &tdo);

        if (res == TRUE)
        {
            ret = (ind != OCI_IND_NOTNULL);
        }
    }

    OCI_RESULT(res);

    return ret;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetTypeInfo
 * ------------------------------------------------------------------------ */

OCI_TypeInfo * OCI_API OCI_ObjectGetTypeInfo(OCI_Object *obj)
{
    OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, NULL);

    OCI_RESULT(TRUE);

    return obj->typinf;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetType
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_ObjectGetType(OCI_Object *obj)
{
    OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, OCI_UNKNOWN);

    OCI_RESULT(TRUE);

    return (unsigned int) obj->type;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetSelfRef
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectGetSelfRef(OCI_Object *obj, OCI_Ref *ref)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
    OCI_CHECK_PTR(OCI_IPC_REF   , ref, FALSE);

    OCI_CHECK_COMPAT(obj->con, obj->typinf == ref->typinf, FALSE);

    OCI_CALL2
    (
        res, obj->con,

        OCIObjectGetObjectRef(OCILib.env, obj->con->err, obj->handle, ref->handle)
    )

    if (res == TRUE)
    {
        OCI_ObjectFree(ref->obj);
        ref->obj = NULL;
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ObjectGetStruct
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ObjectGetStruct(OCI_Object *obj, void **pp_struct,
                                    void** pp_ind)
{
    OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);

    OCI_RESULT(TRUE);

    *pp_struct = (void *) obj->handle;

    if (pp_ind)
        *pp_ind = (void *) obj->tab_ind;

    OCI_RESULT(TRUE);

    return TRUE;
}