connection.cpp

ncbi源码

}


CODBC_Connection::~CODBC_Connection()
{
    if (Refresh()) {
        switch(SQLDisconnect(m_Link)) {
        case SQL_SUCCESS_WITH_INFO:
        case SQL_ERROR:
            m_Reporter.ReportErrors();
        case SQL_SUCCESS:
            break;
        default:
            throw CDB_ClientEx(eDB_Error, 410009, "CODBC_Connection::~CODBC_Connection",
                               "SQLDisconnect failed (memory corruption suspected)");
            
        }
    }
    if(SQLFreeHandle(SQL_HANDLE_DBC, m_Link) == SQL_ERROR) {
        m_Reporter.ReportErrors();
    }
        
}


void CODBC_Connection::DropCmd(CDB_BaseEnt& cmd)
{
    m_CMDs.Remove(static_cast<TPotItem> (&cmd));
}


static bool ODBC_xSendDataPrepare(SQLHSTMT cmd, CDB_ITDescriptor& descr_in,
                                  SQLINTEGER size, bool is_text, bool logit, 
						          SQLPOINTER id, CODBC_Reporter& rep)
{
    string q= "update ";
    q+= descr_in.TableName();
    q+= " set ";
    q+= descr_in.ColumnName();
    q+= "=? where ";
    q+= descr_in.SearchConditions();
    //q+= " ;\nset rowcount 0";

#ifdef SQL_TEXTPTR_LOGGING
	if(!logit) {
		switch(SQLSetStmtAttr(cmd, SQL_TEXTPTR_LOGGING, /*SQL_SOPT_SS_TEXTPTR_LOGGING,*/
			(SQLPOINTER)SQL_TL_OFF, SQL_IS_INTEGER)) {
		case SQL_SUCCESS_WITH_INFO:
		case SQL_ERROR:
			rep.ReportErrors();
		default: break;
		}
	}
#endif

	switch(SQLPrepare(cmd, (SQLCHAR*)q.c_str(), SQL_NTS)) {
	case SQL_SUCCESS_WITH_INFO:
		rep.ReportErrors();
	case SQL_SUCCESS: break;
	case SQL_ERROR:
		rep.ReportErrors();
	default: return false;
	}
			
	SQLSMALLINT par_type, par_dig, par_null;
    SQLUINTEGER par_size;

#if 0
	switch(SQLNumParams(cmd, &par_dig)) {
	case SQL_SUCCESS: break;
	case SQL_SUCCESS_WITH_INFO:
	case SQL_ERROR:
		rep.ReportErrors();
	default: return false;
	}
#endif

	switch(SQLDescribeParam(cmd, 1, &par_type, &par_size, &par_dig, &par_null)){
	case SQL_SUCCESS_WITH_INFO:
		rep.ReportErrors();
	case SQL_SUCCESS: break;
	case SQL_ERROR:
		rep.ReportErrors();
	default: return false;
	}

    SQLINTEGER p= SQL_LEN_DATA_AT_EXEC(size);

    switch(SQLBindParameter(cmd, 1, SQL_PARAM_INPUT, 
                     is_text? SQL_C_CHAR : SQL_C_BINARY, par_type,
                     // is_text? SQL_LONGVARCHAR : SQL_LONGVARBINARY,
                     size, 0, id, 0, &p)) {
	case SQL_SUCCESS_WITH_INFO:
		rep.ReportErrors();
	case SQL_SUCCESS: break;
	case SQL_ERROR:
		rep.ReportErrors();
	default: return false;
	}
		

    
    switch(SQLExecute(cmd)) {
    case SQL_NEED_DATA:
        return true;
    case SQL_SUCCESS_WITH_INFO:
    case SQL_ERROR:
        rep.ReportErrors();
    default:
        return false;
    }
}

static bool ODBC_xSendDataGetId(SQLHSTMT cmd, SQLPOINTER* id, 
                                CODBC_Reporter& rep)
{
    switch(SQLParamData(cmd, id)) {
    case SQL_NEED_DATA:
        return true;
    case SQL_SUCCESS_WITH_INFO:
    case SQL_ERROR:
        rep.ReportErrors();
    default:
        return false;
    }
}

bool CODBC_Connection::x_SendData(SQLHSTMT cmd, CDB_Stream& stream, CODBC_Reporter& rep)
{
    char buff[1801];
    size_t s;

    while((s= stream.Read(buff, sizeof(buff))) != 0) {
        switch(SQLPutData(cmd, (SQLPOINTER)buff, (SQLINTEGER)s)) {
        case SQL_SUCCESS_WITH_INFO:
            rep.ReportErrors();
        case SQL_NEED_DATA:
			continue;
        case SQL_NO_DATA:
			return true;
        case SQL_SUCCESS:
            break;
        case SQL_ERROR:
            rep.ReportErrors();
        default:
            return false;
        }
    }
    switch(SQLParamData(cmd, (SQLPOINTER*)&s)) {
	case SQL_SUCCESS_WITH_INFO: rep.ReportErrors();
    case SQL_SUCCESS:           break;
	case SQL_NO_DATA:           return true;
    case SQL_NEED_DATA: 
	    throw CDB_ClientEx(eDB_Error, 410044, "CODBC_Connection::SendData",
                               "Not all the data were sent");
	case SQL_ERROR:             rep.ReportErrors();
	default:
		throw CDB_ClientEx(eDB_Error, 410045, "CODBC_Connection::SendData",
                           "SQLParamData failed");
	}
	
    for(;;) {
        switch(SQLMoreResults(cmd)) {
        case SQL_SUCCESS_WITH_INFO: rep.ReportErrors();
        case SQL_SUCCESS:           continue;
        case SQL_NO_DATA:           break;
        case SQL_ERROR:             
            rep.ReportErrors();
            throw CDB_ClientEx(eDB_Error, 410014, "CODBC_Connection::SendData",
                               "SQLMoreResults failed");
        default:
            throw CDB_ClientEx(eDB_Error, 410015, "CODBC_Connection::SendData",
                               "SQLMoreResults failed (memory corruption suspected)");
        }
		break;
    }
    return true;
}
        
void CODBC_Connection::ODBC_SetTimeout(SQLUINTEGER nof_secs) {}
void CODBC_Connection::ODBC_SetTextImageSize(SQLUINTEGER nof_bytes) {}


/////////////////////////////////////////////////////////////////////////////
//
//  CODBC_SendDataCmd::
//

CODBC_SendDataCmd::CODBC_SendDataCmd(CODBC_Connection* conn, 
                                     SQLHSTMT cmd, 
                                     CDB_ITDescriptor& descr,
                                     size_t nof_bytes, bool logit) :
    m_Connect(conn), m_Cmd(cmd), m_Bytes2go(nof_bytes),
    m_Reporter(&conn->m_MsgHandlers, SQL_HANDLE_STMT, cmd)
{
    SQLPOINTER p= (SQLPOINTER)1;
    if((!ODBC_xSendDataPrepare(cmd, descr, (SQLINTEGER)nof_bytes,
                              false, logit, p, m_Reporter)) ||
       (!ODBC_xSendDataGetId(cmd, &p, m_Reporter))) {
        throw CDB_ClientEx(eDB_Error, 410035, "CODBC_SendDataCmd::CODBC_SendDataCm",
                           "can not prepare a command");
    }   
}

size_t CODBC_SendDataCmd::SendChunk(const void* chunk_ptr, size_t nof_bytes)
{
    if(nof_bytes > m_Bytes2go) nof_bytes= m_Bytes2go;
    if(nof_bytes < 1) return 0;

    switch(SQLPutData(m_Cmd, (SQLPOINTER)chunk_ptr, (SQLINTEGER)nof_bytes)) {
    case SQL_SUCCESS_WITH_INFO:
        m_Reporter.ReportErrors();
    case SQL_NEED_DATA:
    case SQL_NO_DATA:
    case SQL_SUCCESS:
        m_Bytes2go-= nof_bytes;
        if(m_Bytes2go == 0) break;
        return nof_bytes;
    case SQL_ERROR:
        m_Reporter.ReportErrors();
    default:
        return 0;
    }

    size_t s;
    switch(SQLParamData(m_Cmd, (SQLPOINTER*)&s)) {
	case SQL_SUCCESS_WITH_INFO: m_Reporter.ReportErrors();
    case SQL_SUCCESS:           break;
	case SQL_NO_DATA:           break;
    case SQL_NEED_DATA: 
	    throw CDB_ClientEx(eDB_Error, 410044, "CODBC_Connection::SendChunk",
                               "Not all the data were sent");
	case SQL_ERROR:             m_Reporter.ReportErrors();
	default:
		throw CDB_ClientEx(eDB_Error, 410045, "CODBC_Connection::SendChunk",
                           "SQLParamData failed");
	}

    for(;;) {
        switch(SQLMoreResults(m_Cmd)) {
        case SQL_SUCCESS_WITH_INFO: m_Reporter.ReportErrors();
        case SQL_SUCCESS:           continue;
        case SQL_NO_DATA:           break;
        case SQL_ERROR:             
            m_Reporter.ReportErrors();
            throw CDB_ClientEx(eDB_Error, 410014, "CODBC_SendDataCmd::SendChunk",
                               "SQLMoreResults failed");
        default:
            throw CDB_ClientEx(eDB_Error, 410015, "CODBC_SendDataCmd::SendChunk",
                               "SQLMoreResults failed (memory corruption suspected)");
        }
		break;
    }
    return nof_bytes;
}

void CODBC_SendDataCmd::Release()
{
    m_BR = 0;
    if (m_Bytes2go > 0) {
        xCancel();
        m_Bytes2go = 0;
    }
    m_Connect->DropCmd(*this);
    delete this;
}


CODBC_SendDataCmd::~CODBC_SendDataCmd()
{
    if (m_Bytes2go > 0)
        xCancel();
    if (m_BR)
        *m_BR = 0;
    SQLFreeHandle(SQL_HANDLE_STMT, m_Cmd);
}

void CODBC_SendDataCmd::xCancel()
{
    switch(SQLFreeStmt(m_Cmd, SQL_CLOSE)) {
    case SQL_SUCCESS_WITH_INFO: m_Reporter.ReportErrors();
    case SQL_SUCCESS:           break;
    case SQL_ERROR:             m_Reporter.ReportErrors();
    default:                    return;
    }
    SQLFreeStmt(m_Cmd, SQL_RESET_PARAMS);
}

END_NCBI_SCOPE



/*
 * ===========================================================================
 * $Log: connection.cpp,v $
 * Revision 1000.1  2004/06/01 19:21:40  gouriano
 * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.5
 *
 * Revision 1.5  2004/05/17 21:16:05  gorelenk
 * Added include of PCH ncbi_pch.hpp
 *
 * Revision 1.4  2003/06/05 16:02:04  soussov
 * adds code for DumpResults and for the dumped results processing
 *
 * Revision 1.3  2003/05/05 20:47:45  ucko
 * Check HAVE_ODBCSS_H; regardless, disable BCP on Unix, since even
 * DataDirect's implementation lacks the relevant bcp_* functions.
 *
 * Revision 1.2  2002/07/05 20:47:56  soussov
 * fixes bug in SendData
 *
 *
 * ===========================================================================
 */