Sujet de veille 12
Django
Nour & Bastien
29/01/2020
Sujet de veille 12
Sommaire
Sujet de veille 12
L'accès aux données
avec Django
La structure globale
Affichage pour l'utilisateur
Les urls
Les templates
Les modèles
Les vues
L'affichage final pour l'utilisateur
Sujet de veille 12
La Structure Django
Sujet de
Le modèle ORM Django
C'est quoi un ORM? (Object Relational Mapping)
- Un ORM est une technique de programmation qui donne l'illusion de travailler avec une base de données orientée objet.
- En d’autres termes, vous créez vos bases de données en définissant des Classes et des attribut de Classes.
- Ces attributs seront automatiquement interprétés et convertis par Django pour créer une base de données.
- La plupart des interactions avec cette base de données sera faite par le biais d’objets au lieu de requêtes
- Vous ne faites plus de requêtes SQL mais vous travaillez directement avec vos objets.
Sujet de veille 12
Les modèles Django:
1 Model
Un modèle est la source d’information unique et définitive à propos de vos données. Il contient les champs et le comportement essentiels des données que vous stockez. Généralement, chaque modèle correspond à une seule table de base de données.
1 Model
#models.py
from django.db import models
class Person(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
Cet exemple de modèle définit une personne (Person) avec un prénom (first_name) et un nom (last_name) :
first_name et last_name sont des champs du modèle. Chaque champ est défini comme un attribut de classe, et chaque attribut correspond à une colonne de base de données.
Le modèle Person ci-dessus va créer une table de base de données comme celle-ci :
CREATE TABLE myapp_person (
"id" serial NOT NULL PRIMARY KEY,
"first_name" varchar(30) NOT NULL,
"last_name" varchar(30) NOT NULL
);2 Field
La partie la plus importante d’un modèle (et la seule qui soit obligatoire) est la liste des champs de base de données qu’il définit.
Les champs sont définis par des attributs de classe. Faites attention à ne pas choisir des noms de champs qui entrent en conflit avec l”API des modèles comme clean, save ou delete. Exemple :
#models.py
from django.db import models
class Musician(models.Model):
first_name = models.CharField(max_length=50)
last_name = models.CharField(max_length=50)
instrument = models.CharField(max_length=100)
class Album(models.Model):
artist = models.ForeignKey(Musician, on_delete=models.CASCADE)
name = models.CharField(max_length=100)
release_date = models.DateField()
num_stars = models.IntegerField()2 Field
Chaque champ accepte un certain nombre de paramètres spécifiques (documentés dans la référence des champs de modèle).
Par exemple, CharField (et ses sous-classes) exige un paramètre max_length indiquant la taille du champ de base de données VARCHAR qui stockera les données.
Il existe aussi un ensemble de paramètres communs à tous les types de champs. Ils sont tous facultatifs. Ils sont décrits en détails dans la référence (null, blank, choices, default, help_text, primary_key …)
3 Primary Key
Par défaut, Django ajoute à chaque modèle le champ suivant :
C’est une clé primaire avec incrémentation automatique.
Si vous souhaitez spécifier une clé primaire personnalisée, ajoutez primary_key=True à l’un de vos champs.
Si Django voit que vous avez explicitement défini Field.primary_key, il n’ajoutera pas de colonne id automatique.
Pour chaque modèle, il est obligatoire d’avoir un et un seul champ ayant le paramètre primary_key=True (qu’il soit déclaré explicitement ou ajouté automatiquement).
id = models.AutoField(primary_key=True)
4 ForeignKey
Django définit aussi un ensemble de champs représentant les relations.
class ForeignKey(to, on_delete, **options)Une relation plusieurs-à-un. Exige deux paramètres : la classe à laquelle le modèle est lié et l’option on_delete.
Pour créer une relation récursive (un objet avec une relation plusieurs-à-un vers lui-même), utilisez models.ForeignKey('self', on_delete=models.CASCADE).
Si vous avez besoin de créer une relation vers un modèle qui n’a pas encore été défini, vous pouvez utiliser le nom de ce modèle, à la place de l’objet modèle lui-même :
from django.db import models
class Car(models.Model):
manufacturer = models.ForeignKey(
'Manufacturer',
on_delete=models.CASCADE,
)
# ...
class Manufacturer(models.Model):
# ...
pass
Sujet de veille 12
Mapping des associations:
OneToOne, OneToMany, ManyToOne, ManyToMany.
Rappels:
- La première chose à comprendre est que chaque table SQL a un champ (généralement auto-incrémenté), qui est appelé une «clé primaire». ou pk
- Ce champ est une colonne avec une valeur unique pour chaque ligne.
Maintenant, prenons un exemple d’un model représentant un Author et qui a 3 colonnes.
(first_name, last_name et un “email” facultatif.)
Django va automatiquement ajouter à ce tableau une premiere colonne pk (primary-key).
Donc quand on va utiliser la commande ‘migrate’, le tableau suivant va se créer:
| pk | first_name | last_name |
|---|
Si on ajoute une valeur (Disons 'Stephen King’) cet auteur viendra s’ajouter à ce tableau de cette façon:
| pk | first_name | last_name | |
|---|---|---|---|
| 1 | Stephen | King | stephenking@gmail.com |
| pk | first_name | last_name | |
|---|---|---|---|
| 1 | Stephen | King | stephenking@gmail.com |
| 2 | John | Salinger |
et un second...
maintenant, créons un autre tableau que l’on va nommer ‘Book’:
| pk | title | genre | author |
|---|---|---|---|
| 1 | Pet Semetary | Horror | 1 |
Maintenant, vous voyez ce qu’on a fait ? Sur le champ author, nous avons donné au livre la valeur de la clé primaire (pk) de Stephen King - rappelez-vous, il est unique, donc il ne récupérera que Stephen King.
| pk | title | genre | author |
|---|---|---|---|
| 1 | Pet Semetary | Horror | 1 |
C'est ce qu’on appelle une ForeignKey - ou (clé étrangère)
elle pointe vers un pk sur une table associée et représente une relation plusieurs-à-un, c'est-à-dire que plusieurs livres peuvent pointer vers le même pk d'un auteur, mais pas l'inverse.
De cette façon, chaque auteur peut avoir de nombreux livres associés, mais chaque livre n'a qu'un seul auteur.
| pk | title | genre | author |
|---|---|---|---|
| 1 | Pet Semetary | Horror | 1 |
| 2 | The Talisman | Fantasy | 1 |
Ajoutons maintenant un second livre à l’auteur Stephen King:
Mais...
Supposons que ce livre à été écrit co-écrit par un autre beau-gosse appelé Peter Straub...
Donc, premiere chose à faire, on va devoir l’ajouter à la table ‘Author’
| pk | first_name | last_name | |
|---|---|---|---|
| 1 | Stephen | King | stephenking@gmail.com |
| 2 | John | Salinger | |
| 3 | Peter | Straub |
Mais maintenant, comment pouvons-nous dire aux tables que The Talisman soit lié à deux lignes différentes?
C’est simple, on va utiliser un troisième tableau pour lier les deux.
- Le tableau 1 sera donc composé d'auteurs
- Le tableau 2 contiendra les livres.
- Le tableau 3 s'appellera authors_books et ressemblera à ceci:
| pk_of_book | pk_of_author |
|---|---|
| 1 (Pet Semetary) | 1 (Stephen King) |
| 2 (The Talisman) | 1 (Stephen King) |
| 2 (The Talisman) | 3 (Peter Straub) |
Et c’est ce qu’on appelle relation Many-to-Many (plusieurs-à-plusieurs), car différents livres peuvent être liés à différents auteurs et vice versa.
| pk | title | genre | author |
|---|---|---|---|
| 1 | Pet Semetary | Horror | 1 |
| 2 | The Talisman | Fantasy | 1 |
| pk | first_name | last_name | |
|---|---|---|---|
| 1 | Stephen | King | stephenking@gmail.com |
| 2 | John | Salinger | |
| 3 | Peter | Straub |
| pk _of_book | pk_of_author |
|---|---|
| 1 (Pet Semetary) | 1 (Stephen King) |
| 2 (The Talisman) | 1 (Stephen King) |
| 2 (The Talisman) | 3 (Peter Straub) |
Les relations OneToOne se font sont avec un ForeignKey mais avec un unique = True.
Vous pourriez alors lier un objet à un autre et c'est tout.
?
Sujet de veille 12