Discussion :

[Drone]

Bonjour,

On m'a donné un fichier TABLE1.ibd de 28go à restaurer.

J'ai recréé la table "TABLE1" en mode recovery puis fait un dump TABLE1.mysql pour réinsérer les données.

L'ennuie c'est qu'ils ont continué à insérer des données sur une même table "NEWTABLE1" avec un autoincrément sur clé primaire partant de 0.

Je me retrouve avec deux tables TABLE1 et NEWTABLE1 contenant des doublons de clé primaire num_index.

J'aimerai que le num_index de la table NEWTABLE1 commence à la suite du num_index de la table TABLE1.

Sachant que je peux recréer des dumps de TABLE1 et NEWTABLE1

J'ai pensé à faire un dump de NEWTABLE1 en mettant la valeur NULL a tous les INSERT num_index afin que le dump de NEWTABLE1 s'autoincrémente sur TABLE1, mais je ne sais pas comment faire.

Avez vous des idées ?

Merci.

[Drone]

Re,

Pour l'instant j'ai trouvé la solution suivante qui est un peu lourde :

Code :

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

1
2
3
4
5
alter table newtable1 modify `Num_Index` bigint(20) null;  -- je change les propriétés du champ pour pouvoir supprimer la clé primaire
alter table newtable1 drop primary key;                              -- je supprime la clé primaire
alter table newtable1 modify `Num_Index` bigint(20) null;  -- je suis obligé de réécrire que le champ accepte la valeur null sinon la commande qui suit met des 0 à la place des NULL
UPDATE newtable1                                                            -- cette commande écrit des NULL sur tous les num_index
SET	num_index = NULL;

Ensuite je fais un dump qui ne contiendra que les INSERT :

Code :

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

mysqldump.exe" --skip-add-drop-table -t BDD table1 -u user -p > table1.sql

puis je réinsère le dump de newtable1 sur mon ancien table table1 et ça fonctionne.

Cependant la table était une table d'exemple assez légère, j'ai peu que sur une table trop grosse cela soit trop lourd, auriez vous une idée pour que je n'ai pas à écrire deux fois la même requête :

Code :

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

alter table newtable1 modify `Num_Index` bigint(20) null;

Merci d'avance

[CinePhil]

Si la table dans laquelle ont été insérées de données avec auto-incrément n'est pas référencée par des clé étrangères ou si ces clés étrangères ont toutes une consigne ON UPDATE CASCADE, vous pouvez faire la chose suivante, en connaissant l'ID max des données à restaurer :

Code :

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

1
2
UPDATE newtable1
SET ID = ID + 1 -- max ID de la table à restaurer. +1 au cas où le premier ID serait zéro

Ensuite, insérer les données à restaurer.

[Drone]

Bonjour Cinéphil,

Merci pour votre bonne idée! Cela me permettra de ne pas avoir à dump leurs nouvelles tables. Et non je n'ai pas de tables liés donc pas de contrainte d'intégrité

J'ai pu récupérer instantanément l'ID Max de mes tables qui font environ 30go avec la requête suivante

Code :

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

select num_index from table1 ORDER BY num_index DESC LIMIT 0,1;

J'obtient instantanément un num_index de 290 584 157

Merci pour l'aide je vais utiliser votre solution mais par curiosité, auriez vous une idée pour supprimer une clé primaire d'un champ int et mettre des null à la place avec le moins de requête possible ?
Je remet le code que j'avais fait ici, en 4 requêtes.. très peu performant.. :

Code :

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

1
2
3
4
5
alter table newtable1 modify `Num_Index` bigint(20) null;  -- je change les propriétés du champ Num_index pour pouvoir supprimer la clé primaire
alter table newtable1 drop primary key;                                    -- je supprime la clé primaire
alter table newtable1 modify `Num_Index` bigint(20) null;           -- je suis obligé de réécrire cette requête sinon la commande qui suit met des 0 à la place des NULL
UPDATE newtable1                                                                -- cette commande écrit des NULL sur tous les num_index
SET	num_index = NULL;

[CinePhil]

Code :

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

select num_index from table1 ORDER BY num_index DESC LIMIT 0,1;

Plus simple :

Code :

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

1
2
SELECT MAX(num_index) 
FROM table1

Code :

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

