sql >> Database >  >> RDS >> MariaDB

C++-programma's verbinden met MariaDB

Vandaag hebben we de algemene beschikbaarheid van MariaDB Connector/C++ aangekondigd. De C++-taal staat bekend om zijn efficiëntie, veelzijdigheid en uitbreidbaarheid. Het wordt zelfs vaak gebruikt in sectoren zoals fintech en gaming, waar toepassingen voorspelbare gelijktijdigheid en latentie vereisen. Met MariaDB Connector/C++ kunnen ontwikkelaars de nieuwe connector binnen hun applicaties gebruiken om native verbinding te maken met MariaDB Server op locatie en in de cloud op MariaDB SkySQL.

In dit artikel zal ik u kennis laten maken met MariaDB Connector/C++ met eenvoudige voorbeelden die interacties van maken, lezen, bijwerken en verwijderen (CRUD) demonstreren met gegevens die zijn opgeslagen in MariaDB. Meer specifiek ga ik door het proces lopen van het maken van een C++-consoletoepassing waarmee u eenvoudige bewerkingen kunt uitvoeren voor het beheren van taken. Maar genoeg gepraat, laten we beginnen!

Downloaden en installeren

Om MariaDB Connector/C++ te gebruiken, moet u toegang hebben tot een instantie van MariaDB Server. Er zijn verschillende manieren om met MariaDB aan de slag te gaan op uw lokale computer, on-premises of zelfs in de cloud.

  1. Download en installeer MariaDB Community Server
    1. Direct
    2. Een Docker-afbeelding gebruiken
  2. Download en installeer MariaDB Enterprise Server 
  3. Implementeer met MariaDB SkySQL, de ultieme MariaDB-clouddatabase

Nadat u een MariaDB Server-instantie heeft ingesteld, kunt u de stappen in de MariaDB Enterprise-documentatie volgen voor instructies over het downloaden en installeren van MariaDB Connector/C++.

MariaDB-server voorbereiden

In dit voorbeeld heeft u, voordat u de nieuwe MariaDB C++-connector kunt gebruiken, een database en tabel nodig. Gebruik een client naar keuze om verbinding te maken met uw MariaDB-database-instantie en:

1. Maak een nieuwe database en een enkele tabel die verantwoordelijk is voor het opslaan van de taakrecords.

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. Maak een nieuwe databasegebruiker aan die Connector/C++ zal gebruiken om verbinding te maken met MariaDB.

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

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

Verbinding maken met MariaDB Server

Nu u uw database-instantie, schema en gebruiker hebt ingesteld, is het tijd om in C++ te springen. Het begint allemaal met het tot stand brengen van een verbinding met MariaDB. Om dat te doen, moet u natuurlijk de headerbestanden van de MariaDB-connector hebben opgenomen, met name conncpp.hpp, bovenaan het bestand waaraan u uw C++-code toevoegt.

#include <mariadb/conncpp.hpp>

Om een ​​verbinding tot stand te brengen, begint u met het ophalen van een Driver object dat vervolgens kan worden gebruikt, in combinatie met Java Database Connectivity (JDBC) configuratie-informatie, om een ​​Connection te verkrijgen voorwerp.

// 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));

Raadpleeg onze officiële bedrijfsdocumentatie voor meer informatie over de verbindingsfunctionaliteit van MariaDB's Connector/C++.

Taken toevoegen

Zodra je een Connection hebt verkregen object, je gaat naar de races! Met behulp van conn, uit de vorige sectie, kunt u nu SQL uitvoeren door een voorbereide instructie te gebruiken om gegevens in MariaDB in te voegen.

// 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();
. uit

Taken ophalen

Met een zeer vergelijkbare aanpak, zoals in de laatste sectie, kunt u ook een Statement . maken object om alle taakrecords in de takentabel op te halen en af ​​te drukken.

// 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";
}

Taken bijwerken

U kunt ook een PreparedStatement . gebruiken en specificeren van parameters (en waarden) om een ​​bestaand taakrecord te lokaliseren en te wijzigen.

// 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();
uit

Taken verwijderen

En natuurlijk heb je ook de mogelijkheid om gegevens uit MariaDB te verwijderen met behulp van een DELETE SQL statement met een PreparedStatement , om een ​​specifiek record te targeten.

// 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();

Alles samenbrengen

Ten slotte kunt u alles samenvoegen in één op zichzelf staand voorbeeld door de onderstaande code te kopiëren en te plakken in een nieuw bestand met de naam tasks.cpp . Het onderstaande voorbeeld combineert alle CRUD-bewerkingen die ik heb doorlopen in een verzameling functies die kunnen worden uitgevoerd vanuit het hoofd methode.

#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;
}

U kunt hier ook de volledige bron van deze voorbeeldtoepassing vinden. De bron voor dit C++-voorbeeld bevindt zich in een repository voor een toepassing genaamd "TODO", die ook een web-front-end en verschillende andere voorbeeldtoepassingen voor MariaDB-connectorintegratie bevat die een groot aantal talen omvatten.

De toepassing uitvoeren

Binnen een Linux-omgeving, nadat u tasks.cpp . heeft gemaakt , kunt u een uitvoerbaar bestand maken, genaamd taken, met behulp van een C++-compiler.

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

Met behulp van het uitvoerbare bestand kunt u verschillende argumentwaarden opgeven om de CRUD-bewerkingen te testen.

  • Een nieuw taakrecord invoegen door een waarde voor beschrijving op te geven.
./tasks addTask ‘A New Task’
  • Alle taakrecords afdrukken.
./tasks showTasks
  • De voltooide waarde van een taakrecord bijwerken. Geef eenvoudig waarden op voor id en voltooid.
./tasks updateTaskStatus 1 1
  • Verwijder een taakrecord door een id-waarde op te geven.
./tasks deleteTask 1

Nog maar het begin

Hopelijk vond je het leuk om te zien hoe gemakkelijk het is om aan de slag te gaan met C++ met MariaDB. Hoewel dit een geweldige introductie is tot programmeren in C++ met MariaDB, zijn we nog maar net begonnen met het ontdekken van wat mogelijk is!

Wil je dieper in MariaDB Connector/C++ duiken? Bekijk zeker de MariaDB Developer Hub voor nog meer inhoud over de nieuwe C++-connector en vele andere MariaDB-functies en -mogelijkheden.

Vind de MariaDB Connector/C++ bedrijfsdocumentatie.


  1. Hoe te bestellen op datum in PostgreSQL of Oracle

  2. SQLite - Gegevens verwijderen

  3. Wat zijn enkele manieren om toegang te krijgen tot Microsoft SQL Server vanuit Linux?

  4. ODBC gebruiken met Salesforce en OneLogin Single Sign On (SSO)