tinyoci.cpp

一个Oracle OCI编程接的C++封装

Date         :
Revision     :
***************************************************************************M*/
bool TinyOci::CleanDefineBuffer( void )
{
    int i;
    TinyNamedPtrList* pDefineList;
    TinyItem *pTinyItem;

    pDefineList = CurrentDefineList( );
    if( NULL == pDefineList )
        return false;

    for( i=0; i<pDefineList->GetCount(); i++ )
    {        
        pTinyItem = (TinyItem *)pDefineList->GetAt(i);
        if( NULL != pTinyItem->pValueArray )
        {
            memset( pTinyItem->pValueArray, 0, m_lMaxFetch * pTinyItem->lSize );         
        }
        if( NULL != pTinyItem->IndicatorArray )
        {         
            memset( pTinyItem->IndicatorArray, 0, m_lMaxFetch * sizeof( sb2 ) );
        }
    }

    return true;
}


/*M***************************************************************************
Method Name  : TinyOci::Fetch
            
Return       : TINYOCI_FETCH_ERROR 
               TINYOCI_FETCH_DONE   -> 取了一批数据  
               TINYOCI_FETCH_MORE   -> 取了一批数据              
               TINYOCI_FETCH_NODATA
                                             
Process      :
Note         : 
   
Author       : 
Date         :
Revision     :
***************************************************************************M*/
short TinyOci::Fetch( long &lRows )
{
    short rc;
    ub4   lRowCountSoFar;
    sword Status;

    if( !IsSelect() )
        return TINYOCI_FETCH_ERROR;

    lRows = 0;
    rc    = TINYOCI_FETCH_DONE;
        
    // 清除前一次FETCH得到的数据
    if( !CleanDefineBuffer() )
        return TINYOCI_FETCH_ERROR;

    m_Status = OCIStmtFetch( m_phStmtHandle, 
                             m_phErrorHandle,// Notes:
                             m_lMaxFetch,                                           
                             OCI_FETCH_NEXT,
                             OCI_DEFAULT );
    if( ( OCI_SUCCESS           != m_Status ) && 
        ( OCI_SUCCESS_WITH_INFO != m_Status ) &&
        ( OCI_NO_DATA           != m_Status ) )
        return TINYOCI_FETCH_ERROR;

    Status = OCIAttrGet( (dvoid *)m_phStmtHandle, 
                         (ub4)OCI_HTYPE_STMT, 
                         (dvoid *) &lRowCountSoFar, 
                         (ub4 *) 0, 
                         (ub4)OCI_ATTR_ROW_COUNT, 
                         m_phErrorHandle ); 
    if( OCI_SUCCESS != Status )
    {
        m_Status = Status;
        return TINYOCI_FETCH_ERROR;
    }
        
    switch( m_Status )
    {
    case OCI_NO_DATA:
        rc = TINYOCI_FETCH_NODATA;

        // 也有可能是最后一批数据                
        m_lRowFetched    = lRowCountSoFar - m_lRowCountSoFar;
        m_lRowCountSoFar = lRowCountSoFar;        
        if( m_lRowFetched > 0 )
            rc = TINYOCI_FETCH_DONE;
        break;

    case OCI_SUCCESS:
    case OCI_SUCCESS_WITH_INFO:
        rc = TINYOCI_FETCH_MORE;
        
        // 也有可能是最后一批数据                
        m_lRowFetched    = lRowCountSoFar - m_lRowCountSoFar;
        m_lRowCountSoFar = lRowCountSoFar;                           
        if( m_lRowFetched < m_lMaxFetch )
            rc = TINYOCI_FETCH_DONE;
        break;
    }

    lRows = m_lRowFetched;
    return rc;
}


short TinyOci::Fetch( CMXList< CMXList<CMXString> > &RowsList )
{
    long  i;
    short f;
    long  lRows;
    short rc;
    TinyNamedPtrList *pDefineList;
    CMXList<CMXString> *pFieldsList;
    CMXString *pstrField;
    TinyItem *pTinyItem;
    char szField[128];

    rc = Fetch( lRows );
    switch( rc )
    {
    case TINYOCI_FETCH_ERROR:
    case TINYOCI_FETCH_NODATA:
        break;

    case TINYOCI_FETCH_DONE:
    case TINYOCI_FETCH_MORE:        
        if( NULL == (pDefineList = CurrentDefineList()) )
            return TINYOCI_FETCH_ERROR;

        for( i=0; i<lRows; i++ )
        {
            pFieldsList = new CMXList<CMXString>;
            for( f=0; f<pDefineList->GetCount(); f++ )
            {
                // 把每一个字段转换成字符串，并添加到pFieldsList;
                // 检查每一个字段是否为空值。空字符串可以用来表示“空值”。
                pTinyItem = (TinyItem *)pDefineList->GetAt(f);                                
                switch( pTinyItem->nType )
                {
                case SQLT_FLT:// - double
                    if( -1 == pTinyItem->IndicatorArray[i] )
                        //strcpy( szField, "<NULL>" );
                        szField[0] = 0;
                    else
                        sprintf( szField, "%.5f", ((double*)pTinyItem->pValueArray)[i] );
                    pstrField = new CMXString( (const char*)szField );
                    break;

                case SQLT_INT:// - long
                    if( -1 == pTinyItem->IndicatorArray[i] )
                        //strcpy( szField, "<NULL>" );
                        szField[0] = 0;
                    else
                        sprintf( szField, "%ld", ((long*)pTinyItem->pValueArray)[i] );
                    pstrField = new CMXString( (const char*)szField );
                    break;

                case SQLT_STR:// - sz char                    
                    if( ( -1 == pTinyItem->IndicatorArray[i] ) ||
                        ((((const char*)pTinyItem->pValueArray) + i*pTinyItem->lSize)[0] == 0) )
                        pstrField = new CMXString( (const char*)"" );                    
                    else
                        pstrField = new CMXString( ((const char*)pTinyItem->pValueArray) + i*pTinyItem->lSize );
                    break;

                default:
                    return TINYOCI_FETCH_ERROR;
                    //break;
                }
                
                // 取得一个字段
                pFieldsList->AddTail( pstrField );
            }

            // 取得一条记录
            RowsList.AddTail( pFieldsList );
        }
        break;
    }

    return rc;
}

