Saltar al contenido principal
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*() para ello. Las funciones generales de cadenas y las funciones para reemplazar en cadenas se describen por separado.
La documentación que aparece a continuación se genera a partir de la tabla del sistema system.functions.

​
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ónEl 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 
countMatches(haystack, pattern)
Argumentos
  • haystack — La cadena en la que buscar. String
  • pattern — Patrón de expresión regular. String
Valor devuelto Devuelve el número de coincidencias encontradas. UInt64 Ejemplos Contar secuencias de dígitos
Query
SELECT countMatches('hello 123 world 456 test', '[0-9]+')
Response
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│                                                   2 │
└─────────────────────────────────────────────────────┘

​
countMatchesCaseInsensitive

Introducido en: v21.1.0 Como countMatches, pero realiza coincidencias sin distinguir entre mayúsculas y minúsculas. Sintaxis 
countMatchesCaseInsensitive(haystack, pattern)
Argumentos
  • haystack — La cadena en la que se busca. String
  • pattern — Patrón de expresión regular. const String
Valor devuelto Devuelve el número de coincidencias encontradas. UInt64 Ejemplos Recuento sin distinción entre mayúsculas y minúsculas
Query
SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
Response
┌─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 
countSubstrings(haystack, needle[, start_pos])
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String o Enum. - needle — Subcadena que se busca. String. - start_pos — Posición (basada en 1) de haystack en la que comienza la búsqueda. UInt. Opcional.
Valor devuelto El número de ocurrencias. UInt64 Ejemplos Ejemplo de uso
Query
SELECT countSubstrings('aaaa', 'aa');
Response
┌─countSubstrings('aaaa', 'aa')─┐
│                             2 │
└───────────────────────────────┘
Con el argumento start_pos
Query
SELECT countSubstrings('abc___abc', 'abc', 4);
Response
┌─countSubstrings('abc___abc', 'abc', 4)─┐
│                                      1 │
└────────────────────────────────────────┘

​
countSubstringsCaseInsensitive

Introducido en: v21.1.0 Como countSubstrings, pero cuenta sin distinguir entre mayúsculas y minúsculas. Sintaxis 
countSubstringsCaseInsensitive(haystack, needle[, start_pos])
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String o Enum
  • needle — Subcadena que se va a buscar. String
  • start_pos — Opcional. Posición (basada en 1) de haystack en la que comienza la búsqueda. UInt*
Valor devuelto Devuelve el número de apariciones de needle en haystack. UInt64 Ejemplos Ejemplo de uso
Query
SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
Response
┌─countSubstri⋯AAA', 'aa')─┐
│                        2 │
└──────────────────────────┘
Con el argumento start_pos
Query
SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
Response
┌─countSubstri⋯, 'abc', 4)─┐
│                        2 │
└──────────────────────────┘

​
countSubstringsCaseInsensitiveUTF8

Introducido en: v21.1.0 Como countSubstrings, pero cuenta sin distinguir entre mayúsculas y minúsculas y asume que haystack es una cadena UTF-8. Sintaxis 
countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])
Argumentos
  • haystack — Cadena UTF-8 en la que se realiza la búsqueda. String o Enum
  • needle — Subcadena que se va a buscar. String
  • start_pos — Opcional. Posición (basada en 1) de haystack en la que comienza la búsqueda. UInt*
Valor devuelto Devuelve el número de apariciones de needle en haystack. UInt64 Ejemplos Ejemplo de uso
Query
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
Response
┌─countSubstri⋯шка', 'КА')─┐
│                        4 │
└──────────────────────────┘
Con el argumento start_pos
Query
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
Response
┌─countSubstri⋯, 'КА', 13)─┐
│                        2 │
└──────────────────────────┘

​
extract

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 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 
extract(haystack, pattern)
Argumentos
  • haystack — Cadena de la que se extrae. String
  • pattern — Expresión regular que normalmente contiene un grupo de captura. const String
Valor devuelto Devuelve el fragmento extraído como una cadena. String Ejemplos Extraer el dominio de un correo electrónico
Query
SELECT extract('test@clickhouse.com', '.*@(.*)$')
Response
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com                            │
└───────────────────────────────────────────┘
Si no hay coincidencia, se devuelve una cadena vacía
Query
SELECT extract('test@clickhouse.com', 'no_match')
Response
┌─extract('test@clickhouse.com', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

​
extractAll

Introducido en: v1.1.0 Como 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 
extractAll(haystack, pattern)
Argumentos
  • haystack — Cadena de la que se extraen fragmentos. String
  • pattern — Expresión regular que puede contener grupos de captura. const String
Valor devuelto Devuelve un array de fragmentos extraídos. Array(String) Ejemplos Extraer todos los números
Query
SELECT extractAll('hello 123 world 456', '[0-9]+')
Response
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456']                               │
└─────────────────────────────────────────────┘
Extraer con un grupo de captura
Query
SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
Response
┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user']                                                    │
└────────────────────────────────────────────────────────────────────┘

​
extractAllGroupsHorizontal

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 
extractAllGroupsHorizontal(s, regexp)
Argumentos 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)) Ejemplos Ejemplo de uso
Query
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
[['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']]

​
extractGroups

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 o extractAllGroupsVertical. Sintaxis 
extractGroups(s, regexp)
Argumentos 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) Ejemplos Ejemplo de uso
Query
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
['Server','nginx']

​
hasAllTokens

Introducido en: v25.10.0 Similar a 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 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) 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), 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 
hasAllTokens(input, needles)
Alias: hasAllToken Argumentos
  • input — La columna de entrada. String o FixedString o Array(String) o Array(FixedString)
  • needles — tokens que se van a buscar. String o Array(String)
  • 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
Valor devuelto Devuelve 1 si todos los needles coinciden; 0 en caso contrario. UInt8 Ejemplos Uso básico con una aguja de tipo String
Query
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
┌─count()─┐
│       1 │
└─────────┘
Especifique los needles que se buscarán TAL CUAL (sin tokenización) en un array
Query
SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']);
Response
┌─count()─┐
│       1 │
└─────────┘
Generar needles con la función tokens
Query
SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
Response
┌─count()─┐
│       1 │
└─────────┘
Usar un tokenizador personalizado mediante el tercer argumento
Query
SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
Response
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│                                            1 │
└──────────────────────────────────────────────┘
Ejemplos de uso para columnas de tipo array y map
Query
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
Ejemplo con una columna de tipo Array
Query
SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
Response
┌─count()─┐
│       1 │
└─────────┘
Ejemplo con mapKeys
Query
SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
Response
┌─count()─┐
│       1 │
└─────────┘
Ejemplo con mapValues
Query
SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
Response
┌─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 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) 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), 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 
hasAnyTokens(input, needles)
Aliases: hasAnyToken Argumentos Valor devuelto Devuelve 1 si hubo al menos una coincidencia. 0 en caso contrario. UInt8 Ejemplos Uso básico con una aguja de tipo String
Query
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
┌─count()─┐
│       3 │
└─────────┘
Especifique los needles que se buscarán TAL CUAL (sin tokenización) en un array
Query
SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']);
Response
┌─count()─┐
│       3 │
└─────────┘
Generar needles con la función tokens
Query
SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
Response
┌─count()─┐
│       3 │
└─────────┘
Ejemplos de uso para columnas de tipo array y map
Query
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
Ejemplo con una columna de array
Query
SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
Response
┌─count()─┐
│       1 │
└─────────┘
Ejemplo con mapKeys
Query
SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
Response
┌─count()─┐
│       2 │
└─────────┘
Ejemplo con mapValues
Query
SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
Response
┌─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, hasAnyTokens y 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 
hasPhrase(input, phrase[, tokenizer])
Alias: matchPhrase Argumentos
  • input — La columna de entrada. String o FixedString
  • phrase — La frase que se desea buscar. const String
  • tokenizer — El tokenizador que se va a usar. Opcional; el valor predeterminado es splitByNonAlpha. const String
Valor devuelto Devuelve 1 si la frase se encuentra como una secuencia consecutiva de tokens; en caso contrario, 0. UInt8 Ejemplos Búsqueda por frase
Query
SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
Response
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│                                                      1 │
└────────────────────────────────────────────────────────┘
Tokens no contiguos
Query
SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
Response
┌─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 
hasSubsequence(haystack, needle)
Argumentos
  • haystack — haystack en la que se busca la subsecuencia. String
  • needle — needle que se busca. String
Valor devuelto Devuelve 1 si needle es una subsecuencia de haystack; 0 en caso contrario. UInt8 Ejemplos Comprobación básica de subsecuencia
Query
SELECT hasSubsequence('Hello World', 'HlWrd')
Response
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│                                      1 │
└────────────────────────────────────────┘
No se encontró ninguna subsecuencia
Query
SELECT hasSubsequence('Hello World', 'xyz')
Response
┌─hasSubsequence('Hello World', 'xyz')─┐
│                                    0 │
└──────────────────────────────────────┘

