result.cpp

ncbi源码

I_ITDescriptor* CTDS_ParamResult::GetImageOrTextDescriptor()
{
    return 0;
}


CTDS_ParamResult::~CTDS_ParamResult()
{
    if (m_ColFmt) {
        delete[] m_ColFmt;
        m_ColFmt = 0;
    }
}


/////////////////////////////////////////////////////////////////////////////

#if 0

static EDB_Type s_AltGetDataType(DBPROCESS* cmd, int id, int n)
{
    switch (dbalttype(cmd, id, n)) {
    case SYBBINARY:    return eDB_VarBinary;
    case SYBBIT:       return eDB_Bit;
    case SYBCHAR:      return eDB_VarChar;
    case SYBDATETIME:  return eDB_DateTime;
    case SYBDATETIME4: return eDB_SmallDateTime;
    case SYBINT1:      return eDB_TinyInt;
    case SYBINT2:      return eDB_SmallInt;
    case SYBINT4:      return eDB_Int;
    case SYBFLT8:      return eDB_Double;
    case SYBREAL:      return eDB_Float;
    default:           return eDB_UnsupportedType;
    }
}


// Aux. for CTDS_ComputeResult::GetItem()
static CDB_Object* s_AltGetItem(DBPROCESS* cmd, int id, int item_no,
                                STDS_ColDescr* fmt, CDB_Object* item_buff)
{
    EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
    BYTE* d_ptr = dbadata(cmd, id, item_no);
    DBINT d_len = dbadlen(cmd, id, item_no);
    CDB_Object* val = s_GenericGetItem(fmt->data_type, item_buff,
                                       b_type, d_ptr, d_len);
    if (!val) {
        throw CDB_ClientEx(eDB_Error, 130004, "s_AltGetItem",
                           "unexpected result type");
    }
    return val;
}

#endif



/////////////////////////////////////////////////////////////////////////////
//
//  CTL_ComputeResult::
//

CTDS_ComputeResult::CTDS_ComputeResult(DBPROCESS* cmd,
                                       unsigned int* res_stat)
    : CTDS_RowResult(cmd, res_stat, false)
{
    throw CDB_ClientEx(eDB_Error, 270000,
                       "CDBL_ComputeResult::CDBL_ComputeResult",
                       "The compute results do not implemented in Free TDS");
}


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


bool CTDS_ComputeResult::Fetch()
{
    return false; // do not implemented in Free TDS
}


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


CDB_Object* CTDS_ComputeResult::GetItem(CDB_Object* /*item_buff*/)
{
    return 0; // not implemented in Free TDS
}


size_t CTDS_ComputeResult::ReadItem(void* /*buffer*/, size_t /*buffer_size*/,
                                    bool* /*is_null*/)
{
    return 0; // not implemented in Free TDS
}


I_ITDescriptor* CTDS_ComputeResult::GetImageOrTextDescriptor()
{
    return 0;
}


CTDS_ComputeResult::~CTDS_ComputeResult()
{
    return;
}



/////////////////////////////////////////////////////////////////////////////
//
//  CTL_StatusResult::
//


CTDS_StatusResult::CTDS_StatusResult(DBPROCESS* cmd)
{
    m_Val = dbretstatus(cmd);
    m_Offset = 0;
    m_1stFetch = true;
}

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


unsigned int CTDS_StatusResult::NofItems() const
{
    return 1;
}


const char* CTDS_StatusResult::ItemName(unsigned int) const
{
    return 0;
}


size_t CTDS_StatusResult::ItemMaxSize(unsigned int) const
{
    return sizeof(DBINT);
}


EDB_Type CTDS_StatusResult::ItemDataType(unsigned int) const
{
    return eDB_Int;
}


bool CTDS_StatusResult::Fetch()
{
    if (m_1stFetch) {
        m_1stFetch = false;
        return true;
    }
    return false;
}


int CTDS_StatusResult::CurrentItemNo() const
{
    return m_1stFetch? -1 : 0;
}


CDB_Object* CTDS_StatusResult::GetItem(CDB_Object* item_buff)
{
    if (!item_buff)
        return new CDB_Int(m_Val);

    if (item_buff->GetType() != eDB_Int) {
        throw CDB_ClientEx(eDB_Error, 230020, "CTDS_StatusResult::GetItem",
                           "wrong type of CDB_Object");
    }

    CDB_Int* i = (CDB_Int*) item_buff;
    *i = m_Val;
    return item_buff;
}


size_t CTDS_StatusResult::ReadItem(void* buffer, size_t buffer_size,
                                   bool* is_null)
{
    if (is_null)
        *is_null = false;


    if (sizeof(int) <= (size_t) m_Offset)
        return 0;

    size_t l = sizeof(int) - m_Offset;

    char* p = (char*) &m_Val;

    if (buffer_size > l)
        buffer_size = l;
    memcpy(buffer, p + m_Offset, buffer_size);
    m_Offset += buffer_size;
    return buffer_size;
}


I_ITDescriptor* CTDS_StatusResult::GetImageOrTextDescriptor()
{
    return 0;
}


bool CTDS_StatusResult::SkipItem()
{
    return false;
}


CTDS_StatusResult::~CTDS_StatusResult()
{
    return;
}



/////////////////////////////////////////////////////////////////////////////
//
//  CTL_CursorResult::
//

CTDS_CursorResult::CTDS_CursorResult(CDB_LangCmd* cmd)
    : m_Cmd(cmd), m_Res(0)
{
    try {
        m_Cmd->Send();
        while (m_Cmd->HasMoreResults()) {
            m_Res = m_Cmd->Result();
            if (m_Res  &&  m_Res->ResultType() == eDB_RowResult) {
                return;
            }
            if (m_Res) {
                while (m_Res->Fetch())
                    continue;
                delete m_Res;
                m_Res = 0;
            }
        }
    } catch (CDB_Exception& e) {
        throw CDB_ClientEx(eDB_Error, 222010,
                           "CTDS_CursorResult::CTDS_CursorResult",
                           "failed to get the results");
    }
}


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


unsigned int CTDS_CursorResult::NofItems() const
{
    return m_Res? m_Res->NofItems() : 0;
}


const char* CTDS_CursorResult::ItemName(unsigned int item_num) const
{
    return m_Res ? m_Res->ItemName(item_num) : 0;
}


size_t CTDS_CursorResult::ItemMaxSize(unsigned int item_num) const
{
    return m_Res ? m_Res->ItemMaxSize(item_num) : 0;
}


EDB_Type CTDS_CursorResult::ItemDataType(unsigned int item_num) const
{
    return m_Res ? m_Res->ItemDataType(item_num) : eDB_UnsupportedType;
}


bool CTDS_CursorResult::Fetch()
{
    if (!m_Res)
        return false;

    try {
        if (m_Res->Fetch())
            return true;
    }
    catch (CDB_ClientEx& ex) {
        if (ex.ErrCode() == 200003) {
            m_Res = 0;
        } else {
            throw CDB_ClientEx(eDB_Error, 222011, "CDBL_CursorResult::Fetch",
                               "Failed to fetch the results");
        }
    }

    // try to get next cursor result
    try {
        // finish this command
        if (m_Res)
            delete m_Res;
        while (m_Cmd->HasMoreResults()) {
            m_Res = m_Cmd->Result();
            if (m_Res) {
                while (m_Res->Fetch())
                    continue;
                delete m_Res;
                m_Res = 0;
            }
        }
        // send the another "fetch cursor_name" command
        m_Cmd->Send();
        while (m_Cmd->HasMoreResults()) {
            m_Res = m_Cmd->Result();
            if (m_Res  &&  m_Res->ResultType() == eDB_RowResult) {
                return m_Res->Fetch();
            }
            if (m_Res) {
                while (m_Res->Fetch())
                    continue;
                delete m_Res;
                m_Res = 0;
            }
        }
    } catch (CDB_Exception& e) {
        throw CDB_ClientEx(eDB_Error, 222011, "CTDS_CursorResult::Fetch",
                           "Failed to fetch the results");
    }
    return false;
}


int CTDS_CursorResult::CurrentItemNo() const
{
    return m_Res ? m_Res->CurrentItemNo() : -1;
}


CDB_Object* CTDS_CursorResult::GetItem(CDB_Object* item_buff)
{
    return m_Res ? m_Res->GetItem(item_buff) : 0;
}


size_t CTDS_CursorResult::ReadItem(void* buffer, size_t buffer_size,
                                   bool* is_null)
{
    if (m_Res) {
        return m_Res->ReadItem(buffer, buffer_size, is_null);
    }
    if (is_null)
        *is_null = true;
    return 0;
}


