Uma introdução ao SQLite com Python

Neste artigo, vamos chutar os pneus do SQLite. Aprenderemos como usar o SQLite por meio de uma biblioteca Python chamada sqlite3. No final, exploraremos alguns recursos mais avançados fornecidos por sqlite3 para facilitar nosso trabalho.

Nota: antes de começar, é bom estar familiarizado com o SQL. Se não estiver, você pode querer verificar Simplesmente SQL.

O que é SQLite?

O lema do SQLite é: “Pequeno. Velozes. Confiável. Escolha quaisquer três.”

SQLite é uma biblioteca de banco de dados incorporada escrita em C. Você pode estar familiarizado com outras tecnologias de banco de dados como MySQL ou PostgreSQL. Eles usam uma abordagem cliente-servidor: o banco de dados é instalado como um servidor e, em seguida, um cliente é usado para se conectar a ele. SQLite é diferente: é conhecido como um embutido banco de dados, porque está incluído em um programa como uma biblioteca. Todos os dados são armazenados em um arquivo – geralmente com um .db extensão — e você tem funções que permitem executar instruções SQL ou fazer qualquer outra operação no banco de dados.

A solução de armazenamento baseado em arquivo também oferece acesso simultâneo, o que significa que vários processos ou threads podem acessar o mesmo banco de dados. Ok, então quais são os usos do SQLite? Serve para qualquer tipo de aplicação?

Bem, existem alguns casos em que o SQLite se destaca:

• Sendo incluído na maioria dos sistemas operacionais móveis, como Android e iOS, o SQLite pode ser uma escolha perfeita se você deseja um independente e sem servidor solução de armazenamento de dados.

• Em vez de usar arquivos CSV enormes, você pode explorar o poder de SQL e coloque todos os seus dados em um único banco de dados SQLite.

• SQLite pode ser usado para armazenar dados de configuração para seus aplicativos. Na verdade, o SQLite é 35% mais rápido do que um sistema baseado em arquivos, como um arquivo de configuração.

Por outro lado, quais são algumas razões para não escolher o SQLite?

• Ao contrário do MySQL ou PostgreSQL, o SQLite não possui funcionalidades multiusuário.

• SQLite ainda é uma solução de armazenamento de dados baseada em arquivos, não um serviço. Você não pode gerenciá-lo como um processo, não pode iniciá-lo ou interrompê-lo ou gerenciar o uso de recursos.

A interface Python para SQLite

Como eu disse na introdução, SQLite é uma biblioteca C. Existem interfaces escritas em muitas linguagens, incluindo Python. o sqlite3 O módulo fornece uma interface SQL e requer pelo menos o SQLite 3.7.15.

O incrível é que sqlite3 vem com Python, então você não precisa instalar nada.

Introdução ao sqlite3

É hora de codificar! Nesta primeira parte, criaremos um banco de dados básico. A primeira coisa a fazer é criar um banco de dados e conectar-se a ele:

import sqlite3
dbName = 'database.db'

try:
  conn = sqlite3.connect(dbName)
  cursor = conn.cursor()
  print("Database created!")

except Exception as e:
  print("Something bad happened: ", e)
  if conn:
    conn.close()

Na linha 1, importamos o sqlite3 biblioteca. Então, dentro de um try/except bloco de código, chamamos sqlite3.connect() para inicializar uma conexão com o banco de dados. Se tudo der certo, conn será uma instância do Connection objeto. Se o try falha, imprimimos a exceção recebida e a conexão com o banco de dados é fechada. Conforme declarado na documentação oficial, cada banco de dados SQLite aberto é representado por um Connection objeto. Cada vez que temos que executar um comando SQL, o Connection objeto tem um método chamado cursor(). Em tecnologias de banco de dados, um cursor é uma estrutura de controle que permite a passagem pelos registros em um banco de dados.

Agora, se executarmos este código, devemos obter a seguinte saída:

> Database created!

Se olharmos para a pasta onde está nosso script Python, devemos ver um novo arquivo chamado database.db. Este arquivo foi criado automaticamente por sqlite3.

Criar, ler e modificar registros

Neste ponto, estamos prontos para criar uma nova tabela, adicionar as primeiras entradas e executar comandos SQL como SELECT, UPDATE ou DROP.

Para criar uma tabela, basta executar uma instrução SQL simples. Neste exemplo, criaremos uma tabela de alunos que conterá os seguintes dados:

Depois de print("Database created!") linha, adicione isto:

create_query = '''CREATE TABLE IF NOT EXISTS student(
  id INTEGER PRIMARY KEY,
  name TEXT NOT NULL,
  surname TEXT NOT NULL);
  '''
cursor.execute(create_query)
print("Table created!")


cursor.execute("INSERT INTO student VALUES (1, 'John', 'Smith')")
print("Insert #1 done!")
cursor.execute("INSERT INTO student VALUES (2, 'Lucy', 'Jacobs')")
print("Insert #2 done!")
cursor.execute("INSERT INTO student VALUES (3, 'Stephan', 'Taylor')")
print("Insert #3 done!")
conn.commit()
conn.close()

Criamos uma tabela e chamamos o cursor.execute() método, que é usado quando queremos executar uma única instrução SQL.