​
hasSubsequenceCaseInsensitive

Introducido en: v23.7.0 Igual que hasSubsequence, pero busca sin distinguir entre mayúsculas y minúsculas. Sintaxis 
hasSubsequenceCaseInsensitive(haystack, needle)
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String
  • needle — Subsecuencia que se busca. String
Valor devuelto Devuelve 1 si needle es una subsecuencia de haystack; de lo contrario, 0. UInt8 Ejemplos Ejemplo de uso
Query
SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
Response
┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│                                               1 │
└─────────────────────────────────────────────────┘

​
hasSubsequenceCaseInsensitiveUTF8

Introducido en: v23.7.0 Igual que hasSubsequenceUTF8, pero busca sin distinguir entre mayúsculas y minúsculas. Sintaxis 
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
Argumentos
  • haystack — cadena codificada en UTF8 en la que se realiza la búsqueda. String
  • needle — subsecuencia codificada en UTF8 que se busca. String
Valor devuelto Devuelve 1 si needle es una subsecuencia de haystack, y 0 en caso contrario. UInt8 Ejemplos Ejemplo de uso
Query
SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
Response
┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│                        1 │
└──────────────────────────┘

​
hasSubsequenceUTF8

Introducido en: v23.7.0 Al igual que hasSubsequence, pero asume que el haystack y la subcadena buscada están codificadas en UTF-8. Sintaxis 
hasSubsequenceUTF8(haystack, needle)
Argumentos
  • haystack — La cadena en la que buscar. String
  • needle — La subsecuencia que buscar. String
Valor devuelto Devuelve 1 si needle es una subsecuencia de haystack; en caso contrario, 0. UInt8 Ejemplos Ejemplo de uso
Query
SELECT hasSubsequenceUTF8('картошка', 'кошка');
Response
┌─hasSubsequen⋯', 'кошка')─┐
│                        1 │
└──────────────────────────┘
Subsecuencia que no coincide
Query
SELECT hasSubsequenceUTF8('картошка', 'апельсин');
Response
┌─hasSubsequen⋯'апельсин')─┐
│                        0 │
└──────────────────────────┘

​
hasToken

Introducido en: v20.1.0 Comprueba si el token indicado está presente en el haystack. Utiliza 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 
hasToken(haystack, token)
Argumentos
  • haystack — haystack en la que se busca. String
  • token — Token que se busca. const String
Valor devuelto Devuelve 1 si se encuentra el token; de lo contrario, 0. UInt8 Ejemplos Búsqueda de un token
Query
SELECT hasToken('clickhouse test', 'test')
Response
┌─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 
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 
hasTokenCaseInsensitiveOrNull(haystack, needle)
Argumentos
  • Ninguno.
Valor devuelto Ejemplos

​
hasTokenOrNull

Introducido en: v20.1.0 Igual que hasToken, pero devuelve NULL si el token no está bien formado. Sintaxis 
hasTokenOrNull(haystack, token)
Argumentos
  • haystack — Cadena en la que se buscará. Debe ser constante. String
  • token — Token que se debe buscar. const 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) Ejemplos Ejemplo de uso
Query
SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
Response
┌─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 
highlight(haystack, needles[, open_tag, close_tag])
Argumentos
  • haystack — El texto en el que se busca. String o FixedString
  • needles — Un array de términos de búsqueda que se resaltarán. const Array(String)
  • open_tag — La etiqueta de apertura que se inserta antes de cada coincidencia. Valor predeterminado: <em>. const String
  • close_tag — La etiqueta de cierre que se inserta después de cada coincidencia. Valor predeterminado: </em>. const String
Valor devuelto Devuelve el texto de entrada con los términos coincidentes delimitados por las etiquetas especificadas. String Ejemplos Resaltado básico
Query
SELECT highlight('The quick brown fox', ['quick', 'fox'])
Response
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The <em>quick</em> brown <em>fox</em>              │
└────────────────────────────────────────────────────┘
Etiquetas personalizadas
Query
SELECT highlight('Hello World', ['hello'], '<b>', '</b>')
Response
┌─highlight('Hello World', ['hello'], '<b>', '</b>')─┐
│ <b>Hello</b> World                                 │
└────────────────────────────────────────────────────┘

​
ilike

Introducido en: v20.6.0 Igual que like, pero busca sin distinguir entre mayúsculas y minúsculas. Sintaxis 
ilike(haystack, pattern)
-- haystack ILIKE pattern
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String o FixedString
  • pattern — Patrón LIKE con el que se debe coincidir. 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 Ejemplos Ejemplo de uso
