public.cpp

ncbi源码

void CDB_LangCmd::DumpResults()
{
    s_CheckLangCmd(m_Cmd, "DumpResults");
    m_Cmd->DumpResults();
}

CDB_LangCmd::~CDB_LangCmd()
{
    if ( m_Cmd ) {
        m_Cmd->Release();
    }
}



/////////////////////////////////////////////////////////////////////////////
//  CDB_RPCCmd::
//

CDB_RPCCmd::CDB_RPCCmd(I_RPCCmd* c)
{
    if ( !c ) {
        throw CDB_ClientEx(eDB_Error, 200006, "CDB_RPCCmd::CDB_RPCCmd",
                           "No valid command provided");
    }
    m_Cmd = c;
    m_Cmd->Acquire((CDB_BaseEnt**) &m_Cmd);
}


inline void s_CheckRPCCmd(I_RPCCmd* cmd, const char* method_name)
{
    if ( !cmd ) {
        throw CDB_ClientEx(eDB_Warning, 200005,
                           "CDB_RPCCmd::" + string(method_name),
                           "This command can not be used anymore");
    }
}


bool CDB_RPCCmd::BindParam(const string& param_name, CDB_Object* pVal,
                           bool out_param)
{
    s_CheckRPCCmd(m_Cmd, "BindParam");
    return m_Cmd->BindParam(param_name, pVal, out_param);
}

bool CDB_RPCCmd::SetParam(const string& param_name, CDB_Object* pVal,
                          bool out_param)
{
    s_CheckRPCCmd(m_Cmd, "SetParam");
    return m_Cmd->SetParam(param_name, pVal, out_param);
}

bool CDB_RPCCmd::Send()
{
    s_CheckRPCCmd(m_Cmd, "Send");
    return m_Cmd->Send();
}

bool CDB_RPCCmd::WasSent() const
{
    s_CheckRPCCmd(m_Cmd, "WasSent");
    return m_Cmd->WasSent();
}

bool CDB_RPCCmd::Cancel()
{
    s_CheckRPCCmd(m_Cmd, "Cancel");
    return m_Cmd->Cancel();
}

bool CDB_RPCCmd::WasCanceled() const
{
    s_CheckRPCCmd(m_Cmd, "WasCanceled");
    return m_Cmd->WasCanceled();
}

CDB_Result* CDB_RPCCmd::Result()
{
    s_CheckRPCCmd(m_Cmd, "Result");
    return m_Cmd->Result();
}

bool CDB_RPCCmd::HasMoreResults() const
{
    s_CheckRPCCmd(m_Cmd, "HasMoreResults");
    return m_Cmd->HasMoreResults();
}

bool CDB_RPCCmd::HasFailed() const
{
    s_CheckRPCCmd(m_Cmd, "HasFailed");
    return m_Cmd->HasFailed();
}

int CDB_RPCCmd::RowCount() const
{
    s_CheckRPCCmd(m_Cmd, "RowCount");
    return m_Cmd->RowCount();
}

void CDB_RPCCmd::DumpResults()
{
    s_CheckRPCCmd(m_Cmd, "DumpResults");
    m_Cmd->DumpResults();
}

void CDB_RPCCmd::SetRecompile(bool recompile)
{
    s_CheckRPCCmd(m_Cmd, "SetRecompile");
    m_Cmd->SetRecompile(recompile);
}


CDB_RPCCmd::~CDB_RPCCmd()
{
    if ( m_Cmd ) {
        m_Cmd->Release();
    }
}



////////////////////////////////////////////////////////////////////////////
//  CDB_BCPInCmd::
//

CDB_BCPInCmd::CDB_BCPInCmd(I_BCPInCmd* c)
{
    if ( !c ) {
        throw CDB_ClientEx(eDB_Error, 200007, "CDB_BCPInCmd::CDB_BCPInCmd",
                           "No valid command provided");
    }
    m_Cmd = c;
    m_Cmd->Acquire((CDB_BaseEnt**) &m_Cmd);
}


inline void s_CheckBCPInCmd(I_BCPInCmd* cmd, const char* method_name)
{
    if ( !cmd ) {
        throw CDB_ClientEx(eDB_Warning, 200005,
                           "CDB_BCPInCmd::" + string(method_name),
                           "This command can not be used anymore");
    }
}


bool CDB_BCPInCmd::Bind(unsigned int column_num, CDB_Object* pVal)
{
    s_CheckBCPInCmd(m_Cmd, "Bind");
    return m_Cmd->Bind(column_num, pVal);
}

bool CDB_BCPInCmd::SendRow()
{
    s_CheckBCPInCmd(m_Cmd, "SendRow");
    return m_Cmd->SendRow();
}

bool CDB_BCPInCmd::Cancel()
{
    s_CheckBCPInCmd(m_Cmd, "Cancel");
    return m_Cmd->Cancel();
}

bool CDB_BCPInCmd::CompleteBatch()
{
    s_CheckBCPInCmd(m_Cmd, "CompleteBatch");
    return m_Cmd->CompleteBatch();
}

bool CDB_BCPInCmd::CompleteBCP()
{
    s_CheckBCPInCmd(m_Cmd, "CompleteBCP");
    return m_Cmd->CompleteBCP();
}


CDB_BCPInCmd::~CDB_BCPInCmd()
{
    if ( m_Cmd ) {
        m_Cmd->Release();
    }
}



/////////////////////////////////////////////////////////////////////////////
//  CDB_CursorCmd::
//

CDB_CursorCmd::CDB_CursorCmd(I_CursorCmd* c)
{
    if ( !c ) {
        throw CDB_ClientEx(eDB_Error, 200006, "CDB_CursorCmd::CDB_CursorCmd",
                           "No valid command provided");
    }
    m_Cmd = c;
    m_Cmd->Acquire((CDB_BaseEnt**) &m_Cmd);
}


inline void s_CheckCursorCmd(I_CursorCmd* cmd, const char* method_name)
{
    if ( !cmd ) {
        throw CDB_ClientEx(eDB_Warning, 200005,
                           "CDB_CursorCmd::" + string(method_name),
                           "This command can not be used anymore");
    }
}


bool CDB_CursorCmd::BindParam(const string& param_name, CDB_Object* pVal)
{
    s_CheckCursorCmd(m_Cmd, "BindParam");
    return m_Cmd->BindParam(param_name, pVal);
}


CDB_Result* CDB_CursorCmd::Open()
{
    s_CheckCursorCmd(m_Cmd, "Open");
    return m_Cmd->Open();
}

bool CDB_CursorCmd::Update(const string& table_name, const string& upd_query)
{
    s_CheckCursorCmd(m_Cmd, "Update");
    return m_Cmd->Update(table_name, upd_query);
}

bool CDB_CursorCmd::UpdateTextImage(unsigned int item_num, CDB_Stream& data, bool log_it)
{
    s_CheckCursorCmd(m_Cmd, "UpdateTextImage");
    return m_Cmd->UpdateTextImage(item_num, data, log_it);
}

CDB_SendDataCmd* CDB_CursorCmd::SendDataCmd(unsigned int item_num,
                                            size_t size, bool log_it)
{
    s_CheckCursorCmd(m_Cmd, "SendDataCmd");
    return m_Cmd->SendDataCmd(item_num, size, log_it);
}


bool CDB_CursorCmd::Delete(const string& table_name)
{
    s_CheckCursorCmd(m_Cmd, "Delete");
    return m_Cmd->Delete(table_name);
}

int CDB_CursorCmd::RowCount() const
{
    s_CheckCursorCmd(m_Cmd, "RowCount");
    return m_Cmd->RowCount();
}

bool CDB_CursorCmd::Close()
{
    s_CheckCursorCmd(m_Cmd, "Close");
    return m_Cmd->Close();
}


CDB_CursorCmd::~CDB_CursorCmd()
{
    if ( m_Cmd ) {
        m_Cmd->Release();
    }
}



/////////////////////////////////////////////////////////////////////////////
//  CDB_SendDataCmd::
//

CDB_SendDataCmd::CDB_SendDataCmd(I_SendDataCmd* c)
{
    if ( !c ) {
        throw CDB_ClientEx(eDB_Error, 200006,
                           "CDB_SendDataCmd::CDB_SendDataCmd",
                           "No valid command provided");
    }
    m_Cmd = c;
    m_Cmd->Acquire((CDB_BaseEnt**) &m_Cmd);
}


size_t CDB_SendDataCmd::SendChunk(const void* pChunk, size_t nofBytes)
{
    if ( !m_Cmd ) {
        throw CDB_ClientEx(eDB_Warning, 200005, "CDB_CursorCmd::SendChunk",
                           "This command can not be used anymore");
    }
    return m_Cmd->SendChunk(pChunk, nofBytes);
}


CDB_SendDataCmd::~CDB_SendDataCmd()
{
    if (m_Cmd) {
        m_Cmd->Release();
    }
}



/////////////////////////////////////////////////////////////////////////////
//  CDB_ITDescriptor::
//

int CDB_ITDescriptor::DescriptorType() const
{
    return 0;
}

CDB_ITDescriptor::~CDB_ITDescriptor()
{
}



/////////////////////////////////////////////////////////////////////////////
//  CDB_ResultProcessor::
//

CDB_ResultProcessor::CDB_ResultProcessor(CDB_Connection* c)
{
    m_Con = c;
    if ( m_Con )
        m_Prev = m_Con->SetResultProcessor(this);
}

void CDB_ResultProcessor::ProcessResult(CDB_Result& res)
{
    while (res.Fetch());  // fetch and forget
}


CDB_ResultProcessor::~CDB_ResultProcessor()
{
    if ( m_Con )
        m_Con->SetResultProcessor(m_Prev);
}


END_NCBI_SCOPE



/*
 * ===========================================================================
 * $Log: public.cpp,v $
 * Revision 1000.1  2004/06/01 19:19:25  gouriano
 * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.8
 *
 * Revision 1.8  2004/05/17 21:11:38  gorelenk
 * Added include of PCH ncbi_pch.hpp
 *
 * Revision 1.7  2003/06/20 19:11:25  vakatov
 * CDB_ResultProcessor::
 *  - added MS-Win DLL export macro
 *  - made the destructor virtual
 *  - moved code from the header to the source file
 *  - formally reformatted the code
 *
 * Revision 1.6  2003/06/05 15:58:38  soussov
 * adds DumpResults method for LangCmd and RPC, SetResultProcessor method
 * for Connection interface, adds CDB_ResultProcessor class
 *
 * Revision 1.5  2003/01/29 22:35:05  soussov
 * replaces const string& with const char* in inlines
 *
 * Revision 1.4  2002/03/26 15:32:24  soussov
 * new image/text operations added
 *
 * Revision 1.3  2001/11/06 17:59:54  lavr
 * Formatted uniformly as the rest of the library
 *
 * Revision 1.2  2001/09/27 20:08:32  vakatov
 * Added "DB_" (or "I_") prefix where it was missing
 *
 * Revision 1.1  2001/09/21 23:40:00  vakatov
 * -----  Initial (draft) revision.  -----
 * This is a major revamp (by Denis Vakatov, with help from Vladimir Soussov)
 * of the DBAPI "driver" libs originally written by Vladimir Soussov.
 * The revamp involved massive code shuffling and grooming, numerous local
 * API redesigns, adding comments and incorporating DBAPI to the C++ Toolkit.
 *
 * ===========================================================================
 */