Em seguida, fazemos uma INSERT para cada linha que queremos adicionar. Após todas as nossas alterações terem sido feitas, chamamos conn.commit() para confirmar a transação pendente no banco de dados. Sem chamar o commit() método, qualquer alteração pendente no banco de dados será perdida. Por fim, fechamos a conexão com o banco de dados chamando o conn.close() método.

Ok, agora vamos consultar nosso banco de dados! Vamos precisar de uma variável para salvar os resultados de nossa consulta, então vamos salvar o resultado de cursor.execute() para uma variável chamada records:

records = cursor.execute("SELECT * FROM student")
for row in findrecords:
  print(row)

Depois de executar isso, veremos todos os registros para stdout:

(1, 'John', 'Smith')
(2, 'Lucy', 'Jacobs')
(3, 'Stephan', 'Taylor')

Neste ponto, você deve ter notado que, dentro do cursor.execute() método, colocamos o comando SQL que deve ser executado. Nada muda na sintaxe do Python se quisermos executar outro comando SQL como UPDATE ou DROP.

Os espaços reservados

o cursor.execute() O método precisa de uma string como argumento. Na seção anterior, vimos como inserir dados em nosso banco de dados, mas tudo estava codificado. E se precisarmos armazenar no banco de dados algo que esteja em uma variável? Por esta razão, sqlite3 tem algumas coisas extravagantes chamadas placeholders. Espaços reservados nos permite usar a substituição de parâmetros, o que tornará a inserção de uma variável em uma consulta muito mais fácil.

Vejamos este exemplo:

def insert_command(conn, student_id, name, surname):
  command = 'INSERT INTO student VALUES (?, ?, ?)'
  cur = conn.cursor()
  cur.execute(command, (student_id, name, surname, ))
  conn.commit()

Criamos um método chamado insert_command(). Este método recebe quatro argumentos: o primeiro é um Connection instância, e os outros três serão usados ​​em nosso comando SQL.

Cada ? dentro de command variável representa um espaço reservado. Isso significa que, se você chamar o insert_command funcionar com student_id=1, name="Jason" e surname="Green"a INSERT declaração se tornará INSERT INTO student VALUES(1, 'Jason', 'Green').

Quando chamamos o execute() função, passamos nosso comando e todas as variáveis ​​que serão substituídas para os espaços reservados. A partir de agora, toda vez que precisarmos inserir uma linha na tabela do aluno, chamamos o método insert_command() método com os parâmetros necessários.

Transações

Mesmo que você não seja novo na definição de uma transação, deixe-me recapitular rapidamente sua importância. UMA transação é uma sequência de operações executadas em um banco de dados que é tratado logicamente como uma única unidade.

O benefício mais importante de uma transação é garantir a integridade dos dados. Pode ser inútil no exemplo que apresentamos acima, mas quando lidamos com mais dados armazenados em várias tabelas, as transações fazem a diferença.

do Python sqlite3 módulo inicia uma transação antes de execute() e executemany() executar INSERT, UPDATE, DELETEou REPLACE declarações. Isso implica duas coisas:

• Devemos cuidar de chamar o commit() método. Se nós chamarmos Connection.close() sem fazer um commit()todas as alterações feitas durante a transação serão perdidas.
• Não podemos abrir uma transação no mesmo processo usando BEGIN.

A solução? Manipule as transações explicitamente.

Como? Usando a chamada de função sqlite3.connect(dbName, isolation_level=None) ao invés de sqlite3.connect(dbName). Definindo isolation_level para Nonenós forçamos sqlite3 nunca abrir transações implicitamente.

O código a seguir é uma reescrita do código anterior, mas com o uso explícito de transações:

import sqlite3
dbName = 'database.db'

def insert_command(conn, student_id, name, surname):
  command = 'INSERT INTO student VALUES (?, ?, ?)'
  cur = conn.cursor()
  cur.execute("BEGIN")
  try:
    cur.execute(command, (student_id, name, surname, ))
    cur.execute("COMMIT")
  except conn.Error as e:
    print("Got an error: ", e)
    print("Aborting...")
    cur.execute("ROLLBACK")

conn = sqlite3.connect(dbName, isolation_level=None)
cursor = conn.cursor()
print("Database created!")


create_query = '''CREATE TABLE IF NOT EXISTS student(
  id INTEGER PRIMARY KEY,
  name TEXT NOT NULL,
  surname TEXT NOT NULL);
  '''
cursor.execute(create_query)
print("Table created!")


insert_command(conn , 1, 'John', 'Smith')
insert_command(conn , 2, 'Lucy', 'Jacobs')
insert_command(conn , 3, 'Stephan', 'Taylor')
insert_command(conn , 4, 'Joseph', 'Random')
findRecords = cursor.execute("SELECT * FROM student")
for row in findRecords:
  print(row)

conn.close()

Conclusão

Espero que agora você tenha uma boa compreensão do que é SQLite, como você pode usá-lo para seus projetos Python e como alguns de seus recursos avançados funcionam. O gerenciamento explícito de transações pode ser um pouco complicado no começo, mas certamente pode ajudá-lo a aproveitar ao máximo sqlite3.

Leitura relacionada: