result.cpp

ncbi源码

                            (unsigned char*) DBNUMERIC_val(v)) : new CDB_Numeric;
    }

    case eDB_Text: {
        if (item_buff && b_type != eDB_Text && b_type != eDB_Image) {
            throw CDB_ClientEx(eDB_Error, 130020, "s_GetItem",
                               "wrong type of CDB_Object");
        }
        CDB_Text* v = item_buff ? (CDB_Text*) item_buff : new CDB_Text;
        v->Append((char*) d_ptr, (int) d_len);
        return v;
    }

    case eDB_Image: {
        if (item_buff && b_type != eDB_Text && b_type != eDB_Image) {
            throw CDB_ClientEx(eDB_Error, 130020, "s_GetItem",
                               "wrong type of CDB_Object");
        }
        CDB_Image* v = item_buff ? (CDB_Image*) item_buff : new CDB_Image;
        v->Append((void*) d_ptr, (int) d_len);
        return v;
    }

    default:
        throw CDB_ClientEx(eDB_Error, 130004, "s_GetItem",
                           "unexpected result type");
    }
}


CDB_Object* CDBL_RowResult::GetItem(CDB_Object* item_buff)
{
    if ((unsigned int) m_CurrItem >= m_NofCols) {
        return 0;
    }
    CDB_Object* r = s_GetItem(m_Cmd, m_CurrItem + 1,
                              &m_ColFmt[m_CurrItem], item_buff);
    ++m_CurrItem;
    m_Offset = 0;
    return r;
}


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

    const BYTE* d_ptr = dbdata  (m_Cmd, m_CurrItem + 1);
    DBINT d_len = dbdatlen(m_Cmd, m_CurrItem + 1);

    if (d_ptr == 0 || d_len < 1) { // NULL value
        ++m_CurrItem;
        m_Offset = 0;
        if (is_null)
            *is_null = true;
        return 0;
    }

    if (is_null)
        *is_null = false;
    if ((size_t) d_len - m_Offset < buffer_size)
        buffer_size = (size_t) d_len - m_Offset;
    memcpy(buffer, d_ptr + m_Offset, buffer_size);
    m_Offset += buffer_size;
    if (m_Offset >= (size_t) d_len) {
        m_Offset = 0;
        ++m_CurrItem;
    }

    return buffer_size;
}


I_ITDescriptor* CDBL_RowResult::GetImageOrTextDescriptor()
{
    if ((unsigned int) m_CurrItem >= m_NofCols)
        return 0;
    return new CDBL_ITDescriptor(m_Cmd, m_CurrItem+1);
}


bool CDBL_RowResult::SkipItem()
{
    if ((unsigned int) m_CurrItem < m_NofCols) {
        ++m_CurrItem;
        m_Offset = 0;
        return true;
    }
    return false;
}


CDBL_RowResult::~CDBL_RowResult()
{
    if (m_ColFmt) {
        delete[] m_ColFmt;
        m_ColFmt = 0;
    }
    if (!m_EOR)
        dbcanquery(m_Cmd);
}



/////////////////////////////////////////////////////////////////////////////
//
//  CDBL_BlobResult::


CDBL_BlobResult::CDBL_BlobResult(DBPROCESS* cmd) :
    m_Cmd(cmd), m_CurrItem(-1), m_EOR(false)
{
    m_CmdNum = DBCURCMD(cmd);

    m_ColFmt.max_length = dbcollen(m_Cmd, 1);
    m_ColFmt.data_type = s_GetDataType(m_Cmd, 1);
    const char* s = dbcolname(m_Cmd, 1);
    m_ColFmt.col_name = s ? s : "";
}

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


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


const char* CDBL_BlobResult::ItemName(unsigned int item_num) const
{
    return item_num ? 0 : m_ColFmt.col_name.c_str();
}


size_t CDBL_BlobResult::ItemMaxSize(unsigned int item_num) const
{
    return item_num ? 0 : m_ColFmt.max_length;
}


EDB_Type CDBL_BlobResult::ItemDataType(unsigned int) const
{
    return m_ColFmt.data_type;
}


bool CDBL_BlobResult::Fetch()
{
    if (m_EOR)
        return false;

    STATUS s;
    if (m_CurrItem == 0) {
        while ((s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff))) > 0)
            ;
        switch (s) {
        case 0:
            break;
        case NO_MORE_ROWS:
            m_EOR = true;
            return false;
        default:
            throw CDB_ClientEx(eDB_Error, 280003, "CDBL_BlobResult::Fetch",
                               "error in fetching row");
        }
    }
    else m_CurrItem = 0;
    s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff));
    if(s == NO_MORE_ROWS) return false;
    if(s < 0) {
        throw CDB_ClientEx(eDB_Error, 280003, "CDBL_BlobResult::Fetch",
                           "error in fetching row");
    }
    m_BytesInBuffer= s;
    m_ReadedBytes= 0;
    return true;
}


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


