regexp_replace tout sauf un mot spécifique

Bonjour tout le monde,
J'ai l'honneur d'avoir venu appeler à vos compétences.
En bref; en utilisant des expressions régulières je replacer tous les mot &caractères à part un mot spécifique.

exp:

Code:

---

select regexp_replace( 'totoA , totoA autreMot, UnMot totoA autttttreMot, unMot totoMotCollé', ......sauf totoA.......... ,'@' ) from dual

---

Résultat

Code:

---

totoA @ totoA @ @ totoA @ @

---

Merci pour vos collaborations.

Puisque d'après ton exemple la virgule semble être remplacée, on va utiliser "mot" dans le sens de "suite de caractères imprimables et non blanc" (ce qui exclu, les caractères blancs comme l'espace, la tabulation, le retour chariot, le saut de ligne, etc., et les caractères de contrôle.)

Les regex POSIX offrent assez peu d'éléments de vocabulaire pour pouvoir exprimer facilement la négation d'une suite de caractères. On pourrait jouer avec des négations de classes de caractères, mais cette technique devient vite très fastidieuse quand le mot à éviter est long. Un exemple de cette technique avec le mot à éviter "abc":

Code:

---

(^|[^[:graph:]])([[:graph:]]{1,2}|[[:graph:]]{4,}|[^[:space:][:cntrl:]a][[:graph:]]{2}|a[^[:space:][:cntrl:]b][[:graph:]]|ab[^[:space:][:cntrl:]c])([^[:graph:]|$)

---

La première partie (^|[^[:graph:]]) et la dernière partie ([^[:graph:]|$) font office de word boundaries pour être sûr que les limites du "mot" sont atteintes. La partie du milieu décrit les différents "mots" possible:

• les "mots" d'un ou deux caractères [[:graph:]]{1,2}
• les "mots" de quatre caractères ou plus [[:graph:]]{4,}
• les "mots" de trois caractères ne commençant pas par "a" [^[:space:][:cntrl:]a][[:graph:]]{2}
• les "mots" de trois caractères commençant par "a" mais non suivi de "b" a[^[:space:][:cntrl:]b][[:graph:]]
• les "mots" de trois caractères commençant par "ab" mais non suivi de "c" ab[^[:space:][:cntrl:]c]

Voilà, pour trois malheureuses lettres on obtient une pattern de trois kilomètres ce qui déjà ne simplifie pas la mise en pratique, mais qui en plus est inutilisable dans le cadre d'une recherche globale car les limites des mots qui se suivent risquent de se chevaucher. (par exemple avec la chaîne 'def ghi' seul 'def ' sera trouvé mais pas 'ghi' car l'espace entre les deux mots est déjà consommé par la première correspondance.)

Cette voie est donc à exclure.

Une autre solution est de définir un "mot" à remplacer dans son contexte:

Citation:

---

Un mot à remplacer peut être précédé de zéro ou plusieurs "totoA" (séparés de caractères non-imprimables) et peut être suivi d'un ou plusieurs "totoA" jusqu'à la fin de la chaîne.

---

Avec une telle définition, il ne s'agit plus d'éviter le mot "totoA", mais au contraire de l'incorporer dans la pattern, ce qui donne:

Code:

---

((totoA[^[:graph:]]+)*)[[:graph:]]+(([^[:graph:]]+totoA)+[^[:graph:]]*$)?

---

((totoA[^[:graph:]]+)*) capture les "totoA" précédents dans le groupe 1.
(([^[:graph:]]+totoA)+[^[:graph:]]*$)? capture les éventuels "totoA" jusqu'à la fin dans le groupe 3.

Il suffit alors de placer les références à ces groupes dans la chaîne de remplacement, ce qui donne \1@\3:

Code:

---

regexp_replace('totoA , totoA autreMot, UnMot totoA autttttreMot, unMot totoMotCollé', '((totoA[^[:graph:]]+)*)[[:graph:]]+(([^[:graph:]]+totoA)+[^[:graph:]]*$)?', '\1@\3')

---

MerciCosmoKnacki ;c'est ce que je cherchais.:king:

J'ai pu l'adapté pour mon cas.
MAIS....

Je contrétise mon cas;
J'ai des chaines de caractères de type CLOB qui comporte des requêtes SQL:

exemple:

Code:

---

'AAA=bbb;select col1,col2 FROMla_table1; CCC; DDDDDDD;select col1,col2 from la_table2;select col1,col2,col3 From la_table3,ta_table4 ....'

---

mon but est d'extraire toutes les tables figurant dans la chaine donnée.

Résultat souhaité:

Code:

---

la_table1 la_table2 la_table3,ta_table4

---

Je ai pu extrait toutes les tables dont le mot from qui suivent un espace en utilisant:

Code:

---

regexp_replace(upper(Le_Text),'((((FROM)\s+[^[:space:]]+)[^[:graph:]]+)*)[[:graph:]]+(([^[:graph:]]+((FROM)\s+[^[:space:]]+))+[^[:graph:]]*$)?', '\1\3')

---

NB:Si le mot from suit un point-virgule, l'expression ne me donne pas un bon résultat.

Dans ce cas, la situation est un peu différente car les mots à conserver ne sont pas définis, par contre ils sont repérables car toujours situés après l'instruction FROM^(*) et éventuellement séparés par des virgules quand il y en a plusieurs. Contrairement au cas précédent, les FROM table1 ne peuvent pas se succéder, il est donc inutile de répéter le groupe contenant FROM et les noms de table. Aussi vu que l'on sait à quel type de chaîne on a à faire, on peut être un peu plus explicite avec les classes de caractères utilisées.

On peut décrire le nom d'une table comme une suite de caractères n'ayant ni espaces, ni virgules, ni point-virgules: [^ ;,]+
Donc un ou plusieurs noms de table séparés par des virgules: [^ ;,]+( *, *[^ ;,]+)*
On capture l'ensemble de ces noms de table et on place un FROM devant: FROM +([^ ;,]+( *, *[^ ;,]+)*)
Reste donc a construire l'expression avec ces éléments comme précédemment:

Code:

---

( +FROM( ) *([^ ;,]+( *, *[^ ;,]+)*) *;?)? *[^ ]+( +FROM +([^ ;,]+( *, *[^ ;,]+)*)[ ;]*$)?

---

À noter la ruse pour récupérer un espace dans le groupe 2 juste après le premier FROM pour en disposer quand on en a besoin. Malheureusement même de cette manière, il n'est pas possible d'éviter tous les espaces inutiles.


Ce qui donne:

Code:

---

regexp_replace(upper(Le_Text), '( +FROM( ) *([^ ;,]+( *, *[^ ;,]+)*) *;?)? *[^ ]+( +FROM +([^ ;,]+( *, *[^ ;,]+)*)[ ;]*$)?', '\3\2\6')

---

_{(*) On part du principe que FROM est toujours suivi d'un ou plusieurs noms de tables et que la chaîne ne contient que des requêtes basiques. Ce n'est pas forcément le cas, par exemple FROM pourrait être suivi d'un nom d'utilisateur ou de rôle lors d'une modification de privilèges ou encore de la pseudo table DUAL lors d'un calcul. Autre chose, un nom de table peut très bien être suivi d'une définition d'alias: FROM table1 AS toto, table2 t2. L'expression précédente ne gère pas ces cas et, à vrai dire, les gérer n'est plus du ressort des expressions régulières mais d'une analyse syntaxique du langage SQL.}

Ca marche très bien.
sauf que l'expression règulière extrait meme les table de la requete

Code:

---

delete from la_table

---

Si tu veux que ça ne concerne que les requêtes SELECT il suffit de le préciser en remplaçant ' +FROM' par SELECT[^;]+ FROM

Ca n'a pas marché cette dernière, en grosso-modo j'ai appris l'astuce. merci:king: