Tutorial de MySQL en Python: primeros pasos

Crear una base de datos nueva en MySQL con Python

A partir de aquí necesitarás conocimientos de SQL; el curso Introduction to SQL de DataCamp es un buen punto de partida para ponerte al día. 

La forma típica de crear una base de datos en MySQL es la siguiente: 

CREATE DATABASE book_ratings;

Para ejecutar la misma consulta en Python, debes crear una instancia del objeto cursor(). 

Desde el objeto cursor() puedes pasar comandos SQL como cadena al método execute(), que ejecutará el código. 

Creemos una base de datos llamada “book_ratings”…

create_db = "CREATE DATABASE book_ratings"
with database.cursor() as cursor:
    cursor.execute(create_db)

Nota: si ejecutas este código varias veces, se producirá un error indicando que la base de datos ya existe.

Puedes comprobar las bases de datos existentes en un servidor así:

show_existing_db = "SHOW DATABASES"

with database.cursor() as cursor: 
    cursor.execute(show_existing_db)
    for db in cursor:
        print(db)

"""
('book_ratings',)
('information_schema',)
('mysql',)
('performance_schema',)
('sakila',)
('sys',)
('world',)
"""

El código anterior imprime los nombres de todas las bases de datos que hay actualmente en nuestro servidor MySQL. Hay más de una porque el servidor MySQL genera automáticamente bases de datos para proporcionar acceso a distintos metadatos y configuraciones del servidor.

Conectar con una base de datos existente

Imagina que ya has creado una base de datos, pero aún no te has conectado al servidor; ¿cómo te conectarías directamente a esa base de datos? 

Muy fácil. 

Pasa el nombre de la base de datos como argumento al método connect():

try:
    with connector.connect(
        host = "localhost",
        user = "root",
        password = PASSWORD,
        database = "book_ratings"
    ) as database:
       
        print(database})

except connector.Error as e:
    print(e)

"""
<mysql.connector.connection_cext.CMySQLConnection object at 0x0000016DD8C24970>
"""

Crear tablas

La información de una base de datos se almacena en tablas. Una tabla es simplemente un formato para guardar una colección de datos relacionados compuesta por columnas y filas. 

Puede haber varias tablas dentro de una misma base de datos, aunque no estén relacionadas entre sí. También puedes tener una base de datos relacional con una sola tabla, como mostraremos en esta sección. Amplía tus conocimientos sobre bases de datos relacionales con el curso Introduction to Relational Databases in SQL. 

La creación de tablas sigue un enfoque similar a lo que ya has visto: 

• Escribe una sentencia SQL como cadena. 
• Pásala al método execute() del cursor. 

En este caso, la sentencia SQL es CREATE TABLE.

Vamos a crear una tabla para libros:

create_books_table = """
CREATE TABLE books(
    id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    author VARCHAR(100),
    genre VARCHAR(100),
    release_year YEAR(4)
)
"""
# Create cursor object
with existing_database.cursor() as cursor:
    cursor.execute(create_books_table)
    existing_database.commit()

En la última línea verás que usamos el método commit() sobre el objeto existing_database. Es necesario porque el conector de MySQL para Python no hace commit automático por defecto. 

Siempre que modifiques datos de una tabla, debes llamar al método commit() – puedes saber más sobre commit() en la documentación de MySQL. 

Otros puntos importantes del código: 

• NOT NULL: restricción que impide aceptar valores NULL en una columna. 
• PRIMARY KEY: valor único para identificar filas concretas de una tabla. 
• AUTO_INCREMENT: genera automáticamente un número único para nuevos registros insertados en la tabla. 

Podemos comprobar que el esquema se creó correctamente usando la sentencia DESCRIBE y después imprimiendo todos los elementos con el método fetchall() del cursor…

describe_books = "DESCRIBE books"
with existing_database.cursor() as cursor:
    cursor.execute(describe_books)
    books_schema = cursor.fetchall()
    for column in books_schema:
        print(column)

"""
('id', b'int', 'NO', 'PRI', None, 'auto_increment')
('title', b'varchar(100)', 'YES', '', None, '')
('author', b'varchar(100)', 'YES', '', None, '')
('genre', b'varchar(100)', 'YES', '', None, '')
('release_year', b'year', 'YES', '', None, '')
"""

Inserción de datos

En las secciones anteriores, creamos una tabla llamada books en nuestra base de datos book_ratings. Por ahora, esta tabla está vacía. A continuación verás dos formas de poblar una tabla. 

Insertar un único registro

Puede que en algún momento necesites insertar un solo registro en una tabla. Aunque no es lo habitual en casos reales, puedes hacerlo así:

# INSERT SINGLE RECORD
insert_single_record = "INSERT INTO books (id, title, author, genre, release_year)\
    VALUES (%s, %s, %s, %s, %s)"
single_record = (
    "1", "Choose Yourself! Be Happy, Make Millions, Live the Dream", "James Altucher", "self-help", "2013"
    )

# Create cursor object
with existing_database.cursor() as cursor:
    cursor.execute(insert_single_record, single_record)
    existing_database.commit()

Insertar múltiples registros

Lo más habitual es insertar datos en bloque con el método executemany(operation_to_perform, seq_of_params) del cursor; así puedes insertar varios registros de una vez. 

La estructura de la operación es la misma; solo cambiamos la secuencia de parámetros. 

Así se vería en código: 

multiple_records = [
    (
        "2",
        "Skip the Line: The 10,000 Experiments Rule and Other Surprising Advice for Reaching Your Goals",
        "James Altucher",
        "self-help",
        "2021"        
    ),
    (
        "3",
        "The Power of No: Because One Little Word Can Bring Health, Abundance, and Happiness",
        "James Altucher",
        "self-help",
        "2014"
    ),
    ]

with existing_database.cursor() as cursor:
    cursor.executemany(insert_multiple_records, multiple_records)
    existing_database.commit()

Selección de datos 

La sentencia SELECT se usa para recuperar filas de una o varias tablas de una base de datos. Podemos usar SELECT de dos maneras: 

1. Seleccionar columnas específicas de una tabla.

select_specific_cols = "SELECT author, release_year FROM books"
with existing_database.cursor() as cursor:
    cursor.execute(select_specific_cols)

1. Devolver todas las columnas usando un asterisco “*”.

# Create cursor object
select_all_cols = "SELECT * FROM books"
with existing_database.cursor() as cursor:
    cursor.execute(select_all_cols)

Ordenar y filtrar datos 

Ordenar y filtrar datos te permite devolver solo los resultados que te interesan proporcionando criterios específicos que deben cumplir los registros. 

Algunos ejemplos: 

WHERE

La sentencia WHERE te permite filtrar datos según una condición indicada. 

Por ejemplo, si queremos extraer el nombre del autor y el título del libro para cualquier obra anterior o igual a 2010: 

condition = "SELECT author, title FROM books WHERE release_year <= 2010"
with existing_database.cursor() as cursor:
    cursor.execute(condition)

ORDER BY

También podemos usar la sentencia ORDER BY para ordenar los resultados en orden ascendente (ASC) o descendente (DESC). Ten en cuenta que, por defecto, el orden es ascendente salvo que indiques lo contrario. 

Así ordenaríamos por año de publicación en orden descendente:

order_by_year = "SELECT * FROM books ORDER BY release_year DESC"
with existing_database.cursor() as cursor:
    cursor.execute(order_by_year)

LIMIT

La sentencia LIMIT te permite especificar el número de registros que se devolverán en el conjunto de resultados.

# Create cursor object
define_limit = "SELECT * FROM books LIMIT 3"
with existing_database.cursor() as cursor:
    cursor.execute(define_limit)

El código anterior limita a tres el número de registros devueltos. 

Actualizar y eliminar datos

Habrá ocasiones en que los datos cambien, dejen de ser útiles o sean incorrectos. En esta sección aprenderás a gestionar estos casos con actualizaciones y eliminaciones. 

UPDATE

La consulta UPDATE te permite cambiar valores existentes dentro de una tabla sin afectar a su estructura. 

Por ejemplo, puede que tengas que actualizar un registro si alguien cambia su nombre. Así se vería en código:

update_query = """
UPDATE
    books
SET
    author = "Big J"
WHERE
    author = "James Altucher"
"""
with existing_database.cursor() as cursor:
    cursor.execute(update_query)
    existing_database.commit()

DELETE

La consulta DELETE te permite borrar registros de una tabla:

drop_record = "DELETE FROM books WHERE release_year <= 2000"
with existing_database.cursor() as cursor:
    cursor.execute(drop_record)
    existing_database.commit()

En este código eliminamos todos los registros con año de publicación menor o igual a 2000. 

DROP TABLE

La sentencia DROP TABLE te permite eliminar de forma permanente una tabla de una base de datos. Añadir IF EXISTS es útil si no tienes claro si la tabla existe, aunque es totalmente opcional. 

Eliminemos la tabla que creamos en nuestra base de datos book_ratings: 

drop_table = "DROP TABLE IF EXISTS books"
with existing_database.cursor() as cursor:
    cursor.execute(drop_table)
    existing_database.commit()

Conclusión

En este tutorial has aprendido a establecer una conexión con un servidor MySQL en Python, crear una base de datos nueva, conectarte a una existente, crear una tabla y realizar distintas operaciones de consulta sobre una tabla de MySQL desde Python.  

Sigue aprendiendo con estos recursos:

• Introduction to Databases in Python 
• SQL Server, PostgreSQL, MySQL… ¿cuáles son las diferencias? ¿Por dónde empiezo?
• Cursos de SQL para principiantes
• PostgreSQL vs. MySQL