You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
2 Hrs
18 Min
44 Seg
Curso de PostgreSQL

Curso de PostgreSQL

Oswaldo Rodríguez González

Oswaldo Rodríguez González

Transacciones

25/32
Resources

What is a database transaction?

Database transactions are sequences of operations treated as a single action. Their purpose is to ensure that the operations performed are consistent and secure, especially in systems that require high reliability, such as banking systems.

  • Atomicity: Transactions are atomic, which means that all operations within the transaction must complete successfully. If any one fails, the entire change must be reversed.

How are transactions initiated and executed?

To initiate a transaction, we use the BEGIN command. Upon completion of the necessary operations, it is paramount to secure the changes with COMMIT. If the changes have to be undone because something went wrong, we use ROLLBACK.

BEGIN;-- inserts and otherCOMMIT operations;

What happens if something goes wrong?

If any of the operations in the transaction fails, the database will use ROLLBACK to return to its previous state and revert all transactions performed up to that point.

How does Autocommit work in PGAdmin?

PGAdmin, by default, has Autocommit enabled, which means that each transaction is automatically saved. To handle transactions manually, you must deactivate this option.

  • Disable Autocommit: This is crucial to avoid confusion and to handle transactions with full control.

How to handle transactions with multiple queries?

To execute multiple queries in a transaction block, BEGIN and COMMIT are used. This is essential for complex changes where all actions must succeed.

Example transaction with inserts

BEGIN;INSERT INTO station (name, address) VALUES ('Station Transaction', '123 Fake Street');INSERT INTO train (model, capacity) VALUES ('Model Transaction', 300);COMMIT;

What happens if an insert fails because of a duplicate key?

In case a query within a transaction fails, for example, when trying to insert an ID that already exists, the whole transaction will be rolled back.

BEGIN;INSERT INTO tren (model, capacity) VALUES ('Existing Model', 300); -- Assuming this model already existsCOMMIT;-- The insertion will fail and ROLLBACK will be used automatically.

When is the explicit use of ROLLBACK useful?

Although implicit ROLLBACK is used automatically, there are cases where defining it explicitly is beneficial, such as when implementing custom business logic.

Practical example:

Imagine wanting to limit insertions to a maximum of three passengers for a specific flight. You could use a business condition that triggers explicit ROLLBACK when trying to add a fourth passenger.

BEGIN;-- logic before INSERTIF (SELECT COUNT(*) FROM passengers WHERE flight_id = 1) >= 3 THEN ROLLBACK;END IF;INSERT INTO passengers (name, flight_id) VALUES ('New Passenger', 1);COMMIT;

Transaction handling recommendations

  • Plan your transactions: In any critical operation, make sure your queries are well designed to avoid failures.
  • Test in a secure environment: Before implementing complex transactions in production, test in a development environment to avoid costly errors.
  • Document and educate: Familiarize your team with best practices for secure and efficient transactions.

Proper transaction handling ensures database integrity and prevents inconsistencies that can be critical in sensitive applications. Keep learning, as practice and knowledge are key to effective database management.

Contributions 50

Questions 10

Sort by:

Want to see more contributions, questions and answers from the community?

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,

Aqui les va un ejemplo en una transaccion de dinero mis amigues: BEGIN; UPDATE cuentas SET saldo = saldo - 100 WHERE id = 1; -- Restar de la cuenta 1 \-- Verificamos si la operación fue exitosa IF (SELECT saldo FROM cuentas WHERE id = 1) < 0 THEN ROLLBACK; -- Si no hay suficiente saldo, deshacer RAISE EXCEPTION 'Saldo insuficiente'; ELSE UPDATE cuentas SET saldo = saldo + 100 WHERE id = 2; -- Agregar a la cuenta 2 COMMIT; -- Si todo fue bien, confirmar la transacción END IF;

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.

😂

