开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
connection.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：24k
源码类别：

生物技术

开发平台：

C/C++

connection.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: connection.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:19:34  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.17
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: connection.cpp,v 1000.1 2004/06/01 19:19:34 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Vladimir Soussov
  36.  *
  37.  * File Description:  CTLib connection
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <dbapi/driver/ctlib/interfaces.hpp>
  43. #include <string.h>
  46. BEGIN_NCBI_SCOPE
  49. CTL_Connection::CTL_Connection(CTLibContext* cntx, CS_CONNECTION* con,
  50.                                bool reusable, const string& pool_name)
  51. {
  52.     m_Link     = con;
  53.     m_Context  = cntx;
  54.     m_Reusable = reusable;
  55.     m_Pool     = pool_name;
  57.     CTL_Connection* link = this;
  58.     ct_con_props(m_Link, CS_SET, CS_USERDATA,
  59.                  &link, (CS_INT) sizeof(link), NULL);
  61.     // retrieve the connection attributes
  62.     CS_INT outlen(0);
  63.     char   buf[512];
  65.     ct_con_props(m_Link, CS_GET, CS_SERVERNAME,
  66.                  buf, (CS_INT) (sizeof(buf) - 1), &outlen);
  67.     if((outlen > 0) && (buf[outlen-1] == '')) --outlen;
  68.     m_Server.append(buf, (size_t) outlen);
  70.     ct_con_props(m_Link, CS_GET, CS_USERNAME,
  71.                  buf, (CS_INT) (sizeof(buf) - 1), &outlen);
  72.     if((outlen > 0) && (buf[outlen-1] == '')) --outlen;
  73.     m_User.append(buf, (size_t) outlen);
  75.     ct_con_props(m_Link, CS_GET, CS_PASSWORD,
  76.                  buf, (CS_INT) (sizeof(buf) - 1), &outlen);
  77.     if((outlen > 0) && (buf[outlen-1] == '')) --outlen;
  78.     m_Passwd.append(buf, (size_t) outlen);
  80.     CS_BOOL flag;
  81.     ct_con_props(m_Link, CS_GET, CS_BULK_LOGIN, &flag, CS_UNUSED, &outlen);
  82.     m_BCPable = (flag == CS_TRUE);
  84.     ct_con_props(m_Link, CS_GET, CS_SEC_ENCRYPTION, &flag, CS_UNUSED, &outlen);
  85.     m_SecureLogin = (flag == CS_TRUE);
  87.     m_ResProc= 0;
  88. }
  91. bool CTL_Connection::IsAlive()
  92. {
  93.     CS_INT status;
  94.     if (ct_con_props(m_Link, CS_GET, CS_CON_STATUS, &status, CS_UNUSED, 0)
  95.         != CS_SUCCEED)
  96.         return false;
  98.     return
  99.         (status & CS_CONSTAT_CONNECTED) != 0  &&
  100.         (status & CS_CONSTAT_DEAD     ) == 0;
  101. }
  104. CDB_LangCmd* CTL_Connection::LangCmd(const string& lang_query,
  105.                                      unsigned int  nof_params)
  106. {
  107.     CS_COMMAND* cmd;
  109.     switch ( ct_cmd_alloc(m_Link, &cmd) ) {
  110.     case CS_SUCCEED:
  111.         break;
  112.     case CS_FAIL:
  113.         throw CDB_ClientEx(eDB_Fatal, 110001, "CTL_Connection::LangCmd",
  114.                            "ct_cmd_alloc failed");
  115.     case CS_BUSY:
  116.         throw CDB_ClientEx(eDB_Fatal, 110002, "CTL_Connection::LangCmd",
  117.                            "the connection is busy");
  118.     }
  120.     CTL_LangCmd* lcmd = new CTL_LangCmd(this, cmd, lang_query, nof_params);
  121.     m_CMDs.Add(lcmd);
  122.     return Create_LangCmd(*lcmd);
  123. }
  126. CDB_RPCCmd* CTL_Connection::RPC(const string& rpc_name,
  127.                                 unsigned int  nof_args)
  128. {
  129.     CS_COMMAND* cmd;
  131.     switch ( ct_cmd_alloc(m_Link, &cmd) ) {
  132.     case CS_SUCCEED:
  133.         break;
  134.     case CS_FAIL:
  135.         throw CDB_ClientEx(eDB_Fatal, 110001, "CTL_Connection::RPC",
  136.                            "ct_cmd_alloc failed");
  137.     case CS_BUSY:
  138.         throw CDB_ClientEx(eDB_Fatal, 110002, "CTL_Connection::RPC",
  139.                            "the connection is busy");
  140.     }
  142.     CTL_RPCCmd* rcmd = new CTL_RPCCmd(this, cmd, rpc_name, nof_args);
  143.     m_CMDs.Add(rcmd);
  144.     return Create_RPCCmd(*rcmd);
  145. }
  148. CDB_BCPInCmd* CTL_Connection::BCPIn(const string& table_name,
  149.                                     unsigned int  nof_columns)
  150. {
  151.     if (!m_BCPable) {
  152.         throw CDB_ClientEx(eDB_Error, 110003, "CTL_Connection::BCPIn",
  153.                            "No bcp on this connection");
  154.     }
  156.     CS_BLKDESC* cmd;
  157.     if (blk_alloc(m_Link, BLK_VERSION_100, &cmd) != CS_SUCCEED) {
  158.         throw CDB_ClientEx(eDB_Fatal, 110004, "CTL_Connection::BCPIn",
  159.                            "blk_alloc failed");
  160.     }
  162.     CTL_BCPInCmd* bcmd = new CTL_BCPInCmd(this, cmd, table_name, nof_columns);
  163.     m_CMDs.Add(bcmd);
  164.     return Create_BCPInCmd(*bcmd);
  165. }
  168. CDB_CursorCmd* CTL_Connection::Cursor(const string& cursor_name,
  169.                                       const string& query,
  170.                                       unsigned int  nof_params,
  171.                                       unsigned int  batch_size)
  172. {
  173.     CS_COMMAND* cmd;
  175.     switch ( ct_cmd_alloc(m_Link, &cmd) ) {
  176.     case CS_SUCCEED:
  177.         break;
  178.     case CS_FAIL:
  179.         throw CDB_ClientEx(eDB_Fatal, 110001, "CTL_Connection::Cursor",
  180.                            "ct_cmd_alloc failed");
  181.     case CS_BUSY:
  182.         throw CDB_ClientEx(eDB_Fatal, 110002, "CTL_Connection::Cursor",
  183.                            "the connection is busy");
  184.     }
  186.     CTL_CursorCmd* ccmd = new CTL_CursorCmd(this, cmd, cursor_name, query,
  187.                                             nof_params, batch_size);
  188.     m_CMDs.Add(ccmd);
  189.     return Create_CursorCmd(*ccmd);
  190. }
  193. CDB_SendDataCmd* CTL_Connection::SendDataCmd(I_ITDescriptor& descr_in,
  194.                                              size_t data_size, bool log_it)
  195. {
  196.     if ( !data_size ) {
  197.         throw CDB_ClientEx(eDB_Fatal, 110092, "CTL_Connection::SendDataCmd",
  198.                            "wrong (zero) data size");
  199.     }
  201.     I_ITDescriptor* p_desc= 0;
  203.     // check what type of descriptor we've got
  204.     if(descr_in.DescriptorType() != CTL_ITDESCRIPTOR_TYPE_MAGNUM) {
  205.         // this is not a native descriptor
  206.         p_desc= x_GetNativeITDescriptor
  207.             (dynamic_cast<CDB_ITDescriptor&> (descr_in));
  208.         if(p_desc == 0) return 0;
  209.     }
  211.     C_ITDescriptorGuard d_guard(p_desc);
  212.     CS_COMMAND* cmd;
  214.     switch ( ct_cmd_alloc(m_Link, &cmd) ) {
  215.     case CS_SUCCEED:
  216.         break;
  217.     case CS_FAIL:
  218.         throw CDB_ClientEx(eDB_Fatal, 110001, "CTL_Connection::SendDataCmd",
  219.                            "ct_cmd_alloc failed");
  220.     case CS_BUSY:
  221.         throw CDB_ClientEx(eDB_Fatal, 110002, "CTL_Connection::SendDataCmd",
  222.                            "the connection is busy");
  223.     }
  225.     if (ct_command(cmd, CS_SEND_DATA_CMD, 0, CS_UNUSED, CS_COLUMN_DATA)
  226.         != CS_SUCCEED) {
  227.         ct_cmd_drop(cmd);
  228.         throw CDB_ClientEx(eDB_Fatal, 110093, "CTL_Connection::SendDataCmd",
  229.                            "ct_command failed");
  230.     }
  232.     CTL_ITDescriptor& desc = p_desc? dynamic_cast<CTL_ITDescriptor&>(*p_desc) :
  233.         dynamic_cast<CTL_ITDescriptor&> (descr_in);
  234.     // desc.m_Desc.datatype   = CS_TEXT_TYPE;
  235.     desc.m_Desc.total_txtlen  = (CS_INT)data_size;
  236.     desc.m_Desc.log_on_update = log_it ? CS_TRUE : CS_FALSE;
  238.     if (ct_data_info(cmd, CS_SET, CS_UNUSED, &desc.m_Desc) != CS_SUCCEED) {
  239.         ct_cancel(0, cmd, CS_CANCEL_ALL);
  240.         ct_cmd_drop(cmd);
  241.         throw CDB_ClientEx(eDB_Fatal, 110093, "CTL_Connection::SendDataCmd",
  242.                            "ct_data_info failed");
  243.     }
  245.     CTL_SendDataCmd* sd_cmd = new CTL_SendDataCmd(this, cmd, data_size);
  246.     m_CMDs.Add(sd_cmd);
  247.     return Create_SendDataCmd(*sd_cmd);
  248. }
  251. bool CTL_Connection::SendData(I_ITDescriptor& desc, CDB_Image& img,
  252.                               bool log_it)
  253. {
  254.     return x_SendData(desc, img, log_it);
  255. }
  258. bool CTL_Connection::SendData(I_ITDescriptor& desc, CDB_Text& txt,
  259.                               bool log_it)
  260. {
  261.     return x_SendData(desc, txt, log_it);
  262. }
  265. bool CTL_Connection::Refresh()
  266. {
  267.     // close all commands first
  268.     while(m_CMDs.NofItems() > 0) {
  269.         CDB_BaseEnt* pCmd = static_cast<CDB_BaseEnt*> (m_CMDs.Get(0));
  270.         try {
  271.             delete pCmd;
  272.         } catch (CDB_Exception& ) {
  273.         }
  274.         m_CMDs.Remove((int) 0);
  275.     }
  277.     // cancel all pending commands
  278.     if (ct_cancel(m_Link, 0, CS_CANCEL_ALL) != CS_SUCCEED)
  279.         return false;
  281.     // check the connection status
  282.     CS_INT status;
  283.     if (ct_con_props(m_Link, CS_GET, CS_CON_STATUS, &status, CS_UNUSED, 0)
  284.         != CS_SUCCEED)
  285.         return false;
  287.     return
  288.         (status & CS_CONSTAT_CONNECTED) != 0  &&
  289.         (status & CS_CONSTAT_DEAD     ) == 0;
  290. }
  293. const string& CTL_Connection::ServerName() const
  294. {
  295.     return m_Server;
  296. }
  299. const string& CTL_Connection::UserName() const
  300. {
  301.     return m_User;
  302. }
  305. const string& CTL_Connection::Password() const
  306. {
  307.     return m_Passwd;
  308. }
  311. I_DriverContext::TConnectionMode CTL_Connection::ConnectMode() const
  312. {
  313.     I_DriverContext::TConnectionMode mode = 0;
  314.     if ( m_BCPable ) {
  315.         mode |= I_DriverContext::fBcpIn;
  316.     }
  317.     if ( m_SecureLogin ) {
  318.         mode |= I_DriverContext::fPasswordEncrypted;
  319.     }
  320.     return mode;
  321. }
  324. bool CTL_Connection::IsReusable() const
  325. {
  326.     return m_Reusable;
  327. }
  330. const string& CTL_Connection::PoolName() const
  331. {
  332.     return m_Pool;
  333. }
  336. I_DriverContext* CTL_Connection::Context() const
  337. {
  338.     return const_cast<CTLibContext*> (m_Context);
  339. }
  342. void CTL_Connection::PushMsgHandler(CDB_UserHandler* h)
  343. {
  344.     m_MsgHandlers.Push(h);
  345. }
  348. void CTL_Connection::PopMsgHandler(CDB_UserHandler* h)
  349. {
  350.     m_MsgHandlers.Pop(h);
  351. }
  353. CDB_ResultProcessor* CTL_Connection::SetResultProcessor(CDB_ResultProcessor* rp)
  354. {
  355.     CDB_ResultProcessor* r= m_ResProc;
  356.     m_ResProc= rp;
  357.     return r;
  358. }
  360. void CTL_Connection::Release()
  361. {
  362.     m_BR = 0;
  363.     // close all commands first
  364.     while(m_CMDs.NofItems() > 0) {
  365.         CDB_BaseEnt* pCmd = static_cast<CDB_BaseEnt*> (m_CMDs.Get(0));
  366.         try {
  367.             delete pCmd;
  368.         } catch (CDB_Exception& ) {
  369.         }
  370.         m_CMDs.Remove((int) 0);
  371.     }
  372. }
  375. CTL_Connection::~CTL_Connection()
  376. {
  377.     if (!Refresh()  ||  ct_close(m_Link, CS_UNUSED) != CS_SUCCEED) {
  378.         ct_close(m_Link, CS_FORCE_CLOSE);
  379.     }
  381.     ct_con_drop(m_Link);
  382. }
  385. void CTL_Connection::DropCmd(CDB_BaseEnt& cmd)
  386. {
  387.     m_CMDs.Remove(static_cast<TPotItem> (&cmd));
  388. }
  391. bool CTL_Connection::x_SendData(I_ITDescriptor& descr_in, CDB_Stream& img,
  392.                                 bool log_it)
  393. {
  394.     CS_INT size = (CS_INT) img.Size();
  395.     if ( !size )
  396.         return false;
  398.     I_ITDescriptor* p_desc= 0;
  400.     // check what type of descriptor we've got
  401.     if(descr_in.DescriptorType() != CTL_ITDESCRIPTOR_TYPE_MAGNUM) {
  402.         // this is not a native descriptor
  403.         p_desc= x_GetNativeITDescriptor
  404.             (dynamic_cast<CDB_ITDescriptor&> (descr_in));
  405.         if(p_desc == 0)
  406.             return false;
  407.     }
  408.     
  410.     C_ITDescriptorGuard d_guard(p_desc);
  411.     CS_COMMAND* cmd;
  413.     switch ( ct_cmd_alloc(m_Link, &cmd) ) {
  414.     case CS_SUCCEED:
  415.         break;
  416.     case CS_FAIL:
  417.         throw CDB_ClientEx(eDB_Fatal, 110001, "CTL_Connection::SendData",
  418.                            "ct_cmd_alloc failed");
  419.     case CS_BUSY:
  420.         throw CDB_ClientEx(eDB_Fatal, 110002, "CTL_Connection::SendData",
  421.                            "the connection is busy");
  422.     }
  424.     if (ct_command(cmd, CS_SEND_DATA_CMD, 0, CS_UNUSED, CS_COLUMN_DATA)
  425.         != CS_SUCCEED) {
  426.         ct_cmd_drop(cmd);
  427.         throw CDB_ClientEx(eDB_Fatal, 110031, "CTL_Connection::SendData",
  428.                            "ct_command failed");
  429.     }
  431.     CTL_ITDescriptor& desc = p_desc ?
  432.         dynamic_cast<CTL_ITDescriptor&> (*p_desc) : 
  433.             dynamic_cast<CTL_ITDescriptor&> (descr_in);
  434.     // desc->m_Desc.datatype = CS_TEXT_TYPE;
  435.     desc.m_Desc.total_txtlen  = size;
  436.     desc.m_Desc.log_on_update = log_it ? CS_TRUE : CS_FALSE;
  438.     if (ct_data_info(cmd, CS_SET, CS_UNUSED, &desc.m_Desc) != CS_SUCCEED) {
  439.         ct_cancel(0, cmd, CS_CANCEL_ALL);
  440.         ct_cmd_drop(cmd);
  441.         return false;
  442.     }
  444.     while (size > 0) {
  445.         char   buff[1800];
  446.         CS_INT n_read = (CS_INT) img.Read(buff, sizeof(buff));
  447.         if ( !n_read ) {
  448.             ct_cancel(0, cmd, CS_CANCEL_ALL);
  449.             ct_cmd_drop(cmd);
  450.             throw CDB_ClientEx(eDB_Fatal, 110032, "CTL_Connection::SendData",
  451.                                "Text/Image data corrupted");
  452.         }
  453.         if (ct_send_data(cmd, buff, n_read) != CS_SUCCEED) {
  454.             ct_cancel(0, cmd, CS_CANCEL_CURRENT);
  455.             ct_cmd_drop(cmd);
  456.             throw CDB_ClientEx(eDB_Fatal, 110033, "CTL_Connection::SendData",
  457.                                "ct_send_data failed");
  458.         }
  459.         size -= n_read;
  460.     }
  462.     if (ct_send(cmd) != CS_SUCCEED) {
  463.         ct_cancel(0, cmd, CS_CANCEL_CURRENT);
  464.         ct_cmd_drop(cmd);
  465.         throw CDB_ClientEx(eDB_Fatal, 110034, "CTL_Connection::SendData",
  466.                            "ct_send failed");
  467.     }
  469.     for (;;) {
  470.         CS_INT res_type;
  471.         switch ( ct_results(cmd, &res_type) ) {
  472.         case CS_SUCCEED: {
  473.             if(m_ResProc) {
  474.                 I_Result* res= 0;
  475.                 switch (res_type) {
  476.                 case CS_ROW_RESULT:
  477.                     res = new CTL_RowResult(cmd);
  478.                     break;
  479.                 case CS_PARAM_RESULT:
  480.                     res = new CTL_ParamResult(cmd);
  481.                     break;
  482.                 case CS_COMPUTE_RESULT:
  483.                     res = new CTL_ComputeResult(cmd);
  484.                     break;
  485.                 case CS_STATUS_RESULT:
  486.                     res = new CTL_StatusResult(cmd);
  487.                     break;
  488.                 }
  489.                 if(res) {
  490.                     CDB_Result* dbres= Create_Result(*res);
  491.                     m_ResProc->ProcessResult(*dbres);
  492.                     delete dbres;
  493.                     delete res;
  494.                     continue;
  495.                 }
  496.             }
  497.                     
  498.             switch (res_type) {
  499.             case CS_COMPUTE_RESULT:
  500.             case CS_CURSOR_RESULT:
  501.             case CS_PARAM_RESULT:
  502.             case CS_ROW_RESULT:
  503.             case CS_STATUS_RESULT: {
  504.                 CS_RETCODE ret_code;
  505.                 while ((ret_code = ct_fetch(cmd, CS_UNUSED, CS_UNUSED,
  506.                                             CS_UNUSED, 0)) == CS_SUCCEED) {
  507.                     continue;
  508.                 }
  509.                 if (ret_code != CS_END_DATA) {
  510.                     ct_cmd_drop(cmd);
  511.                     throw CDB_ClientEx(eDB_Fatal, 110036,
  512.                                        "CTL_Connection::SendData",
  513.                                        "ct_fetch failed");
  514.                 }
  515.                 break;
  516.             }
  517.             case CS_CMD_FAIL:
  518.                 ct_cmd_drop(cmd);
  519.                 throw CDB_ClientEx(eDB_Error, 110037,
  520.                                    "CTL_Connection::SendData",
  521.                                    "command failed");
  522.             default:
  523.                 break;
  524.             }
  525.             continue;
  526.         }
  527.         case CS_END_RESULTS: {
  528.             ct_cmd_drop(cmd);
  529.             return true;
  530.         }
  531.         default: {
  532.             if (ct_cancel(0, cmd, CS_CANCEL_ALL) != CS_SUCCEED) {
  533.                 // we need to close this connection
  534.                 ct_cmd_drop(cmd);
  535.                 throw CDB_ClientEx(eDB_Fatal, 110033,
  536.                                    "CTL_Connection::SendData",
  537.                                    "Unrecoverable crash of ct_result. "
  538.                                    "Connection must be closed");
  539.             }
  540.             ct_cmd_drop(cmd);
  541.             throw CDB_ClientEx(eDB_Error, 110034, "CTL_Connection::SendData",
  542.                                "ct_result failed");
  543.         }
  544.         }
  545.     }
  546. }
  549. I_ITDescriptor* CTL_Connection::x_GetNativeITDescriptor
  550. (const CDB_ITDescriptor& descr_in)
  551. {
  552.     string q= "set rowcount 1nupdate ";
  553.     q+= descr_in.TableName();
  554.     q+= " set ";
  555.     q+= descr_in.ColumnName();
  556.     q+= "=NULL where ";
  557.     q+= descr_in.SearchConditions();
  558.     q+= " nselect ";
  559.     q+= descr_in.ColumnName();
  560.     q+= " from ";
  561.     q+= descr_in.TableName();
  562.     q+= " where ";
  563.     q+= descr_in.SearchConditions();
  564.     q+= " nset rowcount 0";
  565.     
  566.     CDB_LangCmd* lcmd= LangCmd(q, 0);
  567.     if(!lcmd->Send()) {
  568.         throw CDB_ClientEx(eDB_Error, 110035, "CTL_Connection::SendData",
  569.                            "can not send the language command");
  570.     }
  572.     CDB_Result* res;
  573.     I_ITDescriptor* descr= 0;
  575.     while(lcmd->HasMoreResults()) {
  576.         res= lcmd->Result();
  577.         if(res == 0) continue;
  578.         if((res->ResultType() == eDB_RowResult) && (descr == 0)) {
  579.             while(res->Fetch()) {
  580.                 //res->ReadItem(&i, 0);
  581.                 descr= res->GetImageOrTextDescriptor();
  582.                 if(descr) break;
  583.             }
  584.         }
  585.         delete res;
  586.     }
  587.     delete lcmd;
  589.     return descr;
  590. }
  594. /////////////////////////////////////////////////////////////////////////////
  595. //
  596. //  CTL_SendDataCmd::
  597. //
  600. CTL_SendDataCmd::CTL_SendDataCmd(CTL_Connection* con, CS_COMMAND* cmd,
  601.                                  size_t nof_bytes)
  602. {
  603.     m_Connect  = con;
  604.     m_Cmd      = cmd;
  605.     m_Bytes2go = nof_bytes;
  606. }
  609. size_t CTL_SendDataCmd::SendChunk(const void* pChunk, size_t nof_bytes)
  610. {
  611.     if (!pChunk  ||  !nof_bytes) {
  612.         throw CDB_ClientEx(eDB_Fatal, 190000, "CTL_SendDataCmd::SendChunk",
  613.                            "wrong (zero) arguments");
  614.     }
  616.     if ( !m_Bytes2go )
  617.         return 0;
  619.     if (nof_bytes > m_Bytes2go)
  620.         nof_bytes = m_Bytes2go;
  622.     if (ct_send_data(m_Cmd, (void*) pChunk, (CS_INT) nof_bytes) != CS_SUCCEED){
  623.         throw CDB_ClientEx(eDB_Fatal, 190001, "CTL_SendDataCmd::SendChunk",
  624.                            "ct_send_data failed");
  625.     }
  627.     m_Bytes2go -= nof_bytes;
  628.     if ( m_Bytes2go )
  629.         return nof_bytes;
  631.     if (ct_send(m_Cmd) != CS_SUCCEED) {
  632.         ct_cancel(0, m_Cmd, CS_CANCEL_CURRENT);
  633.         throw CDB_ClientEx(eDB_Fatal, 190004, "CTL_SendDataCmd::SendChunk",
  634.                            "ct_send failed");
  635.     }
  637.     for (;;) {
  638.         CS_INT res_type;
  639.         switch ( ct_results(m_Cmd, &res_type) ) {
  640.         case CS_SUCCEED: {
  641.             if(m_Connect->m_ResProc) {
  642.                 I_Result* res= 0;
  643.                 switch (res_type) {
  644.                 case CS_ROW_RESULT:
  645.                     res = new CTL_RowResult(m_Cmd);
  646.                     break;
  647.                 case CS_PARAM_RESULT:
  648.                     res = new CTL_ParamResult(m_Cmd);
  649.                     break;
  650.                 case CS_COMPUTE_RESULT:
  651.                     res = new CTL_ComputeResult(m_Cmd);
  652.                     break;
  653.                 case CS_STATUS_RESULT:
  654.                     res = new CTL_StatusResult(m_Cmd);
  655.                     break;
  656.                 }
  657.                 if(res) {
  658.                     CDB_Result* dbres= Create_Result(*res);
  659.                     m_Connect->m_ResProc->ProcessResult(*dbres);
  660.                     delete dbres;
  661.                     delete res;
  662.                     continue;
  663.                 }
  664.             }
  665.             switch ( res_type ) {
  666.             case CS_COMPUTE_RESULT:
  667.             case CS_CURSOR_RESULT:
  668.             case CS_PARAM_RESULT:
  669.             case CS_ROW_RESULT:
  670.             case CS_STATUS_RESULT: {
  671.                 CS_RETCODE ret_code;
  672.                 while ((ret_code = ct_fetch(m_Cmd, CS_UNUSED, CS_UNUSED,
  673.                                             CS_UNUSED, 0)) == CS_SUCCEED);
  674.                 if (ret_code != CS_END_DATA) {
  675.                     throw CDB_ClientEx(eDB_Fatal, 190006,
  676.                                        "CTL_SendDataCmd::SendChunk",
  677.                                        "ct_fetch failed");
  678.                 }
  679.                 break;
  680.             }
  681.             case CS_CMD_FAIL: {
  682.                 ct_cancel(NULL, m_Cmd, CS_CANCEL_ALL);
  683.                 throw CDB_ClientEx(eDB_Error, 190007,
  684.                                    "CTL_SendDataCmd::SendChunk",
  685.                                    "command failed");
  686.             }
  687.             default: {
  688.                 break;
  689.             }
  690.             }
  691.             continue;
  692.         }
  693.         case CS_END_RESULTS: {
  694.             return nof_bytes;
  695.         }
  696.         default: {
  697.             if (ct_cancel(0, m_Cmd, CS_CANCEL_ALL) != CS_SUCCEED) {
  698.                 throw CDB_ClientEx(eDB_Fatal, 190002,
  699.                                    "CTL_SendDataCmd::SendChunk",
  700.                                    "Unrecoverable crash of ct_result. "
  701.                                    "Connection must be closed");
  702.             }
  703.             throw CDB_ClientEx(eDB_Error, 190003, "CTL_SendDataCmd::SendChunk",
  704.                                "ct_result failed");
  705.         }
  706.         }
  707.     }
  708. }
  711. void CTL_SendDataCmd::Release()
  712. {
  713.     m_BR = 0;
  714.     if ( m_Bytes2go ) {
  715.         ct_cancel(0, m_Cmd, CS_CANCEL_ALL);
  716.         m_Bytes2go = 0;
  717.     }
  718.     m_Connect->DropCmd(*this);
  719.     delete this;
  720. }
  723. CTL_SendDataCmd::~CTL_SendDataCmd()
  724. {
  725.     if ( m_Bytes2go )
  726.         ct_cancel(0, m_Cmd, CS_CANCEL_ALL);
  728.     if ( m_BR )
  729.         *m_BR = 0;
  731.     ct_cmd_drop(m_Cmd);
  732. }
  735. END_NCBI_SCOPE
  739. /*
  740.  * ===========================================================================
  741.  * $Log: connection.cpp,v $
  742.  * Revision 1000.1  2004/06/01 19:19:34  gouriano
  743.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.17
  744.  *
  745.  * Revision 1.17  2004/05/17 21:12:03  gorelenk
  746.  * Added include of PCH ncbi_pch.hpp
  747.  *
  748.  * Revision 1.16  2003/09/23 19:38:22  soussov
  749.  * cancels send_data cmd if it failes while processing results
  750.  *
  751.  * Revision 1.15  2003/07/08 18:51:38  soussov
  752.  * fixed bug in constructor
  753.  *
  754.  * Revision 1.14  2003/06/05 16:00:31  soussov
  755.  * adds code for DumpResults and for the dumped results processing
  756.  *
  757.  * Revision 1.13  2003/02/05 14:56:22  dicuccio
  758.  * Fixed uninitialized read reported by valgrind.
  759.  *
  760.  * Revision 1.12  2003/01/31 16:49:38  lavr
  761.  * Remove unused variable "e" from catch() clause
  762.  *
  763.  * Revision 1.11  2002/12/16 16:17:25  soussov
  764.  * ct_con_props returns an outlen == strlen(x)+1. Adaptin to this feature
  765.  *
  766.  * Revision 1.10  2002/09/16 15:10:23  soussov
  767.  * add try catch when canceling active commands in Refresh method
  768.  *
  769.  * Revision 1.9  2002/03/27 05:01:58  vakatov
  770.  * Minor formal fixes
  771.  *
  772.  * Revision 1.8  2002/03/26 15:34:37  soussov
  773.  * new image/text operations added
  774.  *
  775.  * Revision 1.7  2002/02/01 21:49:37  soussov
  776.  * ct_cmd_drop for the CTL_Connection::SendData added
  777.  *
  778.  * Revision 1.6  2001/11/06 17:59:55  lavr
  779.  * Formatted uniformly as the rest of the library
  780.  *
  781.  * Revision 1.5  2001/10/12 21:21:00  lavr
  782.  * Faster checks against zero for unsigned ints
  783.  *
  784.  * Revision 1.4  2001/09/27 20:08:33  vakatov
  785.  * Added "DB_" (or "I_") prefix where it was missing
  786.  *
  787.  * Revision 1.3  2001/09/27 15:42:09  soussov
  788.  * CTL_Connection::Release() added
  789.  *
  790.  * Revision 1.2  2001/09/25 15:05:43  soussov
  791.  * fixed typo in CTL_SendDataCmd::SendChunk
  792.  *
  793.  * Revision 1.1  2001/09/21 23:40:02  vakatov
  794.  * -----  Initial (draft) revision.  -----
  795.  * This is a major revamp (by Denis Vakatov, with help from Vladimir Soussov)
  796.  * of the DBAPI "driver" libs originally written by Vladimir Soussov.
  797.  * The revamp involved massive code shuffling and grooming, numerous local
  798.  * API redesigns, adding comments and incorporating DBAPI to the C++ Toolkit.
  799.  *
  800.  * ===========================================================================
  801.  */