> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Diseño de diccionario de árbol de expresiones regulares
> Configure un diccionario de árbol de expresiones regulares para búsquedas basadas en patrones.
export const CloudNotSupportedBadge = () => {
return
Not supported in ClickHouse Cloud
;
};
## Descripción general
El diccionario `regexp_tree` permite asignar claves a valores en función de patrones jerárquicos de expresiones regulares.
Está optimizado para lookups por coincidencia de patrones (por ejemplo, clasificar cadenas como user agent strings mediante la coincidencia con patrones regex) en lugar de la coincidencia exacta de claves.
## Use el Diccionario de árbol de expresiones regulares con el origen YAMLRegExpTree
Los diccionarios de árbol de expresiones regulares se definen en ClickHouse open-source mediante el origen [`YAMLRegExpTree`](/es/reference/statements/create/dictionary/sources/yamlregexptree), al que se le indica la ruta a un archivo YAML que contiene el árbol de expresiones regulares.
```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 fuente del diccionario [`YAMLRegExpTree`](/es/reference/statements/create/dictionary/sources/yamlregexptree) representa la estructura de un árbol de expresiones regulares. Por ejemplo:
```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'
```
Esta configuración consta de una lista de nodos de árbol de expresiones regulares. Cada nodo tiene la siguiente estructura:
* **regexp**: la expresión regular del nodo.
* **attributes**: una lista de atributos de diccionario definidos por el usuario. En este ejemplo, hay dos atributos: `name` y `version`. El primer nodo define ambos atributos. El segundo nodo solo define el atributo `name`. El atributo `version` lo proporcionan los nodos hijos del segundo nodo.
* El valor de un atributo puede contener **retroreferencias**, que remiten a grupos de captura de la expresión regular coincidente. En el ejemplo, el valor del atributo `version` en el primer nodo consta de una retroreferencia `\1` al grupo de captura `(\d+[\.\d]*)` en la expresión regular. Los números de retroreferencia van del 1 al 9 y se escriben como `$1` o `\1` (para el número 1). La retroreferencia se sustituye por el grupo de captura coincidente durante la ejecución de la consulta.
* **child nodes**: una lista de nodos hijos de un nodo de árbol regexp, cada uno con sus propios atributos y, potencialmente, nodos hijos. La coincidencia de cadenas se realiza recorriendo el árbol en profundidad. Si una cadena coincide con un nodo regexp, el diccionario comprueba si también coincide con los nodos hijos de ese nodo. Si es así, se asignan los atributos del nodo coincidente más profundo. Los atributos de un nodo hijo sobrescriben los atributos con el mismo nombre de los nodos padre. El nombre de los nodos hijos en archivos YAML puede ser arbitrario; por ejemplo, `versions` en el ejemplo anterior.
Los diccionarios de árbol regexp solo permiten el acceso mediante las funciones `dictGet`, `dictGetOrDefault` y `dictGetAll`. Por ejemplo:
```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') │
└─────────────────────────────────────────────────────────────────┘
```
En este caso, primero se hace coincidir la expresión regular `\d+/tclwebkit(?:\d+[\.\d]*)` en el segundo nodo de la capa superior.
A continuación, el diccionario sigue buscando en los nodos hijo y encuentra que la cadena también coincide con `3[12]/tclwebkit`.
Como resultado, el valor del atributo `name` es `Android` (definido en la primera capa) y el valor del atributo `version` es `12` (definido en el nodo hijo).
Con un sofisticado archivo de configuración YAML, puede usar los diccionarios de árbol regexp como analizador de cadenas user agent.
ClickHouse es compatible con [uap-core](https://github.com/ua-parser/uap-core) y puede ver cómo usarlo en la prueba funcional [02504\_regexp\_dictionary\_ua\_parser](https://github.com/ClickHouse/ClickHouse/blob/master/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh)
### Recopilación de valores de atributos
A veces resulta útil devolver valores de varias expresiones regulares que hayan coincidido, en lugar de devolver solo el valor de un nodo hoja. En esos casos, se puede usar la función especializada [`dictGetAll`](/es/reference/functions/regular-functions/ext-dict-functions#dictGetAll). Si un nodo tiene un valor de atributo de tipo `T`, `dictGetAll` devolverá un `Array(T)` que contiene cero o más valores.
De forma predeterminada, el número de coincidencias devueltas por clave no tiene límite. Se puede pasar un límite como cuarto argumento opcional a `dictGetAll`. El array se rellena en *orden topológico*, lo que significa que los nodos hijo van antes que los nodos padre y que los nodos hermanos siguen el orden del origen.
Ejemplo:
```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],[]) │
└────────────────────────────────────────┴───────────────────────────────────────────────────────────────────────────────────────┘
```
### Modos de coincidencia
El comportamiento de la coincidencia de patrones puede modificarse con ciertas opciones de configuración del diccionario:
* `regexp_dict_flag_case_insensitive`: Usa coincidencia sin distinguir entre mayúsculas y minúsculas (el valor predeterminado es `false`). Puede sobrescribirse en expresiones individuales con `(?i)` y `(?-i)`.
* `regexp_dict_flag_dotall`: Permite que '.' coincida con caracteres de salto de línea (el valor predeterminado es `false`).
## Usar un diccionario de árbol de expresiones regulares en ClickHouse Cloud
La fuente [`YAMLRegExpTree`](/es/reference/statements/create/dictionary/sources/yamlregexptree) funciona en ClickHouse Open Source, pero no en ClickHouse Cloud.
Para usar diccionarios de árbol de expresiones regulares en ClickHouse Cloud, primero cree localmente en ClickHouse Open Source un diccionario de árbol de expresiones regulares a partir de un archivo YAML y, a continuación, vuelque este diccionario en un archivo CSV mediante la función de tabla `dictionary` y la cláusula [INTO OUTFILE](/es/reference/statements/select/into-outfile).
```sql theme={null}
SELECT * FROM dictionary(regexp_dict) INTO OUTFILE('regexp_dict.csv')
```
El contenido del archivo CSV es:
```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']"
```
El esquema del archivo de volcado es:
* `id UInt64`: el ID del nodo de RegexpTree.
* `parent_id UInt64`: el ID del nodo padre.
* `regexp String`: la cadena de la expresión regular.
* `keys Array(String)`: los nombres de los atributos definidos por el usuario.
* `values Array(String)`: los valores de los atributos definidos por el usuario.
Para crear el Diccionario en ClickHouse Cloud, primero cree una tabla `regexp_dictionary_source_table` con la siguiente estructura de la tabla:
```sql theme={null}
CREATE TABLE regexp_dictionary_source_table
(
id UInt64,
parent_id UInt64,
regexp String,
keys Array(String),
values Array(String)
) ENGINE=Memory;
```
A continuación, actualiza el CSV local con
```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
```
Puede consultar [Insertar archivos locales](/es/integrations/connectors/data-ingestion/insert-local-files) para obtener más información. Después de inicializar la tabla de origen, podemos crear un RegexpTree basado en la tabla de origen:
```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);
```