Produtos com super desconto na Amazon!
Produtos com super desconto na Amazon!

Como utilizar o SQLAlchemy com o banco de dados SQLite3

Hoje veremos como utilizar a linguagem de programação Python e o SQLAlchemy com o banco de dados SQLite3.

SQLAlchemy

O SQLAlchemy é uma biblioteca em Python que fornece uma maneira de interagir com bancos de dados relacionais de forma flexível e poderosa.

Ele permite que você trabalhe com bancos de dados SQL de uma maneira orientada a objetos, mapeando tabelas de banco de dados para classes em Python e consultando essas tabelas usando uma sintaxe semelhante ao SQL.

Em resumo, o SQLAlchemy simplifica o acesso e a manipulação de bancos de dados SQL em aplicativos Python.

O SQLAlchemy pode ser instalado usando o pip, que é o gerenciador de pacotes padrão do Python:

pip install pip SQLAlchemy

SQLite3

O SQLite é um banco de dados leve, autônomo e de código aberto que não requer um servidor para funcionar.

Ele é amplamente utilizado em aplicativos móveis, navegadores da web e outros sistemas de software devido à sua simplicidade, portabilidade e facilidade de uso.

Neste artigo, vamos explorar os conceitos fundamentais do SQLite de uma maneira acessível para quem está começando.

O que é o SQLite?

O SQLite é um banco de dados relacional que armazena dados em um arquivo de banco de dados, em vez de em um servidor de banco de dados separado.

Isso o torna uma escolha popular para aplicativos que precisam de um banco de dados embutido, como aplicativos móveis, navegadores da web e software de desktop.

Principais Conceitos do SQLite

1. Arquivo de Banco de Dados: No SQLite, os dados são armazenados em um único arquivo de banco de dados. Esse arquivo contém todas as tabelas, índices, visões e outros objetos de banco de dados.

2. Tabelas As tabelas são estruturas fundamentais do SQLite que armazenam dados de forma organizada. Cada tabela é composta por colunas (campos) e linhas (registros). As colunas representam os diferentes tipos de informações que serão armazenadas, enquanto as linhas representam os registros individuais.

3. Consultas SQL: O SQLite suporta a linguagem SQL (Structured Query Language) para realizar operações de consulta e manipulação de dados. Com SQL, você pode realizar consultas para recuperar dados de uma tabela, inserir novos dados, atualizar registros existentes e excluir dados.

4. Transações: O SQLite suporta transações ACID (Atomicidade, Consistência, Isolamento, Durabilidade), o que significa que as operações de banco de dados são executadas de forma segura e confiável, mesmo em casos de falha.

5. Índices: Os índices no SQLite são estruturas de dados usadas para acelerar a recuperação de dados de uma tabela. Eles são criados em colunas específicas e ajudam o SQLite a encontrar registros com base em critérios de pesquisa de maneira mais eficiente.

Exemplo de CRUD

# -*- coding: utf-8 -*-
'''CRUD - Python - SQLAlchemy - SQLite3.'''

import pathlib

from sqlalchemy import (SmallInteger, String,
                        create_engine, insert, select, delete, update)
from sqlalchemy.orm import DeclarativeBase, Mapped, sessionmaker, mapped_column

BASE_DIR = pathlib.Path(__file__).resolve().parent

# In-Memory Database.
# engine = sa.create_engine(url='sqlite://')
engine = create_engine(url='sqlite:///:memory:')

# Local file.
# engine = sa.create_engine(url=f'sqlite:///{BASE_DIR.joinpath('db.sqlite3')}')

Session = sessionmaker(bind=engine)


class Base(DeclarativeBase):
    pass


class TableName(Base):
    __tablename__ = 'table_name'

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column('name', String(32))
    age: Mapped[int] = mapped_column('age', SmallInteger)

    def __repr__(self) -> str:
        return f'TableName(id={self.id}, name={self.name}, age={self.age})'


if __name__ == '__main__':
    # Removing all tables from the database.
    Base.metadata.drop_all(engine)

    # Creating all tables.
    Base.metadata.create_all(engine)

    # Creating a session (add, commit, query, etc.).
    session = Session()

    # Create.
    print('[!] Create [!]')
    session.execute(
        insert(TableName)
        .values(
            name='renato',
            age=35,
        ),
    )

    # Returning the object that will be created.
    result = session.scalar(
        insert(TableName)
        .values(
            name='josé',
            age=29,
        )
        .returning(TableName),
    )
    session.commit()
    print(result)

    # Bulk create.
    session.execute(
        insert(TableName),
        [
            {'name': 'maria', 'age': 25},
            {'name': 'sandy', 'age': 19},
        ],
    )

    result = session.scalars(
        insert(TableName)
        .returning(TableName),
        [
            {'name': 'patrick', 'age': 33},
            {'name': 'gisele', 'age': 21},
        ],
    )
    session.commit()
    print(result.all())

    # Read.
    print('\n[!] Read [!]')
    result = session.scalars(
        select(TableName),
    )
    print(result.all())

    # Get by id.
    result = session.get(TableName, 1)
    print(result)

    # Limit.
    result = session.scalars(
        select(TableName)
        .limit(3),
    )
    print(result.all())

    # Where.
    result = session.scalars(
        select(TableName)
        .where(TableName.age > 30),
    )
    print(result.all())

    result = session.scalar(
        select(TableName)
        .where(TableName.id == 1),
    )
    print(result)

    # Filter.
    result = session.scalars(
        select(TableName)
        .filter_by(name='renato'),
    )
    print(result.all())

    # Update.
    print('\n[!] Update [!]')
    print(session.get(TableName, 1))
    session.execute(
        update(TableName)
        .where(TableName.id == 1)
        .values(name='joão'),
    )
    print(session.get(TableName, 1))

    print(session.get(TableName, 2))
    result = session.scalar(
        select(TableName)
        .where(TableName.id == 2),
    )
    result.name = 'antônio'
    session.commit()
    print(session.get(TableName, 2))

    # Delete.
    print('\n[!] Delete [!]')
    print(session.get(TableName, 1))
    session.execute(
        delete(TableName)
        .where(TableName.id == 1),
    )
    print(session.get(TableName, 1))

    print(session.get(TableName, 2))
    result = session.scalar(
        select(TableName)
        .where(TableName.id == 2),
    )
    session.delete(result)
    session.commit()
    print(session.get(TableName, 2))

    session.close()

Conclusão

O SQLite3 é uma excelente escolha para projetos que precisam de um banco de dados leve e embutido.

Compreender os conceitos básicos, como arquivo de banco de dados, tabelas, consultas SQL e transações, pode ajudá-lo a utilizar o SQLite3 de forma eficaz em seus projetos de desenvolvimento.