/*M***************************************************************************
Method Name  : TinyOci::CurrentDefineList
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
TinyNamedPtrList* TinyOci::CurrentDefineList( void )
{
    if( DescDefineNameList.GetCount() > 0 )
        return &DescDefineNameList;
    else if( DefineNameList.GetCount() > 0 )
        return &DefineNameList;
    else 
        return (TinyNamedPtrList*)NULL;    
}

/*M***************************************************************************
Method Name  : TinyOci::CheckNull
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
void TinyOci::CheckNull( void )
{
}

/*M***************************************************************************
Method Name  : TinyOci::SetPrefetch
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool  TinyOci::SetPrefetch( long lPrefetch )
{
    m_lPrefetch = lPrefetch;
    return true;
}

/*M***************************************************************************
Method Name  : TinyOci::SetMaxFetch
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool  TinyOci::SetMaxFetch( long lMaxFetch )
{
    m_lMaxFetch = (lMaxFetch > TINYOCI_MAXFETCH) ? TINYOCI_MAXFETCH:lMaxFetch;
    return true;
}

/*M***************************************************************************
Method Name  : TinyOci::IsCommBreak
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool TinyOci::IsCommBreak( void )
{
    sb4 aErrCode[] = 
    {
        TINYOCI_CONNECTION_BROKEN,
        TINYOCI_SESSION_KILLED,   
        TINYOCI_IVALID_SESSION,   
        TINYOCI_EOF_COMM_CHANNEL 
    };
    sb4 ErrorCode;
    int nItem;
    int i;

    ErrorCode = GetError( NULL );    
    nItem     = sizeof( aErrCode )/sizeof( aErrCode[0] );
    for( i=0; i<nItem; i++ )
    {
        if( ErrorCode == aErrCode[i] )
            return true;
    }

    return false;
}

/*M***************************************************************************
Method Name  : TinyOci::PushBindList
            
Return       :                
Process      :
Note         : IndicatorArray allocation is defered !
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool TinyOci::PushBindList( const char *pszName, ub2 DataType, long lSize, void *pValue )
{
    TinyItem *p;
    
    p = new TinyItem;
    strcpy( p->szName, pszName );
    p->nType          = DataType;
    p->lSize          = lSize;
    p->pValueArray    = pValue;
    p->IndicatorArray =  NULL; // Defered

    return BindNameList.Append( pszName, p );
}

/*M***************************************************************************
Method Name  : TinyOci::PushDefineList
            
Return       :                
Process      :
Note         : IndicatorArray allocation is defered !
               
               DataType只能取以下的值：
               SQLT_FLT
               SQLT_INT
               SQLT_STR
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool TinyOci::PushDefineList( const char *pszName, ub2 DataType, long lSize, void *pValue )
{
    bool bRc = false;
    TinyItem *p;
    
    switch( DataType )
    {
    case SQLT_FLT:
    case SQLT_INT:
    case SQLT_STR:
        p = new TinyItem;
        strcpy( p->szName, pszName );
        p->nType          = DataType;
        p->lSize          = lSize;
        p->pValueArray    = pValue;
        p->IndicatorArray =  NULL; // Defered
        
        bRc = DefineNameList.Append( p->szName, p );
        break;

    default:
        bRc = false;
        break;
    }
    
    return bRc;
}

/*M***************************************************************************
Method Name  : TinyOci::CleanBindList,CleanDefineList
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool TinyOci::CleanBindList( void )
{
    TinyItem *pTinyItem;
    int i;

    for(i=0; i<BindNameList.GetCount(); i++ )
    {
        pTinyItem = (TinyItem *)BindNameList.GetAt(i);
        if( NULL != pTinyItem->IndicatorArray )
        {
            delete [] pTinyItem->IndicatorArray;
            pTinyItem->IndicatorArray = NULL;
        }
        delete pTinyItem;
    }

    BindNameList.Clean();    
    return true;
}

bool TinyOci::CleanDefineList( void )
{
    TinyItem *pTinyItem;
    int i;

    for(i=0; i<DefineNameList.GetCount(); i++ )
    {
        pTinyItem = (TinyItem *)DefineNameList.GetAt(i);
        if( NULL != pTinyItem->IndicatorArray )
        {
            delete [] pTinyItem->IndicatorArray;
            pTinyItem->IndicatorArray = NULL;
        }
        delete pTinyItem;
    }
    
    DefineNameList.Clean();
    return true;
}

bool TinyOci::CleanDescDefineList( void )
{
    TinyItem *pTinyItem;
    int i;

    for(i=0; i<DescDefineNameList.GetCount(); i++ )
    {
        pTinyItem = (TinyItem *)DescDefineNameList.GetAt(i);
        if( NULL != pTinyItem->IndicatorArray )
        {            
            delete [] (char*)(pTinyItem->IndicatorArray);
            pTinyItem->IndicatorArray = NULL;
        }

        if( NULL != pTinyItem->pValueArray )
        {            
            delete [] (char*)(pTinyItem->pValueArray);
            pTinyItem->pValueArray = NULL;
        }

        delete pTinyItem;
    }
    
    DescDefineNameList.Clean();
    return true;
}

bool TinyOci::ResetList( void )
{
    return ( CleanBindList() &&
             CleanDefineList() &&
             CleanDescDefineList()
           );
}

/*M***************************************************************************
Method Name  : TinyOci::SetDateFormat
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool TinyOci::SetDateFormat( short nFormat )
{    
    char szFormat[256];

    switch( nFormat )
    {
    case TINYOCI_DATEFORMAT_1:
        strcpy( szFormat, "Alter session set NLS_DATE_FORMAT = 'YYYYMMDD' ");
        break;
    case TINYOCI_DATEFORMAT_3:
        strcpy( szFormat, "Alter session set NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS' ");
        break;
    case TINYOCI_DATEFORMAT_4:
        strcpy( szFormat, "Alter session set NLS_DATE_FORMAT = 'DD-MON-YY' ");
        break;
    case TINYOCI_DATEFORMAT_5:
        strcpy( szFormat, "Alter session set NLS_DATE_FORMAT = 'DD-MON-YYYY' ");
        break;
    case TINYOCI_DATEFORMAT_2:
    default:
        strcpy( szFormat, "Alter session set NLS_DATE_FORMAT = 'YYYYMMDDHH24MISS' ");
        break;
    }

    return Execute( szFormat );
}


// End Of File