Query
SELECT ilike('ClickHouse', '%house%');
Response
┌─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, 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 
like(haystack, pattern)
-- haystack LIKE pattern
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String o 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
Valor devuelto Devuelve 1 si la cadena coincide con el patrón LIKE; en caso contrario, 0. UInt8 Ejemplos Ejemplo de uso
Query
SELECT like('ClickHouse', '%House');
Response
┌─like('ClickHouse', '%House')─┐
│                            1 │
└──────────────────────────────┘
Comodín de un solo carácter
Query
SELECT like('ClickHouse', 'Click_ouse');
Response
┌─like('ClickH⋯lick_ouse')─┐
│                        1 │
└──────────────────────────┘
Patrón no coincidente
Query
SELECT like('ClickHouse', '%SQL%');
Response
┌─like('ClickHouse', '%SQL%')─┐
│                           0 │
└─────────────────────────────┘

​
locate

Introducido en: v18.16.0 Igual que position, pero con los argumentos haystack y locate intercambiados.
Comportamiento según la versiónEl 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 
locate(needle, haystack[, start_pos])
Argumentos
  • needle — needle que se debe buscar. String
  • haystack — Cadena en la que se realiza la búsqueda. String o Enum
  • start_pos — Opcional. Posición (a partir de 1) en haystack donde comienza la búsqueda. UInt
Valor devuelto Devuelve la posición inicial en bytes, contando desde 1, si se encontró la subcadena; 0 si no se encontró. UInt64 Ejemplos Uso básico
Query
SELECT locate('ca', 'abcabc')
Response
┌─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 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 o position, que son mucho más rápidas que esta función. Sintaxis alternativa del operador: haystack REGEXP pattern. Sintaxis 
match(haystack, pattern)
Alias: REGEXP_MATCHES Argumentos
  • haystack — Cadena en la que se busca el patrón. String
  • pattern — Patrón de expresión regular. const String
Valor devuelto Devuelve 1 si el patrón coincide, 0 en caso contrario. UInt8 Ejemplos Coincidencia de patrones básica
Query
SELECT match('Hello World', 'Hello.*')
Response
┌─match('Hello World', 'Hello.*')─┐
│                               1 │
└─────────────────────────────────┘
El patrón no coincide
Query
SELECT match('Hello World', 'goodbye.*')
Response
┌─match('Hello World', 'goodbye.*')─┐
│                                 0 │
└───────────────────────────────────┘
Coincidencia con una subcadena
Query
SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
Response
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│                       1 │                         0 │
└─────────────────────────┴───────────────────────────┘

​
multiFuzzyMatchAllIndices

Introducido en: v20.1.0 Como 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 constante. Sintaxis 
multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])
Argumentos
  • haystack — String en la que se realiza la búsqueda. String
  • distance — La distancia de edición máxima para la coincidencia difusa. UInt8
  • pattern — Array de patrones con los que se realiza la coincidencia. Array(String)
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) Ejemplos Ejemplo de uso
Query
SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
Response
┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2]                │
└──────────────────────────┘

​
multiFuzzyMatchAny

Introducido en: v20.1.0 Como multiMatchAny, pero devuelve 1 si algún patrón coincide con el haystack dentro de una distancia de edición constante. Esta función se basa en una característica experimental de la biblioteca hyperscan 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 
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])
Argumentos
  • haystack — haystack donde se realiza la búsqueda. String
  • distance — La distancia máxima de edición para la coincidencia difusa. UInt8
  • pattern — Opcional. Un array de patrones con los que buscar coincidencias. Array(String)
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 Ejemplos Ejemplo de uso
Query
SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
Response
┌─multiFuzzyMa⋯lickHose'])─┐
│                        1 │
└──────────────────────────┘

​
multiFuzzyMatchAnyIndex

Introducido en: v20.1.0 Igual que multiFuzzyMatchAny, pero devuelve cualquier índice que coincida con el haystack dentro de una distancia de edición constante. Sintaxis 
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])
Argumentos
  • haystack — haystack en la que se realiza la búsqueda. String
  • distance — La distancia de edición máxima para la coincidencia difusa. UInt8
  • pattern — Array de patrones con los que se compara. Array(String)
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 Ejemplos Ejemplo de uso
Query
SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
Response
┌─multiFuzzyMa⋯ickHouse'])─┐
│                        2 │
└──────────────────────────┘

