sql >> Base de Datos >  >> RDS >> Database

Introducción a las bibliotecas Python SQL

Todas las aplicaciones de software interactúan con datos , más comúnmente a través de un sistema de gestión de bases de datos (DBMS). Algunos lenguajes de programación vienen con módulos que puede usar para interactuar con un DBMS, mientras que otros requieren el uso de paquetes de terceros. En este tutorial, explorará las diferentes bibliotecas SQL de Python que puedes usar. Desarrollará una aplicación sencilla para interactuar con bases de datos SQLite, MySQL y PostgreSQL.

En este tutorial, aprenderá a:

  • Conectar a diferentes sistemas de gestión de bases de datos con bibliotecas Python SQL
  • Interactuar con bases de datos SQLite, MySQL y PostgreSQL
  • Interpretar consultas comunes de bases de datos utilizando una aplicación de Python
  • Desarrollar aplicaciones a través de diferentes bases de datos utilizando un script de Python

Para aprovechar al máximo este tutorial, debe tener conocimientos básicos de Python, SQL y trabajar con sistemas de administración de bases de datos. También debe poder descargar e importar paquetes en Python y saber cómo instalar y ejecutar diferentes servidores de bases de datos de forma local o remota.

Descarga gratuita de PDF: Hoja de referencia de Python 3


Comprender el esquema de la base de datos

En este tutorial, desarrollará una base de datos muy pequeña para una aplicación de redes sociales. La base de datos constará de cuatro tablas:

  1. users
  2. posts
  3. comments
  4. likes

A continuación se muestra un diagrama de alto nivel del esquema de la base de datos:

Ambos users y posts tendrá una relación de uno a muchos, ya que a un usuario le pueden gustar muchas publicaciones. Del mismo modo, un usuario puede publicar muchos comentarios y una publicación también puede tener varios comentarios. Entonces, ambos users y posts también tendrá relaciones de uno a muchos con los comments mesa. Esto también se aplica a los likes tabla, por lo que ambos users y posts tendrá una relación de uno a muchos con los likes mesa.



Uso de bibliotecas Python SQL para conectarse a una base de datos

Antes de interactuar con cualquier base de datos a través de una biblioteca Python SQL, debe conectarse a esa base de datos. En esta sección, verá cómo conectarse a bases de datos SQLite, MySQL y PostgreSQL desde una aplicación de Python.

Nota: Necesitará servidores MySQL y PostgreSQL en funcionamiento antes de ejecutar los scripts en las secciones de la base de datos MySQL y PostgreSQL. Para obtener una introducción rápida sobre cómo iniciar un servidor MySQL, consulte la sección MySQL de Inicio de un proyecto Django. Para aprender a crear una base de datos en PostgreSQL, consulte la sección Configuración de una base de datos de Prevención de ataques de inyección SQL con Python.

Se recomienda que cree tres archivos de Python diferentes, de modo que tenga uno para cada una de las tres bases de datos. Ejecutarás el script para cada base de datos en su archivo correspondiente.


SQLite

SQLite es probablemente la base de datos más sencilla para conectarse con una aplicación de Python, ya que no necesita instalar ningún módulo SQL de Python externo para hacerlo. De forma predeterminada, su instalación de Python contiene una biblioteca Python SQL llamada sqlite3 que puede usar para interactuar con una base de datos SQLite.

Además, las bases de datos SQLite son sin servidor y autónomo , ya que leen y escriben datos en un archivo. Esto significa que, a diferencia de MySQL y PostgreSQL, ¡ni siquiera necesita instalar y ejecutar un servidor SQLite para realizar operaciones de base de datos!

Así es como se usa sqlite3 para conectarse a una base de datos SQLite en Python:

 1import sqlite3
 2from sqlite3 import Error
 3
 4def create_connection(path):
 5    connection = None
 6    try:
 7        connection = sqlite3.connect(path)
 8        print("Connection to SQLite DB successful")
 9    except Error as e:
10        print(f"The error '{e}' occurred")
11
12    return connection

