Introdução ao ORM do Django: Exercícios Práticos
Tags: webdev, django, orm, python
Published: 2024-07-10 17:36:59

O ORM (Object-Relational Mapping) do Django é uma poderosa ferramenta que permite aos desenvolvedores interagir com bancos de dados relacionais usando código Python em vez de SQL. Essa abordagem orientada a objetos abstrai a complexidade das consultas SQL, tornando o processo de manipulação de dados mais intuitivo e alinhado com a lógica da aplicação. Com o ORM do Django, modelos de dados são definidos como classes Python, onde cada atributo da classe representa um campo no banco de dados. Isso permite que desenvolvedores trabalhem com dados de uma maneira mais natural e coesa dentro do ambiente de desenvolvimento Python.

Além de simplificar a interação com o banco de dados, o ORM do Django oferece uma série de funcionalidades avançadas que facilitam a execução de consultas complexas, a manipulação de dados e a manutenção da integridade referencial. Por exemplo, ao definir relações entre diferentes modelos, como OneToMany, ManyToMany e ForeignKey, o ORM do Django gerencia automaticamente as ligações entre tabelas, assegurando consistência e integridade dos dados. Adicionalmente, ele suporta operações de CRUD (Create, Read, Update, Delete) de forma eficiente e segura, além de permitir a construção de consultas dinâmicas e otimizadas usando Q objects e filtros. Com essas capacidades, o ORM do Django não só acelera o desenvolvimento, mas também promove práticas de codificação mais limpas e manuteníveis.


# Introdução ao ORM do Django: Exercícios Práticos

Neste post, vamos explorar 10 exercícios práticos que cobrem os conceitos fundamentais do ORM do Django. Cada exercício inclui uma pergunta e sua respectiva resposta para que você possa praticar e consolidar seu entendimento.

## 1. Criação de um Modelo

**Assunto:** Como definir um modelo Django com campos específicos.

**Exercício:**
Crie um modelo chamado `Book` com os campos `title` (char), `author` (char) e `published_date` (date).

```python
from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    
    def __str__(self):
        return self.title
```

## 2. Inserir Registros no Modelo

**Assunto:** Como inserir registros em um modelo usando o ORM do Django.

**Exercício:**
Insira um registro no modelo `Book` com os seguintes valores: `title` = "Django for Beginners", `author` = "gustavo g. Pereira", `published_date` = "2020-01-01".

```python
Book.objects.create(
    title="Django for Beginners",
    author="gustavo g. Pereira",
    published_date="2020-01-01"
)
```

## 3. Consultar Registros

**Assunto:** Como consultar todos os registros de um modelo.

**Exercício:**
Consulte todos os registros do modelo `Book`.

```python
books = Book.objects.all()
for book in books:
    print(book.title)
```

## 4. Filtrar Registros

**Assunto:** Como filtrar registros com base em um campo específico.

**Exercício:**
Filtre os registros do modelo `Book` onde o `author` é "William S. Vincent".

```python
books = Book.objects.filter(author="gustavo g. Pereira")
for book in books:
    print(book.title)
```

## 5. Atualizar Registros

**Assunto:** Como atualizar registros existentes no banco de dados.

**Exercício:**
Atualize o campo `title` do registro onde o `author` é "gustavo g. Pereira" para "Django for Experts".

```python
Book.objects.filter(author="gustavo g. Pereira").update(title="Django for Experts")
```

## 6. Excluir Registros

**Assunto:** Como excluir registros do banco de dados.

**Exercício:**
Exclua todos os registros do modelo `Book` onde o `author` é "gustavo g. Pereira".

```python
Book.objects.filter(author="gustavo g. Pereira").delete()
```

## 7. Consultar Registros Ordenados

**Assunto:** Como consultar registros ordenados por um campo específico.

**Exercício:**
Consulte todos os registros do modelo `Book` ordenados pelo campo `published_date`.

```python
books = Book.objects.all().order_by('published_date')
for book in books:
    print(book.title)
```

## 8. Usar Valores Distintos

**Assunto:** Como obter valores distintos de um campo específico.

**Exercício:**
Consulte todos os valores distintos do campo `author` no modelo `Book`.

```python
authors = Book.objects.values('author').distinct()
for author in authors:
    print(author['author'])
```

## 9. Limitar a Quantidade de Registros Retornados

**Assunto:** Como limitar o número de registros retornados em uma consulta.

**Exercício:**
Consulte os primeiros 5 registros do modelo `Book`.

```python
books = Book.objects.all()[:5]
for book in books:
    print(book.title)
```

## 10. Usar Q Objects para Consultas Complexas

**Assunto:** Como realizar consultas complexas usando Q objects para combinar múltiplas condições.

**Exercício:**
Consulte os registros do modelo `Book` onde o `title` contém a palavra "Django" e o `published_date` é após "2019-01-01".

```python
from django.db.models import Q
books = Book.objects.filter(Q(title__icontains="Django") & Q(published_date__gt="2019-01-01"))
for book in books:
    print(book.title)
```

---

Espero que esses exercícios práticos ajudem você a entender melhor como utilizar o ORM do Django em suas aplicações. Se você tiver dúvidas ou quiser compartilhar suas próprias experiências, deixe um comentário abaixo!