Programacion Access

MANUAL DEL CURSO
PROGRAMACIN EN
ACCESS

Manual de Programacin en Access I
NDICE DE CONTENIDOS

CAPTULO 1:INTRODUCCIN
1.1 CUNDO UTILIZAR UNA MACRO Y CUNDO VISUAL BASIC PARA
APLICACIONES................................................................................. 1
1.1.1 CUNDO UTILIZAR UNA MACRO .......................................................... 2
1.1.2 CUNDO UTILIZAR VISUAL BASIC ....................................................... 2
CAPTULO 2: MDULOS
2.1 AYUDA DE VBA ............................................................................... 5
2.2 INTRODUCCIN A LOS MDULOS Y SUBRUTINAS................................. 6
2.2.1 PARA CREAR UN MDULO NUEVO........................................................ 7
2.2.2 CREACIN DE UNA SUBRUTINA......................................................... 10
2.3 VARIABLES .................................................................................. 13
2.4 USO DE EXPRESIONES................................................................... 15
2.4.1 EXPRESIONES ARITMTICAS ............................................................ 15
2.4.1.1 PRIORIDAD DE OPERADORES.......................................................... 15
2.4.2 CONCATENACIN DE CADENAS......................................................... 16
2.4.3 OPERADORES DE COMPARACIN....................................................... 16
2.4.4 OPERADORES LGICOS ................................................................... 17
2.5 COMENTARIOS EN EL CDIGO ........................................................ 17
2.6 ENTRADA Y SALIDA DE DATOS........................................................ 18
2.6.1 LA FUNCIN MSGBOX...................................................................... 18
2.6.2 LA FUNCIN INPUTBOX ................................................................... 21

Ejercicio 4: Concatenar y Calcular.......................................................... 22
CAPTULO 3: CONTROL DEL FLUJO DE EJECUCIN: SENTENCIAS
CONDICIONALES
3.1 SENTENCIA IF THEN................................................................... 23
3.2 SENTENCIA IF THEN ELSE........................................................ 24
3.3 SENTENCIA IF THEN ELSEIF ELSE........................................... 25
3.4 SENTENCIA SELECT CASE .............................................................. 25

Ejercicio 5: Los meses del ao .............................................................. 27
Ejercicio 6: Mayor, menor o igual........................................................... 28
CAPTULO 4: CONTROL DEL FLUJO DE EJECUCIN: SENTENCIAS
REPETITIVAS
4.1 SENTENCIA WHILE WEND ........................................................... 29
4.2 SENTENCIA DO LOOP ................................................................. 30
4.3 SENTENCIA FOR NEXT ................................................................ 31
4.4 SENTENCIA FOR EACH NEXT........................................................ 32
Manual de Programacin en Access II
CAPTULO 5: LLAMADAS A SUBRUTINAS, PASO DE ARGUMENTOS Y
FUNCIONES
5.1 LLAMADAS A SUBRUTINAS ............................................................. 34
5.2 PASO DE ARGUMENTOS ................................................................. 35
5.3 FUNCIONES ................................................................................. 36
5.3.1 ARGUMENTOS POR REFERENCIA Y POR VALOR .................................... 37
CAPTULO 6: PROGRAMACIN ORIENTADA A EVENTOS
6.1 ASIGNAR EVENTOS A LOS ELEMENTOS DE UN FORMULARIO ................ 43
6.2 EVENTOS..................................................................................... 44
6.2.1 EVENTOS DE FORMULARIO............................................................... 44
6.2.1.1 AL ABRIR: ................................................................................... 44
6.2.1.2 AL CARGAR:................................................................................. 45
6.2.1.3 AL ACTIVAR REGISTRO:................................................................. 45
6.2.1.4 AL ELIMINAR: ............................................................................... 45
6.2.1.5 AL DESCARGAR: ........................................................................... 46
6.2.1.6 AL CERRAR: ................................................................................. 46
6.2.2 EVENTOS DE CONTROL.................................................................... 46
6.2.2.1 AL HACER CLIC: ........................................................................... 46
6.2.2.2 AL HACER DOBLE CLIC: ................................................................. 47
6.2.2.3 AL RECIBIR EL ENFOQUE:............................................................... 47
6.2.2.4 AL PERDER EL ENFOQUE: ............................................................... 47
6.2.2.5 AL CAMBIAR: ............................................................................... 47
6.2.2.6 AL NO ESTAR EN LA LISTA: ............................................................ 47
6.2.2.7 ANTES DE ACTUALIZAR Y DESPUS DE ACTUALIZAR: ......................... 48
6.3 OBJETOS ..................................................................................... 48
6.3.1 PROPIEDADES................................................................................ 48
6.3.2 MTODOS...................................................................................... 49
6.4 UTILIZACIN DE PROPIEDADES Y MTODOS ..................................... 49
6.5 MATRICES (ARRAYS) ..................................................................... 51
6.5.1 CAMBIAR EL LMITE INFERIOR.......................................................... 51
6.5.2 ALMACENAR VALORES VARIANT EN MATRICES .................................... 52
6.5.3 UTILIZAR MATRICES CON MLTIPLES DIMENSIONES............................ 52
CAPTULO 7: PROGRAMACIN EN ADO
7.1 MODELO DE PROGRAMACIN ADO................................................... 53
7.2 RESUMEN DE OBJETOS DE ADO....................................................... 54
7.3 ABRIR UNA CONEXIN (OBJETO CONNECTION) ................................. 54
7.4 CREAR UN COMANDO (OBJETO COMANDO) ....................................... 55
7.5 TRATAR LOS DATOS (OBJETO RECORDSET)....................................... 56
7.5.1 MTODO OPEN............................................................................... 57
7.5.2 METODO CLOSE ............................................................................. 58
7.5.3 EXPLORACION DE REGISTROS (METODOS MOVE Y PROPIEDADES BOF /
EOF)............................................................................................. 59

Ejercicio 7: Recordsets......................................................................... 61

Manual de Programacin en Access 1
CAPTULO 1: INTRODUCCIN

La programacin en Access nos permite disponer de funcionalidades en nuestras
bases de datos que de otro modo no sera posible utilizar. Para ello contamos con
dos elementos fundamentales, las macros y los mdulos.

Las macros son acciones almacenadas que podemos ejecutar cuando se de un
cierto evento (pulsar un botn por ejemplo). Su funcionalidad se basa en los
elementos de access (abrir un formulario, ejecutar una consulta) y por lo tanto
est limitada a las caractersticas de access.

Los mdulos son pequeos trozos de programas escritos en un lenguaje de
programacin que se basan en los objetos de access. El lenguaje utilizado es Visual
Basic for Applications, un dialecto del conocido Visual Basic y gracias a l
dispondremos de todas las caractersticas de los lenguajes de programacin, junto
con la comodidad de Access.

1.1 CUNDO UTILIZAR UNA MACRO Y CUNDO VISUAL BASIC PARA
APLICACIONES

En Microsoft Access, es posible llevar a cabo numerosas tareas mediante macros o
a travs de la interfaz de usuario. En muchos otros programas de base de datos, es
necesario programar para realizar esas tareas. La eleccin de una macro o de
Microsoft Visual Basic para Aplicaciones depende generalmente de lo que se desee
hacer.


1.1.1 CUNDO UTILIZAR UNA MACRO

Las macros son un mtodo sencillo para controlar tareas simples como abrir y
cerrar formularios, y ejecutar informes. Permiten vincular fcil y rpidamente los
objetos de la base de datos creados, ya que no es necesario recordar mucha
sintaxis; los argumentos de cada accin se muestran en la ventana Macro.

Adems de la facilidad de uso, deber utilizar macros para:

Realizar asignaciones globales de teclas.
Ejecutar una accin o una serie de acciones cuando se abre por primera vez
una base de datos. No obstante, se puede usar el cuadro de dilogo Inicio
para que se realicen determinadas operaciones cuando se abra una base de
datos, por ejemplo, que se abra un formulario.

1.1.2 CUNDO UTILIZAR VISUAL BASIC

Utilice Visual Basic en lugar de macros para:

Facilitar el mantenimiento de la base de datos. Puesto que las macros son
objetos independientes de los formularios y los informes que las utilizan,
puede resultar difcil mantener una base de datos que contenga muchas
macros que respondan a eventos de formularios e informes. Por el contrario,
los procedimientos de eventos de Visual Basic se integran en la definicin del
formulario o informe. Si mueve un formulario o un informe de una base de
datos a otra, se movern con l procedimientos de evento incorporados en el
formulario o el informe.
Utilizar funciones integradas o crear funciones propias. Access tiene muchas
funciones integradas, como la funcin Inters, que calcula el pago de
intereses. Puede utilizar estas funciones para realizar clculos sin necesidad
de crear expresiones complicadas. Mediante Visual Basic, puede crear sus
propias funciones para realizar clculos que superen la capacidad de una
expresin o reemplacen expresiones complejas. Adems, puede utilizar las
funciones que cree en expresiones para aplicar una operacin comn a ms
de un objeto.
Administrar mensajes de error. Cuando ocurre algo inesperado mientras el
usuario trabaja con la base de datos y Access muestra un mensaje de error,
el mensaje puede resultar bastante desconcertante para el usuario,
especialmente si no conoce Access. Con Visual Basic, puede detectar el error
cuando se produce y mostrar su propio mensaje o realizar alguna accin.
Crear o trabajar con objetos. En la mayora de los casos, observar que es
ms fcil crear y modificar un objeto en la vista Diseo de ese objeto. Sin
embargo, en algunas situaciones, es posible que desee manipular la
definicin de un objeto en cdigo. Utilizando Visual Basic, puede manipular
todos los objetos de una base de datos, as como la base de datos
propiamente dicha.

Realizar acciones a nivel de sistema. Puede utilizar la accin
EjecutarAplicacin en una macro para ejecutar desde su aplicacin otro
programa basado en Microsoft Windows o Microsoft MS-DOS, pero una
macro no sirve para hacer mucho ms fuera de Access. Con Visual Basic,
puede comprobar si un archivo est en el sistema, emplear Automatizacin o
DDE (Intercambio dinmico de datos) para comunicar con otras aplicaciones
basadas en Windows, como Microsoft Excel, y llamar a funciones de
bibliotecas de vnculos dinmicos (DLL) de Windows.
Trabajar con los registros de uno en uno. Puede emplear Visual Basic para
explorar un conjunto de registros de uno en uno y realizar una operacin en
cada registro. Al contrario, las macros trabajan con conjuntos de registros
completos a la vez.
Pasar argumentos a los procedimientos de Visual Basic. Se pueden
establecer argumentos para acciones de macro en la parte inferior de la
ventana Macro durante su creacin, pero no se pueden cambiar cuando la
macro est en ejecucin. Sin embargo, con Visual Basic, se pueden pasar
argumentos al cdigo en el momento en que se ejecuta o se pueden utilizar
variables para los argumentos, lo que no es posible con las macros. Esto
ofrece una gran flexibilidad a la manera en que se ejecutan los
procedimientos de Visual Basic.

CAPTULO 2: MDULOS

Como ya se mencion con anterioridad, para la programacin de mdulos se utiliza
el lenguaje de programacin Visual Basic for Aplications, ms conocido por sus
siglas VBA. La mecnica a seguir a la hora de introducir cdigo programado en
access es la siguiente: nosotros dispondremos nuestro elemento que
desencadenar el cdigo (por ejemplo un botn en un formulario).

A continuacin, desplegaremos su men contextual, nos situaremos en la pestaa
eventos y le indicaremos que al producirse el evento deseado (hacer clic suele ser
el ms habitual) nos abra el generador de cdigo (pulsaremos el botn con 3
puntitos) desde este generador introduciremos el cdigo que queremos que se
ejecute cuando se produzca ese evento.

Pero de esta forma tendremos un trozo de cdigo asociado a un botn, si nosotros
quisiramos asociar de nuevo ese cdigo a otro botn de otro formulario por
ejemplo deberamos repetir toda la operacin de generacin de cdigo.

Para solucionar esto tenemos la posibilidad de crear subrutinas. Las subrutinas son
trozos de cdigo que ejecutan una cierta accin y que se pueden guardar para su
posterior utilizacin. Para guardar las subrutinas disponemos de los mdulos. Por lo
tanto podemos definir un mdulo como una coleccin de subrutinas relacionadas de
algn modo.

Y qu ocurre con el cdigo que introducimos directamente al crear el evento? Bien,
este cdigo permanece almacenado dentro del formulario en el que se encuentra el
botn con el cdigo asociado, de tal forma que si borramos el formulario tambin
borraremos todo el cdigo. Por lo tanto mediante los mdulos con subrutinas
podemos crear cdigo independiente de los formularios y almacenarlos en
elementos independientes de access.


No se preocupe el lector si no le han quedado claro todos los conceptos expuestos
hasta ahora, debido a su densidad, estos conceptos se explicaran con ms
profundidad en los captulos siguientes.

2.1 AYUDA DE VBA

Para acceder a la ayuda de Visual Basic antes de nada debemos abrir el editor de
Visual Basic. Para ello creamos un nuevo formulario en vista de diseo y colocamos
un elemento al que asignar un trozo de cdigo, el elemento ms habitual suele ser
un botn. Una vez tengamos nuestro botn en el formulario pulsaremos sobre l
con el botn derecho y nos situaremos en la pestaa eventos.

En esta pestaa disponemos de una entrada para cada posible desencadenador de
evento (hacer clic, hacer doble-clic...), eligiendo el que ms nos convenga. Para
abrir el editor de Visual Basic deberemos pulsar el botn con los 3 puntos y en el
men emergente elegir la opcin generador de cdigo. Tras realizar los pasos
anteriores deberemos tener una pantalla similar a la siguiente:

En esta ventana, si pulsamos sobre el men ayuda - > ayuda de Microsoft Visual
Basic entraremos a la ayuda de Visual Basic.

Otra forma, quiz ms adecuada, es mediante la ayuda contextual. Para acceder a
la ayuda contextual seleccione la palabra de la cual desee obtener la ayuda (por
ejemplo el nombre de una funcin) y pulse la tecla F1, la ayuda de Visual Basic
abre el tema de ayuda correspondiente a dicha palabra.

Para poder utilizar la ayuda de Visual Basic de forma eficaz es recomendable
conocer las convenciones utilizadas, estas son:

Sintaxis
Convencin de
formato
Ejemplo
Palabras clave
En negrita con la
primera letra en
maysculas
Sub
Argumentos de la funcin Palabras en cursiva Array(listaDeArgumentos)
Argumentos opcionales,
que se pueden incluir u
omitir
Corchetes Mid(cadena, inicio ,[ longitud])

Veamos un ejemplo para aclarar lo anterior. Escribimos la palabra msgbox y
pulsamos F1 tenindola seleccionada, con lo cual la ayuda nos mostrar la siguiente
pantalla

Que nos indica que MsgBox es una funcin que admite hasta 5 argumentos de los
cuales el nico obligatorio es el primero.

Adems la ayuda nos muestra informacin adicional sobre el significado de los
argumentos, un ejemplo detallado del uso de esa funcin y otras funciones que
pudieran estar relacionadas con la anterior.

Adems de la ayuda, Visual Basic nos facilita la tarea de introduccin de cdigo,
pues al introducir el nombre de un objeto o una funcin nos aparecer un recuadro
amarillo indicndonos las propiedades disponibles o los argumentos necesarios.

2.2 INTRODUCCIN A LOS MDULOS Y SUBRUTINAS

Como ya se coment con anterioridad cuando nosotros introducimos cdigo lo
hacemos mediante instrucciones dentro de subrutinas. Estas subrutinas pueden
estar incluidas en un formulario o informe, o bien en un mdulo independiente. Por
lo tanto las subrutinas estn formadas por instrucciones.

Una instruccin es una lnea de cdigo que realiza una tarea. Con una instruccin
podemos asignar un valor a una variable, realizar un clculo o abrir un formulario.
Ejemplo:

Con esta instruccin lo que hacemos es multiplicar el contenido de la variable
precio por el de la variable cantidad y el resultado se lo asignamos a la variable
total.

Por lo tanto una subrutina es un conjunto de instrucciones que conjuntamente
realizan una tarea ms compleja.

Ej emplo :

Solicitamos al usuario informacin sobre el precio y la cantidad y le mostramos el
total. Para ello necesitamos instrucciones para mostrar mensajes al usuario
(Introducir el precio y la cantidad), instrucciones para almacenar esos valores en
variables, instrucciones para realizar el clculo (la instruccin del ejemplo anterior)
y para finalizar instrucciones para mostrar el resultado. El resultado en cdigo VBA
es el siguiente:

Como ver las instrucciones se componen de palabras y/o operadores. Hay ciertas
palabras especiales, denominadas palabras clave, que tienen un significado
especial, por ejemplo la palabra dim que sirve para definir variables.

Los mdulos son grupos de subrutinas con funcionalidades relacionadas de alguna
forma (subrutinas matemticas, de consultas). Los mdulos nos sirven para
almacenar subrutinas independientemente de los formularios o los informes.

Los mdulos son similares al resto de objetos de la base de datos, es necesario
guardarlos y darles un nombre.

2.2.1 PARA CREAR UN MDULO NUEVO

En la ventana principal de la Base de Datos, en la barra objetos haga clic
en mdulos.


Una vez situado en la seccin mdulos haga clic en nuevo para crear un
nuevo mdulo.

Se abrir el editor de Visual Basic y aparecer la ventana cdigo.


Cuando finalice la creacin del mdulo, introduciendo la/s subrutinas que lo
formarn deber guardarlo. Para ello:

Haga clic en guardar, mediante la barra de herramientas o a travs de la
opcin de men Archivo - Guardar

Escriba el nombre del mdulo y haga clic en aceptar.


Despus de guardado, un mdulo puede ser abierto de nuevo para modificarlo de
algn modo o revisar el cdigo que ha escrito, para ello en la seccin mdulos haga
doble clic sobre el modulo que quiera abrir o seleccinelo con un clic y pulse el
botn diseo.

Del mismo modo, para eliminar un mdulo lo seleccionamos y pulsamos la tecla
SUPR o bien el botn eliminar.

2.2.2 CREACIN DE UNA SUBRUTINA

Las subrutinas pueden utilizarse para tareas que vayan a ser compartidas o
realizadas varias veces. Para crear una subrutina utilizamos la palabra reservada
Sub o function (de momento trataremos las subrutinas sub), un nombre, que ser
el nombre de la subrutina y unos argumentos entre parntesis (los argumentos los
trataremos con posterioridad).

Al finalizar la subrutina es necesario utilizar las palabras End Sub, aunque estas las
inserta el editor automticamente.

Las instrucciones que componen la subrutina irn colocadas entre Sub y End Sub
segn el siguiente esquema:

Sub NombreSubrutina([Argumentos])
Instrucciones
End Sub

Veamos un ejemplo:

Cree una nueva base de datos y pngale un nombre.

En la seccin mdulos haga clic en nuevo para crear un nuevo mdulo

Debe aparecer la frase Option Compare Database que indica cmo deben de
compararse las cadenas de texto en este mdulo.

Debajo de la frase anterior escriba Sub saludo y pulse intro.

Deben de haberse escrito los parntesis vacos (nuestra subrutina no tiene
argumentos), adems de la frase End Sub y el cursor se debe de haber
colocado entre las dos frases.

Escriba la instruccin MsgBox (Hola mundo)

La instruccin anterior consta de la funcin MsgBox, que sirve para mostrar
mensajes y el argumento Hola mundo que es la frase a mostrar, pero al ser un
texto debe de ir entre comillas.

Con esto hemos terminado nuestra primera subrutina, solamente nos falta
ejecutarla para probar que funciona, para ello pulsamos el botn ejecutar sub/user
form de la barra de tareas. Si en nuestro mdulo hubiera ms de una subrutina
se ejecutara aquella en la que estuviera el cursor o si ste no est en ninguna
subrutina nos mostrara un dialogo en el cual elegiramos la que queremos ejecutar.

2.3 VARIABLES

Una variable es un trozo de memoria en el que podemos almacenar valores.
Podemos imaginarnos las variables como cajas que contienen datos en su interior.
Para poder utilizar una variable, lo primero que debemos hacer es declararla.
Declarar una variable consiste en darle un nombre e indicar el tipo de datos que
puede contener. Para ello utilizamos la palabra reservada Dim de la siguiente
forma:

Dim NombreVariable As TipoDeDatos

Los nombres de variable deben comenzar con un carcter alfabtico, deben ser
nicos dentro del mismo mbito (no puede haber dos variables con el mismo
nombre en la misma subrutina), no deben contener ms de 255 caracteres y no
pueden contener un punto o carcter de declaracin de tipo.

Para indicar los tipos de datos de las variables se utilizan palabras reservadas.
Existe una concordancia entre los tipos de datos para los campos y los tipos de
datos de las variables:

Tipo de datos de campo Tipos de datos de
variables
Texto String
Nmero Integer
Long
Double
Single
Si/No Bolean
Fecha/Hora Date
Moneda Currency

Existe un tipo especial de datos, el tipo Variant. En una variable de tipo variant
puede almacenar cualquier tipo de datos, nmeros, texto Este tipo necesita ms
memoria que el resto y es el que se aplica si no se indica nada. Es recomendable
declarar las variables del tipo ms adecuado y slo usar variant cuando sea
necesario, con el fin de ahorrar memoria.

Como se ha indicado anteriormente, antes de usar una variable es necesario
declararla, si bien Visual Basic no nos obliga a ello. No declarar variables no es
aconsejable pues se pueden producir errores, para ello y con el fin de obligar
siempre a declarar las variables podemos usar la instruccin Option Explicit al
principio del mdulo. Tambin se puede configurar Visual Basic para que incluya
esta instruccin en todos los mdulos nuevos.

Para asignar un valor a una variable, esto es, almacenar ese valor en la variable, se
debe usar la siguiente sintaxis:

NombreDeVariable = valor

Donde valor es un nmero, cadena de caracteres, o cualquier otro valor constante o
bien el contenido de otra variable.
Ejemplos:

VariableEjemplo = 5
VariableEjemplo = Las cadenas de texto deben de ir entrecomilladas
VariableEjemplo = OtraVariable

Es conveniente que justo despus de declarar una variable se la inicialice, esto es,
asignarle un valor inicial. Esta prctica es muy recomendable porque una variable
no inicializada tendr un valor predeterminado, que depende de su tipo de datos.

Para evitar problemas es recomendable seguir la siguiente estructura en nuestras
subrutinas:

Sub NuestraSubrutina( )

Declaracin de las variables
necesarias

Inicializacin de las
variables anteriores

Instrucciones necesarias
para la realizacin de la
subrutina

End Sub

Si a pesar de lo anterior decidimos no inicializar las variables que utilizaremos, es
conveniente al menos conocer el valor predeterminado que les asigna Visual Basic,
el cual se corresponde con la siguiente tabla:

Tipo de datos Valor
predeterminado
String (cadena vaca)
Date 30 de diciembre de
1899
Integer, Long, Double,
Single
0
Boolean False

2.4 USO DE EXPRESIONES

Muchas operaciones de Access usan expresiones. Una expresin es una
combinacin de identificadores de variables, de campos, controles, smbolos que
producen un resultado. Ya hemos visto algunas expresiones sencillas en los
ejemplos anteriores.

Las expresiones pueden ser aritmticas, de cadenas, de asignacin y de
comparacin.

2.4.1 EXPRESIONES ARITMTICAS

Las expresiones aritmticas son iguales a las expresiones a las que estamos
acostumbrados, as disponemos de los operadores suma, resta, multiplicacin Los
operadores aritmticos los podemos usar con variables o con valores constantes,
pero han de ser de un tipo vlido. No podemos sumar una variable cuyo contenido
sea una cadena de caracteres con el nmero 5 por ejemplo. A continuacin se
muestra una tabla con los distintos operadores y un ejemplo de utilizacin:

Operador Significado Ejemplo Explicacin
+ Suma 75 + Total Suma 75 al contenido de la variable
Total
- Resta Ingresos -
Gastos
Resta el contenido del contenido de la
variable Ingresos el contenido de la
variable Gastos
* Multiplicacin 13 * 5 Multiplica el nmero 13 por 5
/ Divisin Beneficios / 5 Divide el contenido de la variable
Beneficios entre 5.
Mod Resto 29 mod 3 Calcula el resto de la divisin de 29
entre 3, que en este caso es 2.

2.4.1.1 PRIORIDAD DE OPERADORES

Debemos de tener en cuenta la prioridad de los operadores, esto es, el orden en el
que se ejecutan las operaciones. El orden de prioridad de los operadores es el
siguiente:

Expresiones entre parntesis
Multiplicacin y divisin
Suma y resta

Ejemplo:

Total = 4+3*2, primero se multiplica 3*2, que da 6 y luego se le suman 4, con lo
que la variable Total tendra un valor de 10. Si quisiramos sumar primero y
multiplicar despus deberamos usar parntesis de la forma: Total = (4+3)*2, con
lo que Total valdra 14.

2.4.2 CONCATENACIN DE CADENAS

La accin de juntar varias cadenas de caracteres en una sola se conoce como
concatenacin. El operador utilizado para concatenar cadenas es el smbolo &.

Ejemplo:

cadResultado = cadena1 & cadena2
Suponiendo que el contenido de cadena1 es Hola y el de cadena2 es alumno, el
resultado obtenido en la cadena cadResultado sera Holaalumno. Si quisiramos
una separacin en el resultado la instruccin debera de haber sido:
cadResultado= cadena1 & & cadena2

Se pueden concatenar datos que no sean cadenas de caracteres con datos de
cadena, pues el resultado se convierte automticamente. As, la instruccin:
cadResultado = Aula: & numAula
Suponiendo que el contenido de la variable numAula es 5, el resultado obtenido en
cadResultado sera Aula: 5

2.4.3 OPERADORES DE COMPARACIN

Las expresiones de comp aracin sirven para comparar valores entre s, y devolver
verdadero (true) o falso (false) en funcin de la expresin.

Veamos un ejemplo:

Operador Significado Ejemplo Comentarios
< Menor que 10 < 5 El resultado devuelto es false
> Mayor que Aula > 3 El resultado devuelto depende
del valor de la variable Aula
= Igual a Apellido =
Garca
No confundir con el operador de
asignacin
<> Distinto de cadena1 <>
cadena2
El resultado depende de los
valores de las variables cadena1
y cadena2.
<= Menor o igual
que
10 <= 10 El resultado es true
>= Mayor o igual
que
5 >= numero1 Depende del contenido de la
variable numero1

Si se intentan comparar datos distintos (una variable que contenga una cadena de
caracteres con un nmero, por ejemplo) Visual Basic nos mostrar un mensaje de
error. Es recomendable cerciorarse de que los datos que se comparan son del
mismo tipo.


2.4.4 OPERADORES LGICOS

Al igual que ocurre en Access, en VBA tambin disponemos de operadores lgicos
que sirven para comparar expresiones booleanas (expresiones verdadero/falso).
Los operadores lgicos son AND, OR, XOR y NOT.

El operador AND nos devuelve verdadero cuando las dos expresiones a comparar
son verdaderas y falso en caso contrario. Su tabla de funcionamiento es la
siguiente:

Expresin 1 Expresin 2 Resultado
False False False
False True False
True False False
True True True

El operador OR nos devuelve verdadero si al menos una de las dos expresiones es
verdadera y falso si las dos son falsas. Su tabla de funcionamiento es la siguiente:

False False False
False True True
True False True
True True True

El operador NOT devuelve verdadero si la expresin es falsa y falso en caso de que
la expresin sea verdadera. Su tabla de funcionamiento es la siguiente:

Expresin Resultado
False True
Trae False

El operador XOR devuelve verdadero en caso de que solo una expresin sea
verdadera y falso en caso de que las dos sean falsas o las dos sean verdaderas. Su
tabla es:

False False False
False True True
True False True
True True False

2.5 COMENTARIOS EN EL CDIGO

A veces las subrutinas son difciles de entender a medida que se hacen ms
complicadas y grandes, para facilitar su lectura por parte de otros usuarios, o por
nosotros mismos ms adelante, es conveniente agregar comentarios. Los
comentarios nos sirven para explicar el porqu de las instrucciones y las
expresiones utilizadas. Puede agregar comentarios en cualquier lugar de una
subrutina, para ello inserte un apstrofe y Visual Basic ignorar todo lo que haya
despus y hasta el final de la lnea. Si necesita insertar comentarios de varias lneas
no olvide incluir un apstrofe al principio de cada una.

Ejemplo:

Los comentarios son fcilmente identificables, pues el editor de Visual Basic los
pone de color verde (en este manual los marcaremos en gris) para as distinguirlos
claramente del cdigo normal.

2.6 ENTRADA Y SALIDA DE DATOS

A menudo es necesario realizar tareas que requieran mostrar informacin al usuario
o bien solicitar de ste algn dato. Para ello disponemos de instrucciones que nos
permiten la entrada y salida de datos, InputBox y MsgBox respectivamente.

2.6.1 LA FUNCIN MSGBOX

La sintaxis de esta funcin es la siguiente:

MsgBox(pregunta [, botones] [, ttulo] [,
archivoDeAyuda, contexto])

Como ya sabemos los corchetes son argumentos opcionales de las funciones, por lo
tanto el nico argumento necesario por esta funcin es el argumento pregunta.
Este argumento se corresponde con la frase que se le mostrar al usuario. Un
ejemplo tpico lo vimos anteriormente con la instruccin: MsgBox (Hola mundo).
Esta instruccin muestra la frase elegida como argumento en un cuadro de dialogo,
junto con el botn de aceptar.

Como vimos anteriormente, tambin disponemos de un argumento botones en el
que le informamos a la funcin de qu botones, iconos y tipo de dialogo debe
mostrar. Los posibles valores de este argumento son los siguientes:

Constante Valor Descripcin
VbOKOnly 0 Muestra solamente el botn Aceptar.
VbOKCancel 1 Muestra los botones Aceptar y Cancelar.
VbAbortRetryIgnore 2 Muestra los botones Anular, Reintentar
e Ignorar.
VbYesNoCancel 3 Muestra los botones S, No y Cancelar.
VbYesNo 4 Muestra los botones S y No.
VbRetryCancel 5 Muestra los botones Reintentar y
Cancelar.
VbCritical 16 Muestra el icono de mensaje crtico.
VbQuestion 32 Muestra el icono de pregunta de
advertencia.
VbExclamation 48 Muestra el icono de mensaje de
advertencia.
VbInformation 64 Muestra el icono de mensaje de
informacin.
VbDefaultButton1 0 El primer botn es el predeterminado.
VbDefaultButton2 256 El segundo botn es el predeterminado.
VbDefaultButton3 512 El tercer botn es el predeterminado.
VbDefaultButton4 768 El cuarto botn es el predeterminado.
VbApplicationModal 0 Aplicacin modal; el usuario debe
responder al cuadro de mensajes antes de
poder seguir trabajando en la aplicacin
actual.
VbSystemModal 4096 Sistema modal; se suspenden todas las
aplicaciones hasta que el usuario responda
al cuadro de mensajes.
VbMsgBoxHelpButton 16384 Agrega el botn Ayuda al cuadro de
mensaje.
VbMsgBoxSetForeground 65536 Especifica la ventana del cuadro de
mensaje como la ventana de primer
plano.
VbMsgBoxRight 524288 El texto se alnea a la derecha.
VbMsgBoxRtlReading 1048576 Especifica que el texto debe aparecer para
ser ledo de derecha a izquierda en
sistemas hebreo y rabe.

El valor del argumento botones se puede indicar usando el nombre de la constante
o el valor numrico correspondiente. Hay que tener en cuenta que los distintos
tipos de botones, iconos se pueden agrupar, para ello es necesario sumar sus
valores y especificar el resultado.

Ejemplo: Nos puede interesar mostrar un dialogo con los botones de aceptar y
cancelar, junto con el icono de mensaje de advertencia. Para ello sumamos los
valores de la tabla anterior, 1 para los botones de aceptar y cancelar y 48 para el
icono de advertencia, por lo tanto nuestra funcin quedara: MsgBox (Hola
mundo, 49).

Si probamos el ejemplo anterior comprobaremos que Visual Basic nos da un error,
esto es as, por que si utilizamos la funcin MsgBox para mostrar dilogos con
varios botones la funcin nos devuelve informacin sobre que botn se ha pulsado.
Esta informacin se corresponde con la siguiente tabla:

Constante Valor Descripcin
vbOK 1 Aceptar
vbCancel 2 Cancelar
vbAbort 3 Anular
vbRetry 4 Reintentar
vbIgnore 5 Ignorar
vbYes 6 S
vbNo 7 No

Al igual que ocurra anteriormente podemos usar el valor numrico directamente o
la constante correspondiente.

Por lo tanto, como en este caso MsgBox nos devuelve un valor, necesitamos una
variable en la cual almacenarlo (si lo necesitamos podremos consultar el valor de
esta variable con posterioridad), quedando la sintaxis de la instruccin:

ValorDeRetorno = MsgBox(pregunta [, botones] [,
ttulo] [, archivoDeAyuda, contexto])

El argumento ttulo establece la cadena que se mostrar en la barra de ttulo del
cuadro de dialogo.

Los dos argumentos restantes identifican el archivo de ayuda y el tema que se
mostrar en caso de que el usuario pulse la tecla F1.

Para finalizar veamos un sencillo ejemplo de utilizacin de la funcin MsgBox con
valor de retorno, mostrando un mensaje segn el botn pulsado:

Como ver el ejemplo anterior es muy sencillo, tan solo mostramos el cdigo
numrico del botn que se ha pulsado. Lo realmente interesante es realizar una
tarea si se pulsa un botn y otra distinta si se pulsa el otro, pero para esto
necesitamos usar sentencias condicionales, que veremos con posterioridad.
2.6.2 LA FUNCIN INPUTBOX

La funcin InputBox muestra un cuadro de dialogo que nos solicita la entrada de
datos. Cuando pulsamos el botn aceptar devuelve una cadena con el contenido del
cuadro de texto. La sintaxis de esta funcin es la siguiente:

ValorDeRetorno = InputBox(pregunta [,ttulo] [, valor
predeterminado])

Los argumentos pregunta y ttulo son iguales a los descritos para la funcin
MsgBox. El argumento valor predeterminado indica que el valor que aparecer
inicialmente en el cuadro de texto. Existen otros argumentos, como el fichero de
ayuda, el contexto y opciones para determinar la posicin del cuadro de dialogo,
pero los ms relevantes son estos tres.

En la variable ValorDeRetorno se almacena el valor que el usuario ha escrito en el
cuadro de texto, pudindose usar con posterioridad en la subrutina.

Veamos un ejemplo de utilizacin de la funcin InputBox:

Observaremos que lo nico distinto en este ejemplo es la propia utilizacin de la
funcin InputBox, para ello hemos indicado los dos argumentos de la pregunta y
del ttulo con sendas cadenas de caracteres y no hemos utilizado el argumento
opcional de valor predeterminado.

Para terminar, hemos almacenado este valor en la variable respuesta.
Posteriormente hemos juntado el contenido de la variable respuesta (el nombre que
el usuario nos haya respondido) con el saludo.

Ejercicio 4: Concatenar y Calcular

I NSTRUCCI ONES:

Crea un mdulo con el nombre Ejercicios, definiendo una Subrutina
llamada Clculo en el que declares 2 variables de tipo Integer, luego,
debes solicitar al usuario que te introduzca dos nmeros, los cuales tendrs
que multiplicar y mostrar como resultado lo siguiente:


CAPTULO 3: CONTROL DEL FLUJO
DE EJECUCIN: SENTENCIAS
CONDICIONALES

Normalmente la ejecucin del cdigo contenido en una subrutina se realiza de
arriba hacia abajo, es decir, las instrucciones se ejecutan una por una comenzando
por la que est inmediantamente despus de Sub nombreSubrutina( ) hasta llegar
a End Sub.

Cmo ya se ha comentado anteriormente, en determinadas ocasiones nos interesa
realizar una tarea si el usuario pulsa el botn aceptar y otra distinta si se pulsa el
botn cancelar, para esto necesitamos una forma de dirigir la ejecucin por una va
o por otra, en funcin de una condicin. Normalmente esta condicin es una
expresin de comparacin que produce un valor verdadero o falso.

El ejemplo anterior de la pulsacin de varios botones no es el nico en el que nos
interesa realizar bifurcaciones de nuestro cdigo, para resolver ciertas subrutinas
tambin son necesarias. Por ejemplo, para determinar si un nmero proporcionado
por el usuario es par o impar podemos realizar el mdulo de dicho nmero entre 2
y si el resto es 0 el nmero es par e impar en caso contrario.

La bifurcacin de nuestro cdigo lo conseguimos con la utilizacin de sentencias
condicionales, en VBA existen cuatro tipos de sentencias condicionales:

If Then
If Then Else
If Then Elseif Else
Select Case

Fjese el lector que tres de los tipos son variaciones de la estructura If.

3.1 SENTENCIA IF THEN

En general esta estructura se utiliza cuando queremos que se ejecuten ciertas
instrucciones cuando se cumpla una condicin y que no se haga nada si no se
cumple.

La forma comn de uso de la sentencia If Then es la siguiente:

If condicin Then
Instrucciones
End If

Donde condicin es una expresin de comparacin. Obsrvese la necesidad de
emplear las palabras reservadas End If para indicar el trmino de las instrucciones
a ejecutar en caso de que la condicin se evale a verdadero. Estas palabras
reservadas no son necesarias si nicamente debemos ejecutar una instruccin y lo
hacemos en una misma lnea, utilizando la siguiente sintaxis:

If condicin Then instruccin

Un ejemplo de uso de la estructura If Then es el siguiente:

Como la estructura anterior consta tan solo de una instruccin podramos ponerlo
todo en una sola lnea sin la necesidad de End If, de la siguiente forma:

If x < 10 Then MsgBox(El contenido de la variable x es menor de 10)

En cualquiera de los dos casos el resultado es el mismo, siendo la diferencia por
tanto tan solo una reduccin del cdigo a emplear.
Si observamos el ejemplo, el cuadro de dialogo con el mensaje tan solo se mostrar
cuando el contenido de la variable x sea inferior a 10, si el contenido fuera 10 o
superior no se mostrara nada.

3.2 SENTENCIA IF THEN ELSE

Como hemos visto, el caso anterior tiene utilidad cuando queramos ejecutar un
cierto cdigo si se cumple una condicin y nada en caso contrario, pero a veces nos
interesa ejecutar un trozo de cdigo si la condicin se evala a verdadero y otro
trozo distinto si se evala a falso. Para ello usaremos esta variante de estructura If,
cuaya sintaxis es la siguiente:

If condicin Then
Instrucciones en caso de condicin verdadera
Else
Instrucciones en caso de condicin falsa
End If

El ejemplo anterior lo podemos mejorar si mostrasemos adems un cuadro de
dialogo informando de que el contenido de la variable es mayor de 10. Para ello
pondramos el siguiente cdigo:

Si observamos detenidamente lo que hacemos es una bifurcacin en la ejecucin
del cdigo, ste comenzar secuencialmente y al llegar a la estructura If se
ejecutar un trozo u otro (nunca los dos a la vez) continuando secuencialmente
despus del End If.

3.3 SENTENCIA IF THEN ELSEIF ELSE

Esta variacin es utilizada cuando las posibles alternativas en la ejecucin del
cdigo son tres o ms. Su sintaxis es la siguiente:

If condicin1 Then
Instrucciones para la alternativa 1
ElseIf condicin2 Then
Else
End If

Podemos insertar tantos bloques ElseIf como sean necesarios para reflejar todas las
posibles alternativas.

Siguiendo con el ejemplo anterior, puede que nos interesara mostrar un mensaje
en caso de que el contenido de la variable fuera menor de 10, otro en caso de que
fuera 10 y otro distinto si el contenido de la variable fuera mayor de 10, para ello el
cdigo necesario sera:

En este caso tiene un ejemplo completo, observe la utilizacin de la instruccin
InputBox para recoger informacin del usuario, los comentarios utilizados para
mejorar la legibilidad y el uso de la estructura If Then ElseIf Else.

Como se disponen de varias sentencias, es necesario una planific acin que
determine el nmero de alternativas necesarias y por lo tanto que sentencia
utilizar.

3.4 SENTENCIA SELECT CASE

La sentencia Select Case se utiliza cuando existen gran cantidad de alternativas.
Aunque para ello podemos usar la estructura If Then ElseIf Else con
varios bloques ElseIf, el cdigo resultante sera enrevesado y dificultoso de leer,
por lo tanto disponemos de la estructura Select Case que es ms adecuada para
estos casos.

Esta estructura est especialmente indicada para probar el valor de una expresin
en un intervalo de valores posibles. Su sintaxis es:

Select Case expresin
Case expresin1
Case expresin2

Case expresinN
Instrucciones para la alternativa N
Case Else
Instrucciones para la alternativa no coincidente con ninguna anterior
End Select

El siguiente cdigo muestra como utilizar la sentencia Select Case, para ello
solicitaremos el nombre de un pas al usuario y mostraremos su capital o la frase
desconozco ese pas en caso de que el pas est mal escrito o no fuera una de las
alternativas.

En el ejemplo anterior se hace uso del operador & para concatenar cadenas tal y
como hemos visto. Observe adems que en el caso de que el pas introducido no
coincida con ninguna de las alternativas propuestas se ejecutara la clusula Case
Else.
Ejercicio 5: Los meses del ao

I NSTRUCCI ONES:

En el mdulo anterior generar una sentencia condicional, para que en
funcin del nmero introducido por el usuario, el programa nos muestre el
mes que corresponde.
Ejercicio 6: Mayor, menor o igual

I NSTRUCCI ONES:

Crear una subrutina en el mismo mdulo para qu en funcin de dos valores
introducidos por el usuario, nos devuelva como respuesta si un nmero es
mayor que el otro, o bien, que ambos son iguales.
CAPTULO 4: CONTROL DEL FLUJO
DE EJECUCIN: SENTENCIAS
REPETITIVAS

En numerosas ocasiones necesitamos repetir una serie de instrucciones un nmero
de veces para resolver un problema. Para conseguir esto disponemos de las
estructuras repetitivas, tambin denominas bucles.

Pongamos un ejemplo para verlo ms claro. Si quisiramos calcular el factorial de
un nmero necesitaremos ir multiplicando el nmero introducido por l mismo
menos 1, el resultado habr que multiplicarlo de nuevo, pero ahora por l mismo
menos 2, , as mientras la resta nos de un nmero mayor que 1 .
El factorial de 5 es 5 * (5 - 1 = 4) = 20 * (5 2 = 3) = 60 * (5 3 = 2) = 120,
que es justamente el factorial de 5.

El caso del clculo del factorial no es nico, existen numerosos ejemplos de
utilizacin de bucles, por lo tanto este tipo de estructuras es muy usual. Todo bucle
consta de una condicin, que es la condicin de parada del bucle. Esta condicin
debe de alcanzarse en algn momento, por que si no el bucle sera infinito y la
subrutina no funcionara correctamente. En el ejemplo del factorial vamos restando
mientras el nmero sea mayor que 1, que es la condicin de parada.

En visual Basic existen los siguientes tipos de bucles:

Sentencia While Wend
Sentencia Do Loop
Sentencia For Next
Sentencia For Each Next

4.1 SENTENCIA WHILE WEND

Mediante esta sentencia se ejecutan una serie de instrucciones mientras se cumpla
una condicin. Su sintaxis es la siguiente:

While condicin
Instrucciones
Wend

Veamos un ejmplo para verlo ms claro, para ello realizaremos una subrutina que
calcule el factorial de un nmero dado con este tipo de bucles:


El proceso de ejecucin de un bucle es el siguiente. Cuando se llega a la sentencia
While se evala la condicin, si esta fuera falsa se continuara la ejecucin despus
de Wend (el bucle se ejecutara 0 veces). Si la condicin es verdadera se ejecutan
las instrucciones hasta el Wend y al llegar a este punto se vuelve a la sentencia
While, comprobndose de nuevo la condicin y repitindose el proceso. Como ya se
ha comentado, es necesario que exista una instruccin dentro del bucle (entre
While y Wend) que garantice que la condicin se evaluar en algn momento al
valor false, para que el bucle no se vuelva a ejecutar.

4.2 SENTENCIA DO LOOP

Esta sentencia es muy similar a la anterior, si bien la condicin puede ser evaluada
al principio o al final (con lo que nos aseguramos que el bucle siempre se ejecuta al
menos una vez), y esta evaluacin puede hacerse a verdadero o falso. Su sintaxis
es la siguiente:

Condicin evaluada al principio Condicin evaluada al final
Do While/Until condicin
Instrucciones
Loop
Do
Instrucciones
Loop While/Until condicin

Si se utiliza la clasula While la condicin se evala a verdadero, es decir, se entra
en el bucle si la condicin es verdadera y no se entra si la condicin es falsa. Si se
utiliza la clasula Until ocurre lo contrario, se entra en el bucle si la condicin es
falsa y no se entra si es verdadera.

Realizaremos a continuacin el ejemplo anterior del clculo del factorial, pero esta
vez con la sentencia Do Loop y evaluacin de la condicin al final usando la
clausula Until.


Si probamos el programa anterior comprobaremos que funciona para todos los
valores excepto para el 1. Esto es as por que la condicin se evala al final y se
produce la resta (el contador valdra 0) antes de la evaluacin de la condicin, con
lo que se realiza una vuelta que no se debera de realizar.

Para solucionar esto bastara con colocar la condicin al principio del bucle, con lo
que sta vuelta no se realizara. Por lo tanto, el ejemplo anterior nos sirve para
demostrar que a veces es conveniente poner la condicin al principio y otras veces
al final y que esto ha de ser tenido en cuenta.

Existe la posibilidad de usar la sentencia Exit Do, que permite salir de un bucle Do
Loop en cualquier momento de su ejecucin, si bien su uso no es recomendable
pues no cumple con la filosofa de la programacin estructurada.

4.3 SENTENCIA FOR NEXT

Los bucles de tipo For Next se ultilizan cuando se conoce el nmero de
iteraciones necesarias. Es decir, los bucles tipo While Wend y tipo Do Loop
se repiten mientras se cumpla una condicin y los bucles For Next parten de un
valor inicial hasta un valor final. Su sintaxis es la siguiente:

For variable = expresin1 To expresin2 [Step expresin3]
Instrucciones
Next variable

Cuando se ejecuta una sentencia For, primero se asigna el valor de la expresin1 a
la variable y se comprueba si su valor es mayor o menor que la expresin2. En caso
de ser menor se ejecutan las instrucciones, y en caso de ser mayor la ejecucin de
la subrutina contina por las instrucciones situadas despus de la clausula Next.
Esto sucede si expresin3 es positiva, siendo al revs si es negativa. Una vez
ejecutadas las instrucciones, la variable se incrementa en el valor de expresin3 (o
se decrementa en caso de ser expresin3 negativa), o en 1 si no se especifica
Step, volvindose a efectuar la comparacin entre la variable y la expresin2, y as
sucesivamente.

Al igual que ocurra con los bucles Do Loop tenemos tambin la posibilidad de
salir en cualquier momento, utilizando la sentencia Exit For.
Como en la explicacin de los bucles anteriores veremos ahora el ejemplo del
clculo del factorial con un bucle for:


4.4 SENTENCIA FOR EACH NEXT

Esta estructura est especialmente indicada para recorrer arrays, por lo tanto su
estudio se realizar simultneamente al de la citada estructura de datos.

Como ver por los ejemplos anteriores el resultado es muy similar,
independientemente del bucle utilizado para su resolucin. Es ms, el uso de un
bucle u otro es en la mayora de los casos equivalente, siendo la eleccin una
cuestin principalmente de gustos o estilos de programacin.

A continuacin veremos la resolucin de otro ejemplo clsico, en el que
combinaremos la utilizacin de bucles y de sentencias condicionales.

El caso que nos ocupar ser el de indicar si un nmero introducido por el usuario
es un nmero perfecto o no. Un nmero perfecto es aquel que es igual a la suma
de sus divisores (excepto l mismo).

El 6 tiene como divisores (excepto l mismo) el 3, el 2 y el 1. Si sumamos 3 + 2 +
1 = 6, por lo tanto es perfecto. El 12 tiene como divisores el 6, el 4, el 3, el 2 y el
1. Si sumamos 6 + 4 + 3 + 2 +1 = 15, por lo tanto no es perfecto.

CAPTULO 5: LLAMADAS A
SUBRUTINAS, PASO DE
ARGUMENTOS Y FUNCIONES

A medida que vamos aadiendo funcionalidades a nuestra base de datos es normal
que las lneas de cdigo aumenten significativamente. Para permitir manejar tal
volumen de informacin se hace necesario una modularizacin, que es el proceso
consistente en dividir un problema muy grande en una serie de mdulos mucho
ms pequeos y manejables. Estos mdulos estn formados por subrutinas ms
especficas, que a su vez pueden estar divididas en otras subrutinas. Bsicamente
la tcnica a emplear es divide y vencers.

Las ventajas de la modularizacin son las siguientes:

Modularizacin. Cada subrutina tiene una misin muy concreta, de modo
que no tiene un nmero de lneas excesivo. Adems una subrutina puede ser
llamada muchas veces, incluso desde otras bases de datos. Cada subrutina
es desarrollada y comprobada por separado, con lo que se aslan los errores.
Ahorro de memoria y tiempo de desarrollo. En la medida en que una
misma subrutina es usada varias veces, el nmero total de lneas de cdigo
disminuye y tambin lo hace por tanto la probabilidad de incluir errores.
Independencia de datos y ocultamiento de informacin. A veces es
frecuente que al introducir nuevo cdigo se produzcan errores en partes que
anteriormente funcionaban bien. Utilizando subrutinas cada una se comporta
de forma aislada y los errores se circunscriben a la subrutina en que nos
encontremos.

En VBA se distingue entre funciones y procedimientos Sub. En ocasiones se
utiliza la palabra genrica subrutina para referirse a ambos. Hasta ahora las
subrutinas que hemos desarrollado han sido procedimientos Sub, en este captulo
estudiaremos con ms detalle su utilizacin, sus caractersticas y sus diferencias
principales con las funciones.

La principal diferencia entre un procedimiento sub y una funcin es que sta ltima
puede ser utilizada en una expresin porque tiene un valor de retorno, es decir,
devuelve un dato.

5.1 LLAMADAS A SUBRUTINAS

Cuando realizamos la llamada a una subrutina desde dentro de otra subrutina el
cliclo de ejecucin cambia de la subrutina principal a la secundaria. Para llamar a
un subrutina desde dentro de otra subrutina basta con poner el nombre de la
subrutina a llamar como una instruccin ms. Como hemos comentado disponemos
de dos tipos de subrutinas: los procedimientos sub y las funciones.

La sintaxis que define un procedimiento sub es la siguiente:

Sub nombre ([argumento1 as tipo1, argumento2 as tipo2, ])
Instrucciones
End Sub

A continuacin veremos un ejemplo de llamada a procedimientos Sub. El paso de
argumentos y las funciones se explicar con posterioridad.

Supongamos que la subrutina que se est ejecutando, por ejemplo al pulsar un
botn, es la subrutina llamada principal. Esta subrutina lo primero que hara sera
mostrar un cuadro de dilogo con un saludo, despus pasa la ejecucin a la
subrutina llamada, que se ejecuta con todas sus instrucciones (mostrara otro
saludo), y al llegar al final cede de nuevo el control a la subrutina principal, la cual
continua justo despus de la llamada, mostrando el mensaje de adis.

Grficamente la ejecucin de una subrutina es la siguiente:

En el ejemplo anterior no parece muy lgico el utilizar subrutinas, sin embargo
cuando hemos de repetir el mismo trozo de cdigo varias veces es ms eficiente
crear una subrutina con ese trozo de cdigo y utilizar llamadas que no hacer varias
veces lo mismo.

5.2 PASO DE ARGUMENTOS

A menudo una subrutina necesita cierta informacin para poder ejecutarse, o lo que
es lo mismo, a veces nos puede interesar que una subrutina haga algo en funcin
de cierta informacin que le pasemos.

Esta informacin se conoce como argumentos de la subrutina y debe ser
especificada en el diseo de la subrutina y a la hora de hacer la llamada. Veamos
un ejemplo:

Sub principal ()
Instrucciones

llamada a subrutina
secundaria
.
End Sub
Sub secundaria ()
Instrucciones
End Sub

Como vemos, a la hora de definir la subrutina comprobar_edad hemos puesto entre
parntesis el nombre de un argumento y su tipo. Dentro de esta subrutina hemos
usado este nombre para referirnos a este dato. Al realizar la llamada hemos metido
entre parntesis el valor del argumento.

Es decir, primero realizamos la subrutina y utilizamos el nombre del argumento, y
al hacer la llamada le damos el valor a ese argumento (en nuestro caso el
contenido de una variable).

Lo que en realidad sucede es que el valor con el que hacemos la llamada se copia
en el nombre que internamente usa la subrutina (el nombre del argumento), y por
lo tanto sta realiza los clculos con los datos correctos.

Hay que tener en cuenta que los datos con que hagamos la llamada se copian en
los argumentos segn el orden establecido, es decir, el primer dato de la llamada
se copia en el primer argumento, el segundo dato en el segundo argumento por lo
tanto es necesario que los datos de la llamada sean del mismo tipo que los
argumentos y en el mismo orden.

5.3 FUNCIONES

Como se ha comentado la diferencia entre funciones y procedimientos Sub es el
valor de retorno, lo que posibilita a las funciones ser usadas como parte de una
instruccin.

De tal forma la instruccin:

p = subrutina

Slo es vlida si subrutina es una funcin, producindose un error en caso de
tratarse de un procedimiento Sub.

Por lo tanto, cuando en una subrutina necesitemos devolver un valor, si realizamos
un clculo necesitaremos que el resultado se conozca desde donde se llam a la
subrutina, es necesario utilizar funciones.

La sintaxis correspondiente a una funcin es la siguiente:

Function nombre ([argumento1 as tipo1, argumento2 as tipo2,]) as tipo
Instrucciones
Nombre = expresin del valor de retorno
End Function

Veamos un ejemplo, de utilizacin de la sintaxis anterior. Para ello resolveremos la
siguiente ecuacin:

Resultado = mayor (x,y) * z

Necesitamos primero calcular el mayor entre x e y y despus multiplicar este
resultado parcial por el nmero z. Para ello realizaremos una funcin que nos
devuelva el mayor de los dos argumentos suministrados y despus lo
multiplicaremos por z.

Si nos fijamos en el cdigo anterior con detenimiento observaremos que en la
funcin mayor existe una instruccin (en nuestro caso dos) que asigna al nombre
de la funcin un valor, esto es as pues es la forma de retornar los datos.

Posteriormente en la subrutina ecuacin se utiliza en algn momento el nombre de
la funcin mayor (que se cambiar por el valor de retorno) como parte de una
instruccin. En nuestro ejemplo es:

resultado = mayor(numero1, numero2)*numero3

Llegados a esta instruccin se transfiere el control a la funcin mayor, copindose
los datos en los argumentos correspondientes. Al finalizar la funcin se devuelve el
control a la subrutina que realiza la llamada, pero se cambia donde pone
mayor(numero1, numero2) por el dato de retorno de la funcin, el cual se
multiplica por numero3 y el resultado se asigna a la variable resultado.

5.3.1 ARGUMENTOS POR REFERENCIA Y POR VALOR

Como hemos visto, mediante las funciones podemos devolver un resultado a la
subrutina que la ha llamado, pero a veces nos puede interesar devolver ms de un
valor. Cmo conseguimos esto? La solucin es hacer que los argumentos sean de
entrada y de salida, es decir que no slo proporcionen informacin a la funcin (o al
procedimiento sub) sino que sta los modifique y puedan ser consultados desde
fuera. Veamos un ejemplo:

Estudie con detenimiento el ejemplo anterior, pues en l se engloban buena parte
de lo que llevamos estudiado. Si observa con detenimiento ver que el resultado se
obtiene en las variables r1 y r2 que se le pasan como argumentos a la funcin y
que sta se encarga de modificar convenientemente.

Lo anterior sucede por que VBA pasa los argumentos por referencia, es decir, que
los cambios realizados en las funciones se ven reflejados fuera de stas. Pero a
veces nos interesa pasar los argumentos por valor, es decir, evitar que los
argumentos sean de entrada y salida y obligar a que solo sean de entrada (de esta
forma los cambios realizados en las funciones a los argumentos se desechan). Para
pasar un argumento por valor en vez de por referencia slo es necesario anteponer
la palabra ByVal a la declaracin del argumento en la cabecera de la subrutina (Sub
o Function)

Function Raiz (ByVal N As Double)
Sub Raiz (ByVal N As Double, F As Double)

Pasar argumentos por valor evita modificaciones accidentales, pero tiene un mayor
coste en tiempo y en memoria para la ejecucin del cdigo.

CAPTULO 6: PROGRAMACIN
ORIENTADA A EVENTOS

Hasta ahora hemos estudiado la sintaxis y la metodologa de programacin en VBA.
A partir de ahora aplicaremos dicha sintaxis y metodologa a casos concretos, con
ejemplos de bases de datos.

En Access se utiliza la llamada programacin orientada a eventos, es decir, las
distintas secciones de cdigo se ejecutan como respuesta a eventos. Los eventos se
producen en los objetos de las aplicaciones de Microsoft Access. Un objeto es una
combinacin de cdigo y datos que se puede tratar y controlar como una unidad.
Los botones de comando y otros controles de un formulario son ejemplos de
objetos. Cada formulario de un proyecto de Access es un objeto independiente. Por
lo tanto los objetos pueden contener otros objetos en su interior.

En la programacin orientada a eventos el programador escribe cdigo que
responde a eventos. Las acciones del usuario pueden desencadenar eventos, como
hacer clic con el mouse (ratn) o seleccionar un botn. Un evento tambin se
puede desencadenar por mensajes del sistema, de Access o bien de otras
aplicaciones.

La secuencia de los eventos determina la secuencia en la que se ejecuta el cdigo.
Por lo tanto, el orden de ejecucin del cdigo puede ser distinto cada vez que se
ejecute el programa.

Los eventos disponibles para un objeto varan segn el objeto del que se trate, por
ejemplo, a continuacin veremos los eventos disponibles para un botn y para un
cuadro de texto:

Botn Cuadro de texto
Al entrar Antes de actualizar
Al salir Despus de actualizar
Al recibir el enfoque En datos no guardados
Al perder el enfoque Al deshacer
Al hacer clic Al cambiar
Al hacer doble clic Al entrar
Al bajar el mouse Al salir
Al mover el mouse Al recibir el enfoque
Al subir el mouse Al perder el enfoque
Al bajar una tecla Al hacer clic
Al subir una tecla Al hacer doble clic
Al presionar una tecla Al bajar el mouse
Al mover el mouse
Al subir el mouse
Al bajar una tecla
Al subir una tecla
Al presionar una tecla

No es necesario escribir cdigo que responda a todos los eventos de un objeto, slo
a aquellos que nos interese.

Veamos a continuacin un ejemplo de como agregar un manejador de eventos para
responder a un evento:

Creamos un nuevo formulario en la vista de diseo e insertamos un botn de
comando con el texto Aceptar y el nombre BtnAceptar.

Nos vamos a las propiedades del objeto y en la seccin eventos elegimos el
evento ms adecuado, en este caso Al hacer clic y pulsamos el botn

Nos aparecer una ventana en la que elegimos el generador, en nuestro
caso el generador de cdigo.


Una vez hecho clic nos aparecer la ventana de edicin de Visual Basic,
desde la que podemos introducir cdigo en VBA.

Si nos fijamos en la ventana anterior, aparece un procedimiento Sub (con la
palabra reservada private
1
delante) llamado como el nombre del objeto, un guin
bajo y el nombre del evento. Este procedimiento de evento es el manejador de
evento propiamente dicho y su cdigo se almacenara en el formulario. Puede que
nos interese escribir aqu todo el cdigo necesario para manejar ese evento o bien
realizar una llamada a una subrutina contenida en un mdulo. En nuestro caso
llamaremos a la subrutina ejemplo, que nos permita calcular la multiplicacin de
dos nmeros y la divisin del mayor entre el menor (Ejemplo de uso de funciones).

Escribimos el cdigo necesario para nuestro manejador de eventos

1
La palabra reservada private indica que a esta subrutina slo se puede acceder
desde otras subrutinas del mismo mdulo, formulario o informe.

Guardamos nuestro cdigo, cerramos el editor de Visual Basic y probamos el
correcto funcionamiento de nuestro botn en la en la vista formulario.

6.1 ASIGNAR EVENTOS A LOS ELEMENTOS DE UN FORMULARIO

Para realizar una correcta aplicacin de bases de datos es conveniente realizar un
estudio de los manejadores de eventos necesarios para cada formulario. Veamos un
ejemplo con el siguiente formulario:

En este caso necesitaremos dos manejadores de eventos para el evento Al hacer
clic de los dos botones, imprimir y cancelar, que realizarn las acciones oportunas.

Adems, necesitaremos un manejador para el grupo de opciones en el evento
Despus de actualizar que cambie el estado del cuadro combinado provincia (de
activado a desactivado y viceversa).

6.2 EVENTOS

A continuacin se dar una breve explicacin de los eventos que se producen en los
distintos objetos.

6.2.1 EVENTOS DE FORMULARIO

En los formularios los eventos se producen cuando se abren, se cambia de registro,
se cierran veamos a continuacin los ms importantes:

6.2.1.1 AL ABRIR:

Se produce cuando se abre un formulario, antes que se muestre el primer registro.

Posibles usos:

Cerrar una ventana
Mover el foco a un determinado registro
Comprobar si se dispone de la informacin necesaria para poder abrir el
formulario (solicitar una contrasea y si no es correcta cancelar la apertura)

Ejemplo: solicitamos una contrasea para poder abrir un formulario:


6.2.1.2 AL CARGAR:

Se produce despus de abrir un formulario para mostrar sus registros.

Posibles usos:

Asignar valores predeterminados para los controles
Solicitar el nombre del usuario que utilizar el formulario.

6.2.1.3 AL ACTIVAR REGISTRO:

Se produce cuando el foco se mueve de registro, convirtindolo en el registro
actual. Este evento se produce cuando un formulario se abre y siempre que el foco
pasa de un registro a otro.

Posibles usos:

Mostrar un mensaje con el nombre del registro actual
Mostrar los pedidos de un determinado cliente cuando su registro es el
actual en un mensaje
Cambiar el ttulo del formulario por un campo del registro actual.

Ejemplo: cambiamos el ttulo del formulario a medida que el usuario cambia de
registro

6.2.1.4 AL ELIMINAR:

Se produce cuando el usuario pulsa la tecla SUPR para eliminar un registro, pero
antes de que se llegue a eliminar realmente el registro.

Posibles usos:

Evitar eliminaciones errneas de registros.

Ejemplo: pedimos confirmacin para eliminar un registro


6.2.1.5 AL DESCARGAR:

Se produce cuando se pulsa el botn para cerrar un formulario. Se produce antes
de cerrar el formulario realmente y permite su cancelacin.

Posibles usos:

Evitar cerrar el formulario por error

Ejemplo: evitaremos que el formulario se cierre por error pidiendo confirmacin

6.2.1.6 AL CERRAR:

Se produce cuando un formulario se cierra y se quita de la pantalla.

Posibles usos:

Abrir una ventana al cerrar el formulario.
Limpiar informacin intermedia que haya sido usada por el formulario.
Almacenar en una tabla el nombre del usuario que utiliz el formulario.

6.2.2 EVENTOS DE CONTROL

Un control es cada elemento de un formulario, como un botn, un cuadro
combinado

6.2.2.1 AL HACER CLIC:

Se produce cuando el usuario presiona y a continuacin suelta el botn izquierdo
del ratn mientras el puntero se encuentra sobre un control.

Ejemplo: mostrar un mensaje al hacer clic en un botn

6.2.2.2 AL HACER DOBLE CLIC:

Se produce cuando el usuario presiona y suelta el botn del ratn dos veces
rpidamente.

Ejemplo: mostrar un mensaje al hacer doble clic en un botn

6.2.2.3 AL RECIBIR EL ENFOQUE:

Se produce cuando un control recibe el foco, el foco viene determinado por una fila
de hormigas o la presencia del cursor. El foco se recibe haciendo clic o pulsando la
tecla TAB. Un control solo puede recibir el foco si el control est visible.

6.2.2.4 AL PERDER EL ENFOQUE:

Se produce cuando un control pierde el foco, evidentemente por que otro control lo
recibe.

Posibles usos:

Se suele utilizar para validar los datos introducidos en un control antes de
pasar al siguiente.

Ejemplo: comprobamos que el nmero introducido en un cuadro de texto es menor
que 100, si no mostramos un mensaje.

6.2.2.5 AL CAMBIAR:

Se produce cuando cambia el contenido de un cuadro de texto o un cuadro
combinado. El evento Al cambiar no se produce cuando un valor cambia en un
control calculado.

Posibles usos:

Puede ser interesante actualizar una lista, por ejemplo de provincias, si
cambia la seleccin de un cuadro combinado, por ejemplo pases.

6.2.2.6 AL NO ESTAR EN LA LISTA:

Se produce cuando el usuario introduce un valor en un cuadro combinado que no
est en el mismo. Este evento permite que el usuario agregue un nuevo valor a la
lista del cuadro combinado.

El evento Al no estar en la lista slo se produce si la propiedad Limitar a la lista
del cuadro combinado est establecida en S.

6.2.2.7 ANTES DE ACTUALIZAR Y DESPUS DE ACTUALIZAR:

Se desencadenan cuando se cambia un control o un registro. Tambin cuando se
elige otra opcin de un grupo de opciones. El evento Antes de actualizar se
produce antes de que se actualicen los datos y el evento Despus de actualizar
despus de la actualizacin.

Ejemplo: cuando se elige la otra opcin de un grupo de dos opciones se cambia el
estado de un control de activado a desactivado o viceversa.

6.3 OBJETOS

Los objetos son un tipo de variables especiales, pues contienen cdigo y datos en la
misma unidad. Pueden ser vistos como variables que adems de los datos tambin
disponen de funciones y procedimientos que permiten manejar esos datos.

Por lo tanto un objeto es una unidad independiente que proporciona propiedades y
mtodos para su uso. Para poder usar un objeto slo es necesario conocer sus
propiedades y mtodos, no como estos realizan internamente las acciones.

Los formularios, los informes y las tablas son ejemplos de objetos. Los botones de
comando y otros controles tambin son ejemplos. Hay objetos que no se ven como
los botones o los cuadros combinados, son los objetos internos de Access, como el
objeto DoCmd.

6.3.1 PROPIEDADES

Una propiedad es un atributo de un objeto, se puede definir como las
caractersticas de un objeto. Muchas de estas propiedades aparecen en el dilogo
propiedades al pulsar con el botn derecho en un objeto (un control o un
formulario por ejemplo). Por ejemplo, un botn de comando es un objeto, una
propiedad de ese objeto es si est activado o desactivado.


6.3.2 MTODOS

Un mtodo es una accin que un objeto puede realizar. Los mtodos sirven para
consultar o para modificar las propiedades de los objetos. Por ejemplo, el objeto
DoCmd sirve para ejecutar acciones, un mtodo de este objeto nos permite abrir
formularios. Veamos un ejemplo:

Como vemos hemos usado el mtodo OpenForm para lograr nuestro objetivo. Cada
objeto tiene sus propios mtodos.

6.4 UTILIZACIN DE PROPIEDADES Y MTODOS

Para referirse a una determinada propiedad de un determinado objeto es necesario
utilizar la siguiente sintaxis:

NombreDeObjeto.NombreDePropiedad

Observe la utilizacin del operador . Para separar el nombre del objeto de la
propiedad.

Por lo tanto para asignar un valor a una propiedad es necesario utilizar la siguiente
sintaxis:

NombreDeObjeto.NombreDePropiedad = valor

Un ejemplo lo obtendremos explicando ms en profundidad un caso anterior:

Si observamos el ejemplo anterior, modificamos la propiedad enabled del objeto
provincias, asignndole la misma propiedad pero cambiada. Es decir si la propiedad
estaba en verdadero nosotros la ponemos a falso y si estaba en falso la ponemos
en verdadero. La propiedad enabled determina si un objeto (en este caso
provincias es un cuadro combinado) est activado o desactivado.

Como hemos visto los mtodos son operaciones integradas que realiza el objeto.
Mediante el uso de mtodos, puede controlar el comportamiento del objeto. Para
utilizar un mtodo de un objeto es necesaria la siguiente sintaxis:

NombreDeObjeto.NombreDeMtodo(argumento1, argumento2,)

Observe de nuevo la utilizacin del operador . como separacin.
Un ejemplo:

Utilizamos el mtodo SetFocus del objeto Texto1 que lo que hace es asignarle el
foco a ese objeto. En este caso el mtodo SetFocus no lleva argumentos.

Su utilizacin es muy similar a los procedimientos Sub y a las funciones, que ya
hemos visto, slo se diferencian en que ahora llevan el nombre del objeto sobre el
que operar delante del punto.

Para simplificar el concepto de propiedades y mtodos considere las propiedades
como adjetivos y los mtodos como verbos.

En la ventana de edicin de Visual Basic, justamente despus de poner el nombre
de un objeto y un punto, se activan todas las propiedades y mtodos disponibles
para ese objeto, en caso de no ser as, presionar las teclas <Ctrl>+<J>. Para
distinguir unas de otros slo es necesario fijarse en el icono que aparece al lado.

El icono representa propiedades y el icono representa mtodos.

6.5 MATRICES (ARRAYS)

Una matriz es un conjunto de elementos que tienen el mismo tipo de datos y que
estn ordenados secuencialmente. Cada elemento de una matriz posee un nmero
de ndice nico que lo identifica. Los cambios efectuados a un eleme nto de una
matriz no afectan a los dems elementos.

Se puede declarar una matriz para operar con un conjunto de valores del mismo
tipo de datos. Una matriz es una nica variable con muchos elementos en que se
pueden almacenar valores, mientras que una variable normal tiene slo un rea de
almacenamiento en el que slo se puede archivar un valor. Puede referirse a la
matriz como un todo cuando se trata de hacer referencia a todos los valores que
contiene, o bien hacer referencia a sus elementos individuales.

Por ejemplo, para almacenar los gastos diarios de todos los das del ao se puede
declarar una variable matriz con 365 elementos, mejor que declarar 365 variables.
Cada elemento de una matriz contiene un valor. La siguiente instruccin declara la
variable matriz curGastos con 365 elementos. Si no se especifica lo contrario, el
ndice de una matriz comienza por el cero, con lo que el lmite superior de la matriz
es 364 en vez de 365.

Para dar valor a un elemento individual, es preciso especificar el ndice del
elemento. El siguiente ejemplo asigna un valor inicial de 20 a todos los elementos
de la matriz.

6.5.1 CAMBIAR EL LMITE INFERIOR

Se puede usar la instruccin Option Base al principio de un mdulo para cambiar
el ndice predefinido del primer elemento del 0 al 1. En el siguiente ejemplo, la
instruccin Option Base cambia el ndice del primer elemento y la instruccin Dim
declara la variable matriz curGastos con 365 elementos.

Tambin se puede fijar de forma explcita el lmite inferior de una matriz mediante
el uso de la clusula To tal y como muestra el siguiente ejemplo.

6.5.2 ALMACENAR VALORES VARIANT EN MATRICES

Hay dos formas de crear matrices de valores Variant. Una forma consiste en
declarar una matriz como del tipo de datos Variant, tal y como muestra el siguiente
ejemplo:

La otra forma consiste en asignar la matriz que devuelve la funcin Matriz a una
variable Variant, tal y como muestra el siguiente ejemplo.

Los elementos de una matriz de valores Variant se identifican mediante su ndice,
sea cual sea la tcnica que se haya usado para crear la matriz. Por ejemplo, la
siguiente instruccin podra aadirse a cualquiera de los ejemplos anteriores.

6.5.3 UTILIZAR MATRICES CON MLTIPLES DIMENSIONES

En Visual Basic se pueden declarar matrices con hasta 60 dimensiones. Por
ejemplo, la siguiente instruccin declara una matriz de dos dimensiones, de 5 por
10.

Si considera a la matriz como una tabla de dos entradas, el primer argumento
representara a las filas y el segundo a las columnas.

Utilice instrucciones For...Next para operar con matrices de dimensiones mltiples.
El siguiente procedimiento llena una matriz bidimensional con valores Single.

CAPTULO 7: PROGRAMACIN EN
ADO

A travs de ADO (Active Data Objects) tendremos la posibilidad, a travs de cdigo,
de generar una conexin a una base de datos y manipular su informacin.

ADO define un modelo de programacin: la secuencia de actividades necesarias
para tener acceso y actualizar un origen de datos.

El modelo de programacin sugiere un modelo de objetos: el conjunto de objetos
que corresponde e implementa el modelo de programacin. Los objetos poseen
mtodos, que realizan algunas operaciones en los datos, y propiedades, que
representan algunos atributos de los datos o controlan el comportamiento de
algunos mtodos de objetos.

Asociados con estos objetos estn los eventos, que son notificaciones de que
algunas operaciones han sucedido o estn a punto de suceder.

ADO proporciona los medios para realizar la siguiente secuencia de acciones:

Conectarse a un origen de datos. Opcionalmente, puede asegurarse de que
todos los cambios del origen de datos se realicen correctamente o no se
realice ninguno.

Especificar un comando para tener acceso al origen de datos, opcionalmente
con parmetros variables o con el mejor rendimiento.

Ejecutar el comando.

Si el comando hace que los datos se devuelvan en forma de filas en una
tabla, almacenar las filas en una cach que se pueda examinar, tratar o
cambiar con facilidad.

Si corresponde, actualizar el origen de datos con los cambios de las filas de
la cach.

Proporcionar un medio general para detectar los errores (normalmente,
como resultado de establecer una conexin o ejecutar un comando).

7.1 MODELO DE PROGRAMACIN ADO

El objetivo de ADO es tener acceso, modificar y actualizar orgenes de datos. El
modelo de programacin representa la secuencia de actividades necesarias para
alcanzar este objetivo.

7.2 RESUMEN DE OBJETOS DE ADO

OBJETO DESCRIPCIN
Connection Permite el intercambio de los datos.
Command Representa una sentencia SQL.
Parameter Representa un parmetro de una sentencia SQL.
Recordset Permite la exploracin y tratamiento de los datos.
Field Representa una columna de un objeto Recordset o Record.
Error Representa un error en una conexin.
Property Representa una caracterstica de un objeto de ADO.
Record Representa un directorio o un archivo.
Stream Representa el contenido de un archivo.

7.3 ABRIR UNA CONEXIN (OBJETO CONNECTION)

Se necesita una forma de establecer las condiciones necesarias para intercambiar
datos, es decir, una conexin. El origen de datos al que se conecta se establece en
una cadena de conexin, aunque los parmetros que se especifican pueden variar
segn el proveedor y el origen de datos.

La forma principal en que ADO abre una conexin es con el mtodo
Connection.Open. Tambin puede llamar al mtodo abreviado Recordset.Open,
tanto para abrir una conexin como para emitir un comando a travs de dicha
conexin en una sola operacin.

El objeto Connection representa una sesin nica con un origen de datos. En el
caso de un sistema de base de datos cliente-servidor, puede ser equivalente a una
conexin de red real con el servidor. Segn la funcionalidad que admita el
proveedor, puede que algunas colecciones, mtodos o propiedades del objeto
Connection no estn disponibles.

Con las colecciones, mtodos y propiedades del objeto Connection, puede hacer lo
siguiente:

Configurar la conexin antes de abrirla con las propiedades
ConnectionString, ConnectionTimeout y Mode. ConnectionString es la
propiedad predeterminada del objeto Connection.

Establecer la propiedad CursorLocation para invocar el Servicio de cursores
para OLE DB, que acepta actualizaciones por lotes.

Establecer la base de datos predeterminada de la conexin con la propiedad
DefaultDatabase.

Establecer el nivel de aislamiento de las transacciones abiertas en la
conexin con la propiedad IsolationLevel.

Especificar un proveedor de OLE DB con la propiedad Provider.

Establecer, y ms tarde terminar, la conexin fsica con el origen de datos
con los mtodos Open y Close.

La manera de definir una conexin en VBA es declarando una variable que haga
referencia al objeto Connection.

A continuacin, para establecer la conexin con la base de datos actual de Access:

Al finalizar el procedimiento, cerramos la conexin y quitamos la variable de objeto
de la memoria del siguiente modo:

7.4 CREAR UN COMANDO (OBJETO COMANDO)

Un comando es una instruccin que puede entender el proveedor de datos que va a
modificar, administrar o tratar el origen de datos. Los comandos se suelen escribir
en SQL, aunque no se requiere ningn lenguaje de comandos determinado. Un
comando de consulta solicita que el proveedor de datos devuelva un objeto
Recordset con filas de informacin.

El objeto Command define un comando especfico que puede ejecutar contra un
origen de datos.

Utilice el objeto Command para consultar una base de datos y obtener registros en
un objeto Recordset, para ejecutar una operacin masiva de datos o para tratar la
estructura de una base de datos. Segn la funcionalidad del proveedor, algunas
colecciones, mtodos o propiedades Command pueden generar un error cuando se
les hace referencia.

Con las colecciones, mtodos y propiedades del objeto Command, puede hacer lo
siguiente:

Definir el texto ejecutable del comando (por ejemplo, una instruccin SQL)
con la propiedad CommandText.

Definir consultas parametrizadas o argumentos de procedimientos
almacenados con los objetos Parameter y la coleccin Parameters.

Ejecutar un comando y obtener un objeto Recordset si resulta apropiado con
el mtodo Execute.

Especificar el tipo de comando con la propiedad CommandType antes de la
ejecucin para optimizar el rendimiento.

Controlar si el proveedor guarda una versin preparada (o compilada) del
comando antes de la ejecucin, con la propiedad Prepared.
Establecer el nmero de segundos que el proveedor espera a que el
comando se ejecute, con la propiedad CommandTimeout.

Asociar una conexin abierta con un objeto Command mediante el
establecimiento de su propiedad ActiveConnection.

Establecer la propiedad Name para identificar el objeto Command como
mtodo del objeto Connection asociado.

Pasar un objeto Command a la propiedad Source de un Recordset para
obtener los datos.

Para ejecutar una consulta sin utilizar un objeto Command, pase una cadena de
consulta al mtodo Execute de un objeto Connection o al mtodo Open de un
objeto Recordset.

7.5 TRATAR LOS DATOS (OBJETO RECORDSET)

La mayor parte de las propiedades y mtodos del objeto Recordset estn
destinadas a examinar, tratar y desplazarse por los datos del Recordset.

Se puede considerar el Recordset como una matriz de filas. La fila que se puede
examinar y tratar en cualquier momento es la fila actual y su ubicacin en el
Recordset es la posicin de la fila actual. Cada vez que se mueve a otra fila, dicha
fila se convierte en la nueva fila actual.

Varios mtodos se mueven o se "desplazan" explcitamente por el Recordset (los
mtodos Move). Algunos mtodos (el mtodo Find) lo hacen como efecto
secundario de su funcionamiento. Adems, al establecer determinadas propiedades
(propiedad Bookmark) tambin puede cambiarse su posicin en las filas. La
propiedad CursorType del objeto Recordset o el parmetro CursorType del
mtodo Open determinan si puede desplazarse hacia delante y hacia atrs por el
Recordset.

La propiedad Filter controla las filas a las que se puede tener acceso (es decir, las
filas que se pueden "ver"). La propiedad Sort controla el orden en que se desplaza
por las filas del Recordset.

Puede crear filas con el mtodo AddNew o suprimirlas con el mtodo Delete.

Cada Recordset tiene una coleccin Fields que es el conjunto de objetos Field que
representan cada campo o cada columna de una fila. Con la propiedad Value del
objeto Field puede asignar o recuperar los datos de los campos. Con el mtodo
GetRows tambin puede tener acceso a los datos del campo de forma global. Una
vez que ha modificado el Recordset, propague los cambios al origen de datos con
los mtodos Update.

Cuando se utiliza ADO, los datos se tratan de forma casi completa con objetos
Recordset. Todos los objetos Recordset estn formados por registros (filas) y
campos (columnas).

En ADO hay cuatro tipos diferentes de cursores (elemento de la base de datos que
controla el desplazamiento a travs de registros):

Cursor dinmico: permite ver las inserciones, cambios y eliminaciones de
otros usuarios; todos los tipos de movimientos a travs del Recordset que
no se basen en marcadores; y los marcadores si el proveedor los acepta.
(adOpenDynamic)

Cursor de conjunto de claves: se comporta como un cursor dinmico,
excepto en que impide ver registros agregados por otros usuarios y el
acceso a registros eliminados por otros usuarios. Los cambios en los datos
efectuados por otros usuarios siguen siendo visibles. Siempre acepta
marcadores y, por lo tanto, permite todos los tipos de movimientos a travs
del Recordset. (adOpenKeyset)

Cursor esttico: proporciona una copia esttica de un conjunto de registros
para usarlos en bsquedas de datos o en la generacin de informes; siempre
permite los marcadores y, por lo tanto, todos los tipos de movimientos a
travs del Recordset. Las inserciones, cambios o eliminaciones efectuados
por otros usuarios no sern visibles. ste es el nico tipo de cursor permitido
cuando se abre un objeto Recordset en la capa de cliente. (adOpenStatic)

Cursor de desplazamiento slo hacia adelante: slo permite recorrer el
objeto Recordset movindose hacia delante. Las inserciones, cambios o
eliminaciones efectuados por otros usuarios no sern visibles. Esto aumenta
el rendimiento en situaciones en las que slo hay que efectuar un paso a
travs de un Recordset. (adOpenForwardOnly)

Establezca la propiedad CursorType antes de abrir el Recordset para elegir el tipo
de cursor o pase un argumento CursorType con el mtodo Open.

Se pueden crear tantos objetos Recordset como sea necesario.

Cuando se abre un Recordset, el registro actual se sita en el primer registro (si lo
hay) y las propiedades BOF y EOF se establecen a False. Si no hay registros, los
valores de las propiedades BOF y EOF son True.

Siempre que el proveedor admita la funcionalidad necesaria para ello, se pueden
usar los mtodos MoveFirst, MoveLast, MoveNext y MovePrevius, as como el
mtodo Move, y las propiedades AbsolutePosition, AbsolutePage y Filter para
colocar el registro actual. Los objetos Recordset de desplazamiento slo hacia
adelante slo aceptan el mtodo MoveNext . Cuando utilice los mtodos Move para
visitar todos los registros (o para enumerar el Recordset), puede utilizar las
propiedades BOF y EOF para saber si ha llegado al principio o al final del objeto
Recordset.

Los objetos Recordset pueden aceptar dos tipos de actualizacin: inmediata y por
lotes. En la actualizacin inmediata, todos los cambios se escriben inmediatamente
en el origen de datos subyacente al llamar al mtodo Update. Tambin se pueden
pasar matrices de valores como parmetros con los mtodos AddNew y Update, y
actualizar de forma simultnea varios campos de un registro.

7.5.1 MTODO OPEN

Open abre un cursor.

Sintaxis:

recordset.Open Source, ActiveConnection, CursorType, LockType, Options

Parmetros:

Source: Opcional. Un valor Variant que da como resultado un objeto Command
vlido, instruccin SQL, nombre de tabla, procedimiento almacenado, direccin URL
o nombre de un archivo u objeto Stream que contiene un objeto Recordset
almacenado de forma persistente.

ActiveConnection: Opcional. Un valor Variant que da como resultado una variable
de objeto Connection vlida, o un valor String que contiene los parmetros de
ConnectionString.

CursorType: Opcional. Un valor de la enumeracin CursorTypeEnum que determina
el tipo de cursor que el proveedor tiene que usar al abrir el objeto Recordset. El
valor predeterminado es adOpenForwardOnly.

LockType: Opcional. Un valor de la enumeracin LockTypeEnum que determina el
tipo de bloqueo (simultaneidad) que el proveedor tiene que usar al abrir el objeto
Recordset. El valor predeterminado es adLockReadOnly.

Options: Opcional. Valor Long que indica cmo el proveedor tiene que evaluar el
argumento Source si representa algo distinto de un objeto Command o que el
objeto Recordset se tiene que restaurar a partir de un archivo donde se guard
anteriormente. Puede ser uno o varios valores de la enumeracin
CommandTypeEnum o ExecuteOptionEnum.

Ejemplo:

7.5.2 METODO CLOSE

Close cierra un objeto abierto y cualquier otro dependiente.

Sintaxis:

object.Close

Utilice el mtodo Close para cerrar un objeto Connection, Record, Recordset o
Stream y liberar recursos de sistemas asociados. Al cerrar un objeto no se quita de
la memoria; se pueden cambiar los valores de sus propiedades y volver a abrirlo
ms tarde. Para eliminar completamente un objeto de la memoria, establezca la
variable del objeto a Nothing (en Visual Basic) despus de cerrarlo.

Ejemplo:

7.5.3 EXPLORACION DE REGISTROS (METODOS MOVE Y PROPIEDADES
BOF / EOF)

Los mtodos MoveFirst, MoveLast, MoveNext y MovePrevious pasan al primer,
ltimo, siguiente o anterior registro de un objeto Recordset especificado y lo
convierte en el registro actual.

Sintaxis:

recordset.{MoveFirst | MoveLast | MoveNext | MovePrevious}

Comentarios:

Utilice el mtodo MoveFirst para mover la posicin del registro actual al primer
registro del Recorset.

Utilice el mtodo MoveLast para mover la posicin del registro actual al ltimo
registro del Recordset. El objeto Recordset tiene que aceptar marcadores o permitir
el movimiento hacia atrs del cursor; si no, la llamada al mtodo generar un error.
Utilice el mtodo MoveLast para mover la posicin del registro actual al ltimo
registro del Recordset.

Utilice el mtodo MoveNext para mover la posicin del registro actual un registro
hacia delante (hacia el final del Recordset). Si el ltimo registro es el actual y se
llama al mtodo MoveNext, ADO establece el registro actual a la posicin posterior
al ltimo registro del Recordset (EOF es True). El intento de avanzar cuando la
propiedad EOF ya es True genera un error.

En los casos en que se ha filtrado u ordenado el Recordset y han cambiado los
datos del registro actual, tambin puede cambiar la posicin. En tales casos, el
mtodo MoveNext funciona con normalidad, pero es necesario tener en cuenta que
la posicin se mueve un registro hacia delante a partir de la nueva posicin, no de
la antigua. Por ejemplo, cambiar los datos del registro actual, de forma que el
registro se mueva hasta el final del Recordset que se ha ordenado, implicara que
llamar a MoveNext tendra como resultado que ADO estableciera el registro actual a
la posicin posterior al ltimo registro del Recordset (EOF = True).

Utilice el mtodo MovePrevious para mover la posicin del registro actual un
registro hacia atrs (hacia el principio del Recordset). El objeto Recordset tiene que
aceptar marcadores o movimiento hacia atrs; si no, la llamada al mtodo generar
un error. Si el primer registro es el registro actual y se llama al mtodo
MovePrevious, ADO establece el registro actual a la posicin anterior al primer
registro del Recordset (BOF es True). El intento de retroceder cuando la propiedad
BOF ya es True genera un error. Si el objeto Recordset no acepta marcadores o no
permite el movimiento hacia atrs, el mtodo MovePrevious generar un error.

Si el Recordset es de desplazamiento slo hacia delante y desea desplazarse hacia
adelante y hacia atrs, puede utilizar la propiedad CacheSize para crear una cach
de registros que permita el movimiento hacia atrs mediante el mtodo Move.

Como los registros de la cach se guardan en la memoria, evite guardar en ella
ms registros de los estrictamente necesarios. Puede invocar el mtodo MoveFirst
en un objeto Recordset de desplazamiento slo hacia delante; si lo hace, el
proveedor vuelve a ejecutar el comando que gener el objeto Recordset.

La propiedad BOF indica que la posicin del registro actual est antes del primer
registro de un objeto Recordset.

La propiedad EOF indica que la posicin del registro actual est despus del ltimo
registro de un objeto Recordset.

Ambas propiedades devuelven valores boolean.

Esta tabla muestra qu mtodos Move se permiten con diferentes combinaciones
de las propiedades BOF y EOF.

MoveFirst,
MoveLast
MovePrevious,
Move < 0

Move 0
MoveNext,
Move > 0
BOF=True,
EOF=False
Permitido Error Error Permitido
BOF=False,
EOF=True
Permitido Permitido Error Error
Ambas True Error Error Error Error
Ambas False Permitido Permitido Permitido Permitido

Ejemplo:

Ejercicio 7: Recordsets

Crear un Recordset que, a partir de la conexin con la base de datos actual
y utilizando una instruccin SQL, actualice los sueldos de todos los
empleados aumentndolos un 3%.

y utilizando una instruccin SQL, muestre los nombre y apellidos de todos
aquellos empleados que tengan vehculo, ordenando el resultado por los
apellidos de los empleados.

y utilizando una instruccin SQL, agregue un nuevo registro a la tabla
Empleados con los siguiente valores:
Cdigo Empleado: 131
Nombre: Jos Javier
Apellidos: Carmona Lpez

Programacion Access

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programacion Access

Cargado por

Copyright:

Formatos disponibles

MANUAL DEL CURSO

También podría gustarte