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

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

生物技术

开发平台：

C/C++

result.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: result.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:20:55  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.14
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: result.cpp,v 1000.2 2004/06/01 19:20:55 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Vladimir Soussov
  36.  *
  37.  * File Description:   TDS Results
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <dbapi/driver/ftds/interfaces.hpp>
  43. #include <dbapi/driver/util/numeric_convert.hpp>
  46. BEGIN_NCBI_SCOPE
  49. // Aux. for s_*GetItem()
  50. static CDB_Object* s_GenericGetItem(EDB_Type data_type, CDB_Object* item_buff,
  51.                                     EDB_Type b_type, BYTE* d_ptr, DBINT d_len)
  52. {
  53.     switch (data_type) {
  54.     case eDB_VarBinary: {
  55.         if (item_buff) {
  56.             switch (b_type) {
  57.             case eDB_VarBinary:
  58.                 ((CDB_VarBinary*) item_buff)->SetValue((const void*) d_ptr,
  59.                                                        (size_t) d_len);
  60.                 break;
  61.             case eDB_Binary:
  62.                 ((CDB_Binary*)    item_buff)->SetValue((const void*) d_ptr,
  63.                                                        (size_t) d_len);
  64.                 break;
  65.             case eDB_VarChar:
  66.                 ((CDB_VarChar*)   item_buff)->SetValue((const char*) d_ptr,
  67.                                                        (size_t) d_len);
  68.                 break;
  69.             case eDB_Char:
  70.                 ((CDB_Char*)      item_buff)->SetValue((const char*) d_ptr,
  71.                                                        (size_t) d_len);
  72.                 break;
  73. case eDB_LongBinary:
  74.                 ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
  75.                                                        (size_t) d_len);
  76.                 break;
  77.             case eDB_LongChar:
  78.                 ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
  79.                                                        (size_t) d_len);
  80.                 break;
  82.             default:
  83.                 throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  84.                                    "wrong type of CDB_Object");
  85.             }
  86.             return item_buff;
  87.         }
  89.         return d_ptr ? new CDB_VarBinary((const void*) d_ptr, (size_t) d_len)
  90.             : new CDB_VarBinary();
  91.     }
  93.     case eDB_Bit: {
  94.         DBBIT* v = (DBBIT*) d_ptr;
  95.         if (item_buff) {
  96.             if (v) {
  97.                 switch (b_type) {
  98.                 case eDB_Bit:
  99.                     *((CDB_Bit*)      item_buff) = (int) *v;
  100.                     break;
  101.                 case eDB_TinyInt:
  102.                     *((CDB_TinyInt*)  item_buff) = *v ? 1 : 0;
  103.                     break;
  104.                 case eDB_SmallInt:
  105.                     *((CDB_SmallInt*) item_buff) = *v ? 1 : 0;
  106.                     break;
  107.                 case eDB_Int:
  108.                     *((CDB_Int*)      item_buff) = *v ? 1 : 0;
  109.                     break;
  110.                 default:
  111.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  112.                                        "wrong type of CDB_Object");
  113.                 }
  114.             } else
  115.                 item_buff->AssignNULL();
  116.             return item_buff;
  117.         }
  119.         return v ? new CDB_Bit((int) *v) : new CDB_Bit;
  120.     }
  122.     case eDB_VarChar: {
  123.         if (item_buff) {
  124.             switch (b_type) {
  125.             case eDB_VarChar:
  126.                 ((CDB_VarChar*)   item_buff)->SetValue((const char*) d_ptr,
  127.                                                        (size_t) d_len);
  128.                 break;
  129.             case eDB_Char:
  130.                 ((CDB_Char*)      item_buff)->SetValue((const char*) d_ptr,
  131.                                                        (size_t) d_len);
  132.                 break;
  133.             case eDB_LongChar:
  134.                 ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
  135.                                                        (size_t) d_len);
  136.                 break;
  137.             case eDB_VarBinary:
  138.                 ((CDB_VarBinary*) item_buff)->SetValue((const void*) d_ptr,
  139.                                                        (size_t) d_len);
  140.                 break;
  141.             case eDB_Binary:
  142.                 ((CDB_Binary*)    item_buff)->SetValue((const void*) d_ptr,
  143.                                                        (size_t) d_len);
  144.                 break;
  145.             case eDB_LongBinary:
  146.                 ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
  147.                                                        (size_t) d_len);
  148.                 break;
  149.             default:
  150.                 throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  151.                                    "wrong type of CDB_Object");
  152.             }
  153.             return item_buff;
  154.         }
  156.         return d_ptr ? new CDB_VarChar((const char*) d_ptr, (size_t) d_len)
  157.             : new CDB_VarChar();
  158.     }
  160.     case eDB_DateTime: {
  161.         DBDATETIME* v = (DBDATETIME*) d_ptr;
  162.         if (item_buff) {
  163.             if (b_type != eDB_DateTime) {
  164.                 throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  165.                                    "wrong type of CDB_Object");
  166.             }
  167.             if (v)
  168.                 ((CDB_DateTime*) item_buff)->Assign(v->dtdays, v->dttime);
  169.             else
  170.                 item_buff->AssignNULL();
  171.             return item_buff;
  172.         }
  174.         return v ? new CDB_DateTime(v->dtdays, v->dttime) : new CDB_DateTime;
  175.     }
  177.     case eDB_SmallDateTime: {
  178.         DBDATETIME4* v = (DBDATETIME4*)d_ptr;
  179.         if (item_buff) {
  180.             if (v) {
  181.                 switch (b_type) {
  182.                 case eDB_SmallDateTime:
  183.                     ((CDB_SmallDateTime*) item_buff)->Assign
  184.                         (v->days,             v->minutes);
  185.                     break;
  186.                 case eDB_DateTime:
  187.                     ((CDB_DateTime*)      item_buff)->Assign
  188.                         ((int) v->days, (int) v->minutes*60*300);
  189.                     break;
  190.                 default:
  191.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  192.                                        "wrong type of CDB_Object");
  193.                 }
  194.             } else
  195.                 item_buff->AssignNULL();
  196.             return item_buff;
  197.         }
  199.         return v ?
  200.             new CDB_SmallDateTime(v->days, v->minutes) : new CDB_SmallDateTime;
  201.     }
  203.     case eDB_TinyInt: {
  204.         DBTINYINT* v = (DBTINYINT*) d_ptr;
  205.         if (item_buff) {
  206.             if (v) {
  207.                 switch (b_type) {
  208.                 case eDB_TinyInt:
  209.                     *((CDB_TinyInt*)  item_buff) = (Uint1) *v;
  210.                     break;
  211.                 case eDB_SmallInt:
  212.                     *((CDB_SmallInt*) item_buff) = (Int2)  *v;
  213.                     break;
  214.                 case eDB_Int:
  215.                     *((CDB_Int*)      item_buff) = (Int4)  *v;
  216.                     break;
  217.                 default:
  218.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  219.                                        "wrong type of CDB_Object");
  220.                 }
  221.             } else
  222.                 item_buff->AssignNULL();
  223.             return item_buff;
  224.         }
  226.         return v ? new CDB_TinyInt((Uint1) *v) : new CDB_TinyInt;
  227.     }
  229.     case eDB_SmallInt: {
  230.         DBSMALLINT* v = (DBSMALLINT*) d_ptr;
  231.         if (item_buff) {
  232.             if (v) {
  233.                 switch (b_type) {
  234.                 case eDB_SmallInt:
  235.                     *((CDB_SmallInt*) item_buff) = (Int2) *v;
  236.                     break;
  237.                 case eDB_Int:
  238.                     *((CDB_Int*)      item_buff) = (Int4) *v;
  239.                     break;
  240.                 default:
  241.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  242.                                        "wrong type of CDB_Object");
  243.                 }
  244.             } else
  245.                 item_buff->AssignNULL();
  246.             return item_buff;
  247.         }
  249.         return v ? new CDB_SmallInt((Int2) *v) : new CDB_SmallInt;
  250.     }
  252.     case eDB_Int: {
  253.         DBINT* v = (DBINT*) d_ptr;
  254.         if (item_buff) {
  255.             if (v) {
  256.                 if (b_type == eDB_Int)
  257.                     *((CDB_Int*) item_buff) = (Int4) *v;
  258.                 else {
  259.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  260.                                        "wrong type of CDB_Object");
  261.                 }
  262.             } else
  263.                 item_buff->AssignNULL();
  264.             return item_buff;
  265.         }
  267.         return v ? new CDB_Int((Int4) *v) : new CDB_Int;
  268.     }
  270.     case eDB_Double: {
  271.         if (item_buff  &&  b_type != eDB_Double) {
  272.             throw CDB_ClientEx(eDB_Error, 130020, "s_GenericGetItem",
  273.                                "wrong type of CDB_Object");
  274.         }
  275.         DBFLT8 v;
  276.         if(d_ptr) memcpy((void*)&v, d_ptr, sizeof(DBFLT8));
  277.         if (item_buff) {
  278.             if (d_ptr)
  279.                 *((CDB_Double*) item_buff) = (double) v;
  280.             else
  281.                 item_buff->AssignNULL();
  282.             return item_buff;
  283.         }
  285.         return d_ptr ? new CDB_Double((double)v) : new CDB_Double;
  286.     }
  288.     case eDB_Float: {
  289.         if (item_buff  &&  b_type != eDB_Float) {
  290.             throw CDB_ClientEx(eDB_Error, 130020, "s_GenericGetItem",
  291.                                "wrong type of CDB_Object");
  292.         }
  293.         DBREAL* v = (DBREAL*) d_ptr;
  294.         if (item_buff) {
  295.             if (v)
  296.                 *((CDB_Float*) item_buff) = (float) *v;
  297.             else
  298.                 item_buff->AssignNULL();
  299.             return item_buff;
  300.         }
  302.         return v ? new CDB_Float((float) *v) : new CDB_Float;
  303.     }
  305.     case eDB_LongBinary: {
  306.         if (item_buff) {
  307.             switch (b_type) {
  308. case eDB_LongBinary:
  309.                 ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
  310.                                                        (size_t) d_len);
  311.                 break;
  312.             case eDB_LongChar:
  313.                 ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
  314.                                                        (size_t) d_len);
  315.                 break;
  317.             default:
  318.                 throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  319.                                    "wrong type of CDB_Object");
  320.             }
  321.             return item_buff;
  322.         }
  324.         return d_ptr ? new CDB_LongBinary((size_t) d_len, (const void*) d_ptr, 
  325.                                           (size_t) d_len)
  326.             : new CDB_LongBinary();
  327.     }
  329.     case eDB_LongChar: {
  330.         if (item_buff) {
  331.             switch (b_type) {
  332.             case eDB_LongChar:
  333.                 ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
  334.                                                        (size_t) d_len);
  335.                 break;
  336.             case eDB_LongBinary:
  337.                 ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
  338.                                                        (size_t) d_len);
  339.                 break;
  340.             default:
  341.                 throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
  342.                                    "wrong type of CDB_Object");
  343.             }
  344.             return item_buff;
  345.         }
  347.         return d_ptr ? new CDB_LongChar((size_t) d_len, (const char*) d_ptr)
  348.             : new CDB_LongChar();
  349.     }
  351.     default:
  352.         return 0;
  353.     }
  354. }
  357. /////////////////////////////////////////////////////////////////////////////
  359. static EDB_Type s_GetDataType(DBPROCESS* cmd, int n)
  360. {
  361.     switch (dbcoltype(cmd, n)) {
  362.     case SYBBINARY:    return (dbcollen(cmd, n) > 255) ? eDB_LongBinary : 
  363.                                                          eDB_VarBinary;
  364.     case SYBBITN:                                                         
  365.     case SYBBIT:       return eDB_Bit;
  366.     case SYBCHAR:      return (dbcollen(cmd, n) > 255) ? eDB_LongChar :
  367.                                                          eDB_VarChar;
  368.     case SYBDATETIME:  return eDB_DateTime;
  369.     case SYBDATETIME4: return eDB_SmallDateTime;
  370.     case SYBINT1:      return eDB_TinyInt;
  371.     case SYBINT2:      return eDB_SmallInt;
  372.     case SYBINT4:      return eDB_Int;
  373.     case SYBINT8:      return eDB_BigInt;
  374.     case SYBDECIMAL:
  375.     case SYBNUMERIC:   break;
  376.     case SYBFLT8:      return eDB_Double;
  377.     case SYBREAL:      return eDB_Float;
  378.     case SYBTEXT:      return eDB_Text;
  379.     case SYBIMAGE:     return eDB_Image;
  380.     default:           return eDB_UnsupportedType;
  381.     }
  382.     DBTYPEINFO* t = dbcoltypeinfo(cmd, n);
  383.     return (t->scale == 0  &&  t->precision < 20) ? eDB_BigInt : eDB_Numeric;
  384. }
  387. /////////////////////////////////////////////////////////////////////////////
  388. //
  389. //  CTDS_RowResult::
  390. //
  393. CTDS_RowResult::CTDS_RowResult(DBPROCESS* cmd,
  394.                                unsigned int* res_status, bool need_init)
  395.     : m_Cmd(cmd), m_CurrItem(-1), m_EOR(false),
  396.       m_ResStatus(res_status), m_Offset(0)
  397. {
  398.     if (!need_init)
  399.         return;
  401.     m_NofCols = dbnumcols(cmd);
  402.     m_CmdNum = DBCURCMD(cmd);
  404.     m_ColFmt = new STDS_ColDescr[m_NofCols];
  405.     for (unsigned int n = 0;  n < m_NofCols;  n++) {
  406.         m_ColFmt[n].max_length = dbcollen(m_Cmd, n + 1);
  407.         m_ColFmt[n].data_type = s_GetDataType(m_Cmd, n + 1);
  408.         char* s = dbcolname(m_Cmd, n + 1);
  409.         m_ColFmt[n].col_name = s ? s : "";
  410.     }
  411. }
  414. EDB_ResType CTDS_RowResult::ResultType() const
  415. {
  416.     return eDB_RowResult;
  417. }
  420. unsigned int CTDS_RowResult::NofItems() const
  421. {
  422.     return m_NofCols;
  423. }
  426. const char* CTDS_RowResult::ItemName(unsigned int item_num) const
  427. {
  428.     return item_num < m_NofCols ? m_ColFmt[item_num].col_name.c_str() : 0;
  429. }
  432. size_t CTDS_RowResult::ItemMaxSize(unsigned int item_num) const
  433. {
  434.     return item_num < m_NofCols ? m_ColFmt[item_num].max_length : 0;
  435. }
  438. EDB_Type CTDS_RowResult::ItemDataType(unsigned int item_num) const
  439. {
  440.     return item_num < m_NofCols
  441.         ? m_ColFmt[item_num].data_type : eDB_UnsupportedType;
  442. }
  445. bool CTDS_RowResult::Fetch()
  446. {
  447.     m_CurrItem = -1;
  448.     if ( m_EOR )
  449.         return false;
  451.     switch ( dbnextrow(m_Cmd) ) {
  452.     case REG_ROW:
  453.         m_CurrItem = 0;
  454.         m_Offset = 0;
  455.         return true;
  456.     case NO_MORE_ROWS:
  457.         m_EOR = true;
  458.         break;
  459.     case FAIL:
  460.         throw CDB_ClientEx(eDB_Error, 230003, "CTDS_RowResult::Fetch",
  461.                            "error in fetching row");
  462.     case BUF_FULL:
  463.         throw CDB_ClientEx(eDB_Error, 230006, "CTDS_RowResult::Fetch",
  464.                            "buffer is full");
  465.     default:
  466.         *m_ResStatus |= 0x10;
  467.         m_EOR = true;
  468.         break;
  469.     }
  470.     return false;
  471. }
  474. int CTDS_RowResult::CurrentItemNo() const
  475. {
  476.     return m_CurrItem;
  477. }
  480. // Aux. for CTDS_RowResult::GetItem()
  481. static CDB_Object* s_GetItem(DBPROCESS* cmd, int item_no,
  482.                              STDS_ColDescr* fmt, CDB_Object* item_buff)
  483. {
  484.     EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
  485.     BYTE* d_ptr = dbdata  (cmd, item_no);
  486.     DBINT d_len = dbdatlen(cmd, item_no);
  488.     CDB_Object* val = s_GenericGetItem(fmt->data_type, item_buff,
  489.                                        b_type, d_ptr, d_len);
  490.     if (val)
  491.         return val;
  493.     switch (fmt->data_type) {
  494.     case eDB_BigInt: {
  495.     if(dbcoltype(cmd, item_no) == SYBINT8) {
  496.   Int8* v= (Int8*) d_ptr;
  497.   if(item_buff) {
  498. if(v) {
  499.       if(b_type == eDB_BigInt) {
  500. *((CDB_BigInt*) item_buff)= *v;
  501.   } 
  502.   else {
  503. throw CDB_ClientEx(eDB_Error, 230020, "s_GetItem",
  504.                                        "wrong type of CDB_Object");
  505.   }
  506. }
  507. else 
  508.                 item_buff->AssignNULL();
  509.             return item_buff;
  510.   }
  512.   return v ?
  513.             new CDB_BigInt(*v) : new CDB_BigInt;
  514.     }
  515.         DBNUMERIC* v = (DBNUMERIC*) d_ptr;
  516.         if (item_buff) {
  517.             if (v) {
  518.                 if (b_type == eDB_Numeric) {
  519.                     ((CDB_Numeric*) item_buff)->Assign
  520.                         ((unsigned int)   v->precision,
  521.                          (unsigned int)   v->scale,
  522.                          (unsigned char*) v->array);
  523.                 } else if (b_type == eDB_BigInt) {
  524.                     *((CDB_BigInt*) item_buff) = numeric_to_longlong
  525.                         ((unsigned int) v->precision, v->array);
  526.                 } else {
  527.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GetItem",
  528.                                        "wrong type of CDB_Object");
  529.                 }
  530.             } else
  531.                 item_buff->AssignNULL();
  532.             return item_buff;
  533.         }
  535.         return v ?
  536.             new CDB_BigInt(numeric_to_longlong((unsigned int) v->precision,
  537.                                                v->array)) : new CDB_BigInt;
  538.     }
  540.     case eDB_Numeric: {
  541.         DBNUMERIC* v = (DBNUMERIC*) d_ptr;
  542.         if (item_buff) {
  543.             if (v) {
  544.                 if (b_type == eDB_Numeric) {
  545.                     ((CDB_Numeric*) item_buff)->Assign
  546.                         ((unsigned int)   v->precision,
  547.                          (unsigned int)   v->scale,
  548.                          (unsigned char*) v->array);
  549.                 } else {
  550.                     throw CDB_ClientEx(eDB_Error, 230020, "s_GetItem",
  551.                                        "wrong type of CDB_Object");
  552.                 }
  553.             } else
  554.                 item_buff->AssignNULL();
  555.             return item_buff;
  556.         }
  558.         return v ?
  559.             new CDB_Numeric((unsigned int)   v->precision,
  560.                             (unsigned int)   v->scale,
  561.                             (unsigned char*) v->array) : new CDB_Numeric;
  562.     }
  564.     case eDB_Text: {
  565.         if (item_buff  &&  b_type != eDB_Text  &&  b_type != eDB_Image) {
  566.             throw CDB_ClientEx(eDB_Error, 130020, "s_GetItem",
  567.                                "wrong type of CDB_Object");
  568.         }
  569.         CDB_Text* v = item_buff ? (CDB_Text*) item_buff : new CDB_Text;
  570.         v->Append((char*) d_ptr, (int) d_len);
  571.         return v;
  572.     }
  574.     case eDB_Image: {
  575.         if (item_buff  &&  b_type != eDB_Text  &&  b_type != eDB_Image) {
  576.             throw CDB_ClientEx(eDB_Error, 130020, "s_GetItem",
  577.                                "wrong type of CDB_Object");
  578.         }
  579.         CDB_Image* v = item_buff ? (CDB_Image*) item_buff : new CDB_Image;
  580.         v->Append((void*) d_ptr, (int) d_len);
  581.         return v;
  582.     }
  584.     default:
  585.         throw CDB_ClientEx(eDB_Error, 130004, "s_GetItem",
  586.                            "unexpected result type");
  587.     }
  588. }
  591. CDB_Object* CTDS_RowResult::GetItem(CDB_Object* item_buff)
  592. {
  593.     if ((unsigned int) m_CurrItem >= m_NofCols) {
  594.         return 0;
  595.     }
  596.     CDB_Object* r = s_GetItem(m_Cmd, m_CurrItem + 1,
  597.                               &m_ColFmt[m_CurrItem], item_buff);
  598.     ++m_CurrItem;
  599.     m_Offset = 0;
  600.     return r;
  601. }
  604. size_t CTDS_RowResult::ReadItem(void* buffer, size_t buffer_size,bool* is_null)
  605. {
  606.     if ((unsigned int) m_CurrItem >= m_NofCols) {
  607.         if (is_null)
  608.             *is_null = true;
  609.         return 0;
  610.     }
  612.     BYTE* d_ptr = dbdata  (m_Cmd, m_CurrItem + 1);
  613.     DBINT d_len = dbdatlen(m_Cmd, m_CurrItem + 1);
  615.     if (d_ptr == 0  ||  d_len < 1) { // NULL value
  616.         ++m_CurrItem;
  617.         m_Offset = 0;
  618.         if (is_null)
  619.             *is_null = true;
  620.         return 0;
  621.     }
  623.     if (is_null)
  624.         *is_null = false;
  625.     if ((size_t) (d_len - m_Offset) < buffer_size) {
  626.         buffer_size = d_len - m_Offset;
  627.     }
  629.     if (buffer)
  630.         memcpy(buffer, d_ptr + m_Offset, buffer_size);
  631.     m_Offset += buffer_size;
  632.     if (m_Offset >= d_len) {
  633.         m_Offset = 0;
  634.         ++m_CurrItem;
  635.     }
  637.     return buffer_size;
  638. }
  641. I_ITDescriptor* CTDS_RowResult::GetImageOrTextDescriptor()
  642. {
  643.     if ((unsigned int) m_CurrItem >= m_NofCols)
  644.         return 0;
  645.     return new CTDS_ITDescriptor(m_Cmd, m_CurrItem + 1);
  646. }
  649. bool CTDS_RowResult::SkipItem()
  650. {
  651.     if ((unsigned int) m_CurrItem < m_NofCols) {
  652.         ++m_CurrItem;
  653.         m_Offset = 0;
  654.         return true;
  655.     }
  656.     return false;
  657. }
  660. CTDS_RowResult::~CTDS_RowResult()
  661. {
  662.     if (m_ColFmt) {
  663.         delete[] m_ColFmt;
  664.         m_ColFmt = 0;
  665.     }
  666.     if (!m_EOR)
  667.         dbcanquery(m_Cmd);
  668. }
  672. /////////////////////////////////////////////////////////////////////////////
  673. //
  674. //  CTDS_BlobResult::
  677. CTDS_BlobResult::CTDS_BlobResult(DBPROCESS* cmd)
  678.     : m_Cmd(cmd), m_CurrItem(-1), m_EOR(false)
  679. {
  680.     m_CmdNum = DBCURCMD(cmd);
  682.     m_ColFmt.max_length = dbcollen(m_Cmd, 1);
  683.     m_ColFmt.data_type = s_GetDataType(m_Cmd, 1);
  684.     char* s = dbcolname(m_Cmd, 1);
  685.     m_ColFmt.col_name = s ? s : "";
  686. }
  688. EDB_ResType CTDS_BlobResult::ResultType() const
  689. {
  690.     return eDB_RowResult;
  691. }
  694. unsigned int CTDS_BlobResult::NofItems() const
  695. {
  696.     return 1;
  697. }
  700. const char* CTDS_BlobResult::ItemName(unsigned int item_num) const
  701. {
  702.     return item_num ? 0 : m_ColFmt.col_name.c_str();
  703. }
  706. size_t CTDS_BlobResult::ItemMaxSize(unsigned int item_num) const
  707. {
  708.     return item_num ? 0 : m_ColFmt.max_length;
  709. }
  712. EDB_Type CTDS_BlobResult::ItemDataType(unsigned int) const
  713. {
  714.     return m_ColFmt.data_type;
  715. }
  718. bool CTDS_BlobResult::Fetch()
  719. {
  720.     if (m_EOR)
  721.         return false;
  723.     STATUS s;
  724.     if (m_CurrItem == 0) {
  725.         while ((s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff))) > 0)
  726.             ;
  727.         switch (s) {
  728.         case 0:
  729.             break;
  730.         case NO_MORE_ROWS:
  731.             m_EOR = true;
  732.             return false;
  733.         default:
  734.             throw CDB_ClientEx(eDB_Error, 280003, "CTDS_BlobResult::Fetch",
  735.                                "error in fetching row");
  736.         }
  737.     }
  738.     else {
  739.         m_CurrItem = 0;
  740.     }
  741.     s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff));
  742.     if (s == NO_MORE_ROWS)
  743.         return false;
  744.     if (s < 0) {
  745.         throw CDB_ClientEx(eDB_Error, 280003, "CTDS_BlobResult::Fetch",
  746.                            "error in fetching row");
  747.     }
  748.     m_BytesInBuffer = s;
  749.     m_ReadedBytes = 0;
  750.     return true;
  751. }
  754. int CTDS_BlobResult::CurrentItemNo() const
  755. {
  756.     return m_CurrItem;
  757. }
  760. CDB_Object* CTDS_BlobResult::GetItem(CDB_Object* item_buff)
  761. {
  762.     if (m_CurrItem)
  763.         return 0;
  765.     EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
  767.     if (item_buff  &&  b_type != eDB_Text  &&  b_type != eDB_Image) {
  768.         throw CDB_ClientEx(eDB_Error, 230020, "CTDS_BlobResult::GetItem",
  769.                            "wrong type of CDB_Object");
  770.     }
  772.     if (item_buff == 0) {
  773.         item_buff = m_ColFmt.data_type == eDB_Text
  774.             ? (CDB_Object*) new CDB_Text : (CDB_Object*) new CDB_Image;
  775.     }
  777.     CDB_Text* val = (CDB_Text*) item_buff;
  779.     // check if we do have something in buffer
  780.     if (m_ReadedBytes < m_BytesInBuffer) {
  781.         val->Append(m_Buff + m_ReadedBytes, m_BytesInBuffer - m_ReadedBytes);
  782.         m_ReadedBytes = m_BytesInBuffer;
  783.     }
  785.     if (m_BytesInBuffer == 0) {
  786.         return item_buff;
  787.     }
  790.     STATUS s;
  791.     while ((s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff))) > 0) {
  792.         val->Append(m_Buff, (s < sizeof(m_Buff))? (size_t)s : sizeof(m_Buff));
  793.     }
  795.     switch (s) {
  796.     case NO_MORE_ROWS:
  797.         m_EOR = true;
  798.     case 0:
  799.         m_CurrItem = 1;
  800.         break;
  801.     default:
  802.         throw CDB_ClientEx(eDB_Error, 280003, "CTDS_BlobResult::GetItem",
  803.                            "dbreadtext failed");
  804.     }
  806.     return item_buff;
  807. }
  810. size_t CTDS_BlobResult::ReadItem(void* buffer, size_t buffer_size,
  811.                                  bool* is_null)
  812. {
  813.     if (m_BytesInBuffer == 0)
  814.         m_CurrItem = 1;
  816.     if (m_CurrItem != 0) {
  817.         if (is_null)
  818.             *is_null = true;
  819.         return 0;
  820.     }
  822.     size_t l = 0;
  823.     // check if we do have something in buffer
  824.     if (m_ReadedBytes < m_BytesInBuffer) {
  825.         l = m_BytesInBuffer - m_ReadedBytes;
  826.         if (l >= buffer_size) {
  827.             memcpy(buffer, m_Buff + m_ReadedBytes, buffer_size);
  828.             m_ReadedBytes += buffer_size;
  829.             if (is_null)
  830.                 *is_null = false;
  831.             return buffer_size;
  832.         }
  833.         memcpy(buffer, m_Buff + m_ReadedBytes, l);
  834.     }
  836.     STATUS s = dbreadtext(m_Cmd,
  837.                           (void*)((char*)buffer + l), (DBINT)(buffer_size-l));
  838.     switch (s) {
  839.     case NO_MORE_ROWS:
  840.         m_EOR = true;
  841.     case 0:
  842.         m_CurrItem = 1;
  843.         break;
  844.     case -1:
  845.         throw CDB_ClientEx(eDB_Error, 280003, "CTDS_BlobResult::ReadItem",
  846.                            "dbreadtext failed");
  847.     default:
  848.         break;
  849.     }
  851.     if (is_null) {
  852.         *is_null = (m_BytesInBuffer == 0  &&  s <= 0);
  853.     }
  854.     return (size_t) s + l;
  855. }
  858. I_ITDescriptor* CTDS_BlobResult::GetImageOrTextDescriptor()
  859. {
  860.     if (m_CurrItem != 0)
  861.         return 0;
  862.     return new CTDS_ITDescriptor(m_Cmd, 1);
  863. }
  866. bool CTDS_BlobResult::SkipItem()
  867. {
  868.     if (m_EOR  ||  m_CurrItem)
  869.         return false;
  871.     STATUS s;
  872.     while ((s = dbreadtext(m_Cmd, m_Buff, sizeof(m_Buff))) > 0)
  873.         continue;
  875.     switch (s) {
  876.     case NO_MORE_ROWS:
  877.         m_EOR = true;
  878.     case 0:
  879.         m_CurrItem = 1;
  880.         break;
  881.     default:
  882.         throw CDB_ClientEx(eDB_Error, 280003, "CTDS_BlobResult::SkipItem",
  883.                            "dbreadtext failed");
  884.     }
  885.     return true;
  886. }
  889. CTDS_BlobResult::~CTDS_BlobResult()
  890. {
  891.     if (!m_EOR)
  892.         dbcanquery(m_Cmd);
  893. }
  896. /////////////////////////////////////////////////////////////////////////////
  898. static EDB_Type s_RetGetDataType(DBPROCESS* cmd, int n)
  899. {
  900.     switch (dbrettype(cmd, n)) {
  901.     case SYBBINARY:    return (dbretlen(cmd, n) > 255)? eDB_LongBinary : 
  902.                                                         eDB_VarBinary;
  903.     case SYBBIT:       return eDB_Bit;
  904.     case SYBCHAR:      return (dbretlen(cmd, n) > 255)? eDB_LongChar : 
  905.                                                         eDB_VarChar;
  906.     case SYBDATETIME:  return eDB_DateTime;
  907.     case SYBDATETIME4: return eDB_SmallDateTime;
  908.     case SYBINT1:      return eDB_TinyInt;
  909.     case SYBINT2:      return eDB_SmallInt;
  910.     case SYBINT4:      return eDB_Int;
  911.     case SYBFLT8:      return eDB_Double;
  912.     case SYBREAL:      return eDB_Float;
  913.     default:           return eDB_UnsupportedType;
  914.     }
  915. }
  918. // Aux. for CTDS_ParamResult::GetItem()
  919. static CDB_Object* s_RetGetItem(DBPROCESS* cmd, int item_no,
  920.                                 STDS_ColDescr* fmt, CDB_Object* item_buff)
  921. {
  922.     EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
  923.     BYTE* d_ptr = dbretdata(cmd, item_no);
  924.     DBINT d_len = dbretlen (cmd, item_no);
  925.     CDB_Object* val = s_GenericGetItem(fmt->data_type, item_buff,
  926.                                        b_type, d_ptr, d_len);
  927.     if (!val) {
  928.         throw CDB_ClientEx(eDB_Error, 230004, "s_RetGetItem",
  929.                            "unexpected result type");
  930.     }
  931.     return val;
  932. }
  935. /////////////////////////////////////////////////////////////////////////////
  936. //
  937. //  CTDS_ParamResult::
  938. //
  940. CTDS_ParamResult::CTDS_ParamResult(DBPROCESS* cmd, int nof_params)
  941.     : CTDS_RowResult(cmd, 0, false)
  942. {
  944.     m_NofCols = nof_params;
  945.     m_CmdNum = DBCURCMD(cmd);
  947.     m_ColFmt = new STDS_ColDescr[m_NofCols];
  948.     for (unsigned int n = 0;  n < m_NofCols;  n++) {
  949.         m_ColFmt[n].max_length = 255;
  950.         m_ColFmt[n].data_type = s_RetGetDataType(m_Cmd, n + 1);
  951.         const char* s = dbretname(m_Cmd, n + 1);
  952.         m_ColFmt[n].col_name = s ? s : "";
  953.     }
  954.     m_1stFetch = true;
  955. }
  958. EDB_ResType CTDS_ParamResult::ResultType() const
  959. {
  960.     return eDB_ParamResult;
  961. }
  964. bool CTDS_ParamResult::Fetch()
  965. {
  966.     if (m_1stFetch) { // we didn't get the items yet;
  967.         m_1stFetch = false;
  968. m_CurrItem= 0;
  969.         return true;
  970.     }
  971.     return false;
  972. }
  975. CDB_Object* CTDS_ParamResult::GetItem(CDB_Object* item_buff)
  976. {
  977.     if ((unsigned int) m_CurrItem >= m_NofCols) {
  978.         return 0;
  979.     }
  981.     CDB_Object* r = s_RetGetItem(m_Cmd, m_CurrItem + 1,
  982.                                  &m_ColFmt[m_CurrItem], item_buff);
  983.     ++m_CurrItem;
  984.     m_Offset = 0;
  985.     return r;
  986. }
  989. size_t CTDS_ParamResult::ReadItem(void* buffer, size_t buffer_size,
  990.                                   bool* is_null)
  991. {
  992.     if ((unsigned int) m_CurrItem >= m_NofCols) {
  993.         if (is_null)
  994.             *is_null = true;
  995.         return 0;
  996.     }
  998.     BYTE* d_ptr = dbretdata(m_Cmd, m_CurrItem + 1);
  999.     DBINT d_len = dbretlen (m_Cmd, m_CurrItem + 1);
  1001.     if (d_ptr == 0  ||  d_len < 1) { // NULL value
  1002.         ++m_CurrItem;
  1003.         m_Offset = 0;
  1004.         if (is_null)
  1005.             *is_null = true;
  1006.         return 0;
  1007.     }
  1009.     if (is_null)
  1010.         *is_null = false;
  1011.     if ((size_t) (d_len - m_Offset) < buffer_size) {
  1012.         buffer_size = d_len - m_Offset;
  1013.     }
  1015.     memcpy(buffer, d_ptr + m_Offset, buffer_size);
  1016.     m_Offset += buffer_size;
  1017.     if (m_Offset >= d_len) {
  1018.         m_Offset = 0;
  1019.         ++m_CurrItem;
  1020.     }
  1021.     return buffer_size;
  1022. }
  1025. I_ITDescriptor* CTDS_ParamResult::GetImageOrTextDescriptor()
  1026. {
  1027.     return 0;
  1028. }
  1031. CTDS_ParamResult::~CTDS_ParamResult()
  1032. {
  1033.     if (m_ColFmt) {
  1034.         delete[] m_ColFmt;
  1035.         m_ColFmt = 0;
  1036.     }
  1037. }
  1040. /////////////////////////////////////////////////////////////////////////////
  1042. #if 0
  1044. static EDB_Type s_AltGetDataType(DBPROCESS* cmd, int id, int n)
  1045. {
  1046.     switch (dbalttype(cmd, id, n)) {
  1047.     case SYBBINARY:    return eDB_VarBinary;
  1048.     case SYBBIT:       return eDB_Bit;
  1049.     case SYBCHAR:      return eDB_VarChar;
  1050.     case SYBDATETIME:  return eDB_DateTime;
  1051.     case SYBDATETIME4: return eDB_SmallDateTime;
  1052.     case SYBINT1:      return eDB_TinyInt;
  1053.     case SYBINT2:      return eDB_SmallInt;
  1054.     case SYBINT4:      return eDB_Int;
  1055.     case SYBFLT8:      return eDB_Double;
  1056.     case SYBREAL:      return eDB_Float;
  1057.     default:           return eDB_UnsupportedType;
  1058.     }
  1059. }
  1062. // Aux. for CTDS_ComputeResult::GetItem()
  1063. static CDB_Object* s_AltGetItem(DBPROCESS* cmd, int id, int item_no,
  1064.                                 STDS_ColDescr* fmt, CDB_Object* item_buff)
  1065. {
  1066.     EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
  1067.     BYTE* d_ptr = dbadata(cmd, id, item_no);
  1068.     DBINT d_len = dbadlen(cmd, id, item_no);
  1069.     CDB_Object* val = s_GenericGetItem(fmt->data_type, item_buff,
  1070.                                        b_type, d_ptr, d_len);
  1071.     if (!val) {
  1072.         throw CDB_ClientEx(eDB_Error, 130004, "s_AltGetItem",
  1073.                            "unexpected result type");
  1074.     }
  1075.     return val;
  1076. }
  1078. #endif
  1082. /////////////////////////////////////////////////////////////////////////////
  1083. //
  1084. //  CTL_ComputeResult::
  1085. //
  1087. CTDS_ComputeResult::CTDS_ComputeResult(DBPROCESS* cmd,
  1088.                                        unsigned int* res_stat)
  1089.     : CTDS_RowResult(cmd, res_stat, false)
  1090. {
  1091.     throw CDB_ClientEx(eDB_Error, 270000,
  1092.                        "CDBL_ComputeResult::CDBL_ComputeResult",
  1093.                        "The compute results do not implemented in Free TDS");
  1094. }
  1097. EDB_ResType CTDS_ComputeResult::ResultType() const
  1098. {
  1099.     return eDB_ComputeResult;
  1100. }
  1103. bool CTDS_ComputeResult::Fetch()
  1104. {
  1105.     return false; // do not implemented in Free TDS
  1106. }
  1109. int CTDS_ComputeResult::CurrentItemNo() const
  1110. {
  1111.     return m_CurrItem;
  1112. }
  1115. CDB_Object* CTDS_ComputeResult::GetItem(CDB_Object* /*item_buff*/)
  1116. {
  1117.     return 0; // not implemented in Free TDS
  1118. }
  1121. size_t CTDS_ComputeResult::ReadItem(void* /*buffer*/, size_t /*buffer_size*/,
  1122.                                     bool* /*is_null*/)
  1123. {
  1124.     return 0; // not implemented in Free TDS
  1125. }
  1128. I_ITDescriptor* CTDS_ComputeResult::GetImageOrTextDescriptor()
  1129. {
  1130.     return 0;
  1131. }
  1134. CTDS_ComputeResult::~CTDS_ComputeResult()
  1135. {
  1136.     return;
  1137. }
  1141. /////////////////////////////////////////////////////////////////////////////
  1142. //
  1143. //  CTL_StatusResult::
  1144. //
  1147. CTDS_StatusResult::CTDS_StatusResult(DBPROCESS* cmd)
  1148. {
  1149.     m_Val = dbretstatus(cmd);
  1150.     m_Offset = 0;
  1151.     m_1stFetch = true;
  1152. }
  1154. EDB_ResType CTDS_StatusResult::ResultType() const
  1155. {
  1156.     return eDB_StatusResult;
  1157. }
  1160. unsigned int CTDS_StatusResult::NofItems() const
  1161. {
  1162.     return 1;
  1163. }
  1166. const char* CTDS_StatusResult::ItemName(unsigned int) const
  1167. {
  1168.     return 0;
  1169. }
  1172. size_t CTDS_StatusResult::ItemMaxSize(unsigned int) const
  1173. {
  1174.     return sizeof(DBINT);
  1175. }
  1178. EDB_Type CTDS_StatusResult::ItemDataType(unsigned int) const
  1179. {
  1180.     return eDB_Int;
  1181. }
  1184. bool CTDS_StatusResult::Fetch()
  1185. {
  1186.     if (m_1stFetch) {
  1187.         m_1stFetch = false;
  1188.         return true;
  1189.     }
  1190.     return false;
  1191. }
  1194. int CTDS_StatusResult::CurrentItemNo() const
  1195. {
  1196.     return m_1stFetch? -1 : 0;
  1197. }
  1200. CDB_Object* CTDS_StatusResult::GetItem(CDB_Object* item_buff)
  1201. {
  1202.     if (!item_buff)
  1203.         return new CDB_Int(m_Val);
  1205.     if (item_buff->GetType() != eDB_Int) {
  1206.         throw CDB_ClientEx(eDB_Error, 230020, "CTDS_StatusResult::GetItem",
  1207.                            "wrong type of CDB_Object");
  1208.     }
  1210.     CDB_Int* i = (CDB_Int*) item_buff;
  1211.     *i = m_Val;
  1212.     return item_buff;
  1213. }
  1216. size_t CTDS_StatusResult::ReadItem(void* buffer, size_t buffer_size,
  1217.                                    bool* is_null)
  1218. {
  1219.     if (is_null)
  1220.         *is_null = false;
  1223.     if (sizeof(int) <= (size_t) m_Offset)
  1224.         return 0;
  1226.     size_t l = sizeof(int) - m_Offset;
  1228.     char* p = (char*) &m_Val;
  1230.     if (buffer_size > l)
  1231.         buffer_size = l;
  1232.     memcpy(buffer, p + m_Offset, buffer_size);
  1233.     m_Offset += buffer_size;
  1234.     return buffer_size;
  1235. }
  1238. I_ITDescriptor* CTDS_StatusResult::GetImageOrTextDescriptor()
  1239. {
  1240.     return 0;
  1241. }
  1244. bool CTDS_StatusResult::SkipItem()
  1245. {
  1246.     return false;
  1247. }
  1250. CTDS_StatusResult::~CTDS_StatusResult()
  1251. {
  1252.     return;
  1253. }
  1257. /////////////////////////////////////////////////////////////////////////////
  1258. //
  1259. //  CTL_CursorResult::
  1260. //
  1262. CTDS_CursorResult::CTDS_CursorResult(CDB_LangCmd* cmd)
  1263.     : m_Cmd(cmd), m_Res(0)
  1264. {
  1265.     try {
  1266.         m_Cmd->Send();
  1267.         while (m_Cmd->HasMoreResults()) {
  1268.             m_Res = m_Cmd->Result();
  1269.             if (m_Res  &&  m_Res->ResultType() == eDB_RowResult) {
  1270.                 return;
  1271.             }
  1272.             if (m_Res) {
  1273.                 while (m_Res->Fetch())
  1274.                     continue;
  1275.                 delete m_Res;
  1276.                 m_Res = 0;
  1277.             }
  1278.         }
  1279.     } catch (CDB_Exception& e) {
  1280.         throw CDB_ClientEx(eDB_Error, 222010,
  1281.                            "CTDS_CursorResult::CTDS_CursorResult",
  1282.                            "failed to get the results");
  1283.     }
  1284. }
  1287. EDB_ResType CTDS_CursorResult::ResultType() const
  1288. {
  1289.     return eDB_CursorResult;
  1290. }
  1293. unsigned int CTDS_CursorResult::NofItems() const
  1294. {
  1295.     return m_Res? m_Res->NofItems() : 0;
  1296. }
  1299. const char* CTDS_CursorResult::ItemName(unsigned int item_num) const
  1300. {
  1301.     return m_Res ? m_Res->ItemName(item_num) : 0;
  1302. }
  1305. size_t CTDS_CursorResult::ItemMaxSize(unsigned int item_num) const
  1306. {
  1307.     return m_Res ? m_Res->ItemMaxSize(item_num) : 0;
  1308. }
  1311. EDB_Type CTDS_CursorResult::ItemDataType(unsigned int item_num) const
  1312. {
  1313.     return m_Res ? m_Res->ItemDataType(item_num) : eDB_UnsupportedType;
  1314. }
  1317. bool CTDS_CursorResult::Fetch()
  1318. {
  1319.     if (!m_Res)
  1320.         return false;
  1322.     try {
  1323.         if (m_Res->Fetch())
  1324.             return true;
  1325.     }
  1326.     catch (CDB_ClientEx& ex) {
  1327.         if (ex.ErrCode() == 200003) {
  1328.             m_Res = 0;
  1329.         } else {
  1330.             throw CDB_ClientEx(eDB_Error, 222011, "CDBL_CursorResult::Fetch",
  1331.                                "Failed to fetch the results");
  1332.         }
  1333.     }
  1335.     // try to get next cursor result
  1336.     try {
  1337.         // finish this command
  1338.         if (m_Res)
  1339.             delete m_Res;
  1340.         while (m_Cmd->HasMoreResults()) {
  1341.             m_Res = m_Cmd->Result();
  1342.             if (m_Res) {
  1343.                 while (m_Res->Fetch())
  1344.                     continue;
  1345.                 delete m_Res;
  1346.                 m_Res = 0;
  1347.             }
  1348.         }
  1349.         // send the another "fetch cursor_name" command
  1350.         m_Cmd->Send();
  1351.         while (m_Cmd->HasMoreResults()) {
  1352.             m_Res = m_Cmd->Result();
  1353.             if (m_Res  &&  m_Res->ResultType() == eDB_RowResult) {
  1354.                 return m_Res->Fetch();
  1355.             }
  1356.             if (m_Res) {
  1357.                 while (m_Res->Fetch())
  1358.                     continue;
  1359.                 delete m_Res;
  1360.                 m_Res = 0;
  1361.             }
  1362.         }
  1363.     } catch (CDB_Exception& e) {
  1364.         throw CDB_ClientEx(eDB_Error, 222011, "CTDS_CursorResult::Fetch",
  1365.                            "Failed to fetch the results");
  1366.     }
  1367.     return false;
  1368. }
  1371. int CTDS_CursorResult::CurrentItemNo() const
  1372. {
  1373.     return m_Res ? m_Res->CurrentItemNo() : -1;
  1374. }
  1377. CDB_Object* CTDS_CursorResult::GetItem(CDB_Object* item_buff)
  1378. {
  1379.     return m_Res ? m_Res->GetItem(item_buff) : 0;
  1380. }
  1383. size_t CTDS_CursorResult::ReadItem(void* buffer, size_t buffer_size,
  1384.                                    bool* is_null)
  1385. {
  1386.     if (m_Res) {
  1387.         return m_Res->ReadItem(buffer, buffer_size, is_null);
  1388.     }
  1389.     if (is_null)
  1390.         *is_null = true;
  1391.     return 0;
  1392. }
  1395. I_ITDescriptor* CTDS_CursorResult::GetImageOrTextDescriptor()
  1396. {
  1397.     return m_Res ? m_Res->GetImageOrTextDescriptor() : 0;
  1398. }
  1401. bool CTDS_CursorResult::SkipItem()
  1402. {
  1403.     return m_Res ? m_Res->SkipItem() : false;
  1404. }
  1407. CTDS_CursorResult::~CTDS_CursorResult()
  1408. {
  1409.     delete m_Res;
  1410. }
  1414. /////////////////////////////////////////////////////////////////////////////
  1415. //
  1416. //  CTDS_ITDescriptor::
  1417. //
  1419. CTDS_ITDescriptor::CTDS_ITDescriptor(DBPROCESS* dblink, int col_num)
  1420. {
  1422.     m_ObjName = dbcolsource(dblink, col_num);
  1423.     DBBINARY* p = dbtxptr(dblink, col_num);
  1424.     if (p) {
  1425.         memcpy(m_TxtPtr, p, DBTXPLEN);
  1426.         m_TxtPtr_is_NULL = false;
  1427.     } else
  1428.         m_TxtPtr_is_NULL = true;
  1430.     p = dbtxtimestamp(dblink, col_num);
  1431.     if (p) {
  1432.         memcpy(m_TimeStamp, p, DBTXTSLEN);
  1433.         m_TimeStamp_is_NULL = false;
  1434.     } else
  1435.         m_TimeStamp_is_NULL = true;
  1436. }
  1439. CTDS_ITDescriptor::CTDS_ITDescriptor(DBPROCESS* dblink,
  1440.                                      const CDB_ITDescriptor& inp_d)
  1441. {
  1442.     m_ObjName = inp_d.TableName();
  1443.     m_ObjName += ".";
  1444.     m_ObjName += inp_d.ColumnName();
  1447.     DBBINARY* p = dbtxptr(dblink, 1);
  1448.     if (p) {
  1449.         memcpy(m_TxtPtr, p, DBTXPLEN);
  1450.         m_TxtPtr_is_NULL = false;
  1451.     } else
  1452.         m_TxtPtr_is_NULL = true;
  1454.     p = dbtxtimestamp(dblink, 1);
  1455.     if (p) {
  1456.         memcpy(m_TimeStamp, p, DBTXTSLEN);
  1457.         m_TimeStamp_is_NULL = false;
  1458.     } else
  1459.         m_TimeStamp_is_NULL = true;
  1460. }
  1463. int CTDS_ITDescriptor::DescriptorType() const
  1464. {
  1465.     return CTDS_ITDESCRIPTOR_TYPE_MAGNUM;
  1466. }
  1469. CTDS_ITDescriptor::~CTDS_ITDescriptor()
  1470. {
  1471.     return;
  1472. }
  1475. END_NCBI_SCOPE
  1479. /*
  1480.  * ===========================================================================
  1481.  * $Log: result.cpp,v $
  1482.  * Revision 1000.2  2004/06/01 19:20:55  gouriano
  1483.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.14
  1484.  *
  1485.  * Revision 1.14  2004/05/17 21:13:37  gorelenk
  1486.  * Added include of PCH ncbi_pch.hpp
  1487.  *
  1488.  * Revision 1.13  2004/02/24 20:22:12  soussov
  1489.  * SYBBITN processing added
  1490.  *
  1491.  * Revision 1.12  2003/04/29 21:15:03  soussov
  1492.  * new datatypes CDB_LongChar and CDB_LongBinary added
  1493.  *
  1494.  * Revision 1.11  2003/02/06 16:26:52  soussov
  1495.  * adding support for bigint datatype
  1496.  *
  1497.  * Revision 1.10  2003/01/06 16:59:31  soussov
  1498.  * sets m_CurrItem = -1 for all result types if no fetch was called
  1499.  *
  1500.  * Revision 1.9  2003/01/03 21:48:18  soussov
  1501.  * set m_CurrItem = -1 if fetch failes
  1502.  *
  1503.  * Revision 1.8  2002/07/18 14:59:31  soussov
  1504.  * fixes bug in blob result
  1505.  *
  1506.  * Revision 1.7  2002/06/13 21:10:18  soussov
  1507.  * freeTDS does not place doubles properly in memory, patch added
  1508.  *
  1509.  * Revision 1.6  2002/06/08 06:18:43  vakatov
  1510.  * Ran through 64-bit compilation (tests were successful on Solaris/Forte6u2).
  1511.  * Fixed a return type in CTDS_CursorResult::ItemMaxSize, eliminated a couple
  1512.  * of warnings. Formally formatted the code to fit the C++ Toolkit style.
  1513.  *
  1514.  * Revision 1.5  2002/05/29 22:04:29  soussov
  1515.  * Makes BlobResult read ahead
  1516.  *
  1517.  * Revision 1.4  2002/03/26 15:35:10  soussov
  1518.  * new image/text operations added
  1519.  *
  1520.  * Revision 1.3  2002/02/06 22:30:56  soussov
  1521.  * fixes the arguments order in numeric assign
  1522.  *
  1523.  * Revision 1.2  2001/11/06 18:00:02  lavr
  1524.  * Formatted uniformly as the rest of the library
  1525.  *
  1526.  * Revision 1.1  2001/10/25 00:39:22  vakatov
  1527.  * Initial revision
  1528.  *
  1529.  * ===========================================================================
  1530.  */