Manual

de
Programación
SQL
 Índice
1.Introducción a SQL......................................................................................................................................... 4

1.1.Grupos de comando ................................................................................................................................... 5

1.2.Cláusulas ..................................................................................................................................................... 5

1.3.Sintaxis de una instrucción SQL .......................................................................................................... 5

1.4.Primera instrucción SQL ........................................................................................................................ 6

2.Cláusulas y operadores ................................................................................................................................... 9

2.1.Ejemplos de consultas SQL con cláusula WHERE .......................................................................... 10

2.2.Ejercicios ................................................................................................................................................ 13

3.Cláusula ORDER BY. Ordenando registros .............................................................................................. 17

3.1.Ejercicios ................................................................................................................................................. 18

4.Consultas de agrupación o totales ............................................................................................................. 20

4.1.Agrupando y sumando ............................................................................................................................ 20

4.2.Agrupando y promediando algunas secciones .................................................................................. 21

4.3.Agrupando y contando clientes por población ................................................................................. 21

4.4.Agrupando y estableciendo máximos ................................................................................................ 22

4.5.Ejercicios ................................................................................................................................................ 23

5.Consultas de cálculo ...................................................................................................................................... 25

5.1.Consultas de cálculo ............................................................................................................................... 25

5.2.Consultas de fecha ................................................................................................................................ 27

5.3.Ejercicios ................................................................................................................................................ 27

6.Consultas Multitabla I (consultas de unión externa) ............................................................................ 29

6.1.Consultas con UNION ........................................................................................................................... 29

6.2.Consultas con UNION ALL .................................................................................................................. 31

7.Consultas Multitabla II (consultas de unión interna) ........................................................................... 32

8.Subconsultas I ............................................................................................................................................... 37

8.1.Subconsulta escalonada ........................................................................................................................ 37

8.2.Subconsulta de lista ............................................................................................................................. 38

9.Subconsultas II ............................................................................................................................................. 39

10.Consultas de acción I .................................................................................................................................. 42

10.1.Consultas de actualización.................................................................................................................. 42

10.2.Consultas de creación de tabla a partir de otra ........................................................................... 43

10.3.Ejercicios .............................................................................................................................................. 44
11.Consultas de acción II ................................................................................................................................ 47

11.1.Predicado DISTINCT .......................................................................................................................... 48

12.Consultas de acción III. Consultas de datos anexados ...................................................................... 48

13.Referencias cruzadas ................................................................................................................................. 49

13.1.Ejercicios ............................................................................................................................................... 53

14.DDL. Creación de tablas ............................................................................................................................. 55

14.1.Create Table.......................................................................................................................................... 55

14.2.Eliminar tabla (drop table) ................................................................................................................ 60

15.Agregar, eliminar y modificar campos .................................................................................................... 60

15.1.Agregando campos ............................................................................................................................... 61

15.2.Eliminando campos ............................................................................................................................... 61

15.3.Modificando el tipo de datos ............................................................................................................ 62

15.4.Establecer valor por defecto en un campo (SET DEFAULT)..................................................... 62

16.Índices ........................................................................................................................................................... 63

16.1.Índice clave primaria (Primary Key) ................................................................................................. 64

16.2.Índice ordinario (Index) .................................................................................................................... 65

16.3.Índice único (UNIQUE) ..................................................................................................................... 66

17.Eliminando índices ....................................................................................................................................... 67

18.Triggers I (disparadores). Introducción e INSERT ........................................................................... 67

18.1.Trigger de ingreso INSERT .............................................................................................................. 68

19.Triggers II (disparadores). UPDATE ..................................................................................................... 71

20.Triggers III (disparadores). DELETE ................................................................................................... 74

20.1.Agregando campos a la tabla de productos eliminados ............................................................... 76

20.2.Eliminar un trigger desde código ..................................................................................................... 77

20.3.Eliminar un trigger en un solo paso ................................................................................................. 77

 1.Introducción a SQL

En este capítulo hablaremos de la procedencia del lenguaje, estándares y

crearemos una primera instrucción SQL que nos permita obtener información
de una BBDD.

Veamos el siguiente esquema para entender el funcionamiento de SQL:

Conozcamos, además, el estándar SQL:

4
 1.1.Grupos de comando

Observaremos aquí cómo se dividen y componen los grupos de comando:

1.2.Cláusulas

Introducimos aquí lo que son las cláusulas SQL:

1.3.Sintaxis de una instrucción SQL

Vemos aquí cuál es la sintaxis de una instrucción SQL:

Es importante decir que no todas las instrucciones SQL tienen que componerse
así. Lo que sí necesariamente tienen que tener es comando(s) y cláusula(s).

5
 1.4.Primera instrucción SQL

Primeramente, creamos una base de datos en phpMyAdmin. Una vez que la

creamos, la seleccionamos y pulsamos en Importar:

Al hacer esto, emerge lo siguiente:

Seleccionamos el archivo de Clientes.ods:

6
Una vez allí, tenemos que cotejar que el formato sea de Hoja de Cálculo y que
todas las Opciones específicas al formato estén seleccionadas:

Hecho esto, pulsamos en Continuar, creándose así la tabla clientes:

Luego de todo esto, realizamos lo mismo con la tabla Productos.ods. El proceso

es exactamente igual. El resultado será este:

7
De esta manera, la base de datos curso_sql tiene esta estructura:

Una vez aquí pulsamos en la pestaña SQL y escribimos la instrucción que

deseemos:

Como se puede observar, utilizamos el comando SELECT y la cláusula FROM.

Pulsamos en el botón de Continuar y este habrá de ser el resultado de la

consulta:

Tal como vemos, lo que se desprende de la consulta son todos los registros,
aunque solamente podemos visualizar la empresa, la dirección y la población.

8
 2.Cláusulas y operadores

En este capítulo comenzamos a ver las cláusulas y los operadores. Abordaremos

concretamente a la cláusula WHERE.

Conozcamos entonces a las cláusulas:

Veamos también a los operadores de comparación:

A su vez, tenemos a los operadores lógicos:

9
Dicho todo esto, es importante que tengamos presente el orden de escritura:

2.1.Ejemplos de consultas SQL con cláusula WHERE

A continuación veremos algunos ejemplos prácticos de consultas SQL con

cláusula WHERE:

Lo que estamos solicitando aquí es que nos muestre el nombre y el precio de los
artículos que se encuentren en la sección de cerámica. Este es el resultado final
de la consulta:

Un segundo ejemplo sería el de realizar una consulta, pidiendo que nos muestre
el precio y el nombre de todos los artículos pertenecientes a las secciones de
cerámica y deportes:

10
Tal como se puede observar, aquí utilizamos el operador lógico OR ya que
nuestro objetivo es que cumpla una u otra condición. No podríamos ponerle AND
ya que eso implicaría que cumpliera las dos condiciones al mismo tiempo.

En consecuencia, el resultado que arroja la consulta es el siguiente:

Un tercer ejemplo de consulta es que queremos que nos muestre todos los
campos de la tabla, estableciendo como criterio que solamente nos traiga los
productos de la sección deportes, cuyo país de origen sea Estados Unidos:

Tal como podemos observar, utilizamos el * ya que estamos haciendo referencia

a todos los artículos de la tabla PRODUCTOS. Utilizamos la cláusula WHERE
para determinar los criterios y el operador AND para indiciar que se tienen que
cumplir las dos condiciones establecidas como criterio de consulta. El resultado
será:

Hecho todo esto, ahora queremos realizar consultas, pero hay un problema con el
tipo de datos. Para ello, eliminamos a la tabla PRODUCTOS y la volvemos a

11
importar. No obstante, antes de volverla a importar, debemos hacer unas
modificaciones en el archivo de origen (es decir, desde el cual importaremos la
tabla). Establecemos que los valores del campo precio (no el título) serán de tipo
moneda, mientras que a los valores del campo fecha (no el título) los tenemos que
personalizar (yyyy-mm-dd o aaaa-mm-dd). La configuración varía según la
versión de MS Excel. Realizado esto, volvemos a importa la tabla PRODUCTOS a
nuestra Base de Datos curso_sql.

Al importarla, luego tenemos que ir a la pestaña de Examinar:

Aquí podemos observar que, efectivamente, el campo PRECIO ahora tiene datos
de tipo decimal. Sin embargo, el campo FECHA sigue siendo varchar. Por este
motivo, debemos de modificarlo ingresando en el botón de Cambiar y sustituir
DATE por VARCHAR. Una vez que lo guardamos, esto es lo que nos aparece como
resultado:

A continuación, nos posicionamos en la pestaña SQL y escribimos la consulta:

12
En esta ocasión, estamos solicitando que nos muestre todos los artículos de la
tabla PRODUCTOS que sean de marzo y de abril. Para ello, hemos utilizado el
operador de comparación BEWTEEN acompañado del operador lógico AND. El
resultado será:

2.2.Ejercicios

En esta sub-sección se plantearán y resolverán una serie de ejercicios.

La sentencia es:

Y, el resultado:

13
La sentencia es:

Y, el resultado:

La sentencia es:

Otra opción de sentencia podría ser esta:

Y, el resultado:

14
La sentencia es:

Y, el resultado:

La sentencia es:

15
Y, el resultado:

La sentencia es:

Y, el resultado:

16
 3.Cláusula ORDER BY. Ordenando registros

En este capítulo veremos cómo ordenar los registros de una consulta SQL con
la cláusula Order By.

Veamos un ejemplo de sentencia:

Siendo el resultado el que observamos a continuación:

Tal como podemos observar, hemos ordenado la tabla de manera ascendente

teniendo como primer criterio el campo sección. El segundo criterio de
ordenación ha sido el país de origen, mientras que el tercer criterio jerárquico
seleccionado ha sido el precio. Los tres niveles jerárquicos van en sentido
ascendente (el cual se da por defecto). En caso de que quisiéramos ordenarlos en
sentido descendiente debemos colocar la instrucción DESC al final.

17
 3.1.Ejercicios

En esta sub-sección se plantearán y resolverán una serie de ejercicios.

La sentencia es:

Y, el resultado:

La sentencia es:

18
Y, el resultado:

La sentencia es:

Y, el resultado:

19
 4.Consultas de agrupación o totales

En este capítulo veremos cómo realizar consultas SQL de agrupación o

totales.

Veamos entonces cuáles son las funciones de agregado:

4.1.Agrupando y sumando

En este caso, veremos cómo agrupar y sumar:

Esta sentencia SQL lo que solicita es poder ver cuánto es el valor total de los
precios por sección. Para ello, tenemos que crear un campo de agrupación
(SECCIÓN) y un campo de suma (PRECIO). A su vez, tenemos que utilizar un
alias (en SQL, los alias se escriben AS). Para indicar el campo por el cual
agruparemos se utilizar la instrucción GROUP BY y para ordenar el precio
usamos la instrucción ORDER BY y le ponemos el campo que recibió un alias.

20
Pulsamos en continuar y este habrá de ser el resultado de la consulta:

Tal como vemos, ocurrieron dos cosas. La primera es que el campo PRECIO ahora
se llama SUMA_ARTICULOS y, en segundo lugar, damos cuenta que los artículos
fueron ordenados de menor a mayor en función del total de sus valores.

4.2.Agrupando y promediando algunas secciones

En este caso, veremos cómo agrupar y promediar solamente los productos

pertenecientes a las secciones de DEPORTES y CERÁMICA.

Por tanto, la instrucción será la siguiente:

En cuanto a esto, es importante decir que el HAVING sustituye al WHERE en

las consultas agrupadas.

El resultado será:

4.3.Agrupando y contando clientes por población

En este caso, veremos cómo agrupar y contar a los clientes según su población.
Es decir, cuántos hay de cada provincia española.

21
Por tanto, la sentencia es:

Siendo el resultado de la consulta el siguiente:

4.4.Agrupando y estableciendo máximos

En este caso, veremos cómo agrupar y encontrar al valor máximo de todos los
artículos de la sección “Confección”.

Por tanto, la sentencia será:

Y, el resultado:

22
 4.5.Ejercicios

A continuación, se desarrollarán una serie de ejercicios.

La sentencia es:

Y, el resultado:

23
La sentencia es:

Siendo el resultado de la consulta:

Esta es la sentencia:

Siendo el resultado de la consulta:

24
Siendo el resultado de la consulta:

Esta es la sentencia:

Siendo el resultado:

5.Consultas de cálculo

En este capítulo veremos cómo realizar consultas de cálculo con SQL. Veremos
también el uso de algunas funciones frecuentes de fecha y formato.

5.1.Consultas de cálculo

Veamos un primer ejemplo de cómo realizar consultas de cálculo. En el primer

ejemplo daremos cuenta de cómo implementar la instrucción ROUND para
redondear valores.

La sentencia es:

25
Es importante notar que cuando queremos hacer uso de la instrucción ROUND, la
sintaxis es: ROUND(Expresión, cantidad de decimales). El resultado de la
consulta habrá de ser:

Hecho esto, prestemos atención a un segundo ejemplo de consulta de cálculo.

La sentencia es:

Siendo el resultado:

26
 5.2.Consultas de fecha

En este tramo aprenderemos a cómo crear consultas de fecha. Por tanto, aquí
veremos las siguientes funciones:

 NOW(), la cual nos da la fecha actual.

 DATE_FORMAT(expresión, ‘%D-%M-%Y’). Esta función nos da el
formato de fecha.
 DATE_DIFF(fecha 1, fecha2). Esta función nos proporciona la
diferencia entre dos fechas.

A continuación, veremos un ejemplo en el cual se aplican estas tres funciones. En

consecuencia, la sentencia de la consulta será:

Siendo el resultado final:

5.3.Ejercicios

En esta sección tenemos tres ejercicios prácticos.

La sentencia es:

27
Y el resultado:

La sentencia es:

Y el resultado es:

La sentencia es:

28
Y el resultado es:

6.Consultas Multitabla I (consultas de unión externa)

En este capítulo comenzamos a abordar las consultas multitablas. En particular,

iniciaremos el tema las consultas llamadas de unión externa. Veremos, en
consecuencia, a los operadores Union y Union All.

6.1.Consultas con UNION

Observemos el siguiente cuadro que muestra la utilidad del operador UNION:

Hay que tener que este tipo de consultas obligan a que:

 Ambas tablas tengan la misma cantidad de campos.

 Los campos deben tener tipos de datos compatibles.

29
Veamos un primer ejemplo en el cual lo que se pretende es unir en una sola
consulta a las secciones de DEPORTES y de DEPORTES DE RIESGO de ambas
tablas.

La sentencia es:

Siendo el resultado el que vemos a continuación:

Es importante aclarar aquí que el criterio de búsqueda no tiene por qué ser
necesariamente el mismo. En consecuencia, veamos cómo se unen dos tablas, pero
con diferentes criterios de consulta. Por tanto, la sentencia sería:

Arrojando el siguiente resultado:

30
Tal como podemos observar, en esta segunda consulta hemos unidos a aquellos
artículos de la tabla PRODUCTOS, cuyo precio es superior a 500, con los
artículos de la tabla PRODUCTOSNUEVOS que pertenezcan a la sección de alta
costura.

6.2.Consultas con UNION ALL

La diferencia entre UNION y UNION ALL es que, si hay registros repetidos en

ambas tablas, UNION solamente los muestra una vez, mientras que UNION ALL
los muestra todas las veces que se repitan.

Por tanto, la sentencia es:

Siendo el resultado el que vemos a continuación:

Aquí podemos observar como con el operador UNION ALL se ve el mismo

artículo repetido dos veces. Si hubiéramos puesto UNION en lugar de UNION
ALL solamente veríamos el registro una sola vez sin su repetición, claro está.

31
 7.Consultas Multitabla II (consultas de unión interna)

En este capítulo veremos las consultas con tablas relacionadas. Utilizaremos la

cláusula inner join. Precisamente, esta cláusula nos permite ver qué elementos
tienen en común dos tablas o más.

Veamos un esquema:

Luego de haber realizado la importación de las tablas CLIENTES y PEDIDOS

tenemos que relacionarlas en phpMyAdmin ya que con la sola importación no se
relacionan automáticamente.

Para ello, nos posicionamos en la tabla Clientes y vamos a la pestaña de

Estructura:

A continuación, visualizamos lo siguiente:

32
Pulsamos Continuar en la zona de creación de índices y emerge lo siguiente:

Completamos los campos y pulsamos en Guardar:

Al hacer esto, la estructura queda así:

33
Hacemos lo mismo para la tabla PEDIDOS:

Quedando así su estructura:

Hecho esto, creamos un segundo índice, que será indexado:

34
Quedando su estructura de la siguiente manera:

Hecho todo esto, tenemos que pulsar en la opción de vista de relaciones:

Aquí rellenamos lo siguiente:

Pulsamos en Guardar y vemos esto:

35
De esta manera queda por finalizado el proceso de relacionamiento.

Hecho esto, ya estamos en condiciones de hacer una consulta SQL con la

instrucción INNER JOIN. La misma es:

Aquí estamos seleccionando al código de cliente (de la tabla clientes), a la

población, a la dirección, al número de pedido, al código de cliente (de la tabla
pedidos) y a la forma de pago. Todo esto lo estamos seleccionando desde la tabla
de CLIENTES. Todo ello lo unimos a la tabla PEDIDOS utilizando la instrucción
INNER JOIN. Luego de ello tenemos que especificar que el código de cliente es
el mismo en ambas tablas. Esto se hace con la instrucción ON. Por último,
establecemos como criterio que nos arroje a los registros que solamente sean de
Madrid.

El resultado de la consulta es:

36
 8.Subconsultas I

En este capítulo comenzamos a tratar el tema de las subconsultas, las cuales no

son más que una consulta dentro de otra consulta. O, lo que es lo mismo, un
SELECT dentro de otro SELECT:

Profundizando un poco más:

Para poder trabajar con las subconsultas es necesario que tengamos presente a
los distintos operadores:

8.1.Subconsulta escalonada

Veamos un ejemplo:

37
Tal como podemos ver, estamos solicitando que nos muestre todos los productos
cuyo precio sea menor al promedio/media. El resultado será:

8.2.Subconsulta de lista

Veamos el siguiente ejemplo utilizando el operador ALL:

Esta consulta se traduce en que nos muestre todos los registros que tengan un
precio más alto que el registro perteneciente a la sección cerámica con precio
más alto. El resultado es:

38
 9.Subconsultas II

En este capítulo continuamos avanzando en las subconsultas sql. Utilizaremos los

predicados IN (están) y NOT IN (no están).

Para ello, nos vamos a ACCESS. Pulsamos en la pestaña CREAR y luego hacemos
click en Diseño de consulta:

Aparece lo siguiente:

Pulsamos en Cerrar y hacemos click en Vista SQL:

Esto nos permite ya empezar a codificar las consultas.:

39
Pulsamos en Ejecutar y veremos el resultado:

El objetivo de esta consulta es mostrar todos aquellos artículos que hayan sido
pedidos en un valor mayor a las 20 unidas. Hemos utilizado IN para indicar que,
primeramente, nos muestre a los campos Nombre de Artículo y Precio de la tabla
PRODUCTOS. En esta consulta incluimos (IN) a la otra consulta en la cual
estamos seleccionando a todos los Códigos de Artículo de la tabla
PRODUCTOSPEDIDOS donde el número de Unidades sea mayor a 20.

Un segundo ejemplo de subconsulta sql con el predicado NOT IN es el que

presentaremos a continuación:

40
Siendo el resultado:

El objetivo de esta consulta es que nos muestre a todas las empresas que hayan
hecho pagos sin tarjeta o que, de hecho, no hayan hecho pago alguno. Para ello,
creamos una consulta en la cual nos traiga el Código del Cliente de la tabla
PEDIDOS de todos aquellos que hayan pagado con tarjeta. Luego de ello,
realizamos una consulta padre en la cual le solicitamos que nos muestre el
Nombre de la Empresa y la Población de todos los registros de la tabla
PRODUCTOS. Para combinar estas dos consultas, utilizamos el predicado NOT
IN.

El resultado gramatical de esta consulta con subconsulta será que nos muestre
todas aquellas empresas y su población que no hayan pago con tarjeta o que no
hayan pago en absoluto.

41
 10.Consultas de acción I

En este capítulo comenzamos a abordar las consultas de acción, concretamente

las consultas de creación de tabla y las de actualización.

10.1.Consultas de actualización

Comencemos por la consulta de actualización (UPDATE SET:

Lo que estamos haciendo así es actualizar en 10 euros de incremento el precio de

todos los artículos de la tabla PRODUCTOS que pertenezcan a la sección
deportes. El resultado será:

A su vez, este tipo de consultas también pueden hacerse para campos de tipo
texto. Veamos un ejemplo:

42
Aquí hemos modificado el nombre de la sección, la cual pasará de llamarse
“Deportes” para llamarse “Deportivos”.

Veamos el resultado de la consulta:

10.2.Consultas de creación de tabla a partir de otra

Veamos ahora a las consultas de creación de tabla a partir de otra (CREATE

TABLE):

Como vemos, se crea una nueva tabla, la cual solamente contiene a los registros
de Madrid:

43
 10.3.Ejercicios

Esta es la sentencia:

Y este, el resultado:

Esta es la sentencia:

44
Y el resultado:

La sentencia es:

Y el resultado:

La sentencia es:

45
Y el resultado:

La sentencia es:

Dando el siguiente resultado:

46
 11.Consultas de acción II

En este capítulo veremos el comando DELETE de las consultas de eliminación

SQL.

Por ejemplo, si quisiéramos eliminar a los registros de Madrid de la tabla

Clientes, esta sería la sentencia de la consulta:

Otro ejemplo puede ser el de eliminar a los campos de la sección de Deportes

que tengan un precio entre 50 y 100. Todos ellos pertenecen a la tabla
Productos:

Un tercer ejemplo será el de eliminar a aquellos clientes que no hayan hecho

ningún pedido. Para ello, tenemos que utilizar el predicado DISTINCTROW y,
también, LEFT JOIN. En consecuencia, la sentencia es:

47
 11.1.Predicado DISTINCT

Este predicado hace que el mismo nombre de un registro solamente aparezca una
vez. Por ejemplo, supongamos que una empresa tiene varios registros y nosotros
solamente queremos saber qué empresas trabajan con nosotros, entonces este
predicado se torna interesante. Veamos una sentencia de ejemplo:

Y el resultado será:

Esto nos arroja la lista de nuestros clientes.

12.Consultas de acción III. Consultas de datos anexados

En este capítulo veremos la última de las consultas de acción: la consulta de

datos anexados.

48
La sintaxis de la sentencia es la siguiente:

Dando como resultado:

13.Referencias cruzadas

En este capítulo veremos cómo realizar consultas de referencias cruzadas en

SQL. Una consulta de referencia cruzada es prácticamente lo mismo que una
tabla dinámica de Excel.

Veamos el siguiente esquema para conocer su estructura:

49
Es importante aclarar que phpMyAdmin (MySQL) no admite este tipo de
consultas. Por tanto, debemos utilizar Access. Vayamos entonces allí.

La sintaxis de la sentencia es la siguiente y debe respetar el orden establecido:

El resultado, luego de la ejecución, es este:

Lo que hacemos con esta consulta es que no sume el precio de los artículos. Por
ejemplo, en el caso de los destornilladores, nos ha sumado los precios de los
artículos que son destornilladores. Esto ha sido posible utilizando la función de
suma SUM delante del campo PRECIO.

50
A continuación haremos otra consulta en la cual queremos saber la cantidad que
tenemos de cada artículo que tengan precio. Para ello, usamos la instrucción
COUNT:

Arrojando el siguiente resultado:

Ahora probemos trabajar con dos tablas relacionadas. Primeramente, tenemos

que cruzarlas y guardarlas en una consulta (de nombre previa):

51
Hecho esto, realizamos la consulta de referencia cruzada:

El resultado será:

Por último, veremos cómo se pueden ingresar varios campos en la zona de las
filas:

52
El resultado es:

13.1.Ejercicios

53
La sentencia es:

Corroborando el resultado:

54
 14.DDL. Creación de tablas

En este capítulo trabajaremos con los comandos DDL que nos permitirán
ejecutar sentencias de definición de datos. Estas sentencias crean, modifican y
eliminan nuevas tablas y BBDD.

Veamos el siguiente esquema:

Además, es importante que conozcamos los tres tipos de tablas que hay en
SQL:

14.1.Create Table

Observemos su sintaxis:

55
En cuanto a los tipos de datos, existen varias categorías:

Y estos son los subtipos:

56
Los pasos para crear una tabla en phpMyAdmin son los que desarrollaremos a
continuación.

En primer lugar, tenemos que seleccionar la base de datos y luego pulsar en la

pestaña SQL:

Quedando así:

57
Allí escribimos lo siguiente:

Ponemos la instrucción CREATE TABLE y el nombre que le queremos poner a la

tabla. En este caso, será PRUEBA. Entre paréntesis ponemos el nombre del
campo que tendrá esta tabla y el tipo de dato. A su vez, debemos especificar la
extensión que tendrá el tipo de dato. Hecho todo esto pulsamos en el botón de
Continuar, creándose así la tabla:

En ACCESS es similar. Simplemente se escribe TEXT en lugar de VARCHAR.

58
Probemos ahora crear una tabla con varios campos que tengan distintos tipos
de dato:

Una vez que pulsamos en Continuar, se crea la tabla, la cual tendrá esta
estructura:

En ACCESS se pone TEXT en lugar de VARCHAR, BYTE en lugar de TINYINT y

BIT en lugar de BOOL.

Hecho todo esto, tenemos que ver cómo ingresar un CAMPO AUTONUMÉRICO:

Aquí tenemos que crear el campo, asignarle un tipo de dato INT

AUTO_INCREMENT. Luego de ello, al final de la sentencia hay que especificar
que será la clave primaria (PRIMARY KEY) y, entre paréntesis, el nombre del
campo autonumérico.

En ACCESS se modifica por COUNTER solo al principio. No hay que especificar

la clave primaria.

59
La estructura de la tabla será:

14.2.Eliminar tabla (drop table)

La instrucción DROP TABLE se utiliza para eliminar una tabla. Veamos un

ejemplo de cómo se lleva esto a la práctica:

En efecto, se elimina.

15.Agregar, eliminar y modificar campos

En este capítulo veremos al comando ALTER para agregar y modificar campos

en las tablas. También veremos la cláusula SET DEFAULT para establecer
valores por defecto dentro de un campo.

60
 15.1.Agregando campos

Para agregar un campo en la tabla tenemos que utilizar la instrucción ALTER. La

sintaxis es la siguiente:

Con este campo agregado, la estructura ahora es:

15.2.Eliminando campos

Para eliminar un campo esta será la sentencia:

61
Veremos que en la tabla SIMPLE ya no aparece más el campo POBLACION:

15.3.Modificando el tipo de datos

Para realizar esto, debemos utilizar doblemente el comando ALTER:

El primer ALTER corresponde a la tabla en la cual realizaremos las

modificaciones, mientras que el segundo ALTER refiere al tipo de dato que
queremos cambiar de un campo en particular.

15.4.Establecer valor por defecto en un campo (SET DEFAULT)

La cláusula SET DEFAULT no es admitida por todos los gestores. Por ejemplo,
ACCESS no la reconoce, mientras que phpMyAdmin sí lo hace.

Vayamos allí e ingresemos la siguiente instrucción:

Luego de ello, nos dirigimos a la estructura de la tabla:

62
Si quisiéramos valor por defecto tenemos que escribir la siguiente instrucción:

Pasando a ser la estructura:

16.Índices

En este capítulo veremos cómo crear índices en campos de tablas desde SQL.

Veamos los tipos de índice con los que trabajaremos:

63
 16.1.Índice clave primaria (Primary Key)

La clave primaria o PRIMARY KEY se utiliza en los campos que admiten

solamente valores únicos. Por tanto, veamos el siguiente esquema:

Esta es la sentencia de creación de una clave primaria:

Obteniendo el siguiente resultado:

Cómo cambiar una clave primaria:

Obteniendo el siguiente resultado:

64
 16.2.Índice ordinario (Index)

El índice ordinario o INDEX se utiliza en campos, que admiten valores duplicados

y se crea con el comando CREATE INDEX.

Veamos el siguiente ejemplo:

Arrojando como resultado:

Observemos un segundo ejemplo en la tabla Ejemplo:

65
Quedando la estructura de la siguiente manera:

16.3.Índice único (UNIQUE)

El índice único o UNIQUE se utiliza en campos, que admiten valores únicos y se

crean con el comando CREATE UNIQUE INDEX. Por tanto, observemos este
esquema

Esta es la sentencia:

Mostrando el siguiente resultado de estructura:

66
 17.Eliminando índices

Para eliminar índices, se utiliza el comando DROP INDEX y el comando DROP

PRIMARY KEY.

Comenzaremos eliminando el PRIMARY KEY de la tabla CLIENTES_MADRID.

Para ello, escribimos la siguiente instrucción:

Hecho todo esto, procederemos a eliminar al INDEX haciendo uso del comando
DROP INDEX:

18.Triggers I (disparadores). Introducción e INSERT

En este capítulo comenzamos a ver el tema de los triggers o disparadores.

Veremos en qué consisten, qué utilidad tienen, los diferentes tipos de triggers y
cómo crear un trigger sencillo. En cuanto a esto, los triggers no pueden ser
utilizados en Access.

67
Veamos el siguiente esquema para comprender de mejor forma qué es un trigger:

En resumidas cuentas, un trigger cumple la misma funcionalidad que un evento en

Javascript o PHP.

Por otra parte, también tenemos que establecer en qué momento (after o
before) ocurrirá un trigger:

18.1.Trigger de ingreso INSERT

Aquí veremos un primer ejemplo de trigger. En consecuencia, primeramente

crearemos una tabla para ir almacenando los registros.

68
Por tanto, nos ubicamos en phpMyAdmin dentro de la base de datos curso_sql:

Luego de ello, pulsamos en la pestaña de SQL y escribimos lo siguiente:

Dando como estructura resultante:

Hecho esto, crearemos un trigger, el cual estará asociado a la tabla

PRODUCTOS. Para esto, nos vamos nuevamente a la pestaña SQL y escribimos
la siguiente instrucción:

Con esta instrucción lo primer que hacemos es crear al trigger. Por convención se
recomienda escribir una referencia que aluda a la tabla a la cual se le aplicará el
trigger. Por ello, hemos puesto PRODUCTOS. A su vez, también es recomendable
escribir la letra inicial de cuándo queremos que se suceda el trigger. En
consecuencia, hemos puesto la A (after) ya que queremos que el trigger ocurra a
posteriori. Al lado de dicha letra, se estila poner una letra que refiera al tipo de

69
trigger. En este caso, será un INSERT y por ello la I. Todo esto da como
resultado PRODUCTOS_AI. A continuación tenemos que poner AFTER INSERT
ON y el nombre de la tabla (PRODUCTOS) en la cual se insertará.

Luego de ello, tenemos que especificarle que sea para ingresar registro de a uno.
A esto se debe la instrucción FOR EACH ROW.

Hecho esto, tenemos que decirle que en la tabla que creamos con el trigger
(REG_PRODUCTOS) nos muestre los campos de código del artículo, nombre del
artículo, precio e insertado. Estos campos recibirán como valores a los nuevos
códigos que se ingresen. De allí, la función NEW seguida de un punto (.) y el
nombre del campo en donde se ingresarán. Por su parte, el campo INSERTADO
recibe como valor a la función NOW() ya que al ser un campo de tipo
DATETIME, lo que queremos obtener aquí es ver la fecha y hora del registro
ingresado.

Toda esta instrucción nos da como resultado la creación de un trigger que se

encuentra dentro de la tabla PRODUCTOS:

Hecho todo esto, nos vamos nuevamente a la pestaña SQL y escribimos la

instrucción para insertar registros:

70
Ejecutamos la consulta y veremos que en la tabla PRODUCTOS se ha ingresado
el nuevo registro:

Y si vamos a la tabla REG_PRODUCTOS sabremos la fecha y hora del registro

ingresado:

19.Triggers II (disparadores). UPDATE

En este capítulo veremos a los triggers de actualización. Utilizaremos un

ejemplo para explicar las instrucciones old, new, after y before.

Inicialmente, tenemos que crear una tabla para la actualización de registros:

Tal como podemos observar, hemos creado una tabla (de respaldo), en la cual
aparecerán los registros originales (anterior) y los registros actualizados
(nuevo). A su vez, hemos agregado dos campos extra (USUARIO y
FECHA_MODIF) para saber quién realizó las actualizaciones y en qué fecha.

71
Ejecutamos la consulta y esta es la tabla PRODUCTOS_ACTUALIZADOS
resultante:

Hecho todo esto, tenemos que proceder a la creación del trigger de

actualización propiamente dicho.

Esta sentencia, tal como se puede apreciar, consta de varias instrucciones. La

primera de ellas es la creación del trigger. Luego de escribir la instrucción
CREATE TRIGGER tenemos que poner una referencia de respecto de lo que hará
el trigger, en qué momento y donde. En este caso, el trigger se desencadenará
antes (BEFORE-B) y lo que se hará, será una actualización (UPDATE-U). Todo
esto se realizará en la tabla PRODUCTOS.

Tenemos que hacer uso de la instrucción FOR EACH ROW INSERT INTO y el
nombre de la tabla respaldo (en este caso, PRODUCTOS_ACTUALIZADAS). Es

72
decir, la tabla creada en el paso anterior. Una vez allí, ingresamos el nombre de
los campos originales (ANTERIOR) y de los campos actualizados (NUEVO). A
continuación de los campos nuevos, agregamos los campos USUARIO y
FECHA_MODIF.

Culminado esto, el último paso será agregar los valores, tanto viejos (OLD) como
nuevos (NEW). En estos casos, se utiliza la nomenclatura del punto (.) seguida
del nombre de cada campo. Por último, para asignarle un valor al campo
USUARIO y al campo FECHA_MODIF hacemos uso de las funciones
CURRENT_USER() y NOW(), respectivamente. Esto nos permitirá saber quién
hizo las modificaciones y en qué momento.

Al ejecutar la consulta, vamos a la estructura de la tabla PRODUCTOS y

veremos cómo se ha creado este trigger de actualización:

Hecho esto, hacemos la consulta para aplicar el trigger de actualización:

73
Luego de esto nos dirigimos a la tabla PRODUCTOS y, efectivamente, la
actualización del precio se ha hecho exitosamente:

Si deseamos ver cuál era el precio anterior y cuál es el precio nuevo, tenemos
que irnos a la tabla PRODUCTOS_ACTUALIZADOS:

Y, si quisiéramos ver quién y cuándo hizo la actualización, debemos deslizarnos

hacia la derecha y observar lo siguiente:

20.Triggers III (disparadores). DELETE

En este capítulo veremos a los triggers de eliminación. También veremos cómo

eliminar y modificar un trigger desde código.

Por tanto, primeramente crearemos una tabla en la cual aparecerá la información

eliminada. La sentencia será:

74
Pulsamos el botón de Continuar, siendo esta la estructura resultante de nuestra
nueva tabla:

Luego de haber creado a la tabla de respaldo, procedemos a construir el trigger

de eliminación:

Luego de ello, vamos a la tabla de PRODUCTOS y vemos cómo ha quedado creado

este trigger de eliminación:

75
A continuación, nos posicionamos en la pestaña SQL y creamos la instrucción
para eliminar un registro:

En consecuencia, si después de realizar esto examinamos la tabla PRODUCTOS,

veremos que dicho registro ha sido efectivamente eliminado.

Hecho esto, nos dirigimos a la tabla donde creamos el trigger de eliminación

para ver qué producto fue eliminado:

20.1.Agregando campos a la tabla de productos eliminados

En esta parte veremos cómo agregar dos campos a la tabla de productos

eliminados prod_eliminados. Para ello, utilizamos el comando ALTER TABLE:

Su estructura se conforma, ahora, de la siguiente manera:

76
 20.2.Eliminar un trigger desde código

A continuación, veremos cómo eliminar un trigger desde código. Esto consta de

dos pasos.

El PRIMER PASO es eliminar el trigger:

Hemos utilizado la instrucción DROP TRIGGER más el nombre del trigger que
queremos eliminar.

El SEGUNDO PASO consta en volver a crear el trigger:

20.3.Eliminar un trigger en un solo paso

Ahora veremos cómo modificar o agregar un trigger, pero en un solo paso. Aquí
tendremos que utilizar DROP TRIGGER IF EXISTS + nombre del trigger. La
instrucción será:

77
Yendo a la estructura de la tabla PRODUCTOS veremos cómo ha quedado creado
el nuevo trigger:

78