Variable définie dans un fichier texte

**africanism** · 15/10/2019, 09h22

Bonjour a tous,

voila je cherche a utilisé un fichier texte dans lequel je vais definir des lignes , chaque lignes correspondra a une variable.

je ne sais pas si c'est possible mais je voudrais que mon script sql fasse une boucle et que apres chaques execution il passe a la ligne suivante pour la définir comme variable etc etc.

CA m’évitera de faire 50 variables avec 50 scripts.

est ce possible j'ai entendu parlez de curseur mais je ne voit pas bien comment l'utilisé.

Voici mon script pour une variable.

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
 
set @Courrier = 'CTR_PJ_ABSENCE_CONTRAT_';
set @courrierv0 = 'CTR_PJ_ABSENCE_CONTRAT';
UPDATE `bdoci-connect`.`bdocument` SET `version`='V0' WHERE `version`='';
UPDATE `bdoci-connect`.`pjbgeneration` SET `version`='V0' WHERE `version`='';
 
 
UPDATE `bdoci-connect`.assembledbdocument set annotatedContent = replace(annotatedContent, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.bdocdocument set htmlContent = replace(htmlContent, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.datafieldentity set formId = replace(formId, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.datafieldentity set datafield_key = replace(datafield_key, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.datafieldentity set name = replace(name, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.generation_notlockedtext set key_NotLockedText = replace(key_NotLockedText, @Courrier,concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.state_validationaction set VALIDATIONACTION_KEY = replace(VALIDATIONACTION_KEY, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.validationaction set formId = replace(formId, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.inputdatafields set DATA_KEY = replace(DATA_KEY, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.datafieldfs set name = replace(name, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.datafieldfs set formId = replace(formId, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.pinputscriptform set formId = replace(formId, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.pinputscriptform set structContent = replace(structContent, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.state_scriptformmap set scriptFormMap_KEY = replace(scriptFormMap_KEY, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-connect`.interactionresult set structContent = replace(structContent, @Courrier, concat(@Courrierv0,'V0_'));

merci a tous.

**manzeki** · 16/10/2019, 02h12

Il est plus approprié de traiter le problème côté application et non côté MySQL.

Pourquoi ne pas mettre les parametres dans un tableau et laisser l'application construire la requête.
De telle sorte que chaque requête soit exécutée par php (ou par un autre language) dans une boucle.
NB : Mettre un delais de quelques millisecondes pour ne pas saturer le serveur.

Sinon laisser php créer un script SQL qui sera exécuter en batch.

Code :

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

mysql -h hostname -u user database < path/to/monscript.sql

Tout d'abord est-ce que toutes les requêtes dans tous les fichiers ont la même structure : concatenation, puis update de la colonne désignée.
Pourriez-vous montrer le script correspondant à la variable suivante ?

Suggestion

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
 
$variables = array();
$variables[] = array('assembledbdocument',	'annotatedContent', 'CTR_PJ_ABSENCE_CONTRAT_', 'CTR_PJ_ABSENCE_CONTRAT', 'V0');
$variables[] = array('bdocdocument', 'htmlContent', 'CTR_PJ_ABSENCE_CONTRAT_', 'CTR_PJ_ABSENCE_CONTRAT', 'V0');
$variables[] = array('datafieldentity', 'formId ', 'CTR_PJ_ABSENCE_CONTRAT_', 'CTR_PJ_ABSENCE_CONTRAT', 'V0');
$variables[] = array('datafieldentity ', 'datafield_key', 'CTR_PJ_ABSENCE_CONTRAT_', 'CTR_PJ_ABSENCE_CONTRAT', 'V0');
 
$variables[] = array('generation_notlockedtext ', 'key_NotLockedText', 	'CTR_PJ_ABSENCE_CONTRAT_', 'CTR_PJ_ABSENCE_CONTRAT', 'V0');
$variables[] = array('state_validationaction ', 'VALIDATIONACTION_KEY', 'CTR_PJ_ABSENCE_CONTRAT_', 'CTR_PJ_ABSENCE_CONTRAT', 'V0');
$variables[] = array('datafieldentity ', 'datafield_key', 'CTR_PJ_ABSENCE_CONTRAT_', 'CTR_PJ_ABSENCE_CONTRAT', 'V0');
 
 
foreach($variables as $i => $t){
	list($table, $colonne, $courrier, $courrierv0, $version) = $t;
	$sql = 'UPDATE bdoci-connect.' . $table . ' SET ' . $colonne . ' = replace(' . $colonne . ', ' . $courrier . ', concat(\'' . $courrierv0 . '\', \'' . $version . '\', \'_\' ))';
	mysql_query($sql, $connexion);
}

**Artemus24** · 16/10/2019, 17h41

Salut à tous.

Pour commencer, donnez nous un exemple de fichier à télécharger dans une table. Et ensuite, ce que vous désirez faire avec.

Un fichier plat contient fréquemment des répétitions de données.
Le but sera de les répartir dans différentes tables et de créer des relations.

Cela se fait très facilement avec l'utilitaire MySql "Load data infile".

@+

**escartefigue** · 16/10/2019, 19h10

Bonsoir,
Si je comprends bien le besoin, vous souhaitez générer du SQL dynamique à partir du contenu d'un fichier séquentiel, c'est bien ça ?

Ce qui est étonnant, c'est que la requête update ne comporte aucune clause WHERE.
Ce qui signifie que chaque update va être fait sur toutes les lignes de la table et potentiellement toujours sur la même colonne, auquel cas vous seriez très largement gagnant de ne traiter que la dernière ligne du fichier

Dans le cas contraire, si des éléments issus du fichier ont vocation à participer à la clause WHERE, attention aux failles de sécurité (injections SQL)

Pour le reste :
- vous faites des concaténations de chaînes de caractères, attention aux troncatures
- le fichier a peut-être été créé avec un jeu de caractères différent, est-ce pris en compte le cas échéant
- le fichier a-t-il fait l'objet d'un contrôle de cohérence en amont : présence de zones obligatoire, contrôle de validité du contenu...
- si la table mise à jour possède des colonnes d'un type différent de (var)char, alors le principe n'est pas applicable, car il faut au préalable faire une conversion de type (vers date, décimal, integer ou autre)

Bref, ça ressemble à une véritable usine à gaz et je m'interroge sur ce qui motive une solution aussi alambiquée...

**africanism** · 17/10/2019, 12h12

merci pour vos retour voici le fichier

le load data infile me parais pas mal, mais comment l’utilisé avec le fichier ?

**escartefigue** · 17/10/2019, 13h09

Vous n'avez pas répondu à mes questions d'hier soir : pourquoi faire un update de toutes les lignes de la table, la table possède -t- elle des colonnes de type autre que char ou varchar

Et surtout : quel est le besoin fonctionnel ? Avant de dire comment faire, il faut comprendre le pourquoi

**africanism** · 17/10/2019, 13h37

désolé en gros.

pour une histoire de versioning je doit modifier plusieurs ligne d'ou les updates.

ex: donc je doit remplacer "CTR_PJ_ABSENCE_CONTRAT_" par "CTR_PJ_ABSENCE_CONTRATV0" a plusieurs endroits.

dans le fichier texte j'ai toutes les lignes que je doit chercher .

ex: dans le fichier texte j'ai la ligne CTR_PJ_ENQUETE dons je veut cree les variables
"set @Courrier = 'CTR_PJ_ENQUETE_';"
"set @courrierv0 = 'CTR_PJ_ENQUETE';"

afin qui fasse l'update toutes les lignes suivantes.

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
UPDATE `bdoci-mafconnect`.assembledbdocument set annotatedContent = replace(annotatedContent, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.bdocdocument set htmlContent = replace(htmlContent, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.datafieldentity set formId = replace(formId, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.datafieldentity set datafield_key = replace(datafield_key, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.datafieldentity set name = replace(name, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.generation_notlockedtext set key_NotLockedText = replace(key_NotLockedText, @Courrier,concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.state_validationaction set VALIDATIONACTION_KEY = replace(VALIDATIONACTION_KEY, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.validationaction set formId = replace(formId, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.inputdatafields set DATA_KEY = replace(DATA_KEY, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.datafieldfs set name = replace(name, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.datafieldfs set formId = replace(formId, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.pinputscriptform set formId = replace(formId, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.pinputscriptform set structContent = replace(structContent, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.state_scriptformmap set scriptFormMap_KEY = replace(scriptFormMap_KEY, @Courrier, concat(@Courrierv0,'V0_'));
UPDATE `bdoci-mafconnect`.interactionresult set structContent = replace(structContent, @Courrier, concat(@Courrierv0,'V0_'));

mais j'ai plus de 50 lignes dans le fichier texte , d'ou ma demande, savoir si en place du set on peut definir qu'il aille cherche les infos dans le fichier texte passer le script puis passer a la ligne suiavnte dans le fichier texte.

**escartefigue** · 17/10/2019, 14h10

Sauf que, encore une fois, je ne vois pas de clause WHERE dans votre requête, ce qui signifie que, pour chaque ligne du fichier en entrée, vous allez faire un update de toutes les lignes de la table !
Je doute que ce soit le fonctionnement souhaité...

**Artemus24** · 17/10/2019, 14h24

Salut africanism.

D'après ce que j'ai compris de votre problème, vous partez d'un fichier texte.
Dans ce fichier, vous avez un libelle de type courrier (enfin je crois).
Chaque ligne va correspondre à ce que vous appelez une variable.

Vous allez balayer toutes vos tables ayant d'une part des colonnes de types : char, varchar, text, ...
et d'autre ayant la présence de ce libelle.
Si c'est le cas, vous remplacer l'ancienne chaîne, donc le contenu de votre variable, par la concaténation d'avec "V0_".

Est-ce que j'ai bien compris ?

Voici ce que je propose.

1) je crée deux bases, dont l'une va contenir la table "courrier" et les deux procédures stockées.
Une autre base qui va contenir toutes vos tables que vous devez modifier.

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
--------------
START TRANSACTION
--------------
 
--------------
DROP DATABASE IF EXISTS `baseone`
--------------
 
--------------
CREATE DATABASE IF NOT EXISTS `baseone`
        DEFAULT CHARACTER SET `latin1`
        DEFAULT COLLATE       `latin1_general_ci`
--------------
 
--------------
DROP TABLE IF EXISTS `courrier`
--------------
 
--------------
CREATE TABLE `courrier`
( `id`    smallint unsigned AUTO_INCREMENT NOT NULL PRIMARY KEY,
  `lib`   varchar(255)                     NOT NULL
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
LOAD DATA INFILE 'E:/30.MySql/01.exercices/Ex_30/Fichier.txt'
     INTO TABLE `courrier`
     CHARACTER SET latin1
     FIELDS TERMINATED            BY ';'
            OPTIONALLY ENCLOSED   BY '\"'
            ESCAPED               BY '\\'
     LINES  TERMINATED            BY '\r\n'
     IGNORE 1  LINES
     (lib)
--------------
 
--------------
select * from `courrier`
--------------
 
+----+---------------------------------------------+
| id | lib                                         |
+----+---------------------------------------------+
|  1 | CTR_PJ_ABSENCE_CONTRAT                      |
|  2 | CTR_PJ_ACCEPT_JUGEMENT_ADH                  |
|  3 | CTR_PJ_ACCEPT_JUGEMENT_AVC                  |
|  4 | CTR_PJ_APPEL_ADHERENT                       |
|  5 | CTR_PJ_APPEL_PAR_ADH_AVC                    |
|  6 | CTR_PJ_AVOCAT_PERSO_ADH                     |
|  7 | CTR_PJ_CONSEIL_MEMOIRE_RECLA                |
|  8 | CTR_PJ_DEMANDE_TITRE_EXE_AU_TRIB            |
|  9 | CTR_PJ_ENQUETE                              |
| 10 | CTR_PJ_ENVOI_POUVOIR_IP                     |
| 11 | CTR_PJ_EXECUTION_HUISSIER                   |
| 12 | CTR_PJ_FORMULAIRE_INJ_DE_PAYER_J_PROX_TI_TC |
| 13 | SIN_PJ_HORS_DOMAINE_D_INTERVENTION          |
| 14 | CTR_PJ_INFERIEUR_AU_SEUIL                   |
| 15 | CTR_PJ_INFO_ADH_DEPOT_REQ_INJ_DE_PAYER      |
| 16 | CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIRE |
| 17 | CTR_PJ_INFO_EXPERT_SAISINE_HUISSIER         |
| 18 | SIN_PJ_INTERV_SUR_ASSIGNATION               |
| 19 | CTR_PJ_LETTRE_D_ATTENTE                     |
| 20 | CTR_PJ_MED_DEB_EXPERT_JUDICIAIRE            |
| 21 | CTR_PJ_OD                                   |
| 22 | CTR_PJ_OD_DDE_DOC                           |
| 23 | CTR_PJ_OD_EXPERT_JUD                        |
| 24 | SIN_PJ_PAIEMENTS                            |
| 25 | SIN_PJ_PRESCRIPTION                         |
| 26 | CTR_RAPPEL_DE_FRANCHISE                     |
| 27 | SIN_PJ_REFUS_DECLARATION_TARDIVE            |
| 28 | SIN_PJ_REFUS_GARANTIE_ET_DELAI_CARENCE      |
| 29 | SIN_PJ_REFUS_GARANTIE_RC                    |
| 30 | CTR_PJ_SAISINE_AVOCAT_ADH                   |
| 31 | SIN_PJ_SAISINE_AVOCAT_MAF                   |
| 32 | CTR_PJ_SAISINE_HUISSIER_HONOS_EXPERT        |
+----+---------------------------------------------+
--------------
DROP DATABASE IF EXISTS `basetwo`
--------------
 
--------------
CREATE DATABASE IF NOT EXISTS `basetwo`
        DEFAULT CHARACTER SET `latin1`
        DEFAULT COLLATE       `latin1_general_ci`
--------------
 
--------------
DROP TABLE IF EXISTS `test`
--------------
 
--------------
CREATE TABLE `test`
( `id`      smallint unsigned AUTO_INCREMENT NOT NULL PRIMARY KEY,
  `libone`  varchar(255)                     NOT NULL,
  `libtwo`  varchar(255)                     NOT NULL
) ENGINE=InnoDB
  DEFAULT CHARSET=`latin1` COLLATE=`latin1_general_ci`
  ROW_FORMAT=COMPRESSED
--------------
 
--------------
insert into `test` (`libone`,`libtwo`) value
  ('>>>CTR_PJ_ENQUETE<<<','bla bla bla'),
  ('bla ba bla','>>>CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIRE<<<'),
  ('>>>CTR_PJ_OD<<<','bla bla'),
  ('bla bla','>>>CTR_RAPPEL_DE_FRANCHISE<<<')
--------------
 
--------------
select * from `test`
--------------
 
+----+----------------------+---------------------------------------------------+
| id | libone               | libtwo                                            |
+----+----------------------+---------------------------------------------------+
|  1 | >>>CTR_PJ_ENQUETE<<< | bla bla bla                                       |
|  2 | bla ba bla           | >>>CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIRE<<< |
|  3 | >>>CTR_PJ_OD<<<      | bla bla                                           |
|  4 | bla bla              | >>>CTR_RAPPEL_DE_FRANCHISE<<<                     |
+----+----------------------+---------------------------------------------------+
--------------
COMMIT
--------------
 
Appuyez sur une touche pour continuer...

2) voici les deux procédures stockées :

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
--------------
DROP PROCEDURE IF EXISTS changer
--------------
 
--------------
CREATE PROCEDURE changer(_base  VARCHAR(255),
                         _old   VARCHAR(255),
                         _new   VARCHAR(255))
DETERMINISTIC
NO SQL
BEGIN
        DECLARE _fin      INTEGER DEFAULT 1;
        DECLARE _table    VARCHAR(255);
        DECLARE _colonne  VARCHAR(255);
 
        DECLARE curseur CURSOR FOR
                SELECT  table_name, column_name
                  FROM  information_schema.columns
                 WHERE  table_schema = _base
                   AND  data_type    IN ('varchar','char','tinytext','mediumtext','text','longtext');
 
        DECLARE CONTINUE HANDLER FOR NOT FOUND SET _fin=0;
 
 
 
        OPEN curseur;
 
        FETCH curseur INTO _table,_colonne;
 
        WHILE _FIN DO
                SET @s = concat('update ',concat(_base,'.',_table),' SET ',_colonne,' = replace(',_colonne,',\'',_old,'\',\'',_new,'\') where ',_colonne,' like \'%',_old,'%\';');
 
                SELECT @s;
 
                PREPARE stmt1 FROM @s;
                EXECUTE stmt1;
                DEALLOCATE PREPARE stmt1;
 
                FETCH curseur INTO _table,_colonne;
        END WHILE;
 
        CLOSE curseur;
END
--------------
 
--------------
DROP PROCEDURE IF EXISTS lecture
--------------
 
--------------
CREATE PROCEDURE lecture()
DETERMINISTIC
NO SQL
BEGIN
        DECLARE _fin      INTEGER DEFAULT 1;
        DECLARE _table    VARCHAR(255);
        DECLARE _colonne  VARCHAR(255);
 
        DECLARE curseur CURSOR FOR
                SELECT  lib FROM `courrier`;
 
        DECLARE CONTINUE HANDLER FOR NOT FOUND SET _fin=0;
 
        OPEN curseur;
 
        FETCH curseur INTO _colonne;
 
        WHILE _FIN DO
                set @s = concat("call `changer`('basetwo','",_colonne,"','",concat(_colonne,'V0_'),"');");
 
                SELECT @s;
 
                PREPARE stmt2 FROM @s;
                EXECUTE stmt2;
                DEALLOCATE PREPARE stmt2;
 
                FETCH curseur INTO _colonne;
        END WHILE;
 
        CLOSE curseur;
END
--------------
 
Appuyez sur une touche pour continuer...

La première se nomme "changer" et va réaliser la substitution.
La seconde appelle la procédure "changer" et va effectuer le passage des paramètres à partir de la table "courrier".

Et voici l'exécution :

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
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
 
--------------
select * from `test`
--------------
 
+----+----------------------+---------------------------------------------------+
| id | libone               | libtwo                                            |
+----+----------------------+---------------------------------------------------+
|  1 | >>>CTR_PJ_ENQUETE<<< | bla bla bla                                       |
|  2 | bla ba bla           | >>>CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIRE<<< |
|  3 | >>>CTR_PJ_OD<<<      | bla bla                                           |
|  4 | bla bla              | >>>CTR_RAPPEL_DE_FRANCHISE<<<                     |
+----+----------------------+---------------------------------------------------+
--------------
call baseone.lecture()
--------------
 
+---------------------------------------------------------------------------------+
| @s                                                                              |
+---------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_ABSENCE_CONTRAT','CTR_PJ_ABSENCE_CONTRATV0_'); |
+---------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                  |
+-----------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_ABSENCE_CONTRAT','CTR_PJ_ABSENCE_CONTRATV0_') where libone like '%CTR_PJ_ABSENCE_CONTRAT%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                  |
+-----------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_ABSENCE_CONTRAT','CTR_PJ_ABSENCE_CONTRATV0_') where libtwo like '%CTR_PJ_ABSENCE_CONTRAT%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------+
| @s                                                                                      |
+-----------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_ACCEPT_JUGEMENT_ADH','CTR_PJ_ACCEPT_JUGEMENT_ADHV0_'); |
+-----------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                              |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_ACCEPT_JUGEMENT_ADH','CTR_PJ_ACCEPT_JUGEMENT_ADHV0_') where libone like '%CTR_PJ_ACCEPT_JUGEMENT_ADH%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                              |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_ACCEPT_JUGEMENT_ADH','CTR_PJ_ACCEPT_JUGEMENT_ADHV0_') where libtwo like '%CTR_PJ_ACCEPT_JUGEMENT_ADH%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------+
| @s                                                                                      |
+-----------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_ACCEPT_JUGEMENT_AVC','CTR_PJ_ACCEPT_JUGEMENT_AVCV0_'); |
+-----------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                              |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_ACCEPT_JUGEMENT_AVC','CTR_PJ_ACCEPT_JUGEMENT_AVCV0_') where libone like '%CTR_PJ_ACCEPT_JUGEMENT_AVC%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                              |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_ACCEPT_JUGEMENT_AVC','CTR_PJ_ACCEPT_JUGEMENT_AVCV0_') where libtwo like '%CTR_PJ_ACCEPT_JUGEMENT_AVC%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-------------------------------------------------------------------------------+
| @s                                                                            |
+-------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_APPEL_ADHERENT','CTR_PJ_APPEL_ADHERENTV0_'); |
+-------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                               |
+--------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_APPEL_ADHERENT','CTR_PJ_APPEL_ADHERENTV0_') where libone like '%CTR_PJ_APPEL_ADHERENT%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                               |
+--------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_APPEL_ADHERENT','CTR_PJ_APPEL_ADHERENTV0_') where libtwo like '%CTR_PJ_APPEL_ADHERENT%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------+
+-------------------------------------------------------------------------------------+
| @s                                                                                  |
+-------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_APPEL_PAR_ADH_AVC','CTR_PJ_APPEL_PAR_ADH_AVCV0_'); |
+-------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                        |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_APPEL_PAR_ADH_AVC','CTR_PJ_APPEL_PAR_ADH_AVCV0_') where libone like '%CTR_PJ_APPEL_PAR_ADH_AVC%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                        |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_APPEL_PAR_ADH_AVC','CTR_PJ_APPEL_PAR_ADH_AVCV0_') where libtwo like '%CTR_PJ_APPEL_PAR_ADH_AVC%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------+
| @s                                                                                |
+-----------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_AVOCAT_PERSO_ADH','CTR_PJ_AVOCAT_PERSO_ADHV0_'); |
+-----------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_AVOCAT_PERSO_ADH','CTR_PJ_AVOCAT_PERSO_ADHV0_') where libone like '%CTR_PJ_AVOCAT_PERSO_ADH%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_AVOCAT_PERSO_ADH','CTR_PJ_AVOCAT_PERSO_ADHV0_') where libtwo like '%CTR_PJ_AVOCAT_PERSO_ADH%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+---------------------------------------------------------------------------------------------+
| @s                                                                                          |
+---------------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_CONSEIL_MEMOIRE_RECLA','CTR_PJ_CONSEIL_MEMOIRE_RECLAV0_'); |
+---------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                    |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_CONSEIL_MEMOIRE_RECLA','CTR_PJ_CONSEIL_MEMOIRE_RECLAV0_') where libone like '%CTR_PJ_CONSEIL_MEMOIRE_RECLA%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                    |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_CONSEIL_MEMOIRE_RECLA','CTR_PJ_CONSEIL_MEMOIRE_RECLAV0_') where libtwo like '%CTR_PJ_CONSEIL_MEMOIRE_RECLA%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------+
| @s                                                                                                  |
+-----------------------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_DEMANDE_TITRE_EXE_AU_TRIB','CTR_PJ_DEMANDE_TITRE_EXE_AU_TRIBV0_'); |
+-----------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_DEMANDE_TITRE_EXE_AU_TRIB','CTR_PJ_DEMANDE_TITRE_EXE_AU_TRIBV0_') where libone like '%CTR_PJ_DEMANDE_TITRE_EXE_AU_TRIB%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_DEMANDE_TITRE_EXE_AU_TRIB','CTR_PJ_DEMANDE_TITRE_EXE_AU_TRIBV0_') where libtwo like '%CTR_PJ_DEMANDE_TITRE_EXE_AU_TRIB%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------+
| @s                                                              |
+-----------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_ENQUETE','CTR_PJ_ENQUETEV0_'); |
+-----------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                          |
+-----------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_ENQUETE','CTR_PJ_ENQUETEV0_') where libone like '%CTR_PJ_ENQUETE%'; |
+-----------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                          |
+-----------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_ENQUETE','CTR_PJ_ENQUETEV0_') where libtwo like '%CTR_PJ_ENQUETE%'; |
+-----------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------+
| @s                                                                                |
+-----------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_ENVOI_POUVOIR_IP','CTR_PJ_ENVOI_POUVOIR_IPV0_'); |
+-----------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_ENVOI_POUVOIR_IP','CTR_PJ_ENVOI_POUVOIR_IPV0_') where libone like '%CTR_PJ_ENVOI_POUVOIR_IP%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_ENVOI_POUVOIR_IP','CTR_PJ_ENVOI_POUVOIR_IPV0_') where libtwo like '%CTR_PJ_ENVOI_POUVOIR_IP%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+---------------------------------------------------------------------------------------+
| @s                                                                                    |
+---------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_EXECUTION_HUISSIER','CTR_PJ_EXECUTION_HUISSIERV0_'); |
+---------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                           |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_EXECUTION_HUISSIER','CTR_PJ_EXECUTION_HUISSIERV0_') where libone like '%CTR_PJ_EXECUTION_HUISSIER%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                           |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_EXECUTION_HUISSIER','CTR_PJ_EXECUTION_HUISSIERV0_') where libtwo like '%CTR_PJ_EXECUTION_HUISSIER%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
+---------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                        |
+---------------------------------------------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_FORMULAIRE_INJ_DE_PAYER_J_PROX_TI_TC','CTR_PJ_FORMULAIRE_INJ_DE_PAYER_J_PROX_TI_TCV0_'); |
+---------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                                                 |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_FORMULAIRE_INJ_DE_PAYER_J_PROX_TI_TC','CTR_PJ_FORMULAIRE_INJ_DE_PAYER_J_PROX_TI_TCV0_') where libone like '%CTR_PJ_FORMULAIRE_INJ_DE_PAYER_J_PROX_TI_TC%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                                                 |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_FORMULAIRE_INJ_DE_PAYER_J_PROX_TI_TC','CTR_PJ_FORMULAIRE_INJ_DE_PAYER_J_PROX_TI_TCV0_') where libtwo like '%CTR_PJ_FORMULAIRE_INJ_DE_PAYER_J_PROX_TI_TC%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+---------------------------------------------------------------------------------------------------------+
| @s                                                                                                      |
+---------------------------------------------------------------------------------------------------------+
| call `changer`('basetwo','SIN_PJ_HORS_DOMAINE_D_INTERVENTION','SIN_PJ_HORS_DOMAINE_D_INTERVENTIONV0_'); |
+---------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                      |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'SIN_PJ_HORS_DOMAINE_D_INTERVENTION','SIN_PJ_HORS_DOMAINE_D_INTERVENTIONV0_') where libone like '%SIN_PJ_HORS_DOMAINE_D_INTERVENTION%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                      |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'SIN_PJ_HORS_DOMAINE_D_INTERVENTION','SIN_PJ_HORS_DOMAINE_D_INTERVENTIONV0_') where libtwo like '%SIN_PJ_HORS_DOMAINE_D_INTERVENTION%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+---------------------------------------------------------------------------------------+
| @s                                                                                    |
+---------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_INFERIEUR_AU_SEUIL','CTR_PJ_INFERIEUR_AU_SEUILV0_'); |
+---------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                           |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_INFERIEUR_AU_SEUIL','CTR_PJ_INFERIEUR_AU_SEUILV0_') where libone like '%CTR_PJ_INFERIEUR_AU_SEUIL%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                           |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_INFERIEUR_AU_SEUIL','CTR_PJ_INFERIEUR_AU_SEUILV0_') where libtwo like '%CTR_PJ_INFERIEUR_AU_SEUIL%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------+
| @s                                                                                                              |
+-----------------------------------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_INFO_ADH_DEPOT_REQ_INJ_DE_PAYER','CTR_PJ_INFO_ADH_DEPOT_REQ_INJ_DE_PAYERV0_'); |
+-----------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                                  |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_INFO_ADH_DEPOT_REQ_INJ_DE_PAYER','CTR_PJ_INFO_ADH_DEPOT_REQ_INJ_DE_PAYERV0_') where libone like '%CTR_PJ_INFO_ADH_DEPOT_REQ_INJ_DE_PAYER%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                                  |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_INFO_ADH_DEPOT_REQ_INJ_DE_PAYER','CTR_PJ_INFO_ADH_DEPOT_REQ_INJ_DE_PAYERV0_') where libtwo like '%CTR_PJ_INFO_ADH_DEPOT_REQ_INJ_DE_PAYER%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+---------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                        |
+---------------------------------------------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIRE','CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIREV0_'); |
+---------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                                                 |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIRE','CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIREV0_') where libone like '%CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIRE%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                                                 |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIRE','CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIREV0_') where libtwo like '%CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIRE%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------+
| @s                                                                                                        |
+-----------------------------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_INFO_EXPERT_SAISINE_HUISSIER','CTR_PJ_INFO_EXPERT_SAISINE_HUISSIERV0_'); |
+-----------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                         |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_INFO_EXPERT_SAISINE_HUISSIER','CTR_PJ_INFO_EXPERT_SAISINE_HUISSIERV0_') where libone like '%CTR_PJ_INFO_EXPERT_SAISINE_HUISSIER%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                         |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_INFO_EXPERT_SAISINE_HUISSIER','CTR_PJ_INFO_EXPERT_SAISINE_HUISSIERV0_') where libtwo like '%CTR_PJ_INFO_EXPERT_SAISINE_HUISSIER%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------+
| @s                                                                                            |
+-----------------------------------------------------------------------------------------------+
| call `changer`('basetwo','SIN_PJ_INTERV_SUR_ASSIGNATION','SIN_PJ_INTERV_SUR_ASSIGNATIONV0_'); |
+-----------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                       |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'SIN_PJ_INTERV_SUR_ASSIGNATION','SIN_PJ_INTERV_SUR_ASSIGNATIONV0_') where libone like '%SIN_PJ_INTERV_SUR_ASSIGNATION%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                       |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'SIN_PJ_INTERV_SUR_ASSIGNATION','SIN_PJ_INTERV_SUR_ASSIGNATIONV0_') where libtwo like '%SIN_PJ_INTERV_SUR_ASSIGNATION%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------+
| @s                                                                                |
+-----------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_LETTRE_D_ATTENTE','CTR_PJ_LETTRE_D_ATTENTEV0_'); |
+-----------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_LETTRE_D_ATTENTE','CTR_PJ_LETTRE_D_ATTENTEV0_') where libone like '%CTR_PJ_LETTRE_D_ATTENTE%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_LETTRE_D_ATTENTE','CTR_PJ_LETTRE_D_ATTENTEV0_') where libtwo like '%CTR_PJ_LETTRE_D_ATTENTE%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------+
| @s                                                                                                  |
+-----------------------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_MED_DEB_EXPERT_JUDICIAIRE','CTR_PJ_MED_DEB_EXPERT_JUDICIAIREV0_'); |
+-----------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_MED_DEB_EXPERT_JUDICIAIRE','CTR_PJ_MED_DEB_EXPERT_JUDICIAIREV0_') where libone like '%CTR_PJ_MED_DEB_EXPERT_JUDICIAIRE%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_MED_DEB_EXPERT_JUDICIAIRE','CTR_PJ_MED_DEB_EXPERT_JUDICIAIREV0_') where libtwo like '%CTR_PJ_MED_DEB_EXPERT_JUDICIAIRE%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-------------------------------------------------------+
| @s                                                    |
+-------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_OD','CTR_PJ_ODV0_'); |
+-------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------+
| @s                                                                                                           |
+--------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_OD','CTR_PJ_ODV0_') where libone like '%CTR_PJ_OD%'; |
+--------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------+
| @s                                                                                                           |
+--------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_OD','CTR_PJ_ODV0_') where libtwo like '%CTR_PJ_OD%'; |
+--------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------+
| @s                                                                    |
+-----------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_OD_DDE_DOC','CTR_PJ_OD_DDE_DOCV0_'); |
+-----------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                   |
+--------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_OD_DDE_DOC','CTR_PJ_OD_DDE_DOCV0_') where libone like '%CTR_PJ_OD_DDE_DOC%'; |
+--------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                   |
+--------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_OD_DDE_DOC','CTR_PJ_OD_DDE_DOCV0_') where libtwo like '%CTR_PJ_OD_DDE_DOC%'; |
+--------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
| @s                                                                          |
+-----------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_OD_EXPERT_JUD','CTR_PJ_OD_EXPERT_JUDV0_'); |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                            |
+-----------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_OD_EXPERT_JUD','CTR_PJ_OD_EXPERT_JUDV0_') where libone like '%CTR_PJ_OD_EXPERT_JUD%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                            |
+-----------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_OD_EXPERT_JUD','CTR_PJ_OD_EXPERT_JUDV0_') where libtwo like '%CTR_PJ_OD_EXPERT_JUD%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------+
+---------------------------------------------------------------------+
| @s                                                                  |
+---------------------------------------------------------------------+
| call `changer`('basetwo','SIN_PJ_PAIEMENTS','SIN_PJ_PAIEMENTSV0_'); |
+---------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                |
+-----------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'SIN_PJ_PAIEMENTS','SIN_PJ_PAIEMENTSV0_') where libone like '%SIN_PJ_PAIEMENTS%'; |
+-----------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                |
+-----------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'SIN_PJ_PAIEMENTS','SIN_PJ_PAIEMENTSV0_') where libtwo like '%SIN_PJ_PAIEMENTS%'; |
+-----------------------------------------------------------------------------------------------------------------------------------+
+---------------------------------------------------------------------------+
| @s                                                                        |
+---------------------------------------------------------------------------+
| call `changer`('basetwo','SIN_PJ_PRESCRIPTION','SIN_PJ_PRESCRIPTIONV0_'); |
+---------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                         |
+--------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'SIN_PJ_PRESCRIPTION','SIN_PJ_PRESCRIPTIONV0_') where libone like '%SIN_PJ_PRESCRIPTION%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                         |
+--------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'SIN_PJ_PRESCRIPTION','SIN_PJ_PRESCRIPTIONV0_') where libtwo like '%SIN_PJ_PRESCRIPTION%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------+
| @s                                                                                |
+-----------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_RAPPEL_DE_FRANCHISE','CTR_RAPPEL_DE_FRANCHISEV0_'); |
+-----------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_RAPPEL_DE_FRANCHISE','CTR_RAPPEL_DE_FRANCHISEV0_') where libone like '%CTR_RAPPEL_DE_FRANCHISE%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                     |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_RAPPEL_DE_FRANCHISE','CTR_RAPPEL_DE_FRANCHISEV0_') where libtwo like '%CTR_RAPPEL_DE_FRANCHISE%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------+
| @s                                                                                                  |
+-----------------------------------------------------------------------------------------------------+
| call `changer`('basetwo','SIN_PJ_REFUS_DECLARATION_TARDIVE','SIN_PJ_REFUS_DECLARATION_TARDIVEV0_'); |
+-----------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'SIN_PJ_REFUS_DECLARATION_TARDIVE','SIN_PJ_REFUS_DECLARATION_TARDIVEV0_') where libone like '%SIN_PJ_REFUS_DECLARATION_TARDIVE%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'SIN_PJ_REFUS_DECLARATION_TARDIVE','SIN_PJ_REFUS_DECLARATION_TARDIVEV0_') where libtwo like '%SIN_PJ_REFUS_DECLARATION_TARDIVE%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------+
| @s                                                                                                              |
+-----------------------------------------------------------------------------------------------------------------+
| call `changer`('basetwo','SIN_PJ_REFUS_GARANTIE_ET_DELAI_CARENCE','SIN_PJ_REFUS_GARANTIE_ET_DELAI_CARENCEV0_'); |
+-----------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                                  |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'SIN_PJ_REFUS_GARANTIE_ET_DELAI_CARENCE','SIN_PJ_REFUS_GARANTIE_ET_DELAI_CARENCEV0_') where libone like '%SIN_PJ_REFUS_GARANTIE_ET_DELAI_CARENCE%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                                  |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'SIN_PJ_REFUS_GARANTIE_ET_DELAI_CARENCE','SIN_PJ_REFUS_GARANTIE_ET_DELAI_CARENCEV0_') where libtwo like '%SIN_PJ_REFUS_GARANTIE_ET_DELAI_CARENCE%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-------------------------------------------------------------------------------------+
| @s                                                                                  |
+-------------------------------------------------------------------------------------+
| call `changer`('basetwo','SIN_PJ_REFUS_GARANTIE_RC','SIN_PJ_REFUS_GARANTIE_RCV0_'); |
+-------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                        |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'SIN_PJ_REFUS_GARANTIE_RC','SIN_PJ_REFUS_GARANTIE_RCV0_') where libone like '%SIN_PJ_REFUS_GARANTIE_RC%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                        |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'SIN_PJ_REFUS_GARANTIE_RC','SIN_PJ_REFUS_GARANTIE_RCV0_') where libtwo like '%SIN_PJ_REFUS_GARANTIE_RC%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+---------------------------------------------------------------------------------------+
| @s                                                                                    |
+---------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_SAISINE_AVOCAT_ADH','CTR_PJ_SAISINE_AVOCAT_ADHV0_'); |
+---------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                           |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_SAISINE_AVOCAT_ADH','CTR_PJ_SAISINE_AVOCAT_ADHV0_') where libone like '%CTR_PJ_SAISINE_AVOCAT_ADH%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                           |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_SAISINE_AVOCAT_ADH','CTR_PJ_SAISINE_AVOCAT_ADHV0_') where libtwo like '%CTR_PJ_SAISINE_AVOCAT_ADH%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
+---------------------------------------------------------------------------------------+
| @s                                                                                    |
+---------------------------------------------------------------------------------------+
| call `changer`('basetwo','SIN_PJ_SAISINE_AVOCAT_MAF','SIN_PJ_SAISINE_AVOCAT_MAFV0_'); |
+---------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                           |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'SIN_PJ_SAISINE_AVOCAT_MAF','SIN_PJ_SAISINE_AVOCAT_MAFV0_') where libone like '%SIN_PJ_SAISINE_AVOCAT_MAF%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                           |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'SIN_PJ_SAISINE_AVOCAT_MAF','SIN_PJ_SAISINE_AVOCAT_MAFV0_') where libtwo like '%SIN_PJ_SAISINE_AVOCAT_MAF%'; |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-------------------------------------------------------------------------------------------------------------+
| @s                                                                                                          |
+-------------------------------------------------------------------------------------------------------------+
| call `changer`('basetwo','CTR_PJ_SAISINE_HUISSIER_HONOS_EXPERT','CTR_PJ_SAISINE_HUISSIER_HONOS_EXPERTV0_'); |
+-------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                            |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libone = replace(libone,'CTR_PJ_SAISINE_HUISSIER_HONOS_EXPERT','CTR_PJ_SAISINE_HUISSIER_HONOS_EXPERTV0_') where libone like '%CTR_PJ_SAISINE_HUISSIER_HONOS_EXPERT%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| @s                                                                                                                                                                                            |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| update basetwo.test SET libtwo = replace(libtwo,'CTR_PJ_SAISINE_HUISSIER_HONOS_EXPERT','CTR_PJ_SAISINE_HUISSIER_HONOS_EXPERTV0_') where libtwo like '%CTR_PJ_SAISINE_HUISSIER_HONOS_EXPERT%'; |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
--------------
select * from `test`
--------------
 
+----+-------------------------+------------------------------------------------------+
| id | libone                  | libtwo                                               |
+----+-------------------------+------------------------------------------------------+
|  1 | >>>CTR_PJ_ENQUETEV0_<<< | bla bla bla                                          |
|  2 | bla ba bla              | >>>CTR_PJ_INFO_ADH_DELIVRANCE_TITRE_EXECUTOIREV0_<<< |
|  3 | >>>CTR_PJ_ODV0_<<<      | bla bla                                              |
|  4 | bla bla                 | >>>CTR_RAPPEL_DE_FRANCHISEV0_<<<                     |
+----+-------------------------+------------------------------------------------------+
 
Appuyez sur une touche pour continuer...

J'ai laissé les select dans les procédures afin d'avoir une trace de ce qui se fait.
A vous de l'adapter à votre environnement.

@+

Variable définie dans un fichier texte

Requêtes MySQL

Discussions similaires

Partager

Partager