Así es como funciona este código:

  • Líneas 1 y 2 importar sqlite3 y el Error del módulo clase.
  • Línea 4 define una función .create_connection() que acepta la ruta a la base de datos SQLite.
  • Línea 7 usa .connect() desde el sqlite3 módulo y toma la ruta de la base de datos SQLite como parámetro. Si la base de datos existe en la ubicación especificada, se establece una conexión con la base de datos. De lo contrario, se crea una nueva base de datos en la ubicación especificada y se establece una conexión.
  • Línea 8 imprime el estado de la conexión exitosa a la base de datos.
  • Línea 9 detecta cualquier excepción que pueda generarse si .connect() no puede establecer una conexión.
  • Línea 10 muestra el mensaje de error en la consola.

sqlite3.connect(path) devuelve una connection objeto, que a su vez es devuelto por create_connection() . Esta connection El objeto se puede utilizar para ejecutar consultas en una base de datos SQLite. El siguiente script crea una conexión a la base de datos SQLite:

connection = create_connection("E:\\sm_app.sqlite")

Una vez que ejecute el script anterior, verá que un archivo de base de datos sm_app.sqlite se crea en el directorio raíz. Tenga en cuenta que puede cambiar la ubicación para que coincida con su configuración.



MySQL

A diferencia de SQLite, no hay un módulo Python SQL predeterminado que pueda usar para conectarse a una base de datos MySQL. En su lugar, deberá instalar un controlador Python SQL para MySQL con el fin de interactuar con una base de datos MySQL desde dentro de una aplicación de Python. Uno de esos controladores es mysql-connector-python . Puede descargar este módulo Python SQL con pip :

$ pip install mysql-connector-python

Tenga en cuenta que MySQL es un basado en servidor sistema de administración de base de datos. Un servidor MySQL puede tener múltiples bases de datos. A diferencia de SQLite, donde crear una conexión equivale a crear una base de datos, una base de datos MySQL tiene un proceso de dos pasos para la creación de la base de datos:

  1. Establecer una conexión a un servidor MySQL.
  2. Ejecutar una consulta independiente para crear la base de datos.

Defina una función que se conecte al servidor de la base de datos MySQL y devuelva el objeto de conexión:

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection(host_name, user_name, user_password):
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect(
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        )
12        print("Connection to MySQL DB successful")
13    except Error as e:
14        print(f"The error '{e}' occurred")
15
16    return connection
17
18connection = create_connection("localhost", "root", "")

En el script anterior, define una función create_connection() que acepta tres parámetros:

  1. nombre_del_host
  2. nombre_de_usuario
  3. contraseña_usuario

El mysql.connector El módulo Python SQL contiene un método .connect() que usa en la línea 7 para conectarse a un servidor de base de datos MySQL. Una vez establecida la conexión, la connection el objeto se devuelve a la función de llamada. Finalmente, en la línea 18 llamas a create_connection() con el nombre de host, el nombre de usuario y la contraseña.

Hasta ahora, solo ha establecido la conexión. La base de datos aún no está creada. Para hacer esto, definirá otra función create_database() que acepta dos parámetros:

  1. connection es la connection objeto al servidor de la base de datos con el que desea interactuar.
  2. query es la consulta que crea la base de datos.

Así es como se ve esta función:

def create_database(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Database created successfully")
    except Error as e:
        print(f"The error '{e}' occurred")

Para ejecutar consultas, utiliza el cursor objeto. La query a ejecutar se pasa a cursor.execute() en formato de cadena.

Crea una base de datos llamada sm_app para su aplicación de redes sociales en el servidor de base de datos MySQL:

create_database_query = "CREATE DATABASE sm_app"
create_database(connection, create_database_query)

Ahora ha creado una base de datos sm_app en el servidor de base de datos. Sin embargo, la connection objeto devuelto por create_connection() está conectado al servidor de base de datos MySQL. Debes conectarte a la sm_app base de datos. Para hacerlo, puede modificar create_connection() de la siguiente manera:

 1def create_connection(host_name, user_name, user_password, db_name):
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect(
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        )
10        print("Connection to MySQL DB successful")
11    except Error as e:
12        print(f"The error '{e}' occurred")
13
14    return connection

Puedes ver en la línea 8 que create_connection() ahora acepta un parámetro adicional llamado db_name . Este parámetro especifica el nombre de la base de datos a la que desea conectarse. Puede pasar el nombre de la base de datos a la que desea conectarse cuando llama a esta función:

connection = create_connection("localhost", "root", "", "sm_app")

El script anterior llama con éxito a create_connection() y se conecta a la sm_app base de datos.



PostgreSQL

Al igual que MySQL, no existe una biblioteca Python SQL predeterminada que pueda usar para interactuar con una base de datos PostgreSQL. En su lugar, debe instalar un controlador Python SQL de terceros para interactuar con PostgreSQL. Uno de estos controladores Python SQL para PostgreSQL es psycopg2 . Ejecute el siguiente comando en su terminal para instalar psycopg2 Módulo Python SQL:

$ pip install psycopg2

Al igual que con las bases de datos SQLite y MySQL, definirá create_connection() para hacer una conexión con su base de datos PostgreSQL:

import psycopg2
from psycopg2 import OperationalError

def create_connection(db_name, db_user, db_password, db_host, db_port):
    connection = None
    try:
        connection = psycopg2.connect(
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        )
        print("Connection to PostgreSQL DB successful")
    except OperationalError as e:
        print(f"The error '{e}' occurred")
    return connection

Usas psycopg2.connect() para conectarse a un servidor PostgreSQL desde su aplicación Python.

Luego puede usar create_connection() para crear una conexión a una base de datos PostgreSQL. Primero, establecerá una conexión con la base de datos predeterminada postgres usando la siguiente cadena:

connection = create_connection(
    "postgres", "postgres", "abc123", "127.0.0.1", "5432"
)

A continuación, debe crear la base de datos sm_app dentro del postgres predeterminado base de datos. Puede definir una función para ejecutar cualquier consulta SQL en PostgreSQL. A continuación, define create_database() para crear una nueva base de datos en el servidor de base de datos PostgreSQL:

def create_database(connection, query):
    connection.autocommit = True
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Query executed successfully")
    except OperationalError as e:
        print(f"The error '{e}' occurred")

create_database_query = "CREATE DATABASE sm_app"
create_database(connection, create_database_query)

Una vez que ejecute el script anterior, verá la sm_app base de datos en su servidor de base de datos PostgreSQL.

Antes de ejecutar consultas en sm_app base de datos, necesita conectarse a ella:

connection = create_connection(
    "sm_app", "postgres", "abc123", "127.0.0.1", "5432"
)

Una vez que ejecute el script anterior, se establecerá una conexión con sm_app base de datos ubicada en postgres servidor de base de datos. Aquí, 127.0.0.1 se refiere a la dirección IP del host del servidor de la base de datos y 5432 se refiere al número de puerto del servidor de la base de datos.




Creación de tablas

En la sección anterior, vio cómo conectarse a servidores de bases de datos SQLite, MySQL y PostgreSQL utilizando diferentes bibliotecas Python SQL. Creaste la sm_app base de datos en los tres servidores de bases de datos. En esta sección, verá cómo crear tablas dentro de estas tres bases de datos.

Como se discutió anteriormente, creará cuatro tablas:

  1. users
  2. posts
  3. comments
  4. likes

Empezarás con SQLite.


SQLite

Para ejecutar consultas en SQLite, use cursor.execute() . En esta sección, definirá una función execute_query() que utiliza este método. Tu función aceptará la connection objeto y una cadena de consulta, que pasará a cursor.execute() .

.execute() puede ejecutar cualquier consulta que se le pase en forma de cadena. Utilizará este método para crear tablas en esta sección. En las próximas secciones, utilizará este mismo método para ejecutar consultas de actualización y eliminación también.

Nota: Este script debe ejecutarse en el mismo archivo donde creó la conexión para su base de datos SQLite.

Aquí está la definición de su función:

def execute_query(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        connection.commit()
        print("Query executed successfully")
    except Error as e:
        print(f"The error '{e}' occurred")

Este código intenta ejecutar la query dada e imprime un mensaje de error si es necesario.

A continuación, escribe tu consulta :

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL,
  age INTEGER,
  gender TEXT,
  nationality TEXT
);
"""

Esto dice que cree una tabla users con las siguientes cinco columnas:

  1. id
  2. name
  3. age
  4. gender
  5. nationality

Finalmente, llamará a execute_query() para crear la tabla. Pasarás la connection objeto que creó en la sección anterior, junto con el create_users_table cadena que contiene la consulta de creación de tabla:

execute_query(connection, create_users_table)

La siguiente consulta se utiliza para crear las posts tabla:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts(
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id)
);
"""

Dado que existe una relación de uno a muchos entre users y posts , puede ver una clave externa user_id en las posts tabla que hace referencia al id columna en los users mesa. Ejecute el siguiente script para crear las posts tabla:

execute_query(connection, create_posts_table)

Finalmente, puedes crear los comments y likes tablas con el siguiente script:

create_comments_table = """
CREATE TABLE IF NOT EXISTS comments (
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  text TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  post_id INTEGER NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id) FOREIGN KEY (post_id) REFERENCES posts (id)
);
"""

create_likes_table = """
CREATE TABLE IF NOT EXISTS likes (
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  user_id INTEGER NOT NULL, 
  post_id integer NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id) FOREIGN KEY (post_id) REFERENCES posts (id)
);
"""

execute_query(connection, create_comments_table)  
execute_query(connection, create_likes_table)

Puedes ver que crear tablas en SQLite es muy similar a usar SQL sin formato. Todo lo que tiene que hacer es almacenar la consulta en una variable de cadena y luego pasar esa variable a cursor.execute() .



MySQL

Usarás el mysql-connector-python Módulo Python SQL para crear tablas en MySQL. Al igual que con SQLite, debe pasar su consulta a cursor.execute() , que se devuelve llamando a .cursor() en la connection objeto. Puedes crear otra función execute_query() que acepta la connection y query cadena:

 1def execute_query(connection, query):
 2    cursor = connection.cursor()
 3    try:
 4        cursor.execute(query)
 5        connection.commit()
 6        print("Query executed successfully")
 7    except Error as e:
 8        print(f"The error '{e}' occurred")

En la línea 4, pasa la query a cursor.execute() .

Ahora puedes crear tus users tabla usando esta función:

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
  id INT AUTO_INCREMENT, 
  name TEXT NOT NULL, 
  age INT, 
  gender TEXT, 
  nationality TEXT, 
  PRIMARY KEY (id)
) ENGINE = InnoDB
"""

execute_query(connection, create_users_table)

La consulta para implementar la relación de clave externa es ligeramente diferente en MySQL en comparación con SQLite. Además, MySQL usa el AUTO_INCREMENT palabra clave (en comparación con SQLite AUTOINCREMENT palabra clave) para crear columnas donde los valores se incrementan automáticamente cuando se insertan nuevos registros.

El siguiente script crea las posts tabla, que contiene una clave foránea user_id que hace referencia al id columna de los users tabla:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts (
  id INT AUTO_INCREMENT, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  FOREIGN KEY fk_user_id (user_id) REFERENCES users(id), 
  PRIMARY KEY (id)
) ENGINE = InnoDB
"""

