POSTGRE

modelo ACID
• A: Atomicity – Atomicidad -> Separar las funciones desarrolladas en la BD como
pequeñas tareas y ejecutarlas como un todo. Si alguna tarea falla se hace un
rollback(Se deshacen los cambios)
• C: Consistency – Consistencia -> Todo lo que se desarrolló en base al objeto
relacional. Los datos tienen congruencia
• I: Isolation – Aislamiento -> Varias tareas ejecutándose al mismo tiempo dentro
de la BD
• D: Durability – Durabilidad -> Puedes tener seguridad que la información no se
perderá por un fallo catastrófico. PostgreSQL guarda la información en una Bitácora

comandos
ENTRAR A LA CONSOLA DE POSTGRES
psql -U postgres -W
VER LOS COMANDOS \ DE POSTGRES
\?
LISTAR TODAS LAS BASES DE DATOS
\l
VER LAS TABLAS DE UNA BASE DE DATOS
\dt
CAMBIAR A OTRA BD
\c nombre_BD
DESCRIBIR UNA TABLA
\d nombre_tabla
VER TODOS LOS COMANDOS SQL
\h
VER COMO SE EJECTUA UN COMANDO SQL
\h nombre_de_la_funcion
CANCELAR TODO LO QUE HAY EN PANTALLA
Ctrl + C
VER LA VERSION DE POSTGRES INSTALADA, IMPORTANTE PONER EL ';'
SELECT version();
VOLVER A EJECUTAR LA FUNCION REALIADA ANTERIORMENTE
\g
INICIALIZAR EL CONTADOR DE TIEMPO PARA QUE LA CONSOLA TE DIGA EN CADA EJECUCION
¿CUANTO DEMORO EN EJECUTAR ESA FUNCION?
\timing
LIMPIAR PANTALLA DE LA CONSOLA PSQL
Ctrl + L

ARCHIVOS DE CONFIGURACION

postgresql.conf configuraciones generales de postgre

pg_hba.conf // roles de permisos acceso
pg_ident.conf //roles de mapeo de usuarios permit definir roles a usuarios en SO

Comandos de navegación y consulta de información

\c Saltar entre bases de datos

\l Listar base de datos disponibles

\dt Listar las tablas de la base de datos

\d <nombre_tabla> Describir una tabla

\dn Listar los esquemas de la base de datos actual

\df Listar las funciones disponibles de la base de datos actual

\dv Listar las vistas de la base de datos actual

\du Listar los usuarios y sus roles de la base de datos actual

Comandos de inspección y ejecución

\g Volver a ejecutar el comando ejecutando justo antes

\s Ver el historial de comandos ejecutados

\s <nombre_archivo> Si se quiere guardar la lista de comandos ejecutados en un

archivo de texto plano

\i <nombre_archivo> Ejecutar los comandos desde un archivo

\e Permite abrir un editor de texto plano, escribir comandos y ejecutar en lote. \e

abre el editor de texto, escribir allí todos los comandos, luego guardar los
cambios y cerrar, al cerrar se ejecutarán todos los comandos guardados.

\ef Equivalente al comando anterior pero permite editar también funciones en

PostgreSQL

Comandos para debug y optimización

\timing Activar / Desactivar el contador de tiempo por consulta

Comandos para cerrar la consola

\q Cerrar la consola
Ejecutando consultas en la base de datos usando la consola

timing : indica el tiempo que dura la consulta

Tipos de datos

Principales:
Numéricos(Numeros enteros, Numeros Decimales, Seriales)
Monetarios(cantidad de moneda)
Texto(almacenar cadenas y texto, existen tres VARCHAR, CHAR, TEXT)
Binario(1 Y 0)
Fecha/Hora(Para almacenar Fechas y/o Horas, DATE TYPE, TIME TYPE, TIMESTAMP,
INTERVAL)
Boolean(Verdadero o Falso)
Especiales propios de postgres
Geométricos: Permiten calcular distancias y áreas usando dos valores X y Y.
Direcciones de Red: Cálculos de máscara de red
Texto tipo bit: Cálculos en otros sistemas, ejm(hexadecimal, binario)
XML, JSON: Postgres no permite guardar en estos formatos
Arreglos: Vectores y Matrices

oda jerarquía de base de datos se basa en los siguientes elementos:

Servidor de base de datos: Computador que tiene un motor de base de datos instalado
y en ejecución.
Motor de base de datos: Software que provee un conjunto de servicios encargados de
administrar una base de datos.

Base de datos: Grupo de datos que pertenecen a un mismo contexto.

Esquemas de base de datos en PostgreSQL: Grupo de objetos de base de datos que

guarda relación entre sí (tablas, funciones, relaciones, secuencias).

Tablas de base de datos: Estructura que organiza los datos en filas y columnas
formando una matriz.

current_date; ver el formato de la fecha actual.

Particiones
- Separacion fisica de datos
- Estructura logica

-- Tabla bitacora_viaje
CREATE TABLE public.bitacora_viaje(
id serial,
id_viaje integer,
fecha date
) PARTITION BY RANGE (fecha) WITH (OIDS = FALSE);
ALTER TABLE public.bitacora_viaje OWNER to postgres;

-- Vamos a crear la particion

CREATE TABLE bitacora_viaje201001 PARTITION OF public.bitacora_viaje
FOR VALUES FROM ('2010-01-01') TO ('2020-04-24');

-- Insertamos un dato --> ERROR antes de crear la particions

INSERT INTO public.bitacora_viaje(id_viaje, fecha)
VALUES(1, '2010-01-01');

-- Mostramos los valores de la tabla bitacora_viaje

SELECT * FROM bitacora_viaje;

-- eliminamos la tabla bitacora_viaje y se eliminara la particion igualmente

DROP TABLE bitacora_viaje;```

funciones

ON CONFLICT DO
Esta instruccion nos permite especificar que debemos hacer en caso de un conflicto.

Ejemplo: Imaginamos que realizamos una consulta donde el id ya ha sido utilizado.

Podemos especificar que en ese caso, actualize los datos.

INSERT INTO pasajero (id, nombre, direccion_residencia, fecha_nacimiento)

values (1, '', '','2010-01-01')
ON CONFLICT (id) DO
UPDATE SET
nombre = '', direccion_residencia='', fecha_nacimiento='2010-01-01';

RETURNING
Returning nos devuelve una consulta select de los campos sobre los que ha tenido
efecto la instruccion.
Ejemplo: Queremos saber cual es el id que le fue asignado a un dato insertado.

INSERT INTO tren (modelo, capacidad)

VALUES('modelo x', 100)
RETURNING id;
/*
Opcionalmente tambien puedes solicitar todos los campos o alguno de ellos
*/

INSERT INTO tren (modelo, capacidad)

VALUES('modelo x', 100)
RETURNING id;

INSERT INTO tren (modelo, capacidad)

VALUES('modelo x', 100)
RETURNING id, capacidad;

Like / Ilike
Las funciones like y ilike sirven para crear consultas a base de expresiones
regulares.

Like considera mayusculas y minusculas, mientras que ilike solo considera las
letras.

Ejemplo: Busquemos a los pasajeros con nombre que terminen con la letra o

-- Usando LIKE
SELECT * FROM PASAJERO
WHERE pasajero.nombre LIKE '%O'
-- No devulve nada, porque ningun nombre terminara con una letra mayuscula

IS / IS NOT
Permite hacer comprobacion de valores especiales como null

Ejemplo: Consultemos a todos los usuarios que tengan como direccion_residencia NULL

-- IS
SELECT * FROM PASAJERO
WHERE pasajero.nombre IS null;
Ahora a los que si tengan la direccion_recidencia con algun valor

-- IS NOT
SELECT * FROM PASAJERO
WHERE pasajero.nombre IS NOT null;

Funciones Especiales avanzadas en PosgreSQL

• COALES: compara dos valores y retorna el que es nulo
• NULLIF: Retorna null si son iguales
• GREATEST: Compara un arreglo y retorna el mayor
• LEAST: Compara un arreglo de valores y retorna el menor
• BLOQUES ANONIMOS: Ingresa condicionales dentro de una consulta de BD

SELECT id_pasajero, COALESCE (nom_pasajero, 'NO APLICA'), fecha_nacimiento,

direccion,
CASE WHEN fecha_nacimiento > '2015-01-01' THEN
'NIÑO'
ELSE 'MAYOR'
END,
CASE WHEN nom_pasajero ILIKE 'D%' THEN
'Empieza por D' ELSE 'No empieza con D'
END,
CASE WHEN extract(year from age(current_timestamp, fecha_nacimiento::timestamp))
>=18 THEN
'MAYOR DE EDAD'
ELSE
'MENOR DE EDAD'
END
FROM public."pasajeros " ;

vistas
es una consulta que se realiza muy amenudo

tipos de vistas
volatiles; informacion reciente

vistas materializada,

Agarra una consulta que se realice muchas veces y colocarla bajo un solo nombre.
Centraliza muchos esfuerzos en una sola función.
Vista volátil: Siempre que se haga la consulta en la vista, la BD hace la ejecución
de la consulta en la BD, por lo que siempre se va a tener información reciente.
Vista materializada: Hace la consulta una sola vez, y la información queda
almacenada en memoria, la siguiente vez que se consulte, trae el dato almacenado,
eso es bueno y malo a la vez, bueno porque la velocidad con la que se entrega la
información es rápida, malo porque la información no es actualizada. Es ideal
utilizar este tipo de vista en procesos que utilice días anteriores, porque el día
de ayer, ya pasó y no hay razón para actualizarlo.
Para crear una vista volátil en postgres, damos click derecho a views, create,
view, le damos un nombre, y en la pestaña code escribimos o pegamos el código de la
consulta que queremos guardar, la guardamos y para usar la vista usamos:

SELECT * FROM <nombre_vista>; y listo.

Para crear una vista materializada, primero creamos la consulta, y definimos si los
datos nos interesan o no, luego, vamos a la opción materialized views, click
derecho, create, materialized view. Se abre la ventana, le damos un nombre, termina
con _mview, y en la pestaña Definition escribimos la consulta que necesitamos
guardar. Guardamos.
Al probarla en este momento nos lanza un error, ¿por qué? porque no tiene datos
almacenados. Para almacenar datos usamos:

REFRESH MATERIALIZED VIEW <nombre vista>;

Y ahora si podemos consultarla:

SELECT * FROM <nombre_vista_mview>;

PL
PROCESOS ALMACENADOS
CREATE FUNTION importantePL()
RETURN void
AS $$
DECLARE
contador intger :=0;
rec record;
BEGIN
FOR rec IN SELECT * FROM pasajeros LOOP
RAISE NOTICE 'un pasajero se llama %', rec.nom_pasajero;
contador := contador + 1;
END lOOP;
RAISE NOTECE 'Conteo es%',contador;
END
$$
LEGUAGE PLPGSQL

DECLARE
contador integer :=0;
rec record;
BEGIN
FOR rec IN SELECT * FROM public."pasajeros " LOOP
RAISE NOTICE 'un pasajero se llama %', rec.nom_pasajero;
contador := contador + 1;
END lOOP;
INSERT INTO conteo(total,tiempo)
VALUES (Contador,now());
RETURN contador;
END
ambién conocidos como disparadores. Permiten ejecutar funciones dependiendo de
acciones que se ejecuten dentro de una DB.
Insert.
Update.
Delete.
Primero validamos la función, y que podamos guardar datos en una nueva tabla que
hemos creado, para este caso se llamará ‘passenger_counter’. Seleccionamos en el
menú desplegable las funciones, la función que vamos a editar, en este caso es
testPL, y añadimos la función para añadir la cantidad de pasajeros.

CREATE OR REPLACE FUNCTION public."testPL"(

)
RETURNS integer
LANGUAGE 'plpgsql'

COST 100
VOLATILE

AS $BODY$DECLARE
rec record;
counter integer := 0;
BEGIN
FOR rec IN SELECT * FROM passenger LOOP
RAISE NOTICE 'Un pasajero se llama %', rec.name;
counter := counter + 1;
END LOOP;
INSERT INTO passenger_counter (total, time)
VALUES (counter, now());
RETURN counter;
END$BODY$;

ALTER FUNCTION public."testPL"()

OWNER TO postgres;
Ya que funciona, ahora la función no puede devolver un tipo de dato integer, sino
un tipo de dato trigger. Elíminamos el RETURN porque al ser un trigger no returna
ningún tipo de dato.

CREATE OR REPLACE FUNCTION public."testPL"(

 )
RETURNS TRIGGER
LANGUAGE 'plpgsql'
AS $BODY$DECLARE
rec record;
counter integer := 0;
BEGIN
FOR rec IN SELECT * FROM passenger LOOP
counter := counter + 1;
END LOOP;
INSERT INTO passenger_counter (total, time)
VALUES (counter, now());
END$BODY$;
Borramos la función anterior con DROP FUNCTION y volvemos a crear la nueva función
con el retorno de dato de tipo trigger.
Para crear un trigger tenemos 3 tipos de disparadores
BEFORE: Antes de que se hagan los cambios.
AFTER: Después que se hagan los cambios.
INSTEAD OF: En vez de hacer los cambios.
Y ahora creamos el trigger de la siguiente manera:

CREATE TRIGGER my_trigger // Creamos el trigger y le ponemos el nombre my_trigger

AFTER INSERT // Después de insertar
ON passenger // En la tabla pasajero
FOR EACH ROW // Para cada fila
EXECUTE PROCEDURE "testPL"(); // Ejecutar el procedimiento/función "testPL"()
Ahora, al momento de crear una fila nos arrojará un error, ¿por qué? porque el
trigger tiene que retornarnos que se ha creado un dato.
Primero hay que eliminar los triggers y las funciones, como la función es un
trigger, se encuentra en el menú desplegable “trigger functions”.
Vuelve y se crea la función, y el trigger con el siguiente código.

DROP FUNCTION public."testPL"();

CREATE FUNCTION public."testPL"()

RETURNS trigger
LANGUAGE 'plpgsql'
COST 100
VOLATILE NOT LEAKPROOF
AS $BODY$DECLARE
rec record;
counter integer := 0;
BEGIN
FOR rec IN SELECT * FROM passenger LOOP
counter := counter + 1;
END LOOP;
INSERT INTO passenger_counter (total, time)
VALUES (counter, now());
RETURN NEW; // NEW es para retornar los datos nuevos que se están ingresando,
OLD retorna los valores antiguos. Como estamos insertando valores, se necesita
retornar los datos que estamos ingresando
END$BODY$;

ALTER FUNCTION public."testPL"()

OWNER TO postgres;

CREATE TRIGGER my_trigger

AFTER INSERT
ON public.passenger
 FOR EACH ROW
EXECUTE PROCEDURE public."testPL"();
RETO CREAR UN TRIGGER PARA CUANDO SE BORRE UN DATO DE LA TABLA.

CREATE TRIGGER delete_trigger

AFTER DELETE
ON public.passenger
FOR EACH ROW
EXECUTE PROCEDURE public."testPL"();
No necesitamos crear una función de más, simplemente usamos la función anterior
para que cuente los registros, y que se ejecute después que se borre un registro.

DO $$
DECLARE
contador intger :=0;
rec record;
BEGIN
FOR rec IN SELECT * FROM pasajeros LOOP
RAISE NOTICE 'un pasajero se llama %', rec.nom_pasajero;
contador := contador + 1;
END lOOP;
RAISE NOTECE 'Conteo es%',contador;
END
$$

TRIGGERS
DISPARADOPRES
ACCCIONES
INSERT
DELETE
UPDATE