BASES DE DATOS CON MICROSOFT ACCESS

Y D.A.O.
(Data Access Objects)

TUTORIAL 1: Por Malcom Marchen

Parte I

THE13THBANDIDO.FREEHOST.COM

Existen varias formas de acceder a una base de datos, en este tutorial, se manejaran solamente bases de
datos de Access (mdb). Una de esas formas es mediante la tecnología DAO, por Data Access Objects ;
los obejtos DAO, funcionan como un intermediario entre nuestra apliación Visual Basic y el motor de
bases de datos JET, con el que Access trabaja, dicho de alguna manera por default. Por lo anterior,
recomiendo de sobremanera acceder por DAO a una base de datos tipo Access.

Las ventajas de DAO con Access, además de las mencionadas, es que trabaja directamente con el
motor JET, el cual puede trabajar sobre diferentes bases de datos; la posibilidad de combinar tablas de
diferentes origenes, es decir, obtener datos de una base de dBase, Oracle etc. sin necesidad de hacer
que el usuario de nuestra aplicación tenga la necesidad de instalar dichos programas y/o sistemas, sino
que bastará con incluir en nuestro programa de instalación las dll’s correspondientes al motor JET.
Además el motor JET soporta todas las versiones de Access.

Aunque como todo, tiene sus desventajas, y una de ellas es la cantidad de recursos del sistema que
necesita JET, además de ser muy grande. DAO solo podía acceder a bases de datos ODBC a travéz del
motor JET, sin embargo, esto solo fue hasta la versión 3.5.

Personalmente, me inclino por la opción de Access/DAO para las bases de datos “pequeñas”.

No es objetivo de este tutorial el manejo de Access, pero se aclararán algunos procedimientos que
serán necesarios para comprender bien este texto, como puede ser crear la base con puro código, o por
visdata (Visual Basic 6 vers. incluye esta aplicación en cualquiera de sus versiones empresarial o
profesional), tocaré lo menos posible Access, para enfocarnos directamente en la creación de la
aplicación; entiendo que tal vez tu ya tienes una base de datos, aunque incluyo los archivos necesarios
para que no queden dudas respecto a DAO/Access.

Si tienes problemas con DAO/Access, si eres principiante o simplemente necesitas ejemplos, créeme,
esta es la página correcta. La forma en que se presentará el texto es con el formato siguiente:

PROPIEDADES VALOR CONTROL CODIGO

Por último, después del código pongo la explicavión de cada parte del mismo, aunque en el proyecto
anexado pongo los comentarios de cada función, aquí no , por razones de tamaño del docuemnto.

La ruta de acceso a las bases de datos en TODO el tutorial, la manejo como A:\, puedes usar un floppy
igual que yo o modificar la ruta en todos los ejemplos; creo que para esto no hay mayor problema.
 - Creación de la base de datos con objetos DAO
El código de este tema esta en: Creación una base con objetos DAO.vbp

Comenzamos por crear una base de datos Access mediante código basic, siempre es bueno saber
crear la base por código y por el programa Access, si ya tienes el archivo MDB, puedes saltarte
este tema, de no ser que te interese y este consiente que ninguna iformación está de mas.

1.Abre un nuevo proyecto MVB6 (EXE Estandar)

2.Clickea en la barra de menús la opcion PROYECTO (Project, yo tengo la versión en inglés, pero
me referiré a ellos con el nombre en español para aquellos que no saben ni una pizca)
3.Clickea en la opción REFERENCIAS
4.Marca la casilla con el item de Microsoft DAO 3.5 Object Library o superior (Yo manejo 3.51 pero
no hay problema por esto en este tutorial) y después , clickeas en ACEPTAR.
5. Agrega a tu FORM1 dos COMMAND BUTTON, a los que asignaremos las siguientes propiedades:

______________ Commandbutton1
Nombre Crearbase_btn
Caption Nueva base

______________ Commandbutton2
Nombre Creartabla_btn
Caption Nueva tabla
_____________________________

6. Declaramos las siguientes variables a nivel Formulario

Option Explicit
Dim Base_de_datos As DAO.Database
Dim Tabla As DAO.TableDef
Dim Campo As DAO.Field

