Classes de caractères

Les classes de caractères spécifient les caractères que vous essayez ou n'essayez pas de mettre en correspondance. Veillez à remplacer . dans votre .*s par un caractère plus spécifique. Le .* va invariablement atteindre la fin de l'entrée puis revenir en arrière, c'est-à-dire à l'état précédemment enregistré pour poursuivre la recherche d'une correspondance. Lorsque vous utilisez une classe de caractères spécifique, vous contrôlez le nombre de caractères que le * va faire consommer au moteur d'expressions rationnelles, ce qui vous permet d'arrêter les retours en arrière incontrôlables.

Prenons l'exemple d'expression rationnelle 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 :

Comme résultat de l'expression rationnelle spécifiée, la mise en correspondance entraînerait un retour en arrière. Cette situation est détectée par Oracle Logging Analytics et l'opération de mise en correspondance est abandonnée.

En remplaçant l'expression rationnelle par l'exemple ci-dessous, vous pouvez vous assurer que la mise en correspondance est plus rapide. Notez que [\S\s]* est remplacée par [^,], ce qui évite le retour arrière inutile.

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

Quantificateurs paresseux

Dans de nombreuses expressions rationnelles, les quantificateurs gourmands (.*s) peuvent être remplacés par des quantificateurs paresseux (.*?s), ce qui améliore la performance de l'expression rationnelle sans modifier le résultat.

Prenons l'entrée :

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)

Examinons l'expression rationnelle gourmande suivante pour l'entrée indiqué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'expressions rationnelles atteint la fin de l'entrée chaque fois qu'il détecte .*.. La première fois que la valeur .* apparaît, elle consomme toutes les entrées, puis revient en arrière jusqu'à ORACLE_HOME. Il s'agit d'une méthode de mise en correspondance inefficace. L'expression rationnelle paresseuse alternative est présentée ci-dessous :

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 rationnelle paresseuse ci-dessus consomme du début de la chaîne jusqu'à ORACLE_HOME où elle pourra poursuivre la mise en correspondance du reste de la chaîne.

Note : Si le champ ORACLE_HOME apparaît vers le début de l'entrée, le quantificateur paresseux doit être utilisé. Si le champ ORACLE_HOME apparaît vers la fin, il peut être judicieux d'utiliser le quantificateur gourmand.

Ancres

Les ancres indiquent au moteur d'expressions rationnelles que vous voulez placer le curseur à un endroit particulier dans l'entrée. Les ancres les plus courantes sont ^ et $, indiquant le début et la fin de l'entrée.

Examinons les expressions rationnelles 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}

Notez que la deuxième expression rationnelle commence par ^ et qu'elle est donc spécifique de l'adresse IP qui apparaît au début de l'entrée.

Nous recherchons dans l'entrée l'expression rationnelle 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 sans correspondance ressemble à 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 rationnelle (qui commence par ^) s'exécute plus rapidement sur l'entrée non correspondante car elle l'ignore immédiatement.

L'importance de l'ordre

L'ordre étant important, vous devez placer les options les plus courantes au début pour qu'elles puissent trouver une correspondance plus rapidement. Si les options plus rares sont devant, le moteur d'expressions rationnelles va perdre du temps à les vérifier avant de traiter les options plus courantes qui ont plus de chance de succès. Par ailleurs, essayez d'extraire les modèles courants. Par exemple, au lieu de (abcd|abef), utilisez ab(cd|ef).

Observons les expressions rationnelles suivantes :

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

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

Dans l'entrée suivante :

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

La deuxième expression rationnelle correspond plus rapidement car l'alternance recherche d'abord le caractère [, suivi d'une valeur nulle. Comme l'entrée contient [, la mise en correspondance s'exécute plus rapidement.