​
multiMatchAllIndices

Introducido en: v20.1.0 Como multiMatchAny, pero devuelve un array con todos los índices que coinciden con el texto de entrada, en cualquier orden. Sintaxis 
multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])
Argumentos
  • haystack — String en la que se realiza la búsqueda. String
  • pattern — Expresiones regulares con las que buscar coincidencias. 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) Ejemplos Ejemplo de uso
Query
SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
Response
┌─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; funciona mucho más rápido que esta función. Sintaxis 
multiMatchAny(haystack, pattern1[, pattern2, ...])
Argumentos
  • haystack — Cadena en la que se buscan los patrones. String
  • pattern1[, pattern2, ...] — Un array de uno o más patrones de expresiones regulares. Array(String)
Valor devuelto Devuelve 1 si coincide algún patrón; de lo contrario, 0. UInt8 Ejemplos Coincidencia de varios patrones
Query
SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
Response
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│                                                  1 │
└────────────────────────────────────────────────────┘
No coincide ningún patrón
Query
SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
Response
┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

​
multiMatchAnyIndex

Introducido en: v20.1.0 Como multiMatchAny, pero devuelve cualquier índice que encuentre una coincidencia en el haystack. Sintaxis 
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])
Argumentos
  • haystack — haystack en la que se realiza la búsqueda. String
  • pattern — Expresiones regulares con las que buscar coincidencias. Array(String)
Valor devuelto Devuelve el índice (a partir de 1) del primer patrón que coincide, o 0 si no se encuentra ninguna coincidencia. UInt64 Ejemplos Ejemplo de uso
Query
SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
Response
┌─multiMatchAn⋯, 'Click'])─┐
│                        3 │
└──────────────────────────┘

​
multiSearchAllPositions

Introducido en: v20.1.0 Como 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 
multiSearchAllPositions(haystack, needle1[, needle2, ...])
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String
  • needle1[, needle2, ...] — Un array de una o más subcadenas que se buscan. Array(String)
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) Ejemplos Búsqueda de múltiples subcadenas
Query
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
Response
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0]                                                          │
└───────────────────────────────────────────────────────────────────┘

​
multiSearchAllPositionsCaseInsensitive

Introducido en: v20.1.0 Igual que multiSearchAllPositions, pero no distingue entre mayúsculas y minúsculas. Sintaxis 
multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String
  • needle1[, needle2, ...] — Un array de una o más subcadenas que se van a buscar. Array(String)
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) Ejemplos Búsqueda múltiple sin distinción entre mayúsculas y minúsculas
Query
SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
Response
┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6]                    │
└──────────────────────────┘

​
multiSearchAllPositionsCaseInsensitiveUTF8

Introducido en: v20.1.0 Como multiSearchAllPositionsUTF8, pero ignora mayúsculas y minúsculas. Sintaxis 
multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Argumentos
  • haystack — cadena codificada en UTF-8 en la que se realiza la búsqueda. String
  • needle — subcadenas codificadas en UTF-8 que se deben buscar. Array(String)
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 Ejemplos Búsqueda en UTF-8 sin distinción entre mayúsculas y minúsculas
Query
SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
Response
┌─multiSearchA⋯й', 'МИР'])─┐
│ [1, 13]                  │
└──────────────────────────┘

​
multiSearchAllPositionsUTF8

Introducido en: v20.1.0 Como multiSearchAllPositions, pero supone que haystack y las subcadenas needle son cadenas codificadas en UTF-8. Sintaxis 
multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])
Argumentos
  • haystack — Cadena codificada en UTF-8 en la que se realiza la búsqueda. String
  • needle1[, needle2, ...] — Un array de subcadenas codificadas en UTF-8 que se deben buscar. Array(String)
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 Ejemplos Búsqueda múltiple en UTF-8
Query
SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
Response
┌─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, multiSearchAnyUTF8 y multiSearchAnyCaseInsensitiveUTF8 ofrecen variantes sin distinción entre mayúsculas y minúsculas y/o UTF-8 de esta función. Sintaxis 
multiSearchAny(haystack, needle1[, needle2, ...])
Argumentos
  • haystack — haystack en la que se realiza la búsqueda. String
  • needle1[, needle2, ...] — Un array de subcadenas que se buscarán. Array(String)
Valor devuelto Devuelve 1 si hubo al menos una coincidencia; de lo contrario, 0 si no hubo ninguna coincidencia. UInt8 Ejemplos Búsqueda de cualquier coincidencia
Query
SELECT multiSearchAny('ClickHouse',['C','H'])
Response
┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│                                        1 │
└──────────────────────────────────────────┘

​
multiSearchAnyCaseInsensitive

Introducido en: v20.1.0 Como multiSearchAny, pero no distingue entre mayúsculas y minúsculas. Sintaxis 
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
Argumentos
  • haystack — String en la que se realiza la búsqueda. String
  • needle — Subcadenas que se buscarán. Array(String)
Valor devuelto Devuelve 1 si hubo al menos una coincidencia sin distinción entre mayúsculas y minúsculas; de lo contrario, 0. UInt8 Ejemplos Búsqueda sin distinción entre mayúsculas y minúsculas
Query
SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
Response
┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│                                                       1 │
└─────────────────────────────────────────────────────────┘

​
multiSearchAnyCaseInsensitiveUTF8

Introducida en: v20.1.0 Como multiSearchAnyUTF8, pero no distingue entre mayúsculas y minúsculas. Sintaxis 
multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Argumentos
  • haystack — cadena UTF-8 en la que se realiza la búsqueda. String
  • needle — subcadenas UTF-8 que se buscan. Array(String)
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 Ejemplos Dada una cadena UTF-8 ‘Здравствуйте’, compruebe si el carácter ‘з’ (en minúscula) está presente
Query
SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
Response
┌─multiSearchA⋯те', ['з'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchAnyUTF8

Introducido en: v20.1.0 Igual que multiSearchAny, pero supone que haystack y las subcadenas needle están codificadas en UTF-8. Sintaxis 
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
Argumentos
  • haystack — cadena UTF-8 en la que se realiza la búsqueda. String
  • needle — subcadenas UTF-8 que se buscan. Array(String)
Valor devuelto Devuelve 1 si hubo al menos una coincidencia; en caso contrario, 0 si no la hubo. UInt8 Ejemplos Dada ‘你好，世界’ (‘Hello, world’) como cadena UTF-8, comprueba si la cadena contiene algún carácter 你 o 界
Query
SELECT multiSearchAnyUTF8('你好，世界', ['你', '界'])
Response
┌─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 
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
Argumentos
  • haystack — La cadena en la que se busca. String
  • needles — Array de cadenas que se buscan. Array(String)
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 Ejemplos Ejemplo de uso
Query
SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
Response
┌─multiSearchF⋯ 'Server'])─┐
│                        1 │
└──────────────────────────┘
Comportamiento que distingue entre mayúsculas y minúsculas
Query
SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
Response
┌─multiSearchF⋯ 'Server'])─┐
│                        2 │
└──────────────────────────┘
No se encontró ninguna coincidencia
Query
SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
Response
┌─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 
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String
  • needle — Subcadenas que se van a buscar. Array(String)
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 Ejemplos Ejemplo de uso
Query
SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
Response
┌─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 
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Argumentos
  • haystack — La cadena en la que se busca. String
  • needles — Array de cadenas que se buscan. Array(String)
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 Ejemplos Ejemplo de uso
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
Response
┌─multiSearchF⋯ 'server'])─┐
│                        1 │
└──────────────────────────┘
Tratamiento de mayúsculas y minúsculas en UTF-8
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
Response
┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│                        1 │
└──────────────────────────┘
No se encontró ninguna coincidencia
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
Response
┌─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 
multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])
Argumentos
  • haystack — cadena UTF-8 en la que se realiza la búsqueda. String
  • needle — Array de subcadenas UTF-8 que se van a buscar. Array(String)
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 Ejemplos Ejemplo de uso
Query
SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
Response
┌─multiSearchF⋯вствуйте'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstPosition

Introducido en: v20.1.0 Como 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, multiSearchFirstPositionUTF8 y multiSearchFirstPositionCaseInsensitiveUTF8 proporcionan variantes de esta función sin distinción entre mayúsculas y minúsculas y/o en UTF-8. Sintaxis 
multiSearchFirstPosition(haystack, needle1[, needle2, ...])
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String
  • needle1[, needle2, ...] — Un array de una o más subcadenas que se van a buscar. Array(String)
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 Ejemplos Búsqueda de la primera posición
Query
SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
Response
┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│                                                             3 │
└───────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionCaseInsensitive

Introducido en: v20.1.0 Como multiSearchFirstPosition, pero ignora mayúsculas y minúsculas. Sintaxis 
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String
  • needle — Array de subcadenas que se van a buscar. Array(String)
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 Ejemplos Primera posición sin distinguir entre mayúsculas y minúsculas
Query
SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
Response
┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionCaseInsensitiveUTF8

Introducido en: v20.1.0 Como multiSearchFirstPosition, pero asume que haystack y needle son cadenas UTF-8 y no distingue entre mayúsculas y minúsculas. Sintaxis 
multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Argumentos
  • haystack — cadena UTF-8 en la que se realiza la búsqueda. String
  • needle — Array de subcadenas UTF-8 que se van a buscar. Array(String)
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 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
Query
SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
Response
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['мир', 'вст', 'Здра'])─┐
│                                                                                      3 │
└────────────────────────────────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionUTF8

Introducido en: v20.1.0 Igual que multiSearchFirstPosition, pero supone que haystack y needle son cadenas UTF-8. Sintaxis 
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
Argumentos
  • haystack — cadena UTF-8 en la que se realiza la búsqueda. String
  • needle — Array de subcadenas UTF-8 que se buscarán. Array(String)
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 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
Query
SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
Response
┌─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, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8. Sintaxis 
ngramDistance(haystack, needle)
Argumentos
  • haystack — Cadena de comparación. String
  • needle — Cadena de comparación. 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 Ejemplos Calcular la distancia de 4-gramas
Query
SELECT ngramDistance('ClickHouse', 'ClickHouses')
Response
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│                                        0.1 │
└────────────────────────────────────────────┘

​
ngramDistanceCaseInsensitive

Introducido en: v20.1.0 Proporciona una variante de 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 
ngramDistanceCaseInsensitive(haystack, needle)
Argumentos
  • haystack — Primera cadena de comparación. String
  • needle — Segunda cadena de comparación. String
Valor devuelto Devuelve un número de tipo Float32 entre 0 y 1. Float32 Ejemplos Distancia de 4-gramas sin distinción entre mayúsculas y minúsculas
Query
SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
Response
┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐
│                                                       0 │
└─────────────────────────────────────────────────────────┘

​
ngramDistanceCaseInsensitiveUTF8

Introducido en: v20.1.0 Proporciona una variante UTF-8 de 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 
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
Argumentos
  • haystack — Primera cadena de comparación codificada en UTF-8. String
  • needle — Segunda cadena de comparación codificada en UTF-8. String
Valor devuelto Devuelve un valor Float32 entre 0 y 1. Float32 Ejemplos Distancia de 3-gramas UTF-8 sin distinción entre mayúsculas y minúsculas
Query
SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
Response
┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐
│                                             0.5 │
└─────────────────────────────────────────────────┘

​
ngramDistanceUTF8

Introducido en: v20.1.0 Proporciona una variante UTF-8 de 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 
ngramDistanceUTF8(haystack, needle)
Argumentos
  • haystack — Primera cadena de comparación en UTF-8. String
  • needle — Segunda cadena de comparación en UTF-8. String
Valor devuelto Devuelve un número Float32 entre 0 y 1. Float32 Ejemplos Distancia de 3-gramas en UTF-8
Query
SELECT ngramDistanceUTF8('abcde','cde')
Response
┌─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 
ngramSearch(haystack, needle)
Argumentos
  • haystack — Cadena para comparar. String
  • needle — Cadena para comparar. 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 Ejemplos Búsqueda con 4-gramas
Query
SELECT ngramSearch('ClickHouse', 'Click')
Response
┌─ngramSearch('ClickHouse', 'Click')─┐
│                                  1 │
└────────────────────────────────────┘

​
ngramSearchCaseInsensitive

Introducido en: v20.1.0 Proporciona una variante sin distinción entre mayúsculas y minúsculas de 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 
ngramSearchCaseInsensitive(haystack, needle)
Argumentos
  • haystack — Cadena para comparar. String
  • needle — Cadena para comparar. 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 Ejemplos Búsqueda sin distinción entre mayúsculas y minúsculas con 4-gramas
Query
SELECT ngramSearchCaseInsensitive('Hello World','hello')
Response
┌─ngramSearchCaseInsensitive('Hello World','hello')─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

​
ngramSearchCaseInsensitiveUTF8

Introducido en: v20.1.0 Proporciona una variante UTF-8 de 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 
ngramSearchCaseInsensitiveUTF8(haystack, needle)
Argumentos
  • haystack — cadena UTF-8 para comparación. String
  • needle — cadena UTF-8 para comparación. 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 Ejemplos Búsqueda UTF-8 sin distinción entre mayúsculas y minúsculas mediante 3-gramas
