Índice de contenido1.- Ejemplos de Formularios Complejos........................................................................................ 22.- Referencias a los objetos de los formularios o informes.........................................................153.- Macros avanzadas. Ejecución condicional..............................................................................16

Bucles................................................................................................................................................ 16Ejemplo de construcción y uso de macros........................................................................................ 17Organización de macros.................................................................................................................... 18Macros autoejecutables..................................................................................................................... 18

4.- Los módulos. .......................................................................................................................... 195.- Controles Lista y Combo-Box................................................................................................ 266.- Manejo de Controles de Radio Botón y Check-box................................................................377.- Manejo de formularios Maestro/Detalle................................................................................. 418.- Creación de Aplicación de arranque....................................................................................... 459.- Objetos de Access................................................................................................................... 4810.- Formularios de consulta........................................................................................................ 5011.- Sentencias Condicionales......................................................................................................5411.- Sentencias Iterativas..............................................................................................................5612.- Formulario con Programación...............................................................................................5913.- Tipos de datos, operadores y constantes............................................................................... 61

Operadores aritméticos.......................................................................................................................... 62Operadores de concatenación................................................................................................................ 62Operadores lógicos.................................................................................................................................63

14.- Funciones de Visual Basic.................................................................................................... 6315.- Inicio a la Programación en la Librería ADO....................................................................... 6416.- El objeto Conexión................................................................................................................6617.- El Objeto Recordset.............................................................................................................. 6618.- El Objeto “Command”.......................................................................................................... 6719.- El tratamiento de los Errores en ADO.................................................................................. 68

1.- Ejemplos de Formularios Complejos.

Ejemplo 1.

Formulario base sobre la tabla “obra” creado con el asistente para la tabla obra, con todos sus campos, en columnas y estándar. Hasta obtener el siguiente diseño básico:

Comenzaremos modificando las etiquetas predeterminadas que se utilizan cuando queremos introducir textos constantes normalmente mensajes identificativos sobre textos. Una vez que tenemos nuestra etiquetas introducidas podemos modificarles las distintas propiedades de edición con botón derecho-Propiedades:

Las propiedades se agrupan en tres grupos:• Formato: que corresponde con el formato o forma de la etiqueta. Normalmente

ajustamos: color, fuente, tamaño, efecto, etc...• Datos: cuando queremos mostrar datos de una tabla es preciso asociar un cuadro de

texto al campo correspondiente de una tabla.• Eventos: el evento es cualquier cosa que se puede hacer con el objeto. Por ejemplo:

hacer clic con el ratón. Lo importante es la respuesta al evento, que hago cuando hago clic con el ratón sobre ese campo.

• Otras: es un grupo de propiedades no clasificarles dentro de las anteriores.

Cambiando los textos hasta llegar al siguiente formato:

Una vez obtenido este formato básico vamos a ver el formulario en el formato “Vista formulario” para ver como se comportan los datos de este.

Ejemplo 2.

Sobre el formulario anterior vamos a colocar en la parte superior una etiqueta que ponga “Tabla de Obras”. Para ello, movemos los campos anteriores, introducimos la etiqueta y modificamos el formato para que resalte con el resto del texto:

Sobre este formulario vamos a añadir un botón con el texto “Salir” y nombre “cmdSalir”. Una vez añadido el botón nuestro formulario de trabajo presenta el siguiente formato:

Aunque tenemos el botón al pulsar sobre él no hace nada. Es preciso asignarle una acción (cerrar el formulario) cuando se produce el evento (o hecho) de pulsar el botón con el ratón. De nuevo accedemos a las propiedades del botón hasta llegar a la siguiente propiedad de la pestaña de eventos:

Para hacer algo en este punto o ejecutamos una macro o ejecutamos código en un procedimiento de Visual Basic para aplicaciones. Escogemos la opción de [Procedimiento de evento] y nos aparece la ventana de trabajo de Visual Basic que rellenamos con el siguiente código:

Los procedimiento o subrutinas Visual Basic almacenan conjunto de instrucciones dentro de un lenguaje de programación. Visual Basic los nombra en función del nombre del objeto al que se asocian. En este caso es “Click” sobre el botón “cmdSalir”. La acción que se realiza es “Close” sobre el objeto “DoCmd” que es como se identifica al formulario Access dentro de Visual Basic.

Ejemplo 3.

Continuando con nuestro formulario de trabajo vamos añadir dos botones que nos permiten avanzar al siguiente registro y al anterior sin necesidad de el objeto predeterminado de Access.

Comenzamos creando los botones “cmdSiguiente” y “cmdAnterior”. Una vez realizadas estas tareas, escogemos por ejemplo el botón anterior y en evento “Al hacer clic” escogemos la opción “Generador de macros”:

Desde este punto accedemos al “Generador de macros” que ejecuta un conjunto de ordenes predeterminadas que realizan ordenes especificas sobre los distintos objetos y elementos que se manejan en Access.

Entramos en el “Generado de macros” y nada más entrar salvamos nuestra nueva macro con el nombre “anterior” como podemos comprobar en la siguiente figura:

Una vez realizada esta tarea pasamos a buscar la acción que nos interesa de la lista de acciones y macros disponibles y la configuramos según los siguientes parámetros:Es preciso cambiar la propiedad “Registro” y fijar un desplazamiento. Los valores disponibles para “Registro” son:

Como podemos observar la misma Acción parametrizada correctamente nos permite ir al Anterior, siguiente, primero, ultimo, al numero que yo quiera y casi insertar un registro con nuevo.

Tarea: realizar el mismo proceso para el botón “Siguiente”.Tarea: implementar un botón para cada una de las opciones que se especifican dentro de la

pestaña de registro.

Ejemplo 4.

Podemos modificar el ejemplo anterior sustituyendo la ejecución de una macro por la orden correspondiente en un”Procedimiento de evento” Visual Basic insertando los siguientes códigos asociados a los botones:

En este caso estamos ejecutando el método”GoToRecord” del objeto genérico doCmd. La propiedad que nos interesa es la de avance que se pasa como tercer parámetro. Los valores que puede tomar esta propiedad son:

Podemos observar la similitud con los valores que toma la macro “IralRegistro”. De todas formas realiza un tarea semejante.

Ejemplo 5.

Sobre la base del ejercicio anterior podemos mezclar la ejecución de una macro con la ejecución de un “Procedimiento de evento” en código Visual Basic. Aplicando el método RunMacro del objeto del sistema DoCmd como podemos observar en el siguiente código:

Ejemplo 6.

Vamos a construir un formulario que nos va a abrir a otro formulario, a un informe. Para ello creamos el formulario frmMaterial sobre la tabla material y el informe infMaterial sobre la misma tabla. Los creamos utilizando el asistente y su único objetivo es comprobar el acceso a ellos, no nos interesa el formato que presente.

Una vez construidos estos objetos podemos comenzar a crear nuestro formulario “frmMenu” directamente desde “Vista diseño” y añadimos los botones “cmdSalir”, “cmdFormulario” y “cmdInforme” según la siguiente estructura:

En este caso vamos a ejecutar las acciones utilizando macros. Vamos a crear las macros “salir”, “frmMateriales” y “infMateriales” a la vez que las asociamos al evento “click” del botón correspondiente.

Comenzamos con la macro “salir”:

Macro “frmMaterial”:

Macro “infMaterial”:

Como podemos observar en estas dos últimas macros realizan la acción “AbrirFormulario” y “AbrirInforme” y es preciso pasarle como parámetro el nombre del formulario y el nombre del informe para que identifiquen sobre que objeto tienen que operar.

Podemos comprobar la lista de macros que hemos construido en los distintos ejemplos desarrollados:

Ejercicios para realizar:Realizar la misma tarea con código Visual Basic utilizando el objeto doCmd y sus distintos

métodos.Realizar la misma tarea con Visual Basic utilizando el método RunMacro del objeto doCmd

para ejecutar las macros anteriores.

Ejemplo 7. Creación de formulario sin usar el asistente.

Vamos a crear el formulario “frmObrero” que trabaje sobre la tabla “Obrero” sin utilizar el asistente de formularios.

Partimos de la creación de un formulario desde “Crear formulario en Vista diseño”, llegando al siguiente punto:

Una vez que hemos creado el formulario es preciso engancharlo a la tabla de “Obrero” poder acceder a la vista de datos. Para esto hay que acceder a las propiedades del formulario que se encuentra en el recuadro de la parte superior izquierda bajo el Icono que representa el formulario, pulsando con el botón derecho del ratón en el cuadrito sombreado:

Escogemos la opción “Propiedades” y modificamos la siguiente propiedad asociada a datos dentro del formulario:

Como podemos observar los “Orígenes de datos” coinciden con las tablas y consultas de nuestra base de datos. Una vez seleccionada la tabla obrero disponemos de una nueva ventana que es la “Lista de Campos”, esta ventana es la que nos permite enlazar los controles de tipo texto a los campos de la tabla “Obrero”.

Si pasamos a la vista formulario, disponemos de un objeto gráfico del tipo “RecordSet” que nos permite recorrer de forma automática los distintos registros de la tabla “Obrero”

Volvemos a la “Vista diseño”, para añadir los campos de la tabla a nuestro formulario basta con arrastrarlos desde la hoja de datos hasta el formulario.

Arrastramos los distintos campos, aumentando el tamaño del área de detalle. Cambiamos los nombres de las etiquetas asociadas hasta obtener el siguiente diseño del formulario “frmObrero”:

Para manejar las etiquetas del cuadro de texto de forma independiente, es preciso pulsar el cuadro negro de la parte superior Izquierda de la etiqueta o texto. Manejándose de forma independiente. De esta forma podemos acercar los objetos o eliminar uno de ellos.

Ejemplo 8. Formulario maestro/detalle con campos calculados.

Se denomina formulario maestro/detalle a aquellos que muestran un registro relacionado con unos pocos. Por ejemplo, materiales con gasto de material. Aparece por cada material todos sus gastos.

Antes de construir el formulario maestro/detalle vamos a comprobar y si es preciso crear una relación de integridad referencial mediante claves foráneas entre las tablas “Material” y “GstMtr”. Para ello accedemos a la ventana de relaciones:

Y desde esta establecemos las relaciones entre las tablas hasta obtener un diseño semejante al de la Introducción:

Una vez establecidas las relaciones comenzamos creando el formulario frmMtrGst desde el “Asistente” de formulario. Escogemos la tabla “Material” , en columnas y el diseño “Estándar”. Desde “Vista Diseño” agrandamos el espacio de la zona de detalle hasta llegar al siguiente punto:

Ahora activamos la barra de herramientas y escogemos la opción Sub-formulario:

Y creamos un objeto Subformulario en la parte inferior de la ventana anterior y nos aparece un cuadro en blanco y la siguiente ventana de selección:

Escogemos la opción “Usar tablas y consultas existentes” y pulsamos el botón “siguiente” para seleccionar la tabla “GstMtr” y todos sus campos. Para futuras aplicaciones podemos en estos casos eliminar los campos claves comunes en el formulario detalle porque aparecen en el formulario maestro. Una vez seleccionada la tabla y los campo pasamos a la siguiente ventana:

Donde elegimos las opciones por defecto. Las opciones por defecto funcionan correctamente por el diseño actual de la base de datos, que como podemos comprobar ha enlazado los datos correctamente. Pulsamos el botón “Siguiente” asignamos un nombre al formulario detalle y finalizamos el proceso.

La vista en diseño deja bastante que desear pero la vista formulario nos muestra una estructura semejante a la de una factura:

Como se puede observar aparecen todos los gastos de materiales del material 'm1' y se repite en esta columna el código 'm1'. Por este motivo, es normal eliminar este campo en los futuros diseños.

Comenzamos introduciendo un primer campo calculado que nos muestra la valoración en almacén de nuestro articulo. En este caso nMtrImp * nMtrExs. Comenzamos introduciendo un cuadro de texto, denominándolo “valoración” y desde la pestaña de datos asignarle la siguiente expresión a la propiedad “Origen del control”:

Para ello hemos utilizado el “Generado de expresiones” que como sabemos se accede desde el icono: “...”. Los campos [nMtrImp] y [nMtrExs] lo he seleccionado directamente de la lista de controles que aparece en la zona central de la ventana del “Generador de Expresiones”.

Obteniéndose el siguiente resultado desde la vista formulario:

Vamos a repetir el mismo proceso para generar el campo calculado “Valor” que multiplicará los campos “nGstMtrUnd” * “nMtrImp” de la tabla “GstMtr”. En este caso es preciso insertar el Cuadro de texto dentro del sub-formulario para que se comporte como un campo de la tabla “GstMtr”. Hay que gastar cuidado con el campo nMtrImp que se encuentra repetido en ambas tablas. Si todo se ha realizado correctamente la vista formulario debería mostrar los siguientes datos:

Podemos observar que la columna “cMtrCdg” del formulario detalle siempre toma el valor 'm1' al estar relacionada con el correspondiente registro de la tabla material. En la mayoría de los diseños no se añaden estas columnas a los formularios detalle al encontrarse repetidos y aparecer en el formulario maestro.

2.- Referencias a los objetos de los formularios o informes.

En numerosas acciones de macros es necesario consultar el valor o hacer algún tipo de referencia a los controles de los formularios o informes. Recordemos que cada control en un formulario o informe, así como los propios formularios/informes están identificados mediante una propiedad nombre.Cada control dentro de un formulario o informe tiene un nombre identificativo único. Mediante este

nombre podemos acceder al valor que tiene almacenado. Siguiendo una estrategia similar a la utilizada en programación orientada a objetos, se puede identificar un control dentro de un formulario o informe nombrando un camino completo que permita llegar al control, partiendo de la base de datos e identificando cada paso con el nombre de un objeto.

Inicialmente existen dos grupos de controles, los pertenecientes a formularios y los pertenecientes a informes. Puesto que formularios e informes no comparten el espacio de nombres, una identificación global de un control en la base de datos debe reflejar este extremo, y debe comenzar por establecer el grupo al que pertenece. Además, habrá que nombrar el formulario o informe concreto y por último el control.

Además de al contenido de un control, se puede acceder a todas sus propiedades. Para ello basta con concatenar el nombre de la propiedad. Por ejemplo:

Propiedad de control Significado

Formularios![Almacenes]![IDalmacen].ColorDelFondo Número del color de fondo del control IDalmacen del formulario Almacenes.

Informes![Almacenes]![IDalmacen].NombreDeFuente Nombre de la fuente del texto del control IDalmacen del informe Almacenes.

Formularios![Notas Alumnos]![Apellido1].Altura Altura (en centímetros ) del controlo Apellido1 del formulario Notas Alumnos.

Para que una referencia a un control de un formulario o informe sea válida, el formulario o informe concreto debe estar abierto, aunque no sea el que esté activo en ese momento. En un formulario de tipo continuo existen múltiples "copias" de los controles situados en la sección Detalle. Entonces, una referencia al contenido de uno de estos controles afectará al control que contenga información del registro activado (en edición) en ese momento.En determinadas situaciones no es necesario utilizar la identificación global de los controles. Por ejemplo, los controles de un formulario se puede referenciar desde el propio formulario sólo con el nombre del control, sin necesidad de especificar el grupo de formularios y el nombre de formulario. También es posible referenciar controles de formularios o informes desde macros sólo con el nombre del control cuando las macros se ejecutan como consecuencia de eventos elevados desde ese formulario o informe.

La identificación de controles se puede realizar desde y hacia cualquier objeto de la base de datos: tablas, consultas, formularios, informes, macros y módulos.

3.- Macros avanzadas. Ejecución condicionalComo ya se introdujo en el tema anterior, es posible añadir una columna a la tabla de acciones

de una macro para establecer expresiones condicionales que regulen la ejecución de las acciones (hay que pulsar el botón o la opción correspondiente del menú Ver). Para cada acción se puede especificar una condición lógica. Este expresión se evalúa antes de ejecutar la acción, y si el resultado de la expresión es verdadero, la acción se efectúa, y si no, se ignora. Si para una acción se omite la expresión condicional, se supone que es una expresión verdadera y la acción correspondiente se ejecuta siempre.Si una secuencia de acciones dependen de la misma expresión no es necesario replicar la expresión para cada acción. La expresión "..." (tres puntos) indica a Access que la condición que regula a una acción es la misma que la de la acción anterior.

BuclesLa única forma de ejecutar bucles dentro de las macros es mediante el uso de la acción EjecutarMacro. Las propiedades de esta acción son:

• Nombre de la macro: macro que hay que ejecutar.

• Número de repeticiones: número de veces que hay que ejecutar la macro.• Expresión de repetición: Expresión que indica continuación en el bucle: el bucle termina

cuando la expresión sea falsa o termine el número de iteraciones establecido en Numero de repeticiones.

Ejemplo de construcción y uso de macrosSupongamos que tenemos una formulario para introducir características de clientes. Nuestra

empresa ofrece descuentos especiales a clientes menores de 25 años, a minusválidos y a poseedores de un carnet de socios según el siguiente criterio:

Tipo DescuentoMenores de 25 años 5%Minusválidos 10%Socios 20%Socios minusválidos 25%Minusválidos menores de 25 10%Socios menores de 25 años NO PERMITIDOS

La tabla que almacena esta información consta de los siguientes campos (el Descuento, aunque se puede calcular a partir de los otros campos, se almacena en la tabla por razones de eficiencia):

Campo ComentariosApellidos, Nombre, DNI Texto.Edad Numérico.Minusválido Texto de longitud 1, con dos únicas posibilidades: "S" o "N"NumSocio Numérico. Nulo si no es socio.Descuento Numérico entre 0 y 100.

Tenemos un formulario con un control para cada campo, con el mismo nombre que el campo. El formulario debe establecer de forma automática el descuento a partir de las características del cliente. Además debe detectar las situaciones prohibidas, como un cliente menor de 25 años.

Figura 5.2 Aspecto del formulario descrito

Veamos las macros necesarias para el formulario, así como los eventos asociados a cada macro. Suponemos que el formulario se llama "Clientes" y que existen reglas de validación para verificar que el contenido del campo minusválido es "S" o "N" y que el descuento está comprendido entre 0 y 100.Necesitaremos las siguientes macros:

Nombre de macro Descripción Eventos a los que se asocia

Calcular descuentoCalcula el descuento a partir de los datos del cliente, siempre y cuando el descuento esté en blanco.

Evento "Después de actualizar" del control Edad.Evento "Después de actualizar" del control Minusválido.Evento "Después de actualizar" del control NumSocio.

Comprobar validezComprueba que no haya situaciones prohibidas como socios menores de 25 años.

Evento "Antes de actualizar" del control Edad.Evento "Antes de actualizar" del control NumSocio.

El contenido de la macro Calcular descuento será el siguiente:

Condición Acción Descripción Propiedades adicionales([Edad]<25) Y ([Minusválido]<>"S") EstablecerValor Pone descuento al 5% para

menores no minusválidosElemento: [Descuento]Expresión: 5

... DetenerMacro Terminar([Minusválido]="S") Y ([NumSocio] Es Nulo) EstablecerValor Pone descuento al 10% para

minusválidos no sociosElemento: [Descuento]Expresión: 10

... DetenerMacro Terminar([Minusválido]="S") Y ([NumSocio] Es Negado Nulo) EstablecerValor Pone descuento al 25% para

socios minusválidos Elemento: [Descuento]Expresión: 25

... DetenerMacro Terminar([Minusválido]<>"S") Y ([NumSocio] Es Negado Nulo) EstablecerValor Pone descuento al 20% para

socios no minusválidosElemento: [Descuento]Expresión: 20

... DetenerMacro Terminar

EstablecerValor Pone descuento al 0% si no es ninguno de los anteriores.

Elemento: [Descuento]Expresión: 0

El contenido de la macro Comprobar validez será el siguiente:

Condición Acción Descripción Propiedades adicionales

([Edad]<25) Y ([NumSocio] Es Negado Nulo) CuadroMsj Mostrar un mensaje de error.

Mensaje: No puede ser socioBip: SíTipo: CríticoTítulo: Error

... CancelarEvento No aceptar el cambio.

Organización de macrosEs habitual que las bases de datos contengan un gran número de macros. En tal caso resulta incómodo trabajar en la ventana de la base de datos con tantos nombres de macros. Por eso, Access permite organizar las macros en grupos de macros, aunque sólo permite un nivel de agrupamiento.La estrategia es definir diferentes partes dentro de una misma macro. Cada parte queda etiquetada con un nombre único dentro de la macro, de forma que el acceso a cada una de las partes (que son macros independientes) se hace mediante [nombre de macro].[nombre de parte].Para hacer todo esto es necesario utilizar la columna Nombre de macro de la tabla de acciones del editor de macros, la cual se muestra y oculta pulsado el botón o la opción correspondiente del menú Ver.En la columna Nombre de macro debe especificarse el nombre del grupo en la primera acción del grupo, y para el resto de acciones debe dejarse en blanco. Así, las acciones de un grupo serán aquéllas que comienzan en la acción que contiene el nombre del grupo, y todas las siguientes no identificadas hasta la próxima acción identificada (que pertenecerá al siguiente grupo).En el siguiente ejemplo, hay tres grupos dentro de la misma macro, con 3, 2 y 5 acciones:

Nombre de macro Acción ComentarioSalirAccess CuadroMsj Mensaje de despedida

Salir Salir de AccessComenzar CuadroMsj Mensaje de bienvenida

Minimizar Minimizar la ventana de la base de datosAbrirFormulario Abrir formulario principal

Informe CuadroMsj Mensaje de que se va a imprimir un informeEstablecerAdvertencias No mostrar más mensajesEjecutarConsulta Hacer los cálculos, primera parteEjecutarConsulta Hacer los cálculos, segunda parteAbrirInforme Imprimir el informe

Macros autoejecutablesEs posible definir en toda base de datos una macro que se ejecute de forma automática cada vez

que se abre la base de datos. Esta macro debe tener el nombre "Autoexec". Habitualmente se utiliza

para abrir un formulario no vinculado a ninguna tabla ni consulta, que contiene una serie de opciones (botones de comando, menús, etc.) para abrir el resto de formularios de la base de datos, dando al sistema un aspecto de programa de aplicación más que de base de datos.

