Última actualización: 15 de diciembre de 2023

2.4. 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.

SQLite, 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.jpg

Figura 2.1, Figura 2.1, 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.4.1. Instalación

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

$ python -c "import sqlite3 ; print(sqlite3.__package__)"

Si muestra el nombre del paquete sqlite3, tiene instalado la librería.

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

2.4.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 sqlite3

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

$ sqlite3
SQLite version 3.31.1 2020-01-27 19:55:54
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 instalada el administrador de base de datos nativa sqlite3 por linea de comando.

Nota

Mas información consulte https://www.sqlite.org/cli.html

2.4.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.3, Figura 2.3, 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

Mas 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 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.4, Figura 2.4, DB Browser for SQLite en Linux

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

2.4.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 linea 1, se importa la librería os de la librería estándar Python.

  • En la linea 2, se importa la librería sqlite3 de la librería estándar Python.

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

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

  • En la linea 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.4.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
 
"""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

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

SQL_SCRIPTS = """INSERT INTO clientes VALUES (?, ?, ?, ?, ?);"""


def insertar_registro():
    """Función para la inserción de registro de la tabla"""

    try:
        conexion = sqlite3.connect(DB)
        cursor = conexion.cursor()
        logging.info(f"¡Conectado a la base de datos {DB_FILE}!\n")

        count = cursor.executemany(SQL_SCRIPTS, MULTIPLE_COLUMNS)
        conexion.commit()
        logging.info(
            "¡Fueron insertado(s) {} registro(s) correctamente en la tabla!\n".format(
                cursor.rowcount
            )
        )
        cursor.close()

    except sqlite3.Error as error:
        print("¡Fallo la inserción de registro(s) en la tabla!", error)
    finally:
        if conexion:
            conexion.close()
            logging.info(
                "¡La conexión SQLite a la base de datos {} fue cerrada!\n".format(
                    DB_FILE
                )
            )


if __name__ == "__main__":
    insertar_registro()

Importante

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

Truco

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

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

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

$ python 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:¡Fueron insertado(s) 3 registro(s) correctamente en la tabla!

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

2.4.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
 
"""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
SQL_SCRIPTS = """SELECT * FROM clientes;"""


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

    try:
        conexion = sqlite3.connect(DB)
        cursor = conexion.cursor()
        logging.info(f"¡Conectado a la base de datos {DB_FILE}!\n")

        cursor.execute(SQL_SCRIPTS)
        registros = cursor.fetchall()

        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]}")
            print(f"\tCódigo postal: {fila[2]}")
            print(f"\tTeléfono: {fila[3]}\n")

        cursor.close()

    except sqlite3.Error as error:
        print("¡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(
                "¡La conexión SQLite a la base de datos {} fue cerrada!\n".format(
                    DB_FILE
                )
            )


if __name__ == "__main__":
    consultar_registro()

Importante

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

Truco

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

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

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

$ python 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: 3

Mostrar cada fila:

        Id: 1
        Nombre: Leonardo
        Código postal: Caballero
        Teléfono: 5001

        Id: 2
        Nombre: Ana
        Código postal: Poleo
        Teléfono: 6302

        Id: 3
        Nombre: Pedro
        Código postal: Lopez
        Teléfono: 4001

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

2.4.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
 
"""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),
]

SQL_SCRIPTS = """UPDATE clientes SET codigo_postal = ? WHERE id = ?;"""


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

    try:
        # Crear la instancia de DB y pasar el nombre del archivo
        conexion = sqlite3.connect(DB)
        cursor = conexion.cursor()
        logging.info(f"¡Conectado a la base de datos {DB_FILE}!\n")

        count = cursor.executemany(SQL_SCRIPTS, MULTIPLE_COLUMNS)
        # Guardar los cambios en la base de datos
        conexion.commit()
        logging.info(
            "¡Fueron actualizado(s) {} registro(s) correctamente en la tabla!\n".format(
                cursor.rowcount
            )
        )
        cursor.close()

    except sqlite3.Error as error:
        print("¡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(
                "¡La conexión SQLite a la base de datos {} fue cerrada!\n".format(
                    DB_FILE
                )
            )


if __name__ == "__main__":

Importante

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

Truco

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

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

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

$ python 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!

2.4.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
 
"""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
SQL_SCRIPTS = """DELETE FROM clientes WHERE id = 3;"""


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

    try:
        conexion = sqlite3.connect(DB)
        cursor = conexion.cursor()
        logging.info(f"¡Conectado a la base de datos {DB_FILE}!\n")

        # Eliminar un fila de registro simple
        cursor.execute(SQL_SCRIPTS)
        # Guardar los cambios en la base de datos
        conexion.commit()
        logging.info("¡Registro eliminado correctamente!\n")
        cursor.close()

    except sqlite3.Error as error:
        print("¡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(
                "¡La conexión SQLite a la base de datos {} fue cerrada!\n".format(
                    DB_FILE
                )
            )


if __name__ == "__main__":
    eliminar_registro()

Importante

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

Truco

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

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

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

$ python 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!

Asi de esta forma puede ingresar, consultar, actualizar y eliminar registro en una tabla en una base de datos SQLite.

2.4.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 main.py

Modulo 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
 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
 
""" Programa para realizar operaciones a base de datos SQLite """

from settings import *
import logging
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


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:
        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:
        print(f"ERROR: ¡Se produjo una falla de programación: '{e}'!")
    except OperationalError as e:
        print(f"ERROR: Se produjo lo siguiente: '{e}'")

    return conexion_bd


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:
        cursor = conexion_bd.cursor()
        count = cursor.executemany(insert_sql, insert_values)
        conexion.commit()
        logging.info(
            "¡Fueron insertado(s) {} registro(s) correctamente en la tabla!\n".format(
                cursor.rowcount
            )
        )
        cursor.close()
    except Error as error:
        print("¡Fallo la inserción de registro(s) en la tabla!", error)


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:
        cursor = conexion_bd.cursor()
        cursor.execute(select_sql)
        registros = cursor.fetchall()

        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]}")
            print(f"\tCódigo postal: {fila[2]}")
            print(f"\tTeléfono: {fila[3]}\n")

        cursor.close()

    except Error as error:
        print("¡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): _description_
    """

    try:
        cursor = conexion_bd.cursor()
        count = cursor.executemany(update_sql, update_values)
        conexion.commit()
        logging.info(
            "¡Fueron actualizado(s) {} registro(s) correctamente en la tabla!\n".format(
                cursor.rowcount
            )
        )
        cursor.close()

    except Error as error:
        print("¡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:
        cursor = conexion_bd.cursor()
        cursor.execute(delete_sql)
        conexion.commit()
        logging.info("¡Registro eliminado correctamente!\n")
        cursor.close()

    except Error as error:
        print("¡Fallo la eliminación de registro(s) en la tabla!", error)


if __name__ == "__main__":
    conexion = crear_conexion(DB)
    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)

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

Modulo 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
 
import os
from dotenv import load_dotenv

load_dotenv()

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

# Lista de filas a ingresar
INSERT_MULTIPLE_COLUMNS = [
    (1, "Leonardo", "Caballero", "5001", "+58-412-4734567"),
    (2, "Ana", "Poleo", "6302", "+58-426-5831297"),
    (3, "Pedro", "Lopez", "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 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.

Teniendo creada la anterior estructura de proyecto, vuelva a ejecutar ahora el modulo 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:

$ pip install -r requirements.txt

Ademas debe instalar y editar el archivo .env, 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 fuente de esta practica debe invocar al modulo main.py, abra una consola de comando, acceda al directorio donde se encuentra la estructura previa y ejecute el siguiente comando:

$ python 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!

Total de filas son: 3

Mostrar cada fila:

        Id: 1
        Nombre: Leonardo
        Código postal: Caballero
        Teléfono: 5001

        Id: 2
        Nombre: Ana
        Código postal: Poleo
        Teléfono: 6302

        Id: 3
        Nombre: Pedro
        Código postal: Lopez
        Teléfono: 4001

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

INFO:root:¡Registro eliminado correctamente!

Asi 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:

Truco

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

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

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

$ python main.py

Ver también

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