BASE DATOS I

DML
• Facultad: Ingenierías y Arquitectura
• Departamento: Eléctrica, Electrónica, Sistemas y
Telecomunicaciones
• Código: 167401
• Tipo: Teórico practica
• Docente: Francisco Alexis Vera Peña.
 DML – ALTER TABLE
Para cambiar la estructura de una tabla existente, utiliza ALTER TABLE

sintaxis básica:

ALTER TABLE nombre_tabla acción;

acciones:

• Cambiar el nombre de una tabla (RENAME TO)

• Agregar una columna (ADD COLUMN)
• Eliminar una columna (DROP COLUMN)
• Cambiar el tipo de datos de una columna (ALTER COLUMN SET)
• Cambiar el nombre de una columna(RENAME COLUMN)
• Cambiarvalor predeterminado para la columna.
(ALTER COLUMN SET DEFAULT o DROP DEFAULT).
• Agregue una restricción a una columna (ADD CONSTRAINT)
• Modificar el nombre de una tabla:

ALTER TABLE nombre_actual RENAME TO nuevo_nombre;

• Para modificar varias columnas, hay que realizarlo cada columna por separado. Se
puede omitir la palabra reservada COLUMN :

ALTER TABLE nombre_tabla RENAME COLUMN

actual_nombre_columna TO nuevo_nombre_columna;

• También se puede modificar el nombre de las restricciones de la siguiente forma.

En este caso hay que incluir la palabra reservada CONSTRAINT.

ALTER TABLE nombre_tabla RENAME CONSTRAINT

actual_nombre_restriccion TO nuevo_nombre_restriccion;
• Podemos modificar la estructura de la tabla añadiendo más columnas o eliminando las
actuales. No es necesario escribir la palabra reservada COLUMN en ninguno de estos dos
casos. Hay tener especial cuidado cuando se eliminan las columnas, pues evidentemente
también se eliminan todos los valores correspondiente a ese campo.

ALTER TABLE nombre_tabla ADD COLUMN nombre_columna TIPO_DATO;

ALTER TABLE nombre_tabla DROP COLUMN nombre_columna;

• Cambiar el tipo de dato (SET DATA TYPE) y el tamaño del dato. En principio podemos
cambiar el tipo de dato de una columna sin problemas, aunque en algunos casos nos dará
un error por el contenido de los registros. Las palabras reservadas COLUMN y SET DATA se
pueden omitir.

ALTER TABLE nombre_tabla ALTER COLUMN nombre_columna

SET DATA TYPE tipo_de_dato;

ALTER TABLE nombre_tabla ALTER COLUMN

nombre_columna TYPE tipo_dato(tamaño);
• Para cambiar el nombre de una columna:

ALTER TABLE nombre_tabla

RENAME COLUMN nombre_columna
TO nuevo_nombre_columna;

• Para cambiar un valor predeterminado de la columna:

ALTER TABLE nombre_tabla

ALTER COLUMN nombre_columna
SET DEFAULT valor;

ALTER TABLE nombre_tabla

ALTER COLUMN nombre_columna
DROP DEFAULT;
 RESTRICCIONES – ALTER TABLE
• Para cambiar NOT NULL:

ALTER TABLE nombre_tabla

ALTER COLUMN nombre_columna
SET NOT NULL;

ALTER TABLE nombre_tabla

ALTER COLUMN nombre_columna
DROP NOT NULL;

• Para agregar una PRIMARY KEY:

ALTER TABLE nombre_tabla

ADD PRIMARY KEY (nombre_columna);

• Antes de utilizar el comando ALTER TABLE para agregar una clave primaria, necesitará
asegurarse de que el campo esté definido como NOT NULL, en otras palabras, NULL no
puede aceptarse como valor para ese campo.
 DML – ALTER TABLE

• para agregar una restricción a una tabla:

ALTER TABLE nombre_tabla

ADD CONSTRAINT nombre_restricción

declarar la restricción:

• La sintaxis para CHECK:

ALTER TABLE Nombre_tabla

ADD CONSTRAINT Nombre_constraint

CHECK Condicion;
 DML – ALTER TABLE

• sintaxis PRIMARY KEY:

ALTER TABLE nombre_tabla

ADD CONSTRAINT nombre_constraint

PRIMARY KEY (Campo,...);

• sintaxis FOREIGN KEY

ALTER TABLE nombre_tabla

ADD CONSTRAINT Nombre_restriccion

FOREIGN KEY (Campo_llave_foranea) REFERENCES nombre_tabla (campo);

 DML – ALTER TABLE

• sintaxis CHECK:

ALTER TABLE nombre_tabla

ADD CONSTRAINT nombre_constraint

CHECK(condición);

• sintaxis UNIQUE

ALTER TABLE nombre_tabla

ADD CONSTRAINT Nombre_restriccion

UNIQUE (Campo);
SELECT & DROP:

• Para ver la estructura de una tabla consultaremos una tabla propia del PostgreSQL:

SELECT table_name, column_name, data_type, is_nullable, udt_name, character_maximum_length

FROM INFORMATION_SCHEMA.COLUMNS
WHERE table_name ='persona’;

• Para eliminar una tabla usamos "drop table" junto al nombre de la tabla a eliminar:

DROP TABLE nombre_tabla;

Si intentamos eliminar una tabla que no existe, aparece un mensaje de error indicando tal
situación y la sentencia no se ejecuta, podemos escribir una variante de drop table verificando
si existe la tabla:

DROP TABLE IF EXISTS nombre_tabla;

 ALTER TABLE - DROP CONSTRAINT
Eliminar restricciones
sintaxis básica:

ALTER TABLE Nombre_tabla

DROP CONSTRAINT Nombre_restriccion;

Ejemplo:

ALTER TABLE libros

ADD CONSTRAINT PK_libros_codigo

PRIMARY KEY(codigo);

-- Eliminamos la restricción "PK_libros_codigo":

ALTER TABLE libros

DROP CONSTRAINT PK_libros_codigo;

 DML-INSERT
Insertar y recuperar registros de una tabla (insert into - select)
Al ingresar los datos de cada registro debe tenerse en cuenta la cantidad y el orden de los
campos.

INSERT INTO Nombretabla (Nombre_campo_1, ..., Nombre_campo_n)

VALUES (Valor_campo_1, ..., Valor_campo_n);

Usamos "insert into", luego el nombre de la tabla, detallamos los nombres de los campos
entre paréntesis y separados por comas y luego de la cláusula "values" colocamos los valores
para cada campo, también entre paréntesis y separados por comas.

CREATE TABLE Usuario( Se debe ingresar los

nom_usuario VARCHAR(15) NOT NULL, valores en el mismo
contraseña VARCHAR(10) NOT NULL orden en que se
); nombran los campos

INSERT INTO usuario (nom_usuario, contraseña) VALUES (‘Colombia’, ’camp2021');

 DML-INSERT

-- INSERTAR DATOS EN UNA TABLA

INSERT INTO Persona (
Nom_Persona,
Apellido_Persona,
Tipo_Sangre,
Presupuesto,
Fecha_nacimiento,
Num_hijos)
VALUES
('JUAN', 'ROA','B',305670, '2000/12/24', 3);

INSERT INTO Persona

(Nom_Persona, Apellido_Persona, Tipo_Sangre, Presupuesto, Fecha_nacimiento, Num_hijos)
VALUES
('JHON', 'ROJAS','b',500670, '1998-12-24', 2);

SELECT * FROM Persona;

 COPIAR DATOS

copia el contenido de una tabla en un archivo o copia datos de un

archivo a una tabla).
• Usamos “COPY "
• luego el nombre de la tabla donde queremos importar los datos,
detallamos los nombres de los campos que vamos poblar entre
paréntesis y separados por comas.
• FROM la ruta donde se encuentra el archivo con su nombre
extensión.
• La cláusula “ DELIMITER “ entre comillas sencillas el separador (‘,’).
• extensión del archivo
• HEADER si tiene encabezado.

COPY Personas(numero_identificación, cedula, nombre, apellido_paterno, apellido_materno)

FROM ‘c:\carros\personas.csv’ DELIMITER‘,’ CSV HEADER;
• La siguiente tabla BOOKS

Creación de la tabla:

CREATE TABLE IF NOT EXISTS BOOKS (

TITLE varchar(128),
AUTHOR character varying(128),
EDITORIAL varchar(128),
AREA varchar(128),
PRICE numeric(10,2),
STOCK integer
)
• La siguiente tabla book.csv

Importación de los datos de archivo .csv

COPY BOOKS(TITLE, AUTHOR, EDITORIAL, AREA, PRICE, STOCK)

FROM 'D:\book\book.csv' DELIMITER';' CSV HEADER;

• La siguiente tabla libros.txt

Importación de los datos de archivo .txt

COPY BOOKS(TITLE, AUTHOR, EDITORIAL, AREA, PRICE, STOCK)

FROM 'D:\libros.txt' DELIMITER ’,' CSV HEADER;

 DML - SELECT

Para ver los registros de una tabla usamos SELECT:

El comando SELECT recupera los registros de una tabla.

El asterisco (*(comodin)) indica que se seleccionan todos los campos de la tabla.

SELECT * FROM books;

Podemos especificar el nombre de los campos que queremos ver separándolos por comas:

SELECT TITLE, AUTHOR, PRICE FROM BOOK;

Para recuperar los registros que contengan el valor "null" en algún campo, debemos utilizar los
operadores "is null" (es igual a null) y "is not null" (no es null):

