Differenze tra "COMMIT", "ROLLBACK" e non mettere nulla

di iBaffiPro il
8 risposte
Nel database seguente qual è la differenze tra "COMMIT", "ROLLBACK" e non mettere nulla?
-- Create table
create table APP_USER
(
  USER_ID           BIGINT not null,
  USER_NAME         VARCHAR(36) not null,
  ENCRYTED_PASSWORD VARCHAR(128) not null,
  ENABLED           Int not null 
) ;
--  
alter table APP_USER
  add constraint APP_USER_PK primary key (USER_ID);
 
alter table APP_USER
  add constraint APP_USER_UK unique (USER_NAME);
 
 
-- Create table
create table APP_ROLE
(
  ROLE_ID   BIGINT not null,
  ROLE_NAME VARCHAR(30) not null
) ;
--  
alter table APP_ROLE
  add constraint APP_ROLE_PK primary key (ROLE_ID);
 
alter table APP_ROLE
  add constraint APP_ROLE_UK unique (ROLE_NAME);
 
 
-- Create table
create table USER_ROLE
(
  ID      BIGINT not null,
  USER_ID BIGINT not null,
  ROLE_ID BIGINT not null
);
--  
alter table USER_ROLE
  add constraint USER_ROLE_PK primary key (ID);
 
alter table USER_ROLE
  add constraint USER_ROLE_UK unique (USER_ID, ROLE_ID);
 
alter table USER_ROLE
  add constraint USER_ROLE_FK1 foreign key (USER_ID)
  references APP_USER (USER_ID);
 
alter table USER_ROLE
  add constraint USER_ROLE_FK2 foreign key (ROLE_ID)
  references APP_ROLE (ROLE_ID);
 
  
  
-- Used by Spring Remember Me API.  
CREATE TABLE Persistent_Logins (
 
    username varchar(64) not null,
    series varchar(64) not null,
    token varchar(64) not null,
    last_used timestamp not null,
    PRIMARY KEY (series)
     
);
  
--------------------------------------
 
insert into App_User (USER_ID, USER_NAME, ENCRYTED_PASSWORD, ENABLED)
values (2, 'dbuser1', '$2a$10$PrI5Gk9L.tSZiW9FXhTS8O8Mz9E97k2FZbFvGFFaSsiTUIl.TCrFu', 1);
 
insert into App_User (USER_ID, USER_NAME, ENCRYTED_PASSWORD, ENABLED)
values (1, 'dbadmin1', '$2a$10$PrI5Gk9L.tSZiW9FXhTS8O8Mz9E97k2FZbFvGFFaSsiTUIl.TCrFu', 1);
 
---
 
insert into app_role (ROLE_ID, ROLE_NAME)
values (1, 'ROLE_ADMIN');
 
insert into app_role (ROLE_ID, ROLE_NAME)
values (2, 'ROLE_USER');
 
---
 
insert into user_role (ID, USER_ID, ROLE_ID)
values (1, 1, 1);
 
insert into user_role (ID, USER_ID, ROLE_ID)
values (2, 1, 2);
 
insert into user_role (ID, USER_ID, ROLE_ID)
values (3, 2, 2);

Commit;
Vorrei appuntarmi nel codice questa differenza per non dimenticarmi più. Mi è stato detto che quello che avevo in mente non era esatto.

-- COMMIT invia una segnalazione di errore nel caso una delle N transazioni precedenti alla parola COMMIT fallisca ma
-- non riporta il DB allo stato originario, quindi può accadere che queste N transazioni vengano in parte applicate al
-- DB.
-- ROLLBACK invia una segnalazione di errore nel caso una delle N transazioni precedenti alla parola ROLLBACK fallisca
-- ma riporta il DB allo stato originario, quindi se anche solo una delle precedenti transazioni fallisce il DB non
-- viene assolutamente modificato. Con ROLLBACK il DB prima di eseguire le N modifiche le testa e verifica che non vi
-- siano errori.
-- Per definire le N transazioni atomiche queste ultime vengono precedute da "BEGIN TRANSACTION;" in PostgreSQL, da
-- "START TRANSACTION;" in MySQL e vengono fatte seguire da "COMMIT;" oppure da "ROLLBACK;".
-- Se mancano "BEGIN TRANSACTION;" oppure "START TRANSACTION;" le N transazioni sono rappresentate dall'intero file
-- .sql.

8 Risposte

  • Grazie mille, la guida che mi hai consigliato mi ha aiutato a capire.
    Quindi usare "COMMIT" permette di applicare al DB tutto lo schema oppure nulla in caso di errori, fatta eccezione per la creazione delle tabelle qualora la loro creazione sia fattibile.
  • Perché BIGINT invece di BIGSERIAL per definire un id? Gli id possono essere negativi? Come puoi vedere non sono esperto di DB ma non sapevo che un id potesse essere negativo. Riesci ad aiutarmi anche su questo?
    Sono sempre esistiti id negativi oppure no?
    https://www.postgresql.org/docs/9.1/datatype-numeric.html
  • Altra cosa strana che non sono abituato a vedere è l'assegnazione di un vincolo al campo id, al nome, ecc... Dare un nome a tutti questi vincoli che utilità ha? Conviene sempre farlo oppure no?
    ciao
  • Smallserial, serial, bigserial sono numeri positivi autoincrementali che partono da 1.
    Se come primary key della tabella vuoi usare un numero univoco incrementale , puoi usare la tipologia di dati di cui sopra. Non ti devi preoccupare tu di gestire l'incremento ma lo deleghi a PostgreSQL.
    Diversamente dovresti usare le SEQUENCE o soluzioni custom.

    Se vuoi degli id negativi non puoi usare i serial e devi quindi gestirli. Detto questo, non è cosa comune usare id negativi e non ha senso farlo. Per necessità particolari, sistemi più elaborati, si usano chiavi testuali custom (in genere "parlanti").
  • Grazie mille.
    In merito ai nomi dei vincoli cosa mi dici?
    Possono avere un'utilità in qualche query complessa?
  • Le CONSTRAINTS devono per forza avere un identificatore (quello che tu chiami nome).
    Se non lo specifichi tu, lo imposta automaticamente PostgreSQL.
  • Grazie mille
Devi accedere o registrarti per scrivere nel forum
8 risposte