7. Agrega el siguiente código al evento Click del botón Crearbase_btn o examina el código del
proyecto anexado.

Set Base_de_datos = CreateDatabase("a:\Socios.mdb", dbLangGeneral)

8. Agrega el siguiente código al evento Click del botón Creartabla_btn o examina el código del
proyecto anexado.

Set Base_de_datos = OpenDatabase("A:\Empresa") ( Puede omitirse esta línea, checa la ACLARACION que
está al final del tema, evitarás confusiones)

Set Tabla = Base_de_datos.CreateTableDef("Empleados")

Set Campo = Tabla.CreateField("Clave", dbInteger)
Tabla.Fields.Append Campo

Set Campo = Tabla.CreateField("Puesto", dbText, 20)

Tabla.Fields.Append Campo

Set Campo = Tabla.CreateField("Nombre", dbText, 50)

Tabla.Fields.Append Campo

Set Campo = Tabla.CreateField("Email", dbText, 50)

Tabla.Fields.Append Campo

Base_de_datos.TableDefs.Append Tabla

8. Antes de explicar el código, examina el siguiente cuadro:

Ingenieria de DAO

DBENGINE --- WORKSPACES

Workspace ----------- DATABASES
Workspace Database ------TABLEDEFS
Database TableDef
Database TableDef ------------- FIELDS
TableDef Field
TableDef Field
TableDef Field
TableDef
TableDef ------------- INDEXES
TableDef Field
Field
Field

Este mismo cuadro, lo tienes en la ayuda de VB6. Fíjate como el objeto DBENGINE tiene una
colección de objetos WORKSPACES (Espacios de trabajo)

Dentro de WORKSPACES, existe una colección de objetos WORKSPACE (Sin la “s” del final), a su
vez, cada uno de ellos, cuenta con una conjutno de objetos DATABASES .

Los conjuntos de DATABASES cuentan con una colección de objetos DATABASE, y así
sucesivamente, cada DATABASE cuenta con una colección TABLEDEFS, cada TABLEDEFS cuenta
con una colección de objetos TABLEDEF; cada TABLEDEF posee una colección de objetos FIELDS
e INDEXES, etc.

Mas claramente , sin usar tecniscismos, y en “español”. Comencemos de otra manera, Tenemos un
grupo de campos como son clave, puesto, nombre y email , cada uno de ellos representa un Field, el
conjunto de cada Field, representa FIELDS (FIELDS es como deecir, conjunto de campos o conjunto
de Field ), un conjunto de FIELDS, son parte de una tabla , que en nuestro ejemplo era EMPLEADOS
aunque podriamos haber creado también otra tabla que se llamara por ejemplo DATOSPERSONALES
y otra mas llamada CARACTERISTICASFISICAS; bueno, hasta aquí todo claro (espero!), pues cada
una de esas tablas son llamadas Tabledef , al grupo de todas las mencionadas tabla (Tabledef), se les
agrupa en un solo conjunto de tablas llamado TABLEDEFS. Nuestra base de datos representa un solo
objeto Database , este objeto contiene la colección de TABLEDEFS que acabo de describir.

Aquí manejamos una sola base de datos o DATABASE, aunque podriamos o no usar mas bases de
datos, que a su vez, formarian un conjunto llamado DATABASES, un conjunto de una sola o varias
bases de datos, forman DATABASES.

A este conjunto se le toma como un Espacio de trabajo o Workspace, que es parte de un grupo llamado
WORKSPACES y así sucesivamente. Espero realmente haberme explicado bien.

Las propiedades de INDEX las describiré mas adelante.

Regresando a lo del código, examinenos paso a paso:
Las variables las declaramos a nivel formulario para poder usar los mismos objetos en todo el código.

Option Explicit

Dim Base_de_datos As DAO.Database

Localiza en el cuadro el objeto DATABASE

Dim Tabla As DAO.TableDef

Localiza en el cuadro el objeto TABLEDEF

Dim Campo As DAO.Field

Ahora localiza en el cuadro el objeto FIELD, ahora puedes ver otro ejemplo del cuento anterior, fíjate
como cada uno pertenece a otro.

