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

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

生物技术

开发平台：

C/C++

cursor.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: cursor.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:19:41  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.9
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: cursor.cpp,v 1000.1 2004/06/01 19:19:41 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 cursor command
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <dbapi/driver/ctlib/interfaces.hpp>
  45. BEGIN_NCBI_SCOPE
  48. /////////////////////////////////////////////////////////////////////////////
  49. //
  50. //  CTL_CursorCmd::
  51. //
  53. CTL_CursorCmd::CTL_CursorCmd(CTL_Connection* conn, CS_COMMAND* cmd,
  54.                              const string& cursor_name, const string& query,
  55.                              unsigned int nof_params, unsigned int fetch_size)
  56.     : m_Connect(conn),
  57.       m_Cmd(cmd),
  58.       m_Name(cursor_name),
  59.       m_Query(query),
  60.       m_Params(nof_params),
  61.       m_FetchSize(fetch_size)
  62. {
  63.     m_IsOpen      = false;
  64.     m_HasFailed   = false;
  65.     m_Used        = false;
  66.     m_Res         = 0;
  67.     m_RowCount    = -1;
  68. }
  71. bool CTL_CursorCmd::BindParam(const string& param_name, CDB_Object* param_ptr)
  72. {
  73.     return
  74.         m_Params.BindParam(CDB_Params::kNoParamNumber, param_name, param_ptr);
  75. }
  78. CDB_Result* CTL_CursorCmd::Open()
  79. {
  80.     if ( m_IsOpen ) {
  81.         // need to close it first
  82.         Close();
  83.     }
  85.     if ( !m_Used ) {
  86.         m_HasFailed = false;
  88.         switch ( ct_cursor(m_Cmd, CS_CURSOR_DECLARE,
  89.                            const_cast<char*> (m_Name.c_str()), CS_NULLTERM,
  90.                            const_cast<char*> (m_Query.c_str()), CS_NULLTERM,
  91.                            CS_UNUSED) ) {
  92.         case CS_SUCCEED:
  93.             break;
  94.         case CS_FAIL:
  95.             m_HasFailed = true;
  96.             throw CDB_ClientEx(eDB_Fatal, 122001, "CTL_CursorCmd::Open",
  97.                                "ct_cursor(DECLARE) failed");
  98.         case CS_BUSY:
  99.             throw CDB_ClientEx(eDB_Error, 122002, "CTL_CursorCmd::Open",
  100.                                "the connection is busy");
  101.         }
  103.         if (m_Params.NofParams() > 0) {
  104.             // we do have the parameters
  105.             // check if query is a select statement or a function call
  106.             if (m_Query.find("select") != string::npos  ||
  107.                 m_Query.find("SELECT") != string::npos) {
  108.                 // this is a select
  109.                 if ( !x_AssignParams(true) ) {
  110.                     m_HasFailed = true;
  111.                     throw CDB_ClientEx(eDB_Error, 122003,"CTL_CursorCmd::Open",
  112.                                        "cannot declare the params");
  113.                 }
  114.             }
  115.         }
  117.         if (m_FetchSize > 1) {
  118.             switch ( ct_cursor(m_Cmd, CS_CURSOR_ROWS, 0, CS_UNUSED,
  119.                                0, CS_UNUSED, (CS_INT) m_FetchSize) ) {
  120.             case CS_SUCCEED:
  121.                 break;
  122.             case CS_FAIL:
  123.                 m_HasFailed = true;
  124.                 throw CDB_ClientEx(eDB_Fatal, 122004, "CTL_CursorCmd::Open",
  125.                                    "ct_cursor(ROWS) failed");
  126.             case CS_BUSY:
  127.                 throw CDB_ClientEx(eDB_Error, 122002, "CTL_CursorCmd::Open",
  128.                                    "the connection is busy");
  129.             }
  130.         }
  131.     }
  133.     m_HasFailed = false;
  135.     // open the cursor
  136.     switch ( ct_cursor(m_Cmd, CS_CURSOR_OPEN, 0, CS_UNUSED, 0, CS_UNUSED,
  137.                        m_Used ? CS_RESTORE_OPEN : CS_UNUSED) ) {
  138.     case CS_SUCCEED:
  139.         break;
  140.     case CS_FAIL:
  141.         m_HasFailed = true;
  142.         throw CDB_ClientEx(eDB_Fatal, 122005, "CTL_CursorCmd::Open",
  143.                            "ct_cursor(open) failed");
  144.     case CS_BUSY:
  145.         throw CDB_ClientEx(eDB_Error, 122002, "CTL_CursorCmd::Open",
  146.                            "the connection is busy");
  147.     }
  149.     m_IsOpen = true;
  151.     if (m_Params.NofParams() > 0) {
  152.         // we do have the parameters
  153.         if ( !x_AssignParams(false) ) {
  154.             m_HasFailed = true;
  155.             throw CDB_ClientEx(eDB_Error, 122003, "CTL_CursorCmd::Open",
  156.                                "cannot assign the params");
  157.         }
  158.     }
  160.     // send this command
  161.     switch ( ct_send(m_Cmd) ) {
  162.     case CS_SUCCEED:
  163.         break;
  164.     case CS_FAIL:
  165.         m_HasFailed = true;
  166.         throw CDB_ClientEx(eDB_Error, 122006, "CTL_CursorCmd::Open",
  167.                            "ct_send failed");
  168.     case CS_CANCELED:
  169.         throw CDB_ClientEx(eDB_Error, 122008, "CTL_CursorCmd::Open",
  170.                            "command was canceled");
  171.     case CS_BUSY:
  172.     case CS_PENDING:
  173.         throw CDB_ClientEx(eDB_Error, 122007, "CTL_CursorCmd::Open",
  174.                            "connection has another request pending");
  175.     }
  177.     m_Used = true;
  179.     for (;;) {
  180.         CS_INT res_type;
  182.         switch ( ct_results(m_Cmd, &res_type) ) {
  183.         case CS_SUCCEED:
  184.             break;
  185.         case CS_END_RESULTS:
  186.             return 0;
  187.         case CS_FAIL:
  188.             m_HasFailed = true;
  189.             throw CDB_ClientEx(eDB_Error, 122013, "CTL_CursorCmd::Open",
  190.                                "ct_result failed");
  191.         case CS_CANCELED:
  192.             throw CDB_ClientEx(eDB_Error, 122011, "CTL_CursorCmd::Open",
  193.                                "your command has been canceled");
  194.         case CS_BUSY:
  195.             throw CDB_ClientEx(eDB_Error, 122014, "CTL_CursorCmd::Open",
  196.                                "connection has another request pending");
  197.         default:
  198.             throw CDB_ClientEx(eDB_Error, 122015, "CTL_CursorCmd::Open",
  199.                                "your request is pending");
  200.         }
  202.         switch ( res_type ) {
  203.         case CS_CMD_SUCCEED:
  204.         case CS_CMD_DONE:
  205.             // done with this command -- check the number of affected rows
  206.             g_CTLIB_GetRowCount(m_Cmd, &m_RowCount);
  207.             continue;
  208.         case CS_CMD_FAIL:
  209.             // the command has failed -- check the number of affected rows
  210.             g_CTLIB_GetRowCount(m_Cmd, &m_RowCount);
  211.             m_HasFailed = true;
  212.             while (ct_results(m_Cmd, &res_type) == CS_SUCCEED) {
  213.                 continue;
  214.             }
  215.             throw CDB_ClientEx(eDB_Warning, 122016, "CTL_CursorCmd::Open",
  216.                                "The server encountered an error while "
  217.                                "executing a command");
  218.         case CS_CURSOR_RESULT:
  219.             m_Res = new CTL_CursorResult(m_Cmd);
  220.             break;
  221.         default:
  222.             continue;
  223.         }
  225.         return Create_Result(*m_Res);
  226.     }
  227. }
  230. bool CTL_CursorCmd::Update(const string& table_name, const string& upd_query)
  231. {
  232.     if ( !m_IsOpen ) {
  233.         return false;
  234.     }
  236.     switch ( ct_cursor(m_Cmd, CS_CURSOR_UPDATE,
  237.                        const_cast<char*> (table_name.c_str()), CS_NULLTERM,
  238.                        const_cast<char*> (upd_query.c_str()),  CS_NULLTERM,
  239.                        CS_UNUSED) ) {
  240.     case CS_SUCCEED:
  241.         break;
  242.     case CS_FAIL:
  243.         m_HasFailed = true;
  244.         throw CDB_ClientEx(eDB_Fatal, 122030, "CTL_CursorCmd::Update",
  245.                            "ct_cursor(update) failed");
  246.     case CS_BUSY:
  247.         throw CDB_ClientEx(eDB_Error, 122031, "CTL_CursorCmd::Update",
  248.                            "the connection is busy");
  249.     }
  252.     // send this command
  253.     switch ( ct_send(m_Cmd) ) {
  254.     case CS_SUCCEED:
  255.         break;
  256.     case CS_FAIL:
  257.         m_HasFailed = true;
  258.         throw CDB_ClientEx(eDB_Error, 122032, "CTL_CursorCmd::Update",
  259.                            "ct_send failed");
  260.     case CS_CANCELED:
  261.         throw CDB_ClientEx(eDB_Error, 122033, "CTL_CursorCmd::Update",
  262.                            "command was canceled");
  263.     case CS_BUSY:
  264.     case CS_PENDING:
  265.         throw CDB_ClientEx(eDB_Error, 122034, "CTL_CursorCmd::Update",
  266.                            "connection has another request pending");
  267.     }
  269.     // process the results
  270.     for (;;) {
  271.         CS_INT res_type;
  273.         switch ( ct_results(m_Cmd, &res_type) ) {
  274.         case CS_SUCCEED:
  275.             break;
  276.         case CS_END_RESULTS:
  277.             return true;
  278.         case CS_FAIL:
  279.             m_HasFailed = true;
  280.             throw CDB_ClientEx(eDB_Error, 122035, "CTL_CursorCmd::Update",
  281.                                "ct_result failed");
  282.         case CS_CANCELED:
  283.             throw CDB_ClientEx(eDB_Error, 122036, "CTL_CursorCmd::Update",
  284.                                "your command has been canceled");
  285.         case CS_BUSY:
  286.             throw CDB_ClientEx(eDB_Error, 122037, "CTL_CursorCmd::Update",
  287.                                "connection has another request pending");
  288.         default:
  289.             throw CDB_ClientEx(eDB_Error, 122038, "CTL_CursorCmd::Update",
  290.                                "your request is pending");
  291.         }
  293.         if(m_Connect->m_ResProc) {
  294.             I_Result* res= 0;
  295.             switch (res_type) {
  296.             case CS_ROW_RESULT:
  297.                 res = new CTL_RowResult(m_Cmd);
  298.                 break;
  299.             case CS_PARAM_RESULT:
  300.                 res = new CTL_ParamResult(m_Cmd);
  301.                 break;
  302.             case CS_COMPUTE_RESULT:
  303.                 res = new CTL_ComputeResult(m_Cmd);
  304.                 break;
  305.             case CS_STATUS_RESULT:
  306.                 res = new CTL_StatusResult(m_Cmd);
  307.                 break;
  308.             }
  309.             if(res) {
  310.                 CDB_Result* dbres= Create_Result(*res);
  311.                 m_Connect->m_ResProc->ProcessResult(*dbres);
  312.                 delete dbres;
  313.                 delete res;
  314.                 continue;
  315.             }
  316.         }
  317.         switch ( res_type ) {
  318.         case CS_CMD_SUCCEED:
  319.         case CS_CMD_DONE: // done with this command
  320.             continue;
  321.         case CS_CMD_FAIL: // the command has failed
  322.             m_HasFailed = true;
  323.             while (ct_results(m_Cmd, &res_type) == CS_SUCCEED) {
  324.                 continue;
  325.             }
  326.             throw CDB_ClientEx(eDB_Warning, 122039, "CTL_CursorCmd::Update",
  327.                                "The server encountered an error while "
  328.                                "executing a command");
  329.         default:
  330.             continue;
  331.         }
  332.     }
  333. }
  335. I_ITDescriptor* CTL_CursorCmd::x_GetITDescriptor(unsigned int item_num)
  336. {
  337.     if(!m_IsOpen || (m_Res == 0)) {
  338.         return 0;
  339.     }
  340.     while(m_Res->CurrentItemNo() < item_num) {
  341.         if(!m_Res->SkipItem()) return 0;
  342.     }
  343.     
  344.     I_ITDescriptor* desc= 0;
  345.     if(m_Res->CurrentItemNo() == item_num) {
  346.         desc= m_Res->GetImageOrTextDescriptor();
  347.     }
  348.     else {
  349.         CTL_ITDescriptor* dsc = new CTL_ITDescriptor;
  350.         
  351.         if (ct_data_info(m_Cmd, CS_GET, item_num+1, &dsc->m_Desc)
  352.             != CS_SUCCEED) {
  353.             delete dsc;
  354.             throw CDB_ClientEx(eDB_Error, 130010,
  355.                                "CTL_CursorCmd::UpdateTextImage",
  356.                                "ct_data_info failed");
  357.         }
  358.         desc= dsc;
  359.     }
  360.     return desc;
  361. }
  363. bool CTL_CursorCmd::UpdateTextImage(unsigned int item_num, CDB_Stream& data, 
  364.     bool log_it)
  365. {
  366.     I_ITDescriptor* desc= x_GetITDescriptor(item_num);
  367.     C_ITDescriptorGuard d_guard(desc);
  369.     return (desc) ? m_Connect->x_SendData(*desc, data, log_it) : false;
  370. }
  372. CDB_SendDataCmd* CTL_CursorCmd::SendDataCmd(unsigned int item_num, size_t size, 
  373.     bool log_it)
  374. {
  375.     I_ITDescriptor* desc= x_GetITDescriptor(item_num);
  376.     C_ITDescriptorGuard d_guard(desc);
  378.     return (desc) ? m_Connect->SendDataCmd(*desc, size, log_it) : 0;
  379. }     
  381. bool CTL_CursorCmd::Delete(const string& table_name)
  382. {
  383.     if ( !m_IsOpen ) {
  384.         return false;
  385.     }
  387.     switch ( ct_cursor(m_Cmd, CS_CURSOR_DELETE,
  388.                        const_cast<char*> (table_name.c_str()), CS_NULLTERM,
  389.                        0, CS_UNUSED, CS_UNUSED) ) {
  390.     case CS_SUCCEED:
  391.         break;
  392.     case CS_FAIL:
  393.         m_HasFailed = true;
  394.         throw CDB_ClientEx(eDB_Fatal, 122040, "CTL_CursorCmd::Delete",
  395.                            "ct_cursor(delete) failed");
  396.     case CS_BUSY:
  397.         throw CDB_ClientEx(eDB_Error, 122041, "CTL_CursorCmd::Delete",
  398.                            "the connection is busy");
  399.     }
  401.     // send this command
  402.     switch ( ct_send(m_Cmd) ) {
  403.     case CS_SUCCEED:
  404.         break;
  405.     case CS_FAIL:
  406.         m_HasFailed = true;
  407.         throw CDB_ClientEx(eDB_Error, 122042, "CTL_CursorCmd::Delete",
  408.                            "ct_send failed");
  409.     case CS_CANCELED:
  410.         throw CDB_ClientEx(eDB_Error, 122043, "CTL_CursorCmd::Delete",
  411.                            "command was canceled");
  412.     case CS_BUSY:
  413.     case CS_PENDING:
  414.         throw CDB_ClientEx(eDB_Error, 122044, "CTL_CursorCmd::Delete",
  415.                            "connection has another request pending");
  416.     }
  418.     // process the results
  419.     for (;;) {
  420.         CS_INT res_type;
  422.         switch ( ct_results(m_Cmd, &res_type) ) {
  423.         case CS_SUCCEED:
  424.             break;
  425.         case CS_END_RESULTS:
  426.             return true;
  427.         case CS_FAIL:
  428.             m_HasFailed = true;
  429.             throw CDB_ClientEx(eDB_Error, 122045, "CTL_CursorCmd::Delete",
  430.                                "ct_result failed");
  431.         case CS_CANCELED:
  432.             throw CDB_ClientEx(eDB_Error, 122046, "CTL_CursorCmd::Delete",
  433.                                "your command has been canceled");
  434.         case CS_BUSY:
  435.             throw CDB_ClientEx(eDB_Error, 122047, "CTL_CursorCmd::Delete",
  436.                                "connection has another request pending");
  437.         default:
  438.             throw CDB_ClientEx(eDB_Error, 122048, "CTL_CursorCmd::Delete",
  439.                                "your request is pending");
  440.         }
  442.         if(m_Connect->m_ResProc) {
  443.             I_Result* res= 0;
  444.             switch (res_type) {
  445.             case CS_ROW_RESULT:
  446.                 res = new CTL_RowResult(m_Cmd);
  447.                 break;
  448.             case CS_PARAM_RESULT:
  449.                 res = new CTL_ParamResult(m_Cmd);
  450.                 break;
  451.             case CS_COMPUTE_RESULT:
  452.                 res = new CTL_ComputeResult(m_Cmd);
  453.                 break;
  454.             case CS_STATUS_RESULT:
  455.                 res = new CTL_StatusResult(m_Cmd);
  456.                 break;
  457.             }
  458.             if(res) {
  459.                 CDB_Result* dbres= Create_Result(*res);
  460.                 m_Connect->m_ResProc->ProcessResult(*dbres);
  461.                 delete dbres;
  462.                 delete res;
  463.                 continue;
  464.             }
  465.         }
  466.         switch ( res_type ) {
  467.         case CS_CMD_SUCCEED:
  468.         case CS_CMD_DONE: // done with this command
  469.             continue;
  470.         case CS_CMD_FAIL: // the command has failed
  471.             m_HasFailed = true;
  472.             while(ct_results(m_Cmd, &res_type) == CS_SUCCEED);
  473.             throw CDB_ClientEx(eDB_Warning, 122049, "CTL_CursorCmd::Delete",
  474.                                "The server encountered an error while "
  475.                                "executing a command");
  476.         default:
  477.             continue;
  478.         }
  479.     }
  480. }
  483. int CTL_CursorCmd::RowCount() const
  484. {
  485.     return m_RowCount;
  486. }
  489. bool CTL_CursorCmd::Close()
  490. {
  491.     if ( !m_IsOpen ) {
  492.         return false;
  493.     }
  495.     if (m_Res) {
  496.         delete m_Res;
  497.         m_Res = 0;
  498.     }
  500.     switch ( ct_cursor(m_Cmd, CS_CURSOR_CLOSE, 0, CS_UNUSED, 0, CS_UNUSED,
  501.                        CS_UNUSED) ) {
  502.     case CS_SUCCEED:
  503.         break;
  504.     case CS_FAIL:
  505.         m_HasFailed = true;
  506.         throw CDB_ClientEx(eDB_Fatal, 122020, "CTL_CursorCmd::Close",
  507.                            "ct_cursor(close) failed");
  508.     case CS_BUSY:
  509.         throw CDB_ClientEx(eDB_Error, 122021, "CTL_CursorCmd::Close",
  510.                            "the connection is busy");
  511.     }
  513.     // send this command
  514.     switch ( ct_send(m_Cmd) ) {
  515.     case CS_SUCCEED:
  516.         break;
  517.     case CS_FAIL:
  518.         m_HasFailed = true;
  519.         throw CDB_ClientEx(eDB_Error, 122022, "CTL_CursorCmd::Close",
  520.                            "ct_send failed");
  521.     case CS_CANCELED:
  522.         throw CDB_ClientEx(eDB_Error, 122023, "CTL_CursorCmd::Close",
  523.                            "command was canceled");
  524.     case CS_BUSY:
  525.     case CS_PENDING:
  526.         throw CDB_ClientEx(eDB_Error, 122024, "CTL_CursorCmd::Close",
  527.                            "connection has another request pending");
  528.     }
  530.     m_IsOpen = false;
  532.     CS_INT res_type;
  533.     for (;;) {
  534.         switch ( ct_results(m_Cmd, &res_type) ) {
  535.         case CS_SUCCEED:
  536.             break;
  537.         case CS_END_RESULTS:
  538.             return true;
  539.         case CS_FAIL:
  540.             m_HasFailed = true;
  541.             throw CDB_ClientEx(eDB_Error, 122025, "CTL_CursorCmd::Close",
  542.                                "ct_result failed");
  543.         case CS_CANCELED:
  544.             throw CDB_ClientEx(eDB_Error, 122026, "CTL_CursorCmd::Close",
  545.                                "your command has been canceled");
  546.         case CS_BUSY:
  547.             throw CDB_ClientEx(eDB_Error, 122027, "CTL_CursorCmd::Close",
  548.                                "connection has another request pending");
  549.         default:
  550.             throw CDB_ClientEx(eDB_Error, 122028, "CTL_CursorCmd::Close",
  551.                                "your request is pending");
  552.         }
  554.         if(m_Connect->m_ResProc) {
  555.             I_Result* res= 0;
  556.             switch (res_type) {
  557.             case CS_ROW_RESULT:
  558.                 res = new CTL_RowResult(m_Cmd);
  559.                 break;
  560.             case CS_PARAM_RESULT:
  561.                 res = new CTL_ParamResult(m_Cmd);
  562.                 break;
  563.             case CS_COMPUTE_RESULT:
  564.                 res = new CTL_ComputeResult(m_Cmd);
  565.                 break;
  566.             case CS_STATUS_RESULT:
  567.                 res = new CTL_StatusResult(m_Cmd);
  568.                 break;
  569.             }
  570.             if(res) {
  571.                 CDB_Result* dbres= Create_Result(*res);
  572.                 m_Connect->m_ResProc->ProcessResult(*dbres);
  573.                 delete dbres;
  574.                 delete res;
  575.                 continue;
  576.             }
  577.         }
  578.         switch ( res_type ) {
  579.         case CS_CMD_SUCCEED:
  580.         case CS_CMD_DONE:
  581.             // done with this command
  582.             continue;
  583.         case CS_CMD_FAIL:
  584.             // the command has failed
  585.             m_HasFailed = true;
  586.             while (ct_results(m_Cmd, &res_type) == CS_SUCCEED) {
  587.                 continue;
  588.             }
  589.             throw CDB_ClientEx(eDB_Warning, 122029, "CTL_CursorCmd::Close",
  590.                                "The server encountered an error while "
  591.                                "executing a command");
  592.         }
  593.     }
  594. }
  597. void CTL_CursorCmd::Release()
  598. {
  599.     m_BR = 0;
  600.     if ( m_IsOpen ) {
  601.         Close();
  602.         m_IsOpen = false;
  603.     }
  604.     m_Connect->DropCmd(*this);
  605.     delete this;
  606. }
  609. CTL_CursorCmd::~CTL_CursorCmd()
  610. {
  611.     if ( m_BR ) {
  612.         *m_BR = 0;
  613.     }
  615.     if ( m_IsOpen ) {
  616.         Close();
  617.     }
  619.     if ( m_Used ) {
  620.         // deallocate the cursor
  621.         switch ( ct_cursor(m_Cmd, CS_CURSOR_DEALLOC,
  622.                            0, CS_UNUSED, 0, CS_UNUSED, CS_UNUSED) ) {
  623.         case CS_SUCCEED:
  624.             break;
  625.         case CS_FAIL:
  626.             // m_HasFailed = true;
  627.             //throw CDB_ClientEx(eDB_Fatal, 122050, "::~CTL_CursorCmd",
  628.             //                   "ct_cursor(dealloc) failed");
  629.         case CS_BUSY:
  630.             //throw CDB_ClientEx(eDB_Error, 122051, "::~CTL_CursorCmd",
  631.             //                   "the connection is busy");
  632.             ct_cmd_drop(m_Cmd);
  633.             return;
  634.         }
  636.         // send this command
  637.         switch ( ct_send(m_Cmd) ) {
  638.         case CS_SUCCEED:
  639.             break;
  640.         case CS_FAIL:
  641.             // m_HasFailed = true;
  642.             // throw CDB_ClientEx(eDB_Error, 122052, "::~CTL_CursorCmd",
  643.             //                   "ct_send failed");
  644.         case CS_CANCELED:
  645.             // throw CDB_ClientEx(eDB_Error, 122053, "::~CTL_CursorCmd",
  646.             //                   "command was canceled");
  647.         case CS_BUSY:
  648.         case CS_PENDING:
  649.             // throw CDB_ClientEx(eDB_Error, 122054, "::~CTL_CursorCmd",
  650.             //                   "connection has another request pending");
  651.             ct_cmd_drop(m_Cmd);
  652.             return;
  653.         }
  655.         // process the results
  656.         for (bool need_cont = true;  need_cont; ) {
  657.             CS_INT res_type;
  659.             switch ( ct_results(m_Cmd, &res_type) ) {
  660.             case CS_SUCCEED:
  661.                 break;
  662.             case CS_END_RESULTS:
  663.                 need_cont = false;
  664.                 continue;
  665.             case CS_FAIL:
  666.                 // m_HasFailed = true;
  667.                 //throw CDB_ClientEx(eDB_Error, 122055, "::~CTL_CursorCmd",
  668.                 //                   "ct_result failed");
  669.             case CS_CANCELED:                          
  670.                 // throw CDB_ClientEx(eDB_Error, 122056, "::~CTL_CursorCmd",
  671.                 //                   "your command has been canceled");
  672.             case CS_BUSY:                              
  673.                 // throw CDB_ClientEx(eDB_Error, 122057, "::~CTL_CursorCmd",
  674.                 //                   "connection has another request pending");
  675.             default:                                   
  676.                 //throw CDB_ClientEx(eDB_Error, 122058, "::~CTL_CursorCmd",
  677.                 //                   "your request is pending");
  678.                 need_cont = false;
  679.                 continue;
  680.             }
  682.             if(m_Connect->m_ResProc) {
  683.                 I_Result* res= 0;
  684.                 switch (res_type) {
  685.                 case CS_ROW_RESULT:
  686.                     res = new CTL_RowResult(m_Cmd);
  687.                     break;
  688.                 case CS_PARAM_RESULT:
  689.                     res = new CTL_ParamResult(m_Cmd);
  690.                     break;
  691.                 case CS_COMPUTE_RESULT:
  692.                     res = new CTL_ComputeResult(m_Cmd);
  693.                     break;
  694.                 case CS_STATUS_RESULT:
  695.                     res = new CTL_StatusResult(m_Cmd);
  696.                     break;
  697.                 }
  698.                 if(res) {
  699.                     CDB_Result* dbres= Create_Result(*res);
  700.                     m_Connect->m_ResProc->ProcessResult(*dbres);
  701.                     delete dbres;
  702.                     delete res;
  703.                     continue;
  704.                 }
  705.             }
  706.             switch ( res_type ) {
  707.             case CS_CMD_SUCCEED:
  708.             case CS_CMD_DONE: // done with this command
  709.                 continue;
  710.             case CS_CMD_FAIL: // the command has failed
  711.                 // m_HasFailed = true;
  712.                 while (ct_results(m_Cmd, &res_type) == CS_SUCCEED);
  713.                 // throw CDB_ClientEx(eDB_Warning, 122059, "::~CTL_CursorCmd",
  714.                 //                   "The server encountered an error while "
  715.                 //                   "executing a command");
  716.                 need_cont = false;
  717.             default:
  718.                 continue;
  719.             }
  720.         }
  721.     }
  723. #if 0
  724.     if (ct_cmd_drop(m_Cmd) != CS_SUCCEED) {
  725.         // throw CDB_ClientEx(eDB_Fatal, 122060, "::~CTL_CursorCmd",
  726.         //                   "ct_cmd_drop failed");
  727.     }
  728. #else
  729.     ct_cmd_drop(m_Cmd);
  730. #endif
  731. }
  734. bool CTL_CursorCmd::x_AssignParams(bool declare_only)
  735. {
  736.     CS_DATAFMT param_fmt;
  737.     memset(&param_fmt, 0, sizeof(param_fmt));
  738.     param_fmt.namelen = CS_NULLTERM;
  739.     param_fmt.status  = CS_INPUTVALUE;
  741.     for (unsigned int i = 0;  i < m_Params.NofParams();  i++) {
  742.         if(m_Params.GetParamStatus(i) == 0) continue;
  744.         CDB_Object&   param = *m_Params.GetParam(i);
  745.         const string& param_name = m_Params.GetParamName(i);
  746.         CS_SMALLINT   indicator = (!declare_only  &&  param.IsNULL()) ? -1 : 0;
  748.         if ( !g_CTLIB_AssignCmdParam(m_Cmd, param, param_name, param_fmt,
  749.                                      indicator, declare_only) ) {
  750.             return false;
  751.         }
  752.     }
  754.     return true;
  755. }
  758. END_NCBI_SCOPE
  762. /*
  763.  * ===========================================================================
  764.  * $Log: cursor.cpp,v $
  765.  * Revision 1000.1  2004/06/01 19:19:41  gouriano
  766.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.9
  767.  *
  768.  * Revision 1.9  2004/05/17 21:12:03  gorelenk
  769.  * Added include of PCH ncbi_pch.hpp
  770.  *
  771.  * Revision 1.8  2003/06/05 16:00:31  soussov
  772.  * adds code for DumpResults and for the dumped results processing
  773.  *
  774.  * Revision 1.7  2003/05/16 20:24:24  soussov
  775.  * adds code to skip parameters if it was not set
  776.  *
  777.  * Revision 1.6  2002/09/16 16:34:16  soussov
  778.  * add try catch when canceling in Release method
  779.  *
  780.  * Revision 1.5  2002/05/16 21:35:22  soussov
  781.  * fixes the memory leak in text/image processing
  782.  *
  783.  * Revision 1.4  2002/03/26 15:34:38  soussov
  784.  * new image/text operations added
  785.  *
  786.  * Revision 1.3  2001/11/06 17:59:55  lavr
  787.  * Formatted uniformly as the rest of the library
  788.  *
  789.  * Revision 1.2  2001/09/25 16:29:57  soussov
  790.  * fixed typo in CTL_CursorCmd::x_AssignParams
  791.  *
  792.  * Revision 1.1  2001/09/21 23:40:02  vakatov
  793.  * -----  Initial (draft) revision.  -----
  794.  * This is a major revamp (by Denis Vakatov, with help from Vladimir Soussov)
  795.  * of the DBAPI "driver" libs originally written by Vladimir Soussov.
  796.  * The revamp involved massive code shuffling and grooming, numerous local
  797.  * API redesigns, adding comments and incorporating DBAPI to the C++ Toolkit.
  798.  *
  799.  * ===========================================================================
  800.  */