Discussion :

[Wolfloner]

Bonjour à tous,

Je suis relativement Newby dans le sql et j'essaye de faire un petit site dans lequel je souhaite utiliser un input range lequel va me donner une fourchette. Dans cette fourchette, je souhaite INSERER une donnée fournit par un input Text dans le premier trou de séquence numGroup libre de ma table dans cette fourchette.
Franchement, j'ai essayer plein de truc prit sur le net, j'ai tenté de les adapter, de comprendre le code, mais je sèche complètement.

Voici la structure de ma table

Code SQL :

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

1
2
3
4
5
6
7
8
CREATE TABLE IF NOT EXISTS `liste_groupuscule` (
  `id_groupe` int(10) NOT NULL AUTO_INCREMENT,
  `nomGroup` varchar(50) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,
  `numGroup` int(10) NOT NULL,
  `image_groupe` text CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,
  `liste_membres` text CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`id_groupe`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=47 ;

Mes inputs sont les suivant :

Code html :

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

1
2
3
4
 
<input type="range" name="numGroup" min="10" max="200" step="5"/>
<input type="text" name="nomGroup" />
<input type="submit" name="soumettre" value="soumettre"/>

bon là rien de bien compliqué, je récupère ma donnée basiquement :

Code php :

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
<?php
if (isset($_POST['soumettre'])){
 
 
$numGroup = $_POST['numGroup'];  // début de la fourchette
$numGroup2 = $_POST['numGroup']+10; // fin de la fourchette
 
$sql = "SELECT numGroup FROM liste_groupuscule WHERE numGroup BETWEEN '$numGroup' AND '$numGroup2' ORDER BY numGroup ASC";
$sql = $conn -> prepare($sql);
$sql -> execute();
$resulte = $sql -> fetch();
 
// Et la je bloque !!!
// Car je ne sais pas comment trouver le trou dans la colonne numGroup
 
}
 
?>

Mais en faite si je traduit ce que je veux faire cela devrait ressembler à un truc du genre

Code SQL :

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

INSERT INTO liste_groupuscule WHERE (dernier numGroup avant le trou dans la fourchette)+1 IS NULL

Merci de vos réponse d'aide et désolé peut-être c'est une réponse simple à trouver ^^ mais j'ai besoin d'un coup de main

[Artemus24]

Salut à tous.

Les trous sont dut simplement au faite de laisser des espaces libre afin de compléter ma liste, justement gràce à un INSERT.

Quel est l'intérêt de chercher à combler des trous ??? Franchement, vous vous compliquez l'existence pour rien.
Si vous rencontrez un problème de faisabilité, c'est que vous avez un problème de modélisation de votre base de données.

Au lieu de chercher à combler des trous, utilisez un critère pour ranger vos futurs lignes à insérer dans votre table.

D'après ce que j'ai pu comprendre de vos explications, ce critère serait la colonne "NomGroupe".
A chaque fois que vous avez le même nom de groupe, vous incrémentez de "1", la colonne "NumGroupe".

Comment procéder ? Le mieux est de vous donner un exemple :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
--------------
SET AUTOCOMMIT = 0
--------------
 
--------------
START TRANSACTION
--------------
 
--------------
DROP DATABASE IF EXISTS `base`
--------------
 
--------------
CREATE DATABASE `base`
    DEFAULT CHARACTER SET `latin1`
    DEFAULT COLLATE       `latin1_general_ci`
--------------
 
--------------
DROP TABLE IF EXISTS `test`
--------------
 
--------------
CREATE TABLE `test`
( `id`       integer unsigned not null auto_increment primary key,
  `groupe`   varchar(255)     not null,
  `rang`     integer unsigned not null,
  `libelle`  varchar(255)     not null,
  index `idx` (`groupe`)
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
DROP TRIGGER IF EXISTS `rang`
--------------
 
--------------
CREATE TRIGGER `rang`
BEFORE insert ON `test`
FOR EACH ROW
BEGIN
  SET NEW.rang=ifnull((select max(rang)+1 from `test` where groupe=NEW.groupe),1);
END
--------------
 
--------------
insert into `test` (`groupe`,`libelle`) values
  ('un',    'bleu'),  ('deux',  'rouge'),  ('trois',  'vert'),  ('un',    'jaune'),  ('un',    'marron'),
  ('deux',  'rose'),  ('un',    'noir'),   ('trois', 'gris'),   ('deux',  'vert'),   ('trois', 'cyan')
--------------
 
--------------
select * from `test` order by groupe, rang
--------------
 
+----+--------+------+---------+
| id | groupe | rang | libelle |
+----+--------+------+---------+
|  2 | deux   |    1 | rouge   |
|  6 | deux   |    2 | rose    |
|  9 | deux   |    3 | vert    |
|  3 | trois  |    1 | vert    |
|  8 | trois  |    2 | gris    |
| 10 | trois  |    3 | cyan    |
|  1 | un     |    1 | bleu    |
|  4 | un     |    2 | jaune   |
|  5 | un     |    3 | marron  |
|  7 | un     |    4 | noir    |
+----+--------+------+---------+
--------------
COMMIT
--------------
 
--------------
SET AUTOCOMMIT = 1
--------------
 
Appuyez sur une touche pour continuer...

Ainsi vous avez une numérotation indépendante pour chaque groupe.

@+

[Wolfloner]

Bonjour Artemus,

Merci pour votre aide, je réfléchis à votre code qui est très intéressant.

Les numGroup sont à la fois des niveaux de dangerosité et des clés pour les options d'un input select. Les nomGroupes étant unique. Mon critère était plutôt une fourchette, qu'effectivement je peux réduire à groupe by pour un rang.

exemple :
rang === numGroup === nomGroup
10 === 1 === fatum
10 === 52 === renards
25 === 50 === archibal
25 === 51 === leopard
200 === 2 === vendales

Votre code me fait effectivement réfléchir, car dans mon input select je peux organiser le select Order by rang ASC et order by numGroup ASC

[CinePhil]

Euh...
Je n'approuve pas l'exemple d'Artemus qui consiste à enregistrer de multiples fois le même nom de groupe et je crains que vous n'en fassiez une mauvaise utilisation, vu votre réponse à sa suggestion.

Rassurez-moi : dans votre table liste_groupuscule (que vous auriez pu simplement appeler groupuscule, peut-être, mais bon, c'est un autre sujet...), chaque nomGroup est unique ?

Là où je suis d'accord avec Artemus, est que si numGroup vous sert simplement à ordonner vos groupuscules, cette colonne pourrait plus simplement s'appeler rang ou ordre.

J'ai l'impression que vous devriez sérieusement revoir votre modèle de données sur le plan sémantique. Sans plus d'informations sur ce que représentent ces groupuscules par rapport au reste de votre modèle, je suis un peu perdu.

Au fait, ma requête ne répondait-elle pas à votre besoin ?

[Wolfloner]

Bonjour Cinephil,

Votre réponse correspondait à ma première demande en effet et je vous remercie pour cela.

Dans une de mes réponses, j'ai soulever un problème, que se passerait-il si je n'avais plus de trous ?

En effet, les nomGroup sont unique. Les numGroup se devait de l'être aussi et je voulais m'en servir comme "id" unique et en même temps comme "niveau" de dangerosité. Artemus en intervenant ma fait réfléchirt et en effet ma table est mal construite.
Car si j'employais numGroup comme niveau de dangerosité, je serai limiter par le nombre d'insert :

numGroup > 10 <=29 -> VIP
numGroup >= 30 <= 74 -> peu dangereux
numGroup >= 75 <= 99 -> modérément dangereux
numGroup >=100 <= 149 -> Dangereux
numGroup >=150 <= 174 -> Très dangereux
numGroup > = 175 <= 200 -> Extrêmement dangereux

Alors qu'en revoyant ma table comme le propose Artemus ainsi :

-- Structure de la table `liste_groupuscule`
--

CREATE TABLE IF NOT EXISTS `liste_groupuscule` (
`id_groupe` int(10) NOT NULL AUTO_INCREMENT,
`categorieGroup` int(10) NOT NULL,
`nomGroup` varchar(50) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,
`numGroup` int(10) NOT NULL,
`image_groupe` text CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,
UNIQUE KEY `id_groupe` (`id_groupe`),
KEY `CategorieGroup` (`categorieGroup`),
KEY `id_groupe_2` (`id_groupe`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=11 ;

Mon categorieGroup devient le niveau de dangerosité, le numGroup est juste un classement et mon id_groupe devient mon identifiant unique, qui sera la valeur de mon input select de mon menu déroulant.
J'ai effectivement aussi enlever le 'liste_membre' lequel je n'ai plus besoin et qui me prenait en effet trop de ressources pour rien comme tu me l'a fait remarqué Cinéphil et j'ai créer une table "personnages" où j'ai rajouter la colonne "groupuscule" qui recueillera les id_groupe auquel chaque personnage peu appartenir.

Voila. Bon ne connaissant pas comment implanter un trigger dans une requête php/mysql, je suis parti sur un code comme cela :

Code :

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

1
2
3
4
5
6
			$sql = $conn -> prepare ("SELECT MAX(numGroup)+1 AS premier_trou FROM liste_groupuscule WHERE categorieGroup='$categorieGroup'");
			$sql -> execute();
			$result = $sql -> fetch();
		$premier_trou = $result['premier_trou'];
			$sql2 = $conn -> prepare ("INSERT INTO liste_groupuscule (nomGroup, numGroup, categorieGroup) VALUES ('$nomGroup', '$premier_trou', '$categorieGroup')");
			$sql2 -> execute();

Pour les noms des tables et des colonnes, disons que c'est ma manière de m'y retrouver, peut-être pas la meilleur je le conçois

Mais en tout cas merci à tous les deux

[CinePhil]

Donc votre problème est ?

[Artemus24]

Salut à tous.

Les numGroup sont à la fois des niveaux de dangerosité et des clés pour les options d'un input select.

Désolé mais je ne comprends pas le rôle joué par la colonne "NumGroupe".

Les nomGroupes étant unique.

D'accord ! Donc mon approche de votre problème ne peut pas convenir.

Code :

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

1
2
3
4
5
6
rang		===		numGroup		===		nomGroup
10		===		1			===		fatum
10		===		52			===		renards
25		===		50			===		archibal
25		===		51			===		leopard
200		===		2			===		vendales

Je ne comprends pas, non plus, comment vous faites pour attribuer 10, 25 et 200 à la colonne "Rang".

Je n'approuve pas l'exemple d'Artemus qui consiste à enregistrer de multiples fois le même nom de groupe et je crains que vous n'en fassiez une mauvaise utilisation, vu votre réponse à sa suggestion.

Le problème ne se porte pas sur la colonne "NomGroupe" mais sur comment remplir la colonne "NumGroupe".
Dans une base de données normalement conçue, la colonne "NomGroupe" serait remplacée par une clef étrangère.
Mais pour simplification du problème, je préfère laisser cette colonne telle quelle.

Rassurez-moi : dans votre table liste_groupuscule ... chaque nomGroup est unique ?

Si la colonne "NomGroupe" est unique, ma solution ne fonctionne pas. On aura toujours "1" pour la colonne "NumGroupe".

J'ai utilisé la colonne "NomGroupe" comme critère pour incrémenter la colonne "NumGroupe".
Sinon, je n'ai pas compris la finalité de tout cela.

Là où je suis d'accord avec Artemus, est que si numGroup vous sert simplement à ordonner vos groupuscules, cette colonne pourrait plus simplement s'appeler rang ou ordre.

En effet, c'est l'idée que j'ai développé.
Boucher des trous est une approche compliquée, surtout que cela ne se justifie pas en terme de fonctionnelle.

Sans plus d'informations sur ce que représentent ces groupuscules par rapport au reste de votre modèle, je suis un peu perdu.

Vous n'êtes pas le seul. La question posée n'est pas très clair et demande plus d'explication.

Au fait, ma requête ne répondait-elle pas à votre besoin ?

Nous ne sommes pas en compétition, CinePhil, mais juste là pour fournir de l'aide.

En effet, les nomGroup sont unique. Les numGroup se devait de l'être aussi et je voulais m'en servir comme "id" unique et en même temps comme "niveau" de dangerosité".

Vu vos explications, vous avez un problème de modélisation.
La colonne "Id" de la table "liste_groupuscule" possède déjà un identifiant unique : "Id_groupe". Pour quelle raison, vous avez besoin d'un second identifiant unique ?
Et que signifie "niveau" de dangerosité" ? Une colonne ne peut pas avoir plus signification.

[quote="CinePhil"Donc votre problème est ?[/quote]
Non, le problème n'est pas résolu.

En fait, vous devez éclater votre table d'origine en trois tables que voici :

1) la table des "groupes", contenant le libellé du groupe, avec un identifiant unique.

Code :

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

1
2
3
4
5
6
7
8
9
 
22 : 'Liste noir Champagne'
23 : 'Les anges'
24 : 'Basile indépendantiste Touraine'
25 : 'Suspicion joker'
26 : 'Nouveau Brigands'
27 : 'Brigands '
28 : 'Confédération helvétique'
29 : 'Surveillance artois Fatum'

2) la table des "dangerosités", contenant un libellé décrivant le niveau du danger rencontré, avec bien sûr un identifiant.
Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
1 : normal
2 : bénin
3 : il faut s'inquiéter
4 : peu dangereux
5 : modérément dangereux
6 : dangereux
7 : très dangereux
8 : extrêmement dangereux
9 : alerte rouge !

3) une table association où pour le groupe vous allez attribuer le niveau de dangerosité.
Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
Identifiant Groupe		Niveau dangerosité
22					5
23					4
24					7
25					5
26					3
27					4
28					5
29					2

@+

[Wolfloner]

@Artemus

En faite Artemus, le "rang" comme vous le nommé est obtenu par l'input range ainsi :

Code :

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

1
2
3
4
5
<form method="POST" action="#">
		<input type="range" name="categorieGroup" id="range" min="10" max="200" step="20"/><br>
		<input type="text" name="nomGroup" id="nom" /><br>
		<input type="submit" name="submit" value="submit">
</form>

C'est dur d'être Newby Et peut-être que je m'exprime mal ou je vous explique mal ^^ comme Artemus le dit, je me complique, promis je ne le fais pas exprès.

donc j'ai refais une table :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
-- Structure de la table `liste_groupuscule32`
--
 
CREATE TABLE IF NOT EXISTS `liste_groupuscule32` (
  `id_groupe` int(10) NOT NULL AUTO_INCREMENT,
  `categorieGroupe` int(10) NOT NULL,
  `numGroup` int(100) NOT NULL,
  `nomGroup` varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,
  `imageGroup` text CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`id_groupe`),
  UNIQUE KEY `nomGroup` (`nomGroup`),
  KEY `categorieGroupe` (`categorieGroupe`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=1

rang === numGroup === nomGroup
10 === 1 === fatum
10 === 52 === renards
25 === 50 === archibal
25 === 51 === leopard
200 === 2 === vendales

Je ne comprends pas, non plus, comment vous faites pour attribuer 10, 25 et 200 à la colonne "Rang".

Du coup faut oublier cet exemple, puisque numGroup n'est plus l'identifiant et est remplacer par id_group

Donc ce code fonctionne :

Code :

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

1
2
3
4
5
6
7
			$sql = $conn -> prepare ("SELECT MAX(numGroup)+1 AS premier_trou FROM liste_groupuscule32 WHERE categorieGroup='$categorieGroup'");
			$sql -> execute();
			$result = $sql -> fetch();
		$premier_trou = $result['premier_trou'];
			echo $premier_trou.'<br>';
			$sql2 = $conn -> prepare ("INSERT INTO liste_groupuscule32 (nomGroup, numGroup, categorieGroup) VALUES ('$nomGroup', '$premier_trou', '$categorieGroup')");
			$sql2 -> execute();

Il faut juste peut-être que je rajoute ON DUPLICATE KEY UPDATE categorieGroup = VALUES(categorieGroup), numGroup=VALUE(numGroup)

[Artemus24]

Salut Wolfloner.

le "rang" comme vous le nommé est obtenu par l'input range ainsi :

Vous voulez dire que l'utilisateur clique sur une échelle allant d'une valeur minimale jusqu'à la valeur maximale et que cette valeur va vous servir comme "niveau de dangerosité".

Ensuite qu'allez-vous faire de cette information numérique que vous retourne l'utilisateur ?
Elle ne peut pas servir d'identifiant car dans la table, sa valeur n'est pas unique.

Cette information, doit être rattachée à un identifiant unique, comme par exemple l'attribuez à un groupe.
C'est ce que vous faites en utilisant les input.

Code html :

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

1
2
3
<input type="range" name="numGroup" min="10" max="200" step="5"/>
<input type="text" name="nomGroup" />
<input type="submit" name="soumettre" value="soumettre"/>

Pourquoi faire une variation par pas de "5" ? A moins que cela a une signification pour vous, le mieux est de laisser une variation par pas de "1".

Si je comprends la signification de votre balise "input", c'est une saisie en masse que vous êtes en train de faire.
Vous saisissez un "Nom de Groupe" et vous lui attribuez une valeur en tant que "numéro de groupe".

Déjà, cela porte à confusion de nommer cette colonne "NumGroupe". Pourquoi ne pas la nommer "NivDanger" pour "niveau de dangerosité", si c'est la signification que vous lui donnez ?

Je reviens maintenant sur la question posée, à savoir "je ne sais pas comment trouver le trou dans la colonne numGroup" ?
C'est là que je ne comprends pas la relation qui existe entre l'information provenant de la balise "input" et que vous attribuez à la colonne "NumGroupe" et le fait de recherchez des trous ?

peut-être que je m'exprime mal

C'est le cas car vous ne donnez aucun sens à ce que vous nous expliquez.
Et je n'ai toujours pas compris l'utilité de rechercher les trous dans votre table.

Pour la résolution de votre problème, la solution du premier trou donné par CinePhil est excellente.

Code :

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

1
2
3
select  min(rang)+1 as premier_trou
  from  test as t1
 where  not exists (select 1 from test as t2 where t2.rang = t1.rang+1);

La plupart du temps, les internautes posent la question concerant l'identifiant auto incrémenté, où dans celui-ci il y a des trous, suite à plusieurs suppressions.

1) Si c'est un problème d'amplitude, au lieu de mettre "integer unsigned", on peut mettre plus grand avec "bigint unsigned".
Même s'il y a des trous dnas l'identifiant, il vous reste assez de valeur avant d'atteindre le maximum.

2) on ne peux pas réutiliser un identifiant supprimé car cela peut poser des problèmes d'intégrités, comme par exemple dans le cas d'une historisation.

3) il y a une astuce qui peut être utilisée en maintenance, c'est de faire une renumérotation de votre identifiant.
C'est dangereux comme approche, car cela demande quelques vérifications au préalable.
Est-ce que cet identifiant est utilisé comme clef étrangère dans une autre table ?
Si la réponse est non, vous pouvez renuméroter votre identifiant.

Si la réponse est oui alors vérifiez comment se fait la déclaration de votre clef étrangère dans la table fille. Si par exemple vous avez :

Code :

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

  CONSTRAINT `FK_01` FOREIGN KEY (`mere_id`) REFERENCES `mere` (`mere_id`) ON DELETE CASCADE ON UPDATE CASCADE

vous pouvez modifier l'identifiant de la table "pere", car il y aura une mise à jour qui va se faire par propagation en cascade (ce qui j'ai mis en rouge).

Si par exemple vous avez maintenant :

Code :

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

  CONSTRAINT `FK_01` FOREIGN KEY (`mere_id`) REFERENCES `mere` (`mere_id`) ON DELETE SET NULL ON UPDATE NO ACTION

vous ne pouvez pas modifier votre identifiant, car il n'y aura pas de propagation. C'est le "no action" qui vous l'interdit.

En ce qui concerne la modification de l'identifiant, l'astuce est de faire ainsi :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
--------------
SET AUTOCOMMIT = 0
--------------
 
--------------
START TRANSACTION
--------------
 
--------------
DROP DATABASE IF EXISTS `base`
--------------
 
--------------
CREATE DATABASE IF NOT EXISTS `base`
        DEFAULT CHARACTER SET `latin1`
        DEFAULT COLLATE       `latin1_general_ci`
--------------
 
--------------
drop table if exists `test`
--------------
 
--------------
CREATE TABLE `test`
( `id`    integer unsigned  NOT NULL auto_increment primary key,
  `val`   char(10)              NULL default NULL
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
insert into `test` (`id`,`val`) values (25, 'un'),(33, 'deux'),(75, 'trois'),(207, 'quatre'),(349, 'cinq'),(711, 'six'),(813, 'sept')
--------------
 
--------------
select * from  `test`
--------------
 
+-----+--------+
| id  | val    |
+-----+--------+
|  25 | un     |
|  33 | deux   |
|  75 | trois  |
| 207 | quatre |
| 349 | cinq   |
| 711 | six    |
| 813 | sept   |
+-----+--------+
--------------
SELECT AUTO_INCREMENT as last_id
FROM   INFORMATION_SCHEMA.TABLES
WHERE  table_schema = 'base' and table_name = 'test'
--------------
 
+---------+
| last_id |
+---------+
|     814 |
+---------+
--------------
commit
--------------
 
--------------
alter table `test` drop column `id`
--------------
 
--------------
alter table `test` add  column `id` integer unsigned auto_increment not null primary key first
--------------
 
--------------
describe `test`
--------------
 
+-------+------------------+------+-----+---------+----------------+
| Field | Type             | Null | Key | Default | Extra          |
+-------+------------------+------+-----+---------+----------------+
| id    | int(10) unsigned | NO   | PRI | NULL    | auto_increment |
| val   | char(10)         | YES  |     | NULL    |                |
+-------+------------------+------+-----+---------+----------------+
--------------
select * from  `test`
--------------
 
+----+--------+
| id | val    |
+----+--------+
|  1 | un     |
|  2 | deux   |
|  3 | trois  |
|  4 | quatre |
|  5 | cinq   |
|  6 | six    |
|  7 | sept   |
+----+--------+
--------------
SELECT AUTO_INCREMENT as last_id
FROM   INFORMATION_SCHEMA.TABLES
WHERE  table_schema = 'base' and table_name = 'test'
--------------
 
+---------+
| last_id |
+---------+
|       8 |
+---------+
--------------
COMMIT
--------------
 
--------------
SET AUTOCOMMIT = 1
--------------
 
Appuyez sur une touche pour continuer...

Autrement dit, on détruit la colonne "primary key" auto incrémenté, et on la reconstruit.

Je ne vous conseille pas ce genre d'astuce à moins que vous ayez une bonne maîtrise de MySql.
car vous risquez de créer un problème d'intégrité de votre base de données, juste pour boucher des trous.

Sinon, pouvez-vous expliquer ce que vous cherchez à faire ne bouchant vos trous ?

@+

[Wolfloner]

Salut Artemus,

Au tout début, j'avais une liste reprise sur un menu déroulant <select> d'une page php d'un ami comme suit :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
<select name='ufamille'><option value=""> (0)</option>
<option value="à récuperer">à récuperer (1)</option>
<option value="Admin RR">Admin RR (2)</option>
<option value="VIP Royal">VIP Royal (10)</option>
<option value="Pairs de France">Pairs de France (15)</option>
<option value="Grands officiers Royaux">Grands officiers Royaux (20)</option>
<option value="Capitaines de la Royale">Capitaines de la Royale (25)</option>
<option value="GR">GR (30)</option>
<option value="Licornes">Licornes (30)</option>
<option value="OR">OR (30)</option>
<option value="Ordre Royal de la Dame Blanche à l'Ecu vert">Ordre Royal de la Dame Blanche à l'Ecu vert (30)</option>
<option value="Ordre Royal des Hospitaliers de Saint Jean de Jerusalem">Ordre Royal des Hospitaliers de Saint Jean de Jerusalem (30)</option>
<option value="Amis OR (Hospis)">Amis OR (Hospis) (35)</option>
<option value="Amis OR">Amis OR (36)</option>
<option value="DR">DR (40)</option>
<option value="VIP Champagne">VIP Champagne (45)</option>
<option value="Ami DR">Ami DR (48)</option>
<option value="OR OERSS">OR OERSS (50)</option>
<option value="Ami OERSS">Ami OERSS (51)</option>
<option value="Ami Royaume">Ami Royaume (52)</option>
<option value="Amis de Provence">Amis de Provence (53)</option>
<option value="Corps expéditionnaire">Corps expéditionnaire (54)</option>
<option value="Suivi">Suivi (55)</option>
<option value="Corsaire de le Couronne de France">Corsaire de le Couronne de France (56)</option>
<option value="Ponant">Ponant (57)</option>
<option value="Renard délisté">Renard délisté (58)</option>
<option value="Ordre des Chevaliers Francs">Ordre des Chevaliers Francs (65)</option>
<option value="Breton ">Breton  (67)</option>
<option value="Conseil breton">Conseil breton (68)</option>
<option value="Suspect">Suspect (70)</option>
<option value="Ordre du Saint Esprit">Ordre du Saint Esprit (74)</option>
<option value="Ordre Teutonique">Ordre Teutonique (75)</option>
<option value="Angevin">Angevin (76)</option>
<option value="Surveillance, (gracié)">Surveillance, (gracié) (80)</option>
<option value="Surveillance, gracié">Surveillance, gracié (80)</option>
<option value="Liste jaune Champagne">Liste jaune Champagne (81)</option>
<option value="Liste orange Champagne">Liste orange Champagne (82)</option>
<option value="Liste rouge Champagne">Liste rouge Champagne (83)</option>
<option value="SRING">SRING (84)</option>
<option selected='selected' value="Liste Benoit">Liste Benoit (85)</option>
<option value="Berry">Berry (87)</option>
<option value="Liste noire Champagne">Liste noire Champagne (89)</option>
<option value="Les Anges ">Les Anges  (90)</option>
<option value="Basile (Indépendantistes de Touraine)">Basile (Indépendantistes de Touraine) (95)</option>
<option value="Suspicion Joker">Suspicion Joker (96)</option>
<option value="Joker">Joker (97)</option>
<option value="Nouveaux Brigands">Nouveaux Brigands (99)</option>
<option value="Brigand">Brigand (100)</option>
<option value="Confédération Helvétique">Confédération Helvétique (104)</option>
<option value="Surveillance Artois & Fatum">Surveillance Artois & Fatum (109)</option>
<option value="Surveillance">Surveillance (110)</option>
<option value="Surveillance SSRF">Surveillance SSRF (111)</option>
<option value="Surveillance Renards">Surveillance Renards (113)</option>
<option value="Surveillance Hydre">Surveillance Hydre (114)</option>
<option value="Surveillance Fatum">Surveillance Fatum (115)</option>
<option value="Lunes Pourpres">Lunes Pourpres (118)</option>
<option value="Trente">Trente (122)</option>
<option value=" Lion de Juda"> Lion de Juda (125)</option>
<option value="Renards">Renards (129)</option>
<option value="Fatum">Fatum (130)</option>
<option value="Lion de Judas et Fatum">Lion de Judas et Fatum (131)</option>
<option value="Les Celestes">Les Celestes (132)</option>
<option value="Pirate">Pirate (140)</option>
<option value="Flandres">Flandres (149)</option>
<option value="Artois">Artois (150)</option>
<option value="Poursuivi">Poursuivi (155)</option>
<option value="Ennemis Couronne">Ennemis Couronne (200)</option>
<option value="Surveillance, Traître a la Couronne">Surveillance, Traître a la Couronne (200)</option>
</select>

comme vous le voyez : <option value= les noms des groupes > noms des groupes (indices)< option>
J'avais donc utilisé ces indices comme valeur de l'option et donc valeur dans la colonne "numGroup" de ma table. En regroupant dans ma table les indices pour éviter de les avoir en doublon. ex l'indice 30 devenait simplement "OR".
Comme vous le voyez, il y a des trous entre les indices et donc les valeur numGroup.
Comme expliqué la valeur 10 étant VIP, la valeur 100 dangereux et la valeur 200 extrêmement dangereux.

J'étais donc parti sur l'idée d'utiliser cette modélisation afin de pouvoir faire la manip suivante :

Code :

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

1
2
3
4
5
$sql=$conn -> prepare (SELECT * FROM liste_groupuscule ORDER BY numGroup ASC);
$sql -> execute();
while ($rechercher = $sql -> fetch()){
echo '<option value="'.$rechercher["numGroup"].'">'.$recherche["nomGroup"].'</option>';
}

Ensuite qu'allez-vous faire de cette information numérique que vous retourne l'utilisateur ?

Cela pour ajouter à la table "personnages" dans la colonne "groupuscule" la valeur de l'option soit donc numGroup qui était jusqu'à lors une valeur UNIQUE.
Laquelle table qui me sert de base pour sortir les fiches de personnages pour des modifications, des ajouts, des suppressions etc...

Puis je me suis donc dit, "oui mais le jeu évolue et des nouveaux groupuscules pourraient être ajouté" et donc je me suis dis : "Comment ajouter ces groupes sur la modélisation actuelle de la table liste_groupuscule".
Et donc avec ma logique "personnelle", l'idée était combler les trous en délimitant justement le niveau de dangerosité par un "<input type='range'>".

Elle ne peut pas servir d'identifiant car dans la table, sa valeur n'est pas unique.

Elle pouvait justement, dans ma modélisation primaire, être UNIQUE. Mais comme je l'explique plus haut j'aurais été limité par le nombre de trou libre entre chaque valeur représentant un niveau de dangerosité.

D'où le faite, que j'ai réviser ma table et de ce faite utiliser la modélisation que vous avez proposer en détachant le Niveau de dangerosité (categorieGroup) et l'indexialisation dans chaque Niveau de Dangerosité avec numGroup, les deux NOT UNIQUE donc.
De ce principe, vous serez d'accord avec moi, il me fallait une UNIQUE KEY, pour identifier chacun de mes ROWS et les utiliser comme valeur de mon input option. J'ai choisi d'utiliser simplement la PRIMARY KEY (id_group) qui est donc UNIQUE.

Pourquoi faire une variation par pas de "5" ? A moins que cela a une signification pour vous, le mieux est de laisser une variation par pas de "1".

Parce que entre chaque niveau de dangerosité, il y a plus de 5 pas, je pourrais même faire un pas 20 ou 25. dites vous que cela représente une valeur de %tage de dangerosité.

Citation Envoyé par Wolfloner
peut-être que je m'exprime mal
C'est le cas car vous ne donnez aucun sens à ce que vous nous expliquez.

Je vous explique simplement que j'ai recommencer le code dès la base en prenant votre idée.^^ Donc ma question de base : "Insérer donnée dans table au premier trou de séquence entre une fourchette (range)" est résolue par Cinephil malgré le faite que j'ai convergé dans la réalisation de mon code au final grâce à vous, en me faisant voir une différente approche de ma table, laquel en effet je n'avais pas pensé.

Voili voilou, j'espère avoir été plus clair dans mes explications ^^

[CinePhil]

Bonjour,

En lisant le titre, j'ai eu peur qu'il s'agisse de combler les trous d'une clé primaire auto-incrémentée après suppression de lignes. Vu la description de votre table ce n'est pas ça. Néanmoins, à quoi sont dus les trous ? S'il sont apparus suite à suppression de lignes, demandez vous s'il est pertinent de les combler car ce n'est pas forcément une bonne idée.

Ou alors, peut-être cherchez-vous à faire un truc similaire à ce que j'ai décrit dans un billet de mon blog : incrémenter quelque chose relativement à autre chose, comme des chambres dans des hôtels ?

Sinon, si j'ai bien compris, voici une requête qui devrait vous donner le premier trou à l'intérieur d'une série de numGroup :

Code SQL :

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

1
2
3
4
5
6
7
8
9
SELECT MIN(lg1.numGroup) + 1 AS premier_trou
FROM liste_groupuscule lg1
WHERE lg1.numGroup BETWEEN :numGroup1 AND :numGroup2
	AND NOT EXISTS
	(
		SELECT *
		FROM liste_groupuscule lg2
		WHERE lg2.numGroup + 1 = lg1.numGroup
	)

Autre remarque qui n'a rien à voir...

Code SQL :

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

`liste_membres` text CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,

Ça c'est très mal modélisé !
Quand vous chercherez tous les groupes d'un membre et si votre base de données est volumineuse, les performances vont vite se dégrader car aucun index performant ne sera utilisable pour cette recherche.

Vous devriez plutôt avoir une table séparée pour les membres de groupes :
tj_mbr_appartenir_grp_mag (mag_id_membre, mag_id_groupe)

[Wolfloner]

Bonjour Cinephil, je vous remercie pour cette requête.

Les trous sont dut simplement au faite de laisser des espaces libre afin de compléter ma liste, justement gràce à un INSERT. Par contre ces trous ne possèdent pas encore d'Id.

J'ai par exemple dans ma table liste_groupuscule les choses suivantes :

Code :

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

1
2
3
4
5
6
7
8
(22, 'Liste noir Champagne', 89, 'https://img4.hostingpics.net/pics/753238ListeN.gif', ''),
(23, 'Les anges', 90, 'https://img4.hostingpics.net/pics/157768angel.gif', ''),
(24, 'Basile indépendantiste Touraine', 95, 'https://img4.hostingpics.net/pics/40968826B.png', ''),
(25, 'Suspicion joker', 96, '', ''),
(26, 'Nouveau Brigands', 99, 'https://img4.hostingpics.net/pics/56807707lo.png', ''),
(27, 'Brigands ', 100, 'https://img4.hostingpics.net/pics/73004608lr.png', ''),
(28, 'Confédération helvétique', 104, 'https://img4.hostingpics.net/pics/45329984CH.gif', ''),
(29, 'Sureveillance artois Fatum', 109, 'https://img4.hostingpics.net/pics/42314089Fr.png', ''),

J'ai lu votre code, par contre j'ai deux ou trois questions, la première à quoi correspond le 'lg1.' , je n'ai jamais utiliser ce type de methode dans mes requêtes.
Ensuite je pense que je dois faire des Bindparam pour ":numGroup1" et :numGroup2".

Mais la plus grande question de toute, est-ce que j'execute cette requête en premier et j'obtient une variable que j'utilise comme value d'INSERT pour mon futur
$numGroup ou puis-je inserer directement les valeurs ?

J'ai fait donc la requête comme cela :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
	$sql = $conn -> prepare ("SELECT MIN(lg1.numGroup) + 1 AS premier_trou
FROM liste_groupuscule lg1
WHERE lg1.numGroup BETWEEN :numGroup1 AND :numGroup2
	AND NOT EXISTS
	(
		SELECT *
		FROM liste_groupuscule lg2
		WHERE lg2.numGroup + 1 = lg1.numGroup
	)");
	$sql -> bindparam(':numGroup1',$numGroup);
	$sql -> bindparam(':numGroup2', $numGroup2);
	$sql -> execute();

Merci pour vos explications.

[Wolfloner]

Bon pour le coup j'ai trouver en faite la réponse à mes deux questions :

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
	$sql = $conn -> prepare ("SELECT MIN(lg1.numGroup) + 1 AS premier_trou
FROM liste_groupuscule2 lg1
WHERE lg1.numGroup BETWEEN :numGroup1 AND :numGroup2
	AND NOT EXISTS
	(
		SELECT *
		FROM liste_groupuscule2 lg2
		WHERE lg2.numGroup + 1 = lg1.numGroup
	)");
	$sql -> bindparam(':numGroup1',$numGroup);
	$sql -> bindparam(':numGroup2', $numGroup2);
	$sql -> execute();
			$result = $sql -> fetch();
		$premier_trou = $result['premier_trou'];	
			$sql2 = $conn -> prepare ("INSERT INTO liste_groupuscule2 (nomGroup, numGroup) VALUES ('$nomGroup', '$premier_trou')");
			$sql2 -> execute();

J'ai pas encore tester s'il n'y avais pas de trous. Par contre j'ai aussi noté qu'il sautait certains trou parfois.

Je garde un peu ouvert cette discussion même si les grandes lignes sont résolues

Merci

[CinePhil]

à quoi correspond le 'lg1.'

C'est un alias pour la table liste_groupuscule, tout comme lg2 dans la sous requête, tout simplement pour distinguer les deux instances utilisées de la table. L'utilisation des alias, quand une requête utilise plus d'une table, permet aussi de simplifier l'écriture des requêtes.

Ensuite je pense que je dois faire des Bindparam pour ":numGroup1" et :numGroup2".

Oui. C'est mieux de faire ainsi, notamment parce qu'on peut en plus spécifier de quel type est la valeur attendue (par exemple PDO:ARAM_STR ou PDO:ARAM_INT). C'est une sécurité contre les injections SQL. Ainsi, dans votre code, vous devriez les utiliser :

Code :

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

1
2
$sql -> bindparam(':numGroup1', $numGroup, PDO::PARAM_INT);
	$sql -> bindparam(':numGroup2', $numGroup2, PDO::PARAM_INT);

Par contre j'ai aussi noté qu'il sautait certains trou parfois.

Effectivement, je viens de tester et ma requête n'est pas bonne.

Essaie plutôt celle-là :

Code SQL :

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

1
2
3
4
5
6
7
8
9
SELECT MIN(lg1.numGroup) + 1 AS premier_trou
FROM liste_groupuscule lg1
WHERE lg1.numGroup BETWEEN :numGroup1 AND :numGroup2
	AND NOT EXISTS
	(
		SELECT *
		FROM liste_groupuscule lg2
		WHERE lg2.numGroup = lg1.numGroup + 1
	)