ORM Productivity Layer

sqla-lite

Uma camada declarativa sobre SQLAlchemy para escrever menos código repetitivo, padronizar modelos e acelerar desenvolvimento sem perder o controle da ORM.

  • ✦ Menos boilerplate em models e queries
  • ✦ API declarativa com foco em legibilidade
  • ✦ Mantém compatibilidade com ecossistema SQLAlchemy
  • ✦ Curva de adoção rápida para times Python
↗ GitHub PyPI
Comparações

SQLAlchemy vs sqla-lite

Exemplos práticos para mostrar o ganho de clareza no dia a dia.

1. Definição de modelo

Mesma ideia do SQLAlchemy, com marcadores declarativos do sqla-lite.

SQLAlchemy 
                                    
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True)
    name = Column(String(100))
    age = Column(Integer)
sqla-lite 
                                    
from sqla_lite import Id, Size
from sqla_lite import table

@table("users")
class User:

    id: int = Id()
    name: str = Size(100)
    age: int

2. Repositório e persistência

Configuração global do engine e uso sem boilerplate de sessão por operação.

SQLAlchemy 
                                    
from sqlalchemy import create_engine
from sqlalchemy.orm import Session

engine = create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)

class UserRepository:
    def save(self, user):
        with Session(engine) as session:
            session.add(user)
            session.commit()

    def get(self, user_id):
        with Session(engine) as session:
            return session.get(User, user_id)

repo = UserRepository()
user = User(name="John Doe", age=25)
repo.save(user)
loaded = repo.get(1)
sqla-lite 
                                    
from sqlalchemy import create_engine
from sqla_lite import configure_database, repository
from sqla_lite.core import Base

engine = create_engine("sqlite:///:memory:")

@repository(User)
class UserRepository:
    pass

Base.metadata.create_all(engine)
configure_database(engine)

repo = UserRepository()
user = User(name="John Doe", age=25)
repo.save(user)
loaded = repo.get(1)

3. Query customizada

Método declarativo com @query para filtros comuns dentro do repositório.

SQLAlchemy 
                                    
from sqlalchemy.orm import Session

class UserRepository:
    def find_adults(self):
        with Session(self.engine) as session:
            return (
                session.query(User)
                .filter(User.age >= 18)
                .all()
            )
sqla-lite 
                                    
from sqla_lite import repository, query

@repository(User)
class UserRepository:
    @query
    def find_adults(self, session):
        return session.filter(self.entity_class.age >= 18).all()

Benefício

Produtividade real

Menos código repetitivo em CRUD e consultas comuns, reduzindo tempo de entrega.

Benefício

Legibilidade de equipe

Código mais previsível para onboarding e manutenção de projetos de médio e grande porte.

Benefício

Menos atrito arquitetural

A biblioteca simplifica sem esconder a base SQLAlchemy, mantendo liberdade para casos avançados.

Por que usar sqla-lite?

Porque ele resolve o que mais cansa no dia a dia com ORM: repetição, padrões dispersos e código difícil de escalar em equipe. sqla-lite entrega velocidade sem abrir mão de clareza.

Ver repositório Voltar para Home