result.cpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: result.cpp,v $
 * PRODUCTION Revision 1000.1  2004/06/01 19:19:47  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.18
 * PRODUCTION
 * ===========================================================================
 */

/* $Id: result.cpp,v 1000.1 2004/06/01 19:19:47 gouriano Exp $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Author:  Vladimir Soussov
 *
 * File Description:  CTLib Results
 *
 */


#include <ncbi_pch.hpp>
#include <dbapi/driver/ctlib/interfaces.hpp>
#include <dbapi/driver/util/numeric_convert.hpp>


BEGIN_NCBI_SCOPE


/////////////////////////////////////////////////////////////////////////////
//
//  CTL_RowResult::
//


CTL_RowResult::CTL_RowResult(CS_COMMAND* cmd)
    : m_Cmd(cmd),
      m_CurrItem(-1),
      m_EOR(false)
{
    CS_INT outlen;

    CS_INT nof_cols;
    if (ct_res_info(m_Cmd, CS_NUMDATA, &nof_cols, CS_UNUSED, &outlen)
        != CS_SUCCEED) {
        throw CDB_ClientEx(eDB_Error, 130001, "::CTL_RowResult",
                           "ct_res_info(CS_NUMDATA) failed");
    }
    m_NofCols = nof_cols;

    CS_INT cmd_num;
    if (ct_res_info(m_Cmd, CS_CMD_NUMBER, &cmd_num, CS_UNUSED, &outlen)
        != CS_SUCCEED) {
        throw CDB_ClientEx(eDB_Error, 130001, "::CTL_RowResult",
                           "ct_res_info(CS_CMD_NUMBER) failed");
    }
    m_CmdNum = cmd_num;

	CS_INT bind_len= 0;
	m_BindedCols= 0;

    m_ColFmt = new CS_DATAFMT[m_NofCols];
    for (unsigned int nof_items = 0;  nof_items < m_NofCols;  nof_items++) {
        if (ct_describe(m_Cmd, (CS_INT) nof_items + 1, &m_ColFmt[nof_items])
            != CS_SUCCEED) {
            throw CDB_ClientEx(eDB_Error, 130002, "::CTL_RowResult",
                               "ct_describe failed");
        }
		bind_len+= m_ColFmt[nof_items].maxlength;
		if(bind_len <= 2048) m_BindedCols++;
    }
	if(m_BindedCols) {
	    m_BindItem= new CS_VOID*[m_BindedCols];
		m_Copied= new CS_INT[m_BindedCols];
		m_Indicator= new CS_SMALLINT[m_BindedCols];
		for(int i= 0; i < m_BindedCols; i++) {
		  m_BindItem[i]= i? ((unsigned char*)(m_BindItem[i-1])) + m_ColFmt[i-1].maxlength : m_BindBuff;
		  if(ct_bind(m_Cmd, i+1, &m_ColFmt[i], m_BindItem[i], &m_Copied[i], &m_Indicator[i]) 
			 != CS_SUCCEED) {
            throw CDB_ClientEx(eDB_Error, 130042, "::CTL_RowResult",
                               "ct_bind failed");
		  }
		}
	}
}


EDB_ResType CTL_RowResult::ResultType() const
{
    return eDB_RowResult;
}


unsigned int CTL_RowResult::NofItems() const
{
    return m_NofCols;
}


const char* CTL_RowResult::ItemName(unsigned int item_num) const
{
    return (item_num < m_NofCols  &&  m_ColFmt[item_num].namelen > 0)
        ? m_ColFmt[item_num].name : 0;
}


size_t CTL_RowResult::ItemMaxSize(unsigned int item_num) const
{
    return (item_num < m_NofCols) ? m_ColFmt[item_num].maxlength : 0;
}


EDB_Type CTL_RowResult::ItemDataType(unsigned int item_num) const
{
    if (item_num >= m_NofCols) {
        return eDB_UnsupportedType;
    }

    const CS_DATAFMT& fmt = m_ColFmt[item_num];
    switch ( fmt.datatype ) {
    case CS_BINARY_TYPE:    return eDB_VarBinary;
    case CS_BIT_TYPE:       return eDB_Bit;
    case CS_CHAR_TYPE:      return eDB_VarChar;
    case CS_DATETIME_TYPE:  return eDB_DateTime;
    case CS_DATETIME4_TYPE: return eDB_SmallDateTime;
    case CS_TINYINT_TYPE:   return eDB_TinyInt;
    case CS_SMALLINT_TYPE:  return eDB_SmallInt;
    case CS_INT_TYPE:       return eDB_Int;
    case CS_DECIMAL_TYPE:
    case CS_NUMERIC_TYPE:   return (fmt.scale == 0  &&  fmt.precision < 20)
                                ? eDB_BigInt : eDB_Numeric;
    case CS_FLOAT_TYPE:     return eDB_Double;
    case CS_REAL_TYPE:      return eDB_Float;
    case CS_TEXT_TYPE:      return eDB_Text;
    case CS_IMAGE_TYPE:     return eDB_Image;
	case CS_LONGCHAR_TYPE:  return eDB_LongChar;
	case CS_LONGBINARY_TYPE: return eDB_LongBinary;
    }

    return eDB_UnsupportedType;
}


bool CTL_RowResult::Fetch()
{
    m_CurrItem = -1;
    if ( m_EOR ) {
        return false;
    }

    switch ( ct_fetch(m_Cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, 0) ) {
    case CS_SUCCEED:
        m_CurrItem = 0;
        return true;
    case CS_END_DATA:
        m_EOR = true;
        return false;
    case CS_ROW_FAIL:
        throw CDB_ClientEx(eDB_Error, 130003, "CTL_RowResult::Fetch",
                           "error while fetching the row");
    case CS_FAIL:
        throw CDB_ClientEx(eDB_Error, 130006, "CTL_RowResult::Fetch",
                           "ct_fetch has failed. "
                           "You need to cancel the command");
    case CS_CANCELED:
        throw CDB_ClientEx(eDB_Error, 130004, "CTL_RowResult::Fetch",
                           "the command has been canceled");
    default:
        throw CDB_ClientEx(eDB_Error, 130005, "CTL_RowResult::Fetch",
                           "the connection is busy");
    }
}


int CTL_RowResult::CurrentItemNo() const
{
    return m_CurrItem;
}

CS_RETCODE CTL_RowResult::my_ct_get_data(CS_COMMAND* cmd, CS_INT item, 
										 CS_VOID* buffer, 
										 CS_INT buflen, CS_INT *outlen)
{
  if(item > m_BindedCols)
	return ct_get_data(cmd, item, buffer, buflen, outlen);

  --item;

  if((m_Indicator[item] < 0) || ((CS_INT)m_Indicator[item] >= m_Copied[item])) {
	if(outlen) *outlen= 0;
	return CS_END_ITEM;
  }

  if(!buffer || (buflen < 1)) return CS_SUCCEED;

  CS_INT n= m_Copied[item] - m_Indicator[item];
  if(buflen > n) buflen= n;
  memcpy(buffer, (char*)(m_BindItem[item]) + m_Indicator[item], buflen);
  if(outlen) *outlen= buflen;
  m_Indicator[item]+= buflen;
  return (n == buflen)? CS_END_ITEM : CS_SUCCEED;
}