Query
SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
Response
┌─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 
ngramSearchUTF8(haystack, needle)
Argumentos
  • haystack — cadena UTF-8 para comparar. String
  • needle — cadena UTF-8 para comparar. 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 Ejemplos Búsqueda UTF-8 mediante 3-gramas
Query
SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
Response
┌─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 
notILike(haystack, pattern)
Argumentos
  • haystack — La cadena de entrada en la que se busca. String o 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
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 Ejemplos Ejemplo de uso
Query
SELECT notILike('ClickHouse', '%house%');
Response
┌─notILike('Cl⋯ '%house%')─┐
│                        0 │
└──────────────────────────┘

​
notLike

Introducido en: v1.1.0 Similar a like, pero invierte el resultado. Sintaxis 
notLike(haystack, pattern)
-- haystack NOT LIKE pattern
Argumentos
  • haystack — String donde se realiza la búsqueda. String o FixedString
  • pattern — Patrón LIKE con el que se compara. String
Valor devuelto Devuelve 1 si la cadena no coincide con el patrón LIKE; de lo contrario, 0. UInt8 Ejemplos Ejemplo de uso
Query
SELECT notLike('ClickHouse', '%House%');
Response
┌─notLike('Cli⋯ '%House%')─┐
│                        0 │
└──────────────────────────┘
Patrón no coincidente
Query
SELECT notLike('ClickHouse', '%SQL%');
Response
┌─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, positionCaseInsensitive, positionUTF8 y positionCaseInsensitiveUTF8. Sintaxis 
position(haystack, needle[, start_pos])
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String o Enum
  • needle — Subcadena que se va a buscar. String
  • start_pos — Posición (basada en 1) en haystack en la que comienza la búsqueda. Opcional. 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 Ejemplos Uso básico
Query
SELECT position('Hello, world!', '!')
Response
┌─position('Hello, world!', '!')─┐
│                             13 │
└────────────────────────────────┘
Con el argumento start_pos
Query
SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)
Response
┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│                                 5 │                                 9 │
└───────────────────────────────────┴───────────────────────────────────┘
Sintaxis de needle IN haystack
Query
SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
Response
┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘
Subcadena buscada vacía
Query
SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)
Response
┌─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, pero sin distinguir entre mayúsculas y minúsculas. Sintaxis 
positionCaseInsensitive(haystack, needle[, start_pos])
Alias: instr Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String o Enum
  • needle — Subcadena que se va a buscar. String
  • start_pos — Opcional. Posición (con base 1) en haystack a partir de la cual comienza la búsqueda. UInt*
Valor devuelto Devuelve la posición inicial en bytes, contando desde 1, si se encuentra la subcadena; de lo contrario, devuelve 0. UInt64 Ejemplos Búsqueda sin distinción entre mayúsculas y minúsculas
Query
SELECT positionCaseInsensitive('Hello, world!', 'hello')
Response
┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│                                                 1 │
└───────────────────────────────────────────────────┘

​
positionCaseInsensitiveUTF8

Introducido en: v1.1.0 Como positionUTF8, pero busca sin distinción entre mayúsculas y minúsculas. Sintaxis 
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String o Enum
  • needle — Subcadena que se busca. String
  • start_pos — Opcional. Posición (basada en 1) de haystack en la que comienza la búsqueda. UInt*
Valor devuelto Devuelve la posición inicial, en bytes y contando desde 1, si se encuentra la subcadena; de lo contrario, 0. UInt64 Ejemplos Búsqueda UTF-8 sin distinción entre mayúsculas y minúsculas
Query
SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
Response
┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│                                                8 │
└──────────────────────────────────────────────────┘

​
positionUTF8

Introducido en: v1.1.0 Como position, pero supone que haystack y needle son cadenas codificadas en UTF-8. Sintaxis 
positionUTF8(haystack, needle[, start_pos])
Argumentos
  • haystack — Cadena en la que se realiza la búsqueda. String o Enum
  • needle — Subcadena que se debe buscar. String
  • start_pos — Opcional. Posición (basada en 1) de haystack en la que comienza la búsqueda. UInt*
Valor devuelto Devuelve la posición inicial, en bytes y contando desde 1, si se encuentra la subcadena; en caso contrario, 0. UInt64 Ejemplos Recuento de caracteres UTF-8
Query
SELECT positionUTF8('Motörhead', 'r')
Response
┌─position('Motörhead', 'r')─┐
│                          5 │
└────────────────────────────┘
Última modificación el 10 de junio de 2026