1
2
3
4
5
alter table newtable1 modify `Num_Index` bigint(20) null;  -- je change les propriétés du champ Num_index pour pouvoir supprimer la clé primaire
alter table newtable1 drop primary key;                                    -- je supprime la clé primaire
alter table newtable1 modify `Num_Index` bigint(20) null;           -- je suis obligé de réécrire cette requête sinon la commande qui suit met des 0 à la place des NULL
UPDATE newtable1                                                                -- cette commande écrit des NULL sur tous les num_index
SET	num_index = NULL;

La première requête ne sert à rien.

Mais pourquoi vouloir faire ça ?

[Drone]

Bonjour,

Plus simple :

Code :

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

1
2
SELECT MAX(num_index) 
FROM table1

En effet la commande est réduite, merci.

La première requête ne sert à rien.

Je ne peux pas supprimer la clé primaire tant que le champ a pour propriété l'auto incrémentation :"there can be only one auto column and it must be defined as a key"

De même comme je dois dire que ce champ peut avoir la valeur null, j'écris la commande complête :

Code :

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

1
2
3
4
5
6
7
8
alter table newtable1 modify `Num_Index` bigint(20) null;
 
-- Le problème étant qu'une fois je supprime la clé primaire.. 
alter table newtable1 drop primary key; 
 
-- Il faut de nouveau que je lui indique que le champ peut être à null
alter table newtable1 modify `Num_Index` bigint(20) null; 
--sinon j'ai des valeur à "0" à la place de "NULL" lorsque je rentre cette commande

Mais pourquoi vouloir faire ça ?

Comme je vous ai dit votre solution du SET ID = ID +1 me satisfait, cependant je suis curieux , j'avais commencé à réfléchir au problème et je voulais voir si c'était possible en moins de requête.

[Artemus24]

Salut Drone.

On m'a donné un fichier TABLE1.ibd de 28go à restaurer.

Ce n'est pas la bonne façon de procéder ainsi.
Ce fichier "*.ibd" est un fichier système que gère le SGBDR MySql et qui concerne les tables dont le moteur est InnoDB.

La bonne façon de faire est d'effectuer un export de votre table.
Vous pouvez le faire soit en ligne de commande avec "mysqldump" soit sous phpmyadmin, dans l'onglet "export".
Et ensuite, en effectuant un import toujours par phpmyadmin.

J'aimerai que le num_index de la table NEWTABLE1 commence à la suite du num_index de la table TABLE1.

Mon exemple contient quatre tables, qui sont : tabone et newtabone puis tabtwo et newtabtwo
tabtwo est lié à tabone par une clef étrangère, histoire de faire compliquer !

Pour insérer newtabone dans tabone, j'effectue qu'une simple recopie.
Tandis que pour tabtwo, je suis obligé d'allez chercher la nouvelle clef étrangère dans tabone, en passant par newtabtwo puis newtabone.
Voici mon 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
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
--------------
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 `tabone`
--------------
 
--------------
CREATE TABLE `tabone`
(  `id`   integer unsigned not null auto_increment primary key,
   `lib`  varchar(255)     not null
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
INSERT INTO `tabone` (`lib`) VALUES
  ('un'),('deux'),('trois'),('quatre'),('cinq')
--------------
 
--------------
select * from `tabone`
--------------
 
+----+--------+
| id | lib    |
+----+--------+
|  1 | un     |
|  2 | deux   |
|  3 | trois  |
|  4 | quatre |
|  5 | cinq   |
+----+--------+
--------------
DROP TABLE IF EXISTS `tabtwo`
--------------
 
--------------
CREATE TABLE `tabtwo`
(  `id`     integer unsigned not null auto_increment primary key,
   `clef`   integer unsigned not null,
   `mess`   varchar(255)     not null,
  CONSTRAINT `FK_TABONE` FOREIGN KEY (`clef`) REFERENCES `tabone` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
INSERT INTO `tabtwo` (`clef`,`mess`) VALUES
  (1, 'eins'),(1,'one'),
  (2, 'zwei'),(2,'two'),
  (3, 'drei'),(3,'three'),
  (4, 'vier'),(4,'four'),
  (5, 'funf'),(5,'five')
--------------
 
--------------
select * from `tabtwo`
--------------
 
+----+------+-------+
| id | clef | mess  |
+----+------+-------+
|  1 |    1 | eins  |
|  2 |    1 | one   |
|  3 |    2 | zwei  |
|  4 |    2 | two   |
|  5 |    3 | drei  |
|  6 |    3 | three |
|  7 |    4 | vier  |
|  8 |    4 | four  |
|  9 |    5 | funf  |
| 10 |    5 | five  |
+----+------+-------+
--------------
select      *
      from  `tabtwo` as t1
inner join  `tabone` as t2
        on  t2.id = t1.clef
--------------
 
+----+------+-------+----+--------+
| id | clef | mess  | id | lib    |
+----+------+-------+----+--------+
|  1 |    1 | eins  |  1 | un     |
|  2 |    1 | one   |  1 | un     |
|  3 |    2 | zwei  |  2 | deux   |
|  4 |    2 | two   |  2 | deux   |
|  5 |    3 | drei  |  3 | trois  |
|  6 |    3 | three |  3 | trois  |
|  7 |    4 | vier  |  4 | quatre |
|  8 |    4 | four  |  4 | quatre |
|  9 |    5 | funf  |  5 | cinq   |
| 10 |    5 | five  |  5 | cinq   |
+----+------+-------+----+--------+
--------------
DROP TABLE IF EXISTS `newtabone`
--------------
 
--------------
CREATE TABLE `newtabone`
(  `id`   integer unsigned not null auto_increment primary key,
   `lib`  varchar(255)     not null
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
INSERT INTO `newtabone` (`lib`) VALUES
  ('six'),('sept'),('huit'),('neuf'),('dix')
--------------
 
--------------
select * from `newtabone`
--------------
 
+----+------+
| id | lib  |
+----+------+
|  1 | six  |
|  2 | sept |
|  3 | huit |
|  4 | neuf |
|  5 | dix  |
+----+------+
--------------
DROP TABLE IF EXISTS `newtabtwo`
--------------
 
--------------
CREATE TABLE `newtabtwo`
(  `id`     integer unsigned not null auto_increment primary key,
   `clef`   integer unsigned not null,
   `mess`   varchar(255)     not null,
  CONSTRAINT `FK_NEWTABONE` FOREIGN KEY (`clef`) REFERENCES `newtabone` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
INSERT INTO `newtabtwo` (`clef`,`mess`) VALUES
  (1, 'sechs'), (1,'six'),
  (2, 'sieben'),(2,'seven'),
  (3, 'acht'),  (3,'eight'),
  (4, 'neuf'),  (4,'nine'),
  (5, 'zehn'),  (5,'ten')
--------------
 
--------------
select * from `newtabtwo`
--------------
 
+----+------+--------+
| id | clef | mess   |
+----+------+--------+
|  1 |    1 | sechs  |
|  2 |    1 | six    |
|  3 |    2 | sieben |
|  4 |    2 | seven  |
|  5 |    3 | acht   |
|  6 |    3 | eight  |
|  7 |    4 | neuf   |
|  8 |    4 | nine   |
|  9 |    5 | zehn   |
| 10 |    5 | ten    |
+----+------+--------+
--------------
select      *
      from  `newtabtwo` as t1
inner join  `newtabone` as t2
        on  t2.id = t1.clef
--------------
 
+----+------+--------+----+------+
| id | clef | mess   | id | lib  |
+----+------+--------+----+------+
|  1 |    1 | sechs  |  1 | six  |
|  2 |    1 | six    |  1 | six  |
|  3 |    2 | sieben |  2 | sept |
|  4 |    2 | seven  |  2 | sept |
|  5 |    3 | acht   |  3 | huit |
|  6 |    3 | eight  |  3 | huit |
|  7 |    4 | neuf   |  4 | neuf |
|  8 |    4 | nine   |  4 | neuf |
|  9 |    5 | zehn   |  5 | dix  |
| 10 |    5 | ten    |  5 | dix  |
+----+------+--------+----+------+
--------------
insert into `tabone` (`lib`)
  select  `lib`
    from  `newtabone`
order by  id
--------------
 
--------------
select * from `tabone`
--------------
 
+----+--------+
| id | lib    |
+----+--------+
|  1 | un     |
|  2 | deux   |
|  3 | trois  |
|  4 | quatre |
|  5 | cinq   |
|  6 | six    |
|  7 | sept   |
|  8 | huit   |
|  9 | neuf   |
| 10 | dix    |
+----+--------+
--------------
insert into `tabtwo` (`clef`,`mess`)
  select  t2.clef,
          t1.mess
 
  from  `newtabtwo` as t1
 
inner join (      select  ta.mess,
                          tc.id as clef
 
                    from  `newtabtwo` as ta
 
              inner join  `newtabone` as tb
                      on  tb.id = ta.clef
 
              inner join  `tabone`    as tc
                      on  tc.lib = tb.lib
           ) as t2
        on  t2.mess = t1.mess
--------------
 
--------------
select * from `tabtwo`
--------------
 
+----+------+--------+
| id | clef | mess   |
+----+------+--------+
|  1 |    1 | eins   |
|  2 |    1 | one    |
|  3 |    2 | zwei   |
|  4 |    2 | two    |
|  5 |    3 | drei   |
|  6 |    3 | three  |
|  7 |    4 | vier   |
|  8 |    4 | four   |
|  9 |    5 | funf   |
| 10 |    5 | five   |
| 11 |    6 | sechs  |
| 12 |    6 | six    |
| 13 |    7 | sieben |
| 14 |    7 | seven  |
| 15 |    8 | acht   |
| 16 |    8 | eight  |
| 17 |    9 | neuf   |
| 18 |    9 | nine   |
| 19 |   10 | zehn   |
| 20 |   10 | ten    |
+----+------+--------+
--------------
select      *
      from  `tabtwo` as t1
inner join  `tabone` as t2
        on  t2.id = t1.clef
--------------
 
+----+------+--------+----+--------+
| id | clef | mess   | id | lib    |
+----+------+--------+----+--------+
|  1 |    1 | eins   |  1 | un     |
|  2 |    1 | one    |  1 | un     |
|  3 |    2 | zwei   |  2 | deux   |
|  4 |    2 | two    |  2 | deux   |
|  5 |    3 | drei   |  3 | trois  |
|  6 |    3 | three  |  3 | trois  |
|  7 |    4 | vier   |  4 | quatre |
|  8 |    4 | four   |  4 | quatre |
|  9 |    5 | funf   |  5 | cinq   |
| 10 |    5 | five   |  5 | cinq   |
| 11 |    6 | sechs  |  6 | six    |
| 12 |    6 | six    |  6 | six    |
| 13 |    7 | sieben |  7 | sept   |
| 14 |    7 | seven  |  7 | sept   |
| 15 |    8 | acht   |  8 | huit   |
| 16 |    8 | eight  |  8 | huit   |
| 17 |    9 | neuf   |  9 | neuf   |
| 18 |    9 | nine   |  9 | neuf   |
| 19 |   10 | zehn   | 10 | dix    |
| 20 |   10 | ten    | 10 | dix    |
+----+------+--------+----+--------+
--------------
COMMIT
--------------
 
--------------
SET AUTOCOMMIT = 1
--------------
 
Appuyez sur une touche pour continuer...

Une autre solution, beaucoup plus simple est de faire un export de votre "newtabone".
De récupérer que les insert, sans ajouter la colonne "id".
J'espère pour vous, qua la colonne "id" est bien auto incrémenté comme dans mon exemple.
Puis ensuite, de faire un import uniquement avec les insert modifiés.

Si vous avez, comme le suggère CinePhil, une clef étrangère dans votre "newtabtwo" qui pointe sur "newtabone", la seule solution est de faire, comme je l'ai fait, une requête pour calculer la nouvelle clef étrangère.

@+

[Drone]

Salut Drone.

Bonjour Artemus,

Ce n'est pas la bonne façon de procéder ainsi.
Ce fichier "*.ibd" est un fichier système que gère le SGBDR MySql et qui concerne les tables dont le moteur est InnoDB.

La bonne façon de faire est d'effectuer un export de votre table.
Vous pouvez le faire soit en ligne de commande avec "mysqldump" soit sous phpmyadmin, dans l'onglet "export".
Et ensuite, en effectuant un import toujours par phpmyadmin.

Merci. Cependant on m'a amené un fichier ibd car la base de données a été corrompu et on avait plus que ça de viable.

Mon exemple contient quatre tables, qui sont : tabone et newtabone puis tabtwo et newtabtwo
tabtwo est lié à tabone par une clef étrangère, histoire de faire compliquer !

Pour insérer newtabone dans tabone, j'effectue qu'une simple recopie.
Tandis que pour tabtwo, je suis obligé d'allez chercher la nouvelle clef étrangère dans tabone, en passant par newtabtwo puis newtabone.
Voici mon 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
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
--------------
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 `tabone`
--------------
 
--------------
CREATE TABLE `tabone`
(  `id`   integer unsigned not null auto_increment primary key,
   `lib`  varchar(255)     not null
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
INSERT INTO `tabone` (`lib`) VALUES
  ('un'),('deux'),('trois'),('quatre'),('cinq')
--------------
 
--------------
select * from `tabone`
--------------
 
+----+--------+
| id | lib    |
+----+--------+
|  1 | un     |
|  2 | deux   |
|  3 | trois  |
|  4 | quatre |
|  5 | cinq   |
+----+--------+
--------------
DROP TABLE IF EXISTS `tabtwo`
--------------
 
--------------
CREATE TABLE `tabtwo`
(  `id`     integer unsigned not null auto_increment primary key,
   `clef`   integer unsigned not null,
   `mess`   varchar(255)     not null,
  CONSTRAINT `FK_TABONE` FOREIGN KEY (`clef`) REFERENCES `tabone` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
INSERT INTO `tabtwo` (`clef`,`mess`) VALUES
  (1, 'eins'),(1,'one'),
  (2, 'zwei'),(2,'two'),
  (3, 'drei'),(3,'three'),
  (4, 'vier'),(4,'four'),
  (5, 'funf'),(5,'five')
--------------
 
--------------
select * from `tabtwo`
--------------
 
+----+------+-------+
| id | clef | mess  |
+----+------+-------+
|  1 |    1 | eins  |
|  2 |    1 | one   |
|  3 |    2 | zwei  |
|  4 |    2 | two   |
|  5 |    3 | drei  |
|  6 |    3 | three |
|  7 |    4 | vier  |
|  8 |    4 | four  |
|  9 |    5 | funf  |
| 10 |    5 | five  |
+----+------+-------+
--------------
select      *
      from  `tabtwo` as t1
inner join  `tabone` as t2
        on  t2.id = t1.clef
--------------
 
+----+------+-------+----+--------+
| id | clef | mess  | id | lib    |
+----+------+-------+----+--------+
|  1 |    1 | eins  |  1 | un     |
|  2 |    1 | one   |  1 | un     |
|  3 |    2 | zwei  |  2 | deux   |
|  4 |    2 | two   |  2 | deux   |
|  5 |    3 | drei  |  3 | trois  |
|  6 |    3 | three |  3 | trois  |
|  7 |    4 | vier  |  4 | quatre |
|  8 |    4 | four  |  4 | quatre |
|  9 |    5 | funf  |  5 | cinq   |
| 10 |    5 | five  |  5 | cinq   |
+----+------+-------+----+--------+
--------------
DROP TABLE IF EXISTS `newtabone`
--------------
 
--------------
CREATE TABLE `newtabone`
(  `id`   integer unsigned not null auto_increment primary key,
   `lib`  varchar(255)     not null
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
INSERT INTO `newtabone` (`lib`) VALUES
  ('six'),('sept'),('huit'),('neuf'),('dix')
--------------
 
--------------
select * from `newtabone`
--------------
 
+----+------+
| id | lib  |
+----+------+
|  1 | six  |
|  2 | sept |
|  3 | huit |
|  4 | neuf |
|  5 | dix  |
+----+------+
--------------
DROP TABLE IF EXISTS `newtabtwo`
--------------
 
--------------
CREATE TABLE `newtabtwo`
(  `id`     integer unsigned not null auto_increment primary key,
   `clef`   integer unsigned not null,
   `mess`   varchar(255)     not null,
  CONSTRAINT `FK_NEWTABONE` FOREIGN KEY (`clef`) REFERENCES `newtabone` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
INSERT INTO `newtabtwo` (`clef`,`mess`) VALUES
  (1, 'sechs'), (1,'six'),
  (2, 'sieben'),(2,'seven'),
  (3, 'acht'),  (3,'eight'),
  (4, 'neuf'),  (4,'nine'),
  (5, 'zehn'),  (5,'ten')
--------------
 
--------------
select * from `newtabtwo`
--------------
 
+----+------+--------+
| id | clef | mess   |
+----+------+--------+
|  1 |    1 | sechs  |
|  2 |    1 | six    |
|  3 |    2 | sieben |
|  4 |    2 | seven  |
|  5 |    3 | acht   |
|  6 |    3 | eight  |
|  7 |    4 | neuf   |
|  8 |    4 | nine   |
|  9 |    5 | zehn   |
| 10 |    5 | ten    |
+----+------+--------+
--------------
select      *
      from  `newtabtwo` as t1
inner join  `newtabone` as t2
        on  t2.id = t1.clef
--------------
 
+----+------+--------+----+------+
| id | clef | mess   | id | lib  |
+----+------+--------+----+------+
|  1 |    1 | sechs  |  1 | six  |
|  2 |    1 | six    |  1 | six  |
|  3 |    2 | sieben |  2 | sept |
|  4 |    2 | seven  |  2 | sept |
|  5 |    3 | acht   |  3 | huit |
|  6 |    3 | eight  |  3 | huit |
|  7 |    4 | neuf   |  4 | neuf |
|  8 |    4 | nine   |  4 | neuf |
|  9 |    5 | zehn   |  5 | dix  |
| 10 |    5 | ten    |  5 | dix  |
+----+------+--------+----+------+
--------------
insert into `tabone` (`lib`)
  select  `lib`
    from  `newtabone`
order by  id
--------------
 
--------------
select * from `tabone`
--------------
 
+----+--------+
| id | lib    |
+----+--------+
|  1 | un     |
|  2 | deux   |
|  3 | trois  |
|  4 | quatre |
|  5 | cinq   |
|  6 | six    |
|  7 | sept   |
|  8 | huit   |
|  9 | neuf   |
| 10 | dix    |
+----+--------+
--------------
insert into `tabtwo` (`clef`,`mess`)
  select  t2.clef,
          t1.mess
 
  from  `newtabtwo` as t1
 
inner join (      select  ta.mess,
                          tc.id as clef
 
                    from  `newtabtwo` as ta
 
              inner join  `newtabone` as tb
                      on  tb.id = ta.clef
 
              inner join  `tabone`    as tc
                      on  tc.lib = tb.lib
           ) as t2
        on  t2.mess = t1.mess
--------------
 
--------------
select * from `tabtwo`
--------------
 
+----+------+--------+
| id | clef | mess   |
+----+------+--------+
|  1 |    1 | eins   |
|  2 |    1 | one    |
|  3 |    2 | zwei   |
|  4 |    2 | two    |
|  5 |    3 | drei   |
|  6 |    3 | three  |
|  7 |    4 | vier   |
|  8 |    4 | four   |
|  9 |    5 | funf   |
| 10 |    5 | five   |
| 11 |    6 | sechs  |
| 12 |    6 | six    |
| 13 |    7 | sieben |
| 14 |    7 | seven  |
| 15 |    8 | acht   |
| 16 |    8 | eight  |
| 17 |    9 | neuf   |
| 18 |    9 | nine   |
| 19 |   10 | zehn   |
| 20 |   10 | ten    |
+----+------+--------+
--------------
select      *
      from  `tabtwo` as t1
inner join  `tabone` as t2
        on  t2.id = t1.clef
--------------
 
+----+------+--------+----+--------+
| id | clef | mess   | id | lib    |
+----+------+--------+----+--------+
|  1 |    1 | eins   |  1 | un     |
|  2 |    1 | one    |  1 | un     |
|  3 |    2 | zwei   |  2 | deux   |
|  4 |    2 | two    |  2 | deux   |
|  5 |    3 | drei   |  3 | trois  |
|  6 |    3 | three  |  3 | trois  |
|  7 |    4 | vier   |  4 | quatre |
|  8 |    4 | four   |  4 | quatre |
|  9 |    5 | funf   |  5 | cinq   |
| 10 |    5 | five   |  5 | cinq   |
| 11 |    6 | sechs  |  6 | six    |
| 12 |    6 | six    |  6 | six    |
| 13 |    7 | sieben |  7 | sept   |
| 14 |    7 | seven  |  7 | sept   |
| 15 |    8 | acht   |  8 | huit   |
| 16 |    8 | eight  |  8 | huit   |
| 17 |    9 | neuf   |  9 | neuf   |
| 18 |    9 | nine   |  9 | neuf   |
| 19 |   10 | zehn   | 10 | dix    |
| 20 |   10 | ten    | 10 | dix    |
+----+------+--------+----+--------+
--------------
COMMIT
--------------
 
--------------
SET AUTOCOMMIT = 1
--------------
 
Appuyez sur une touche pour continuer...

Une autre solution, beaucoup plus simple est de faire un export de votre "newtabone".
De récupérer que les insert, sans ajouter la colonne "id".
J'espère pour vous, qua la colonne "id" est bien auto incrémenté comme dans mon exemple.
Puis ensuite, de faire un import uniquement avec les insert modifiés.

Si vous avez, comme le suggère CinePhil, une clef étrangère dans votre "newtabtwo" qui pointe sur "newtabone", la seule solution est de faire, comme je l'ai fait, une requête pour calculer la nouvelle clef étrangère.

@+

Merci pour ces solutions.
Le "insert into table1 (... ) select ... from newtable" pourra m'être utile un jour.
Dans mon cas actuel dans l'environnement de prod je n'ai pas encore fait d'import et faire un SET ID = ID +X puis un import sera plus rapide.