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

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

生物技术

开发平台：

C/C++

rpc.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: rpc.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:21:56  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.9
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: rpc.cpp,v 1000.3 2004/06/01 19:21:56 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:  ODBC RPC command
  38.  *
  39.  */
  40.  
  41. #include <ncbi_pch.hpp>
  42. #include <dbapi/driver/odbc/interfaces.hpp>
  43. #include <dbapi/driver/util/numeric_convert.hpp>
  45. #include <stdio.h>
  47. BEGIN_NCBI_SCOPE
  50. /////////////////////////////////////////////////////////////////////////////
  51. //
  52. //  CODBC_RPCCmd::
  53. //
  55. CODBC_RPCCmd::CODBC_RPCCmd(CODBC_Connection* con, SQLHSTMT cmd,
  56.                          const string& proc_name, unsigned int nof_params) :
  57.     m_Connect(con), m_Cmd(cmd), m_Query(proc_name), m_Params(nof_params),
  58.     m_WasSent(false), m_HasFailed(false), m_Recompile(false), m_Res(0),
  59.     m_RowCount(-1), m_Reporter(&con->m_MsgHandlers, SQL_HANDLE_STMT, cmd)
  60. {
  61.     return;
  62. }
  65. bool CODBC_RPCCmd::BindParam(const string& param_name,
  66.                             CDB_Object* param_ptr, bool out_param)
  67. {
  68.     return m_Params.BindParam(CDB_Params::kNoParamNumber, param_name,
  69.                               param_ptr, out_param);
  70. }
  73. bool CODBC_RPCCmd::SetParam(const string& param_name,
  74.                            CDB_Object* param_ptr, bool out_param)
  75. {
  76.     return m_Params.SetParam(CDB_Params::kNoParamNumber, param_name,
  77.                              param_ptr, out_param);
  78. }
  81. bool CODBC_RPCCmd::Send()
  82. {
  83.     if (m_WasSent)
  84.         Cancel();
  86.     m_HasFailed = false;
  87.     m_HasStatus = false;
  89.     // make a language command
  90.     string main_exec_query("declare @STpROCrETURNsTATUS int;nexec @STpROCrETURNsTATUS=");
  91.     main_exec_query+= m_Query;
  92.     string param_result_query;
  94.     CMemPot bindGuard;
  95.     string q_str;
  97. if(m_Params.NofParams() > 0) {
  98. SQLINTEGER* indicator= (SQLINTEGER*)
  99. bindGuard.Alloc(m_Params.NofParams()*sizeof(SQLINTEGER));
  101. if (!x_AssignParams(q_str, main_exec_query, param_result_query, 
  102.                           bindGuard, indicator)) {
  103. SQLFreeStmt(m_Cmd, SQL_RESET_PARAMS);
  104. m_HasFailed = true;
  105. throw CDB_ClientEx(eDB_Error, 420003, "CODBC_RPCCmd::Send",
  106.                            "cannot assign params");
  107. }
  108. }
  110.    if(m_Recompile) main_exec_query+= " with recompile";
  112.    q_str+= main_exec_query + ";nselect STpROCrETURNsTATUS=@STpROCrETURNsTATUS";
  113.    if(!param_result_query.empty()) {
  114.        q_str+= ";nselect " + param_result_query;
  115.    }
  117.     switch(SQLExecDirect(m_Cmd, (SQLCHAR*)q_str.c_str(), SQL_NTS)) {
  118.     case SQL_SUCCESS:
  119.         m_hasResults= true;
  120.         break;
  122.     case SQL_NO_DATA:
  123.         m_hasResults= true; /* this is a bug in SQLExecDirect it returns SQL_NO_DATA if
  124.                                status result is the only result of RPC */
  125.         m_RowCount= 0;
  126.         break;
  128.     case SQL_ERROR:
  129.         m_Reporter.ReportErrors();
  130.         SQLFreeStmt(m_Cmd, SQL_RESET_PARAMS);
  131.         m_HasFailed = true;
  132.         throw CDB_ClientEx(eDB_Fatal, 420001, "CODBC_RPCCmd::Send",
  133.                            "SQLExecDirect failed");
  135.     case SQL_SUCCESS_WITH_INFO:
  136.         m_Reporter.ReportErrors();
  137.         m_hasResults= true;
  138.         break;
  140.     case SQL_STILL_EXECUTING:
  141.         m_Reporter.ReportErrors();
  142.         SQLFreeStmt(m_Cmd, SQL_RESET_PARAMS);
  143.         m_HasFailed = true;
  144.         throw CDB_ClientEx(eDB_Fatal, 420002, "CODBC_RPCCmd::Send",
  145.                            "Some other query is executing on this connection");
  146.         
  147.     case SQL_INVALID_HANDLE:
  148.         m_HasFailed= true;
  149.         throw CDB_ClientEx(eDB_Fatal, 420004, "CODBC_RPCCmd::Send",
  150.                            "The statement handler is invalid (memory corruption suspected)");
  151.         
  152.     default:
  153.         m_Reporter.ReportErrors();
  154.         SQLFreeStmt(m_Cmd, SQL_RESET_PARAMS);
  155.         m_HasFailed = true;
  156.         throw CDB_ClientEx(eDB_Fatal, 420005, "CODBC_RPCCmd::Send",
  157.                            "Unexpected error");
  158.         
  159.     }
  160.     m_WasSent = true;
  161.     return true;
  162. }
  165. bool CODBC_RPCCmd::WasSent() const
  166. {
  167.     return m_WasSent;
  168. }
  171. bool CODBC_RPCCmd::Cancel()
  172. {
  173.     if (m_WasSent) {
  174.         if (m_Res) {
  175.             delete m_Res;
  176.             m_Res = 0;
  177.         }
  178.         m_WasSent = false;
  179.         switch(SQLFreeStmt(m_Cmd, SQL_CLOSE)) {
  180.         case SQL_SUCCESS_WITH_INFO: m_Reporter.ReportErrors();
  181.         case SQL_SUCCESS:           break;
  182.         case SQL_ERROR:             m_Reporter.ReportErrors();
  183.         default:                    return false;
  184.         }
  185.     }
  187.     SQLFreeStmt(m_Cmd, SQL_RESET_PARAMS);
  188.     m_Query.erase();
  189.     return true;
  190. }
  193. bool CODBC_RPCCmd::WasCanceled() const
  194. {
  195.     return !m_WasSent;
  196. }
  199. CDB_Result* CODBC_RPCCmd::Result()
  200. {
  201.     if (m_Res) {
  202.         delete m_Res;
  203.         m_Res = 0;
  204.         m_hasResults= xCheck4MoreResults();
  205.     }
  207.     if (!m_WasSent) {
  208.         throw CDB_ClientEx(eDB_Error, 420010, "CODBC_RPCCmd::Result",
  209.                            "a command has to be sent first");
  210.     }
  212.     if(!m_hasResults) {
  213. m_WasSent= false;
  214.         return 0;
  215.     }
  217.     SQLSMALLINT nof_cols= 0;
  218.     char n_buff[64];
  220.     while(m_hasResults) {
  221.         switch(SQLNumResultCols(m_Cmd, &nof_cols)) {
  222.         case SQL_SUCCESS_WITH_INFO:
  223.             m_Reporter.ReportErrors();
  225.         case SQL_SUCCESS:
  226.             break;
  228.         case SQL_ERROR:
  229.             m_Reporter.ReportErrors();
  230.             throw CDB_ClientEx(eDB_Error, 420011, "CODBC_RPCCmd::Result",
  231.                                "SQLNumResultCols failed");
  232.         default:
  233.             throw CDB_ClientEx(eDB_Error, 420012, "CODBC_RPCCmd::Result",
  234.                                "SQLNumResultCols failed (memory corruption suspected)");
  235.         }
  237.         if(nof_cols < 1) { // no data in this result set
  238. SQLINTEGER rc;
  239. switch(SQLRowCount(m_Cmd, &rc)) {
  240. case SQL_SUCCESS_WITH_INFO:
  241. m_Reporter.ReportErrors(); 
  242. case SQL_SUCCESS: break;
  243. case SQL_ERROR:
  244. m_Reporter.ReportErrors();
  245. throw CDB_ClientEx(eDB_Error, 420013, "CODBC_RPCCmd::Result",
  246.                                "SQLRowCount failed");
  247. default:
  248. throw CDB_ClientEx(eDB_Error, 420014, "CODBC_RPCCmd::Result",
  249. "SQLRowCount failed (memory corruption suspected)");
  250. }
  252.             m_RowCount = rc;
  253.             m_hasResults= xCheck4MoreResults();
  254.             continue;
  255.         }
  257.         if(nof_cols == 1) { // it could be a status result
  258.             SQLSMALLINT l;
  259.             switch(SQLColAttribute(m_Cmd, 1, SQL_DESC_LABEL, n_buff, 64, &l, 0)) {
  260.             case SQL_SUCCESS_WITH_INFO: m_Reporter.ReportErrors();
  261.             case SQL_SUCCESS:           break;
  262.             case SQL_ERROR:
  263.                 m_Reporter.ReportErrors();
  264.                 throw CDB_ClientEx(eDB_Error, 420015, "CODBC_RPCCmd::Result",
  265.                                    "SQLColAttribute failed");
  266.             default:
  267.                 throw CDB_ClientEx(eDB_Error, 420016, "CODBC_RPCCmd::Result",
  268.                                    "SQLColAttribute failed (memory corruption suspected)");
  269.             }
  270.             
  271.             if(strcmp(n_buff, "STpROCrETURNsTATUS") == 0) {//this is a status result
  272.                 m_HasStatus= true;
  273.                 m_Res= new CODBC_StatusResult(m_Cmd, m_Reporter);
  274.             }
  275.         }
  276. if(!m_Res) {
  277. if(m_HasStatus) {
  278. m_HasStatus= false;
  279. m_Res= new CODBC_ParamResult(nof_cols, m_Cmd, m_Reporter);
  280. }
  281. else {
  282. m_Res = new CODBC_RowResult(nof_cols, m_Cmd, m_Reporter);
  283. }
  284. }
  285. return Create_Result(*m_Res);
  286.     }
  288.     m_WasSent = false;
  289.     return 0;
  290. }
  293. bool CODBC_RPCCmd::HasMoreResults() const
  294. {
  295.     return m_hasResults;
  296. }
  298. void CODBC_RPCCmd::DumpResults()
  299. {
  300.     CDB_Result* dbres;
  301.     while(m_WasSent) {
  302.         dbres= Result();
  303.         if(dbres) {
  304.             if(m_Connect->m_ResProc) {
  305.                 m_Connect->m_ResProc->ProcessResult(*dbres);
  306.             }
  307.             else {
  308.                 while(dbres->Fetch());
  309.             }
  310.             delete dbres;
  311.         }
  312.     }
  313. }
  315. bool CODBC_RPCCmd::HasFailed() const
  316. {
  317.     return m_HasFailed;
  318. }
  321. int CODBC_RPCCmd::RowCount() const
  322. {
  323.     return m_RowCount;
  324. }
  327. void CODBC_RPCCmd::SetRecompile(bool recompile)
  328. {
  329.     m_Recompile = recompile;
  330. }
  333. void CODBC_RPCCmd::Release()
  334. {
  335.     m_BR = 0;
  336.     if (m_WasSent) {
  337.         Cancel();
  338.         m_WasSent = false;
  339.     }
  340.     m_Connect->DropCmd(*this);
  341.     delete this;
  342. }
  345. CODBC_RPCCmd::~CODBC_RPCCmd()
  346. {
  347.     if (m_BR)
  348.         *m_BR = 0;
  349.     if (m_WasSent)
  350.         Cancel();
  351.     SQLFreeHandle(SQL_HANDLE_STMT, m_Cmd);
  352. }
  355. bool CODBC_RPCCmd::x_AssignParams(string& cmd, string& q_exec, string& q_select,
  356.                                    CMemPot& bind_guard, SQLINTEGER* indicator)
  357. {
  358.     char p_nm[16], tbuf[32];
  359.     // check if we do have a named parameters (first named - all named)
  360.     bool param_named= !m_Params.GetParamName(0).empty();
  362.     for (unsigned int n = 0; n < m_Params.NofParams(); n++) {
  363.         if(m_Params.GetParamStatus(n) == 0) continue;
  364.         const string& name  =  m_Params.GetParamName(n);
  365.         CDB_Object&   param = *m_Params.GetParam(n);
  366.         const char*   type;
  368.         switch (param.GetType()) {
  369.         case eDB_Int: {
  370.             CDB_Int& val = dynamic_cast<CDB_Int&> (param);
  371.             type = "int";
  372.             indicator[n]= 4;
  373.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_SLONG, 
  374.                              SQL_INTEGER, 4, 0, val.BindVal(), 4, indicator+n);
  375.             break;
  376.         }
  377.         case eDB_SmallInt: {
  378.             CDB_SmallInt& val = dynamic_cast<CDB_SmallInt&> (param);
  379.             type = "smallint";
  380.             indicator[n]= 2;
  381.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_SSHORT, 
  382.                              SQL_SMALLINT, 2, 0, val.BindVal(), 2, indicator+n);
  383.             break;
  384.         }
  385.         case eDB_TinyInt: {
  386.             CDB_TinyInt& val = dynamic_cast<CDB_TinyInt&> (param);
  387.             type = "tinyint";
  388.             indicator[n]= 1;
  389.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_UTINYINT, 
  390.                              SQL_TINYINT, 1, 0, val.BindVal(), 1, indicator+n);
  391.             break;
  392.         }
  393.         case eDB_BigInt: {
  394.             CDB_BigInt& val = dynamic_cast<CDB_BigInt&> (param);
  395.             type = "numeric";
  396.             indicator[n]= 8;
  397.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_SBIGINT, 
  398.                              SQL_NUMERIC, 18, 0, val.BindVal(), 18, indicator+n);
  399.             
  400.             break;
  401.         }
  402.         case eDB_Char: {
  403.             CDB_Char& val = dynamic_cast<CDB_Char&> (param);
  404.             type= "varchar(255)";
  405.             indicator[n]= SQL_NTS;
  406.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_CHAR, 
  407.                              SQL_VARCHAR, 255, 0, (void*)val.Value(), 256, indicator+n);
  408.             break;
  409.         }
  410.         case eDB_VarChar: {
  411.             CDB_VarChar& val = dynamic_cast<CDB_VarChar&> (param);
  412.             type = "varchar(255)";
  413.             indicator[n]= SQL_NTS;
  414.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_CHAR, 
  415.                              SQL_VARCHAR, 255, 0, (void*)val.Value(), 256, indicator+n);
  416.             break;
  417.         }
  418.         case eDB_LongChar: {
  419.             CDB_LongChar& val = dynamic_cast<CDB_LongChar&> (param);
  420. sprintf(tbuf,"varchar(%d)", val.Size());
  421.             type= tbuf;
  422.             indicator[n]= SQL_NTS;
  423.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_CHAR, 
  424.                              SQL_VARCHAR, val.Size(), 0, (void*)val.Value(), val.Size(), indicator+n);
  425.             break;
  426.         }
  427.         case eDB_Binary: {
  428.             CDB_Binary& val = dynamic_cast<CDB_Binary&> (param);
  429.             type = "varbinary(255)";
  430.             indicator[n]= val.Size();
  431.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_BINARY, 
  432.                              SQL_VARBINARY, 255, 0, (void*)val.Value(), 255, indicator+n);
  433.             break;
  434.         }
  435.         case eDB_VarBinary: {
  436.             CDB_VarBinary& val = dynamic_cast<CDB_VarBinary&> (param);
  437.             type = "varbinary(255)";
  438.             indicator[n]= val.Size();
  439.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_BINARY, 
  440.                              SQL_VARBINARY, 255, 0, (void*)val.Value(), 255, indicator+n);
  441.             break;
  442.         }
  443.         case eDB_LongBinary: {
  444.             CDB_LongBinary& val = dynamic_cast<CDB_LongBinary&> (param);
  445. sprintf(tbuf,"varbinary(%d)", val.Size());
  446.             type= tbuf;
  447.             indicator[n]= val.DataSize();
  448.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_BINARY, 
  449.                              SQL_VARBINARY, val.Size(), 0, (void*)val.Value(), val.Size(), indicator+n);
  450.             break;
  451.         }
  452.         case eDB_Float: {
  453.             CDB_Float& val = dynamic_cast<CDB_Float&> (param);
  454.             type = "real";
  455.             indicator[n]= 4;
  456.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_FLOAT, 
  457.                              SQL_REAL, 4, 0, val.BindVal(), 4, indicator+n);
  458.             break;
  459.         }
  460.         case eDB_Double: {
  461.             CDB_Double& val = dynamic_cast<CDB_Double&> (param);
  462.             type = "float";
  463.             indicator[n]= 8;
  464.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_DOUBLE, 
  465.                              SQL_FLOAT, 8, 0, val.BindVal(), 8, indicator+n);
  466.             break;
  467.         }
  468.         case eDB_SmallDateTime: {
  469.             CDB_SmallDateTime& val = dynamic_cast<CDB_SmallDateTime&> (param);
  470.             type = "smalldatetime";
  471.             SQL_TIMESTAMP_STRUCT* ts= 0;
  472.             if(!val.IsNULL()) {
  473.                 ts= (SQL_TIMESTAMP_STRUCT*)bind_guard.Alloc(sizeof(SQL_TIMESTAMP_STRUCT));
  474.                 const CTime& t= val.Value();
  475.                 ts->year= t.Year();
  476.                 ts->month= t.Month();
  477.                 ts->day= t.Day();
  478.                 ts->hour= t.Hour();
  479.                 ts->minute= t.Minute();
  480.                 ts->second= 0;
  481.                 ts->fraction= 0;
  482.                 indicator[n]= sizeof(SQL_TIMESTAMP_STRUCT);
  483.             }
  484.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_TYPE_TIMESTAMP, 
  485.                              SQL_TYPE_TIMESTAMP, 16, 0, (void*)ts, sizeof(SQL_TIMESTAMP_STRUCT), 
  486.                              indicator+n);
  487.             break;
  488.         }
  489.         case eDB_DateTime: {
  490.             CDB_DateTime& val = dynamic_cast<CDB_DateTime&> (param);
  491.             type = "datetime";
  492.             SQL_TIMESTAMP_STRUCT* ts= 0;
  493.             if(!val.IsNULL()) {
  494.                 ts= (SQL_TIMESTAMP_STRUCT*)bind_guard.Alloc(sizeof(SQL_TIMESTAMP_STRUCT));
  495.                 const CTime& t= val.Value();
  496.                 ts->year= t.Year();
  497.                 ts->month= t.Month();
  498.                 ts->day= t.Day();
  499.                 ts->hour= t.Hour();
  500.                 ts->minute= t.Minute();
  501.                 ts->second= t.Second();
  502.                 ts->fraction= t.NanoSecond()/1000000;
  503. ts->fraction*= 1000000; /* MSSQL has a bug - it can not handle fraction of msecs */
  504.                 indicator[n]= sizeof(SQL_TIMESTAMP_STRUCT);
  505.             }
  506.             SQLBindParameter(m_Cmd, n+1, SQL_PARAM_INPUT, SQL_C_TYPE_TIMESTAMP, 
  507.                              SQL_TYPE_TIMESTAMP, 23, 3, ts, sizeof(SQL_TIMESTAMP_STRUCT), 
  508.                              indicator+n);
  509.             break;
  510.         }
  511.         default:
  512.             return false;
  513.         }
  515.         q_exec+= n? ',':' ';
  517.         if(!param_named) {
  518.             sprintf(p_nm, "@pR%d", n);
  519.             q_exec+= p_nm;
  520.             cmd+= "declare ";
  521. cmd+= p_nm;
  522. cmd+= ' ';
  523. cmd+= type;
  524. cmd+= ";select ";
  525. cmd+= p_nm;
  526. cmd+= " = ?;";
  527.         }
  528.         else {
  529.             q_exec+= name+'='+name;
  530.             cmd += "declare " + name + ' ' + type + ";select " + name + " = ?;";
  531.         }
  533.         if(param.IsNULL()) {
  534.             indicator[n]= SQL_NULL_DATA;
  535.         }
  537.         if ((m_Params.GetParamStatus(n) & CDB_Params::fOutput) != 0) {
  538.             q_exec+= " output";
  539.             const char* p_name= param_named? name.c_str() : p_nm;
  540.             if(!q_select.empty()) q_select+= ',';
  541.             q_select.append(p_name+1);
  542.             q_select+= '=';
  543. q_select+= p_name;
  544.         }
  545.             
  546.     }
  547.     return true;
  548. }
  550. bool CODBC_RPCCmd::xCheck4MoreResults()
  551. {
  552.     switch(SQLMoreResults(m_Cmd)) {
  553.     case SQL_SUCCESS_WITH_INFO: m_Reporter.ReportErrors();
  554.     case SQL_SUCCESS:           return true;
  555.     case SQL_NO_DATA:           return false;
  556.     case SQL_ERROR:             
  557.         m_Reporter.ReportErrors();
  558.         throw CDB_ClientEx(eDB_Error, 420014, "CODBC_RPCCmd::xCheck4MoreResults",
  559.                            "SQLMoreResults failed");
  560.     default:
  561.         throw CDB_ClientEx(eDB_Error, 420015, "CODBC_RPCCmd::xCheck4MoreResults",
  562.                            "SQLMoreResults failed (memory corruption suspected)");
  563.     }
  564. }
  566. END_NCBI_SCOPE
  570. /*
  571.  * ===========================================================================
  572.  * $Log: rpc.cpp,v $
  573.  * Revision 1000.3  2004/06/01 19:21:56  gouriano
  574.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.9
  575.  *
  576.  * Revision 1.9  2004/05/17 21:16:06  gorelenk
  577.  * Added include of PCH ncbi_pch.hpp
  578.  *
  579.  * Revision 1.8  2004/01/27 18:00:07  soussov
  580.  * patches the SQLExecDirect bug
  581.  *
  582.  * Revision 1.7  2003/11/07 17:14:20  soussov
  583.  * work around the odbc bug. It can not handle properly the fractions of msecs
  584.  *
  585.  * Revision 1.6  2003/11/06 20:33:32  soussov
  586.  * fixed bug in DateTime bindings
  587.  *
  588.  * Revision 1.5  2003/06/05 16:02:04  soussov
  589.  * adds code for DumpResults and for the dumped results processing
  590.  *
  591.  * Revision 1.4  2003/05/16 20:26:44  soussov
  592.  * adds code to skip parameter if it was not set
  593.  *
  594.  * Revision 1.3  2003/05/08 20:30:24  soussov
  595.  * CDB_LongChar CDB_LongBinary added
  596.  *
  597.  * Revision 1.2  2003/05/05 20:48:47  ucko
  598.  * +<stdio.h> for sprintf
  599.  *
  600.  * Revision 1.1  2002/06/18 22:06:25  soussov
  601.  * initial commit
  602.  *
  603.  *
  604.  * ===========================================================================
  605.  */