rpc.cpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: rpc.cpp,v $
 * PRODUCTION Revision 1000.1  2004/06/01 19:20:58  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
 * PRODUCTION
 * ===========================================================================
 */

/* $Id: rpc.cpp,v 1000.1 2004/06/01 19:20:58 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 RPC command
 *
 */
 
#include <ncbi_pch.hpp>
#include <dbapi/driver/ftds/interfaces.hpp>
#include <dbapi/driver/util/numeric_convert.hpp>


BEGIN_NCBI_SCOPE


/////////////////////////////////////////////////////////////////////////////
//
//  CTDS_RPCCmd::
//

CTDS_RPCCmd::CTDS_RPCCmd(CTDS_Connection* con, DBPROCESS* cmd,
                         const string& proc_name, unsigned int nof_params) :
    m_Connect(con), m_Cmd(cmd), m_Query(proc_name), m_Params(nof_params),
    m_WasSent(false), m_HasFailed(false), m_Recompile(false), m_Res(0),
    m_RowCount(-1), m_Status(0)
{
    return;
}


bool CTDS_RPCCmd::BindParam(const string& param_name,
                            CDB_Object* param_ptr, bool out_param)
{
    return m_Params.BindParam(CDB_Params::kNoParamNumber, param_name,
                              param_ptr, out_param);
}


bool CTDS_RPCCmd::SetParam(const string& param_name,
                           CDB_Object* param_ptr, bool out_param)
{
    return m_Params.SetParam(CDB_Params::kNoParamNumber, param_name,
                             param_ptr, out_param);
}


bool CTDS_RPCCmd::Send()
{
    if (m_WasSent)
        Cancel();

    m_HasFailed = false;

    if (!x_AssignOutputParams()) {
        dbfreebuf(m_Cmd);
        m_HasFailed = true;
        throw CDB_ClientEx(eDB_Error, 221001, "CTDS_RPCCmd::Send",
                           "cannot assign the output params");
    }

    string cmd= "execute " + m_Query;
    if (dbcmd(m_Cmd, (char*)(cmd.c_str())) != SUCCEED) {
        dbfreebuf(m_Cmd);
        m_HasFailed = true;
        throw CDB_ClientEx(eDB_Fatal, 221002, "CTDS_RPCCmd::Send",
                           "dbcmd failed");
    }

    if (!x_AssignParams()) {
        m_HasFailed = true;
        throw CDB_ClientEx(eDB_Error, 221003, "CTDS_RPCCmd::Send",
                           "can not assign the params");
    }

    m_Connect->TDS_SetTimeout();

    if (dbsqlsend(m_Cmd) != SUCCEED) {
        m_HasFailed = true;
        throw CDB_ClientEx(eDB_Error, 221005, "CTDS_RPCCmd::Send",
                           "dbsqlsend failed");
    }

    m_WasSent = true;
    m_Status = 0;
    return true;
}


bool CTDS_RPCCmd::WasSent() const
{
    return m_WasSent;
}


bool CTDS_RPCCmd::Cancel()
{
    if (m_WasSent) {
        if (m_Res) {
            delete m_Res;
            m_Res = 0;
        }
        m_WasSent = false;
        return dbcancel(m_Cmd) == SUCCEED;
    }
    // m_Query.erase();
    return true;
}


bool CTDS_RPCCmd::WasCanceled() const
{
    return !m_WasSent;
}


CDB_Result* CTDS_RPCCmd::Result()
{
    if (m_Res) {
        if(m_RowCount < 0) {
            m_RowCount = DBCOUNT(m_Cmd);
        }
        delete m_Res;
        m_Res = 0;
    }

    if (!m_WasSent) {
        throw CDB_ClientEx(eDB_Error, 221010, "CTDS_RPCCmd::Result",
                           "you have to send a command first");
    }

    if (m_Status == 0) {
        m_Status = 1;
        if (dbsqlok(m_Cmd) != SUCCEED) {
            m_WasSent = false;
            m_HasFailed = true;
            throw CDB_ClientEx(eDB_Error, 221011, "CTDS_RPCCmd::Result",
                               "dbsqlok failed");
        }
    }

    if ((m_Status & 0x10) != 0) { // we do have a compute result
        m_Res = new CTDS_ComputeResult(m_Cmd, &m_Status);
        m_RowCount = 1;
        return Create_Result(*m_Res);
    }

    while ((m_Status & 0x1) != 0) {
        switch (dbresults(m_Cmd)) {
        case SUCCEED:
            if (DBCMDROW(m_Cmd) == SUCCEED) { // we may get rows in this result
                m_Res = new CTDS_RowResult(m_Cmd, &m_Status);
                m_RowCount = -1;
                return Create_Result(*m_Res);
            } else {
                m_RowCount = DBCOUNT(m_Cmd);
                continue;
            }
        case NO_MORE_RESULTS:
            m_Status = 2;
            break;
        default:
            m_HasFailed = true;
            throw CDB_ClientEx(eDB_Warning, 221016, "CTDS_RPCCmd::Result",
                               "error encountered in command execution");
        }
        break;
    }

    // we've done with the row results at this point
    // let's look at return parameters and ret status
    if (m_Status == 2) {
        m_Status = 4;
        int n = dbnumrets(m_Cmd);
        if (n > 0) {
            m_Res = new CTDS_ParamResult(m_Cmd, n);
            m_RowCount = 1;
            return Create_Result(*m_Res);
        }
    }

    if (m_Status == 4) {
        m_Status = 6;
        if (dbhasretstat(m_Cmd)) {
            m_Res = new CTDS_StatusResult(m_Cmd);
            m_RowCount = 1;
            return Create_Result(*m_Res);
        }
    }

    m_WasSent = false;
    return 0;
}


bool CTDS_RPCCmd::HasMoreResults() const
{
    return m_WasSent;
}

void CTDS_RPCCmd::DumpResults()
{
    CDB_Result* dbres;
    while(m_WasSent) {
        dbres= Result();
        if(dbres) {
            if(m_Connect->m_ResProc) {
                m_Connect->m_ResProc->ProcessResult(*dbres);
            }
            else {
                while(dbres->Fetch());
            }
            delete dbres;
        }
    }
}

bool CTDS_RPCCmd::HasFailed() const
{
    return m_HasFailed;
}


int CTDS_RPCCmd::RowCount() const
{
    return (m_RowCount < 0)? DBCOUNT(m_Cmd) : m_RowCount;
}


void CTDS_RPCCmd::SetRecompile(bool recompile)
{
    m_Recompile = recompile;
}


void CTDS_RPCCmd::Release()
{
    m_BR = 0;
    if (m_WasSent) {
        Cancel();
        m_WasSent = false;
    }
    m_Connect->DropCmd(*this);
    delete this;
}


CTDS_RPCCmd::~CTDS_RPCCmd()
{
    if (m_BR)
        *m_BR = 0;
    if (m_WasSent)
        Cancel();
}


bool CTDS_RPCCmd::x_AddParamValue(string& cmd, const CDB_Object& param)
{
    static const char s_hexnum[] = "0123456789ABCDEF";
    char val_buffer[16*1024];

    if (!param.IsNULL()) {
        switch (param.GetType()) {
        case eDB_Int: {
            const CDB_Int& val = dynamic_cast<const CDB_Int&> (param);
            sprintf(val_buffer, "%d\n", val.Value());
            break;
        }
        case eDB_SmallInt: {
            const CDB_SmallInt& val = dynamic_cast<const CDB_SmallInt&>(param);
            sprintf(val_buffer, "%d\n", (int) val.Value());
            break;
        }