result.cpp

ncbi源码

                               "Wrong type of CDB_Object");
        }

        CS_FLOAT 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 {
                    *((CDB_Double*) item_buf) = (double) v;
                }
                return item_buf;
            }

            return (outlen == 0)
                ? new CDB_Double() : new CDB_Double((double) 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_REAL_TYPE: {
        if (item_buf  &&  b_type != eDB_Float) {
            throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
                               "Wrong type of CDB_Object");
        }

        CS_REAL 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 {
                    *((CDB_Float*) item_buf) = (float) v;
                }
                return item_buf;
            }

            return (outlen == 0) ? new CDB_Float() : new CDB_Float((float) 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_TEXT_TYPE:
    case CS_IMAGE_TYPE: {
       if (item_buf  &&  b_type != eDB_Text  &&  b_type != eDB_Image) {
            throw CDB_ClientEx(eDB_Error, 130020, "CTL_***Result::GetItem",
                               "Wrong type of CDB_Object");
        }

        CDB_Stream* val =
            item_buf                         ? (CDB_Stream*) item_buf
            : (fmt.datatype == CS_TEXT_TYPE) ? (CDB_Stream*) new CDB_Text
            :                                  (CDB_Stream*) new CDB_Image;

        for (;;) {
            switch ( my_ct_get_data(cmd, item_no, buffer, 2048, &outlen) ) {
            case CS_SUCCEED:
                if (outlen != 0)
                    val->Append(buffer, outlen);
                continue;
            case CS_END_ITEM:
            case CS_END_DATA:
                if (outlen != 0)
                    val->Append(buffer, outlen);
                return val;
            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");
            }
        }
    }

    default: {
        throw CDB_ClientEx(eDB_Error, 130004, "CTL_***Result::GetItem",
                           "unexpected result type");
    }
    }
}


CDB_Object* CTL_RowResult::GetItem(CDB_Object* item_buf)
{
    if ((unsigned int) m_CurrItem >= m_NofCols  ||  m_CurrItem == -1) {
        return 0;
    }

    CDB_Object* item = s_GetItem(m_Cmd, m_CurrItem + 1, m_ColFmt[m_CurrItem],
                                 item_buf);

    ++m_CurrItem;
    return item;
}


size_t CTL_RowResult::ReadItem(void* buffer, size_t buffer_size,
                               bool* is_null)
{
    if ((unsigned int) m_CurrItem >= m_NofCols  ||  m_CurrItem == -1) {
        return 0;
    }

    CS_INT outlen = 0;

    if((buffer == 0) && (buffer_size == 0)) {
	buffer= (void*)(&buffer_size);
    }

    switch ( my_ct_get_data(m_Cmd, m_CurrItem+1, buffer, (CS_INT) buffer_size,
                         &outlen) ) {
    case CS_END_ITEM:
    case CS_END_DATA:
        ++m_CurrItem;
    case CS_SUCCEED:
        break;
    case CS_CANCELED:
        throw CDB_ClientEx(eDB_Error, 130004, "CTL_RowResult::ReadItem",
                           "the command has been canceled");
    default:
        throw CDB_ClientEx(eDB_Error, 130000, "CTL_RowResult::ReadItem",
                           "ct_get_data failed");
    }

    if ( is_null ) {
        *is_null = (outlen == 0);
    }

    return (size_t) outlen;
}


I_ITDescriptor* CTL_RowResult::GetImageOrTextDescriptor()
{
    if ((unsigned int) m_CurrItem >= m_NofCols  ||  m_CurrItem == -1) {
        return 0;
    }

    char dummy[4];
    switch ( my_ct_get_data(m_Cmd, m_CurrItem+1, dummy, 0, 0) ) {
    case CS_END_ITEM:
    case CS_END_DATA:
    case CS_SUCCEED:
        break;
    case CS_CANCELED:
        throw CDB_ClientEx(eDB_Error, 130004,
                           "CTL_RowResult::GetImageOrTextDescriptor",
                           "the command has been canceled");
    default:
        throw CDB_ClientEx(eDB_Error, 130000,
                           "CTL_RowResult::GetImageOrTextDescriptor",
                           "ct_get_data failed");
    }


    CTL_ITDescriptor* desc = new CTL_ITDescriptor;

    if (ct_data_info(m_Cmd, CS_GET, m_CurrItem+1, &desc->m_Desc)
        != CS_SUCCEED) {
        delete desc;
        throw CDB_ClientEx(eDB_Error, 130010,
                           "CTL_RowResult::GetImageOrTextDescriptor",
                           "ct_data_info failed");
    }

    return desc;
}


bool CTL_RowResult::SkipItem()
{
    if (m_CurrItem < (int) m_NofCols) {
        ++m_CurrItem;
        return true;
    }

    return false;
}


CTL_RowResult::~CTL_RowResult()
{
    if ( m_ColFmt ) {
        delete[] m_ColFmt;
    }
	if(m_BindedCols) {
	  delete [] m_BindItem;
	  delete [] m_Copied;
	  delete [] m_Indicator;
	}

    if ( m_EOR ) {
        return;
    }

    switch (ct_cancel(NULL, m_Cmd, CS_CANCEL_CURRENT)) {
    case CS_SUCCEED:
    case CS_CANCELED:
        break;
    default:
        CS_INT err_code = 130007;
        ct_cmd_props(m_Cmd, CS_SET, CS_USERDATA,
                     &err_code, (CS_INT) sizeof(err_code), 0);
    }
}



/////////////////////////////////////////////////////////////////////////////
//
//  CTL_ParamResult::
//  CTL_ComputeResult::
//  CTL_StatusResult::
//  CTL_CursorResult::
//

EDB_ResType CTL_ParamResult::ResultType() const
{
    return eDB_ParamResult;
}


EDB_ResType CTL_ComputeResult::ResultType() const
{
    return eDB_ComputeResult;
}


EDB_ResType CTL_StatusResult::ResultType() const
{
    return eDB_StatusResult;
}


EDB_ResType CTL_CursorResult::ResultType() const
{
    return eDB_CursorResult;
}


bool CTL_CursorResult::SkipItem()
{
    if (m_CurrItem < (int) m_NofCols) {
        ++m_CurrItem;
	char dummy[4];
	switch ( my_ct_get_data(m_Cmd, m_CurrItem, dummy, 0, 0) ) {
	case CS_END_ITEM:
	case CS_END_DATA:
	case CS_SUCCEED:
	    break;
	case CS_CANCELED:
	    throw CDB_ClientEx(eDB_Error, 130004,
			       "CTL_CursorResult::SkipItem",
			       "the command has been canceled");
	default:
	    throw CDB_ClientEx(eDB_Error, 130000,
			       "CTL_CursorResult::SkipItem",
			       "ct_get_data failed");
	}
        return true;
    }

    return false;
}

CTL_CursorResult::~CTL_CursorResult()
{
    if (m_EOR) { // this is not a bug
        CS_INT res_type;
        while (ct_results(m_Cmd, &res_type) == CS_SUCCEED) {
            continue;
        }
    }
    else m_EOR= true; // to prevent ct_cancel call (close cursor will do a job)
}



/////////////////////////////////////////////////////////////////////////////
//
//  CTL_ITDescriptor::
//

CTL_ITDescriptor::CTL_ITDescriptor()
{
    return;
}

int CTL_ITDescriptor::DescriptorType() const
{
    return CTL_ITDESCRIPTOR_TYPE_MAGNUM;
}


CTL_ITDescriptor::~CTL_ITDescriptor()
{
    return;
}


END_NCBI_SCOPE



/*
 * ===========================================================================
 * $Log: result.cpp,v $
 * Revision 1000.1  2004/06/01 19:19:47  gouriano
 * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.18
 *
 * Revision 1.18  2004/05/17 21:12:03  gorelenk
 * Added include of PCH ncbi_pch.hpp
 *
 * Revision 1.17  2003/04/29 21:15:35  soussov
 * new datatypes CDB_LongChar and CDB_LongBinary added
 *
 * Revision 1.16  2003/04/21 20:18:14  soussov
 * Buffering fetched result to avoid ct_get_data performance issue
 *
 * Revision 1.15  2003/01/03 21:47:42  soussov
 * set m_CurrItem = -1 if fetch failes
 *
 * Revision 1.14  2002/11/27 17:09:50  soussov
 * patch to fix NULL numeric related bug in ctlib for Windows
 *
 * Revision 1.13  2002/03/26 15:34:38  soussov
 * new image/text operations added
 *
 * Revision 1.12  2002/02/06 22:24:43  soussov
 * fixes the arguments order in numeric assign
 *
 * Revision 1.11  2002/01/04 19:41:46  soussov
 * allows usage ReadItem(0, 0)
 *
 * Revision 1.10  2001/11/06 18:02:00  lavr
 * Added methods formely inline (moved from header files)
 *
 * Revision 1.9  2001/10/11 16:30:44  soussov
 * exclude ctlib dependencies from numeric conversion calls
 *
 * Revision 1.8  2001/10/03 14:21:01  soussov
 * pevents the ct_cancel call in ~CTL_CursorResult()
 *
 * Revision 1.7  2001/10/02 22:14:50  soussov
 * fixed bug in ~CTL_CursorResult()
 *
 * Revision 1.6  2001/10/01 19:27:40  soussov
 * Fixed typo in ~CTL_CursorResult
 *
 * Revision 1.5  2001/10/01 19:13:56  soussov
 * Eliminates double deletes in results destructor
 *
 * Revision 1.4  2001/09/27 23:01:07  vakatov
 * CTL_***Result::  virtual methods' implementation moved away from the header
 *
 * Revision 1.3  2001/09/27 20:08:33  vakatov
 * Added "DB_" (or "I_") prefix where it was missing
 *
 * Revision 1.2  2001/09/26 23:23:31  vakatov
 * Moved the err.message handlers' stack functionality (generic storage
 * and methods) to the "abstract interface" level.
 *
 * Revision 1.1  2001/09/21 23:40:02  vakatov
 * -----  Initial (draft) revision.  -----
 * This is a major revamp (by Denis Vakatov, with help from Vladimir Soussov)
 * of the DBAPI "driver" libs originally written by Vladimir Soussov.
 * The revamp involved massive code shuffling and grooming, numerous local
 * API redesigns, adding comments and incorporating DBAPI to the C++ Toolkit.
 *
 * ===========================================================================
 */