CURSO DE SQL

CAPÍTULO 11

Índice de contenido
CAPÍTULO 1.......................................................................................................................................1
INTRODUCCIÓN................................................................................................................................2
¿POR QUÉ ESTE CURSO?............................................................................................................2
CONFESIONES ÍNTIMAS.............................................................................................................2
Y EN ESTE PRIMER CAPÍTULO.................................................................................................3
EL LENGUAJE SQL...........................................................................................................................3
RÁPIDAMENTE... ¿QUÉ ES?.......................................................................................................3
TIPOS DE DATOS..........................................................................................................................4
DATOS TIPO TEXTO................................................................................................................4
DATOS TIPO MEMO.................................................................................................................5
DATOS TIPO NÚMERO............................................................................................................6
DATOS TIPO FECHA/HORA....................................................................................................7
DATOS TIPO MONEDA............................................................................................................8
DATOS TIPO AUTONUMÉRICO.............................................................................................8
DATOS SÍ/NO (DATOS BOOLEANOS)...................................................................................8
DATOS OBJETO OLE...............................................................................................................8
DATOS BINARIOS....................................................................................................................9
CUADRO RESUMEN................................................................................................................9
ALGUNOS COMPONENTES DE SQL.......................................................................................10
COMANDOS............................................................................................................................10
CLÁUSULAS...........................................................................................................................11
PREDICADOS..........................................................................................................................11
OPERACIONES.......................................................................................................................11
OPERADORES........................................................................................................................12
FUNCIONES AGREGADAS...................................................................................................12
PREPARACIÓN Y EXPLICACIONES VARIAS PARA SEGUIR EL RESTO DEL CURSO.........13
PARA FINALIZAR ESTE CAPÍTULO.............................................................................................18

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

1
Visítame en http://bit.ly/NckAccess
 INTRODUCCIÓN

¿POR QUÉ ESTE CURSO?

Cuando profundizamos un poco en Access, y sobre todo

cuando profundizamos en VBA para Access, nos
encontramos con una “palabrita” extraña que se escribe
“SQL”. Con toda probabilidad, por poco que hayamos
toqueteado las consultas de Access, nos habremos
encontrado con algo que se llama “vista SQL”.
Ahí nuestra gran consulta se nos habrá convertido en un grupo de palabras, a cual más
extraña, y pensando “no entiendo nada de esto” nos habremos vuelto a la vista diseño de la
consulta y tan frescos.
Por otra parte, si ya hablamos de código, quizás hayamos encontrado algún código donde se
nos dice que “construimos nuestra consulta a través de la variable miSQL”, y también
habremos podido ver que nuestra variable String se confeccionaba con un conjunto de
“palabrejas” que bueno... ni Dios que lo entienda, pero funciona.

Entonces se enciende una bombilla en eso que llaman cerebro y pienso: “¿por qué no hacer un
curso para que los sufridos usuarios de Access puedan entender qué están haciendo?”

Y, como diría Aristóteles, de la potencia al acto: de ahí que ahora los “afortunados” tengáis en
vuestras manos este curso (modestia aparte, claro... je, je...).

Como habréis podido intuir, y quienes me conocéis un poco ya habréis adivinado, la idea de
este curso no es meterse a fondo en teoría sobre SQL; mi intención es darle un carácter
práctico, y el objetivo final es que al ver una sentencia SQL sepáis qué está haciendo, además
de poder construiros vosotros mismos vuestras propias instrucciones para “esos códigos que
tan bien funcionan en nuestras BD's”.

Finalmente lo que se explicará en este curso sobre SQL está enfocado, principalmente, a su
funcionamiento con Access. Cierto es que SQL es un lenguaje estándar, pero bueno, digamos
que cada sistema gestor de bases de datos puede tener sus propias particularidades. Sin
embargo, e insisto en ello, el enfoque que se dé será siempre de cara a su desarrollo para
Access.

Doy por supuesto que el lector tiene un cierto control sobre VBA para Access, dado que los
ejemplos van a estar basados prácticamente en este lenguaje de programación. Aunque
intentaré explicar qué estoy haciendo hay cosas que se darán por sabidas. Si tenemos dudas
siempre podemos consultar este fantástico manual sobre VBA para Access (je, je...)

Espero que este curso os sea útil. Y, si encontráis algún error o “desastre”, además de pedir
disculpas por adelantado, os rogaría que me lo comunicarais para poder “enmendar la pifia”.

¡Suerte!

CONFESIONES ÍNTIMAS
No me considero un “monstruo” de SQL. De hecho, a mis efectos, diría que soy un neófito en
esto de SQL. ¿Por qué? Porque Access nos facilita muchísimo el trabajo de construcción de
SQL's que son las que, generalmente, nos funcionan perfectamente en nuestras BD's.

2
Visítame en http://bit.ly/NckAccess
Supongo que por esta “falta de necesidad” no se me ha ocurrido profundizar hasta las entrañas
“más oscuras” de SQL. En fin...

¿Y qué quiero decir con esto? Que quien espere encontrar,

en este manual, “grandes construcciones SQL” con una
“complejidad rayana en la locura”... pues se ha equivocado
de manual.

¿Y qué encontraremos en este manual, entonces? Pues la

finalidad, como os comentaba antes, es simplemente que
“entendamos”, al leer o construir una SQL, qué estamos
haciendo. Y lo que encontraremos serán las construcciones
SQL más comunes (bueno, quizá alguna de no tan común)
y cómo podemos implementarlas en nuestros códigos VBA.
Insisto: para grandes complicaciones... pues a buscar un
buen manual (y caro) sobre SQL.

Y EN ESTE PRIMER CAPÍTULO...

Vamos a dividir este capítulo en dos partes bien diferenciadas: teoría y preparación de datos
para poder desarrollar y practicar en los próximos capítulos.

Como casi todo en la vida no se puede empezar la casa por el techo. Por ello este primer
capítulo será un poco (mucho) teórico. De hecho, pienso que es mejor un sólo capítulo (este)
fundamentalmente teórico que no teoría por aquí, teoría por allá...

Por eso os pido un poco de paciencia, puesto que es imprescindible sentar las bases de
terminología, conceptos y “otros chascarrillos” antes de meternos de lleno en temas prácticos.

Pero tranquilos, que ya sabéis que a mí me gusta más la práctica que la teoría, por lo que
intentaré ser 3B: bueno, bonito y breve.

En cuanto a la preparación de los datos la idea es crearse una BD de ejemplo y que con ella
seamos capaces de desarrollar todas las diferentes explicaciones que se llevarán a cabo en los
siguientes capítulos. Sé que también es un esfuerzo, pero estoy convencido de que el mismo
tendrá una buena recompensa.

Evidentemente se puede seguir el curso sin realizar la parte práctica, pero si en alguna parte
nos perdemos y no hemos seguido los ejemplos probablemente este esfuerzo que hacemos al
principio lo tengamos que realizar tarde o temprano si queremos entender bien qué estamos
haciendo. En definitiva, que es una decisión personal de cada uno.

Finalmente, recordad que todos los contenidos estarán basados en la aplicación de sentencias
SQL dentro de VB para Access. No debemos perder de vista lo anterior.

EL LENGUAJE SQL

RÁPIDAMENTE... ¿QUÉ ES?

Si nos ceñimos a la definición que podemos leer en Wikipedia 2, nos encontramos con que SQL
es:

<<El lenguaje de consulta estructurado o SQL (por sus siglas en inglés structured query language) es
2 [http://es.wikipedia.org/wiki/SQL ]. Consulta en línea el 21/04/12

3
Visítame en http://bit.ly/NckAccess
un lenguaje declarativo de acceso a bases de datos relacionales que permite especificar diversos tipos de
operaciones en estas. Una de sus características es el manejo del álgebra y el cálculo relacional permitiendo
efectuar consultas con el fin de recuperar -de una forma sencilla- información de interés de una base de
datos, así como también hacer cambios sobre ella.>>

En resumidas cuentas, SQL es:

– Un lenguaje de programación...
– para bases de datos relacionales... (¡Caramba!
Access es un GBDR3)
– que a través de unos instrumentos...
– nos permite efectuar consultas...
– para extraer información de la base de datos.

Se utiliza SQL porque es un lenguaje estándar de una gran aceptación y que, salvo honrosas
excepciones, nos permite manipular bases de datos independientemente del sistema gestor. Es
decir, que en principio nos da igual si es Access quien gestiona la BD, SQL-Server, Oracle o
phpMyAdmin, entre otros.

Otra de las ventajas de SQL es su relativa sencillez, de manera que con el conocimiento de
unas pocas palabras “claves” podemos efectuar potentes consultas para conseguir la
información necesaria.

Finalmente, nuestro “querido” VBA acepta la implementación de SQL dentro del código, con lo
que si sabemos programar en VBA y SQL podemos obtener una sinergia importante para una
mejor utilización de nuestra BD.

Como ya comentaba en la introducción, a partir de aquí las referencias que se hagan serán
todas referidas a su utilización en Access y en VBA para Access (insisto en que lo anterior no
excluye su uso, en un alto porcentaje, en otros sistemas de gestión). Veremos cómo
complementar estos dos lenguajes de programación para conseguir las sinergias que
comentábamos antes.

TIPOS DE DATOS
Vamos a partir, para este epígrafe, de lo “conocido” para llegar a lo “desconocido”. Y Access
será nuestra “luz y guía” para ello.

Cuando creamos una tabla en Access y

definimos un campo debemos definir también
su tipo de dato. Es decir, que nos
encontramos con una cosa así:

Vamos a ir recorriendo estos tipos de campos

para ver sus características y su relación con
SQL

DATOS TIPO TEXTO

Un dato tipo texto es simplemente una
cadena de caracteres, con una longitud máxima de 255 caracteres.
Hasta aquí muy bien. Pero nuestro campo tipo texto, ¿es de longitud variable o de longitud
fija?

3 GBDR: Gestor de Bases de Datos Relacional

4
Visítame en http://bit.ly/NckAccess
Que un dato sea de longitud variable o fija tiene su repercusión en el tamaño de
almacenamiento en bites del dato. Eso quiere decir que:
– Si el texto es de longitud fija el tamaño de almacenamiento
será el doble del tamaño definido
– Si el texto es de longitud variable el tamaño de
almacenamiento será el doble del tamaño real.
Para que nos entendamos: si yo defino un campo con un
tamaño máximo de 25 caracteres de longitud y el valor que
hay dentro de ese campo tiene 15 caracteres mis tamaños
de almacenamiento en bites serán los siguientes:
– Si el texto es fijo: 25*2=50
– Si el texto es variable: 15*2=30
Conclusión: si sabemos de antemano que los valores que vamos a introducir en ese campo van
a tener todos una longitud similar sería mejor utilizar un texto fijo; al contrario, si esa longitud
va a ser dispar utilizaríamos un texto variable.
Más cosas: ¿qué tipo de texto utiliza Access? Access utiliza por defecto, un tamaño variable. ¿Y
cómo podemos saber “visualmente” qué tipo de texto se está utilizando? Pues abriendo la
tabla en vista hoja de datos y mirando qué selección (marcado en negro) se hace del valor del
campo. Si vemos que se selecciona sólo el valor estaremos ante un texto variable; si se
selecciona todo el campo será un texto fijo4.
Es decir:

¿Cómo definimos uno y otro en SQL? Pues utilizando las “palabras reservadas” que tenemos
para ello. Disponemos de varias palabras reservadas en algunos casos (es decir, como si fueran
sinónimos). La siguiente tabla muestra de qué opciones disponemos:

Texto – Longitud fija CHAR

Texto – Longitud variable ALPHANUMERIC / STRING / TEXT / TEXT (N) /
VARCHAR

DATOS TIPO MEMO

Los datos tipo memo no son más que datos de tipo texto, pero sin la limitación de los 255
caracteres. De hecho, un campo memo puede acumular hasta un máximo de 65.536
caracteres. Si el campo no contiene datos binarios nuestro límite aumenta hasta el límite
máximo que se puede alcanzar con un archivo Access, que como bien sabemos está en los 2
GB.
Si el campo es memo ya no hablamos ni de longitud fija ni variable, ya que la única posibilidad
es esta última, es decir, longitud variable. Si seguimos la sistemática del apartado anterior
podremos deducir que el tamaño de almacenamiento es el doble de la longitud real del valor
almacenado en el campo.

4 Como habréis imaginado esta definición de tipo dato no se puede establecer a través de la interface de Access, sino que debemos
hacerlo a través de una SQL. En capítulos posteriores veremos cómo realizar esta operación.

5
Visítame en http://bit.ly/NckAccess
Para definir un campo como memo utilizamos:

Texto - Memo LONGTEXT / LONGCHAR / MEMO / NOTE

DATOS TIPO NÚMERO

Y aquí empieza el festival, porque existen diferentes
tipologías de números. La primera gran división que
podemos hacer de los números es aquella que diferencia
entre valores sin decimales (valores enteros) y valores con
decimales (valores decimales).
Una vez establecida esta primera división podemos dividir ambos tipos en función del intervalo
de datos admitido.
Veamos:
VALORES ENTEROS
– Tenemos un tipo de campo que admite valores positivos del 0 al 255. En VB serían los
datos tipo BYTE
– Tenemos un tipo de campo que admite valores positivos y negativos en el intervalo que
va desde el -32.768 hasta el 32.767. En VB serían los datos tipo INTEGER
– Tenemos un tipo de campo que admite valores positivos y negativos en el intervalo que
va desde el -2.147.483.648 hasta el 2.147.483.647. En VB serían los datos tipo LONG
¿Y cuáles son las palabras reservadas en SQL para estos tipos de datos? Pues son las
siguientes:

TIPO DATO VB SQL

Byte BYTE / INTEGER1
Integer SMALLINT / SHORT / INTEGER2
Long INTEGER / LONG / INT / INTEGER4

Conclusión: debemos ir con mucho cuidado y “centrarnos” en si definimos el tipo de dato en

VB o en SQL, puesto que, como podéis ver, las palabras reservadas pueden llevarnos a
confusión por su similitud entre diferentes tipos.
Si volvemos a recurrir a la interfaz de Access estaríamos hablando de:

VALORES DECIMALES
– Tenemos un tipo de datos, denominados “de coma flotante de precisión simple”, que
abarcan un intervalo de valores positivos y negativos que va desde/hasta:
– Para valores negativos: -3.402823E38 y -1,401298E-45
– Para valores positivos: 1,401298E-45 y 3,402823E38
Es lo que en VB conocemos somo SINGLE
– Tenemos otro tipo de datos, denominados “de coma flotante de precisión doble”, que

6
Visítame en http://bit.ly/NckAccess
 abarcan un intervalo de valores positivos y negativos que va desde/hasta:
– Para valores negativos: -1,79769313486231E308 y
-4,940656458441247E-324
– Para valores positivos: 4,940656458441247E-324 y
1,79769313486231E308
Es lo que en VB conocemos como DOUBLE
– Tenemos otro tipo de valores, que denominamos “datos
decimales”, en los que no profundizaremos en este capítulo,
debido a sus características “especiales”. Para que nos
entendamos, y por decirlo de alguna manera, a no ser que
desarrollemos una base de datos para la NASA, en la que
necesitemos un factor de precisión decimal altísimo (¡pero
que muy muy alto!), mejor no utilizar este tipo de datos.
creo que “tenemos de sobra”.
Para definir estos tipos de datos en SQL tenemos:

TIPO DATO VB SQL

Single REAL / SINGLE / FLOAT4 / IEEESINGLE
Double FLOAT / DOUBLE / FLOAT8 / IEEEDOUBLE /
NUMBER
Decimal DECIMAL

Y si volvemos a la interfaz gráfica de Access estaríamos hablando de:

VALORES DE ID. DE RÉPLICA

Los valores de id. de réplica representan un número de identificación global de 16 bites, y
sirven para poder establecer un identificador único y no repetible cuando, precisamente,
replicamos una base de datos Access.
Si queremos definir este tipo de datos con SQL utilizaríamos:

Id. de réplica GUID

DATOS TIPO FECHA/HORA

Los datos de tipo fecha/hora no tienen mayor dificultad. Resaltar que pueden almacenar
valores que van desde el 01/01/100 a 31/12/9999.
Son los datos que en VB conocemos como DATE.

En SQL tendríamos:

7
Visítame en http://bit.ly/NckAccess
TIPO DATO VB SQL
Date DATETIME / DATE / TIME / TIMESTAMP

DATOS TIPO MONEDA

Estos tipos de datos tienen, lógicamente, formato
monetario, y permiten manipular valores que contengan
entre uno y cuatro decimales. Su nivel de precisión es de
hasta quince dígitos a la izquierda del separador de
decimales y, como hemos comentado, cuatro dígitos a su
derecha.
El rango que abarca va desde -922.337.203.685.477,5808 hasta 922.337.203.685.477,5807.
En VB los conocemos como CURRENCY.
En SQL tendríamos:

TIPO DATO VB SQL

Currency MONEY / CURRENCY

DATOS TIPO AUTONUMÉRICO

Los datos de este tipo son en realidad datos numéricos, enmarcados dentro de la categoría de
“Enteros”, y de tipo LONG. Como imagino que todos sabréis, su particularidad reside en que
permite un incremento automático de valor en cada registro nuevo (ojo, que no tiene por que
ser de una unidad en una unidad).
Por esta peculiaridad son idóneos para utilizarlos como clave principal en las tablas.
Para definirlos en SQL utilizamos:

Autonumérico COUNTER / AUTOINCREMENT

DATOS SÍ/NO (DATOS BOOLEANOS)

Los datos sí/no almacenan sólo uno de dos valores posibles: verdadero o falso. Si el valor es
falso se almacena en valor 0, mientras que si es verdadero se almacena el valor -1 (ojo, esto
en Access. Hay otros gestores de bases de datos que pueden tomar el valor 1).
Son los que en VB conocemos como BOOLEAN
Para definirlos en SQL utilizamos:

Booleano BIT / LOGICAL / LOGICAL1

DATOS OBJETO OLE

Este tipo de datos se utiliza para guardar datos binarios largos. Por ejemplo, un documento
Word, o un libro de Excel, corresponden a esta categoría.
Debemos tener en cuenta que su tamaño máximo viene determinado por el tamaño máximo
de archivo que admite Access, que como ya sabemos es de 2GB (para ser más exactos
2,14GB).

8
Visítame en http://bit.ly/NckAccess
No hay una equivalencia exacta en VB para un objeto OLE. Si tuviéramos que almacenarlo
utilizaríamos un tipo VARIANT.
Y para definirlos en SQL tendríamos:

Objeto OLE IMAGE / LONGBINARY / GENERAL /

OLEOBJECT

DATOS BINARIOS
Los he dejado para lo último porque este tipo de datos no se
puede definir desde la interfaz de Access (no tenemos la opción al
crear la tabla). ¿Y qué es un dato binario?
Un dato binario no es más que cualquier tipo de dato que se muestra en su formato nativo, sin
sufrir ninguna transformación por parte de Access. En pocas palabras, lo que se escribe es lo
que se muestra.
Hay que decir que los valores binarios son datos de longitud fija (echad un vistazo al apartado
de los datos de texto si no nos acordamos de qué significa “longitud fija”). Cierto es que se
pueden almacenar datos binarios de longitud variable, pero necesitaríamos utilizar ADO para
poder manipular este tipo de datos (no entraremos en esto, de todas maneras).
Para representar estos datos en SQL tenemos:

Binarios BINARY

CUADRO RESUMEN
Después de esta “disertación sobre tipos de datos” probablemente tengamos la cabeza más
que hinchada... Os pongo pues aquí un cuadro resumen con todo lo que acabamos de
comentar:

TIPO DE DATO (según Access) SQL

Texto – Longitud fija (no disponible en la interfaz CHAR
gráfica de Access)

Texto – Longitud variable (String en VBA) ALPHANUMERIC / STRING / TEXT / TEXT (N) /
VARCHAR
Texto - Memo LONGTEXT / LONGCHAR / MEMO / NOTE
Numérico Byte (Byte en VBA) BYTE / INTEGER1
Numérico entero (Integer en VBA) SMALLINT / SHORT / INTEGER2
Númerico entero largo (Long en VBA) INTEGER / LONG / INT / INTEGER4
Numérico simple (Single en VBA) REAL / SINGLE / FLOAT4 / IEEESINGLE
Numérico doble (Double en VBA) FLOAT / DOUBLE / FLOAT8 / IEEEDOUBLE /
NUMBER
Numérico Id. de réplica GUID
Numérico decimal DECIMAL
Fecha/Hora (Date en VBA) DATETIME / DATE / TIME / TIMESTAMP
Moneda (Currency en VBA) MONEY / CURRENCY
Autonumérico COUNTER / AUTOINCREMENT

9
Visítame en http://bit.ly/NckAccess
Sí/No (Boolean en VBA) BIT / LOGICAL / LOGICAL1

Objeto OLE IMAGE / LONGBINARY / GENERAL /

OLEOBJECT
Binarios (no disponible en la interfaz gráfica de Access) BINARY

ALGUNOS COMPONENTES DE SQL

Vamos a ver algunos componentes que conforman el lenguaje SQL simplemente para “sentar
bases terminológicas”. Las iremos desarrollando a lo largo del curso.

COMANDOS
Si partimos de la base que una instrucción la definimos como una expresión de consulta SQL
generada por un comando y sus argumentos o parámetros podremos decir que un comando es
aquella instrucción que se puede ejecutar directamente en una consulta SQL.
En el lenguaje SQL podemos encontrar dos tipos de comandos:
– Los pertenecientes al lenguaje de definición de datos (DDL)
– Los pertenecientes al lenguaje de manipulación de datos (DML)
Los primeros permiten crear y definir tablas, campos, índices, procedimientos almacenados,
vistas, usuarios y grupos de trabajo.
De las anteriores acciones hay algunas que son exclusivas de trabajo en ADO. En este curso no
se van a ver estos comandos.
Los segundos permiten crear consultas para ordenar, filtrar y extraer datos de la BD.
Por ejemplo, entre los primeros tendríamos:

CREATE TABLE
ALTER TABLE
CREATE INDEX
DROP TABLE
DROP INDEX

Entre los segundos tendríamos:

SELECT
UPDATE

10
Visítame en http://bit.ly/NckAccess
INSERT
DELETE

CLÁUSULAS
Podríamos decir que las cláusulas son condiciones que
permiten la modificación la definición de los datos que
vamos a manipular o seleccionar.
Por ejemplo, son cláusulas:

AS
FROM
WHERE
GROUP BY
CONSTRAINT
HAVING
ORDER BY
PROCEDURE

PREDICADOS
Como predicados podríamos entender aquellas expresiones que, de alguna manera, modifican
la acción de los comandos en cuanto al resultado que se va obtener.
Serían predicados:

ALL
DISTINCT
DISTINCTROW
TOP
UNION

OPERACIONES
Mediante las operaciones definimos alguna “operación específica” (valga la redundancia) que
condiciona la ejecución de la SQL y, por extensión, los resultados mostrados.
Serían operaciones:

UNION
INNER JOIN
LEFT JOIN
RIGHT JOIN

11
Visítame en http://bit.ly/NckAccess
OPERADORES
Dentro de los operadores podemos encontrar dos tipos:
– Operadores lógicos
– Operadores matemáticos y de comparación
Dentro de los operadores lógicos tendríamos:

AND
OR
XOR
NOT

Y dentro de los operadores matemáticos y de comparación tendríamos:

< >
<= >=
= <>
BETWEEN...AND IN
LIKE

FUNCIONES AGREGADAS
Las funciones agregadas permiten manipular grupos de registros con la finalidad de retornar
un sólo valor, que será el que defina la propia función.

Dentro de las funciones agregadas podemos encontrar:

COUNT Devuelve el conteo de registros

AVG Devuelve el promedio
SUM Devuelve la suma
VAR Devuelve la varianza de una muestra de población
VARP Devuelve la varianza de una población
STDEV Devuelve la desviación estándar de una muestra de
población
STDEVP Devuelve la desviación estándar de una población
FIRST Devuelve el valor del primer registro
LAST Devuelve el valor del último registro
MAX Devuelve el valor máximo
MIN Devuelve el valor mínimo

12
Visítame en http://bit.ly/NckAccess
PREPARACIÓN Y EXPLICACIONES VARIAS PARA SEGUIR EL
RESTO DEL CURSO
Vamos a desarrollar el curso sobre un ejemplo de una base
de datos5, para poder ver aplicaciones prácticas de las
sentencias SQL.
Los ejemplos de sentencias SQL los vamos a ver
incardinados dentro de código VBA, de manera que, en la
mayoría de casos, no tendremos una SQL “directa”, sino
que la pasaremos por una variable, a los simples efectos de
poder ver con mayor claridad las diferentes estructuras de
las SQL.
Las consultas de acción no tienen mayor problema, en este aspecto, porque las vamos a
ejecutar y vamos a poder ver los resultados de manera directa o indirecta; para las consultas
de selección, sin embargo, no podemos apreciar directamente sus resultados. Para poder
verlos tendremos que convertir nuestra SQL en un objeto-consulta de Access, y ello nos
obligará a seguir la siguiente estructura en los códigos:
– Borramos el objeto-consulta por si existiera (si ya existe obtendríamos un error de
código)
– Creamos la SQL
– La convertimos en un objeto-consulta, para poder ver los resultados.
Para poder realizar lo anterior utilizaremos un módulo, que nos ejecutará el primer y el tercer
paso, dejando el segundo en el código del botón que programemos (las programaremos a
través de clicks de botón porque considero que es un proceso muy sencillo), lo cual nos
permitirá centrarnos en esta segunda parte, esto es, en la SQL propiamente dicha.
Para hacer lo anterior vamos a seguir estos pasos:
1.- Creamos una BD en blanco, y sacamos el editor de VB (ALT+F11)
2.- Insertamos un módulo (VBE menú → Insertar → Módulo)
3.- Guardamos ese módulo con el nombre de mdlProcesos
4.- En ese módulo escribimos los siguientes procedimientos6:
…
Public Sub eliminaConsulta(nomConsulta As String)
Dim qry As Object
For Each qry In CurrentData.AllQueries
If qry.Name = nomConsulta Then
DoCmd.DeleteObject acQuery, qry.Name
Exit For
End If
Next
End Sub
…
Public Sub creaConsulta(nomConsulta As String, laSql As String)

5 Esta BD inicial os la podéis bajar aquí.

6 Si utilizamos Access 2003 deberemos asegurarnos de que tenemos registrada la librería “Microsoft DAO 3.6 Object Library” (VBE
Menú → Herramientas → Referencias...)

13
Visítame en http://bit.ly/NckAccess
 Dim qryDef As DAO.QueryDef
Set qryDef = CurrentDb.CreateQueryDef(nomConsulta)
qryDef.SQL = laSql
End Sub
…
Vamos a seguir con nuestra BD. Vamos a crearnos una
tabla donde introduciremos los datos personales de los
trabajadores. A esta tabla la llamaremos TTrabPersonal. Le
daremos la siguiente estructura:

A continuación nos crearemos una segunda tabla, con los datos laborales de los trabajadores,
y la llamaremos TTrabLaboral, y tendrá la siguiente estructura:

Debemos tener en cuenta que el campo [IdTrab] lo hemos definido a través de un asistente
para búsquedas, que nos ha buscado, en la tabla TTrabPersonal, sus tres primeros campos en
este orden: [Id], [ApellTrab] y [NomTrab]; hemos ordenado por apellidos ascendente,
ocultando la clave principal.
Es decir, que aunque este campo nos muestre apellidos-nombre el valor que almacena es el
código del trabajador.
El mismo proceso se ha seguido para el campo [DependeDe]
Vamos a crearnos una tabla con los datos de los clientes de la empresa, que llamaremos
TClientes. Tendrá la siguiente estructura:

14
Visítame en http://bit.ly/NckAccess
 Ahora vamos a crear una tabla de ventas donde reflejaremos las
ventas realizadas a los clientes. La llamaremos TVentas, y tendrá
la siguiente estructura:

Teniendo en cuenta que para el campo [IdCliVta] hemos utilizado el asistente para búsquedas,
que ha buscado en la tabla TClientes el nombre del cliente. Es decir, nos muestra el nombre del
cliente, pero almacena su código.
Si hemos realizado correctamente los pasos anteriores la ventana de relaciones nos debería
haber quedado así:

Vamos a crearnos seguidamente una tabla auxiliar, que llamaremos TMeses, que tendrá la
siguiente estructura (no vamos a poner ningún campo como clave principal):

15
Visítame en http://bit.ly/NckAccess
Finalmente crearemos una tabla muy simple, cuya idea es que nos recoja el usuario que está
operando en ese momento en la BD. Esta BD tendrá siempre un solo registro (el nombre del
usuario activo), que llamaremos TUsuarioAct, y la construiremos con esta simple estructura:

Ya tenemos las estructuras de las tablas preparadas. Ahora sólo hay que introducir datos.
Evidentemente podéis dar de alta los datos que queráis, pero como yo voy a mostrar los
resultados en base a la información que haya en estas tablas o bien os bajáis la BD de ejemplo
y anexáis los datos a vuestras tablas o bien operáis directamente con la BD de ejemplo...
Como siempre, a gusto del consumidor.
Yo os indico los registros que he dado de alta:
Para la tabla TClientes:

Para la tabla TMeses

Para la tabla TTrabPersonal

16
Visítame en http://bit.ly/NckAccess
Para la tabla TTrabLaboral

Para la tabla TVentas

Y para la tabla TUsuarioAct podemos escribir el nombre que queramos. Lógicamente y he

17
Visítame en http://bit.ly/NckAccess
escrito:

PARA FINALIZAR ESTE CAPÍTULO

Creo que este capítulo ha sido interesante: hemos cogido dolor de cabeza al leer tanta teoría y
hemos cogido dolor de dedos al tener que prepararnos tantas tablas con datos. Como reza el
dicho: “Para lucir hay que sufrir”... je, je...
Sinceramente creo que era necesario realizar este esfuerzo inicial. En los próximos capítulos
veremos cómo sacar rendimiento a tantos “desvelos”.
Un saludo, y...
¡Suerte!

18
Visítame en http://bit.ly/NckAccess