result.cpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: result.cpp,v $
 * PRODUCTION Revision 1000.2  2004/06/01 19:20:55  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.14
 * PRODUCTION
 * ===========================================================================
 */

/* $Id: result.cpp,v 1000.2 2004/06/01 19:20:55 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:   TDS Results
 *
 */

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


BEGIN_NCBI_SCOPE


// Aux. for s_*GetItem()
static CDB_Object* s_GenericGetItem(EDB_Type data_type, CDB_Object* item_buff,
                                    EDB_Type b_type, BYTE* d_ptr, DBINT d_len)
{
    switch (data_type) {
    case eDB_VarBinary: {
        if (item_buff) {
            switch (b_type) {
            case eDB_VarBinary:
                ((CDB_VarBinary*) item_buff)->SetValue((const void*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_Binary:
                ((CDB_Binary*)    item_buff)->SetValue((const void*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_VarChar:
                ((CDB_VarChar*)   item_buff)->SetValue((const char*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_Char:
                ((CDB_Char*)      item_buff)->SetValue((const char*) d_ptr,
                                                       (size_t) d_len);
                break;
			case eDB_LongBinary:
                ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_LongChar:
                ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
                                                       (size_t) d_len);
                break;

            default:
                throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
                                   "wrong type of CDB_Object");
            }
            return item_buff;
        }

        return d_ptr ? new CDB_VarBinary((const void*) d_ptr, (size_t) d_len)
            : new CDB_VarBinary();
    }

    case eDB_Bit: {
        DBBIT* v = (DBBIT*) d_ptr;
        if (item_buff) {
            if (v) {
                switch (b_type) {
                case eDB_Bit:
                    *((CDB_Bit*)      item_buff) = (int) *v;
                    break;
                case eDB_TinyInt:
                    *((CDB_TinyInt*)  item_buff) = *v ? 1 : 0;
                    break;
                case eDB_SmallInt:
                    *((CDB_SmallInt*) item_buff) = *v ? 1 : 0;
                    break;
                case eDB_Int:
                    *((CDB_Int*)      item_buff) = *v ? 1 : 0;
                    break;
                default:
                    throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
                                       "wrong type of CDB_Object");
                }
            } else
                item_buff->AssignNULL();
            return item_buff;
        }

        return v ? new CDB_Bit((int) *v) : new CDB_Bit;
    }

    case eDB_VarChar: {
        if (item_buff) {
            switch (b_type) {
            case eDB_VarChar:
                ((CDB_VarChar*)   item_buff)->SetValue((const char*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_Char:
                ((CDB_Char*)      item_buff)->SetValue((const char*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_LongChar:
                ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_VarBinary:
                ((CDB_VarBinary*) item_buff)->SetValue((const void*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_Binary:
                ((CDB_Binary*)    item_buff)->SetValue((const void*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_LongBinary:
                ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
                                                       (size_t) d_len);
                break;
            default:
                throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
                                   "wrong type of CDB_Object");
            }
            return item_buff;
        }

        return d_ptr ? new CDB_VarChar((const char*) d_ptr, (size_t) d_len)
            : new CDB_VarChar();
    }

    case eDB_DateTime: {
        DBDATETIME* v = (DBDATETIME*) d_ptr;
        if (item_buff) {
            if (b_type != eDB_DateTime) {
                throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
                                   "wrong type of CDB_Object");
            }
            if (v)
                ((CDB_DateTime*) item_buff)->Assign(v->dtdays, v->dttime);
            else
                item_buff->AssignNULL();
            return item_buff;
        }

        return v ? new CDB_DateTime(v->dtdays, v->dttime) : new CDB_DateTime;
    }

    case eDB_SmallDateTime: {
        DBDATETIME4* v = (DBDATETIME4*)d_ptr;
        if (item_buff) {
            if (v) {
                switch (b_type) {
                case eDB_SmallDateTime:
                    ((CDB_SmallDateTime*) item_buff)->Assign
                        (v->days,             v->minutes);
                    break;
                case eDB_DateTime:
                    ((CDB_DateTime*)      item_buff)->Assign
                        ((int) v->days, (int) v->minutes*60*300);
                    break;
                default:
                    throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
                                       "wrong type of CDB_Object");
                }
            } else
                item_buff->AssignNULL();
            return item_buff;
        }

        return v ?
            new CDB_SmallDateTime(v->days, v->minutes) : new CDB_SmallDateTime;
    }

    case eDB_TinyInt: {
        DBTINYINT* v = (DBTINYINT*) d_ptr;
        if (item_buff) {
            if (v) {
                switch (b_type) {
                case eDB_TinyInt:
                    *((CDB_TinyInt*)  item_buff) = (Uint1) *v;
                    break;
                case eDB_SmallInt:
                    *((CDB_SmallInt*) item_buff) = (Int2)  *v;
                    break;
                case eDB_Int:
                    *((CDB_Int*)      item_buff) = (Int4)  *v;
                    break;
                default:
                    throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
                                       "wrong type of CDB_Object");
                }
            } else
                item_buff->AssignNULL();
            return item_buff;
        }

        return v ? new CDB_TinyInt((Uint1) *v) : new CDB_TinyInt;
    }

    case eDB_SmallInt: {
        DBSMALLINT* v = (DBSMALLINT*) d_ptr;
        if (item_buff) {
            if (v) {
                switch (b_type) {
                case eDB_SmallInt:
                    *((CDB_SmallInt*) item_buff) = (Int2) *v;
                    break;
                case eDB_Int:
                    *((CDB_Int*)      item_buff) = (Int4) *v;
                    break;
                default:
                    throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
                                       "wrong type of CDB_Object");
                }
            } else
                item_buff->AssignNULL();
            return item_buff;
        }

        return v ? new CDB_SmallInt((Int2) *v) : new CDB_SmallInt;
    }

    case eDB_Int: {
        DBINT* v = (DBINT*) d_ptr;
        if (item_buff) {
            if (v) {
                if (b_type == eDB_Int)
                    *((CDB_Int*) item_buff) = (Int4) *v;
                else {
                    throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
                                       "wrong type of CDB_Object");
                }
            } else
                item_buff->AssignNULL();
            return item_buff;
        }

        return v ? new CDB_Int((Int4) *v) : new CDB_Int;
    }

    case eDB_Double: {
        if (item_buff  &&  b_type != eDB_Double) {
            throw CDB_ClientEx(eDB_Error, 130020, "s_GenericGetItem",
                               "wrong type of CDB_Object");
        }
        DBFLT8 v;
        if(d_ptr) memcpy((void*)&v, d_ptr, sizeof(DBFLT8));
        if (item_buff) {
            if (d_ptr)
                *((CDB_Double*) item_buff) = (double) v;
            else
                item_buff->AssignNULL();
            return item_buff;
        }

        return d_ptr ? new CDB_Double((double)v) : new CDB_Double;
    }

    case eDB_Float: {
        if (item_buff  &&  b_type != eDB_Float) {
            throw CDB_ClientEx(eDB_Error, 130020, "s_GenericGetItem",
                               "wrong type of CDB_Object");
        }
        DBREAL* v = (DBREAL*) d_ptr;
        if (item_buff) {
            if (v)
                *((CDB_Float*) item_buff) = (float) *v;
            else
                item_buff->AssignNULL();
            return item_buff;
        }

        return v ? new CDB_Float((float) *v) : new CDB_Float;
    }

    case eDB_LongBinary: {
        if (item_buff) {
            switch (b_type) {
			case eDB_LongBinary:
                ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_LongChar:
                ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
                                                       (size_t) d_len);
                break;

            default:
                throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
                                   "wrong type of CDB_Object");
            }
            return item_buff;
        }

        return d_ptr ? new CDB_LongBinary((size_t) d_len, (const void*) d_ptr, 
                                          (size_t) d_len)
            : new CDB_LongBinary();
    }

    case eDB_LongChar: {
        if (item_buff) {
            switch (b_type) {
            case eDB_LongChar:
                ((CDB_LongChar*)  item_buff)->SetValue((const char*) d_ptr,
                                                       (size_t) d_len);
                break;
            case eDB_LongBinary:
                ((CDB_LongBinary*)item_buff)->SetValue((const void*) d_ptr,
                                                       (size_t) d_len);
                break;
            default:
                throw CDB_ClientEx(eDB_Error, 230020, "s_GenericGetItem",
                                   "wrong type of CDB_Object");
            }
            return item_buff;
        }

        return d_ptr ? new CDB_LongChar((size_t) d_len, (const char*) d_ptr)
            : new CDB_LongChar();
    }

    default:
        return 0;
    }
}


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

static EDB_Type s_GetDataType(DBPROCESS* cmd, int n)
{
    switch (dbcoltype(cmd, n)) {
    case SYBBINARY:    return (dbcollen(cmd, n) > 255) ? eDB_LongBinary : 
                                                         eDB_VarBinary;
    case SYBBITN:                                                         
    case SYBBIT:       return eDB_Bit;
    case SYBCHAR:      return (dbcollen(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 SYBINT8:      return eDB_BigInt;
    case SYBDECIMAL:
    case SYBNUMERIC:   break;
    case SYBFLT8:      return eDB_Double;
    case SYBREAL:      return eDB_Float;
    case SYBTEXT:      return eDB_Text;
    case SYBIMAGE:     return eDB_Image;
    default:           return eDB_UnsupportedType;
    }
    DBTYPEINFO* t = dbcoltypeinfo(cmd, n);
    return (t->scale == 0  &&  t->precision < 20) ? eDB_BigInt : eDB_Numeric;
}


/////////////////////////////////////////////////////////////////////////////
//
//  CTDS_RowResult::
//


CTDS_RowResult::CTDS_RowResult(DBPROCESS* cmd,
                               unsigned int* res_status, bool need_init)
    : m_Cmd(cmd), m_CurrItem(-1), m_EOR(false),
      m_ResStatus(res_status), m_Offset(0)
{
    if (!need_init)
        return;

    m_NofCols = dbnumcols(cmd);
    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 = dbcollen(m_Cmd, n + 1);
        m_ColFmt[n].data_type = s_GetDataType(m_Cmd, n + 1);
        char* s = dbcolname(m_Cmd, n + 1);
        m_ColFmt[n].col_name = s ? s : "";
    }
}


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


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


const char* CTDS_RowResult::ItemName(unsigned int item_num) const
{
    return item_num < m_NofCols ? m_ColFmt[item_num].col_name.c_str() : 0;
}


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


EDB_Type CTDS_RowResult::ItemDataType(unsigned int item_num) const
{
    return item_num < m_NofCols
        ? m_ColFmt[item_num].data_type : eDB_UnsupportedType;
}


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

    switch ( dbnextrow(m_Cmd) ) {
    case REG_ROW:
        m_CurrItem = 0;
        m_Offset = 0;
        return true;
    case NO_MORE_ROWS:
        m_EOR = true;
        break;
    case FAIL:
        throw CDB_ClientEx(eDB_Error, 230003, "CTDS_RowResult::Fetch",
                           "error in fetching row");
    case BUF_FULL:
        throw CDB_ClientEx(eDB_Error, 230006, "CTDS_RowResult::Fetch",
                           "buffer is full");
    default:
        *m_ResStatus |= 0x10;
        m_EOR = true;
        break;
    }
    return false;
}


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


// Aux. for CTDS_RowResult::GetItem()
static CDB_Object* s_GetItem(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 = dbdata  (cmd, item_no);
    DBINT d_len = dbdatlen(cmd, item_no);

    CDB_Object* val = s_GenericGetItem(fmt->data_type, item_buff,
                                       b_type, d_ptr, d_len);
    if (val)
        return val;

    switch (fmt->data_type) {
    case eDB_BigInt: {
	    if(dbcoltype(cmd, item_no) == SYBINT8) {
		  Int8* v= (Int8*) d_ptr;
		  if(item_buff) {
			if(v) {
		      if(b_type == eDB_BigInt) {
				*((CDB_BigInt*) item_buff)= *v;
			  } 
			  else {
				throw CDB_ClientEx(eDB_Error, 230020, "s_GetItem",
                                       "wrong type of CDB_Object");
			  }
			}
			else 
                item_buff->AssignNULL();
            return item_buff;
		  }