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

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

生物技术

开发平台：

C/C++

result.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: result.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:20:21  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.22
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: result.cpp,v 1000.2 2004/06/01 19:20:21 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.  */
  40. #include <ncbi_pch.hpp>
  42. #ifndef USE_MS_DBLIB
  43. #  include <dbapi/driver/dblib/interfaces.hpp>
  44. #  include <dbapi/driver/dblib/interfaces_p.hpp>
  45. #else
  46. #  include <dbapi/driver/msdblib/interfaces.hpp>
  47. #  include <dbapi/driver/msdblib/interfaces_p.hpp>
  48. #endif
  49. #include <dbapi/driver/util/numeric_convert.hpp>
  52. BEGIN_NCBI_SCOPE
  55. // Aux. for s_*GetItem()
  56. static CDB_Object* s_GenericGetItem(EDB_Type data_type, CDB_Object* item_buff,
  57.                                     EDB_Type b_type, const BYTE* d_ptr, DBINT d_len)
  58. {
  59.     switch (data_type) {
  60.     case eDB_VarBinary: {
  61.         if (item_buff) {
  62.             switch (b_type) {
  63.             case eDB_VarBinary:
  64.                 ((CDB_VarBinary*) item_buff)->SetValue((const void*) d_ptr,
  65.                                                        (size_t) d_len);
  66.                 break;
  67.             case eDB_Binary:
  68.                 ((CDB_Binary*)    item_buff)->SetValue((const void*) d_ptr,
  69.                                                        (size_t) d_len);
  70.                 break;
  71.             case eDB_VarChar:
  72.                 ((CDB_VarChar*)   item_buff)->SetValue((const char*) d_ptr,
  73.                                                        (size_t) d_len);
  74.                 break;
  75.             case eDB_Char:
  76.                 ((CDB_Char*)      item_buff)->SetValue((const char*) d_ptr,
  77.                                                        (size_t) d_len);
  78.                 break;
  79. case eDB_LongBinary:
  80.                 ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
  81.                                                        (size_t) d_len);
  82.                 break;
  83.             case eDB_LongChar:
  84.                 ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
  85.                                                        (size_t) d_len);
  86.                 break;
  87.             default:
  88.                 throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  89.                                    "wrong type of CDB_Object");
  90.             }
  91.             return item_buff;
  92.         }
  94.         return d_ptr ? new CDB_VarBinary((const void*) d_ptr, (size_t) d_len)
  95.             : new CDB_VarBinary();
  96.     }
  98.     case eDB_Bit: {
  99.         DBBIT* v = (DBBIT*) d_ptr;
  100.         if (item_buff) {
  101.             if (v) {
  102.                 switch (b_type) {
  103.                 case eDB_Bit:
  104.                     *((CDB_Bit*)      item_buff) = (int) *v;
  105.                     break;
  106.                 case eDB_TinyInt:
  107.                     *((CDB_TinyInt*)  item_buff) = *v ? 1 : 0;
  108.                     break;
  109.                 case eDB_SmallInt:
  110.                     *((CDB_SmallInt*) item_buff) = *v ? 1 : 0;
  111.                     break;
  112.                 case eDB_Int:
  113.                     *((CDB_Int*)      item_buff) = *v ? 1 : 0;
  114.                     break;
  115.                 default:
  116.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  117.                                        "wrong type of CDB_Object");
  118.                 }
  119.             } else
  120.                 item_buff->AssignNULL();
  121.             return item_buff;
  122.         }
  124.         return v ? new CDB_Bit((int) *v) : new CDB_Bit;
  125.     }
  127.     case eDB_VarChar: {
  128.         if (item_buff) {
  129.             switch (b_type) {
  130.             case eDB_VarChar:
  131.                 ((CDB_VarChar*)   item_buff)->SetValue((const char*) d_ptr,
  132.                                                        (size_t) d_len);
  133.                 break;
  134.             case eDB_Char:
  135.                 ((CDB_Char*)      item_buff)->SetValue((const char*) d_ptr,
  136.                                                        (size_t) d_len);
  137.                 break;
  138.             case eDB_LongChar:
  139.                 ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
  140.                                                        (size_t) d_len);
  141.                 break;
  142.             case eDB_VarBinary:
  143.                 ((CDB_VarBinary*) item_buff)->SetValue((const void*) d_ptr,
  144.                                                        (size_t) d_len);
  145.                 break;
  146.             case eDB_Binary:
  147.                 ((CDB_Binary*)    item_buff)->SetValue((const void*) d_ptr,
  148.                                                        (size_t) d_len);
  149.                 break;
  150.             case eDB_LongBinary:
  151.                 ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
  152.                                                        (size_t) d_len);
  153.                 break;
  154.             default:
  155.                 throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  156.                                    "wrong type of CDB_Object");
  157.             }
  158.             return item_buff;
  159.         }
  161.         return d_ptr ? new CDB_VarChar((const char*) d_ptr, (size_t) d_len)
  162.             : new CDB_VarChar();
  163.     }
  165.     case eDB_DateTime: {
  166.         DBDATETIME* v = (DBDATETIME*) d_ptr;
  167.         if (item_buff) {
  168.             if (b_type != eDB_DateTime) {
  169.                 throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  170.                                    "wrong type of CDB_Object");
  171.             }
  172.             if (v)
  173.                 ((CDB_DateTime*) item_buff)->Assign(v->dtdays, v->dttime);
  174.             else
  175.                 item_buff->AssignNULL();
  176.             return item_buff;
  177.         }
  179.         return v ? new CDB_DateTime(v->dtdays, v->dttime) : new CDB_DateTime;
  180.     }
  182.     case eDB_SmallDateTime: {
  183.         DBDATETIME4* v = (DBDATETIME4*)d_ptr;
  184.         if (item_buff) {
  185.             if (v) {
  186.                 switch (b_type) {
  187.                 case eDB_SmallDateTime:
  188.                     ((CDB_SmallDateTime*) item_buff)->Assign
  189.                         (DBDATETIME4_days(v),             DBDATETIME4_mins(v));
  190.                     break;
  191.                 case eDB_DateTime:
  192.                     ((CDB_DateTime*)      item_buff)->Assign
  193.                         ((int) DBDATETIME4_days(v), (int) DBDATETIME4_mins(v)*60*300);
  194.                     break;
  195.                 default:
  196.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  197.                                        "wrong type of CDB_Object");
  198.                 }
  199.             } else
  200.                 item_buff->AssignNULL();
  201.             return item_buff;
  202.         }
  204.         return v ?
  205.             new CDB_SmallDateTime(DBDATETIME4_days(v), DBDATETIME4_mins(v)) : new CDB_SmallDateTime;
  206.     }
  208.     case eDB_TinyInt: {
  209.         DBTINYINT* v = (DBTINYINT*) d_ptr;
  210.         if (item_buff) {
  211.             if (v) {
  212.                 switch (b_type) {
  213.                 case eDB_TinyInt:
  214.                     *((CDB_TinyInt*)  item_buff) = (Uint1) *v;
  215.                     break;
  216.                 case eDB_SmallInt:
  217.                     *((CDB_SmallInt*) item_buff) = (Int2)  *v;
  218.                     break;
  219.                 case eDB_Int:
  220.                     *((CDB_Int*)      item_buff) = (Int4)  *v;
  221.                     break;
  222.                 default:
  223.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  224.                                        "wrong type of CDB_Object");
  225.                 }
  226.             } else
  227.                 item_buff->AssignNULL();
  228.             return item_buff;
  229.         }
  231.         return v ? new CDB_TinyInt((Uint1) *v) : new CDB_TinyInt;
  232.     }
  234.     case eDB_SmallInt: {
  235.         DBSMALLINT* v = (DBSMALLINT*) d_ptr;
  236.         if (item_buff) {
  237.             if (v) {
  238.                 switch (b_type) {
  239.                 case eDB_SmallInt:
  240.                     *((CDB_SmallInt*) item_buff) = (Int2) *v;
  241.                     break;
  242.                 case eDB_Int:
  243.                     *((CDB_Int*)      item_buff) = (Int4) *v;
  244.                         break;
  245.                 default:
  246.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  247.                                        "wrong type of CDB_Object");
  248.                 }
  249.             } else
  250.                 item_buff->AssignNULL();
  251.             return item_buff;
  252.         }
  254.         return v ? new CDB_SmallInt((Int2) *v) : new CDB_SmallInt;
  255.     }
  257.     case eDB_Int: {
  258.         DBINT* v = (DBINT*) d_ptr;
  259.         if (item_buff) {
  260.             if (v) {
  261.                 if (b_type == eDB_Int)
  262.                     *((CDB_Int*) item_buff) = (Int4) *v;
  263.                 else {
  264.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  265.                                        "wrong type of CDB_Object");
  266.                 }
  267.             } else
  268.                 item_buff->AssignNULL();
  269.             return item_buff;
  270.         }
  272.         return v ? new CDB_Int((Int4) *v) : new CDB_Int;
  273.     }
  275.     case eDB_Double: {
  276.         if (item_buff && b_type != eDB_Double) {
  277.             throw CDB_ClientEx(eDB_Error, 130020, "s_GenericGetItem",
  278.                                "wrong type of CDB_Object");
  279.         }
  280.         DBFLT8* v = (DBFLT8*) d_ptr;
  281.         if (item_buff) {
  282.             if (v)
  283.                 *((CDB_Double*) item_buff) = (double) *v;
  284.             else
  285.                 item_buff->AssignNULL();
  286.             return item_buff;
  287.         }
  289.         return v ? new CDB_Double((double)*v) : new CDB_Double;
  290.     }
  292.     case eDB_Float: {
  293.         if (item_buff && b_type != eDB_Float) {
  294.             throw CDB_ClientEx(eDB_Error, 130020, "s_GenericGetItem",
  295.                                "wrong type of CDB_Object");
  296.         }
  297.         DBREAL* v = (DBREAL*) d_ptr;
  298.         if (item_buff) {
  299.             if (v)
  300.                 *((CDB_Float*) item_buff) = (float) *v;
  301.             else
  302.                 item_buff->AssignNULL();
  303.             return item_buff;
  304.         }
  306.         return v ? new CDB_Float((float)*v) : new CDB_Float;
  307.     }
  309.     case eDB_LongBinary: {
  310.         if (item_buff) {
  311.             switch (b_type) {
  312. case eDB_LongBinary:
  313.                 ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
  314.                                                        (size_t) d_len);
  315.                 break;
  316.             case eDB_LongChar:
  317.                 ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
  318.                                                        (size_t) d_len);
  319.                 break;
  321.             default:
  322.                 throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  323.                                    "wrong type of CDB_Object");
  324.             }
  325.             return item_buff;
  326.         }
  328.         return d_ptr ? new CDB_LongBinary((size_t) d_len, (const void*) d_ptr, 
  329.                                           (size_t) d_len)
  330.             : new CDB_LongBinary();
  331.     }
  333.     case eDB_LongChar: {
  334.         if (item_buff) {
  335.             switch (b_type) {
  336.             case eDB_LongChar:
  337.                 ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
  338.                                                        (size_t) d_len);
  339.                 break;
  340.             case eDB_LongBinary:
  341.                 ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
  342.                                                        (size_t) d_len);
  343.                 break;
  344.             default:
  345.                 throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  346.                                    "wrong type of CDB_Object");
  347.             }
  348.             return item_buff;
  349.         }
  351.         return d_ptr ? new CDB_LongChar((size_t) d_len, (const char*) d_ptr)
  352.             : new CDB_LongChar();
  353.     }
  355.     default:
  356.         return 0;
  357.     }
  358. }
  361. /////////////////////////////////////////////////////////////////////////////
  363. static EDB_Type s_GetDataType(DBPROCESS* cmd, int n)
  364. {
  365.     switch (dbcoltype(cmd, n)) {
  366.     case SYBBINARY:    return (dbcollen(cmd, n) > 255) ? eDB_LongBinary : 
  367.                                                          eDB_VarBinary;
  368.     case SYBBIT:       return eDB_Bit;
  369.     case SYBCHAR:      return (dbcollen(cmd, n) > 255) ? eDB_LongChar :
  370.                                                          eDB_VarChar;
  371.     case SYBDATETIME:  return eDB_DateTime;
  372.     case SYBDATETIME4: return eDB_SmallDateTime;
  373.     case SYBINT1:      return eDB_TinyInt;
  374.     case SYBINT2:      return eDB_SmallInt;
  375.     case SYBINT4:      return eDB_Int;
  376.     case SYBDECIMAL:
  377.     case SYBNUMERIC:   break;
  378.     case SYBFLT8:      return eDB_Double;
  379.     case SYBREAL:      return eDB_Float;
  380.     case SYBTEXT:      return eDB_Text;
  381.     case SYBIMAGE:     return eDB_Image;
  382.     default:           return eDB_UnsupportedType;
  383.     }
  385. #ifdef MS_DBLIB_IN_USE
  386.     DBCOL dbcol; dbcol.SizeOfStruct = sizeof(DBCOL);
  387.     RETCODE res = dbcolinfo(cmd, CI_REGULAR, n, 0, &dbcol );
  388.     return dbcol.Scale == 0 && dbcol.Precision < 20 ? eDB_BigInt : eDB_Numeric;
  389. #else
  390.     DBTYPEINFO* t = dbcoltypeinfo(cmd, n);
  391.     return t->scale == 0 && t->precision < 20 ? eDB_BigInt : eDB_Numeric;
  392. #endif
  394. }
  397. /////////////////////////////////////////////////////////////////////////////
  398. //
  399. //  CDBL_RowResult::
  400. //
  403. CDBL_RowResult::CDBL_RowResult(DBPROCESS* cmd,
  404.                                unsigned int* res_status, bool need_init) :
  405.     m_Cmd(cmd), m_CurrItem(-1), m_EOR(false),
  406.     m_ResStatus(res_status), m_Offset(0)
  407. {
  408.     if (!need_init)
  409.         return;
  411.     m_NofCols = dbnumcols(cmd);
  412.     m_CmdNum = DBCURCMD(cmd);
  414.     m_ColFmt = new SDBL_ColDescr[m_NofCols];
  415.     for (unsigned int n = 0; n < m_NofCols; n++) {
  416.         m_ColFmt[n].max_length = dbcollen(m_Cmd, n + 1);
  417.         m_ColFmt[n].data_type = s_GetDataType(m_Cmd, n + 1);
  418.         const char* s = dbcolname(m_Cmd, n + 1);
  419.         m_ColFmt[n].col_name = s ? s : "";
  420.     }
  421. }
  424. EDB_ResType CDBL_RowResult::ResultType() const
  425. {
  426.     return eDB_RowResult;
  427. }
  430. unsigned int CDBL_RowResult::NofItems() const
  431. {
  432.     return m_NofCols;
  433. }
  436. const char* CDBL_RowResult::ItemName(unsigned int item_num) const
  437. {
  438.     return item_num < m_NofCols ? m_ColFmt[item_num].col_name.c_str() : 0;
  439. }
  442. size_t CDBL_RowResult::ItemMaxSize(unsigned int item_num) const
  443. {
  444.     return item_num < m_NofCols ? m_ColFmt[item_num].max_length : 0;
  445. }
  448. EDB_Type CDBL_RowResult::ItemDataType(unsigned int item_num) const
  449. {
  450.     return item_num < m_NofCols
  451.         ? m_ColFmt[item_num].data_type : eDB_UnsupportedType;
  452. }
  455. bool CDBL_RowResult::Fetch()
  456. {
  457.     m_CurrItem = -1;
  458.     if (!m_EOR) {
  459.         switch (dbnextrow(m_Cmd)) {
  460.         case REG_ROW:
  461.             m_CurrItem = 0;
  462.             m_Offset = 0;
  463.             return true;
  464.         case NO_MORE_ROWS:
  465.             m_EOR = true;
  466.             break;
  467.         case FAIL:
  468.             throw CDB_ClientEx(eDB_Error, 230003, "CDBL_RowResult::Fetch",
  469.                                "error in fetching row");
  470.         case BUF_FULL:
  471.             throw CDB_ClientEx(eDB_Error, 230006, "CDBL_RowResult::Fetch",
  472.                                "buffer is full");
  473.         default:
  474.             *m_ResStatus|= 0x10;
  475.             m_EOR = true;
  476.             break;
  477.         }
  478.     }
  479.     return false;
  480. }
  483. int CDBL_RowResult::CurrentItemNo() const
  484. {
  485.     return m_CurrItem;
  486. }
  489. // Aux. for CDBL_RowResult::GetItem()
  490. static CDB_Object* s_GetItem(DBPROCESS* cmd, int item_no,
  491.                              SDBL_ColDescr* fmt, CDB_Object* item_buff)
  492. {
  493.     EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
  494.     const BYTE* d_ptr = dbdata  (cmd, item_no);
  495.     DBINT d_len = dbdatlen(cmd, item_no);
  497.     CDB_Object* val = s_GenericGetItem(fmt->data_type, item_buff,
  498.                                        b_type, d_ptr, d_len);
  499.     if (val)
  500.         return val;
  502.     switch (fmt->data_type) {
  503.     case eDB_BigInt: {
  504.         DBNUMERIC* v = (DBNUMERIC*) d_ptr;
  505.         if (item_buff) {
  506.             if (v) {
  507.                 if (b_type == eDB_Numeric) {
  508.                     ((CDB_Numeric*) item_buff)->Assign
  509.                         ((unsigned int)   v->precision,
  510.                          (unsigned int)   v->scale,
  511.                          (unsigned char*) DBNUMERIC_val(v));
  512.                 } else if (b_type == eDB_BigInt) {
  513.                     *((CDB_BigInt*) item_buff) = numeric_to_longlong
  514.                         ((unsigned int) v->precision, DBNUMERIC_val(v));
  515.                 } else {
  516.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GetItem",
  517.                                        "wrong type of CDB_Object");
  518.                 }
  519.             } else
  520.                 item_buff->AssignNULL();
  521.             return item_buff;
  522.         }
  524.         return v ?
  525.             new CDB_BigInt(numeric_to_longlong((unsigned int) v->precision,
  526.                                                DBNUMERIC_val(v))) : new CDB_BigInt;
  527.     }
  529.     case eDB_Numeric: {
  530.         DBNUMERIC* v = (DBNUMERIC*) d_ptr;
  531.         if (item_buff) {
  532.                 if (v) {
  533.                     if (b_type == eDB_Numeric) {
  534.                         ((CDB_Numeric*) item_buff)->Assign
  535.                             ((unsigned int)   v->precision,
  536.                              (unsigned int)   v->scale,
  537.                              (unsigned char*) DBNUMERIC_val(v));
  538.                     } else {
  539.                         throw CDB_ClientEx(eDB_Error, 230020, "s_GetItem",
  540.                                            "wrong type of CDB_Object");
  541.                     }
  542.                 } else
  543.                     item_buff->AssignNULL();
  544.                 return item_buff;
  545.         }
  547.         return v ?
  548.             new CDB_Numeric((unsigned int)   v->precision,
  549.                             (unsigned int)   v->scale,
  550.                             (unsigned char*) DBNUMERIC_val(v)) : new CDB_Numeric;
  551.     }
  553.     case eDB_Text: {
  554.         if (item_buff && b_type != eDB_Text && b_type != eDB_Image) {
  555.             throw CDB_ClientEx(eDB_Error, 130020, "s_GetItem",
  556.                                "wrong type of CDB_Object");
  557.         }
  558.         CDB_Text* v = item_buff ? (CDB_Text*) item_buff : new CDB_Text;
  559.         v->Append((char*) d_ptr, (int) d_len);
  560.         return v;
  561.     }
  563.     case eDB_Image: {
  564.         if (item_buff && b_type != eDB_Text && b_type != eDB_Image) {
  565.             throw CDB_ClientEx(eDB_Error, 130020, "s_GetItem",
  566.                                "wrong type of CDB_Object");
  567.         }
  568.         CDB_Image* v = item_buff ? (CDB_Image*) item_buff : new CDB_Image;
  569.         v->Append((void*) d_ptr, (int) d_len);
  570.         return v;
  571.     }
  573.     default:
  574.         throw CDB_ClientEx(eDB_Error, 130004, "s_GetItem",
  575.                            "unexpected result type");
  576.     }
  577. }
  580. CDB_Object* CDBL_RowResult::GetItem(CDB_Object* item_buff)
  581. {
  582.     if ((unsigned int) m_CurrItem >= m_NofCols) {
  583.         return 0;
  584.     }
  585.     CDB_Object* r = s_GetItem(m_Cmd, m_CurrItem + 1,
  586.                               &m_ColFmt[m_CurrItem], item_buff);
  587.     ++m_CurrItem;
  588.     m_Offset = 0;
  589.     return r;
  590. }
  593. size_t CDBL_RowResult::ReadItem(void* buffer, size_t buffer_size,bool* is_null)
  594. {
  595.     if ((unsigned int) m_CurrItem >= m_NofCols) {
  596.         if (is_null)
  597.             *is_null = true;
  598.         return 0;
  599.     }
  601.     const BYTE* d_ptr = dbdata  (m_Cmd, m_CurrItem + 1);
  602.     DBINT d_len = dbdatlen(m_Cmd, m_CurrItem + 1);
  604.     if (d_ptr == 0 || d_len < 1) { // NULL value
  605.         ++m_CurrItem;
  606.         m_Offset = 0;
  607.         if (is_null)
  608.             *is_null = true;
  609.         return 0;
  610.     }
  612.     if (is_null)
  613.         *is_null = false;
  614.     if ((size_t) d_len - m_Offset < buffer_size)
  615.         buffer_size = (size_t) d_len - m_Offset;
  616.     memcpy(buffer, d_ptr + m_Offset, buffer_size);
  617.     m_Offset += buffer_size;
  618.     if (m_Offset >= (size_t) d_len) {
  619.         m_Offset = 0;
  620.         ++m_CurrItem;
  621.     }
  623.     return buffer_size;
  624. }
  627. I_ITDescriptor* CDBL_RowResult::GetImageOrTextDescriptor()
  628. {
  629.     if ((unsigned int) m_CurrItem >= m_NofCols)
  630.         return 0;
  631.     return new CDBL_ITDescriptor(m_Cmd, m_CurrItem+1);
  632. }
  635. bool CDBL_RowResult::SkipItem()
  636. {
  637.     if ((unsigned int) m_CurrItem < m_NofCols) {
  638.         ++m_CurrItem;
  639.         m_Offset = 0;
  640.         return true;
  641.     }
  642.     return false;
  643. }
  646. CDBL_RowResult::~CDBL_RowResult()
  647. {
  648.     if (m_ColFmt) {
  649.         delete[] m_ColFmt;
  650.         m_ColFmt = 0;
  651.     }
  652.     if (!m_EOR)
  653.         dbcanquery(m_Cmd);
  654. }
  658. /////////////////////////////////////////////////////////////////////////////
  659. //
  660. //  CDBL_BlobResult::
  663. CDBL_BlobResult::CDBL_BlobResult(DBPROCESS* cmd) :
  664.     m_Cmd(cmd), m_CurrItem(-1), m_EOR(false)
  665. {
  666.     m_CmdNum = DBCURCMD(cmd);
  668.     m_ColFmt.max_length = dbcollen(m_Cmd, 1);
  669.     m_ColFmt.data_type = s_GetDataType(m_Cmd, 1);
  670.     const char* s = dbcolname(m_Cmd, 1);
  671.     m_ColFmt.col_name = s ? s : "";
  672. }
  674. EDB_ResType CDBL_BlobResult::ResultType() const
  675. {
  676.     return eDB_RowResult;
  677. }
  680. unsigned int CDBL_BlobResult::NofItems() const
  681. {
  682.     return 1;
  683. }
  686. const char* CDBL_BlobResult::ItemName(unsigned int item_num) const
  687. {
  688.     return item_num ? 0 : m_ColFmt.col_name.c_str();
  689. }
  692. size_t CDBL_BlobResult::ItemMaxSize(unsigned int item_num) const
  693. {
  694.     return item_num ? 0 : m_ColFmt.max_length;
  695. }
  698. EDB_Type CDBL_BlobResult::ItemDataType(unsigned int) const
  699. {
  700.     return m_ColFmt.data_type;
  701. }
  704. bool CDBL_BlobResult::Fetch()
  705. {
  706.     if (m_EOR)
  707.         return false;
  709.     STATUS s;
  710.     if (m_CurrItem == 0) {
  711.         while ((s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff))) > 0)
  712.             ;
  713.         switch (s) {
  714.         case 0:
  715.             break;
  716.         case NO_MORE_ROWS:
  717.             m_EOR = true;
  718.             return false;
  719.         default:
  720.             throw CDB_ClientEx(eDB_Error, 280003, "CDBL_BlobResult::Fetch",
  721.                                "error in fetching row");
  722.         }
  723.     }
  724.     else m_CurrItem = 0;
  725.     s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff));
  726.     if(s == NO_MORE_ROWS) return false;
  727.     if(s < 0) {
  728.         throw CDB_ClientEx(eDB_Error, 280003, "CDBL_BlobResult::Fetch",
  729.                            "error in fetching row");
  730.     }
  731.     m_BytesInBuffer= s;
  732.     m_ReadedBytes= 0;
  733.     return true;
  734. }
  737. int CDBL_BlobResult::CurrentItemNo() const
  738. {
  739.     return m_CurrItem;
  740. }
  743. CDB_Object* CDBL_BlobResult::GetItem(CDB_Object* item_buff)
  744. {
  745.     if (m_CurrItem)
  746.         return 0;
  748.     EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
  750.     if (item_buff && b_type != eDB_Text && b_type != eDB_Image) {
  751.         throw CDB_ClientEx(eDB_Error, 230020, "CDBL_BlobResult::GetItem",
  752.                            "wrong type of CDB_Object");
  753.     }
  755.     if (item_buff == 0) {
  756.         item_buff = m_ColFmt.data_type == eDB_Text
  757.             ? (CDB_Object*) new CDB_Text : (CDB_Object*) new CDB_Image;
  758.     }
  760.     CDB_Text* val = (CDB_Text*) item_buff;
  762.     // check if we do have something in buffer
  763.     if(m_ReadedBytes < m_BytesInBuffer) {
  764.         val->Append(m_Buff + m_ReadedBytes, m_BytesInBuffer - m_ReadedBytes);
  765.         m_ReadedBytes= m_BytesInBuffer;
  766.     }
  768.     if(m_BytesInBuffer == 0) {
  769.         return item_buff;
  770.     }
  771.         
  773.     STATUS s;
  774.     while ((s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff))) > 0)
  775.         val->Append(m_Buff, (s < sizeof(m_Buff))? (size_t)s : sizeof(m_Buff));
  777.     switch (s) {
  778.     case NO_MORE_ROWS:
  779.         m_EOR = true;
  780.     case 0:
  781.         m_CurrItem = 1;
  782.         break;
  783.     default:
  784.         throw CDB_ClientEx(eDB_Error, 280003, "CDBL_BlobResult::GetItem",
  785.                            "dbreadtext failed");
  786.     }
  788.     return item_buff;
  789. }
  792. size_t CDBL_BlobResult::ReadItem(void* buffer, size_t buffer_size,
  793.                                  bool* is_null)
  794. {
  795.     if(m_BytesInBuffer == 0) 
  796.         m_CurrItem= 1;
  798.     if (m_CurrItem != 0) {
  799.         if (is_null)
  800.             *is_null = true;
  801.         return 0;
  802.     }
  804.     size_t l= 0;
  805.     // check if we do have something in buffer
  806.     if(m_ReadedBytes < m_BytesInBuffer) {
  807.         l= m_BytesInBuffer - m_ReadedBytes;
  808.         if(l >= buffer_size) {
  809.             memcpy(buffer, m_Buff + m_ReadedBytes, buffer_size);
  810.             m_ReadedBytes+= buffer_size;
  811.             if (is_null)
  812.                 *is_null = false;
  813.             return buffer_size;
  814.         }
  815.         memcpy(buffer, m_Buff + m_ReadedBytes, l);
  816.     }
  817.         
  818.     STATUS s = dbreadtext(m_Cmd, (void*)((char*)buffer + l), (DBINT)(buffer_size-l));
  819.     switch (s) {
  820.     case NO_MORE_ROWS:
  821.         m_EOR = true;
  822.     case 0:
  823.         m_CurrItem = 1;
  824.         break;
  825.     case -1:
  826.         throw CDB_ClientEx(eDB_Error, 280003, "CDBL_BlobResult::ReadItem",
  827.                            "dbreadtext failed");
  828.     default:
  829.         break;
  830.     }
  832.     if(is_null) *is_null= (m_BytesInBuffer == 0 && s <= 0);
  833.     return (size_t) s + l;
  834. }
  837. I_ITDescriptor* CDBL_BlobResult::GetImageOrTextDescriptor()
  838. {
  839.     if (m_CurrItem != 0)
  840.         return 0;
  841.     return new CDBL_ITDescriptor(m_Cmd, 1);
  842. }
  845. bool CDBL_BlobResult::SkipItem()
  846. {
  847.     if (m_EOR || m_CurrItem)
  848.         return false;
  850.     STATUS s;
  851.     while ((s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff))) > 0);
  852.     switch (s) {
  853.     case NO_MORE_ROWS:
  854.         m_EOR = true;
  855.     case 0:
  856.         m_CurrItem = 1;
  857.         break;
  858.     default:
  859.         throw CDB_ClientEx(eDB_Error, 280003, "CDBL_BlobResult::SkipItem",
  860.                            "dbreadtext failed");
  861.     }
  862.     return true;
  863. }
  866. CDBL_BlobResult::~CDBL_BlobResult()
  867. {
  868.     if (!m_EOR)
  869.         dbcanquery(m_Cmd);
  870. }
  873. /////////////////////////////////////////////////////////////////////////////
  875. static EDB_Type s_RetGetDataType(DBPROCESS* cmd, int n)
  876. {
  877.     switch (dbrettype(cmd, n)) {
  878.     case SYBBINARY:    return (dbretlen(cmd, n) > 255)? eDB_LongBinary : 
  879.                                                         eDB_VarBinary;
  880.     case SYBBIT:       return eDB_Bit;
  881.     case SYBCHAR:      return (dbretlen(cmd, n) > 255)? eDB_LongChar : 
  882.                                                         eDB_VarChar;
  883.     case SYBDATETIME:  return eDB_DateTime;
  884.     case SYBDATETIME4: return eDB_SmallDateTime;
  885.     case SYBINT1:      return eDB_TinyInt;
  886.     case SYBINT2:      return eDB_SmallInt;
  887.     case SYBINT4:      return eDB_Int;
  888.     case SYBFLT8:      return eDB_Double;
  889.     case SYBREAL:      return eDB_Float;
  890.     default:           return eDB_UnsupportedType;
  891.     }
  892. }
  895. // Aux. for CDBL_ParamResult::GetItem()
  896. static CDB_Object* s_RetGetItem(DBPROCESS* cmd, int item_no,
  897.                                 SDBL_ColDescr* fmt, CDB_Object* item_buff)
  898. {
  899.     EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
  900.     const BYTE* d_ptr = dbretdata(cmd, item_no);
  901.     DBINT d_len = dbretlen (cmd, item_no);
  902.     CDB_Object* val = s_GenericGetItem(fmt->data_type, item_buff,
  903.                                        b_type, d_ptr, d_len);
  904.     if (!val) {
  905.         throw CDB_ClientEx(eDB_Error, 230004, "s_RetGetItem",
  906.                            "unexpected result type");
  907.     }
  908.     return val;
  909. }
  912. /////////////////////////////////////////////////////////////////////////////
  913. //
  914. //  CDBL_ParamResult::
  915. //
  917. CDBL_ParamResult::CDBL_ParamResult(DBPROCESS* cmd, int nof_params) :
  918.     CDBL_RowResult(cmd, 0, false)
  919. {
  921.     m_NofCols = nof_params;
  922.     m_CmdNum = DBCURCMD(cmd);
  924.     m_ColFmt = new SDBL_ColDescr[m_NofCols];
  925.     for (unsigned int n = 0; n < m_NofCols; n++) {
  926.         m_ColFmt[n].max_length = 255;
  927.         m_ColFmt[n].data_type = s_RetGetDataType(m_Cmd, n + 1);
  928.         const char* s = dbretname(m_Cmd, n + 1);
  929.         m_ColFmt[n].col_name = s ? s : "";
  930.     }
  931.     m_1stFetch = true;
  932. }
  935. EDB_ResType CDBL_ParamResult::ResultType() const
  936. {
  937.     return eDB_ParamResult;
  938. }
  941. bool CDBL_ParamResult::Fetch()
  942. {
  943.     if (m_1stFetch) { // we didn't get the items yet;
  944.         m_1stFetch = false;
  945. m_CurrItem= 0;
  946.         return true;
  947.     }
  948.     m_CurrItem= -1;
  949.     return false;
  950. }
  953. CDB_Object* CDBL_ParamResult::GetItem(CDB_Object* item_buff)
  954. {
  955.     if ((unsigned int) m_CurrItem >= m_NofCols) {
  956.         return 0;
  957.     }
  959.     CDB_Object* r = s_RetGetItem(m_Cmd, m_CurrItem + 1,
  960.                                  &m_ColFmt[m_CurrItem], item_buff);
  961.     ++m_CurrItem;
  962.     m_Offset = 0;
  963.     return r;
  964. }
  967. size_t CDBL_ParamResult::ReadItem(void* buffer, size_t buffer_size,
  968.                                   bool* is_null)
  969. {
  970.     if ((unsigned int) m_CurrItem >= m_NofCols) {
  971.         if (is_null)
  972.             *is_null = true;
  973.         return 0;
  974.     }
  976.     const BYTE* d_ptr = dbretdata(m_Cmd, m_CurrItem + 1);
  977.     DBINT d_len = dbretlen (m_Cmd, m_CurrItem + 1);
  979.     if (d_ptr == 0 || d_len < 1) { // NULL value
  980.         ++m_CurrItem;
  981.         m_Offset = 0;
  982.         if (is_null)
  983.             *is_null = true;
  984.         return 0;
  985.     }
  987.     if (is_null)
  988.         *is_null = false;
  989.     if ((size_t) d_len - m_Offset < buffer_size)
  990.         buffer_size = (size_t) d_len - m_Offset;
  991.     memcpy(buffer, d_ptr + m_Offset, buffer_size);
  992.     m_Offset += buffer_size;
  993.     if (m_Offset >= (size_t) d_len) {
  994.         m_Offset = 0;
  995.         ++m_CurrItem;
  996.     }
  997.     return buffer_size;
  998. }
  1001. I_ITDescriptor* CDBL_ParamResult::GetImageOrTextDescriptor()
  1002. {
  1003.     return 0;
  1004. }
  1007. CDBL_ParamResult::~CDBL_ParamResult()
  1008. {
  1009.     if (m_ColFmt) {
  1010.         delete[] m_ColFmt;
  1011.         m_ColFmt = 0;
  1012.     }
  1013. }
  1016. /////////////////////////////////////////////////////////////////////////////
  1018. static EDB_Type s_AltGetDataType(DBPROCESS* cmd, int id, int n)
  1019. {
  1020.     switch (dbalttype(cmd, id, n)) {
  1021.     case SYBBINARY:    return (dbaltlen(cmd, id, n) > 255)? eDB_LongBinary : 
  1022.                                                         eDB_VarBinary;
  1023.     case SYBBIT:       return eDB_Bit;
  1024.     case SYBCHAR:      return (dbaltlen(cmd, id, n) > 255)? eDB_LongChar : 
  1025.                                                         eDB_VarChar;
  1026.     case SYBDATETIME:  return eDB_DateTime;
  1027.     case SYBDATETIME4: return eDB_SmallDateTime;
  1028.     case SYBINT1:      return eDB_TinyInt;
  1029.     case SYBINT2:      return eDB_SmallInt;
  1030.     case SYBINT4:      return eDB_Int;
  1031.     case SYBFLT8:      return eDB_Double;
  1032.     case SYBREAL:      return eDB_Float;
  1033.     default:           return eDB_UnsupportedType;
  1034.     }
  1035. }
  1038. // Aux. for CDBL_ComputeResult::GetItem()
  1039. static CDB_Object* s_AltGetItem(DBPROCESS* cmd, int id, int item_no,
  1040.                                 SDBL_ColDescr* fmt, CDB_Object* item_buff)
  1041. {
  1042.     EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
  1043.     const BYTE* d_ptr = dbadata(cmd, id, item_no);
  1044.     DBINT d_len = dbadlen(cmd, id, item_no);
  1045.     CDB_Object* val = s_GenericGetItem(fmt->data_type, item_buff,
  1046.                                        b_type, d_ptr, d_len);
  1047.     if (!val) {
  1048.         throw CDB_ClientEx(eDB_Error, 130004, "s_AltGetItem",
  1049.                            "unexpected result type");
  1050.     }
  1051.     return val;
  1052. }
  1056. /////////////////////////////////////////////////////////////////////////////
  1057. //
  1058. //  CTL_ComputeResult::
  1059. //
  1061. CDBL_ComputeResult::CDBL_ComputeResult(DBPROCESS* cmd,
  1062.                                        unsigned int* res_stat) :
  1063.     CDBL_RowResult(cmd, res_stat, false)
  1064. {
  1065.     m_ComputeId = DBROWTYPE(cmd);
  1066.     if (m_ComputeId == REG_ROW || m_ComputeId == NO_MORE_ROWS) {
  1067.         throw CDB_ClientEx(eDB_Error, 270000,
  1068.                            "CDBL_ComputeResult::CDBL_ComputeResult",
  1069.                            "no compute row found");
  1070.     }
  1071.     m_NofCols = dbnumalts(cmd, m_ComputeId);
  1072.     if (m_NofCols < 1) {
  1073.         throw CDB_ClientEx(eDB_Error, 270001,
  1074.                            "CDBL_ComputeResult::CDBL_ComputeResult",
  1075.                            "compute id is invalid");
  1076.     }
  1077.     m_CmdNum = DBCURCMD(cmd);
  1078.     m_ColFmt = new SDBL_ColDescr[m_NofCols];
  1079.     for (unsigned int n = 0; n < m_NofCols; n++) {
  1080.         m_ColFmt[n].max_length = dbaltlen(m_Cmd, m_ComputeId, n+1);
  1081.         m_ColFmt[n].data_type = s_AltGetDataType(m_Cmd, m_ComputeId, n + 1);
  1082.         int op = dbaltop(m_Cmd, m_ComputeId, n + 1);
  1083.         const char* s = op != -1 ? dbprtype(op) : "Unknown";
  1084.         m_ColFmt[n].col_name = s ? s : "";
  1085.     }
  1086.     m_1stFetch = true;
  1087. }
  1090. EDB_ResType CDBL_ComputeResult::ResultType() const
  1091. {
  1092.     return eDB_ComputeResult;
  1093. }
  1096. bool CDBL_ComputeResult::Fetch()
  1097. {
  1098.     if (m_1stFetch) { // we didn't get the items yet;
  1099.         m_1stFetch = false;
  1100. m_CurrItem= 0;
  1101.         return true;
  1102.     }
  1104.     STATUS s = dbnextrow(m_Cmd);
  1105.     switch (s) {
  1106.     case REG_ROW:
  1107.     case NO_MORE_ROWS:
  1108.         *m_ResStatus ^= 0x10;
  1109.         break;
  1110.     case FAIL:
  1111.         throw CDB_ClientEx(eDB_Error, 270003, "CDBL_ComputeResult::Fetch",
  1112.                            "error in fetching row");
  1113.     case BUF_FULL:
  1114.         throw CDB_ClientEx(eDB_Error, 270006, "CDBL_ComputeResult::Fetch",
  1115.                            "buffer is full");
  1116.     default:
  1117.         break;
  1118.     }
  1119.     m_EOR = true;
  1120.     m_CurrItem= -1;
  1121.     return false;
  1122. }
  1125. int CDBL_ComputeResult::CurrentItemNo() const
  1126. {
  1127.     return m_CurrItem;
  1128. }
  1131. CDB_Object* CDBL_ComputeResult::GetItem(CDB_Object* item_buff)
  1132. {
  1133.     if ((unsigned int) m_CurrItem >= m_NofCols) {
  1134.         return 0;
  1135.     }
  1136.     CDB_Object* r = s_AltGetItem(m_Cmd, m_ComputeId, m_CurrItem + 1,
  1137.                                  &m_ColFmt[m_CurrItem], item_buff);
  1138.     ++m_CurrItem;
  1139.     m_Offset = 0;
  1140.     return r;
  1141. }
  1144. size_t CDBL_ComputeResult::ReadItem(void* buffer, size_t buffer_size,
  1145.                                     bool* is_null)
  1146. {
  1147.     if ((unsigned int) m_CurrItem >= m_NofCols) {
  1148.         if (is_null)
  1149.             *is_null = true;
  1150.         return 0;
  1151.     }
  1153.     const BYTE* d_ptr = dbadata(m_Cmd, m_ComputeId, m_CurrItem + 1);
  1154.     DBINT d_len = dbadlen(m_Cmd, m_ComputeId, m_CurrItem + 1);
  1156.     if (d_ptr == 0 || d_len < 1) { // NULL value
  1157.         ++m_CurrItem;
  1158.         m_Offset = 0;
  1159.         if (is_null)
  1160.             *is_null = true;
  1161.         return 0;
  1162.     }
  1164.     if (is_null)
  1165.         *is_null = false;
  1166.     if ((size_t) d_len - m_Offset < buffer_size)
  1167.         buffer_size = (size_t) d_len - m_Offset;
  1168.     memcpy(buffer, d_ptr + m_Offset, buffer_size);
  1169.     m_Offset += buffer_size;
  1170.     if (m_Offset >= (size_t) d_len) {
  1171.         m_Offset = 0;
  1172.         ++m_CurrItem;
  1173.     }
  1174.     return buffer_size;
  1175. }
  1178. I_ITDescriptor* CDBL_ComputeResult::GetImageOrTextDescriptor()
  1179. {
  1180.     return 0;
  1181. }
  1184. CDBL_ComputeResult::~CDBL_ComputeResult()
  1185. {
  1186.     if (m_ColFmt) {
  1187.         delete[] m_ColFmt;
  1188.         m_ColFmt = 0;
  1189.     }
  1190.     while (!m_EOR)
  1191.         Fetch();
  1192. }
  1196. /////////////////////////////////////////////////////////////////////////////
  1197. //
  1198. //  CTL_StatusResult::
  1199. //
  1202. CDBL_StatusResult::CDBL_StatusResult(DBPROCESS* cmd) :
  1203.     m_Offset(0), m_1stFetch(true)
  1204. {
  1205.     m_Val = dbretstatus(cmd);
  1206. }
  1209. EDB_ResType CDBL_StatusResult::ResultType() const
  1210. {
  1211.     return eDB_StatusResult;
  1212. }
  1215. unsigned int CDBL_StatusResult::NofItems() const
  1216. {
  1217.     return 1;
  1218. }
  1221. const char* CDBL_StatusResult::ItemName(unsigned int) const
  1222. {
  1223.     return 0;
  1224. }
  1227. size_t CDBL_StatusResult::ItemMaxSize(unsigned int) const
  1228. {
  1229.     return sizeof(DBINT);
  1230. }
  1233. EDB_Type CDBL_StatusResult::ItemDataType(unsigned int) const
  1234. {
  1235.     return eDB_Int;
  1236. }
  1239. bool CDBL_StatusResult::Fetch()
  1240. {
  1241.     if (m_1stFetch) {
  1242.         m_1stFetch = false;
  1243.         return true;
  1244.     }
  1245.     return false;
  1246. }
  1249. int CDBL_StatusResult::CurrentItemNo() const
  1250. {
  1251.     return m_1stFetch? -1 : 0;
  1252. }
  1255. CDB_Object* CDBL_StatusResult::GetItem(CDB_Object* item_buff)
  1256. {
  1257.     if (!item_buff)
  1258.         return new CDB_Int(m_Val);
  1260.     if (item_buff->GetType() != eDB_Int) {
  1261.         throw CDB_ClientEx(eDB_Error, 230020, "CDBL_StatusResult::GetItem",
  1262.                            "wrong type of CDB_Object");
  1263.     }
  1265.     CDB_Int* i = (CDB_Int*) item_buff;
  1266.     *i = m_Val;
  1267.     return item_buff;
  1268. }
  1271. size_t CDBL_StatusResult::ReadItem(void* buffer, size_t buffer_size,
  1272.                                    bool* is_null)
  1273. {
  1274.     if (is_null)
  1275.         *is_null = false;
  1277.     if (sizeof(m_Val) <= m_Offset)
  1278.         return 0;
  1280.     size_t l = sizeof(int) - m_Offset;
  1281.     char* p = (char*) &m_Val;
  1283.     if (buffer_size > l)
  1284.         buffer_size = l;
  1285.     memcpy(buffer, p + m_Offset, buffer_size);
  1286.     m_Offset += buffer_size;
  1287.     return buffer_size;
  1288. }
  1291. I_ITDescriptor* CDBL_StatusResult::GetImageOrTextDescriptor()
  1292. {
  1293.     return 0;
  1294. }
  1297. bool CDBL_StatusResult::SkipItem()
  1298. {
  1299.     return false;
  1300. }
  1303. CDBL_StatusResult::~CDBL_StatusResult()
  1304. {
  1305. }
  1309. /////////////////////////////////////////////////////////////////////////////
  1310. //
  1311. //  CTL_CursorResult::
  1312. //
  1314. CDBL_CursorResult::CDBL_CursorResult(CDB_LangCmd* cmd) :
  1315.     m_Cmd(cmd), m_Res(0)
  1316. {
  1317.     try {
  1318.         m_Cmd->Send();
  1319.         while (m_Cmd->HasMoreResults()) {
  1320.             m_Res = m_Cmd->Result();
  1321.             if (m_Res && m_Res->ResultType() == eDB_RowResult) {
  1322.                 return;
  1323.             }
  1324.             if (m_Res) {
  1325.                 while (m_Res->Fetch())
  1326.                     ;
  1327.                 delete m_Res;
  1328.                 m_Res = 0;
  1329.             }
  1330.         }
  1331.     } catch (CDB_Exception& ) {
  1332.         throw CDB_ClientEx(eDB_Error, 222010,
  1333.                            "CDBL_CursorResult::CDBL_CursorResult",
  1334.                            "failed to get the results");
  1335.     }
  1336. }
  1339. EDB_ResType CDBL_CursorResult::ResultType() const
  1340. {
  1341.     return eDB_CursorResult;
  1342. }
  1345. unsigned int CDBL_CursorResult::NofItems() const
  1346. {
  1347.     return m_Res? m_Res->NofItems() : 0;
  1348. }
  1351. const char* CDBL_CursorResult::ItemName(unsigned int item_num) const
  1352. {
  1353.     return m_Res ? m_Res->ItemName(item_num) : 0;
  1354. }
  1357. size_t CDBL_CursorResult::ItemMaxSize(unsigned int item_num) const
  1358. {
  1359.     return m_Res ? m_Res->ItemMaxSize(item_num) : 0;
  1360. }
  1363. EDB_Type CDBL_CursorResult::ItemDataType(unsigned int item_num) const
  1364. {
  1365.     return m_Res ? m_Res->ItemDataType(item_num) : eDB_UnsupportedType;
  1366. }
  1369. bool CDBL_CursorResult::Fetch()
  1370. {
  1371.     if (!m_Res)
  1372.         return false;
  1373.     if (m_Res->Fetch())
  1374.         return true;
  1376.     try {
  1377.         // finish this command
  1378.         delete m_Res;
  1379.         while (m_Cmd->HasMoreResults()) {
  1380.             m_Res = m_Cmd->Result();
  1381.             if (m_Res) {
  1382.                 while (m_Res->Fetch())
  1383.                     ;
  1384.                 delete m_Res;
  1385.                 m_Res = 0;
  1386.             }
  1387.         }
  1388.         // send the another "fetch cursor_name" command
  1389.         m_Cmd->Send();
  1390.         while (m_Cmd->HasMoreResults()) {
  1391.             m_Res = m_Cmd->Result();
  1392.             if (m_Res && m_Res->ResultType() == eDB_RowResult) {
  1393.                 return m_Res->Fetch();
  1394.             }
  1395.             if (m_Res) {
  1396.                 while (m_Res->Fetch())
  1397.                     ;
  1398.                 delete m_Res;
  1399.                 m_Res = 0;
  1400.             }
  1401.         }
  1402.     } catch (CDB_Exception& ) {
  1403.         throw CDB_ClientEx(eDB_Error, 222011, "CDBL_CursorResult::Fetch",
  1404.                            "Failed to fetch the results");
  1405.     }
  1406.     return false;
  1407. }
  1410. int CDBL_CursorResult::CurrentItemNo() const
  1411. {
  1412.     return m_Res ? m_Res->CurrentItemNo() : -1;
  1413. }
  1416. CDB_Object* CDBL_CursorResult::GetItem(CDB_Object* item_buff)
  1417. {
  1418.     return m_Res ? m_Res->GetItem(item_buff) : 0;
  1419. }
  1422. size_t CDBL_CursorResult::ReadItem(void* buffer, size_t buffer_size,
  1423.                                    bool* is_null)
  1424. {
  1425.     if (m_Res) {
  1426.         return m_Res->ReadItem(buffer, buffer_size, is_null);
  1427.     }
  1428.     if (is_null)
  1429.         *is_null = true;
  1430.     return 0;
  1431. }
  1434. I_ITDescriptor* CDBL_CursorResult::GetImageOrTextDescriptor()
  1435. {
  1436.     return m_Res ? m_Res->GetImageOrTextDescriptor() : 0;
  1437. }
  1440. bool CDBL_CursorResult::SkipItem()
  1441. {
  1442.     return m_Res ? m_Res->SkipItem() : false;
  1443. }
  1446. CDBL_CursorResult::~CDBL_CursorResult()
  1447. {
  1448.     if (m_Res)
  1449.         delete m_Res;
  1450. }
  1454. /////////////////////////////////////////////////////////////////////////////
  1455. //
  1456. //  CDBL_ITDescriptor::
  1457. //
  1459. CDBL_ITDescriptor::CDBL_ITDescriptor(DBPROCESS* dblink, int col_num)
  1460. {
  1461. #ifdef MS_DBLIB_IN_USE /*Text,Image*/
  1462.     const char* pColName = dbcolname(dblink,col_num);
  1463.     if(pColName == NULL) {
  1464.         throw CDB_ClientEx(eDB_Error, 280000,
  1465.                            "CDBL_ITDescriptor::CDBL_ITDescriptor",
  1466.                            "dbcolname() returns NULL");
  1467.     }
  1469.     // We have to use an offset in some undocumented structure
  1470.     // (obtained with the help of a debugger).
  1471.     // It may change in future MS dblib versions...
  1472.     const char* pTabName = *(char**)(pColName+50);
  1474.     m_ObjName += pTabName;
  1475.     m_ObjName += ".";
  1476.     m_ObjName += pColName;
  1477. #else
  1478.     DBCOLINFO* col_info = (DBCOLINFO*) dbcolname(dblink, col_num);
  1480.     if (col_info == 0) {
  1481.         throw CDB_ClientEx(eDB_Error, 280000,
  1482.                            "CDBL_ITDescriptor::CDBL_ITDescriptor",
  1483.                            "Can not get the DBCOLINFO*");
  1484.     }
  1485.     if (!x_MakeObjName(col_info)) {
  1486.         m_ObjName = "";
  1487.     }
  1488. #endif
  1490.     DBBINARY* p = dbtxptr(dblink, col_num);
  1491.     if (p) {
  1492.         memcpy(m_TxtPtr, p, DBTXPLEN);
  1493.         m_TxtPtr_is_NULL = false;
  1494.     } else
  1495.         m_TxtPtr_is_NULL = true;
  1497.     p = dbtxtimestamp(dblink, col_num);
  1498.     if (p) {
  1499.         memcpy(m_TimeStamp, p, DBTXTSLEN);
  1500.         m_TimeStamp_is_NULL = false;
  1501.     } else
  1502.         m_TimeStamp_is_NULL = true;
  1503. }
  1505. CDBL_ITDescriptor::CDBL_ITDescriptor(DBPROCESS* dblink, const CDB_ITDescriptor& inp_d)
  1506. {
  1507.     m_ObjName= inp_d.TableName();
  1508.     m_ObjName+= ".";
  1509.     m_ObjName+= inp_d.ColumnName();
  1510.     
  1512.     DBBINARY* p = dbtxptr(dblink, 1);
  1513.     if (p) {
  1514.         memcpy(m_TxtPtr, p, DBTXPLEN);
  1515.         m_TxtPtr_is_NULL = false;
  1516.     } else
  1517.         m_TxtPtr_is_NULL = true;
  1519.     p = dbtxtimestamp(dblink, 1);
  1520.     if (p) {
  1521.         memcpy(m_TimeStamp, p, DBTXTSLEN);
  1522.         m_TimeStamp_is_NULL = false;
  1523.     } else
  1524.         m_TimeStamp_is_NULL = true;
  1525. }
  1528. int CDBL_ITDescriptor::DescriptorType() const
  1529. {
  1530. #ifndef MS_DBLIB_IN_USE
  1531.     return CDBL_ITDESCRIPTOR_TYPE_MAGNUM;
  1532. #else
  1533. return CMSDBL_ITDESCRIPTOR_TYPE_MAGNUM;
  1534. #endif
  1535. }
  1537. CDBL_ITDescriptor::~CDBL_ITDescriptor()
  1538. {
  1539. }
  1541. #ifndef MS_DBLIB_IN_USE
  1542. bool CDBL_ITDescriptor::x_MakeObjName(DBCOLINFO* col_info)
  1543. {
  1544.     if (!col_info || !col_info->coltxobjname)
  1545.         return false;
  1546.     m_ObjName = col_info->coltxobjname;
  1548.     // check if we do have ".colname" suffix already
  1549.     char* p_dot = strrchr(col_info->coltxobjname, '.');
  1550.     if (!p_dot || strcmp(p_dot + 1, col_info->colname) != 0) {
  1551.         // we don't have a suffix. Add it now
  1552.         m_ObjName += '.';
  1553.         m_ObjName += col_info->colname;
  1554.     }
  1555.     return true;
  1556. }
  1557. #endif
  1560. END_NCBI_SCOPE
  1564. /*
  1565.  * ===========================================================================
  1566.  * $Log: result.cpp,v $
  1567.  * Revision 1000.2  2004/06/01 19:20:21  gouriano
  1568.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.22
  1569.  *
  1570.  * Revision 1.22  2004/05/18 18:30:36  gorelenk
  1571.  * PCH <ncbi_pch.hpp> moved to correct place .
  1572.  *
  1573.  * Revision 1.21  2004/05/17 21:12:41  gorelenk
  1574.  * Added include of PCH ncbi_pch.hpp
  1575.  *
  1576.  * Revision 1.20  2004/04/08 19:05:51  gorelenk
  1577.  * Changed declalation of s_GenericGetItem (added 'const' to 'BYTE* d_ptr')
  1578.  * and fixed compilation errors on MSVC 7.10 .
  1579.  *
  1580.  * Revision 1.19  2003/04/29 21:16:21  soussov
  1581.  * new datatypes CDB_LongChar and CDB_LongBinary added
  1582.  *
  1583.  * Revision 1.18  2003/01/31 16:50:12  lavr
  1584.  * Remove unused variable "e" from catch() clause
  1585.  *
  1586.  * Revision 1.17  2003/01/06 16:40:49  soussov
  1587.  * sets m_CurrItem = -1 for all result types if no fetch was called
  1588.  *
  1589.  * Revision 1.16  2003/01/03 21:48:08  soussov
  1590.  * set m_CurrItem = -1 if fetch failes
  1591.  *
  1592.  * Revision 1.15  2002/07/18 14:59:10  soussov
  1593.  * fixes bug in blob result
  1594.  *
  1595.  * Revision 1.14  2002/07/02 16:05:50  soussov
  1596.  * splitting Sybase dblib and MS dblib
  1597.  *
  1598.  * Revision 1.13  2002/05/29 22:04:58  soussov
  1599.  * Makes BlobResult read ahead
  1600.  *
  1601.  * Revision 1.12  2002/03/26 15:37:52  soussov
  1602.  * new image/text operations added
  1603.  *
  1604.  * Revision 1.11  2002/02/06 22:27:54  soussov
  1605.  * fixes the arguments order in numeric assign
  1606.  *
  1607.  * Revision 1.10  2002/01/11 20:11:43  vakatov
  1608.  * Fixed CVS logs from prev. revision that messed up the compilation
  1609.  *
  1610.  * Revision 1.9  2002/01/10 22:05:52  sapojnik
  1611.  * MS-specific workarounds needed to use blobs via I_ITDescriptor
  1612.  * (see Text,Image)
  1613.  *
  1614.  * Revision 1.8  2002/01/08 18:10:18  sapojnik
  1615.  * Syabse to MSSQL name translations moved to interface_p.hpp
  1616.  *
  1617.  * Revision 1.7  2002/01/03 17:01:56  sapojnik
  1618.  * fixing CR/LF mixup
  1619.  *
  1620.  * Revision 1.6  2002/01/03 15:46:23  sapojnik
  1621.  * ported to MS SQL (about 12 'ifdef NCBI_OS_MSWIN' in 6 files)
  1622.  *
  1623.  * Revision 1.5  2001/11/06 17:59:58  lavr
  1624.  * Formatted uniformly as the rest of the library
  1625.  *
  1626.  * Revision 1.4  2001/10/24 16:38:42  lavr
  1627.  * Explicit casts (where necessary) to eliminate 64->32 bit compiler warnings
  1628.  *
  1629.  * Revision 1.3  2001/10/24 05:19:24  vakatov
  1630.  * Fixed return type for ItemMaxSize()
  1631.  *
  1632.  * Revision 1.2  2001/10/22 16:28:01  lavr
  1633.  * Default argument values removed
  1634.  * (mistakenly left while moving code from header files)
  1635.  *
  1636.  * Revision 1.1  2001/10/22 15:19:55  lavr
  1637.  * This is a major revamp (by Anton Lavrentiev, with help from Vladimir
  1638.  * Soussov and Denis Vakatov) of the DBAPI "driver" libs originally
  1639.  * written by Vladimir Soussov. The revamp follows the one of CTLib
  1640.  * driver, and it involved massive code shuffling and grooming, numerous
  1641.  * local API redesigns, adding comments and incorporating DBAPI to
  1642.  * the C++ Toolkit.
  1643.  *
  1644.  * ===========================================================================
  1645.  */