Como se supone que no teniamos una base de datos, creamos una; establecemos al objeto
Base_de_datos, que es un DATABASE los parametros necesarios, como lo es el nombre físico,
dbLangGeneral es una parámetro pre-establecido que tiene que ver con el orden de clasificación
(Europeo, occidental: inglés. alemán etc. No te confundas por esto, ahora no es importante).
Hacemos uso de la función CreateDatabase para crear la base, al crearla, es donde toma los parámetros
que establecimos. De modo que si no existiese la base, al clickear en el Command, se ceraria un
archivo en la unidad a:\ con el nombre Socios y su extensión mdb, que corresponde a access.

Set Base_de_datos = CreateDatabase("a:\Socios.mdb", dbLangGeneral)

Sugiero correr el programa una vez y presionar solo el primer botón (Nuevabase_btn).

Clickea en la barra de menús en la opción COMPLEMENTOS, y luego, en ADMINISTRADOR DE

DATOS para iniciar la aplicación VisData, incluida en VB.

Clickea en la barra del menú de VisData en la opción Archivo/Abrir base de datos ... /Microsoft
Access... , ahí veras que la base de datos se ha creado satisfactoriamente, aunque si la abres, verás que
no contiene ninguna tabla , mucho menos, algun registro.

Cierra la base de datos o completamente VisData, ahora que hemos visto el “esqueleto de la base”
EMPRESA.
Una vez creada con la función CreateDatabase, procedemos a abrirla con la función OpenDatabase,
especificandole a la máquina donde debe buscarla, si se omite este parámetro, buscará en el directorio
de la aplicación.

Set Base_de_datos = OpenDatabase("A:\Empresa")

Ya tenemos la base abierta; a Tabla, que es un TableDef, le damos la instrucción para crear la tabla
Tabla, valga la expresión., a partir de Base_de_datos, que es un Database.

Set Tabla = Base_de_datos.CreateTableDef("Empleados")

La tabla está vacía y se ha creado simplemente la estructura, aquí, es donde empezamos a agregarlo los
campos o columnas.
Definimos el campo o columna Campo; hacemos uso de la funcón CreateField a partir del Tabledef
Tabla, ¿te vas dando cuenta como va siguiendo la estructura del campo enterio?. Aquí, los parámetros
para CreateField son el nombre del campo o columna, aquí lo llamamos Clave, y lo asignamos de tipo
Integer, los tipos de datos supongo que ya los conoces.

Set Campo = Tabla.CreateField("Clave", dbInteger)

Ya hemos creado la estructura de uno de los campos, así que lo que sigue es simplemente sumarlo a la
colección de Fields, esto lo hacemos con la instrucción de Append. Osea, a pertir de Tabla (Tabledef)
definimos un elemento de la colección de campos (Fields) y lo agregamos (Append Campo)

Tabla.Fields.Append Campo

Así para cada uno de los campos

Set Campo = Tabla.CreateField("Puesto", dbText, 20)

Tabla.Fields.Append Campo
Set Campo = Tabla.CreateField("Nombre", dbText, 50)
Tabla.Fields.Append Campo
Set Campo = Tabla.CreateField("Email", dbText, 50)
Tabla.Fields.Append Campo

Como ya hemos definido toda la estructura de la tabla “Tabla”, pasamos a lo siguiente, a partir de
Base_de_datos, que es un Database, tomamos la colección de TablesDefs para agregarle la tabla
“Tabla” con la función Append.

Base_de_datos.TableDefs.Append Tabla

Puede resultar “un poco“ confuso al principio, y dirás que tal vez yo te lo complico mas, pero ten en
cuenta que para estos ejemplos, es necesario repetir varias veces los mismo términos.
Sugiero abrir nuevamente Visdata y localiza la base EMPRESA y abrela; en la ventana con la
descripción, clickea en la división de PROPIEDADES, ahí debe de estar ya la estructura de nuestra
base de datos, con la tabla EMPLEADOS; si clickeas también en la tabla, observarás los campos o
columnas, aunque aún, sin ningún registro.
Te recomiendo que al repartir tu aplicación, entreges la estructura de la base de datos ya hecha si no
necesitas cambiar su estructura, para que el usuario, solo se dedique a cargar los registros.
ACLARACION: Se vuelve a abrir la base con Opendatabase para evitar un error en caso de que hayas seguido las sugerencias.
-
 - Crear una aplicación de acceso a datos con objetos DAO
