manipulations de chaines de caractères sur Oracle

Version imprimable

Bonjour j'ai dans une de mes tables (Oracle) des enregistrements que j'aimerais modifier par les fonction instr, replace, etc. Mais c'est un peu compliqué, j'explique :

Mes rengistrements ressemblent à ça:
Code:

1 2 3 95% Rouge, 5% Vert 100% Noir Bleuté 50% Vert Clair, 45% Vert Foncé, 5% Vert Bizarre
Mon but est d'obtenir ça:
Code:

1 2 3 95% <a href="lien_rouge.htm">Rouge</a>, 5% <a href="lien_vert.htm">Vert</a> 100% <a href="lien_noir_bleute.htm">Noir Bleuté</a> 50% <a href="lien_vert_clair.htm">Vert Clair</a>, 45% <a href="lien_vert_fonce.htm">Vert Foncé</a>, 5% <a href="lien_vert_bizarre.htm">Vert Bizarre</a>
Je suppose qu'il y a une possibilité de requête pour réaliser cette modification puisqu'il y a une logique:
-les début des liens html sont situés toujours après "% "
-les fins des liens html sont situés toujours avant une virgule ou après le dernier caractère.
-les adresse des liens sont le mot en mininuscule, sans les accents, et les espaces sont remplacés par "_"

En me promenant sur ce forum, j'a vu que certains étaient très forts en manipulation de chaines de caractère,
que pensez-vous de cette requête ?

manipulation de chaines de caractères

Bonjour j'ai dans une de mes tables (Oracle) des enregistrements que j'aimerais modifier par les fonction instr, replace, etc. Mais c'est un peu compliqué, j'explique :

Mes rengistrements ressemblent à ça:
Code:

1 2 3 95% Rouge, 5% Vert 100% Noir Bleuté 50% Vert Clair, 45% Vert Foncé, 5% Vert Bizarre
Mon but est d'obtenir ça:
Code:

1 2 3 95% <a href="lien_rouge.htm">Rouge</a>, 5% <a href="lien_vert.htm">Vert</a> 100% <a href="lien_noir_bleute.htm">Noir Bleuté</a> 50% <a href="lien_vert_clair.htm">Vert Clair</a>, 45% <a href="lien_vert_fonce.htm">Vert Foncé</a>, 5% <a href="lien_vert_bizarre.htm">Vert Bizarre</a>
Je suppose qu'il y a une possibilité de requête pour réaliser cette modification puisqu'il y a une logique:
-les début des liens html sont situés toujours après "% "
-les fins des liens html sont situés toujours avant une virgule ou après le dernier caractère.
-les adresse des liens sont le mot en mininuscule, sans les accents

En me promenant sur ce forum, j'a vu que certains étaient très forts en manipulation de chaines de caractère,
que pensez-vous de cette requête ?

30/07/2009, 16h17
Pomalaix

Bonjour

Quelle est votre version d'Oracle (à préciser dans toute question) ?
30/07/2009, 16h23
ajor

La version d'Oracle (en détail...)

----------------------------------------------------------------
Oracle Database 10g Enterprise Edition Release 10.1.0.3.0 - 64bi
PL/SQL Release 10.1.0.3.0 - Production
CORE 10.1.0.3.0 Production
TNS for IBM/AIX RISC System/6000: Version 10.1.0.3.0 - Productio
NLSRTL Version 10.1.0.3.0 - Production

Et j'utilise SQL*Plus: Release 10.1.0.2.0

En SQL pur, ça va être raide étant donné que vous avez des valeurs composées.
Ca peut se traiter par une fonction récursive dans le genre de cette amorce, à compléter pour introduire la gestion des exceptions, la conversion de tous les caractères exotiques dans le TRANSLATE, etc.

En l'état, ça permet déjà d'obtenir le bon résultat pour vos exemples.

Code:

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
 
create or replace function bricole(liste varchar2) return varchar2
is
        fragment        varchar2(100);
        pos_virgule     number(4);
        val_virgule 	varchar2(2);
        suite           varchar2(4000);
        pos_pct         number(4);
        val_pct         varchar2(10);
        couleur         varchar2(30);
        couleur_fmt 	varchar2(30);
        resultat        varchar2(4000);
 