execute_query(connection, create_posts_table)

Del mismo modo, para crear los comments y likes tablas, puede pasar el correspondiente CREATE consultas a execute_query() .



PostgreSQL

Al igual que con las bases de datos SQLite y MySQL, la connection objeto devuelto por psycopg2.connect() contiene un cursor objeto. Puedes usar cursor.execute() para ejecutar consultas Python SQL en su base de datos PostgreSQL.

Definir una función execute_query() :

def execute_query(connection, query):
    connection.autocommit = True
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Query executed successfully")
    except OperationalError as e:
        print(f"The error '{e}' occurred")

Puede usar esta función para crear tablas, insertar registros, modificar registros y eliminar registros en su base de datos PostgreSQL.

Ahora crea los users tabla dentro de la sm_app base de datos:

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL, 
  age INTEGER,
  gender TEXT,
  nationality TEXT
)
"""

execute_query(connection, create_users_table)

Puede ver que la consulta para crear los users table en PostgreSQL es ligeramente diferente a SQLite y MySQL. Aquí, la palabra clave SERIAL se utiliza para crear columnas que se incrementan automáticamente. Recuerde que MySQL usa la palabra clave AUTO_INCREMENT .

Además, la referencia de clave externa también se especifica de manera diferente, como se muestra en el siguiente script que crea las posts tabla:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts (
  id SERIAL PRIMARY KEY, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER REFERENCES users(id)
)
"""

execute_query(connection, create_posts_table)

Para crear los comments tabla, tendrás que escribir un CREATE consulta por los comments tabla y pásela a execute_query() . El proceso para crear los likes la mesa es la misma. Solo tienes que modificar el CREATE consulta para crear los likes tabla en lugar de los comments mesa.




Inserción de registros

En la sección anterior, vio cómo crear tablas en sus bases de datos SQLite, MySQL y PostgreSQL utilizando diferentes módulos Python SQL. En esta sección, verá cómo insertar registros en sus tablas.


SQLite

Para insertar registros en su base de datos SQLite, puede usar el mismo execute_query() función que usó para crear tablas. Primero, debe almacenar su INSERT INTO consulta en una cadena. Luego, puede pasar la connection objeto y query cadena a execute_query() . Insertemos cinco registros en los users tabla:

create_users = """
INSERT INTO
  users (name, age, gender, nationality)
VALUES
  ('James', 25, 'male', 'USA'),
  ('Leila', 32, 'female', 'France'),
  ('Brigitte', 35, 'female', 'England'),
  ('Mike', 40, 'male', 'Denmark'),
  ('Elizabeth', 21, 'female', 'Canada');
"""

execute_query(connection, create_users)

Desde que configuraste el id columna para auto-incrementar, no necesita especificar el valor del id columna para estos users . Los users la tabla autocompletará estos cinco registros con id valores de 1 a 5 .

Ahora inserte seis registros en las posts tabla:

create_posts = """
INSERT INTO
  posts (title, description, user_id)
VALUES
  ("Happy", "I am feeling very happy today", 1),
  ("Hot Weather", "The weather is very hot today", 2),
  ("Help", "I need some help with my work", 2),
  ("Great News", "I am getting married", 1),
  ("Interesting Game", "It was a fantastic game of tennis", 5),
  ("Party", "Anyone up for a late-night party today?", 3);
"""

execute_query(connection, create_posts)

Es importante mencionar que el user_id columna de las posts la tabla es una clave externa que hace referencia al id columna de los users mesa. Esto significa que el user_id la columna debe contener un valor que ya existe en el id columna de los users mesa. Si no existe, verá un error.

De manera similar, el siguiente script inserta registros en los comments y likes tablas:

create_comments = """
INSERT INTO
  comments (text, user_id, post_id)
VALUES
  ('Count me in', 1, 6),
  ('What sort of help?', 5, 3),
  ('Congrats buddy', 2, 4),
  ('I was rooting for Nadal though', 4, 5),
  ('Help with your thesis?', 2, 3),
  ('Many congratulations', 5, 4);
"""

create_likes = """
INSERT INTO
  likes (user_id, post_id)
VALUES
  (1, 6),
  (2, 3),
  (1, 5),
  (5, 4),
  (2, 4),
  (4, 2),
  (3, 6);
"""

execute_query(connection, create_comments)
execute_query(connection, create_likes)

En ambos casos, almacena su INSERT INTO consulta como una cadena y ejecútala con execute_query() .



MySQL

Hay dos formas de insertar registros en bases de datos MySQL desde una aplicación de Python. El primer enfoque es similar a SQLite. Puede almacenar el INSERT INTO consulta en una cadena y luego usa cursor.execute() para insertar registros.

Anteriormente, definió una función contenedora execute_query() que utilizó para insertar registros. Puede usar esta misma función ahora para insertar registros en su tabla MySQL. El siguiente script inserta registros en los users tabla usando execute_query() :

create_users = """
INSERT INTO
  `users` (`name`, `age`, `gender`, `nationality`)
VALUES
  ('James', 25, 'male', 'USA'),
  ('Leila', 32, 'female', 'France'),
  ('Brigitte', 35, 'female', 'England'),
  ('Mike', 40, 'male', 'Denmark'),
  ('Elizabeth', 21, 'female', 'Canada');
"""

execute_query(connection, create_users)

El segundo enfoque usa cursor.executemany() , que acepta dos parámetros:

  1. La consulta cadena que contiene marcadores de posición para los registros que se insertarán
  2. La lista de registros que desea insertar

Mire el siguiente ejemplo, que inserta dos registros en los likes tabla:

sql = "INSERT INTO likes ( user_id, post_id ) VALUES ( %s, %s )"
val = [(4, 5), (3, 4)]

cursor = connection.cursor()
cursor.executemany(sql, val)
connection.commit()

Depende de usted qué enfoque elija para insertar registros en su tabla MySQL. Si es un experto en SQL, puede usar .execute() . Si no está muy familiarizado con SQL, entonces puede ser más sencillo para usted usar .executemany() . Con cualquiera de los dos enfoques, puede insertar registros con éxito en las posts , comments y likes mesas.



PostgreSQL

En la sección anterior, vio dos enfoques para insertar registros en las tablas de la base de datos SQLite. El primero usa una consulta de cadena SQL y el segundo usa .executemany() . psycopg2 sigue este segundo enfoque, aunque .execute() se utiliza para ejecutar una consulta basada en marcador de posición.

Pasa la consulta SQL con los marcadores de posición y la lista de registros a .execute() . Cada registro en la lista será una tupla, donde los valores de la tupla corresponden a los valores de la columna en la tabla de la base de datos. Así es como puede insertar registros de usuario en users tabla en una base de datos PostgreSQL:

users = [
    ("James", 25, "male", "USA"),
    ("Leila", 32, "female", "France"),
    ("Brigitte", 35, "female", "England"),
    ("Mike", 40, "male", "Denmark"),
    ("Elizabeth", 21, "female", "Canada"),
]

user_records = ", ".join(["%s"] * len(users))

insert_query = (
    f"INSERT INTO users (name, age, gender, nationality) VALUES {user_records}"
)

connection.autocommit = True
cursor = connection.cursor()
cursor.execute(insert_query, users)

El script anterior crea una lista de users que contiene cinco registros de usuario en forma de tuplas. A continuación, crea una cadena de marcador de posición con cinco elementos de marcador de posición (%s ) que corresponden a los cinco registros de usuario. La cadena de marcador de posición se concatena con la consulta que inserta registros en los users mesa. Finalmente, la cadena de consulta y los registros de usuario se pasan a .execute() . El script anterior inserta con éxito cinco registros en los users mesa.

Eche un vistazo a otro ejemplo de inserción de registros en una tabla de PostgreSQL. El siguiente script inserta registros en las posts tabla:

posts = [
    ("Happy", "I am feeling very happy today", 1),
    ("Hot Weather", "The weather is very hot today", 2),
    ("Help", "I need some help with my work", 2),
    ("Great News", "I am getting married", 1),
    ("Interesting Game", "It was a fantastic game of tennis", 5),
    ("Party", "Anyone up for a late-night party today?", 3),
]

post_records = ", ".join(["%s"] * len(posts))

insert_query = (
    f"INSERT INTO posts (title, description, user_id) VALUES {post_records}"
)

connection.autocommit = True
cursor = connection.cursor()
cursor.execute(insert_query, posts)

Puede insertar registros en los comments y likes tablas con el mismo enfoque.




Selección de registros

En esta sección, verá cómo seleccionar registros de las tablas de la base de datos utilizando los diferentes módulos SQL de Python. En particular, verá cómo realizar SELECT consultas en sus bases de datos SQLite, MySQL y PostgreSQL.


SQLite

Para seleccionar registros usando SQLite, puede usar nuevamente cursor.execute() . Sin embargo, después de hacer esto, deberá llamar a .fetchall() . Este método devuelve una lista de tuplas donde cada tupla se asigna a la fila correspondiente en los registros recuperados.

Para simplificar el proceso, puede crear una función execute_read_query() :

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except Error as e:
        print(f"The error '{e}' occurred")

Esta función acepta la connection objeto y el SELECT consulta y devuelve el registro seleccionado.


SELECT

Ahora seleccionemos todos los registros de los users tabla:

select_users = "SELECT * from users"
users = execute_read_query(connection, select_users)

for user in users:
    print(user)

En el script anterior, SELECT consulta selecciona todos los usuarios de los users mesa. Esto se pasa a execute_read_query() , que devuelve todos los registros de los users mesa. Luego, los registros se recorren y se imprimen en la consola.

Nota: No se recomienda usar SELECT * en tablas grandes, ya que puede generar una gran cantidad de operaciones de E/S que aumentan el tráfico de red.

El resultado de la consulta anterior se ve así:

(1, 'James', 25, 'male', 'USA')
(2, 'Leila', 32, 'female', 'France')
(3, 'Brigitte', 35, 'female', 'England')
(4, 'Mike', 40, 'male', 'Denmark')
(5, 'Elizabeth', 21, 'female', 'Canada')

De la misma forma, puedes recuperar todos los registros de las posts tabla con el siguiente script:

select_posts = "SELECT * FROM posts"
posts = execute_read_query(connection, select_posts)

for post in posts:
    print(post)

La salida se ve así:

(1, 'Happy', 'I am feeling very happy today', 1)
(2, 'Hot Weather', 'The weather is very hot today', 2)
(3, 'Help', 'I need some help with my work', 2)
(4, 'Great News', 'I am getting married', 1)
(5, 'Interesting Game', 'It was a fantastic game of tennis', 5)
(6, 'Party', 'Anyone up for a late-night party today?', 3)

El resultado muestra todos los registros en las posts mesa.



JOIN

You can also execute complex queries involving JOIN operations to retrieve data from two related tables. For instance, the following script returns the user ids and names, along with the description of the posts that these users posted:

select_users_posts = """
SELECT
  users.id,
  users.name,
  posts.description
FROM
  posts
  INNER JOIN users ON users.id = posts.user_id
"""

users_posts = execute_read_query(connection, select_users_posts)

for users_post in users_posts:
    print(users_post)

Here’s the output:

(1, 'James', 'I am feeling very happy today')
(2, 'Leila', 'The weather is very hot today')
(2, 'Leila', 'I need some help with my work')
(1, 'James', 'I am getting married')
(5, 'Elizabeth', 'It was a fantastic game of tennis')
(3, 'Brigitte', 'Anyone up for a late night party today?')

You can also select data from three related tables by implementing multiple JOIN operators . The following script returns all posts, along with the comments on the posts and the names of the users who posted the comments:

select_posts_comments_users = """
SELECT
  posts.description as post,
  text as comment,
  name
FROM
  posts
  INNER JOIN comments ON posts.id = comments.post_id
  INNER JOIN users ON users.id = comments.user_id
"""

posts_comments_users = execute_read_query(
    connection, select_posts_comments_users
)

for posts_comments_user in posts_comments_users:
    print(posts_comments_user)

The output looks like this:

('Anyone up for a late night party today?', 'Count me in', 'James')
('I need some help with my work', 'What sort of help?', 'Elizabeth')
('I am getting married', 'Congrats buddy', 'Leila')
('It was a fantastic game of tennis', 'I was rooting for Nadal though', 'Mike')
('I need some help with my work', 'Help with your thesis?', 'Leila')
('I am getting married', 'Many congratulations', 'Elizabeth')

You can see from the output that the column names are not being returned by .fetchall() . To return column names, you can use the .description attribute of the cursor objeto. For instance, the following list returns all the column names for the above query:

cursor = connection.cursor()
cursor.execute(select_posts_comments_users)
cursor.fetchall()

column_names = [description[0] for description in cursor.description]
print(column_names)

The output looks like this:

['post', 'comment', 'name']

You can see the names of the columns for the given query.



WHERE

Now you’ll execute a SELECT query that returns the post, along with the total number of likes that the post received:

select_post_likes = """
SELECT
  description as Post,
  COUNT(likes.id) as Likes
FROM
  likes,
  posts
WHERE
  posts.id = likes.post_id
GROUP BY
  likes.post_id
"""

post_likes = execute_read_query(connection, select_post_likes)

for post_like in post_likes:
    print(post_like)

The output is as follows:

('The weather is very hot today', 1)
('I need some help with my work', 1)
('I am getting married', 2)
('It was a fantastic game of tennis', 1)
('Anyone up for a late night party today?', 2)

By using a WHERE clause, you’re able to return more specific results.




MySQL

The process of selecting records in MySQL is absolutely identical to selecting records in SQLite. You can use cursor.execute() followed by .fetchall() . The following script creates a wrapper function execute_read_query() that you can use to select records:

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except Error as e:
        print(f"The error '{e}' occurred")

Now select all the records from the users table:

select_users = "SELECT * FROM users"
users = execute_read_query(connection, select_users)

for user in users:
    print(user)

The output will be similar to what you saw with SQLite.



PostgreSQL

The process of selecting records from a PostgreSQL table with the psycopg2 Python SQL module is similar to what you did with SQLite and MySQL. Again, you’ll use cursor.execute() followed by .fetchall() to select records from your PostgreSQL table. The following script selects all the records from the users table and prints them to the console:

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except OperationalError as e:
        print(f"The error '{e}' occurred")

select_users = "SELECT * FROM users"
users = execute_read_query(connection, select_users)

for user in users:
    print(user)

Again, the output will be similar to what you’ve seen before.




Updating Table Records

In the last section, you saw how to select records from SQLite, MySQL, and PostgreSQL databases. In this section, you’ll cover the process for updating records using the Python SQL libraries for SQLite, PostgresSQL, and MySQL.


SQLite

Updating records in SQLite is pretty straightforward. You can again make use of execute_query() . As an example, you can update the description of the post with an id of 2 . First, SELECT the description of this post:

select_post_description = "SELECT description FROM posts WHERE id = 2"

post_description = execute_read_query(connection, select_post_description)

for description in post_description:
    print(description)

You should see the following output:

('The weather is very hot today',)

The following script updates the description:

update_post_description = """
UPDATE
  posts
SET
  description = "The weather has become pleasant now"
WHERE
  id = 2
"""

execute_query(connection,  update_post_description)

Now, if you execute the SELECT query again, you should see the following result:

('The weather has become pleasant now',)

The output has been updated.



MySQL

The process of updating records in MySQL with mysql-connector-python is also a carbon copy of the sqlite3 Python SQL module. You need to pass the string query to cursor.execute() . For example, the following script updates the description of the post with an id of 2 :

update_post_description = """
UPDATE
  posts
SET
  description = "The weather has become pleasant now"
WHERE
  id = 2
"""

execute_query(connection,  update_post_description)

Again, you’ve used your wrapper function execute_query() to update the post description.



PostgreSQL

The update query for PostgreSQL is similar to what you’ve seen with SQLite and MySQL. You can use the above scripts to update records in your PostgreSQL table.




Deleting Table Records

In this section, you’ll see how to delete table records using the Python SQL modules for SQLite, MySQL, and PostgreSQL databases. The process of deleting records is uniform for all three databases since the DELETE query for the three databases is the same.


SQLite

You can again use execute_query() to delete records from YOUR SQLite database. All you have to do is pass the connection object and the string query for the record you want to delete to execute_query() . Then, execute_query() will create a cursor object using the connection and pass the string query to cursor.execute() , which will delete the records.

As an example, try to delete the comment with an id of 5 :

delete_comment = "DELETE FROM comments WHERE id = 5"
execute_query(connection, delete_comment)

Now, if you select all the records from the comments table, you’ll see that the fifth comment has been deleted.



MySQL

The process for deletion in MySQL is also similar to SQLite, as shown in the following example:

delete_comment = "DELETE FROM comments WHERE id = 2"
execute_query(connection, delete_comment)

Here, you delete the second comment from the sm_app database’s comments table in your MySQL database server.



PostgreSQL

The delete query for PostgreSQL is also similar to SQLite and MySQL. You can write a delete query string by using the DELETE keyword and then passing the query and the connection object to execute_query() . This will delete the specified records from your PostgreSQL database.




Conclusion

In this tutorial, you’ve learned how to use three common Python SQL libraries. sqlite3 , mysql-connector-python , and psycopg2 allow you to connect a Python application to SQLite, MySQL, and PostgreSQL databases, respectively.

Now you can:

  • Interact with SQLite, MySQL, or PostgreSQL databases
  • Use three different Python SQL modules
  • Execute SQL queries on various databases from within a Python application

However, this is just the tip of the iceberg! There are also Python SQL libraries for object-relational mapping , such as SQLAlchemy and Django ORM, that automate the task of database interaction in Python. You’ll learn more about these libraries in other tutorials in our Python databases section.