El código de este tema esta en: Acceso a datos con objetos DAO.vbp

Una aplicación con acceso a datos, debe incluir, al menos, la posibilidad de explorar , modificar,
agregar y eliminar registros. Supongo que debes saber esto, los registros y campos, es equivalente
a decir filas y columnas; los objetos utilizados en DAO para obtener un grupo el total de registros
en una base de datos, se hace mediante un recordset, o claro, solo los registros que cumplan cierta
condición, lo aclaro para no confundirnos con los Resultset, de ADO. Manejaremos de aquí en
adelante como registros y campos, y recordset’s, ya que estamos trabajando con el motor Jet.

Utilizaremos la base de datos EMPRESA1.mdb anexa

1.Abre un nuevo proyecto MVB6 (EXE Estandar)

2.Clickea en la barra de menús la opcion PROYECTO
3.Clickea en la opción REFERENCIAS
4.Marca la casilla con el item de Microsoft DAO 3.5 Object Library o superior y después , clickeas en
ACEPTAR.
5. Agrega a tu FORM1 cuatro COMMAND BUTTON, cuatro TEXTBOX y cuatro ETIQUETAS, a los
que asignaremos las siguientes propiedades:

______________ Commandbutton1
Nombre Primer_btn
Caption <<
______________ Commandbutton2
Nombre Anterior_btn
Caption <
______________ Commandbutton3
Nombre Siguiente_btn
Caption >>
______________ Commandbutton4
Nombre Ultimo_btn
Caption >
______________ TextBox 1
Nombre Clave_txt
Caption
______________ TextBox 2
Nombre Puesto_txt
Caption
______________ TextBox 3
Nombre Nombre_txt
Caption
______________ TextBox 4
Nombre Email_txt
Caption
______________ Label11
Caption Clave de empleado:
______________ Label12
Caption Puesto
______________ Label13
Caption Nombre
______________ Label14
Caption Email
_____________________________
6. Declaramos los objetos DAO a utilizar a nivel Formulario

Option Explicit
Dim Base_de_datos As DAO.Database
Dim Conjunto_de_resultados As DAO.Recordset

7. Agrega el siguiente código al evento Load del Formulario o examina el del proyecto.

Set Base_de_datos = OpenDatabase("a:\Empresa1.mdb")

Set Conjunto_de_resultados = Base_de_datos.OpenRecordset _
("Select * from Empleados", dbOpenDynaset, dbOptimistic)
Cargar_cajas_de_texto

8. Agrega el siguiente código al evento Click del botón Primer_btn o examina el del proyecto.

Conjunto_de_resultados.MoveFirst
Cargar_cajas_de_texto

9. Agrega el siguiente código al evento Click del botón Anterior_btn o examina el del proyecto.

Conjunto_de_resultados.MovePrevious
If Conjunto_de_resultados.BOF = False Then
Cargar_cajas_de_texto
Else
Conjunto_de_resultados.MoveFirst
Cargar_cajas_de_texto
End If

10. Agrega el siguiente código al evento Click del botón Siguiente_btn o examina el del proyecto.

Conjunto_de_resultados.MoveNext
If Conjunto_de_resultados.EOF = False Then
Cargar_cajas_de_texto
Else
Conjunto_de_resultados.MoveLast
Cargar_cajas_de_texto
End If

11. Agrega el siguiente código al evento Click del botón Ultimo_btn o examina el del proyecto.
Conjunto_de_resultados.MoveLast
Cargar_cajas_de_texto

12. Define una función llamada Cargar_cajas_de_texto y agrega el siguiente código.

Clave_txt.Text = Conjunto_de_resultados!Clave
Puesto_txt.Text = Conjunto_de_resultados!Puesto
Nombre_txt.Text = Conjunto_de_resultados!Nombre
Email_txt.Text = Conjunto_de_resultados!Email
Examinemos el código paso a paso.

