Transacciones

Hola a todos. Mi aporte a la clase es otra forma de usar ROLLBACK con otra función de postgresql que se llama SAVEPOINT. Básicamente se pueden crear puntos de guardado por cada consulta que uno desee y hacer que el ROLLBACK solo sea efectivo hasta ese punto, es decir, que las operaciones anteriores al SAVEPOINT sí se ejecuten.

25.Transacciones
Las transacciones, tienen la capacidad para empaquetar varios pasos en una sola operación “todo o nada”.y si ocurre alguna falla que impida que se complete la transacción, entonces ninguno de los pasos se ejecuta y no se afecta la base de datos en absoluto.

SQL Transacción - Estructura
La transacciones tienen la siguiente estructura postgres. Postgres en las operaciones normales usa de manera implícita el rollback el rollback.

BEGIN;
<Intrucciones>
COMMIT|ROLLBACK

SQL Transacción - Ejemplo en PgAdmin

1. Desactivamos en la equina superior de pg-admin el auto commit

2. Iniciamos la transacción

BEGIN;
INSERT INTO  public.estacion(nombre,direccion)
VALUES('Estación Transacción',' 1');
 
INSERT INTO  public.tren(modelo,capacidad)
VALUES('Modelo Transacción','2');
 
COMMIT;

SQL Transacción - Ejemplo de un rollback implícito
Como se puede visualizar en el ejemplo existe una inserción correcta en la tabla tren pero en la tabla estación sé está haciendo un insert a un id que existe realmente.

BEGIN;
 
 
INSERT INTO  public.tren(modelo,capacidad)
VALUES('Modelo Transacción 2','2');
 
INSERT INTO  public.estacion(id,nombre,direccion)
VALUES(101,'Estación Transacción 2',' 1');
 
COMMIT;

Es como Git masomenos hahaha 😄

Información resumida de esta clase
#EstudiantesDePlatzi

• Las transacciones nos ayudan a llevar a cabo procesos complejos de manera segura, si una transacción falla, la base de datos no genera los cambios.

• Las funciones para las transacciones son: BEGIN, COMMIT y ROLLBACK

• BEGIN inicia la consulta con las condiciones, COMMIT guarda los cambios al final y ROLLBACK devuelve todo si algo quedo mal

• Debemos verificar en las opciones de ejecución que no esté activado el COMMIT

• Postgre por defecto corre el ROLLBACK cuando una transacción presenta problemas

Las transacciones, tienen la capacidad para empaquetar varios pasos en una sola operación “todo o nada”.y si ocurre alguna falla que impida que se complete la transacción, entonces ninguno de los pasos se ejecuta y no se afecta la base de datos en absoluto.

COMMIT
Muy importante para mantener la integridad de los datos. Hay que tene rmucho cuidado en cerrar siempre la transaccion, ya sea con COMIMIT o ROLLBACK.

BEGIN;
SELECT now();
COMMIT;

BEGIN;	
INSERT INTO public.tren(
	 modelo, capacidad)
	VALUES ( 'Model Tran', 100);
	
INSERT INTO public.estacion(
	 id, nombre, direccion)
	VALUES ( 2,'Begin', 'Tran');
COMMIT;

Entonces una transacción sirve para agrupar varias consultas juntas y garantizar que cada una de ellas se ejecute de manera exitosa, en caso de que alguna falle, todas las operaciones del bloque que comienza con BEGIN se ven descartadas, sin duda muy interesante!

Intente hacer el codigo para solo permitir 3 personas que sean vip. Lo que intente fue que a la hora de ejecutar cuantas personas vip habian si era mayor a 3 trataba de hacer caer en error. Este fue mi resultado.

BEGIN;

INSERT INTO vip (id,fecha)
VALUES (50,NOW());

DO $$
DECLARE 
	rec record;
	x integer := 0;
BEGIN 
	FOR rec IN
		SELECT *
		FROM vip
	LOOP
		x:= x+1;
	END LOOP;
	
	IF 
		x>3 THEN x=0;
		ROLLBACK;
	END IF;
END 
$$;

COMMIT;

Me hubiera gustado que el ejemplo de ROLLBACK, lo hicieran aunque pues siempre esos problemas raros lo buscan es a uno

Creo que la noción es clara para los que hemos usado Git y Github

Esto tiene muchisima importancia cuando te encuentras en un entorno real, funcionando con una DB de negocio,

Esto me recuerda no solo el uso de transacciones, sino tb que debemos controlarlo o gestionarlo dependiendo de la logica de negocio.

Para realizar un rollback de manera explicta podría ser dentro de una función (PL) escrita en plpgsql

Las transacciones son un concepto fundamental en las bases de datos relacionales que garantiza la consistencia y la integridad de los datos. Una transacción agrupa una serie de operaciones en una unidad atómica, lo que significa que todas las operaciones se realizan como una única entidad o ninguna se realiza en absoluto

BEGIN TRANSACTION; -- Inicia la transacción

-- Realiza operaciones SQL aquí
UPDATE tabla SET columna = valor WHERE condición;

-- Verifica si todo está bien
IF todo_esta_bien THEN
    COMMIT; -- Confirma la transacción
ELSE
    ROLLBACK; -- Deshace la transacción
END IF;

Ojala funcionara asi en Peru. En peru si la transaccion falla se realiza igual la transaccion, pero, no te llega constancia de transferencia. El destinatario feliz porque tiene el dinero y no tienes como probarle que se transfirio.

Es importante tener en cuenta que las transacciones pueden afectar el rendimiento del sistema de bases de datos, ya que pueden bloquear las tablas y las filas que se están modificando hasta que se finalice la transacción. Por lo tanto, es recomendable utilizar transacciones solo cuando sea necesario y en casos donde se requiera la integridad de los datos y la consistencia de las operaciones.

Here, the documentation: https://www.postgresql.org/docs/8.3/tutorial-transactions.html

😂

Qué costaba 2 minutos más de video y mostrar el ROLLBACK EXPLÍCITO?

• The essential point of a transaction is that it bundles multiple steps into a single, all-or-nothing operation.
• La idea fundamental de una transacción es que agrupa múltiples pasos en una sola operación, la cual se realiza por completo o no se realiza en absoluto.

En resumen:

• BEGIN inicializa la transaccion
• ROLLBACK es como un ctrl+z que retrocede hasta antes de realizar la ultima transaccion que ejecutemos
• COMMIT verifica que todas las sentencias dentro de la transaccion este bien escrito. Si uno o mas no estan bien escrito ninguna se ejecuta.

Transacciones

Las transacciones en PostgreSQL son un mecanismo que permite realizar múltiples operaciones sobre la base de datos como una sola unidad de trabajo.

Esto significa que si una operación falla, todas las operaciones realizadas en la transacción son revertidas, garantizando la integridad de los datos.

• Las transacciones se pueden iniciar con el comando “BEGIN”, seguido de una serie de sentencias SQL, y se finalizan con el comando “COMMIT” o “ROLLBACK”. Este mecanismo es esencial para asegurar la consistencia y la integridad de los datos en la base de datos.

BEGIN;

INSERT INTO table_name (column1, column2, column3)
VALUES ('value1', 'value2', 'value3');

UPDATE table_name
SET column2 = 'new_value'
WHERE column1 = 'value1';

COMMIT;

En este ejemplo, la sentencia BEGIN inicia la transacción. Luego se inserta un nuevo registro en la tabla table_name con valores específicos para las columnas. Después, se actualiza el registro con un nuevo valor en la columna column2 donde la columna column1 es igual a value1. Finalmente, la sentencia COMMIT confirma los cambios realizados en la transacción.

• Los pasos dentro de la transacción van a ser varias sentencias SQL.
• Si se quiere que todo se ejecute, se debe dejar un COMMIT al final, sino, se puede probar como va quedando y al final EJECUTAR UN COMMIT o si se hizo alguna transacción la cual se quiere deshacer se puede utilizar ROLLBACK

Excelente explicación sobre BEGIN, COMMIT y ROLLBACK… de forma muy breve y sencilla. Me parece muy interesante esta función, garantiza confiabilidad en los procesos.

Todo el código que esté entre un BEGIN y un COMMIT PostgreSQL lo considera una sola transacción (teniendo desactivado el autocommit).
Es decir: iniciada la transacción hasta que no se ejecute el COMMIT los datos van a estar en memoria pero no se van a hacer efectivos en la base de datos. Solo con la ejecución del COMMIT se hacen recién efectivos en BD.
Si una de las tareas de la transacción falla, automáticamente se ejecuta un ROLLBACK y todas las tareas de la transacción vuelven para atrás. La tarea que falló y todas las que no fallaron.
Un uso explícito de la sentencia ROLLBACK es cuando tenemos que limitar un cupo.
Por ejemplo: queremos que solo 3 pasajeros sean vip. Entonces ponemos esta restricción en la respectiva tabla y en el código inmediatamente luego de un INSERT INTO está la sentencia ROLLBACK. Si al realizar el INSERT INTO falla porque son más de 3 entonces el ROLLBACK vuelve todo para atrás.

