Tutorial de MySQL em Python: primeiros passos

Criando um novo banco de dados no MySQL com Python

A partir daqui, você vai precisar de conhecimentos em SQL; o curso Introduction to SQL da DataCamp é um ótimo ponto de partida para ficar em dia. 

A forma típica de criar um banco no MySQL é a seguinte: 

CREATE DATABASE book_ratings;

Para executar a mesma consulta em Python, você precisa criar uma instância do objeto cursor(). 

A partir do objeto cursor(), você pode passar comandos SQL como string para o método execute(), que executará o código. 

Vamos criar um banco chamado “book_ratings…”

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

Observação: executar esse código várias vezes vai gerar um erro informando que o banco já existe.

Você pode verificar os bancos existentes em um servidor assim:

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',)
"""

O código acima imprime os nomes de todos os bancos atualmente no nosso servidor MySQL. Há mais de um porque o servidor MySQL gera bancos automaticamente para dar acesso a vários metadados e configurações do servidor.

Conectando a um banco existente

Vamos supor que você já criou um banco, mas ainda não se conectou ao servidor; como se conectar diretamente ao banco? 

Simples. 

Passe o nome do banco como argumento para o 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>
"""

Criando tabelas

As informações em um banco de dados são armazenadas em tabelas. Uma tabela é apenas um formato para guardar um conjunto de dados relacionados, composto por colunas e linhas. 

Pode haver várias tabelas em um banco, mesmo que não tenham relação entre si. Você também pode ter um banco relacional com uma única tabela, como vamos demonstrar nesta seção – aprofunde seus conhecimentos em bancos relacionais com o curso Introduction to Relational Databases in SQL. 

A criação de tabela segue a mesma lógica que você já viu: 

• Escreva um comando SQL como string 
• Passe-o para o método execute() do cursor. 

A instrução SQL neste caso é CREATE TABLE.

Vamos usá-la para criar uma tabela de livros:

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()

Na última linha, você deve ter notado o uso do método commit() no objeto existing_database. Fizemos isso porque o comportamento padrão do conector MySQL para Python não é efetivar a transação automaticamente. 

Sempre que você modificar dados de uma tabela, deve chamar o método commit() – saiba mais sobre o commit() na documentação do MySQL. 

Outros pontos importantes no código: 

• NOT NULL: uma restrição que impede a coluna de aceitar valores NULL. 
• PRIMARY KEY: um valor único usado para identificar linhas específicas em uma tabela. 
• AUTO_INCREMENT: gera automaticamente um número único para novos registros inseridos. 

Podemos verificar se o esquema foi criado corretamente usando a instrução DESCRIBE e depois imprimindo os elementos com o método fetchall() no 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, '')
"""

Inserção de dados

Nas seções anteriores, criamos a tabela books no banco book_ratings. No momento, ela está vazia. A seguir, vamos ver duas abordagens para popular uma tabela. 

Inserindo um único registro

Pode haver situações em que você precise inserir um único registro em uma tabela. Embora raro no dia a dia, é totalmente possível fazer assim:

# 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()

Inserindo vários registros

A forma mais comum de inserir dados em uma tabela é com o método executemany(operation_to_perform, seq_of_params) do cursor; ele permite inserir vários registros de uma vez. 

A estrutura da operação que queremos realizar permanece a mesma; só atualizamos a sequência de parâmetros. 

Veja como fica no 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()

Selecionando dados 

A instrução SELECT é usada para recuperar linhas selecionadas de uma ou mais tabelas de um banco. Podemos usar SELECT de duas formas: 

1. Selecionar colunas específicas de uma tabela.

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

1. Retornar todas as colunas usando o asterisco “*”

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

Ordenando e filtrando dados 

Ordenar e filtrar dados permite retornar apenas os resultados que importam, definindo critérios específicos que os registros devem atender. 

Alguns exemplos: 

WHERE

A cláusula WHERE permite filtrar dados com base em uma condição especificada. 

Por exemplo, vamos extrair o nome do autor e o título de qualquer livro lançado até 2010 (inclusive): 

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

ORDER BY

Também podemos usar a cláusula ORDER BY para ordenar os resultados em ordem crescente (ASC) ou decrescente (DESC). O padrão é sempre crescente, a menos que você especifique o contrário. 

Veja como ordenar os dados pelo ano de lançamento em ordem decrescente:

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

LIMIT

A cláusula LIMIT permite definir o número de registros a serem retornados no conjunto de resultados.

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

O código acima limita o retorno a três registros. 

Atualizando e excluindo dados

Vai haver momentos em que os dados mudam, deixam de ser úteis ou estão incorretos. Nesta seção, você vai aprender a lidar com esses casos com atualizações e exclusões. 

UPDATE

A consulta UPDATE permite alterar valores existentes em uma tabela sem afetar sua estrutura. 

Por exemplo, pode ser necessário atualizar um registro se alguém mudar de nome; em código, ficaria assim:

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

A consulta DELETE permite excluir um registro de uma tabela:

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

Nesse código, excluímos todos os registros com ano de lançamento menor ou igual a 2000. 

DROP TABLE

A instrução DROP TABLE permite remover permanentemente uma tabela de um banco. Incluir IF EXISTS ajuda em cenários em que você não tem certeza se a tabela existe, mas é totalmente opcional. 

Vamos remover a tabela que criamos no banco book_ratings: 

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

Conclusão

Neste tutorial, você aprendeu a estabelecer uma conexão com um servidor MySQL em Python, criar um novo banco de dados, conectar a um banco existente, criar uma tabela e executar várias operações de consulta em uma tabela MySQL a partir do Python.  

Confira estes recursos para continuar aprendendo:

• Introduction to Databases in Python 
• SQL Server, PostgreSQL, MySQL… Qual a diferença? Por onde começar?
• Cursos de SQL para iniciantes
• PostgreSQL vs. MySQL