Noções Basicas de Models no Django e Como Usá-los Para Interagir Com o Banco de Dados.

Django models são simplemente a definição e representação de dados em uma aplicação Django.

Com isso, caso você queira trabalhar e implementar interações com algum banco de dados e essencial que você entenda como trabalhar com essa ferramenta no qual ira te ajudar muito no seu desenvolvimento.

Vamos lá! Irei explicar sobre os models do django de uma forma simplificada, no qual esperofacilitar o seu entendimento.

Ok, mas o que são django models de uma forma mais técnica?

Bem, se você ja tem uma noção do que é um banco de dados relacional. Onde existem tabelas especificas que se pode se inserir dados, ficará muito facil te explicar.

No caso, os models do Django são usados para criar e representar tabelas de um banco de dados como objetos em Python.

Em outras palavras, você poderá criar um model no Django (que representa uma tabela) herdando uma classe do Django chamada Model.

Como cada tabela de um banco de dados tem tipos de campos diferentes, você também poderá aplicar essa tipificação aos campos da mesma maneira, porém utilizando o Django.

Exemplo de uma tabela simples no SQL:

Agora, como uma tabela seria representada em uma aplicação Django?

from django.db import models # <-- Herdando toda a lógica pronta do Django

class Postagen(models.Model):
    titulo = models.CharField(max_length=120)
    descricao = models.TextField()
    
    def __str__(self):
      return self.titulo

Como podemos notar, temos uma tabela (vamos dizer que é uma tabela em um banco de dados 😄) chamada Postagens. Logo abaixo, temos um model no Django que representa essa tabela com o mesmo número de colunas: título e descrição.

Ah, só para lembrar que, no Django, não é necessário adicionar o campo ID. Ele é adicionado por padrão nos modelos do Django. 😉

Dessa forma, com uma explicação um pouco mais técnica que a introdução, você já consegue entender melhor qual é o propósito inicial de um model no Django.

Campos Comuns Usados em Modelo do Django

Como existem vários tipos de dados para colunas em um banco de dados, como strings, caracteres, booleanos, numéricos (inteiros, flutuantes e especiais), etc., no próprio model do Django você terá a possibilidade de criar diferentes colunas com diferentes tipos de dados.

No exemplo acima, vemos duas colunas: título e descrição. Essas duas colunas têm tipos de dados praticamente iguais: CharField() e TextField().

O CharField traz a capacidade de criar textos com um número limitado de caracteres (no exemplo acima, com 120 caracteres) e será traduzido como VARCHAR no banco de dados.

Já o TextField é basicamente a representação de uma string, sem limitação de caracteres, e será traduzido como TEXT no banco de dados.

Além dessas existe uma gama de campos usados em models no Django.

Porém as mais comuns são os campos:

1. Para textos temos os CharField (cujo e obrigatorio usar o parametro max_length) e o TextField.
2. Tipo numéricos temos o IntegerField (que armazena numeros inteiros), FloatField e o DecimalField que tambem adiciona numeros flutuantes porem com casas decimais definidas como a adição de casas decimais com o parametro decimal_places, e o numero total de digitos com o parametro max_digits.
3. Também temos campos que representam data e hora. Com os campos, DateField que apenas armazena (ano, mes e dia). O TimeField que apenas armazena horas e o DateTimeField que armazen data e horas.
4. Alem disso também temos campos do tipo booleanos como o BooleanField no qual e usado para adicionar valores como True ou False.
5. E por fim, temos os campos de relacionamentos: ForeignKey onde se cria um relacionamento de “muitos para um” onde se é necessario adicionar para qual tabela ou modelo esta sendo relacionado e o parametro on_delete no qual será setado o que acontecerá ao deletar a row com o relacionamento. O campo de relacionamento OneToOneField no qual cria um relacionamento de “um para um” entre duas tabelas. E por fim o campo de relacionamento ManyToManyField que criar relacionamentos de “mutos para muitos” entre duas tabelas.

Os campos citados acima são apenas os mais comuns usados para a criação de um model no django. Existem varios outros no qual voce pode pesquisar para uso mais especificos e tambem pode ate criar um campo especifico para seu uso especifico, porem eu não irei entrar em muitos detalhes nesta postagem.

Conectando com bancos de dados em uma aplicação django

Antes de iniciar qualquer explicação aqui sobre a criação de objetos usando a ORM do django através dos models, ficaria sem sentido fazer isso sem a explicação da conexão de uma aplicação django com um banco de dados. Com isso explicarei brevemente como uma conexão do django e feita com o banco de dados:

Por padrão o django tem um arquivo de configuração chamado settings.py onde vários arquivos de conexão e configurações estão alocadas, e uma delas é a conexão com o banco de dados.

# settings.py

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.sqlite3",
        "NAME": "mydatabase",
    }
}

No código acima podemos ver qual é a constante que representa a conexão com o banco de dados chamada DATABASES. Neste exemplo é representado com uma configuração padrão de uma aplicação inicial do Django.

Por outro lado, também podemos usar esta mesma constante para se conectar com diferente bancos de dados:

# settings.py

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": "mydatabase",
        "USER": "mydatabaseuser",
        "PASSWORD": "mypassword",
        "HOST": "127.0.0.1",
        "PORT": "5432",
    }
}

Com o exemplo acima criando a conexão com um banco de dados “ENGINE” postgresql e suas variaveis necessarias para conexão.

Migrando as Tabelas

Quando você define os models (modelos de dados) no Django, eles ainda não existem no banco de dados. Para criar as tabelas no banco, você usa o comando python manage.py migrate. O Django então traduz os models em tabelas SQL e as cria no banco de dados.

Realizando a Conexão

Quando você executa o Django (comandos como runserver ou migrate), o Django usa essas informações para se conectar ao banco de dados. Ele cria uma conexão automática por meio de sua camada de abstração de banco de dados, chamada ORM (Object-Relational Mapping). Com o ORM, o Django traduz o código Python em consultas SQL para interagir com o banco de dados.

Interagindo com o Banco de Dados

Com a conexão estabelecida, o Django permite que você faça operações como criar, ler, atualizar e deletar registros no banco de dados usando código Python. Basicamente, Você não precisa escrever consultas SQL manualmente, o Django faz isso por você com seu ORM.

Passo-a-passo de iteração com banco de dados usando django models e ORM

Vamos supor que iremos criar uma aplicação django onde iremos adicionar postagens (da mesma maneira que fizemos no topo desta postagem). Porém iremos usar esta tabela para iteragir com o banco de dados.

# models.py
from django.db import models
from django.contrib.auth.models import User

class Postagem(models.Model):
    titulo = models.CharField(max_length=120)
    descricao = models.TextField()
    data_criacao = models.DateField(auto_now_add=True)
    autor = models.ForeignKey(User, on_delete=models.DO_NOTHING)
    
    def __str__(self):
        return self.titulo

Ao criar esta tabela devemos rodar o comando:

python manage.py makemigrations # cria um arquivo de migrations
python manage.py migrate # reflete o model no banco de dados

Ao ativar os dois comandos acima, por padrão, será criado um banco de dados sqlite3 no django (em caso você não fazer conexão com outro banco de dados). É refletida todas as migrations padrão do django e a desse modelo para o banco de dados.

Interagindo Com o Banco de Dados Usando ORM do Django

Agora que temos toda configuração feita podemos testar nosso modelo de postagens em usuarios usando o ORM do django.

No terminal adicione o seguinte comando:

python manage.py shell

Com isso voce terá acesso ao shell da aplicação django que voce esta trabalhando. Então se tudo correu bem você terá acesso ao shell da aplicação como a seguir:

(venv) C:\software_projects\projeto_de_configuração> python manage.py shell
Python 3.10.11 (...) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> # seu codigo ira ser adicionado aqui

Agora vamos iniciar a criação dos dados usando os models que criamos e a ORM do django.

>>> # imports
>>> from postagens.models import Postagem       
>>> from django.contrib.auth.models import User
>>> 
>>> # criação de usuario --
>>> user = User.objects.create(username="Elias", password="Aprendendo123")
>>> 
>>> # testando se usuario foi criado
>>> user
<User: Elias>
>>>
>>> # criacao de postagem --
>>> postagem = Postagem.objects.create(
... titulo="Noções Basicas de Models no Django..",
... descricao="Models é simplemente a definição e representação de dados em...",
... autor=user
... )
>>> # checagem se a postagem foi criada
>>> postagem
<Postagem: Noções Basicas de Models no Django..>
>>>
>>> # checagem de campos.     
>>> postagem.autor
<User: Elias>
>>> postagem.data_criacao
datetime.date(2024, 9, 27)
>>>

Como vemos acima, usamos um sub-framework do Django ORM para interagir com o banco de dados. Explicando o que foi feito: assim que entrei no shell com o comando python manage.py shell, fiz o import dos models que irei usar, o model Postagem e o User (que é padrão do Django).

Em seguida, foi usado o comando para criar um único usuário com apenas username e password. Só para lembrar que foi criado o usuário porque seria necessário para a criação de uma postagem.

Sem um usuário, não seria possível criar uma postagem. Dessa forma, a postagem foi criada, associando o usuário criado anteriormente ao campo autor.

Por último, foi verificado se a postagem havia sido criada corretamente, também checando os campos como postagem.autor e postagem.data_criacao.

Checando Os Dados Diretamente No Banco de Dados

Caso você esteja usando o VSCode, poderá instalar uma extensão chamada SQLite Viewer.

Com essa extensão você poderá acessar o banco de dados de teste sqlite clicando no icone do sqlite para acessar os dados que foram criados usando os comandos do shell.

Como voce vê acima, para visualizar as tabelas criadas você poderá seguir os passos que foram feitos acima (logo após você instalar o SQLite Viewer).

1. Então nesse caso, você poderá iniciar clicando no icone do banco db.sqlite3.
2. Ja na sequência você terá acesso a todas as tabelas que existem no sistema.
3. Ache a tabela que precisa saber onde estão os dados criados (lembrando que o django segue um padrão de nomeação de tabelas (<app-name>_<model-name>)). Então nesse caso precisa-se clicar em postagens_postagem.
4. Ao clicar na tabela você terá o acesso aos dados que você criou com os dados como id, titulo, descricao, data_criacao e autor_id.

Conclusão

Nesta postagem poderia ser explicado tudo que sei sobre ORM, como criação de diferente relacionamentos, criação de campos customizaveis ou até mesmo te explicar outros tipos de campos como o JSONField() porém o foco é você entender as noções basicas de models no django.

Nesta postagem eu gostaria apenas de te apresentar como podemos trabalhar com models de uma forma simples e se conectar com o banco, criando alguns objetos, com inserção dos dados no banco de dados.

Caso você precise de uma postagem mais complexa futuramente irei iniciar uma postagem com detalhes a fundo de django ORM, olhando por de baixo do capô do django e entendendo como esse framework funciona por de baixo dos panos.