column.c

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

            col->bufsize  = sizeof(OCIStmt *);
            col->dtype    = OCI_HTYPE_STMT;
            break;

        case SQLT_RID:
        case SQLT_RDD:

            col->icode   = SQLT_STR;
            col->type    = OCI_CDT_TEXT;

            if ((col->ocode == SQLT_RDD) || (col->size > sizeof(OCIRowid *)))
            {
                /* For Oracle 7 ROWIDs and regular ROWID descriptors, the 
                   max size of the hex value is defined by the constant
                   OCI_SIZE_ROWID 
                */

                col->bufsize = (OCI_SIZE_ROWID + 1) * sizeof(dtext);
            }
            else
            {
                /* For ROWID descriptor, if column size is bigger than the size
                    of the descriptor, it means that an UROWID column and then 
                    the column size is the maximum size needed for representing
                    its value as an hex string
                */

                col->bufsize = (col->size + 1) * sizeof(dtext);
            }

            break;
 
        case SQLT_BIN:

            col->type    = OCI_CDT_RAW;
            col->bufsize = col->size + sizeof(dtext); /* for string conversion */
            break;

        case SQLT_BLOB:

            col->type    = OCI_CDT_LOB;
            col->subtype = OCI_BLOB;
            col->dtype   = OCI_DTYPE_LOB;
            col->bufsize = sizeof(OCILobLocator *);
            break;

        case SQLT_CLOB:

            col->type    = OCI_CDT_LOB;
            col->dtype   = OCI_DTYPE_LOB;
            col->bufsize = sizeof(OCILobLocator *);
           
            if (col->csfrm == SQLCS_NCHAR)
                col->subtype = OCI_NCLOB;
            else
                col->subtype = OCI_CLOB;

            break;

        case SQLT_BFILE:

            col->type    = OCI_CDT_FILE;
            col->subtype = OCI_BFILE;
            col->dtype   = OCI_DTYPE_LOB;
            col->bufsize = sizeof(OCILobLocator *);
            break;

        case SQLT_CFILE:

            col->type    = OCI_CDT_FILE;
            col->subtype = OCI_CFILE;
            col->bufsize = sizeof(OCILobLocator *);
            col->dtype   = OCI_DTYPE_LOB;
            break;

        case SQLT_LNG:
        case SQLT_LVC:
        case SQLT_LBI:
        case SQLT_LVB:
        case SQLT_VBI:

            if ((col->icode == SQLT_LNG || col->icode == SQLT_LVC) &&
                (stmt != NULL && stmt->long_mode == OCI_LONG_IMPLICIT))
            {
                 col->type = OCI_CDT_TEXT;
                 col->bufsize = (OCI_SIZE_LONG+1);
                 col->subtype = OCI_CLONG;
            }
            else
            {
                col->type    = OCI_CDT_LONG;
                col->bufsize = INT_MAX;
                
                if (col->icode == SQLT_LBI ||
                    col->icode == SQLT_LVB ||
                    col->icode == SQLT_VBI)
                {
                    col->subtype = OCI_BLONG;
                }
                else
                {
                    col->subtype = OCI_CLONG;
                }

            }

            break;

#if OCI_VERSION_COMPILE >= OCI_9

        case SQLT_TIMESTAMP:

            col->type    = OCI_CDT_TIMESTAMP;
            col->subtype = OCI_TIMESTAMP;
            col->dtype   = OCI_DTYPE_TIMESTAMP;
            col->bufsize = sizeof(OCIDateTime *);
            break;

        case SQLT_TIMESTAMP_TZ:

            col->type    = OCI_CDT_TIMESTAMP;
            col->subtype = OCI_TIMESTAMP_TZ;
            col->dtype   = OCI_DTYPE_TIMESTAMP_TZ;
            col->bufsize = sizeof(OCIDateTime *);
            break;

        case SQLT_TIMESTAMP_LTZ:

            col->type    = OCI_CDT_TIMESTAMP;
            col->subtype = OCI_TIMESTAMP_LTZ;
            col->dtype   = OCI_DTYPE_TIMESTAMP_LTZ;
            col->bufsize = sizeof(OCIDateTime *);
            break;

        case SQLT_INTERVAL_YM:

            col->type    = OCI_CDT_INTERVAL;
            col->subtype = OCI_INTERVAL_YM;
            col->dtype   = OCI_DTYPE_INTERVAL_YM;
            col->bufsize = sizeof(OCIInterval *);
            break;

        case SQLT_INTERVAL_DS:

            col->type    = OCI_CDT_INTERVAL;
            col->subtype = OCI_INTERVAL_DS;
            col->dtype   = OCI_DTYPE_INTERVAL_DS;
            col->bufsize = sizeof(OCIInterval *);
            break;