SELECT * FROM TITLE WHERE PRICE IS NULL;

 DML – SELECT con WHERE
WHERE se especifica una o varias condiciones para una consulta SELECT.

La sintaxis básica y general es la siguiente:

SELECT nombre_campo_1, ..., nombre_campo_n
FROM Nombre_tabla
WHERE Condicion;
Para las condiciones se utilizan operadores relacionales:

Signo Descripción
= Igual
<> Distinto
> Mayor
< Menor
>= Mayor o Igual
<= Menor o Igual
 DML – SELECT-WHERE
Recuperar algunos registros (WHERE)

Podemos recuperar registros específicos, sólo los que cumplan con ciertas condiciones
indicadas con la cláusula WHERE.

Ejemplo:

Queremos ver los libros que el precio sea mayor a 60, para ello utilizamos WHERE y luego de
ella, la condición:

SELECT * FROM BOOKS WHERE PRICE > 60;

 OPERADORES LOGICOS
and - or - not

La condición con WHERE utilizando operadores relacionales. Podemos establecer

más de una condición con la cláusula WHERE, para ello aprenderemos los
operadores lógicos.

Son los siguientes:

• AND, significa "y“

• OR, significa "y/o“

• NOT, significa "no", invierte el resultado

• (), paréntesis

Los operadores lógicos se usan para combinar condiciones.

 OPERADORES LOGICOS
and - or - not
• Si queremos recuperar todos los libros cuya editorial sea igual a " CENGAGE " y cuyo precio
no supere los $90, necesitamos 2 condiciones:
SELECT * FROM BOOK
WHERE (EDITORIAL ='CENGAGE ') AND (PRICE <= 90);
“Los registros recuperados en una sentencia que une 2 condiciones con el operador "and",
cumplen con las 2 condiciones”.

• Ver los libros cuya EDITORIAL sea " CENGAGE " y/o cuyo autor sea " MICHAEL SIPSER ":
SELECT * FROM BOOKS
WHERE author='MICHAEL SIPSER' OR EDITORIAL = 'CENGAGE';
“Los registros recuperados con una sentencia que une 2 condiciones con el operador "or",
cumplen 1 de las condiciones o ambas”.
 OPERADORES LOGICOS
and - or - not
• Recuperar los libros que NO cumplan la condición dada, por ejemplo, aquellos
cuya editorial NO sea "Planeta":
SELECT * FROM BOOKS
WHERE NOT EDITORIAL ='CENGAGE';
El operador NOT invierte el resultado de la condición a la cual antecede.

• Los paréntesis se usan para encerrar condiciones, para que se evalúen como una
sola expresión.

Cuando explicitamos varias condiciones con diferentes operadores lógicos

(combinamos "and", "or") permite establecer el orden de prioridad de la evaluación;
además permite diferenciar las expresiones más claramente.
 OPERADORES LOGICOS
and - or - not
Ejemplo, las siguientes expresiones devuelven un resultado diferente:

SELECT * FROM BOOKS

WHERE ((author = 'MICHAEL SIPSER') OR (editorial= 'CENGAGE' AND price < 70));

SELECT * FROM BOOKS

WHERE ((AUTHOR = 'MICHAEL SIPSER' OR EDITORIAL = 'CENGAGE') AND precio < 70);

Si bien los paréntesis no son obligatorios en todos los casos, se recomienda utilizarlos
para evitar confusiones.
 OPERADORES LOGICOS
and - or - not
El orden de prioridad de los operadores lógicos es el siguiente:

NOT se aplica antes que AND

AND antes que OR

Si no se especifica un orden de evaluación mediante el uso de paréntesis.

El orden en el que se evalúan los operadores con igual nivel de precedencia es

indefinido, por ello se recomienda usar los paréntesis.

Entonces, para establecer más de una condición en un "where" es necesario emplear

operadores lógicos.
 DML - DELETE
Para eliminar registros de una tabla.

DELETE FROM usuario; DELETE FROM nom_tabla WHERE nom_columna=‘dato';

Si no queremos eliminar todos los registros, sino solamente algunos, debemos indicar cuál o
cuáles, para ello utilizamos el comando DELETE junto con la clausula WHERE con la cual
establecemos la condición que deben cumplir los registros a borrar.
DELETE FROM usuario Antes de hacer DELETE
WHERE nombre = 'Marcelo'; realizar un SELECT.

Si solicitamos el borrado de un registro y, ningún registro cumple con la condición

especificada, ningún registro será eliminado.

Tenga en cuenta que si no colocamos una condición, se

eliminan todos los registros de la tabla nombrada.
 DML - TRUNCATE
También podemos eliminar todos los registros de una tabla con TRUNCATE TABLE.

TRUNCATE TABLE Articulo;

La sentencia TRUNCATE TABLE vacía la tabla (elimina todos los registros) y vuelve a crear la
tabla con la misma estructura.

La diferencia con DROP TABLE es que esta sentencia borra la tabla, TRUNCATE TABLE la vacía.

La diferencia con DELETE es la velocidad, es más rápido TRUNCATE TABLE que DELETE (se
nota cuando la cantidad de registros es muy grande) ya que éste borra los registros uno a uno.
 DML – UPDATE
actualizar registro
Decimos que actualizamos un registro cuando modificamos alguno de sus valores.

Para modificar uno o varios datos de uno o varios registros utilizamos UPDATE.

Por ejemplo, en la tabla BOOKS, queremos cambiar los valores de todos los precios, por 0:

UPDATE BOOKS SET PRICE = 0;

El cambio afectará a todos los registros.

Podemos modificar algunos registros, con WHERE:

UPDATE BOOKS SET PRICE = 0 WHERE EDITORIAL = 'CENGAGE';

Las condiciones no son obligatorias, pero si omitimos la cláusula

"WHERE", la actualización afectará a todos los registros.
 DML - UPDATE
Para actualizar varios campos en una sola instrucción:

colocamos UPDATE, el nombre de la tabla, SET junto al nombre del campo y el nuevo valor y
separado por coma, el otro nombre del campo con su nuevo valor.

UPDATE USERS SET USERNAME = 'Colombia', USERPASSWORD = ‘NewPassword'

WHERE USERNAME= 'COLOMBIA';

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

UPDATE usuarios SET usu_nombre = 'David Rojas', usu_clave = ‘********'

WHERE nombre = 'david';
 COLUMNAS CALCULADAS
operadores aritméticos y de concatenación
PostgreSQL tiene 4 tipos de operadores:

1. Relacionales o de comparación.

2. Lógicos.

3. Aritméticos.

4. Concatenación.

Los operadores aritméticos permiten realizar cálculos con valores numéricos.

Son: multiplicación (*), división (/) y módulo (%) (el resto de dividir números enteros), suma
(+) y resta (-).

Es posible obtener salidas en las cuales una columna sea el resultado de un cálculo y no un
campo de una tabla.
 COLUMNAS CALCULADAS
operadores aritméticos y de concatenación

• Si queremos ver los títulos, precio y cantidad de cada libro escribimos la siguiente
sentencia:
SELECT TITLE, PRICE, STOCK
FROM BOOKS;

• Si queremos saber el monto total en dinero de un título podemos multiplicar el

precio por la cantidad por cada título, pero también podemos hacer que
PostgreSQL realice el cálculo y lo incluya en una columna extra en la salida:

SELECT TITLE, PRICE, STOCK, PRICE * STOCK

FROM BOOKS;
 COLUMNAS CALCULADAS
operadores aritméticos y de concatenación

• Si queremos saber el precio de cada libro con un 10% de descuento podemos

incluir en la sentencia los siguientes cálculos:

SELECT TITLE, PRICE, PRICE * 0,9

FROM BOOKS;

• También podemos actualizar los datos empleando operadores aritméticos:

UPDATE BOOKS SET PRICE = (PRICE * 1.16);

“Todas las operaciones matemáticas retornan error si no se pueden ejecutar”.

 COLUMNAS CALCULADAS
operadores aritméticos y de concatenación

• Los operadores de concatenación:

permite concatenar cadenas, el más (||).

Para concatenar el título, el autor y la editorial de cada libro usamos el operador de

concatenación ("||"):
SELECT TITLE||'-'||AUTHOR||'-'||EDITORIAL
FROM BOOKS;

Note que se concatena unos guiones para separar los campos.

 ALIAS
Una manera de hacer más comprensible el resultado de una consulta consiste en cambiar los
encabezados de las columnas.

Por ejemplo, tenemos la tabla "agenda" con un campo "nombre" (entre otros) en el cual se
almacena el nombre y apellido de nuestros amigos; queremos que al mostrar la información
de dicha tabla aparezca como encabezado del campo "nombre" el texto "nombre y apellido",
para ello colocamos un alias de la siguiente manera:
SELECT TITLE AS TITULO, AUTHOR AS AUTOR, PRICE AS PRECIO
FROM BOOKS;

Se puede crear un alias para columnas calculadas.

SELECT TITLE, PRICE, PRICE * 0,9 AS "Precio Con el 10% descuento"

FROM BOOKS;
Entonces, un "alias" se usa como nombre de un campo o de una expresión. En estos casos, son
opcionales, sirven para hacer más comprensible el resultado.
 ORDER BY
Ordenar registros

Podemos ordenar el resultado de un SELECT para que los registros se muestren

ordenados por algún campo, para ello usamos la cláusula ORDER BY.

La sintaxis básica es la siguiente:

SELECT * FROM nombre_tabla

ORDER BY campo;

Por ejemplo, recuperamos los registros de la tabla "libros" ordenados por el título:

SELECT * FROM BOOKS

ORDER BY TITLE;
 ORDER BY
Ordenar registros
• Colocar el número de orden del campo por el que queremos que se ordene en lugar de su
nombre, es decir, referenciar a los campos por su posición en la lista de selección. Por
ejemplo, queremos el resultado del SELECT ordenado por "precio":

SELECT TITLE, AUTHOR,PRICE

FROM BOOKS
ORDER BY 3;

Por defecto, si no aclaramos en la sentencia, los ordena de manera ascendente (de menor a
mayor).

• Podemos ordenarlos de mayor a menor, para ello agregamos la palabra clave "DESC":

SELECT TITLE, AUTHOR,PRICE

FROM BOOKS
ORDER BY EDITORIAL DESC;
 ORDER BY
Ordenar registros
• Ordenar por varios campos, por ejemplo, por titulo y editorial:

SELECT * FROM BOOKS ORDER BY TITLE, EDITORIAL;

• Ordenar en distintos sentidos, por ejemplo, por "titulo" en sentido ascendente y "editorial"
en sentido descendente:

SELECT * FROM BOOKS ORDER BY title ASC, editorial DESC;

Debe aclararse al lado de cada campo, pues estas palabras claves afectan al campo
inmediatamente anterior.

• Es posible ordenar por un campo que no se lista en la selección.

• Se permite ordenar por valores calculados o expresiones.

 DML - BETWEEN

BETWEEN significa "entre". Funciona con intervalos de valores.

Para recuperar de la tabla “BOOKS" los libros con precio mayor o igual a 20 y menor
o igual a 40, como usar BETWEEN:

SELECT * FROM BOOKS WHERE PRICE BETWEEN 20 AND 40;

• Este operador se puede emplear con tipos de datos numéricos y tipos de datos
fecha y hora (incluye sólo el valor mínimo).

• No tiene en cuenta los valores "null".

 DML - BETWEEN
Si agregamos el operador "NOT" antes de "BETWEEN" el resultado se invierte, es
decir, se recuperan los registros que están fuera del intervalo especificado.

Recuperamos los libros cuyo precio NO se encuentre entre 20 y 35, es decir, los
menores a 15 y mayores a 25:

SELECT * FROM BOOKS

WHERE precio NOT BETWEEN 20 and 35;

Siempre que sea posible, emplee condiciones de búsqueda positivas ("between"),

evite las negativas ("not between") porque hace más lenta la recuperación de los
datos.
 DML - IN
Se utiliza IN para averiguar si el valor de un campo está incluido en una lista de valores
especificada.

En la siguiente sentencia usamos IN para averiguar si el valor del campo autor está incluido en
la lista de valores especificada (en este caso, 2 cadenas).
SELECT * FROM BOOKS
WHERE AUTHOR IN ('MICHAEL SIPSER ',' ROBERT LAFORE');
Para recuperar los libros cuyo autor no sea 'MICHAEL SIPSER ',' ROBERT LAFORE’ usábamos:

SELECT * FROM BOOKS WHERE AUTHOR NOT IN ('MICHAEL SIPSER ',' ROBERT LAFORE');

• Los valores "null" no se consideran.

Recuerde: siempre que sea posible, emplee condiciones de búsqueda positivas ("IN"), evite las
negativas ("NOT IN") porque con ellas se evalúan todos los registros y esto hace más lenta la
recuperación de los datos.
 LIKE - NOT LIKE
Búsqueda de patrones
Para comparar porciones de cadenas utilizamos los operadores LIKE Y NOT LIKE se usa
exclusivamente para realizar comparaciones de cadenas.

Imaginemos que tenemos registrados estos 2 libros:

"OBJECT-ORIENTED PROGRAMMING IN C++, ROBERT LAFORE";

"ARTIFICIAL INTELLIGENCE: FOUNDATIONS OF COMPUTATIONAL AGENTS,DAVID L. POOLE";

Entonces, podemos comparar trozos de cadenas de caracteres para realizar consultas. Para
recuperar todos los registros cuyo autor contenga la cadena "Borges" debemos tipear:

SELECT * FROM BOOKS

WHERE AUTHOR LIKE ‘%ROBERT%’;

El símbolo "%" (porcentaje) reemplaza cualquier cantidad de caracteres (incluyendo ningún

caracter). Es un caracter comodín. LIKE y NOT LIKE son operadores de comparación que
señalan igualdad o diferencia.
 LIKE - NOT LIKE
Para seleccionar todos los libros que comiencen con "M":

SELECT * FROM BOOKS WHERE TITLE LIKE 'M%';

