Discussion :

[Benamour Jr]

Bonjour,

J'ai une table COURS dont voici la structure

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
  `id` mediumint(8) unsigned NOT NULL AUTO_INCREMENT,
  `id_categorie` smallint(5) unsigned NOT NULL,
  `id_chapitre` mediumint(5) unsigned NOT NULL,
  `titre` varchar(150) NOT NULL,
  `description` text NOT NULL,
  `youtube` varchar(100) NOT NULL,

En gros il s'agit d'une liste de cours répartis en catégorie (arithmétique, algèbre, géométrie,...), et chacune des catégories est elle même divisée en chapitre (calcul écrit, technique de calcul,...)

Je suis en train de programmer une page categorie.php contenant les 3 premiers cours de chaque chapitre dont l'id_categorie de ce tableau COURS est une valeur précise.

Concrêtement, id_categorie=1 correspond à la catégorie "Arithmétique", et sur cette page Arithmétique je veux afficher les 3 premiers cours de chaque chapitre appartenant à cette catégorie arithmétique.

Quelle est selon vous la méthode la plus optimale pour procéder ?

La solution la plus évidente serait de faire une requête de ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SELECT ... FROM Cours WHERE id_categorie=1 AND id_chapitre=1 LIMIT 3

Et de la répéter autant de fois qu'il y a de chapitre, en changeant donc à chaque fois l'id_chapitre concerné.

Mais j'ai peur que niveau performance ce ne soit pas efficace !

Sinon j'avais pensé à créer une table temporaire issue de la table Cours mais ne reprenant que les lignes dont id_categorie=1. Et puis à partir de cette table temporaire je ferais ce genre de requête.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SELECT ... FROM TMP_Arithmétique WHERE id_chapitre=1 LIMIT 3

Requête à également répéter autant de fois qu'il y a de chapitre différent...

Mais pareil, j'ai peur pour les performances car ca ne doit pas etre anodins de créer à chaque fois une table, et puis de faire toutes les requêtes sachant qu'il peut y avoir une vingtaine de chapitres.

Devrais-je m'orienter alors plutôt vers une vue matérialisée ? Mais dans ce cas la je dois prendre en compte le cout de la mise à jour de cette vue matérialisée...

Existe-t-il une solution plus simple à laquelle je n'aurais pas pensé ? Je vous serai très reconnaissant si vous pouviez m'éclairer, merci !

[Benamour Jr]

Désolé je me rends compte que mon message n'était pas très bien expliqué, en fait un cours c'est par exemple "Comment calculer la pente de la fonction", le site n'aborde que les math. Donc Math est divisé en catégorie (ce sont mes menus principaux), et chaque catégorie est divisée en chapitre, et chaque chapitre est divisé en cours, et ces cours sont donc repris dans le tableau en question. Ce qui fait que plusieurs cours appartiennent à un même chapitre, que plusieurs chapitres appartiennent à une meme catégorie, et que toutes les catégories appartiennent à maths. Un cours n'a qu'un seul chapitre et une seule catégorie, et un chapitre n'a qu'une seule catégorie. Voilà j'espère que vous y verrez plus claire

[aieeeuuuuu]

Bonjour,


Vous parlez de vue matérialisées qui - sauf erreur de ma part - n'existent pas sous MySQL.
Si vous êtes sur un autre SGBD, il y aura des solutions simples, avec les fonctions fenêtrées. Celles-ci n'étant pas non plus implémentées sous MySQL, si vous êtes bien sous MySQL, il faudra mettre en œuvre d'autres solutions plus complexes et moins performantes.

Pouvez-vous donc préciser votre SGBD ?

Par ailleurs, vous parlez de "trois premiers", mais votre table ne semble contenir aucune colonne pouvant indiquer un ordre (date, rang,...), pouvez vous également préciser ce point ?

[Benamour Jr]

Bonjour,

Merci pour votre réponse.
Je suis bien sous MySQL.
C'est via un cours que j'ai pris connaissance des vues matérialisées:
En gros il s'agit de table tout à fait normal, c'est simplement l'utilisation qui en est faite qui les différencies. Ces vues matérialisées ont probablement d'autres formes sous d'autre SSGBD.

Concernant l'ordre, il peut être retrouvé en classant par ordre croissant ou décroissant les ID des cours.
Par exemple pour tous les cours d'arithmétique, chapitre calcul écrit (id_categorie = 1 et id_chapitre = 1)
j'ai une liste de cours dont l'id peut être 1, 5, 9, 12,...
et donc si je prends les trois plus petit id (1, 5, 9), j'ai bien les 3 premiers cours de ce chapitre.
sauf que si je veux ajouter un cours préliminaire à une liste de cours déjà existante je suis piégé... je viens de m'en rendre compte !
merci d'avoir attiré mon attention sur ce point ! du coup me faudrait-il créer un champ 'rang' dans ma table cours ?

[escartefigue]

Concernant l'ordre, il peut être retrouvé en classant par ordre croissant ou décroissant les ID des cours.

Non, les identifiants de type auto incrément ne sont pas toujours attribués dans l'ordre chronologique, il ne faut surtout pas les utiliser en ce sens, ni pour quelque usage fonctionnel que ce soit
Si vous avez besoin d'informations chronologiques, il faut soit ajouter des colonnes d'horodatage dans vos tables, soit gérer un chrono fonctionnel dont vous garantissez la chronologie.

[Benamour Jr]

Comme ce n'est pas la date qui est important pour l'ordre de mes cours mais simplement l'ordre dans lequel je juge qu'un cours doit être étudié avant un autre, je pense donc m'orienter vers la création d'un champs rang au sein de ma table Cours.
Ainsi je peux faire une requête SQL globale du type

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SELECT * FROM Cours WHERE id_categorie = 1 AND rang <=3

Et bam je me retrouve uniquement avec les cours occupant les trois premiers rangs de tous les chapitres de la catégorie qui m'intéresse, que je n'ai plus qu'à classer en fonction de l'id_chapitre
Qu'en pensez-vous ?

[escartefigue]

Si le "rang" a un sens fonctionnel, il faut effectivement créer une colonne et procéder comme vous le proposez
Dans le cas contraire, si vous souhaitez uniquement afficher 3 enregistrements quelconques, vous pouvez utiliser la clause "limit"

Attention toutefois, si votre requête concerne des volumes conséquents, la clause limit ne s'appliquant qu'après sélection, les performances ne seront pas optimales

[Artemus24]

Salut à tous.

Quelle est selon vous la méthode la plus optimale pour procéder ?

D'après ce que j'ai compris, votre clef primaire qui n'apparait pas ici dans le descriptif de votre table, devrait resoudre votre problème.

En tenant compte que du couple (id_categorie` ; `id_chapitre`), vous avez déjà un ordre que vous recherchez.
Du coup, la colonne `id` ne vous sert plus à rien car redondante avec le couple ci-dessus.

je veux afficher les 3 premiers cours de chaque chapitre

Donc il vous manque une autre colonne, que l'on peut baptiser du nom de `id_cours`.

Et du coup, votre clef primaire devient un triplé : (id_categorie` ; `id_chapitre`, `id_cours`)

Autrement dit, un cours appartient à un chapitre donné et un chapitre appartient à une catégorie donnée.
Il suffit de faire une numérotation qui s'adapte à votre besoin.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
+-----------+----------+-------+
| Categorie | Chapitre | Cours |
+-----------+----------+-------+
|     1     |     1    |   1   |
|     1     |     1    |   2   |
|     1     |     1    |   3   |
|     1     |     1    |   4   |
+-----------+----------+-------+
|     1     |     2    |   1   |
|     1     |     2    |   2   |
|     1     |     2    |   3   |
+-----------+----------+-------+
|     1     |     3    |   1   |
|     1     |     3    |   2   |
+-----------+----------+-------+
|     2     |     1    |   1   |
|     2     |     1    |   2   |
|     2     |     1    |   3   |
+-----------+----------+-------+
|     2     |     2    |   1   |
|     2     |     2    |   2   |
|     2     |     2    |   3   |
+-----------+----------+-------+
|     3     |     1    |   1   |
|     3     |     1    |   2   |
+-----------+----------+-------+

Pour ce faire, votre table doit avoir la structure suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
DROP TABLE IF EXISTS `cours`;
 
CREATE TABLE `cours`
( `id_categorie`  integer  unsigned NOT NULL,
  `id_chapitre`   smallint unsigned NOT NULL,
  `id_cours`      smallint unsigned NOT NULL,
  `titre`         varchar(255)      NOT NULL,
  `description`   text              NOT NULL,
  `youtube`       varchar(255)      NOT NULL,
  `name`          varchar(255)      NOT NULL,
  `visiteur`      integer unsigned  NOT NULL,
  PRIMARY KEY     (`id_categorie`,`id_chapitre`,`id_cours`)
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED;

Et comme vous le constatez, la colonne `id` auto_incrementé a disparu.
Vous désirez obtenir les trois premiers cours pour une catégorie donnée, et un chapitre donnée.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
select    *
    from  `cours`
   where  id_categorie = 1
     and  id_chapitre  = 1
     and  id_cours     < 4
order by  id_categorie, id_chapitre, id_cours;

Cela n'est pas très différent de votre solution initiale, sauf que la structure de la table a changé.

Si ce sont les trois premiers cours pour une catégorie donnée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
select    *
    from  `cours`
   where  id_categorie = 1
     and  id_cours     < 4
order by  id_categorie, id_chapitre, id_cours;

C'est plus souple à l'usage !

@+

[Benamour Jr]

WOAAW mais oui... Simplicité et efficacité merci !!
Par contre je me pose quand meme une question... si c'est le trio id_cours, id_chapitre et id_categorie qui permet d'identifier un cours en particulier, comment procéder lorsque l'on veut ajouter un nouveau cours à un chapitre contenant déjà des cours, et que ce nouveau cours que l'on rajoute doit apparaitre AVANT tous les autres. Cela veut dire que je vais devoir fixer pour ce nouveau cours la valeur de id_cours à 1 et incrémenter de 1 tous les autres cours ayant le meme chapitre et la meme catégorie... Mais donc tous les liens que les internautes auront enregistré dans leur favoris renvoyant au id_cours 1 id_chapitre 1 id_categorie 1 renverra désormais vers un nouveau cours qu'ils n'avaient pas demandé...
Car finalement l'avantage d'avoir une colonne rang à ma table ferait que je peux facilement changer l'ordre de mes cours sans pour autant changer l'id qui permet aux internautes d'y accéder.
Vous voyez où je veux en venir ?

[Artemus24]

Salut Benamour Jr.

Une clef primaire n'est pas faite pour être changé tous les cinq minutes.

comment procéder lorsque l'on veut ajouter un nouveau cours à un chapitre contenant déjà des cours, et que ce nouveau cours que l'on rajoute doit apparaître AVANT tous les autres.

Personne ne vous a dit de numéroter vos cours de 1 en 1. Qu'est-ce qui vous empêche de les numéroter de 100 en 100 ?
Si vous avez un oubli et que vous désirez l'insérer en deuxième position, alors vous mettez "id_cours" = 150.
Ce qui donne la nouvelle séquence "100", "150", "200", "300", "400", ...
En laissant des trous dans la numérotation, vous pouvez ainsi prévoir les oublis.

tous les liens que les internautes auront enregistré dans leur favoris renvoyant au id_cours 1 id_chapitre 1 id_categorie 1 renverra désormais vers un nouveau cours qu'ils n'avaient pas demandé...

Oui, c'est tout à fait cela et donc cela va grandement perturber vos utilisateurs.
A partir du moment où un lien a été créé, il ne faut plus y toucher.

Vous voyez où je veux en venir ?

Ce que je ne comprends pas bien dans votre façon de gérer vos liens, c'est la présentation de vos cours ?

Admettons que pour la catégorie "Arithmétique", vous avez les cours "100" et "200" du chapitre "3".
Vous avez oublié un cours qui vient s'insérer entre le cours "100" et le "200". Vous le numérotez "150".
Comment allez vous présenter cela à vos utilisateurs ?

Je pense pour l'utilisateur, à une présentation sous forme de tableau.
Ce sont les libellés qui apparaissent et non la numérotation que vous utilisez.

@+

[Benamour Jr]

Bonjour,

En effet rien ne m'oblige à les numéroter de 1 en 1, mon cerveau a la fâcheuse tendance à créer des barrières imaginaires, c'est gentil à vous d'élargir mon horizon

L'idée est de proposer des cours de math en vidéo pour l'ensemble de la matière du secondaire.
Etant donné qu'on part de zéro, on va d'abord s'attaquer pour chaque chapitre à l'essentiel de ce qu'il faut connaitre.
En cours de développement, nous serons donc amené à étoffer chacun de nos chapitres par des vidéos supplémentaires qui devront s'insérer un peu partout, d'où l'importance de pouvoir gérer facilement un ordre fonctionnel entre nos différents cours.
Lorsqu'une nouvelle vidéo sera publiée au sein d'un chapitre, l'utilisateur pourra en avoir connaissance via notre page d’accueil ou via notre chaine YouTube. L'utilisateur est également invité à s'abonner à une newsletter qui présentera un compte-rendu mensuel des nouvelles vidéos.

Je vois quand meme un léger soucis par rapport à cette numérotation de 100 à 100, car du coup ma requête SQL risque d'être moins performante.
Dans le cas de la création d'une colonne rang au sein du tableau Cours, j'avais pensé à utiliser une requête contenant 'rang <= 3' pour la sélection des 3 premiers cours d'un chapitre. Dans le cas de l'ajout d'un cours en plein milieu de la structure d'un chapitre, je peux facilement changer la valeur rang de chacun des cours étant donné qu'il ne s'agit pas d'id utilisé dans un lien permettant d'identifier le cours.
Dans votre exemple sans colonne rang et où la numéoration se fait de 100 à 100 et où des cours viennent s'insérer un peu partout, je suis obligé d'utiliser une LIMIT 3, or cette limite est effectuée après que SQL ait sélectionné l'ensemble des cours, ca risque donc d'être assez lourd une fois que la BDD contiendra de nombreux cours au sein de chaque chapitre :s

[Artemus24]

Salut Benamour Jr.

l'importance de pouvoir gérer facilement un ordre fonctionnel entre nos différents cours.

Rien ne vous empêche de mettre en plus, une date de livraison ou de mise à disposition de votre nouvelle vidéo.
Ainsi l'utilisateur verra les nouveaux cours, même s'ils viennent s'insérer dans des cours déjà existant.
La date sera l'information qui va justifier ce nouveau cours.

Franchement, je ne trouve pas que le critère de l'ordre soit un grave problème.
A mon avis, c'est plus un problème de présentation sur votre site pour signaler un nouveau cours.

Je vois quand même un léger soucis par rapport à cette numérotation de 100 à 100, car du coup ma requête SQL risque d'être moins performante.

Franchement non, car vous fixez votre critère de sélection sur la catégorie et sur le chapitre.
Et en tant que cours, vous n'en avez pas des centaines de milliers, mais au maximum, une dizaine.

La requête devient alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
select    *
    from  `cours`
   where  id_categorie = 1
     and  id_chapitre  = 1
order by  id_categorie, id_chapitre, id_cours
limit 3;

Cette requête va récupérer que les trois premières lignes de la catégorie "Arithmétique" du premier chapitre.
Donc cela sera indépendant de votre façon de numéroter vos cours.

Dans le cas de la création d'une colonne rang ...

Mais votre colonne rang, c'est ma colonne id_cours.

je suis obligé d'utiliser une LIMIT 3, or cette limite est effectuée après que SQL ait sélectionné l'ensemble des cours, ca risque donc d'être assez lourd

Pour extraire trois lignes ??? Je vous assure que non !
Et ce n'est pas sur l'ensemble des cours, mais juste sur votre critère, c'est-à-dire le couple (`id_categorie`,`id_chapitre`).

@+

[Benamour Jr]

un GRAND merci Artemus24, vous m'avez ouvert l'esprit sur pas mal de chose, je vais tâcher d’implémenter tout ça

[Artemus24]

Salut Benamour Jr.

Le mieux est de faire des tests de fonctionnalités et de performance.
Il se peut, par la suite, que vous ayez besoin de créer des index afin d'améliorer la performance.
Mais comme votre critère de sélection se fait avec votre clef primaire, il n'est pas nécessaire de créer un index.

Bonne continuation !

Et merci pour les '+1'.

@+