📄 sh_database.cpp

📁 rsa算法打的一个包
💻 CPP
字号:
// SH_Database.cpp: implementation of the SH_Database class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SH_Database.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

SH_Database::SH_Database()
{
	m_hEnv  = NULL;
	m_hConn = NULL;
	m_hStmt = NULL;
	
	m_nTimeout = 5;

	m_strDSN    = _T("");
	m_strUID    = _T("");
	m_strPWD    = _T("");
	m_strSQL    = _T("");
    m_strDriver = _T("");

}

SH_Database::~SH_Database()
{
    /*Database connection close*/
	Close();

    /*Memory clear*/
    Clear();
}

void SH_Database::Close()
{
	/*Close handle*/
	if(m_hStmt)
		SQLFreeHandle(SQL_HANDLE_STMT,m_hStmt);


	if(m_hConn)
	{
		SQLDisconnect(m_hConn);
		SQLFreeHandle(SQL_HANDLE_DBC,m_hConn);
	}
	if(m_hEnv)
		SQLFreeHandle(SQL_HANDLE_ENV,m_hEnv);

	m_hEnv  = NULL;
	m_hConn = NULL;
	m_hStmt = NULL;
}

BOOL SH_Database::Open(LPCTSTR szDatabase,LPCTSTR szUID,LPCTSTR szPWD,int nTimeout)
{
	SQLRETURN sr;

	SetDatabase(szDatabase);
	SetUID(szUID);
	SetPWD(szPWD);
    SetDSN(szDatabase);
	SetTimeout(nTimeout);

	sr = SQLAllocHandle(SQL_HANDLE_ENV,NULL,&m_hEnv);
	if(!SUCCEED(sr))
	{
		TRACE("Allocate ODBC Env failed\n");
		return FALSE;
	}
	sr = SQLSetEnvAttr(m_hEnv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); 
	if(!SUCCEED(sr))
	{
		TRACE("Set ODBC Env attribute failed\n");
		SQLFreeHandle(SQL_HANDLE_ENV,m_hEnv);
		return FALSE;
	}
	sr = SQLAllocHandle(SQL_HANDLE_DBC,m_hEnv,&m_hConn);
	if(!SUCCEED(sr))
	{
		TRACE("Allocate ODBC DBC failed\n");
		SQLFreeHandle(SQL_HANDLE_ENV,m_hEnv);
		return FALSE;
	}

	SQLSetConnectAttr(m_hConn, (SQLINTEGER)SQL_LOGIN_TIMEOUT, (SQLPOINTER)m_nTimeout, 0);

	/* Connect to data source */
	sr = SQLConnect(m_hConn,
		                 (SQLCHAR*)GetDSN(), SQL_NTS,
						 (SQLCHAR*)GetUID(), SQL_NTS,
						 (SQLCHAR*)GetPWD(), SQL_NTS);
	 
	if (!SUCCEED(sr))
	{
		TRACE("ODBC connect failed\n");
		SQLFreeHandle(SQL_HANDLE_DBC,m_hConn);
		SQLFreeHandle(SQL_HANDLE_ENV,m_hEnv);
		return FALSE;
	}
    /* Allocate statement handle */
    sr = SQLAllocHandle(SQL_HANDLE_STMT, m_hConn, &m_hStmt); 
	if(!SUCCEED(sr))
	{
		TRACE("Allocate ODBC stmt failed\n");
		SQLFreeHandle(SQL_HANDLE_DBC,m_hConn);
		SQLDisconnect(m_hConn);
		SQLFreeHandle(SQL_HANDLE_ENV,m_hEnv);
		return FALSE;
	}

    if(!GetColumns())
        OutputDebugString("Error:Fail to retrieve database's information!\n");

    return TRUE;
}
BOOL SH_Database::OpenEx(LPCTSTR szDatabase,int nTimeout)
{
	SWORD nResult;
	SQLRETURN sr;
	UCHAR szConnOut[MAX_CONNECT_LEN];

	SetDatabase(szDatabase);
    SetDSN(szDatabase);
	SetTimeout(nTimeout);

	sr = SQLAllocHandle(SQL_HANDLE_ENV,NULL,&m_hEnv);
	if(!SUCCEED(sr))
	{
		TRACE("Allocate ODBC Env failed\n");
		return FALSE;
	}
	sr = SQLSetEnvAttr(m_hEnv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); 
	if(!SUCCEED(sr))
	{
		TRACE("Set ODBC Env attribute failed\n");
		SQLFreeHandle(SQL_HANDLE_ENV,m_hEnv);
		return FALSE;
	}
	sr = SQLAllocHandle(SQL_HANDLE_DBC,m_hEnv,&m_hConn);
	if(!SUCCEED(sr))
	{
		TRACE("Allocate ODBC DBC failed\n");
		SQLFreeHandle(SQL_HANDLE_ENV,m_hEnv);
		return FALSE;
	}

	SQLSetConnectAttr(m_hConn, (SQLINTEGER)SQL_LOGIN_TIMEOUT, (SQLPOINTER)m_nTimeout, 0);

    /* Connect to data source */

    sr = SQLDriverConnect(m_hConn, 
                          NULL,
		                  (SQLCHAR*)GetDSN(), SQL_NTS,
		                  szConnOut, sizeof(szConnOut)-1,
		                  &nResult, SQL_DRIVER_NOPROMPT);
	 
	if (!SUCCEED(sr))
	{
		TRACE("ODBC connect failed\n");
		SQLFreeHandle(SQL_HANDLE_DBC,m_hConn);
		SQLFreeHandle(SQL_HANDLE_ENV,m_hEnv);
		return FALSE;
	}
    /* Allocate statement handle */
    sr = SQLAllocHandle(SQL_HANDLE_STMT, m_hConn, &m_hStmt); 
	if(!SUCCEED(sr))
	{
		TRACE("Allocate ODBC stmt failed\n");
		SQLFreeHandle(SQL_HANDLE_DBC,m_hConn);
		SQLDisconnect(m_hConn);
		SQLFreeHandle(SQL_HANDLE_ENV,m_hEnv);
		return FALSE;
	}
 
    if(!GetColumns())
        OutputDebugString("Error:Fail to retrieve database's information!\n");

	return TRUE;
}
BOOL SH_Database::SUCCEED(SQLRETURN sr)
{
    if(sr == SQL_SUCCESS || sr == SQL_SUCCESS_WITH_INFO)
        return TRUE;
    else
    {
        TRACE("SQL error.Error no is %d\n",sr);
        return FALSE;
    }
}

BOOL SH_Database::ExecuteSQL(LPCTSTR lpszSQL,int nStrLen)
{
	SQLRETURN sr = SQLExecDirect(m_hStmt,(SQLTCHAR*)lpszSQL,(SQLINTEGER)nStrLen);
	
	return SUCCEED(sr);
}

BOOL SH_Database::GetRowCount(int * pnCount)
{
	SQLRETURN sr = SQL_ERROR;

	sr = SQLRowCount(m_hStmt,(SQLINTEGER*)pnCount);

	return SUCCEED(sr);
}

BOOL SH_Database::Fetch()
{
	SQLRETURN sr = SQL_ERROR;
    char str[256] = {0};

    sprintf(str,"Executing fetch operation,HSTMT 's handle %08X\n",(DWORD)m_hStmt);
    OutputDebugString(str);
    
    sr = SQLFetch(m_hStmt);

	return SUCCEED(sr);
}

BOOL SH_Database::MoveFirst()
{
	SQLRETURN sr = SQL_ERROR;

	return SUCCEED(sr);

}

BOOL SH_Database::MoveLast()
{
	SQLRETURN sr = SQL_ERROR;

	return SUCCEED(sr);

}

BOOL SH_Database::MoveNext()
{
	SQLRETURN sr = SQL_ERROR;

	sr = SQLFetch(m_hStmt);

	return SUCCEED(sr);

}

BOOL SH_Database::MovePrev()
{
	SQLRETURN sr = SQL_ERROR;

	return SUCCEED(sr);
}

BOOL SH_Database::BindCol(int nIndex, int nType, void *pValue, int nLen)
{
	SQLRETURN sr = SQL_ERROR;
	SQLINTEGER cbLen;

	sr = SQLBindCol(m_hStmt,nIndex,nType,(SQLPOINTER)pValue,nLen,(SQLINTEGER*)&cbLen);

	return SUCCEED(sr);
}
BOOL SH_Database::BindCol(LPCTSTR szTable,LPCTSTR szField,int nType,void * pValue,int nLen)
{
	SQLRETURN sr = SQL_ERROR;
    SH_Field *  pField;

    pField = FindField(szTable,szField);

    if(pField)
    {
        sr = BindCol(pField->nPos,nType,pValue,nLen);
    }

	return SUCCEED(sr);
}
BOOL SH_Database::BindCol(LPCTSTR szTable,LPCTSTR szField,void * pValue,int nLen)
{
	SQLRETURN sr = SQL_ERROR;
    SH_Field *  pField;

    pField = FindField(szTable,szField);

    if(pField)
    {
        sr = BindCol(pField->nPos,pField->nType,pValue,nLen);
    }

	return SUCCEED(sr);
}

BOOL SH_Database::FetchBegin()
{
    /* Allocate statement handle */
	SQLRETURN sr = SQL_ERROR;
    sr = SQLAllocHandle(SQL_HANDLE_STMT, m_hConn, &m_hStmt); 
	return SUCCEED(sr);
}

BOOL SH_Database::FetchEnd()
{
	SQLRETURN sr = SQL_ERROR;
    sr = SQLFreeHandle(SQL_HANDLE_STMT,m_hStmt); 

//  sr = SQLFreeStmt(m_hStmt,SQL_UNBIND|SQL_CLOSE);
    m_hStmt = NULL;
	return SUCCEED(sr);
}
BOOL SH_Database::GetColumns()
{
    BOOL          bRet = FALSE;
    /* Declare buffers for result set data */
    SQLCHAR       szCatalog[129], szSchema[129];
    SQLCHAR       szTableName[129], szColumnName[129];
    SQLCHAR       szTypeName[129], szRemarks[255];
    SQLCHAR       szColumnDefault[129], szIsNullable[129];
    SQLINTEGER    ColumnSize, BufferLength, CharOctetLength, OrdinalPosition;
    SQLSMALLINT   DataType, DecimalDigits, NumPrecRadix, Nullable;
    SQLSMALLINT   SQLDataType, DatetimeSubtypeCode;
    SQLRETURN     sr;

    /* Declare buffers for bytes available to return */

    SQLINTEGER cbCatalog, cbSchema, cbTableName, cbColumnName;
    SQLINTEGER cbDataType, cbTypeName, cbColumnSize, cbBufferLength;
    SQLINTEGER cbDecimalDigits, cbNumPrecRadix, cbNullable, cbRemarks;
    SQLINTEGER cbColumnDefault, cbSQLDataType, cbDatetimeSubtypeCode, cbCharOctetLength;
    SQLINTEGER cbOrdinalPosition, cbIsNullable;

    SH_Table *     pTable;
    SH_Field *     pField;

    
    FetchBegin();
    
    sr = SQLColumns(m_hStmt,NULL, 0,NULL, 0,NULL, 0,NULL, 0);

    if (SUCCEED(sr)) 
    {

       /* Bind columns in result set to buffers */
       SQLBindCol(m_hStmt, 1, SQL_C_CHAR, szCatalog, 129,&cbCatalog);
       SQLBindCol(m_hStmt, 2, SQL_C_CHAR, szSchema, 129, &cbSchema);
       SQLBindCol(m_hStmt, 3, SQL_C_CHAR, szTableName, 129,&cbTableName);
       SQLBindCol(m_hStmt, 4, SQL_C_CHAR, szColumnName, 129, &cbColumnName);
       SQLBindCol(m_hStmt, 5, SQL_C_SSHORT, &DataType, 0, &cbDataType);
       SQLBindCol(m_hStmt, 6, SQL_C_CHAR, szTypeName, 129, &cbTypeName);
       SQLBindCol(m_hStmt, 7, SQL_C_SLONG, &ColumnSize, 0, &cbColumnSize);
       SQLBindCol(m_hStmt, 8, SQL_C_SLONG, &BufferLength, 0, &cbBufferLength);
       SQLBindCol(m_hStmt, 9, SQL_C_SSHORT, &DecimalDigits, 0, &cbDecimalDigits);
       SQLBindCol(m_hStmt, 10, SQL_C_SSHORT, &NumPrecRadix, 0, &cbNumPrecRadix);
       SQLBindCol(m_hStmt, 11, SQL_C_SSHORT, &Nullable, 0, &cbNullable);
       SQLBindCol(m_hStmt, 12, SQL_C_CHAR, szRemarks, 255, &cbRemarks);
       SQLBindCol(m_hStmt, 13, SQL_C_CHAR, szColumnDefault, 129, &cbColumnDefault);
       SQLBindCol(m_hStmt, 14, SQL_C_SSHORT, &SQLDataType, 0, &cbSQLDataType);
       SQLBindCol(m_hStmt, 15, SQL_C_SSHORT, &DatetimeSubtypeCode, 0,&cbDatetimeSubtypeCode);
       SQLBindCol(m_hStmt, 16, SQL_C_SLONG, &CharOctetLength, 0, &cbCharOctetLength);
       SQLBindCol(m_hStmt, 17, SQL_C_SLONG, &OrdinalPosition, 0, &cbOrdinalPosition);
       SQLBindCol(m_hStmt, 18, SQL_C_CHAR, szIsNullable, 129, &cbIsNullable);

       while(Fetch()) 
       {
           bRet = TRUE;
           
           if(IsSystemTable((LPCTSTR)szTableName)) continue;

           pTable = AppendTable((LPCTSTR)szTableName);

           pField = AppendField(pTable,(LPCTSTR)szColumnName);
           pField->nLen  = ColumnSize;
           pField->nPos  = OrdinalPosition;
           pField->nType = SQLDataType;

/*
           TRACE("Table:%s,Field:%s,TypeName:%s,DataType:%d,SQLType:%d,Position:%d,ColumnSize:%d\n",
               szTableName,szColumnName,szTypeName,DataType,SQLDataType,OrdinalPosition,ColumnSize);
*/
       }
    }

    FetchEnd();
    return bRet;
}

SH_Database::SH_Table *  SH_Database::AppendTable(LPCTSTR lpszTable)
{
    SH_Table *   pTable;

    pTable = FindTable(lpszTable);
    if(pTable == NULL)
    {
        pTable = new SH_Table;

        strcpy(pTable->szName,lpszTable);

        m_TableList.AddTail(pTable);
    }
    return pTable;
}

SH_Database::SH_Field *  SH_Database::AppendField(SH_Table *  pTable, LPCTSTR lpszField)
{
    SH_Field *   pField;

    VERIFY(pTable != NULL);

    pField = FindField(pTable,lpszField);
    
    if(pField == NULL)
    {
        pField = new SH_Field;
        VERIFY(pField!=NULL);

        strcpy(pField->szName,lpszField);
        pField->pUserData = NULL;

        pTable->m_FieldList.AddTail(pField);
    }

    return pField;
}

SH_Database::SH_Table *  SH_Database::FindTable(LPCTSTR lpszTable)
{
    SH_Position  pos;
    SH_Table *   pTable;

    pos = m_TableList.GetHeadPosition();

    while(pos)
    {
        pTable = m_TableList.GetNext(pos);

        if(strcmp(pTable->szName,lpszTable) == 0)
            return pTable;
    }
    return NULL;
}

SH_Database::SH_Field *  SH_Database::FindField(SH_Table *  pTable, LPCTSTR lpszField)
{
    SH_Position pos;
    SH_Field *   pField;

    VERIFY(pTable != NULL);

    pos = pTable->m_FieldList.GetHeadPosition();

    while(pos)
    {
        pField = pTable->m_FieldList.GetNext(pos);

        if(pField)
        {
            if(strcmp(pField->szName,lpszField) == 0)
                return pField;
        }
    }
    return NULL;
}

SH_Database::SH_Field *  SH_Database::FindField(LPCTSTR lpszTable, LPCTSTR lpszField)
{
    SH_Table *  pTable = NULL;
    SH_Field *  pField = NULL;

    pTable = FindTable(lpszTable);

    if(pTable)
    {
        pField = FindField(pTable,lpszField);
    }
    return pField;
}

void SH_Database::Clear()
{
    SH_Position       pos;
    SH_Table *  pTable;

    /*Clear field list*/
    pos = m_TableList.GetHeadPosition();

    while(pos)
    {
        pTable = m_TableList.GetNext(pos);

        if(pTable)
        {
            while(!pTable->m_FieldList.IsEmpty())
            {
                delete (SH_Field * )pTable->m_FieldList.RemoveHead();
            }
        }
    }

    /*Clear table list*/
    while(!m_TableList.IsEmpty())
    {
        delete (SH_Table * )m_TableList.RemoveHead();
    }
}



BOOL SH_Database::Execute(LPCTSTR lpszSQL, int nLen)
{
	SQLRETURN sr;

    FetchBegin();
    sr = SQLExecDirect(m_hStmt,(SQLTCHAR*)lpszSQL,(SQLINTEGER)nLen);
    FetchEnd();
    
    return SUCCEED(sr);
}

BOOL SH_Database::Execute(SH_String strSQL)
{
	return Execute((LPCTSTR)strSQL,strSQL.GetLength());
}
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -