INSTITUTO TECNOLÓGICO DE SALINA CRUZ

ACTIVIDAD: LENGUAJE DE MANIPULACIÓN DE DATOS

NOMBRE (S): ANTHONY SOLANO LÓPEZ

ASIGNATURA: TALLER DE BASE DE DATOS

GRADO Y GRUPO: 4E

CARRERA: ING. EN TECNOLOGÍA DE LA INFORMACIÓN Y COMUNICACIONES

FACILITADOR:
ING. ROSALES RUIZ MARIA DE LOS ANGELES

SALINA CRUZ, OAX. A 20/03/2020

ÍNDICE
2.1 Lenguaje de Manipulación de Datos............................................................3
2.2 Las consultas simples SQL............................................................................5
2.3 Consultas por varias Tablas..........................................................................9
2.3.1 Subconsultas en SQL...............................................................................12
2.3.2 Operadores de conjunto en SQL-Server: UNION, INTERSECT y EXCEPT. 17
2.4 Funciones de agregado (Transact-SQL)......................................................20
2.1 Lenguaje de Manipulación de Datos

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 Las consultas simples SQL

Empezaremos por estudiar la sentencia SELECT, que permite recuperar datos de una o varias tablas. La
sentencia SELECT es con mucho la más compleja y potente de las sentencias SQL. Empezaremos por ver las
consultas más simples, basadas en una sola tabla.

Esta sentencia forma parte del DML (lenguaje de manipulación de datos), en este tema veremos cómo
seleccionar columnas de una tabla, cómo seleccionar filas y cómo obtener las filas ordenadas por el criterio
que queramos.

El resultado de la consulta es una tabla lógica, porque no se guarda en el disco sino que está en memoria y
cada vez que ejecutamos la consulta se vuelve a calcular.

Cuando ejecutamos la consulta se visualiza el resultado en forma de tabla con columnas y filas, pues en la
SELECT tenemos que indicar qué columnas queremos que tenga el resultado y qué filas queremos seleccionar
de la tabla origen.

Sintaxis de la sentencia SELECT (consultas simples)

La tabla origen - FROM -

Con la cláusula FROM indicamos en qué tabla tiene que buscar la información. En este capítulo de consultas
simples el resultado se obtiene de una única tabla. La sintaxis de la cláusula es:
FROM especificación de tabla

Una especificación de tabla puede ser el nombre de una consulta guardada (las que aparecen en la ventana de
base de datos), o el nombre de una tabla que a su vez puede tener el siguiente formato:

Tabla es un nombre de alias, es como un segundo nombre que asignamos a la tabla, si en una consulta
definimos un alias para la tabla, esta se deberá nombrar utilizando ese nombre y no su nombre real, además
ese nombre sólo es válido en la consulta donde se define. El alias se suele emplear en consultas basadas en
más de una tabla que veremos en el tema siguiente. La palabra AS que se puede poner delante del nombre de
alias es opcional y es el valor por defecto por lo que no tienen ningún efecto.

Ejemplo: SELECT ......FROM oficinas ofi; equivalente a SELECT ......FROM oficinas AS ofi esta sentencia
me indica que se van a buscar los datos en la tabla oficinas que queda renombrada en esta consulta conofi.

En una SELECT podemos utilizar tablas que no están definidas en la base de datos (siempre que tengamos
los permisos adecuados claro), si la tabla no está en la base de datos activa, debemos indicar en qué base de
datos se encuentra con la cláusula IN.

En la cláusula IN el nombre de la base de datos debe incluir el camino completo, la extensión (.mdb), y estar
entre comillas simples.

Supongamos que la tabla empleados estuviese en otra base de datos llamada otra en la carpeta c:\mis
documentos\, habría que indicarlo así:

SELECT *

FROM empleados IN 'c:\mis documentos\otra.mdb'

Generalmente tenemos las tablas en la misma base de datos y no hay que utilizar la cláusula IN.

Selección de columnas
La lista de columnas que queremos que aparezcan en el resultado es lo que llamamos lista de selección y se
especifica delante de la cláusula FROM.

Se utiliza el asterisco * en la lista de selección para indicar 'todas las columnas de la tabla'.

Tiene dos ventajas:

Evitar nombrar las columnas una a una (es más corto).

Si añadimos una columna nueva en la tabla, esta nueva columna saldrá sin tener que modificar la consulta.

Se puede combinar el * con el nombre de una tabla (ej. oficinas.*), pero esto se utiliza más cuando el origen
de la consulta son dos tablas.

SELECT * FROM oficinas

o bien

SELECT oficinas.* FROM oficinas

Lista todos los datos de las oficinas

columnas de la tabla origen

Las columnas se pueden especificar mediante su nombre simple (nbcol) o su nombre cualificado
(nbtabla.nbcol, el nombre de la columna precedido del nombre de la tabla que contiene la columna y
separados por un punto).

El nombre cualificado se puede emplear siempre que queramos y es obligatorio en algunos casos que veremos
más adelante.

Cuando el nombre de la columna o de la tabla contiene espacios en blanco, hay que poner el nombre entre
corchetes [ ] y además el número de espacios en blanco debe coincidir. Por ejemplo [codigo de cliente] no es
lo mismo que [ codigo de cliente] (el segundo lleva un espacio en blanco delante de código)

Ejemplos :

SELECT nombre, oficina, contrato

FROM ofiventas

Lista el nombre, oficina, y fecha de contrato de todos los empleados.

SELECT idfab, idproducto, descripcion, precio

FROM productos

Lista una tarifa de productos

Alias de columna.

Cuando se visualiza el resultado de la consulta, normalmente las columnas toman el nombre que tiene la
columna en la tabla, si queremos cambiar ese nombre lo podemos hacer definiendo un alias de columna
mediante la cláusula AS será el nombre que aparecerá como título de la columna.

Ejemplo:

SELECT idfab AS fabricante, idproducto, descripcion

FROM productos

Como título de la primera columna aparecerá fabricante en vez de idfab

Columnas calculadas.

Además de las columnas que provienen directamente de la tabla origen, una consulta SQL puede incluir
columnas calculadas cuyos valores se calculan a partir de los valores de los datos almacenados.

Para solicitar una columna calculada, se especifica en la lista de selección una expresión en vez de un nombre
de columna. La expresión puede contener sumas, restas, multiplicaciones y divisiones, concatenación & ,
paréntesis y también funciones predefinidas).

Para ver con más detalle cómo formar una expresión pincha aquí

Ejemplos:

SELECT ciudad, región, (ventas-objetivo) AS superavit

FROM oficinas

Lista la ciudad, región y el superavit de cada oficina.

SELECT idfab, idproducto, descripcion, (existencias * precio) AS valoracion

FROM productos

De cada producto obtiene su fabricante, idproducto, su descripción y el valor del inventario

SELECT nombre, MONTH(contrato), YEAR(contrato)

FROM repventas

Lista el nombre, mes y año del contrato de cada vendedor.

 La función MONTH() devuelve el mes de una fecha

La función YEAR() devuelve el año de una fecha

SELECT oficina, 'tiene ventas de ', ventas

FROM oficinas

Listar las ventas en cada oficina con el formato: 22 tiene ventas de 186,042.00 ptas

2.3 Consultas por varias Tablas

En Access, es posible realizar consultas involucrando campos de varias tablas, de modo que el resultado de la consulta muestre información
procedente de todas ellas. Para que una consulta pueda realizarse sobre campos de varias tablas, éstas deben tener un campo común, y las
tablas deberán estar relacionadas por esos campos. Si no se hubieran establecido las relaciones anteriormente, habría que establecerlas en este
momento (en la propia consulta), ya que si no existen
relaciones entre las tablas, Access no encontrará relación entre los campos especificados en la ventana de diseño y no mostrará ningún registro
como resultado de la consulta.
Una vez establecidas las relaciones entre las tablas el modo de generar una consulta de varias tablas es imilar a la de creación de cualquier otra
consulta, sin más que "subir" a la parte superior de la consulta las tablas necesarias
(varias en lugar de una sola), y "bajar" los campos a incluir en la consulta desde cada correspondiente tabla en la que se encuentren

Ejemplo-1: Supongamos que en la federación de golf (siguiendo con el ejemplo de la base de datos Socios del Club) se ha asignado un
responsable tutor por cada uno de los niveles de juego de forma que a cada jugador le pasa a corresponder un responsable deportivo en virtud
de si su nivel de juego es principiante, medio o senior. Dicho tutor, tiene unos datos que lo identifican, tales como son su nombre, apellidos,
teléfono de contacto, fax, dirección de e-mail, dirección de ficina...Sería preciso que en el registro de cada socio se dispusiera de toda la
información de su tutor o responsable deportivo.

Tras un análisis de la nueva situación, se deduce que si en la tabla socios agregamos tantos campos como para albergar la información de
dichos tutores, a todos los socios con el mismo nivel de juego, les va a corresponder el mismo tutor, con lo que todos los datos del tutor
estarían repetidos de forma masiva y redundante en la tabla socios (ocupando mucho espacio y lentificando el proceso básicamente). Quizás la
mejor solución sea, en este caso, definir otra tabla llamada Tutores, en la que deberá existir un registro para cada nivel de juego y por lo tanto
para cada tutor. La estructura de la tabla sería la siguiente:
 Se introducirán los datos de los niveles junto a sus responsables...

Pero, ¿de qué manera podríamos enlazar o relacionar esta nueva tabla de tutores con la gran tabla de socios?

Será necesario relacionar el nivel de juego de cada socio de la tabla de socios con el código de nivel de la tabla de tutores. Pero como son de
distinto tipo (texto -en socios- frente a numérico -en tutores-) no se podrá. La solución es sustituir en la tabla de socios el campo nivel por el
campo codnivel (por ejemplo) de tipo numérico y luego colocar a cada socio un código (el que corresponde a su nivel de juego) en este campo
de acuerdo a los niveles y tutores introducidos en la tabla de
tutores (1, 2 o 3).

1. Se deberá crear en la tabla de socios el campo codnivel.

2. Mediante tres consultas de actualización, a aquellos que tengan nivel de juego principiante, actualizaremos ese nuevo campo
codnivel (de la tabla de socios) a 1. De igual manera, los socios con nivel senior actualizaremos a 2 su campo codnivel. Y a 3 el
campo codnivel de los socios con nivel senior.

3. A continuación deberemos (de forma recomendada, aunque en este ejemplo no lo borremos) eliminar el campo nivel de la tabla
socios ya que, a partir de ahora, Se conocerá el nivel de juego gracias a un código en la tabla de socios, que se corresponderá con
uno de los niveles y tutores de la tabla tutores.

4. Ahora tendremos que establecer la relación (en la pantalla de relaciones) de acuerdo a la siguiente pantalla:
A partir de este momento, podríamos crear consultas, formularios e informes en donde aparecen ambas tablas implicadas, eso si, previamente
relacionadas.

Ejemplo-2: Supongamos un ejemplo superficial de gestión de sanciones de tráfico en una localidad. Existen diferentes tipos de sanción (tipos
de multa), diferentes guardias o agentes, los vehículos, los cuales pertenecen a un
ciudadano o propietario, y... por supuesto sanciones. Las sanciones las "pone" un agente a un vehículo, un determinado día, a una hora, en un
lugar, y esa infracción es de un determinado tipo de entre las que se pueden
sancionar. Un ciudadano puede tener más de un vehículo.

La información habrá que disgregarla en diferentes tablas, (la de vehículos se supone que la facilita tráfico con todos los vehículos), que
deberán estar... Relacionadas. La siguiente imagen muestra un posible planteamiento.
2.3.1 Subconsultas en SQL

Si ya dominas las consultas SELECT de SQL con WHERE, GROUP BY o HAVING lo siguiente que debes
aprender son las subconsultas SQL.

A continuación, encontrarás el tutorial dividido en tres partes:

Respuesta a qué son las subconsultas.

Explicación de cómo se utilizan las subqueries en SQL.

Varios ejemplos de subconsultas, de más fácil a más complejo.

¿Qué es una subconsulta SQL?

Primero una definición: una subconsulta es una instrucción SELECT SQL anidada dentro de otra instrucción
SELECT, INSERT, DELETE o UPDATE. Además, debes saber que se realizarán casi siempre dentro de la
cláusula WHERE de las consultas.

Otra forma de explicarlo sería diciendo que tenemos un SELECT dentro de otra consulta SELECT,
INSERT ... INTO, UPDATE o DELETE.

Además, existen tres formas distintas de crear una subconsulta:

Con ANY, ALL, SOME precediendo a la consulta anidada.

Haciendo uso de la expresión IN o NOT IN antes de la subconsulta.

EXISTS o NOT EXISTS y a continuación la subquery.

¿Cómo se usa una subconsulta SQL?

En esta parte me voy a centrar en las consultas anidadas dentro de la cláusula WHERE, ya que las consultas
INSERT INTO las expliqué en otro artículo.

Para realizar una consulta de SQL con subqueries necesitaremos:

Una consulta normalmente formada del tipo SELECT, UPDATE o DELETE

Una cláusula WHERE o HAVING con las condiciones deseadas más uno de los operadores SQL anteriores
(ANY, ALL, SOME, IN, NOT IN, EXISTS o NOT EXISTS) u operadores de comparación como "=", ">" o
"<"
La consulta SELECT entre paréntesis.

Hay varios puntos importantes sobre su uso a tener en cuenta para evitar errores:

La subconsulta siempre irá entre paréntesis, sin excepciones.

Las subconsultas se pueden anidar dentro de otras subconsultas.

La subconsulta siempre deberá devolver el mismo tipo y número de valores a comparar: no puede haber una
subconsulta que devuelva dos columnas para una comparación con 1 columna.

La subconsulta siempre debería (aunque no es obligatorio) de colocarse a la derecha del operador relacional.

Ahora que ya tienes la teoría rondando por tu cabeza, a continuación, te enseño un pequeño ejemplo
cumpliendo los tres puntos recién comentados.

Consulta SELECT de ejemplo

Primero voy a crear una consulta SELECT normal, que obtenga el nombre y apellidos de las filas de una tala
llamada ciudadanos

SELECT nombre, apellidos

FROM ciudadanos

Añadir la cláusula WHERE

Ahora añado la cláusula WHERE a la consulta anterior y le voy a añadir uno de los operadores compatibles.

SELECT nombre, apellidos

FROM ciudadanos

WHERE dni IN ....

Subconsulta entre paréntesis

Y por último voy a realizar la subconsulta entre paréntesis que seleccione la columna DNI de una tabla
"delincuentes":

SELECT nombre, apellidos

FROM ciudadanos

WHERE dni IN ( SELECT dni FROM delincuentes );

¡Ya está! Lo que ocurrirá ahora es que la base de datos hará:

Primero resolver la subconsulta.

Después comparara los valores devueltos por el DNI de la subconsulta con el dni de la consulta SELECT
"PADRE".

Devolverá los valores de la consulta principal como resultado de la consulta.

Ejemplos de subconsultas en SQL

Hora de los ejemplos. A partir de aquí voy a mostrarte varios ejemplos para que acabes de interiorizar las
subconsultas.

Empezaré con un par de ejemplos sencillos, siguiendo la tónica del anterior apartado y continuaré con
ejemplos más complejos y avanzados.

Para los siguientes ejemplos voy a crear 2 tablas:

Tabla sobre videojuegos a la que llamaré videojuego.

Tabla sobre jugadores a la que llamaré jugador.

Las consultas CREATE SQL son las siguientes:

CREATE TABLE videojuego (

id INT (11) NOT NULL AUTO_INCREMENT PRIMARY KEY,

titulo VARCHAR(100) NOT NULL,

lenguaje VARCHAR(5) NOT NULL,

resumen TEXT NULL,

nota DECIMAL (3,1),

total_jugadores INT DEFAULT 0

);

CREATE TABLE jugador(

id INT (11) NOT NULL AUTO_INCREMENT,

nombre VARCHAR(80) NOT NULL,

edad INT NOT NULL,

es_famoso INT NOT NULL DEFAULT 0,

id_videojuego INT NOT NULL,

FOREIGN KEY(id_videojuego) REFERENCES videojuego(id),

 fecha_registro DATE NULL

);

Ahora que ya tengo mis dos tablas vamos a realizar unas subconsultas.

Ejemplo subconsultas 1

Recuperar todos los juegos en los que al menos juega 1 jugador:

SELECT *

FROM videojuego

WHERE id IN ( SELECT id_videojuego FROM jugador );

Otra forma alternativa de realizar esta subconsulta sería utilizando la cláusula ANY o SOME:

SELECT *

FROM videojuego

