2.5. SQLite

Nota

Propósito: es una libraría proporciona una interfaz SQL compatible con la especificación DB-API 2.0 requiere SQLite, 3.7.15 o posterior.

sqlite3, es una libraría de C que provee una base de datos ligera basada en disco que no requiere un proceso de servidor separado y permite acceder a la base de datos usando una variación no estándar del lenguaje de consulta SQL.

../_images/sqlite_logo.png

Figura 2.3, Logotipo de SQLite

Algunas aplicaciones pueden usar SQLite para almacenamiento interno. También es posible prototipar una aplicación usando SQLite y luego transferir el código a una base de datos más grande como PostgreSQL u Oracle.

2.5.1. Instalación

El módulo sqlite3 esta incluida en librería estándar de Python, puede probar la instalación existe, ejecutando el siguiente comando:

python3 -c "import sqlite3 ; print(sqlite3.__package__)"

Si muestra el nombre del módulo sqlite3, tiene correctamente instalado el módulo. Con esto, ya tiene todo listo para continuar.

Adicionalmente puedes instalar administradores de base de datos SQLite nativos para sistemas operativos Linux y Windows, a continuación se presentan alternativas:

2.5.1.1. SQLite Tools

Es un paquete de herramientas de línea de comandos para administrar archivos de base de datos SQLite, incluido el programa sqlite3.exe para la shell de línea de comandos, el programa sqldiff.exe y el programa sqlite3_analyzer.exe.

Para instalar el administrador de base de datos SQLite SQLite Tools de forma nativa para sistemas operativos Linux y Windows, a continuación se presentan los modos de instalación:

Para instalar administradores de base de datos nativos sqlite3 para la plataforma Unix/Linux debe seguir los siguientes pasos:

sudo apt install -y sqlite3

Puede probar si la instalación se realizo correctamente, ejecutando el siguiente comando:

sqlite3

Si ejecuto el comando anterior, este da como resultado lo siguiente:

SQLite version 3.40.1 2022-12-28 14:03:47
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.
sqlite>

Si muestra la consola SQLite sqlite>, tiene correctamente instalado el administrador de base de datos nativa sqlite3 por línea de comando.

Nota

Más información consulte https://www.sqlite.org/cli.html

2.5.1.2. DB Browser for SQLite

DB Browser for SQLite (DB4S), es una herramienta de código abierto, visual y de alta calidad para crear, diseñar y editar archivos de bases de datos compatibles con SQLite.

Esta herramienta esta destinada para usuarios y desarrolladores que desean crear, buscar y editar bases de datos. DB4S utiliza una interfaz familiar similar a una hoja de cálculo y no es necesario aprender complicados comandos SQL.

../_images/dbbrowser4sqlite_logo.jpg

Figura 2.5, Logotipo de DB Browser for SQLite

Los controles y asistentes están disponibles para que los usuarios:

  • Crear y compactar archivos de base de datos.

  • Crear, definir, modificar y eliminar tablas.

  • Crear, definir y eliminar índices.

  • Explorar, editar, agregar y eliminar registros.

  • Buscar registros.

  • Importar y exportar registros como texto.

  • Importar y exportar tablas desde/a archivos CSV.

  • Importar y exportar bases de datos desde/hacia archivos de volcado de SQL.

  • Emita consultas SQL e inspeccione los resultados.

  • Examinar un registro de todos los comandos SQL emitidos por la aplicación.

  • Trace gráficos simples basados en tablas o datos de consulta.

Nota

Más información consulte https://sqlitebrowser.org/

Para instalar el administrador de base de datos SQLite DB Browser for SQLite (DB4S) de forma nativa para sistemas operativos Linux y Windows, a continuación se presentan los modos de instalación:

Para instalar el programa sqlitebrowser para administrador de base de datos nativos sqlite3 para la plataforma Unix/Linux debe seguir los siguientes pasos:

sudo apt install -y sqlitebrowser

Puede probar si la instalación del el administrador de base de datos nativo de sqlite3 gráfico llamado sqlitebrowser se realizo correctamente, ejecutando el siguiente comando:

sqlitebrowser

El comando anterior debería mostrar la interfaz gráfica de sqlitebrowser, como se muestra a continuación:

../_images/dbbrowser4sqlite_linux.png

Figura 2.6, DB Browser for SQLite en Linux

Si muestra la interfaz gráfica de sqlitebrowser, tiene correctamente instalado el administrador de base de datos gráfico nativo de sqlite3.

2.5.1.3. Estructura de archivos

Para crear la estructura de archivos del proyecto SQLite debe ejecutar los siguientes comandos:

Crear el directorio crud con el siguiente comando:

Crear y acceder al directorio en un solo comando, ejecutando el siguiente comando:

mkdir -p ~/proyectos/sqlite/crud && cd $_

El comando anterior crea la siguiente estructura de directorios:

proyectos/
└── sqlite/
    └── crud/

Si tiene la estructura de archivo previa, entonces puede continuar con la siguiente sección.

2.5.2. Cadenas de conexión

Para definir el método connect debe definir las cadenas de conexión con SQLite como se describe a continuación:

DB_PATH

Ruta absoluta o relativa del archivo de base de datos SQLite.

DB_FILE

Nombre del archivo de base de datos SQLite.

A continuación presento un ejemplo en Python implementando una cadena de conexión para una base de datos SQLite:

1
2
3
4
5
6
7
8
import os
import sqlite3

DB_PATH = os.path.dirname(os.path.abspath(__file__)) + os.sep
DB_FILE = "sistema.db"
DB = DB_PATH + DB_FILE

conexion = sqlite3.connect(DB)

El ejemplo anterior se describe a continuación:

  • En la línea 1, se importa el módulo os de la librería estándar de Python.

  • En la línea 2, se importa el módulo sqlite3 de la librería estándar de Python.

  • En la línea 4, se define en la constante DB_PATH la ruta absoluta usada para guardar la base de datos.

  • En la línea 5, se define en la constante DB_FILE el nombre de la base de datos.

  • En la línea 6, se define en la constante DB la ruta completa usada para leer la base de datos.

De esta forma se crea una cadena de conexión para SQLite para ser usada por el método connect.

2.5.3. Insertar registros

Si requiere insertar registro en una tabla, a continuación tiene un ejemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
"""Programa para la inserción de registro(s) de la tabla"""

import logging
import sqlite3
import os

logging.basicConfig(level=logging.INFO)

DB_PATH = os.path.dirname(os.path.abspath(__file__)) + os.sep
DB_FILE = "sistema.db"
DB = DB_PATH + DB_FILE

# Script CREATE TABLE SQL para crear tabla clientes
CREATE_TABLE_SQL = """
CREATE TABLE IF NOT EXISTS clientes (
    id INTEGER UNIQUE NOT NULL,
    nombre TEXT NOT NULL,
    apellido TEXT NOT NULL,
    codigo_postal INTEGER NOT NULL,
    telefono TEXT NOT NULL,
    PRIMARY KEY(id)
);"""

# Creando una lista de filas a ingresar
MULTIPLE_COLUMNS = [
    (1, "Leonardo", "Caballero", "5001", "+58-412-4734567"),
    (2, "Ana", "Poleo", "6302", "+58-426-5831297"),
    (3, "Manuel", "Matos", "4001", "+58-414-2360943"),
]

# Script INSERT SQL a usar al ingresar datos
INSERT_SQL_SCRIPTS = """INSERT INTO clientes VALUES (?, ?, ?, ?, ?);"""


def insertar_registro(create_table_sql, insert_sql, insert_values):
    """Función para la inserción de registro de la tabla"""

    conexion = None
    try:
        # Establecer la conexión con la base de datos
        conexion = sqlite3.connect(DB)
        # Crear un objeto cursor para la base de datos
        cursor = conexion.cursor()
        logging.info(f"✅ ¡Conectado a la base de datos '{DB_FILE}'!\n")
        # Crear la tabla productos si no existe
        cursor.execute(create_table_sql)
        # Confirmar la creación de la tabla
        conexion.commit()
        logging.info(
            f"✅ ¡Fue creo una tabla correctamente en la base de datos '{DB_FILE}'!\n"
        )
        # Insertar nuevos registros en la tabla
        cursor.executemany(insert_sql, insert_values)
        # Confirmar la inserción de los registros
        conexion.commit()
        logging.info(
            f"✅ ¡Fueron insertado(s) {cursor.rowcount} registro(s) correctamente en la tabla!\n"
        )
        # Insertar un nuevo registro en la tabla
        cursor.execute(
            insert_sql, (4, "Liliana", "Andradez", "3105", "+58-414-6782473")
        )
        # Confirmar la inserción del registro
        conexion.commit()
        logging.info(
            f"✅ ¡Fueron insertado(s) {cursor.rowcount} registro(s) correctamente en la tabla!\n"
        )
        # Cerrar el cursor
        cursor.close()
    except sqlite3.Error as error:
        logging.error(
            f"❌ ERROR: ¡Fallo la inserción de registro(s) en la tabla!: {error}\n"
        )
    finally:
        if conexion:
            # Cerrar la conexión a la base de datos
            conexion.close()
            logging.info(
                f"✅ ¡La conexión SQLite a la base de datos '{DB_FILE}' fue cerrada!"
            )


if __name__ == "__main__":
    insertar_registro(CREATE_TABLE_SQL, INSERT_SQL_SCRIPTS, MULTIPLE_COLUMNS)

Importante

Usted puede descargar el código usado en esta sección haciendo clic en el siguiente enlace:

Truco

Para ejecutar el código sqlite3_record_insert.py abra una consola de comando, acceda al directorio donde se encuentra el programa:

proyectos/
└── sqlite/
    └── crud/
        └── sqlite_record_insert.py

Si tiene la estructura de archivo previa, entonces ejecute el siguiente comando:

python3 sqlite_record_insert.py

El anterior código al ejecutar debe mostrar el siguiente mensaje:

INFO:root:✅ ¡Conectado a la base de datos 'sistema.db'!

INFO:root:✅ ¡Fue creo una tabla correctamente en la base de datos 'sistema.db'!

INFO:root:✅ ¡Fueron insertado(s) 3 registro(s) correctamente en la tabla!

INFO:root:✅ ¡Fueron insertado(s) 1 registro(s) correctamente en la tabla!

INFO:root:✅ ¡La conexión SQLite a la base de datos 'sistema.db' fue cerrada!

De esta forma puede ingresar registros en una tabla dentro una base de datos SQLite.

2.5.4. Consultar registros

Si requiere consultar registros de tabla, a continuación tiene un ejemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
"""Programa para la consulta de registro(s) de la tabla"""

import logging
import sqlite3
import os

logging.basicConfig(level=logging.INFO)

DB_PATH = os.path.dirname(os.path.abspath(__file__)) + os.sep
DB_FILE = "sistema.db"
DB = DB_PATH + DB_FILE

# Script SELECT SQL a usar al consultar datos
SELECT_SQL_SCRIPTS = """SELECT * FROM clientes;"""


def consultar_registro(select_sql):
    """Función para la consulta de registro(s) de la tabla"""

    conexion = None
    try:
        # Establecer la conexión con la base de datos
        conexion = sqlite3.connect(DB)
        # Crear un objeto cursor para ejecutar las consultas
        cursor = conexion.cursor()
        logging.info(f"✅ ¡Conectado a la base de datos '{DB_FILE}'!\n")
        # Realizar consulta la tabla clientes
        cursor.execute(select_sql)
        # Recuperar los registros de la consulta
        registros = cursor.fetchall()
        # Mostrar los registros de la tabla
        print(f"📜 Total de filas son: {len(registros)} \n")
        print("📜 Mostrar cada fila: \n")
        for fila in registros:
            print(f"\tId: {fila[0]}")
            print(f"\tNombre: {fila[1]} {fila[2]}")
            print(f"\tCódigo postal: {fila[3]}")
            print(f"\tTeléfono: {fila[4]}\n")
        # Cerrar el cursor
        cursor.close()
    except sqlite3.Error as error:
        logging.error(
            f"❌ ERROR: ¡Fallo la consulta de registro(s) en la tabla!: {error}"
        )
    finally:
        if conexion:
            # Cerrar la conexión a la base de datos
            conexion.close()
            logging.info(
                f"✅ ¡La conexión SQLite a la base de datos '{DB_FILE}' fue cerrada!"
            )


if __name__ == "__main__":
    consultar_registro(SELECT_SQL_SCRIPTS)

Importante

Usted puede descargar el código usado en esta sección haciendo clic en el siguiente enlace:

Truco

Para ejecutar el código sqlite3_record_select.py abra una consola de comando, acceda al directorio donde se encuentra el programa:

proyectos/
└── sqlite/
    └── crud/
        └── sqlite_record_select.py

Si tiene la estructura de archivo previa, entonces ejecute el siguiente comando:

python3 sqlite_record_select.py

El anterior código al ejecutar debe mostrar el siguiente mensaje:

INFO:root:✅ ¡Conectado a la base de datos 'sistema.db'!

📜 Total de filas son: 4

📜 Mostrar cada fila:

        Id: 1
        Nombre: Leonardo Caballero
        Código postal: 5001
        Teléfono: +58-412-4734567

        Id: 2
        Nombre: Ana Poleo
        Código postal: 6302
        Teléfono: +58-426-5831297

        Id: 3
        Nombre: Manuel Matos
        Código postal: 4001
        Teléfono: +58-414-2360943

        Id: 4
        Nombre: Liliana Andradez
        Código postal: 3105
        Teléfono: +58-414-6782473

INFO:root:✅ ¡La conexión SQLite a la base de datos 'sistema.db' fue cerrada!

De esta forma puede consultar registros en una tabla dentro una base de datos SQLite.

2.5.5. Actualizar registros

Si requiere actualizar registro de tabla, a continuación tiene un ejemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
"""Programa para la actualización de registro de la tabla"""

import logging
import sqlite3
import os

logging.basicConfig(level=logging.INFO)

DB_PATH = os.path.dirname(os.path.abspath(__file__)) + os.sep
DB_FILE = "sistema.db"
DB = DB_PATH + DB_FILE

# Creando una lista de filas a actualizar
MULTIPLE_COLUMNS = [
    ("5051", 1),
    ("6303", 2),
]

# Script UPDATE SQL a usar al actualizar datos
UPDATE_SQL_SCRIPTS = """UPDATE clientes SET codigo_postal = ? WHERE id = ?;"""


def actualizar_registro(update_sql, update_values):
    """Función para la actualización de registro de la tabla"""

    conexion = None
    try:
        # Establecer la conexión con la base de datos
        conexion = sqlite3.connect(DB)
        # Crear un cursor para la base de datos
        cursor = conexion.cursor()
        logging.info(f"✅ ¡Conectado a la base de datos '{DB_FILE}'!\n")
        # Actualizar nuevos registros en la tabla
        cursor.executemany(update_sql, update_values)
        # Guardar los cambios en la base de datos
        conexion.commit()
        logging.info(
            f"✅ ¡Fueron actualizado(s) {cursor.rowcount} registro(s) correctamente en la tabla!\n"
        )
        # Cerrar el cursor
        cursor.close()
    except sqlite3.Error as error:
        logging.error(
            f"❌ ERROR: ¡Fallo la actualización de registro(s) en la tabla!: {error}"
        )
    finally:
        if conexion:
            # Cerrar la conexión a la base de datos
            conexion.close()
            logging.info(
                f"✅ ¡La conexión SQLite a la base de datos '{DB_FILE}' fue cerrada!"
            )


if __name__ == "__main__":
    actualizar_registro(UPDATE_SQL_SCRIPTS, MULTIPLE_COLUMNS)

Importante

Usted puede descargar el código usado en esta sección haciendo clic en el siguiente enlace:

Truco

Para ejecutar el código sqlite3_record_update.py abra una consola de comando, acceda al directorio donde se encuentra el programa:

proyectos/
└── sqlite/
    └── crud/
        └── sqlite_record_update.py

Si tiene la estructura de archivo previa, entonces ejecute el siguiente comando:

python3 sqlite_record_update.py

El anterior código al ejecutar debe mostrar el siguiente mensaje:

INFO:root:✅ ¡Conectado a la base de datos 'sistema.db'!

INFO:root:✅ ¡Fueron actualizado(s) 2 registro(s) correctamente en la tabla!

INFO:root:✅ ¡La conexión SQLite a la base de datos 'sistema.db' fue cerrada!

De esta forma puede actualizar registros en una tabla dentro una base de datos SQLite.

2.5.6. Eliminar registros

Si requiere eliminar registro de tabla, a continuación tiene un ejemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
"""Programa para la eliminación de registro de la tabla"""

import logging
import sqlite3
import os

logging.basicConfig(level=logging.INFO)

DB_PATH = os.path.dirname(os.path.abspath(__file__)) + os.sep
DB_FILE = "sistema.db"
DB = DB_PATH + DB_FILE

# Script DELETE SQL a usar al eliminar datos
DELETE_SQL_SCRIPTS = """DELETE FROM clientes WHERE id = 3;"""


def eliminar_registro(delete_sql):
    """Función para la eliminación de registro de la tabla"""

    conexion = None
    try:
        # Establecer la conexión con la base de datos
        conexion = sqlite3.connect(DB)
        # Crear un objeto cursor para ejecutar las eliminaciones
        cursor = conexion.cursor()
        logging.info(f"✅ ¡Conectado a la base de datos '{DB_FILE}'!\n")
        # Eliminar un fila de registro simple
        cursor.execute(delete_sql)
        # Guardar los cambios en la base de datos
        conexion.commit()
        logging.info("✅ ¡Registro eliminado correctamente!\n")
        # Cerrar el cursor
        cursor.close()
    except sqlite3.Error as error:
        logging.error(
            f"❌ ERROR: ¡Fallo la eliminación de registro(s) en la tabla!: {error}"
        )
    finally:
        if conexion:
            # Cerrar la conexión a la base de datos
            conexion.close()
            logging.info(
                f"✅ ¡La conexión SQLite a la base de datos '{DB_FILE}' fue cerrada!"
            )


if __name__ == "__main__":
    eliminar_registro(DELETE_SQL_SCRIPTS)

Importante

Usted puede descargar el código usado en esta sección haciendo clic en el siguiente enlace:

Truco

Para ejecutar el código sqlite3_record_delete.py abra una consola de comando, acceda al directorio donde se encuentra el programa:

proyectos/
└── sqlite/
    └── crud/
        └── sqlite_record_delete.py

Si tiene la estructura de archivo previa, entonces ejecute el siguiente comando:

python3 sqlite_record_delete.py

El anterior código al ejecutar debe mostrar el siguiente mensaje:

INFO:root:✅ ¡Conectado a la base de datos 'sistema.db'!

INFO:root:✅ ¡Registro eliminado correctamente!

INFO:root:✅ ¡La conexión SQLite a la base de datos 'sistema.db' fue cerrada!

De esta forma puede eliminar registros en una tabla dentro una base de datos SQLite.

Nota

Así de esta forma puede realizar las operaciones de ingresar, consultar, actualizar y eliminar registro en una tabla en una base de datos SQLite de forma separada en programas Python, en la siguiente práctica se mostrara un caso real de uso de todos estas operaciones en un solo programa Python.

2.5.7. Práctica - Caso real

A continuación se presenta una práctica más real de implementar el uso de proyectos con sqlite3, a continuación la estructura de proyecto llamado sqlite:

A continuación se presenta y explica el uso de cada archivo para este proyecto:

Archivo .env.example

Archivo plantilla dotenv del paquete adicional python-dotenv.

1
2
### SQLite #############################
DB=sistema.db

Archivo requirements.txt

Archivo de requirements.txt de la herramienta de gestión de paquetes pip.

1
2
# Install the packages from PyPi repository.
python-dotenv==0.21.0

Archivo settings.py

Módulo de configuraciones del programa.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import os
from dotenv import load_dotenv

load_dotenv()

# Nombre del archivo de base de datos.
DB_FILE = os.getenv("DB")

# Script CREATE TABLE SQL para crear tabla(s)
CREATE_TABLE_SQL = """
CREATE TABLE IF NOT EXISTS clientes (
    id INTEGER UNIQUE NOT NULL,
    nombre TEXT NOT NULL,
    apellido TEXT NOT NULL,
    codigo_postal INTEGER NOT NULL,
    telefono TEXT NOT NULL,
    PRIMARY KEY(id)
);"""

# Lista de filas a ingresar
INSERT_MULTIPLE_COLUMNS = [
    (1, "Leonardo", "Caballero", "5001", "+58-412-4734567"),
    (2, "Ana", "Poleo", "6302", "+58-426-5831297"),
    (3, "Manuel", "Matos", "4001", "+58-414-2360943"),
]

# Script INSERT SQL a usar al ingresar datos
INSERT_SQL_SCRIPTS = """INSERT INTO clientes VALUES (?, ?, ?, ?, ?);"""

# Script SELECT SQL a usar al consultar datos
SELECT_SQL_SCRIPTS = """SELECT * FROM clientes;"""

# Lista de filas a actualizar
UPDATE_MULTIPLE_COLUMNS = [
    ("5051", 1),
    ("6303", 2),
]

# Script UPDATE SQL a usar al actualizar datos
UPDATE_SQL_SCRIPTS = """UPDATE clientes SET codigo_postal = ? WHERE id = ?;"""

# Script DELETE SQL a usar al eliminar datos
DELETE_SQL_SCRIPTS = """DELETE FROM clientes WHERE id = 3;"""

Archivo main.py

Módulo de principal del programa.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
"""Programa para realizar operaciones a base de datos SQLite"""

import logging
from settings import (
    DB_FILE,
    CREATE_TABLE_SQL,
    INSERT_MULTIPLE_COLUMNS,
    INSERT_SQL_SCRIPTS,
    SELECT_SQL_SCRIPTS,
    UPDATE_MULTIPLE_COLUMNS,
    UPDATE_SQL_SCRIPTS,
    DELETE_SQL_SCRIPTS,
)
import os
from sqlite3 import Error, OperationalError, ProgrammingError, connect

logging.basicConfig(level=logging.INFO)

DB_PATH = os.path.dirname(os.path.abspath(__file__)) + os.sep
DB = DB_PATH + (DB_FILE or "")


def crear_conexion(ruta):
    """Crear conexión con un servidor SQLite

    Args:
        ruta (str): La ruta completa usada para leer la base de datos

    Returns:
        conexion_bd (Connection): Representación conexión a la base de datos SQLite
    """
    conexion_bd = None
    try:
        # Establecer la conexión con la base de datos
        conexion_bd = connect(ruta)
        logging.info(
            f"✅ ¡Conexión a la base de datos '{os.path.basename(ruta)}' fue exitosa!\n"
        )
    except ProgrammingError as e:
        logging.error(f"❌ ERROR: ¡Se produjo una falla de programación: '{e}'!")
    except OperationalError as e:
        logging.error(f"❌ ERROR: Se produjo lo siguiente: '{e}'")
    return conexion_bd


def crear_tablas(conexion_bd, create_table_sql):
    """Creación de tabla(s) dentro de la base de datos

    Args:
        conexion_bd (Connection): Representación conexión a la base de datos SQLite
        create_table_sql (str): Script CREATE TABLE SQL para crear tabla(s)
    """
    try:
        # Crear un objeto cursor para ejecutar script SQL
        cursor = conexion_bd.cursor()
        # Crear la tabla(s) si no existe
        cursor.execute(create_table_sql)
        # Hacer persistentes los cambios en la base de datos
        conexion_bd.commit()
        if cursor.rowcount == -1:
            logging.info(f"✅ ¡Las tabla(s) ya existen en la base de datos!\n")
        else:
            logging.info(
                f"✅ ¡Fueron creado(s) {cursor.rowcount} tabla(s) correctamente en la base de datos!\n"
            )
        # Cerrar el cursor
        cursor.close()
    except Error as error:
        logging.error(
            f"❌ ERROR: ¡Fallo la creación de tabla(s) en la base de datos!: {error}"
        )


def insertar_registro(conexion_bd, insert_values, insert_sql):
    """Función para la inserción de registro de la tabla

    Args:
        conexion_bd (Connection): Representación conexión a la base de datos SQLite
        insert_values (list): Lista de filas a ingresar
        insert_sql (str): Script INSERT SQL a usar al ingresar datos
    """
    try:
        # Crear un objeto cursor para ejecutar script SQL
        cursor = conexion_bd.cursor()
        # Insertar nuevos registros en la tabla
        cursor.executemany(insert_sql, insert_values)
        logging.info(
            f"✅ ¡Fueron insertado(s) {cursor.rowcount} registro(s) correctamente en la tabla!\n"
        )
        # Insertar un nuevo registro en la tabla
        cursor.execute(
            INSERT_SQL_SCRIPTS, (4, "Liliana", "Andradez", "3105", "+58-414-6782473")
        )
        # Hacer persistentes los cambios en la base de datos
        conexion_bd.commit()
        logging.info(
            f"✅ ¡Fueron insertado(s) {cursor.rowcount} registro(s) correctamente en la tabla!"
        )
        # Cerrar el cursor
        cursor.close()
    except Error as error:
        logging.error(
            f"❌ ERROR: ¡Fallo la inserción de registro(s) en la tabla!: {error}\n"
        )


def consultar_registro(conexion_bd, select_sql):
    """Función para la consulta de registro(s) de la tabla

    Args:
        conexion_bd (Connection): Representación conexión a la base de datos SQLite
        select_sql (str): Script SELECT SQL a usar al consultar datos
    """
    try:
        # Crear un objeto cursor para ejecutar script SQL
        cursor = conexion_bd.cursor()
        # Realizar consulta la tabla clientes
        cursor.execute(select_sql)
        # Recuperar los registros de la consulta
        registros = cursor.fetchall()
        # Mostrar los registros de la tabla
        print(f"\n📜 Total de filas son: {len(registros)} \n")
        print("📜 Mostrar cada fila: \n")
        for fila in registros:
            print(f"\tId: {fila[0]}")
            print(f"\tNombre: {fila[1]} {fila[2]}")
            print(f"\tCódigo postal: {fila[3]}")
            print(f"\tTeléfono: {fila[4]}\n")
        # Cerrar el cursor
        cursor.close()
    except Error as error:
        logging.error(
            f"❌ ERROR: ¡Fallo la consulta de registro(s) en la tabla!: {error}"
        )


def actualizar_registro(conexion_bd, update_values, update_sql):
    """Función para la actualización de registro de la tabla

    Args:
        conexion_bd (Connection): Representación conexión a la base de datos SQLite
        update_values (list): Lista de filas a actualizar
        update_sql (str): Script UPDATE SQL a usar al actualizar datos
    """
    try:
        # Crear un objeto cursor para ejecutar script SQL
        cursor = conexion_bd.cursor()
        # Actualizar nuevos registros en la tabla
        cursor.executemany(update_sql, update_values)
        # Hacer persistentes los cambios en la base de datos
        conexion_bd.commit()
        logging.info(
            f"✅ ¡Fueron actualizado(s) {cursor.rowcount} registro(s) correctamente en la tabla!\n"
        )
        # Cerrar el cursor
        cursor.close()
    except Error as error:
        logging.error(
            f"❌ ERROR: ¡Fallo la actualización de registro(s) en la tabla!: {error}"
        )


def eliminar_registro(conexion_bd, delete_sql):
    """Función para la eliminación de registro de la tabla

    Args:
        conexion_bd (Connection): Representación conexión a la base de datos SQLite
        delete_sql (str): Script DELETE SQL a usar al eliminar datos
    """
    try:
        # Crear un objeto cursor para ejecutar script SQL
        cursor = conexion_bd.cursor()
        # Eliminar un fila de registro simple
        cursor.execute(delete_sql)
        # Hacer persistentes los cambios en la base de datos
        conexion_bd.commit()
        logging.info("✅ ¡Registro eliminado correctamente!\n")
        # Cerrar el cursor
        cursor.close()
    except Error as error:
        logging.error(
            f"❌ ERROR: ¡Fallo la eliminación de registro(s) en la tabla!: {error}\n"
        )


if __name__ == "__main__":
    conexion = None
    try:
        # Crear conexión a SQLite
        conexion = crear_conexion(DB)
        # Crear la tabla dentro de la base de datos
        crear_tablas(conexion, CREATE_TABLE_SQL)
        insertar_registro(conexion, INSERT_MULTIPLE_COLUMNS, INSERT_SQL_SCRIPTS)
        consultar_registro(conexion, SELECT_SQL_SCRIPTS)
        actualizar_registro(conexion, UPDATE_MULTIPLE_COLUMNS, UPDATE_SQL_SCRIPTS)
        eliminar_registro(conexion, DELETE_SQL_SCRIPTS)
    except Error as e:
        logging.error(
            f"❌ ERROR: ¡Se produjo un falla al establecer la conexión a la base de datos '{DB_FILE}': '{e}'!"
        )
    finally:
        if conexion:
            # Cerrar la conexión a la base de datos
            conexion.close()
            logging.info(
                f"✅ ¡La conexión SQLite a la base de datos '{DB_FILE}' fue cerrada!"
            )

Teniendo creada la anterior estructura de proyecto, vuelva a ejecutar ahora el módulo con el siguiente comando, el cual a continuación se presentan el correspondiente comando de tu sistema operativo:

Antes de ejecutar debes instalar sus dependencias, con el siguiente comando:

pip3 install -r requirements.txt

Además debe crear el archivo .env en base a la plantilla .env.example` y editarlo, con el siguiente comando:

cp .env.example .env && nano .env

Truco

El archivo .env se definen las configuraciones de conexión a la base de datos, puede modificarlo cambiar valores de la conexión.

Truco

Para ejecutar el código del proyecto llamado sistema abra una consola de comando, acceda al directorio donde se encuentra el programa:

proyectos/
└── sqlite/
    └── sistema/
        ├── __init__.py
        ├── .env
        ├── .env.example
        ├── main.py
        ├── requirements.txt
        └── settings.py

Si tiene la estructura de archivo previa, entonces puede continuar con la ejecución del código fuente.

Truco

Para ejecutar el código fuente de esta práctica debe invocar al módulo main.py, abra una consola de comando, acceda al directorio donde se encuentra la estructura previa y ejecute el siguiente comando:

python3 main.py

El anterior código al ejecutar debe mostrar el siguiente mensaje:

INFO:root:✅ ¡Conexión a la base de datos 'sistema.db' fue exitosa!

INFO:root:✅ ¡Fueron insertado(s) 3 registro(s) correctamente en la tabla!

INFO:root:✅ ¡Fueron insertado(s) 1 registro(s) correctamente en la tabla!

📜 Total de filas son: 4

📜 Mostrar cada fila:

        Id: 1
        Nombre: Leonardo Caballero
        Código postal: 5001
        Teléfono: +58-412-4734567

        Id: 2
        Nombre: Ana Poleo
        Código postal: 6302
        Teléfono: +58-426-5831297

        Id: 3
        Nombre: Manuel Matos
        Código postal: 4001
        Teléfono: +58-414-2360943

        Id: 4
        Nombre: Liliana Andradez
        Código postal: 3105
        Teléfono: +58-414-6782473

INFO:root:✅ ¡Fueron actualizado(s) 2 registro(s) correctamente en la tabla!

INFO:root:✅ ¡Registro eliminado correctamente!

INFO:root:✅ ¡La conexión SQLite a la base de datos 'sistema.db' fue cerrada!

La ejecución anterior generar la siguiente estructura:

proyectos/
└── sqlite/
    └── sistema/
        ├── __init__.py
        ├── .env
        ├── .env.example
        ├── main.py
        ├── requirements.txt
        ├── settings.py
        └── sistema.db

Archivo sistema.db

Archivo de base de datos de SQLite llamado sistema.db la cual no se incluye ya que cada vez que se inicia el programa main.py se elimina y crea nuevamente, para cuidar la creación de los datos iniciales.

Así de esta forma puede ingresar, consultar, actualizar y eliminar registro en una tabla usando SQLite.

Importante

Usted puede descargar el código usado en esta sección haciendo clic en los siguientes enlaces:

Así de esta forma puede replicar una práctica real de un proyecto para realizar operaciones en una base de datos SQLite, aplicando buenas prácticas de código funcional.

Ver también

Consulte la sección de lecturas suplementarias del entrenamiento para ampliar su conocimiento en esta temática.

¿Cómo puedo ayudar?

¡Mi soporte está aquí para ayudar!

Mi horario de oficina es de lunes a sábado, de 9 AM a 5 PM. UTM - Madrid, España.

La hora aquí es actualmente 7:35 PM UTM.

Mi objetivo es responder a todos los mensajes dentro de un día hábil.

Contáctenos en la sección de soporte
Contrata mi increíble soporte profesional