Esercizi Transazioni MySQL C++
Codegrind Team•Jul 12 2024
Ecco degli esercizi con soluzione per praticare l’utilizzo delle transazioni in MySQL utilizzando C++.
Esercizio 1: Inizio e fine di una transazione
Creare un programma che avvia una transazione, esegue un'operazione di inserimento e poi effettua un commit.
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <cppconn/exception.h>
#include <iostream>
int main() {
try {
sql::mysql::MySQL_Driver* driver = sql::mysql::get_mysql_driver_instance();
std::unique_ptr<sql::Connection> con(driver->connect("tcp://127.0.0.1:3306", "root", "password"));
con->setSchema("test_db");
con->setAutoCommit(false);
std::unique_ptr<sql::Statement> stmt(con->createStatement());
stmt->execute("INSERT INTO test_table (name, age) VALUES ('Alice', 30)");
con->commit();
std::cout << "Transazione completata con successo" << std::endl;
} catch (sql::SQLException& e) {
std::cerr << "Errore SQL: " << e.what() << std::endl;
}
return 0;
}
Esercizio 2: Transazione con rollback
Creare un programma che avvia una transazione, esegue un'operazione di inserimento e poi effettua un rollback in caso di errore.
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <cppconn/exception.h>
#include <iostream>
int main() {
try {
sql::mysql::MySQL_Driver* driver = sql::mysql::get_mysql_driver_instance();
std::unique_ptr<sql::Connection> con(driver->connect("tcp://127.0.0.1:3306", "root", "password"));
con->setSchema("test_db");
con->setAutoCommit(false);
std::unique_ptr<sql::Statement> stmt(con->createStatement());
stmt->execute("INSERT INTO test_table (name, age) VALUES ('Bob', 25)");
throw std::runtime_error("Errore simulato");
con->commit();
std::cout << "Transazione completata con successo" << std::endl;
} catch (const std::exception& e) {
std::cerr << "Errore: " << e.what() << std::endl;
try {
std::unique_ptr<sql::Connection> con(driver->connect("tcp://127.0.0.1:3306", "root", "password"));
con->rollback();
std::cout << "Transazione annullata" << std::endl;
} catch (sql::SQLException& e) {
std::cerr << "Errore SQL durante il rollback: " << e.what() << std::endl;
}
}
return 0;
}
Esercizio 3: Transazione con più operazioni
Creare un programma che avvia una transazione, esegue più operazioni (inserimento, aggiornamento) e poi effettua un commit.
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <cppconn/exception.h>
#include <iostream>
int main() {
try {
sql::mysql::MySQL_Driver* driver = sql::mysql::get_mysql_driver_instance();
std::unique_ptr<sql::Connection> con(driver->connect("tcp://127.0.0.1:3306", "root", "password"));
con->setSchema("test_db");
con->setAutoCommit(false);
std::unique_ptr<sql::Statement> stmt(con->createStatement());
stmt->execute("INSERT INTO test_table (name, age) VALUES ('Charlie', 35)");
stmt->execute("UPDATE test_table SET age = 36 WHERE name = 'Charlie'");
con->commit();
std::cout << "Transazione completata con successo" << std::endl;
} catch (sql::SQLException& e) {
std::cerr << "Errore SQL: " << e.what() << std::endl;
try {
con->rollback();
std::cout << "Transazione annullata" << std::endl;
} catch (sql::SQLException& e) {
std::cerr << "Errore SQL durante il rollback: " << e.what() << std::endl;
}
}
return 0;
}
Esercizio 4: Transazione con controllo degli errori
Creare un programma che avvia una transazione, esegue più operazioni e gestisce gli errori per decidere se effettuare commit o rollback.
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <cppconn/exception.h>
#include <iostream>
int main() {
try {
sql::mysql::MySQL_Driver* driver = sql::mysql::get_mysql_driver_instance();
std::unique_ptr<sql::Connection> con(driver->connect("tcp://127.0.0.1:3306", "root", "password"));
con->setSchema("test_db");
con->setAutoCommit(false);
std::unique_ptr<sql::Statement> stmt(con->createStatement());
stmt->execute("INSERT INTO test_table (name, age) VALUES ('Dave', 40)");
stmt->execute("UPDATE test_table SET age = 41 WHERE name = 'Dave'");
// Simuliamo un errore
if (true) {
throw std::runtime_error("Errore simulato durante la transazione");
}
con->commit();
std::cout << "Transazione completata con successo" << std::endl;
} catch (const std::exception& e) {
std::cerr << "Errore: " << e.what() << std::endl;
try {
con->rollback();
std::cout << "Transazione annullata" << std::endl;
} catch (sql::SQLException& e) {
std::cerr << "Errore SQL durante il rollback: " << e.what() << std::endl;
}
}
return 0;
}
Esercizio 5: Transazione annidata
Creare un programma che avvia una transazione annidata e gestisce commit e rollback per le transazioni interne.
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <cppconn/exception.h>
#include <iostream>
int main() {
try {
sql::mysql::MySQL_Driver* driver = sql::mysql::get_mysql_driver_instance();
std::unique_ptr<sql::Connection> con(driver->connect("tcp://127.0.0.1:3306", "root", "password"));
con->setSchema("test_db");
con->setAutoCommit(false);
std::unique_ptr<sql::Statement> stmt(con->createStatement());
stmt->execute("SAVEPOINT sp1");
stmt->execute("INSERT INTO test_table (name, age) VALUES ('Eve', 45)");
try {
stmt->execute("SAVEPOINT sp2");
stmt->execute("INSERT INTO test_table (name, age) VALUES ('Frank', 50)");
throw std::runtime_error("Errore simulato nella transazione annidata");
stmt->execute("RELEASE SAVEPOINT sp2");
} catch (const std::exception& e) {
std::cerr << "Errore interno: " << e.what() << std::endl;
stmt->execute("ROLLBACK TO SAVEPOINT sp2");
}
con->commit();
std::cout << "Transazione completata con successo" << std::endl;
} catch (const std::exception& e) {
std::cerr << "Errore: " << e.what() << std::endl;
try {
con->rollback();
std::cout << "Transazione annullata" << std::endl;
} catch (sql::SQLException& e) {
std::cerr << "Errore SQL durante il rollback
: " << e.what() << std::endl;
}
}
return 0;
}
Esercizio 6: Transazione con gestione esplicita delle connessioni
Creare un programma che gestisce esplicitamente le connessioni a MySQL e utilizza le transazioni per garantire l'integrità dei dati.
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <cppconn/exception.h>
#include <iostream>
void executeTransaction(sql::Connection* con) {
try {
con->setAutoCommit(false);
std::unique_ptr<sql::Statement> stmt(con->createStatement());
stmt->execute("INSERT INTO test_table (name, age) VALUES ('George', 55)");
stmt->execute("INSERT INTO test_table (name, age) VALUES ('Hannah', 60)");
con->commit();
std::cout << "Transazione completata con successo" << std::endl;
} catch (sql::SQLException& e) {
std::cerr << "Errore SQL: " << e.what() << std::endl;
try {
con->rollback();
std::cout << "Transazione annullata" << std::endl;
} catch (sql::SQLException& e) {
std::cerr << "Errore SQL durante il rollback: " << e.what() << std::endl;
}
}
}
int main() {
try {
sql::mysql::MySQL_Driver* driver = sql::mysql::get_mysql_driver_instance();
std::unique_ptr<sql::Connection> con(driver->connect("tcp://127.0.0.1:3306", "root", "password"));
con->setSchema("test_db");
executeTransaction(con.get());
} catch (sql::SQLException& e) {
std::cerr << "Errore SQL durante la connessione: " << e.what() << std::endl;
}
return 0;
}