PDF de programación - Curso de VB - Capítulo 11

CURSO DE VB

CAPÍTULO 111

Índice de contenido
OBJETOS DE ACCESO A DATOS (II)...............................................................................................2
RECORDSET..................................................................................................................................2
LA MANERA MÁS FÁCIL DE ACCEDER A UN RECORDSET: CLONARLO........................3
UN POCO DE TEORÍA..................................................................................................................5
ABRIR UN RECORDSET PARA CONSULTAR UN DATO........................................................6
RECORRER UN CONJUNTO DE REGISTROS..........................................................................7
MODIFICANDO UN REGISTRO..................................................................................................9
MODIFICANDO TODOS LOS REGISTROS.............................................................................10
Modificando todos los registros pero con más de un campo....................................................11
Consultando una consulta.........................................................................................................12
Consultando una consulta que aún no existe.............................................................................14
¿Error porque el valor no existe?.........................................................................................15
BÚSQUEDA RÁPIDA: Seek........................................................................................................17
AÑADIENDO UN REGISTRO....................................................................................................18
UNOS PREPARATIVOS NECESARIOS.....................................................................................19
EL EJEMPLO FINAL: UN “MIX” DE TODO LO APRENDIDO...............................................21
Cómo sería nuestra SQL...........................................................................................................21
ESTRUCTURACIÓN DEL CÓDIGO......................................................................................22
DESARROLLANDO EL CÓDIGO.........................................................................................22
UNAS PALABRAS FINALES......................................................................................................25

1 La BD donde están los ejemplos de este capítulo os la podéis bajar aquí.

Visítame en http://siliconproject.com.ar/neckkito/

1

OBJETOS DE ACCESO A DATOS (II)

En el capítulo anterior hemos visto el método de acceso a
datos DAO. Sin embargo, nos faltaba “algo”.

Ese algo es examinar con detenimiento el mundo de los
recordset con DAO. Y a eso nos vamos a dedicar
inmediatamente.

Seguiremos manejando la BD de pruebas que comenzamos
a “confeccionar” en dicho capítulo, por lo que se hará
referencia, lógicamente, a elementos que ya creamos en su
momento.

Manos a la obra.

RECORDSET
Recordset, recordset... “potito palabro”. Access nos aclara qué es un recordset de la siguiente
manera:

<<Un objeto Recordset representa los registros de una tabla base o los registros resultantes
de la ejecución de una consulta>>

Bueno... Ahora todos podemos presumir de que ya sabemos qué es un recordset, ¿verdad? Je,
je...

Por ahora, lo que tenemos claro es que es un objeto, y, como tal, tiene sus propiedades y
métodos, y es manipulable (¿os suena la frase?)

Si abrimos una tabla o de una consulta podemos ver los datos que hay en ellas, organizados
en registros. El conjunto de esos registros constituiría un recordset. Pero la idea de recordset
lleva implícita algo más, algo que podríamos llamar “inmaterial”.

Lo que voy a comentaros a continuación es algo que está totalmente alejado de “tecnicismos y
teoría” y, en el fondo, es una reflexión mía de carácter personal. Sin embargo, considero que
tras su lectura todo el mundo debería tener una idea más que clara de lo que es un recordset.

Vamos a hacer un símil, poniéndonos un poco filosóficos: abrimos una tabla (con datos, claro),
miramos intensamente la pantalla y cerramos los ojos. Si queremos podemos ver, en nuestra
mente, reproducida esa tabla con su información. Es más, podemos centrarnos en un registro
e imaginar que ese registro desaparece. O nos centramos en un registro, siempre en nuestra
mente, y más en concreto en un campo y un dato. Y ahí donde pone “electricista” (por
ejemplo) nos imaginamos que pone “fontanero”. Y , por nuestra voluntad, automáticamente
sólo “vemos” los registros en los que en ese campo hay el valor “fontanero”, y los otros
“desaparecen”.

Pues Access sería como nosotros mismos, y los recordset serían esa “imagen” que tenemos en
el cerebro. Así como nosotros podemos imaginar que desaparecen registros Access puede
hacer desaparecer registros, añadir de nuevos, sustituir los existentes, añadir más campos,
etc.

¿Dónde está físicamente ese recordset que maneja Access? Pues para nosotros “no está”, en el
sentido que no podemos verlo en la aplicación. Sólo podemos tener acceso “visible” al mismo
cuando Access escribe los resultados en una tabla o consulta, o, a veces, ni siquiera eso,

Visítame en http://siliconproject.com.ar/neckkito/

2

