Crud Python - Sqlite

Gu铆a paso a paso como hacer un SQLITE CRUD en Python.

← Consumir Apis Dotenv para variables de entorno →
Tabla de Contenido

Comenzando

Creamos un nuevo archivo main.py:

  • 1

    touch main.py

  • 1

    type null > main.py
main.py 
1
2
3
4
5

def init():
    pass

if __name__ == "__main__":
    init()

La instrucci贸n if __name__ == "__main__": comprueba si el script se est谩 ejecutando como programa principal. Si es as铆, llama a la funci贸n init() que de momento solo tiene la declaraci贸n pass esto es m谩s que nada para promover la modularidad y la reutilizaci贸n. Permite que el script sirva como programa independiente y como m贸dulo importable.

Abrir una nueva conexi贸n a SQLITE

main.py 
import sqlite3

def init():
    conexion = sqlite3.connect("cars.db")

if __name__ == "__main__":
    init()

Ahora como se puede observar en el c贸digo anterior, importamos el m贸dulo de sqlite3 que viene integrado con Python y dentro de la funci贸n init() que arranca junto a la ejecuci贸n del programa almacenamos en la variable conexion una nueva conexi贸n a un archivo llamado cars.db.

Crear una tabla en la base de datos

Para facilitarnos la existencia, vamos a modularizar el c贸digo, quiere decir que vamos subdividir el programa en m谩s archivos.

Creamos un nuevo archivo db.py:

  • 1

    touch db.py

  • 1

    type null > db.py
db.py 
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

import sqlite3
from sqlite3 import Error
import os

CURDIR = os.path.dirname(os.path.abspath(__file__))
FILENAME = "schema.sql"
FILE = os.path.join(CURDIR, "db", FILENAME)

def open_db():
    try:
        con = sqlite3.connect('cars.db')
        return con
    except Error as e:
        print('Error: ', e)

def run_query(sql, params='', multiple=False):

    with open_db() as con:
        cursor = con.cursor()
        try:
            if multiple:
                return cursor.executemany(sql, params)
            else:
                return cursor.execute(sql, params)
        except Error as e:
            print('Error: ', e)

def create_schema():
    with open(FILE, 'r') as sql_file:
        sql_script = sql_file.read()
        schema_created = run_query(sql_script)
        if schema_created.rowcount == -1:
            print("Database created successfully")

if __name__ == "__main__":
    create_schema()

Como vemos en primer lugar tenemos que importar el m贸dulo, luego tenemos que definir algunas funciones como:

open_db()
Se encargar谩 de crear o abrir la base de datos envultos en un bloque try/except para manejar posibles errores.
run_query
Esta funci贸n va a utilizar la conexi贸n que retorna open_db y con ella podemos realizar consultas a la base de datos.
create_schema()
La funci贸n va a construir el esquema de la base de datos que tenemos que crearlo luego en un archivo schema.sql.
  • main.py 
    1
2
3
4
5
6
7

    import db

def init():
    db.create_schema()

if __name__ == "__main__":
    init()
  • db.py 
    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

    import sqlite3
from sqlite3 import Error
import os

CURDIR = os.path.dirname(os.path.abspath(__file__))
FILENAME = "schema.sql"
FILE = os.path.join(CURDIR, "db", FILENAME)

def open_db():
    try:
        con = sqlite3.connect('cars.db')
        return con
    except Error as e:
        print('Error: ', e)

def run_query(sql, params='', multiple=False):

    with open_db() as con:
        cursor = con.cursor()
        try:
            if multiple:
                return cursor.executemany(sql, params)
            else:
                return cursor.execute(sql, params)
        except Error as e:
            print('Error: ', e)

def create_schema():
    with open(FILE, 'r') as sql_file:
        sql_script = sql_file.read()
        schema_created = run_query(sql_script)
        if schema_created.rowcount == -1:
            print("Database created successfully")

if __name__ == "__main__":
    create_schema()
  • db/schema.sql 
    1
2
3
4

    CREATE TABLE IF NOT EXISTS cars(
    brand VARCHAR(50) NOT NULL,
    model VARCHAR(12) NOT NULL
);

Insertar Datos

Para comenzar con las operaciones del CRUD, creamos un nuevo archivo crud.py:

  • 1

    touch crud.py

  • 1

    type null > crud.py

Y en el archivo vamos a crear una funci贸n que pueda utilizar el m贸dulo db.py para llamar a la funci贸n run_query y as铆 insertar algunos datos:

crud.py 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import db