WHERE id = ANY ( SELECT id_videojuego FROM jugador );

//alternativa con SOME

SELECT *

FROM videojuego

WHERE id = SOME ( SELECT id_videojuego FROM jugador );

Realmente las dos condiciones son iguales ya que SOME es un ALIAS de ANY, lo que quiere decir que son el
mismo comando.

Ejemplo de subqueries 2

En el siguiente ejemplo seleccionaré todos los jugadores que juegan a un juego en Español:

SELECT nombre, es_famoso

FROM jugador

WHERE id_videojuego IN ( SELECT id FROM videojuego WHERE lenguaje = 'es' );

Ejemplo 3 de consultas anidadas

Ahora voy a realizar otra consulta con una subconsulta y funciones agregadas, en concreto utilizando MAX.

Para demostrártelo selecciono los jugadores que tienen la mayor edad entre los jugadores:

SELECT nombre, apellidos

FROM jugador

WHERE edad = ( SELECT MAX(edad) FROM jugador );

Ejemplo 4 subconsulta con subconsulta anidada

En este ejemplo voy a subir un poco la dificultad, voy a mostrarte las posiblidades casi infinitas de las
subqueries utilizando para ello una subconsulta anidada dentro de otra subconsulta. Lo entenderás mejor con
el ejemplo.

Recuerda: Las subconsultas se resuelven antes que su consulta principal

SELECT *

FROM videojuego

WHERE lenguaje IN ( SELECT lenguaje FROM videojuego WHERE id = SOME ( SELECT id_videojuego
FROM jugador WHERE es_famoso = 1 ) );

¿Lo has entendido? La consulta en su totalidad selecciona todos los videojuegos de uno de los lenguajes a los
que juega algún jugador famoso.

En orden de ejecución de las subconsultas ( de la última a la principal) selecciono:

El ID de todos los jugadores famosos

El lenguaje de todos los videojuegos que si ID coincide con el ID de los jugadores famosos.

Todos los datos de los videojuegos que su lenguaje coincide con alguno de los idiomas de la subconsulta del
punto 2.

#5 Ejemplo de subconsulta con UPDATE SQL

Creo que con las consultas SELECT se ven todas las posibilidades de las subconsultas, pero para que veas de
forma gráfica un ejemplo de cómo usarlas en UPDATE o DELETE te dejo ahora un ejemplo.

En concreto, voy a añadir 1 al contador de total jugadores de aquellos videojuegos que tienen un jugador
jugándolo en la fecha '2019-12-01'
UPDATE videojuego

SET total_jugadores = jugadores + 1

WHERE id IN (SELECT id_videojuego FROM jugador WHERE fecha = '2019-12-01' )

2.3.2 Operadores de conjunto en SQL-Server: UNION, INTERSECT y EXCEPT

Los operadores de conjunto UNION, INTERSECT y EXCEPT nos permite combinar en una misma salida el
resultado de distintas consultas SELECT, construyendo así una consulta más compleja, lo que se llama una
consulta compuesta. Para poder combinar dos consultas con estos operadores necesitamos que se cumplan dos
requisitos:

Que ambas consultas devuelvan el mismo número de columnas.

Que estas columnas contengan el mismo tipo de datos, o al menos tipos de datos que se puedan convertir de
forma implícita.

Estos tres operadores se incorporaron a SQL-Server a partir de la versión 2008 y están también disponibles en
la base de datos SQL de la plataforma Azure. Los tres operadores aceptan además el parámetro ALL, que
modificará ligeramente los resultados ¿Cómo funcionan y qué diferencia hay entre ellas?

EXCEPT:
Este operador encuentra la diferencia entre las dos consultas y devuelve las filas que pertenecen únicamente a
la primera consulta. Es decir, si una tupa aparece tanto en la consulta de la izquierda como en la de la derecha
no será incluida en el resultado final. Si aparece solo en la de izquierda y en la de la derecha no, entonces será
devuelta una vez.

Si añadimos ALL al EXCEPT notaremos una pequeña diferencia. Al igual que con el EXCEPT a secas el
operador buscará la diferencia entre las dos consultas, pero los datos devueltos cambian. En este caso si una
tupla aparece un número m de veces en la primera consulta, y la misma tupla aparece un número n veces en la
segunda consulta, entonces esa tupla aparece m – n veces en la respuesta de salida, si dicha resta es mayor que
0.

/*consultamos una tabla de Productos

y sacamos todos los resultados únicos

que no que existen en la consulta sobre la tabla Almacén*/

Select Descripcion, Codigo from Productos

EXCEPT
Select Descripcion, Codigo from Almacen

/*Con ALL si la tupa Descripción,Codigo existiese tres veces

en el resultado de la primera consulta y una vez en la segunda

entonces en el resultado final saldría dos veces*/

Select Descripcion, Codigo from Productos

EXCEPT ALL

Select Descripcion, Codigo from Almacen

INTERSECT:
Este operador combina los resultados de dos consultas en un único resultado que comprime todas las filas
comunes para ambas consultas. Es decir, funcionaría como un AND lógico: devuelve solo las ocurrencias
existentes en ambas consultas.

Si añadimos ALL a este operador el resultado también cambiará. En ese caso si una tupla aparece un número
m de veces en el resultado de la primera consulta y la misma tupla aparece n veces en la segunda, entonces
esa tupla aparece el menor número de entre m o n en la respuesta de salida.

/*consultamos una tabla de Productos

y sacamos todos los resultados únicos

que también existen en la consulta sobre la tabla Almacén*/

Select Descripcion, Codigo from Productos

INTERSECT
Select Descripcion, Codigo from Almacen

/*Con ALL si la tupa Descripción,Codigo existiese tres veces

en el resultado de la primera consulta y una vez en la segunda

entonces en el resultado final saldría una vez solo*/

Select Descripcion, Codigo from Productos

INTERSECT ALL
Select Descripcion, Codigo from Almacen

UNION:
Finalmente vamos con UNION. Si antes os decía que INTERSECT funciona como un operador lógico AND
entonces UNION funcionaría como un operador lógico OR. Devuelve las filas únicas que existen o en la
consulta de la izquierda o en la de la derecha.

En este caso el operador ALL lo que hará será modificar el resultado del UNION de forma que en lugar de
recibir solo las filas únicas recibamos tantas filas como haya en la primera consulta y en la segunda, un poco
la operación contraria a la que realiza EXCEPT ALL. En este caso si una tupla aparece un número m de veces
en la primera consulta, y la misma tupla aparece un número n veces en la segunda consulta, entonces esa tupla
aparece m + n veces en la respuesta de salida.

/*consultamos una tabla de Productos

y la tabla Almacén y sacamos los resultados únicos, distintos*/

Select Descripcion, Codigo from Productos

UNION

Select Descripcion, Codigo from Almacen

/*Con ALL si la tupa Descripción,Codigo existiese tres veces

en el resultado de la primera consulta y una vez en la segunda

entonces en el resultado final saldría cuatro veces*/

Select Descripcion, Codigo from Productos

UNION ALL
Select Descripcion, Codigo from Almacen

2.4 Funciones de agregado (Transact-SQL)

SE APLICA A: SQL Server Azure SQL Database Azure Synapse Analytics
(SQL DW) Almacenamiento de datos paralelos

Una función de agregado realiza un cálculo sobre un conjunto de valores y devuelve un solo valor. Con la
excepción de COUNT, las funciones de agregado ignoran los valores NULL. Las funciones de agregado se
suelen usar con la cláusula GROUP BY de la instrucción SELECT.

Todas las funciones de agregado son deterministas. En otras palabras, las funciones de agregado devuelven el
mismo valor cada vez que se las llama con un conjunto específico de valores de entrada. Vea Funciones
deterministas y no deterministas para obtener más información sobre el determinismo de las
funciones. La cláusula OVER puede seguir todas las funciones de agregado excepto STRING_AGG,
GROUPING o GROUPING_ID.

Las funciones de agregado solo se pueden usar como expresiones en las situaciones siguientes:

 La lista de selección de una instrucción SELECT (una subconsulta o una consulta externa).
 Cláusula HAVING.

Transact-SQL proporciona las siguientes funciones de agregado:

TA B L A 1
APPROX_COUNT_DISTINCT MIN
AVG STDEV
CHECKSUM_AGG STDEVP
COUNT STRING_AGG
COUNT_BIG SUM
GROUPING VAR
GROUPING_ID VARP
MAX