result.cpp

ncbi源码

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

/* $Id: result.cpp,v 1000.2 2004/06/01 19:20:21 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:  DBLib Results
 *
 */
#include <ncbi_pch.hpp>

#ifndef USE_MS_DBLIB
#  include <dbapi/driver/dblib/interfaces.hpp>
#  include <dbapi/driver/dblib/interfaces_p.hpp>
#else
#  include <dbapi/driver/msdblib/interfaces.hpp>
#  include <dbapi/driver/msdblib/interfaces_p.hpp>
#endif
#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, const 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
                        (DBDATETIME4_days(v),             DBDATETIME4_mins(v));
                    break;
                case eDB_DateTime:
                    ((CDB_DateTime*)      item_buff)->Assign
                        ((int) DBDATETIME4_days(v), (int) DBDATETIME4_mins(v)*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(DBDATETIME4_days(v), DBDATETIME4_mins(v)) : 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 = (DBFLT8*) d_ptr;
        if (item_buff) {
            if (v)
                *((CDB_Double*) item_buff) = (double) *v;
            else
                item_buff->AssignNULL();
            return item_buff;
        }

        return v ? 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 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 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;
    }

#ifdef MS_DBLIB_IN_USE
    DBCOL dbcol; dbcol.SizeOfStruct = sizeof(DBCOL);
    RETCODE res = dbcolinfo(cmd, CI_REGULAR, n, 0, &dbcol );
    return dbcol.Scale == 0 && dbcol.Precision < 20 ? eDB_BigInt : eDB_Numeric;
#else
    DBTYPEINFO* t = dbcoltypeinfo(cmd, n);
    return t->scale == 0 && t->precision < 20 ? eDB_BigInt : eDB_Numeric;
#endif

}


/////////////////////////////////////////////////////////////////////////////
//
//  CDBL_RowResult::
//


CDBL_RowResult::CDBL_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 SDBL_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);
        const char* s = dbcolname(m_Cmd, n + 1);
        m_ColFmt[n].col_name = s ? s : "";
    }
}


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


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


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


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


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


bool CDBL_RowResult::Fetch()
{
    m_CurrItem = -1;
    if (!m_EOR) {
        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, "CDBL_RowResult::Fetch",
                               "error in fetching row");
        case BUF_FULL:
            throw CDB_ClientEx(eDB_Error, 230006, "CDBL_RowResult::Fetch",
                               "buffer is full");
        default:
            *m_ResStatus|= 0x10;
            m_EOR = true;
            break;
        }
    }
    return false;
}


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


// Aux. for CDBL_RowResult::GetItem()
static CDB_Object* s_GetItem(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 = 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: {
        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*) DBNUMERIC_val(v));
                } else if (b_type == eDB_BigInt) {
                    *((CDB_BigInt*) item_buff) = numeric_to_longlong
                        ((unsigned int) v->precision, DBNUMERIC_val(v));
                } 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,
                                               DBNUMERIC_val(v))) : 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*) DBNUMERIC_val(v));
                    } 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,