4.- Los módulos. Los módulos permiten ampliar las posibilidades de Access. Con ellos se pueden hacer

procedimientos y funciones que no estén ya creados en Access para efectuar distintas operaciones en la base de datos. Los procedimientos y funciones se programan en lenguaje Visual Basic para aplicaciones que es un subconjunto del lenguaje de programación Visual Basic.

En nuestro caso utilizaremos la programación sobre Access en Visual Basic para Aplicaciones por ser prácticamente igual que el Visual Basic puro facilitando el manejo por parte del usuario.

Los módulos de código son conjunto de procedimiento (subrutinas) y funciones generales a la base de datos almacenadas en un fichero (objeto) que es el módulo. Un procedimiento o subrutina es un conjunto de ordenes que realizan una tarea. Por ejemplo, queremos imprimir a la vez tres Impresos o abrir varios formularios. Una función es un trozo de código que calcula un valor a partir de unos datos que normalmente introducimos como parámetros de la función. Por ejemplo, pasamos una nota numérica (parámetro de entrada) y nos devuelve (calcula) la nota en cadena de texto a partir de esta nota numérica.

Los módulos como hemos visto pueden estar asociados a formularios para realizar tareas relativas a este formulario o ser de carácter general y podemos acceder desde cualquier objeto de Access a ellos de una forma cómoda.

Comenzamos en la ventana principal seleccionando la opción módulos y el Icono de nuevo:

Módulos abre una nueva ventana independiente de la ventana de trabajo de Access, por lo que a partir de este punto tenemos dos ventanas. La ventana de trabajo de Access y el entorno en modo texto del módulo.

La ventana de trabajo de módulos presenta el siguiente aspecto:

Podemos distinguir a primera vista cuatro partes:

● Explorador de Proyectos: parte superior izquierda. Nos muestra los módulos y los objetos de estos.

● Ventana de propiedades: Inferior Izquierda. Muestra las propiedades del objeto con el que trabajamos.

● Ventana Principal: Superior Derecha. Es donde se escribe el texto en forma de código de los distintos módulos.

● Ventana de Inmediato: Escribir o pegar una línea de código y presionar Entrar para ejecutarlo.

Comenzamos creando el procedimiento abrir. Menú principal: “Insertar-Procedimiento” accediendo a la siguiente ventana:

Escogemos la opción “Procedimiento”:

Donde:

● Nombre: nombre de nuestro objeto en este caso “abrir”

● Tipo: es el tipo de objeto.

● Procedimiento: para realizar varias tareas.

● Función: para calcular valores.

● Propiedad: cuando creamos objetos podemos asociarles propiedades. Parecidas a los objetos del sistema como por ejemplo el tamaño de un botón o el color de fondo.

● Ámbito: es la visibilidad de los objetos.

● Público: se puede ver desde cualquier objeto access.

● Privado: sólo se ve desde este módulo.

● Todas las variables locales como estáticas: una variable es un elemento para realizar cálculos. Es estática cuando almacena valores de una ejecución anterior. Dicho de otra forma me guarda los valores que tenía cuando ejecute la vez anterior el procedimiento o función. Su uso en programación es muy restrictivo.

Dejamos el cuadro tal cual se ve en la figura anterior y comenzamos a escribir nuestro código, para abrir formularios es preciso acceder a un objeto del sistema denominado doCmd y ejecutar el metódo OpenForm:

Los objetos del sistema y los que se crea el usuario tienen propiedades, métodos y eventos (objetos gráficos). Una propiedad es un valor asociado a un objeto (tamaño, color), un método es algo que puede hacer el objeto una tarea ( por ejemplo abrir un formulario) y un evento en un objeto de un entorno gráfico es que puede controlar acciones sobre él, por ejemplo puede controlar que se pulsa el ratón sobre él. Es tan importante saber que detecta el evento como la respuesta que este objeto da al

evento que es lo que completa el programador. Existen eventos no relacionados con entornos gráficos como por ejemplo los eventos que detectan que se abre o se cierra un formulario y podemos realizar tareas cuando se producen estos hechos.

El código de nuestro procedimiento puede quedar:

Option Compare Database

Public Sub abrir()

DoCmd.OpenForm "autobus"

DoCmd.OpenForm "conductor"

End Sub

Donde “autobus” y “conductor” son los nombres de dos formularios. Observe se que van entre comillas, esto indica que son cadenas de caracteres constantes no la invocación del objeto formulario.

Podemos probar nuestro procedimiento directamente con la orden Run desde la ventana de inmediato como podemos ver en la siguiente ventanta:

Podemos crear un nuevo procedimiento “cerrar” que nos cierre los formularios que hemos abierto anteriormente, con el siguiente código:

Public Sub cerrar()

DoCmd.Close acForm, "autobus"

DoCmd.Close acForm, "conductor"

End Sub

Donde:

● acForm: es una constante del sistema que nos indica que queremos cerrar un formulario. Esto se usa porque el método Close es capaz de cerrar cualquier objeto. Entonces le decimos que queremos cerrar un formulario y luego le datos como segundo parámetro el nombre del formulario a cerrar.

Recomendamos observar el funcionamiento de ambos procedimientos desde la ventana de inmediato. Primero ejecutamos el procedimiento “abrir” y a continuación tras comprobar la apertura de los formularios probamos el procedimiento “cerrar”.

Para poder ejecutar nuestro código desde una macro es preciso convertir nuestro procedimientos en funciones. Para ello basta con retocar el código hasta obtener el siguiente:

Option Compare Database

Public Function abrir()

DoCmd.OpenForm "autobus"

DoCmd.OpenForm "conductor"

End Function

Public Function cerrar()

DoCmd.Close acForm, "autobus"

DoCmd.Close acForm, "conductor"

End Function

Una vez modificado este código construimos la macro “mabrir” según podemos observar en la siguiente figura:

La acción asociada es “EjecutarCódigo” y nuestra función “abrir()” debe aparecer en la siguiente ventana de búsqueda de funciones:

Al ser las funciones públicas dentro del módulo1 son accesibles desde cualquier punto de la base de datos.

Los procedimientos no son accesibles desde las macros por eso hemos tenido que usar funciones. La diferencia principal entre procedimientos y funciones es que las funciones devuelven un valor. En el caso de Visual Basic la función devuelve el valor asignado al nombre de la función que se

comporta como una especie de variable.

Por ejemplo, dentro de nuestro módulo1 vamos a crear la función cuadrado que devuelve el cuadrado de un numero que se le pasa como parámetro. Esta función tiene el siguiente código:

Public Function cuadrado(parametro1 As Integer) As Integer

cuadrado = parametro1 * parametro1

End Function

Vamos a describir el código anterior:

● parametro1 as Integer: “as” significa que el tipo del parámetro es entero.

● Public Function ..... As Integer: significa que la función también es de tipo entero.

● cuadrado = parametro1 * parametro1: almacena en el nombre de la función el valor que calcula. En este caso el producto del parámetro por si mismo, que corresponde con su cuadrado.

Para comprobar el funcionamiento de nuestra función podemos ejecutar el siguiente código en la ventana de inmediato:

Debug es un objeto del sistema que con el método “Print”, nos permite escribir valores o resultados. En este caso el valor entero devuelto por la función.

Variables dentro de los módulos. Las variables son elementos que pueden almacenar un valor de un tipo cualquiera de datos. Las variables son semejantes a los campos de los registros pero a diferencia de estos sólo pueden contener un único valor. Las variables pueden ser de las siguientes clases:

● Dim: son variables locales al módulo pero accesibles a los descendientes. Si declaro una variable “Dim” en el módulo principal es visible en todo el módulo.

● Public: son variables publicas a todo el módulo e incluso el exterior.

● Private: son privadas al módulo, procedimiento o función que la contenga y no se ve desde el exteriror.

● Static: es un tipo de variable “Dim” que almacena los valores que tenía antes. Normalmente se usan en funciones o procedimientos y almacena el valor que tenía la variable en una ejecución anterior del procedimiento o función.

La declaración de una variable es bastante simple:

clase variable1 as tipo, variable2 as tipo, ...

Las variables es preciso iniciarizarlas antes de usarlas aunque por defecto las variables numéricas se inicializan a 0 y las de tipo string a la cadena de caracteres vacía.

Vamos a crear un nuevo Módulo de código denominado “variables”con el siguiente código:

Option Compare Database

Dim nVrb1 As Integer

Public Function suma1()

nVrb1 = nVrb1 + 1

suma1 = nVrb1

End Function

Public Function suma2()

Dim nVrb2 As Integer

nVrb2 = nVrb2 + 1

suma2 = nVrb2

End Function

Public Function suma3()

Static nVrb3 As Integer

nVrb3 = nVrb3 + 1

suma3 = nVrb3

End Function

Las funciones suma suman un 1 a cada una de las variables y después devuelven el valor de dicha variable. Vamos a ejecutar en la ventana de inmediato los siguientes códigos:

debug.Print suma1()

1

debug.Print suma1()

2

debug.Print suma1()

3

debug.Print suma2()

1

debug.Print suma2()

1

debug.Print suma2()

1

debug.Print suma3()

1

debug.Print suma3()

2

debug.Print suma3()

3

Dejamos al lector como trabajo el porque de estos resultados. Observar que suma3 tiene un comportamiento semejante al de suma1.

Para que las variables sean visibles desde la ventana de inmediato es preciso que se declaren como Public. Al fin y al cabo la ventana de inmediato es un entorno de trabajo diferente al modulo de código.

5.- Controles Lista y Combo-Box.

Los controles de lista y Combo-Box nos permiten escoger los valores de un campo a partir de una lista. Dicha lista de valores la podemos cargar en caso de un numero reducido de opciones o las podemos obtener de una tabla.

Comenzaremos con un ejemplo en el que se escogen los valores de una lista fija para la titulación de los alumnos que puede entrar a un ciclo formativo de grado superior que puede ser “FP 2”, “Bachillerato”, “BUP” y “Prueba de Acceso”

Partimos del diseño de la siguiente tabla de ejemplo “Matricula”:

Una vez creada la tabla creamos un formulario básico sobre la tabla matricula y eliminamos el campo “cMtrEst”, llegando al siguiente punto:

Vamos a introducir un “Cuadro combinado” que en principio nos da más opciones que un control “Cuadro Lista”. Automáticamente nos aparece el asistente donde vamos completando los siguientes elementos:

En este cuadro indicamos el tipo origen de los valores, en este caso se trata de valores predeterminados.

En la ventana anterior introducimos la lista de valores, como se puede observar se pueden introducir más de una columna y posteriormente escogeríamos los valores de una de ellas, siendo las otras columnas de información.

Asociamos el campo “cMtrEst” al control que estamos manejando. Por último, indicamos la etiqueta asociada a nuestro control:

Ya podemos introducir datos desde la Vista-Diseño de nuestro formulario recién creado:

Vamos a repasar las propiedades de nuestro control Cuadro combinado para comprender mejor su funcionamiento:

Las propiedades más interesantes son:• Origen del control: campo asociado a este.

• Tipo de origen de la fila: “Lista de valores” que nos indica que vamos a introducir la lista de valores manualmente.

• Origen de la fila: lista de valores a introducir separados por ;.• Columna dependiente: numero de columna que se asocia al campo.

Una vez que hemos creado un cuadro combinado de este tipo estamos listos para crear un “Cuadro combinado” que asocie una clave foránea con sus posibles valores en la clave principal. Por ejemplo, en la tabla Obrero generar un cuadro combinado con las posibles categorías disponibles correspondientes a la tabla categoría para poder escoger una de ellas. Partimos de un formulario de Obrero creado automáticamente con el asistente del que hemos eliminado el campos “cCtgCdg”:

Al igual que en caso anterior añadimos un control “Cuadro combinado”, pero en este caso vamos cambiando las opciones del asistente según podemos comprobar en los siguientes formularios:

Comienzo escogiendo el tipo de origen, en este caso asociado a una tabla o consulta.

Selecciono la tabla origen “Categoría”.

Escojo dos campos el código que voy a asociar al campo y la descripción que voy a mostrar a la hora de seleccionar o escoger los valores.

En principio no voy a ordenar los valores por ningún campo por lo que paso a la siguiente ventana:

Mantengo la ocultación de la clave principal (se recomienda) para que sólo muestre la columna descripción y no la clave.

Asocio el control al campo “cCtgCdg” de la tabla obrero. Por último, fijo una etiqueta al “Cuadro Combinado” y dispongo ya del siguiente formulario:

Vamos a revisar las propiedades más interesantes asociadas al cuadro combinado:

Donde hay que destacar:• Origen del control.• Tipo de origen de la fila.

• Origen de la fila.• Columna dependiente: indica el numero de la columna de la que se recogen valores.

Para mostrar o no una columna en concreto de las seleccionadas en la orden “Select” se le da un ancho distinto de 0 en la siguiente propiedad:

El “Ancho de columnas” que es una propiedad de “Formato”, nos da el ancho de visualización de cada columna de la orden “Select” separado por “;”. Un ancho de “0 cm” como podemos observar para el primer valor no mostraría dicha columna. En este caso corresponde con la columna “cCtgCdg” que de forma automática habíamos ocultado.

Existe un tercer tipo de “Cuadro Combinado” independiente que nos permite mostrar los registros de la tabla actual y situarnos en el que hallamos seleccionado dentro del cuadro. Este cuadro combinado nos realiza una especie de búsqueda Este control en teoría poco tiene que ver con los dos anteriores que eran controles dependientes de un campo al que se le asignaba un valor de una lista.

Para la creación de estos “Cuadro Combinados de búsqueda” partimos de un formulario base de obrero con todos sus campos como el siguiente:

Sobre este formulario añadimos un cuadro combinado con las siguientes características:

Donde hemos escogido la opción de búsqueda.

Seleccionamos los campos nif y nombre. Nos muestra de todas formas un linea por cada uno de los registros de nuestra tabla de obreros.

Mostramos los dos campos tras desmarcar la casilla “Ocultar la columna clave (se recomienda)”.

Por último, fijamos la etiqueta con el valor “Búsqueda” y podemos realizar saltos o búsquedas utilizando nuestro cuadro combinado:

Como hemos comentado anteriormente este control “Cuadro Combinado” es independiente y no se encuentra asociado a ningún campo. Se esta utilizando como elemento de busqué rápida de registro en una base de datos. Como podemos observar en las propiedades de datos de este control:

6.- Manejo de Controles de Radio Botón y Check-box.Comenzamos con la siguiente tabla de ejemplo de alumnos:

El campo nAlmSex de tipo Byte con los valores (1: Hombre, 2: mujer, 3: otros) lo vamos a definir como un conjunto de Radio/botones. Los campos bAlmBec (beca) y bAlmBch (bachillerato) son dos campos de tipo booleano (Si/No) que vamos a manejar con un Check-box.

Comenzamos construyendo un formulario por defecto sobre la tabla formulario hasta llegar al siguiente diseño:

Sobre este diseño que automáticamente ha introducido los check-box eliminamos el campo nAlmSex y utilizando el icono:

Correspondiente al asistente para controles y el icono:

Que representa al grupo de opciones que vamos a asociar al botón comenzamos la creación de nuestro grupo de botones asignados al campo nAlmSex según podemos observar en las siguientes ventanas:

Hasta obtener el siguiente diseño:

El nuevo Control que hemos utilizado:

Es un objeto contenedor de otros controles, en este caso agrupaciones de Radio/botones o de elementos del mismo tipo asociados a un único campo. Como podemos observar en las propiedades de dicho control contenedor:

Los radio botones presentan las siguientes propiedades:

El único problema que se presenta a la hora de manejar estos elementos es el problema de insertar el Radio/Botón dentro del Grupo de Opciones. Recomendamos utilizar el asistente o cortar/pegar el botón dentro del área definida en el Grupo de Opciones. Puede ocurrir que es Radio-Botón este encima del Grupo de opciones pero que no este asociado a este. El hecho de que se seleccionen y se muevan en grupo es sinónimo de agrupación.

7.- Manejo de formularios Maestro/Detalle.

Vamos a construir un formulario Maestro/detalle que muestre por cada Obrero su horas trabajadas. Establecemos la relación entre la tabla Obrero y GstPrs. Comenzamos creando un formulario normal sobre la tabla Obrero y reagrupamos los campos hasta llegar al siguiente diseño:

Una vez obtenido el diseño básico insertamos un subformulario y utilizando el asistente asignamos los siguiente valores:

Llegando tras pasar el último formulario al siguiente diseño:

Una vez obtenido este diseño es preciso cambiar el modo de presentación del subformulario en la propiedad “Vista predeterminada” al formato “Formularios continuos” . Comos se puede observar en la siguiente figura:

En este formato se presentan varios registros en la misma área. Para que el diseño tenga aspecto de tabla es preciso alargar el tamaño de este, poner los campos horizontalmente y fijar las etiquetas en el encabezado del formulario hasta obtener el siguiente diseño:

Como se puede observar en la figura anterior se han expandido ligeramente en “Encabezado” y el “Pie” de formulario. El siguiente paso es añadir un campo Importe, que corresponde con un importe parcial por linea de los campos “nCtgImp” por “nGstPrsHrs”, cuyas propiedades son:

Fijamos la etiqueta “Importe” y obtenemos el siguiente diseño en “Vista-Formulario”:

Llegado a este punto nos puede ser interesante saber cuantas horas ha realizado cada uno de los obreros, o calcular el importe total de las horas realizadas por cada uno de los obreros que estamos consultando. Para esto es preciso incluir los campos con funciones agregado:

• sum(nGstPrsHor) para total de horas.• Sum(nGstPrsHor * nCtgImp) para calcular el importe total por obrero.

En Access se introducen dichos campos en el pie del sub-formulario y se sustituye la función “sum” por su termino en castellano “suma”. Según las siguientes propiedades:

Llegando al siguiente diseño final en Vista-Formulario:

8.- Creación de Aplicación de arranque.Una vez que hemos construido nuestro menús, barras de herramientas y demás elementos es

preciso construir una aplicación que nos arranque por un formulario y a partir de este se acceda a los demás elementos de Access. Accedemos al menú de “Herramientas” opción “Inicio”:

Donde configuramos adecuadamente la siguiente ventana:

Podemos fijar un “Titulo de la aplicación” o nombre y es obligatorio para que podamos comenzar a trabajar el fijar o “Mostrar formulario/pagina” que nos arrancaría nuestra aplicación por este formulario.

Recomendamos la creación de una “Barra de menús” y una “Barra de menú contextual” personalizada para nuestra aplicación.

Una vez realizada esta simple tarea de forma automática se abriría nuestro formulario al acceder al fichero .mdb de la base de datos Access. Para que su funcionamiento parezca lo más natural posible es necesario ajustar las barras de herramientas y menús que se muestran en Access para que sólo salgan aquellos que nos convengan.

Podemos proteger nuestra aplicación al igual que nuestra base de datos en Access utilizando contraseñas. Para ello, antes de preparar nuestra aplicación de inicio accedemos a la opción “Herramientas-Seguridad-Establecer contraseña para la base de datos”:

Donde fijamos nuestra contraseña de acceso a la base de datos :

Cada vez que iniciamos Access, aparece una ventana de presentación, un mapa de bits que anuncia el nombre y el número de versión de Access. En nuestras aplicaciones, nos interesará sustituir esta pantalla por nuestra pantalla de presentación, de forma que al abrir la aplicación se muestre una pantalla con el nombre de la aplicación personalizada a nuestro gusto.

Para reemplazar la pantalla de presentación estándar, todo lo que tendremos que hacer será colocar una imagen de mapa de bits (.bmp) en la misma carpeta donde está el archivo de base de datos de nuestra aplicación (.mdb) y asignarle el mismo nombre del archivo de base de datos. Para crear dicha pantalla, podemos utilizar la aplicación Paint de Windows o cualquier otra aplicación que cree archivos de mapas de bits.

PREPARACIÓN PARA DISTRIBUIR LA APLICACIÓN A LOS USUARIOS

Nuestra aplicación está lista para su uso sólo nos falta ponerla a disposición de los usuarios. En el caso más simple, bastará con copiar el archivo de la aplicación al sistema de los usuarios o a una máquina de red a la que puedan acceder. No obstante, antes de sacarla al dominio público, conviene pensar en cómo la distribuiremos y mantendremos. ¿Cómo haremos para distribuir las actualizaciones? ¿Cómo podrán los usuarios crear copias de seguridad y compactar la base de datos? ¿Necesitamos algún archivo adicional

para distribuir la aplicación?

Si nuestra aplicación está diseñada para ser utilizada por muchos usuarios o sobre una red, o si es demasiado grande, estas preguntas serán importantes a la hora de distribuirla. Aquí van algunas ideas para la perfecta distribución y el mantenimiento de una aplicación de Access.

Divida la aplicación en dos archivos de base de datos. Por omisión, todos los datos y objetos de una aplicación se guardan en un único archivo de base

de datos. Este archivo puede llegar a ser demasiado grande y difícil de manejar. En aplicaciones muy grandes, conviene tener un archivo de Access para las consultas, formularios y demás objetos que consiguen que la aplicación funcione, y otro archivo para las tablas. El archivo principal de la

aplicación suele denominarse base de datos de cliente (front-end), porque es lo que los usuarios abren y utilizan; el archivo de datos que contiene las tablas suele recibir el nombre de base de datos de servidor (back-end).

Coloque su aplicación o el archivo de datos en una unidad de red.

Access es un sistema de bases de datos multiusuario, lo que significa que más de un usuario puede ver y cambiar datos en la misma base de datos simultáneamente. Para que su aplicación esté disponible para varios usuarios, bastará con colocarla en una unidad de red. Si ha dividido la aplicación en dos archivos de base de datos, sólo será necesario colocar en la red el archivo que contiene las tablas, proporcionando a cada usuario una copia el archivo de la aplicación -lo que conseguirá que la aplicación funcione más rápido.

Cree accesos directos de Windows para ejecutar su aplicación o para realizar otras tareas.

En Windows, puede crear iconos de acceso directo para facilitar la ejecución de la aplicación, especialmente si se encuentra en una red o en una carpeta con muchos otros archivos. También puede crear otros accesos directos para los usuarios -por ejemplo, podría crear uno para comprimir la base de datos o para crear una copia de seguridad. Si desea información sobre cómo crear accesos directos, consulte su documentación de

Windows o busque en la ayuda el tema «accesos directos».

Asegúrese de que los usuarios tienen todos los archivos que necesitan.

Prácticamente todo lo que necesita una aplicación está incluido en el archivo de base de datos o instalado con Access. Si su aplicación utiliza más de un archivo, asegúrese de distribuir a los usuarios todos los archivos necesarios. Por ejemplo, si divide su aplicación en dos archivos, los usuarios deberán tener acceso a ambos. Si su aplicación incluye una pantalla de presentación o algún otro archivo externo, todos ellos deberán estar a disposición de los usuarios. Por último, si su aplicación utiliza características especiales de Access, como controladores de acceso a datos o controles personalizados, los usuarios deberán tener instaladas esas características en Access.

9.- Objetos de Access.

Los objetos de Access son todos los elementos que podemos definir en Access desde un “botón” hasta un formulario. Hemos utilizado un objeto genérico en nuestras practicas de programación exactamente el objeto “doCmd” este objeto dispone de propiedades (valores) y métodos (funciones que hacen cosas) y dentro de él podemos acceder a otros sub-objetos que contiene. El “Examinador de Objetos” es una herramienta que muestra de forma jerarquizada todos los objetos o elementos disponibles en nuestra base de datos. Esta herramienta muestra los objetos que hemos ido creando como nuestros formularios y los objetos genéricos del sistema. Para acceder al “Examinado de Objetos” pulsamos la tecla “F” desde el Visualizador de código Visual Basic. Apareciendo la siguiente ventana:

Los objetos generales que se muestran son:

• Access La biblioteca de objetos Access contiene los objetos, métodos y constantes que utilizamos para controlar la interfaz de usuario de nuestra aplicación, como formularios, informes y controles. Esta biblioteca incluye además el objeto DoCmd y sus métodos.

• ADODB La biblioteca de Objetos de Datos ActiveX de Microsoft (ADO) contiene los objetos, métodos y constantes que utilizamos para trabajar directamente con archivos de base

de datos, así como los datos guardados en las mismas• Obra2: Nuestra aplicación es también una biblioteca de objetos. Contiene los

formularios, informes y módulos de la base de datos, junto con sus controles, propiedades y cualquier procedimiento que contengan. Visual Basic controla los objetos de nuestra aplicación exactamente igual que el resto de sus objetos incorporados, por lo que podremos hacer referencia a ellos en el código utilizando una función.

• VBA La biblioteca de objetos Visual Basic para Aplicaciones (VBA) contiene todas las funciones y constantes de Visual Basic que hemos visto, como, por ejemplo, la función MsgBox. El uso del Examinador de objetos nos permite explorar cada una de estas bibliotecas de objetos. En este capítulo aprenderemos a trabajar con algunos de los objetos más importantes de las bibliotecas Access y ADODB; la mayoría de estas técnicas serán aplicables también a otros tipos de objetos.

Pase al modelo de objetos de Access

Antes de continuar es preciso indicar que existen los siguientes elementos:• Objetos: objetos que existen y hacen cosas. Por ejemplo, un formulario.• Colecciones: terminan en con la letra “s”. Y son un conjunto de objetos del mismo tipo.

Por ejemplo, la colección “Forms” agrupa a todos los formularios de nuestra base de datos.• Método: es una función dependiente de un objeto. Cuando ejecuto un método el objeto

hace algo.• Propiedades: es un valor que almacena el objeto. Muchas veces son propiedades puras

del objeto como un color de fondo. Si cambio el valor de la propiedad color de fondo de un formulario cambio el color de fondo de dicho formulario.

• Eventos: un evento es algo que ocurre. La mayoría de los objetos gráficos presenta una posible respuesta cuando ocurre o pasa algo sobre ellos, por ejemplo cuando se pulsa un ratón sobre ellos. En este caso lo que nos interesa es la acción o código asociado a la respuesta a dicho evento sobre el objeto.

El Examinador de objetos proporciona un modo sencillo de acceder al contenido de una aplicación que incluye muchos módulos y procedimientos. Sin embargo, es probable que nos resulte más útil para explorar los modelos de objetos Access, DA0 y VBA, dado su gran tamaño.

1. En el cuadro combinado Proyecto/Biblioteca, seleccione Access. El Examinador de objetos mostrará las clases de objetos pertenecientes a Access. La entrada «<globales>», que está seleccionada por omisión, es un buen lugar para empezar. La mayoría de los miembros de este grupo son constantes, algunas de las cuales ya las hemos utilizado en los capítulos anteriores para especificar argumentos en el código. Sin embargo,si desplaza la lista hacia abajo, cerca del final empezará a encontrar métodos, como RunCommand y SetOption, y propiedades, como MenuBar y Visible.

2. Desplace la lista Clases y seleccione DoCmd. Esta parte de la lista Clases contiene objetos de Access que nos resultan más familiares. Aquí encontramos objetos como ComboBox, Command-Button y Form, que ya hemos utilizado varias veces. Al seleccionar DoCmd, en la lista Miembros se muestran todos los métodos de este objeto, muchos de los cuales ya los hemos visto en capítulos anteriores.

3. Seleccione Close en la lista Miembros.DataAccessPage Métodos del objeto DoCmd Igual que cuando visualizamos los elementos de la aplicación Seguimiento de problemas, en el panel inferior del Examinador de objetos se muestra información sobre el elemento seleccionado. En este caso, el Examinador de objetos muestra los argumentos que se pueden utilizar con el método Close.

A continuación, echaremos un vistazo a la clase Form, una de las más importantes en la jerarquía de Access. Después pasaremos directamente del Examinador de objetos a la ayuda interactiva sobre el objeto que estemos viendo.

1. En el cuadro de lista Clases, seleccione Form.La lista Miembros de la derecha mostrará las propiedades y los eventos que pertenecen a los formularios reconocerá el evento AfterUpdate y la propiedad AllowEdits, entre otros. Si recorremos la lista, podremos ver algunos de los métodos que hemos utilizado en las lecciones anteriores, como GoToPage, Refresh y Requery.

2. En la lista Miembros, seleccione Controls.Controls es el nombre de una colección de objetos. Cada formulario tiene su colección, y contiene -lo adivinó- los controles incluidos en dicho formulario. El botón Ayuda que aparece en la parte superior de la ventana (el que tiene el signo de interrogación) nos proporciona una sencilla forma de acceder a la ayuda interactiva sobre el elemento seleccionado. Para los objetos de Access, como podrá ver, el uso de la ayuda interactiva es una delas mejores formas de explorar el modelo de objetos.

3. Pulse el botón Ayuda en el Examinador de objetos. El tema de ayuda sobre la colección Controls aparecerá en una ventana aparte. Esta ayuda nos proporciona una gran cantidad de información sobre cómo utilizar la colección y permite acceder a un ejemplo de código Visual Basic. El tema muestra también una representación gráfica de la porción del modelo de objeto a la que pertenece la colección, que podremos utilizar para recorrer otros temas de ayuda. Tal como muestra el gráfico del modelo de objeto, el objeto Application se encuentra en lo más alto de la jerarquía y un poco más abajo se encuentra la colección Controls, que a su vez contiene objetos Control individuales. El cuadro Múltiple Objects (Múltiples objetos) indica que son muchos los objetos que tienen una colección Controls.

4. Cierre la ventana de ayuda.5. En el Examinador de objetos, pulse el botón Cerrar.

REFERENCIA A OBJETOS Y COLECCIONESEn las lecciones anteriores hemos utilizado bastantes objetos -y hemos aprendido a referirnos a

ellos en nuestro código. Por ejemplo, para hacer referencia al formulario Obrero, utilizamos la expresión Forms!Obrero, y para nombrar al control cObrNif de ese formulario utilizamos la expresión Forms!Obrero!cObrNif. De hecho, la mayoría de las referencias a objetos que utilizaremos en el código serán tan simples como éstas. Aún así, como las utilizaremos con mucha frecuencia, conviene entender de forma más completa cómo funcionan las referencias a objetos. Como veremos más adelante en esta capítulo, no todas las expresiones que incluyen objetos son tan sencillas como las que hemos visto hasta ahora. Cuando hacemos referencia a los objetos de una colección, como la colección Forms, podemos utilizar distintos modos de referencia alternativos. Una forma de referenciar objetos es mediante números. Los objetos de una colección están numerados consecutivamente empezando desde cero, por lo que podemos hacer referencia a un objeto utilizando su número entre paréntesis. Por ejemplo, el primer objeto de formulario de la colección Forms es Forms(O), el segundo es Forms(1) y así sucesivamente. Pero hay más formas de referenciar un miembro de una colección -por nombre, o utilizando el operador signo de exclamación (!). Cada uno de estos métodos sigue reglas ligeramente diferentes. En lugar de hablar sobre ellas, quizá sería mejor probar estos tipos de referencias para entender cómo funcionan. En esta sección, probaremos varios tipos de referencias a objetos utilizando la ventana Inmediato.

10.- Formularios de consulta.Como hemos visto anteriormente es posible acceder desde un formulario Access a los objetos

de otros formularios Access. Este tipo de procesos es muy útil para consultar datos seleccionar un cliente o articulo y pasarlo a una factura. Estos procesos se facilitan por el sistema de funcionamiento de Access (Librerías DAO y ADO) que aunque se muestren varios registros en un formulario únicamente uno se encuentra activo y sobre este se modifican los valores y se realizan las operaciones.

Como ejemplo vamos a crear un formulario básico de tipo “En columnas” sobre la tabla “GstPrs” utilizando el asistente para formularios obteniendo un diseño básico como el siguiente:

El objetivo es añadir un botón que abra un formulario sobre la tabla Obrero seleccione un registro y me devuelva el nif del obrero que he seleccionada al campo cObrNif de la tabla “GstPrs”. Antes de seguir trabajando vamos a construir el formulario frmcnsObrero de tipo “Tabular sobre la tabla obrero, más o menos con el siguiente formato:

Llegado a este punto tenemos un formulario principal que hemos denominado GstPrs y un formulario de consulta que hemos llamado frmCnsObrero. Una vez que tenemos estos dos formularios volvemos al diseños del formulario GstPrs y vamos a insertar el botón “cmdSlcObr” al pulsar este botón abrimos el formulario “frmCnsObrero”. Para abrir el formulario vamos a utilizar una macro asociada al evento clic del botón denominada mObrero con la siguiente estructura:

El código asociado a la macro escoge la acción “AbrirFormulario” seleccionamos el formulario “frmCnsObrero” y fijamos el “Modo de datos” a “Sólo lectura” para que no podamos modificar los datos de la tabla “Obrero” desde esta consulta. Una vez construida la macro probamos el funcionamiento de nuestro nuevo botón desde el formulario “GstPrs” y observamos que podemos cambiar de la ventana maestra “GstPrs” a la de consulta sin problemas:

Una vez probado el funcionamiento del botón es preciso volver al diseño de la ventana “frmCnsObrero” donde añadimos dos botones “cmdSeleccionar” que modifica el campo “cObrNif” en el formulario “GstPrs” y cierra la ventana y el botón “cmdSalir” que finalizar la ejecución del formulario sin devolver valores.

Las acciones a estos botones las vamos a enlazar en el siguiente código Visual Basic para aplicaciones:

Option Compare Database

Private Sub cmdSalir_Click() DoCmd.CloseEnd Sub

Private Sub cmdSeleccionar_Click() Forms!gstprs!cObrNif.Value = cObrNif.Value DoCmd.CloseEnd Sub

Para mejorar el comportamiento de nuestra ventanas es conveniente poner la propiedad “Modal” del formulario “frmCnsObrero” a “Si”. Una ventana modal pasa a segundo plano desactivandola la ventana que la llamo. En este caso bloque el formulario “GstPrs” hasta que seleccione un obrero o salga de la ventana:

El diseño del formulario “frmCnsObrero” queda:

Para que nuestro sistema funcione correctamente es preciso arrancar primero el formulario “GstPrs” y desde este activar “frmCnsObrero”.

Antes de terminar es preciso comentar el código asociado a la siguiente linea:

Forms!gstprs!cObrNif.Value = cObrNif.Value

Donde:● Forms: todo objeto del sistema que termina en “s” es un colección o conjunto de, en

este caso “Forms” es el conjunto o colección de todos los formularios del sistema. Para indicar un elemento de una colección existen diferentes técnicas una de ellas es el uso de la admiración como separador.

● gstprs: es el nombre del formulario maestro de “gasto de personal”. Un formulario tiene propiedades, métodos y colecciones. En este caso estamos accediendo al usar “!” a la colección por defecto de controles.

● cObrNif: es un control, en este caso un “Cuadro de texto” de la colección de controles del formulario “gstprs”.

● .Value: es una propiedad del cuadro de texto cObrNif que nos permite cambiar y acceder al valor de dicho control.

● cObrNif.Value: de la parte derecha de la igualdad accede al valor del cuadro de texto del formulario actual o activo.

Sobre el diseño del formulario “GstPrs” se pueden realizar muchas mejoras que se proponen como ejercicios en la que cabe destacar:

● Insertar otro formulario de consulta para buscar la obra y la fase.● Cambiar la tabla “GstPrs” por una consulta que contenga todos los campos de esta tabla

más información complementaria interesante como el nombre del Operario.● Construir un menú sobre una aplicación principal que abra el formulario “GstPrs” sólo

para insertar registro o sólo para modificar registros, etc....

11.- Sentencias Condicionales.

Hasta ahora hemos realizado tareas simples en código Visual Basic. Un grupo de sentencias que no hemos visto son las sentencias condicionales que realizan una tarea u otra en función de una condición.

Construimos un nuevo módulo de datos denominado “condicional” y dentro de él vamos a crear la función signo que nos devuelve el texto positivo si es un numero positivo y negativo si es un numero negativo. El cero lo consideramos como positivo.

Option Compare DatabasePublic Function positivo(nPrm1 As Integer) As String If (nPrm1 >= 0) Then positivo = "positivo" Else positivo = "negativo" End IfEnd Function

Y probamos nuestra función en inmediato:

debug.Print positivo(9)positivodebug.Print positivo(0)positivodebug.Print positivo(-9)negativo

Nuestra función tiene un parámetro de tipo entero y devuelve un String. La sentencia condicional if tiene una parte “Then” que se ejecuta cuando la condición es verdadera y una parte negativa “else” que se ejecuta cuando la condición es falsa.

Existe una variante en la cual evalúa una primera condición si es verdadera se hace algo si es falsa sigue evaluando otra condición hasta llegar a una clausula “else” que se hace algo al fin. La clausula “else” es opcional, a veces sólo me interesa hacer algo si se cumple una determinada condición. Como ejemplo, véase positivo2 que escribe positivo, cero o negativo según sea el numero que se pasa como parámetro:

Public Function positivo2(nPrm1 As Integer) As String If (nPrm1 > 0) Then positivo2 = "positivo" ElseIf (nPrm1 = 0) Then positivo2 = "cero"

Else positivo2 = "negativo" End If End Function

Con las siguientes pruebas:

debug.Print positivo2(9)positivodebug.Print positivo2(0)cerodebug.Print positivo2(-9)negativo

Para casos en los cuales se evalúa múltiples condiciones sobre valores por ejemplo para pasar una nota numérica a cadena de caracteres se puede usar la sentencia “select case” con el siguiente formato:

Select Case expresión_prueba[Case lista_expresion-n[instrucciones-n]] ...[Case Else[instrucciones_else]]

End SelectPara ello vamos a construir nuestra función notTxt (nota de tipo texto) con el siguiente código:Public Function notTxt(nPrm1 As Integer) As String Select Case nPrm1 Case 1 To 4 notTxt = "insuficiente" Case 5, 6 notTxt = "suficiente" Case 7 notTxt = "bien" Case 8 notTxt = "notable" Case 9, 10 notTxt = "sobresaliente" Case Else notTxt = "error en la nota" End Select End Function

Donde:● Case 1 to 4: indica que se pueden tomar los valores del 1 hasta el 4.● Case 5,6 : indica dos selecciones de valores. Podemos usar valores sueltos o rangos con

to.● Case else: es verdadero para el resto de los valores.

Podemos observar los resultados de nuestra función en las siguientes pruebas:debug.Print nottxt(3)

insuficientedebug.Print nottxt(11)error en la notadebug.Print nottxt(9)sobresalientedebug.Print nottxt(-3)error en la nota

11.- Sentencias Iterativas.

Las sentencias Iterativas o repetitivas son las que repiten un trozo de código un numero determinado de veces o mientras que se cumpla una condición. Vamos a comenzar con las sentencias que repiten algo. Vamos a empezar con un procedimiento que escribe un numero de veces determinado que se pasa como parámetro la palabra “hola”. Este procedimiento presenta el siguiente código:

Public Sub escHol(nVcs As Integer) Dim nCnt As Integer For nCnt = 1 To nVcs Debug.Print "hola" NextEnd Sub

La sentencia For que es la encargada de repetir presenta la siguiente sintaxis:For contador = principio To fin [Step incremento][instrucciones][Exit For][instrucciones]

Next [contador]

Básicamente la sentencia “for” usa un contador que va tomando los valores desde 1 hasta el nVcs (numero de veces a repetir) y por cada valor y con este ejecuta las sentencias que hay dentro del for. Podemos comprobar el funcionamiento cambiando el código a:

Public Sub escHol2(nVcs As Integer) Dim nCnt As Integer For nCnt = 1 To nVcs Debug.Print nCnt Debug.Print "hola" NextEnd Sub

Cuya ejecución en inmediato queda:run "eschol2", 3 1 hola 2 hola 3

hola

Dentro de la sentencia “for” se puede controlar el salto o paso (step) que es como avanza el contador. Por defecto es 1 aunque podemos avanzar con cualquier numero entero ya sea positivo o negativo. Se recomienda realizar pruebas con avances negativos para comprobar como se coloca el valor inicial y el valor final.

Existe otra sentencia que nos permite repetir un grupo de sentencias mientras que se cumpla una determinada condición. Es la sentencia repetitiva “While” con el siguiente formato:

While condición[intrucciones]

WendLa sentencia “While” se utiliza para recorrer lista de objetos cuyo numero desconocemos y

vamos avanzando hasta que llegamos al final. Es la técnica utilizada para leer un todos los registros de una tabla y procesarlos. Vamos a usar la sentencia “While” para simular el comportamiento de la sentencia “For”, según el siguiente código:

Public Sub escHol4(nVcs As Integer) Dim nCnt As Integer nCnt = 1 While (nCnt <= nVcs) Debug.Print "hola" nCnt = nCnt + 1 WendEnd Sub

Para la emulación de la sentencia “for” es preciso las siguientes actuaciones:● ncnt = 1: es preciso inicializar el contador al valor inicial del for.● (nCnt <= nVcs): esta ejecutando mientras sea menor o igual que el valor final. Esta

condición tiene esta forma cuando el incremento es positivo.● Ncnt = nCnt +1: es preciso incrementar el contador dentro del “while” para que valla

avanzando el valor al siguiente según el paso o “step”.

Existe otra sentencia más completa y compleja que “While” que es la sentencia “Loop” que presenta los siguientes formatos:

Do [{While | Until} condición][instrucciones][Exit Do][instrucciones]

LoopO bien, puede utilizar esta sintaxis:

Do[instrucciones][Exit Do][instrucciones]

Loop [{While | Until} condición]

Donde:● Exit do: nos permite terminar el bucle en el momento que queramos.● Until: esta ejecutando el bucle mientras la condición sea falsa o dicho de otra forma

hasta que sea falsa.

La diferencia entre el primer y segundo formato radica que en el segundo formato primero ejecuta el código y luego comprueba la condición para la siguiente ejecución. En el primer formato al igual que el “While” primero comprueba la condición y se falla no hace nada. El segundo formato garantiza siempre al menos una ejecución del código.

Para repasar los bucles anteriores vamos a realizar varios formatos de la función sumatorio. La función sumatorio devuelve la suma de los números comprendidos desde 1 hasta el numero que le queremos calcular el sumatorio.

Public Function sumatorio1(nPrm1 As Integer) As IntegerDim nCnt As Integersumatorio1 = 0For nCnt = 1 To nPrm1 sumatorio1 = sumatorio1 + nCntNextEnd Function

Public Function sumatorio2(nPrm1 As Integer) As IntegerDim nCnt As Integersumatorio2 = 0nCnt = 1While (nCnt <= nPrm1) sumatorio2 = sumatorio2 + nCnt nCnt = nCnt + 1WendEnd Function

Public Function sumatorio3(nPrm1 As Integer) As IntegerDim nCnt As Integersumatorio3 = 0nCnt = 1Do While (nCnt <= nPrm1) sumatorio3 = sumatorio3 + nCnt nCnt = nCnt + 1LoopEnd Function

Public Function sumatorio4(nPrm1 As Integer) As IntegerDim nCnt As Integersumatorio4 = 0nCnt = 0Do sumatorio4 = sumatorio4 + nCnt nCnt = nCnt + 1Loop While (nCnt <= nPrm1)End Function

Podemos observar las siguientes pruebas con inmediato:debug.Print sumatorio1(3) 6

debug.Print sumatorio2(3) 6 debug.Print sumatorio3(3) 6 debug.Print sumatorio4(3) 6 Como podemos observar las tres primeras versiones son idénticas y lo único que realizo es un

ajuste de setencia “For” mediante “while” según hemos visto anteriormente. El formato más raro es el de sumatorio4 que comienzo el contador por 0. Esto es para sumar 0 en el caso de que el primer numero fuera un 0. De hecho este último formato ejecuta la suma aunque la condición sea nula, caso a tener en cuenta.

12.- Formulario con Programación.

Los módulos vistos en los apartados anteriores nos valen como librerías o colecciones de procedimientos y funciones que podemos utilizar en cualquier otro objeto Access que nos permita programación. Normalmente trabajaremos con formularios, estos objetos incorporan su propio módulo de programación donde construimos los procedimientos y funciones necesarios para trabajar con ellos.

Cono ejemplo vamos a construir un formulario con dos cuadros de texto y un botón que nos calcule el factorial de numero que hemos introducido previamente en un cuadro de texto. Partimos del siguiente formulario Access construido con “Vista Diseño”:

Los “Cuadro de texto” son “Independientes” esto quiere decir que no se encuentran asociados a ningún campo de una tabla de la base de datos. El objetivo es poner un numero en el primer cuadro de texto y calcular su factorial en el campo resultado. Recordamos que el factorial de un numero positivo es el producto de los números comprendidos entre 1 y ese numero. Se representa por numero!. Por ejemplo:

5! = 1* 2 * 3 * 4 * 5

3! = 1* 2 * 3

Para calcular el factorial vamos a asociar código como respuesta al evento de hacer “clic” sobre el botón “calcular Factorial” . En el siguiente cuadro podemos observar los nombres asignados a los distintos objetos de nuestro formulario:

Por ahora nos interesan los siguientes:● numero: “cuadro de texto” donde se introduce el numero● resultado: “cuadro de texto” donde se muestra el resultado.● CmdClcFct: botón que realiza las operaciones de calculo.

Comenzamos con pulsando el botón derecho del ratón sobre nuestro botón “Calcular factorial” escogiendo la opción “Generar evento” donde escogemos la opción “Generador de código” como podemos observar en la siguiente figura:

Y nos introducimos en el editor de código en un módulo nuevo asociado al formulario con el que estamos trabajando:

Para calcular el factorial de un numero vamos a construir una función privada con el siguiente código:

Option Compare Database

Private Sub cmdClcFct_Click() me.resultado.Value = Factorial(me.numero.Value)End Sub

Private Function Factorial(nmr As Integer) As Integer Dim contador As Integer Factorial = 1 For contador = 2 To nmr Factorial = Factorial * contador NextEnd Function

A la función factorial se le pasa un numero y nos devuelve el factorial del numero multiplicando desde 2 hasta el numero que se pasa como parámetro y en principio realiza el calculo del factorial que

se pasa como parámetro.

El código más interesante es el del procedimiento “ cmdClcFct_Click”, donde:● cmdClcFct_Click: la primera parte corresponde con el nombre del objeto al que se aplica

en este caso “cmdClcFct” que es el botón del formulario y la segunda parte “Click” identifica al evento al cual responde, en este caso al hacer Click con el ratón sobre dicho botón.

● me.resultado.value: “me” ser refiere al formulario, equivale a nuestra expresión “yo mismo”, el formulario mismo tiene el cuadro de texto “resultado” que tiene la propiedad “value” que es la que necesito modificar, a partir del resultado de la función factorial.

● me.numero.Value: con el mismo significado del caso anterior pero como en consulta.

La ventaja que presenta el uso de esta sintaxis separando los objetos con sus propiedades y métodos mediante puntos es que automáticamente se muestran listas de selección donde podemos seleccionar cómodamente la propiedad/método que más nos interese.

Se deja como tarea el construir un formulario que nos calcule el sumatorio de un numero que corresponde con la suma de todos los números comprendidos entre 1 y dicho numero:

∑ 8 = 1+ 2 + 3 +4 + 5+ 6 + 7 + 8

13.- Tipos de datos, operadores y constantes.

Al igual que las base de datos disponen de un conjunto de tipos de datos existen en los lenguajes de programación un conjunto de tipos de datos básicos sobre los que podemos definir variables. La lista de tipos disponibles en Visual Basic es:

Tipo de datos Tamaño de almacenamiento

Intervalo

Byte 1 byte 0 a 255

Boolean 2 bytes True o FalseInteger 2 bytes -32,768 a 32,767

Long(entero largo)

4 bytes -2,147,483,648 a 2,147,483,647

Single(coma flotante/ precisión simple)

4 bytes -3,402823E38 a –1,401298E-45 para valores negativos; 1,401298E-45 a 3,402823E38 para valores positivos

Double(coma flotante/ precisión doble)

8 bytes -1.79769313486231E308 a -4,94065645841247E-324 para valores negativos; 4,94065645841247E-324 a 1,79769313486232E308 para valores positivos

Currency(entero a escala)

8 bytes -922.337.203.685.477,5808 a 922.337.203.685.477,5807

Decimal 14 bytes +/-79.228.162.514.264.337.593.543.950.335 sin punto decimal; +/-7,9228162514264337593543950335 con 28 posiciones a la derecha del signo decimal; el

número más pequeño distinto de cero es +/-0,0000000000000000000000000001

Date 8 bytes 1 de enero de 100 a 31 de diciembre de 9999

Object 4 bytes Cualquier referencia a tipo ObjectString (longitud variable)

10 bytes + longitud de la cadena

Desde 0 a 2.000 millones

String(longitud fija)

Longitud de la cadena Desde 1 a 65.400 aproximadamente

Variant(con números)

16 bytes Cualquier valor numérico hasta el intervalo de un tipo Double

Variant(con caracteres)

22 bytes + longitud de la cadena

El mismo intervalo que para un tipo String de longitud variable

Definido por el usuario (utilizando Type)

Número requerido por los elementos

El intervalo de cada elemento es el mismo que el intervalo de su tipo de datos.

Además de estos tipos se encuentran las matrices y colecciones que no vamos a tratar y los Clases de objetos que se pueden considerar como una evolución de los tipos básicos.

Sobre las variables y constantes se pueden utilizar los siguientes operadores:

Operadores aritméticos^ (operador)

* (operador)

/ (operador)

\ (operador)

Mod (operador)

+ (operador)

- (operador)

Operadores de concatenación& (operador)

+ (operador)

Operadores de comparación:

Operador True si False si Null si< (Menor que) expresión1 <

expresión2expresión1 >= expresión2

expresión1 o expresión2 = Null

<= (Menor o igual que)

expresión1 <= expresión2

expresión1 > expresión2

expresión1 o expresión2 = Null

> (Mayor que) expresión1 > expresión2

expresión1 <= expresión2

expresión1 o expresión2 = Null

>= (Mayor o igual que)

expresión1 >= expresión2

expresión1 < expresión2

expresión1 o expresión2 = Null

= (Igual a) expresión1 = expresión2

expresión1 <> expresión2

expresión1 o expresión2 = Null

<> (Distinto de) expresión1 <> expresión2

expresión1 = expresión2

expresión1 o expresión2 = Null

Operadores lógicosAnd (operador)

Eqv (operador)

Imp (operador)

Not (operador)

Or (operador)

Xor (operador)

Constantes.

Las constantes se pueden ver desde el sistema desde dos puntos de vista desde un conjunto de valores del sistema que almacenan valores constantes como por ejemplo el numero pi o como la posibilidad de poder introducir un valor de tipo fecha, string o numérico que conozco, como por ejemplo mi edad o la fecha de nacimiento.

Las constantes numéricas utilizan la matemática clásica para su representación su representación. Las constantes de tipo string utilizan las “” comillas a diferencia y por compatibilidad con SQL que utiliza las comillas simples ''. Las constantes de tipo fecha utilizan como separador el símbolo sostenido o almohadilla #01-01-2008#.

14.- Funciones de Visual Basic.

Al igual que SQL-Server y Access Visual Basic dispone de un conjunto de funciones del sistema. Esta funciones que devuelven datos de un determinado tipo se utilizan normalmente para implementar operaciones matemáticas, tratamiento de cadenas de caracteres, manejo de fechas y conversión de tipos de datos.

Funciones matemáticas:● Abs (Función): valor absoluto.

● Atn (Función): arco tangente

● Cos (Función): Coseno.

● Exp (Función): Exponencial.

● Fix (Función): devuelve la parte entera de un numero decimal.

● Int (Función): convierte un numero decimal a entero, devuelve el primer numero entero menor o igual al valor decimal.

● Log (Función): calcula el logaritmo neperiano.

● Rnd (Función): Devuelve un tipo Single que contiene un número aleatorio.

● Sgn (Función): devuelve el signo del numero.

● Sin (Función): función seno.

● Sqr (Función): calcula la raíz cuadrada de un numero.

● Tan (Función): calcula la tangente.

Funciones de cadena de caracteres o de tipo String.

En Visual Basic existe un gran numero de funciones de tipo String el formato y significado es muy parecido al que hemos vistos en otros entornos como SQL Server. Entre la listas de funciones vamos destacar:

● len: devuelve la longitud de una cadena.● InStr: devuelve la posición de una cadena en otra.● String: repite un carácter un numero determinado de veces.● Trim, rtrim, ltrim: que eliminan espacios por ambos lados, por la derecha y por la

izquierda.● Left, rigth: que devuelve trozos de una cadena por la izquierda o por la derecha.● Space: devuelve una cadena formada por espacios en blanco.

Dentro de las funciones de tipo fecha podemos describir las siguientes:● date: devuelve la fecha del sistema.● Day, month, year, weakday: devuelve el día del mes, mes, año y día de la semana de una

fecha.● Now: devuelve la fecha/hora del sistema.● Dateadd: añade periodos a una fecha.● Datediff: devuelve el numero de periodos entre dos fecha.● datepart: devuelve una parte de una fecha, año, mes, etc...

Funciones de conversión son aquellas que nos permiten realizar una conversión entre los distintos tipos de datos:

● Cbool(expresión)

● Cbyte(expresión)

● Ccur(expresión)

● Cdate(expresión)

● Cdbl(expresión)

● Cdec(expresión)

● Cint(expresión)

● Clng(expresión)

● Csng(expresión)

● Cstr(expresión)

● CVar(expresión)

15.- Inicio a la Programación en la Librería ADO.Tanto Visual Basic VI, Visual Studio Net y Access permiten acceder a librerías (conjunto de

procedimientos, funciones, objetos y contantes) de acceso a Base de Datos. Una de las últimas librerías implementada en estos entornos son la librerías ADO en sus distintas versiones.

Las librerías ADO se manejan desde código y es preciso definir todos los elementos que corresponde con una conexión a una Base de Datos. Las libererías ADO presentan la siguiente estructura de objetos:

Vamos a comenzar con un ejemplo de un procedimiento que lista todos los código de obra de la tabla obra en la base de datos Obra2. Accedemos de forma directa desde la base de datos actual a una tabla de otra base de datos. El código sería el siguiente:

Public Sub lstAtb() Dim cncObr As New ADODB.Connection Dim rcsObr As New ADODB.Recordset cncObr.Provider = "Microsoft.Jet.OLEDB.4.0" cncObr.Open "D:\Curso07-08\BaseDatos\tema6\obra2.mdb" rcsObr.Open "select * from obra", cncObr While Not rcsObr.EOF Debug.Print rcsObr!cobrcdg rcsObr.MoveNext Wend End Sub

Donde:● cncObr: es el objeto conexión que me dice a que base de datos me conecto.● rcsObr: es el objeto recordset que engacho a una sentencia select de una tabla de la base

de datos.● cncObr.Provider: es el proveedor o tipo de conexión, en este caso corresponde con la

conexión a una base de datos Access.● rcsObr.open: se le indica la orden “select” y la conexión.● rcsObr!cobrcdg: se usa “!” para acceder a un campo.

● rcsObr.MoveNext: pasa al siguiente registro.● rcsObr.EOF: toma el valor verdadero si he llegado al final.

Para cambiar de una base de datos a otra, incluso para acceder a SQL Server basta con cambiar el proveedor. En el siguiente ejemplo se accede a la base de datos “cooperativa” de aceitunas accedida mediante un ODBC denominado “almazara”:

Public Sub lstAtb2() Dim cncAlm As New ADODB.Connection Dim rcsSoc As New ADODB.Recordset

cncAlm.Open "dsn=almazara;uid=sa" rcsSoc.Open "select * from socio", cncAlm While Not rcsSoc.EOF Debug.Print rcsSoc!csocnif rcsObr.MoveNext Wend End Sub

Podemos buscar el proveedor exacto para SQL Server según nuestra maquina y las versiones del Servidor pero la conexión anterior nos vale para cualquier conexión realizada mediante ODBC.

16.- El objeto Conexión.

El objetivo de la conexión en la estructura de Objetos de la librería ADO es realizar la conexión a una determinada base de datos. Una vez realizada la conexión se utiliza este objeto como parámetro en los métodos de apertura de los otros objetos. El objeto Conexión presenta la siguiente estructura:

La colección “Errors” es fundamental porque en ella se almacenarán los errores que se produzcan en los otros objetos ADO. Por ejemplo, si se produce una duplicidad de claves es preciso acceder a la conexión y desde ella recorrer la colección de “Errors” para poder determinar el error que se ha producido. La colección “Properties” es una colección genérica de los objetos ADO que almacena propiedades generales de cada objeto en particular.

Los métodos más importante son .Openconnection.Open ConnectionString, UserID, Password, Optionsy el método .Close que cierra o finaliza la conexión liberando los recursos que se han utilizado

en esta.

17.- El Objeto Recordset.

El Objeto Recordset es el más importante dentro del conjunto de objetos ADO ya que permite

realizar operaciones de leer, modificar, añadir y borrar registros de las tablas de las base de datos. Los objetos Recorset presentan la siguiente estructura:

La colección “Fields” se refiere a los campos o atributos de la tabla o sentencia “Select” sobre el que se monta el “RecordSet” o conjunto de datos. Como hemos visto anteriormente, podemos utilizar el separador “!” para acceder de una forma más cómoda a los campos de la tabla.

En principio podemos utilizar un tabla, una vista o una sentencia Select. La posibilidad de modificar, borrar e insertar valores al igual que con las vistas dependerá de la sentencia Select en si, al comportarse como una vista temporal de la base de datos a la que estamos conectados.

Una vez enlazado como hemos visto anteriormente presenta la siguiente lista de métodos:● AddNew: añade un nuevo registro en blanco, se rellena y se salva con update.

● Clone: obtiene un recordset clon al primero.

● Close; cierra el recordset y libera los recursos.

● Delete: borra el registro actual.

● Find: realiza búsquedas dentro de los registros del recordset.

● Move: se mueve dentro del recordset:

● MoveFirst, MoveLast, MoveNext, MovePrevious: métodos de avance de registros.

● Open: método de apertura.

● Requery: refresca el recordset.

● Update: nos permite actualizar los campos de un registro. Primero modificamos los campos y luego Update modifica el registro. Es preciso usarlo con AddNew.

Es conveniente manejar las siguientes propiedades de los objetos RecordSet:

● Eof: que es verdadero cuando se detecta el final.

● Bof: que es verdadero cuando se encuentra al principio.

De hecho es como si existieran dos registros vacíos uno al principio y otro al final del RecordSet, de tal forma que al llegar a ellos estas funciones toman el valor verdadero. Si intentamos forzar el avance más allá de estos registros se produce un error.

Como ejercicio se propone construir un formulario que recorra un recordset con botones de anterior, siguiente, etc... mostrando los datos de los registros de este recordset sobre cuadros de texto.

Como ejercicio complementario al primero introducir inserciones y modificaciones de registros.

18.- El Objeto “Command”.

El objeto “Command” que presenta la siguiente estructura de objetos dentro de la jerarquía ADO:

Este objeto nos permite ejecutar en bruto cualquier sentencia SQL sobre la base de datos a la cual nos conectamos.

Public Sub InsSoc()

Dim cncAlm As New ADODB.Connection

Dim cmdSoc As New ADODB.Command

Dim Sentencia As String

cncAlm.Open "dsn=almazara;uid=sa"

Set cmdSoc.ActiveConnection = cncAlm

Sentencia = "Insert into socio values ('1111', 'nombre1111', 'calle111', 'pueblo111', 'cnt111');"

cmdSoc.CommandText = Sentencia

cmdSoc.CommandType = adCmdText

cmdSoc.Execute

End Sub

El funcionamiento es semejante al Recordset creamos la conexión, con la propiedad ActiveConnection le decimos a que conexión pertenece, CommandText almacena la sentencia SQL en bruto, CommandType orienta sobre el tipo de sentencia y por último el método Exeute ejecuta la sentencia SQL.

Recomendamos realizar los siguientes formularios de ejemplo:

● Formulario que no introduzca un socio cuyos valores se recogen desde cuadro de texto.

● Formulario que nos permita borrar un socio cuyo NIF se introduce desde un cuadro de texto.

19.- El tratamiento de los Errores en ADO.

El tratamiento de los Errores en los objetos ADO es un caso particular y ampliado del tratamiento de errores de carácter general que implementa Visual Basic.

Comenzaremos con procedimiento donde vamos a provocar un error grave, por ejemplo una división por cero.

Public Sub error1()

Dim numero As Integer

On Error GoTo tratamiento

numero = 3 / 0

Debug.Print "Error tratado"

Exit Sub

tratamiento:

Debug.Print "tratamiento del error"

Resume Next

End Sub

Donde:

● On Error goto tratamiento: nos indica que cuando se produzca un error salte a la parte del procedimiento etiquetada como tratamiento:

● exit sub: finaliza la ejecución del procedimiento. Esto se introduce para que no se ejecute la rutina de tratamiento de errores cuando estos no se producen.

● “Tratamiento:” : es la definición de una etiqueta o punto de salto.

● Resume Next: hace que una vez tratado el error, pase a la sentencia siguiente que los produjo. Esta sentencia tiene tres formatos:

● resume: repite la sentencia que ha producido el error

● resume next: salta a la siguiente.

● Resume etiqueta: salta a la etiqueta que hemos introducido.

En el ejemplo anterior sólo hemos detectado el error y no hemos realizado nada sobre él. Existe un objeto denominado “Err” de carácter genérico que me da información sobre el error que se ha producido y sobre este numero podemos realizar diversas acciones según el erro que se haya producido. Como en el siguiente código de error1, modificado:

Public Sub error1()

Dim numero As Integer

On Error GoTo tratamiento

numero = 3 / 0

Debug.Print "Error tratado"

Exit Sub

tratamiento:

Debug.Print "tratamiento del error"

Debug.Print Err.Number

Debug.Print Err.Description

Resume Next

End Sub

Ejecutando el procedimiento desde la ventana de inmediato:

run "error1"

tratamiento del error

11

División por cero

Error tratado

Del objeto “Err” interesa:

● Err.Number: que devuelve un código o numero de error. Es preciso consultar la documentación de Visual Basic para identificar el código.

● Err.Description: es una propiedad que me devuelve una breve descripción del código de error que se ha producido.

● Err.raise: es un método que envia el error a otro procedimiento de nivel superior. Normalmente cuando tratamos un error Visual Basic supone que los hemos subsanado, sin no lo conseguimos utilizamos el método “Err.Raise” para elevar el error al objeto que llamo al elemento actual.

Vamos aplicar el tratamiento de errores a los objetos ADO, practicaremos sobre el procedimiento “InsSoc” del ejemplo anterior y buscamos provocar errores por la duplicidad del nif del socio como clave principal al ejecutar varias veces el mismo procedimiento.

Public Sub InsSoc()

Dim cncAlm As New ADODB.Connection

Dim cmdSoc As New ADODB.Command

Dim Sentencia As String

On Error GoTo tratamiento

cncAlm.Open "dsn=almazara;uid=sa"

Set cmdSoc.ActiveConnection = cncAlm

Sentencia = "Insert into socio values ('1111', 'nombre1111', 'calle111', 'pueblo111', 'cnt111');"

cmdSoc.CommandText = Sentencia

cmdSoc.CommandType = adCmdText

cmdSoc.Execute

Exit Sub

tratamiento:

Debug.Print "tratamiento del error"

Debug.Print Err.Number

Debug.Print Err.Description

Resume Next

End Sub

En la ventana de inmediato termina apareciendo la siguiente información sobre el error:

run "InsSoc"

tratamiento del error

-2147217900

[Microsoft][ODBC SQL Server Driver][SQL Server]Infracción de la restricción PRIMARY KEY 'PK_socio'. No se puede insertar una clave duplicada en el objeto 'socio'.

El numero de error es poco significado pero la descripción si se asemeja al error que se ha producido. En nuestro caso es posible acceder a más información sobre los errores producidos al recorrer la colección de errores dependiente de la conexión ADO, como podemos comprobar en el siguiente código InsSoc:

Public Sub InsSoc()

Dim cncAlm As New ADODB.Connection

Dim cmdSoc As New ADODB.Command

Dim Sentencia As String

Dim miError As ADODB.Error

On Error GoTo tratamiento

cncAlm.Open "dsn=almazara;uid=sa"

Set cmdSoc.ActiveConnection = cncAlm

Sentencia = "Insert into socio values ('1111', 'nombre1111', 'calle111', 'pueblo111', 'cnt111');"

cmdSoc.CommandText = Sentencia

cmdSoc.CommandType = adCmdText

cmdSoc.Execute

Exit Sub

tratamiento:

Debug.Print "tratamiento del error"

Debug.Print Err.Number

Debug.Print Err.Description

For Each miError In cncAlm.Errors

Debug.Print miError.Number

Debug.Print miError.Description

Debug.Print miError.NativeError

Next

Resume Next

End Sub

Los errores producidos en los objetos ADO se almacenan en forma de Colección o conjunto de elementos de un tipo. El bucle “For Each” es que se utiliza para recorrer todos los elementos de una

colección de una forma cómoda. Microsoft SQL Server produce dos errores ADO como podemos observar en los valores devueltos por la ventana de inmediato:

run "InsSoc"

tratamiento del error

-2147217900

[Microsoft][ODBC SQL Server Driver][SQL Server]Infracción de la restricción PRIMARY KEY 'PK_socio'. No se puede insertar una clave duplicada en el objeto 'socio'.

-2147217900

[Microsoft][ODBC SQL Server Driver][SQL Server]Infracción de la restricción PRIMARY KEY 'PK_socio'. No se puede insertar una clave duplicada en el objeto 'socio'.

2627

-2147217900

[Microsoft][ODBC SQL Server Driver][SQL Server]Se terminó la instrucción.

3621

Los errores nativos o de la base de datos son el numero 2627 y el 3621.