pqxx wiederverwenden/reaktivieren eine Arbeit Transaktion

Question

Ich möchte ein pqxx :: arbeiten für mehrere Abfragen und Verpflichtungen, während die commit Funktion verhindern, dass ich es wieder verwenden. Hier ist ein einfaches Beispiel:

pqxx::connection G_connexion("dbname=basetest user=usertest password=1234"); 
pqxx::work G_work(G_connexion); 

int main(int argc, char* argv[]) { 
    G_work.exec("insert into test.table1(nom) VALUES('foo');"); 
    G_work.commit();//until here, no problem 
    G_work.exec("insert into test.table1(nom) VALUES('bar');"); //error, transaction already closed 
    G_work.commit(); 
} 

Wenn ich versuche, den ‚Bar‘ Wert einfügen, nach dem Commit, erhalte ich ein pqxx :: usage_error: Error executing query . Attempt to activate transaction<READ COMMITTED> which is already closed

Wie kann ich vermeiden, dass die Verbindung schließen nachdem ich die Änderungen vorgenommen habe? Kann ich G_work mit einem folgenden Äquivalent von G_work = pqxx :: work (G_connexion) zurücksetzen? Außerdem sollte eine ungültige Anforderung nicht den gesamten Prozess abstürzen lassen, sondern nur den in Bearbeitung befindlichen (G_work kann nach einem Fehler weiterhin verwendet werden).

Ich muss die gleiche Variable G_Work behalten, weil es eine globale Variable sein wird, die von vielen Stellen im Programm aufgerufen wird.

Answer 1

pqxx::work ist nur eine pqxx::transaction<>, die schließlich die meisten ihrer Logik von pqxx::transaction_base bekommt.

Diese Klasse ist nicht für mehrere Transaktionen vorgesehen. Stattdessen ist es für eine einzelne Transaktion innerhalb eines try/catch-Blocks vorgesehen. Es hat eine Statuselementvariable (m_Status), die selbst nach einem Commit nie neu initialisiert wird.

Das normale Muster:

{ 
    pqxx::work l_work(G_connexion); 
    try { 
     l_work.exec("insert into test.table1(nom) VALUES('foo');"); 
     l_work.commit(); 
    } catch (const exception& e) { 
     l_work.abort(); 
     throw; 
    } 
} 

Argumentieren, libpqxx die Transaktion beim Löschen Rollback könnte (die versuchen zu vermeiden/fangen ganz), aber es funktioniert nicht.

Es scheint, dass dies nicht Ihrem Verwendungsmuster entspricht, da Sie G_work eine globale Variable sein möchten, die von mehreren Stellen in Ihrem Programm zugänglich ist. Bitte beachten Sie, dass pqxx :: work nicht die Klasse für Verbindungsobjekte ist, sondern nur eine Möglichkeit, um begin/commit/rollback mit C++ - Ausnahmen zu kapseln.

Dennoch ermöglicht es libpqxx auch, Anweisungen außerhalb von Transaktionen auszuführen (oder zumindest außerhalb von von libpqxx verwalteten Transaktionen). Sie sollten Instanzen der Klasse pqxx::nontransaction verwenden.

#include "pqxx/nontransaction" 

pqxx::connection G_connexion("dbname=basetest user=usertest password=1234"); 
pqxx::nontransaction G_work(G_connexion); 

int f() { 
    G_work.exec("insert into test.table1(nom) VALUES('foo');"); 
    G_work.exec("insert into test.table1(nom) VALUES('bar');"); 
} 

Bitte beachten Sie, dass dies entspricht:

#include "pqxx/nontransaction" 

pqxx::connection G_connexion("dbname=basetest user=usertest password=1234"); 

int f() { 
    pqxx::nontransaction l_work(G_connexion); 
    l_work.exec("insert into test.table1(nom) VALUES('foo');"); 
    l_work.exec("insert into test.table1(nom) VALUES('bar');"); 
} 

Schließlich nichts hindert Sie Transaktionen mit pqxx::nontransaction zu verwalten. Dies gilt insbesondere, wenn Sie savepoints möchten. Ich würde auch empfehlen, pqxx::nontransaction zu verwenden, wenn Ihre Transaktion über einen Funktionsumfang hinaus dauern soll (z. B. im globalen Gültigkeitsbereich).

#include "pqxx/nontransaction" 

pqxx::connection G_connexion("dbname=basetest user=usertest password=1234"); 
pqxx::nontransaction G_work(G_connexion); 

int f() { 
    G_work.exec("begin;"); 
    G_work.exec("insert into test.table1(nom) VALUES('foo');"); 
    G_work.exec("savepoint f_savepoint;"); 
    // If the statement fails, rollback to checkpoint. 
    try { 
     G_work.exec("insert into test.table1(nom) VALUES('bar');"); 
    } catch (const pqxx::sql_error& e) { 
     G_work.exec("rollback to savepoint f_savepoint;"); 
    } 
    G_work.exec("commit;"); 
}