dblib.cpp

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

    dbfcmd = (p_dbfcmd)GetProcAddress(CDblib::hDLL, "dbfcmd");
    if (!dbfcmd)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbfirstrow
    dbfirstrow = (p_dbfirstrow)GetProcAddress(CDblib::hDLL, "dbfirstrow");
    if (!dbfirstrow)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dblastrow
    dblastrow = (p_dblastrow)GetProcAddress(CDblib::hDLL, "dblastrow");
    if (!dblastrow)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
/*    //dbiscount
    dbiscount = (p_dbiscount)GetProcAddress(CDblib::hDLL, "dbiscount");
    if (!dbiscount)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }*/
    //dbnumcols
    dbnumcols = (p_dbnumcols)GetProcAddress(CDblib::hDLL, "dbnumcols");
    if (!dbnumcols)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbnumorders
    dbnumorders = (p_dbnumorders)GetProcAddress(CDblib::hDLL, "dbnumorders");
    if (!dbnumorders)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbnumrets
    dbnumrets = (p_dbnumrets)GetProcAddress(CDblib::hDLL, "dbnumrets");
    if (!dbnumrets)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbordercol
    dbordercol = (p_dbordercol)GetProcAddress(CDblib::hDLL, "dbordercol");
    if (!dbordercol)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbrows
    dbrows = (p_dbrows)GetProcAddress(CDblib::hDLL, "dbrows");
    if (!dbrows)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbrowtype
    dbrowtype = (p_dbrowtype)GetProcAddress(CDblib::hDLL, "dbrowtype");
    if (!dbrowtype)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbretstatus
    dbretstatus = (p_dbretstatus)GetProcAddress(CDblib::hDLL, "dbretstatus");
    if (!dbretstatus)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbexit
    dbexit = (p_dbexit)GetProcAddress(CDblib::hDLL, "dbexit");
    if (!dbexit)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbserverenum
    dbserverenum = (p_dbserverenum)GetProcAddress(CDblib::hDLL, "dbserverenum");
    if (!dbserverenum)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbcolinfo
    dbcolinfo = (p_dbcolinfo)GetProcAddress(CDblib::hDLL, "dbcolinfo");
    if (!dbcolinfo)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbmsghandle
    dbmsghandle = (p_dbmsghandle)GetProcAddress(CDblib::hDLL,"dbmsghandle");
    if (!dbmsghandle)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbfreelogin
    dbfreelogin = (p_dbfreelogin)GetProcAddress(CDblib::hDLL,"dbfreelogin");
    if (!dbfreelogin)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbgetuserdata
    CDblib::dbgetuserdata = (p_dbgetuserdata)GetProcAddress(CDblib::hDLL,"dbgetuserdata");
    if (!CDblib::dbgetuserdata)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbsetuserdata
    CDblib::dbsetuserdata = (p_dbsetuserdata)GetProcAddress(CDblib::hDLL,"dbsetuserdata");
    if (!CDblib::dbsetuserdata)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbgetmaxprocs
    dbgetmaxprocs = (p_dbgetmaxprocs)GetProcAddress(CDblib::hDLL,"dbgetmaxprocs");
    if (!dbgetmaxprocs)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbsetmaxprocs
    dbsetmaxprocs = (p_dbsetmaxprocs)GetProcAddress(CDblib::hDLL,"dbsetmaxprocs");
    if (!dbsetmaxprocs)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbname
    dbname = (p_dbname)GetProcAddress(CDblib::hDLL,"dbname");
    if (!dbname)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //dbchange
    dbchange = (p_dbchange)GetProcAddress(CDblib::hDLL,"dbchange");
    if (!dbchange)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }

    //bcp_init
    bcp_init = (p_bcp_init)GetProcAddress(CDblib::hDLL,"bcp_init");
    if (!bcp_init)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //bcp_exec
    bcp_exec = (p_bcp_exec)GetProcAddress(CDblib::hDLL,"bcp_exec");
    if (!bcp_exec)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //bcp_readfmt
    bcp_readfmt = (p_bcp_readfmt)GetProcAddress(CDblib::hDLL,"bcp_readfmt");
    if (!bcp_readfmt)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //bcp_writefmt
    bcp_writefmt = (p_bcp_writefmt)GetProcAddress(CDblib::hDLL,"bcp_writefmt");
    if (!bcp_writefmt)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //bcp_colfmt
    bcp_colfmt = (p_bcp_colfmt)GetProcAddress(CDblib::hDLL,"bcp_colfmt");
    if (!bcp_colfmt)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //bcp_bind
    bcp_bind = (p_bcp_bind)GetProcAddress(CDblib::hDLL,"bcp_bind");
    if (!bcp_bind)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //bcp_sendrow
    bcp_sendrow = (p_bcp_sendrow)GetProcAddress(CDblib::hDLL,"bcp_sendrow");
    if (!bcp_sendrow)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //bcp_batch
    bcp_batch = (p_bcp_batch)GetProcAddress(CDblib::hDLL,"bcp_batch");
    if (!bcp_batch)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
    //bcp_done
    bcp_done = (p_bcp_done)GetProcAddress(CDblib::hDLL,"bcp_done");
    if (!bcp_done)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }

    //dbconvert
    dbconvert = (p_dbconvert)GetProcAddress(CDblib::hDLL,"dbconvert");
    if (!dbconvert)
    {
        FreeLibrary(CDblib::hDLL);
        return false;
    }
