PDF de programación - Apunte de VC++ - Capítulo XIV

Apunte de Visual C++

 

Por: Demian Panello        [email protected]      
Capítulo XIV
Indice rápido del capítulo 14:

Qué es ADO.
Dificultades al usar ADO con C++.
Uso de ADO en una aplicación Dialog Based.
Importar librería de ADO.
Inicialización OLE.
Objeto _ConnectionPtr.
Método Open() de una conexión.
Modos de conexión.
catch (_com_error&).
Objeto _RecordsetPtr.
Metodo Open() de un recordset.
uuidof() y uuid.
Acceso a los contenidos de los campos.

 

ACTIVEX DATA OBJECT (ADO):  

En principio se podría decir que ADO es el sucesor de DAO y RDO. Es la nueva interfaz orientada a objetos para el acceso
a bases de datos. Como ADO encapsula la funcionalidad, (aunque no toda, por cierto), de DAO y RDO, se está convirtiendo
en un estándar en la programación de bases de datos. No obstante el mismo Microsoft aconseja el uso de DAO para
aplicaciones con bases de datos locales y recomienda a aquellos que usan RDO para conexiones con bases de datos de SQL
Server y de Oracle, que utilicen ADO.

ADO funciona a través de un servidor OLE DB, o sea, es una interfaz entre el servidor OLE DB de los datos, (ejemplo
Access, SQL Server, Oracle, etc.), y la aplicación.

ADO es un componente COM, (Component Object Model), que encapsula diversos objetos útiles al momento de manipular
grandes bases de datos. (Se recomienda la lectura de artículos de MSDN sobre la arquitectura COM.).

Dificultades al usar ADO con C++:
 
En Visual Basic o en Java es muy transparente el uso de ADO y hasta diría simple. En cambio en Visual C++ no existe una
clase que encapsule la funcionalidad de la librería de ADO, (por lo menos hasta donde yo sé, aún no he visto el Visual C++
.NET), lo que implica que la aplicación se debe "comunicar" directamente con el componente COM, (aunque puede usar la
clase que escribió Carlos Antollini cuyos fuentes y documentación puede encontrar en la sección de artículos).
Pero salvado ese obstáculo, aún se encuentran contratiempos al momento de manipular los datos que al igual que DAO son
devueltos por la funciones como valores de tipo VARIANT, (COleVariant o _variant_t). Además las cadenas que esperan
ciertas funciones deben de tipo _bstr_t.
 
ADO en una aplicación Dialog Based:
 
Bien, vamos a hacer una aplicación Dialog Based sencilla que nos permita ver como se usa ADO en Visual C++, (lo más
importante, la conexión a la base y creación de un recordset). Para esto vamos a usar una base de datos de Access(*) llamada
"base_empleados.mdb" que consta de una tabla "Empleados" con los campos "Apellido", "Nombre", "Salario" e "ID"..
Cree una aplicación Dialog Based de nombre "ado_emp", (en realidad puede poner el nombre que quiera) y diseñe el
diálogo más o menos como se ve en la siguiente imagen:
 

 
(*)la base puede ser creada con cualquier versión de Access ya que todas soportan ADO, no pasa lo mismo con DAO, que a apartir de Access 2000 no
es reconocido, (salvo que se guarde la base de datos como una versión anterior).
 
Especifique las siguientes propiedades y cree variables asociadas a los controles de acuerdo a lo indicado en la siguiente
tabla:
 

Control
CListBox

CEdit
CEdit
CEdit
CButton
CButton

ID

IDC_LISTAPE
IDC_NOMBRE
IDC_SALARIO

IDC_ID
IDC_INFO
IDC_SALIR

Propiedades
por defecto
Read Only
Read Only
Read Only
por defecto
por defecto

Variable asociada
CListBox m_lstApe
CString m_Nombre
CString m_Salario

CString m_ID

ninguna.
ninguna.

La idea es que cuando se cargue el diálogo, (OnInitDialog()), deberemos llenar la lista con los apellidos de la tabla, luego al
seleccionar un apellido de la lista mostrar los restantes campos en los cuadros de edición, (muy parecido a lo hecho en el
capítulo anterior con DAO).
 
Importando la librería de ADO:
 
Para trabajar con ADO hay que importar el archivo DLL correspondiente: msado15.dll con la directiva #import, (en
realidad existen tres formas de acceder a ADO, ver Knowledge Base de MSDN Q174565). Un buen lugar para ubicar esta
sentencia es en el archivo de cabecera del diálogo,ado_empDlg.h, allí luego de la línea #endif escriba:
 
#import "c:\Archivos de programa\Archivos comunes\system\ado\msado15.dll" no_namespace rename("EOF","adoEOF")
 
El path puede variar si su versión de Windows está en inglés, (ni que decir si esta en islandés o mandarín... en fin  : ).
En esta sentencia, además de indicar la importación de funciones de esa librería, estamos renombrando la propiedad EOF
por adoEOF ya que de lo contrario el compilador nos arrojaría errores.
 
Inicialización de OLE:
 
Es necesario inicializar OLE antes de establecer la conexión, (por que se trata de objetos COM), para eso usaremos la
función CoInitialise() pasándole como parámetro NULL. Escriba en el constructor del diálogo:
 
CoInitialize(NULL);
 
Conectando la base de datos:
 
Con ADO en lugar de abrir directamente la base de datos, se realiza primero una conexión, para eso agregue una variable al
diálogo, (en la clase del diálogo), de tipo _ConnectionPtr.

 
_ConnectionPtr pAdoCone;
 
