rpc.cpp

ncbi源码

        case eDB_TinyInt: {
            const CDB_TinyInt& val = dynamic_cast<const CDB_TinyInt&> (param);
            sprintf(val_buffer, "%d\n", (int) val.Value());
            break;
        }
        case eDB_BigInt: {
            const CDB_BigInt& val = dynamic_cast<const CDB_BigInt&> (param);
            sprintf(val_buffer, "%lld\n", val.Value());
            break;
        }
        case eDB_Char: {
            const CDB_Char& val = dynamic_cast<const CDB_Char&> (param);
            const char* c = val.Value(); // No more than 255 chars
            size_t i = 0;
            val_buffer[i++] = '\'';
            while (*c) {
                if (*c == '\'')
                    val_buffer[i++] = '\'';
                val_buffer[i++] = *c++;
            }
            val_buffer[i++] = '\'';
            val_buffer[i++] = '\n';
            val_buffer[i] = '\0';
            break;
        }
        case eDB_VarChar: {
            const CDB_VarChar& val = dynamic_cast<const CDB_VarChar&> (param);
            const char* c = val.Value();
            size_t i = 0;
            val_buffer[i++] = '\'';
            while (*c) {
                if (*c == '\'')
                    val_buffer[i++] = '\'';
                val_buffer[i++] = *c++;
            }
            val_buffer[i++] = '\'';
            val_buffer[i++] = '\n';
            val_buffer[i] = '\0';
            break;
        }
        case eDB_LongChar: {
            const CDB_LongChar& val = dynamic_cast<const CDB_LongChar&> (param);
            const char* c = val.Value();
            size_t i = 0;
            val_buffer[i++] = '\'';
            while (*c && (i < sizeof(val_buffer) - 4)) {
                if (*c == '\'')
                    val_buffer[i++] = '\'';
                val_buffer[i++] = *c++;
            }
			if(*c != '\0') return false;
            val_buffer[i++] = '\'';
            val_buffer[i++] = '\n';
            val_buffer[i] = '\0';
            break;
        }
        case eDB_Binary: {
            const CDB_Binary& val = dynamic_cast<const CDB_Binary&> (param);
            const unsigned char* c = (const unsigned char*) val.Value();
            size_t i = 0, size = val.Size();
            val_buffer[i++] = '0';
            val_buffer[i++] = 'x';
            for (size_t j = 0; j < size; j++) {
                val_buffer[i++] = s_hexnum[c[j] >> 4];
                val_buffer[i++] = s_hexnum[c[j] & 0x0F];
            }
            val_buffer[i++] = '\n';
            val_buffer[i++] = '\0';
            break;
        }
        case eDB_VarBinary: {
            const CDB_VarBinary& val =
                dynamic_cast<const CDB_VarBinary&> (param);
            const unsigned char* c = (const unsigned char*) val.Value();
            size_t i = 0, size = val.Size();
            val_buffer[i++] = '0';
            val_buffer[i++] = 'x';
            for (size_t j = 0; j < size; j++) {
                val_buffer[i++] = s_hexnum[c[j] >> 4];
                val_buffer[i++] = s_hexnum[c[j] & 0x0F];
            }
            val_buffer[i++] = '\n';
            val_buffer[i++] = '\0';
            break;
        }
        case eDB_LongBinary: {
            const CDB_LongBinary& val =
                dynamic_cast<const CDB_LongBinary&> (param);
            const unsigned char* c = (const unsigned char*) val.Value();
            size_t i = 0, size = val.DataSize();
			if(size*2 > sizeof(val_buffer) - 4) return false;
            val_buffer[i++] = '0';
            val_buffer[i++] = 'x';
            for (size_t j = 0; j < size; j++) {
                val_buffer[i++] = s_hexnum[c[j] >> 4];
                val_buffer[i++] = s_hexnum[c[j] & 0x0F];
            }
            val_buffer[i++] = '\n';
            val_buffer[i++] = '\0';
            break;
        }
        case eDB_Float: {
            const CDB_Float& val = dynamic_cast<const CDB_Float&> (param);
            sprintf(val_buffer, "%E\n", (double) val.Value());
            break;
        }
        case eDB_Double: {
            const CDB_Double& val = dynamic_cast<const CDB_Double&> (param);
            sprintf(val_buffer, "%E\n", val.Value());
            break;
        }
        case eDB_SmallDateTime: {
            const CDB_SmallDateTime& val =
                dynamic_cast<const CDB_SmallDateTime&> (param);
            sprintf(val_buffer, "'%s'\n",
		    val.Value().AsString("M/D/Y h:m").c_str());
            break;
        }
        case eDB_DateTime: {
            const CDB_DateTime& val =
                dynamic_cast<const CDB_DateTime&> (param);
            sprintf(val_buffer, "'%s:%.3d'\n",
		    val.Value().AsString("M/D/Y h:m:s").c_str(),
		    (int)(val.Value().NanoSecond()/1000000));
            break;
        }
        default:
            return false; // dummy for compiler
        }
        cmd += val_buffer;
    } else {
        cmd += "NULL";
    }

    return true;
}


bool CTDS_RPCCmd::x_AssignOutputParams()
{
    char buffer[64];
    for (unsigned int n = 0; n < m_Params.NofParams(); n++) {
        if ((m_Params.GetParamStatus(n) & CDB_Params::fOutput) == 0)
            continue;

        const string& name  =  m_Params.GetParamName(n);
        CDB_Object&   param = *m_Params.GetParam(n);
        const char*   type;
        string        cmd;

        if (name.length() > kTDSMaxNameLen)
            return false;

        switch (param.GetType()) {
        case eDB_Int:
            type = "int";
            break;
        case eDB_SmallInt:
            type = "smallint";
            break;
        case eDB_TinyInt:
            type = "tinyint";
            break;
        case eDB_BigInt:
            type = "numeric";
            break;
        case eDB_Char:
        case eDB_VarChar:
            type = "varchar(255)";
            break;
		case eDB_LongChar: {
		    CDB_LongChar& lc = dynamic_cast<CDB_LongChar&> (param);
		    sprintf(buffer, "varchar(%d)", lc.Size());
		    type= buffer;
			break;
		}
        case eDB_Binary:
        case eDB_VarBinary:
            type = "varbinary(255)";
            break;
		case eDB_LongBinary: {
		    CDB_LongBinary& lb = dynamic_cast<CDB_LongBinary&> (param);
		    sprintf(buffer, "varbinary(%d)", lb.Size());
		    type= buffer;
			break;
		}
        case eDB_Float:
            type = "real";
            break;
        case eDB_Double:
            type = "float";
            break;
        case eDB_SmallDateTime:
            type = "smalldatetime";
            break;
        case eDB_DateTime:
            type = "datetime";
            break;            
        default:
            return false;
        }

        cmd += "declare " + name + ' ' + type + '\n';
        if (!param.IsNULL()) {
            cmd += "select " + name + " = ";
            x_AddParamValue(cmd, param);
            cmd+= '\n';
        }

        if (dbcmd(m_Cmd, (char*) cmd.c_str()) != SUCCEED)
            return false;
    }
    return true;
}

bool CTDS_RPCCmd::x_AssignParams()
{
    for (unsigned int i = 0;  i < m_Params.NofParams();  i++) {
      if(!m_Params.GetParamStatus(i)) continue;
        CDB_Object& param = *m_Params.GetParam(i);
        bool is_output =
            (m_Params.GetParamStatus(i) & CDB_Params::fOutput) != 0;
        const string& name  = m_Params.GetParamName(i);
        string cmd= i? ", " : " ";

        if(!name.empty()) {
            cmd+= name + '=';
            if(is_output) {
                cmd+= name + " out";
            }
            else {
                x_AddParamValue(cmd, param);
            }
        }
        else {
            x_AddParamValue(cmd, param);
        }
        if (dbcmd(m_Cmd, (char*) cmd.c_str()) != SUCCEED)
            return false;
    }
    return true;
}


END_NCBI_SCOPE



/*
 * ===========================================================================
 * $Log: rpc.cpp,v $
 * Revision 1000.1  2004/06/01 19:20:58  gouriano
 * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
 *
 * Revision 1.12  2004/05/17 21:13:37  gorelenk
 * Added include of PCH ncbi_pch.hpp
 *
 * Revision 1.11  2003/08/13 18:04:05  soussov
 * fixes copy/paste bug for DateTime
 *
 * Revision 1.10  2003/06/05 16:01:40  soussov
 * adds code for DumpResults and for the dumped results processing
 *
 * Revision 1.9  2003/04/29 21:15:03  soussov
 * new datatypes CDB_LongChar and CDB_LongBinary added
 *
 * Revision 1.8  2002/11/20 20:36:09  soussov
 * fixed bug in parameters assignment
 *
 * Revision 1.7  2002/07/22 20:11:07  soussov
 * fixes the RowCount calculations
 *
 * Revision 1.6  2002/02/22 22:12:45  soussov
 * fixes bug with return params result
 *
 * Revision 1.5  2002/01/14 20:38:49  soussov
 * timeout support for tds added
 *
 * Revision 1.4  2001/12/18 19:29:08  soussov
 * adds conversion from nanosecs to milisecs for datetime args
 *
 * Revision 1.3  2001/12/18 16:42:44  soussov
 * fixes bug in datetime argument processing
 *
 * Revision 1.2  2001/12/13 23:40:53  soussov
 * changes double quotes to single quotes in SQL queries
 *
 * Revision 1.1  2001/10/25 00:39:22  vakatov
 * Initial revision
 *
 * Revision 1.2  2001/10/22 16:28:02  lavr
 * Default argument values removed
 * (mistakenly left while moving code from header files)
 *
 * Revision 1.1  2001/10/22 15:19:56  lavr
 * This is a major revamp (by Anton Lavrentiev, with help from Vladimir
 * Soussov and Denis Vakatov) of the DBAPI "driver" libs originally
 * written by Vladimir Soussov. The revamp follows the one of CTLib
 * driver, and it involved massive code shuffling and grooming, numerous
 * local API redesigns, adding comments and incorporating DBAPI to
 * the C++ Toolkit.
 *
 * ===========================================================================
 */