🚀 Nuova versione beta disponibile! Feedback o problemi? Contattaci

Esercizi Creazione Tabelle MySQL C++

Codegrind Team•Jul 12 2024

Ecco degli esercizi semplici con soluzione per praticare la creazione di tabelle in MySQL utilizzando C++ sia in modo sequenziale che OOP.

Esercizio 1: Creazione di una tabella in MySQL usando la libreria MySQL Connector/C++ (metodo sequenziale)

Stabilire una connessione a MySQL e creare una tabella. 
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <iostream>

int main() {
    sql::mysql::MySQL_Driver* driver = sql::mysql::get_mysql_driver_instance();
    sql::Connection* con = driver->connect("tcp://127.0.0.1:3306", "root", "password");
    con->setSchema("test_db");

    sql::Statement* stmt = con->createStatement();
    stmt->execute("CREATE TABLE IF NOT EXISTS esempio (id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(255))");
    std::cout << "Tabella creata: esempio" << std::endl;

    delete stmt;
    delete con;
    return 0;
}

Esercizio 2: Creazione di una tabella in MySQL usando la libreria MySQL Connector/C++ (OOP)

Creare una classe per gestire la connessione a MySQL e creare una tabella. 
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <iostream>

class MySQLClient {
private:
    sql::mysql::MySQL_Driver* driver;
    sql::Connection* con;
public:
    MySQLClient(const std::string& host, const std::string& user, const std::string& pass, const std::string& db) {
        driver = sql::mysql::get_mysql_driver_instance();
        con = driver->connect(host, user, pass);
        con->setSchema(db);
    }

    ~MySQLClient() {
        delete con;
    }

    void creaTabella(const std::string& table_name) {
        sql::Statement* stmt = con->createStatement();
        stmt->execute("CREATE TABLE IF NOT EXISTS " + table_name + " (id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(255))");
        std::cout << "Tabella creata: " << table_name << std::endl;
        delete stmt;
    }
};

int main() {
    MySQLClient client("tcp://127.0.0.1:3306", "root", "password", "test_db");
    client.creaTabella("esempio");
    return 0;
}

Esercizio 3: Creazione di una tabella in MySQL usando la libreria MySQL C API (metodo sequenziale)

Stabilire una connessione a MySQL e creare una tabella usando MySQL C API. 
#include <mysql/mysql.h>
#include <iostream>

int main() {
    MYSQL* conn;
    conn = mysql_init(nullptr);

    if (conn == nullptr) {
        std::cerr << "mysql_init() failed\n";
        return EXIT_FAILURE;
    }

    if (mysql_real_connect(conn, "localhost", "root", "password", "test_db", 0, nullptr, 0) == nullptr) {
        std::cerr << "mysql_real_connect() failed\n";
        mysql_close(conn);
        return EXIT_FAILURE;
    }

    const char* query = "CREATE TABLE IF NOT EXISTS esempio (id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(255))";
    if (mysql_query(conn, query)) {
        std::cerr << "CREATE TABLE failed. Error: " << mysql_error(conn) << std::endl;
        mysql_close(conn);
        return EXIT_FAILURE;
    }

    std::cout << "Tabella creata: esempio" << std::endl;

    mysql_close(conn);
    return EXIT_SUCCESS;
}

Esercizio 4: Creazione di una tabella in MySQL usando la libreria MySQL C API (OOP)

Creare una classe per gestire la connessione a MySQL e creare una tabella usando MySQL C API. 
#include <mysql/mysql.h>
#include <iostream>
#include <stdexcept>

class MySQLClient {
private:
    MYSQL* conn;
public:
    MySQLClient(const std::string& host, const std::string& user, const std::string& pass, const std::string& db) {
        conn = mysql_init(nullptr);
        if (conn == nullptr) {
            throw std::runtime_error("mysql_init() failed");
        }
        if (mysql_real_connect(conn, host.c_str(), user.c_str(), pass.c_str(), db.c_str(), 0, nullptr, 0) == nullptr) {
            mysql_close(conn);
            throw std::runtime_error("mysql_real_connect() failed");
        }
    }

    ~MySQLClient() {
        mysql_close(conn);
    }

    void creaTabella(const std::string& table_name) {
        std::string query = "CREATE TABLE IF NOT EXISTS " + table_name + " (id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(255))";
        if (mysql_query(conn, query.c_str())) {
            throw std::runtime_error("CREATE TABLE failed: " + std::string(mysql_error(conn)));
        }
        std::cout << "Tabella creata: " << table_name << std::endl;
    }
};

int main() {
    try {
        MySQLClient client("localhost", "root", "password", "test_db");
        client.creaTabella("esempio");
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

Esercizio 5: Creazione di una tabella in MySQL usando la libreria SOCI (metodo sequenziale)

Stabilire una connessione a MySQL e creare una tabella usando SOCI. 
#include <soci/soci.h>
#include <soci/mysql/soci-mysql.h>
#include <iostream>

int main() {
    try {
        soci::session sql(soci::mysql, "db=test_db user=root password='password' host=localhost");
        sql << "CREATE TABLE IF NOT EXISTS esempio (id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(255))";
        std::cout << "Tabella creata: esempio" << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 6: Creazione di una tabella in MySQL usando la libreria SOCI (OOP)

Creare una classe per gestire la connessione a MySQL e creare una tabella usando SOCI. 
#include <soci/soci.h>
#include <soci/mysql/soci-mysql.h>
#include <iostream>

class MySQLClient {
private:
    soci::session sql;
public:
    MySQLClient(const std::string& connection_string) : sql(soci::mysql, connection_string) {}

    void creaTabella(const std::string& table_name) {
        sql << "CREATE TABLE IF NOT EXISTS " + table_name + " (id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(255))";
        std::cout << "Tabella creata: " << table_name << std::endl;
    }
};

int main() {
    try {
        MySQLClient client("db=test_db user=root password='password' host=localhost");
        client.creaTabella("esempio");
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 7: Creazione di una tabella con colonne avanzate usando MySQL Connector/C++ (metodo sequenziale)

Stabilire una connessione a MySQL e creare una tabella con colonne avanzate. 


#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <iostream>

int main() {
    sql::mysql::MySQL_Driver* driver = sql::mysql::get_mysql_driver_instance();
    sql::Connection* con = driver->connect("tcp://127.0.0.1:3306", "root", "password");
    con->setSchema("test_db");

    sql::Statement* stmt = con->createStatement();
    stmt->execute("CREATE TABLE IF NOT EXISTS avanzata (id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(255), eta INT, data_nascita DATE)");
    std::cout << "Tabella creata: avanzata" << std::endl;

    delete stmt;
    delete con;
    return 0;
}

Esercizio 8: Creazione di una tabella con colonne avanzate usando MySQL Connector/C++ (OOP)

Creare una classe per gestire la connessione a MySQL e creare una tabella con colonne avanzate. 
#include <mysql_driver.h>
#include <mysql_connection.h>
#include <cppconn/statement.h>
#include <iostream>

class MySQLClient {
private:
    sql::mysql::MySQL_Driver* driver;
    sql::Connection* con;
public:
    MySQLClient(const std::string& host, const std::string& user, const std::string& pass, const std::string& db) {
        driver = sql::mysql::get_mysql_driver_instance();
        con = driver->connect(host, user, pass);
        con->setSchema(db);
    }

    ~MySQLClient() {
        delete con;
    }

    void creaTabella(const std::string& table_name) {
        sql::Statement* stmt = con->createStatement();
        stmt->execute("CREATE TABLE IF NOT EXISTS " + table_name + " (id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(255), eta INT, data_nascita DATE)");
        std::cout << "Tabella creata: " << table_name << std::endl;
        delete stmt;
    }
};

int main() {
    MySQLClient client("tcp://127.0.0.1:3306", "root", "password", "test_db");
    client.creaTabella("avanzata");
    return 0;
}
PrecedenteConnessione a MySQLSuccessivoInserimento di Dati MySQL