Leitores como você ajudam a apoiar o MUO. Quando você faz uma compra usando links em nosso site, podemos ganhar uma comissão de afiliado.
Um relacionamento de banco de dados descreve a conexão entre diferentes tabelas de banco de dados. As relações determinam como armazenar e recuperar dados. Django funciona bem com sistemas de banco de dados relacionais (RDBMS). Ele, portanto, oferece suporte a relacionamentos de tabelas de banco de dados.
Os tipos de relacionamentos dependem dos requisitos de seu aplicativo e dos dados que ele modela. Boas relações entre os modelos Django e o banco de dados melhoram a manutenção dos dados. Isso inclui melhorar o desempenho da consulta e reduzir a duplicação de dados.
Você pode aprender como os relacionamentos de banco de dados do Django afetam o desempenho do aplicativo explorando os três principais tipos de relacionamento.
Relacionamentos de banco de dados
Os sistemas de banco de dados relacionais suportam três tipos de relacionamentos de banco de dados. Essas relações são um-para-muitos, muitos-para-muitos e um-para-um. O tipo de relação de banco de dados afeta os casos de uso de seu aplicativo.
modelos Django representam tabelas de banco de dados no aplicativo. Você deve criar boas relações entre as tabelas para criar um bom sistema de banco de dados. As relações de banco de dados determinam como armazenar e apresentar dados em seu aplicativo.
Para entender as relações do banco de dados, comece por criando um projeto Django nomeado Capuzes. O aplicativo será uma rede social do bairro. Ele administrará as atividades sociais, a segurança e os negócios de vários bairros.
Os residentes podem se registrar, entrar e criar perfis. Eles também podem criar postagens e anúncios de negócios para todos verem.
Para começar, crie um banco de dados que armazenará todos os dados da vizinhança. Em seguida, você criará os modelos de Perfil, Vizinhança, Negócio e Posto. Para criar os modelos, você deve determinar o relacionamento que as tabelas do banco de dados precisam.
Relacionamento de banco de dados um para um
Um relacionamento um-para-um implica que um registro em um modelo Django está relacionado a outro registro em outro modelo. Os dois registros dependem um do outro. Neste caso, o modelo de perfil depende do modelo de usuário para criar perfis de residentes.
Portanto, só pode haver um perfil para cada morador cadastrado no app. Além disso, sem um usuário, um perfil não pode existir.
de django.db importar modelos
dedjango.contrib.auth.modelosimportarDo utilizadoraulaPerfil(modelos. Modelo):
usuário = modelos. OneToOneField (Usuário, on_delete=models. CASCADE, related_name='perfil')
nome = modelos. CharField (max_length=80, em branco =Verdadeiro)
bio = modelos. TextField (max_length=254, em branco =Verdadeiro)
profile_picture = CloudinaryField('Foto do perfil', padrão='default.png')
localização = modelos. CharField (max_length=50, em branco =Verdadeiro, nulo=Verdadeiro)
email = modelos. EmailField(nulo=Verdadeiro)
def__str__(auto):
retornar f'{auto.user.username} perfil'
Modelo de usuário do Django é um modelo de autenticação embutido no Django. Você não precisa criar um modelo para isso. Em vez disso, importe-o de django.contrib.auth. O OneToOneField() no modelo de perfil define um relacionamento um-para-um.
O on_delete=modelos. CASCATA argumento impede a exclusão de um desses registros. Você deve excluir os registros de ambas as tabelas.
Você pode usar a interface de administração do Django para visualizar o relacionamento em seu aplicativo. Para fazer login no administrador do Django, você deve se registrar como um usuário administrador conhecido como superusuário.
Crie um superusuário executando o seguinte comando no terminal:
Pitãogerenciar.pycriarsuperusuárioHaverá uma solicitação para inserir seu nome de usuário, e-mail e senha. Feito isso, inicie o servidor.
Abra a página de administração em um navegador usando o URL http://127.0.0.1:8000/admin.
Você verá a página de administração onde poderá fazer login com as credenciais que criou anteriormente. Uma vez logado, você verá o Grupos e Usuários objetos. A estrutura de autenticação do Django gerencia esses dois modelos. Na parte inferior, você verá o Modelo de perfil.
Abra o Perfil modelo e prossiga para adicionar um perfil. Você verá que aparece da seguinte forma:
Observe que você tem a opção de criar um perfil para um usuário. O tipo de dados OneToOneField() permite criar perfis para usuários autenticados. É assim que o aplicativo administra relacionamentos um-para-um.
Relacionamentos um-para-muitos
Um relacionamento um-para-muitos implica que um registro em um modelo se associa a muitos registros em outro modelo. Também é chamado de relacionamento muitos-para-um.
No seu caso, um administrador pode criar várias vizinhanças. Mas cada bairro só pode pertencer a um administrador. Você pode usar o tipo de dados ForeignKey para definir tal relacionamento.
O Django possui uma interface de administração embutida. Você não precisa criar um modelo para isso. O administrador tem o direito de gerenciar o conteúdo e visualizar o aplicativo no painel de administração.
O modelo que acomoda muitos registros terá a Chave Estrangeira. Ele define o relacionamento como um-para-muitos. O código abaixo mostra onde colocar a chave.
aulaVizinhança(modelos. Modelo):
admin = modelos. Chave estrangeira("Perfil", on_delete=modelos. CASCADE, related_name='capuz')
nome = modelos. CharField (max_length=50)
localização = modelos. CharField (max_length=60)
hood_logo = CloudinaryField('hood_logo', padrão='default.png')
descrição = modelos. Campo de texto()
health_tell = modelos. CampoInteiro(nulo=Verdadeiro, em branco =Verdadeiro)
número_polícia = modelos. CampoInteiro(nulo=Verdadeiro, em branco =Verdadeiro)
Contagem = modelos. CampoInteiro(nulo=Verdadeiro, em branco =Verdadeiro)
def__str__(auto):
retornar f'{auto.nome} capa'
Você pode ver a relação no app conforme ilustrado na imagem:
O Vizinhança modelo agora tem um administrador. Para qualquer pessoa criar uma vizinhança, ela deve ter direitos de administrador. E um bairro não pode ter muitos administradores.
Relacionamentos de banco de dados muitos para muitos
Em relacionamentos muitos-para-muitos, muitos registros em um modelo se associam a outros em outro. Por exemplo, o Publicar e Negócios os modelos podem ter vários registros uns dos outros. Os usuários podem fazer vários anúncios comerciais em suas postagens e vice-versa.
No entanto, criar relacionamentos muitos-para-muitos pode levar a dados imprecisos. Em outros frameworks, você teria que criar uma nova tabela para unir as duas tabelas.
Django tem uma solução para isso. Quando você usa o campo muitos para muitos, ele cria uma nova tabela mapeando as duas tabelas juntas. Você pode colocar o campo muitos-para-muitos em qualquer um dos dois modelos, mas não deve estar em ambos os modelos.
aulaPublicar(modelos. Modelo):
título = modelos. CharField (max_length=120, nulo=Verdadeiro)
postagem = modelos. Campo de texto()
data = modelos. DateTimeField (auto_now_add=Verdadeiro)
usuário = modelos. ForeignKey (Perfil, on_delete=models. CASCADE, related_name='post_owner')
capuz = modelos. ForeignKey (NeighbourHood, on_delete=models. CASCADE, related_name='post_capuz')
negócios = modelos. ManyToManyField (Negócios)
def__str__(auto):
retornar f'{auto.title} post'
Agora, quando você visualiza o Publicar modelo no painel de administração, você pode anexar várias empresas a uma postagem.
Django simplifica relacionamentos de banco de dados
O tipo de banco de dados que você usa para seu aplicativo determina como aproveitar os dados. O Django possui um sistema abrangente que facilita a conexão e a operação de bancos de dados relacionais.
Os recursos do Django facilitam o armazenamento e a recuperação de dados de tabelas relacionadas. Ele possui APIs integradas que conectam e criam relações de banco de dados para seu aplicativo.
Os relacionamentos do banco de dados determinam o comportamento do seu aplicativo. Depende de você usar relacionamentos um-para-um, um-para-muitos ou muitos-para-muitos.
Com o Django, você pode configurar e testar recursos sem quebrar seu aplicativo. Use Django para proteger sistemas de banco de dados e otimizar sua experiência de desenvolvedor.
