Hoe transaction_timestamp() werkt in PostgreSQL

In PostgreSQL, de transaction_timestamp() functie retourneert de huidige datum en tijd (inclusief de tijdzone-offset), aan het begin van de huidige transactie.

Het is het equivalent van de traditionele Postgres-functie now() .

Het is ook vergelijkbaar met de current_timestamp functie (wanneer aangeroepen zonder een argument), behalve dat het een naam heeft om duidelijk weer te geven wat het doet.

De transaction_timestamp() functie accepteert geen parameters, dus u kunt de precisie ervan niet specificeren, terwijl current_timestamp kan worden aangeroepen met of zonder een precisieparameter.

Ook transaction_timestamp() is een niet-SQL-standaard functie.

Syntaxis

De syntaxis gaat als volgt:

transaction_timestamp()

Er zijn geen argumenten vereist of geaccepteerd.

Basisvoorbeeld

Hier is een eenvoudig voorbeeld om te demonstreren.

SELECT transaction_timestamp();

Resultaat:

2020-07-02 08:23:08.810484+10

Binnen een transactie

Hier is een voorbeeld om te laten zien hoe het werkt binnen een transactie.

BEGIN;
SELECT transaction_timestamp();
SELECT pg_sleep(5);
SELECT transaction_timestamp();
SELECT pg_sleep(5);
SELECT transaction_timestamp();
COMMIT;

Hier is de volledige uitvoer in mijn terminal bij gebruik van psql:

postgres=# BEGIN;
BEGIN
postgres=# SELECT transaction_timestamp();
     transaction_timestamp     
-------------------------------
 2020-07-02 08:27:04.229266+10
(1 row)


postgres=# SELECT pg_sleep(5);
 pg_sleep 
----------
 
(1 row)


postgres=# SELECT transaction_timestamp();
     transaction_timestamp     
-------------------------------
 2020-07-02 08:27:04.229266+10
(1 row)


postgres=# SELECT pg_sleep(5);
 pg_sleep 
----------
 
(1 row)


postgres=# SELECT transaction_timestamp();
     transaction_timestamp     
-------------------------------
 2020-07-02 08:27:04.229266+10
(1 row)


postgres=# COMMIT;
COMMIT

Alle drie de tijdwaarden zijn identiek, hoewel de pg_sleep() functie werd gebruikt om de uitvoering te vertragen tussen elke aanroep naar transaction_timestamp() , die elk toevallig in hun eigen SQL-instructie stonden.

We kunnen dus zien dat de tijd die voor elk afschrift wordt geretourneerd, is gebaseerd op de starttijd van de huidige transactie - niet op het afschrift. Het verandert niet naarmate de transactie vordert.

Hierdoor kan een enkele transactie een consistent idee hebben van de "huidige" tijd, zodat meerdere wijzigingen binnen dezelfde transactie hetzelfde tijdstempel dragen.

Meerdere oproepen binnen een verklaring

Het verandert ook niet naarmate de verklaring vordert.

\x
SELECT 
  transaction_timestamp(),
  pg_sleep(5),
  transaction_timestamp(),
  pg_sleep(5),
  transaction_timestamp();

Resultaat (met verticale uitvoer):

transaction_timestamp | 2020-07-02 09:15:56.154175+10
pg_sleep              | 
transaction_timestamp | 2020-07-02 09:15:56.154175+10
pg_sleep              | 
transaction_timestamp | 2020-07-02 09:15:56.154175+10

Nogmaals, alle drie de tijdwaarden zijn identiek, hoewel de pg_sleep() functie werd gebruikt om de uitvoering te vertragen tussen elke aanroep naar transaction_timestamp() .

Dit in tegenstelling tot statement_timestamp() , wat doet veranderen met elke instructie, en ook de clock_timestamp() functie, die verandert zelfs als het door elke instructie gaat (indien meerdere keren aangeroepen binnen de instructie).