Cómo Trabajar con SQLite en Python – Un Manual para Principiantes

SQLite es uno de los sistemas de gestión de bases de datos relacionales (RDBMS) más populares. Es ligero, lo que significa que no ocupa mucho espacio en su sistema. Una de sus mejores características es que es sin servidor, por lo que no necesita instalar o administrar un servidor separado para utilizarlo.

En su lugar, almacena todo en un simple archivo en su ordenador. También requiere cero configuración, por lo que no hay un proceso de configuración complicado, lo que lo hace perfecto para principiantes y proyectos pequeños.

SQLite es una buena opción para aplicaciones pequeñas a medianas porque es fácil de usar, rápido y puede manejar la mayoría de las tareas que hacen otras bases de datos más grandes, pero sin la molestia de administrar software extra. Tanto si estás construyendo un proyecto personal como si estás probando una nueva aplicación, SQLite es una opción sólida para ponerlo en marcha rápidamente.

En este tutorial, aprenderá a trabajar con SQLite utilizando Python. Aquí es lo que vamos a cubrir en este tutorial:

Cómo Configurar su Entorno de Python
Cómo Crear una Base de Datos SQLite
Cómo Crear Tablas de Base de Datos
Cómo Insertar Datos en una Tabla
Cómo Consultar Datos
Cómo Actualizar y Eliminar Datos
Cómo Usar Transacciones
Cómo Optimizar el Rendimiento de Consultas SQLite con Indexación
Cómo Manejar Errores y Excepciones
Cómo exportar e importar datos [Sección de bonificación]
Resumen

Este tutorial es perfecto para cualquiera que quiera empezar con las bases de datos sin sumergirse en configuraciones complejas.

Cómo configurar su entorno de Python

Antes de trabajar con SQLite, aseguremos que su entorno de Python esté listo. Aquí cómo configurar todo.

Instalación de Python

Si aún no tienes Python instalado en tu sistema, puedes descargarlo desde el sitio oficial del sitio web de Python. Sigue las instrucciones de instalación para tu sistema operativo (Windows, macOS o Linux).

Para verificar si Python está instalado, abre tu terminal (o símbolo del sistema) y escribe:

python --version

Esto debería mostrar la versión actual de Python instalada. Si no está instalado, sigue las instrucciones en el sitio web de Python.

Instalación del módulo SQLite3

La buena noticia es que SQLite3 viene integrado con Python! No necesitas instalarlo por separado ya que está incluido en la biblioteca estándar de Python. Esto significa que puedes empezar a usarlo inmediatamente sin ninguna configuración adicional.

Cómo crear un entorno virtual (opcional pero recomendado)

Es una buena idea crear un entorno virtual para cada proyecto para mantener tus dependencias organizadas. Un entorno virtual es como una superficie limpia donde puedes instalar paquetes sin afectar tu instalación global de Python.

Para crear un entorno virtual, sigue estos pasos:

Primero, abre tu terminal o consola de comandos y navega hacia el directorio donde quieres crear tu proyecto.
Ejecuta el siguiente comando para crear un entorno virtual:

python -m venv env

Aquí, env es el nombre del entorno virtual. Puedes ponerle cualquier nombre que te guste.

Activa el entorno virtual:

# Usa el comando para Windows
env\Scripts\activate

# Usa el comando para macOS/Linux:
env/bin/activate

Después de activar el entorno virtual, verás que el prompt de tu terminal cambia, mostrando el nombre del entorno virtual. Esto significa que ya estás trabajando dentro de él.

Instalando bibliotecas necesarias

Nos necesitaremos algunas bibliotecas adicionales para este proyecto. Específicamente, utilizaremos:

pandas: Esta es una biblioteca opcional para manejar y mostrar datos en formato tabular, útil para casos de uso avanzados.
faker: Esta biblioteca nos ayudará a generar datos falsos, como nombres y direcciones aleatorios, que podemos insertar en nuestra base de datos para pruebas.

Para instalar pandas y faker, simplemente ejecuta los siguientes comandos:

pip install pandas faker

Esto instala tanto pandas como faker en tu entorno virtual. Con esto, tu entorno está configurado y listo para comenzar a crear y administrar tu base de datos SQLite en Python!

Cómo Crear una Base de Datos SQLite

Una base de datos es una forma estructurada de almacenar y administrar datos para que puedan accederse, actualizarse y organizarse fácilmente. Es como un sistema de archivo digital que te permite almacenar eficientemente grandes cantidades de datos, ya sea para una aplicación simple o un sistema más complejo. Las bases de datos utilizan tablas para organizar los datos, con filas y columnas que representan registros individuales y sus atributos.

Cómo Funcionan las Bases de Datos SQLite

A diferencia de la mayoría de los otros sistemas de bases de datos, SQLite es una base de datos sin servidor. Esto significa que no requiere configurar o administrar un servidor, lo que lo hace ligero y fácil de usar. Todos los datos se almacenan en un único archivo en su computadora, que puede mover, compartir o respaldar fácilmente. A pesar de su simplicidad, SQLite es lo suficientemente potente para manejar muchas tareas comunes de bases de datos y se utiliza ampliamente en aplicaciones móviles, sistemas empotrados y proyectos de pequeña a mediana escala.

Cómo Crear una Nueva Base de Datos SQLite

Vamos a crear una nueva base de datos SQLite y aprenderemos cómo interactuar con ella usando la biblioteca de Python sqlite3.

Conectándonos a la Base de Datos

Desde que sqlite3 está preinstalado, solo necesitas importarlo en tu script de Python. Para crear una nueva base de datos o conectarte a una existente, usamos el método sqlite3.connect(). Este método toma el nombre del archivo de la base de datos como argumento. Si el archivo no existe, SQLite lo creará automáticamente.

import sqlite3

# Conectar a la base de datos SQLite (o crearla si no existe)
connection = sqlite3.connect('my_database.db')

En este ejemplo, se crea un archivo llamado my_database.db en el mismo directorio que su script. Si el archivo ya existe, SQLite simplemente abrirá la conexión a él.

Creando un Cursor

Una vez que tienes una conexión, el siguiente paso es crear un objeto cursor. El cursor es responsable de ejecutar comandos y consultas SQL en la base de datos.

# Crear un objeto cursor
cursor = connection.cursor()

Cerrando la Conexión

Después de haber terminado con la base de datos, es importante cerrar la conexión para liberar cualquier recurso. Puedes cerrar la conexión con el siguiente comando:

# Cierra la conexión de la base de datos
connection.close()

Sin embargo, debes cerrar la conexión solamente una vez que hayas terminado todas tus operaciones.

Cuando ejecute su script de Python, se creará un archivo llamado my_database.db en su directorio de trabajo actual. ¡Ahora ha creado exitosamente su primera base de datos SQLite!

Cómo Usar el Gestor de Contexto para Abrir y Cerrar Conexiones

Python proporciona una manera más eficiente y limpia para manejar las conexiones de base de datos utilizando la sentencia with, también conocida como un gestor de contexto. La sentencia with abre y cierra automáticamente la conexión, garantizando que la conexión se cierra correctamente incluso si ocurre un error durante las operaciones de base de datos. Esto elimina la necesidad de llamar manualmente a connection.close().

Aquí es cómo puedes usar la sentencia with para manejar las conexiones de base de datos:

import sqlite3

# Paso 1: Use 'with' para conectar a la base de datos (o crear una) y cerrarla automáticamente cuando haya terminado
with sqlite3.connect('my_database.db') as connection:

    # Paso 2: Cree un objeto cursor para interactuar con la base de datos
    cursor = connection.cursor()

    print("Database created and connected successfully!")

# No es necesario llamar a connection.close(); se hace automáticamente!

Desde ahora, utilizaremos la declaración with en nuestros próximos ejemplos de código para gestionar eficientemente las conexiones a la base de datos. Esto hará que el código sea más conciso y fácil de mantener.

Cómo Crear Tablas de Base de Datos

Una vez creada la base de datos SQLite y conectada, el siguiente paso es crear tablas dentro de la base de datos. Una tabla es donde almacenaremos nuestros datos, organizados en filas (registros) y columnas (atributos). Para este ejemplo, crearemos una tabla llamada Students para almacenar información sobre los estudiantes, que reutilizaremos en las próximas secciones.

Para crear una tabla, utilizamos la sentencia CREATE TABLE de SQL. Este comando define la estructura de la tabla, incluyendo los nombres de las columnas y los tipos de datos para cada columna.

Aquí hay una simple orden SQL para crear una tabla Students con los siguientes campos:

id: Un identificador único para cada estudiante (un entero).
name: El nombre del estudiante (texto).
age: La edad del estudiante (un entero).
email: La dirección de correo electrónico del estudiante (texto).

La orden SQL para crear esta tabla sería así:

CREATE TABLE Students (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    age INTEGER,
    email TEXT
);

Podemos ejecutar este comando SQL CREATE TABLE en Python utilizando la biblioteca sqlite3. Vamos a ver cómo hacerlo.

import sqlite3

# Usar 'with' para conectar a la base de datos SQLite y cerrar automáticamente la conexión cuando se haya terminado
with sqlite3.connect('my_database.db') as connection:

    # Crear un objeto cursor
    cursor = connection.cursor()

    # Escribir el comando SQL para crear la tabla Students
    create_table_query = '''
    CREATE TABLE IF NOT EXISTS Students (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        age INTEGER,
        email TEXT
    );
    '''

    # Ejecutar el comando SQL
    cursor.execute(create_table_query)

    # Commitear los cambios
    connection.commit()

    # Imprimir un mensaje de confirmación
    print("Table 'Students' created successfully!")

IF NOT EXISTS: Esto garantiza que la tabla solo se crea si no existe ya, evitando errores si la tabla se ha creado antes.
connection.commit(): Esto guarda (comitea) los cambios en la base de datos.

Cuando ejecutes el código de Python de arriba, creará la tabla Students en el archivo de base de datos my_database.db. También verás un mensaje en la terminal confirmando que se ha creado correctamente la tabla.

Si estás usando Visual Studio Code, puedes instalar la extensión SQLite Viewer para ver bases de datos SQLite.

Tipos de Datos en SQLite y su Mapeo a Python

SQLite soporta varios tipos de datos, los cuales necesitamos entender al definir nuestras tablas. Aquí tienes un rápido resumen de los tipos de datos comunes en SQLite y cómo se mapean a tipos de Python:

Tipo de Datos de SQLite	Descripción	Equivalente en Python
INTEGER	Números enteros	`int`
TEXT	Cadenas de texto	`str`
REAL	Números de coma flotante	`float`
BLOB	Datos binarios (por ejemplo, imágenes, archivos)	`bytes`
NULL	Representa sin valor o datos ausentes	`None`

En nuestra tabla Students:

id es de tipo INTEGER, que se mapea al int de Python.
name y email son de tipo TEXT, que se mapean a str de Python.
age también es de tipo INTEGER, mapeando al int de Python.

Cómo Insertar Datos en una Tabla

Ya que tenemos nuestra tabla Students creada, es hora de empezar a insertar datos en la base de datos. En esta sección, cubriremos cómo insertar tanto registros individuales como múltiples usando Python y SQLite, y cómo evitar problemas de seguridad comunes como la inyección SQL mediante consultas parametrizadas.

Cómo Insertar un Registro Único

Para insertar datos en la base de datos, usamos el comando SQL INSERT INTO. Comencemos por insertar un registro único en nuestra tabla Students.

Este es el esquema básico de sintaxis SQL para insertar un registro único:

INSERT INTO Students (name, age, email) 
VALUES ('John Doe', 20, '[email protected]');

Sin embargo, en lugar de escribir SQL directamente en nuestro script de Python con valores hardcoded, usaremos consultas parametrizadas para hacer nuestro código más seguro y flexible. Las consultas parametrizadas ayudan a prevenir la inyección SQL, un ataque común donde los usuarios malintencionados pueden manipular la consulta SQL pasando entrada dañina.

Así es cómo podemos insertar un registro único en la tabla Students usando una consulta parametrizada:

import sqlite3

# Usa 'with' para abrir y cerrar la conexión automáticamente
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # Inserta un registro en la tabla Students
    insert_query = '''
    INSERT INTO Students (name, age, email) 
    VALUES (?, ?, ?);
    '''
    student_data = ('Jane Doe', 23, '[email protected]')

    cursor.execute(insert_query, student_data)

    # Confirma los cambios automáticamente
    connection.commit()

    # No es necesario llamar a connection.close(); se hace automáticamente!
    print("Record inserted successfully!")

Los marcadores de posición ? representan los valores a insertar en la tabla. Los valores reales se pasan como una tupla (student_data) en el método cursor.execute().

Cómo Insertar Múltiples Registros

Si quieres insertar varios registros a la vez, puedes usar el método executemany() en Python. Este método toma una lista de tuplas, donde cada tupla representa un registro.

Para hacer nuestro ejemplo más dinámico, podemos usar la biblioteca Faker para generar datos de estudiantes aleatorios. Esto es útil para pruebas y simular escenarios del mundo real.

from faker import Faker
import sqlite3

# Inicializa Faker
fake = Faker(['en_IN'])

