Bonsoir à tous

J'ai été confronté ce matin à un petit soucis d'organisation et je n'ai pas su décider laquelle était la meilleure

Je dois gérer une relation de voisinage entre deux items. J'ai donc créé la table principale
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
create table item (
    id_item integer not null,
    ..., ..., ...
);
 
alter table item add constraint pkey_item primary_key (id_item);
Jusque là, pas de souci.

Puis, ma table voisinage
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
create table voisin (
    id_item1 integer not null,
    id_item2 integer not null
);
alter table voisin add constraint pkey_item primary_key (id_item1, id_item2);
Puis les foreign keys. Jusque là, ça va encore.

Mais mon problème c'est quand je veux insérer un voisin style item 1 voisin avec item 5. Là, j'ai 2 choix possibles
1) soit je rentre systématiquement dans ma table le tuple (1, 5) puis le tuple (5, 1)

2) soit je ne rentre que le tuple (1, 5) en disant "si 1 est voisin avec 5, alors 5 est automatiquement voisin avec 1".
Mais dans ce cas, j'aimerais bloquer l'insertion du tuple (5, 1) si le tuple (1, 5) est déjà dans la table. Et là, j'ai pas trouvé comment faire
J'ai essayé de créer une contrainte d'unicité sur le groupe (id_item2, id_item1) mais ça n'a rien empêché du tout.

Et donc ma question c'est: vaut-il mieux choisir la solution 1 et avoir chaque relation de voisinage écrite 2 fois ou vaut-il mieux utiliser la solution 2 mais sans pouvoir empêcher une insertion existant déjà dans le sens inverse ? Et corollaire: y a-t-il moyen, dans Postgres, d'empêcher cette insertion si le tuple inverse est déjà présent dans la table ?

Merci à tous