Classes de caractères

Les classes de caractères spécifient les caractères que vous essayez ou non de mettre en correspondance. Veillez à remplacer . dans .*s par un caractère plus spécifique. La partie .* passe invariablement à la fin de votre entrée, puis revient à l'état précédemment enregistré pour poursuivre la recherche de correspondance. Si vous utilisez une classe de caractères, vous contrôlez le nombre de caractères que le moteur d'expression régulière consommera grâce à *, vous donnant la possibilité d'arrêter le retour en arrière incontrôlé.

Prenons l'exemple d'expression régulière suivant :

(\d{4})(\d{2})(\d{2}),(\S+),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([\S\s]*),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+)

Pour l'entrée suivante :

Du fait de l'expression régulière spécifiée, la correspondance peut subir des retours en arrière. Cette situation est détectée par Oracle Logging Analytics et l'opération de correspondance est abandonnée.

En remplaçant l'expression régulière par l'exemple ci-dessous, vous pouvez vous assurer que la mise en correspondance se termine plus rapidement. Nous remplaçons [\S\s]* par [^,], ce qui évite tout retour en arrière inutile.

(\d{4})(\d{2})(\d{2}),(\S+),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+),([0-9.]+)

Quantificateurs lazy

Dans de nombreuses expressions régulières, les quantificateurs à consommation importante de ressources (.*s) peuvent être remplacés sans encombres par des quantificateurs lazy (.*?s), augmentant ainsi les performances de l'expression régulière sans modifier le résultat.

Prenons l'entrée suivante :

Trace file /u01/app/oracle/diag/rdbms/navisdb/NAVISDB/trace/NAVISDB_arc0_3941.trc
Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - 64bit Production
With the Partitioning, OLAP, Data Mining and Real Application Testing options
ORACLE_HOME = /u01/app/oracle/product/11.2.0/db_1
System name: Linux
Node name: NAVISDB
Release: 2.6.18-308.el5
Version: #1 SMP Fri Jan 27 17:17:51 EST 2012
Machine: x86_64
Instance name: NAVISDB
Redo thread mounted by this instance: 1
Oracle process number: 21
Unix process pid: 3941, image: oracle@NAVISDB (ARC0)

Prenons également l'expression régulière à consommation importante de ressources ci-dessous pour l'entrée donnée :

Trace\sfile\s(\S*).*ORACLE_HOME\s*[:=]\s*(\S*).*System\sname:\s*(\S*).*Node\sname:\s*(\S*).*Release:\s*(\S*).*Machine:\s*(\S*).*Instance\sname:\s*(\S*).*Redo\sthread\smounted\sby\sthis\sinstance:\s(\d*).*Oracle\sprocess\snumber:\s*(\d*).*Unix\sprocess\spid:\s(\d*).*image:\s+([^\n\r]*)

Le moteur d'expression régulière est renvoyé à la fin de l'entrée chaque fois qu'il rencontre .*.. La première fois que .* apparaît, il consomme toute l'entrée, puis revient en arrière jusqu'à atteindre ORACLE_HOME. Cette méthode de correspondance n'est pas efficace. L'expression régulière lazy alternative est la suivante :

Trace\sfileRelease:\s*(\S*).*?Machine:\s*(\S*).*?Instance\sname:\s*(\S*).*?Redo\sthread\smounted\sby\sthis\sinstance:\s(\d*).*?Oracle\sprocess\snumber:\s*(\d*).*?Unix\sprocess\spid:\s(\d*).*?image:\s+([^\n\r]*)

L'expression régulière lazy ci-dessus est lue à partir du début de la chaîne jusqu'à ORACLE_HOME, point auquel elle peut alors mettre en correspondance le reste de la chaîne.

Remarque : si le champ ORACLE_HOME dans les débuts de l'entrée, le quantificateur lazy doit être utilisé. Si le champ ORACLE_HOME apparaît vers la fin, il conviendrait d'utiliser le quantificateur à consommation importante de ressources.

Ancrages

Les ancrages indiquent au moteur d'expression régulière que vous comptez placer le curseur à un endroit particulier dans l'entrée. Les ancrages les plus courants sont ^ et $, indiquant le début et la fin de l'entrée.

Prenons les expressions régulières suivantes pour rechercher une adresse IPv4 :

\d{1,3}\.d{1,3}.\d{1,3}.\d{1,3}

^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}

La deuxième expression régulière commence par ^ et est spécifique de l'adresse IP qui apparaît au début de l'entrée.

Nous recherchons l'expression régulière dans l'entrée qui ressemble à l'exemple suivant :

107.21.20.1 - - [07/Dec/2012:18:55:53 -0500] "GET
      /extension/bsupport/design/cl/images/btn_letschat.png HTTP/1.1" 200
    2144

Une entrée non correspondante ressemblerait à l'exemple suivant :

[07/Dec/2012:23:57:13 +0000] 1354924633 GET "/favicon.ico" "" HTTP/1.1 200 82726 "-"
      "ELB-HealthChecker/1.0"

La deuxième expression régulière (commençant par ^) est exécutée plus rapidement sur l'entrée non correspondante car elle l'annule instantanément.

Importance de l'alternance

L'ordre d'alternance a une importance. Placez donc les options les plus courantes en premier pour qu'elles puissent être mises en correspondances plus rapidement. Si les options les plus rares apparaissent en premier, le moteur d'expression régulière perd du temps à les vérifier avant de vérifier les plus courantes, qui sont plus susceptibles de réussir. Essayez également d'extraire des modèles courants. Par exemple, au lieu de (abcd|abef), utilisez ab(cd|ef).

Observez les expressions régulières suivantes :

{TIMEDATE}\s{0,1}:\s*(?:|\[)(\w+)(?:\:|\])(?:\[|)(\d+)(?:\:|\])(.{1,1000}).*

{TIMEDATE}\s{0,1}:\s*(?:\[|)(\w+)(?:\:|\])(?:\[|)(\d+)(?:\:|\])(.{1,1000}).*

Sur l'entrée suivante :

2014-06-16 12:13:46.743: [UiServer][1166092608] {0:7:2} Done for
ctx=0x2aaab45d8330

La deuxième expression régulière est mise en correspondance plus rapidement lorsque l'alternance cherche le caractère [ en premier, suivi de null. La correspondance est plus rapide car l'entrée possède le caractère [.