Modelos Django

Resumo : neste tutorial, você aprenderá sobre modelos Django e como criar modelos para sua aplicação Django.

Este tutorial começa onde  o tutorial de criação de templates do Django parou.

Introdução aos modelos Django

No Django, um modelo é uma subclasse da django.db.models.Modelclasse. Um modelo contém um ou mais campos e métodos que manipulam os campos.

Essencialmente, um modelo Django é mapeado para uma única tabela no banco de dados na qual cada campo do modelo representa uma coluna na tabela.

Um aplicativo pode ter zero ou mais modelos armazenados no models.pymódulo. Por exemplo, o seguinte define um Postmodelo para o blogaplicativo:

from django.db import models
from django.utils import timezone


class Post(models.Model):
    title = models.CharField(max_length=120)
    content = models.TextField()
    published_at = models.DateTimeField(default=timezone.now)Linguagem de código:  Python  ( python )

O Postmodelo possui os campos title, contente published_at. Baseado no Postmodelo, o Django criará uma tabela no banco de dados com o seguinte código SQL:

CREATE TABLE "blog_post" (
  "id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, 
  "title" varchar(120) NOT NULL, 
  "content" text NOT NULL, 
  "published_at" datetime NOT NULL, 
);Linguagem de código:  SQL (linguagem de consulta estruturada)  ( sql )

Observe que o SQL gerado acima é para SQLite . Se você usar um banco de dados diferente, verá que o código SQL é um pouco diferente.

O nome da tabela blog_posté derivado automaticamente dos nomes do aplicativo e do modelo:

application.modelLinguagem de código:  Python  ( python )

Neste exemplo, o Django criará uma tabela blog_postpara o Postmodelo.

Para especificar um nome de tabela em vez de usar o nome padrão gerado pelo Django, você pode usar o db_tableatributo da Metaclasse assim:

from django.db import models
from django.utils import timezone


class Post(models.Model):
    title = models.CharField(max_length=120)
    content = models.TextField()
    published_at = models.DateTimeField(default=timezone.now)
    
    class Meta:
        db_table = 'posts'
Linguagem de código:  Python  ( python )

Nesse caso, o Postmodelo será mapeado para a poststabela em vez da blog_posttabela gerada. Neste tutorial, ficaremos com o nome da tabela gerada padrão blog_post.

Ao criar uma tabela, o Django adiciona automaticamente o idcampo como chave primária da tabela. O idcampo é um campo de incremento automático com o tipo especificado no settings.pyarquivo do projeto:

DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'Linguagem de código:  Python  ( python )

Se quiser especificar seu próprio campo de chave primária, você precisará defini-lo explicitamente no modelo como este:

post_id = models.BigAutoField(primary_key=True)Linguagem de código:  Python  ( python )

Neste exemplo, the primary_key=Trueindica que the post_idé uma chave primária . Quando o Django vê um campo no modelo com primary_key=True, ele não adiciona a idcoluna automática.

O Django exige que cada modelo tenha exatamente um campo com a extensão primary_key=True.

Usando modelos

Depois de definir os modelos, você precisa informar ao Django que irá utilizá-los registrando o nome da aplicação na INSTALLED_APPSlista settings.pydo projeto:

INSTALLED_APPS = [
    # ...
    'blog.apps.BlogConfig',
]Linguagem de código:  Python  ( python )

Modelos integrados

Django vem com alguns modelos integrados, como Userfrom django.contrib.auth.modelsmodule. Para usar o Usermodelo, você precisa importá-lo para o models.pyarquivo:

from django.contrib.auth.models import UserLinguagem de código:  Python  ( python )

Chaves estrangeiras

Cada postagem no blogaplicativo é criada por um usuário e um usuário pode criar zero ou mais postagens. Isso é chamado de relacionamento um-para-muitos .

Para modelar o relacionamento um-para-muitos, você usa o ForeignKeycampo:

from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User


class Post(models.Model):
    title = models.CharField(max_length=120)
    content = models.TextField()
    published_at = models.DateTimeField(default=timezone.now)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
Linguagem de código:  Python  ( python )

Baseado neste modelo, o Django criará a blog_posttabela com a seguinte estrutura:

CREATE TABLE "blog_post" (
  "id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, 
  "title" varchar(120) NOT NULL, 
  "content" text NOT NULL, 
  "published_at" datetime NOT NULL, 
  "author_id" integer NOT NULL 
   REFERENCES "auth_user" ("id") 
   DEFERRABLE INITIALLY DEFERRED
);Linguagem de código:  SQL (linguagem de consulta estruturada)  ( sql )

Neste exemplo, auth_idé uma chave estrangeira que cria um relacionamento entre blog_posttabela e auth_usertabela. Observe que a auth_usertabela é a tabela fornecida pelo Django.

O método __str__()

Para definir a representação de string de um modelo, você pode substituir o __str__()método. Por exemplo:

from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User


class Post(models.Model):
    title = models.CharField(max_length=120)
    content = models.TextField()
    published_at = models.DateTimeField(default=timezone.now)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    

    def __str__(self):
        return self.titleLinguagem de código:  Python  ( python )

Quando você usa a instância do modelo Post como uma string, o Django chama o __str__()método e exibe seu resultado.

Adicionando Metaclasse à classe Model

A Metaclasse permite que você configure o modelo. Por exemplo, o seguinte define a Metaclasse dentro da Postclasse modelo que classifica as postagens em published_atordem decrescente ( -published_at), ou seja, as postagens mais recentes primeiro e as postagens mais antigas depois.

from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User

class Post(models.Model):
    title = models.CharField(max_length=120)
    content = models.TextField()
    published_at = models.DateTimeField(default=timezone.now)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    

    def __str__(self):
        return self.title
    
    class Meta:
        ordering = ['-published_at']Linguagem de código:  Python  ( python )

Após definir os modelos, você pode criar e aplicar migrações para criar tabelas no banco de dados, que abordaremos no próximo tutorial.

Baixe o código fonte do Projeto Django

Resumo

• Defina todos os modelos no models.pyarquivo da aplicação Django.
• Defina uma classe que herda de django.db.models.Modelpara criar um modelo.
• Um modelo é mapeado para uma tabela no banco de dados, na qual cada campo é mapeado para uma coluna na tabela do banco de dados.
• Substitua __str__()o método para retornar uma representação de string de um modelo.
• Use a Metaclasse para configurar o modelo.