I_ITDescriptor* CTDS_CursorResult::GetImageOrTextDescriptor()
{
    return m_Res ? m_Res->GetImageOrTextDescriptor() : 0;
}


bool CTDS_CursorResult::SkipItem()
{
    return m_Res ? m_Res->SkipItem() : false;
}


CTDS_CursorResult::~CTDS_CursorResult()
{
    delete m_Res;
}



/////////////////////////////////////////////////////////////////////////////
//
//  CTDS_ITDescriptor::
//

CTDS_ITDescriptor::CTDS_ITDescriptor(DBPROCESS* dblink, int col_num)
{

    m_ObjName = dbcolsource(dblink, col_num);
    DBBINARY* p = dbtxptr(dblink, col_num);
    if (p) {
        memcpy(m_TxtPtr, p, DBTXPLEN);
        m_TxtPtr_is_NULL = false;
    } else
        m_TxtPtr_is_NULL = true;

    p = dbtxtimestamp(dblink, col_num);
    if (p) {
        memcpy(m_TimeStamp, p, DBTXTSLEN);
        m_TimeStamp_is_NULL = false;
    } else
        m_TimeStamp_is_NULL = true;
}


CTDS_ITDescriptor::CTDS_ITDescriptor(DBPROCESS* dblink,
                                     const CDB_ITDescriptor& inp_d)
{
    m_ObjName = inp_d.TableName();
    m_ObjName += ".";
    m_ObjName += inp_d.ColumnName();


    DBBINARY* p = dbtxptr(dblink, 1);
    if (p) {
        memcpy(m_TxtPtr, p, DBTXPLEN);
        m_TxtPtr_is_NULL = false;
    } else
        m_TxtPtr_is_NULL = true;

    p = dbtxtimestamp(dblink, 1);
    if (p) {
        memcpy(m_TimeStamp, p, DBTXTSLEN);
        m_TimeStamp_is_NULL = false;
    } else
        m_TimeStamp_is_NULL = true;
}


int CTDS_ITDescriptor::DescriptorType() const
{
    return CTDS_ITDESCRIPTOR_TYPE_MAGNUM;
}


CTDS_ITDescriptor::~CTDS_ITDescriptor()
{
    return;
}


END_NCBI_SCOPE



/*
 * ===========================================================================
 * $Log: result.cpp,v $
 * Revision 1000.2  2004/06/01 19:20:55  gouriano
 * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.14
 *
 * Revision 1.14  2004/05/17 21:13:37  gorelenk
 * Added include of PCH ncbi_pch.hpp
 *
 * Revision 1.13  2004/02/24 20:22:12  soussov
 * SYBBITN processing added
 *
 * Revision 1.12  2003/04/29 21:15:03  soussov
 * new datatypes CDB_LongChar and CDB_LongBinary added
 *
 * Revision 1.11  2003/02/06 16:26:52  soussov
 * adding support for bigint datatype
 *
 * Revision 1.10  2003/01/06 16:59:31  soussov
 * sets m_CurrItem = -1 for all result types if no fetch was called
 *
 * Revision 1.9  2003/01/03 21:48:18  soussov
 * set m_CurrItem = -1 if fetch failes
 *
 * Revision 1.8  2002/07/18 14:59:31  soussov
 * fixes bug in blob result
 *
 * Revision 1.7  2002/06/13 21:10:18  soussov
 * freeTDS does not place doubles properly in memory, patch added
 *
 * Revision 1.6  2002/06/08 06:18:43  vakatov
 * Ran through 64-bit compilation (tests were successful on Solaris/Forte6u2).
 * Fixed a return type in CTDS_CursorResult::ItemMaxSize, eliminated a couple
 * of warnings. Formally formatted the code to fit the C++ Toolkit style.
 *
 * Revision 1.5  2002/05/29 22:04:29  soussov
 * Makes BlobResult read ahead
 *
 * Revision 1.4  2002/03/26 15:35:10  soussov
 * new image/text operations added
 *
 * Revision 1.3  2002/02/06 22:30:56  soussov
 * fixes the arguments order in numeric assign
 *
 * Revision 1.2  2001/11/06 18:00:02  lavr
 * Formatted uniformly as the rest of the library
 *
 * Revision 1.1  2001/10/25 00:39:22  vakatov
 * Initial revision
 *
 * ===========================================================================
 */