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

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

生物技术

开发平台：

C/C++

result.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: result.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:19:47  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.18
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: result.cpp,v 1000.1 2004/06/01 19:19:47 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 Results
  38.  *
  39.  */
  42. #include <ncbi_pch.hpp>
  43. #include <dbapi/driver/ctlib/interfaces.hpp>
  44. #include <dbapi/driver/util/numeric_convert.hpp>
  47. BEGIN_NCBI_SCOPE
  50. /////////////////////////////////////////////////////////////////////////////
  51. //
  52. //  CTL_RowResult::
  53. //
  56. CTL_RowResult::CTL_RowResult(CS_COMMAND* cmd)
  57.     : m_Cmd(cmd),
  58.       m_CurrItem(-1),
  59.       m_EOR(false)
  60. {
  61.     CS_INT outlen;
  63.     CS_INT nof_cols;
  64.     if (ct_res_info(m_Cmd, CS_NUMDATA, &nof_cols, CS_UNUSED, &outlen)
  65.         != CS_SUCCEED) {
  66.         throw CDB_ClientEx(eDB_Error, 130001, "::CTL_RowResult",
  67.                            "ct_res_info(CS_NUMDATA) failed");
  68.     }
  69.     m_NofCols = nof_cols;
  71.     CS_INT cmd_num;
  72.     if (ct_res_info(m_Cmd, CS_CMD_NUMBER, &cmd_num, CS_UNUSED, &outlen)
  73.         != CS_SUCCEED) {
  74.         throw CDB_ClientEx(eDB_Error, 130001, "::CTL_RowResult",
  75.                            "ct_res_info(CS_CMD_NUMBER) failed");
  76.     }
  77.     m_CmdNum = cmd_num;
  79. CS_INT bind_len= 0;
  80. m_BindedCols= 0;
  82.     m_ColFmt = new CS_DATAFMT[m_NofCols];
  83.     for (unsigned int nof_items = 0;  nof_items < m_NofCols;  nof_items++) {
  84.         if (ct_describe(m_Cmd, (CS_INT) nof_items + 1, &m_ColFmt[nof_items])
  85.             != CS_SUCCEED) {
  86.             throw CDB_ClientEx(eDB_Error, 130002, "::CTL_RowResult",
  87.                                "ct_describe failed");
  88.         }
  89. bind_len+= m_ColFmt[nof_items].maxlength;
  90. if(bind_len <= 2048) m_BindedCols++;
  91.     }
  92. if(m_BindedCols) {
  93.     m_BindItem= new CS_VOID*[m_BindedCols];
  94. m_Copied= new CS_INT[m_BindedCols];
  95. m_Indicator= new CS_SMALLINT[m_BindedCols];
  96. for(int i= 0; i < m_BindedCols; i++) {
  97.   m_BindItem[i]= i? ((unsigned char*)(m_BindItem[i-1])) + m_ColFmt[i-1].maxlength : m_BindBuff;
  98.   if(ct_bind(m_Cmd, i+1, &m_ColFmt[i], m_BindItem[i], &m_Copied[i], &m_Indicator[i]) 
  99.  != CS_SUCCEED) {
  100.             throw CDB_ClientEx(eDB_Error, 130042, "::CTL_RowResult",
  101.                                "ct_bind failed");
  102.   }
  103. }
  104. }
  105. }
  108. EDB_ResType CTL_RowResult::ResultType() const
  109. {
  110.     return eDB_RowResult;
  111. }
  114. unsigned int CTL_RowResult::NofItems() const
  115. {
  116.     return m_NofCols;
  117. }
  120. const char* CTL_RowResult::ItemName(unsigned int item_num) const
  121. {
  122.     return (item_num < m_NofCols  &&  m_ColFmt[item_num].namelen > 0)
  123.         ? m_ColFmt[item_num].name : 0;
  124. }
  127. size_t CTL_RowResult::ItemMaxSize(unsigned int item_num) const
  128. {
  129.     return (item_num < m_NofCols) ? m_ColFmt[item_num].maxlength : 0;
  130. }
  133. EDB_Type CTL_RowResult::ItemDataType(unsigned int item_num) const
  134. {
  135.     if (item_num >= m_NofCols) {
  136.         return eDB_UnsupportedType;
  137.     }
  139.     const CS_DATAFMT& fmt = m_ColFmt[item_num];
  140.     switch ( fmt.datatype ) {
  141.     case CS_BINARY_TYPE:    return eDB_VarBinary;
  142.     case CS_BIT_TYPE:       return eDB_Bit;
  143.     case CS_CHAR_TYPE:      return eDB_VarChar;
  144.     case CS_DATETIME_TYPE:  return eDB_DateTime;
  145.     case CS_DATETIME4_TYPE: return eDB_SmallDateTime;
  146.     case CS_TINYINT_TYPE:   return eDB_TinyInt;
  147.     case CS_SMALLINT_TYPE:  return eDB_SmallInt;
  148.     case CS_INT_TYPE:       return eDB_Int;
  149.     case CS_DECIMAL_TYPE:
  150.     case CS_NUMERIC_TYPE:   return (fmt.scale == 0  &&  fmt.precision < 20)
  151.                                 ? eDB_BigInt : eDB_Numeric;
  152.     case CS_FLOAT_TYPE:     return eDB_Double;
  153.     case CS_REAL_TYPE:      return eDB_Float;
  154.     case CS_TEXT_TYPE:      return eDB_Text;
  155.     case CS_IMAGE_TYPE:     return eDB_Image;
  156. case CS_LONGCHAR_TYPE:  return eDB_LongChar;
  157. case CS_LONGBINARY_TYPE: return eDB_LongBinary;
  158.     }
  160.     return eDB_UnsupportedType;
  161. }
  164. bool CTL_RowResult::Fetch()
  165. {
  166.     m_CurrItem = -1;
  167.     if ( m_EOR ) {
  168.         return false;
  169.     }
  171.     switch ( ct_fetch(m_Cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, 0) ) {
  172.     case CS_SUCCEED:
  173.         m_CurrItem = 0;
  174.         return true;
  175.     case CS_END_DATA:
  176.         m_EOR = true;
  177.         return false;
  178.     case CS_ROW_FAIL:
  179.         throw CDB_ClientEx(eDB_Error, 130003, "CTL_RowResult::Fetch",
  180.                            "error while fetching the row");
  181.     case CS_FAIL:
  182.         throw CDB_ClientEx(eDB_Error, 130006, "CTL_RowResult::Fetch",
  183.                            "ct_fetch has failed. "
  184.                            "You need to cancel the command");
  185.     case CS_CANCELED:
  186.         throw CDB_ClientEx(eDB_Error, 130004, "CTL_RowResult::Fetch",
  187.                            "the command has been canceled");
  188.     default:
  189.         throw CDB_ClientEx(eDB_Error, 130005, "CTL_RowResult::Fetch",
  190.                            "the connection is busy");
  191.     }
  192. }
  195. int CTL_RowResult::CurrentItemNo() const
  196. {
  197.     return m_CurrItem;
  198. }
  200. CS_RETCODE CTL_RowResult::my_ct_get_data(CS_COMMAND* cmd, CS_INT item, 
  201.  CS_VOID* buffer, 
  202.  CS_INT buflen, CS_INT *outlen)
  203. {
  204.   if(item > m_BindedCols)
  205. return ct_get_data(cmd, item, buffer, buflen, outlen);
  207.   --item;
  209.   if((m_Indicator[item] < 0) || ((CS_INT)m_Indicator[item] >= m_Copied[item])) {
  210. if(outlen) *outlen= 0;
  211. return CS_END_ITEM;
  212.   }
  214.   if(!buffer || (buflen < 1)) return CS_SUCCEED;
  216.   CS_INT n= m_Copied[item] - m_Indicator[item];
  217.   if(buflen > n) buflen= n;
  218.   memcpy(buffer, (char*)(m_BindItem[item]) + m_Indicator[item], buflen);
  219.   if(outlen) *outlen= buflen;
  220.   m_Indicator[item]+= buflen;
  221.   return (n == buflen)? CS_END_ITEM : CS_SUCCEED;
  222. }
  224. // Aux. for CTL_RowResult::GetItem()
  225. CDB_Object* CTL_RowResult::s_GetItem(CS_COMMAND* cmd, CS_INT item_no, CS_DATAFMT& fmt,
  226.  CDB_Object* item_buf)
  227. {
  228.     CS_INT outlen = 0;
  229.     char buffer[2048];
  230.     EDB_Type b_type = item_buf ? item_buf->GetType() : eDB_UnsupportedType;
  232.     switch ( fmt.datatype ) {
  233.     case CS_BINARY_TYPE: {
  234.         if (item_buf  &&
  235.             b_type != eDB_VarBinary  &&  b_type != eDB_Binary  &&
  236.             b_type != eDB_VarChar    &&  b_type != eDB_Char &&
  237. b_type != eDB_LongChar   &&  b_type != eDB_LongBinary) {
  238.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  239.                                "Wrong type of CDB_Object");
  240.         }
  242.         char* v = (fmt.maxlength < (CS_INT) sizeof(buffer))
  243.             ? buffer : new char[fmt.maxlength + 1];
  245.         switch ( my_ct_get_data(cmd, item_no, v, fmt.maxlength, &outlen) ) {
  246.         case CS_SUCCEED:
  247.         case CS_END_ITEM:
  248.         case CS_END_DATA: {
  249.             if ( item_buf ) {
  250.                 switch ( b_type ) {
  251.                 case eDB_VarBinary:
  252.                     ((CDB_VarBinary*) item_buf)->SetValue(v, outlen);
  253.                     break;
  254.                 case eDB_Binary:
  255.                     ((CDB_Binary*)    item_buf)->SetValue(v, outlen);
  256.                     break;
  257.                 case eDB_VarChar:
  258.                     v[outlen] = '';
  259.                     *((CDB_VarChar*)  item_buf) = v;
  260.                     break;
  261.                 case eDB_Char:
  262.                     v[outlen] = '';
  263.                     *((CDB_Char*)     item_buf) = v;
  264.                     break;
  265.                 case eDB_LongChar:
  266.                     v[outlen] = '';
  267.                     *((CDB_LongChar*)     item_buf) = v;
  268.                     break;
  269.                 case eDB_LongBinary:
  270.                     ((CDB_LongBinary*)     item_buf)->SetValue(v, outlen);
  271.                     break;
  272.                 default:
  273.                     break;
  274.                 }
  276.                 if (v != buffer)  delete[] v;
  277.                 return item_buf;
  278.             }
  280.             CDB_VarBinary* val = (outlen == 0)
  281.                 ? new CDB_VarBinary() : new CDB_VarBinary(v, outlen);
  283.             if ( v != buffer)  delete[] v;
  284.             return val;
  285.         }
  286.         case CS_CANCELED:
  287.             if (v != buffer)  delete[] v;
  288.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  289.                                "the command has been canceled");
  290.         default:
  291.             if (v != buffer)  delete[] v;
  292.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  293.                                "ct_get_data failed");
  294.         }
  295.     }
  297.     case CS_LONGBINARY_TYPE: {
  298.         if (item_buf  &&
  299. b_type != eDB_LongChar   &&  b_type != eDB_LongBinary) {
  300.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  301.                                "Wrong type of CDB_Object");
  302.         }
  304.         char* v = (fmt.maxlength < (CS_INT) sizeof(buffer))
  305.             ? buffer : new char[fmt.maxlength + 1];
  307.         switch ( my_ct_get_data(cmd, item_no, v, fmt.maxlength, &outlen) ) {
  308.         case CS_SUCCEED:
  309.         case CS_END_ITEM:
  310.         case CS_END_DATA: {
  311.             if ( item_buf ) {
  312.                 switch ( b_type ) {
  313.                 case eDB_LongBinary:
  314.                     ((CDB_LongBinary*) item_buf)->SetValue(v, outlen);
  315.                     break;
  316. case eDB_LongChar:
  317.                     v[outlen] = '';
  318.                     *((CDB_LongChar*)     item_buf) = v;
  319.                 default:
  320.                     break;
  321.                 }
  323.                 if (v != buffer)  delete[] v;
  324.                 return item_buf;
  325.             }
  327.             CDB_LongBinary* val = (outlen == 0)
  328.                 ? new CDB_LongBinary(fmt.maxlength) : 
  329.       new CDB_LongBinary(fmt.maxlength, v, outlen);
  331.             if ( v != buffer)  delete[] v;
  332.             return val;
  333.         }
  334.         case CS_CANCELED:
  335.             if (v != buffer)  delete[] v;
  336.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  337.                                "the command has been canceled");
  338.         default:
  339.             if (v != buffer)  delete[] v;
  340.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  341.                                "ct_get_data failed");
  342.         }
  343.     }
  345.     case CS_BIT_TYPE: {
  346.         if (item_buf  &&
  347.             b_type != eDB_Bit       &&  b_type != eDB_TinyInt  &&
  348.             b_type != eDB_SmallInt  &&  b_type != eDB_Int) {
  349.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  350.                                "Wrong type of CDB_Object");
  351.         }
  353.         CS_BIT v;
  354.         switch ( my_ct_get_data(cmd, item_no, &v, (CS_INT) sizeof(v), &outlen) ) {
  355.         case CS_SUCCEED:
  356.         case CS_END_ITEM:
  357.         case CS_END_DATA: {
  358.             if ( item_buf ) {
  359.                 if (outlen == 0) {
  360.                     item_buf->AssignNULL();
  361.                 }
  362.                 else {
  363.                     switch ( b_type ) {
  364.                     case eDB_Bit:
  365.                         *((CDB_Bit*)      item_buf) = (int) v;
  366.                         break;
  367.                     case eDB_TinyInt:
  368.                         *((CDB_TinyInt*)  item_buf) = v ? 1 : 0;
  369.                         break;
  370.                     case eDB_SmallInt:
  371.                         *((CDB_SmallInt*) item_buf) = v ? 1 : 0;
  372.                         break;
  373.                     case eDB_Int:
  374.                         *((CDB_Int*)      item_buf) = v ? 1 : 0;
  375.                         break;
  376.                     default:
  377.                         break;
  378.                     }
  379.                 }
  380.                 return item_buf;
  381.             }
  383.             return (outlen == 0) ? new CDB_Bit() : new CDB_Bit((int) v);
  384.         }
  385.         case CS_CANCELED: {
  386.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  387.                                "the command has been canceled");
  388.         }
  389.         default: {
  390.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  391.                                "ct_get_data failed");
  392.         }
  393.         }
  394.     }
  396.     case CS_CHAR_TYPE: {
  397.         if (item_buf  &&
  398.             b_type != eDB_VarBinary  &&  b_type != eDB_Binary  &&
  399.             b_type != eDB_VarChar    &&  b_type != eDB_Char &&
  400. b_type != eDB_LongChar   &&  b_type != eDB_LongBinary) {
  401.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  402.                                "Wrong type of CDB_Object");
  403.         }
  405.         char* v = fmt.maxlength < 2048
  406.             ? buffer : new char[fmt.maxlength + 1];
  407.         switch ( my_ct_get_data(cmd, item_no, v, fmt.maxlength, &outlen) ) {
  408.         case CS_SUCCEED:
  409.         case CS_END_ITEM:
  410.         case CS_END_DATA: {
  411.             v[outlen] = '';
  412.             if ( item_buf) {
  413.                 if ( outlen <= 0) {
  414.                     item_buf->AssignNULL();
  415.                 }
  416.                 else {
  417.                     switch ( b_type ) {
  418.                     case eDB_VarChar:
  419.                         *((CDB_VarChar*)  item_buf) = v;
  420.                         break;
  421.                     case eDB_Char:
  422.                         *((CDB_Char*)     item_buf) = v;
  423.                         break;
  424.                     case eDB_LongChar:
  425.                         *((CDB_LongChar*)     item_buf) = v;
  426.                         break;
  427.                     case eDB_VarBinary:
  428.                         ((CDB_VarBinary*) item_buf)->SetValue(v, outlen);
  429.                         break;
  430.                     case eDB_Binary:
  431.                         ((CDB_Binary*)    item_buf)->SetValue(v, outlen);
  432.                         break;
  433.                     case eDB_LongBinary:
  434.                         ((CDB_LongBinary*)    item_buf)->SetValue(v, outlen);
  435.                         break;
  436.                     default:
  437.                         break;
  438.                     }
  439.                 }
  441.                 if ( v != buffer) delete[] v;
  442.                 return item_buf;
  443.             }
  445.             CDB_VarChar* val = (outlen == 0)
  446.                 ? new CDB_VarChar() : new CDB_VarChar(v, (size_t) outlen);
  448.             if (v != buffer) delete[] v;
  449.             return val;
  450.         }
  451.         case CS_CANCELED: {
  452.             if (v != buffer) delete[] v;
  453.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  454.                                "the command has been canceled");
  455.         }
  456.         default: {
  457.             if (v != buffer) delete[] v;
  458.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  459.                                "ct_get_data failed");
  460.         }
  461.         }
  462.     }
  464.     case CS_LONGCHAR_TYPE: {
  465.         if (item_buf  &&
  466. b_type != eDB_LongChar   &&  b_type != eDB_LongBinary) {
  467.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  468.                                "Wrong type of CDB_Object");
  469.         }
  471.         char* v = fmt.maxlength < 2048
  472.             ? buffer : new char[fmt.maxlength + 1];
  473.         switch ( my_ct_get_data(cmd, item_no, v, fmt.maxlength, &outlen) ) {
  474.         case CS_SUCCEED:
  475.         case CS_END_ITEM:
  476.         case CS_END_DATA: {
  477.             v[outlen] = '';
  478.             if ( item_buf) {
  479.                 if ( outlen <= 0) {
  480.                     item_buf->AssignNULL();
  481.                 }
  482.                 else {
  483.                     switch ( b_type ) {
  484.                     case eDB_LongChar:
  485.                         *((CDB_LongChar*)     item_buf) = v;
  486.                         break;
  487.                     case eDB_LongBinary:
  488.                         ((CDB_LongBinary*)    item_buf)->SetValue(v, outlen);
  489.                         break;
  490.                     default:
  491.                         break;
  492.                     }
  493.                 }
  495.                 if ( v != buffer) delete[] v;
  496.                 return item_buf;
  497.             }
  499.             CDB_LongChar* val = (outlen == 0)
  500.                 ? new CDB_LongChar(fmt.maxlength) : new CDB_LongChar((size_t) outlen, v);
  502.             if (v != buffer) delete[] v;
  503.             return val;
  504.         }
  505.         case CS_CANCELED: {
  506.             if (v != buffer) delete[] v;
  507.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  508.                                "the command has been canceled");
  509.         }
  510.         default: {
  511.             if (v != buffer) delete[] v;
  512.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  513.                                "ct_get_data failed");
  514.         }
  515.         }
  516.     }
  518.     case CS_DATETIME_TYPE: {
  519.         if (item_buf  &&  b_type != eDB_DateTime) {
  520.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  521.                                "Wrong type of CDB_Object");
  522.         }
  524.         CS_DATETIME v;
  525.         switch ( my_ct_get_data(cmd, item_no, &v, (CS_INT) sizeof(v), &outlen) ) {
  526.         case CS_SUCCEED:
  527.         case CS_END_ITEM:
  528.         case CS_END_DATA: {
  529.             if ( item_buf) {
  530.                 if ( outlen > 0) {
  531.                     ((CDB_DateTime*)item_buf)->Assign(v.dtdays, v.dttime);
  532.                 }
  533.                 else {
  534.                     item_buf->AssignNULL();
  535.                 }
  536.                 return item_buf;
  537.             }
  539.             CDB_DateTime* val;
  540.             if ( outlen > 0) {
  541.                 val = new CDB_DateTime(v.dtdays, v.dttime);
  542.             } else {
  543.                 val = new CDB_DateTime;
  544.             }
  546.             return val;
  547.         }
  548.         case CS_CANCELED: {
  549.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  550.                                "the command has been canceled");
  551.         }
  552.         default: {
  553.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  554.                                "ct_get_data failed");
  555.         }
  556.         }
  557.     }
  559.     case CS_DATETIME4_TYPE:  {
  560.         if (item_buf  &&
  561.             b_type != eDB_SmallDateTime  &&  b_type != eDB_DateTime) {
  562.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  563.                                "Wrong type of CDB_Object");
  564.         }
  566.         CS_DATETIME4 v;
  567.         switch ( my_ct_get_data(cmd, item_no, &v, (CS_INT) sizeof(v), &outlen) ) {
  568.         case CS_SUCCEED:
  569.         case CS_END_ITEM:
  570.         case CS_END_DATA: {
  571.             if ( item_buf) {
  572.                 if (outlen > 0) {
  573.                     switch ( b_type ) {
  574.                     case eDB_SmallDateTime:
  575.                         ((CDB_SmallDateTime*) item_buf)->Assign
  576.                             (v.days, v.minutes);
  577.                         break;
  578.                     case eDB_DateTime:
  579.                         ((CDB_DateTime*)      item_buf)->Assign
  580.                             (v.days, v.minutes * 60 * 300);
  581.                         break;
  582.                     default:
  583.                         break;
  584.                     }
  585.                 }
  586.                 else {
  587.                     item_buf->AssignNULL();
  588.                 }
  589.                 return item_buf;
  590.             }
  592.             return (outlen <= 0)
  593.                 ? new CDB_SmallDateTime
  594.                 : new CDB_SmallDateTime(v.days, v.minutes);
  595.         }
  596.         case CS_CANCELED: {
  597.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  598.                                "the command has been canceled");
  599.         }
  600.         default: {
  601.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  602.                                "ct_get_data failed");
  603.         }
  604.         }
  605.     }
  607.     case CS_TINYINT_TYPE: {
  608.         if (item_buf  &&
  609.             b_type != eDB_TinyInt  &&  b_type != eDB_SmallInt  &&
  610.             b_type != eDB_Int) {
  611.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  612.                                "Wrong type of CDB_Object");
  613.         }
  615.         CS_TINYINT v;
  616.         switch ( my_ct_get_data(cmd, item_no, &v, (CS_INT) sizeof(v), &outlen) ) {
  617.         case CS_SUCCEED:
  618.         case CS_END_ITEM:
  619.         case CS_END_DATA: {
  620.             if ( item_buf ) {
  621.                 if (outlen == 0) {
  622.                     item_buf->AssignNULL();
  623.                 }
  624.                 else {
  625.                     switch ( b_type ) {
  626.                     case eDB_TinyInt:
  627.                         *((CDB_TinyInt*)  item_buf) = (Uint1) v;
  628.                         break;
  629.                     case eDB_SmallInt:
  630.                         *((CDB_SmallInt*) item_buf) = (Int2) v;
  631.                         break;
  632.                     case eDB_Int:
  633.                         *((CDB_Int*)      item_buf) = (Int4) v;
  634.                         break;
  635.                     default:
  636.                         break;
  637.                     }
  638.                 }
  639.                 return item_buf;
  640.             }
  642.             return (outlen == 0)
  643.                 ? new CDB_TinyInt() : new CDB_TinyInt((Uint1) v);
  644.         }
  645.         case CS_CANCELED: {
  646.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  647.                                "the command has been canceled");
  648.         }
  649.         default: {
  650.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  651.                                "ct_get_data failed");
  652.         }
  653.         }
  654.     }
  656.     case CS_SMALLINT_TYPE: {
  657.         if (item_buf  &&
  658.             b_type != eDB_SmallInt  &&  b_type != eDB_Int) {
  659.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  660.                                "Wrong type of CDB_Object");
  661.         }
  663.         CS_SMALLINT v;
  664.         switch ( my_ct_get_data(cmd, item_no, &v, (CS_INT) sizeof(v), &outlen) ) {
  665.         case CS_SUCCEED:
  666.         case CS_END_ITEM:
  667.         case CS_END_DATA: {
  668.             if ( item_buf ) {
  669.                 if (outlen == 0) {
  670.                     item_buf->AssignNULL();
  671.                 }
  672.                 else {
  673.                     switch ( b_type ) {
  674.                     case eDB_SmallInt:
  675.                         *((CDB_SmallInt*) item_buf) = (Int2) v;
  676.                         break;
  677.                     case eDB_Int:
  678.                         *((CDB_Int*)      item_buf) = (Int4) v;
  679.                         break;
  680.                     default:
  681.                         break;
  682.                     }
  683.                 }
  684.                 return item_buf;
  685.             }
  687.             return (outlen == 0)
  688.                 ? new CDB_SmallInt() : new CDB_SmallInt((Int2) v);
  689.         }
  690.         case CS_CANCELED: {
  691.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  692.                                "the command has been canceled");
  693.         }
  694.         default: {
  695.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  696.                                "ct_get_data failed");
  697.         }
  698.         }
  699.     }
  701.     case CS_INT_TYPE: {
  702.         if (item_buf  &&  b_type != eDB_Int) {
  703.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  704.                                "Wrong type of CDB_Object");
  705.         }
  707.         CS_INT v;
  708.         switch ( my_ct_get_data(cmd, item_no, &v, (CS_INT) sizeof(v), &outlen) ) {
  709.         case CS_SUCCEED:
  710.         case CS_END_ITEM:
  711.         case CS_END_DATA: {
  712.             if ( item_buf ) {
  713.                 if (outlen == 0) {
  714.                     item_buf->AssignNULL();
  715.                 }
  716.                 else {
  717.                     *((CDB_Int*) item_buf) = (Int4) v;
  718.                 }
  719.                 return item_buf;
  720.             }
  722.             return (outlen == 0) ? new CDB_Int() : new CDB_Int((Int4) v);
  723.         }
  724.         case CS_CANCELED: {
  725.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  726.                                "the command has been canceled");
  727.         }
  728.         default: {
  729.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  730.                                "ct_get_data failed");
  731.         }
  732.         }
  733.     }
  735.     case CS_DECIMAL_TYPE:
  736.     case CS_NUMERIC_TYPE: {
  737.         if (item_buf  &&  b_type != eDB_BigInt  &&  b_type != eDB_Numeric) {
  738.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  739.                                "Wrong type of CDB_Object");
  740.         }
  742.         CS_NUMERIC v;
  743.         switch ( my_ct_get_data(cmd, item_no, &v, (CS_INT) sizeof(v), &outlen) ) {
  744.         case CS_SUCCEED:
  745.         case CS_END_ITEM:
  746.         case CS_END_DATA: {
  747.             if ( item_buf ) {
  748.                 if (outlen < 3) { /* it used to be == 0 but ctlib on windows
  749.      returns 2 even for NULL numeric */
  750.                     item_buf->AssignNULL();
  751.                 }
  752.                 else {
  753.                     if (b_type == eDB_Numeric) {
  754.                         ((CDB_Numeric*) item_buf)->Assign
  755.                             ((unsigned int)         v.precision,
  756.                              (unsigned int)         v.scale,
  757.                              (const unsigned char*) v.array);
  758.                     }
  759.                     else {
  760.                         *((CDB_BigInt*) item_buf) =
  761.                             numeric_to_longlong((unsigned int)
  762.                                                 v.precision, v.array);
  763.                     }
  764.                 }
  765.                 return item_buf;
  766.             }
  768.             if (fmt.scale == 0  &&  fmt.precision < 20) {
  769.                 return (outlen == 0)
  770.                     ? new CDB_BigInt
  771.                     : new CDB_BigInt(numeric_to_longlong((unsigned int)
  772.                                                          v.precision,v.array));
  773.             } else {
  774.                 return  (outlen == 0)
  775.                     ? new CDB_Numeric
  776.                     : new CDB_Numeric((unsigned int)         v.precision,
  777.                                       (unsigned int)         v.scale,
  778.                                       (const unsigned char*) v.array);
  779.             }
  780.         }
  781.         case CS_CANCELED: {
  782.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  783.                                "the command has been canceled");
  784.         }
  785.         default: {
  786.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  787.                                "ct_get_data failed");
  788.         }
  789.         }
  790.     }
  792.     case CS_FLOAT_TYPE: {
  793.         if (item_buf  &&  b_type != eDB_Double) {
  794.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  795.                                "Wrong type of CDB_Object");
  796.         }
  798.         CS_FLOAT v;
  799.         switch ( my_ct_get_data(cmd, item_no, &v, (CS_INT) sizeof(v), &outlen) ) {
  800.         case CS_SUCCEED:
  801.         case CS_END_ITEM:
  802.         case CS_END_DATA: {
  803.             if ( item_buf ) {
  804.                 if (outlen == 0) {
  805.                     item_buf->AssignNULL();
  806.                 }
  807.                 else {
  808.                     *((CDB_Double*) item_buf) = (double) v;
  809.                 }
  810.                 return item_buf;
  811.             }
  813.             return (outlen == 0)
  814.                 ? new CDB_Double() : new CDB_Double((double) v);
  815.         }
  816.         case CS_CANCELED: {
  817.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  818.                                "the command has been canceled");
  819.         }
  820.         default: {
  821.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  822.                                "ct_get_data failed");
  823.         }
  824.         }
  825.     }
  827.     case CS_REAL_TYPE: {
  828.         if (item_buf  &&  b_type != eDB_Float) {
  829.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  830.                                "Wrong type of CDB_Object");
  831.         }
  833.         CS_REAL v;
  834.         switch ( my_ct_get_data(cmd, item_no, &v, (CS_INT) sizeof(v), &outlen) ) {
  835.         case CS_SUCCEED:
  836.         case CS_END_ITEM:
  837.         case CS_END_DATA: {
  838.             if ( item_buf ) {
  839.                 if (outlen == 0) {
  840.                     item_buf->AssignNULL();
  841.                 }
  842.                 else {
  843.                     *((CDB_Float*) item_buf) = (float) v;
  844.                 }
  845.                 return item_buf;
  846.             }
  848.             return (outlen == 0) ? new CDB_Float() : new CDB_Float((float) v);
  849.         }
  850.         case CS_CANCELED: {
  851.             throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  852.                                "the command has been canceled");
  853.         }
  854.         default: {
  855.             throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  856.                                "ct_get_data failed");
  857.         }
  858.         }
  859.     }
  861.     case CS_TEXT_TYPE:
  862.     case CS_IMAGE_TYPE: {
  863.        if (item_buf  &&  b_type != eDB_Text  &&  b_type != eDB_Image) {
  864.             throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
  865.                                "Wrong type of CDB_Object");
  866.         }
  868.         CDB_Stream* val =
  869.             item_buf                         ? (CDB_Stream*) item_buf
  870.             : (fmt.datatype == CS_TEXT_TYPE) ? (CDB_Stream*) new CDB_Text
  871.             :                                  (CDB_Stream*) new CDB_Image;
  873.         for (;;) {
  874.             switch ( my_ct_get_data(cmd, item_no, buffer, 2048, &outlen) ) {
  875.             case CS_SUCCEED:
  876.                 if (outlen != 0)
  877.                     val->Append(buffer, outlen);
  878.                 continue;
  879.             case CS_END_ITEM:
  880.             case CS_END_DATA:
  881.                 if (outlen != 0)
  882.                     val->Append(buffer, outlen);
  883.                 return val;
  884.             case CS_CANCELED:
  885.                 throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  886.                                    "the command has been canceled");
  887.             default:
  888.                 throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
  889.                                    "ct_get_data failed");
  890.             }
  891.         }
  892.     }
  894.     default: {
  895.         throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
  896.                            "unexpected result type");
  897.     }
  898.     }
  899. }
  902. CDB_Object* CTL_RowResult::GetItem(CDB_Object* item_buf)
  903. {
  904.     if ((unsigned int) m_CurrItem >= m_NofCols  ||  m_CurrItem == -1) {
  905.         return 0;
  906.     }
  908.     CDB_Object* item = s_GetItem(m_Cmd, m_CurrItem + 1, m_ColFmt[m_CurrItem],
  909.                                  item_buf);
  911.     ++m_CurrItem;
  912.     return item;
  913. }
  916. size_t CTL_RowResult::ReadItem(void* buffer, size_t buffer_size,
  917.                                bool* is_null)
  918. {
  919.     if ((unsigned int) m_CurrItem >= m_NofCols  ||  m_CurrItem == -1) {
  920.         return 0;
  921.     }
  923.     CS_INT outlen = 0;
  925.     if((buffer == 0) && (buffer_size == 0)) {
  926. buffer= (void*)(&buffer_size);
  927.     }
  929.     switch ( my_ct_get_data(m_Cmd, m_CurrItem+1, buffer, (CS_INT) buffer_size,
  930.                          &outlen) ) {
  931.     case CS_END_ITEM:
  932.     case CS_END_DATA:
  933.         ++m_CurrItem;
  934.     case CS_SUCCEED:
  935.         break;
  936.     case CS_CANCELED:
  937.         throw CDB_ClientEx(eDB_Error, 130004, "CTL_RowResult::ReadItem",
  938.                            "the command has been canceled");
  939.     default:
  940.         throw CDB_ClientEx(eDB_Error, 130000, "CTL_RowResult::ReadItem",
  941.                            "ct_get_data failed");
  942.     }
  944.     if ( is_null ) {
  945.         *is_null = (outlen == 0);
  946.     }
  948.     return (size_t) outlen;
  949. }
  952. I_ITDescriptor* CTL_RowResult::GetImageOrTextDescriptor()
  953. {
  954.     if ((unsigned int) m_CurrItem >= m_NofCols  ||  m_CurrItem == -1) {
  955.         return 0;
  956.     }
  958.     char dummy[4];
  959.     switch ( my_ct_get_data(m_Cmd, m_CurrItem+1, dummy, 0, 0) ) {
  960.     case CS_END_ITEM:
  961.     case CS_END_DATA:
  962.     case CS_SUCCEED:
  963.         break;
  964.     case CS_CANCELED:
  965.         throw CDB_ClientEx(eDB_Error, 130004,
  966.                            "CTL_RowResult::GetImageOrTextDescriptor",
  967.                            "the command has been canceled");
  968.     default:
  969.         throw CDB_ClientEx(eDB_Error, 130000,
  970.                            "CTL_RowResult::GetImageOrTextDescriptor",
  971.                            "ct_get_data failed");
  972.     }
  975.     CTL_ITDescriptor* desc = new CTL_ITDescriptor;
  977.     if (ct_data_info(m_Cmd, CS_GET, m_CurrItem+1, &desc->m_Desc)
  978.         != CS_SUCCEED) {
  979.         delete desc;
  980.         throw CDB_ClientEx(eDB_Error, 130010,
  981.                            "CTL_RowResult::GetImageOrTextDescriptor",
  982.                            "ct_data_info failed");
  983.     }
  985.     return desc;
  986. }
  989. bool CTL_RowResult::SkipItem()
  990. {
  991.     if (m_CurrItem < (int) m_NofCols) {
  992.         ++m_CurrItem;
  993.         return true;
  994.     }
  996.     return false;
  997. }
  1000. CTL_RowResult::~CTL_RowResult()
  1001. {
  1002.     if ( m_ColFmt ) {
  1003.         delete[] m_ColFmt;
  1004.     }
  1005. if(m_BindedCols) {
  1006.   delete [] m_BindItem;
  1007.   delete [] m_Copied;
  1008.   delete [] m_Indicator;
  1009. }
  1011.     if ( m_EOR ) {
  1012.         return;
  1013.     }
  1015.     switch (ct_cancel(NULL, m_Cmd, CS_CANCEL_CURRENT)) {
  1016.     case CS_SUCCEED:
  1017.     case CS_CANCELED:
  1018.         break;
  1019.     default:
  1020.         CS_INT err_code = 130007;
  1021.         ct_cmd_props(m_Cmd, CS_SET, CS_USERDATA,
  1022.                      &err_code, (CS_INT) sizeof(err_code), 0);
  1023.     }
  1024. }
  1028. /////////////////////////////////////////////////////////////////////////////
  1029. //
  1030. //  CTL_ParamResult::
  1031. //  CTL_ComputeResult::
  1032. //  CTL_StatusResult::
  1033. //  CTL_CursorResult::
  1034. //
  1036. EDB_ResType CTL_ParamResult::ResultType() const
  1037. {
  1038.     return eDB_ParamResult;
  1039. }
  1042. EDB_ResType CTL_ComputeResult::ResultType() const
  1043. {
  1044.     return eDB_ComputeResult;
  1045. }
  1048. EDB_ResType CTL_StatusResult::ResultType() const
  1049. {
  1050.     return eDB_StatusResult;
  1051. }
  1054. EDB_ResType CTL_CursorResult::ResultType() const
  1055. {
  1056.     return eDB_CursorResult;
  1057. }
  1060. bool CTL_CursorResult::SkipItem()
  1061. {
  1062.     if (m_CurrItem < (int) m_NofCols) {
  1063.         ++m_CurrItem;
  1064. char dummy[4];
  1065. switch ( my_ct_get_data(m_Cmd, m_CurrItem, dummy, 0, 0) ) {
  1066. case CS_END_ITEM:
  1067. case CS_END_DATA:
  1068. case CS_SUCCEED:
  1069.     break;
  1070. case CS_CANCELED:
  1071.     throw CDB_ClientEx(eDB_Error, 130004,
  1072.        "CTL_CursorResult::SkipItem",
  1073.        "the command has been canceled");
  1074. default:
  1075.     throw CDB_ClientEx(eDB_Error, 130000,
  1076.        "CTL_CursorResult::SkipItem",
  1077.        "ct_get_data failed");
  1078. }
  1079.         return true;
  1080.     }
  1082.     return false;
  1083. }
  1085. CTL_CursorResult::~CTL_CursorResult()
  1086. {
  1087.     if (m_EOR) { // this is not a bug
  1088.         CS_INT res_type;
  1089.         while (ct_results(m_Cmd, &res_type) == CS_SUCCEED) {
  1090.             continue;
  1091.         }
  1092.     }
  1093.     else m_EOR= true; // to prevent ct_cancel call (close cursor will do a job)
  1094. }
  1098. /////////////////////////////////////////////////////////////////////////////
  1099. //
  1100. //  CTL_ITDescriptor::
  1101. //
  1103. CTL_ITDescriptor::CTL_ITDescriptor()
  1104. {
  1105.     return;
  1106. }
  1108. int CTL_ITDescriptor::DescriptorType() const
  1109. {
  1110.     return CTL_ITDESCRIPTOR_TYPE_MAGNUM;
  1111. }
  1114. CTL_ITDescriptor::~CTL_ITDescriptor()
  1115. {
  1116.     return;
  1117. }
  1120. END_NCBI_SCOPE
  1124. /*
  1125.  * ===========================================================================
  1126.  * $Log: result.cpp,v $
  1127.  * Revision 1000.1  2004/06/01 19:19:47  gouriano
  1128.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.18
  1129.  *
  1130.  * Revision 1.18  2004/05/17 21:12:03  gorelenk
  1131.  * Added include of PCH ncbi_pch.hpp
  1132.  *
  1133.  * Revision 1.17  2003/04/29 21:15:35  soussov
  1134.  * new datatypes CDB_LongChar and CDB_LongBinary added
  1135.  *
  1136.  * Revision 1.16  2003/04/21 20:18:14  soussov
  1137.  * Buffering fetched result to avoid ct_get_data performance issue
  1138.  *
  1139.  * Revision 1.15  2003/01/03 21:47:42  soussov
  1140.  * set m_CurrItem = -1 if fetch failes
  1141.  *
  1142.  * Revision 1.14  2002/11/27 17:09:50  soussov
  1143.  * patch to fix NULL numeric related bug in ctlib for Windows
  1144.  *
  1145.  * Revision 1.13  2002/03/26 15:34:38  soussov
  1146.  * new image/text operations added
  1147.  *
  1148.  * Revision 1.12  2002/02/06 22:24:43  soussov
  1149.  * fixes the arguments order in numeric assign
  1150.  *
  1151.  * Revision 1.11  2002/01/04 19:41:46  soussov
  1152.  * allows usage ReadItem(0, 0)
  1153.  *
  1154.  * Revision 1.10  2001/11/06 18:02:00  lavr
  1155.  * Added methods formely inline (moved from header files)
  1156.  *
  1157.  * Revision 1.9  2001/10/11 16:30:44  soussov
  1158.  * exclude ctlib dependencies from numeric conversion calls
  1159.  *
  1160.  * Revision 1.8  2001/10/03 14:21:01  soussov
  1161.  * pevents the ct_cancel call in ~CTL_CursorResult()
  1162.  *
  1163.  * Revision 1.7  2001/10/02 22:14:50  soussov
  1164.  * fixed bug in ~CTL_CursorResult()
  1165.  *
  1166.  * Revision 1.6  2001/10/01 19:27:40  soussov
  1167.  * Fixed typo in ~CTL_CursorResult
  1168.  *
  1169.  * Revision 1.5  2001/10/01 19:13:56  soussov
  1170.  * Eliminates double deletes in results destructor
  1171.  *
  1172.  * Revision 1.4  2001/09/27 23:01:07  vakatov
  1173.  * CTL_***Result::  virtual methods' implementation moved away from the header
  1174.  *
  1175.  * Revision 1.3  2001/09/27 20:08:33  vakatov
  1176.  * Added "DB_" (or "I_") prefix where it was missing
  1177.  *
  1178.  * Revision 1.2  2001/09/26 23:23:31  vakatov
  1179.  * Moved the err.message handlers' stack functionality (generic storage
  1180.  * and methods) to the "abstract interface" level.
  1181.  *
  1182.  * Revision 1.1  2001/09/21 23:40:02  vakatov
  1183.  * -----  Initial (draft) revision.  -----
  1184.  * This is a major revamp (by Denis Vakatov, with help from Vladimir Soussov)
  1185.  * of the DBAPI "driver" libs originally written by Vladimir Soussov.
  1186.  * The revamp involved massive code shuffling and grooming, numerous local
  1187.  * API redesigns, adding comments and incorporating DBAPI to the C++ Toolkit.
  1188.  *
  1189.  * ===========================================================================
  1190.  */