result.cpp

ncbi源码

		  return v ?
            new CDB_BigInt(*v) : new CDB_BigInt;
	    }
        DBNUMERIC* v = (DBNUMERIC*) d_ptr;
        if (item_buff) {
            if (v) {
                if (b_type == eDB_Numeric) {
                    ((CDB_Numeric*) item_buff)->Assign
                        ((unsigned int)   v->precision,
                         (unsigned int)   v->scale,
                         (unsigned char*) v->array);
                } else if (b_type == eDB_BigInt) {
                    *((CDB_BigInt*) item_buff) = numeric_to_longlong
                        ((unsigned int) v->precision, v->array);
                } else {
                    throw CDB_ClientEx(eDB_Error, 230020, "s_GetItem",
                                       "wrong type of CDB_Object");
                }
            } else
                item_buff->AssignNULL();
            return item_buff;
        }

        return v ?
            new CDB_BigInt(numeric_to_longlong((unsigned int) v->precision,
                                               v->array)) : new CDB_BigInt;
    }

    case eDB_Numeric: {
        DBNUMERIC* v = (DBNUMERIC*) d_ptr;
        if (item_buff) {
            if (v) {
                if (b_type == eDB_Numeric) {
                    ((CDB_Numeric*) item_buff)->Assign
                        ((unsigned int)   v->precision,
                         (unsigned int)   v->scale,
                         (unsigned char*) v->array);
                } else {
                    throw CDB_ClientEx(eDB_Error, 230020, "s_GetItem",
                                       "wrong type of CDB_Object");
                }
            } else
                item_buff->AssignNULL();
            return item_buff;
        }

        return v ?
            new CDB_Numeric((unsigned int)   v->precision,
                            (unsigned int)   v->scale,
                            (unsigned char*) v->array) : 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* CTDS_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 CTDS_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;
    }

    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 = d_len - m_Offset;
    }

    if (buffer)
        memcpy(buffer, d_ptr + m_Offset, buffer_size);
    m_Offset += buffer_size;
    if (m_Offset >= d_len) {
        m_Offset = 0;
        ++m_CurrItem;
    }

    return buffer_size;
}


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


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


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



/////////////////////////////////////////////////////////////////////////////
//
//  CTDS_BlobResult::


CTDS_BlobResult::CTDS_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);
    char* s = dbcolname(m_Cmd, 1);
    m_ColFmt.col_name = s ? s : "";
}

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


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


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


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


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


bool CTDS_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, "CTDS_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, "CTDS_BlobResult::Fetch",
                           "error in fetching row");
    }
    m_BytesInBuffer = s;
    m_ReadedBytes = 0;
    return true;
}


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


CDB_Object* CTDS_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, "CTDS_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, "CTDS_BlobResult::GetItem",
                           "dbreadtext failed");
    }

    return item_buff;
}


size_t CTDS_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, "CTDS_BlobResult::ReadItem",
                           "dbreadtext failed");
    default:
        break;
    }

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


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


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

    STATUS s;
    while ((s = dbreadtext(m_Cmd, m_Buff, sizeof(m_Buff))) > 0)
        continue;

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


CTDS_BlobResult::~CTDS_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 CTDS_ParamResult::GetItem()
static CDB_Object* s_RetGetItem(DBPROCESS* cmd, int item_no,
                                STDS_ColDescr* fmt, CDB_Object* item_buff)
{
    EDB_Type b_type = item_buff ? item_buff->GetType() : eDB_UnsupportedType;
    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;
}


/////////////////////////////////////////////////////////////////////////////
//
//  CTDS_ParamResult::
//

CTDS_ParamResult::CTDS_ParamResult(DBPROCESS* cmd, int nof_params)
    : CTDS_RowResult(cmd, 0, false)
{

    m_NofCols = nof_params;
    m_CmdNum = DBCURCMD(cmd);

    m_ColFmt = new STDS_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 CTDS_ParamResult::ResultType() const
{
    return eDB_ParamResult;
}


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


CDB_Object* CTDS_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 CTDS_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;
    }

    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 = d_len - m_Offset;
    }

    memcpy(buffer, d_ptr + m_Offset, buffer_size);
    m_Offset += buffer_size;
    if (m_Offset >= d_len) {
        m_Offset = 0;
        ++m_CurrItem;
    }
    return buffer_size;
}