Note que el símbolo "%" ya no está al comienzo, con esto indicamos que el título
debe tener como primera letra la "M" y luego, cualquier cantidad de caracteres.

Para seleccionar todos los libros que NO comiencen con "M":

SELECT * FROM BOOKS WHERE TITLE NOT LIKE 'M%’;

Así como "%" reemplaza cualquier cantidad de caracteres, el guion bajo "_"
reemplaza un carácter, es otro carácter comodín. Por ejemplo, queremos ver los
libros de "Lewis Carroll" pero no recordamos si se escribe "Carroll" o "Carrolt",
entonces digitamos esta condición:

SELECT * FROM BOOKS WHERE AUTHOR LIKE "%Carrol_";

 LIKE - NOT LIKE
"LIKE" se emplea con tipos de datos char, varchar, date, time, timestamp. Si
empleamos LIKE con tipos de datos que no son caracteres utilizamos el comando
CAST convirtiendo éste al tipo de dato. Por ejemplo, queremos buscar todos los
libros cuyo precio se encuentre entre 10.00 y 19.99:

SELECT TITLE, PRICE FROM BOOKS

WHERE CAST(PRICE AS VARCHAR) LIKE '1_.%';

Queremos los libros que NO incluyen centavos en sus precios:

SELECT TITLE, PRICE FROM BOOKS

WHERE CAST(PRICE AS VARCHAR) LIKE '%.00';
 ILIKE - NOT LIKE
Operador ILIKE, similar al operador LIKE, pero permite coincidencias que no
distinguen entre mayúsculas y minúsculas:

SELECT * FROM BOOKS WHERE TITLE ILIKE ‘m%';

SELECT * FROM BOOKS WHERE TITLE NOT ILIKE ‘%m%’;

SELECT * FROM BOOKS WHERE AUTHOR ILIKE "%Carrol_";

 COUNT - SUM - MIN - MAX - AVG
Funciones de agrupamiento
La función COUNT() cuenta la cantidad de registros de una tabla, incluyendo
los que tienen valor nulo.

Imaginemos que nuestra tabla "libros" contiene muchos registros. Para

averiguar la cantidad usamos la función COUNT().

SELECT COUNT(*) FROM BOOKS;

También podemos utilizar esta función junto con la cláusula WHERE para una
consulta más específica. Queremos saber la cantidad de libros de la editorial
"Planeta":

SELECT COUNT(*) FROM BOOKS WHERE editorial = 'CENGAGE';

 COUNT - SUM - MIN - MAX - AVG
Funciones de agrupamiento

Para contar los registros que tienen precio (sin tener en cuenta los que tienen valor
nulo), usamos la función COUNT() y en los paréntesis colocamos el nombre del
campo que necesitamos contar:

SELECT COUNT(PRICE) FROM libros;

Todas las funciones de agregado, excepto "count(*)", excluye los valores nulos de los
campos. "count(*)" cuenta todos los registros, incluidos los que contienen "null".
 COUNT - SUM - MIN - MAX - AVG
Funciones de agrupamiento
Todas estas funciones retornan NULL si ningún registro cumple con la condición del WHERE,
excepto COUNT que en tal caso retorna cero.

El tipo de dato del campo determina las funciones que se pueden emplear con ellas.

• COUNT: se puede emplear con cualquier tipo de dato.

• MIN y MAX: con cualquier tipo de dato.

• SUM y AVG: sólo en campos de tipo numérico.

La función “SUM()" retorna la suma de los valores que contiene el campo especificado. Si
queremos saber la cantidad total de libros que tenemos disponibles para la venta, debemos
sumar todos los valores del campo STOCK:

SELECT SUM(STOCK) FROM libros;

 COUNT - SUM - MIN - MAX - AVG
Funciones de agrupamiento
Para averiguar el valor máximo o mínimo de un campo usamos las funciones MAX() y MIN()
respectivamente.
Queremos saber cuál es el mayor precio de todos los libros:

SELECT MAX(PRICE) FROM BOOKS;

Entonces, dentro del paréntesis de la función colocamos el nombre del campo del cuál
queremos el máximo valor.

La función AVG() retorna el valor promedio de los valores del campo especificado. Queremos
saber el promedio del precio de los libros referentes a “SQL":

SELECT AVG(PRICE) FROM BOOKS WHERE TITLE ILIKE '%SQL%';

 GROUP BY
Agrupar registros
Hemos aprendido que las funciones de agregado permiten realizar varios cálculos operando
con conjuntos de registros.

Podemos generar valores de resumen para un solo campo, combinando las funciones de
agregado con la cláusula GROUP BY, que agrupa registros para consultas detalladas.

Queremos saber la cantidad de libros de cada editorial, podemos tipear la siguiente sentencia:

SELECT EDITORIAL, COUNT(*) FROM BOOKS GROUP BY EDITORIAL;

