> ## 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.
> Documentación de las funciones para trabajar con diccionarios integrados
# Funciones para trabajar con diccionarios integrados
Para que las funciones siguientes funcionen, la configuración del servidor debe especificar las rutas y direcciones necesarias para obtener todos los diccionarios integrados. Los diccionarios se cargan en la primera llamada a cualquiera de estas funciones. Si no se pueden cargar las listas de referencia, se produce una excepción.
Por lo tanto, los ejemplos que se muestran en esta sección producirán una excepción en [ClickHouse Fiddle](https://fiddle.clickhouse.com/) y en los despliegues quick release y de producción de forma predeterminada, a menos que se hayan configurado previamente.
Para obtener información sobre cómo crear listas de referencia, consulte la sección ["Diccionarios"](/es/reference/statements/create/dictionary/embedded).
## Múltiples geobases
ClickHouse permite trabajar simultáneamente con múltiples geobases alternativas (jerarquías regionales) para admitir distintas perspectivas sobre a qué países pertenecen ciertas regiones.
La configuración de `clickhouse-server` especifica el archivo con la jerarquía regional:
`/opt/geo/regions_hierarchy.txt`
Además de este archivo, también busca archivos cercanos que tengan el símbolo `_` y cualquier sufijo añadido al nombre (antes de la extensión del archivo).
Por ejemplo, también encontrará el archivo `/opt/geo/regions_hierarchy_ua.txt`, si existe. Aquí, `ua` se denomina la clave del diccionario. En el caso de un diccionario sin sufijo, la clave es una cadena vacía.
Todos los diccionarios se recargan durante el tiempo de ejecución (cada cierto número de segundos, según se define en el parámetro de configuración [`builtin_dictionaries_reload_interval`](/es/reference/settings/server-settings/settings#builtin_dictionaries_reload_interval), o una vez por hora de forma predeterminada). Sin embargo, la lista de diccionarios disponibles se define una sola vez, cuando se inicia el servidor.
Todas las funciones para trabajar con regiones tienen un argumento opcional al final: la clave del diccionario. A esto se le llama la geobase.
Ejemplo:
```sql theme={null}
regionToCountry(RegionID) – Uses the default dictionary: /opt/geo/regions_hierarchy.txt
regionToCountry(RegionID, '') – Uses the default dictionary: /opt/geo/regions_hierarchy.txt
regionToCountry(RegionID, 'ua') – Uses the dictionary for the 'ua' key: /opt/geo/regions_hierarchy_ua.txt
```
### regionToName
Acepta un ID de región y geobase, y devuelve una cadena con el nombre de la región en el idioma correspondiente. Si no existe una región con el ID especificado, se devuelve una cadena vacía.
**Sintaxis**
```sql theme={null}
regionToName(id\[, lang\])
```
**Parámetros**
* `id` — ID de la región de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `geobase` — Clave del diccionario. Consulte [Múltiples geobases](#multiple-geobases). [String](/es/reference/data-types/string). Opcional.
**Valor devuelto**
* Nombre de la región en el idioma correspondiente indicado por `geobase`. [String](/es/reference/data-types/string).
* De lo contrario, una cadena vacía.
**Ejemplo**
```sql title="Query" theme={null}
SELECT regionToName(number::UInt32,'en') FROM numbers(0,5);
```
```text title="Response" theme={null}
┌─regionToName(CAST(number, 'UInt32'), 'en')─┐
│ │
│ World │
│ USA │
│ Colorado │
│ Boulder County │
└────────────────────────────────────────────┘
```
### regionToCity
Acepta un ID de región de la geobase. Si esta región es una ciudad o parte de una ciudad, devuelve el ID de región de la ciudad correspondiente. En caso contrario, devuelve 0.
**Sintaxis**
```sql theme={null}
regionToCity(id [, geobase])
```
**Parámetros**
* `id` — ID de la región de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `geobase` — Clave del diccionario. Consulte [Múltiples geobases](#multiple-geobases). [String](/es/reference/data-types/string). Opcional.
**Valor devuelto**
* ID de la región de la ciudad correspondiente, si existe. [UInt32](/es/reference/data-types/int-uint).
* 0, si no existe.
**Ejemplo**
```sql title="Query" theme={null}
SELECT regionToName(number::UInt32, 'en'), regionToCity(number::UInt32) AS id, regionToName(id, 'en') FROM numbers(13);
```
```response title="Response" theme={null}
┌─regionToName(CAST(number, 'UInt32'), 'en')─┬─id─┬─regionToName(regionToCity(CAST(number, 'UInt32')), 'en')─┐
│ │ 0 │ │
│ World │ 0 │ │
│ USA │ 0 │ │
│ Colorado │ 0 │ │
│ Boulder County │ 0 │ │
│ Boulder │ 5 │ Boulder │
│ China │ 0 │ │
│ Sichuan │ 0 │ │
│ Chengdu │ 8 │ Chengdu │
│ America │ 0 │ │
│ North America │ 0 │ │
│ Eurasia │ 0 │ │
│ Asia │ 0 │ │
└────────────────────────────────────────────┴────┴──────────────────────────────────────────────────────────┘
```
### regionToArea
Convierte una región en un área (tipo 5 en la geobase). En todos los demás aspectos, esta función es igual que ['regionToCity'](#regiontocity).
**Sintaxis**
```sql theme={null}
regionToArea(id [, geobase])
```
**Parámetros**
* `id` — ID de la región de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `geobase` — Clave del diccionario. Consulte [Múltiples geobases](#multiple-geobases). [String](/es/reference/data-types/string). Opcional.
**Valor devuelto**
* ID de la región del área correspondiente, si existe. [UInt32](/es/reference/data-types/int-uint).
* 0 si no existe.
**Ejemplo**
```sql title="Query" theme={null}
SELECT DISTINCT regionToName(regionToArea(toUInt32(number), 'ua'))
FROM system.numbers
LIMIT 15
```
```text title="Response" theme={null}
┌─regionToName(regionToArea(toUInt32(number), \'ua\'))─┐
│ │
│ Moscow and Moscow region │
│ St. Petersburg and Leningrad region │
│ Belgorod region │
│ Ivanovsk region │
│ Kaluga region │
│ Kostroma region │
│ Kursk region │
│ Lipetsk region │
│ Orlov region │
│ Ryazan region │
│ Smolensk region │
│ Tambov region │
│ Tver region │
│ Tula region │
└──────────────────────────────────────────────────────┘
```
### regionToDistrict
Convierte una región en un distrito federal (tipo 4 en la geobase). Por lo demás, esta función es igual que 'regionToCity'.
**Sintaxis**
```sql theme={null}
regionToDistrict(id [, geobase])
```
**Parámetros**
* `id` — ID de la región de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `geobase` — Clave del diccionario. Consulta [Múltiples geobases](#multiple-geobases). [String](/es/reference/data-types/string). Opcional.
**Valor devuelto**
* ID de la región de la ciudad correspondiente, si existe. [UInt32](/es/reference/data-types/int-uint).
* 0, si no existe ninguna.
**Ejemplo**
```sql title="Query" theme={null}
SELECT DISTINCT regionToName(regionToDistrict(toUInt32(number), 'ua'))
FROM system.numbers
LIMIT 15
```
```text title="Response" theme={null}
┌─regionToName(regionToDistrict(toUInt32(number), \'ua\'))─┐
│ │
│ Central federal district │
│ Northwest federal district │
│ South federal district │
│ North Caucases federal district │
│ Privolga federal district │
│ Ural federal district │
│ Siberian federal district │
│ Far East federal district │
│ Scotland │
│ Faroe Islands │
│ Flemish region │
│ Brussels capital region │
│ Wallonia │
│ Federation of Bosnia and Herzegovina │
└──────────────────────────────────────────────────────────┘
```
### regionToCountry
Convierte una región en un país (tipo 3 de la geobase). Por lo demás, esta función es igual que 'regionToCity'.
**Sintaxis**
```sql theme={null}
regionToCountry(id [, geobase])
```
**Parámetros**
* `id` — ID de la región de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `geobase` — Clave del diccionario. Consulte [Múltiples geobases](#multiple-geobases). [String](/es/reference/data-types/string). Opcional.
**Valor devuelto**
* ID de la región del país correspondiente, si existe. [UInt32](/es/reference/data-types/int-uint).
* 0, si no existe.
**Ejemplo**
```sql title="Query" theme={null}
SELECT regionToName(number::UInt32, 'en'), regionToCountry(number::UInt32) AS id, regionToName(id, 'en') FROM numbers(13);
```
```text title="Response" theme={null}
┌─regionToName(CAST(number, 'UInt32'), 'en')─┬─id─┬─regionToName(regionToCountry(CAST(number, 'UInt32')), 'en')─┐
│ │ 0 │ │
│ World │ 0 │ │
│ USA │ 2 │ USA │
│ Colorado │ 2 │ USA │
│ Boulder County │ 2 │ USA │
│ Boulder │ 2 │ USA │
│ China │ 6 │ China │
│ Sichuan │ 6 │ China │
│ Chengdu │ 6 │ China │
│ America │ 0 │ │
│ North America │ 0 │ │
│ Eurasia │ 0 │ │
│ Asia │ 0 │ │
└────────────────────────────────────────────┴────┴─────────────────────────────────────────────────────────────┘
```
### regionToContinent
Convierte una región en un continente (tipo 1 de la geobase). En todo lo demás, esta función es igual que 'regionToCity'.
**Sintaxis**
```sql theme={null}
regionToContinent(id [, geobase])
```
**Parámetros**
* `id` — ID de la región de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `geobase` — Clave del diccionario. Véase [Múltiples geobases](#multiple-geobases). [String](/es/reference/data-types/string). Opcional.
**Valor devuelto**
* ID de la región del continente correspondiente, si existe. [UInt32](/es/reference/data-types/int-uint).
* 0, si no existe.
**Ejemplo**
```sql title="Query" theme={null}
SELECT regionToName(number::UInt32, 'en'), regionToContinent(number::UInt32) AS id, regionToName(id, 'en') FROM numbers(13);
```
```text title="Response" theme={null}
┌─regionToName(CAST(number, 'UInt32'), 'en')─┬─id─┬─regionToName(regionToContinent(CAST(number, 'UInt32')), 'en')─┐
│ │ 0 │ │
│ World │ 0 │ │
│ USA │ 10 │ North America │
│ Colorado │ 10 │ North America │
│ Boulder County │ 10 │ North America │
│ Boulder │ 10 │ North America │
│ China │ 12 │ Asia │
│ Sichuan │ 12 │ Asia │
│ Chengdu │ 12 │ Asia │
│ America │ 9 │ America │
│ North America │ 10 │ North America │
│ Eurasia │ 11 │ Eurasia │
│ Asia │ 12 │ Asia │
└────────────────────────────────────────────┴────┴───────────────────────────────────────────────────────────────┘
```
### regionToTopContinent
Devuelve el continente de nivel superior en la jerarquía para la región.
**Sintaxis**
```sql theme={null}
regionToTopContinent(id[, geobase])
```
**Parámetros**
* `id` — ID de la región de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `geobase` — Clave del diccionario. Consulte [Múltiples Geobases](#multiple-geobases). [String](/es/reference/data-types/string). Opcional.
**Valor devuelto**
* Identificador del continente de nivel superior (al subir por la jerarquía de regiones).[UInt32](/es/reference/data-types/int-uint).
* 0, si no existe ninguno.
**Ejemplo**
```sql title="Query" theme={null}
SELECT regionToName(number::UInt32, 'en'), regionToTopContinent(number::UInt32) AS id, regionToName(id, 'en') FROM numbers(13);
```
```text title="Response" theme={null}
┌─regionToName(CAST(number, 'UInt32'), 'en')─┬─id─┬─regionToName(regionToTopContinent(CAST(number, 'UInt32')), 'en')─┐
│ │ 0 │ │
│ World │ 0 │ │
│ USA │ 9 │ America │
│ Colorado │ 9 │ America │
│ Boulder County │ 9 │ America │
│ Boulder │ 9 │ America │
│ China │ 11 │ Eurasia │
│ Sichuan │ 11 │ Eurasia │
│ Chengdu │ 11 │ Eurasia │
│ America │ 9 │ America │
│ North America │ 9 │ America │
│ Eurasia │ 11 │ Eurasia │
│ Asia │ 11 │ Eurasia │
└────────────────────────────────────────────┴────┴──────────────────────────────────────────────────────────────────┘
```
### regionToPopulation
Obtiene la población de una región. La población puede estar registrada en archivos de geobase. Consulte la sección ["Diccionarios"](/es/reference/statements/create/dictionary/embedded). Si la población no está registrada para la región, devuelve 0. En la geobase, la población puede estar registrada para regiones subordinadas, pero no para las regiones superiores.
**Sintaxis**
```sql theme={null}
regionToPopulation(id[, geobase])
```
**Parámetros**
* `id` — ID de la región de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `geobase` — Clave del diccionario. Consulte [Múltiples geobases](#multiple-geobases). [String](/es/reference/data-types/string). Opcional.
**Valor devuelto**
* Población de la región. [UInt32](/es/reference/data-types/int-uint).
* 0, si no existe.
**Ejemplo**
```sql title="Query" theme={null}
SELECT regionToName(number::UInt32, 'en'), regionToPopulation(number::UInt32) AS id, regionToName(id, 'en') FROM numbers(13);
```
```text title="Response" theme={null}
┌─regionToName(CAST(number, 'UInt32'), 'en')─┬─population─┐
│ │ 0 │
│ World │ 4294967295 │
│ USA │ 330000000 │
│ Colorado │ 5700000 │
│ Boulder County │ 330000 │
│ Boulder │ 100000 │
│ China │ 1500000000 │
│ Sichuan │ 83000000 │
│ Chengdu │ 20000000 │
│ America │ 1000000000 │
│ North America │ 600000000 │
│ Eurasia │ 4294967295 │
│ Asia │ 4294967295 │
└────────────────────────────────────────────┴────────────┘
```
### regionIn
Comprueba si una región `lhs` pertenece a una región `rhs`. Devuelve un valor UInt8 igual a 1 si pertenece, o 0 si no.
**Sintaxis**
```sql theme={null}
regionIn(lhs, rhs\[, geobase\])
```
**Parámetros**
* `lhs` — ID de región de `lhs` de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `rhs` — ID de región de `rhs` de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `geobase` — Clave del diccionario. Consulte [Múltiples geobases](#multiple-geobases). [String](/es/reference/data-types/string). Opcional.
**Valor devuelto**
* 1, si pertenece. [UInt8](/es/reference/data-types/int-uint).
* 0, si no pertenece.
**Detalles de implementación**
La relación es reflexiva: cualquier región también pertenece a sí misma.
**Ejemplo**
```sql title="Query" theme={null}
SELECT regionToName(n1.number::UInt32, 'en') || (regionIn(n1.number::UInt32, n2.number::UInt32) ? ' is in ' : ' is not in ') || regionToName(n2.number::UInt32, 'en') FROM numbers(1,2) AS n1 CROSS JOIN numbers(1,5) AS n2;
```
```text title="Response" theme={null}
World is in World
World is not in USA
World is not in Colorado
World is not in Boulder County
World is not in Boulder
USA is in World
USA is in USA
USA is not in Colorado
USA is not in Boulder County
USA is not in Boulder
```
### regionHierarchy
Acepta un número UInt32: el ID de región de la geobase. Devuelve un array de ID de región que incluye la región proporcionada y todas sus regiones padre en la jerarquía.
**Sintaxis**
```sql theme={null}
regionHierarchy(id\[, geobase\])
```
**Parámetros**
* `id` — ID de región de la geobase. [UInt32](/es/reference/data-types/int-uint).
* `geobase` — Clave del diccionario. Consulte [Múltiples geobases](#multiple-geobases). [String](/es/reference/data-types/string). Opcional.
**Valor devuelto**
* Array de ID de región que consta de la región proporcionada y de todos sus padres en la cadena. [Array](/es/reference/data-types/array)([UInt32](/es/reference/data-types/int-uint)).
**Ejemplo**
```sql title="Query" theme={null}
SELECT regionHierarchy(number::UInt32) AS arr, arrayMap(id -> regionToName(id, 'en'), arr) FROM numbers(5);
```
```text title="Response" theme={null}
┌─arr────────────┬─arrayMap(lambda(tuple(id), regionToName(id, 'en')), regionHierarchy(CAST(number, 'UInt32')))─┐
│ [] │ [] │
│ [1] │ ['World'] │
│ [2,10,9,1] │ ['USA','North America','America','World'] │
│ [3,2,10,9,1] │ ['Colorado','USA','North America','America','World'] │
│ [4,3,2,10,9,1] │ ['Boulder County','Colorado','USA','North America','America','World'] │
└────────────────┴──────────────────────────────────────────────────────────────────────────────────────────────┘
```
{/*AUTOGENERATED_START*/}