# Usa 'with' para abrir y cerrar la conexión automáticamente
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # Inserta un registro en la tabla Students
    insert_query = '''
    INSERT INTO Students (name, age, email) 
    VALUES (?, ?, ?);
    '''
    students_data = [(fake.name(), fake.random_int(
        min=18, max=25), fake.email()) for _ in range(5)]

    # Ejecuta la consulta para múltiples registros
    cursor.executemany(insert_query, students_data)

    # Confirma los cambios
    connection.commit()

    # Imprime un mensaje de confirmación
    print("Fake student records inserted successfully!")

En este código:

Faker() genera nombres, edades y correos electrónicos aleatorios para los estudiantes. Pasar la configuración regional ([‘en_IN’]) es opcional.
cursor.executemany(): Este método nos permite insertar varios registros a la vez, haciendo que el código sea más eficiente.
students_data: Una lista de tuplas donde cada tupla representa los datos de un estudiante.

Cómo manejar problemas comunes: Inyección SQL

La inyección SQL es una vulnerabilidad de seguridad donde los atacantes pueden insertar o manipular consultas SQL proporcionando entrada dañina. Por ejemplo, un atacante podría intentar inyectar código como '; DROP TABLE Students; -- para eliminar la tabla.

Al utilizar consultas parametrizadas (como se demostró anteriormente), evitamos este problema. Los marcadores de posición ? en las consultas parametrizadas garantizan que los valores de entrada se tratan como datos, no como parte de la orden SQL. Esto hace que sea imposible la ejecución de código malicioso.

Cómo consultar datos

Ahora que hemos insertado algunos datos en nuestra tabla Students, aprendamos cómo recuperar los datos de la tabla. Exploraremos diferentes métodos para obtener datos en Python, incluyendo fetchone(), fetchall() y fetchmany().

Para consultar datos de una tabla, usamos la declaración SELECT. Aquí tienes un comando SQL simple para seleccionar todas las columnas de la tabla Students:

SELECT * FROM Students;

Este comando recupera todos los registros y columnas de la tabla Students. Podemos ejecutar esta consulta SELECT en Python y obtener los resultados.

Cómo obtener todos los registros

A continuación, se muestra cómo podemos obtener todos los registros de la tabla Students:

import sqlite3

# Usar 'with' para conectarse a la base de datos SQLite
with sqlite3.connect('my_database.db') as connection:

    # Crear un objeto cursor
    cursor = connection.cursor()

    # Escribir el comando SQL para seleccionar todos los registros de la tabla Students
    select_query = "SELECT * FROM Students;"

    # Ejecutar el comando SQL
    cursor.execute(select_query)

    # Obtener todos los registros
    all_students = cursor.fetchall()

    # Mostrar resultados en la terminal
    print("All Students:")
    for student in all_students:
        print(student)

En este ejemplo, el método fetchall() recupera todas las filas devueltas por la consulta como una lista de tuplas.

All Students:
(1, 'Jane Doe', 23, '[email protected]')
(2, 'Bahadurjit Sabharwal', 18, '[email protected]')
(3, 'Zayyan Arya', 20, '[email protected]')
(4, 'Hemani Shukla', 18, '[email protected]')
(5, 'Warda Kara', 20, '[email protected]')
(6, 'Mitali Nazareth', 19, '[email protected]')

Cómo obtener un solo registro

Si deseas recuperar solo un registro, puedes usar el método fetchone():

import sqlite3

# Usar 'with' para conectar a la base de datos SQLite
with sqlite3.connect('my_database.db') as connection:

    # Crear un objeto cursor
    cursor = connection.cursor()

    # Escribir el comando SQL para seleccionar todos los registros de la tabla Students
    select_query = "SELECT * FROM Students;"

    # Ejecutar el comando SQL
    cursor.execute(select_query)

    # Obtener un registro
    student = cursor.fetchone()

    # Mostrar el resultado
    print("First Student:")
    print(student)

Salida:

First Student:
(1, 'Jane Doe', 23, '[email protected]')

Cómo Obtener Múltiples Registros

Para obtener un número específico de registros, puede usar fetchmany(size):

import sqlite3

# Usar 'with' para conectar a la base de datos SQLite
with sqlite3.connect('my_database.db') as connection:

    # Crear un objeto cursor
    cursor = connection.cursor()

    # Escribir el comando SQL para seleccionar todos los registros de la tabla Students
    select_query = "SELECT * FROM Students;"

    # Ejecutar el comando SQL
    cursor.execute(select_query)

    # Obtener tres registros
    three_students = cursor.fetchmany(3)

    # Mostrar resultados
    print("Three Students:")
    for student in three_students:
        print(student)

Salida:

Three Students:
(1, 'Jane Doe', 23, '[email protected]')
(2, 'Bahadurjit Sabharwal', 18, '[email protected]')
(3, 'Zayyan Arya', 20, '[email protected]')

Cómo Utilizar `pandas` para una Mejor presentación de Datos

Para una mejor presentación de datos, podemos usar la biblioteca pandas para crear un DataFrame a partir de nuestros resultados de consulta. Esto hace más fácil la manipulación y visualización de los datos.

Aquí cómo obtener todos los registros y mostrarlos como un DataFrame de pandas:

import sqlite3
import pandas as pd

# Usar 'with' para conectar a la base de datos SQLite
with sqlite3.connect('my_database.db') as connection:
    # Escribir el comando SQL para seleccionar todos los registros de la tabla Students
    select_query = "SELECT * FROM Students;"

    # Usar pandas para leer la consulta SQL directamente en un DataFrame
    df = pd.read_sql_query(select_query, connection)

# Mostrar el DataFrame
print("All Students as DataFrame:")
print(df)

Salida:

All Students as DataFrame:
   id                  name  age                        email
0   1              Jane Doe   23             [email protected]
1   2  Bahadurjit Sabharwal   18  [email protected]
2   3           Zayyan Arya   20  [email protected]
3   4         Hemani Shukla   18    [email protected]
4   5            Warda Kara   20           [email protected]
5   6       Mitali Nazareth   19          [email protected]

La función pd.read_sql_query() ejecuta la consulta SQL y devuelve directamente los resultados como un DataFrame de pandas.

Cómo Actualizar y Eliminar Datos

En esta sección, aprenderemos cómo actualizar registros existentes y eliminar registros de nuestra tabla Students usando comandos SQL en Python. Esto es fundamental para manejar y mantener sus datos de manera efectiva.

Actualizar Registros Existentes

Para modificar registros existentes en una base de datos, usamos el comando SQL UPDATE. Este comando nos permite cambiar los valores de columnas específicas en una o más filas basándonos en una condición especificada.

Por ejemplo, si queremos actualizar la edad de un estudiante, el comando SQL se vería así:

UPDATE Students 
SET age = 21 
WHERE name = 'Jane Doe';

Ahora, vamos a escribir código de Python para actualizar la edad de un estudiante específico en nuestra tabla Students.

import sqlite3

# Usar 'with' para conectar a la base de datos SQLite
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # Comando SQL para actualizar la edad de un estudiante
    update_query = '''
    UPDATE Students 
    SET age = ? 
    WHERE name = ?;
    '''

    # Datos para la actualización
    new_age = 21
    student_name = 'Jane Doe'

    # Ejecutar el comando SQL con los datos
    cursor.execute(update_query, (new_age, student_name))

    # Confirmar los cambios para guardar la actualización
    connection.commit()

    # Imprimir un mensaje de confirmación
    print(f"Updated age for {student_name} to {new_age}.")

En este ejemplo, hemos usado consultas parametrizadas para evitar la inyección SQL.

Cómo Eliminar Registros de la Tabla

Para eliminar registros de una base de datos, usamos el comando SQL DELETE. Este comando nos permite eliminar una o más filas basándonos en una condición especificada.

Por ejemplo, si queremos eliminar a un estudiante llamado ‘Jane Doe’, el comando SQL se vería así:

DELETE FROM Students 
WHERE name = 'Jane Doe';

Vamos a escribir código Python para eliminar a un estudiante específico de nuestra tabla Students usando el statement with.

import sqlite3

# Usar 'with' para conectar a la base de datos SQLite
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # Comando SQL para eliminar un estudiante
    delete_query = '''
    DELETE FROM Students 
    WHERE name = ?;
    '''

    # Nombre del estudiante a eliminar
    student_name = 'Jane Doe'

    # Ejecutar el comando SQL con los datos
    cursor.execute(delete_query, (student_name,))

    # Confirmar los cambios para guardar la eliminación
    connection.commit()

    # Imprimir un mensaje de confirmación
    print(f"Deleted student record for {student_name}.")

Consideraciones Importantes

Condiciones: Siempre use la cláusula WHERE al actualizar o eliminar registros para evitar modificar o eliminar todas las filas en la tabla. Sin una cláusula WHERE, el comando afecta a todas las filas de la tabla.
Respaldo: Es una buena práctica hacer una copia de seguridad de su base de datos antes de realizar actualizaciones o eliminaciones, especialmente en entornos de producción.

Cómo utilizar transacciones

Una transacción es una secuencia de una o más operaciones SQL que se tratan como una sola unidad de trabajo. En el contexto de una base de datos, una transacción le permite realizar múltiples operaciones que bien todas tienen éxito o ninguna. Esto asegura que su base de datos permanezca en un estado consistente, incluso ante errores o problemas inesperados.

Por ejemplo, si está transfiriendo dinero entre dos cuentas bancarias, querría que tanto el débito de una cuenta como el crédito a la otra tengan éxito o fallen juntos. Si una operación falla, la otra no debería ejecutarse para mantener la consistencia.

¿Por qué utilizar transacciones?

Atomicidad: Las transacciones garantizan que una serie de operaciones se traten como una sola unidad. Si una operación falla, ninguna de las operaciones se aplicará a la base de datos.
Consistencia: Las transacciones ayudan a mantener la integridad de la base de datos al garantizar que se sigan todas las reglas y restricciones.
Aislamiento: Cada transacción opera de forma independiente de las demás, evitando interferencias no deseadas.
Durabilidad: Una vez que una transacción se ha confirmado, los cambios son permanentes, incluso en caso de fallo del sistema.

¿Cuándo utilizar transacciones?

Debería utilizar transacciones cuando:

Realice múltiples operaciones relacionadas que deben tener éxito o fallar juntas.
Modifique datos críticos que requieren consistencia e integridad.
Trabajando con operaciones que pueden fallar potencialmente, como transacciones financieras o migraciones de datos.

Cómo manejar transacciones en Python

En SQLite, las transacciones se gestionan usando los comandos BEGIN, COMMIT y ROLLBACK. Sin embargo, al usar el módulo sqlite3 en Python, típicamente se gestionan las transacciones a través del objeto de conexión.

Iniciar una Transacción

Una transacción comienza implícitamente cuando ejecutas cualquier sentencia SQL. Para iniciar una transacción explícitamente, puedes usar el comando BEGIN:

cursor.execute("BEGIN;")

Sin embargo, por lo general no es necesario iniciar una transacción manualmente, ya que SQLite inicia una transacción automáticamente cuando ejecutas una sentencia SQL.

Cómo confirmar una transacción

Para guardar todos los cambios realizados durante una transacción, utilizas el método commit(). Esto hace que todas las modificaciones sean permanentes en la base de datos.

connection.commit()

Ya hemos utilizado el método commit() en los ejemplos proporcionados anteriormente.

Deshacer una transacción

Si algo sale mal y quieres revertir los cambios realizados durante una transacción, puedes usar el método rollback(). Esto deshará todos los cambios realizados desde que comenzó la transacción.

connection.rollback()

Ejemplo de uso de transacciones en Python

Para ilustrar el uso de transacciones en un escenario del mundo real, crearemos una nueva tabla llamada Customers para gestionar las cuentas de los clientes. En este ejemplo, supondremos que cada cliente tiene un balance. Añadiremos dos clientes a esta tabla y realizaremos una operación de transferencia de fondos entre ellos.

Primero, creemos la tabla Customers e insertemos dos clientes:

import sqlite3

# Crear la tabla Customers y agregar dos clientes
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # Crear tabla Customers
    create_customers_table = '''
    CREATE TABLE IF NOT EXISTS Customers (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL UNIQUE,
        balance REAL NOT NULL
    );
    '''
    cursor.execute(create_customers_table)

    # Insertar dos clientes
    cursor.execute(
        "INSERT INTO Customers (name, balance) VALUES (?, ?);", ('Ashutosh', 100.0))
    cursor.execute(
        "INSERT INTO Customers (name, balance) VALUES (?, ?);", ('Krishna', 50.0))

    connection.commit()

Ahora, realicemos la operación de transferencia de fondos entre Ashutosh y Krishna:

import sqlite3


def transfer_funds(from_customer, to_customer, amount):
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        try:
            # Iniciar una transacción
            cursor.execute("BEGIN;")

            # Descontar cantidad del remitente
            cursor.execute(
                "UPDATE Customers SET balance = balance - ? WHERE name = ?;", (amount, from_customer))
            # Añadir cantidad al destinatario
            cursor.execute(
                "UPDATE Customers SET balance = balance + ? WHERE name = ?;", (amount, to_customer))

            # Confirmar los cambios
            connection.commit()
            print(
                f"Transferred {amount} from {from_customer} to {to_customer}.")

        except Exception as e:
            # Si ocurre un error, deshacer la transacción
            connection.rollback()
            print(f"Transaction failed: {e}")


# Ejemplo de uso
transfer_funds('Ashutosh', 'Krishna', 80.0)

En este ejemplo, primero creamos una tabla Clientes y insertamos dos clientes, Ashutosh con un saldo de ₹100, y Krishna con un saldo de ₹50. Luego realizamos una transferencia de fondos de ₹80 de Ashutosh a Krishna. Al utilizar transacciones, aseguramos que ambos la debito en la cuenta de Ashutosh y el crédito en la cuenta de Krishna se ejecutan como una sola operación atómica, manteniendo la integridad de los datos en caso de cualquier error. Si la transferencia falla (por ejemplo, debido a fondos insuficientes), la transacción se deshace, dejando ambas cuentas sin cambios.

Cómo Optimizar el Rendimiento de las Consultas de SQLite con la Indexación

La indexación es una técnica poderosa utilizada en bases de datos para mejorar el rendimiento de las consultas. Un índice es básicamente una estructura de datos que almacena la ubicación de las filas en base a valores específicos de columnas, similar a que un índice en el reverso de un libro le ayuda a localizar rápidamente un tema.

Sin un índice, SQLite tiene que examinar toda la tabla fila por fila para encontrar los datos relevantes, lo cual resulta ineficiente a medida que el conjunto de datos crece. Al utilizar un índice, SQLite puede saltar directamente a las filas necesarias, reduciendo significativamente el tiempo de ejecución de las consultas.

Cómo Llenar la Base de Datos con Datos Falsos

Para probar efectivamente el impacto de la indexación, necesitamos un conjunto de datos de tamaño considerable. En lugar de agregar registros manualmente, podemos utilizar la biblioteca faker para generar rápidamente datos falsos. En esta sección, generaremos 10,000 registros falsos y los insertaremos en nuestra tabla Estudiantes. Esto simulará un escenario real en el que las bases de datos se hacen grandes y el rendimiento de las consultas se vuelve importante.

Utilizaremos el método executemany() para insertar los registros de la siguiente manera:

import sqlite3
from faker import Faker

# Inicializar la biblioteca Faker
fake = Faker(['en_IN'])


def insert_fake_students(num_records):
    """Generate and insert fake student data into the Students table."""
    fake_data = [(fake.name(), fake.random_int(min=18, max=25),
                  fake.email()) for _ in range(num_records)]

    # Utilizar 'with' para manejar la conexión a la base de datos
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Insertar datos falsos en la tabla Students
        cursor.executemany('''
        INSERT INTO Students (name, age, email) 
        VALUES (?, ?, ?);
        ''', fake_data)

        connection.commit()

    print(f"{num_records} fake student records inserted successfully.")


# Insertar 10.000 registros falsos en la tabla Students
insert_fake_students(10000)

Al ejecutar este script, se agregarán 10.000 registros falsos de estudiantes a la tabla Students. En la siguiente sección, consultaremos la base de datos y compararemos el rendimiento de las consultas con y sin indexación.

Cómo realizar consultas sin índices

En esta sección, consultaremos la tabla Students sin ningún índice para observar cómo SQLite se desempeña cuando no hay optimizaciones en su lugar. Esto servirá como referencia para comparar el rendimiento cuando agreguemos índices más adelante.

Sin índices, SQLite realiza un escaneo completo de la tabla, lo que significa que debe verificar cada fila en la tabla para encontrar resultados coincidentes. Para conjuntos de datos pequeños, esto es manejable, pero a medida que el número de registros aumenta, el tiempo necesario para realizar la búsqueda aumenta drásticamente. Veamos esto en acción ejecutando una consulta básica de SELECT para buscar un estudiante específico por nombre y medir cuánto tiempo lleva.

Primero, consultaremos la tabla Students buscando un estudiante con un nombre específico. Registraremos el tiempo necesario para ejecutar la consulta utilizando el módulo time de Python para medir el rendimiento.

import sqlite3
import time


def query_without_index(search_name):
    """Query the Students table by name without an index and measure the time taken."""

    # Conectar a la base de datos usando 'with'
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Medir el tiempo de inicio
        start_time = time.perf_counter_ns()

        # Ejecutar una consulta SELECT para encontrar un estudiante por nombre
        cursor.execute('''
        SELECT * FROM Students WHERE name = ?;
        ''', (search_name,))

        # Obtener todos los resultados (debería haber solo uno o unos pocos en práctica)
        results = cursor.fetchall()

        # Medir el tiempo de finalización
        end_time = time.perf_counter_ns()

        # Calcular el tiempo total transcurrido
        elapsed_time = (end_time - start_time) / 1000

        # Mostrar los resultados y el tiempo transcurrido
        print(f"Query completed in {elapsed_time:.5f} microseconds.")
        print("Results:", results)


# Ejemplo: Buscar un estudiante por nombre
query_without_index('Ojasvi Dhawan')

Aquí está la salida:

Query completed in 1578.10000 microseconds.
Results: [(104, 'Ojasvi Dhawan', 21, '[email protected]')]

Al ejecutar el script anterior, verás cuánto tarda en buscar la tabla de Estudiantes sin ninguna indexación. Por ejemplo, si hay 10,000 registros en la tabla, la consulta podría tardar entre 1000-2000 microsegundos dependiendo de la tabla y del hardware. Esto puede no parecer demasiado lento para un pequeño conjunto de datos, pero la performance se degradará conforme aumenten los registros.

Usamos time.perf_counter_ns() para medir el tiempo de ejecución de la consulta en nanosegundos. Este método es altamente preciso para la benchmarking de pequeños intervalos de tiempo. Convertimos el tiempo a microsegundos (us) para una lectura más fácil.

Nos presentamos con el Plan de Consulta

Al trabajar con bases de datos, entender cómo se ejecutan las consultas puede ayudar a identificar los puntos de bloqueo en el rendimiento y optimizar su código. SQLite proporciona una herramienta útil para esto llamada EXPLAIN QUERY PLAN, que permite analizar los pasos que SQLite realiza para recuperar datos.

En esta sección, introduciremos cómo utilizar EXPLAIN QUERY PLAN para visualizar y comprender el funcionamiento interno de una consulta, específicamente cómo SQLite realiza una lectura completa de la tabla cuando no hay índices presentes.

Vamos a usar EXPLAIN QUERY PLAN para ver cómo SQLite recupera datos de la tabla Students sin índices. Buscaremos a un estudiante por su nombre, y el plan de consulta revelará los pasos que SQLite realiza para encontrar las filas coincidentes.

import sqlite3


def explain_query(search_name):
    """Explain the query execution plan for a SELECT query without an index."""

    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Usar EXPLAIN QUERY PLAN para analizar cómo se ejecuta la consulta
        cursor.execute('''
        EXPLAIN QUERY PLAN
        SELECT * FROM Students WHERE name = ?;
        ''', (search_name,))

        # Obtener y mostrar el plan de consulta
        query_plan = cursor.fetchall()

        print("Query Plan:")
        for step in query_plan:
            print(step)


# Ejemplo: Analizar el plan de consulta para buscar por nombre
explain_query('Ojasvi Dhawan')

Cuando ejecute este código, SQLite devolverá un desglose de cómo planea ejecutar la consulta. Aquí tiene un ejemplo de cómo podría verse la salida:

Query Plan:
(2, 0, 0, 'SCAN Students')

Esto indica que SQLite está realizando una lectura completa de la tabla Students (una lectura completa de tabla) para encontrar las filas en las que la columna name coincide con el valor proporcionado (Ojasvi Dhawan). Dado que no hay índice en la columna name, SQLite debe examinar cada fila de la tabla.

Cómo Crear un Índice

Crear un índice en una columna permite a SQLite encontrar filas más rápidamente durante las operaciones de consulta. En lugar de escanear toda la tabla, SQLite puede usar el índice para saltar directamente a las filas relevantes, acelerando significativamente las consultas, especialmente aquellas que involucran conjuntos de datos grandes.

Para crear un índice, use el siguiente comando SQL:

CREATE INDEX IF NOT EXISTS index-name ON table (column(s));

En este ejemplo, crearemos un índice en la columna name de la tabla Students. Aquí está cómo hacerlo usando Python:

import sqlite3
import time


def create_index():
    """Create an index on the name column of the Students table."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Comando SQL para crear un índice en la columna name
        create_index_query = '''
        CREATE INDEX IF NOT EXISTS idx_name ON Students (name);
        '''

        # Medir el tiempo de inicio
        start_time = time.perf_counter_ns()

        # Ejecutar el comando SQL para crear el índice
        cursor.execute(create_index_query)

        # Medir el tiempo de inicio
        end_time = time.perf_counter_ns()

        # Hacer commit de los cambios
        connection.commit()

        print("Index on 'name' column created successfully!")

        # Calcular el tiempo total transcurrido
        elapsed_time = (end_time - start_time) / 1000

        # Mostrar los resultados y el tiempo transcurrido
        print(f"Query completed in {elapsed_time:.5f} microseconds.")


# Llamar a la función para crear el índice
create_index()

Salida:

Index on 'name' column created successfully!
Query completed in 102768.60000 microseconds.

Aunque la creación del índice tarde este largo (102768.6 microsegundos), es una operación única. Aún obtendrá un aumento sustancial de velocidad al ejecutar múltiples consultas. En las siguientes secciones, consultaremos la base de datos de nuevo para observar las mejoras en el rendimiento posibles gracias a este índice.

Cómo consultar con índices

En esta sección, realizaremos la misma consulta SELECT que ejecutamos anteriormente, pero esta vez aprovecharemos el índice que creamos en la columna name de la tabla Students. Mediremos y registraremos el tiempo de ejecución para observar las mejoras en el rendimiento proporcionadas por el índice.

import sqlite3
import time


def query_with_index(student_name):
    """Query the Students table using an index on the name column."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Comando SQL para seleccionar un estudiante por nombre
        select_query = 'SELECT * FROM Students WHERE name = ?;'

        # Medir el tiempo de ejecución
        start_time = time.perf_counter_ns()  # Iniciar el cronómetro

        # Ejecutar la consulta con el nombre de estudiante proporcionado
        cursor.execute(select_query, (student_name,))
        result = cursor.fetchall()  # Obtener todos los resultados

        end_time = time.perf_counter_ns()  # Finalizar el cronómetro

        # Calcular el tiempo transcurrido en microsegundos
        execution_time = (end_time - start_time) / 1000

        # Mostrar resultados y tiempo de ejecución
        print(f"Query result: {result}")
        print(f"Execution time with index: {execution_time:.5f} microseconds")


# Ejemplo: Buscar un estudiante por nombre
query_with_index('Ojasvi Dhawan')

Aquí lo que obtenemos en la salida:

Query result: [(104, 'Ojasvi Dhawan', 21, '[email protected]')]
Execution time with index: 390.70000 microseconds

Podemos observar una reducción significativa en el tiempo de ejecución en comparación con cuando se realizó la consulta sin un índice.

Analicemos el plan de ejecución de la consulta para la consulta con el índice en la columna name de la tabla Students. Si ejecutas el mismo script de nuevo para explicar la consulta, obtendrás la siguiente salida:

Query Plan:
(3, 0, 0, 'SEARCH Students USING INDEX idx_name (name=?)')

El plan ahora muestra que la consulta utiliza el índice idx_name, lo que reduce significativamente el número de filas que deben escanearse, lo que conduce a una ejecución de consulta más rápida.

Comparando Resultados de Rendimiento

Ahora, resumiremos los resultados de rendimiento que obtuvimos al consultar con y sin índices.

Comparación de Tiempo de Ejecución

Tipo de Consulta	Tiempo de Ejecución (microsegundos)
Sin Índice	1578.1
Con Índice	390.7

Resumen de Mejora de Rendimiento

La consulta con el índice es aproximadamente 4.04 veces más rápida que la consulta sin el índice.
El tiempo de ejecución mejoró aproximadamente un 75.24% después de agregar el índice.

Mejores Prácticas para el Uso de Índices

Los índices pueden mejorar significativamente el rendimiento de su base de datos SQLite, pero deben usarse con prudencia. Aquí hay algunas mejores prácticas a considerar al trabajar con índices:

Cuándo y Por Qué Usar Índices

Columnas de Consulta Frecuentes: Utilice índices en columnas que se utilizan frecuentemente en consultas SELECT, especialmente aquellas utilizadas en cláusulas WHERE, JOIN y ORDER BY. Esto se debe a que indexar estas columnas puede reducir drásticamente el tiempo de ejecución de la consulta.
Restricciones de Unicidad: Cuando tiene columnas que deben contener valores únicos (como nombres de usuario o direcciones de correo electrónico), crear un índice puede imponer esta restricción de manera eficiente.
Conjuntos de Datos Grandes: Para tablas con un gran número de registros, los índices se vuelven cada vez más beneficiosos. Permite búsquedas rápidas, lo que es esencial para mantener el rendimiento a medida que su datos crecen.
Índices Combinados: Considere crear índices combinados para consultas que filtran o ordenan por múltiples columnas. Por ejemplo, si a menudo busca estudiantes por ambos nombre y edad, un índice en ambas columnas puede optimizar tales consultas.

Potenciales Inconvenientes de los Índices

Aunque los índices ofrecen ventajas significativas, hay algunos inconvenientes potenciales:

Operaciones de Insertar/Actualizar más lentas: Cuando insertas o actualizas registros en una tabla con índices, SQLite también debe actualizar el índice, lo cual puede ralentizar estas operaciones. Esto es así porque cada inserción o actualización requiere un overhead adicional para mantener la estructura del índice.
Requerimientos de Almacenamiento Incrementados: Los índices consumen espacio adicional en el disco. Para tablas grandes, el costo de almacenamiento puede ser sustancial. Tener en cuenta esto al diseñar tu esquema de base de datos, especialmente para sistemas con recursos de almacenamiento limitados.
Gestión compleja de índices: Tener demasiados índices puede complicar el manejo de la base de datos. Puede llevar a situaciones en las que hay índices redundantes, que pueden degradar el rendimiento en lugar de mejorarlo. Revisar y optimizar periódicamente los índices es una buena práctica.

Los índices son herramientas poderosas para optimizar las consultas de base de datos, pero requieren una consideración cuidadosa. Encontrar un equilibrio entre un mejor rendimiento de lectura y el potencial sobrecarga en las operaciones de escritura es clave. Aquí están algunas estrategias para alcanzar este equilibrio:

Monitorear el rendimiento de las consultas: Utilice EXPLAIN QUERY PLAN de SQLite para analizar cómo se realizan las consultas con y sin índices. Esto puede ayudar a identificar qué índices son beneficiosos y cuáles pueden ser innecesarios.
Mantenimiento periódico: Revisar periódicamente los índices y evaluar si aún son necesarios. Elimine los índices redundantes o poco utilizados para simplificar las operaciones de su base de datos.
Prueba y Evalúa: Antes de implementar índices en un entorno de producción, realiza pruebas detalladas para comprender su impacto tanto en operaciones de lectura como de escritura.

Al seguir estas mejores prácticas, puedes aprovechar los beneficios de los índices al mismo tiempo que minimizas los posibles desventajas, mejorando finalmente la eficiencia y el rendimiento de tu base de datos SQLite.

Cómo manejar errores y excepciones

En esta sección, discutiremos cómo manejar errores y excepciones al trabajar con SQLite en Python. Un manejo adecuado de errores es crucial para mantener la integridad de tu base de datos y para que tu aplicación se comporte de manera predecible.

Errores Comunes en Operaciones SQLite

Al interactuar con una base de datos SQLite, pueden surgir varios errores comunes:

Violaciones de Constraint: Esto ocurre cuando intentas insertar o actualizar datos que violan una restricción de la base de datos, como la unicidad del primary key o las restricciones de key foránea. Por ejemplo, intentar insertar una clave primaria duplicada generará un error.
Discrepancias de Tipo de Datos: Intentar insertar datos del tipo incorrecto (por ejemplo, insertar una cadena donde se espera un número) puede provocar un error.
Errores de Base de Datos Bloqueada: Si una base de datos está siendo escrita por otro proceso o conexión, intentar acceder a ella puede resultar en un error de “base de datos bloqueada”.
Errores de Sintaxis: Los errores en la sintaxis de tu SQL resultarán en errores cuando intentes ejecutar tus comandos.

Cómo Utilizar el Manejo de Excepciones en Python

Los mecanismos de manejo de excepciones (exception handling) integrados en Python (try y except) son esenciales para gestionar errores en las operaciones de SQLite. Mediante estos constructores, puedes capturar excepciones y responder adecuadamente sin que tu programa se cuelgue.

Aquí tienes un ejemplo básico de cómo manejar errores al insertar datos en la base de datos:

import sqlite3


def add_customer_with_error_handling(name, balance):
    """Add a new customer with error handling."""
    try:
        with sqlite3.connect('my_database.db') as connection:
            cursor = connection.cursor()
            cursor.execute(
                "INSERT INTO Customers (name, balance) VALUES (?, ?);", (name, balance))
            connection.commit()
            print(f"Added customer: {name} with balance: {balance}")

    except sqlite3.IntegrityError as e:
        print(f"Error: Integrity constraint violated - {e}")

    except sqlite3.OperationalError as e:
        print(f"Error: Operational issue - {e}")

    except Exception as e:
        print(f"An unexpected error occurred: {e}")


# Ejemplo de uso
add_customer_with_error_handling('Vishakha', 100.0)  # Entrada válida
add_customer_with_error_handling('Vishakha', 150.0)  # Entrada duplicada

En este ejemplo:

Caputramos IntegrityError, que se lanza por violaciones como restricciones de unicidad.
Caputramos OperationalError para problemas generales relacionados con la base de datos (como errores de bloqueo de la base de datos).
También tenemos un bloque except genérico para manejar cualquier excepción inesperada.

Salida:

Added customer: Vishakha with balance: 100.0
Error: Integrity constraint violated - UNIQUE constraint failed: Customers.name

Mejores Prácticas para Garantizar la Integridad de la Base de Datos

Utilizar Transacciones: Siempre use transacciones (como se discutió en la sección anterior) al realizar varias operaciones relacionadas. Esto ayuda a garantizar que todas las operaciones tengan éxito o que ninguna lo haga, manteniendo la consistencia.
Validar Datos de Entrada: Antes de ejecutar comandos SQL, valide los datos de entrada para asegurarse de que cumplan con los criterios esperados (por ejemplo, tipos correctos, dentro de los rangos permitidos).
Atrapar Excepciones Específicas: Siempre atrape excepciones específicas para manejar adecuadamente diferentes tipos de errores. Esto permite un manejo y depuración de errores más claros.
Registrar Errores: En lugar de imprimir solo los errores en la consola, considere registrarlos en un archivo o sistema de monitoreo. Esto le ayudará a rastrear problemas en producción.
Degradación Elegante: Diseña tu aplicación para manejar errores con elegancia. Si una operación falla, proporciona retroalimentación significativa al usuario en lugar de hacer que la aplicación se bloquee.
Respaldar Datos Regularmente: Realiza copias de seguridad de tu base de datos regularmente para evitar pérdidas de datos en caso de fallas críticas o corrupción.
Usar Sentencias Preparadas: Las sentencias preparadas ayudan a prevenir ataques de inyección SQL y también pueden proporcionar un mejor rendimiento para consultas repetidas.

Cómo Exportar e Importar Datos [Sección de Bonificación]

En esta sección, aprenderemos cómo exportar datos de una base de datos SQLite a formatos comunes como CSV y JSON, así como cómo importar datos a SQLite desde estos formatos usando Python. Esto es útil para compartir datos, hacer copias de seguridad y integrar con otras aplicaciones.

Exportar Datos de SQLite a CSV

Exportar datos a un archivo CSV (Valores Separados por Comas) es directo con las bibliotecas integradas de Python. Los archivos CSV son ampliamente utilizados para almacenamiento y intercambio de datos, haciendo de ellos un formato conveniente para exportar datos.

Aquí tienes cómo exportar datos de una tabla SQLite a un archivo CSV:

import sqlite3
import csv

def export_to_csv(file_name):
    """Export data from the Customers table to a CSV file."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Ejecuta una consulta para obtener todos los datos de los clientes
        cursor.execute("SELECT * FROM Customers;")
        customers = cursor.fetchall()

        # Escribe los datos en un archivo CSV
        with open(file_name, 'w', newline='') as csv_file:
            csv_writer = csv.writer(csv_file)
            csv_writer.writerow(['ID', 'Name', 'Balance'])  # Escribir encabezado
            csv_writer.writerows(customers)  # Escribir filas de datos

        print(f"Data exported successfully to {file_name}.")

# Ejemplo de uso
export_to_csv('customers.csv')

Cómo exportar datos a JSON

De manera similar, puedes exportar datos a un archivo JSON (JavaScript Object Notation), que es un formato popular para el intercambio de datos, especialmente en aplicaciones web.

Aquí tienes un ejemplo de cómo exportar datos a JSON:

import json
import sqlite3


def export_to_json(file_name):
    """Export data from the Customers table to a JSON file."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Ejecuta una consulta para obtener todos los datos de los clientes
        cursor.execute("SELECT * FROM Customers;")
        customers = cursor.fetchall()

        # Convierte los datos en una lista de diccionarios
        customers_list = [{'ID': customer[0], 'Name': customer[1],
                           'Balance': customer[2]} for customer in customers]

        # Escribe los datos en JSON
        with open(file_name, 'w') as json_file:
            json.dump(customers_list, json_file, indent=4)

        print(f"Data exported successfully to {file_name}.")


# Ejemplo de uso
export_to_json('customers.json')

Cómo importar datos a SQLite desde un archivo CSV

También puedes importar datos desde un archivo CSV a una base de datos SQLite. Esto es útil para poblar tu base de datos con conjuntos de datos existentes.

Aquí tienes cómo importar datos desde un archivo CSV:

import csv
import sqlite3


def import_from_csv(file_name):
    """Import data from a CSV file into the Customers table."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Abre el archivo CSV para lectura
        with open(file_name, 'r') as csv_file:
            csv_reader = csv.reader(csv_file)
            next(csv_reader)  # Omitir la fila de encabezado

            # Insertar cada fila en la tabla Customers
            for row in csv_reader:
                cursor.execute(
                    "INSERT INTO Customers (name, balance) VALUES (?, ?);", (row[1], row[2]))

        connection.commit()
        print(f"Data imported successfully from {file_name}.")


# Ejemplo de uso
import_from_csv('customer_data.csv')

Cómo importar datos a SQLite desde JSON

De forma similar, importar datos desde un archivo JSON es simple. Puedes leer el archivo JSON e insertar los datos en tu tabla SQLite.

Aquí está cómo hacerlo:

import json
import sqlite3


def import_from_json(file_name):
    """Import data from a JSON file into the Customers table."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Abre el archivo JSON para lectura
        with open(file_name, 'r') as json_file:
            customers_list = json.load(json_file)

            # Inserta cada cliente en la tabla Customers
            for customer in customers_list:
                cursor.execute("INSERT INTO Customers (name, balance) VALUES (?, ?);", (customer['Name'], customer['Balance']))

        connection.commit()
        print(f"Data imported successfully from {file_name}.")


# Ejemplo de uso
import_from_json('customer_data.json')

Resumiendo

Y con eso terminamos! Este guía te ha presentado los fundamentos de trabajar con SQLite en Python, cubriendo desde configurar tu entorno hasta consultar y manipular datos, así como exportar e importar información. Espero que lo haya encontrado útil y que haya despertado tu interés en usar SQLite para tus proyectos.

¡Ahora es tiempo de poner en práctica tu nuevo conocimiento! Te animo a que crees tu proyecto usando SQLite y Python. Ya sea una aplicación simple para gestionar tu biblioteca, una herramienta de presupuesto o algo único, las posibilidades son ilimitadas.

Una vez que hayas completado tu proyecto, compártelo en Twitter y etiquétame. Me encantaría ver lo que has creado y celebrar tus logros.

Puede encontrar todo el código de este tutorial en GitHub. Gracias por acompañarme y ¡buena codificación!

Genera una Tabla de Contenidos para tus artículos de freeCodeCamp gratuitamente usando la herramienta Generador de TOC.

Cómo configurar su entorno de Python

Instalación de Python

Instalación del módulo SQLite3

Cómo crear un entorno virtual (opcional pero recomendado)

Instalando bibliotecas necesarias

Cómo Crear una Base de Datos SQLite

Cómo Funcionan las Bases de Datos SQLite

Cómo Crear una Nueva Base de Datos SQLite

Conectándonos a la Base de Datos

Creando un Cursor

Cerrando la Conexión

Cómo Usar el Gestor de Contexto para Abrir y Cerrar Conexiones

Cómo Crear Tablas de Base de Datos

Tipos de Datos en SQLite y su Mapeo a Python

Cómo Insertar Datos en una Tabla

Cómo Insertar un Registro Único

Cómo Insertar Múltiples Registros

Cómo manejar problemas comunes: Inyección SQL

Cómo consultar datos

Cómo obtener todos los registros

Cómo obtener un solo registro

Cómo Obtener Múltiples Registros

Cómo Utilizar pandas para una Mejor presentación de Datos

Cómo Actualizar y Eliminar Datos

Actualizar Registros Existentes

Cómo Eliminar Registros de la Tabla

Consideraciones Importantes

Cómo utilizar transacciones

¿Por qué utilizar transacciones?

¿Cuándo utilizar transacciones?

Cómo manejar transacciones en Python

Iniciar una Transacción

Cómo confirmar una transacción

Deshacer una transacción

Ejemplo de uso de transacciones en Python

Cómo Optimizar el Rendimiento de las Consultas de SQLite con la Indexación

Cómo Llenar la Base de Datos con Datos Falsos

Cómo realizar consultas sin índices

Nos presentamos con el Plan de Consulta

Cómo Crear un Índice

Cómo consultar con índices

Comparando Resultados de Rendimiento

Comparación de Tiempo de Ejecución

Resumen de Mejora de Rendimiento

Mejores Prácticas para el Uso de Índices

Cuándo y Por Qué Usar Índices

Potenciales Inconvenientes de los Índices

Cómo manejar errores y excepciones

Errores Comunes en Operaciones SQLite

Cómo Utilizar el Manejo de Excepciones en Python

Mejores Prácticas para Garantizar la Integridad de la Base de Datos

Cómo Exportar e Importar Datos [Sección de Bonificación]

Exportar Datos de SQLite a CSV

Cómo exportar datos a JSON

Cómo importar datos a SQLite desde un archivo CSV

Cómo importar datos a SQLite desde JSON

Resumiendo

Cómo Utilizar `pandas` para una Mejor presentación de Datos