sql >> Base de Datos >  >> RDS >> MariaDB

Cómo conectar programas C++ a MariaDB

Hoy anunciamos la disponibilidad general de MariaDB Connector/C++. El lenguaje C++ es conocido por su eficiencia, versatilidad y extensibilidad. De hecho, a menudo se usa en industrias como fintech y juegos, donde las aplicaciones requieren una simultaneidad y una latencia predecibles. Con MariaDB Connector/C++, los desarrolladores pueden usar el nuevo conector dentro de sus aplicaciones para conectarse de forma nativa a MariaDB Server en las instalaciones y en la nube en MariaDB SkySQL.

En este artículo, le presentaré MariaDB Connector/C++ con ejemplos simples que demuestran las interacciones de creación, lectura, actualización y eliminación (CRUD) con datos almacenados en MariaDB. Más específicamente, voy a explicar el proceso de creación de una aplicación de consola C++ que le permitirá realizar operaciones simples para administrar tareas. Pero basta de hablar, ¡comencemos!

Descarga e instalación

Para utilizar MariaDB Connector/C++, debe tener acceso a una instancia de MariaDB Server. Hay una variedad de formas en que puede comenzar con MariaDB en su máquina local, en las instalaciones o incluso en la nube.

  1. Descargue e instale el servidor comunitario de MariaDB
    1. Directamente
    2. Uso de una imagen de Docker
  2. Descargue e instale MariaDB Enterprise Server 
  3. Implemente con MariaDB SkySQL, la mejor base de datos en la nube de MariaDB

Después de configurar una instancia del servidor MariaDB, puede seguir los pasos proporcionados en la documentación de MariaDB Enterprise para obtener instrucciones sobre cómo descargar e instalar MariaDB Connector/C++.

Preparación del servidor MariaDB

En este ejemplo, antes de poder usar el nuevo conector MariaDB C++, necesitará tener una base de datos y una tabla. Usando un cliente de su elección, conéctese a su instancia de base de datos MariaDB y:

1. Cree una nueva base de datos y una tabla única que se encargará de almacenar los registros de tareas.

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. Cree un nuevo usuario de base de datos que Connector/C++ usará para conectarse a MariaDB.

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

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

Conexión al servidor MariaDB

Ahora que tiene la instancia de la base de datos, el esquema y la configuración del usuario, es hora de saltar a C++. Todo comienza estableciendo una conexión a MariaDB. Por supuesto, para hacer eso, debe haber incluido los archivos de encabezado del conector MariaDB, específicamente conncpp.hpp, en la parte superior del archivo al que está agregando su código C++.

#include <mariadb/conncpp.hpp>

Para establecer una conexión, comience recuperando un Driver objeto que luego se puede usar, en combinación con la información de configuración de Java Database Connectivity (JDBC), para obtener una Connection objeto.

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

Para obtener más información sobre la funcionalidad de conexión de MariaDB Connector/C++, asegúrese de consultar nuestra documentación empresarial oficial.

Agregar tareas

Una vez que haya obtenido una Connection Objeto, ¡te vas a las carreras! Usando conn, de la sección anterior, ahora puede ejecutar SQL mediante el uso de una declaración preparada para insertar datos en 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();

Recuperación de tareas

Usando un enfoque muy similar, como en la última sección, también puede crear una Statement objeto para recuperar e imprimir todos los registros de tareas dentro de la tabla de tareas.

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

Actualización de tareas

También puede usar un PreparedStatement y especificar parámetros (y valores) para localizar y modificar un registro de tarea existente.

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

Eliminar tareas

Y, por supuesto, también tiene la capacidad de eliminar datos de MariaDB usando un DELETE SQL declaración con un PreparedStatement , para apuntar a un registro específico.

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

Reuniéndolo todo

Finalmente, puede poner todo junto en un ejemplo independiente copiando y pegando el código a continuación en un nuevo archivo llamado tasks.cpp . El siguiente ejemplo combina todas las operaciones CRUD que he realizado en una colección de funciones que se pueden ejecutar desde el principal método.

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

También puede encontrar la fuente completa de esta aplicación de muestra aquí. La fuente de este ejemplo de C++ se encuentra dentro de un repositorio para una aplicación llamada "TODO", que también incluye un front-end web y varias otras aplicaciones de muestra de integración del conector MariaDB que abarcan una multitud de idiomas.

Ejecución de la aplicación

Dentro de un entorno Linux, después de haber creado tasks.cpp , puede crear un archivo ejecutable, denominado tareas, mediante un compilador de C++.

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

Con el archivo ejecutable, puede proporcionar varios valores de argumento para probar las operaciones CRUD.

  • Insertar un nuevo registro de tarea proporcionando un valor para la descripción.
./tasks addTask ‘A New Task’
  • Impresión de todos los registros de tareas.
./tasks showTasks
  • Actualizar el valor completado de un registro de tareas. Simplemente proporcione valores para id y complete.
./tasks updateTaskStatus 1 1
  • Elimine un registro de tarea proporcionando un valor de identificación.
./tasks deleteTask 1

Solo el comienzo

Con suerte, disfrutó viendo lo fácil que es comenzar a usar C++ con MariaDB. Si bien esta es una gran introducción a la programación en C++ con MariaDB, ¡solo hemos comenzado a arañar la superficie de lo que es posible!

¿Busca profundizar en MariaDB Connector/C++? Asegúrese de visitar MariaDB Developer Hub para obtener aún más contenido sobre el nuevo conector C++, así como muchas otras características y capacidades de MariaDB.

Busque la documentación empresarial de MariaDB Connector/C++.