#endif
    return true;
}

DBINT CDblib::GetErrorCode()
{
    if (m_dbErrorInfo.severity > 10)
    {
        return m_dbErrorInfo.msgno;
    }
    else
    {
        return m_errorCode;
    }
}

const char * CDblib::GetErrorMsg()
{
    if (m_dbErrorInfo.severity > 10)
    {
        return m_dbErrorInfo.msgtext;
    }
    else
        return m_errorMsg;
}

const CDbErrorInfo * CDblib::GetDbErrorInfo()
{
    return &m_dbErrorInfo;
}

bool CDblib::GetSQLDataDir(char * systemPath)
{
    char drive[MAXDRIVE];
    char dir[MAXDIR];
    char file[MAXFILE];
    char ext[MAXEXT];

    if(m_dbmsVersion & dvSybase)
    {
        strcpy(systemPath, "/u/sybase/data/");
        return true;
    }
    else
    {
        Run("select phyname from master..sysdevices where name = 'master'");
        if(GetErrorCode() != 0)
            return false;

        while(MoveNext())
        {
            fnsplit(GetColData(0), drive, dir, file, ext);
            fnmerge(systemPath, drive, dir, file, ext);
            fnsplit(systemPath, drive, dir, file, ext);
            fnmerge(systemPath, drive, dir, NULL, NULL);
        }
    }
    return true;
}

bool CDblib::GetSQLBackupDir(char * systemPath)
{
    char drive[MAXDRIVE];
    char dir[MAXDIR];
    char file[MAXFILE];
    char ext[MAXEXT];

    systemPath[0] = 0;

    if(m_dbmsVersion & dvSybase)
    {
        strcpy(systemPath, "/u/sybase/backup/");
        return true;
    }
    else
    {
        Run("select phyname from master..sysdevices where name = 'master'");
        if(GetErrorCode() != 0)
            return true;

        while(MoveNext())
        {
            fnsplit(GetColData(0), drive, dir, file, ext);
            strcat(dir, "..\\BACKUP\\");
            fnmerge(systemPath, drive, dir, file, ext);
            fnsplit(systemPath, drive, dir, file, ext);
            fnmerge(systemPath, drive, dir, NULL, NULL);
        }
    }
    return true;
}

int CDblib::GetTableColInfo(const char * dbName, const char * tableName, CTableColInfo colInfo[], int maxColNum)
{
    char oldDatabaseName[MAXNAME];
    CTableColInfo temp;
    int colNum = 0;

    memset(&temp, 0, sizeof(temp));

    if(dbName)
    {
        strcpy(oldDatabaseName, dbname(m_dbProcess));
        dbuse(m_dbProcess, (char *)dbName);
    }
    
    Run("select name, type, length, prec, scale, status from syscolumns where id = object_id('%s') order by colid", tableName);
    while(MoveNext())
    {
        if(colNum >= maxColNum)
            continue;
        strncpy(temp.Name, GetColData(0), sizeof(temp.Name));
        temp.Type = (short)atoi(GetColData(1));
        temp.Length = atoi(GetColData(2));
        temp.Prec = atoi(GetColData(3));
        temp.Scale = atoi(GetColData(4));
        temp.Identity = (atoi(GetColData(5)) & 128) ? true : false;
        memcpy(&colInfo[colNum], &temp, sizeof(temp));
        colNum ++;
    }
    Cancel();

    if(dbName)
        dbuse(m_dbProcess, oldDatabaseName);

    return colNum;
}

bool CDblib::BcpInit(LPCSTR tblname, LPCSTR hfile, LPCSTR errfile, INT direction)
{
    return (bcp_init(m_dbProcess, tblname, hfile, errfile, direction) == SUCCEED) ? true : false;
}

bool CDblib::BcpExec(LPDBINT rows_copied)
{
    return (bcp_exec(m_dbProcess, rows_copied) == SUCCEED) ? true : false;
}

bool CDblib::BcpReadFmt(const char * fmt)
{
    return (bcp_readfmt(m_dbProcess, fmt) == SUCCEED) ? true : false;
}

bool CDblib::BcpWriteFmt(const char * fmt)
{
    return (bcp_writefmt(m_dbProcess, fmt) == SUCCEED) ? true : false;
}

bool CDblib::BcpColfmt(INT file_column,
               BYTE file_type,
               INT file_prefixlen,
               DBINT file_collen,
               LPCBYTE file_term,
               INT file_termlen,
               INT table_column )
{
    RETCODE ret;

    ret = bcp_colfmt(m_dbProcess, file_column,
                     file_type,
                     file_prefixlen,
                     file_collen,
                     file_term,
                     file_termlen,
                     table_column );

    return (ret == SUCCEED) ? true : false;
}

bool CDblib::BcpBind( LPCBYTE varaddr,
                      INT prefixlen,
                      DBINT varlen,
                      LPCBYTE terminator,
                      INT termlen,
                      INT type,
                      INT table_column )
{
    RETCODE ret;

    ret = bcp_bind(m_dbProcess,
                   varaddr,
                   prefixlen,
                   varlen,
                   terminator,
                   termlen,
                   type,
                   table_column );

    return (ret == SUCCEED) ? true : false;                   
}

bool CDblib::BcpSendrow()
{
    return (bcp_sendrow(m_dbProcess) == SUCCEED) ? true : false;
}

DBINT CDblib::BcpBatch()
{
    return bcp_batch(m_dbProcess);
}

DBINT CDblib::BcpDone()
{
    return bcp_done(m_dbProcess);
}

bool CDblib::GetSpaceUsed(const char * dbName, tagSpaceInfo & info)
{
    const char * commandStrSQL70Data =
        "dbcc showfilestats\n";

    const char * commandStrSQL70Log =
        "dbcc sqlperf(logspace)\n";

    const char * commandStrSQL65 =
        "set nocount on\n"
        "declare @d1 int, @d2 int, @d3 int, @d4 int\n"
        "select @d1 = sum(size * 2) from master..sysusages where dbid = db_id() and segmap in (3, 7)\n"
        "select @d2 = sum(used * 2) from sysindexes where id != 8\n"
        "select @d3 = sum(size * 2) from master..sysusages where dbid = db_id() and segmap  = 4\n"
        "select @d4 = sum(used * 2) from sysindexes where id = 8\n"
        "select @d1, @d2, @d3, @d4";

    const char * commandStrSystem11 =
        "set nocount on\n"
        "declare @pagekb int, @d1 int, @d2 int, @d3 int, @d4 int\n"
        "select @pagekb = (low / 1024) from master..spt_values where number = 1 and type = 'E'\n"
        "select @d1 = sum(size * @pagekb) from master..sysusages where dbid = db_id() and segmap in (3, 7)\n"
        "select @d2 = sum(curunreservedpgs(db_id(), lstart,unreservedpgs) * @pagekb) from master..sysusages where dbid = db_id() and segmap in (3, 7)\n"
        "select @d3 = sum(size * @pagekb) from master..sysusages where dbid = db_id() and segmap  = 4\n"
        "select @d4 = sum(curunreservedpgs(db_id(), lstart,unreservedpgs) * @pagekb) from master..sysusages where dbid = db_id() and segmap = 4\n"
        "select @d1, @d1 - @d2, @d3, @d3 - @d4";

    const char * commandStrSystem10 =
        "set nocount on\n"
        "declare @d1 int, @d2 int, @d3 int, @d4 int\n"
        "select @d1 = sum(size * 2) from master..sysusages where dbid = db_id() and segmap in (3, 7)\n"
        "select @d2 = sum(unreservedpgs  * 2) from master..sysusages where dbid = db_id() and segmap in (3, 7)\n"
        "select @d3 = sum(size * 2) from master..sysusages where dbid = db_id() and segmap  = 4\n"
        "select @d4 = sum(unreservedpgs  * 2) from master..sysusages where dbid = db_id() and segmap = 4\n"
        "select @d1, @d1 - @d2, @d3, @d3 - @d4";

    info.totalDataSize = 0;
    info.usedDataSize = 0;
    info.totalLogSize = 0;
    info.usedLogSize = 0;

    Use(dbName);
    if(GetErrorCode() != 0)
        return false;

    if(GetDbmsVersion() & CDblib::dvSQL70)
    {
        Run(commandStrSQL70Data);
        while(MoveNext())
        {
            info.totalDataSize += atof(GetColData(2)) * 64.00 / 1024.00;
            info.usedDataSize += atof(GetColData(3)) * 64.00 / 1024.00;
        }

        Run(commandStrSQL70Log);
        while(MoveNext())
        {
            if(strcmp(dbName, GetColData(0)) == 0)
            {
                info.totalLogSize = atof(GetColData(1));
                info.usedLogSize = info.totalLogSize * atof(GetColData(2)) / 100;
            }
        }
    }
    else
    {
        if(GetDbmsVersion() & CDblib::dvSystem11)
            Run(commandStrSystem11);
        else if(GetDbmsVersion() & CDblib::dvSystem10)
            Run(commandStrSystem10);
        else
            Run(commandStrSQL65);

        while(MoveNext())
        {
            info.totalDataSize = atof(GetColData(0)) / 1024.00;
            info.usedDataSize = atof(GetColData(1)) / 1024.00;
            info.totalLogSize = atof(GetColData(2)) / 1024.00;
            info.usedLogSize = atof(GetColData(3)) / 1024.00;
            if(info.totalLogSize <= 0)
            {
                info.usedDataSize += info.usedLogSize;
                info.usedLogSize = 0;
            }
        }
    }
    return true;
}