begin
        -- condition de terminaison
        if liste is null then
                return '';
        end if;
 
        -- découpage
        pos_virgule:=instr(liste, ',');
		if pos_virgule=0 then
			pos_virgule:=length(liste) + 1;
		end if;
		fragment:=substr(liste, 1, pos_virgule-1);
		-- on ne prend ni la virgule, ni l'espace qui la suit
		suite:=substr(liste, pos_virgule + 2);
		if suite is not null then
			val_virgule:=', ';
		else
			val_virgule := '';
		end if;
 
        -- traitement du premier fragment
        pos_pct:=instr(fragment, '%');
        val_pct:=substr(fragment, 1, pos_pct + 1);
        couleur:=substr(fragment, pos_pct + 2);
        couleur_fmt:=translate(lower(replace(couleur, ' ', '_')), 'àÀäÄâÂéÉèÈëËêÊ', 'aaaaaaeeeeeeee');
        resultat:=val_pct || '<a href="lien_' || couleur_fmt || '.htm">' || couleur || '</a>';
 
		-- appel récursif sur la suite de la chaîne
        return resultat || val_virgule || bricole(suite);
end;
/

31/07/2009, 10h08
ajor

Whoa!
C'est encore plus compliqué que je croyais!

Merci beaucoup Pomalaix,

Et comment fait-on pour que cette opération se fasse sur toute une colonne d'une table ? (disons la colonne "Colour" de la table "T_Peinture")

Désolé je connais pas trop, j'ai appris que le SQL classique...

Une dernière précision : ma table contient environ 2000 enregistrements, c'est ok niveau lourdeur de requête ?
31/07/2009, 10h32
Pomalaix

Citation:

Envoyé par ajor

Et comment fait-on pour que cette opération se fasse sur toute une colonne d'une table ? (disons la colonne "Colour" de la table "T_Peinture")

Code:

SELECT bricole(colour) from t_peinture;

Bonjour,

C'est effectivement un peu compliqué.
J'ai essayé de le faire avec des expressions régulières, mais sans succès (je n'arrivais pas à modifier le texte pour obtenir le nom de la page).
Je pense que la solution la plus simple (en terme de lisibilité en tout cas) serait de faire ça en PL/SQL.

En SQL pur, j'ai réussi à le faire avec la requête suivante :

Code:

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
WITH v AS (SELECT 1 id, '95% Rouge, 5% Vert' col FROM dual UNION ALL
           SELECT 2 id, '100% Noir Bleuté' col FROM dual UNION ALL
           SELECT 3 id, '50% Vert Clair, 45% Vert Foncé, 5% Vert Bizarre' col FROM dual)
SELECT /* On reconcatène les différents enregistrements comme à l'origine */
        id, col,
       (   MAX(DECODE(num, 1, new_valeur))
        || MAX(DECODE(num, 2, ','||new_valeur))
        || MAX(DECODE(num, 3, ','||new_valeur))
        || MAX(DECODE(num, 4, ','||new_valeur))
        || MAX(DECODE(num, 5, ','||new_valeur))
        || MAX(DECODE(num, 6, ','||new_valeur))
        || MAX(DECODE(num, 7, ','||new_valeur))
        || MAX(DECODE(num, 8, ','||new_valeur))
        || MAX(DECODE(num, 9, ','||new_valeur))
        || MAX(DECODE(num, 10, ','||new_valeur)) ) new_col
FROM (/* On construit la nouvelle valeur */
      SELECT id, col,
             num,
             pct||' <a href="'||nom_page||'.htm">'||texte||'</a>' new_valeur
      FROM (/* On construit les différents éléments de la nouvelle valeur */
            SELECT id, col,
                   num,
                   SUBSTR(valeur, 1, instr(valeur, '%')) pct,
                   TRIM(SUBSTR(valeur, INSTR(valeur, '%')+1)) texte,
                   TRANSLATE(LOWER(TRIM(SUBSTR(valeur, INSTR(valeur, '%')+1))), ' éèêà', '_eeea') nom_page
            FROM (/* On découpe la chaine en plusieurs enregistrements */
                  SELECT id, col,
                         LEVEL num,
                         CASE WHEN LEVEL = 1 AND INSTR(v.col, ',', 1, LEVEL) = 0
                                THEN v.col
                              WHEN LEVEL = 1
                                THEN SUBSTR(v.col, 1, INSTR(v.col, ',', 1, LEVEL)-1)
                              WHEN INSTR(v.col, ',', 1, LEVEL) = 0
                                THEN SUBSTR(v.col,
                                            INSTR(v.col, ',', 1, LEVEL - 1) + 1)
                              ELSE SUBSTR(v.col,
                                          INSTR(v.col, ',', 1, LEVEL - 1) + 1,
                                          INSTR(v.col, ',', 1, LEVEL) - INSTR(v.col, ',', 1, LEVEL - 1) -1 )
                         END valeur
                  FROM v
                  CONNECT BY LEVEL <= ( LENGTH(v.col) - LENGTH(REPLACE(v.col,',')) + 1 )
            )
      )
)
GROUP BY id, col
ORDER BY id;
 
