Tutorial de Python y MariaDB: Conexión, CRUD, Transacciones y Manejo de Errores

1. Introducción

Para quienes desean trabajar con MariaDB en Python

Muchas personas quieren conectarse a MariaDB usando Python y manipular datos. En este artículo explicaremos todo, desde los conceptos básicos hasta temas más avanzados para trabajar con MariaDB usando Python.

¿Tienes alguno de estos problemas?

• No sabes cómo conectarte a MariaDB desde Python
• Quieres crear, leer, actualizar y eliminar datos en MariaDB de forma sencilla usando Python
• Deseas conocer los errores más comunes y cómo solucionarlos

Qué aprenderás en este artículo

• Cómo conectarte fácilmente a MariaDB desde Python
• Cómo implementar CRUD (Crear, Leer, Actualizar, Eliminar)
• Errores comunes y sus soluciones
• Cómo proteger la integridad de los datos con transacciones

Después de leer este artículo, podrás trabajar sin problemas con MariaDB usando Python. Ahora, profundicemos en los detalles.

2. Configuración del entorno (Instalación de MariaDB y Python)

¿Qué es MariaDB?

MariaDB es un sistema de gestión de bases de datos relacional (RDBMS) de código abierto que se utiliza ampliamente como sucesor de MySQL. Mientras mantiene alta compatibilidad con MySQL, MariaDB ha mejorado el rendimiento y añadido nuevas funcionalidades.

Herramientas requeridas

Para trabajar con MariaDB en Python, necesitas preparar las siguientes herramientas:

• Python (versión 3.x o posterior recomendada)
• MariaDB (servidor)
• Conector Python para MariaDB (la biblioteca mariadb)

Cómo instalar MariaDB (por SO)

Para Windows

1. Descarga el instalador de MariaDB desde el sitio oficial .
2. Ejecuta el instalador y sigue las instrucciones para completar la instalación.
3. Después de la instalación, verifica que MariaDB funciona ejecutando el siguiente comando:

   mysql -u root -p
   

4. Si puedes iniciar sesión correctamente, la instalación ha finalizado.

Para Mac

En Mac, puedes instalar MariaDB fácilmente usando Homebrew.

1. Si Homebrew no está instalado, instálalo con el siguiente comando:

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
   

2. Instala MariaDB:

   brew install mariadb
   

3. Inicia MariaDB:

   brew services start mariadb
   

4. Verifica la instalación:

   mysql -u root -p
   

Para Linux (Ubuntu)

1. Actualiza la lista de paquetes e instala MariaDB:

   sudo apt update
   sudo apt install mariadb-server mariadb-client
   

2. Inicia MariaDB:

   sudo systemctl start mariadb
   

3. Habilita MariaDB (inicio automático al arrancar):

   sudo systemctl enable mariadb
   

4. Ejecuta el script de instalación segura:

   sudo mysql_secure_installation
   

Esto te permite establecer la contraseña de root y eliminar configuraciones predeterminadas innecesarias.

Instalación de Python y la biblioteca requerida

Para integrar MariaDB con Python, necesitas instalar la biblioteca mariadb.

1. Instala la biblioteca mariadb usando pip :

   pip install mariadb
   

2. Verifica la instalación:

   import mariadb
   print("The MariaDB library was installed successfully.")
   

Si no ocurre ningún error, la instalación fue exitosa.

Ahora la configuración de tu entorno para usar Python con MariaDB está completa. A continuación, explicaremos cómo conectarte a MariaDB desde Python.

3. Conexión a MariaDB

Cómo conectarse a MariaDB con Python

Importar la biblioteca requerida

Para conectarte a MariaDB, importa la biblioteca Python mariadb.

import mariadb

Código básico para conectar a la base de datos

El siguiente código muestra la forma básica de conectarse a MariaDB usando Python.

import mariadb

# Database connection settings
config = {
    "host": "localhost",   # Hostname of the MariaDB server
    "user": "root",        # MariaDB username
    "password": "password", # MariaDB password
    "database": "sample_db" # Database name to connect to
}

try:
    # Connect to MariaDB
    conn = mariadb.connect(**config)
    print("Connected to MariaDB!")

    # Crear un cursor
    cursor = conn.cursor()

    # Si la conexión tiene éxito, ciérrala
    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Connection error: {e}")

About the arguments of connect()

If the server is remote, specify an IP address or domain name in host.

A secure connection method using environment variables

Hardcoding sensitive information such as passwords directly in your code is a security risk. By using environment variables, you can manage them more safely.

Install python-dotenv

First, install a library to manage environment variables.

pip install python-dotenv

Create a .env file and write your connection settings

Create a .env file in your project folder and add your connection settings like this:

DB_HOST=localhost
DB_USER=root
DB_PASSWORD=password
DB_NAME=sample_db

Load environment variables in your Python script

To load the .env file in a Python script, write the following:

import mariadb
import os
from dotenv import load_dotenv

# Load the .env file
load_dotenv()

config = {
    "host": os.getenv("DB_HOST"),
    "user": os.getenv("DB_USER"),
    "password": os.getenv("DB_PASSWORD"),
    "database": os.getenv("DB_NAME")
}

try:
    conn = mariadb.connect(**config)
    print("Connected securely to MariaDB!")
    conn.close()
except mariadb.Error as e:
    print(f"Connection error: {e}")

Common connection errors and how to fix them

Below are some errors you may encounter when connecting Python to MariaDB, along with their solutions.

Access denied for user 'root'@'localhost'

Error message

mariadb.OperationalError: Access denied for user 'root'@'localhost' (using password: YES)

Causes

• The user’s credentials are incorrect
• MariaDB authentication settings are not configured properly

Solutions

1. Log in to MariaDB and check the user’s privileges.

   mysql -u root -p
   

2. Grant the required privileges to the user.

   GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
   FLUSH PRIVILEGES;
   

3. Try connecting again.

Can't connect to MySQL server on 'localhost'

Error message

mariadb.OperationalError: Can't connect to MySQL server on 'localhost' (10061)

Causes

• The MariaDB server is not running
• The host setting is incorrect

Solutions

1. Check whether the server is running.

   sudo systemctl status mariadb
   

2. If the server is stopped, start it.

   sudo systemctl start mariadb
   

3. Check that the host setting is correct.

Summary

In this section, we explained how to connect to MariaDB from Python.

• Basic connection method using mariadb.connect()
• A secure connection method using a .env file
• Common connection errors and how to fix them

4. Creating Databases and Tables

Creating a database

In MariaDB, you need to create a database to store data. Let’s look at how to create a database using Python.

Create a database using a MariaDB management tool

You can create a database using the MariaDB command line (or GUI tools such as MySQL Workbench).

CREATE DATABASE sample_db;

To view the list of databases you created, use the following command:

SHOW DATABASES;

Create a database using Python

To create a database using Python, run the following code:

import mariadb

# Database connection (no database specified)
config = {
    "host": "localhost",
    "user": "root",
    "password": "password"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Crear la base de datos
    cursor.execute("CREATE DATABASE IF NOT EXISTS sample_db")

    print("Created database 'sample_db'.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Error ocurrido: {e}")

By adding IF NOT EXISTS, you can prevent errors if a database with the same name already exists.

Creating a table

After creating the database, the next step is to create a table to store data.

Basic table structure

A table typically has a structure like the following:

Create a table with SQL

If you create a table using MariaDB SQL commands, write the following:

USE sample_db;

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

To view the list of tables, run:

SHOW TABLES;

Create a table using Python

Here is how to create the same table using a Python script.

import mariadb

# Conexión a la base de datos
config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Consulta SQL para creación de tabla
    table_creation_query = """
    CREATE TABLE IF NOT EXISTS users (
        id INT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(100) NOT NULL,
        email VARCHAR(100) UNIQUE NOT NULL,
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
    )
    """

    cursor.execute(table_creation_query)
    print("Tabla 'users' creada.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Error ocurrido: {e}")

By adding IF NOT EXISTS, you can prevent errors if the table already exists.

How to choose data types

When designing tables, it is important to choose appropriate data types. Below is a summary of commonly used data types in MariaDB.

For example, it is common to use VARCHAR(100) for the name field, but if you need a longer string, TEXT can be a good option.

How to check and drop existing tables

Check existing tables

To check the tables in a database, use the following SQL:

SHOW TABLES;

To view a table’s detailed structure, run the DESCRIBE command:

DESCRIBE users;

Drop a table

To drop a table, use DROP TABLE:

DROP TABLE users;

To drop a table from Python, run the following code:

cursor.execute("DROP TABLE IF EXISTS users")

Summary

In this section, we explained how to create databases and tables in MariaDB to store data.

• How to create a database in MariaDB
• How to create a table using Python
• How to choose appropriate data types
• How to check and drop existing tables

Now the basic setup for MariaDB is complete. In the next section, we will explain CRUD operations (Create, Read, Update, Delete) in detail.

5. CRUD Operations (Create, Read, Update, Delete)

After creating the MariaDB database and tables, the next step is to perform CRUD operations. CRUD stands for Create, Read, Update, and Delete, which are the basic operations of a database.

In this section, we will explain how to manipulate MariaDB data using Python.

Inserting data (INSERT)

To add a new record to the database, use the INSERT statement.

Insert data using SQL

To insert data using MariaDB SQL, execute the following command:

INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com');

To verify the inserted data, use the SELECT statement:

SELECT * FROM users;

Insert data using Python

To insert data using Python, run the following code:

import mariadb

# Configuración de conexión a la base de datos
config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Insertar datos
    insert_query = "INSERT INTO users (name, email) VALUES (?, ?)"
    data = ("Alice", "alice@example.com")
    cursor.execute(insert_query, data)

    # Guardar cambios
    conn.commit()
    print("¡Datos insertados con éxito!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Ocurrió un error: {e}")

Key points:

• Using ? placeholders helps prevent SQL injection.
• If you do not execute conn.commit() , the data will not be saved to the database.

Retrieving data (SELECT)

To retrieve registered data, use the SELECT statement.

Retrieve data using SQL

To retrieve data using MariaDB SQL:

SELECT * FROM users;

To retrieve data with conditions, use the WHERE clause:

SELECT * FROM users WHERE email = 'alice@example.com';

Retrieve data using Python

To retrieve data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Recuperar datos
    select_query = "SELECT id, name, email FROM users"
    cursor.execute(select_query)

    # Mostrar datos recuperados
    for (id, name, email) in cursor:
        print(f"ID: {id}, Nombre: {name}, Correo: {email}")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Ocurrió un error: {e}")

Key points:

• Execute SQL with cursor.execute(select_query) and retrieve data from the cursor object.
• You can process records one by one using a for loop.

Updating data (UPDATE)

To modify registered data, use the UPDATE statement.

Update data using SQL

To update data using MariaDB SQL, execute:

UPDATE users SET name = 'Alice Smith' WHERE email = 'alice@example.com';

Update data using Python

To update data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Actualizar datos
    update_query = "UPDATE users SET name = ? WHERE email = ?"
    data = ("Alice Smith", "alice@example.com")
    cursor.execute(update_query, data)

    # Guardar cambios
    conn.commit()
    print("¡Datos actualizados con éxito!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Ocurrió un error: {e}")

Deleting data (DELETE)

To remove unnecessary data, use the DELETE statement.

Delete data using SQL

To delete data using MariaDB SQL, execute:

DELETE FROM users WHERE email = 'alice@example.com';

Delete data using Python

To delete data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Eliminar datos
    delete_query = "DELETE FROM users WHERE email = ?"
    data = ("alice@example.com",)
    cursor.execute(delete_query, data)

    # Guardar cambios
    conn.commit()
    print("¡Datos eliminados con éxito!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Ocurrió un error: {e}")

Summary

In this section, we explained how to manipulate MariaDB data using Python.

• Insert data (INSERT)
• Retrieve data (SELECT)
• Update data (UPDATE)
• Delete data (DELETE)

You can now perform basic data operations in MariaDB using Python.

6. Transactions and Rollback (Ensuring Data Integrity)

Al trabajar con una base de datos, es importante usar transacciones para mantener la integridad de los datos.
En particular, la capacidad de restaurar los datos a su estado original (rollback) cuando ocurre un error durante el procesamiento es esencial para mantener la consistencia.

En esta sección, explicaremos cómo gestionar transacciones en MariaDB usando Python.

¿Qué es una transacción?

Una transacción es un mecanismo que agrupa una serie de operaciones de base de datos en una única unidad, confirma todos los cambios si cada proceso tiene éxito y revierte todos los cambios si ocurre un error.

Características de las transacciones

• Propiedades ACID
• Atomicidad : Todas las operaciones se completan con éxito o ninguna se aplica.
• Consistencia : Se mantiene la integridad de los datos.
• Aislamiento : Las transacciones concurrentes no interfieren entre sí.
• Durabilidad : Una vez confirmados, los cambios se guardan permanentemente.

Operaciones básicas de transacción (COMMIT y ROLLBACK)

Las transacciones en MariaDB pueden controlarse con los siguientes comandos:

Uso de transacciones en Python

A continuación se muestra un ejemplo básico de gestión de transacciones en MariaDB usando Python.

Gestión de múltiples operaciones dentro de una única transacción

El siguiente código trata múltiples operaciones de inserción como una sola transacción y confirma solo si todas las operaciones tienen éxito.

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Start transaction
    conn.start_transaction()

    # Insert data
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Bob", "bob@example.com"))
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Charlie", "charlie@example.com"))

    # Commit if all operations succeed
    conn.commit()
    print("Data added successfully.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Error occurred: {e}")
    conn.rollback()  # Roll back if an error occurs

Puntos clave

• Usa conn.start_transaction() para iniciar una transacción.
• Usa conn.commit() para finalizar los cambios (no se pueden deshacer después del commit).
• Si ocurre un error, usa conn.rollback() para cancelar los cambios y restaurar el estado original.

Manejo de errores basado en transacciones

Pueden ocurrir errores durante las operaciones de base de datos.
Por ejemplo, una dirección de correo duplicada (violación de la restricción UNIQUE) o un tiempo de espera del servidor pueden suceder.

Gestión de transacciones con manejo de errores

El siguiente código agrega lógica para revertir los cambios y restaurar el estado original si ocurre un error durante el procesamiento.

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Start transaction
    conn.start_transaction()

    try:
        # First insert succeeds
        cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Dave", "dave@example.com"))

        # Second insert causes an error (duplicate email)
        cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Eve", "dave@example.com"))

        # Commit if all operations succeed
        conn.commit()
        print("Data inserted successfully.")

    except mariadb.Error as e:
        print(f"Error occurred during data processing: {e}")
        conn.rollback()  # Roll back on error
        print("Transaction rolled back.")

    cursor.close()
    conn.close()

except mariadb.Error as e:
    print(f"Database connection error: {e}")

Resumen

En esta sección, explicamos los conceptos básicos de las transacciones y cómo implementarlas en Python.

• La importancia de las transacciones y las propiedades ACID
• Cómo usar commit() y rollback() en Python
• Gestión de transacciones combinada con el manejo de errores

7. Manejo de errores (Errores comunes y soluciones)

Al trabajar con MariaDB en Python, pueden ocurrir errores.
En particular, errores de conexión a la base de datos, errores de sintaxis SQL y errores de integridad de datos son comunes, por lo que es importante comprender sus causas y soluciones.

En esta sección, presentamos las causas de los errores comunes y cómo solucionarlos.

Access denied for user (Error de autenticación)

Mensaje de error

mariadb.OperationalError: Access denied for user 'root'@'localhost' (using password: YES)

Causa

• El nombre de usuario o la contraseña son incorrectos
• El usuario de MariaDB no tiene los privilegios adecuados

Solución

1. Iniciar sesión en MariaDB y verificar los privilegios del usuario

   mysql -u root -p
   

2. Conceder privilegios al usuario

   GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
   FLUSH PRIVILEGES;
   

3. Reiniciar MariaDB

   sudo systemctl restart mariadb
   

Can't connect to MySQL server on 'localhost' (Error de conexión)

Mensaje de error

mariadb.OperationalError: Can't connect to MySQL server on 'localhost' (10061)

Causa

• El servidor MariaDB no está en ejecución
• La configuración host es incorrecta

Solución

1. Verificar si el servidor MariaDB está en ejecución

   sudo systemctl status mariadb
   

2. Si el servidor está detenido, iniciarlo

   sudo systemctl start mariadb
   

3. Configurar el servidor para que se inicie automáticamente

   sudo systemctl enable mariadb
   

Unknown database 'sample_db' (Base de datos no existe)

Mensaje de error

mariadb.ProgrammingError: Unknown database 'sample_db'

Causa

• La base de datos especificada no existe
• Hay un error tipográfico en el nombre de la base de datos

Solución

1. Consultar la lista de bases de datos

   SHOW DATABASES;
   

2. Crear la base de datos si no existe

   CREATE DATABASE sample_db;
   

Table doesn't exist (La tabla no existe)

Mensaje de error

mariadb.ProgrammingError: Table 'sample_db.users' doesn't exist

Causa

• La tabla especificada no existe
• No se seleccionó la base de datos usando USE sample_db;

Solución

1. Consultar la lista de tablas

   SHOW TABLES;
   

2. Crear la tabla si no existe

   CREATE TABLE users (
       id INT AUTO_INCREMENT PRIMARY KEY,
       name VARCHAR(100) NOT NULL,
       email VARCHAR(100) UNIQUE NOT NULL,
       created_at DATETIME DEFAULT CURRENT_TIMESTAMP
   );
   

Duplicate entry (Error de datos duplicados)

Mensaje de error

mariadb.IntegrityError: Duplicate entry 'alice@example.com' for key 'users.email'

Causa

• La columna email tiene una restricción UNIQUE, por lo que no se pueden insertar valores duplicados

Solución

• Verificar duplicados antes de insertar datos
• Utilizar ON DUPLICATE KEY UPDATE

Código Python para prevenir duplicados

try:
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))
    conn.commit()
except mariadb.IntegrityError:
    print("Error: The email address already exists.")

O usar ON DUPLICATE KEY UPDATE

INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
ON DUPLICATE KEY UPDATE name = 'Alice Updated';

Incorrect number of bindings (Desajuste en el número de parámetros)

Mensaje de error

mariadb.ProgrammingError: Incorrect number of bindings supplied. The current statement uses 2, and there are 1 supplied.

Causa

• El número de parámetros requeridos por la sentencia SQL no coincide con la cantidad de argumentos proporcionados

Solución

• Asegúrese de que la cantidad de marcadores de posición coincida con la cantidad de parámetros

Código incorrecto

cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice"))

Código correcto

cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))

Resumen

En esta sección explicamos los errores comunes que ocurren al trabajar con MariaDB en Python y cómo resolverlos.

• Access denied for user (Error de autenticación)
• Can't connect to MySQL server (Error de conexión)
• Unknown database (La base de datos no existe)
• Table doesn't exist (La tabla no existe)
• Duplicate entry (Error de datos duplicados)
• Incorrect number of bindings (Desajuste en la cantidad de parámetros)

8. Conclusión

En este artículo explicamos cómo trabajar con MariaDB usando Python, desde conceptos básicos hasta temas más avanzados.
Al comprender las operaciones fundamentales de bases de datos y al implementar correctamente el manejo de errores y la gestión de transacciones, puedes realizar operaciones de datos más seguras y eficientes.

Recapitulación del artículo

Configuración del entorno

• Cómo instalar MariaDB (Windows / Mac / Linux)
• Cómo instalar la biblioteca conectora de MariaDB (mariadb) para Python

Conexión a MariaDB

• Métodos básicos de conexión a la base de datos
• Conexiones seguras usando variables de entorno
• Soluciones para errores de conexión comunes

Creación de bases de datos y tablas

• Crear bases de datos (SQL / Python)
• Crear tablas y elegir tipos de datos
• Verificar y eliminar tablas existentes

Operaciones CRUD (Crear, Leer, Actualizar, Eliminar)

• Operaciones básicas de datos usando Python
• Uso de marcadores de posición para prevenir inyección SQL
• Manejo adecuado de errores

Transacciones y reversión

• La importancia de las transacciones (propiedades ACID)
• Cómo restaurar datos en caso de error (rollback)
• Gestión manual de transacciones desactivando AutoCommit

Manejo de errores (Errores comunes y soluciones)

• Errores de autenticación (Access denied for user)
• Errores de conexión (Can't connect to MySQL server)
• Errores de base de datos o tabla no encontrada
• Errores de datos duplicados (Duplicate entry)
• Manejo de deadlocks e implementación de lógica de reintento

Puntos clave al combinar Python y MariaDB

1. Usar marcadores de posición

   cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))
   

→ Utiliza variables enlazadas en lugar de incrustar directamente los valores en las sentencias SQL para prevenir inyección SQL.

2. Gestionar las transacciones correctamente

• Usa conn.commit() para confirmar explícitamente los cambios.
• Usa conn.rollback() ante un error para mantener la integridad de los datos.

3. Implementar un manejo exhaustivo de errores

• Usa bloques try-except para capturar posibles errores de antemano.
• Prepara estrategias específicas de manejo para errores como OperationalError e IntegrityError.

4. Considerar el rendimiento

• Inserciones masivas (insertar varios registros a la vez)
• Indexación adecuada (mejorar el rendimiento de búsqueda)

Recursos para seguir aprendiendo

Si deseas profundizar tu comprensión sobre la integración de Python y MariaDB, considera los siguientes recursos:

Documentación oficial

• Documentación oficial de MariaDB

Contenido de aprendizaje relacionado

• Conceptos básicos de SQL (W3Schools)
• Operaciones de bases de datos con Python (Real Python)

Libros recomendados

• SQL, 2ª edición: Operaciones de bases de datos desde cero – Aprende a fondo los fundamentos de SQL
• Effective Python: 90 formas específicas de mejorar tus programas Python – Mejores prácticas en Python

Resumen

Al integrar MariaDB con Python, puedes habilitar gestión de datos basada en scripts y automatización.
Al implementar no solo operaciones CRUD básicas sino también un manejo adecuado de errores y gestión de transacciones, puedes construir un sistema más seguro y eficiente.

Como siguiente paso, considera aprender sobre gestión eficiente de datos y integración de API para aplicar tus conocimientos a operaciones prácticas de bases de datos.