#endif

#if OCI_VERSION_COMPILE >= OCI_9

        case SQLT_PNTY:

#endif

        case SQLT_NTY:

            col->icode   = SQLT_NTY;
            col->bufsize = sizeof(void *);

            if (col->typinf->tcode == SQLT_NCO)
                col->type = OCI_CDT_COLLECTION;                    
            else
                col->type = OCI_CDT_OBJECT;                    

            break;

        case SQLT_REF:

            col->icode   = SQLT_REF;
            col->bufsize = sizeof(OCIRef *);
            col->type    = OCI_CDT_REF;                    

            break;

        case SQLT_CHR:
        case SQLT_STR:
        case SQLT_VCS:
        case SQLT_AFC:
        case SQLT_AVC:
        case SQLT_VST:
        case SQLT_LAB:
        case SQLT_OSL:
        case SQLT_SLS:
        default:

            col->icode   = SQLT_STR;
            col->type    = OCI_CDT_TEXT;
            col->bufsize = (col->size + 1) * sizeof(dtext);
            break;
    }

    return res;
}

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

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetName
 * ------------------------------------------------------------------------ */

const mtext * OCI_API OCI_ColumnGetName(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, NULL);

    return col->name;
}

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetType
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_ColumnGetType(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, OCI_UNKNOWN);

    OCI_RESULT(TRUE);

    return col->type;
}

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetCharsetForm
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_ColumnGetCharsetForm(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, OCI_CSF_NONE);

    OCI_RESULT(TRUE);

    if (col->csfrm == SQLCS_NCHAR)
        return OCI_CSF_NATIONAL;
    else if (col->csfrm == SQLCS_IMPLICIT)
        return OCI_CSF_CHARSET;
    else
        return OCI_CSF_NONE;
}

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetSize
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_ColumnGetSize(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, 0);

    OCI_RESULT(TRUE);

    /* Oracle 9i introduced CHAR attribute on string columns to indicate the 
       size of the column is not in bytes (default) but in chars
       OCI_ColumnDescribe() already managed the Oracle compatibly
       version, so if col->charsize is zero it means :
       - the column is not a string column 
       - the size is not in char
       - client does not support the OCI_ATTR_CHAR_SIZE attribute */
       
    if (col->charused == TRUE && col->charsize > 0)
        return col->charsize;
    else
        return col->size;
}

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetScale
 * ------------------------------------------------------------------------ */

int OCI_API OCI_ColumnGetScale(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, 0);

    OCI_RESULT(TRUE);

    return (int) col->scale;
}

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetPrecision
 * ------------------------------------------------------------------------ */

int OCI_API OCI_ColumnGetPrecision(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, 0);

    OCI_RESULT(TRUE);

    if (col->type == OCI_CDT_NUMERIC)
        return (int) col->prec;
    else
        return 0;
}

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetFractionalPrecision
 * ------------------------------------------------------------------------ */

int OCI_API OCI_ColumnGetFractionalPrecision(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, 0);

    OCI_RESULT(TRUE);

    if (col->type == OCI_CDT_TIMESTAMP)
        return (int) col->prec;
    else if (col->type == OCI_CDT_INTERVAL)
        return (int) col->prec2;
    else
        return 0;
}

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetLeadingPrecision
 * ------------------------------------------------------------------------ */

int OCI_API OCI_ColumnGetLeadingPrecision(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, 0);

    OCI_RESULT(TRUE);

    if (col->type == OCI_CDT_INTERVAL)
        return (int) col->prec;
    else
        return 0;
}

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetNullable
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ColumnGetNullable(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, FALSE);

    OCI_RESULT(TRUE);

    return (col->null == TRUE);
}

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetCharUsed
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ColumnGetCharUsed(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, FALSE);

    OCI_RESULT(TRUE);

    return (boolean) col->charused;
}

/* ------------------------------------------------------------------------ *
 * OCI_ColumnGetSQLType
 * ------------------------------------------------------------------------ */

const mtext * OCI_API OCI_ColumnGetSQLType(OCI_Column *col)
{
    OCI_CHECK_PTR(OCI_IPC_COLUMN, col, NULL);

    /* VARCHAR type will not be returned because Oracle does not make any 
       difference with VARCHAR2. If a column is created with VARCHAR, it is
       internally created as VARCHAR2
    */       

    OCI_RESULT(TRUE);

    switch(col->ocode)
    {
        case SQLT_AFC:

            if (col->csfrm == SQLCS_NCHAR)
                return MT("NCHAR");
            else
                return MT("CHAR");

        case SQLT_AVC:
        case SQLT_STR: