UNIDAD 2: Lenguaje de Manipulación de Datos

2.1 Operaciones de manipulación de datos

Lenguaje de Manipulación de Datos (DML)

Lenguaje de Manipulación de Datos (Data Manipulation Language, DML) es un idioma

proporcionado por los sistemas gestores de bases de datos que permite a los usuarios de la misma
llevar a cabo las tareas de consulta o modificación de los datos contenidos en las Bases de Datos
del Sistema Gestor de Bases de Datos. El lenguaje de manipulación de datos más popular hoy día
es SQL, usado para recuperar y manipular datos en una base de datos relacional. Otros ejemplos
de DML son los usados por bases de datos IMS/DL1, CODASYL u otras.

● Elementos del lenguaje de manipulación de datos

Select, Insert, Delete y Update

● Clasificación de los DML

Se clasifican en dos grandes grupos:

- lenguajes de consulta procedimentales

Lenguajes procedimentales. En este tipo de lenguaje el usuario da instrucciones al sistema para

que realice una serie de procedimientos u operaciones en la base de datos para calcular un
resultado final.

- lenguajes de consulta no procedimentales

En los lenguajes no procedimentales el usuario describe la información deseada sin un

procedimiento específico para obtener esa información.

Lenguaje de manipulación de datos (DML)

Un lenguaje de manipulación de datos (Data Manipulation Language, o DML en inglés) es un
lenguaje proporcionado por el sistema de gestión de base de datos que permite a los usuarios
llevar a cabo las tareas de consulta o manipulación de los datos, organizados por el modelo de
datos adecuado.

El lenguaje de manipulación de datos más popular hoy día es SQL, usado para recuperar y
manipular datos en una base de datos relacional. Otros ejemplos de DML son los usados por bases
de datos IMS/DL1, CODASYL u otras.
1- INSERT

Una sentencia INSERT de SQL agrega uno o más registros a una (y sólo una) tabla en una base de
datos relacional.

Ejemplo 1 (inserto valores alumno pepe en la materia spd2 a la tabla cursada):

INSERT INTO ''cursada'' (''alumno'', ''materia'') VALUES (''pepe'', ''spd2'')

2-UPDATE

Una sentencia UPDATE de SQL es utilizada para modificar los valores de un conjunto de registros
existentes en una tabla.

Ejemplo 1 (modifico la materia donde el alumno sea pepe):

UPDATE ''cursada'' SET ''materia''= ''spd3'' WHERE ''alumno''= ''pepe''

3-DELETE

Una sentencia DELETE de SQL borra uno o más registros existentes en una tabla.

Ejemplo 1 (borro todos los valores de las columnas alumno y materia donde la materia sea spd2):

DELETE FROM ''cursada'' WHERE ''materia''= ''spd2''

2.2 Consultas simples

Consultas de datos con SQL. DQL

Capacidades

DQL es la abreviatura del Data Query Language (lenguaje de consulta de datos) de SQL. El único
comando que pertenece a este lenguaje es el versátil comando SELECT Este comando permite
fundamentalmente:

• Obtener datos de ciertas columnas de una tabla (proyección)

• Obtener registros (filas) de una tabla de acuerdo con ciertos criterios (selección)

• Mezclar datos de tablas diferentes (asociación, join)

• Realizar cálculos sobre los datos

• Agrupar datos
Sintaxis sencilla del comando SELECT
SELECT * | {[DISTINCT] columna | expresión [[AS] alias], ...}

FROM tabla;

Donde:

• *. El asterisco significa que se seleccionan todas las columnas

• DISTINCT. Hace que no se muestren los valores duplicados.

• columna. Es el nombre de una columna de la tabla que se desea mostrar

• expresión. Una expresión válida SQL

• alias. Es un nombre que se le da a la cabecera de la columna en el resultado de esta

instrucción. No es imprescindible usar la palabra AS.

Ejemplos:

/*Selección de todos los registros de la tabla clientes*/

SELECT * FROM Clientes;

/* Selección de algunos campos*/

SELECT nombre, apellido1, apellido2 FROM Clientes;

uso del asterisco

El símbolo * (asterisco) sirve para seleccionar todas las columnas de una tabla. Ejemplo:

SELECT * FROM empleados;

Sólo se puede utilizar tras la palabra SELECT y no puede estar acompañado de ninguna expresión.
Por ejemplo, no es correcto:

SELECT *, precio+iva

FROM empleado;

--Incorrecto, el asterisco no puede estar acompañado de ninguna otra expresión

alias

Los alias sirven para dar otro nombre a una columna. Por ejemplo:

SELECT id_trabajo AS identificador, nombre FROM trabajos;

La columna id_trabajo ha sido renombrada por la palabra identificador. No es un renombrado

permanente, sólo se utiliza en la ejecución de la instrucción SELECT. No estamos realmente
cambiando de nombre a la columna, por ello lo que se dice es que estamos poniendo un alias a esa
expresión.
No es obligatorio utilizar la palabra AS, es igualmente válido dejar un espacio en blanco antes del
alias:

SELECT id_trabajo identificador, nombre FROM trabajos;

Usar o no AS es cuestión de gustos. Sus defensores lo hacen porque la instrucción SELECT es más
legible.

En los alias, es muy normal utilizar espacios en blanco para indicar el nombre a fin de conseguir
nombres más claros. En ese caso se debe utilizar comillas dobles para especificar el alias:

SELECT id_trabajo “identificador de trabajo”, nombre

FROM trabajos;

Con comillas dobles podemos utilizar cualquier carácter para dar nombre al alias.

Cálculos
- Aritméticos
Los operadores + (suma), - (resta), * (multiplicación) y / (división), se pueden utilizar para hacer
cálculos en las consultas. Cuando se utilizan como expresión en una consulta SELECT, no modifican
los datos originales sino que como resultado de la vista generada por SELECT, aparece un nueva
columna. Ejemplo:

SELECT nombre, precio,precio*1.16 FROM articulos;

Esa consulta obtiene tres columnas. La tercera muestra el resultado de la operación. Al no indicar
nombre alguno, se toma la propia expresión (precio*1,16) como cabecera de esa columna. Eso
significa que no tiene un nombre válido, por lo que se debería siempre utilizar alias:

SELECT nombre, precio, precio*1.16 AS precio_con_iva

FROM articulos;

La prioridad de esos operadores es la habitual en todos los lenguajes de programación

• Tienen más prioridad las operaciones de multiplicación y división que las de suma y la
resta.

• En caso de igualdad de prioridad, se realiza primero la operación que esté más a la

izquierda. Como es lógico, se puede evitar cumplir esa prioridad usando paréntesis; el interior de
los paréntesis es lo que se ejecuta primero.

Cuando una expresión aritmética se aplica sobre valores NULL, el resultado es el propio valor
NULL.

Se puede utilizar cualquiera de los operadores aritméticos: suma (+), resta (-), multiplicación (*),
división (/). Como es habitual, la multiplicación y la división tienen preferencia sobre la suma y la
resta en el orden de ejecución de la instrucción; dicho orden se puede alterar mediante el uso de
los paréntesis.
 - Concatenación de textos
El operador de concatenar texto permite unir dos textos. Normalmente se usa para juntar
resultados de diferentes expresiones en una miasma columna de una tabla. Todas las bases de
datos incluyen algún operador para encadenar textos. En SQL Server y otros gestores es el signo +
(suma), en Oracle son los signos ||. Ejemplo (Oracle):

SELECT tipo, modelo, tipo || ‘-’ || modelo “Clave Pieza”

FROM piezas;

El resultado sería:

Tipo Modelo Clave Pieza

AR 6 AR-6

AR 7 AR-7