Este es un objeto de tipo Connection y nos permitirá conectar nuestra base de datos con la aplicación.
Agregue al diálogo una función que retorne int de nombre Conectar y escriba allí:
 
int CAdo_empDlg::Conectar()
{
    //Objeto _bstr_t con la cadena para la conexión.
    _bstr_t bstrCone(L"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=base_empleados.mdb;");  (1)
    
    try
    {
       //Se crea una instancia para la conexión
        pAdoCone.CreateInstance (__uuidof(Connection));   (2)
        //se establece la conexión 
        pAdoCone­>Open (bstrCone ,_bstr_t ( "" ),    _bstr_t ( "" ), adModeUnknown );  (3)
        return 1;
    }
    catch (_com_error& ce) (4)
    {
        //si ocurrió una excepción, se llama a la función que mostrará el mensaje de error
        ver_com_error(ce);  (5)
        return 0;
    }
    
}
 
En (1) se declarar una cadena de tipo _bstr_t, la esperada por las funciones de ADO, cuyo fin es especificar información
como Provider que en nuestro ejemplo es Microsoft.Jet.OLEDB.4.0 ya que pretendemos usar una base de Access, (si fuera
una base de datos de SQL Server deberíamos escribir Provider=SQLOLEDB), y Data Source que hace mención a la fuente
de datos, nuestro archivo.
Luego, dentro de una estructura try­catch, (altamente recomendada), en (2) creamos una instancia de la conexión, (quienes
ya han usado ADO en Visual Basic o ASP esta línea equivale a Set pAdoCone = New Connection) y luego abrimos la
conexión en (3) con la función Open() cuyo formato es:
 

Open(BSTR ConnectionString, BSTR UserID, BSTR Password, long Options)

ConnectioString: La cadena para la conexión que armamos en (1).
UserID y Password: El ID del usuario y el password. En nuestro ejemplo ejemplo pasamos cadenas nulas siempre
convirtiendola al tipo esperado, _bstr_t.
Options: Una constante que especifica un modo de conexión:
 

Constante
adModeUnknown

Descripción
Predeterminada. Indica que los permisos no se han establecido aún o que no
se pueden determinar.
adModeRead
Indica que son permisos de sólo lectura.
adModeWrite
Indica que son permisos de sólo escritura.
adModeReadWrite
Indica que son permisos de lectura/escritura.
adModeShareDenyRead
Impide que otros abran una conexión con permisos de lectura.
adModeShareDenyWrite
Impide que otros abran una conexión con permisos de escritura.
adModeShareExclusive
Impide que otros abran una conexión.
adModeShareDenyNone
Impide que otros abran una conexión con cualquier tipo de permiso.
Ahora, bien, de no existir ningún error, (excepción), la función, (nuestra función Conectar), retorna 1. Si ocurre una
excepción el flujo del programa salta a catch (4) donde lo que se verifica es un error de COM, _com_error. Los datos de la

excepción se almacenarán en la variable ce de tipo _com_error, la cual manipulamos en una función que deberemos crear
llamada ver_com_error. (5)
Entonces agregue al diálogo la función ver_com_error(_com_error &e) con retorno void y escriba en ella:
 
void CAdo_empDlg::ver_com_error(_com_error &e)
{
    CString msgErr; //aquí se almacenará el mensaje de error
    _bstr_t bstrOrigen= e.Source();     //origen del error
    _bstr_t bstrDescri=e.Description();     //texto del error
    msgErr.Format ("ADO ­ COM Error\n\tCódigo = %08lx\n\tOrigen = %s\n\tDescripción = %s\n",
                                e.Error(),(LPCSTR)bstrOrigen, (LPCSTR)bstrDescri);
    
    AfxMessageBox( msgErr, MB_OK | MB_ICONERROR );
}
 
El objeto _com_error e trae información sobre la excepción ocurrida. La función Source() devuelve una cadena que indica el
origen del error y Description() una breve descripción del mismo.
Se formatea un objeto CString con estos datos más el código de error, función Error(), que luego se muestra con
AfxMessageBox().
 
Ahora, coloque en OnInitDialog() la llamada a Conectar() de la siguiente forma:
 
//Llamo a la función conectar
if (!Conectar())
  {
     AfxMessageBox("No se pudo realizar la conexión.");
    EndDialog(0);
  }
 
El siguiente paso es escribir una función que cargue la lista de apellidos con todos los apellidos de la tabla, (en este ejemplo
se supone que no se repite ninguno). Entonces agregue otra función al diálogo, que retorne int, llamada CargaLista() y
escriba:
 
int CAdo_empDlg::CargaLista()
{
    CString msgErr;
    try{
       //Se crea una instancia del recordset
        _RecordsetPtr Rs(__uuidof(Recordset));  (1)   (ver nota)
       //se le asocia la conexión
        Rs­>PutRefActiveConnection(pAdoCone);  (2)
        //armo una cadena de tipo _bstr_t con la sentencia SQL necesaria
        _bstr_t bstrSql(L"Select apellido from Empleados Order By apellido");  (3)
        //abro el recordset
        Rs­>Open(bstrSql,vtMissing,adOpenForwardOnly,adLockReadOnly,adCmdText);   (4)
        CString strApe;
    
        while(!Rs­>adoEOF)          //mientras no sea fin de archivo...
        {
        //obtengo el valor del campo apellido
        strApe = (char*) (_bstr_t) Rs­>Fields­>GetItem("Apellido")­>Value;  (5)
        //lo agre