Option Explicit
Dim Base_de_datos As DAO.Database
Dim Conjunto_de_resultados As DAO.Recordset

Las variables las declaramos a nivel formulario para poder usar los mismos objetos en todo el código.
Base_de_datos hace referencia a un objetos Databse de DAO, hasta aquí es una variable objeto qu eno
tiene ningún valor. Conjunto_de_resultados es un objeto Recordset de DAO, tampoco tiene ningún
valor hasta aquí.

Set Base_de_datos = OpenDatabase("a:\Empresa1.mdb")

Cuando un usuario corra nuestra aplicación (Evento Load), se carga la base de datos Empresa1.mdb,
que contiene 3 registros.

Aquí es donde establecemos a nuestro Recorset los resultados que estamos esperando, examina el
código. Set define el objeto con un valor, el valor es, de Base_de_datos (Empresa1.mdb) , abrir el
recordset , esto es con la función OpenRecordset. Dentro de los parentesis tenemos una sentencia SQL,
que es transparente para cualquier base de datos.

Nos indica lo siguiente:

(“Muestrame todos los registros de la tabla empleados” , el tipo de cursor , las opciones)
( Select )( * )( from ) (Empleados) , (dbOpenDynaset) , (dbOptimistic)

Set Conjunto_de_resultados = Base_de_datos.OpenRecordset _

("Select * from Empleados", dbOpenDynaset, dbOptimistic)

Y llamamos a la función:
Cargar_cajas_de_texto

Al definir el código de esta función encontramos lo siguiente.

Clave_txt.Text = Conjunto_de_resultados!Clave
Puesto_txt.Text = Conjunto_de_resultados!Puesto
Nombre_txt.Text = Conjunto_de_resultados!Nombre
Email_txt.Text = Conjunto_de_resultados!Email

A cada texto de los textbox, les agrega el valor de los resultados, es decir, el texto de “Clave”
(Clave_txt.text = ) es de los resultados de nuestra sentencia SQL, del primer registro encontrado, el
campo clave (!Clave) y así con todos los textbox. El símbolo ! le indica a VB que nos estamos
refiriendo al campo Clave, Puesto , Nombre y Email.

Si quieres mas información acerca del tipo de cursores, puedes encontrar las definiciones en la ayuda
de VB6.

Cuando el usuario de click en el botón Primer_btn, el código marca lo siguiente:

Conjunto_de_resultados.MoveFirst
Cargar_cajas_de_texto

Del conjunto de resultados, posicionamos el recordset en el primer registro con la función MoveFirst,
y cargamos los datos de dicho registro.
Cuando clickeen en el botoón Anterior_bnt, posicionamos, hacemos que el recordset se posicione en el
registro anterior del que estemos actualmente. Si no existe un registro antes, se genererá un error, al
intentar cargar los datos de ese registro, es por eso que utilizamos el siguiente código.

Conjunto_de_resultados.MovePrevious Nos movemos al registro anterior

If Conjunto_de_resultados.BOF = False Then

Cargar_cajas_de_texto
Else
Conjunto_de_resultados.MoveFirst
Cargar_cajas_de_texto
End If

Si del conjunto de registros encontrados nos posicionamos en el primero, lógivcamente no habrá uno
mas atrás, por eso utilizamos la función BOF, o “Principio de resultados” por decirlo de alguna
manera. BOF puede tomar el valor True o False, si es True, estamos al inicio de los resultados, si el
False, aún existen registros atrás. Por eso, si BOF es False, se pueden cargar datos del registro, puesto
que existe. Si no (Else) cargará los datos del primer registro. Lo mismo para el evento Click del botón
Siguiente_btn:

Conjunto_de_resultados.MoveNext Nos movemos al registro siguiente

If Conjunto_de_resultados.EOF = False Then

Cargar_cajas_de_texto
Else
Conjunto_de_resultados.MoveLast
Cargar_cajas_de_texto
End If

Pero aquí, al movernos al siguiente registro con la función MoveNext, lo que necesitamos saber es si
existe algún registro que podamos cargar, este dato nos lo dará la función EOF, “Fin de resultados” o
End of file, como lo desees; si estamos al final de los resultados y nos movemos un registro mas allá,
tendremos un error, puesto que no existe tal. Si EOF toma el valor True, estamos al final, y caso
contrario si es False. El código dice que si NO estamos al final del recordset, cargue los datos, pero en
si lo estamos, evitamos el error posicionandonos en el último registro, no uno mas allá; esto lo
hacemos con MoveLast.

Para el evento click de Ultimo_btn, podás deducir el código:

Conjunto_de_resultados.MoveLast
Cargar_cajas_de_texto

Recuerda que si BOF y EOF toman ambos el valor True, quiere decir que no existen registros.
 - Agregar, modificar y eliminar registros de una base de datos Access con DAO
El código de este tema esta en: Manipular datos con objetos DAO.vbp

La aplicación anterior nos sirve solo para visualizar los registros, ahora terminaremos de
“vestirla”, utilizaremos la aplicación que acabas de crear. Aquí le implementamos las funciones de
agregar, modificar y eliminar, y para algunos usuarios inquietos que pudieran genear errores, aquí
nos ocuparemos de adelantarnos a algunos de sus movimientos.
Utilizaremos la base de datos EMPRESA.mdb que creamos en el primer tema, o puedes utilizar la
que viene anexada, esta base de datos la habíamos creado ya ,pero no contenía ningún registro.
Aquí nos ocuparemos de “poblarla".

1. Se entiende que por ocupar la aplicación pasada, ya tienes los textbox, los labels, la referencia a
Microsoft DAO 3.5 Object Library y los commands button’s.
2. Agrega a tu FORM1 cinco COMMAND BUTTON mas, a los que asignaremos las siguientes
propiedades:
______________ A todas las cajas de texto existentes (Controles existentes)
Locked True

______________ Commandbutton1 (Nuevo)

Nombre Nuevo_btn
Caption Nuevo
______________ Commandbutton2 (Nuevo)
Nombre Editar_btn
Caption Editar
______________ Commandbutton3 (Nuevo)
Nombre Eliminar_btn
Caption Eliminar
______________ Commandbutton4 (Nuevo)
Nombre Aceptar_btn
Caption Aceptar
Enabled False
______________ Commandbutton5 (Nuevo)
Nombre Cancelar_btn
Caption Cancelar
Enabled False
_______________________________

Debería quedarnos algo así...

1.Agrega la variable Accion a nivel formulario, de modo que quede así:

Option Explicit

Dim Base_de_datos As DAO.Database

Dim Conjunto_de_resultados As DAO.Recordset
Dim Accion As String
3.Escribe el siguiente código al evento click del boton Nuevo_btn:

Accion = "Nuevo"
Deshabilitar_exploracion
Deshabilitar_menu
Habilitar_edicion
Limpiar_cajas
Habilitar_Aceptar_Cancelar

4.Escribe el siguiente código al evento click del boton Editar_btn:

Accion = "Editar"
Deshabilitar_exploracion
Deshabilitar_menu
Habilitar_edicion
Habilitar_Aceptar_Cancelar

5.Escribe el siguiente código al evento click del boton Eliminar_btn:

Accion = "Eliminar"
Accion_es

6.Escribe el siguiente código al evento click del boton Aceptar_btn:

Accion_es

7.Escribe el siguiente código al evento click del boton Cancelar_btn:

Deshabilitar_Aceptar_Cancelar
Deshabilitar_edicion
Actualizar

Las funciones que siguen a continuación , son varias, bastantes diría; podría meterlas todas en un
módulo, pero la idea es simplificar al máximo este tema. Son funciones bastante sencillas, puestoo que
solo activan o desactivan botones, limpian cajas, bloquean o desbloquean cajas, son ellas no creo que
tengas mayor problema, pero te repito, son bastantes.

La explicación esta como un comentario, de modo que no dudes en copiar y pegar todo el código por
desconfianza a VB6 te marque un error ...

Continuamos ...
8. Copia este código, son “unas pocas” funciones que debes agregar a tu formulario, ELIMINA la
función de Cargar_cajas_de_texto para sustituirla con otra y agregar otras nuevas:
Function Cargar_cajas_de_texto()
If Conjunto_de_resultados.BOF = True And Conjunto_de_resultados.EOF = True Then
MsgBox "No hay registros en esta base de datos!! ", vbCritical
Deshabilitar_exploracion
Nuevo_btn.Enabled = True
Editar_btn.Enabled = False
Eliminar_btn.Enabled = False
Limpiar_cajas
Else
Clave_txt.Text = Conjunto_de_resultados!Clave
Puesto_txt.Text = Conjunto_de_resultados!Puesto
Nombre_txt.Text = Conjunto_de_resultados!Nombre
Email_txt.Text = Conjunto_de_resultados!Email
Habilitar_exploracion
Habilitar_menu
End If
End Function
‘Al cargar el texto en el evento Load del form, se sigue el mismo procedimiento que el tema anterior,
‘con la diferencia del IF, lo que hace es ver si la base tiene algún registro, si no lo tiene, y para evitar
‘un error de registro, simplemente no se cargan las cajas de texto, y un mensaje nos avisa del caso,
‘deshabilitamos la exploración etc etc, las funciones tienen nombres sencillo que podrás deducir.
‘Como no hay egistros, no tiene caso la exploración, la modificacion o la eliminación , solo la opcion
‘para agregar uno nuevo

Function Accion_es()
MousePointer = vbHourglass
If Accion = "Nuevo" Then
Conjunto_de_resultados.AddNew
Conjunto_de_resultados!Clave = Clave_txt.Text
Conjunto_de_resultados!Puesto = Puesto_txt.Text
Conjunto_de_resultados!Nombre = Nombre_txt.Text
Conjunto_de_resultados!Email = Email_txt.Text
Conjunto_de_resultados.Update
End If
If Accion = "Editar" Then
Conjunto_de_resultados.Edit
Conjunto_de_resultados!Clave = Clave_txt.Text
Conjunto_de_resultados!Puesto = Puesto_txt.Text
Conjunto_de_resultados!Nombre = Nombre_txt.Text
Conjunto_de_resultados!Email = Email_txt.Text
Conjunto_de_resultados.Update
End If
If Accion = "Eliminar" Then
Conjunto_de_resultados.Delete
End If
‘Cada vez que el usuario pulse alguno de los botones,Nuevo, Editar o Eliminar, la variable Accion, que
‘es un String (cadena), toma un valor (Nuevo,Editar o Eliminar), dependiendo del valor que tome, esta
‘función realiza el procedimiento necesario.
‘Al final, sea cual sea la accion tomada, se prepara el formulario con estos valores, que son por default.

Deshabilitar_Aceptar_Cancelar
Habilitar_menu
Deshabilitar_edicion
Actualizar
MousePointer = vbNormal
End Function

‘La función Actualizar, cierra la base de datos, la asigna de nuevo para hacer los cambios “visibles” ‘
‘con la base actualizada y lanza la sentencia de búsqueda nuevamente
Function Actualizar()
Base_de_datos.Close
Set Base_de_datos = OpenDatabase("a:\Empresa.mdb")
Set Conjunto_de_resultados = Base_de_datos.OpenRecordset _
("Select * from Empleados", dbOpenDynaset, dbOptimistic)
Cargar_cajas_de_texto
End Function

‘Esta función solo habilita los botones de exploración (Primero, Anterior etc...)
Function Habilitar_exploracion()
Primer_btn.Enabled = True
Anterior_btn.Enabled = True
Siguiente_btn.Enabled = True
Ultimo_btn.Enabled = True
End Function

‘Deshabilita los botnes de exploración (Primero, Anterior etc...)

Function Deshabilitar_exploracion()
Primer_btn.Enabled = False
Anterior_btn.Enabled = False
Siguiente_btn.Enabled = False
Ultimo_btn.Enabled = False
End Function

‘Habilta Nuevo , Editar etc..

