Sei sulla pagina 1di 24
CURSO DE VB CAPÍTULO 10 1 Índice de contenido OBJETOS DE ACCESO A DATOS (I)
CURSO DE VB
CAPÍTULO 10 1
Índice de contenido
OBJETOS DE ACCESO A DATOS (I)
2
OBJETOS DE ACCESO A DATOS: DAO Y ADO
DAO
2
2
Un poco
de
teoría
2
Registro de la librería DAO
4
Un poco de práctica
5
Base de datos actual
5
Referencia
al espacio de trabajo: Workspace
5
Referencia
a
las
tablas
7
Referencia a las consultas
9
Referencia
a
los
campos
10
Otros objetos que existen y que no vamos a ver aquí
ALGUNOS CÓDIGOS INTERESANTES SOBRE LO QUE HEMOS VISTO
Creación de una tabla
Variación sobre el tema
Creación de una tabla: sistema rápido
Creación de una consulta
PARA FINALIZAR ESTE CAPÍTULO
12
12
13
18
20
22
24
1 La BD donde están los ejemplos de este capítulo os la podéis bajar aquí.
1
Visítame en http://siliconproject.com.ar/neckkito/
OBJETOS DE ACCESO A DATOS (I) Vamos a ver en este capítulo lo que se
OBJETOS DE ACCESO A DATOS (I)
Vamos a ver en este capítulo lo que se denominan “objetos
de acceso a datos”, que son DAO y ADO.
Según cómo se mire este es un tema “complicado”; según
cómo se mire, si se pillan los “fundamentos”, pues tampoco
es tan difícil operar con estos sistemas. Con ello quiero
decir que mi consejo, si seguís este capítulo, es que
analicéis con detenimiento lo que en él se explica y los
códigos de ejemplo, no tanto para “aprender” lo que hace el
código sino para “captar” la mecánica de cómo se utilizan
los distintos elementos que nos van a aparecer.
Para empezar este capítulo vamos a realizar una cosa inicial muy simple:
1.- Vamos, en una nueva base de datos, a crear una tabla, que llamaremos TTrabajadores.
Incluiremos dos campos, de la siguiente manera:
– [DNI] → Numérico y clave principal
– [Nombre] → Texto
Introducimos manualmente tres registros a lo rápido, como estos:
2.- Creamos un formulario sobre nuestra tabla TTrabajadores.
Vamos a llamarlo FTrabajadores.
3.- Insertamos, en la cabecera del formulario, un botón de
comando. Vamos a programar dicho botón con posterioridad.
Y, por ahora, lo dejamos aquí. Ya lo iremos utilizando a
medida que vayamos avanzando en el capítulo.
Y sin más preámbulos, os presento a
OBJETOS DE ACCESO A DATOS: DAO Y ADO
Para poder manipular datos (y cuando digo manipular datos me refiero a buscar datos,
actualizar datos, añadir datos, modificar datos
se denominan “objetos de acceso a datos”.
)
en tablas y consultas nos servimos de lo que
Tenemos dos modelos de “objetos de acceso a datos”: DAO y ADO. Vamos a ver en qué
consisten:
DAO
Un poco de teoría
Vamos con un poco de teoría, para aquellos a los que les guste esto de fardar de “siglas en
conversaciones sobre Access” (pronto entenderéis por qué digo esto de las siglas
ji, ji
)
La
biblioteca de objetos DAO (Data Access Objects) se enmarca en lo que podríamos denominar
dos bloques, a los que se les suele llamar “espacios de trabajo”.
Pensad en todo momento que la idea es acceder a datos, ya sea en una base de datos local o
una base de datos remota. Y claro, cuando empezamos a hablar de estas cosas aparece no
2
Visítame en http://siliconproject.com.ar/neckkito/
sólo la figura de Access, sino que también se suman a la fiesta diferentes sistemas
sólo la figura de Access, sino que también se suman a la fiesta diferentes sistemas gestores de
bases de datos.
El primero de esos “marcos” es el espacio de trabajo
ODBCDirect. El utilizar este espacio hace que sea posible
acceder a servidores de bases ODBC sin tener que pasar el
motor de la base de datos de Microsoft Office.
Por si puede clarificaros algo os copio lo que dice la ayuda
del propio Windows (como SO -Sistema Operativo-) sobre
utilizar orígenes de datos:
<<Puede utilizar la Conectividad abierta de base de datos de orígenes de datos (ODBC) para
tener acceso a datos desde una gran variedad de sistemas de administración de bases de datos. Por
ejemplo, si tiene un programa que obtiene acceso a los datos de una base de datos de SQL,
Orígenes de datos (ODBC) le permitirá usar el mismo programa para tener acceso a los datos de
una base de datos de Visual FoxPro. Para ello, debe agregar componentes de software al sistema,
llamados controladores. Orígenes de datos (ODBC) le ayuda a agregar y a configurar estos
controladores.>>
En definitiva, este espacio de trabajo estaría recomendado para ejecutar consultas, ejecutar
procedimientos (Sub) o funciones (Function) almacenados o funciones específicas de ODBC en
un servidor remoto.
Por cierto, ODBC significa Open DataBase Connectivity.
El segundo “marco” es el espacio de trabajo Microsoft Jet. A través de un controlador ISAM
nos permite acceder a bases de datos como Access, también a servidores de bases de datos
ODBC y a otras fuentes de datos externas que pueden ser tratadas como “bases de datos”,
como por ejemplo Excel, dBase, Paradox, etc.
Y, por cierto, ISAM significa Indexed Sequential Access Method.
Existe lo que se denomina una “Jerarquía de los objetos DAO”, donde se puede apreciar la
estructura de este modelo DAO. No entraremos en sus detalles (porque eso sí que sería teoría
pura y dura). Sólo nos vamos a quedar con un par de ideas:
– Existe un “padre” del que penden el resto de elementos. Es el objeto DBEngine. Este
objeto es único (no puede haber varios).
– Bajo DBEngine encontramos dos objetos: Error y Workspace)
– Bajo DBEngine podemos encontrar toda una serie de colecciones, que a su vez incluyen
todos los objetos de la colección
– Existe una colección que se denomina Properties (menos los objetos Error). Estas
colecciones Properties se refieren a todos los objetos DAO.
– Podemos encontrar “propiedades” y “métodos” en los objetos DAO
Como veis, la cosa es un poco confusa porque estos términos se entrecruzan, y resulta un
poco difícil explicarlo (¡y que conste que intento hacerlo lo mejor posible!).
Vamos a ver un ejemplo: vamos a manipular un método de un objeto DAO. El objeto será
DBEngine, y el método será CompactDatabase (no hace falta que os diga qué significa eso).
Una vez tenemos claro qué es cada cosa podemos escribir:
Private Sub
DBEngine.CompactDatabase “c:\MisBDs\miSuperBD.accdb”
3
Visítame en http://siliconproject.com.ar/neckkito/
End Sub …. Si lo que queremos es utilizar una propiedad la sistemática sería similar:
End Sub
….
Si lo que queremos es utilizar una propiedad la sistemática
sería similar: objeto.propiedad. Por ejemplo:
Private Sub
MsgBox “Mi versión del motor Microsoft Jet es “ &
DBEngine.Version
End Sub
¿Cómo distinguirlos? Afortunadamente el editor de VB nos lo pone fácil. Si nos situamos en
dicho editor y escribimos DBEngine. veremos que automáticamente nos aparece un “chivato”
que nos muestra los métodos y propiedades aceptados para ese objeto. Es decir, que nos
debería aparecer una cosa así:
La “manita con la tarjeta” (por llamarlo de una manera) indica que nos estamos refiriendo a
una propiedad; la “goma de borrar que corre” (también por llamarlo de alguna manera) nos
indica que estamos ante un método 2 .
Registro de la librería DAO
Si bien a partir de Access 2007 no es necesario indicar, en el código, que nos estamos
refiriendo a un objeto DAO, en Access 2003 sí es necesario indicárselo. Y para poder
indicárselo al código es necesario añadir la librería DAO.
Para ello, en el editor de VB, debemos irnos a Menú Herramientas → Referencias
y buscar la
referencia “Microsoft DAO 3.6 Object Library”. Marcamos el check y aceptamos. Ya tenemos así
la biblioteca registrada.
Si en el peor de los casos no nos apareciera esta referencia deberíamos buscarla en nuestro PC
(o bajárnosla de Internet y añadirla a nuestro sistema). El archivo se llama DAO360.dll.
Usualmente suele estar en <C:\Archivos de programa\ Archivos comunes\Microsoft
Shared\DAO>
Si tenemos ganas de leer podemos acudir al archivo DAO360.chm, que es el archivo de ayuda
de esta librería. Su ubicación depende de nuestra versión de Office, pero en mi caso está en la
dirección <C:\Archivos de programa\Archivos comunes\Microsoft Shared\OFFICE12\3082>
2 No es objetivo de este curso explicar todas las propiedades y todos los métodos de todas las colecciones. Si estáis
interesados en algún elemento en particular os recomiendo que en el editor de VB escribáis, con esta ayuda
contextual, el que os interese y, una vez escrito, os situéis sobre lo escrito (o lo seleccionéis todo). Tras eso pulsad
F1 y la ayuda de Access os dará una explicación de lo que es, lo que puede hacer y, con suerte, os mostrará un
ejemplo. Yo sólo os explicaré los que, a mi criterio, pienso que os podrían ser más útiles.
4
Visítame en http://siliconproject.com.ar/neckkito/
Un poco de práctica Base de datos actual Debemos tener presente que cuando nos queremos
Un poco de práctica
Base de datos actual
Debemos tener presente que cuando nos queremos referir a
la BD en la que estamos debemos utilizar la palabra
<CurrentDB>.
Normalmente se suele referenciar la base de datos a través de la
variable dbs. Su declaración suele ser de la siguiente manera:
Dim dbs as Database
o también
Dim dbs as DAO.Database
Para asignarle valor utilizamos el SET, de la siguiente manera:
Set dbs = CurrentDb
Al acabar nuestro código es buena idea cerrar la conexión y liberar memoria. Esto se hace de
la siguiente manera:
dbs.Close
Set dbs = Nothing
Vayámonos a nuestra base de datos de ejemplo. Vamos a crear un formulario en blanco y lo
llamaremos FDAO. En un botón de comando insertamos el siguiente código:
Private Sub cmdIDBD_Click()
Dim dbs As DAO.Database
Set dbs = CurrentDb
MsgBox "Mi base de datos está en/se llama " & dbs.Name, vbInformation, "BD DNI"
dbs.Close
Set dbs = Nothing
End Sub
Si ejecutamos el código veremos como dbs nos devuelve, a través de un MsgBox, la ruta,
nombre y extensión de la base de datos.
Referencia al espacio de trabajo: Workspace
Cuando trabajamos en Access trabajamos en un “espacio de trabajo”. Y como tal, podemos
identificarlo y manipularlo.
Vamos a ver cómo saber cómo se llama nuestro Workspace (no os ilusionéis, puesto que la
respuesta puede ser un poco decepcionante).
Para ello creamos el siguiente código:
Private Sub cmdWrkSce_Click()
Dim wrk As DAO.Workspace
5
Visítame en http://siliconproject.com.ar/neckkito/
Dim miWrk As String Set wrk = DBEngine.Workspaces(0) miWrk = wrk.Name MsgBox "Mi espacio de
Dim miWrk As String
Set wrk = DBEngine.Workspaces(0)
miWrk = wrk.Name
MsgBox "Mi espacio de trabajo se llama: " & miWrk,
vbInformation, "WORKSPACE"
End Sub
Si lo ejecutamos sabremos el nombre tan “inspirado y original” de
nuestro espacio de trabajo.
Vamos a crear otra BD en blanco, y la llamaremos Workspace.mdb (o Workspace.accdb).
Deberemos respetar la extensión con que la hayamos creado en el código que os indicaré a
continuación, simplemente. La pondremos en el mismo directorio donde tengamos nuestra BD
de pruebas.
Lo que vamos a hacer es abrir la BD Workspace en un nuevo espacio de trabajo activo, al que
llamaremos “SuperYo”, situando dicha base en modo de apertura exclusivo (con lo que
bloquearemos su acceso a otros hipotéticos usuarios). Tened en cuenta que cuando digo
“abrir” no estoy diciendo que se nos va a abrir la BD Workspace en pantalla, sino que se va a
abrir “inmaterialmente” (por llamarlo algo). De esta manera podemos acceder “en silencio” a la
nueva BD, operar sobre ella para lo que necesitemos y cerrarla.
Pondremos un pequeño MsgBox para que nos informe sobre qué Workspace y sobre qué BD
estamos operando en ese momento.
El código sería:
Private Sub cmdAbreBDWrkSpce_Click()
Dim wrk As Workspace
Dim dbs As Database
Dim miBd As String
miBd = Application.CurrentProject.Path & "\Workspace.mdb"
Set wrk = CreateWorkspace("SuperYo", "admin", "", dbUseJet)
Set dbs = wrk.OpenDatabase(miBd, True)
MsgBox "Ahora tengo abierta, en mi nuevo espacio de trabajo " & wrk.Name & _
", la BD: " & dbs.Name
dbs.Close
wrk.Close
Set dbs = Nothing
Set wrk = Nothing
End Sub
Aún no tenemos suficientes conocimientos para poder operar sobre esa BD “a distancia”, pero
más adelante vamos a reutilizar este código para poder manipular la BD Workspace.mdb
Tened en cuenta que el anterior código lo que hace son dos cosas:
– Crea un nuevo espacio de trabajo
– Abre la BD en ese nuevo espacio de trabajo
Podríamos decir, hablando muy en general, que los Workspaces nos permiten “administrar” la
BD. Es un tema un tanto complejo y quizás, a nuestro nivel, poco útil. El código anterior utiliza
un Workspace de manera puntual, sin añadirlo a la colección de Workspaces de la BD en la que
6
Visítame en http://siliconproject.com.ar/neckkito/
estamos operando. Si alguien está interesado en profundizar sobre este elemento debe hacer lo siguiente:
estamos operando. Si alguien está interesado en profundizar sobre este elemento debe hacer
lo siguiente:
– En el editor de VB, escribir la palabra Workspace
– Situarse sobre ella y pulsar F1
– De las opciones de ayuda, seleccionar el link
<Workspace (objeto)>
Ahí podrá encontrar información más detallada sobre el espacio de
trabajo.
Aprovecho para comentaros que podemos abrir una BD “a distancia” utilizando el Workspace
actual, sin usar uno adicional. De hecho, ni siquiera tenemos que hacer referencia al
Workspace. Para hacer lo anterior simplemente nuestro código podría ser:
Private Sub cmdAbreBDSinWrkSpc_Click()
Dim dbsExterna As DAO.Database
Dim BDExterna As String
BDExterna = Application.CurrentProject.Path & "\Workspace.mdb"
Set dbsExterna = DBEngine.OpenDatabase(BDExterna)
MsgBox "Acabo de abrir la BD: " & dbsExterna.Name, vbInformation, "BD EXTERNA"
dbsExterna.Close
Set dbsExterna = Nothing
End Sub
Referencia a las tablas
Para referenciar las tablas podemos utilizar la colección TableDefs. A su vez, podemos
manipular esta colección a través de sus métodos y propiedades.
Por ejemplo, para saber cuántas tablas tengo en mi base de datos podríamos utilizar este
código:
Private Sub cmdNumTablas_Click()
Dim dbs As DAO.Database
Dim i As Integer
Set dbs = CurrentDb
i = dbs.TableDefs.Count
i = i
- 9
MsgBox "Tengo " & i & " tablas en mi base de datos", vbInformation, "MIS TABLAS"
dbs.Close
Set dbs = Nothing
End Sub
Y ahora alguien me dirá: ¿por qué a la variable i le restas un 9? Buena pregunta
Cuando creamos una BD nueva automáticamente´se nos crean lo que se denominan “Objetos
del sistema”. Es decir, que se nos crean, usualmente, 9 tablas que contienen información sobre
el sistema. Estas tablas son manipulables a través de código. Si, nos situamos sobre el panel
de exploración (Access 2007) y hacemos click con el botón derecho del ratón → Opciones de
exploración, y marcamos el check “Mostrar objetos del sistema”, veremos como nos aparecen
nuestras tablas de sistema.
7
Visítame en http://siliconproject.com.ar/neckkito/
Se caracterizan porque su nombre empieza por MSys. Podemos crear tablas de sistema propias. Para
Se caracterizan porque su nombre empieza por MSys.
Podemos crear tablas de sistema propias. Para ello
deberíamos guardar la tabla con un nombre que comenzara
por USys. Hablaremos de esto en capítulos posteriores.
¿Y cuáles son los nombres de nuestras tablas? Un simple
código nos lo dirá:
Private Sub cmdNomTablas_Click()
Dim dbs As DAO.Database
Dim i As Integer
Set dbs = CurrentDb
For i = 0 To dbs.TableDefs.Count - 1
MsgBox dbs.TableDefs(i).Name
Next
dbs.Close
Set dbs = Nothing
End Sub
Fijaos que hemos hecho: For i = 0 … ¿Por qué cero? Porque los miembros de una colección
empiezan siempre su numeración por cero, y por ello debemos empezar por dicho número.
Como consecuencia, en el conteo total debemos restar una unidad, de ahí lo de
For i = 0 To dbs.TableDefs.Count - 1
Ahora os pido que “abráis vuestra mente” y recordéis lo que hemos visto en capítulos
anteriores. En realidad, si os sirve de guía, el fondo del asunto es que disponemos de un
conjunto de piezas de un mecano y debemos organizarlas a nuestra manera. ¿Por qué digo
esto? Porque el código anterior nos muestra todas las tablas de nuestra BD (las nuestras y las
del
sistema), lo cual es un auténtico “rollo”.
Mi
pregunta es: ¿a alguien se le ocurre cómo podemos “arreglar” esto? Os aseguro que ya
sabéis hacerlo
Bueno. Si no se ha encendido la bombilla no pasa nada, pues todo es cuestión de práctica.
Acabamos de decir que las tablas de sistema empiezan su nombre por MSys, ¿verdad? Pues
vamos a crear un código que nos “salte” las tablas que empiezan por estas letras. Un posible
código sería el siguiente:
Private Sub cmdTablasNoStma_Click()
Dim dbs As DAO.Database
Dim i As Integer
Set dbs = CurrentDb
For i = 0 To dbs.TableDefs.Count - 1
If Left(dbs.TableDefs(i).Name, 4) <> "MSys" Then
MsgBox dbs.TableDefs(i).Name
End If
Next
dbs.Close
Set dbs = Nothing
End Sub
8
Visítame en http://siliconproject.com.ar/neckkito/
… ¿Le vamos cogiendo el “truquillo”? Referencia a las consultas Igual que hemos hecho, en
¿Le vamos cogiendo el “truquillo”?
Referencia a las consultas
Igual que hemos hecho, en el epígrafe anterior, referencia a
las tablas, podemos hacer referencia a las consultas.
Pero, antes de que alguien me diga: “Y después referencia a los formularios, a los informes
os diré que, si repasamos la definición del modelo, veremos que estamos hablando de “acceso
a objetos que contienen datos”, como son las tablas y consultas. Los formularios y los informes
son una “interface” para mostrarlos, y, por tanto, no entran. Hay otros sistemas para acceder a
este tipo de objetos (que ya veremos en capítulos posteriores).
Siguiendo con nuestro hilo explicativo, para acceder a consultas utilizamos la colección
Querydefs
Vamos a crear, en nuestra BD, una consulta, que llamaremos CTrabajadores. Creamos pues
una simple consulta de selección sobre los datos de TTrabajadores.
Para saber cuántas consultas tenemos creadas utilizaríamos el siguiente código:
Private Sub cmdNumQueries_Click()
Dim dbs As DAO.Database
Dim i As Integer
Set dbs = CurrentDb
i = dbs.QueryDefs.Count
MsgBox "Tenemos " & i & " consultas en la BD", vbInformation, "CONSULTAS"
dbs.Close
Set dbs = Nothing
End Sub
Ejecutamos el código y
¿2 consultas? ¿Dónde está la otra?
Pues la otra está en el formulario FTrabajadores. ¿Recordamos que creamos este formulario
basado en la tabla TTrabajadores? En realidad es “como” si el formulario “consultara” los datos
de TTrabajadores a través de una consulta, y la colección Querydefs entiende que eso es
también una consulta.
A esa
consulta
“del
formulario”
Access
le
asigna
el
nombre,
en
nuestro
caso,
3
~sq_fFTrabajadores
Vaya
¡qué listo es Access! Vamos a arreglar un poco el código:
Private Sub cmdNumQueriesSinForm_Click()
Dim dbs As DAO.Database
Dim i As Integer, j As Integer
Set dbs = CurrentDb
3 Para conseguir el signo ~ podemos:
- Pulsar la combinación de teclas en el teclado numérico: ALT+126
- Pulsar la combinación de teclas ALT GR+4, y a continuación pulsamos la barra espaciadora
9
Visítame en http://siliconproject.com.ar/neckkito/
i = dbs.QueryDefs.Count For j = 0 To dbs.QueryDefs.Count - 1 If Left(dbs.QueryDefs(j).Name, 1) =
i = dbs.QueryDefs.Count
For j = 0 To dbs.QueryDefs.Count - 1
If Left(dbs.QueryDefs(j).Name, 1) = "~" Then
i =
i
-
1
End If
Next j
MsgBox "Tenemos " & i & " consultas en la BD",
vbInformation, "CONSULTAS"
dbs.Close
Set dbs = Nothing
End Sub
Un par de comentarios:
– Como hablamos de una colección recordad que la numeración debe empezar por cero
hasta el recuento de elementos de la colección menos uno:
( For j = 0 To dbs.QueryDefs.Count – 1 )
– Hemos echado mano a una variable auxiliar, j, para el bucle For
Next,
ya que
la
variable i estaba “cumpliendo otra misión”.
– Hemos utilizado el mismo sistema de “descarte” que en el epígrafe anterior, solo que
“filtrando” por la primera letra de la consulta.
Si hubiéramos creado un informe también nos lo hubiera contado, porque, como sabemos, un
informe basado en una tabla o consulta tiene su origen, desde este punto de vista, en una
consulta sobre dicha tabla o consulta. En este caso el nombre que le hubiera asignado,
suponiendo que hubiéramos creado el informe RTrabajadores, sería: ~sq_rRTrabajadores
Finalmente, el código para saber los nombres de las consultas (eliminando las consultas de
formularios e informes) sería el siguiente:
Private Sub cmdNombreQueries_Click()
Dim dbs As DAO.Database
Dim i As Integer
Set dbs = CurrentDb
For i = 0 To dbs.QueryDefs.Count - 1
If Left(dbs.QueryDefs(i).Name, 1) <> "~" Then
MsgBox dbs.QueryDefs(i).Name
End If
Next
dbs.Close
Set dbs = Nothing
End Sub
Recordad que si podemos “pillar” un objeto → lo podemos manipular.
Referencia a los campos
Los campos de una tabla pertenecen a una colección. Dicha colección se conoce con el nombre
de Fields.
Si ahondamos más en la parte teórica, podemos decir que un objeto Field representa un
campo de:
– Una tabla
10
Visítame en http://siliconproject.com.ar/neckkito/
– Una relación – Una consulta – Una relación de registros – Un índice Aunque
Una relación
– Una consulta
– Una relación de registros
– Un índice
Aunque me repita “como la cebolla”, recordad que como es
un objeto implica que tiene propiedades y métodos, y, por
tanto, es manipulable.
Por ejemplo, vamos a escribir un código que nos diga los nombres
de los campos de nuestra tabla TTrabajadores. El código sería:
Private Sub cmdCamposTTrab_Click()
Dim dbs As DAO.Database
Dim tbl As DAO.TableDef
Dim fld As DAO.Field
Set dbs = CurrentDb
Set tbl = dbs.TableDefs("TTrabajadores")
For Each fld In tbl.Fields
MsgBox "Nombre del campo: " & fld.Name, vbInformation, "CAMPOS"
Next fld
End Sub
Si os sirve de referencia pensad en lo que en ocasiones he comentado: Access es “tonto”.
Basándome en esta premisa en el código debemos indicar con qué vamos a trabajar (bueno,
esto entendedlo como algo general y meramente abstracto). Es decir:
Private Sub
Voy a trabajar con una base de datos
Voy a trabajar con las tablas
Voy a trabajar con los campos
La base de datos es la que tengo abierta actualmente
La tabla es “TTrabajadores”
Para cada campo de los campos de la tabla TTrabajadores
etc.
End sub
Cuando vamos a operar con las propiedades de los campos es como si abriéramos la tabla en
vista diseño y, al situarnos sobre uno de los campos, manipuláramos manualmente las
propiedades (algunas más otras “extras”).
Voy a comentar unas pocas (no todas) para que podamos ver las equivalencias:
PROPIEDAD DEL CAMPO
PROPIEDAD VBA
Nombre del campo
Name
Tipo de datos
Type
Tamaño del campo
Size
Tamaño del campo (para memos y OLE's)
FieldSize
Valor predeterminado
DefaultValue
Requerido
Required
Permitir longitud cero
AllowZeroLenght
11
Visítame en http://siliconproject.com.ar/neckkito/
Regla de validación ValidationRule Texto de validación ValidationText OTRAS INTERESANTES Para indicar que el campo
Regla de validación
ValidationRule
Texto de validación
ValidationText
OTRAS INTERESANTES
Para indicar que el campo puede actualizarse
DataUpdatable
Para indicar el campo origen de los datos
SourceField
Para indicar la tabla origen de los datos
SourceTable
Para establecer una validación
inmediatamente después de actualizar su
valor
ValidateOnSet
Otros objetos que existen y que no vamos a ver aquí
Existen otros objetos que no vamos a tratar en este capítulo, básicamente porque, desde mi
punto de vista, para un administrador “normal” de una BD, no son elementos que se utilicen
de manera imprescindible. Evidentemente es mi criterio y supongo que alguien habrá que esté
en desacuerdo. En fin
Sin embargo creo necesario, como mínimo, comentarlos. De esta manera sabremos que
existen y, gracias a nuestro “fantástico” F1, podremos buscar más información sobre ellos.
Esos objetos son:
– Parameter
– Index
– Relation
– Container
– Document
– User
– Group
– Property
Pues ahí quedan, para la memoria histórica de todos.
ALGUNOS CÓDIGOS INTERESANTES SOBRE LO QUE HEMOS VISTO
Vamos a ver algunas acciones interesantes que podemos realizar sobre nuestra BD en base a
los códigos, o, en plan purista, la “esencia” de los códigos que hemos visto hasta ahora.
Aprovecharemos para ver cómo se manipulan algunos métodos y propiedades y cómo se
plasman en un código.
Los códigos los voy a comentar para que sepáis en todo momento qué es lo que están
haciendo. No toméis estos ejemplos como “bloques inamovibles” de código, sino que vedlos
como “pequeños códigos” que unimos para conseguir un “efecto mayor”. Es decir, que una
12
Visítame en http://siliconproject.com.ar/neckkito/
parte del código, si le vemos su utilidad, podría ser aplicada en otra situación para
parte del código, si le vemos su utilidad, podría ser aplicada en otra situación para sacarnos de
un aprieto (sin necesidad de tener que coger “todas las líneas de código). Evidentemente lo
anterior es un “consejo de estudio”.
Ahí vamos con los ejemplos:
Creación de una tabla
Vamos a crear una tabla para recoger los trabajos realizados. ¿Por
qué no creamos la tabla a mano? Pongamos el supuesto que los
datos nos van a llegar a través de un Excel, y no nos interesa
tener esa tabla permanentemente en nuestra BD. Queremos sólo
que aparezca cuando a nosotros nos interese. En definitiva, el
proceso sería:
– Creo la tabla
– Importo el Excel
– Trabajo con la tabla
– Borro la tabla
Lógicamente es un supuesto que podríamos resolver de distintas maneras, pero nosotros lo
haremos a través de lo explicado hasta ahora (sí, ya sé que aún no se ha explicado cómo
importar desde un Excel, pero digamos que aprovecharemos este código para una primera
aproximación).
Ante todo, debemos tener una tabla de características similares al Excel que vamos a importar.
Supongamos que tenemos un Excel llamado ExcelTrabajos.xls con los siguientes datos:
Si analizamos ese Excel veremos que necesitamos:
– Un [Num] numérico, para la línea
– Un [Trabajador] numérico, para el identificador del trabajador
– Un [Trabajo] texto, para la descripción del trabajo
– Un [Fecha] fecha/hora, para la fecha del trabajo
– Un [Coste] moneda, para el coste del trabajo.
Fijaos que la columna <Trabajador> nos está proporcionando el DNI del trabajador.
Pues manos a la obra. La primera fase del código sería así (ojo, que no está acabado aún):
Private Sub cmdCreaTTrabajos_Click()
'Declaramos las variables
Const nomTbl As String = "TTrabajos"
Dim i As Integer
Dim miExcel As String
Dim dbs As DAO.Database
13
Visítame en http://siliconproject.com.ar/neckkito/
Dim tbl As DAO.TableDef Dim fld As DAO.Field 'Definimos la variable dbs Set dbs =
Dim tbl As DAO.TableDef
Dim fld As DAO.Field
'Definimos la variable dbs
Set dbs = CurrentDb
'-----FASE 1: ELIMINACION DE LA TABLA
'Primero debemos examinar si la tabla existe. Si
intentamos crearla
'y la tabla existe nos dará error de código. En teoría la
habremos
'eliminado, pero por si acaso
For i = 0 To dbs.TableDefs.Count - 1
If dbs.TableDefs(i).Name = nomTbl Then
dbs.TableDefs.Delete nomTbl
Exit For
End If
Next i
'-----FASE 2: CREAMOS LA TABLA
'La creamos como un nuevo objeto y después le asignamos el nombre
Set tbl = New DAO.TableDef
tbl.Name = nomTbl
'La tabla está creada ahora, pero no se muestra aún en la BD. Antes
'debemos crear los campos.
'-----FASE 3: CREAMOS LOS CAMPOS
'Creamos los campos como nuevos elementos de la tabla, a la vez que
'definimos las propiedades que nos interesan
Set fld = New DAO.Field
With fld
.Name = "Num"
.Type = dbLong 'Entero largo
End With
'Incluimos el campo creado en la tabla
tbl.Fields.Append fld
Set fld = New DAO.Field
With fld
.Name = "Trabajador"
.Type = dbLong
End With
tbl.Fields.Append fld
Set fld = New DAO.Field
With fld
.Name = "Trabajo"
.Type = dbText 'Texto
.Size = 50
End With
tbl.Fields.Append fld
Set fld = New DAO.Field
With fld
.Name = "Fecha"
.Type = dbDate
End With
tbl.Fields.Append fld
Set fld = New DAO.Field
With fld
.Name = "Coste"
.Type = dbCurrency 'Moneda
End With
14
Visítame en http://siliconproject.com.ar/neckkito/
tbl.Fields.Append fld '-----FASE 4: AÑADIMOS LA TABLA A LA BD ACTUAL dbs.TableDefs.Append tbl '-----FASE 5:
tbl.Fields.Append fld
'-----FASE 4: AÑADIMOS LA TABLA A LA BD ACTUAL
dbs.TableDefs.Append tbl
'-----FASE 5: IMPORTAMOS LOS DATOS DEL EXCEL
'Definimos la ruta donde está el Excel. En este caso lo
tenemos
'situado en el mismo directorio de la BD
miExcel = Application.CurrentProject.Path 'Nos da la ruta
del directorio
miExcel = miExcel & "\ExcelTrabajos.xls" 'Nos da la
ruta+archivo+extensión
'Importamos el Excel a la tabla recién creada
DoCmd.TransferSpreadsheet acImport, acSpreadsheetTypeExcel8, nomTbl, miExcel, True
'Cerramos conexiones y liberamos memoria
dbs.Close
Set fld = Nothing
Set tbl = Nothing
Set dbs = Nothing
End Sub
Vayamos por partes:
Fase 1: con lo visto, no deberíamos tener ningún problema para entender esta fase. Debemos
quedarnos con la idea de que si el objeto tabla ya existe nos dará un error de código. Para ello
se hace imprescindible verificar que no existe y, si existe, borrarlo.
– La sentencia que borra la tabla es, evidentemente: dbs.TableDefs.Delete nomTbl
– Si ya ha encontrado la tabla no tiene sentido seguir ejecutando el bucle. Por eso le
indicamos que salga de él a través de: Exit For
FASE 2: Con esta fase creamos la tabla de manera “inmaterial”, por decirlo de alguna manera.
Si no lo hiciéramos así, ¿dónde crearíamos los campos?
FASE 3: Creamos los campos. En el código hemos creado los campos con los atributos
indispensables. Os recuerdo que podemos establecer más propiedades a través de las
propiedades que os mostraba en la tabla de equivalencias unas páginas antes.
El proceso, como habréis visto, es:
– Creamos el campo como un nuevo campo: Set fld = New DAO.Field
– Establecemos las propiedades (a través de un bloque With
End
With)
– Anexamos el campo a la tabla: tbl.Fields.Append fld
FASE 4: Añadimos la tabla a la BD, ya como objeto “visible”.
FASE 5: Importamos el Excel. No me entretendré en esta línea de código porque explicaremos
en un capítulo posterior la importación/exportación de datos. Si alguien está interesado en
saber más sobre los elementos que componen dicha línea ya sabe que sólo debe ponerse
encima de ellos y pulsar F1.
Muy bien
Ya tenemos nuestra BD creada. Sigamos con el supuesto. Imaginemos que el jefe
quiere hacer un seguimiento de un trabajador en concreto. ¿Qué hacemos? Pues como
tenemos nuestra tabla TTrabajos creada (porque habremos ejecutado el proceso al menos una
vez) lo que vamos a hacer es una consulta parametrizada sobre esa tabla, que llamaremos
CParaElJefe. La consulta será simplemente la siguiente:
15
Visítame en http://siliconproject.com.ar/neckkito/
Ojo! La relación entre los campos [DNI] y [Trabajador] la deberemos realizar manualmente. Y como
Ojo! La relación entre los campos [DNI] y [Trabajador] la deberemos realizar manualmente.
Y como la información es para el jefe vamos a realizar un informe sobre dicha consulta, que
llamaremos RParaElJefe.
Mi informe me ha quedado así. Destacar (si hay algo que destacar) el campo calculado en el
pie del informe.
OK. Ahora ya podemos continuar con nuestro código. Para que os ubiquéis continúo a partir de
la FASE 5
'-----FASE 5: IMPORTAMOS LOS DATOS DEL EXCEL
'Definimos la ruta donde está el Excel. En este caso lo tenemos
'situado en el mismo directorio de la BD
miExcel = Application.CurrentProject.Path 'Nos da la ruta del directorio
miExcel = miExcel & "\ExcelTrabajos.xls" 'Nos da la ruta+archivo+extensión
'Importamos el Excel a la tabla recién creada
DoCmd.TransferSpreadsheet acImport, acSpreadsheetTypeExcel8, nomTbl, miExcel, True
'-----FASE 6: LANZAMOS EL INFORME DIRECTAMENTE A LA IMPRESORA
16
Visítame en http://siliconproject.com.ar/neckkito/
DoCmd.OpenReport "RParaElJefe" '-----FASE 7: BORRAMOS LA TABLA CON LOS DATOS dbs.TableDefs.Delete nomTbl
DoCmd.OpenReport "RParaElJefe"
'-----FASE 7: BORRAMOS LA TABLA CON LOS DATOS
dbs.TableDefs.Delete nomTbl
'Cerramos conexiones y liberamos memoria
dbs.Close
Set fld = Nothing
Set tbl = Nothing
Set dbs = Nothing
End Sub
Si ejecutamos el proceso una vez (como lo sería en un uso normal de la BD) veremos que el
informe se envía correctamente a la impresora. Pero, ¿qué hemos conseguido?
Pues que si por casualidad algún trabajador “listillo” se salta los bloqueos de la BD (o,
simplemente, no hemos “asegurado” nuestra BD) y ve que hay un informe para el jefe, si
intenta abrirlo pues
“su gozo en un pozo”. Intentad abrir ese informe (o la consulta de
origen) a ver qué obtenéis (dando por supuesto que habéis ejecutado el código y que la tabla
TTrabajos se ha borrado, claro)
je, je
El código entero nos quedaría así:
Private Sub cmdCreaTTrabajos2_Click()
'Declaramos las variables
Const nomTbl As String = "TTrabajos"
Dim i As Integer
Dim miExcel As String
Dim dbs As DAO.Database
Dim tbl As DAO.TableDef
Dim fld As DAO.Field
'Definimos la variable dbs
Set dbs = CurrentDb
'-----FASE 1: ELIMINACION DE LA TABLA
'Primero debemos examinar si la tabla existe. Si intentamos crearla
'y la tabla existe nos dará error de código. En teoría la habremos
'eliminado, pero por si acaso
For i = 0 To dbs.TableDefs.Count - 1
If dbs.TableDefs(i).Name = nomTbl Then
dbs.TableDefs.Delete nomTbl
Exit For
End If
Next i
'-----FASE 2: CREAMOS LA TABLA
'La creamos como un nuevo objeto y después le asignamos el nombre
Set tbl = New DAO.TableDef
tbl.Name = nomTbl
'La tabla está creada ahora, pero no se muestra aún en la BD. Antes
'debemos crear los campos.
'-----FASE 3: CREAMOS LOS CAMPOS
'Creamos los campos como nuevos elementos de la tabla, a la vez que
'definimos las propiedades que nos interesan
Set fld = New DAO.Field
With fld
.Name = "Num"
17
Visítame en http://siliconproject.com.ar/neckkito/
.Type = dbLong 'Entero largo End With 'Incluimos el campo creado en la tabla tbl.Fields.Append
.Type = dbLong 'Entero largo
End With
'Incluimos el campo creado en la tabla
tbl.Fields.Append fld
Set fld = New DAO.Field
With fld
.Name = "Trabajador"
.Type = dbLong
End With
tbl.Fields.Append fld
Set fld = New DAO.Field
With fld
.Name = "Trabajo"
.Type = dbText 'Texto
.Size = 50
End With
tbl.Fields.Append fld
Set fld = New DAO.Field
With fld
.Name = "Fecha"
.Type = dbDate
End With
tbl.Fields.Append fld
Set fld = New DAO.Field
With fld
.Name = "Coste"
.Type = dbCurrency 'Moneda
End With
tbl.Fields.Append fld
'-----FASE 4: AÑADIMOS LA TABLA A LA BD ACTUAL
dbs.TableDefs.Append tbl
'-----FASE 5: IMPORTAMOS LOS DATOS DEL EXCEL
'Definimos la ruta donde está el Excel. En este caso lo tenemos
'situado en el mismo directorio de la BD
miExcel = Application.CurrentProject.Path 'Nos da la ruta del directorio
miExcel = miExcel & "\ExcelTrabajos.xls" 'Nos da la ruta+archivo+extensión
'Importamos el Excel a la tabla recién creada
DoCmd.TransferSpreadsheet acImport, acSpreadsheetTypeExcel8, nomTbl, miExcel, True
'-----FASE 6: LANZAMOS EL INFORME DIRECTAMENTE A LA IMPRESORA
DoCmd.OpenReport "RParaElJefe"
'-----FASE 7: BORRAMOS LA TABLA CON LOS DATOS
dbs.TableDefs.Delete nomTbl
'Cerramos conexiones y liberamos memoria
dbs.Close
Set fld = Nothing
Set tbl = Nothing
Set dbs = Nothing
End Sub
Variación sobre el tema
Ahora viene nuestro jefe y nos dice que quiere una vista preliminar del informe antes de
enviarlo a la impresora. Sin problema: cambiamos la línea DoCmd.OpenReport "RParaElJefe"
por la línea DoCmd.OpenReport "RparaElJefe", acViewPreview
18
Visítame en http://siliconproject.com.ar/neckkito/
¿Qué pasa? Pues pasa esto: Es decir, que no nos puede borrar la tabla porque
¿Qué pasa?
Pues pasa esto:
Es decir, que
no nos puede
borrar la
tabla porque el informe la está utilizando. Vaya un “problemón”, ¿verdad? Porque si no
borramos la tabla la información estará al alcance de miradas indiscretas. ¿Qué podemos
hacer?
Pues lo que haremos será dividir la ejecución del código en dos partes. La primera será hasta
que se muestre el informe en vista previa. Así, utilizaríamos todo el código anterior pero lo
finalizaríamos de la siguiente manera:
'Todo el código anterior hasta FASE 5
''-----FASE 6: LANZAMOS UN PREVIEW DEL INFORME
DoCmd.OpenReport "RParaElJefe2", acViewPreview
'Cerramos conexiones y liberamos memoria
dbs.Close
Set fld = Nothing
Set tbl = Nothing
Set dbs = Nothing
End Sub
Ahora vamos a por la segunda parte. Necesitamos un evento que deba producirse
obligatoriamente para asegurarnos que borramos la tabla. El problema que nos encontramos
es que no podemos operar sobre el informe directamente porque la tabla que queremos borrar
es, precisamente, su origen de datos, y obtendríamos el error 3211 que antes comentábamos.
Luego debemos buscar en nuestra BD (y eso ya dependerá de cómo la hayamos estructurado)
algo que nos genere el evento que necesitamos para poder borrar la tabla. Por ejemplo, si
nuestra BD se abre con un formulario de inicio (como es el caso de la BD de ejemplo) podemos
sacar las propiedades de ese formulario y asignar el siguiente código al evento “Al abrir” de
ese formulario
Private Sub Form_Open(Cancel As Integer)
Dim tbl As Object
For Each tbl In CurrentData.AllTables
If tbl.Name = "TTrabajos" Then
DoCmd.DeleteObject acTable, tbl.Name
Exit For
End If
Next tbl
End Sub
19
Visítame en http://siliconproject.com.ar/neckkito/
Fijaos que en este código hemos utilizado otro sistema para identificar la tabla: no hemos
Fijaos que en este código hemos utilizado otro sistema para identificar la tabla: no hemos
definido la variable tbl como un DAO.TableDef, sino que lo hemos definido como un “objeto” de
la base de datos. El proceso ha sido:
– Lo definimos como objeto: Dim tbl As Object
– Le decimos que ese objeto es una tabla:
CurrentData.AllTables
– Miramos si existe a través del bloque FOR EACH
NEXT
e
IF
END
IF
– Si existe lo borramos a través de nuestro amigo DoCmd,
con la siguiente estructura:
DoCmd.DeleteObject acTipoObjeto, nombreObjeto
Como no vamos a operar sobre las propiedades de la tabla no tiene sentido crear referencias a
DAO, borrar la tabla y después tener que cerrar conexiones y liberar memoria. Este sistema
que acabamos de aprender es bastante más práctico si no necesitamos operar sobre
elementos de la tabla.
Creación de una tabla: sistema rápido
El código anterior nos daba un control muy grande sobre todos los elementos de nuestra tabla.
Sin embargo, puede ser que queramos crear una tabla de una manera más rápida (cuando
digo rápida me refiero a no tener que escribir tantas líneas de código). Vamos a verlo.
Supongamos que queremos crear una tabla temporal por los motivos que sean. En nuestro
caso, la tabla será para guardar los trabajos de un proyecto “especial” que se repite
esporádicamente, pero no nos interesa guardar los datos de manera permanente en la BD.
El código para crear esa tabla sería:
Private Sub cmdCreaTblRapido_Click()
'Declaramos las variables
Const nomTabla As String = "TTrabEsporadico"
Dim dbs As DAO.Database
Dim tbl As DAO.TableDef
Dim fld As DAO.Field
Dim tblBorro As Object
'Definimos la BD de trabajo
Set dbs = CurrentDb
'Si la tabla existe, la eliminamos antes
For Each tblBorro In CurrentData.AllTables
If tblBorro.Name = nomTabla Then
dbs.TableDefs.Delete tblBorro.Name
Exit For
End If
Next
'Definimos la tabla creándola directamente
Set tbl = dbs.CreateTableDef(nomTabla)
'Definimos los campos anexándolos directamente a la tabla
With tbl
.Fields.Append .CreateField("Id", dbLong)
.Fields.Append .CreateField("Trabajador", dbLong)
.Fields.Append .CreateField("Fecha", dbDate)
.Fields.Append .CreateField("DescripTrabajo", dbText, 255)
End With
'Añadimos la tabla a la BD actual
20
Visítame en http://siliconproject.com.ar/neckkito/
dbs.TableDefs.Append tbl 'Cerramos conexiones y liberamos memoria dbs.Close Set fld = Nothing Set tbl =
dbs.TableDefs.Append tbl
'Cerramos conexiones y liberamos memoria
dbs.Close
Set fld = Nothing
Set tbl = Nothing
Set dbs = Nothing
End Sub
Como vemos en el código,
– Recordad que debemos borrar la tabla antes de crearla.
– Creamos la tabla al tiempo de definimos la variable:
Set tbl = dbs.CreateTableDef(nomTabla)
– Aprovechamos el bloque With
End
With para
– Manipular los campos a través de .Fields.Append
– Manipular la tabla a través de .CreateField("Id", dbLong)
– Fijaos que hay un espacio entre .Fields.Append y .CreateField. Eso vendría a
significar, si escribiéramos el código sin el bloque With:
tbl.Fields.Append
tbl.CreateField(
)
Importante: tened en cuenta que a veces Access tarda en refrescar la información en el panel
de exploración. Eso significa que quizá no veáis la tabla, pero está ahí. Una manera rápida de
comprobarlo es empezar a crear una consulta en vista diseño, y veremos las tablas que hay
disponibles (cancelamos la creación de la consulta, a no ser que la necesitemos). Cuando
menos lo esperemos nuestra tabla aparecerá en el panel “por arte de magia”.
Adición de campos a una tabla existente
Imaginemos que queremos añadir un campo a una tabla existente. Primero deberemos
comprobar que ese campo no existe, y, si efectivamente no existe, lo añadiremos.
Vamos a ejecutar un código que, además, nos servirá para el epígrafe siguiente. Vamos a
añadir un campo a la tabla TTrabajadores, que nos informará del sexo del trabajador.
El código podría ser el siguiente:
Private Sub cmdAñadeCampo_Click()
'Declaramos las variables
Dim dbs As DAO.Database
Dim tbl As DAO.TableDef
Dim fld As DAO.Field
Dim hayCampo As Boolean
'Definimos las variables
Set dbs = CurrentDb
Set tbl = dbs.TableDefs!TTrabajadores
hayCampo = False
'Recorremos los campos de la tabla para ver si existe
For Each fld In tbl.Fields
If fld.Name = "Sexo" Then
hayCampo = True
Exit For
End If
21
Visítame en http://siliconproject.com.ar/neckkito/
Next fld 'Si no hay campo (es decir, hayCampo es False) lo añadimos 'con el
Next fld
'Si no hay campo (es decir, hayCampo es False) lo añadimos
'con el sistema que hemos acabado de aprender
If hayCampo = False Then
With tbl
.Fields.Append .CreateField("Sexo", dbText, 6)
End With
End If
'Cerramos conexiones y liberamos memoria
dbs.Close
Set fld = Nothing
Set tbl = Nothing
Set dbs = Nothing
End Sub
Destacar una idea nueva que aparece en este código: nos hemos servido, en primer término,
de una variable booleana para, primero, definirla con un valor predeterminado y, segundo,
cambiarle ese valor si se cumple una condición (el campo ya existe). Y, en segundo término,
realizar una serie de acciones en función de lo que devuelva la booleana. Si queréis un consejo
yo tomaría nota de este recurso, porque en ocasiones no se puede ejecutar el código
directamente sin haber evaluado antes una condición, y las variables booleanas se prestan
mucho a facilitarnos el trabajo si fuera el caso.
Para acabar este epígrafe os diré que si lo que quisiéramos es lo contrario, es decir, eliminar un
campo que ya existe en la tabla, el código sería:
Private Sub cmdEliminaCampo_Click()
'Declaramos las variables
Dim dbs As DAO.Database
Dim tbl As DAO.TableDef
Dim fld As DAO.Field
'Definimos las variables
Set dbs = CurrentDb
Set tbl = dbs.TableDefs!TTrabajadores
'Recorremos los campos de la tabla para ver si existe. Si existe
'lo eliminamos
For Each fld In tbl.Fields
If fld.Name = "Sexo" Then
tbl.Fields.Delete fld.Name
Exit For
End If
Next fld
'Cerramos conexiones y liberamos memoria
dbs.Close
Set fld = Nothing
Set tbl = Nothing
Set dbs = Nothing
End Sub
Creación de una consulta
Puede interesarnos también crear consultas en tiempo de ejecución. Y ya sabemos que crear
una consulta es trabajar con SQL. Yo no voy a explicar las SQL que utilicemos aquí (que serán
22
Visítame en http://siliconproject.com.ar/neckkito/
muy fáciles), porque ahora interesa centrarnos en la creación de consultas. Antes vamos a hacer
muy fáciles), porque ahora interesa centrarnos en la creación de consultas.
Antes vamos a hacer una pequeña modificación a nuestra
tabla TTrabajadores. Vamos a completar el campo [Sexo]
que hemos creado en el epígrafe anterior en cada uno de
los registros con los valores “Hombre” o “Mujer”.
Hecho esto, vamos a ver esto de las consultas.
Supongamos que queremos filtrar por el valor “Mujer”. El
código con el que conseguiríamos lo anterior sería:
Private Sub cmdCreaConsulta_Click()
'Declaramos las variables
Dim dbs As DAO.Database
Dim qry As DAO.QueryDef
Dim qryBorro As Object
Dim miSql As String
'Definimos la variable dbs
Set dbs = CurrentDb
'Miramos si existe la consulta. Si existe la eliminamos
For Each qryBorro In CurrentData.AllQueries
If qryBorro.Name = "CTempSexo" Then
DoCmd.DeleteObject acQuery, qryBorro.Name
Exit For
End If
Next
'Definimos la SQL
miSql = "SELECT TTrabajadores.* FROM TTrabajadores"
miSql = miSql & " WHERE TTrabajadores.Sexo='Mujer'"
'Creamos la consulta
Set qry = dbs.CreateQueryDef("CTempSexo", miSql)
'Ejecutamos la consulta
DoCmd.OpenQuery "CTempSexo"
'Cerramos conexiones y liberamos memoria
qry.Close
dbs.Close
Set qry = Nothing
Set dbs = Nothing
End Sub
Tengamos en cuenta lo siguiente:
– Al igual que hacíamos con las tablas, debemos comprobar que la consulta no existe y, si
existe, borrarla. Así nos evitaremos errores de código
– Definimos la SQL a través de una variable de tipo String
– Creamos la SQL a través de la propia definición de la consulta, utilizando
CreateQueryDef, con dos argumentos separados por comas: el nombre de la consulta y
la SQL
Set qry = dbs.CreateQueryDef("CTempSexo", miSql)
– Recordad que es posible que no veamos inmediatamente la consulta en el panel de
exploración por tardanza en el refresco de la información.
¿Y por qué la he llamado CTempSexo? Si recordáis, podemos utilizar nuestro formulario de
23
Visítame en http://siliconproject.com.ar/neckkito/
inicio para “eliminar” todo aquello que no nos interese que quede como objeto en la
inicio para “eliminar” todo aquello que no nos interese que quede como objeto en la base de
datos. Imaginaos que creamos varias consultas en tiempo de ejecución. ¿Hay que “hacer una
lista” de todas ellas para borrarlas?
Pues no: podemos decirle al código que borre sólo las que
comienzan por CTemp. Así, el código en el evento “Al abrir”
de nuestro formulario de inicio (o el que nosotros elijamos
para tal acción) sería:
Private Sub Form_Open(Cancel As Integer)
'Borramos las consultas temporales, si existen
Dim qry As Object
For Each qry In CurrentData.AllQueries
If Left(qry.Name, 5) = "CTemp" Then
DoCmd.DeleteObject acQuery, qry.Name
End If
Next qry
End Sub
Fijaos que esta vez no utilizamos el Exit For, dado que necesitamos que el código recorra todas
las consultas porque puede haber más de una consulta que empiece por CTemp
PARA FINALIZAR ESTE CAPÍTULO
Hemos visto en este capítulo qué sistemas hay para “acceso a datos”, qué es de manera
teórica DAO y cómo podemos, a través de él, crear tablas y consultas (con las “variaciones
sobre el tema” oportunas). El tema es realmente extenso y este “manual” no tiene la
pretensión de ser una “biblia de DAO”.
Sin embargo, no hemos acabado con DAO todavía. En el próximo capítulo entraremos en lo
que se conoce con el nombre de
Recordset.
Y así, por finalizar “a lo americano”, os diré
To be continued
24
Visítame en http://siliconproject.com.ar/neckkito/