puesto que nos informa a través de un MsgBox.

Ni que decir tiene que nosotros manejamos las acciones
que se deben desarrollar sobre el recordset, pero es Access
quien, en ese “limbo”, los ejecuta y después los muestra de
la manera que nosotros le hemos pedido.

Evidentemente he recurrido a una “imagen onírica” para
describiros un recordset, pero, en el fondo, lo que sucede
“dentro” de Access al manejar un recordset es lo que os
acabo de explicar. De hecho, cuando programemos acciones
sobre un recordset involuntaria o voluntariamente
tendremos que imaginarnos esa “acción imaginaria” que se
ejecutará con el fin de conseguir el objetivo deseado.

Y después de este ambiente chillout en que nos hemos sumergido vamos a ver un par de cosas
sobre los recordset.

LA MANERA MÁS FÁCIL DE ACCEDER A UN RECORDSET: CLONARLO
Pero antes, os explico qué vamos a hacer:

El código que vamos a programar nos solicitará un DNI. Acto seguido clonará el recordset de la
tabla. ¿Qué significa eso? Que por una parte tendremos el recordset de la tabla y por otro
tendremos una copia de dicho recordset. En definitiva, que estaremos operando con dos
recordsets: original y copia.

¿Por qué hacemos eso? Pues porque nos es más cómodo, para la operación que vamos a
realizar, trabajar sobre un recordset “inmaterial” que no directamente sobre la tabla. Y ello es
así porque el recordset “copia” tiene una serie de propiedades y métodos que podemos
manipular a nuestro antojo.

Realizamos las operaciones que necesitamos sobre el recordset “copia” y conseguimos un
resultado. Y a continuación lo que vamos a hacer es aplicar dichos resultados sobre el
recordset original. Y como, por decirlo de alguna manera, el recordset original es el que
tenemos en pantalla, podremos ver los resultados también en pantalla.

¿Nos acordamos cuando, en el primer apartado, yo hablaba de “nuestra mente”? Pues el clon
del recordset que hemos creado se aloja “en memoria” del ordenador, lo que implica que está
consumiendo un espacio. Por ello, una vez obtenido el resultado, y dado que ya no
necesitamos más ese clon, podemos cerrarlo, primero, y eliminarlo, después, de la memoria,
tal y como aprendimos en el capítulo anterior (¿nos acordamos de “Close” y de “=Nothing”?).
Así, tal y como lo hemos creado, lo hacemos desaparecer.

Vimos este sistema en el capítulo dedicado a filtros, por lo que ya os debería “sonar” todo lo
que vamos a ver. Pero esta vez el enfoque de la explicación será desde el punto de vista de
DAO.

Si abrimos nuestro formulario FTrabajadores le añadimos un botón en la cabecera del
formulario, y ese botón será el que programaremos.

Ahora sí estamos en condiciones de ver el código (no incluye elementos de control):

….
Private Sub cmdRecordsetClon_Click()
'Declaramos las variables

Visítame en http://siliconproject.com.ar/neckkito/

3

Dim nDNI As Long
Dim filtro As String
Dim rst As Recordset

'Solicitamos al usuario que introduzca un DNI
nDNI = InputBox("Introduzca un DNI a buscar", "DNI")
'Creamos el filtro
filtro = "[DNI]=" & nDNI
'Clonamos el recordset
Set rst = Me.Recordset.Clone
'Manipulamos el recordset del clon para buscar un DNI a
través
'del método Recordset.FindFirst()

rst.FindFirst filtro
'Cuando lo encuentra añadimos un marcador a nuestro clon para
'"fijar" el registro que cumple con el filtro a través de la propiedad
'Recordset.Bookmark
'Traspasamos ese marcador al recordset original. De esta manera
'en pantalla nos situaremos en el registro que cumple con el filtro
Me.Bookmark = rst.Bookmark
'Cerramos el recordset clon
rst.Close
'Lo eliminamos de memoria
Set rst = Nothing
End Sub
…

Si probamos el botón y buscamos un DNI veremos los resultados.

Fijémonos en un par de detalles:

Generalmente, si utilizamos el método DAO, se define el recorset con el nombre de rst
–
Al declararlo como variable le decimos que va a ser un recordset: Dim rst As Recordset
–
Para crearlo utilizamos la estructura SET rst = xxx. Es decir, que para asignar valor a
–
variables las igualábamos directamente (i.e., DNI=123), mientras que para un recordset
debemos utilizar SET (de manera similar a cómo determinábamos dbs o tbl o fld).
Para llamar al recordset original del formulario (que es la tabla TTr