En PostgreSQL, las **transacciones** son bloques de instrucciones que se ejecutan como una unidad atómica, es decir, todas las operaciones dentro de una transacción deben completarse correctamente; de lo contrario, todas las operaciones se deshacen. Esto asegura la integridad de los datos y permite gestionar errores de forma eficiente. A continuación, se explican los conceptos básicos, comandos y ejemplos de transacciones en PostgreSQL: ### **Comandos Básicos de Transacciones** 1. **BEGIN** Inicia una nueva transacción.BEGIN; 2. **COMMIT** Finaliza la transacción y guarda todos los cambios realizados.COMMIT; 3. **ROLLBACK** Deshace todas las operaciones realizadas en la transacción actual.ROLLBACK; 4. **SAVEPOINT** Crea un punto de restauración dentro de la transacción, al que puedes volver si ocurre un error.SAVEPOINT savepoint\_name; 5. **ROLLBACK TO SAVEPOINT** Revierte la transacción al punto de restauración especificado, sin deshacer toda la transacción.ROLLBACK TO SAVEPOINT savepoint\_name; 6. **RELEASE SAVEPOINT** Elimina un punto de restauración creado previamente.RELEASE SAVEPOINT savepoint\_name; ### **Ejemplo Básico de Transacción** BEGIN; \-- Insertar un nuevo usuario INSERT INTO usuarios (nombre, email) VALUES ('Juan', '[email protected]'); \-- Actualizar el saldo de un cliente UPDATE cuentas SET saldo = saldo - 100 WHERE id\_cuenta = 1; \-- Confirmar los cambios COMMIT; Si alguna de las operaciones falla, puedes usar `ROLLBACK` para deshacer los cambios: ROLLBACK; ### **Ejemplo con SAVEPOINT** BEGIN; \-- Crear un savepoint SAVEPOINT antes\_de\_insercion; \-- Intentar insertar un registro INSERT INTO usuarios (nombre, email) VALUES ('María', '[email protected]'); \-- Si ocurre un error, volver al savepoint ROLLBACK TO SAVEPOINT antes\_de\_insercion; \-- Continuar con otras operaciones UPDATE cuentas SET saldo = saldo + 200 WHERE id\_cuenta = 2; COMMIT; ### **Transacciones Automáticas y Modo Autocommit** * **Autocommit:** Por defecto, PostgreSQL ejecuta cada instrucción SQL como una transacción independiente, es decir, hace un `COMMIT` automáticamente después de cada instrucción exitosa. Si deseas gestionar las transacciones manualmente, desactiva el autocommit con `BEGIN` o configurando el cliente. ### **Transacciones con Manejo de Errores** Usa bloques anónimos en PL/pgSQL para capturar y manejar errores dentro de una transacción: DO $$ BEGIN BEGIN; \-- Intentar insertar datos INSERT INTO usuarios (nombre, email) VALUES ('Pedro', '[email protected]'); \-- Forzar un error (si es necesario para pruebas) PERFORM pg\_sleep(-1); COMMIT; EXCEPTION WHEN OTHERS THEN \-- Deshacer cambios si ocurre un error ROLLBACK; RAISE NOTICE 'Se produjo un error. Transacción revertida.'; END; $$ LANGUAGE plpgsql; ### **Bloqueos y Concurrencia** * Las transacciones pueden bloquearse entre sí si intentan modificar los mismos registros. * Usa el comando `SELECT ... FOR UPDATE` para bloquear filas específicas durante una transacción.BEGIN; \-- Bloquear una fila para actualización SELECT \* FROM cuentas WHERE id\_cuenta = 1 FOR UPDATE; \-- Modificar la fila bloqueada UPDATE cuentas SET saldo = saldo - 500 WHERE id\_cuenta = 1; COMMIT; ### **Prácticas Recomendadas** 1. Mantén las transacciones cortas para evitar bloqueos prolongados. 2. Usa `SAVEPOINT` para manejar errores parciales sin deshacer toda la transacción. 3. Revisa los niveles de aislamiento si trabajas con múltiples transacciones concurrentes.
Veo por todas las clases y no encuentro como manejar archivos binarios grandes y muchos. averigue por otros medios y encontré q puede introducir como tipo bytea, pero tambien por fuentes externas se que no es bueno introducir archivos binarios a una tabla, ya que afecta su rendimiento. sin emabrgo, e fuentes externas tambien vi que en sqlserver hay dos maneras de manejar binarios sin introducir a la tabla de base de datos, si no desde una una tabla aparte. En pstgresql imagino debe haber otra forma. Averigué q existe los blob pero no se si se refiere a bytea o que es como formato text q estan dentro de la tabla, y no separado fuer a de bd. Podrian enseñarme por favor eso?, no entiendo por que lo obviaron. Gracias
Las transacciones son una parte fundamental de las bases de datos y permiten agrupar varias operaciones en una única unidad de trabajo. Si alguna de las operaciones dentro de la transacción falla, todas las operaciones pueden ser revertidas (rollback) para asegurar la consistencia de los datos. Vamos a ver cómo usar transacciones en tu base de datos de gestión de inventarios. ### Conceptos Básicos de Transacciones * **BEGIN**: Inicia una nueva transacción. * **COMMIT**: Confirma todas las operaciones realizadas dentro de la transacción. * **ROLLBACK**: Revierte todas las operaciones realizadas dentro de la transacción.
si o si esto se debe aplicar?...

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.