CDB_Object* CDBL_BlobResult::GetItem(CDB_Object* item_buff)
{
    if (m_CurrItem)
        return 0;

    EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;

    if (item_buff && b_type != eDB_Text && b_type != eDB_Image) {
        throw CDB_ClientEx(eDB_Error, 230020, "CDBL_BlobResult::GetItem",
                           "wrong type of CDB_Object");
    }

    if (item_buff == 0) {
        item_buff = m_ColFmt.data_type == eDB_Text
            ? (CDB_Object*) new CDB_Text : (CDB_Object*) new CDB_Image;
    }

    CDB_Text* val = (CDB_Text*) item_buff;

    // check if we do have something in buffer
    if(m_ReadedBytes < m_BytesInBuffer) {
        val->Append(m_Buff + m_ReadedBytes, m_BytesInBuffer - m_ReadedBytes);
        m_ReadedBytes= m_BytesInBuffer;
    }

    if(m_BytesInBuffer == 0) {
        return item_buff;
    }
        

    STATUS s;
    while ((s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff))) > 0)
        val->Append(m_Buff, (s < sizeof(m_Buff))? (size_t)s : sizeof(m_Buff));

    switch (s) {
    case NO_MORE_ROWS:
        m_EOR = true;
    case 0:
        m_CurrItem = 1;
        break;
    default:
        throw CDB_ClientEx(eDB_Error, 280003, "CDBL_BlobResult::GetItem",
                           "dbreadtext failed");
    }

    return item_buff;
}


size_t CDBL_BlobResult::ReadItem(void* buffer, size_t buffer_size,
                                 bool* is_null)
{
    if(m_BytesInBuffer == 0) 
        m_CurrItem= 1;

    if (m_CurrItem != 0) {
        if (is_null)
            *is_null = true;
        return 0;
    }

    size_t l= 0;
    // check if we do have something in buffer
    if(m_ReadedBytes < m_BytesInBuffer) {
        l= m_BytesInBuffer - m_ReadedBytes;
        if(l >= buffer_size) {
            memcpy(buffer, m_Buff + m_ReadedBytes, buffer_size);
            m_ReadedBytes+= buffer_size;
            if (is_null)
                *is_null = false;
            return buffer_size;
        }
        memcpy(buffer, m_Buff + m_ReadedBytes, l);
    }
        
    STATUS s = dbreadtext(m_Cmd, (void*)((char*)buffer + l), (DBINT)(buffer_size-l));
    switch (s) {
    case NO_MORE_ROWS:
        m_EOR = true;
    case 0:
        m_CurrItem = 1;
        break;
    case -1:
        throw CDB_ClientEx(eDB_Error, 280003, "CDBL_BlobResult::ReadItem",
                           "dbreadtext failed");
    default:
        break;
    }

    if(is_null) *is_null= (m_BytesInBuffer == 0 && s <= 0);
    return (size_t) s + l;
}


I_ITDescriptor* CDBL_BlobResult::GetImageOrTextDescriptor()
{
    if (m_CurrItem != 0)
        return 0;
    return new CDBL_ITDescriptor(m_Cmd, 1);
}


bool CDBL_BlobResult::SkipItem()
{
    if (m_EOR || m_CurrItem)
        return false;

    STATUS s;
    while ((s = dbreadtext(m_Cmd, m_Buff, (DBINT) sizeof(m_Buff))) > 0);
    switch (s) {
    case NO_MORE_ROWS:
        m_EOR = true;
    case 0:
        m_CurrItem = 1;
        break;
    default:
        throw CDB_ClientEx(eDB_Error, 280003, "CDBL_BlobResult::SkipItem",
                           "dbreadtext failed");
    }
    return true;
}


CDBL_BlobResult::~CDBL_BlobResult()
{
    if (!m_EOR)
        dbcanquery(m_Cmd);
}


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

static EDB_Type s_RetGetDataType(DBPROCESS* cmd, int n)
{
    switch (dbrettype(cmd, n)) {
    case SYBBINARY:    return (dbretlen(cmd, n) > 255)? eDB_LongBinary : 
                                                        eDB_VarBinary;
    case SYBBIT:       return eDB_Bit;
    case SYBCHAR:      return (dbretlen(cmd, n) > 255)? eDB_LongChar : 
                                                        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 CDBL_ParamResult::GetItem()
static CDB_Object* s_RetGetItem(DBPROCESS* cmd, int item_no,
                                SDBL_ColDescr* fmt, CDB_Object* item_buff)
{
    EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
    const BYTE* d_ptr = dbretdata(cmd, item_no);
    DBINT d_len = dbretlen (cmd, 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, 230004, "s_RetGetItem",
                           "unexpected result type");
    }
    return val;
}


/////////////////////////////////////////////////////////////////////////////
//
//  CDBL_ParamResult::
//

CDBL_ParamResult::CDBL_ParamResult(DBPROCESS* cmd, int nof_params) :
    CDBL_RowResult(cmd, 0, false)
{

    m_NofCols = nof_params;
    m_CmdNum = DBCURCMD(cmd);

    m_ColFmt = new SDBL_ColDescr[m_NofCols];
    for (unsigned int n = 0; n < m_NofCols; n++) {
        m_ColFmt[n].max_length = 255;
        m_ColFmt[n].data_type = s_RetGetDataType(m_Cmd, n + 1);
        const char* s = dbretname(m_Cmd, n + 1);
        m_ColFmt[n].col_name = s ? s : "";
    }
    m_1stFetch = true;
}


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


bool CDBL_ParamResult::Fetch()
{
    if (m_1stFetch) { // we didn't get the items yet;
        m_1stFetch = false;
	m_CurrItem= 0;
        return true;
    }
    m_CurrItem= -1;
    return false;
}


CDB_Object* CDBL_ParamResult::GetItem(CDB_Object* item_buff)
{
    if ((unsigned int) m_CurrItem >= m_NofCols) {
        return 0;
    }

    CDB_Object* r = s_RetGetItem(m_Cmd, m_CurrItem + 1,
                                 &m_ColFmt[m_CurrItem], item_buff);
    ++m_CurrItem;
    m_Offset = 0;
    return r;
}


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

    const BYTE* d_ptr = dbretdata(m_Cmd, m_CurrItem + 1);
    DBINT d_len = dbretlen (m_Cmd, m_CurrItem + 1);

    if (d_ptr == 0 || d_len < 1) { // NULL value
        ++m_CurrItem;
        m_Offset = 0;
        if (is_null)
            *is_null = true;
        return 0;
    }

    if (is_null)
        *is_null = false;
    if ((size_t) d_len - m_Offset < buffer_size)
        buffer_size = (size_t) d_len - m_Offset;
    memcpy(buffer, d_ptr + m_Offset, buffer_size);
    m_Offset += buffer_size;
    if (m_Offset >= (size_t) d_len) {
        m_Offset = 0;
        ++m_CurrItem;
    }
    return buffer_size;
}


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


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


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

static EDB_Type s_AltGetDataType(DBPROCESS* cmd, int id, int n)
{
    switch (dbalttype(cmd, id, n)) {
    case SYBBINARY:    return (dbaltlen(cmd, id, n) > 255)? eDB_LongBinary : 
                                                        eDB_VarBinary;
    case SYBBIT:       return eDB_Bit;
    case SYBCHAR:      return (dbaltlen(cmd, id, n) > 255)? eDB_LongChar : 
                                                        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 CDBL_ComputeResult::GetItem()
static CDB_Object* s_AltGetItem(DBPROCESS* cmd, int id, int item_no,
                                SDBL_ColDescr* fmt, CDB_Object* item_buff)
{
    EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
    const 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;
}



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

CDBL_ComputeResult::CDBL_ComputeResult(DBPROCESS* cmd,
                                       unsigned int* res_stat) :
    CDBL_RowResult(cmd, res_stat, false)
{
    m_ComputeId = DBROWTYPE(cmd);
    if (m_ComputeId == REG_ROW || m_ComputeId == NO_MORE_ROWS) {
        throw CDB_ClientEx(eDB_Error, 270000,
                           "CDBL_ComputeResult::CDBL_ComputeResult",
                           "no compute row found");
    }
    m_NofCols = dbnumalts(cmd, m_ComputeId);
    if (m_NofCols < 1) {
        throw CDB_ClientEx(eDB_Error, 270001,
                           "CDBL_ComputeResult::CDBL_ComputeResult",
                           "compute id is invalid");
    }
    m_CmdNum = DBCURCMD(cmd);
    m_ColFmt = new SDBL_ColDescr[m_NofCols];
    for (unsigned int n = 0; n < m_NofCols; n++) {
        m_ColFmt[n].max_length = dbaltlen(m_Cmd, m_ComputeId, n+1);
        m_ColFmt[n].data_type = s_AltGetDataType(m_Cmd, m_ComputeId, n + 1);
        int op = dbaltop(m_Cmd, m_ComputeId, n + 1);
        const char* s = op != -1 ? dbprtype(op) : "Unknown";
        m_ColFmt[n].col_name = s ? s : "";
    }
    m_1stFetch = true;
}


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


bool CDBL_ComputeResult::Fetch()
{
    if (m_1stFetch) { // we didn't get the items yet;