bcp功能

#include "MyBCP.h" 
#include "odbcss.h" 
  
//1,Allocate an environment handle and a connection handle. 
//2,Set SQL_COPT_SS_BCP and SQL_BHCP_ON to enable bulk copy operations. 
void CMyBCP::Initialize() 
{ 
    SQLRETURN l_uiReturn; 
    l_uiReturn=SQLAllocHandle(SQL_HANDLE_ENV,NULL,&m_hEnvironment); 
    if( l_uiReturn!=SQL_SUCCESS && l_uiReturn!=SQL_SUCCESS_WITH_INFO ) return; 
    l_uiReturn=SQLSetEnvAttr(m_hEnvironment,SQL_ATTR_ODBC_VERSION,(SQLPOINTER)SQL_OV_ODBC3,SQL_IS_INTEGER); 
    if( l_uiReturn!=SQL_SUCCESS && l_uiReturn!=SQL_SUCCESS_WITH_INFO ) return; 
    l_uiReturn=SQLAllocHandle(SQL_HANDLE_DBC,m_hEnvironment,&m_hConnection); 
    if( l_uiReturn!=SQL_SUCCESS && l_uiReturn!=SQL_SUCCESS_WITH_INFO ) return; 
    l_uiReturn=SQLSetConnectAttr(m_hConnection,SQL_COPT_SS_BCP,(void *)SQL_BCP_ON,SQL_IS_INTEGER); 
    if( l_uiReturn!=SQL_SUCCESS && l_uiReturn!=SQL_SUCCESS_WITH_INFO ) return; 
}; 
      
//3,Connect to SQL Server 
void CMyBCP::ConnectToDB() 
{ 
    std::string dsn("DNS-MMLRESOLVE"); 
    std::string user("sa"); 
    std::string password("huawei123,"); 
    SQLRETURN l_uiReturn; 
    l_uiReturn=SQLConnect(m_hConnection, 
            (UCHAR*)dsn.c_str(),SQL_NTS, 
            (UCHAR*)user.c_str(),SQL_NTS, 
            (UCHAR*)password.c_str(),SQL_NTS 
        ); 
}; 
      
//4,Call bcp_init to set the following information: 
// .The name of the table or view to bulk copy from or to. 
// .Specify NULL for the name of the data file. 
// .The name of an data file to receive any bulk copy error messages(specify NULL 
// if you do not want a message file). 
// .The direction of the copy: DB_IN from the application to the view or table or  
// DB_OUT to the application from the table or view. 
void CMyBCP::call_bcp_init(std::string & tablename) 
{ 
    SQLRETURN l_uiReturn=bcp_init(m_hConnection,tablename.c_str(),NULL,NULL,DB_IN); 
}; 
  
