> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-fbfa8bee.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Disposition de dictionnaire en arbre d’expressions régulières
> Configurez une disposition de dictionnaire en arbre d’expressions régulières pour des recherches par motif.
export const CloudNotSupportedBadge = () => {
return
Non pris en charge par ClickHouse Cloud
;
};
## Vue d’ensemble
Le dictionnaire `regexp_tree` vous permet d’associer des clés à des valeurs à partir de motifs hiérarchiques d’expressions régulières.
Il est optimisé pour les recherches par correspondance de motifs (par exemple, pour classer des chaînes telles que des chaînes user agent en faisant correspondre des motifs regex) plutôt que pour la correspondance exacte des clés.
## Utiliser le dictionnaire en arbre d’expressions régulières avec la source YAMLRegExpTree
Les dictionnaires en arbre d’expressions régulières sont définis dans la version open-source de ClickHouse à l’aide de la source [`YAMLRegExpTree`](/fr/reference/statements/create/dictionary/sources/yamlregexptree), à laquelle on fournit le chemin d’accès vers un fichier YAML contenant l’arborescence d’expressions régulières.
```sql title="Query" theme={null}
CREATE DICTIONARY regexp_dict
(
regexp String,
name String,
version String
)
PRIMARY KEY(regexp)
SOURCE(YAMLRegExpTree(PATH '/var/lib/clickhouse/user_files/regexp_tree.yaml'))
LAYOUT(regexp_tree)
...
```
La source de dictionnaire [`YAMLRegExpTree`](/fr/reference/statements/create/dictionary/sources/yamlregexptree) représente la structure d’un arbre regexp. Par exemple :
```yaml theme={null}
- regexp: 'Linux/(\d+[\.\d]*).+tlinux'
name: 'TencentOS'
version: '\1'
- regexp: '\d+/tclwebkit(?:\d+[\.\d]*)'
name: 'Android'
versions:
- regexp: '33/tclwebkit'
version: '13'
- regexp: '3[12]/tclwebkit'
version: '12'
- regexp: '30/tclwebkit'
version: '11'
- regexp: '29/tclwebkit'
version: '10'
```
Cette configuration se compose d’une liste de nœuds d’arbre d’expressions régulières. Chaque nœud a la structure suivante :
* **regexp** : l’expression régulière du nœud.
* **attributes** : une liste d’attributs de dictionnaire définis par l’utilisateur. Dans cet exemple, il y a deux attributs : `name` et `version`. Le premier nœud définit les deux attributs. Le second nœud ne définit que l’attribut `name`. L’attribut `version` est fourni par les nœuds enfants du second nœud.
* La valeur d’un attribut peut contenir des **références arrière**, qui renvoient à des groupes de capture de l’expression régulière correspondante. Dans l’exemple, la valeur de l’attribut `version` dans le premier nœud se compose d’une référence arrière `\1` vers le groupe de capture `(\d+[\.\d]*)` de l’expression régulière. Les numéros de référence arrière vont de 1 à 9 et s’écrivent `$1` ou `\1` (pour le numéro 1). La référence arrière est remplacée par le groupe de capture correspondant lors de l’exécution de la requête.
* **child nodes** : une liste de nœuds enfants d’un nœud d’arbre regexp, chacun ayant ses propres attributs et, éventuellement, ses propres nœuds enfants. La recherche de correspondance dans les chaînes se fait en parcours en profondeur. Si une chaîne correspond à un nœud regexp, le dictionnaire vérifie si elle correspond aussi aux nœuds enfants de ce nœud. Si c’est le cas, les attributs du nœud correspondant le plus profond sont attribués. Les attributs d’un nœud enfant remplacent les attributs de même nom des nœuds parents. Dans les fichiers YAML, le nom des nœuds enfants peut être arbitraire, par exemple `versions` dans l’exemple ci-dessus.
Les dictionnaires en arbre d’expressions régulières n’autorisent l’accès qu’au moyen des fonctions `dictGet`, `dictGetOrDefault` et `dictGetAll`. Par exemple :
```sql title="Query" theme={null}
SELECT dictGet('regexp_dict', ('name', 'version'), '31/tclwebkit1024');
```
```text title="Response" theme={null}
┌─dictGet('regexp_dict', ('name', 'version'), '31/tclwebkit1024')─┐
│ ('Android','12') │
└─────────────────────────────────────────────────────────────────┘
```
Dans ce cas, on commence par faire correspondre l’expression régulière `\d+/tclwebkit(?:\d+[\.\d]*)` dans le deuxième nœud de la couche supérieure.
Le dictionnaire poursuit ensuite la recherche dans les nœuds enfants et constate que la chaîne correspond également à `3[12]/tclwebkit`.
Par conséquent, la valeur de l’attribut `name` est `Android` (définie dans la première couche) et la valeur de l’attribut `version` est `12` (définie dans le nœud enfant).
À l’aide d’un fichier de configuration YAML sophistiqué, vous pouvez utiliser des dictionnaires regexp en arborescence comme parseur de chaînes user agent.
ClickHouse prend en charge [uap-core](https://github.com/ua-parser/uap-core) et vous pouvez voir comment l’utiliser dans le test fonctionnel [02504\_regexp\_dictionary\_ua\_parser](https://github.com/ClickHouse/ClickHouse/blob/master/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh)
### Récupération des valeurs d’attribut
Il est parfois utile de renvoyer les valeurs de plusieurs expressions régulières correspondantes, plutôt que la seule valeur d’un nœud feuille. Dans ce cas, la fonction spécialisée [`dictGetAll`](/fr/reference/functions/regular-functions/ext-dict-functions#dictGetAll) peut être utilisée. Si un nœud possède une valeur d’attribut de type `T`, `dictGetAll` retourne un `Array(T)` contenant zéro, une ou plusieurs valeurs.
Par défaut, le nombre de correspondances renvoyées par clé n’est pas limité. Une limite peut être passée en quatrième argument facultatif à `dictGetAll`. Le tableau est rempli dans un *ordre topologique*, ce qui signifie que les nœuds enfants précèdent les nœuds parents et que les nœuds frères suivent l’ordre dans la source.
Exemple :
```sql theme={null}
CREATE DICTIONARY regexp_dict
(
regexp String,
tag String,
topological_index Int64,
captured Nullable(String),
parent String
)
PRIMARY KEY(regexp)
SOURCE(YAMLRegExpTree(PATH '/var/lib/clickhouse/user_files/regexp_tree.yaml'))
LAYOUT(regexp_tree)
LIFETIME(0)
```
```yaml theme={null}
# /var/lib/clickhouse/user_files/regexp_tree.yaml
- regexp: 'clickhouse\.com'
tag: 'ClickHouse'
topological_index: 1
paths:
- regexp: 'clickhouse\.com/docs(.*)'
tag: 'ClickHouse Documentation'
topological_index: 0
captured: '\1'
parent: 'ClickHouse'
- regexp: '/docs(/|$)'
tag: 'Documentation'
topological_index: 2
- regexp: 'github.com'
tag: 'GitHub'
topological_index: 3
captured: 'NULL'
```
```sql title="Query" theme={null}
CREATE TABLE urls (url String) ENGINE=MergeTree ORDER BY url;
INSERT INTO urls VALUES ('clickhouse.com'), ('clickhouse.com/docs/en'), ('github.com/clickhouse/tree/master/docs');
SELECT url, dictGetAll('regexp_dict', ('tag', 'topological_index', 'captured', 'parent'), url, 2) FROM urls;
```
```text title="Response" theme={null}
┌─url────────────────────────────────────┬─dictGetAll('regexp_dict', ('tag', 'topological_index', 'captured', 'parent'), url, 2)─┐
│ clickhouse.com │ (['ClickHouse'],[1],[],[]) │
│ clickhouse.com/docs/en │ (['ClickHouse Documentation','ClickHouse'],[0,1],['/en'],['ClickHouse']) │
│ github.com/clickhouse/tree/master/docs │ (['Documentation','GitHub'],[2,3],[NULL],[]) │
└────────────────────────────────────────┴───────────────────────────────────────────────────────────────────────────────────────┘
```
### Modes de correspondance
Le comportement de la correspondance de motifs peut être modifié à l’aide de certains paramètres du dictionnaire :
* `regexp_dict_flag_case_insensitive` : utilise une correspondance insensible à la casse (par défaut `false`). Peut être redéfini dans des expressions individuelles avec `(?i)` et `(?-i)`.
* `regexp_dict_flag_dotall` : autorise `.` à correspondre aux caractères de saut de ligne (par défaut `false`).
## Utiliser un dictionnaire en arbre d'expressions régulières dans ClickHouse Cloud
La source [`YAMLRegExpTree`](/fr/reference/statements/create/dictionary/sources/yamlregexptree) fonctionne dans ClickHouse Open Source, mais pas dans ClickHouse Cloud.
Pour utiliser des dictionnaires en arbre d'expressions régulières dans ClickHouse Cloud, créez d'abord localement, dans ClickHouse Open Source, un dictionnaire en arbre d'expressions régulières à partir d'un fichier YAML, puis exportez ce dictionnaire vers un fichier CSV à l'aide de la fonction de table `dictionary` et de la clause [INTO OUTFILE](/fr/reference/statements/select/into-outfile).
```sql theme={null}
SELECT * FROM dictionary(regexp_dict) INTO OUTFILE('regexp_dict.csv')
```
Le contenu du fichier CSV est le suivant :
```text theme={null}
1,0,"Linux/(\d+[\.\d]*).+tlinux","['version','name']","['\\1','TencentOS']"
2,0,"(\d+)/tclwebkit(\d+[\.\d]*)","['comment','version','name']","['test $1 and $2','$1','Android']"
3,2,"33/tclwebkit","['version']","['13']"
4,2,"3[12]/tclwebkit","['version']","['12']"
5,2,"3[12]/tclwebkit","['version']","['11']"
6,2,"3[12]/tclwebkit","['version']","['10']"
```
Le schéma du fichier exporté est :
* `id UInt64` : l’identifiant du nœud RegexpTree.
* `parent_id UInt64` : l’identifiant du parent d’un nœud.
* `regexp String` : la chaîne d’expression régulière.
* `keys Array(String)` : les noms des attributs définis par l’utilisateur.
* `values Array(String)` : les valeurs des attributs définis par l’utilisateur.
Pour créer le dictionnaire dans ClickHouse Cloud, créez d’abord une table `regexp_dictionary_source_table` avec la structure de table suivante :
```sql theme={null}
CREATE TABLE regexp_dictionary_source_table
(
id UInt64,
parent_id UInt64,
regexp String,
keys Array(String),
values Array(String)
) ENGINE=Memory;
```
Ensuite, mettez à jour le fichier CSV local en
```bash theme={null}
clickhouse client \
--host MY_HOST \
--secure \
--password MY_PASSWORD \
--query "
INSERT INTO regexp_dictionary_source_table
SELECT * FROM input ('id UInt64, parent_id UInt64, regexp String, keys Array(String), values Array(String)')
FORMAT CSV" < regexp_dict.csv
```
Pour en savoir plus, vous pouvez consulter [Insérer des fichiers locaux](/fr/integrations/connectors/data-ingestion/insert-local-files). Après avoir initialisé la table source, nous pouvons créer un RegexpTree à partir de la table source :
```sql theme={null}
CREATE DICTIONARY regexp_dict
(
regexp String,
name String,
version String
PRIMARY KEY(regexp)
SOURCE(CLICKHOUSE(TABLE 'regexp_dictionary_source_table'))
LIFETIME(0)
LAYOUT(regexp_tree);
```