PG basics -- Logical Structure Management (transaction)

Transaction submission

pg The default is to automatically commit transactions , You can turn off the automatic submission function

Turn off auto submit

Log in and copy

      
      

       
       postgres
       
       =# \set autocommit off
       
       
postgres
       
       =# \echo 
       
       :autocommit  
       
       
off
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
      
      

savepoint

pg Support savepoint function , In a big business , The operation process can be divided into several parts , After the first part is successfully executed, a savepoint can be created , If the later part fails , Rollback to this savepoint , Instead of rolling back the entire transaction .

Log in and copy

      
      

       
       postgres
       
       =# \d test01
       
       ;
       
       
                      
       
       Table 
       
       "public.test01"
       
       
 Column 
       
       |         Type          
       
       | Collation 
       
       | Nullable 
       
       | Default 
       
       

       
       --------+-----------------------+-----------+----------+---------
       
       
 id     
       
       | 
       
       integer               
       
       |           
       
       | 
       
       not 
       
       null 
       
       | 
       
       
 note   
       
       | character varying
       
       (
       
       20
       
       ) 
       
       |           
       
       |          
       
       | 
       
       
Indexes
       
       :
       
       
    
       
       "test01_pkey" PRIMARY KEY
       
       , btree 
       
       (id
       
       )
       
       

       
       
postgres
       
       =# 
       
       insert 
       
       into test01 
       
       values
       
       (
       
       1
       
       ,
       
       '11'
       
       )
       
       ;
       
       

       
       INSERT 
       
       0 
       
       1
       
       
postgres
       
       =# 
       
       select 
       
       * 
       
       from test01
       
       ;
       
       
 id 
       
       | note 
       
       

       
       ----+------
       
       
  
       
       1 
       
       | 
       
       11
       
       

       
       (
       
       1 row
       
       )
       
       

       
       
postgres
       
       =# savepoint my_savepoint01
       
       ;
       
       
SAVEPOINT
       
       
postgres
       
       =# 
       
       insert 
       
       into test01 
       
       values
       
       (
       
       2
       
       ,
       
       '22'
       
       )
       
       ;
       
       

       
       INSERT 
       
       0 
       
       1
       
       
postgres
       
       =# rollback to savepoint my_savepoint01
       
       ;
       
       
ROLLBACK
       
       
postgres
       
       =# 
       
       select 
       
       * 
       
       from test01
       
       ;
       
       
 id 
       
       | note 
       
       

       
       ----+------
       
       
  
       
       1 
       
       | 
       
       11
       
       

       
       (
       
       1 row
       
       )
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
       
       
6.
       
       
7.
       
       
8.
       
       
9.
       
       
10.
       
       
11.
       
       
12.
       
       
13.
       
       
14.
       
       
15.
       
       
16.
       
       
17.
       
       
18.
       
       
19.
       
       
20.
       
       
21.
       
       
22.
       
       
23.
       
       
24.
       
       
25.
       
       
26.
       
       
27.
       
       
28.
      
      

The second data inserted , Rollback to the first savepoint .

Transaction isolation level

and mysql equally ,pg The transaction isolation level of is also divided into 4 Kind of ,

read uncommited Read uncommitted

read commit Read submitted

repeatable read Repeatable

serializable Serialization

Dirty reading ： One transaction reads uncommitted data from another transaction .

It can't be read repeatedly ： When a transaction re reads the previously read data , It is found that the data has been modified by another transaction （update ,delete）.

Fantasy reading ： After a transaction has started , After querying the qualified data , Query again , More data found (insert).

pg Repeatable reading can avoid non repeatable reading , But unreal reading cannot be avoided , This and mysql equally . The difference is pg The default isolation level is read committed , and mysql The default is repeatable reading .

Two-phase commit

In distributed systems , Transactions often involve the operation of multiple databases , Although the operation of a single database can ensure atomicity , However, atomicity between multiple databases requires two-stage submission .

step

1） The application program first calls each database to do some operations , But don't commit the transaction , Then the application calls the commit method in the transaction coordinator

2） The transaction coordinator will contact each database involved in the transaction , And inform them that they are ready to commit the transaction , This is the beginning of the first phase , It's called PREPARE TRANSACTION.

3） Each database receives PREPARE TRANSACTION after , If the return is successful , Then the database must put itself in the following state ： Ensure that subsequent transactions can be raised when they are submitted , Or the transaction can be rolled back later when required . therefore PG The information ready for submission will be written to the persistent storage , If the database cannot complete this transaction , It will directly return the failure to the transaction coordinator .

4） The transaction coordinator receives responses from all databases .

5） The second stage , If any database fails in the first stage , Then the transaction coordinator will send a rollback command to each database , If all database responses are successful , Send to each database commit prepared command . Notify each database that the transaction is submitted successfully .