bcp.cpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: bcp.cpp,v $
 * PRODUCTION Revision 1000.1  2004/06/01 19:19:32  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.8
 * PRODUCTION
 * ===========================================================================
 */

/* $Id: bcp.cpp,v 1000.1 2004/06/01 19:19:32 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:  CTLib bcp-in command
 *
 */


#include <ncbi_pch.hpp>
#include <dbapi/driver/ctlib/interfaces.hpp>
#include <dbapi/driver/util/numeric_convert.hpp>
#include <string.h>


BEGIN_NCBI_SCOPE


/////////////////////////////////////////////////////////////////////////////
//
//  CTL_BCPInCmd::
//

CTL_BCPInCmd::CTL_BCPInCmd(CTL_Connection* con, CS_BLKDESC* cmd,
                           const string& table_name, unsigned int nof_columns)
    : m_Query(table_name), m_Params(nof_columns)
{
    m_Connect    = con;
    m_Cmd        = cmd;
    m_WasSent    = false;
    m_HasFailed  = false;
    m_Bind       = new SBcpBind[nof_columns];
}


bool CTL_BCPInCmd::Bind(unsigned int column_num, CDB_Object* pVal)
{
    return m_Params.BindParam(column_num, kEmptyStr, pVal);
}


bool CTL_BCPInCmd::x_AssignParams()
{
    CS_DATAFMT param_fmt;
    memset(&param_fmt, 0, sizeof(param_fmt));
    param_fmt.format = CS_FMT_UNUSED;
    param_fmt.count  = 1;

    for (unsigned int i = 0;  i < m_Params.NofParams();  i++) {

        if (m_Params.GetParamStatus(i) == 0)
            continue;

        CDB_Object& param = *m_Params.GetParam(i);
        m_Bind[i].indicator = param.IsNULL() ? -1 : 0;
        m_Bind[i].datalen   = (m_Bind[i].indicator == 0) ? CS_UNUSED : 0;

        CS_RETCODE ret_code;

        switch ( param.GetType() ) {
        case eDB_Int: {
            CDB_Int& par = dynamic_cast<CDB_Int&> (param);
            param_fmt.datatype = CS_INT_TYPE;
            CS_INT value = (CS_INT) par.Value();
            memcpy(m_Bind[i].buffer, &value, sizeof(CS_INT));
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) m_Bind[i].buffer,
                                &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_SmallInt: {
            CDB_SmallInt& par = dynamic_cast<CDB_SmallInt&> (param);
            param_fmt.datatype = CS_SMALLINT_TYPE;
            CS_SMALLINT value = (CS_SMALLINT) par.Value();
            memcpy(m_Bind[i].buffer, &value, sizeof(CS_SMALLINT));
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) m_Bind[i].buffer,
                                &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_TinyInt: {
            CDB_TinyInt& par = dynamic_cast<CDB_TinyInt&> (param);
            param_fmt.datatype = CS_TINYINT_TYPE;
            CS_TINYINT value = (CS_TINYINT) par.Value();
            memcpy(m_Bind[i].buffer, &value, sizeof(CS_TINYINT));
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) m_Bind[i].buffer,
                                &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_BigInt: {
            CDB_BigInt& par = dynamic_cast<CDB_BigInt&> (param);
            param_fmt.datatype = CS_NUMERIC_TYPE;
            CS_NUMERIC value;
            Int8 val8 = par.Value();
            memset(&value, 0, sizeof(value));
            value.precision= 18;
            if (longlong_to_numeric(val8, 18, value.array) == 0)
                return false;
            param_fmt.scale     = 0;
            param_fmt.precision = 18;
            memcpy(m_Bind[i].buffer, &value, sizeof(CS_NUMERIC));
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) m_Bind[i].buffer,
                                &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_Char: {
            CDB_Char& par = dynamic_cast<CDB_Char&> (param);
            param_fmt.datatype  = CS_CHAR_TYPE;
            param_fmt.maxlength = (CS_INT) par.Size() + 1;
            m_Bind[i].datalen   =
                (m_Bind[i].indicator == -1) ? 0 : (CS_INT) par.Size();
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) par.Value(), &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_VarChar: {
            CDB_VarChar& par = dynamic_cast<CDB_VarChar&> (param);
            param_fmt.datatype  = CS_CHAR_TYPE;
            param_fmt.maxlength = (CS_INT) par.Size() + 1;
            m_Bind[i].datalen   = (CS_INT) par.Size();
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) par.Value(), &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_Binary: {
            CDB_Binary& par = dynamic_cast<CDB_Binary&> (param);
            param_fmt.datatype  = CS_BINARY_TYPE;
            param_fmt.maxlength = (CS_INT) par.Size() + 1;
            m_Bind[i].datalen   =
                (m_Bind[i].indicator == -1) ? 0 : (CS_INT) par.Size();
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) par.Value(), &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_VarBinary: {
            CDB_VarBinary& par = dynamic_cast<CDB_VarBinary&> (param);
            param_fmt.datatype  = CS_BINARY_TYPE;
            param_fmt.maxlength = (CS_INT) par.Size() + 1;
            m_Bind[i].datalen   = (CS_INT) par.Size();
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) par.Value(), &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_Float: {
            CDB_Float& par = dynamic_cast<CDB_Float&> (param);
            param_fmt.datatype = CS_REAL_TYPE;
            CS_REAL value = (CS_REAL) par.Value();
            memcpy(m_Bind[i].buffer, &value, sizeof(CS_REAL));
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) m_Bind[i].buffer,
                                &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_Double: {
            CDB_Double& par = dynamic_cast<CDB_Double&> (param);
            param_fmt.datatype = CS_FLOAT_TYPE;
            CS_FLOAT value = (CS_FLOAT) par.Value();
            memcpy(m_Bind[i].buffer, &value, sizeof(CS_FLOAT));
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) m_Bind[i].buffer,
                                &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_SmallDateTime: {
            CDB_SmallDateTime& par = dynamic_cast<CDB_SmallDateTime&> (param);
            param_fmt.datatype = CS_DATETIME4_TYPE;
            CS_DATETIME4 dt;
            dt.days    = par.GetDays();
            dt.minutes = par.GetMinutes();
            memcpy(m_Bind[i].buffer, &dt, sizeof(CS_DATETIME4));
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) m_Bind[i].buffer,
                                &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_DateTime: {
            CDB_DateTime& par = dynamic_cast<CDB_DateTime&> (param);
            param_fmt.datatype = CS_DATETIME_TYPE;
            CS_DATETIME dt;
            dt.dtdays = par.GetDays();
            dt.dttime = par.Get300Secs();
            memcpy(m_Bind[i].buffer, &dt, sizeof(CS_DATETIME));
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,
                                (CS_VOID*) m_Bind[i].buffer,
                                &m_Bind[i].datalen,
                                &m_Bind[i].indicator);
            break;
        }
        case eDB_Text: {
            CDB_Text& par = dynamic_cast<CDB_Text&> (param);
            param_fmt.datatype  = CS_TEXT_TYPE;
            param_fmt.maxlength = (CS_INT) par.Size();
            m_Bind[i].datalen   = (CS_INT) par.Size();
            ret_code = blk_bind(m_Cmd, i + 1, &param_fmt,