📢 Nuovo Corso Bootstrap Completo disponibile!
Home esercizi cpp transazioni mysql

Esercizi Transazioni MySQL C++

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;
}
Corso Python Completo
principianti

Corso Python Completo

Corso da zero per imparare a programmare in linguaggio Python. dai fondamentali fino ai Database ed il suo ecosistema.

24,99 €