column.c

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

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

        case SQLT_RDD:
        case SQLT_RID:

            col->icode   = SQLT_STR;
            col->type    = OCI_CDT_TEXT;
            col->bufsize = (OCI_SIZE_ROWID+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->nty->tcode == SQLT_NCO)
                col->type = OCI_CDT_COLLECTION;                    
            else
                col->type = OCI_CDT_OBJECT;                    

            break;
        }
        case SQLT_REF:

            /* not supported datatypes */

            OCI_ExceptionNotSupported(stmt->con, stmt, col->ocode);

            res = FALSE;

        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 dealed with the Oracle compatibily
       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_ColumnGetFractionnalPrecision
 * ------------------------------------------------------------------------ */

int OCI_API OCI_ColumnGetFractionnalPrecision(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:
        case SQLT_CHR:

            if (col->csfrm == SQLCS_NCHAR)
                return MT("NVARCHAR2");
            else
                return MT("VARCHAR2");

        case SQLT_NUM:

            if (col->scale == -127 && col->prec > 0)