element.c

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

/*
   +----------------------------------------------------------------------+   
   |                                                                      |
   |                     OCILIB - C Driver for Oracle                     |
   |                                                                      |
   |                      (C Wrapper for Oracle OCI)                      |
   |                                                                      |
   +----------------------------------------------------------------------+
   |                      Website : http://ocilib.net                     |
   +----------------------------------------------------------------------+
   |               Copyright (c) 2007-2009 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: element.c, v 3.2.0 2009/04/20 00:00 Vince $
 * ------------------------------------------------------------------------ */

#include "ocilib_internal.h"

/* ************************************************************************ *
 *                             PRIVATE FUNCTIONS
 * ************************************************************************ */

/* ------------------------------------------------------------------------ *
 * OCI_ElemInit
 * ------------------------------------------------------------------------ */

OCI_Elem * OCI_ElemInit(OCI_Connection *con, OCI_Elem **pelem, void *handle, 
                        OCIInd *pind, OCI_TypeInfo *typinf)
{
    OCI_Elem *elem = NULL;
    boolean res    = TRUE;

    OCI_CHECK(pelem == NULL, NULL);

    if (*pelem == NULL)
        *pelem = (OCI_Elem *) OCI_MemAlloc(OCI_IPC_ELEMENT, sizeof(*elem), 1, TRUE);

    if (*pelem != NULL)
    {
        elem = *pelem;

        elem->con     = con;
        elem->handle  = handle;
        elem->ind     = pind;
        elem->typinf  = typinf;
        elem->init    = FALSE;
    
        if (elem->handle == NULL)
            elem->hstate = OCI_OBJECT_ALLOCATED;
        else
            elem->hstate = OCI_OBJECT_FETCHED_CLEAN;
    }
    else
        res = FALSE;

    /* check for failure */

    if (res == FALSE)
    {
        OCI_ElemFree(elem);
        elem = NULL;
    }

    return elem;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemSetNumber
 * ------------------------------------------------------------------------ */

boolean OCI_ElemSetNumber(OCI_Elem  *elem, void *value, uword size, uword flag)
{
    boolean res = FALSE;
        
    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_NUMERIC, FALSE);
  
    res = OCI_NumberSet(elem->con, (OCINumber *) elem->handle, value, size, flag);

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetNumber
 * ------------------------------------------------------------------------ */

boolean OCI_ElemGetNumber(OCI_Elem *elem, void *value, uword size, uword flag)
{
    boolean res = FALSE;
    
    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
    
    if (elem->typinf->cols[0].type == OCI_CDT_NUMERIC)
    {
        OCINumber *num  = (OCINumber *) elem->handle;

        res = OCI_NumberGet(elem->con, num, value, size, flag);
    }
    else if (elem->typinf->cols[0].type == OCI_CDT_TEXT)
    {
        const mtext *fmt = OCI_GetDefaultFormatNumeric(elem->con);
        ub4 fmt_size     = (ub4) mtslen(fmt);
        dtext *data      = (dtext *) OCI_ElemGetString(elem);

        res = OCI_NumberGetFromStr(elem->con, value, size, flag, data, 
                                   (int) dtslen(data),  fmt, fmt_size);
    }
    else
    {
        OCI_ExceptionTypeNotCompatible(elem->con);
    }

    OCI_RESULT(res);

    return res;
}

/* ************************************************************************ *
 *                            PUBLIC FUNCTIONS
 * ************************************************************************ */

/* ------------------------------------------------------------------------ *
 * OCI_ElemCreate
 * ------------------------------------------------------------------------ */

OCI_Elem * OCI_API OCI_ElemCreate(OCI_TypeInfo *typinf)
{
    OCI_Elem *elem = NULL;

    OCI_CHECK_INITIALIZED(NULL);
    OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);

    elem = OCI_ElemInit(typinf->con, &elem, NULL, (OCIInd *) NULL, typinf);
                        
    OCI_RESULT(elem != NULL);

    return elem;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemFree
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ElemFree(OCI_Elem *elem)
{
    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);

    OCI_CHECK_OBJECT_FETCHED(elem, FALSE);

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

    if (elem->obj != NULL)
    {
        OCI_Datatype * data = (OCI_Datatype *) elem->obj;

        if (data->hstate == OCI_OBJECT_FETCHED_CLEAN)
            data->hstate = OCI_OBJECT_FETCHED_DIRTY;

        switch (elem->typinf->cols[0].type)
        {
            case OCI_CDT_DATETIME:

                OCI_DateFree((OCI_Date *) elem->obj);
                break;

            case OCI_CDT_LOB:

                OCI_LobFree((OCI_Lob *) elem->obj);
                break;

            case OCI_CDT_FILE:

                OCI_FileFree((OCI_File *) elem->obj);
                break;

            case OCI_CDT_OBJECT:

                OCI_ObjectFree((OCI_Object *) elem->obj);
                break;

            case OCI_CDT_COLLECTION:

                OCI_CollFree((OCI_Coll *) elem->obj);;
                break;

            case OCI_CDT_TIMESTAMP:

                OCI_TimestampFree((OCI_Timestamp *) elem->obj);
                break;

            case OCI_CDT_INTERVAL:

                OCI_IntervalFree((OCI_Interval *) elem->obj);
                break;
        }
    }

    OCI_FREE(elem->buf);
    OCI_FREE(elem);

    OCI_RESULT(TRUE);

    return TRUE;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetShort
 * ------------------------------------------------------------------------ */

short OCI_API OCI_ElemGetShort(OCI_Elem *elem)
{
    short value = 0;
    
    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, 0);

    OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(short), 
                      (uword) OCI_NUM_SHORT);
  
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetUnsignedShort
 * ------------------------------------------------------------------------ */

unsigned short OCI_API OCI_ElemGetUnsignedShort(OCI_Elem *elem)
{
    unsigned short value = 0;
    
    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, 0);

    OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(unsigned short),
                      (uword) OCI_NUM_USHORT);
 
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetInt
 * ------------------------------------------------------------------------ */

int OCI_API OCI_ElemGetInt(OCI_Elem *elem)
{
    int value = 0;
    
    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, 0);

    OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(value),
                      (uword) OCI_NUM_INT);
 
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetUnsignedInt
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_ElemGetUnsignedInt(OCI_Elem *elem)
{
    unsigned int value = 0;
    
    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, 0);

    OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(value),
                      (uword) OCI_NUM_UINT);
 
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetBigInt
 * ------------------------------------------------------------------------ */

big_int OCI_API OCI_ElemGetBigInt(OCI_Elem *elem)
{
    big_int value = 0;
    
    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, 0);

    OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(big_int),
                      (uword) OCI_NUM_BIGINT);
 
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetUnsignedBigInt
 * ------------------------------------------------------------------------ */

big_uint OCI_API OCI_ElemGetUnsignedBigInt(OCI_Elem *elem)
{
    big_uint value = 0;
    
    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, 0);

    OCI_ElemGetNumber(elem, (void *) &value,  (uword) sizeof(big_uint),
                      (uword) OCI_NUM_BIGUINT);
 
    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetDouble
 * ------------------------------------------------------------------------ */

double OCI_API OCI_ElemGetDouble(OCI_Elem *elem)
{
    double value = 0.0;
    
    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, 0.0);

    OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(double),
                      (uword) OCI_NUM_DOUBLE);

    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_ElemGetString
 * ------------------------------------------------------------------------ */

const dtext * OCI_API OCI_ElemGetString(OCI_Elem *elem)
{
    const dtext *str  = NULL;
    boolean res       = FALSE;

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_TEXT, NULL);

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

        str = (dtext *) OCI_StringFromStringPtr(*(OCIString **) elem->handle,
                                                &elem->buf, &elem->buflen);
    }

    OCI_RESULT(res);

    return str;    
}


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

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

    OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, 0);
    OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_RAW, 0);

    if (elem->handle != NULL)
    {
        OCIRaw *raw = *(OCIRaw **) elem->handle;
        ub4 raw_len = 0;
    
        OCI_CALL2
        (
            res, elem->con,