Avec Django, chaque modèle dispose d’une clé primaire. Par défaut, la clé primaire consiste en un champ unique.
\nDans la plupart des cas, une clé primaire sur un seul champ suffira. Toutefois, en conception de bases de données, la définition d’une clé primaire formée de plusieurs champs est parfois nécessaire.
\nPour utiliser une clé primaire composite lors de la définition d’un modèle, définissez l’attribut pk à une clé CompositePrimaryKey:
class Product(models.Model):\n name = models.CharField(max_length=100)\n\n\nclass Order(models.Model):\n reference = models.CharField(max_length=20, primary_key=True)\n\n\nclass OrderLineItem(models.Model):\n pk = models.CompositePrimaryKey("product_id", "order_id")\n product = models.ForeignKey(Product, on_delete=models.CASCADE)\n order = models.ForeignKey(Order, on_delete=models.CASCADE)\n quantity = models.IntegerField()\nCela indiquera à Django de créer une clé primaire composite (PRIMARY KEY (product_id, order_id)) lors de la création de la table.
Une clé primaire composite est représentée par un tuple:
>>> product = Product.objects.create(name="apple")\n>>> order = Order.objects.create(reference="A755H")\n>>> item = OrderLineItem.objects.create(product=product, order=order, quantity=1)\n>>> item.pk\n(1, "A755H")\nVous pouvez attribuer un tuple à l’attribut pk. Cela va définir les valeurs de champs associés :
>>> item = OrderLineItem(pk=(2, "B142C"))\n>>> item.pk\n(2, "B142C")\n>>> item.product_id\n2\n>>> item.order_id\n"B142C"\nUne clé primaire composite peut aussi être filtrée par un tuple:
>>> OrderLineItem.objects.filter(pk=(1, "A755H")).count()\n1\nNous somme toujours en cours de travail pour la prise en charge des clés primaires composites pour les champs relationnels, y compris les champs GenericForeignKey et le site d’administration de Django. À ce stade, les modèles avec clé primaire composite ne peuvent pas être inscrits dans l’administration de Django. Nous espérons pouvoir résoudre ces questions dans de prochaines versions.
Django ne prend actuellement pas en charge la migration depuis ou vers une clé primaire composite une fois qu’une table a été créée. Il ne gère pas non plus l’ajout ou la suppression de champs faisant partie de la clé primaire composite.
\nSi vous souhaitez faire migrer une table existante à partir d’une clé primaire unique vers une clé primaire composite, suivez les instructions de votre moteur de base de données pour le faire.
\nAprès que la clé primaire composite est en place, ajoutez le champ CompositePrimaryKey à votre modèle. Cela permet à Django de reconnaître et de traiter correctement la clé primaire composite.
Même si les opérations de migration (par ex. AddField, AlterField) sur des champs de clé primaire ne sont pas prises en charge, makemigrations détecte tout de même les modifications.
Afin d’éviter les erreurs, il est recommandé d’appliquer de telles migrations avec --fake.
Une autre possibilité est d’utiliser SeparateDatabaseAndState pour exécuter les migrations spécifiques au moteur et les migrations générées par Django dans une seule opération.
Les champs relationnels ainsi que les relations génériques ne prennent pas en charge les clés primaires composites.
\nPar exemple, considérant le modèle OrderLineItem, le code suivant n’est pas possible :
class Foo(models.Model):\n item = models.ForeignKey(OrderLineItem, on_delete=models.CASCADE)\nCar ForeignKey ne peut actuellement pas faire référence à des modèles avec clé primaire composite.
Pour contourner cette limite, ForeignObject peut être utilisé comme alternative :
class Foo(models.Model):\n item_order_id = models.CharField(max_length=20)\n item_product_id = models.IntegerField()\n item = models.ForeignObject(\n OrderLineItem,\n on_delete=models.CASCADE,\n from_fields=("item_order_id", "item_product_id"),\n to_fields=("order_id", "product_id"),\n )\nForeignObject ressemble beaucoup à ForeignKey, sauf qu’il ne crée pas de colonne (par ex. item_id), de contrainte de clé étrangère ni d’index en base de données, et l’argument on_delete est ignoré.
Beaucoup de fonctions de base de données n’acceptent qu’une seule expression.
\nMAX("order_id") -- OK\nMAX("product_id", "order_id") -- ERROR\nDans ces cas, si on fournit une référence à une clé primaire composite, une erreur ValueError sera produite, car cette clé est composée de plusieurs colonnes. Une exception est admise pour Count.
Max("order_id") # OK\nMax("pk") # ValueError\nCount("pk") # OK\nComme une clé primaire composite est un champ virtuel, c’est-à-dire un champ qui ne représente pas une seule colonne de base de données, ce champ est exclu des formulaires ModelForms.
Par exemple, en prenant l’exemple de ce formulaire
\nclass OrderLineItemForm(forms.ModelForm):\n class Meta:\n model = OrderLineItem\n fields = "__all__"\nCe formulaire ne possède pas de champ de formulaire pk pour la clé primaire composite :
>>> OrderLineItemForm()\n<OrderLineItemForm bound=False, valid=Unknown, fields=(product;order;quantity)>\nSi on veut définir la clé primaire composite pk comme champ de formulaire, une erreur FieldError de champ inconnu est générée.
Comme pk n’est qu’un champ virtuel, l’inclusion de pk comme nom de champ dans l’argument exclude de Model.clean_fields() n’a aucun effet. Pour exclure les champs de clé primaire composite de la validation des modèles, indiquez chacun des champs concernés individuellement. Model.validate_unique() peut tout de même être appelée avec exclude={"pk"} pour omettre les contrôles d’unicité.
Avant l’introduction des clés primaires composites, le champ unique composant la clé primaire pouvait être consulté en interrogeant l’attribut primary_key de ses champs :
>>> pk_field = None\n>>> for field in Product._meta.get_fields():\n... if field.primary_key:\n... pk_field = field\n... break\n...\n>>> pk_field\n<django.db.models.fields.AutoField: id>\nMaintenant qu’une clé primaire peut être composée de plusieurs champs, il n’est plus possible de se fier à l’attribut primary_key pour identifier la composition de la clé primaire, car il vaudra False pour maintenir la règle qu’au plus un seul champ par modèle peut avoir cet attribut à True:
>>> pk_fields = []\n>>> for field in OrderLineItem._meta.get_fields():\n... if field.primary_key:\n... pk_fields.append(field)\n...\n>>> pk_fields\n[]\nSi l’on veut construire du code applicatif qui sache gérer correctement les clés primaires composites, l’attribut _meta.pk_fields est maintenant disponible :
>>> Product._meta.pk_fields\n[<django.db.models.fields.AutoField: id>]\n>>> OrderLineItem._meta.pk_fields\n[\n <django.db.models.fields.ForeignKey: product>,\n <django.db.models.fields.ForeignKey: order>\n]\n