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

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

生物技术

开发平台：

C/C++

result.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: result.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:21:54  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: result.cpp,v 1000.3 2004/06/01 19:21:54 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:  DBLib Results
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <dbapi/driver/odbc/interfaces.hpp>
  43. #include <dbapi/driver/util/numeric_convert.hpp>
  46. BEGIN_NCBI_SCOPE
  49. /////////////////////////////////////////////////////////////////////////////
  51. static EDB_Type s_GetDataType(SQLSMALLINT t, SQLSMALLINT dec_digits,
  52.                               SQLUINTEGER prec)
  53. {
  54.     switch (t) {
  55.     case SQL_WCHAR:
  56.     case SQL_CHAR:         return (prec < 256)? eDB_Char : eDB_LongChar;
  57.     case SQL_WVARCHAR:
  58.     case SQL_VARCHAR:      return (prec < 256)? eDB_VarChar : eDB_LongChar;
  59.     case SQL_LONGVARCHAR:  return eDB_Text;
  60.     case SQL_LONGVARBINARY:
  61.     case SQL_WLONGVARCHAR: return eDB_Image;
  62.     case SQL_DECIMAL:
  63.     case SQL_NUMERIC:      if(prec > 20 || dec_digits > 0) return eDB_Numeric;
  64.     case SQL_BIGINT:       return eDB_BigInt;
  65.     case SQL_SMALLINT:     return eDB_SmallInt;
  66.     case SQL_INTEGER:      return eDB_Int;
  67.     case SQL_REAL:         return eDB_Float;
  68.     case SQL_FLOAT:        return eDB_Double;
  69.     case SQL_BINARY:       return (prec < 256)? eDB_Binary : eDB_LongBinary;
  70.     case SQL_BIT:          return eDB_Bit;
  71.     case SQL_TINYINT:      return eDB_TinyInt;
  72.     case SQL_VARBINARY:    return (prec < 256)? eDB_VarBinary : eDB_LongBinary;
  73.     case SQL_TYPE_TIMESTAMP:
  74.         return (prec > 16 || dec_digits > 0)? eDB_DateTime : eDB_SmallDateTime;
  75.     default:               return eDB_UnsupportedType;
  76.     }
  77. }
  80. /////////////////////////////////////////////////////////////////////////////
  81. //
  82. //  CODBC_RowResult::
  83. //
  86. CODBC_RowResult::CODBC_RowResult(SQLSMALLINT nof_cols, SQLHSTMT cmd,
  87.                                  CODBC_Reporter& r) :
  88.     m_Cmd(cmd), m_Reporter(r), m_CurrItem(-1), m_EOR(false)
  89. {
  90.     m_NofCols = nof_cols;
  92.     SQLSMALLINT actual_name_size, nullable;
  94.     m_ColFmt = new SODBC_ColDescr[m_NofCols];
  95.     for (unsigned int n = 0; n < m_NofCols; n++) {
  96.         switch(SQLDescribeCol(m_Cmd, n+1, m_ColFmt[n].ColumnName,
  97.                               ODBC_COLUMN_NAME_SIZE, &actual_name_size,
  98.                               &m_ColFmt[n].DataType, &m_ColFmt[n].ColumnSize,
  99.                               &m_ColFmt[n].DecimalDigits, &nullable)) {
  100.         case SQL_SUCCESS_WITH_INFO:
  101.             m_Reporter.ReportErrors();
  102.         case SQL_SUCCESS:
  103.             continue;
  104.         case SQL_ERROR:
  105.             m_Reporter.ReportErrors();
  106.             throw CDB_ClientEx(eDB_Error, 420020, "CODBC_RowResult::CODBC_RowResult",
  107.                                "SQLDescribeCol failed");
  108.         default:
  109.             throw CDB_ClientEx(eDB_Error, 420021, "CODBC_RowResult::CODBC_RowResult",
  110.                                "SQLDescribeCol failed (memory corruption suspected)");
  111.    }
  112. }
  113. }
  116. EDB_ResType CODBC_RowResult::ResultType() const
  117. {
  118.     return eDB_RowResult;
  119. }
  122. unsigned int CODBC_RowResult::NofItems() const
  123. {
  124.     return m_NofCols;
  125. }
  128. const char* CODBC_RowResult::ItemName(unsigned int item_num) const
  129. {
  130.     return item_num < m_NofCols ? (char*)m_ColFmt[item_num].ColumnName : 0;
  131. }
  134. size_t CODBC_RowResult::ItemMaxSize(unsigned int item_num) const
  135. {
  136.     return item_num < m_NofCols ? m_ColFmt[item_num].ColumnSize : 0;
  137. }
  140. EDB_Type CODBC_RowResult::ItemDataType(unsigned int item_num) const
  141. {
  142.     return item_num < m_NofCols ?
  143.         s_GetDataType(m_ColFmt[item_num].DataType, m_ColFmt[item_num].DecimalDigits,
  144. m_ColFmt[item_num].ColumnSize) :  eDB_UnsupportedType;
  145. }
  148. bool CODBC_RowResult::Fetch()
  149. {
  150.     m_CurrItem= -1;
  151.     if (!m_EOR) {
  152.         switch (SQLFetch(m_Cmd)) {
  153.         case SQL_SUCCESS_WITH_INFO:
  154.             m_Reporter.ReportErrors();
  155.         case SQL_SUCCESS:
  156.             m_CurrItem = 0;
  157.             return true;
  158.         case SQL_NO_DATA:
  159.             m_EOR = true;
  160.             break;
  161.         case SQL_ERROR:
  162.             m_Reporter.ReportErrors();
  163.             throw CDB_ClientEx(eDB_Error, 430003, "CODBC_RowResult::Fetch",
  164.                                "SQLFetch failed");
  165.         default:
  166.             throw CDB_ClientEx(eDB_Error, 430004, "CODBC_RowResult::Fetch",
  167.                                "SQLFetch failed (memory corruption suspected)");
  168.         }
  169.     }
  170.     return false;
  171. }
  174. int CODBC_RowResult::CurrentItemNo() const
  175. {
  176.     return m_CurrItem;
  177. }
  179. int CODBC_RowResult::xGetData(SQLSMALLINT target_type, SQLPOINTER buffer,
  180.                               SQLINTEGER buffer_size)
  181. {
  182.     SQLINTEGER f;
  184.     switch(SQLGetData(m_Cmd, m_CurrItem+1, target_type, buffer, buffer_size, &f)) {
  185.     case SQL_SUCCESS_WITH_INFO:
  186.         switch(f) {
  187.         case SQL_NO_TOTAL:
  188.             return buffer_size;
  189.         case SQL_NULL_DATA:
  190.             return 0;
  191.         default:
  192. if(f < 0)
  193. m_Reporter.ReportErrors();
  194.             return (int)f;
  195.         }
  196.     case SQL_SUCCESS:
  197.         if(target_type==SQL_C_CHAR) buffer_size--;
  198.         return (f > buffer_size)? buffer_size : (int)f;
  199.     case SQL_NO_DATA:
  200.         return 0;
  201.     case SQL_ERROR:
  202.         m_Reporter.ReportErrors();
  203.     default:
  204.         throw CDB_ClientEx(eDB_Error, 430027, "CODBC_*Result::xGetData",
  205.                                    "SQLGetData failed ");
  206.     }
  207. }
  209. static void xConvert2CDB_Numeric(CDB_Numeric* d, SQL_NUMERIC_STRUCT& s)
  210. {
  211.     swap_numeric_endian((unsigned int)s.precision, s.val);
  212.     d->Assign((unsigned int)s.precision, (unsigned int)s.scale,
  213.              s.sign == 0, s.val);
  214. }
  216. CDB_Object* CODBC_RowResult::xLoadItem(CDB_Object* item_buf)
  217. {
  218.     char buffer[8*1024];
  219.     int outlen;
  221.     switch(m_ColFmt[m_CurrItem].DataType) {
  222.     case SQL_WCHAR:
  223.     case SQL_CHAR:
  224.     case SQL_VARCHAR:
  225.     case SQL_WVARCHAR: {
  226.         switch (item_buf->GetType()) {
  227.         case eDB_VarBinary:
  228.             outlen= xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
  229.             if ( outlen <= 0) item_buf->AssignNULL();
  230.             else ((CDB_VarBinary*) item_buf)->SetValue(buffer, outlen);
  231.             break;
  232.         case eDB_Binary:
  233.             outlen= xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
  234.             if ( outlen <= 0) item_buf->AssignNULL();
  235.             else ((CDB_Binary*) item_buf)->SetValue(buffer, outlen);
  236.             break;
  237.         case eDB_LongBinary:
  238.             outlen= xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
  239.             if ( outlen <= 0) item_buf->AssignNULL();
  240.             else ((CDB_LongBinary*) item_buf)->SetValue(buffer, outlen);
  241.             break;
  242.         case eDB_VarChar:
  243.             outlen= xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
  244.             if ( outlen <= 0) item_buf->AssignNULL();
  245.             else *((CDB_VarChar*)  item_buf) = buffer;
  246.             break;
  247.         case eDB_Char:
  248.             outlen= xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
  249.             if ( outlen <= 0) item_buf->AssignNULL();
  250.             else *((CDB_Char*)     item_buf) = buffer;
  251.             break;
  252.         case eDB_LongChar:
  253.             outlen= xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
  254.             if ( outlen <= 0) item_buf->AssignNULL();
  255.             else *((CDB_LongChar*)     item_buf) = buffer;
  256.             break;
  257.         default:
  258.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  259.                                "Wrong type of CDB_Object");
  260.         }
  261.         break;
  262.     }
  264.     case SQL_BINARY:
  265.     case SQL_VARBINARY: {
  266.         switch ( item_buf->GetType() ) {
  267.         case eDB_VarBinary:
  268.             outlen= xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
  269.             if ( outlen <= 0) item_buf->AssignNULL();
  270.             else ((CDB_VarBinary*) item_buf)->SetValue(buffer, outlen);
  271.             break;
  272.         case eDB_Binary:
  273.             outlen= xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
  274.             if ( outlen <= 0) item_buf->AssignNULL();
  275.             else ((CDB_Binary*) item_buf)->SetValue(buffer, outlen);
  276.             break;
  277.         case eDB_LongBinary:
  278.             outlen= xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
  279.             if ( outlen <= 0) item_buf->AssignNULL();
  280.             else ((CDB_LongBinary*) item_buf)->SetValue(buffer, outlen);
  281.             break;
  282.         case eDB_VarChar:
  283.             outlen= xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
  284.             if (outlen <= 0) item_buf->AssignNULL();
  285.             else *((CDB_VarChar*)  item_buf) = buffer;
  286.             break;
  287.         case eDB_Char:
  288.             outlen= xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
  289.             if (outlen <= 0) item_buf->AssignNULL();
  290.             else *((CDB_Char*) item_buf) = buffer;
  291.             break;
  292.         case eDB_LongChar:
  293.             outlen= xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
  294.             if (outlen <= 0) item_buf->AssignNULL();
  295.             else *((CDB_LongChar*) item_buf) = buffer;
  296.             break;
  297.         default:
  298.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  299.                                "Wrong type of CDB_Object");
  300.         }
  302.         break;
  303.     }
  305.     case SQL_BIT: {
  306.         SQLCHAR v;
  307.         switch (  item_buf->GetType()  ) {
  308.         case eDB_Bit:
  309.             outlen= xGetData(SQL_C_BIT, &v, sizeof(SQLCHAR));
  310.             if (outlen <= 0) item_buf->AssignNULL();
  311.             else *((CDB_Bit*) item_buf) = (int) v;
  312.             break;
  313.         case eDB_TinyInt:
  314.             outlen= xGetData(SQL_C_BIT, &v, sizeof(SQLCHAR));
  315.             if (outlen <= 0) item_buf->AssignNULL();
  316.             else *((CDB_TinyInt*)  item_buf) = v ? 1 : 0;
  317.             break;
  318.         case eDB_SmallInt:
  319.             outlen= xGetData(SQL_C_BIT, &v, sizeof(SQLCHAR));
  320.             if (outlen <= 0) item_buf->AssignNULL();
  321.             else *((CDB_SmallInt*) item_buf) = v ? 1 : 0;
  322.             break;
  323.         case eDB_Int:
  324.             outlen= xGetData(SQL_C_BIT, &v, sizeof(SQLCHAR));
  325.             if (outlen <= 0) item_buf->AssignNULL();
  326.             else *((CDB_Int*)      item_buf) = v ? 1 : 0;
  327.             break;
  328.         default:
  329.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  330.                                "Wrong type of CDB_Object");
  331.         }
  332.         break;
  333.     }
  335.     case SQL_TYPE_TIMESTAMP: {
  336.         SQL_TIMESTAMP_STRUCT v;
  337.         switch ( item_buf->GetType() ) {
  338.         case eDB_SmallDateTime: {
  339.             outlen= xGetData(SQL_C_TYPE_TIMESTAMP, &v, sizeof(SQL_TIMESTAMP_STRUCT));
  340.             if (outlen <= 0) item_buf->AssignNULL();
  341.             else {
  342.                 CTime t((int)v.year, (int)v.month, (int)v.day,
  343.                         (int)v.hour, (int)v.minute, (int)v.second,
  344.                         (long)v.fraction);
  346.                 *((CDB_SmallDateTime*) item_buf)= t;
  347.             }
  348.             break;
  349.         }
  350.         case eDB_DateTime: {
  351.             outlen= xGetData(SQL_C_TYPE_TIMESTAMP, &v, sizeof(SQL_TIMESTAMP_STRUCT));
  352.             if (outlen <= 0) item_buf->AssignNULL();
  353.             else {
  354.                 CTime t((int)v.year, (int)v.month, (int)v.day,
  355.                         (int)v.hour, (int)v.minute, (int)v.second,
  356.                         (long)v.fraction);
  358.                 *((CDB_DateTime*) item_buf)= t;
  359.             }
  360.             break;
  361.         }
  362.         default:
  363.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  364.                                "Wrong type of CDB_Object");
  365.         }
  366.         break;
  367.     }
  369.     case SQL_TINYINT: {
  370.         SQLCHAR v;
  371.         switch (  item_buf->GetType()  ) {
  372.         case eDB_TinyInt:
  373.             outlen= xGetData(SQL_C_UTINYINT, &v, sizeof(SQLCHAR));
  374.             if (outlen <= 0) item_buf->AssignNULL();
  375.             else *((CDB_TinyInt*)  item_buf) = (Uint1) v;
  376.             break;
  377.         case eDB_SmallInt:
  378.             outlen= xGetData(SQL_C_UTINYINT, &v, sizeof(SQLCHAR));
  379.             if (outlen <= 0) item_buf->AssignNULL();
  380.             else *((CDB_SmallInt*) item_buf) = (Int2) v;
  381.             break;
  382.         case eDB_Int:
  383.             outlen= xGetData(SQL_C_UTINYINT, &v, sizeof(SQLCHAR));
  384.             if (outlen <= 0) item_buf->AssignNULL();
  385.             else *((CDB_Int*)      item_buf) = (Int4) v;
  386.             break;
  387.         default:
  388.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  389.                                "Wrong type of CDB_Object");
  390.         }
  391.         break;
  392.     }
  394.     case SQL_SMALLINT: {
  395.         SQLSMALLINT v;
  396.         switch (  item_buf->GetType()  ) {
  397.         case eDB_SmallInt:
  398.             outlen= xGetData(SQL_C_SSHORT, &v, sizeof(SQLSMALLINT));
  399.             if (outlen <= 0) item_buf->AssignNULL();
  400.             else *((CDB_SmallInt*) item_buf) = (Int2) v;
  401.             break;
  402.         case eDB_Int:
  403.             outlen= xGetData(SQL_C_SSHORT, &v, sizeof(SQLSMALLINT));
  404.             if (outlen <= 0) item_buf->AssignNULL();
  405.             else *((CDB_Int*) item_buf) = (Int4) v;
  406.             break;
  407.         default:
  408.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  409.                                "Wrong type of CDB_Object");
  410.         }
  411.         break;
  412.     }
  414.     case SQL_INTEGER: {
  415.         SQLINTEGER v;
  416.         switch (  item_buf->GetType()  ) {
  417.         case eDB_Int:
  418.             outlen= xGetData(SQL_C_SLONG, &v, sizeof(SQLINTEGER));
  419.             if (outlen <= 0) item_buf->AssignNULL();
  420.             else *((CDB_Int*) item_buf) = (Int4) v;
  421.             break;
  422.         default:
  423.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  424.                                "Wrong type of CDB_Object");
  425.         }
  426.         break;
  427.     }
  429.     case SQL_DOUBLE:
  430.     case SQL_FLOAT: {
  431.         SQLDOUBLE v;
  432.         switch (  item_buf->GetType()  ) {
  433.         case eDB_Double:
  434.             outlen= xGetData(SQL_C_DOUBLE, &v, sizeof(SQLDOUBLE));
  435.             if (outlen <= 0) item_buf->AssignNULL();
  436.             else *((CDB_Double*)      item_buf) = v;
  437.             break;
  438.         default:
  439.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  440.                                "Wrong type of CDB_Object");
  441.         }
  442.         break;
  443.     }
  445.     case SQL_REAL: {
  446.         SQLREAL v;
  447.         switch (  item_buf->GetType()  ) {
  448.         case eDB_Float:
  449.             outlen= xGetData(SQL_C_FLOAT, &v, sizeof(SQLREAL));
  450.             if (outlen <= 0) item_buf->AssignNULL();
  451.             else *((CDB_Float*)      item_buf) = v;
  452.             break;
  453.         default:
  454.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  455.                                "Wrong type of CDB_Object");
  456.         }
  457.         break;
  458.     }
  460.     case SQL_BIGINT:
  461.     case SQL_DECIMAL:
  462.     case SQL_NUMERIC: {
  463.         switch (  item_buf->GetType()  ) {
  464.         case eDB_Numeric: {
  465.             SQL_NUMERIC_STRUCT v;
  466. SQLHDESC hdesc;
  467. SQLGetStmtAttr(m_Cmd, SQL_ATTR_APP_ROW_DESC,&hdesc, 0, NULL);
  468. SQLSetDescField(hdesc,m_CurrItem+1,SQL_DESC_TYPE,(VOID*)SQL_C_NUMERIC,0);
  469. SQLSetDescField(hdesc,m_CurrItem+1,SQL_DESC_PRECISION,
  470. (VOID*)(m_ColFmt[m_CurrItem].ColumnSize),0);
  471. SQLSetDescField(hdesc,m_CurrItem+1,SQL_DESC_SCALE,
  472. (VOID*)(m_ColFmt[m_CurrItem].DecimalDigits),0);
  474.             outlen= xGetData(SQL_ARD_TYPE, &v, sizeof(SQL_NUMERIC_STRUCT));
  475.             if (outlen <= 0) item_buf->AssignNULL();
  476.             else xConvert2CDB_Numeric((CDB_Numeric*)item_buf, v);
  477.             break;
  478.         }
  479.         case eDB_BigInt: {
  480.             SQLBIGINT v;
  481.             outlen= xGetData(SQL_C_SBIGINT, &v, sizeof(SQLBIGINT));
  482.             if (outlen <= 0) item_buf->AssignNULL();
  483.             else *((CDB_BigInt*) item_buf) = (Int8) v;
  484.             break;
  485.         }
  486.         default:
  487.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  488.                                "Wrong type of CDB_Object");
  489.         }
  490.         break;
  491.     }
  493.     case SQL_WLONGVARCHAR:
  494.     case SQL_LONGVARBINARY:
  495.     case SQL_LONGVARCHAR: {
  496.         SQLINTEGER f;
  497.         switch(item_buf->GetType()) {
  498.         case eDB_Text: {
  499.             CDB_Stream* val = (CDB_Stream*) item_buf;
  500.             for(;;) {
  501.                 switch(SQLGetData(m_Cmd, m_CurrItem+1, SQL_C_CHAR, buffer, sizeof(buffer), &f)) {
  502.                 case SQL_SUCCESS_WITH_INFO:
  503.                     if(f == SQL_NO_TOTAL) f= sizeof(buffer) - 1;
  504.                     else if(f < 0) m_Reporter.ReportErrors();
  505.                 case SQL_SUCCESS:
  506.                     if(f > 0) {
  507.                         if(f > sizeof(buffer)-1) f= sizeof(buffer)-1;
  508.                         val->Append(buffer, f);
  509.                     }
  510.                     continue;
  511.                 case SQL_NO_DATA:
  512.                     break;
  513.                 case SQL_ERROR:
  514.                     m_Reporter.ReportErrors();
  515.                 default:
  516.                     throw CDB_ClientEx(eDB_Error, 430021, "CODBC_*Result::GetItem",
  517.                                "SQLGetData failed while retrieving text/image into CDB_Text");
  518.                 }
  519. break;
  520.             }
  521.             break;
  522.         }
  523.         case eDB_Image: {
  524.             CDB_Stream* val = (CDB_Stream*) item_buf;
  525.             for(;;) {
  526.                 switch(SQLGetData(m_Cmd, m_CurrItem+1, SQL_C_BINARY, buffer, sizeof(buffer), &f)) {
  527.                 case SQL_SUCCESS_WITH_INFO:
  528.                     if(f == SQL_NO_TOTAL || f > sizeof(buffer)) f= sizeof(buffer);
  529.                     else m_Reporter.ReportErrors();
  530.                 case SQL_SUCCESS:
  531.                     if(f > 0) {
  532.                         if(f > sizeof(buffer)) f= sizeof(buffer);
  533.                         val->Append(buffer, f);
  534.                     }
  535.                     continue;
  536.                 case SQL_NO_DATA:
  537.                     break;
  538.                 case SQL_ERROR:
  539.                     m_Reporter.ReportErrors();
  540.                 default:
  541.                     throw CDB_ClientEx(eDB_Error, 430022, "CODBC_*Result::GetItem",
  542.                                "SQLGetData failed while retrieving text/image into CDB_Image");
  543.                 }
  544. break;
  545.             }
  546.             break;
  547.         }
  548.         default:
  549.             throw CDB_ClientEx(eDB_Error, 430020, "CODBC_*Result::GetItem",
  550.                                "Wrong type of CDB_Object");
  551.         }
  552.         break;
  553.     }
  554.     default:
  555.         throw CDB_ClientEx(eDB_Error, 430025, "CODBC_*Result::GetItem",
  556.                                "Unsupported column type");
  558.     }
  559.     return item_buf;
  560. }
  562. CDB_Object* CODBC_RowResult::xMakeItem()
  563. {
  564.     char buffer[8*1024];
  565.     int outlen;
  567.     switch(m_ColFmt[m_CurrItem].DataType) {
  568.     case SQL_WCHAR:
  569.     case SQL_CHAR:
  570.     case SQL_VARCHAR:
  571.     case SQL_WVARCHAR: {
  572.         outlen= xGetData(SQL_C_CHAR, buffer, sizeof(buffer));
  573. if(m_ColFmt[m_CurrItem].ColumnSize < 256) {
  574. CDB_VarChar* val = (outlen < 0)
  575. ? new CDB_VarChar() : new CDB_VarChar(buffer, (size_t) outlen);
  577. return val;
  578. }
  579. else {
  580. CDB_LongChar* val = (outlen < 0)
  581. ? new CDB_LongChar(m_ColFmt[m_CurrItem].ColumnSize) :
  582. new CDB_LongChar(m_ColFmt[m_CurrItem].ColumnSize,
  583. buffer);
  585. return val;
  586. }
  588.     }
  590.     case SQL_BINARY:
  591.     case SQL_VARBINARY: {
  592.         outlen= xGetData(SQL_C_BINARY, buffer, sizeof(buffer));
  593. if(m_ColFmt[m_CurrItem].ColumnSize < 256) {
  594.         CDB_VarBinary* val = (outlen <= 0)
  595.         ? new CDB_VarBinary() : new CDB_VarBinary(buffer, (size_t)outlen);
  597. return val;
  598. }
  599. else {
  600. CDB_LongBinary* val = (outlen < 0)
  601. ? new CDB_LongBinary(m_ColFmt[m_CurrItem].ColumnSize) :
  602. new CDB_LongBinary(m_ColFmt[m_CurrItem].ColumnSize,
  603. buffer, (size_t) outlen);
  605. return val;
  606. }
  607.     }
  609.     case SQL_BIT: {
  610.         SQLCHAR v;
  611.         outlen= xGetData(SQL_C_BIT, &v, sizeof(SQLCHAR));
  612.         return (outlen <= 0) ? new CDB_Bit() : new CDB_Bit((int) v);
  613.     }
  615.     case SQL_TYPE_TIMESTAMP: {
  616.         SQL_TIMESTAMP_STRUCT v;
  617.         outlen= xGetData(SQL_C_TYPE_TIMESTAMP, &v, sizeof(SQL_TIMESTAMP_STRUCT));
  618.         if (outlen <= 0) {
  619.             return new CDB_SmallInt();
  620.         }
  621.         else {
  622.             CTime t((int)v.year, (int)v.month, (int)v.day,
  623.                     (int)v.hour, (int)v.minute, (int)v.second,
  624.                     (long)v.fraction);
  625.             return new CDB_DateTime(t);
  626.         }
  627.     }
  629.     case SQL_TINYINT: {
  630.         SQLCHAR v;
  631.         outlen= xGetData(SQL_C_UTINYINT, &v, sizeof(SQLCHAR));
  632.         return (outlen <= 0) ? new CDB_TinyInt() : new CDB_TinyInt((Uint1) v);
  633.     }
  635.     case SQL_SMALLINT: {
  636.         SQLSMALLINT v;
  637.         outlen= xGetData(SQL_C_SSHORT, &v, sizeof(SQLSMALLINT));
  638.         return (outlen <= 0) ? new CDB_SmallInt() : new CDB_SmallInt((Int2) v);
  639.     }
  641.     case SQL_INTEGER: {
  642.         SQLINTEGER v;
  643.         outlen= xGetData(SQL_C_SLONG, &v, sizeof(SQLINTEGER));
  644.         return (outlen <= 0) ? new CDB_Int() : new CDB_Int((Int4) v);
  645.     }
  647.     case SQL_DOUBLE:
  648.     case SQL_FLOAT: {
  649.         SQLDOUBLE v;
  650.         outlen= xGetData(SQL_C_DOUBLE, &v, sizeof(SQLDOUBLE));
  651.         return (outlen <= 0) ? new CDB_Double() : new CDB_Double(v);
  652.     }
  653.     case SQL_REAL: {
  654.         SQLREAL v;
  655.         outlen= xGetData(SQL_C_FLOAT, &v, sizeof(SQLREAL));
  656.         return (outlen <= 0) ? new CDB_Float() : new CDB_Float(v);
  657.     }
  659.     case SQL_DECIMAL:
  660.     case SQL_NUMERIC: {
  661.         if((m_ColFmt[m_CurrItem].DecimalDigits > 0) ||
  662.            (m_ColFmt[m_CurrItem].ColumnSize > 20)) { // It should be numeric
  663.             SQL_NUMERIC_STRUCT v;
  664.             outlen= xGetData(SQL_C_NUMERIC, &v, sizeof(SQL_NUMERIC_STRUCT));
  665.             CDB_Numeric* r= new CDB_Numeric;
  666.             if(outlen > 0) {
  667.                 xConvert2CDB_Numeric(r, v);
  668.             }
  669.                 return r;
  670.         }
  671.         else { // It should be bigint
  672.             SQLBIGINT v;
  673.             outlen= xGetData(SQL_C_SBIGINT, &v, sizeof(SQLBIGINT));
  674.             return (outlen <= 0) ? new CDB_BigInt() : new CDB_BigInt((Int8) v);
  675.         }
  676.     }
  678.     case SQL_WLONGVARCHAR:
  679.     case SQL_LONGVARCHAR: {
  680.         CDB_Text* val = new CDB_Text;
  681.         SQLINTEGER f;
  683.         for(;;) {
  684.             switch(SQLGetData(m_Cmd, m_CurrItem+1, SQL_C_CHAR, buffer, sizeof(buffer), &f)) {
  685.             case SQL_SUCCESS_WITH_INFO:
  686.                 if(f == SQL_NO_TOTAL) f= sizeof(buffer) - 1;
  687.                 else if(f < 0) m_Reporter.ReportErrors();
  688.             case SQL_SUCCESS:
  689.                 if(f > 0) {
  690.                     if(f > sizeof(buffer)-1) f= sizeof(buffer)-1;
  691.                     val->Append(buffer, f);
  692.                 }
  693.                 continue;
  694.             case SQL_NO_DATA:
  695.                 break;
  696.             case SQL_ERROR:
  697.                 m_Reporter.ReportErrors();
  698.             default:
  699.                 throw CDB_ClientEx(eDB_Error, 430023, "CODBC_*Result::GetItem",
  700.                                "SQLGetData failed while retrieving text into CDB_Text");
  701.             }
  702.         }
  703.         return val;
  704.     }
  706.     case SQL_LONGVARBINARY: {
  707.         CDB_Image* val = new CDB_Image;
  708.         SQLINTEGER f;
  709.         for(;;) {
  710.             switch(SQLGetData(m_Cmd, m_CurrItem+1, SQL_C_BINARY, buffer, sizeof(buffer), &f)) {
  711.             case SQL_SUCCESS_WITH_INFO:
  712.                 if(f == SQL_NO_TOTAL) f= sizeof(buffer);
  713.                 else if(f < 0) m_Reporter.ReportErrors();
  714.             case SQL_SUCCESS:
  715.                 if(f > 0) {
  716.                     if(f > sizeof(buffer)) f= sizeof(buffer);
  717.                     val->Append(buffer, f);
  718.                 }
  719.                 continue;
  720.             case SQL_NO_DATA:
  721.                 break;
  722.             case SQL_ERROR:
  723.                 m_Reporter.ReportErrors();
  724.             default:
  725.                 throw CDB_ClientEx(eDB_Error, 430024, "CODBC_*Result::GetItem",
  726.                                    "SQLGetData failed while retrieving image into CDB_Image");
  727.             }
  728.         }
  729.         return val;
  730.     }
  731.     default:
  732.         throw CDB_ClientEx(eDB_Error, 430025, "CODBC_*Result::GetItem",
  733.                                "Unsupported column type");
  735.     }
  736. }
  739. CDB_Object* CODBC_RowResult::GetItem(CDB_Object* item_buf)
  740. {
  741.     if ((unsigned int) m_CurrItem >= m_NofCols  ||  m_CurrItem == -1) {
  742.         return 0;
  743.     }
  745.     CDB_Object* item = item_buf? xLoadItem(item_buf) : xMakeItem();
  747.     ++m_CurrItem;
  748.     return item;
  749. }
  752. size_t CODBC_RowResult::ReadItem(void* buffer,size_t buffer_size,bool* is_null)
  753. {
  754.     if ((unsigned int) m_CurrItem >= m_NofCols  ||  m_CurrItem == -1 ||
  755.         buffer == 0 || buffer_size == 0) {
  756.         return 0;
  757.     }
  759.     SQLINTEGER f= 0;
  761.     if(is_null) *is_null= false;
  763.     switch(SQLGetData(m_Cmd, m_CurrItem+1, SQL_C_BINARY, buffer, buffer_size, &f)) {
  764.     case SQL_SUCCESS_WITH_INFO:
  765.         switch(f) {
  766.         case SQL_NO_TOTAL:
  767.             return buffer_size;
  768.         case SQL_NULL_DATA:
  769.             ++m_CurrItem;
  770.             if(is_null) *is_null= true;
  771.             return 0;
  772.         default:
  773.    if(f >= 0) return (f <= buffer_size)? (size_t)f : buffer_size;
  774.             m_Reporter.ReportErrors();
  775.             return 0;
  776.         }
  777.     case SQL_SUCCESS:
  778.         ++m_CurrItem;
  779.         if(f == SQL_NULL_DATA) {
  780.             if(is_null) *is_null= true;
  781.             return 0;
  782.         }
  783.         return (f >= 0)? ((size_t)f) : 0;
  784.     case SQL_NO_DATA:
  785.         ++m_CurrItem;
  786.         if(f == SQL_NULL_DATA) {
  787.             if(is_null) *is_null= true;
  788.         }
  789.         return 0;
  790.     case SQL_ERROR:
  791.         m_Reporter.ReportErrors();
  792.     default:
  793.         throw CDB_ClientEx(eDB_Error, 430026, "CODBC_*Result::ReadItem",
  794.                                    "SQLGetData failed ");
  795.     }
  796. }
  799. CDB_ITDescriptor* CODBC_RowResult::GetImageOrTextDescriptor(int item_no,
  800.                                                             const string& cond)
  801. {
  802.     char* buffer[128];
  803.     SQLSMALLINT slp;
  805.     switch(SQLColAttribute(m_Cmd, item_no+1,
  806.                            SQL_DESC_BASE_TABLE_NAME,
  807.                            (SQLPOINTER)buffer, sizeof(buffer),
  808.                            &slp, 0)) {
  809.     case SQL_SUCCESS_WITH_INFO:
  810.         m_Reporter.ReportErrors();
  811.     case SQL_SUCCESS:
  812.         break;
  813.     case SQL_ERROR:
  814.         m_Reporter.ReportErrors();
  815.         return 0;
  816.     default:
  817.         throw CDB_ClientEx(eDB_Error, 430027,
  818.                            "CODBC_*Result::GetImageOrTextDescriptor",
  819.                            "SQLColAttribute failed");
  820.     }
  821.     string base_table=(const char*)buffer;
  823.     switch(SQLColAttribute(m_Cmd, item_no+1,
  824.                            SQL_DESC_BASE_COLUMN_NAME,
  825.                            (SQLPOINTER)buffer, sizeof(buffer),
  826.                            &slp, 0)) {
  827.     case SQL_SUCCESS_WITH_INFO:
  828.         m_Reporter.ReportErrors();
  829.     case SQL_SUCCESS:
  830.         break;
  831.     case SQL_ERROR:
  832.         m_Reporter.ReportErrors();
  833.         return 0;
  834.     default:
  835.         throw CDB_ClientEx(eDB_Error, 430027,
  836.                            "CODBC_*Result::GetImageOrTextDescriptor",
  837.                            "SQLColAttribute failed");
  838.     }
  839.     string base_column=(const char*)buffer;
  841.     return new CDB_ITDescriptor(base_table, base_column, cond);
  842. }
  844. I_ITDescriptor* CODBC_RowResult::GetImageOrTextDescriptor()
  845. {
  846.     return (I_ITDescriptor*) GetImageOrTextDescriptor(m_CurrItem,
  847.                                                       "don't use me");
  848. }
  850. bool CODBC_RowResult::SkipItem()
  851. {
  852.     if ((unsigned int) m_CurrItem < m_NofCols) {
  853.         ++m_CurrItem;
  854.         return true;
  855.     }
  856.     return false;
  857. }
  860. CODBC_RowResult::~CODBC_RowResult()
  861. {
  862.     if (m_ColFmt) {
  863.         delete[] m_ColFmt;
  864.         m_ColFmt = 0;
  865.     }
  866.     if (!m_EOR)
  867.         SQLFreeStmt(m_Cmd, SQL_CLOSE);
  868. }
  871. /////////////////////////////////////////////////////////////////////////////
  872. //
  873. //  CTL_ParamResult::
  874. //  CTL_StatusResult::
  875. //  CTL_CursorResult::
  876. //
  878. EDB_ResType CODBC_StatusResult::ResultType() const
  879. {
  880.     return eDB_StatusResult;
  881. }
  883. CODBC_StatusResult::~CODBC_StatusResult()
  884. {
  885. }
  887. EDB_ResType CODBC_ParamResult::ResultType() const
  888. {
  889.     return eDB_ParamResult;
  890. }
  892. CODBC_ParamResult::~CODBC_ParamResult()
  893. {
  894. }
  896. /////////////////////////////////////////////////////////////////////////////
  897. //
  898. //  CODBC_CursorResult::
  899. //
  901. CODBC_CursorResult::CODBC_CursorResult(CODBC_LangCmd* cmd) :
  902.     m_Cmd(cmd), m_Res(0)
  903. {
  904.     try {
  905.         m_Cmd->Send();
  906. m_EOR= true;
  907.         while (m_Cmd->HasMoreResults()) {
  908.             m_Res = m_Cmd->Result();
  909.             if (m_Res && m_Res->ResultType() == eDB_RowResult) {
  910. m_EOR= false;
  911.                 return;
  912.             }
  913.             if (m_Res) {
  914.                 while (m_Res->Fetch())
  915.                     ;
  916.                 delete m_Res;
  917.                 m_Res = 0;
  918.             }
  919.         }
  920.     } catch (CDB_Exception& ) {
  921.         throw CDB_ClientEx(eDB_Error, 422010,
  922.                            "CODBC_CursorResult::CODBC_CursorResult",
  923.                            "failed to get the results");
  924.     }
  925. }
  928. EDB_ResType CODBC_CursorResult::ResultType() const
  929. {
  930.     return eDB_CursorResult;
  931. }
  934. unsigned int CODBC_CursorResult::NofItems() const
  935. {
  936.     return m_Res? m_Res->NofItems() : 0;
  937. }
  940. const char* CODBC_CursorResult::ItemName(unsigned int item_num) const
  941. {
  942.     return m_Res ? m_Res->ItemName(item_num) : 0;
  943. }
  946. size_t CODBC_CursorResult::ItemMaxSize(unsigned int item_num) const
  947. {
  948.     return m_Res ? m_Res->ItemMaxSize(item_num) : 0;
  949. }
  952. EDB_Type CODBC_CursorResult::ItemDataType(unsigned int item_num) const
  953. {
  954.     return m_Res ? m_Res->ItemDataType(item_num) : eDB_UnsupportedType;
  955. }
  958. bool CODBC_CursorResult::Fetch()
  959. {
  961. if(m_EOR) return false;
  962. try {
  963. if (m_Res && m_Res->Fetch()) return true;
  964.     } catch (CDB_Exception& ) {
  965. delete m_Res;
  966. m_Res= 0;
  967. }
  969.     try {
  970.         // finish this command
  971. m_EOR= true;
  972.         if(m_Res) {
  973. delete m_Res;
  974. while (m_Cmd->HasMoreResults()) {
  975. m_Res = m_Cmd->Result();
  976. if (m_Res) {
  977. while (m_Res->Fetch())
  978. ;
  979. delete m_Res;
  980. m_Res = 0;
  981. }
  982. }
  983. }
  984.         // send the another "fetch cursor_name" command
  985.         m_Cmd->Send();
  986.         while (m_Cmd->HasMoreResults()) {
  987.             m_Res = m_Cmd->Result();
  988.             if (m_Res && m_Res->ResultType() == eDB_RowResult) {
  989. m_EOR= false;
  990.                 return m_Res->Fetch();
  991.             }
  992.             if (m_Res) {
  993.                 while (m_Res->Fetch())
  994.                     ;
  995.                 delete m_Res;
  996.                 m_Res = 0;
  997.             }
  998.         }
  999.     } catch (CDB_Exception& ) {
  1000.         throw CDB_ClientEx(eDB_Error, 422011, "CODBC_CursorResult::Fetch",
  1001.                            "Failed to fetch the results");
  1002.     }
  1003.     return false;
  1004. }
  1007. int CODBC_CursorResult::CurrentItemNo() const
  1008. {
  1009.     return m_Res ? m_Res->CurrentItemNo() : -1;
  1010. }
  1013. CDB_Object* CODBC_CursorResult::GetItem(CDB_Object* item_buff)
  1014. {
  1015.     return m_Res ? m_Res->GetItem(item_buff) : 0;
  1016. }
  1019. size_t CODBC_CursorResult::ReadItem(void* buffer, size_t buffer_size,
  1020.                                    bool* is_null)
  1021. {
  1022.     if (m_Res) {
  1023.         return m_Res->ReadItem(buffer, buffer_size, is_null);
  1024.     }
  1025.     if (is_null)
  1026.         *is_null = true;
  1027.     return 0;
  1028. }
  1031. I_ITDescriptor* CODBC_CursorResult::GetImageOrTextDescriptor()
  1032. {
  1033.     return m_Res ? m_Res->GetImageOrTextDescriptor() : 0;
  1034. }
  1037. bool CODBC_CursorResult::SkipItem()
  1038. {
  1039.     return m_Res ? m_Res->SkipItem() : false;
  1040. }
  1043. CODBC_CursorResult::~CODBC_CursorResult()
  1044. {
  1045.     if (m_Res)
  1046.         delete m_Res;
  1047. }
  1050. END_NCBI_SCOPE
  1054. /*
  1055.  * ===========================================================================
  1056.  * $Log: result.cpp,v $
  1057.  * Revision 1000.3  2004/06/01 19:21:54  gouriano
  1058.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
  1059.  *
  1060.  * Revision 1.12  2004/05/17 21:16:06  gorelenk
  1061.  * Added include of PCH ncbi_pch.hpp
  1062.  *
  1063.  * Revision 1.11  2004/01/30 20:00:39  soussov
  1064.  * fixes GetItem for CDB_Numeric
  1065.  *
  1066.  * Revision 1.10  2003/12/09 17:35:29  sapojnik
  1067.  * data sizes returned by SQLGetData() adjusted to fit within the buffer
  1068.  *
  1069.  * Revision 1.9  2003/12/09 15:42:15  sapojnik
  1070.  * CODBC_RowResult::ReadItem(): * was missing in *is_null=false; corrected
  1071.  *
  1072.  * Revision 1.8  2003/11/25 20:09:06  soussov
  1073.  * fixes bug in ReadItem: it did return the text/image size instead of number of bytes in buffer in some cases
  1074.  *
  1075.  * Revision 1.7  2003/05/08 20:30:24  soussov
  1076.  * CDB_LongChar CDB_LongBinary added
  1077.  *
  1078.  * Revision 1.6  2003/01/31 16:51:03  lavr
  1079.  * Remove unused variable "e" from catch() clause
  1080.  *
  1081.  * Revision 1.5  2003/01/06 16:59:20  soussov
  1082.  * sets m_CurrItem = -1 for all result types if no fetch was called
  1083.  *
  1084.  * Revision 1.4  2003/01/03 21:48:37  soussov
  1085.  * set m_CurrItem = -1 if fetch failes
  1086.  *
  1087.  * Revision 1.3  2003/01/02 21:05:35  soussov
  1088.  * SQL_BIGINT added in CODBC_RowResult::xLoadItem
  1089.  *
  1090.  * Revision 1.2  2002/07/05 15:15:10  soussov
  1091.  * fixes bug in ReadItem
  1092.  *
  1093.  *
  1094.  * ===========================================================================
  1095.  */