AR 8 AR-8

AR 9 AR-9

AR 12 AR-12

AR 15 AR-15

AR 20 AR-20

AR 21 AR-21

BI 10 BI-10

BI 20 BI-20

BI 22 BI-22

BI 24 BI-24

En la mayoría de bases de datos, la función CONCAT (se describe más adelante) realiza la misma
función.
 - Condiciones
Se pueden realizar consultas que restrinjan los datos de salida de las tablas. Para ello se utiliza la
cláusula WHERE. Esta cláusula permite colocar una condición que han de cumplir todos los
registros, los que no la cumplan no aparecen en el resultado.

Ejemplo:

SELECT Tipo, Modelo FROM Pieza WHERE Precio>3;

Operadores de comparación
Se pueden utilizar en la cláusula WHERE, son:

Operador Significado

> Mayor que

< Menor que

>= Mayor o igual que

<= Menor o igual que

= Igual

<> Distinto

!= Distinto

Se pueden utilizar tanto para comparar números como para comparar textos y fechas. En el caso
de los textos, las comparaciones se hacen en orden alfabético.

En muchas bases de datos hay problemas con la Ñ y otros símbolos nacionales al ordenar o
comparar con el signo de mayor o menor, ya que la el orden ASCII no respeta el orden de cada
alfabeto nacional.

No obstante, es un problema que prácticamente está solucionado, ya que la mayoría de los SGBD
son compatibles con Unicode. En concreto Oracle no tiene este problema desde hace ya unas
cuantas versiones del producto).

Valores lógicos
Son:

Operador Significado

AND Devuelve verdadero si las expresiones a su izquierda y derecha son ambas verdaderas

OR Devuelve verdadero si cualquiera de las dos expresiones a izquierda y derecha del OR, son
verdaderas
NOT Invierte la lógica de la expresión que está a su derecha. Si era verdadera, mediante NOT
pasa a ser falso.

Ejemplos:

/* Obtiene a las personas de entre 25 y 50 años*/

SELECT nombre, apellido1,apellido2 FROM personas

WHERE edad>=25 AND edad<=50;

/*Obtiene a la gente de más de 60 años o de menos de 20*/

SELECT nombre, apellido1,apellido2 FROM personas

WHERE edad>60 OR edad<20;

/*Obtiene a la gente de con primer apellido entre la

A y la O */

SELECT nombre,apellido1,apellido2 FROM personas

WHERE apellido1>’A’ AND apellido2<’Z’;

BETWEEN
El operador BETWEEN nos permite obtener datos que se encuentren en un rango. Uso:

SELECT tipo,modelo,precio FROM piezas

WHERE precio BETWEEN 3 AND 8;

Saca piezas cuyos precios estén entre 3 y 8 (ambos incluidos). En realidad es una forma más rápida
de hacer esta consulta:

SELECT tipo,modelo,precio FROM piezas

WHERE precio>=3 AND precio<=8;

IN
Permite obtener registros cuyos valores estén en una lista de valores:

SELECT tipo,modelo,precio FROM piezas

WHERE precio IN (3,5,8);

Obtiene piezas cuyos precios sean 3, 5 u 8 (no valen ni el precio 4 ni el 6, por ejemplo).
LIKE
Se usa sobre todo con textos, permite obtener registros cuyo valor en un campo cumpla una
condición textual. LIKE utiliza una cadena que puede contener estos símbolos:

Símbolo Significado

% Una serie cualquiera de caracteres

_ Un carácter cualquiera

Ejemplos:

/* Selecciona nombres que empiecen por S */

SELECT nombre FROM personas WHERE nombre LIKE ‘S%’;

/*Selecciona las personas cuyo apellido sea Sanchez, Senchez, Sánchez,...*/

SELECT apellido1 FROM Personas

WHERE apellido1 LIKE ‘S_nchez’;

IS NULL
En SQL para valorar los nulos, es frecuente cometer este error:

SELECT nombre,apellidos FROM personas

WHERE telefono=NULL

Esa expresión no es correcta. No debemos usar los operadores de comparación normales con
valores nulos. La consulta anterior no muestra a las personas sin teléfono (que es lo que
pretendemos).

Lo correcto es usar el operador destina a comprobar si un determinado dato es nulo:

SELECT nombre,apellidos FROM personas

WHERE telefono IS NULL

Esa instrucción selecciona a la gente que no tiene teléfono.

Existe también la expresión contraria: IS NOT NULL que devuelve verdadero en el caso contrario,
ante cualquier valor distinto de nulo.

Precedencia de operadores
A veces las expresiones que se producen en los SELECT son muy extensas y es difícil saber que
parte de la expresión se evalúa primero. Por ello es necesario conocer la tabla de precedencia que
indica qué operadores tienen prioridad entre sí. Los que están al nivel 1 tienen la máxima
prioridad.

La tabla completa es la siguiente:

Orden de precedencia Operador

1 *(Multiplicar) /(dividir)

2 + (Suma) - (Resta)

3 || (Concatenación)

4 Comparaciones (>, <, !=, ...)

5 IS NULL, IS NOT NULL, LIKE, IN, NOT IN

6 NOT, NOT BETWEEN

7 NOT

8 AND

9 OR

Las reglas de prioridad se pueden alterar mediante paréntesis. Por ejemplo, supongamos que
tenemos esta expresión:

SELECT nombre, apellido1, apellido2

FROM alumnos

WHERE id_clase=1 OR id_clase=13 AND nota>=5;

Parece que queremos obtener el nombre y apellidos de los alumnos aprobados (nota>=5) de las
clases número 11 y 13. Pero como AND tiene prioridad sobre el OR, sacaremos los alumnos
aprobados de la clase 13 y además se mostrarán todos los alumnos de la clase 11 (hayan aprobado
o no).

Lo correcto hubiera sido usar paréntesis:

SELECT nombre, apellido1, apellido2

FROM alumnos

WHERE (id_clase=11 OR id_clase=13) AND nota>=5;

Ordenación
introducción
Las filas que resultan de una instrucción SELECT no guarda más que una relación respecto al orden
en el que fueron introducidos, y ese orden normalmente no tiene ningún interés. Para ordenar en
base a criterios más interesantes, se utiliza la cláusula ORDER BY. Esa es a cláusula que permite
hacer efectiva una de las reglas relacionales más importantes: que el orden de introducción de las
filas no importa

En esa cláusula se coloca una lista de campos por los que queremos ordenar los resultados. Se
ordena primero por el primer campo de la lista, si hay coincidencias por el segundo, si ahí también
las hay por el tercero, y así sucesivamente.

Se puede colocar las palabras ASC O DESC (por defecto se toma ASC). Esas palabras permiten
ordenar en ascendente (de la A a la Z, de los números pequeños a los grandes) o en descendente
(de la Z a la a, de los números grandes a los pequeños) respectivamente. Por defecto, si no se
indica nada, la ordenación es ascendente.

sintaxis completa de SELECT con la cláusula ORDER BY

Sintaxis de SELECT (para una sola tabla), incluida la cláusula ORDER BY:

SELECT {* | [DISTINCT] {columna | expresión} [[AS] alias], ... }

FROM tabla

[WHERE condición]

[ORDER BY expresión1 [,expresión2,…][{ASC|DESC}]];

Las expresiones de la cláusula ORDER BY pueden ser cualquiera que haga referencia a una
columna o a cálculos sobre la columna. Ejemplo:

SELECT nombre,apellido1,apellido2

FROM alumnos

ORDER BY apellido1, apellido2, nombre;

Obtendrá la lista de alumnos ordenados por su primer apellido, luego por el segundo y luego por el
nombre.
Ascendente y descendente
Normalmente ordena en ascendente, pero si usamos DESC ordenará en descendente:

SELECT nombre, apellido1, apellido2,

f_n fecha_nacimiento

FROM alumnos

ORDER BY f_n DESC;

Mostrará la lista de alumnos ordenada de forma que aparezcan primero los más jóvenes.

Además podemos usar el alias en lugar del nombre de la columna:

SELECT nombre, apellido1, apellido2,

f_n fecha_nacimiento

FROM alumnos

ORDER BY fecha_nacimiento DESC;

Incluso podemos utilizar el número de columna:

SELECT nombre, apellido1, apellido2,

f_n fecha_nacimiento

FROM alumnos

ORDER BY 4 DESC;

También es posible mezclar ordenaciones en ascendente y descendente:

SELECT nombre, apellido1, apellido2,

f_n fecha_nacimiento, id_clase

FROM alumnos

ORDER BY id_clase, f_n DESC;

Este último SELECT muestra los datos de los alumnos de forma que salgan ordenados en
ascendente por el número de clase. Dentro de cada clase saldrán primero por fecha de
nacimiento, pero ordenando en descendente la fecha.
Orden por número de columnas
Oracle permite ordenar en base a números que representan las columnas en el orden en el que
aparecen en esta instrucción. Ejemplo:

SELECT nombre, apellido1, apellido2,

fecha_nacimiento, id_clase

FROM alumnos

ORDER BY 2,3,1;

En este ejemplo se ordena por primer apellido, luego por segundo y luego por el nombre.

Este formato se puede combinar con los vistos antes. Ejemplo:

SELECT nombre, apellido1, apellido2,

fecha_nacimiento, id_clase

FROM alumnos

ORDER BY 2,3,nombre;

Manejo de nulos en las ordenaciones

Como se ha comentado en varias ocasiones, los valores nulos nunca cumplen las condiciones ni de
ordenación ni las condiciones de las cláusulas WHERE.

A la hora de ordenar si tenemos valores nulos en las columnas por las que estamos ordenando, las
filas con valores nulos aparecen al final de la consulta.

Pero podemos indicar si queremos que los nulos vayan al principio o al final indicándolo de
manera correcta tras la cláusula ORDER BY. Posibilidades:

• NULLS LAST

• NULLS FIRST

Ejemplo:

SELECT nombre, apellido1, apellido2, telefono

FROM alumnos

ORDER BY telefono NULLS FIRST;

En esta consulta los nulos aparecen al principio de la consulta. Por defecto las consultas usan
NULLS LAST la cual coloca los nulos al final de la consulta.

Variables de sustitución.
Es posible tener que repetir consultas en las que sólo cambia un dato. Por ejemplo, esta consulta:

SELECT nombre, apellido1 “Primer Apellido”, apellido2 “Segundo Apellido”

edad, salario

FROM trabajadores

WHERE cod_trabajador=198;

Muestra los datos del trabajador 198. Si ahora quisiéramos los datos del trabajador 199,
repetiríamos la consulta pero modificando el 198 por un 199.

Cuando se detecta este tipo de consultas repetitivas en las que varía un solo dato (o unos pocos),
algunos Sistemas de Bases de Datos proporcionan un mecanismo conocido como variables de
sustitución.

En realidad no forman parte del lenguaje SQL, pero casi todos los sistemas las incluyen. En el caso
de Oracle se utilizan mediante el operador ampersand (&). Tras este símbolo se indica el nombre
de la variable, que será cualquier nombre válido. Esa validez es la misma que las de los nombres de
tablas y columnas en Oracle: 64 caracteres, nada de espacios en blanco, etc.

Ejemplo:

SELECT nombre, apellido1 “Primer Apellido”, apellido2 “Segundo Apellido”

edad, salario

FROM trabajadores

WHERE cod_trabajador=&codigo_trabajador;

Al ejecutar la consulta Oracle permite indicar el valor que deseamos para la variable. Por ejemplo,
de la forma que se muestra en esta imagen:

En él podremos indicar el código de trabajador que queremos ver. De esa forma ya no

modificaremos el código sino que indicaremos el valor de la variable.

La sustitución es literal de modo que si ejecutamos la consulta:

SELECT nombre, apellido1 “Primer Apellido”, apellido2 “Segundo Apellido”

edad, salario
FROM trabajadores

WHERE nombre=&v_nombre;

Y luego, cuando Oracle nos lo reclame, escribimos Antonio como valor para sustituir en la variable,
no se nos mostrarán los datos de Antonio, sino que ocurrirá un error. La razón está en que al
sustituir el valor de la variable, se obtendría esta consulta:

SELECT nombre, apellido1 “Primer Apellido”, apellido2 “Segundo Apellido”

edad, salario

FROM trabajadores

WHERE nombre=Antonio;

El error ocurre porque faltan las comillas. Para no tener ese problema, que obliga a introducir las
comillas en el cuadro, debemos hacer lo siguiente:

SELECT nombre, apellido1 “Primer Apellido”, apellido2 “Segundo Apellido”

edad, salario

FROM trabajadores

WHERE nombre=’&v_nombre’;

El uso de variables de sustitución no sólo está restringido a la cláusula WHERE, se pueden utilizar
en cualquier cláusula.

En Oracle es posible reutilizar el valor de una variable de sustitución en la misma instrucción. Para
ello se utiliza el doble ampersand (&&). Donde aparezca, se reutilizará el valor de esa variable. Por
ejemplo:

SELECT &&columna

FROM alumnos

ORDER BY &columna;

Sólo se nos preguntará una vez por el valor de la variable. El doble ampersand permite reutilizar el
valor de la variable. Para que funcione este uso correctamente, el simple ampersand se pone
después que el doble ampersand en la instrucción.

Comando DEFINE de Oracle

Oracle dispone de un comando SQL*Plus (que no es parte de SQL) llamado DEFINE. Este comando
es accesible desde cualquier software que soporte comandos SQL*Plus (sea o no software de
Oracle). Este comando permite indicar un valor permanente para una variable de sustitución de
Oracle. Ese valor se recuerda por parte de Oracle y cada vez que utilicemos la variable de
sustitución, de la forma vista en el apartado anterior, Oracle sustituirá automáticamente la
variable por el valor definido para ella.
Ejemplo:

DEFINE numero_curso = 301;

SELECT fecha_inicio, fecha_fin FROM cursos

WHERE n_curso=&numero_curso;

SELECT dni_profesor FROM cursos

WHERE n_curso=&numero_curso;

Todo el código anterior se ejecutará sin preguntar al usuario por el valor de la variable. Se tomará
el valor 301 para la columna n_curso en ambas instrucciones SELECT.

Hay otro comando muy interesante que es SET VERIFY ON. Este comando (también es de tipo
SQL*Plus) nos mostrará la instrucción SELECT antes y después de la sustitución para comprobar
cómo quedan las instrucciones tras ejecutarlas como script (es decir ejecutar todo el conjunto de
instrucciones, muy útil si las almacenamos en un archivo, por ejemplo). En el caso anterior con SET
VERIFY ON, se mostraría algo como:

Antiguo:SELECT fecha_inicio, fecha_fin FROM cursos

WHERE n_curso=&numero_curso

Nuevo:SELECT fecha_inicio, fecha_fin FROM cursos

WHERE n_curso=301

FECHA_INICIO FECHA_FIN

--------------------------- ---------------------------

25/12/13 09:00:00,000000000 12/01/14 11:00:00,000000000

Antiguo:SELECT dni_profesor FROM cursos

WHERE n_curso=&numero_curso

Nuevo:SELECT dni_profesor FROM cursos

WHERE n_curso=301

DNI_PROFESOR

------------

71656565U
2.3 Consultas sobre múltiples tablas.
Combinaciones internas - INNER JOIN
Las combinaciones internas se realizan mediante la instrucción INNER JOIN. Devuelven únicamente
aquellos registros/filas que tienen valores idénticos en los dos campos que se comparan para unir
ambas tablas. Es decir aquellas que tienen elementos en las dos tablas, identificados éstos por el
campo de relación.

La mejor forma de verlo es con un diagrama de Venn que ilustre en qué parte de la relación deben
existir registros:

En este caso se devuelven los registros que tienen nexo de unión en ambas tablas. Por ejemplo,
en la relación entre las tablas de clientes y pedidos en Northwind, se devolverán los registros de
todos los clientes que tengan al menos un pedido, relacionándolos por el ID de cliente.

Esto puede ocasionar la desaparición del resultado de filas de alguna de las dos tablas, por tener
valores nulos, o por tener un valor que no exista en la otra tabla entre los campos/columnas que
se están comparando.

Su sintaxis es:

FROM Tabla1 [INNER] JOIN Tabla2 ON Condiciones_Vinculos_Tablas

Así, para seleccionar los registros comunes entre la Tabla1 y la Tabla2 que tengan correspondencia
entre ambas tablas por el campo Col1, escribiríamos:

SELECT T1.Col1, T1.Col2, T1.Col3, T2.Col7

FROM Tabla1 T1 INNER JOIN Tabla2 T2 ON T1.Col1 = T2.Col1

Por ejemplo, para obtener en Northwind los clientes que tengan algún pedido, bastaría con
escribir:

SELECT OrderID, C.CustomerID, CompanyName, OrderDate

FROM Customers C INNER JOIN Orders O ON C.CustomerID = O.CustomerID

Que nos devolverá 830 registros. Hay dos pedidos en la tabla de Orders sin cliente asociado, como
puedes comprobar, y éstos no se devuelven por no existir la relación entre ambas tablas.

En realidad esto ya lo conocíamos puesto que en las combinaciones internas, el uso de la palabra
INNER es opcional (por eso lo hemos puesto entre corchetes). Si simplemente indicamos la palabra
JOIN y la combinación de columnas (como ya hemos visto en el artículo anterior) el sistema
sobreentiende que estamos haciendo una combinación interna. Lo hemos incluido por ampliar la
explicación y por completitud.
Combinaciones externas (OUTER JOIN)
Las combinaciones externas se realizan mediante la instrucción OUTER JOIN. Como enseguida
veremos, devuelven todos los valores de la tabla que hemos puesto a la derecha, los de la tabla
que hemos puesto a la izquierda o los de ambas tablas según el caso, devolviendo además valores
nulos en las columnas de las tablas que no tengan el valor existente en la otra tabla.

Es decir, que nos permite seleccionar algunas filas de una tabla aunque éstas no tengan
correspondencia con las filas de la otra tabla con la que se combina. Ahora lo veremos mejor en
cada caso concreto, ilustrándolo con un diagrama para una mejor comprensión.

La sintaxis general de las combinaciones externas es:

FROM Tabla1 [LEFT/RIGHT/FULL] [OUTER] JOIN Tabla2 ON Condiciones_Vinculos_Tablas

Como vemos existen tres variantes de las combinaciones externas.

En todas estas combinaciones externas el uso de la palabra OUTER es opcional. Si utilizamos LEFT,
RIGHT o FULL y la combinación de columnas, el sistema sobreentiende que estamos haciendo una
combinación externa.

Variante LEFT JOIN

Se obtienen todas las filas de la tabla colocada a la izquierda, aunque no tengan correspondencia
en la tabla de la derecha.

Así, para seleccionar todas las filas de la Tabla1, aunque no tengan correspondencia con las filas de
la Tabla2, suponiendo que se combinan por la columna Col1 de ambas tablas escribiríamos:

SELECT T1.Col1, T1.Col2, T1.Col3, T2.Col7

FROM Tabla1 T1 LEFT [OUTER] JOIN Tabla2 T2 ON T1.Col1 = T2.Col1

De este modo, volviendo a Northwind, si escribimos la siguiente consulta:

SELECT OrderID, C.CustomerID, CompanyName, OrderDate

FROM Customers C LEFT JOIN Orders O ON C.CustomerID = O.CustomerID

Obtendremos 832 registros ya que se incluyen todos los clientes y sus pedidos, incluso aunque no
tengan pedido alguno. Los que no tienen pedidos carecen de la relación apropiada entre las dos
tablas a partir del campo CustomerID. Sin embargo se añaden al resultado final dejando la parte
correspondiente a los datos de la tabla de pedidos con valores nulos, como se puede ver en esta
captura de SQL Server:
Variante RIGHT JOIN
Análogamente, usando RIGHT JOIN se obtienen todas las filas de la tabla de la derecha, aunque no
tengan correspondencia en la tabla de la izquierda.

Así, para seleccionar todas las filas de la Tabla2, aunque no tengan correspondencia con las filas de
la Tabla1 podemos utilizar la cláusula RIGHT:

SELECT T1.Col1, T1.Col2, T1.Col3, T2.Col7

FROM Tabla1 T1 RIGHT [OUTER] JOIN Tabla2 T2 ON T1.Col1 = T2.Col1

Si en nuestra base de datos de ejemplo queremos obtener todos los pedidos aunque no tengan
cliente asociado, junto a los datos de dichos clientes, escribiríamos:

SELECT OrderID, C.CustomerID, CompanyName, OrderDate

FROM Customers C RIGHT JOIN Orders O ON C.CustomerID = O.CustomerID

En este caso se devuelven 830 registros que son todos los pedidos. Si hubiese algún pedido con el
CustomerID vacío (nulo) se devolvería también en esta consulta (es decir, órdenes sin clientes),
aunque en la base de datos de ejemplo no se da el caso.

Variante FULL JOIN

Se obtienen todas las filas en ambas tablas, aunque no tengan correspondencia en la otra tabla. Es
decir, todos los registros de A y de B aunque no haya correspondencia entre ellos, rellenando con
nulos los campos que falten:

Es equivalente a obtener los registros comunes (con un INNER) y luego añadirle los de la tabla A
que no tienen correspondencia en la tabla B, con los campos de la tabla vacíos, y los registros de la
tabla B que no tienen correspondencia en la tabla A, con los campos de la tabla A vacíos.

Su sintaxis es:

SELECT T1.Col1, T1.Col2, T1.Col3, T2.Col7

FROM Tabla1 T1 FULL [OUTER] JOIN Tabla2 T2 ON T1.Col1 = T2.Col1

Por ejemplo, en Northwind esta consulta:

SELECT OrderID, C.CustomerID, CompanyName, OrderDate

FROM Customers C FULL JOIN Orders O ON C.CustomerID = O.CustomerID

nos devuelve nuevamente 832 registros: los clientes y sus pedidos, los clientes sin pedido (hay 2) y
los pedidos sin cliente (que en este caso son 0).
Funciones de Agregación

Las funciones de agregación nos permites realizar algunas operaciones sobre un conjunto de
datos, generalmente se utilizarán en conjunto con la agrupación para potencializar su
rendimiento.

Las funciones de agrupación mas comunes son las siguientes:

COUNT(): Devuelve el número de filas seleccionadas por la consulta

MIN(): Devuelve el valor mínimo del campo que seleccionemos.

MAX(): Devuelve el valor máximo del campo que seleccionemos.

SUM(): Suma los valores del campo que le especifiquemos. NOTA: Solo se pueden utilizar campos
de tipo numérico

AVG(): Acrónimo de AVERGANGE, devuelve el promedio del campo que seleccionemos.