dblib.cpp

访问sybase 数据库的dblib (VC)封装

// Dblib.cpp: implementation of the CDblib class.
//
//////////////////////////////////////////////////////////////////////

//#ifdef __BORLANDC__
//#pragma warn +wucp
//#endif

#include "errorlog.h"
#include "stdafx.h"
/*
#include "Dblib.h"
#include "time.h"
#include <stdlib.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <sys\types.h>
#include <sys\stat.h>
*/

#ifdef __BORLANDC__
#include <forms.hpp>
#endif

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

#ifdef DLL_DBLIB
p_dbgetuserdata CDblib::dbgetuserdata = NULL;
p_dbsetuserdata CDblib::dbsetuserdata = NULL;
#endif

HINSTANCE CDblib::hDLL = NULL;

void (* CDblib::MyMsgFunc)(CDbErrorInfo *) = NULL;

void CDblib::InstallMsgFunc(void (* MsgFunc)(CDbErrorInfo *))
{
    MyMsgFunc = MsgFunc;
}

INT SQLAPI CDblib::MyErrHandler(DBPROCESS *dbproc, INT severity, INT dberr, INT oserr, const char *dberrstr, const char *oserrstr)
{
    FILE *fp;
    time_t t;
    struct tm * tmlocal;
    CDbErrorInfo * dbErrorInfo;
    CDbErrorInfo tempDbErrorInfo;

    if(MyMsgFunc != NULL)
    {
        memset(&tempDbErrorInfo, 0, sizeof(tempDbErrorInfo));
        tempDbErrorInfo.severity = severity;
        tempDbErrorInfo.dberr = dberr;
        tempDbErrorInfo.oserr = oserr;
        if(dberrstr)
            strncpy(tempDbErrorInfo.dberrstr, dberrstr, sizeof(tempDbErrorInfo.dberrstr));
        if(oserrstr)
            strncpy(tempDbErrorInfo.oserrstr, oserrstr, sizeof(tempDbErrorInfo.oserrstr));
        MyMsgFunc(&tempDbErrorInfo);
    }

    if(dbproc == NULL)
    {
        return(INT_CANCEL);
    }
    else
    {
        dbErrorInfo = (CDbErrorInfo *)dbgetuserdata(dbproc);
        if(dbErrorInfo != NULL && severity >= dbErrorInfo->severity)
        {
            dbErrorInfo->severity = severity;
            dbErrorInfo->dberr = dberr;
            dbErrorInfo->oserr = oserr;
            if(dberrstr)
                strncpy(dbErrorInfo->dberrstr, dberrstr, sizeof(dbErrorInfo->dberrstr) - 1);
            if(oserrstr)
                strncpy(dbErrorInfo->oserrstr, oserrstr, sizeof(dbErrorInfo->oserrstr) - 1);
        }
        if (oserr != DBNOERR || dberr != DBNOERR)
        {
            t = ::time(&t);
            tmlocal = ::localtime(&t);

            fp = fopen(GetErrorLogFileName(), "a");
            if(fp != NULL)
            {
                fprintf(fp, "%04d-%02d-%02d [%02d:%02d:%02d] ", tmlocal->tm_year + 1900, tmlocal->tm_mon + 1, tmlocal->tm_mday, tmlocal->tm_hour, tmlocal->tm_min, tmlocal->tm_sec);
                if(oserrstr)
                    fprintf(fp, "Operating-system error:%s\n", oserrstr);
                if(dberrstr)
                    fprintf(fp,"Dblibrary error:%s\n", dberrstr);
                fclose(fp);
            }
        }
        return(INT_CANCEL);
    }
#ifndef __BORLANDC__
    return(INT_CANCEL);
#endif
}

INT SQLAPI CDblib::MyMsgHandler(DBPROCESS *dbproc, DBINT msgno, INT msgstate, INT severity,
              const CHAR *msgtext, const CHAR * s1, const CHAR * s2, DBUSMALLINT dbus)
{
    FILE *fp;
    time_t t;
    struct tm * tmlocal;
    CDbErrorInfo * dbErrorInfo;
    CDbErrorInfo tempDbErrorInfo;

    if(MyMsgFunc != NULL)
    {
        memset(&tempDbErrorInfo, 0, sizeof(tempDbErrorInfo));
        tempDbErrorInfo.severity = severity;
        tempDbErrorInfo.msgno = msgno;
        if(msgtext)
            strncpy(tempDbErrorInfo.msgtext, msgtext, sizeof(tempDbErrorInfo.msgtext));
        MyMsgFunc(&tempDbErrorInfo);
    }

    dbErrorInfo = (CDbErrorInfo *)dbgetuserdata(dbproc);
    if(dbErrorInfo != NULL && severity >= dbErrorInfo->severity)
    {
        dbErrorInfo->msgno = msgno;
        dbErrorInfo->severity = severity;
        sprintf(dbErrorInfo->msgtext,
                "SQL Server Message: message NO %ld, severity %ld\n",
                msgno, severity);
        if(msgtext)
            strncpy(dbErrorInfo->msgtext + strlen(dbErrorInfo->msgtext),
                    msgtext,
                    sizeof(dbErrorInfo->msgtext) - strlen(dbErrorInfo->msgtext) - 1);
    }

    if(severity > 10)
    {
        t = ::time(&t);
        tmlocal = ::localtime(&t);

        fp = fopen(GetErrorLogFileName(), "a");
        if(fp != NULL)
        {
            fprintf(fp, "%04d-%02d-%02d [%02d:%02d:%02d] ", tmlocal->tm_year + 1900, tmlocal->tm_mon + 1, tmlocal->tm_mday, tmlocal->tm_hour, tmlocal->tm_min, tmlocal->tm_sec);
            fprintf(fp, "SQL Server Message: message NO %ld, severity %ld\n", msgno, severity);
            fprintf(fp, "%s\n", msgtext);
            fclose(fp);
        }
    }
    return 0 ;
}

void CDblib::WindowMsgFunc(CDbErrorInfo * info)
{
#ifdef __BORLANDC__
    char buffer[1024];

    if(info->severity > 0 && info->msgno > 0)
    {
        sprintf(buffer, "severity = %d, msgno = %d\n\n%s\n\n", info->severity, info->msgno, info->msgtext);
        MessageBox(Screen->ActiveForm->Handle, buffer, "数据库访问错误", MB_OK | MB_ICONSTOP);
    }
    else if(info->severity > 0 && (info->dberr > 0 || info->oserr > 0))
    {
        sprintf(buffer, "severity = %d, dberr = %d, oserr = %d\n\n%s\n\n%s\n", info->severity, info->dberr, info->oserr, info->dberrstr, info->oserrstr);
        MessageBox(Screen->ActiveForm->Handle, buffer, "数据库访问错误", MB_OK | MB_ICONSTOP);
    }
#endif
}

CDblib::CDblib(bool bcpOK)
{
    m_bcpOK = bcpOK;

    LoadFunc();
    dbinit();
    dbsetlogintime(10);

    dberrhandle(CDblib::MyErrHandler);
    dbmsghandle(CDblib::MyMsgHandler);
    Init();
}

CDblib::~CDblib()
{
    Close();
}

bool CDblib::Init()
{
    m_dbmsOsType = otNT;
    m_dbmsVersion = dvSQL65;

    m_dbProcess = NULL;
    m_loginOK = false;
    memset(m_serverName, 0, sizeof(m_serverName));
    memset(m_loginID, 0, sizeof(m_loginID));
    memset(m_passWord, 0, sizeof(m_passWord));
    memset(m_appName, 0, sizeof(m_appName));
    memset(m_hostName, 0, sizeof(m_hostName));
    memset(m_databaseName, 0, sizeof(m_databaseName));
    m_rowCount = 0;
    m_colCount = 0;
    m_errorCode = 0;
    memset(m_errorMsg, 0, sizeof(m_errorMsg));
    memset(m_colInfo, 0, sizeof(m_colInfo));

    if(dbgetmaxprocs() <= 45)
        dbsetmaxprocs (45);

    return true;
}

bool CDblib::Login(const char *servername, const char *loginID, const char *passWord, const char *appname, const char *hostname)
{
    LOGINREC * loginRec;
    char version[81];

    loginRec = dblogin();

    DBSETLUSER(loginRec, (char *)loginID);
    DBSETLPWD(loginRec, (char *)passWord);
    DBSETLHOST(loginRec, (char *)hostname);
    DBSETLAPP(loginRec, (char *)appname);

    if(m_bcpOK)
        BCP_SETL(loginRec, TRUE);

    m_dbProcess = dbopen(loginRec, (char *)servername);
    dbfreelogin(loginRec);

    if(m_dbProcess == NULL)
    {
        m_errorCode = -1;
        strcpy(m_errorMsg, "连接SQL Server失败");
        m_loginOK = false;
        return false;
    }

    version[0] = 0;
    dbcmd(m_dbProcess, "select upper(substring(@@version, 1, 80))");
    dbsqlexec(m_dbProcess);
    while( dbresults(m_dbProcess ) != NO_MORE_RESULTS )
    {
        if(DBROWS(m_dbProcess) == SUCCEED)
        {
            dbbind(m_dbProcess, 1, NTBSTRINGBIND, 0, (BYTE *)version);
            while(dbnextrow(m_dbProcess) != NO_MORE_ROWS);
        }
    }
    if(strstr(version, "MICROSOFT SQL") == 0)
    {
        if(strstr(version, "/11.") == 0)
            m_dbmsVersion = dvSystem10;
        else
            m_dbmsVersion = dvSystem11;
    }
    else
    {
        if(strstr(version, "7.0"))
            m_dbmsVersion = dvSQL70;
        else
            m_dbmsVersion = dvSQL65;
    }

    if(strstr(version, "UNIX"))
        m_dbmsOsType = otUnix;
    else if(strstr(version, "NOVELL"))
        m_dbmsOsType = otNovell;

    memset(&m_dbErrorInfo, 0, sizeof(CDbErrorInfo));
    dbsetuserdata(m_dbProcess, &m_dbErrorInfo);

    if(m_dbmsVersion & dvSybase)
        dbcmd(m_dbProcess, "set transaction isolation level 1");
    else
        dbcmd(m_dbProcess, "set transaction isolation level read uncommitted");
    dbsqlexec(m_dbProcess);
    while(dbresults(m_dbProcess) != NO_MORE_RESULTS)
        while(dbnextrow(m_dbProcess) != NO_MORE_ROWS);

    if(m_databaseName[0])
        dbuse(m_dbProcess, m_databaseName);

    return true;
}

bool CDblib::Open(const char *servername, const char *loginID, const char *passWord, const char *appname, const char *hostname)
{
    if(m_loginOK == true)
        return true;

    if(Login(servername, loginID, passWord, appname, hostname) == false)
        return false;
        
    strcpy(m_serverName, servername);
    strcpy(m_loginID, loginID);
    strcpy(m_passWord, passWord);
    strcpy(m_appName, appname);
    strcpy(m_hostName, hostname);
    strcpy(m_databaseName, dbname(m_dbProcess));

    m_errorCode = 0;
    strcpy(m_errorMsg, "连接SQL Server成功");
    m_loginOK = true;
    return true;
}

bool CDblib::__Run(const char *CommandStr)
{
    int retryCount = 3;
    FILE *fp;
    time_t t;
    struct tm * tmlocal;

#ifndef __BORLANDC
    Cancel();
#endif

__deadlock:

    memset(&m_dbErrorInfo, 0, sizeof(CDbErrorInfo));

    if(dbcmd(m_dbProcess, (char *)CommandStr) == FAIL)
    {
        if(m_dbProcess == NULL || dbdead(m_dbProcess) == TRUE)
        {
            Login(m_serverName, m_loginID, m_passWord, m_appName, m_hostName);
        }
        m_errorCode = m_dbErrorInfo.msgno;
        strcpy(m_errorMsg, "执行存储过程失败");
        return false;
    }

    if(dbsqlexec(m_dbProcess) == FAIL)
    {
        if(m_dbProcess == NULL || dbdead(m_dbProcess) == TRUE)
        {
            Login(m_serverName, m_loginID, m_passWord, m_appName, m_hostName);
        }
        else if(m_dbErrorInfo.msgno == 1205)
        {
            Sleep(100);
            retryCount --;

            t = ::time(&t);
            tmlocal = ::localtime(&t);

            fp=fopen(GetErrorLogFileName(), "a");
            fprintf(fp, "%04d-%02d-%02d [%02d:%02d:%02d] ", tmlocal->tm_year + 1900, tmlocal->tm_mon + 1, tmlocal->tm_mday, tmlocal->tm_hour, tmlocal->tm_min, tmlocal->tm_sec);
            fprintf(fp, "SQL Server Message: 1205\n");
            fprintf(fp, CommandStr);
            fclose(fp);

            goto __deadlock;
        }

        m_errorCode = m_dbErrorInfo.msgno;
        strcpy(m_errorMsg, "执行存储过程失败");
        Cancel();
        return false;
    }
    else
    {
        m_errorCode = 0;
        strcpy(m_errorMsg, "执行存储过程成功");
        if (dbresults(m_dbProcess) != NO_MORE_RESULTS)
           Bind();
    }
    return true;
}

bool CDblib::Run(const char *CommandStr, ...)
{
    char msg[2048];
    va_list arg_ptr;

    va_start(arg_ptr, CommandStr);
    vsprintf(msg, CommandStr, arg_ptr);
    va_end(arg_ptr);

    return __Run(msg);
}

bool CDblib::__Run20(const char *CommandStr)
{
    int len;
    char _sqlcmd[2048];
    char cznr1[256], cznr2[256], cznr3[256], cznr4[256];

    len = strlen(CommandStr);
    if(len <= 250)
    {
      strcpy(cznr1, CommandStr);
      cznr2[0] = 0;
      cznr3[0] = 0;
      cznr4[0] = 0;
    }
    else if(len <= 500)
    {
      memcpy(cznr1, CommandStr, 250);
      cznr1[250] = 0;

      memcpy(cznr2, CommandStr + 250, len - 250);
      cznr2[250] = 0;

      cznr3[0] = 0;
      cznr4[0] = 0;
    }
    else if(len <= 750)
    {
      memcpy(cznr1, CommandStr, 250);
      cznr1[250] = 0;

      memcpy(cznr2, CommandStr + 250, 250);
      cznr2[250] = 0;

      memcpy(cznr3, CommandStr + 500, len - 500);
      cznr3[250] = 0;

      cznr4[0] = 0;
    }
    else if(len <= 1000)
    {
      memcpy(cznr1, CommandStr, 250);
      cznr1[250] = 0;

      memcpy(cznr2, CommandStr + 250, 250);
      cznr2[250] = 0;

      memcpy(cznr3, CommandStr + 500, 250);
      cznr3[250] = 0;

      memcpy(cznr4, CommandStr + 750, len - 750);
      cznr4[250] = 0;
    }
    else
    {
        strcpy(cznr1, "**********");
        strcpy(cznr2, "**********");
        strcpy(cznr3, "**********");
        strcpy(cznr4, "**********");
    }

    strcpy(_sqlcmd, CommandStr);
    strcat(_sqlcmd, ",\x22\x24");
    strcat(_sqlcmd, cznr1);
    strcat(_sqlcmd, "\x24\x22");
    strcat(_sqlcmd, ",\x22\x24");
    strcat(_sqlcmd, cznr2);
    strcat(_sqlcmd, "\x24\x22");
    strcat(_sqlcmd, ",\x22\x24");
    strcat(_sqlcmd, cznr3);
    strcat(_sqlcmd, "\x24\x22");
    strcat(_sqlcmd, ",\x22\x24");
    strcat(_sqlcmd, cznr4);
    strcat(_sqlcmd, "\x24\x22");

    if(__Run(_sqlcmd) == true)
    {
        while(dbresults(m_dbProcess) != NO_MORE_RESULTS)
        {
            if(DBROWS(m_dbProcess) == SUCCEED)
            {
                dbbind(m_dbProcess, 1, INTBIND, 0, (BYTE *)&m_errorCode);
                dbbind(m_dbProcess, 2, NTBSTRINGBIND, 0, (BYTE *)m_errorMsg);
                while(dbnextrow(m_dbProcess) != NO_MORE_ROWS);
                if (m_errorCode == 0)
                {
                    while(dbresults(m_dbProcess) != NO_MORE_RESULTS)
                    {
                        if(dbnumcols(m_dbProcess) > 0)
                        {
                            Bind();
                            break;
                        }
                    }

                    memset(m_data, 0, sizeof(m_data));
                }
                break;
            }
        }
    }
    else
      return false;

    return true;
}

bool CDblib::Run20(const char *CommandStr, ...)
{
    char msg[1024];
    va_list arg_ptr;

    memset(msg, '@', sizeof(msg));
    va_start(arg_ptr, CommandStr);
    vsprintf(msg, CommandStr, arg_ptr);
    va_end(arg_ptr);

    return __Run20(msg);
}

bool CDblib::Run20Error(const char *CommandStr, ...)
{
#ifdef __BORLANDC__
    char msg[1024];
    va_list arg_ptr;

    memset(msg, '@', sizeof(msg));
    va_start(arg_ptr, CommandStr);
    vsprintf(msg, CommandStr, arg_ptr);
    va_end(arg_ptr);

    __Run20(msg);

    if(GetErrorCode() == 0)
    {
        return true;
    }
    else