La instrucción anterior solicita que muestre el nombre de la editorial y cuente la cantidad

agrupando los registros por el campo "editorial". Como resultado aparecen los nombres de las
editoriales y la cantidad de registros para cada valor del campo.

Los valores nulos se procesan como otro grupo.

 GROUP BY
Agrupar registros
la sintaxis básica es la siguiente:

SELECT campo, FUNCION_DE_AGREGADO

FROM nombre_tabla
GROUP BY campo;

También se puede agrupar por más de un campo, en tal caso, luego del "group by" se listan los
campos, separados por comas. Todos los campos que se especifican en la cláusula "group by"
deben estar en la lista de selección.

SELECT campo1, campo2, FUNCION_DE_AGREGADO

FROM nombre_tabla
GROUP BY campo1,campo2;
 GROUP BY
Agrupar registros
Para obtener la cantidad libros con precio no nulo, de cada editorial utilizamos la función
COUNT() enviándole como argumento el campo PRICE, agregamos GROUP BY y el campo por
el que deseamos que se realice el agrupamiento (editorial):
SELECT EDITORIAL, COUNT(PRICE)
FROM BOOKS
GROUP BY EDITORIAL;
Recuerde la diferencia de los valores que retorna la función COUNT() cuando enviamos como
argumento un asterisco o el nombre de un campo: en el primer caso cuenta todos los registros
incluyendo los que tienen valor nulo, en el segundo, los registros en los cuales el campo
especificado es no nulo.

Para conocer el total en dinero de los libros agrupados por editorial:

SELECT EDITORIAL, SUM(PRICE)
FROM BOOKS
GROUP BY EDITORIAL;
 GROUP BY
Agrupar registros
Para saber el máximo y mínimo valor de los libros agrupados por editorial:

SELECT EDITORIAL, MAX(PRICE) AS MAYOR, MIN(PRICE) AS MENOR

FROM BOOKS
GROUP BY EDITORIAL;

Para calcular el promedio del valor de los libros agrupados por editorial:

SELECT EDITORIAL, AVG(PRICE)

FROM BOOKS
GROUP BY EDITORIAL;
 GROUP BY
Agrupar registros
Es posible limitar la consulta con WHERE.

Si incluye una cláusula WHERE, sólo se agrupan los registros que cumplen
las condiciones.

Vamos a contar y agrupar por editorial considerando solamente los libros

cuyo precio sea menor a 30 pesos:

SELECT editorial, COUNT(*)

FROM BOOKS
WHERE PRICE < 30
GROUP BY EDITORIAL;
 HAVING
Seleccionar grupos
La cláusula HAVING permite seleccionar (o rechazar) un grupo de registros.

Si queremos saber la cantidad de libros agrupados por editorial pero considerando

sólo algunos grupos, por ejemplo, los que devuelvan un valor mayor a 2, usamos la
siguiente instrucción:

SELECT EDITORIAL, COUNT(*) FROM BOOKS

GROUP BY EDITORIAL

HAVING COUNT(*) > 2;

Se utiliza having, seguido de la condición de búsqueda, para seleccionar ciertas filas

retornadas por la cláusula "group by".
 HAVING
Seleccionar grupos
Queremos el promedio de los precios de los libros agrupados por editorial, pero solamente de
aquellos grupos cuyo promedio supere los $25:
SELECT EDITORIAL, AVG(PRICE) FROM BOOKS
GROUP BY EDITORIAL HAVING AVG(PRICE)>25;
En algunos casos es posible confundir las cláusulas WHERE y HAVING. Queremos contar los
registros agrupados por editorial sin tener en cuenta a la editorial 'CENGAGE'.
Analicemos las siguientes sentencias:
SELECT EDITORIAL, COUNT(*) FROM BOOKS WHERE EDITORIAL <> 'CENGAGE'
GROUP BY EDITORIAL;

SELECT EDITORIAL, COUNT(*) FROM BOOKS GROUP BY EDITORIAL

HAVING EDITORIAL <> 'CENGAGE';
Ambas devuelven el mismo resultado, pero son diferentes. La primera, selecciona todos los
registros rechazando los de editorial 'CENGAGE' y luego los agrupa para contarlos. La segunda,
selecciona todos los registros, los agrupa para contarlos y finalmente rechaza fila con la cuenta
correspondiente a la editorial 'CENGAGE'.
 HAVING
Seleccionar grupos
No debemos confundir la cláusula WHERE con la cláusula HAVING. La primera establece
condiciones para la selección de registros de un SELECT; la segunda establece condiciones para
la selección de registros de una salida GROUP BY.

Veamos otros ejemplos combinando WHERE y HAVING. Queremos la cantidad de libros, sin
considerar los que tienen precio NULL, agrupados por EDITORIAL, sin considerar la EDITORIAL
'CENGAGE' :
SELECT editorial, COUNT(*) FROM libros
WHERE precio IS NOT NULL
GROUP BY EDITORIAL
HAVING EDITORIAL <> 'CENGAGE';

Aquí, selecciona los registros rechazando los que no cumplan con la condición dada en
WHERE, luego los agrupa por EDITORIAL y finalmente rechaza los grupos que no cumplan con
la condición dada en el HAVING.
 HAVING
Seleccionar grupos
Se emplea la cláusula HAVING con funciones de agrupamiento, esto no puede hacerlo la
cláusula WHERE. Por ejemplo queremos el promedio de los precios agrupados por editorial,
de aquellas editoriales que tienen más de 2 libros:
SELECT EDITORIAL, AVG(PRICE) FROM BOOKS GROUP BY EDITORIAL HAVING COUNT(*) > 2;

Podemos encontrar el mayor valor de los libros agrupados y ordenados por editorial y
seleccionar las filas que tengan un valor menor a 100 y mayor a 30:
SELECT EDITORIAL, MAX(PRICE) AS mayor • Entonces, usamos la cláusula HAVING para
FROM libros restringir las filas que devuelve una salida
GROUP BY editorial GROUP BY.
HAVING MIN(precio)<100 AND • Va siempre después de la cláusula
MIN(precio)>30 GROUP BY y antes de la cláusula
ORDER BY editorial; ORDER BY si la hubiere.
 DISTINCT
Registros duplicados

Con la cláusula DISTINCT se especifica que los registros con ciertos datos
duplicados sean obviadas en el resultado. Por ejemplo, queremos conocer
todos los autores de los cuales tenemos libros, si utilizamos esta sentencia:

SELECT AUTHOR FROM BOOKS;

Aparecen repetidos. Para obtener la lista de autores sin repetición usamos:

SELECT DISTINCT AUTHOR FROM BOOKS;

También podemos tipear:

SELECT AUTHOR FROM BOOKS GROUP BY AUTHOR;

 DISTINCT
Registros duplicados
Note que en los tres casos anteriores aparece "null" como un valor para "autor"· Si
sólo queremos la lista de autores conocidos, es decir, no queremos incluir "null" en la
lista, podemos utilizar la sentencia siguiente:

SELECT DISTINCT AUTHOR FROM BOOKS WHERE AUTHOR IS NOT NULL;

Para contar los distintos autores, sin considerar el valor "null" usamos:

SELECT COUNT(DISTINCT AUTHOR) FROM BOOKS;

Note que si contamos los autores sin DISTINCT, no incluirá los valores null pero si los
repetidos:

SELECT COUNT(AUTHOR) FROM BOOKS;

Esta sentencia cuenta los registros que tienen autor.

 DISTINCT
Registros duplicados
Podemos combinarla con WHERE. Por ejemplo, queremos conocer los distintos
autores de la editorial "Planeta":

SELECT DISTINCT AUTHOR FROM BOOKS WHERE EDITORIAL = 'CENGAGE';

También puede utilizarse con GROUP BY para contar los diferentes autores por
editorial:

SELECT EDITORIAL, COUNT(DISTINCT AUTHOR) FROM BOOKS GROUP BY EDITORIAL;

La cláusula DISTINCT afecta a todos los campos presentados. Para mostrar los títulos y
editoriales de los libros sin repetir títulos ni editoriales, usamos:

SELECT DISTINCT TITLE, EDITORIAL FROM BOOKS ORDER BY TITLE;

Los registros no están duplicados, aparecen títulos iguales pero con editorial
diferente, cada registro es diferente.
CLÁUSULAS LIMIT Y OFFSET DEL COMANDO SELECT
• Las cláusulas LIMIT y OFFSET se usan para restringir los registros que se retornan en
una consulta SELECT.

• La cláusula LIMIT recibe un argumento numérico positivo que indica el número

máximo de registros a retornar; la cláusula OFFSET indica el número del primer
registro a retornar. El número de registro inicial es 0 (no 1).

• Si el LIMIT supera la cantidad de registros de la tabla, se limita hasta el último

registro.

SELECT * FROM BOOKS LIMIT 4 OFFSET 0;

Muestra los primeros 4 registros, 0,1,2 y 3.

Si digitamos:

SELECT * FROM BOOKS LIMIT 4 OFFSET 5;

Recuperamos 4 registros, desde el 5 al 8.

• Si se coloca solo la cláusula LIMIT retorna tantos registros como el valor indicado,
comenzando desde 0.

Ejemplo:

SELECT * FROM BOOKS LIMIT 3;

Muestra los primeros 3 registros.

• Es conveniente utilizar la cláusula ORDER BY cuando utilizamos LIMIT y OFFSET.

ejemplo:

SELECT * FROM BOOKS ORDER BY TITLE LIMIT 3;