Function Habilitar_menu()
Nuevo_btn.Enabled = True
Editar_btn.Enabled = True
Eliminar_btn.Enabled = True
End Function
‘Deshabilita los botones de nuevo, editar y eliminar
Function Deshabilitar_menu()
Nuevo_btn.Enabled = False
Editar_btn.Enabled = False
Eliminar_btn.Enabled = False
End Function

‘Si estás editando o agregando un registro, debes tener habilitados los botones de Aceptar para
‘ejecutar la acción, o cancelar, en caso que decidas cancelar tu acción
Function Habilitar_Aceptar_Cancelar()
Aceptar_btn.Enabled = True
Cancelar_btn.Enabled = True
End Function

‘Si no estás editando o agregando un registro, no es necesario tener estos botones

Function Deshabilitar_Aceptar_Cancelar()
Aceptar_btn.Enabled = False
Cancelar_btn.Enabled = False
End Function

‘Desbloquea las cajas de texto

Function Habilitar_edicion()
Clave_txt.Locked = False
Puesto_txt.Locked = False
Nombre_txt.Locked = False
Email_txt.Locked = False
End Function

‘Bloquea las cajas

Function Deshabilitar_edicion()
Clave_txt.Locked = True
Puesto_txt.Locked = True
Nombre_txt.Locked = True
Email_txt.Locked = True
End Function

‘Bla …bla …bla

Function Limpiar_cajas()
Clave_txt.Text = ""
Puesto_txt.Text = ""
Nombre_txt.Text = ""
Email_txt.Text = ""
End Function
Es necesario que los botones Aceptar y Cancelar se habiliten o deshabiliten, porque son los que lanzan
los procedimientos necesarios, aunque realmente es mas por estética.

Esto es lo nuevo realmente, examinemos el código de la funcion Accion_es:

Conjunto_de_resultados.AddNew
El método addnew del recordset, agrega un registro, aunque solo su estructura, es decir, un reistro en
blanco.

Conjunto_de_resultados!Clave = Clave_txt.Text
Conjunto_de_resultados!Puesto = Puesto_txt.Text
Conjunto_de_resultados!Nombre = Nombre_txt.Text
Conjunto_de_resultados!Email = Email_txt.Text

Aquí es donde el registro en blanco toma los valores, al igualar cada nombre del registro con el texto
de su respectivo textbox.

Conjunto_de_resultados.Update

El método update, incorpora el nuevo registro a la base de datos.

La faccion de editar, tiene el siguiente código, que examinamos paso a paso:

Conjunto_de_resultados.Edit

Edit, lo que hace es “abrir” el registro, para poder editarlo, a diferencia de addnew, que agrega una
estructura nueva.

Conjunto_de_resultados!Clave = Clave_txt.Text
Conjunto_de_resultados!Puesto = Puesto_txt.Text
Conjunto_de_resultados!Nombre = Nombre_txt.Text
Conjunto_de_resultados!Email = Email_txt.Text
Conjunto_de_resultados.Update

Igual que la descripción anterior, aquí solo igualamos valores con campos, para dales un valor , y con
update, los incorporamos a la base de datos.

Con eliminar la cosa es mas sencilla:

Conjunto_de_resultados.Delete

El recordset lee el valor de la posición del registro actual y simplemente ... lo elimina.

Te preguntarás porque es necesario que abrir y cerrar la base, es por el tipo de cursor que estamos
usando, y como lo estamos usando, es necesario cerrar y abrir la base para que los cambios sean
visibles desde el pricnipio, aunque podrías posicionarte en determinada lugar de la base y cargarlo,
pero aquí, solo alargaríamos mas el documento.
Aún queda mucho que hacer, como aplicar la función IsNumeric para la clave de empleado, mostrar un
mensaje de si está seguro de eliminar determinado registro, podríamos poner un combo o list para
desplegar los puestos entre los que se puede elegir, etc. etc. O las opciones de estética como icono del
form, los colores e infinidad mas. Pero con este tutorial, solo se pretende que aprendas a utilizar los
objetos DAO.

Las propiedades y métodos descritas aquí, son solo las básicas en una base de datos, no dejes de visitar
esta página para continuar con este documento.

The13thBandido.Freehost.com

No dudes en escribir para cualquier aclaración:

bandidito13@hotmail.com