• Transacciones

  • Las transacciones comienzan con un begin.
  • Para indicar que todas las sentencias SQL han terminado correctamente utilizamos el comando commit.
  • En el caso que se deba cancelar la transacción y no tomar en cuenta las sentencias SQL ya comenzados utilizamos el comando rollback.

  BEGIN;
  SELECT true;
  COMMIT; 
  --ROLLBACK;
  

El enfoque de las transacciones es dar una capa de seguridad
a todo lo que se ejecuta con el fin de no generar daños en la información
de manera que no se generen cambios hasta que todo el bloque transaccional
se ejecute de manera correcta.

Muy buena clase!

AQUÍ ESTA EL EJEMPLO Y PUEDES PONER VARIAS SENTENCIAS QUE GUSTES REGISTRAR, POR ESO EN LA IMAGEN AÑADÍ UN UPDATE Y UN SELECT MÍRALO e INTÉNTALO ESPERO TE HAYA GUSTADO.

BEGIN; <Intrucciones;> COMMIT;|ROLLBACK;

Postgres en las operaciones normales usa de manera implicita el rollback

Cuando ejecutó la transacción que falló, veo que los botones de commit y rollback se activaron.
Eso quiere decir que la transacción quedó abierta, ¿O me equivoco?.

Osea, creo que realmente no se hizo un rollback automaticamente, sino que simplemente el primer insert aún no se ha consolidado con un commit.

Asumo que una transacción que queda abierta eventualmente se le agota un tiempo de espera, y allí es cuando realmente se hace un rollback.

Transacciones: Procesos complejo seguros
- Commit: Si llegamos al final devuelva todos los cambios
- Rollback: Si algo fallo que devuelva todo lo que hicimos

BEGIN
<consultas>
COMMIT | ROLLBACK

-- Si todo va correctamente hace commit
BEGIN;
INSERT INTO public.estacion(nombre, direccion)
VALUES('Estacion Transac', 'Dir1');
INSERT INTO public.tren(modelo, capacidad)
VALUES('Modelo trans', 123);
COMMIT;

-- si alguna de ellas falla, el id ya existe. Vuelve donde nos quedamos antes de Begin.
BEGIN;
INSERT INTO public.tren(modelo, capacidad)
VALUES('Modelo trans 2', 1234);
INSERT INTO public.estacion(id, nombre, direccion)
VALUES(108, 'Estacion Transac 2', 'Dir2');
ROLLBACK;

<
BEGIN ;
INSERT INTO trenes(
                   modelo, capacidad)
                VALUES ('Modelo Ehdf2', 130);
INSERT INTO estaciones(
                    estacion_id, nombre, direccion)
            VALUES (50 ,'Estacion Transs', 'San Pablo');
>

Para manejar errores,como try,except

Funciones para una transacción

Desactivar Auto commit

COMMIT: Para que la transacción se guarde en la tabla.

Ejemplo de ROLL BACK: Para cuando hay un error en la transacción.

Para aquellos que usen postgreSQL por consola. Se puede abrir una transacción, ir añadiendo varias sentencias SQL pero una a una, y cerrar con commit.

postgres=# BEGIN;
postgres=# SQL sentence 1;
postgres=# SQL sentence 2;
postgres=# COMMIT;

AUTOCOMMIT
Check status

postgres=# \echo :AUTOCOMMIT

Cambiar el status (ON|OFF)

postgres=# \set AUTOCOMMIT on|off;

Este tema es muy interesante ya que también te puede servir antes de ejecutar cualquier tipo de modificación, Delete, Insert, update ya que despues de ejecutar se puede ejecutar una consulta

Excelente!!!

BEGIN;
INSERT INTO public.estacion(
nombre, direccion)
VALUES (‘Estacion Transaccion’, ‘Dire’);

INSERT INTO public.tren(
 modelo, capacidad)
VALUES ('Modelo Transaccion', 524);
--ROLLBACK
COMMIT;

Excelente explicación.