ID COL                                             NEW_COL
-- ----------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------
1  95% Rouge, 5% Vert                              95% <a href="rouge.htm">Rouge</a>, 5% <a href="vert.htm">Vert</a>
2  100% Noir Bleuté                                100% <a href="noir_bleute.htm">Noir Bleuté</a>
3  50% Vert Clair, 45% Vert Foncé, 5% Vert Bizarre 50% <a href="vert_clair.htm">Vert Clair</a>, 45% <a href="vert_fonce.htm">Vert Foncé</a>, 5% <a href="vert_bizarre.htm">Vert Bizarre</a>

Le principe consiste en gros à découper chaque chaine en plusieurs enregistrements en utilisant la virgule comme séparateur.
Ensuite on génère la nouvelle valeur pour chaque "enregistrement".
Enfin on reconcatène le tout. Ca fonctionne jusqu'à 10 couleurs. Si tu en veux plus, il faut continuer à copier/coller la partie de concaténation.

31/07/2009, 11h05
Pomalaix

Citation:

Envoyé par xdescamp

En SQL pur, j'ai réussi à le faire avec la requête suivante ...

:king: chapeau l'ami, ça c'est du grand art !!

Pour ajor : merci de ne pas lancer une même discussion à plusieurs endroits, comme vous l'avez fait ici :
http://www.developpez.net/forums/d78...cteres-oracle/
31/07/2009, 11h41
xdescamp

Citation:

Envoyé par Pomalaix

:king: chapeau l'ami, ça c'est du grand art !!

Merci :D
N'empêche que je ne voudrais être à la place du gars qui va récupérer ça le jour où il y a un problème! Ca a intérêt à être très bien commenté pour être maintenable.
31/07/2009, 12h59
ajor

merci xdescamp!

Désolé pour le double post, je pensais m'être trompé de forum, et j'ai oublié d'effacer le premier...

J'ai commencé avec la solution de Pomalaix, je continue donc la discussion ici:
http://www.developpez.net/forums/d78...cteres-oracle/
31/07/2009, 13h23
xdescamp

Citation:

Envoyé par ajor

merci xdescamp!
[...]
J'ai commencé avec la solution de Pomalaix, je continue donc la discussion ici

Bah tant pis. Ca m'aura quand même bien plu de me prendre un peu la tête sur ce problème.
31/07/2009, 14h23
ajor

Finalement, l'autre post redirige ici.
Encore désolé pour la confusion créé par ce double post...

Je viens d'essayer ta solution xdescamps, et elle fonctionne très bien aussi.
Excellent! J'avoue ne pas savoir ce qui est mieux entre SQL pur et le PL/SQL, mais ça fonctionne bien en tout cas

Je me demande juste comment adapter cette requête en update pour modifier la colonne "colour" de la table "t_peinture"

Tu peux faire qq chose comme ça :

Code:

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
Update t_peinture t_upd
Set colour = 
SELECT /* On reconcatène les différents enregistrements comme à l'origine */
       (   MAX(DECODE(num, 1, new_valeur))
        || MAX(DECODE(num, 2, ','||new_valeur))
        || MAX(DECODE(num, 3, ','||new_valeur))
        || MAX(DECODE(num, 4, ','||new_valeur))
        || MAX(DECODE(num, 5, ','||new_valeur))
        || MAX(DECODE(num, 6, ','||new_valeur))
        || MAX(DECODE(num, 7, ','||new_valeur))
        || MAX(DECODE(num, 8, ','||new_valeur))
        || MAX(DECODE(num, 9, ','||new_valeur))
        || MAX(DECODE(num, 10, ','||new_valeur)) ) new_col
FROM (/* On construit la nouvelle valeur */
      SELECT id, colour,
             num,
             pct||' <a href="'||nom_page||'.htm">'||texte||'</a>' new_valeur
      FROM (/* On construit les différents éléments de la nouvelle valeur */
            SELECT id, colour,
                   num,
                   SUBSTR(valeur, 1, instr(valeur, '%')) pct,
                   TRIM(SUBSTR(valeur, INSTR(valeur, '%')+1)) texte,
                   TRANSLATE(LOWER(TRIM(SUBSTR(valeur, INSTR(valeur, '%')+1))), ' éèêà', '_eeea') nom_page
            FROM (/* On découpe la chaine en plusieurs enregistrements */
                  SELECT id, colour,
                         LEVEL num,
                         CASE WHEN LEVEL = 1 AND INSTR(v.colour, ',', 1, LEVEL) = 0
                                THEN v.colour
                              WHEN LEVEL = 1
                                THEN SUBSTR(v.colour, 1, INSTR(v.colour, ',', 1, LEVEL)-1)
                              WHEN INSTR(v.colour, ',', 1, LEVEL) = 0
                                THEN SUBSTR(v.colour,
                                            INSTR(v.colour, ',', 1, LEVEL - 1) + 1)
                              ELSE SUBSTR(v.colour,
                                          INSTR(v.colour, ',', 1, LEVEL - 1) + 1,
                                          INSTR(v.colour, ',', 1, LEVEL) - INSTR(v.colour, ',', 1, LEVEL - 1) -1 )
                         END valeur
                  FROM t_peinture v
                  CONNECT BY LEVEL <= ( LENGTH(v.colour) - LENGTH(REPLACE(v.colour,',')) + 1 )
            )
      )
)
Where id = t_upd.id
GROUP BY id, col;

