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

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

生物技术

开发平台：

C/C++

rpc.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: rpc.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:20:58  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: rpc.cpp,v 1000.1 2004/06/01 19:20:58 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:  TDS RPC command
  38.  *
  39.  */
  40.  
  41. #include <ncbi_pch.hpp>
  42. #include <dbapi/driver/ftds/interfaces.hpp>
  43. #include <dbapi/driver/util/numeric_convert.hpp>
  46. BEGIN_NCBI_SCOPE
  49. /////////////////////////////////////////////////////////////////////////////
  50. //
  51. //  CTDS_RPCCmd::
  52. //
  54. CTDS_RPCCmd::CTDS_RPCCmd(CTDS_Connection* con, DBPROCESS* cmd,
  55.                          const string& proc_name, unsigned int nof_params) :
  56.     m_Connect(con), m_Cmd(cmd), m_Query(proc_name), m_Params(nof_params),
  57.     m_WasSent(false), m_HasFailed(false), m_Recompile(false), m_Res(0),
  58.     m_RowCount(-1), m_Status(0)
  59. {
  60.     return;
  61. }
  64. bool CTDS_RPCCmd::BindParam(const string& param_name,
  65.                             CDB_Object* param_ptr, bool out_param)
  66. {
  67.     return m_Params.BindParam(CDB_Params::kNoParamNumber, param_name,
  68.                               param_ptr, out_param);
  69. }
  72. bool CTDS_RPCCmd::SetParam(const string& param_name,
  73.                            CDB_Object* param_ptr, bool out_param)
  74. {
  75.     return m_Params.SetParam(CDB_Params::kNoParamNumber, param_name,
  76.                              param_ptr, out_param);
  77. }
  80. bool CTDS_RPCCmd::Send()
  81. {
  82.     if (m_WasSent)
  83.         Cancel();
  85.     m_HasFailed = false;
  87.     if (!x_AssignOutputParams()) {
  88.         dbfreebuf(m_Cmd);
  89.         m_HasFailed = true;
  90.         throw CDB_ClientEx(eDB_Error, 221001, "CTDS_RPCCmd::Send",
  91.                            "cannot assign the output params");
  92.     }
  94.     string cmd= "execute " + m_Query;
  95.     if (dbcmd(m_Cmd, (char*)(cmd.c_str())) != SUCCEED) {
  96.         dbfreebuf(m_Cmd);
  97.         m_HasFailed = true;
  98.         throw CDB_ClientEx(eDB_Fatal, 221002, "CTDS_RPCCmd::Send",
  99.                            "dbcmd failed");
  100.     }
  102.     if (!x_AssignParams()) {
  103.         m_HasFailed = true;
  104.         throw CDB_ClientEx(eDB_Error, 221003, "CTDS_RPCCmd::Send",
  105.                            "can not assign the params");
  106.     }
  108.     m_Connect->TDS_SetTimeout();
  110.     if (dbsqlsend(m_Cmd) != SUCCEED) {
  111.         m_HasFailed = true;
  112.         throw CDB_ClientEx(eDB_Error, 221005, "CTDS_RPCCmd::Send",
  113.                            "dbsqlsend failed");
  114.     }
  116.     m_WasSent = true;
  117.     m_Status = 0;
  118.     return true;
  119. }
  122. bool CTDS_RPCCmd::WasSent() const
  123. {
  124.     return m_WasSent;
  125. }
  128. bool CTDS_RPCCmd::Cancel()
  129. {
  130.     if (m_WasSent) {
  131.         if (m_Res) {
  132.             delete m_Res;
  133.             m_Res = 0;
  134.         }
  135.         m_WasSent = false;
  136.         return dbcancel(m_Cmd) == SUCCEED;
  137.     }
  138.     // m_Query.erase();
  139.     return true;
  140. }
  143. bool CTDS_RPCCmd::WasCanceled() const
  144. {
  145.     return !m_WasSent;
  146. }
  149. CDB_Result* CTDS_RPCCmd::Result()
  150. {
  151.     if (m_Res) {
  152.         if(m_RowCount < 0) {
  153.             m_RowCount = DBCOUNT(m_Cmd);
  154.         }
  155.         delete m_Res;
  156.         m_Res = 0;
  157.     }
  159.     if (!m_WasSent) {
  160.         throw CDB_ClientEx(eDB_Error, 221010, "CTDS_RPCCmd::Result",
  161.                            "you have to send a command first");
  162.     }
  164.     if (m_Status == 0) {
  165.         m_Status = 1;
  166.         if (dbsqlok(m_Cmd) != SUCCEED) {
  167.             m_WasSent = false;
  168.             m_HasFailed = true;
  169.             throw CDB_ClientEx(eDB_Error, 221011, "CTDS_RPCCmd::Result",
  170.                                "dbsqlok failed");
  171.         }
  172.     }
  174.     if ((m_Status & 0x10) != 0) { // we do have a compute result
  175.         m_Res = new CTDS_ComputeResult(m_Cmd, &m_Status);
  176.         m_RowCount = 1;
  177.         return Create_Result(*m_Res);
  178.     }
  180.     while ((m_Status & 0x1) != 0) {
  181.         switch (dbresults(m_Cmd)) {
  182.         case SUCCEED:
  183.             if (DBCMDROW(m_Cmd) == SUCCEED) { // we may get rows in this result
  184.                 m_Res = new CTDS_RowResult(m_Cmd, &m_Status);
  185.                 m_RowCount = -1;
  186.                 return Create_Result(*m_Res);
  187.             } else {
  188.                 m_RowCount = DBCOUNT(m_Cmd);
  189.                 continue;
  190.             }
  191.         case NO_MORE_RESULTS:
  192.             m_Status = 2;
  193.             break;
  194.         default:
  195.             m_HasFailed = true;
  196.             throw CDB_ClientEx(eDB_Warning, 221016, "CTDS_RPCCmd::Result",
  197.                                "error encountered in command execution");
  198.         }
  199.         break;
  200.     }
  202.     // we've done with the row results at this point
  203.     // let's look at return parameters and ret status
  204.     if (m_Status == 2) {
  205.         m_Status = 4;
  206.         int n = dbnumrets(m_Cmd);
  207.         if (n > 0) {
  208.             m_Res = new CTDS_ParamResult(m_Cmd, n);
  209.             m_RowCount = 1;
  210.             return Create_Result(*m_Res);
  211.         }
  212.     }
  214.     if (m_Status == 4) {
  215.         m_Status = 6;
  216.         if (dbhasretstat(m_Cmd)) {
  217.             m_Res = new CTDS_StatusResult(m_Cmd);
  218.             m_RowCount = 1;
  219.             return Create_Result(*m_Res);
  220.         }
  221.     }
  223.     m_WasSent = false;
  224.     return 0;
  225. }
  228. bool CTDS_RPCCmd::HasMoreResults() const
  229. {
  230.     return m_WasSent;
  231. }
  233. void CTDS_RPCCmd::DumpResults()
  234. {
  235.     CDB_Result* dbres;
  236.     while(m_WasSent) {
  237.         dbres= Result();
  238.         if(dbres) {
  239.             if(m_Connect->m_ResProc) {
  240.                 m_Connect->m_ResProc->ProcessResult(*dbres);
  241.             }
  242.             else {
  243.                 while(dbres->Fetch());
  244.             }
  245.             delete dbres;
  246.         }
  247.     }
  248. }
  250. bool CTDS_RPCCmd::HasFailed() const
  251. {
  252.     return m_HasFailed;
  253. }
  256. int CTDS_RPCCmd::RowCount() const
  257. {
  258.     return (m_RowCount < 0)? DBCOUNT(m_Cmd) : m_RowCount;
  259. }
  262. void CTDS_RPCCmd::SetRecompile(bool recompile)
  263. {
  264.     m_Recompile = recompile;
  265. }
  268. void CTDS_RPCCmd::Release()
  269. {
  270.     m_BR = 0;
  271.     if (m_WasSent) {
  272.         Cancel();
  273.         m_WasSent = false;
  274.     }
  275.     m_Connect->DropCmd(*this);
  276.     delete this;
  277. }
  280. CTDS_RPCCmd::~CTDS_RPCCmd()
  281. {
  282.     if (m_BR)
  283.         *m_BR = 0;
  284.     if (m_WasSent)
  285.         Cancel();
  286. }
  289. bool CTDS_RPCCmd::x_AddParamValue(string& cmd, const CDB_Object& param)
  290. {
  291.     static const char s_hexnum[] = "0123456789ABCDEF";
  292.     char val_buffer[16*1024];
  294.     if (!param.IsNULL()) {
  295.         switch (param.GetType()) {
  296.         case eDB_Int: {
  297.             const CDB_Int& val = dynamic_cast<const CDB_Int&> (param);
  298.             sprintf(val_buffer, "%dn", val.Value());
  299.             break;
  300.         }
  301.         case eDB_SmallInt: {
  302.             const CDB_SmallInt& val = dynamic_cast<const CDB_SmallInt&>(param);
  303.             sprintf(val_buffer, "%dn", (int) val.Value());
  304.             break;
  305.         }
  306.         case eDB_TinyInt: {
  307.             const CDB_TinyInt& val = dynamic_cast<const CDB_TinyInt&> (param);
  308.             sprintf(val_buffer, "%dn", (int) val.Value());
  309.             break;
  310.         }
  311.         case eDB_BigInt: {
  312.             const CDB_BigInt& val = dynamic_cast<const CDB_BigInt&> (param);
  313.             sprintf(val_buffer, "%lldn", val.Value());
  314.             break;
  315.         }
  316.         case eDB_Char: {
  317.             const CDB_Char& val = dynamic_cast<const CDB_Char&> (param);
  318.             const char* c = val.Value(); // No more than 255 chars
  319.             size_t i = 0;
  320.             val_buffer[i++] = ''';
  321.             while (*c) {
  322.                 if (*c == ''')
  323.                     val_buffer[i++] = ''';
  324.                 val_buffer[i++] = *c++;
  325.             }
  326.             val_buffer[i++] = ''';
  327.             val_buffer[i++] = 'n';
  328.             val_buffer[i] = '';
  329.             break;
  330.         }
  331.         case eDB_VarChar: {
  332.             const CDB_VarChar& val = dynamic_cast<const CDB_VarChar&> (param);
  333.             const char* c = val.Value();
  334.             size_t i = 0;
  335.             val_buffer[i++] = ''';
  336.             while (*c) {
  337.                 if (*c == ''')
  338.                     val_buffer[i++] = ''';
  339.                 val_buffer[i++] = *c++;
  340.             }
  341.             val_buffer[i++] = ''';
  342.             val_buffer[i++] = 'n';
  343.             val_buffer[i] = '';
  344.             break;
  345.         }
  346.         case eDB_LongChar: {
  347.             const CDB_LongChar& val = dynamic_cast<const CDB_LongChar&> (param);
  348.             const char* c = val.Value();
  349.             size_t i = 0;
  350.             val_buffer[i++] = ''';
  351.             while (*c && (i < sizeof(val_buffer) - 4)) {
  352.                 if (*c == ''')
  353.                     val_buffer[i++] = ''';
  354.                 val_buffer[i++] = *c++;
  355.             }
  356. if(*c != '') return false;
  357.             val_buffer[i++] = ''';
  358.             val_buffer[i++] = 'n';
  359.             val_buffer[i] = '';
  360.             break;
  361.         }
  362.         case eDB_Binary: {
  363.             const CDB_Binary& val = dynamic_cast<const CDB_Binary&> (param);
  364.             const unsigned char* c = (const unsigned char*) val.Value();
  365.             size_t i = 0, size = val.Size();
  366.             val_buffer[i++] = '0';
  367.             val_buffer[i++] = 'x';
  368.             for (size_t j = 0; j < size; j++) {
  369.                 val_buffer[i++] = s_hexnum[c[j] >> 4];
  370.                 val_buffer[i++] = s_hexnum[c[j] & 0x0F];
  371.             }
  372.             val_buffer[i++] = 'n';
  373.             val_buffer[i++] = '';
  374.             break;
  375.         }
  376.         case eDB_VarBinary: {
  377.             const CDB_VarBinary& val =
  378.                 dynamic_cast<const CDB_VarBinary&> (param);
  379.             const unsigned char* c = (const unsigned char*) val.Value();
  380.             size_t i = 0, size = val.Size();
  381.             val_buffer[i++] = '0';
  382.             val_buffer[i++] = 'x';
  383.             for (size_t j = 0; j < size; j++) {
  384.                 val_buffer[i++] = s_hexnum[c[j] >> 4];
  385.                 val_buffer[i++] = s_hexnum[c[j] & 0x0F];
  386.             }
  387.             val_buffer[i++] = 'n';
  388.             val_buffer[i++] = '';
  389.             break;
  390.         }
  391.         case eDB_LongBinary: {
  392.             const CDB_LongBinary& val =
  393.                 dynamic_cast<const CDB_LongBinary&> (param);
  394.             const unsigned char* c = (const unsigned char*) val.Value();
  395.             size_t i = 0, size = val.DataSize();
  396. if(size*2 > sizeof(val_buffer) - 4) return false;
  397.             val_buffer[i++] = '0';
  398.             val_buffer[i++] = 'x';
  399.             for (size_t j = 0; j < size; j++) {
  400.                 val_buffer[i++] = s_hexnum[c[j] >> 4];
  401.                 val_buffer[i++] = s_hexnum[c[j] & 0x0F];
  402.             }
  403.             val_buffer[i++] = 'n';
  404.             val_buffer[i++] = '';
  405.             break;
  406.         }
  407.         case eDB_Float: {
  408.             const CDB_Float& val = dynamic_cast<const CDB_Float&> (param);
  409.             sprintf(val_buffer, "%En", (double) val.Value());
  410.             break;
  411.         }
  412.         case eDB_Double: {
  413.             const CDB_Double& val = dynamic_cast<const CDB_Double&> (param);
  414.             sprintf(val_buffer, "%En", val.Value());
  415.             break;
  416.         }
  417.         case eDB_SmallDateTime: {
  418.             const CDB_SmallDateTime& val =
  419.                 dynamic_cast<const CDB_SmallDateTime&> (param);
  420.             sprintf(val_buffer, "'%s'n",
  421.     val.Value().AsString("M/D/Y h:m").c_str());
  422.             break;
  423.         }
  424.         case eDB_DateTime: {
  425.             const CDB_DateTime& val =
  426.                 dynamic_cast<const CDB_DateTime&> (param);
  427.             sprintf(val_buffer, "'%s:%.3d'n",
  428.     val.Value().AsString("M/D/Y h:m:s").c_str(),
  429.     (int)(val.Value().NanoSecond()/1000000));
  430.             break;
  431.         }
  432.         default:
  433.             return false; // dummy for compiler
  434.         }
  435.         cmd += val_buffer;
  436.     } else {
  437.         cmd += "NULL";
  438.     }
  440.     return true;
  441. }
  444. bool CTDS_RPCCmd::x_AssignOutputParams()
  445. {
  446.     char buffer[64];
  447.     for (unsigned int n = 0; n < m_Params.NofParams(); n++) {
  448.         if ((m_Params.GetParamStatus(n) & CDB_Params::fOutput) == 0)
  449.             continue;
  451.         const string& name  =  m_Params.GetParamName(n);
  452.         CDB_Object&   param = *m_Params.GetParam(n);
  453.         const char*   type;
  454.         string        cmd;
  456.         if (name.length() > kTDSMaxNameLen)
  457.             return false;
  459.         switch (param.GetType()) {
  460.         case eDB_Int:
  461.             type = "int";
  462.             break;
  463.         case eDB_SmallInt:
  464.             type = "smallint";
  465.             break;
  466.         case eDB_TinyInt:
  467.             type = "tinyint";
  468.             break;
  469.         case eDB_BigInt:
  470.             type = "numeric";
  471.             break;
  472.         case eDB_Char:
  473.         case eDB_VarChar:
  474.             type = "varchar(255)";
  475.             break;
  476. case eDB_LongChar: {
  477.     CDB_LongChar& lc = dynamic_cast<CDB_LongChar&> (param);
  478.     sprintf(buffer, "varchar(%d)", lc.Size());
  479.     type= buffer;
  480. break;
  481. }
  482.         case eDB_Binary:
  483.         case eDB_VarBinary:
  484.             type = "varbinary(255)";
  485.             break;
  486. case eDB_LongBinary: {
  487.     CDB_LongBinary& lb = dynamic_cast<CDB_LongBinary&> (param);
  488.     sprintf(buffer, "varbinary(%d)", lb.Size());
  489.     type= buffer;
  490. break;
  491. }
  492.         case eDB_Float:
  493.             type = "real";
  494.             break;
  495.         case eDB_Double:
  496.             type = "float";
  497.             break;
  498.         case eDB_SmallDateTime:
  499.             type = "smalldatetime";
  500.             break;
  501.         case eDB_DateTime:
  502.             type = "datetime";
  503.             break;            
  504.         default:
  505.             return false;
  506.         }
  508.         cmd += "declare " + name + ' ' + type + 'n';
  509.         if (!param.IsNULL()) {
  510.             cmd += "select " + name + " = ";
  511.             x_AddParamValue(cmd, param);
  512.             cmd+= 'n';
  513.         }
  515.         if (dbcmd(m_Cmd, (char*) cmd.c_str()) != SUCCEED)
  516.             return false;
  517.     }
  518.     return true;
  519. }
  521. bool CTDS_RPCCmd::x_AssignParams()
  522. {
  523.     for (unsigned int i = 0;  i < m_Params.NofParams();  i++) {
  524.       if(!m_Params.GetParamStatus(i)) continue;
  525.         CDB_Object& param = *m_Params.GetParam(i);
  526.         bool is_output =
  527.             (m_Params.GetParamStatus(i) & CDB_Params::fOutput) != 0;
  528.         const string& name  = m_Params.GetParamName(i);
  529.         string cmd= i? ", " : " ";
  531.         if(!name.empty()) {
  532.             cmd+= name + '=';
  533.             if(is_output) {
  534.                 cmd+= name + " out";
  535.             }
  536.             else {
  537.                 x_AddParamValue(cmd, param);
  538.             }
  539.         }
  540.         else {
  541.             x_AddParamValue(cmd, param);
  542.         }
  543.         if (dbcmd(m_Cmd, (char*) cmd.c_str()) != SUCCEED)
  544.             return false;
  545.     }
  546.     return true;
  547. }
  550. END_NCBI_SCOPE
  554. /*
  555.  * ===========================================================================
  556.  * $Log: rpc.cpp,v $
  557.  * Revision 1000.1  2004/06/01 19:20:58  gouriano
  558.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
  559.  *
  560.  * Revision 1.12  2004/05/17 21:13:37  gorelenk
  561.  * Added include of PCH ncbi_pch.hpp
  562.  *
  563.  * Revision 1.11  2003/08/13 18:04:05  soussov
  564.  * fixes copy/paste bug for DateTime
  565.  *
  566.  * Revision 1.10  2003/06/05 16:01:40  soussov
  567.  * adds code for DumpResults and for the dumped results processing
  568.  *
  569.  * Revision 1.9  2003/04/29 21:15:03  soussov
  570.  * new datatypes CDB_LongChar and CDB_LongBinary added
  571.  *
  572.  * Revision 1.8  2002/11/20 20:36:09  soussov
  573.  * fixed bug in parameters assignment
  574.  *
  575.  * Revision 1.7  2002/07/22 20:11:07  soussov
  576.  * fixes the RowCount calculations
  577.  *
  578.  * Revision 1.6  2002/02/22 22:12:45  soussov
  579.  * fixes bug with return params result
  580.  *
  581.  * Revision 1.5  2002/01/14 20:38:49  soussov
  582.  * timeout support for tds added
  583.  *
  584.  * Revision 1.4  2001/12/18 19:29:08  soussov
  585.  * adds conversion from nanosecs to milisecs for datetime args
  586.  *
  587.  * Revision 1.3  2001/12/18 16:42:44  soussov
  588.  * fixes bug in datetime argument processing
  589.  *
  590.  * Revision 1.2  2001/12/13 23:40:53  soussov
  591.  * changes double quotes to single quotes in SQL queries
  592.  *
  593.  * Revision 1.1  2001/10/25 00:39:22  vakatov
  594.  * Initial revision
  595.  *
  596.  * Revision 1.2  2001/10/22 16:28:02  lavr
  597.  * Default argument values removed
  598.  * (mistakenly left while moving code from header files)
  599.  *
  600.  * Revision 1.1  2001/10/22 15:19:56  lavr
  601.  * This is a major revamp (by Anton Lavrentiev, with help from Vladimir
  602.  * Soussov and Denis Vakatov) of the DBAPI "driver" libs originally
  603.  * written by Vladimir Soussov. The revamp follows the one of CTLib
  604.  * driver, and it involved massive code shuffling and grooming, numerous
  605.  * local API redesigns, adding comments and incorporating DBAPI to
  606.  * the C++ Toolkit.
  607.  *
  608.  * ===========================================================================
  609.  */