tinyoci.cpp

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

/*H***************************************************************************
File            : tinyoci.h
Subsystem       : 
Function Name(s):

Description     : 
Author          : Ben
Date            : 2002.05.20
Revision        : 

History
-------
2002.05.20      Ben     Create
                        Many idea is ported from Jason's DBi.

Copyright (c) ShenZhen COMEXE Communication Technology Co. Ltd.  
***************************************************************************H*/
#include <stdlib.h>
#include <string.h>
#include "tinyoci.h"

/*M***************************************************************************
Method Name  : TinyNamedPtrList::*
Return       :                
Process      :
Note         : Append: TinyNamedPtrList不维护pPtr !
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool TinyNamedPtrList::Append( const char*pszName, void *pPtr )
{
    TinyNamedPtr *pTinyNamedPtr;

    pTinyNamedPtr = _Get( pszName );
    if( NULL == pTinyNamedPtr )
    {
        pTinyNamedPtr          = new TinyNamedPtr;
        pTinyNamedPtr->pszName = new char[strlen(pszName)+1];
        strcpy( pTinyNamedPtr->pszName, pszName );
        pTinyNamedPtr->pPtr    = pPtr;

        m_PtrList.AddTail( pTinyNamedPtr );
    }
    else
    {
        // Memory leak ! If ...
        pTinyNamedPtr->pPtr = pPtr;
    }

    return true;
}

TinyNamedPtr* TinyNamedPtrList::_Get( const char *pszName )
{
    TinyNamedPtr *pTinyNamedPtr;
    int i;

    for( i=0; i<m_PtrList.GetPtrNum(); i++ )
    {
        pTinyNamedPtr = (TinyNamedPtr *)m_PtrList.GetAt(i);
        if( strcmp( pszName, pTinyNamedPtr->pszName ) == 0 )
        {
            return pTinyNamedPtr;
        }
    }    
    
    return (TinyNamedPtr *)NULL;
}

void* TinyNamedPtrList::Get( const char* pszName )
{
    TinyNamedPtr *pTinyNamedPtr;
    pTinyNamedPtr = _Get( pszName );
    if( NULL == pTinyNamedPtr )
    {
        return NULL;
    }

    return pTinyNamedPtr->pPtr;
}

bool TinyNamedPtrList::Delete( const char *pszName )
{
    TinyNamedPtr *pTinyNamedPtr;
    int i;

    for( i=0; i<m_PtrList.GetPtrNum(); i++ )
    {
        pTinyNamedPtr = (TinyNamedPtr *)m_PtrList.GetAt(i);
        if( strcmp( pszName, pTinyNamedPtr->pszName ) )
        {
            delete [] pTinyNamedPtr->pszName;
            delete pTinyNamedPtr;

            m_PtrList.DeleteAt(i);
            return true;
        }
    }    
    
    return false;
}

bool TinyNamedPtrList::Clean( void )
{
    TinyNamedPtr *pTinyNamedPtr;
    int i;

    for( i=0; i<m_PtrList.GetPtrNum(); i++ )
    {
        pTinyNamedPtr = (TinyNamedPtr *)m_PtrList.GetAt(i);
        
        delete [] pTinyNamedPtr->pszName;
        pTinyNamedPtr->pszName = NULL;
        delete pTinyNamedPtr;        
    }    
    
    m_PtrList.DeleteAll();
    return true;
}

long TinyNamedPtrList::GetCount( void )
{
    return m_PtrList.GetPtrNum();
}

void* TinyNamedPtrList::GetAt( int i )
{
    TinyNamedPtr *pTinyNamedPtr;
    pTinyNamedPtr = (TinyNamedPtr *)m_PtrList.GetAt(i);

    return pTinyNamedPtr->pPtr;
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
/*M***************************************************************************
Method Name  : TinyOci::TinyOci
               TinyOci::~TinyOci
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
TinyOci::TinyOci()
{
    m_phOCIEnv      = NULL;
    m_phOCIServer   = NULL;
    m_phOCISession  = NULL;
    m_phErrorHandle = NULL;    
    m_phStmtHandle  = NULL;          
    m_phOCISvcCtx   = NULL;
    m_StmtType      = 0;    // Unknow !
    m_Status        = OCI_SUCCESS;    

    m_nIter         = 1;
    m_lMaxFetch     = 1;
    m_lPrefetch     = 50;
    m_lRowCountSoFar= 0;
    m_lRowFetched   = 0; 
}

/*M***************************************************************************
Method Name  : TinyOci::Init
               
Return       :                
Process      : Allocate all needed OCI handles
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool TinyOci::Init( void )
{    
    if( OCI_SUCCESS != (m_Status = OCIInitialize((ub4) OCI_DEFAULT, (dvoid *)0,
                                     0,//(dvoid * (*)(dvoid *, size_t)) 0,
                                     0,//(dvoid * (*)(dvoid *, dvoid *, size_t))0,
                                     0 //(void (*)(dvoid *, dvoid *)) 0 
                                    )) )
    {
        return false;
    }    
    if( OCI_SUCCESS != (m_Status = OCIEnvInit( (OCIEnv **) &m_phOCIEnv, OCI_DEFAULT, (size_t) 0, (dvoid **) 0 )) )
    {
        return false;
    }
        
    if( OCI_SUCCESS != (m_Status = OCIHandleAlloc( (dvoid *) m_phOCIEnv, 
                                       (dvoid **) &m_phErrorHandle, 
                                       OCI_HTYPE_ERROR, (size_t) 0, 
                                       (dvoid **) 0)) )
    {
        return false;
    }

    if( OCI_SUCCESS != (m_Status = OCIHandleAlloc( (dvoid *) m_phOCIEnv, 
                                       (dvoid **) &m_phOCIServer, 
                                       OCI_HTYPE_SERVER, 
                                       (size_t) 0, 
                                       (dvoid **) 0)) )
    {
        return false;
    }
    if( OCI_SUCCESS != (m_Status = OCIHandleAlloc( (dvoid *) m_phOCIEnv, 
                                       (dvoid **) &m_phOCISession, 
                                       OCI_HTYPE_SESSION, 
                                       (size_t) 0, (dvoid **) 0)) )
    {
        return false;
    }

    if( OCI_SUCCESS != (m_Status = OCIHandleAlloc( (dvoid *) m_phOCIEnv, 
                                       (dvoid **) &m_phStmtHandle,
                                       OCI_HTYPE_STMT, 
                                       (size_t) 0, 
                                       (dvoid **) 0)) )
    {
        return false;
    }

    if( OCI_SUCCESS != (m_Status = OCIHandleAlloc( (dvoid *) m_phOCIEnv, 
                                       (dvoid **) &m_phOCISvcCtx, 
                                       (ub4) OCI_HTYPE_SVCCTX, 
                                       (size_t) 0, 
                                       (dvoid **) 0)) )
    {
        return false;
    }

    return true;
}

TinyOci::~TinyOci()
{
    // Clean all Binding and Defining List
    ResetList();
    
    if(NULL != m_phOCIEnv)
    {
        OCIHandleFree( (dvoid *) m_phOCIEnv, OCI_HTYPE_ENV );
    }
}

/*M***************************************************************************
Method Name  : TinyOci::GetError
            
Return       :  ORACLE Error Code is returned               
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
sb4 TinyOci::GetError( char *pszMsg )
{
    char TempBuffer[512];
    long errcode=0;

    switch ( m_Status )
    {
    case OCI_SUCCESS:
        if( NULL != pszMsg ) 
            strcpy( pszMsg, "NO ERROR MSG" );
        break;

    case OCI_SUCCESS_WITH_INFO:
        if( NULL != pszMsg )
            strcpy( pszMsg, (char*)"Error - OCI_SUCCESS_WITH_INFO" );
        break;

    case OCI_NEED_DATA:
        if( NULL != pszMsg )
            strcpy( pszMsg, (char*)"Error - OCI_NEED_DATA" );
        break;

    case OCI_NO_DATA:
        if( NULL != pszMsg )
            strcpy( pszMsg, (char*)"Error - OCI_NODATA" );
        break;

    case OCI_ERROR:
        OCIErrorGet((dvoid *)m_phErrorHandle, (ub4) 1, (OraText *) NULL, (sb4*)&errcode,
                    (ub1*)TempBuffer, (ub4) sizeof(TempBuffer)-1, OCI_HTYPE_ERROR);
        if( NULL != pszMsg )
            sprintf( pszMsg, "(ErrorCode=%ld): %s", errcode, TempBuffer ); 
        break;

    case OCI_INVALID_HANDLE:
        if( NULL != pszMsg )
            strcpy( pszMsg, (char*)"Error - OCI_INVALID_HANDLE" );
        break;

    case OCI_STILL_EXECUTING:
        if( NULL != pszMsg )
            strcpy( pszMsg, (char*)"Error - OCI_STILL_EXECUTE" );
        break;

    case OCI_CONTINUE:
        if( NULL != pszMsg )
            strcpy( pszMsg, (char*)"Error - OCI_CONTINUE" );
        break;

    default:
        if( NULL != pszMsg )
            strcpy( pszMsg, (char*)"Error - Unknown" );
        break;
    }

    return errcode;
}

/*M***************************************************************************
Method Name  : TinyOci::Connect
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool  TinyOci::Connect( const char *pszConnectStr, const char *pszUser, const char *pszPasswd )
{    
    // Attach to ORACLE
    m_Status = OCIServerAttach( m_phOCIServer, m_phErrorHandle, (OraText *)pszConnectStr, strlen((char*)pszConnectStr), OCI_DEFAULT);
    if( OCI_SUCCESS != m_Status )
    {        
        return false;
    }

    // Associate DBServer with Service Context
    m_Status = OCIAttrSet ( m_phOCISvcCtx, OCI_HTYPE_SVCCTX, m_phOCIServer, 0, OCI_ATTR_SERVER, m_phErrorHandle );    
    if(OCI_SUCCESS != m_Status)
    {        
        return false;
    }

    // Set User name
    m_Status = OCIAttrSet( m_phOCISession, OCI_HTYPE_SESSION, (void*)pszUser, strlen(pszUser), OCI_ATTR_USERNAME, m_phErrorHandle );
    if(m_Status != OCI_SUCCESS)
    {
        return false;
    }
    
    // Set password
    m_Status = OCIAttrSet( m_phOCISession, OCI_HTYPE_SESSION, (void*)pszPasswd, strlen( pszPasswd ), OCI_ATTR_PASSWORD, m_phErrorHandle );
    if(m_Status != OCI_SUCCESS)
    {
        return false;
    }

    // Authenticate
    m_Status = OCISessionBegin ( m_phOCISvcCtx, m_phErrorHandle, m_phOCISession, OCI_CRED_RDBMS, OCI_DEFAULT );
    if(OCI_SUCCESS != m_Status)
    {        
        return false;
    }

    // Set the Authentication handle in the service handle
    m_Status = OCIAttrSet( m_phOCISvcCtx, OCI_HTYPE_SVCCTX, m_phOCISession, 0,  OCI_ATTR_SESSION, m_phErrorHandle );
    if (OCI_SUCCESS != m_Status)
    {        
        return false;
    }

    return true;
}


/*M***************************************************************************
Method Name  : TinyOci::Disconnect
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool  TinyOci::Disconnect( void )
{
    sword m_Status;

    m_Status = OCISessionEnd( m_phOCISvcCtx, m_phErrorHandle, m_phOCISession, (ub4)0 );
    if (OCI_SUCCESS != m_Status)
    {     
        return false;
    }
    m_Status = OCIServerDetach( m_phOCIServer, m_phErrorHandle, (ub4)OCI_DEFAULT );
    if (OCI_SUCCESS != m_Status)
    {     
        return false;
    }

    return true;
}


/*M***************************************************************************
Method Name  : TinyOci::IsSelect
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool  TinyOci::IsSelect( void )
{
    return ( OCI_STMT_SELECT == m_StmtType );
}


/*M***************************************************************************
Method Name  : TinyOci::Commit
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool  TinyOci::Commit( void )
{
    sword m_Status;

    m_Status = OCITransCommit( m_phOCISvcCtx, m_phErrorHandle, OCI_DEFAULT );
    if (OCI_SUCCESS != m_Status)
    {     
        return false;
    }

    return true;
}


/*M***************************************************************************
Method Name  : TinyOci::RollBack
            
Return       :                
Process      :
Note         : 
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool  TinyOci::RollBack( void )
{
    sword m_Status;

    m_Status = OCITransRollback( m_phOCISvcCtx, m_phErrorHandle, OCI_DEFAULT );
    if (OCI_SUCCESS != m_Status)
    {     
        return false;
    }

    return true;
}

/*M***************************************************************************
Method Name  : TinyOci::Bind
            
Return       :                
Process      :
Note         : IndicatorArray is allocated here !
Author       : 
Date         :
Revision     :
***************************************************************************M*/
bool TinyOci::Bind( void )
{
    OCIBind  *phBind;
    TinyItem *pTinyItem;
    int i;

    for(i=0; i<BindNameList.GetCount(); i++ )
    {
        pTinyItem = (TinyItem *)BindNameList.GetAt(i);