// Aux. for CTL_RowResult::GetItem()
CDB_Object* CTL_RowResult::s_GetItem(CS_COMMAND* cmd, CS_INT item_no, CS_DATAFMT& fmt,
									 CDB_Object* item_buf)
{
    CS_INT outlen = 0;
    char buffer[2048];
    EDB_Type b_type = item_buf ? item_buf->GetType() : eDB_UnsupportedType;

    switch ( fmt.datatype ) {
    case CS_BINARY_TYPE: {
        if (item_buf  &&
            b_type != eDB_VarBinary  &&  b_type != eDB_Binary  &&
            b_type != eDB_VarChar    &&  b_type != eDB_Char &&
			b_type != eDB_LongChar   &&  b_type != eDB_LongBinary) {
            throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
                               "Wrong type of CDB_Object");
        }

        char* v = (fmt.maxlength < (CS_INT) sizeof(buffer))
            ? buffer : new char[fmt.maxlength + 1];

        switch ( my_ct_get_data(cmd, item_no, v, fmt.maxlength, &outlen) ) {
        case CS_SUCCEED:
        case CS_END_ITEM:
        case CS_END_DATA: {
            if ( item_buf ) {
                switch ( b_type ) {
                case eDB_VarBinary:
                    ((CDB_VarBinary*) item_buf)->SetValue(v, outlen);
                    break;
                case eDB_Binary:
                    ((CDB_Binary*)    item_buf)->SetValue(v, outlen);
                    break;
                case eDB_VarChar:
                    v[outlen] = '\0';
                    *((CDB_VarChar*)  item_buf) = v;
                    break;
                case eDB_Char:
                    v[outlen] = '\0';
                    *((CDB_Char*)     item_buf) = v;
                    break;
                case eDB_LongChar:
                    v[outlen] = '\0';
                    *((CDB_LongChar*)     item_buf) = v;
                    break;
                case eDB_LongBinary:
                    ((CDB_LongBinary*)     item_buf)->SetValue(v, outlen);
                    break;
                default:
                    break;
                }

                if (v != buffer)  delete[] v;
                return item_buf;
            }

            CDB_VarBinary* val = (outlen == 0)
                ? new CDB_VarBinary() : new CDB_VarBinary(v, outlen);

            if ( v != buffer)  delete[] v;
            return val;
        }
        case CS_CANCELED:
            if (v != buffer)  delete[] v;
            throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
                               "the command has been canceled");
        default:
            if (v != buffer)  delete[] v;
            throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
                               "ct_get_data failed");
        }
    }

    case CS_LONGBINARY_TYPE: {
        if (item_buf  &&
			b_type != eDB_LongChar   &&  b_type != eDB_LongBinary) {
            throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
                               "Wrong type of CDB_Object");
        }

        char* v = (fmt.maxlength < (CS_INT) sizeof(buffer))
            ? buffer : new char[fmt.maxlength + 1];

        switch ( my_ct_get_data(cmd, item_no, v, fmt.maxlength, &outlen) ) {
        case CS_SUCCEED:
        case CS_END_ITEM:
        case CS_END_DATA: {
            if ( item_buf ) {
                switch ( b_type ) {
                case eDB_LongBinary:
                    ((CDB_LongBinary*) item_buf)->SetValue(v, outlen);
                    break;
				case eDB_LongChar:
                    v[outlen] = '\0';
                    *((CDB_LongChar*)     item_buf) = v;
                default:
                    break;
                }

                if (v != buffer)  delete[] v;
                return item_buf;
            }

            CDB_LongBinary* val = (outlen == 0)
                ? new CDB_LongBinary(fmt.maxlength) : 
			      new CDB_LongBinary(fmt.maxlength, v, outlen);

            if ( v != buffer)  delete[] v;
            return val;
        }
        case CS_CANCELED:
            if (v != buffer)  delete[] v;
            throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
                               "the command has been canceled");
        default:
            if (v != buffer)  delete[] v;
            throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
                               "ct_get_data failed");
        }
    }

    case CS_BIT_TYPE: {
        if (item_buf  &&
            b_type != eDB_Bit       &&  b_type != eDB_TinyInt  &&
            b_type != eDB_SmallInt  &&  b_type != eDB_Int) {
            throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
                               "Wrong type of CDB_Object");
        }

        CS_BIT v;
        switch ( my_ct_get_data(cmd, item_no, &v, (CS_INT) sizeof(v), &outlen) ) {
        case CS_SUCCEED:
        case CS_END_ITEM:
        case CS_END_DATA: {
            if ( item_buf ) {
                if (outlen == 0) {
                    item_buf->AssignNULL();
                }
                else {
                    switch ( b_type ) {
                    case eDB_Bit:
                        *((CDB_Bit*)      item_buf) = (int) v;
                        break;
                    case eDB_TinyInt:
                        *((CDB_TinyInt*)  item_buf) = v ? 1 : 0;
                        break;
                    case eDB_SmallInt:
                        *((CDB_SmallInt*) item_buf) = v ? 1 : 0;
                        break;
                    case eDB_Int:
                        *((CDB_Int*)      item_buf) = v ? 1 : 0;
                        break;
                    default:
                        break;
                    }
                }
                return item_buf;
            }

            return (outlen == 0) ? new CDB_Bit() : new CDB_Bit((int) v);
        }
        case CS_CANCELED: {
            throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
                               "the command has been canceled");
        }
        default: {
            throw CDB_ClientEx(eDB_Error, 130000, "CTL_***Result::GetItem",
                               "ct_get_data failed");
        }
        }
    }

    case CS_CHAR_TYPE: {
        if (item_buf  &&