Il faut juste que tu fasses la jointure avec une clé unique de ta table (partout où j'ai utilisé la colonne ID).

31/07/2009, 15h27
ajor

Merci de répondre si vite!

Pourquoi as-tu ajouté une table t_upd ?
Je ne comprend pas ce qu'elle vient faire ici...

La seule table que j'ai c'est t_peinture
les colonnes de cette table sont : id_peinture, colour, brillance, prix, etc...

Je ne comprend pas cette histoire de jointure, peux-tu préciser...?!

Je suis vraiment déçu qu'Oracle n'arrive pas à appliquer de fonction aux backreferences des expressions régulières, cette requête aurait répondu au besoin :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
WITH tab AS
(
select '95% Rouge, 5% Vert'                       as fld from dual union all
select '100% Noir Bleuté'                                from dual union all
select '50% Vert Clair, 45% Vert Foncé, 5% Vert Bizarre' from dual
)
select
    fld,
    replace(convert(lower(fld),'US7ASCII'), ' ', '_') as lien,
    regexp_replace(
        fld,
        '([[:digit:]]*)%[[:blank:]]([[:alpha:]]+[[:blank:]]*[[:alpha:]]*)(,|$)',
        '\1% <a href="lien_' || replace(convert(lower('\2'),'US7ASCII'), ' ', '_') || '.htm">\2</a>\3'
                  ) as result
from tab;

Vous pourrez peut-être toujours utiliser ceci pour mettre vos liens en miniscule sans accent :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
WITH tab AS
(
select 'Rouge' as clr from dual union all
select 'Vert'         from dual union all
select 'Noir Bleuté'  from dual union all
select 'Vert Clair'   from dual union all
select 'Vert Foncé'   from dual union all
select 'Vert Bizarre' from dual
)
select clr, replace(convert(lower(clr),'US7ASCII'), ' ', '_') replace
from tab;
 
CLR		REPLACE
Rouge		rouge
Vert		vert
Noir Bleuté	noir_bleute
Vert Clair	vert_clair
Vert Foncé	vert_fonce
Vert Bizarre	vert_bizarre

On peut se débrouiller en faisant comme les méthodes précédentes mais toujours en utilisant les expressions régulières, qui sont peut-être un peu plus compliquées à écrire mais probablement plus souple :

Code:

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
WITH tab AS
(
select 1 as id, '95% Rouge, 5% Vert'                       as fld from dual union all
select 2      , '100% Noir Bleuté'                                from dual union all
select 3      , '50% Vert Clair, 45% Vert Foncé, 5% Vert Bizarre' from dual union all
select 4      , '7% Parmé, 9% Orangé, 8% Bleu cyan, 11% Caramel, ' ||
                '2% Fuchsia, 1% Orangina, 5% Grenadine, 3% Jaunis, ' ||
                '6% Ambré, 1% Châtaigne, 7% Lacté, 10% Réglisse, ' ||
                '5% Albâtre, 3% Céruse, 2% Aile de corbeau, 4% Ébène, ' ||
                '5% Violet d''Évêque, 11% Purpuracé' from dual
),  cpt AS
(
select level i from dual
connect by level <= (select max(regexp_count(fld, ','))+1 from tab)
), words AS
(
select
    id, i,
    regexp_substr(tab.fld, '([[:blank:]]?[[:alnum:]]*)% ', 1, i, 'c') as prc,
    regexp_substr(tab.fld, '([[:alpha:]]+(''*[[:blank:]]*[[:alpha:]]*)*)', 1, i, 'c') as clr,
    regexp_substr(tab.fld, '(,|$)', 1, i, 'c') as fin
from
    tab cross join cpt
where
    regexp_substr(tab.fld, '([[:alpha:]]+(''*[[:blank:]]*[[:alpha:]]*)*)', 1, i, 'c') is not null
), aggr AS
(
select
    id, i,
    prc || '<a href="lien_' || translate(convert(lower(clr),'US7ASCII'), ' ''', '__') || '.htm">' || clr || '</a>' as link
from
    words
)
    select id,
           ltrim(max(sys_connect_by_path(link,',')),',') as rslt
      from aggr
  group by id
START with i = 1
CONNECT by i-1 = prior i
       and  id = prior id
  order by id asc;
 
ID	RSLT
1	95% <a href="lien_rouge.htm">Rouge</a>, 5% <a href="lien_vert.htm">Vert</a>
2	100% <a href="lien_noir_bleute.htm">Noir Bleuté</a>
3	50% <a href="lien_vert_clair.htm">Vert Clair</a>, 45% <a href="lien_vert_fonce.htm">Vert Foncé</a>, 5% <a href="lien_vert_bizarre.htm">Vert Bizarre</a>
4	7% <a href="lien_parme.htm">Parmé</a>, 9% <a href="lien_orange.htm">Orangé</a>, 8% <a href="lien_bleu_cyan.htm">Bleu cyan</a>, 11% <a href="lien_caramel.htm">Caramel</a>, 2% <a href="lien_fuchsia.htm">Fuchsia</a>, 1% <a href="lien_orangina.htm">Orangina</a>, 5% <a href="lien_grenadine.htm">Grenadine</a>, 3% <a href="lien_jaunis.htm">Jaunis</a>, 6% <a href="lien_ambre.htm">Ambré</a>, 1% <a href="lien_chataigne.htm">Châtaigne</a>, 7% <a href="lien_lacte.htm">Lacté</a>, 10% <a href="lien_reglisse.htm">Réglisse</a>, 5% <a href="lien_albatre.htm">Albâtre</a>, 3% <a href="lien_ceruse.htm">Céruse</a>, 2% <a href="lien_aile_de_corbeau.htm">Aile de corbeau</a>, 4% <a href="lien_ebene.htm">Ébène</a>, 5% <a href="lien_violet_d_eveque.htm">Violet d'Évêque</a>, 11% <a href="lien_purpurace.htm">Purpuracé</a>

Pour le String Aggregation j'ai utilisé la méthode du connect by, qui permet plus de couleurs que le max(decode).

Edit : Dans cette solution j'ai utilisé la fonction regexp_count qui est disponible à partir de 11g (je précise car l'auteur est en 10g).

Citation:

Envoyé par Waldar

Vous pourrez peut-être toujours utiliser ceci pour mettre vos liens en miniscule sans accent ...

Attention, CONVERT vers US7ASCII n'est pas une panacée et ne fonctionnera correctement que si le jeu de caractères source s'y prête.
Sur une base en WE8MSWIN1252, ça donne ça :
Code:

1 2 3 4 5 6 7 8 CLR REPLACE ------------ ------------------------------------------------------------ Rouge rouge Vert vert Noir Bleuté noir_bleut? Vert Clair vert_clair Vert Foncé vert_fonc? Vert Bizarre vert_bizarre

