C/Visual C - CRecordset

 
Vista:

CRecordset

Publicado por fernando.gomez (61 intervenciones) el 11/03/2003 00:37:55
Buenas,

alguien sabe como ejecuto un stored procedure desde C++?

Bueno, aqui he lo que he intentado.

Creo un CRecordset, pasando al constructor mi CDatabase abierta. Despues, declaro una variable CString para emplear el metodo ::Format(). En ese format, escribo mi query.

Segun yo, solo meto a esa variable este query:

declare @outvar nchar(20)
exec cim_getnext_seqno N'MSD0', N'NMLBLFIL', @outvar output
select @outvar as SEQNO

, en donde cim_getnext_seqno es el nombre de mi stored procedure, los primeros dos parametros son de entrada y tengo una variable de salida. Esto lo hago con un ADODB.Recordset desde VB y ya, pero aqui me esta regresando una asercion cuando abro mi recordset, justo en:

obRecordset.Open(AFX_DB_USE_DEFAULT_TYPE, csSql.GetBuffer(0));

Segun la documentacion de MSDN de octubre del 2000, tengo que pasar en mi query, para un SP que no tiene variables, algo asi:

csSql.Format(_T("{call cim_getnext_seqno}"));

pero no se que hacer cuando necesito entrar variables y, peor aun, cuando necesito pasar una direccion de una variable (es decir, pasar una variable SQL por referencia).

El MSDN no menciona mucho en estos casos, dice que para tu output es algo con ?, pero no especifica nada mas.

Por ultimo, menciono que me conecto por ODBC, y que mi tipo de base de datos es MS SQL Server 2000.

Un saludo, espero me puedan ayudar. Gracias de antemano,

Fernando A. Gomez F.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Ejecución de stored procedures en C++ usando ODBC

Publicado por Alejandro (1153 intervenciones) el 09/05/2025 00:17:27
Para ejecutar un stored procedure desde C++ utilizando ODBC, debes seguir un enfoque diferente al que usas con `CRecordset`. En lugar de usar `CRecordset`, puedes utilizar las funciones de ODBC directamente para preparar y ejecutar el stored procedure. A continuación, te muestro cómo hacerlo.

Pasos para ejecutar un stored procedure con ODBC



1. Conectar a la base de datos: Asegúrate de que tienes una conexión ODBC abierta a tu base de datos SQL Server.

2. Preparar el stored procedure: Utiliza la función `SQLPrepare` para preparar la llamada al stored procedure.

3. Definir los parámetros: Usa `SQLBindParameter` para vincular los parámetros de entrada y salida.

4. Ejecutar el stored procedure: Utiliza `SQLExecute` para ejecutar el stored procedure.

5. Recuperar el resultado: Si tienes un parámetro de salida, puedes recuperarlo después de la ejecución.

Ejemplo de código



Aquí tienes un ejemplo básico que ilustra cómo ejecutar un stored procedure con parámetros de entrada y salida:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <windows.h>
#include <sql.h>
#include <sqlext.h>
#include <iostream>
 
void executeStoredProcedure(SQLHDBC hdbc) {
    SQLHSTMT hstmt;
    SQLRETURN ret;
 
    // Crear un statement
    SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
 
    // Preparar el stored procedure
    const char* sql = "{call cim_getnext_seqno(?, ?, ?)}";
    ret = SQLPrepare(hstmt, (SQLCHAR*)sql, SQL_NTS);
 
    // Comprobar si la preparación fue exitosa
    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
        std::cerr << "Error al preparar el stored procedure." << std::endl;
        return;
    }
 
    // Definir los parámetros de entrada
    const char* param1 = "MSD0";
    const char* param2 = "NMLBLFIL";
    SQLLEN param1Len = SQL_NTS;
    SQLLEN param2Len = SQL_NTS;
 
    // Vincular los parámetros de entrada
    SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 0, 0, (SQLPOINTER)param1, 0, &param1Len);
    SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 0, 0, (SQLPOINTER)param2, 0, &param2Len);
 
    // Definir el parámetro de salida
    SQLCHAR outvar[20];
    SQLLEN outvarLen = 0; // Longitud del parámetro de salida
 
    // Vincular el parámetro de salida
    SQLBindParameter(hstmt, 3, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_CHAR, sizeof(outvar), 0, outvar, sizeof(outvar), &outvarLen);
 
    // Ejecutar el stored procedure
    ret = SQLExecute(hstmt);
 
    // Comprobar si la ejecución fue exitosa
    if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) {
        std::cout << "El valor de salida es: " << outvar << std::endl;
    } else {
        std::cerr << "Error al ejecutar el stored procedure." << std::endl;
    }
 
    // Limpiar
    SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
}
 
int main() {
    SQLHENV henv;
    SQLHDBC hdbc;
 
    // Inicializar ODBC
    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
    SQLSetEnvAttr(henv, SQL_ATTR_ENVIRONMENT, (SQLPOINTER)SQL_OV_ODBC3, 0);
    SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
 
    // Conectar a la base de datos (ajusta la cadena de conexión según sea necesario)
    SQLCHAR connStr[] = "DSN=YourDataSource;UID=YourUsername;PWD=YourPassword;";
    SQLDriverConnect(hdbc, NULL, connStr, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_COMPLETE);
 
    // Ejecutar el stored procedure
    executeStoredProcedure(hdbc);
 
    // Desconectar y liberar recursos
    SQLDisconnect(hdbc);
    SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
    SQLFreeHandle(SQL_HANDLE_ENV, henv);
 
    return 0;
}

Explicación del código:



- Conexión ODBC: Se establece una conexión a la base de datos utilizando `SQLDriverConnect`.

- Preparación del stored procedure: Se prepara la llamada al stored procedure utilizando `SQLPrepare`.

- Vinculación de parámetros: Se utilizan `SQLBindParameter` para vincular los parámetros de entrada y salida.

- Ejecución: Se ejecuta el stored procedure con `SQLExecute`.

- Recuperación de resultados: Se imprime el valor del parámetro de salida.

Consideraciones:



- Manejo de errores: Asegúrate de manejar adecuadamente los errores en cada paso, especialmente al preparar y ejecutar el stored procedure.

- Configuración de ODBC: Asegúrate de que tu DSN (Data Source Name) esté configurado correctamente en el sistema.

- Tipos de datos: Asegúrate de que los tipos de datos que estás utilizando en `SQLBindParameter` coincidan con los tipos de datos en tu stored procedure.

Este enfoque te permitirá ejecutar un stored procedure en C++ utilizando ODBC. ¡Buena suerte, Fernando!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar