Utilice ADO para operar la base de datos ACCESS en VC
ADO (ActiveX Data Object) es una nueva interfaz para el desarrollo de aplicaciones de bases de datos de Microsoft. Es una tecnología de acceso a bases de datos de alto nivel basada en OLE DB. Incluso si no comprende OLE DB y COM. Puede lidiar fácilmente con ADO porque es muy simple y fácil de usar, incluso más fácil de usar que la API ODBC, DAO y RDO con los que ha estado en contacto antes, sin perder flexibilidad. Este artículo presenta en detalle cómo utilizar ADO para desarrollar aplicaciones de bases de datos en el entorno de desarrollo Visual C y proporciona código de muestra. Para permitir que los lectores y amigos prueben el código proporcionado en este ejemplo, utilizamos la base de datos de Access. Puede encontrar este test.mdb directamente en el código de muestra que proporcionamos. El efecto después de compilar y ejecutar el programa se muestra en la Figura 1:
1. Método de implementación
Todo es difícil al principio. Lo más importante para los principiantes con cualquier tecnología nueva. es "empezar" ", comprenda sus puntos clave. ¡Echemos un vistazo al proceso básico del desarrollo de bases de datos ADO! Sus pasos básicos son los siguientes:
(1) Inicializar la biblioteca COM e introducir el archivo de definición de la biblioteca ADO
(2) Usar el objeto Conexión para conectarse a la base de datos
(3) Utilice la conexión establecida para ejecutar comandos SQL a través de los objetos Conexión y Comando, o utilice el objeto Recordset para obtener el conjunto de registros de resultados para consulta y procesamiento.
(4) Cierre la conexión y suelte el objeto después de su uso.
A continuación, presentaremos los pasos anteriores en detalle y proporcionaremos el código relevante.
1. Inicialización de la biblioteca COM
Podemos usar AfxOleInit() para inicializar la biblioteca COM. Este trabajo generalmente se realiza en la función sobrecargada de CWinApp::InitInstance(), por favor. Mire el siguiente código:
BOOL CADOTest1App::InitInstance()
{
AfxOleInit();
.... ..
}
2. Utilice la directiva #import para introducir la biblioteca de tipos ADO
Para introducir la biblioteca de tipos ADO, debe agregar la siguiente declaración al archivo stdafx.h del proyecto:
#import "c:program filescommon filessystemadomsado15.dll"
no_namespace rename("EOF", "adoEOF")
¿Qué significa esta afirmación? ¿Paño de lana? Su función final es similar a #include con el que ya estamos muy familiarizados. Al compilar, el sistema generará dos archivos de encabezado C msado15.tlh y ado15.tli para que definamos la biblioteca ADO.
Los lectores deben prestar atención a: msado15.dll en su entorno de desarrollo puede no estar en este directorio. Modifíquelo de acuerdo con la situación real. La siguiente advertencia puede aparecer durante la compilación. MSDN Se explica y sugiere que ignoremos esta advertencia: msado15.tlh(405): advertencia C4146: operador menos unario aplicado al tipo sin firmar, el resultado aún sin firmar.
3. Cree un objeto Connection y conéctese a la base de datos
Para agregar primero un puntero al objeto Connection _ConnectionPtr m_pConnection, el siguiente código demuestra cómo crear una instancia del objeto Connection. y cómo conectar la base de datos y la captura de excepciones:
BOOL CADOTest1Dlg::OnInitDialog()
{
CDialog::OnInitDialog();
HRESULT hr;
try
{
hr = m_pConnection.CreateInstance("ADODB.Connection"); ///Crear objeto de conexión
if(SUCCEEDED(hr))
{
hr = m_pConnection-Open("Provider=Microsoft.Jet.OLEDB.4.0;
Data Source= test.mdb", "", "", adModeUnknown); ///Conéctese a la base de datos
//El proveedor en la cadena de conexión en la oración anterior es para el entorno ACCESS2000, para ACCESS97,
//Debe cambiarse a: Provider=Microsoft.Jet.OLEDB.3.51;
}
}
catch(_com_error e)/// Detectando excepción
{
CString errormessage;
errormessage.Format("¡Error al conectarse a la base de datos! Mensaje de error: s ", e.ErrorMessage());
AfxMessageBox(errormessage);///Mostrar mensaje de error
}
En este código nos conectamos a la base de datos a través del método Open del objeto Connection, el siguiente es el prototipo de este método:
HRESULT Connection15::Open (_bstr_t ConnectionString, _bstr_t UserID, _bstr_t Contraseña, opciones largas);
El parámetro ConnectionString en la función anterior es la cadena de conexión; el parámetro UserID es el nombre de usuario; el parámetro Contraseña es la contraseña de inicio de sesión; el parámetro Opciones es la opción de conexión, que se utiliza para especificar el permiso de actualización del objeto Conexión; los datos Generalmente, las Opciones pueden ser las siguientes constantes:
adModeUnknown: predeterminado.
Los permisos actuales no están configurados
adModeRead: solo lectura
adModeWrite: solo escritura
adModeReadWrite: puede leer y escribir
adModeShareDenyRead: Bloquear que otros objetos Connection abran conexiones con permisos de lectura
adModeShareDenyWrite: evita que otros objetos Connection abran conexiones con permisos de escritura
adModeShareExclusive: evita que otros objetos Connection abran conexiones con permisos de lectura y escritura
adModeShareDenyNone: evita que otros objetos de conexión abran conexiones con cualquier permiso
Le brindamos algunos métodos de conexión comúnmente utilizados para su referencia:
(1) Base de datos ACCESS2000 a través de JET Conexión del motor de base de datos:
m_pConnection-Open("Provider=Microsoft.Jet.OLEDB.4.0;
Data Source=C:est.mdb","","",adModeUnknown );
(2) Conéctese a cualquier base de datos que admita ODBC a través de la fuente de datos DSN:
m_pConnection-Open("Data Source=adotest;UID=sa;PWD=;", " ","",adModeUnknown);
(3) Conéctese a la base de datos de SQL SERVER sin DSN:
m_pConnection-Open("driver={SQL Server}; Server=127.0 .0.1; DATABASE=vckbase;
UID=sa;PWD=139","","",adModeUnknown);
Donde Servidor es el nombre del servidor SQL y BASE DE DATOS es el nombre de la biblioteca.
El objeto Connection tiene muchos métodos además del método Open(). Primero presentamos las dos propiedades útiles ConnectionTimeOut y State en el objeto Connection. ConnectionTimeOut se utiliza para establecer el tiempo de espera de la conexión y debe llamarse antes de abrir, por ejemplo:
m_pConnection-ConnectionTimeout = 5 ///Establecer el tiempo de espera en 5 segundos
m_pConnection-Open( "Data Source=adotest;","","",adModeUnknown);
El atributo Estado indica el estado del objeto Conexión actual 0 significa cerrado, 1 significa abierto. lea esta propiedad para realizar el procesamiento correspondiente, por ejemplo:
if(m_pConnection-State)
m_pConnection-Close() ///Si la conexión ya está abierta, ciérrela<; /p>
4. Ejecute el comando SQL y obtenga el conjunto de registros de resultados
Para obtener el conjunto de registros de resultados, definimos un puntero al objeto Recordset: _RecordsetPtr m_pRecordset;
Y cree un objeto Recordset para ello. Ejemplo: m_pRecordset.CreateInstance("ADODB.Recordset"), la ejecución de comandos SQL puede tomar muchas formas, las explicaremos una por una a continuación.
(1) Utilice el método Execute del objeto Connection para ejecutar comandos SQL
El prototipo del método Execute() es el siguiente:
_RecordsetPtr Connection15 ::Ejecutar (_bstr_t CommandText, VARIANT * RecordsAffected, opciones largas)
Donde CommandText es la cadena de comando, generalmente un comando SQL. El parámetro RecordsAffected es el número de filas afectadas una vez completada la operación. El parámetro Opciones indica el tipo de contenido en CommandText. Las opciones pueden tomar uno de los siguientes valores: adCmdText indica que CommandText es un comando de texto; nombre de la tabla; adCmdProc indica que CommandText es un proceso de almacenamiento; adCmdUnknown indica que el contenido de CommandText es desconocido.
Después de ejecutar la función Execute(), devuelve un puntero al conjunto de registros. A continuación damos el código específico y la explicación:
_variant_t RecordsAffected;
///Ejecutar SQL. comando: CREATE TABLE crea la tabla usuarios. Usuarios contiene cuatro campos: ID de número entero, nombre de usuario de cadena, número entero antiguo, tipo de fecha de cumpleaños
m_pConnection-Execute("Usuarios de CREATE TABLE(ID INTEGER, nombre de usuario
TEXTO, INTEGER antiguo, cumpleaños DATETIME)", RecordsAffected, adCmdText);
///Agregar registros a la tabla
m_pConnection-Execute("INSERT INTO users(ID , nombre de usuario, edad, fecha de nacimiento)
VALUES (1, 'Washington', 25, '1970/1/1')", RecordsAffected, adCmdText);
///Convertir todos los registros Agregue uno al valor del campo anterior
m_pConnection-Execute("UPDATE users SET old = old 1", RecordsAffected, adCmdText);
///Ejecute el SQL comando de estadísticas para obtener la barra de registros Número de conjuntos de registros
m_pRecordset = m_pConnection-Execute("SELECT COUNT(*) FROM
usuarios", RecordsAffected, adCmdText);
_variant_t vIndex = (long)0;
_variant_t vCount = m_pRecordset-GetCollect(vIndex); ///Obtiene el valor del primer campo y lo coloca en la variable vCount
CString message;
message.Format("***Hay d registros", vCount.lVal) ;
AfxMessageBox(message); /// Muestra el número actual de registros (2) Utilice el objeto Command para ejecutar comandos SQL
_CommandPtr m_pCommand;
m_pCommand.CreateInstance("ADODB.Command");
p>
_variant_t vNULL;
vNULL.vt = VT_ERROR;
vNULL.scode = DISP_E_PARAMNOTFOUND; /// Definido como sin parámetros
m_pCommand- ActiveConnection = m_pConnection; /// Una frase muy crítica, asígnale la conexión establecida
m_pCommand-CommandText = "SELECT * FROM usuarios"; ///Cadena de comando
m_pRecordset = m_pCommand-Execute(vNULL, vNULL, adCmdText);
//Ejecuta el comando para obtener el conjunto de registros
>
En este código, solo usamos el objeto Command para ejecutar la instrucción de consulta SELECT. El objeto Command realmente puede reflejar su función al llamar a procedimientos almacenados. Entraremos en detalles la próxima vez.
(3) Utilice directamente el objeto Recordset para consultar y obtener el conjunto de registros, por ejemplo:
m_pRecordset-Open("SELECT * FROM users", _variant_t((IDispatch *) m_pConnection, true) ,
adOpenStatic, adLockOptimistic, adCmdText);
El prototipo del método Open() es el siguiente:
HRESULT Recordset15:: Open ( const _variant_t
Fuente, const _variant_t
ActiveConnection, enum CursorTypeEnum CursorType, enum LockTypeEnum LockType, long Opciones)
El parámetro Fuente en la función anterior es el cadena de consulta de datos; se ha establecido el parámetro ActiveConnection Conexión (necesitamos usar el puntero del objeto Conexión para construir un objeto _variant_t); tipo de cursor del parámetro CursorType, que puede ser uno de los siguientes valores, consulte esta estructura de enumeración:
enum CursorTypeEnum
{
adOpenUnspecified = -1, ///Sin especificación especial
adOpenForwardOnly = 0, ///Avanzar el estático cursor. Este cursor solo puede explorar el registro establecido hacia adelante, como usar MoveNext para desplazarse hacia adelante. Este método puede aumentar la velocidad de navegación. Sin embargo, BookMark, RecordCount, AbsolutePosition y AbsolutePage no se pueden usar
adOpenKeyset = 1, /// El conjunto de registros que usa este cursor no puede ver las operaciones de adición y eliminación de otros usuarios, sino para actualizar el Grabado original las acciones son visibles para usted.
adOpenDynamic = 2, /// Cursor dinámico. Todas las operaciones de la base de datos se reflejan inmediatamente en cada conjunto de registros de usuario.
adOpenStatic = 3 ///Cursor estático. Genera una copia de seguridad estática para su conjunto de registros, pero las operaciones de adición, eliminación y actualización de otros usuarios son invisibles para su conjunto de registros.
};
El parámetro LockType representa el tipo de bloqueo de la base de datos. Puede ser uno de los siguientes valores. Consulte la siguiente estructura de enumeración:
. enum LockTypeEnum
p>{
adLockUnspecified = -1, ///Sin especificar
adLockReadOnly = 1, ///Conjunto de registros de solo lectura
adLockPessimistic = 2. Método de bloqueo pesimista. Los datos bloquean todas las demás acciones durante la actualización. Este es el mecanismo de bloqueo más seguro
adLockOptimistic = 3, método de bloqueo optimista. El registro solo se bloquea cuando llama al método Actualizar. Antes de esto, aún se pueden realizar actualizaciones de datos, inserciones, eliminaciones y otras acciones
adLockBatchOptimistic = 4, actualización por lotes optimista. Los registros no se bloquean durante la edición y los cambios, inserciones y eliminaciones se realizan en modo por lotes.
};
Para conocer el significado del parámetro Opciones, consulte la introducción al método Execute() del objeto Conexión en este artículo.
5. Recorrer y actualizar el conjunto de registros
Según la tabla de usuarios que acabamos de crear ejecutando el comando SQL, contiene cuatro campos: ID, nombre de usuario, antigüedad, fecha de nacimiento
p> p>
La siguiente implementación de código: abra el conjunto de registros, recorra todos los registros, elimine el primer registro, agregue tres registros, mueva el cursor al segundo registro, cambie sus datos de edad y guárdelo en la base de datos.
_variant_t vUsername, vBirthday, vID, vOld;
_RecordsetPtr m_pRecordset
m_pRecordset.CreateInstance("ADODB.Recordset"); >m_pRecordset-Open("SELECT * FROM usuarios", _variant_t((IDispatch*)m_pConnection, true),
adOpenStatic, adLockOptimistic, adCmdText
while(!m_pRecordset-adoEOF); )
///¿Por qué es adoEOF en lugar de EOF? ¿Recuerdas la oración rename("EOF", "adoEOF")?
{
vID = m_pRecordset-GetCollect(_variant_t((long)0));///Obtiene el valor de la columna 1, contando desde 0, también puedes dar directamente el nombre de la columna;
vUsername = m_pRecordset -GetCollect("username"); ///Obtener el valor del campo de nombre de usuario
vOld = m_pRecordset-GetCollect("old");
vBirthday = m_pRecordset-GetCollect(" cumpleaños ");
///Envíe los registros en el conjunto de registros en la ventana SALIDA en modo DEPURACIÓN
if(vID.vt != VT_NULL
vUsername.vt != VT_NULL
vOld.vt != VT_NULL
vBirthday.vt != VT_NULL)
TRACE("id: d, nombre: s , edad: d, cumpleaños: s ", vID.lVal, (LPCTSTR) (_bstr_t) vUsername, vOld.lVal, (LPCTSTR) (_bstr_t) vBirthday);
m_pRecordset-MoveNext(); // /Mover al siguiente registro
}
m_pRecordset-MoveFirst(); ///Mover al primer registro
m_pRecordset-Delete(adAffectCurrent); /Eliminar registro actual
///Agregar tres nuevos registros y asignar valores
for(int i=0; i3; i)
{
m_pRecordset-AddNew(); ///Agregar nuevo registro
m_pRecordset-PutCollect("ID",_variant_t((long)(i 10)));
m_pRecordset-PutCollect ("nombre de usuario",_variant_t("Yelchin"));
m_pRecordset-PutCollect("old",_variant_t((long)71));
m_pRecordset-PutCollect ("cumpleaños",_variant_t("1930-3-15"));
}
m_pR
ecordset-Move(1,_variant_t((long)adBookmarkFirst));///Mover un registro hacia abajo desde el primer registro, es decir, pasar al segundo registro
m_pRecordset-PutCollect(_variant_t( "old "), _variant_t((long)45)); ///Modificar su antigüedad
m_pRecordset-Update(); ///Guardar en la biblioteca
6. Cerrar conjuntos de registros y conexiones
Los conjuntos de registros o conexiones se pueden cerrar usando el método Close():
m_pRecordset-Close() ///Cerrar el conjunto de registros
; m_pConnection-Close(); /// Cerrar la conexión
En este punto, creo que los lectores ya están familiarizados con el proceso general de operar la base de datos con ADO. Tal vez ya esté seguro, tal vez todavía lo esté. un poco confundido, ¡no importa! Le sugiero que intente escribir algunos ejemplos para que pueda familiarizarse más con ADO. Finalmente, escribí un pequeño ejemplo para usted. La función del ejemplo es leer todos los registros y colocarlos en un control de lista. Al mismo tiempo, puede agregar, eliminar y modificar registros.
2. Pasos de programación
1. Inicie Visual C 6.0, genere un programa de aplicación basado en diálogo y nombre el programa ADOTest1.
2. control de lista de registros y controles de edición y botones para agregar y eliminar registros en la interfaz del cuadro de diálogo. Configure específicamente la parte de recursos del cuadro de diálogo en el código.
3. una función de respuesta de mensaje al botón registrado en la base de datos;
4. Agréguelo al código del programa, compílelo y ejecútelo.