11/08/2009, 22h55
xdescamp

Citation:

Envoyé par Waldar

Je suis vraiment déçu qu'Oracle n'arrive pas à appliquer de fonction aux backreferences des expressions régulières

Je pense qu'il peut le faire. Par contre, de ce que j'ai pu voir, "\1" représente la première occurrence de la chaîne recherchée, ce qui correspondrait au texte complet dans ton test, et non pas une décomposition en différents éléments.

Citation:

Envoyé par Waldar

On peut se débrouiller en faisant comme les méthodes précédentes mais toujours en utilisant les expressions régulières, qui sont peut-être un peu plus compliquées à écrire mais probablement plus souple :
...
Pour le String Aggregation j'ai utilisé la méthode du connect by, qui permet plus de couleurs que le max(decode).

Grand bravo! J'aime beaucoup la reconcaténation :ccool:
12/08/2009, 00h29
Waldar

Citation:

Envoyé par xdescamp

Je pense qu'il peut le faire.

Malheuresement non, il y a plusieurs sujet sur ce point précis.
C'est du au fait que lorsque qu'on écrit upper('\2'), Oracle converti la chaîne '\2' en majuscule, la backreference n'était pas encore évaluée si j'ai bien saisi le fonctionnement.
Tient ça me donne une idée.

Citation:

Envoyé par xdescamp

Par contre, de ce que j'ai pu voir, "\1" représente la première occurrence de la chaîne recherchée, ce qui correspondrait au texte complet dans ton test, et non pas une décomposition en différents éléments.

Non plus :)
Les \1, \2... \9 représentent le nombre d'éléments variables mis entre parenthèses.
C'est une règle propre aux expressions régulières :
http://www.regular-expressions.info/brackets.html

Citation:

Envoyé par xdescamp

Grand bravo! J'aime beaucoup la reconcaténation :ccool:

Vivement qu'Oracle officialise wm_concat !
Il faut faire attention au point souligné par Pomalaix quand même au niveau du translate (j'avais chippé ce tip chez LaurentSchneider, je le dénonce maintenant que je suis pris en défaut !)

Bonjour à tous,

Merci beaucoup pour vos réponses!

Je suis parti sur cette solution (qui fonctionne très bien pour mon cas):

Code:

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
CREATE OR REPLACE FUNCTION bricole(liste varchar2) RETURN varchar2
IS
        fragment        varchar2(4000);
        pos_virgule     number(4);
        val_virgule 	varchar2(2);
        suite           varchar2(4000);
        pos_pct         number(4);
        val_pct         varchar2(10);
        couleur         varchar2(30);
        couleur_fmt 	varchar2(30);
        resultat        varchar2(4000);
 
begin
        -- condition de terminaison
        IF liste IS NULL then
                RETURN '';
        end IF;
 
        -- découpage
        pos_virgule:=instr(liste, ',');
		IF pos_virgule=0 then
			pos_virgule:=length(liste) + 1;
		end IF;
		fragment:=substr(liste, 1, pos_virgule-1);
		-- on ne prend ni la virgule, ni l'espace qui la suit
		suite:=substr(liste, pos_virgule + 2);
		IF suite IS NOT NULL then
			val_virgule:=', ';
		else
			val_virgule := '';
		end IF;
 
        -- traitement du premier fragment
        pos_pct:=instr(fragment, '%');
        val_pct:=substr(fragment, 1, pos_pct + 1);
        couleur:=substr(fragment, pos_pct + 2);
        couleur_fmt:=translate(lower(REPLACE(couleur, ' ', '-')), 'àÀäÄâÂéÉèÈëËêÊ', 'aaaaaaeeeeeeee');
        resultat:=val_pct || '<a href="lien_' || couleur_fmt || '.htm">' || couleur || '</a>';
 
		-- appel récursif sur la suite de la chaîne
        RETURN resultat || val_virgule || bricole(suite);
end;

Cela dit, il arrive que certains de mes enregistrements ne possèdent pas de pourcentage.
Exemple: 15% Bleu, Vert grisé
Vert, Jaune, Rouge
50% Noir, Gris clair, Bleu turquoize...

Comment gérer ces cas-là? Avez-vous une idée ?