//5,Call bcp_bind for each column in the bulk copy to bind the column to a program variable 
void CMyBCP::call_bcp_bind_char_field(char* pBlock, int colIndex) 
{ 
    RETCODE l_uiRETCODE=bcp_bind(m_hConnection,(LPCBYTE)pBlock, 0, SQL_VARLEN_DATA, (LPCBYTE)"", sizeof(WCHAR), SQLCHARACTER, colIndex); 
    if(l_uiRETCODE==SUCCEED) 
    { 
        printf("call_bcp_bind_char_field() ok!
"); 
    } 
}; 
void CMyBCP::call_bcp_bind_int_field(int &iBlock, int colIndex) 
{ 
    RETCODE l_uiRETCODE=bcp_bind(m_hConnection,(BYTE *)&iBlock, 0, sizeof(DBINT), NULL, (INT)NULL, SQLINT4, colIndex); 
    if(l_uiRETCODE==SUCCEED) 
    { 
        printf("call_bcp_bind_int_field() ok!
"); 
    } 
}; 
  
//6,Fill the program variables with data,and call bcp_sendrow to send a row of data. 
void CMyBCP::call_bcp_sendrow() 
{ 
    RETCODE l_uiRETCODE=bcp_sendrow(m_hConnection); 
    if(l_uiRETCODE==SUCCEED) 
    { 
        printf("bcp_sendrow() ok!"); 
    } 
}; 
  
//7,After several rows have been sent,call bcp_batch to checkpoint the rows already sent. 
//It is good practice to call bcp_batch at least once per 1000 rows. 
void CMyBCP::call_bcp_batch() 
{ 
    DBINT l_uiDBINT=bcp_batch(m_hConnection); 
}; 
  
//8,After all rows have been sent,call bcp_done to complete the operation. 
void CMyBCP::call_bcp_done() 
{ 
    DBINT l_uiDBINT=bcp_done(m_hConnection); 
}; 
  
  
CMyBCP::CMyBCP() 
{ 
    Initialize(); 
    ConnectToDB(); 
}; 
  
CMyBCP::~CMyBCP() 
{ 
    if(m_hConnection!=SQL_NULL_HDBC) 
    { 
        SQLDisconnect(m_hConnection); 
        SQLFreeHandle(SQL_HANDLE_DBC, m_hConnection); 
    } 
    if(m_hEnvironment!=SQL_NULL_HENV) 
    { 
        SQLFreeHandle(SQL_HANDLE_ENV,m_hEnvironment); 
    } 
}; 

#include <Windows.h> 
#include <sqlext.h> 
#include <string> 
  
#pragma  comment(lib,"odbc32.lib")   
#pragma  comment(lib,"odbcbcp.lib") 
#pragma  comment(lib,"odbcbcp.lib") 
  
class CMyBCP 
{ 
public: 
    CMyBCP(); 
    ~CMyBCP(); 
  
public: 
    //1,Allocate an environment handle and a connection handle. 
    //2,Set SQL_COPT_SS_BCP and SQL_BHCP_ON to enable bulk copy operations. 
    void Initialize(); 
      
    //3,Connect to SQL Server 
    void ConnectToDB(); 
      
    //4,Call bcp_init to set the following information: 
    // .The name of the table or view to bulk copy from or to. 
    // .Specify NULL for the name of the data file. 
    // .The name of an data file to receive any bulk copy error messages(specify NULL 
    // if you do not want a message file). 
    // .The direction of the copy: DB_IN from the application to the view or table or  
    // DB_OUT to the application from the table or view. 
    void call_bcp_init(std::string & tablename); 
  
    //5,Call bcp_bind for each column in the bulk copy to bind the column to a program variable 
    //void call_bcp_bind(); 
    void call_bcp_bind_char_field(char* pBlock, int colIndex); 
    void call_bcp_bind_int_field(int &iBlock, int colIndex); 
  
    //6,Fill the program variables with data,and call bcp_sendrow to send a row of data. 
    void call_bcp_sendrow(); 
  
    //7,After several rows have been sent,call bcp_batch to checkpoint the rows already sent. 
    //It is good practice to call bcp_batch at least once per 1000 rows. 
    void call_bcp_batch(); 
  
    //8,After all rows have been sent,call bcp_done to complete the operation. 
    void call_bcp_done(); 
  
private: 
        HENV m_hEnvironment; 
        HDBC m_hConnection; 
}; 

#include <iostream>
#include "MyBCP.h"

int main()
{
CMyBCP bcp;
std::string tablename("[p].[e_LOG_IOEXP]");
bcp.call_bcp_init(tablename);

int int_BSCFlg;
int int_ObjFlg;
std::string str_BSCNAME("");
std::string str_IDENTITY("BXB001A");
bcp.call_bcp_bind_int_field(int_BSCFlg,1);
bcp.call_bcp_bind_int_field(int_ObjFlg,2);
bcp.call_bcp_bind_char_field(const_cast<char *>(str_BSCNAME.c_str()),3);
bcp.call_bcp_bind_char_field(const_cast<char *>(str_IDENTITY.c_str()),4);

bcp.call_bcp_sendrow();
//bcp.call_bcp_batch();
bcp.call_bcp_done();

std::cout<<"Over"<<std::endl;
getchar();
return 0;
};