MariaDB
 sql >> Database >  >> RDS >> MariaDB

Come collegare i programmi C++ a MariaDB

Oggi abbiamo annunciato la disponibilità generale di MariaDB Connector/C++. Il linguaggio C++ è noto per la sua efficienza, versatilità ed estensibilità. In effetti, viene spesso utilizzato in settori come il fintech e i giochi in cui le applicazioni richiedono simultaneità e latenza prevedibili. Con MariaDB Connector/C++, gli sviluppatori possono utilizzare il nuovo connettore all'interno delle loro applicazioni per connettersi in modo nativo a MariaDB Server on-premise e nel cloud su MariaDB SkySQL.

In questo articolo ti presenterò MariaDB Connector/C++ con semplici esempi che dimostrano le interazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) con i dati archiviati in MariaDB. Più specificamente, illustrerò il processo di creazione di un'applicazione console C++ che consentirà di eseguire semplici operazioni per la gestione delle attività. Ma basta parlare, cominciamo!

Download e installazione

Per utilizzare MariaDB Connector/C++ è necessario avere accesso a un'istanza di MariaDB Server. Esistono diversi modi per iniziare a utilizzare MariaDB sul computer locale, in locale o anche nel cloud.

  1. Scarica e installa MariaDB Community Server
    1. Direttamente
    2. Utilizzo di un'immagine Docker
  2. Scarica e installa MariaDB Enterprise Server 
  3. Esegui il deployment con MariaDB SkySQL, il database cloud MariaDB definitivo

Dopo aver configurato un'istanza MariaDB Server, puoi seguire i passaggi forniti nella documentazione di MariaDB Enterprise per istruzioni su come scaricare e installare MariaDB Connector/C++.

Preparazione del server MariaDB

In questo esempio, prima di poter utilizzare il nuovo connettore C++ MariaDB, dovrai disporre di un database e di una tabella. Utilizzando un client di tua scelta, connettiti alla tua istanza del database MariaDB e:

1. Crea un nuovo database e una singola tabella che sarà responsabile della memorizzazione dei record delle attività.

CREATE DATABASE IF NOT EXISTS todo;

CREATE TABLE todo.tasks (
  id INT(11) unsigned NOT NULL AUTO_INCREMENT,
  description VARCHAR(500) NOT NULL,
  completed BOOLEAN NOT NULL DEFAULT 0,
  PRIMARY KEY (id)
);

2. Crea un nuovo utente del database che Connector/C++ utilizzerà per connettersi a MariaDB.

CREATE USER IF NOT EXISTS app_user@localhost IDENTIFIED BY 
 'Password123!';

GRANT ALL PRIVILEGES ON todo.* TO app_user@localhost;

Connessione al server MariaDB

Ora che hai configurato l'istanza del database, lo schema e l'utente, è il momento di passare a C++. Tutto inizia stabilendo una connessione a MariaDB. Ovviamente, per farlo, devi aver incluso i file di intestazione del connettore MariaDB, in particolare conncpp.hpp, nella parte superiore del file a cui stai aggiungendo il codice C++.

#include <mariadb/conncpp.hpp>

Per stabilire una connessione, inizia recuperando un Driver oggetto che può quindi essere utilizzato, in combinazione con le informazioni di configurazione di Java Database Connectivity (JDBC), per ottenere una Connection oggetto.

// Instantiate Driver
sql::Driver* driver = sql::mariadb::get_driver_instance();

// Configure Connection
sql::SQLString url("jdbc:mariadb://localhost:3306/todo");
sql::Properties properties({{"user", "app_user"}, {"password", "Password123!"}});

// Establish Connection
std::unique_ptr<sql::Connection> conn(driver->connect(url, properties));

Per ulteriori informazioni sulla funzionalità di connessione di MariaDB Connector/C++, assicurati di consultare la nostra documentazione aziendale ufficiale.

Aggiunta di attività

Una volta ottenuta una Connection oggetto, vai alle gare! Usando conn, dalla sezione precedente, ora sei in grado di eseguire SQL attraverso l'uso di un'istruzione preparata per inserire dati in MariaDB.

// Create a new PreparedStatement
std::unique_ptr<sql::PreparedStatement> stmnt(conn->prepareStatement("insert into tasks (description) values (?)"));

// Bind values to SQL statement
stmnt->setString(1, description);

// Execute query
stmnt->executeQuery();

Recupero delle attività

Usando un approccio molto simile, come nell'ultima sezione, puoi anche creare una Statement oggetto per recuperare e stampare tutti i record delle attività all'interno della tabella delle attività.

// Create a new Statement
std::unique_ptr stmnt(conn->createStatement());

// Execute query
sql::ResultSet *res = stmnt->executeQuery("select * from tasks");

// Loop through and print results
while (res->next()) {
       std::cout << "id = " << res->getInt(1);
       std::cout << ", description = " << res->getString(2);
       std::cout << ", completed = " << res->getBoolean(3) << "\n";
}

Aggiornamento delle attività

Puoi anche utilizzare un PreparedStatement e specificando parametri (e valori) per individuare e modificare un record di attività esistente.

// Create a new PreparedStatement
std::unique_ptr stmnt(conn->prepareStatement("update tasks set completed = ? where id = ?"));

// Bind values to SQL statement
stmnt->setBoolean(1, completed);
stmnt->setInt(2, id);

// Execute query
stmnt->executeQuery();

Eliminazione delle attività

E, naturalmente, hai anche la possibilità di rimuovere i dati da MariaDB usando un DELETE SQL istruzione con un PreparedStatement , per scegliere come target un record specifico.

// Create a new PreparedStatement
std::unique_ptr stmnt(conn->prepareStatement("delete from tasks where id = ?"));

// Bind values to SQL statement
stmnt->setInt(1, id);

// Execute query
stmnt->executeQuery();

Unendo tutto

Infine, puoi mettere tutto insieme in un esempio autonomo copiando e incollando il codice seguente in un nuovo file chiamato tasks.cpp . L'esempio seguente combina tutte le operazioni CRUD che ho eseguito in una raccolta di funzioni che possono essere eseguite dal principale metodo.

#include <iostream> 
#include <cstring>
#include <mariadb/conncpp.hpp>

// Delete a task record (indicated by id)
void deleteTask(std::unique_ptr &conn, int id) {
    try {
        // Create a new PreparedStatement
        std::unique_ptr stmnt(conn->prepareStatement("delete from tasks where id = ?"));
        // Bind values to SQL statement
        stmnt->setInt(1, id);
        // Execute query
        stmnt->executeQuery();
    }
    catch(sql::SQLException& e){
      std::cerr << "Error deleting task: " << e.what() << std::endl;
   }
}

// Update the completed value of a task record (indicated by id)
void updateTaskStatus(std::unique_ptr &conn, int id, bool completed) {
    try {
        // Create a new PreparedStatement
        std::unique_ptr stmnt(conn->prepareStatement("update tasks set completed = ? where id = ?"));
        // Bind values to SQL statement
        stmnt->setBoolean(1, completed);
        stmnt->setInt(2, id);
        // Execute query
        stmnt->executeQuery();
    }
    catch(sql::SQLException& e){
      std::cerr << "Error updating task status: " << e.what() << std::endl;
   }
}

// Create a new task record
void addTask(std::unique_ptr &conn, std::string description) {
    try {
        // Create a new PreparedStatement
        std::unique_ptr stmnt(conn->prepareStatement("insert into tasks (description) values (?)"));
        // Bind values to SQL statement
        stmnt->setString(1, description);
        // Execute query
        stmnt->executeQuery();
    }
    catch(sql::SQLException& e){
      std::cerr << "Error inserting new task: " << e.what() << std::endl;
   }
}

// Print all records in tasks table 
void showTasks(std::unique_ptr &conn) {
    try {
        // Create a new Statement
        std::unique_ptr stmnt(conn->createStatement());
        // Execute query
        sql::ResultSet *res = stmnt->executeQuery("select * from tasks");
        // Loop through and print results
        while (res->next()) {
            std::cout << "id = " << res->getInt(1);
            std::cout << ", description = " << res->getString(2);
            std::cout << ", completed = " << res->getBoolean(3) << "\n";
        }
    }
    catch(sql::SQLException& e){
      std::cerr << "Error selecting tasks: " << e.what() << std::endl;
   }
}

// Main Process
int main(int argc, char **argv){
    if (argc==1){
        std::cout << "Please provide an argument.\n";
    }
    else {
        try {
            // Instantiate Driver
            sql::Driver* driver = sql::mariadb::get_driver_instance();

            // Configure Connection
            sql::SQLString url("jdbc:mariadb://localhost:3306/todo");
            sql::Properties properties({{"user", "app_user"}, {"password", "Password123!"}});

            // Establish Connection
            std::unique_ptr conn(driver->connect(url, properties));

            // Use arguments to determine execution next steps
            if (!strcmp(argv[1],"showTasks")) {
                showTasks(conn);
            }
            else if (!strcmp(argv[1],"addTask")) {
                if (argc != 3) {
                    std::cout << "Invalid arguments";
                    return 1;
                }
                addTask(conn, argv[2]);
            }
            else if (!strcmp(argv[1],"updateTaskStatus")) {
                if (argc != 4) {
                    std::cout << "Invalid arguments";
                    return 1;
                }
                updateTaskStatus(conn, atoi(argv[2]), argv[3]);
            }
            else if (!strcmp(argv[1],"deleteTask")) {
                if (argc != 3) {
                    std::cout << "Invalid arguments"; return 1; } deleteTask(conn, atoi(argv[2])); } // Close Connection conn->close();
        }
        catch(sql::SQLException& e){
            std::cerr << "Error Connecting to MariaDB Platform: " << e.what() << std::endl;
            // Exit (Failed)
            return 1;
        }
    }

    // Exit (Success)
    return 0;
}

Puoi anche trovare la fonte completa di questa applicazione di esempio qui. L'origine di questo esempio C++ è contenuta in un repository per un'applicazione chiamata "TODO", che include anche un front-end Web e molte altre applicazioni di esempio di integrazione del connettore MariaDB che coprono una moltitudine di linguaggi.

Esecuzione dell'applicazione

All'interno di un ambiente Linux, dopo aver creato tasks.cpp , puoi creare un file eseguibile, chiamato task, usando un compilatore C++.

$ g++ -o tasks tasks.cpp -std=c++11 -lmariadbcpp

Usando il file eseguibile puoi fornire vari valori di argomento per testare le operazioni CRUD.

  • Inserimento di un nuovo record di attività fornendo un valore per la descrizione.
./tasks addTask ‘A New Task’
  • Stampa tutti i record delle attività.
./tasks showTasks
  • Aggiornamento del valore completato di un record di attività. Fornisci semplicemente i valori per id e completato.
./tasks updateTaskStatus 1 1
  • Elimina un record di attività fornendo un valore id.
./tasks deleteTask 1

Solo l'inizio

Si spera che ti sia piaciuto vedere quanto è facile iniziare a usare C++ con MariaDB. Sebbene questa sia un'ottima introduzione alla programmazione C++ con MariaDB, abbiamo solo iniziato a grattare la superficie di ciò che è possibile!

Stai cercando di approfondire MariaDB Connector/C++? Assicurati di controllare MariaDB Developer Hub per ulteriori contenuti sul nuovo connettore C++ e molte altre caratteristiche e capacità di MariaDB.

Trova la documentazione aziendale di MariaDB Connector/C++.