> ## 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.
> Documentación de las funciones para buscar en cadenas
# Funciones para buscar en cadenas
Todas las funciones de esta sección realizan búsquedas distinguiendo mayúsculas de minúsculas de forma predeterminada. La búsqueda sin distinguir mayúsculas de minúsculas suele ofrecerse mediante variantes de función independientes.
La búsqueda sin distinguir mayúsculas de minúsculas sigue las reglas de uso de mayúsculas y minúsculas del inglés. Por ejemplo, la `i` en mayúscula en inglés es
`I`, mientras que en turco es `İ`; los resultados para idiomas distintos del inglés pueden ser inesperados.
Las funciones de esta sección también asumen que la cadena en la que se busca (denominada en esta sección `haystack`) y la cadena de búsqueda (denominada en esta sección `needle`) son texto codificado en un solo byte. Si no se cumple este supuesto,
no se lanza ninguna excepción y los resultados no están definidos. La búsqueda con cadenas codificadas en UTF-8 suele ofrecerse mediante variantes de función
independientes. Del mismo modo, si se usa una variante de función UTF-8 y las cadenas de entrada no son texto codificado en UTF-8, no se lanza ninguna excepción y los
resultados no están definidos. Tenga en cuenta que no se realiza ninguna normalización Unicode automática; no obstante, puede usar las funciones
[normalizeUTF8\*()](/es/reference/functions/regular-functions/string-functions#normalizeUTF8NFC) para ello.
Las [funciones generales de cadenas](/es/reference/functions/regular-functions/string-functions) y las [funciones para reemplazar en cadenas](/es/reference/functions/regular-functions/string-replace-functions) se describen por separado.
La documentación que aparece a continuación se genera a partir de la tabla del sistema `system.functions`.
{/*AUTOGENERATED_START*/}
## countMatches
Introducido en: v21.1.0
Devuelve el número de coincidencias de una expresión regular en una cadena.
**Comportamiento según la versión**
El comportamiento de esta función depende de la versión de ClickHouse:
* en las versiones \< v25.6, la función deja de contar en la primera coincidencia vacía, aunque el patrón la permita.
* en las versiones >= 25.6, la función continúa ejecutándose cuando se produce una coincidencia vacía. El comportamiento heredado se puede restaurar mediante la configuración `count_matches_stop_at_empty_match = true`;
**Sintaxis**
```sql theme={null}
countMatches(haystack, pattern)
```
**Argumentos**
* `haystack` — La cadena en la que buscar. [`String`](/es/reference/data-types/string)
* `pattern` — Patrón de expresión regular. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número de coincidencias encontradas. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Contar secuencias de dígitos**
```sql title=Query theme={null}
SELECT countMatches('hello 123 world 456 test', '[0-9]+')
```
```response title=Response theme={null}
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│ 2 │
└─────────────────────────────────────────────────────┘
```
## countMatchesCaseInsensitive
Introducido en: v21.1.0
Como [`countMatches`](#countMatches), pero realiza coincidencias sin distinguir entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
countMatchesCaseInsensitive(haystack, pattern)
```
**Argumentos**
* `haystack` — La cadena en la que se busca. [`String`](/es/reference/data-types/string)
* `pattern` — Patrón de expresión regular. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número de coincidencias encontradas. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Recuento sin distinción entre mayúsculas y minúsculas**
```sql title=Query theme={null}
SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
```
```response title=Response theme={null}
┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐
│ 2 │
└───────────────────────────────────────────────────────────┘
```
## countSubstrings
Introducido en: v21.1.0
Devuelve cuántas veces aparece la subcadena `needle` en la cadena `haystack`.
**Sintaxis**
```sql theme={null}
countSubstrings(haystack, needle[, start_pos])
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [String](/es/reference/data-types/string) o [Enum](/es/reference/data-types/enum). - `needle` — Subcadena que se busca. [String](/es/reference/data-types/string). - `start_pos` — Posición (basada en 1) de `haystack` en la que comienza la búsqueda. [UInt](/es/reference/data-types/int-uint). Opcional.
**Valor devuelto**
El número de ocurrencias. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT countSubstrings('aaaa', 'aa');
```
```response title=Response theme={null}
┌─countSubstrings('aaaa', 'aa')─┐
│ 2 │
└───────────────────────────────┘
```
**Con el argumento start\_pos**
```sql title=Query theme={null}
SELECT countSubstrings('abc___abc', 'abc', 4);
```
```response title=Response theme={null}
┌─countSubstrings('abc___abc', 'abc', 4)─┐
│ 1 │
└────────────────────────────────────────┘
```
## countSubstringsCaseInsensitive
Introducido en: v21.1.0
Como [`countSubstrings`](#countSubstrings), pero cuenta sin distinguir entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
countSubstringsCaseInsensitive(haystack, needle[, start_pos])
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string) o [`Enum`](/es/reference/data-types/enum)
* `needle` — Subcadena que se va a buscar. [`String`](/es/reference/data-types/string)
* `start_pos` — Opcional. Posición (basada en 1) de `haystack` en la que comienza la búsqueda. [`UInt*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el número de apariciones de `needle` en `haystack`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
```
```response title=Response theme={null}
┌─countSubstri⋯AAA', 'aa')─┐
│ 2 │
└──────────────────────────┘
```
**Con el argumento start\_pos**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
```
```response title=Response theme={null}
┌─countSubstri⋯, 'abc', 4)─┐
│ 2 │
└──────────────────────────┘
```
## countSubstringsCaseInsensitiveUTF8
Introducido en: v21.1.0
Como [`countSubstrings`](#countSubstrings), pero cuenta sin distinguir entre mayúsculas y minúsculas y asume que haystack es una cadena UTF-8.
**Sintaxis**
```sql theme={null}
countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])
```
**Argumentos**
* `haystack` — Cadena UTF-8 en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string) o [`Enum`](/es/reference/data-types/enum)
* `needle` — Subcadena que se va a buscar. [`String`](/es/reference/data-types/string)
* `start_pos` — Opcional. Posición (basada en 1) de `haystack` en la que comienza la búsqueda. [`UInt*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el número de apariciones de `needle` en `haystack`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
```
```response title=Response theme={null}
┌─countSubstri⋯шка', 'КА')─┐
│ 4 │
└──────────────────────────┘
```
**Con el argumento start\_pos**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
```
```response title=Response theme={null}
┌─countSubstri⋯, 'КА', 13)─┐
│ 2 │
└──────────────────────────┘
```
Introducido en: v1.1.0
Extrae la primera coincidencia de una expresión regular en una cadena.
Si 'haystack' no coincide con 'pattern', se devuelve una cadena vacía.
Esta función utiliza la biblioteca de expresiones regulares RE2. Consulta [re2](https://github.com/google/re2/wiki/Syntax) para conocer la sintaxis admitida.
Si la expresión regular tiene grupos de captura (subpatrones), la función hace coincidir la cadena de entrada con el primer grupo de captura.
**Sintaxis**
```sql theme={null}
extract(haystack, pattern)
```
**Argumentos**
* `haystack` — Cadena de la que se extrae. [`String`](/es/reference/data-types/string)
* `pattern` — Expresión regular que normalmente contiene un grupo de captura. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el fragmento extraído como una cadena. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Extraer el dominio de un correo electrónico**
```sql title=Query theme={null}
SELECT extract('test@clickhouse.com', '.*@(.*)$')
```
```response title=Response theme={null}
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com │
└───────────────────────────────────────────┘
```
**Si no hay coincidencia, se devuelve una cadena vacía**
```sql title=Query theme={null}
SELECT extract('test@clickhouse.com', 'no_match')
```
```response title=Response theme={null}
┌─extract('test@clickhouse.com', 'no_match')─┐
│ │
└────────────────────────────────────────────┘
```
Introducido en: v1.1.0
Como [`extract`](#extract), pero devuelve un array con todas las coincidencias de una expresión regular en una cadena.
Si 'haystack' no coincide con la expresión regular 'pattern', se devuelve un array vacío.
Si la expresión regular tiene grupos de captura (subpatrones), la función hace coincidir la cadena de entrada con el primer grupo de captura.
**Sintaxis**
```sql theme={null}
extractAll(haystack, pattern)
```
**Argumentos**
* `haystack` — Cadena de la que se extraen fragmentos. [`String`](/es/reference/data-types/string)
* `pattern` — Expresión regular que puede contener grupos de captura. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un array de fragmentos extraídos. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**Extraer todos los números**
```sql title=Query theme={null}
SELECT extractAll('hello 123 world 456', '[0-9]+')
```
```response title=Response theme={null}
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456'] │
└─────────────────────────────────────────────┘
```
**Extraer con un grupo de captura**
```sql title=Query theme={null}
SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
```
```response title=Response theme={null}
┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user'] │
└────────────────────────────────────────────────────────────────────┘
```
Introducido en: v20.5.0
Extrae todos los grupos de una cadena mediante la expresión regular proporcionada y devuelve un array de arrays, donde cada array contiene todas las capturas del mismo grupo de captura, organizadas por número de grupo.
**Sintaxis**
```sql theme={null}
extractAllGroupsHorizontal(s, regexp)
```
**Argumentos**
* `s` — Cadena de entrada de la que se extrae. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `regexp` — Expresión regular con la que se realiza la coincidencia. [`const String`](/es/reference/data-types/string) o [`const FixedString`](/es/reference/data-types/fixedstring)
**Valor devuelto**
Devuelve un array de arrays, donde cada array interno contiene todas las capturas de un grupo de captura en todas las coincidencias. El primer array interno contiene todas las capturas del grupo 1, el segundo las del grupo 2, etc. Si no se encuentra ninguna coincidencia, devuelve un array vacío. [`Array(Array(String))`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractAllGroupsHorizontal(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
```
```response title=Response theme={null}
[['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']]
```
Introducido en: v20.5.0
Extrae los grupos de captura de la primera subcadena que coincide con una expresión regular. Para extraer los grupos de todas las coincidencias, use [`extractAllGroupsHorizontal`](#extractAllGroupsHorizontal) o [`extractAllGroupsVertical`](/es/reference/functions/regular-functions/splitting-merging-functions#extractAllGroupsVertical).
**Sintaxis**
```sql theme={null}
extractGroups(s, regexp)
```
**Argumentos**
* `s` — Cadena de entrada de la que se extrae. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `regexp` — Expresión regular. Debe contener al menos un grupo de captura. Constante. [`const String`](/es/reference/data-types/string) o [`const FixedString`](/es/reference/data-types/fixedstring)
**Valor devuelto**
Si la expresión regular encuentra una coincidencia, devuelve un array que contiene los grupos capturados (`1` a `N`, donde `N` es el número de grupos de captura en `regexp`) de la primera coincidencia. Si no hay coincidencia, devuelve un array vacío. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
```
```response title=Response theme={null}
['Server','nginx']
```
## hasAllTokens
Introducido en: v25.10.0
Similar a [`hasAnyTokens`](#hasAnyTokens), pero devuelve 1 si todos los tokens de la cadena o array `needle` coinciden con la cadena `input`, y 0 en caso contrario. Si `input` es una columna, devuelve todas las filas que satisfacen esta condición.
La columna `input` debe tener definido un [índice de texto](/es/reference/engines/table-engines/mergetree-family/textindexes) para un rendimiento óptimo.
Si no se define ningún índice de texto, la función realiza un barrido exhaustivo de la columna, que es varios órdenes de magnitud más lento que una búsqueda mediante índice.
Antes de realizar la búsqueda, la función tokeniza
* el argumento `input` (siempre) y
* el argumento `needle` (si se pasa como [String](/es/reference/data-types/string))
usando el tokenizador especificado para el índice de texto.
Si la columna no tiene definido ningún índice de texto, se usa en su lugar el tokenizador `splitByNonAlpha`.
Si el argumento `needle` es de tipo [Array(String)](/es/reference/data-types/array), cada elemento del array se trata como un token; no se realiza ninguna tokenización adicional.
Los tokens duplicados se ignoran.
Por ejemplo, needles = \['ClickHouse', 'ClickHouse'] se trata igual que \['ClickHouse'].
**Sintaxis**
```sql theme={null}
hasAllTokens(input, needles)
```
**Alias**: `hasAllToken`
**Argumentos**
* `input` — La columna de entrada. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`Array(String)`](/es/reference/data-types/array) o [`Array(FixedString)`](/es/reference/data-types/array)
* `needles` — tokens que se van a buscar. [`String`](/es/reference/data-types/string) o [`Array(String)`](/es/reference/data-types/array)
* `tokenizer` — Tokenizador que se usará. Los argumentos válidos son `splitByNonAlpha`, `splitByString`, `asciiCJK`, `ngrams`, `sparseGrams` y `array`. Es opcional; si no se establece explícitamente, el valor predeterminado es `splitByNonAlpha`. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve 1 si todos los needles coinciden; 0 en caso contrario. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Uso básico con una aguja de tipo String**
```sql title=Query theme={null}
CREATE TABLE table (
id UInt32,
msg String,
INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO table VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');
SELECT count() FROM table WHERE hasAllTokens(msg, 'a\\d()');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Especifique los needles que se buscarán TAL CUAL (sin tokenización) en un array**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']);
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Generar needles con la función `tokens`**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Usar un tokenizador personalizado mediante el tercer argumento**
```sql title=Query theme={null}
SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
```
```response title=Response theme={null}
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│ 1 │
└──────────────────────────────────────────────┘
```
**Ejemplos de uso para columnas de tipo array y map**
```sql title=Query theme={null}
CREATE TABLE log (
id UInt32,
tags Array(String),
attributes Map(String, String),
INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO log VALUES
(1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
(2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});
```
```response title=Response theme={null}
```
**Ejemplo con una columna de tipo Array**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Ejemplo con mapKeys**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Ejemplo con mapValues**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
```
```response title=Response theme={null}
┌─count()─┐
│ 0 │
└─────────┘
```
## hasAnyTokens
Introducido en: v25.10.0
Devuelve 1 si al menos un token de la cadena o array `needle` coincide con la cadena `input`, y 0 en caso contrario. Si `input` es una columna, devuelve todas las filas que cumplen esta condición.
La columna `input` debe tener definido un [índice de texto](/es/reference/engines/table-engines/mergetree-family/textindexes) para un rendimiento óptimo.
Si no se define ningún índice de texto, la función realiza un escaneo completo de la columna, que es varios órdenes de magnitud más lento que una búsqueda en un índice.
Antes de realizar la búsqueda, la función tokeniza
* el argumento `input` (siempre), y
* el argumento `needle` (si se proporciona como [String](/es/reference/data-types/string))
usando el tokenizador especificado para el índice de texto.
Si la columna no tiene definido ningún índice de texto, se usa en su lugar el tokenizador `splitByNonAlpha`.
Si el argumento `needle` es de tipo [Array(String)](/es/reference/data-types/array), cada elemento del array se trata como un token; no se realiza ninguna tokenización adicional.
Los tokens duplicados se ignoran.
Por ejemplo, \['ClickHouse', 'ClickHouse'] se trata igual que \['ClickHouse'].
**Sintaxis**
```sql theme={null}
hasAnyTokens(input, needles)
```
**Aliases**: `hasAnyToken`
**Argumentos**
* `input` — La columna de entrada. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`Nullable(String)`](/es/reference/data-types/nullable) o [`Nullable(FixedString)`](/es/reference/data-types/nullable) o [`Array(String)`](/es/reference/data-types/array) o [`Array(FixedString)`](/es/reference/data-types/array) o [`Array(Nullable(String))`](/es/reference/data-types/array) o [`Array(Nullable(FixedString))`](/es/reference/data-types/array)
* `needles` — tokens que se buscan. [`String`](/es/reference/data-types/string) o [`Array(String)`](/es/reference/data-types/array)
* `tokenizer` — El tokenizador que se debe usar. Los argumentos válidos son `splitByNonAlpha`, `splitByString`, `asciiCJK`, `ngrams`, `sparseGrams` y `array`. Es opcional; si no se especifica explícitamente, el valor predeterminado es `splitByNonAlpha`. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si hubo al menos una coincidencia. `0` en caso contrario. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Uso básico con una aguja de tipo String**
```sql title=Query theme={null}
CREATE TABLE table (
id UInt32,
msg String,
INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO table VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');
SELECT count() FROM table WHERE hasAnyTokens(msg, 'a\\d()');
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**Especifique los needles que se buscarán TAL CUAL (sin tokenización) en un array**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']);
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**Generar needles con la función `tokens`**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**Ejemplos de uso para columnas de tipo array y map**
```sql title=Query theme={null}
CREATE TABLE log (
id UInt32,
tags Array(String),
attributes Map(String, String),
INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO log VALUES
(1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
(2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});
```
```response title=Response theme={null}
```
**Ejemplo con una columna de array**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Ejemplo con mapKeys**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
```
```response title=Response theme={null}
┌─count()─┐
│ 2 │
└─────────┘
```
**Ejemplo con mapValues**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
```
```response title=Response theme={null}
┌─count()─┐
│ 2 │
└─────────┘
```
## hasPhrase
Introducido en: v26.4.0
Comprueba si el haystack contiene todos los tokens de la frase en orden consecutivo.
Antes de realizar la búsqueda, la función tokeniza tanto los argumentos `input` como `phrase` mediante el tokenizer especificado como tercer argumento opcional.
El argumento `tokenizer` debe ser uno de `splitByNonAlpha`, `splitByString`, `ngrams` o `asciiCJK`.
Si no se especifica ningún tokenizer, se usará `splitByNonAlpha` de forma predeterminada.
A diferencia de [`hasToken`](#hasToken), [`hasAnyTokens`](#hasAnyTokens) y [`hasAllTokens`](#hasAllTokens), `hasPhrase` requiere que los tokens aparezcan en el mismo orden
y sin ningún token entre medias. Por ejemplo, `hasPhrase('the quick brown fox', 'quick fox')` devuelve 0
porque "brown" aparece entre "quick" y "fox".
**Sintaxis**
```sql theme={null}
hasPhrase(input, phrase[, tokenizer])
```
**Alias**: `matchPhrase`
**Argumentos**
* `input` — La columna de entrada. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `phrase` — La frase que se desea buscar. [`const String`](/es/reference/data-types/string)
* `tokenizer` — El tokenizador que se va a usar. Opcional; el valor predeterminado es `splitByNonAlpha`. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la frase se encuentra como una secuencia consecutiva de tokens; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda por frase**
```sql title=Query theme={null}
SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
```
```response title=Response theme={null}
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│ 1 │
└────────────────────────────────────────────────────────┘
```
**Tokens no contiguos**
```sql title=Query theme={null}
SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
```
```response title=Response theme={null}
┌─hasPhrase('the quick brown fox jumps', 'quick fox')─┐
│ 0 │
└──────────────────────────────────────────────────────┘
```
## hasSubsequence
Introducido en: v23.7.0
Comprueba si una needle es una subsecuencia de un haystack.
Una subsecuencia de una cadena es una secuencia que puede derivarse de otra cadena eliminando algunos caracteres o ninguno, sin cambiar el orden de los caracteres restantes.
**Sintaxis**
```sql theme={null}
hasSubsequence(haystack, needle)
```
**Argumentos**
* `haystack` — haystack en la que se busca la subsecuencia. [`String`](/es/reference/data-types/string)
* `needle` — needle que se busca. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si `needle` es una subsecuencia de `haystack`; `0` en caso contrario. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Comprobación básica de subsecuencia**
```sql title=Query theme={null}
SELECT hasSubsequence('Hello World', 'HlWrd')
```
```response title=Response theme={null}
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│ 1 │
└────────────────────────────────────────┘
```
**No se encontró ninguna subsecuencia**
```sql title=Query theme={null}
SELECT hasSubsequence('Hello World', 'xyz')
```
```response title=Response theme={null}
┌─hasSubsequence('Hello World', 'xyz')─┐
│ 0 │
└──────────────────────────────────────┘
```
## hasSubsequenceCaseInsensitive
Introducido en: v23.7.0
Igual que [`hasSubsequence`](#hasSubsequence), pero busca sin distinguir entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
hasSubsequenceCaseInsensitive(haystack, needle)
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — Subsecuencia que se busca. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve 1 si `needle` es una subsecuencia de `haystack`; de lo contrario, 0. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
```
```response title=Response theme={null}
┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│ 1 │
└─────────────────────────────────────────────────┘
```
## hasSubsequenceCaseInsensitiveUTF8
Introducido en: v23.7.0
Igual que [`hasSubsequenceUTF8`](#hasSubsequenceUTF8), pero busca sin distinguir entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
```
**Argumentos**
* `haystack` — cadena codificada en UTF8 en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — subsecuencia codificada en UTF8 que se busca. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve 1 si `needle` es una subsecuencia de `haystack`, y 0 en caso contrario. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
```
```response title=Response theme={null}
┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│ 1 │
└──────────────────────────┘
```
## hasSubsequenceUTF8
Introducido en: v23.7.0
Al igual que [`hasSubsequence`](/es/reference/functions/regular-functions/string-search-functions#hasSubsequence), pero asume que el haystack y la subcadena buscada están codificadas en UTF-8.
**Sintaxis**
```sql theme={null}
hasSubsequenceUTF8(haystack, needle)
```
**Argumentos**
* `haystack` — La cadena en la que buscar. [`String`](/es/reference/data-types/string)
* `needle` — La subsecuencia que buscar. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si `needle` es una subsecuencia de `haystack`; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT hasSubsequenceUTF8('картошка', 'кошка');
```
```response title=Response theme={null}
┌─hasSubsequen⋯', 'кошка')─┐
│ 1 │
└──────────────────────────┘
```
**Subsecuencia que no coincide**
```sql title=Query theme={null}
SELECT hasSubsequenceUTF8('картошка', 'апельсин');
```
```response title=Response theme={null}
┌─hasSubsequen⋯'апельсин')─┐
│ 0 │
└──────────────────────────┘
```
## hasToken
Introducido en: v20.1.0
Comprueba si el token indicado está presente en el haystack.
Utiliza [splitByNonAlpha](/es/reference/functions/regular-functions/splitting-merging-functions#splitByNonAlpha) como tokenizador; es decir, un token se define como la subsecuencia más larga posible de caracteres consecutivos `[0-9A-Za-z_]` (números, caracteres ASCII y guion bajo).
**Sintaxis**
```sql theme={null}
hasToken(haystack, token)
```
**Argumentos**
* `haystack` — haystack en la que se busca. [`String`](/es/reference/data-types/string)
* `token` — Token que se busca. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si se encuentra el token; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda de un token**
```sql title=Query theme={null}
SELECT hasToken('clickhouse test', 'test')
```
```response title=Response theme={null}
┌─hasToken('clickhouse test', 'test')─┐
│ 1 │
└─────────────────────────────────────┘
```
## hasTokenCaseInsensitive
Introducido en: v20.1.0
Realiza una búsqueda de needle en haystack sin distinguir entre mayúsculas y minúsculas mediante el índice tokenbf\_v1.
**Sintaxis**
```sql theme={null}
hasTokenCaseInsensitive(haystack, needle)
```
**Argumentos**
* Ninguno.
**Valor devuelto**
**Ejemplos**
## hasTokenCaseInsensitiveOrNull
Introducido en: v23.1.0
Realiza una búsqueda de needle en haystack sin distinguir entre mayúsculas y minúsculas mediante el índice tokenbf\_v1. Devuelve NULL si needle no tiene un formato válido.
**Sintaxis**
```sql theme={null}
hasTokenCaseInsensitiveOrNull(haystack, needle)
```
**Argumentos**
* Ninguno.
**Valor devuelto**
**Ejemplos**
## hasTokenOrNull
Introducido en: v20.1.0
Igual que [`hasToken`](#hasToken), pero devuelve NULL si el token no está bien formado.
**Sintaxis**
```sql theme={null}
hasTokenOrNull(haystack, token)
```
**Argumentos**
* `haystack` — Cadena en la que se buscará. Debe ser constante. [`String`](/es/reference/data-types/string)
* `token` — Token que se debe buscar. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si se encuentra el token, `0` en caso contrario y `NULL` si el token tiene un formato no válido. [`Nullable(UInt8)`](/es/reference/data-types/nullable)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
```
```response title=Response theme={null}
┌─hasTokenOrNu⋯ 'ban ana')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
```
## highlight
Introducido en: v26.4.0
Resalta las apariciones de los términos de búsqueda en una cadena de texto envolviéndolas en etiquetas HTML.
La función realiza coincidencias ASCII sin distinguir entre mayúsculas y minúsculas. Si varios términos de búsqueda se superponen o están adyacentes en el texto, las regiones coincidentes se combinan en un único fragmento resaltado.
**Sintaxis**
```sql theme={null}
highlight(haystack, needles[, open_tag, close_tag])
```
**Argumentos**
* `haystack` — El texto en el que se busca. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `needles` — Un array de términos de búsqueda que se resaltarán. [`const Array(String)`](/es/reference/data-types/array)
* `open_tag` — La etiqueta de apertura que se inserta antes de cada coincidencia. Valor predeterminado: ``. [`const String`](/es/reference/data-types/string)
* `close_tag` — La etiqueta de cierre que se inserta después de cada coincidencia. Valor predeterminado: ``. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el texto de entrada con los términos coincidentes delimitados por las etiquetas especificadas. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Resaltado básico**
```sql title=Query theme={null}
SELECT highlight('The quick brown fox', ['quick', 'fox'])
```
```response title=Response theme={null}
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The quick brown fox │
└────────────────────────────────────────────────────┘
```
**Etiquetas personalizadas**
```sql title=Query theme={null}
SELECT highlight('Hello World', ['hello'], '', '')
```
```response title=Response theme={null}
┌─highlight('Hello World', ['hello'], '', '')─┐
│ Hello World │
└────────────────────────────────────────────────────┘
```
## ilike
Introducido en: v20.6.0
Igual que [`like`](#like), pero busca sin distinguir entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
ilike(haystack, pattern)
-- haystack ILIKE pattern
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `pattern` — Patrón LIKE con el que se debe coincidir. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la cadena coincide con el patrón LIKE (sin distinción entre mayúsculas y minúsculas); en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT ilike('ClickHouse', '%house%');
```
```response title=Response theme={null}
┌─ilike('ClickHouse', '%house%')─┐
│ 1 │
└────────────────────────────────┘
```
## like
Introducido en: v1.1.0
Indica si la cadena `haystack` coincide con la expresión `LIKE` `pattern`.
Una expresión `LIKE` puede contener caracteres normales y los siguientes metasímbolos:
* `%` indica una cantidad arbitraria de caracteres arbitrarios (incluidos cero caracteres).
* `_` indica un único carácter arbitrario.
* `\` sirve para escapar los literales `%`, `_` y `\`.
La comparación se basa en UTF-8; por ejemplo, `_` coincide con el punto de código Unicode `¥`, que en UTF-8 se representa con dos bytes.
Si `haystack` o la expresión `LIKE` no son UTF-8 válidos, el comportamiento es indefinido.
No se realiza ninguna normalización Unicode automática; para ello, puede usar las funciones `normalizeUTF8*`.
Para hacer coincidir los caracteres literales `%`, `_` y `\` (que son metacaracteres de `LIKE`), antepóngales una barra invertida: `\%`, `\_` y `\\`.
La barra invertida pierde su significado especial (es decir, se interpreta literalmente) si precede a un carácter distinto de `%`, `_` o `\`.
ClickHouse requiere que las barras invertidas en las cadenas [también se escapen](/es/reference/syntax#string), por lo que en realidad tendría que escribir `\\%`, `\\_` y `\\\\`.
Para expresiones `LIKE` de la forma `%needle%`, la función es tan rápida como la función `position`.
Todas las demás expresiones `LIKE` se convierten internamente en una expresión regular y se ejecutan con un rendimiento similar al de la función `match`.
**Sintaxis**
```sql theme={null}
like(haystack, pattern)
-- haystack LIKE pattern
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `pattern` — Patrón `LIKE` con el que se compara. Puede contener `%` (coincide con cualquier número de caracteres), `_` (coincide con un solo carácter) y `\` como carácter de escape. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la cadena coincide con el patrón `LIKE`; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT like('ClickHouse', '%House');
```
```response title=Response theme={null}
┌─like('ClickHouse', '%House')─┐
│ 1 │
└──────────────────────────────┘
```
**Comodín de un solo carácter**
```sql title=Query theme={null}
SELECT like('ClickHouse', 'Click_ouse');
```
```response title=Response theme={null}
┌─like('ClickH⋯lick_ouse')─┐
│ 1 │
└──────────────────────────┘
```
**Patrón no coincidente**
```sql title=Query theme={null}
SELECT like('ClickHouse', '%SQL%');
```
```response title=Response theme={null}
┌─like('ClickHouse', '%SQL%')─┐
│ 0 │
└─────────────────────────────┘
```
## locate
Introducido en: v18.16.0
Igual que [`position`](#position), pero con los argumentos `haystack` y `locate` intercambiados.
**Comportamiento según la versión**
El comportamiento de esta función depende de la versión de ClickHouse:
* en las versiones \< v24.3, `locate` era un alias de la función `position` y aceptaba los argumentos `(haystack, needle[, start_pos])`.
* en las versiones >= 24.3, `locate` es una función independiente (para mejorar la compatibilidad con MySQL) y acepta los argumentos `(needle, haystack[, start_pos])`.
El comportamiento anterior puede restaurarse usando el ajuste `function_locate_has_mysql_compatible_argument_order = false`.
**Sintaxis**
```sql theme={null}
locate(needle, haystack[, start_pos])
```
**Argumentos**
* `needle` — needle que se debe buscar. [`String`](/es/reference/data-types/string)
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string) o [`Enum`](/es/reference/data-types/enum)
* `start_pos` — Opcional. Posición (a partir de 1) en `haystack` donde comienza la búsqueda. [`UInt`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la posición inicial en bytes, contando desde 1, si se encontró la subcadena; `0` si no se encontró. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT locate('ca', 'abcabc')
```
```response title=Response theme={null}
┌─locate('ca', 'abcabc')─┐
│ 3 │
└────────────────────────┘
```
## match
Introducido en: v1.1.0
Comprueba si una cadena dada coincide con el patrón de expresión regular proporcionado.
Esta función utiliza la biblioteca de expresiones regulares RE2. Consulta [re2](https://github.com/google/re2/wiki/Syntax) para ver la sintaxis admitida.
La coincidencia funciona asumiendo UTF-8; por ejemplo, `¥` usa dos bytes internamente, pero la coincidencia lo trata como un único punto de código.
La expresión regular no debe contener bytes NULL.
Si el haystack o el patrón no son UTF-8 válidos, el comportamiento no está definido.
A diferencia del comportamiento predeterminado de re2, `.` coincide con los saltos de línea. Para desactivarlo, antepón `(?-s)` al patrón.
El patrón no está anclado. Para hacer coincidir toda la cadena, ancla tú mismo el patrón con `^` y `$`.
Si solo quieres buscar substrings, puedes usar en su lugar las funciones [`like`](#like) o [`position`](#position), que son mucho más rápidas que esta función.
Sintaxis alternativa del operador: `haystack REGEXP pattern`.
**Sintaxis**
```sql theme={null}
match(haystack, pattern)
```
**Alias**: `REGEXP_MATCHES`
**Argumentos**
* `haystack` — Cadena en la que se busca el patrón. [`String`](/es/reference/data-types/string)
* `pattern` — Patrón de expresión regular. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si el patrón coincide, `0` en caso contrario. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Coincidencia de patrones básica**
```sql title=Query theme={null}
SELECT match('Hello World', 'Hello.*')
```
```response title=Response theme={null}
┌─match('Hello World', 'Hello.*')─┐
│ 1 │
└─────────────────────────────────┘
```
**El patrón no coincide**
```sql title=Query theme={null}
SELECT match('Hello World', 'goodbye.*')
```
```response title=Response theme={null}
┌─match('Hello World', 'goodbye.*')─┐
│ 0 │
└───────────────────────────────────┘
```
**Coincidencia con una subcadena**
```sql title=Query theme={null}
SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
```
```response title=Response theme={null}
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│ 1 │ 0 │
└─────────────────────────┴───────────────────────────┘
```
## multiFuzzyMatchAllIndices
Introducido en: v20.1.0
Como [`multiFuzzyMatchAny`](#multiFuzzyMatchAny), pero devuelve el array con todos los índices, en cualquier orden, que coinciden con la cadena de búsqueda dentro de una [distancia de edición](https://en.wikipedia.org/wiki/Edit_distance) constante.
**Sintaxis**
```sql theme={null}
multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])
```
**Argumentos**
* `haystack` — String en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `distance` — La distancia de edición máxima para la coincidencia difusa. [`UInt8`](/es/reference/data-types/int-uint)
* `pattern` — Array de patrones con los que se realiza la coincidencia. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array con todos los índices (a partir de 1) que coinciden con `haystack` dentro de la distancia de edición especificada, en cualquier orden. Devuelve un array vacío si no se encuentra ninguna coincidencia. [`Array(UInt64)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2] │
└──────────────────────────┘
```
## multiFuzzyMatchAny
Introducido en: v20.1.0
Como [`multiMatchAny`](#multiMatchAny), pero devuelve 1 si algún patrón coincide con el haystack dentro de una [distancia de edición](https://en.wikipedia.org/wiki/Edit_distance) constante.
Esta función se basa en una característica experimental de la biblioteca [hyperscan](https://intel.github.io/hyperscan/dev-reference/compilation.html#approximate-matching) y puede resultar lenta en determinados casos extremos.
El rendimiento depende del valor de la distancia de edición y de los patrones utilizados, pero su coste siempre es mayor que el de las variantes no difusas.
La familia de funciones `multiFuzzyMatch*()` no admite expresiones regulares UTF-8 (las trata como una secuencia de bytes) debido a las restricciones de hyperscan.
**Sintaxis**
```sql theme={null}
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])
```
**Argumentos**
* `haystack` — haystack donde se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `distance` — La distancia máxima de edición para la coincidencia difusa. [`UInt8`](/es/reference/data-types/int-uint)
* `pattern` — Opcional. Un array de patrones con los que buscar coincidencias. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` si algún patrón coincide con el haystack dentro de la distancia de edición especificada; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯lickHose'])─┐
│ 1 │
└──────────────────────────┘
```
## multiFuzzyMatchAnyIndex
Introducido en: v20.1.0
Igual que [`multiFuzzyMatchAny`](#multiFuzzyMatchAny), pero devuelve cualquier índice que coincida con el haystack dentro de una [distancia de edición](https://en.wikipedia.org/wiki/Edit_distance) constante.
**Sintaxis**
```sql theme={null}
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])
```
**Argumentos**
* `haystack` — haystack en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `distance` — La distancia de edición máxima para la coincidencia difusa. [`UInt8`](/es/reference/data-types/int-uint)
* `pattern` — Array de patrones con los que se compara. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el índice (a partir de 1) de cualquier patrón que coincida con `haystack` dentro de la distancia de edición especificada; en caso contrario, `0`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯ickHouse'])─┐
│ 2 │
└──────────────────────────┘
```
## multiMatchAllIndices
Introducido en: v20.1.0
Como [`multiMatchAny`](#multiMatchAny), pero devuelve un array con todos los índices que coinciden con el texto de entrada, en cualquier orden.
**Sintaxis**
```sql theme={null}
multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])
```
**Argumentos**
* `haystack` — String en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `pattern` — Expresiones regulares con las que buscar coincidencias. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Array con todos los índices (a partir de 1) que coinciden con el haystack en cualquier orden. Devuelve un array vacío si no se encuentra ninguna coincidencia. [`Array(UInt64)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
```
```response title=Response theme={null}
┌─multiMatchAl⋯', 'ouse'])─┐
│ [3, 2, 4] │
└──────────────────────────┘
```
## multiMatchAny
Introducido en: v20.1.0
Comprueba si al menos uno de varios patrones de expresión regular coincide con la cadena de búsqueda.
Si solo quieres buscar varias subcadenas en una cadena, puedes usar la función [`multiSearchAny`](#multiSearchAny); funciona mucho más rápido que esta función.
**Sintaxis**
```sql theme={null}
multiMatchAny(haystack, pattern1[, pattern2, ...])
```
**Argumentos**
* `haystack` — Cadena en la que se buscan los patrones. [`String`](/es/reference/data-types/string)
* `pattern1[, pattern2, ...]` — Un array de uno o más patrones de expresiones regulares. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` si coincide algún patrón; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Coincidencia de varios patrones**
```sql title=Query theme={null}
SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
```
```response title=Response theme={null}
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│ 1 │
└────────────────────────────────────────────────────┘
```
**No coincide ningún patrón**
```sql title=Query theme={null}
SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
```
```response title=Response theme={null}
┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│ 0 │
└──────────────────────────────────────────────────────┘
```
## multiMatchAnyIndex
Introducido en: v20.1.0
Como [`multiMatchAny`](#multiMatchAny), pero devuelve cualquier índice que encuentre una coincidencia en el haystack.
**Sintaxis**
```sql theme={null}
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])
```
**Argumentos**
* `haystack` — haystack en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `pattern` — Expresiones regulares con las que buscar coincidencias. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el índice (a partir de 1) del primer patrón que coincide, o 0 si no se encuentra ninguna coincidencia. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
```
```response title=Response theme={null}
┌─multiMatchAn⋯, 'Click'])─┐
│ 3 │
└──────────────────────────┘
```
## multiSearchAllPositions
Introducido en: v20.1.0
Como [`position`](#position), pero devuelve un array con las posiciones (en bytes, a partir de 1) de varias subcadenas `needle` dentro de una cadena `haystack`.
Todas las funciones `multiSearch*()` solo admiten hasta 2^8 needles.
**Sintaxis**
```sql theme={null}
multiSearchAllPositions(haystack, needle1[, needle2, ...])
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle1[, needle2, ...]` — Un array de una o más subcadenas que se buscan. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array con la posición inicial en bytes, contando desde 1, si se encontró la subcadena, o `0` si no se encontró. [`Array(UInt64)`](/es/reference/data-types/array)
**Ejemplos**
**Búsqueda de múltiples subcadenas**
```sql title=Query theme={null}
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
```
```response title=Response theme={null}
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0] │
└───────────────────────────────────────────────────────────────────┘
```
## multiSearchAllPositionsCaseInsensitive
Introducido en: v20.1.0
Igual que [`multiSearchAllPositions`](#multiSearchAllPositions), pero no distingue entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle1[, needle2, ...]` — Un array de una o más subcadenas que se van a buscar. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array con la posición inicial en bytes, contando desde 1 (si se encontró la subcadena), y `0` si no se encontró. [`Array(UInt64)`](/es/reference/data-types/array)
**Ejemplos**
**Búsqueda múltiple sin distinción entre mayúsculas y minúsculas**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
```
```response title=Response theme={null}
┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6] │
└──────────────────────────┘
```
## multiSearchAllPositionsCaseInsensitiveUTF8
Introducido en: v20.1.0
Como [`multiSearchAllPositionsUTF8`](#multiSearchAllPositionsUTF8), pero ignora mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Argumentos**
* `haystack` — cadena codificada en UTF-8 en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — subcadenas codificadas en UTF-8 que se deben buscar. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Array con las posiciones iniciales en bytes, contando desde 1 (si se encontró la subcadena). Devuelve 0 si no se encontró la subcadena. [`Array`](/es/reference/data-types/array)
**Ejemplos**
**Búsqueda en UTF-8 sin distinción entre mayúsculas y minúsculas**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
```
```response title=Response theme={null}
┌─multiSearchA⋯й', 'МИР'])─┐
│ [1, 13] │
└──────────────────────────┘
```
## multiSearchAllPositionsUTF8
Introducido en: v20.1.0
Como [`multiSearchAllPositions`](#multiSearchAllPositions), pero supone que `haystack` y las subcadenas `needle` son cadenas codificadas en UTF-8.
**Sintaxis**
```sql theme={null}
multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])
```
**Argumentos**
* `haystack` — Cadena codificada en UTF-8 en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle1[, needle2, ...]` — Un array de subcadenas codificadas en UTF-8 que se deben buscar. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array con la posición inicial en bytes, contando desde 1 (si se encontró la subcadena), o `0` si no se encontró. [`Array`](/es/reference/data-types/array)
**Ejemplos**
**Búsqueda múltiple en UTF-8**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
```
```response title=Response theme={null}
┌─multiSearchAllPositionsUTF8('ClickHouse', ['C', 'H'])─┐
│ [1,6] │
└───────────────────────────────────────────────────────┘
```
## multiSearchAny
Introducido en: v20.1.0
Comprueba si al menos una de varias cadenas de búsqueda coincide con el haystack.
Las funciones [`multiSearchAnyCaseInsensitive`](#multiSearchAnyCaseInsensitive), [`multiSearchAnyUTF8`](#multiSearchAnyUTF8) y [`multiSearchAnyCaseInsensitiveUTF8`](#multiSearchAnyCaseInsensitiveUTF8) ofrecen variantes sin distinción entre mayúsculas y minúsculas y/o UTF-8 de esta función.
**Sintaxis**
```sql theme={null}
multiSearchAny(haystack, needle1[, needle2, ...])
```
**Argumentos**
* `haystack` — haystack en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle1[, needle2, ...]` — Un array de subcadenas que se buscarán. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` si hubo al menos una coincidencia; de lo contrario, `0` si no hubo ninguna coincidencia. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda de cualquier coincidencia**
```sql title=Query theme={null}
SELECT multiSearchAny('ClickHouse',['C','H'])
```
```response title=Response theme={null}
┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│ 1 │
└──────────────────────────────────────────┘
```
## multiSearchAnyCaseInsensitive
Introducido en: v20.1.0
Como [multiSearchAny](#multiSearchAny), pero no distingue entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
```
**Argumentos**
* `haystack` — String en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — Subcadenas que se buscarán. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` si hubo al menos una coincidencia sin distinción entre mayúsculas y minúsculas; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda sin distinción entre mayúsculas y minúsculas**
```sql title=Query theme={null}
SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
```
```response title=Response theme={null}
┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│ 1 │
└─────────────────────────────────────────────────────────┘
```
## multiSearchAnyCaseInsensitiveUTF8
Introducida en: v20.1.0
Como [multiSearchAnyUTF8](#multiSearchAnyUTF8), pero no distingue entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Argumentos**
* `haystack` — cadena UTF-8 en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — subcadenas UTF-8 que se buscan. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` si hubo al menos una coincidencia sin distinción entre mayúsculas y minúsculas; en caso contrario, devuelve `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Dada una cadena UTF-8 'Здравствуйте', compruebe si el carácter 'з' (en minúscula) está presente**
```sql title=Query theme={null}
SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
```
```response title=Response theme={null}
┌─multiSearchA⋯те', ['з'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchAnyUTF8
Introducido en: v20.1.0
Igual que [multiSearchAny](#multiSearchAny), pero supone que `haystack` y las subcadenas `needle` están codificadas en UTF-8.
**Sintaxis**
```sql theme={null}
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Argumentos**
* `haystack` — cadena UTF-8 en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — subcadenas UTF-8 que se buscan. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` si hubo al menos una coincidencia; en caso contrario, `0` si no la hubo. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Dada '你好，世界' ('Hello, world') como cadena UTF-8, comprueba si la cadena contiene algún carácter 你 o 界**
```sql title=Query theme={null}
SELECT multiSearchAnyUTF8('你好，世界', ['你', '界'])
```
```response title=Response theme={null}
┌─multiSearchA⋯你', '界'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchFirstIndex
Introducido en: v20.1.0
Busca varias subcadenas en una cadena haystack (distinguiendo entre mayúsculas y minúsculas) y devuelve el índice, basado en 1, de la primera subcadena encontrada.
**Sintaxis**
```sql theme={null}
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
```
**Argumentos**
* `haystack` — La cadena en la que se busca. [`String`](/es/reference/data-types/string)
* `needles` — Array de cadenas que se buscan. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el índice en base 1 (la posición en el array `needles`) de la primera `subcadena` encontrada en `haystack`. Devuelve 0 si no se encuentra ninguna `subcadena`. La búsqueda distingue entre mayúsculas y minúsculas. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'Server'])─┐
│ 1 │
└──────────────────────────┘
```
**Comportamiento que distingue entre mayúsculas y minúsculas**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'Server'])─┐
│ 2 │
└──────────────────────────┘
```
**No se encontró ninguna coincidencia**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
```
```response title=Response theme={null}
┌─multiSearchF⋯', 'test'])─┐
│ 0 │
└──────────────────────────┘
```
## multiSearchFirstIndexCaseInsensitive
Introducido en: v20.1.0
Devuelve el índice `i` (a partir de 1) de `needle`\_i encontrada más a la izquierda en la cadena `haystack`, y 0 en caso contrario.
No distingue entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — Subcadenas que se van a buscar. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el índice (a partir de 1) de la subcadena encontrada más a la izquierda. En caso contrario, devuelve `0` si no hay coincidencias. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
```
```response title=Response theme={null}
┌─multiSearchF⋯, 'Hello'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchFirstIndexCaseInsensitiveUTF8
Introducido en: v20.1.0
Busca varias subcadenas en una cadena haystack, sin distinguir entre mayúsculas y minúsculas y con compatibilidad con UTF-8, y devuelve el índice, empezando por 1, de la primera subcadena encontrada.
**Sintaxis**
```sql theme={null}
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Argumentos**
* `haystack` — La cadena en la que se busca. [`String`](/es/reference/data-types/string)
* `needles` — Array de cadenas que se buscan. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el índice basado en 1 (la posición en el array `needles`) de la primera subcadena encontrada en `haystack`. Devuelve 0 si no se encuentra ninguna subcadena. La búsqueda no distingue entre mayúsculas y minúsculas y respeta la codificación de caracteres UTF-8. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'server'])─┐
│ 1 │
└──────────────────────────┘
```
**Tratamiento de mayúsculas y minúsculas en UTF-8**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│ 1 │
└──────────────────────────┘
```
**No se encontró ninguna coincidencia**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
```
```response title=Response theme={null}
┌─multiSearchF⋯', 'test'])─┐
│ 0 │
└──────────────────────────┘
```
## multiSearchFirstIndexUTF8
Introducido en: v20.1.0
Devuelve el índice `i` (a partir de 1) de la `needle`\_i que aparece más a la izquierda en la cadena `haystack`, y 0 en caso contrario.
Asume que `haystack` y `needle` son cadenas codificadas en UTF-8.
**Sintaxis**
```sql theme={null}
multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Argumentos**
* `haystack` — cadena UTF-8 en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — Array de subcadenas UTF-8 que se van a buscar. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el índice (a partir de 1) de la subcadena buscada encontrada más a la izquierda. En caso contrario, devuelve 0 si no hay coincidencias. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
```
```response title=Response theme={null}
┌─multiSearchF⋯вствуйте'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchFirstPosition
Introducido en: v20.1.0
Como [`position`](#position), pero devuelve el desplazamiento más a la izquierda de una cadena `haystack` que coincide con cualquiera de varias cadenas `needle`.
Las funciones [`multiSearchFirstPositionCaseInsensitive`](#multiSearchFirstPositionCaseInsensitive), [`multiSearchFirstPositionUTF8`](#multiSearchFirstPositionUTF8) y [`multiSearchFirstPositionCaseInsensitiveUTF8`](#multiSearchFirstPositionCaseInsensitiveUTF8) proporcionan variantes de esta función sin distinción entre mayúsculas y minúsculas y/o en UTF-8.
**Sintaxis**
```sql theme={null}
multiSearchFirstPosition(haystack, needle1[, needle2, ...])
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle1[, needle2, ...]` — Un array de una o más subcadenas que se van a buscar. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el desplazamiento de la coincidencia situada más a la izquierda en una cadena `haystack` que coincida con cualquiera de varias cadenas `needle`; de lo contrario, devuelve `0` si no hay coincidencias. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda de la primera posición**
```sql title=Query theme={null}
SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
```
```response title=Response theme={null}
┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│ 3 │
└───────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionCaseInsensitive
Introducido en: v20.1.0
Como [multiSearchFirstPosition](#multiSearchFirstPosition), pero ignora mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — Array de subcadenas que se van a buscar. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el desplazamiento de la coincidencia situada más a la izquierda en una cadena `haystack` que coincide con cualquiera de las cadenas de `needle`. Devuelve `0` si no hay ninguna coincidencia. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Primera posición sin distinguir entre mayúsculas y minúsculas**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│ 2 │
└───────────────────────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionCaseInsensitiveUTF8
Introducido en: v20.1.0
Como [multiSearchFirstPosition](#multiSearchFirstPosition), pero asume que `haystack` y `needle` son cadenas UTF-8 y no distingue entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Argumentos**
* `haystack` — cadena UTF-8 en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — Array de subcadenas UTF-8 que se van a buscar. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el desplazamiento de la coincidencia situada más a la izquierda en una cadena `haystack` que coincida con cualquiera de las múltiples cadenas `needle`, sin distinguir entre mayúsculas y minúsculas. Devuelve `0` si no hay ninguna coincidencia. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Buscar el desplazamiento de la coincidencia situada más a la izquierda en la cadena UTF-8 'Здравствуй, мир' ('Hello, world') que coincida con cualquiera de las `needle` dadas**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['мир', 'вст', 'Здра'])─┐
│ 3 │
└────────────────────────────────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionUTF8
Introducido en: v20.1.0
Igual que [multiSearchFirstPosition](#multiSearchFirstPosition), pero supone que `haystack` y `needle` son cadenas UTF-8.
**Sintaxis**
```sql theme={null}
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Argumentos**
* `haystack` — cadena UTF-8 en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string)
* `needle` — Array de subcadenas UTF-8 que se buscarán. [`Array(String)`](/es/reference/data-types/array)
**Valor devuelto**
Desplazamiento más a la izquierda en una cadena `haystack` que coincide con cualquiera de las cadenas `needle`. Devuelve `0` si no hay ninguna coincidencia. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Encontrar el desplazamiento más a la izquierda en la cadena UTF-8 'Здравствуй, мир' ('Hello, world') que coincide con cualquiera de las cadenas `needle` dadas**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│ 3 │
└─────────────────────────────────────────────────────────────────────────┘
```
## ngramDistance
Introducido en: v20.1.0
Calcula la distancia de 4-gramas entre dos cadenas.
Para ello, cuenta la diferencia simétrica entre dos multiconjuntos de 4-gramas y la normaliza por la suma de sus cardinalidades.
Cuanto menor sea el valor devuelto, más similares serán las cadenas.
Para búsquedas sin distinción entre mayúsculas y minúsculas o en formato UTF8, use las funciones [`ngramDistanceCaseInsensitive`](#ngramDistanceCaseInsensitive), [`ngramDistanceUTF8`](#ngramDistanceUTF8), [`ngramDistanceCaseInsensitiveUTF8`](#ngramDistanceCaseInsensitiveUTF8).
**Sintaxis**
```sql theme={null}
ngramDistance(haystack, needle)
```
**Argumentos**
* `haystack` — Cadena de comparación. [`String`](/es/reference/data-types/string)
* `needle` — Cadena de comparación. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un número Float32 entre `0` y `1`. Cuanto menor sea el valor devuelto, más similares serán las cadenas. [`Float32`](/es/reference/data-types/float)
**Ejemplos**
**Calcular la distancia de 4-gramas**
```sql title=Query theme={null}
SELECT ngramDistance('ClickHouse', 'ClickHouses')
```
```response title=Response theme={null}
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│ 0.1 │
└────────────────────────────────────────────┘
```
## ngramDistanceCaseInsensitive
Introducido en: v20.1.0
Proporciona una variante de [`ngramDistance`](#ngramDistance) sin distinción entre mayúsculas y minúsculas.
Calcula la distancia de 4-gramas entre dos cadenas sin distinguir entre mayúsculas y minúsculas.
Cuanto menor sea el valor devuelto, más similares serán las cadenas.
**Sintaxis**
```sql theme={null}
ngramDistanceCaseInsensitive(haystack, needle)
```
**Argumentos**
* `haystack` — Primera cadena de comparación. [`String`](/es/reference/data-types/string)
* `needle` — Segunda cadena de comparación. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un número de tipo Float32 entre `0` y `1`. [`Float32`](/es/reference/data-types/float)
**Ejemplos**
**Distancia de 4-gramas sin distinción entre mayúsculas y minúsculas**
```sql title=Query theme={null}
SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
```
```response title=Response theme={null}
┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐
│ 0 │
└─────────────────────────────────────────────────────────┘
```
## ngramDistanceCaseInsensitiveUTF8
Introducido en: v20.1.0
Proporciona una variante UTF-8 de [`ngramDistance`](#ngramDistance) sin distinción entre mayúsculas y minúsculas.
Asume que las cadenas `needle` y `haystack` están codificadas en UTF-8 y sin distinción entre mayúsculas y minúsculas.
Calcula la distancia de 3-gramas entre dos cadenas UTF-8, sin distinción entre mayúsculas y minúsculas.
Cuanto menor sea el valor devuelto, más similares serán las cadenas.
**Sintaxis**
```sql theme={null}
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
```
**Argumentos**
* `haystack` — Primera cadena de comparación codificada en UTF-8. [`String`](/es/reference/data-types/string)
* `needle` — Segunda cadena de comparación codificada en UTF-8. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un valor `Float32` entre `0` y `1`. [`Float32`](/es/reference/data-types/float)
**Ejemplos**
**Distancia de 3-gramas UTF-8 sin distinción entre mayúsculas y minúsculas**
```sql title=Query theme={null}
SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
```
```response title=Response theme={null}
┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐
│ 0.5 │
└─────────────────────────────────────────────────┘
```
## ngramDistanceUTF8
Introducido en: v20.1.0
Proporciona una variante UTF-8 de [`ngramDistance`](#ngramDistance).
Asume que las cadenas `needle` y `haystack` están codificadas en UTF-8.
Calcula la distancia de 3-gramas entre dos cadenas UTF-8.
Cuanto menor sea el valor devuelto, más similares serán las cadenas.
**Sintaxis**
```sql theme={null}
ngramDistanceUTF8(haystack, needle)
```
**Argumentos**
* `haystack` — Primera cadena de comparación en UTF-8. [`String`](/es/reference/data-types/string)
* `needle` — Segunda cadena de comparación en UTF-8. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un número `Float32` entre `0` y `1`. [`Float32`](/es/reference/data-types/float)
**Ejemplos**
**Distancia de 3-gramas en UTF-8**
```sql title=Query theme={null}
SELECT ngramDistanceUTF8('abcde','cde')
```
```response title=Response theme={null}
┌─ngramDistanceUTF8('abcde','cde')─┐
│ 0.5 │
└───────────────────────────────────┘
```
## ngramSearch
Introducido en: v20.1.0
Comprueba si la distancia de 4-gramas entre dos cadenas es menor o igual a un umbral dado.
Para búsquedas sin distinción entre mayúsculas y minúsculas, o en formato UTF8, use las funciones `ngramSearchCaseInsensitive`, `ngramSearchUTF8`, `ngramSearchCaseInsensitiveUTF8`.
**Sintaxis**
```sql theme={null}
ngramSearch(haystack, needle)
```
**Argumentos**
* `haystack` — Cadena para comparar. [`String`](/es/reference/data-types/string)
* `needle` — Cadena para comparar. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la distancia de 4-gramas entre las cadenas es menor o igual que un umbral (`1.0` de forma predeterminada); en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda con 4-gramas**
```sql title=Query theme={null}
SELECT ngramSearch('ClickHouse', 'Click')
```
```response title=Response theme={null}
┌─ngramSearch('ClickHouse', 'Click')─┐
│ 1 │
└────────────────────────────────────┘
```
## ngramSearchCaseInsensitive
Introducido en: v20.1.0
Proporciona una variante sin distinción entre mayúsculas y minúsculas de [`ngramSearch`](#ngramSearch).
Calcula la diferencia no simétrica entre una cadena patrón y una cadena donde buscar; es decir, el número de n-gramas del patrón menos el número de n-gramas comunes, normalizado por el número de n-gramas del patrón.
Comprueba si la distancia de 4-gramas entre dos cadenas es menor o igual que un umbral dado, sin distinguir entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
ngramSearchCaseInsensitive(haystack, needle)
```
**Argumentos**
* `haystack` — Cadena para comparar. [`String`](/es/reference/data-types/string)
* `needle` — Cadena para comparar. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la distancia de 4-gramas entre las cadenas es menor o igual al umbral (`1.0` de forma predeterminada); de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda sin distinción entre mayúsculas y minúsculas con 4-gramas**
```sql title=Query theme={null}
SELECT ngramSearchCaseInsensitive('Hello World','hello')
```
```response title=Response theme={null}
┌─ngramSearchCaseInsensitive('Hello World','hello')─┐
│ 1 │
└────────────────────────────────────────────────────┘
```
## ngramSearchCaseInsensitiveUTF8
Introducido en: v20.1.0
Proporciona una variante UTF-8 de [`ngramSearch`](#ngramSearch) que no distingue entre mayúsculas y minúsculas.
Asume que `haystack` y `needle` son cadenas UTF-8 e ignora las diferencias entre mayúsculas y minúsculas.
Comprueba si la distancia de 3-gramas entre dos cadenas UTF-8 es menor o igual que un umbral dado, sin distinguir entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
ngramSearchCaseInsensitiveUTF8(haystack, needle)
```
**Argumentos**
* `haystack` — cadena UTF-8 para comparación. [`String`](/es/reference/data-types/string)
* `needle` — cadena UTF-8 para comparación. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la distancia de 3-gramas entre las cadenas es menor o igual que un umbral (`1.0` de forma predeterminada); en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda UTF-8 sin distinción entre mayúsculas y minúsculas mediante 3-gramas**
```sql title=Query theme={null}
SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
```
```response title=Response theme={null}
┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│ 1 │
└──────────────────────────────────────────────────────────┘
```
## ngramSearchUTF8
Introducido en: v20.1.0
Proporciona una variante UTF-8 de `ngramSearch`.
Asume que `haystack` y `needle` son cadenas UTF-8.
Comprueba si la distancia de 3-gramas entre dos cadenas UTF-8 es inferior o igual a un umbral determinado.
**Sintaxis**
```sql theme={null}
ngramSearchUTF8(haystack, needle)
```
**Argumentos**
* `haystack` — cadena UTF-8 para comparar. [`String`](/es/reference/data-types/string)
* `needle` — cadena UTF-8 para comparar. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la distancia de 3-gramas entre las cadenas es menor o igual que un umbral (`1.0` de forma predeterminada), o `0` en caso contrario. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda UTF-8 mediante 3-gramas**
```sql title=Query theme={null}
SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
```
```response title=Response theme={null}
┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│ 1 │
└────────────────────────────────────────┘
```
## notILike
Introducido en: v20.6.0
Comprueba si una cadena no coincide con un patrón, sin distinguir entre mayúsculas y minúsculas. El patrón puede contener los caracteres especiales `%` y `_` para la coincidencia de SQL LIKE.
**Sintaxis**
```sql theme={null}
notILike(haystack, pattern)
```
**Argumentos**
* `haystack` — La cadena de entrada en la que se busca. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `pattern` — El patrón SQL LIKE con el que se compara. `%` coincide con cualquier número de caracteres (incluido cero), `_` coincide con exactamente un carácter. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la cadena no coincide con el patrón (sin distinguir entre mayúsculas y minúsculas); en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT notILike('ClickHouse', '%house%');
```
```response title=Response theme={null}
┌─notILike('Cl⋯ '%house%')─┐
│ 0 │
└──────────────────────────┘
```
## notLike
Introducido en: v1.1.0
Similar a [`like`](#like), pero invierte el resultado.
**Sintaxis**
```sql theme={null}
notLike(haystack, pattern)
-- haystack NOT LIKE pattern
```
**Argumentos**
* `haystack` — String donde se realiza la búsqueda. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `pattern` — Patrón `LIKE` con el que se compara. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la cadena no coincide con el patrón `LIKE`; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT notLike('ClickHouse', '%House%');
```
```response title=Response theme={null}
┌─notLike('Cli⋯ '%House%')─┐
│ 0 │
└──────────────────────────┘
```
**Patrón no coincidente**
```sql title=Query theme={null}
SELECT notLike('ClickHouse', '%SQL%');
```
```response title=Response theme={null}
┌─notLike('Cli⋯', '%SQL%')─┐
│ 1 │
└──────────────────────────┘
```
## position
Introducido en: v1.1.0
Devuelve la posición (en bytes, a partir de 1) de una subcadena `needle` en una cadena `haystack`.
Si la subcadena `needle` está vacía, se aplican estas reglas:
* si no se especificó `start_pos`: devolver `1`
* si `start_pos = 0`: devolver `1`
* si `start_pos >= 1` y `start_pos <= length(haystack) + 1`: devolver `start_pos`
* en caso contrario: devolver `0`
Estas mismas reglas también se aplican a las funciones [`locate`](#locate), [`positionCaseInsensitive`](#positionCaseInsensitive), [`positionUTF8`](#positionUTF8) y [`positionCaseInsensitiveUTF8`](#positionCaseInsensitiveUTF8).
**Sintaxis**
```sql theme={null}
position(haystack, needle[, start_pos])
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string) o [`Enum`](/es/reference/data-types/enum)
* `needle` — Subcadena que se va a buscar. [`String`](/es/reference/data-types/string)
* `start_pos` — Posición (basada en 1) en `haystack` en la que comienza la búsqueda. Opcional. [`UInt`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la posición inicial, en bytes y contando desde 1, si se encontró la subcadena; en caso contrario, devuelve `0`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT position('Hello, world!', '!')
```
```response title=Response theme={null}
┌─position('Hello, world!', '!')─┐
│ 13 │
└────────────────────────────────┘
```
**Con el argumento start\_pos**
```sql title=Query theme={null}
SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)
```
```response title=Response theme={null}
┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│ 5 │ 9 │
└───────────────────────────────────┴───────────────────────────────────┘
```
**Sintaxis de needle IN haystack**
```sql title=Query theme={null}
SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
```
```response title=Response theme={null}
┌─equals(6, position(s, '/'))─┐
│ 1 │
└─────────────────────────────┘
```
**Subcadena buscada vacía**
```sql title=Query theme={null}
SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)
```
```response title=Response theme={null}
┌─position('abc', '')─┬─position('abc', '', 0)─┬─position('abc', '', 1)─┬─position('abc', '', 2)─┬─position('abc', '', 3)─┬─position('abc', '', 4)─┬─position('abc', '', 5)─┐
│ 1 │ 1 │ 1 │ 2 │ 3 │ 4 │ 0 │
└─────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┘
```
## positionCaseInsensitive
Introducido en: v1.1.0
Como [`position`](#position), pero sin distinguir entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
positionCaseInsensitive(haystack, needle[, start_pos])
```
**Alias**: `instr`
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string) o [`Enum`](/es/reference/data-types/enum)
* `needle` — Subcadena que se va a buscar. [`String`](/es/reference/data-types/string)
* `start_pos` — Opcional. Posición (con base 1) en `haystack` a partir de la cual comienza la búsqueda. [`UInt*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la posición inicial en bytes, contando desde 1, si se encuentra la subcadena; de lo contrario, devuelve `0`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda sin distinción entre mayúsculas y minúsculas**
```sql title=Query theme={null}
SELECT positionCaseInsensitive('Hello, world!', 'hello')
```
```response title=Response theme={null}
┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│ 1 │
└───────────────────────────────────────────────────┘
```
## positionCaseInsensitiveUTF8
Introducido en: v1.1.0
Como [`positionUTF8`](#positionUTF8), pero busca sin distinción entre mayúsculas y minúsculas.
**Sintaxis**
```sql theme={null}
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string) o [`Enum`](/es/reference/data-types/enum)
* `needle` — Subcadena que se busca. [`String`](/es/reference/data-types/string)
* `start_pos` — Opcional. Posición (basada en 1) de `haystack` en la que comienza la búsqueda. [`UInt*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la posición inicial, en bytes y contando desde 1, si se encuentra la subcadena; de lo contrario, `0`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Búsqueda UTF-8 sin distinción entre mayúsculas y minúsculas**
```sql title=Query theme={null}
SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
```
```response title=Response theme={null}
┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│ 8 │
└──────────────────────────────────────────────────┘
```
## positionUTF8
Introducido en: v1.1.0
Como [`position`](#position), pero supone que `haystack` y `needle` son cadenas codificadas en UTF-8.
**Sintaxis**
```sql theme={null}
positionUTF8(haystack, needle[, start_pos])
```
**Argumentos**
* `haystack` — Cadena en la que se realiza la búsqueda. [`String`](/es/reference/data-types/string) o [`Enum`](/es/reference/data-types/enum)
* `needle` — Subcadena que se debe buscar. [`String`](/es/reference/data-types/string)
* `start_pos` — Opcional. Posición (basada en 1) de `haystack` en la que comienza la búsqueda. [`UInt*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la posición inicial, en bytes y contando desde 1, si se encuentra la subcadena; en caso contrario, `0`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Recuento de caracteres UTF-8**
```sql title=Query theme={null}
SELECT positionUTF8('Motörhead', 'r')
```
```response title=Response theme={null}
┌─position('Motörhead', 'r')─┐
│ 5 │
└────────────────────────────┘
```