def insert_data():
  insert_query = "INSERT INTO cars (brand, model) VALUES(?, ?)"
  cars_data = [
      ('Chevrolet', 'Chevrolet Camaro'),
      ('Chevrolet', 'Chevrolet Captiva'),
      ('Fiat', 'Fiat 125 Mirafiori'),
      ('Fiat', 'Fiat 125 Centurion'),
      ('Honda', 'Honda CR-V'),
      ('Honda', 'Honda CR-X del Sol'),
      ('Honda', 'Honda CR-Z')
  ]

  result = db.run_query(insert_query, cars_data, True)
  print("Record inserted successfully into table", result.rowcount)

Ahora, desde el m贸dulo principal main.py importamos al m贸dulo crud.py y ejecutamos la funci贸n insert_data:

  • main.py 
    import db
import crud

def init():
    # db.create_schema()
    crud.insert_data()

if __name__ == "__main__":
    init()
  • crud.py 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

    import db

def insert_data():
  insert_query = "INSERT INTO cars (brand, model) VALUES(?, ?)"
  cars_data = [
      ('Chevrolet', 'Chevrolet Camaro'),
      ('Chevrolet', 'Chevrolet Captiva'),
      ('Fiat', 'Fiat 125 Mirafiori'),
      ('Fiat', 'Fiat 125 Centurion'),
      ('Honda', 'Honda CR-V'),
      ('Honda', 'Honda CR-X del Sol'),
      ('Honda', 'Honda CR-Z')
  ]

  result = db.run_query(insert_query, cars_data, True)
  print("Record inserted successfully into table", result.rowcount)
  • db.py 
    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

    import sqlite3
from sqlite3 import Error
import os

CURDIR = os.path.dirname(os.path.abspath(__file__))
FILENAME = "schema.sql"
FILE = os.path.join(CURDIR, "db", FILENAME)

def open_db():
    try:
        con = sqlite3.connect('cars.db')
        return con
    except Error as e:
        print('Error: ', e)

def run_query(sql, params='', multiple=False):

    with open_db() as con:
        cursor = con.cursor()
        try:
            if multiple:
                return cursor.executemany(sql, params)
            else:
                return cursor.execute(sql, params)
        except Error as e:
            print('Error: ', e)

def create_schema():
    with open(FILE, 'r') as sql_file:
        sql_script = sql_file.read()
        schema_created = run_query(sql_script)
        if schema_created.rowcount == -1:
            print("Database created successfully")

if __name__ == "__main__":
    create_schema()


  • 1

    Record inserted successfully into table 7

Consultado los datos de la tabla

Recuperamos los datos insertados anteriormente:

  • main.py 
    1
2
3
4
5
6
7
8
9
10

    import db
import crud

def init():
    # db.create_schema()
    # crud.insert_data()
    crud.get_data()

if __name__ == "__main__":
    init()
  • crud.py 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

    import db
from prettytable import from_db_cursor # pip install prettytable

def get_data():
  select_query = "SELECT * FROM cars"
  result = db.run_query(select_query)
  mytable = from_db_cursor(result)
  mytable.align = "l"
  print(mytable)

def insert_data():
  insert_query = "INSERT INTO cars (brand, model) VALUES(?, ?)"
  cars_data = [
      ('Chevrolet', 'Chevrolet Camaro'),
      ('Chevrolet', 'Chevrolet Captiva'),
      ('Fiat', 'Fiat 125 Mirafiori'),
      ('Fiat', 'Fiat 125 Centurion'),
      ('Honda', 'Honda CR-V'),
      ('Honda', 'Honda CR-X del Sol'),
      ('Honda', 'Honda CR-Z')
  ]

  result = db.run_query(insert_query, cars_data, True)
  print("Record inserted successfully into table", result.rowcount)
  • db.py 
    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

    import sqlite3
from sqlite3 import Error

def open_db():
    try:
        con = sqlite3.connect('cars.db')
        return con

    except Error as e:
        print('Error: ', e)

def run_query(sql, params='', multiple=False):
    with open_db() as con:
        cursor = con.cursor()
        try:
            if multiple:
                return cursor.executemany(sql, params)
            else:
                return cursor.execute(sql, params)
        except Error as e:
            print('Error: ', e)

def create_schema():
    with open('db/schema.sql', 'r') as sql_file:
        sql_script = sql_file.read()
        schema_created = run_query(sql_script)
        if schema_created.rowcount == -1:
            print("Database created successfully")

if __name__ == "__main__":
    create_schema()

  • 1
2
3
4
5
6
7
8
9
10
11

    +-------+-----------+--------------------+
| rowid | brand     | model              |
+-------+-----------+--------------------+
| 1     | Chevrolet | Chevrolet Camaro   |
| 2     | Chevrolet | Chevrolet Captiva  |
| 3     | Fiat      | Fiat 125 Mirafiori |
| 4     | Fiat      | Fiat 125 Centurion |
| 5     | Honda     | Honda CR-V         |
| 6     | Honda     | Honda CR-X del Sol |
| 7     | Honda     | Honda CR-Z         |
+-------+-----------+--------------------+

prettytable es una librer铆a de Python que da formato de tabla a los datos por consola.

Actualizaci贸n de datos

Podemos actualizar los modelos de autos:

  • main.py 
    1
2
3
4
5
6
7
8
9
10
11

    import db
import crud

def init():
    # db.create_schema()
    # crud.insert_data()
    crud.update_data("CR-V", "HR-V")
    crud.get_data()

if __name__ == "__main__":
    init()
  • crud.py 
    1
2
3
4
5
6
7
8
9
10
11
12
13

    import db
from prettytable import from_db_cursor # pip install prettytable

def update_data(model, newModel):
  update_query = "UPDATE cars SET model = ? WHERE model = ?"
  db.run_query(update_query, (newModel, model))

def get_data():
  select_query = "SELECT * FROM cars"
  result = db.run_query(select_query)
  mytable = from_db_cursor(result)
  mytable.align = "l"
  print(mytable)
  • db.py 
    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

    import sqlite3
from sqlite3 import Error

def open_db():
    try:
        con = sqlite3.connect('cars.db')
        return con

    except Error as e:
        print('Error: ', e)

def run_query(sql, params='', multiple=False):
    with open_db() as con:
        cursor = con.cursor()
        try:
            if multiple:
                return cursor.executemany(sql, params)
            else:
                return cursor.execute(sql, params)
        except Error as e:
            print('Error: ', e)

def create_schema():
    with open('db/schema.sql', 'r') as sql_file:
        sql_script = sql_file.read()
        schema_created = run_query(sql_script)
        if schema_created.rowcount == -1:
            print("Database created successfully")

if __name__ == "__main__":
    create_schema()

  • 1
2
3
4
5
6
7
8
9
10
11

    +-------+-----------+---------------+
| rowid | brand     | model         |
+-------+-----------+---------------+
| 1     | Chevrolet | Camaro        |
| 2     | Chevrolet | Captiva       |
| 3     | Fiat      | Mirafiori     |
| 4     | Fiat      | 125 Centurion |
| 5     | Honda     | HR-V          |
| 6     | Honda     | CR-X del Sol  |
| 7     | Honda     | CR-Z          |
+-------+-----------+---------------+

Eliminar datos

Eliminar datos desde la tabla:

  • main.py 
    1
2
3
4
5
6
7
8
9
10
11
12

    import db
import crud

def init():
    # db.create_schema()
    # crud.insert_data()
    # crud.update_data("CR-V", "HR-V")
    crud.delete_data("Camaro")
    crud.get_data()

if __name__ == "__main__":
    init()
  • crud.py 
    1
2
3
4
5
6
7
8
9
10
11
12
13

    import db
from prettytable import from_db_cursor # pip install prettytable

def get_data():
  select_query = "SELECT * FROM cars"
  result = db.run_query(select_query)
  mytable = from_db_cursor(result)
  mytable.align = "l"
  print(mytable)

def delete_data(model):
  delete_query = "DELETE FROM cars WHERE model = ?"
  db.run_query(delete_query, (model,))
  • db.py 
    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

    import sqlite3
from sqlite3 import Error

def open_db():
    try:
        con = sqlite3.connect('cars.db')
        return con

    except Error as e:
        print('Error: ', e)

def run_query(sql, params='', multiple=False):
    with open_db() as con:
        cursor = con.cursor()
        try:
            if multiple:
                return cursor.executemany(sql, params)
            else:
                return cursor.execute(sql, params)
        except Error as e:
            print('Error: ', e)

def create_schema():
    with open('db/schema.sql', 'r') as sql_file:
        sql_script = sql_file.read()
        schema_created = run_query(sql_script)
        if schema_created.rowcount == -1:
            print("Database created successfully")

if __name__ == "__main__":
    create_schema()

  • 1
2
3
4
5
6
7
8
9
10

    +-------+-----------+---------------+
| rowid | brand     | model         |
+-------+-----------+---------------+
| 2     | Chevrolet | Captiva       |
| 3     | Fiat      | Mirafiori     |
| 4     | Fiat      | 125 Centurion |
| 5     | Honda     | HR-V          |
| 6     | Honda     | CR-X del Sol  |
| 7     | Honda     | CR-Z          |
+-------+-----------+---------------+
← Consumir Apis Dotenv para variables de entorno →