Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

Funciones para buscar en cadenas

View as MarkdownEdit this pageReport an issueSet up docs MCP

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.

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.

countMatches

Introducido en: v21.1.0

Devuelve el número de coincidencias de una expresión regular en una cadena.

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

SELECT countMatches('hello 123 world 456 test', '[0-9]+')
┌─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

SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
┌─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

SELECT countSubstrings('aaaa', 'aa');
┌─countSubstrings('aaaa', 'aa')─┐
│                             2 │
└───────────────────────────────┘

Con el argumento start_pos

SELECT countSubstrings('abc___abc', 'abc', 4);
┌─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

SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
┌─countSubstringsCaseInsensitive('AAAA', 'aa')─┐
│                                            2 │
└──────────────────────────────────────────────┘

Con el argumento start_pos

SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
┌─countSubstringsCaseInsensitive('abc___ABC___abc', '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

SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
┌─countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА')─┐
│                                                                  4 │
└────────────────────────────────────────────────────────────────────┘

Con el argumento start_pos

SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
┌─countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 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

SELECT extract('test@clickhouse.com', '.*@(.*)$')
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com                             │
└────────────────────────────────────────────┘

Si no hay coincidencia, se devuelve una cadena vacía

SELECT extract('test@clickhouse.com', 'no_match')
┌─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

SELECT extractAll('hello 123 world 456', '[0-9]+')
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456']                               │
└─────────────────────────────────────────────┘

Extraer con un grupo de captura

SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
┌─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

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]+)');
[['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

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]+)');
['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.

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. Si el índice de texto tiene configurada una expresión de preprocesador, el preprocesador se aplica a needle (si se proporciona como String) antes de la tokenización. Si el índice de texto tiene configurada una expresión de postprocesador, el postprocesador se aplica a los tokens de needle y a los tokens de entrada (es decir, a ambos después de la tokenización).

Los tokens duplicados se ignoran. Por ejemplo, needles = ['ClickHouse', 'ClickHouse'] se trata igual que ['ClickHouse'].

Sintaxis

hasAllTokens(input, needles[, tokenizer])

Alias: hasAllToken

Argumentos

Valor devuelto

Devuelve 1 si todos los needles coinciden. 0 en caso contrario. UInt8

Ejemplos

Uso básico con una aguja de tipo cadena

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAllTokens(msg, 'a\\d()');
┌─count()─┐
│       1 │
└─────────┘

Especificar needles que se buscarán AS-IS (sin tokenización) en un array

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAllTokens(msg, ['a', 'd']);
┌─count()─┐
│       1 │
└─────────┘

Generar needles con la función tokens

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
┌─count()─┐
│       1 │
└─────────┘

Usar un tokenizador personalizado mediante el tercer argumento

SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│                                          1 │
└────────────────────────────────────────────┘

Ejemplos de uso de columnas Array y Map

DROP TABLE IF EXISTS log;

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'});

Ejemplo con una columna de tipo array

DROP TABLE IF EXISTS log;

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'});

SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
┌─count()─┐
│       1 │
└─────────┘

Ejemplo con mapKeys

DROP TABLE IF EXISTS log;

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'});

SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
┌─count()─┐
│       1 │
└─────────┘

Ejemplo con mapValues

DROP TABLE IF EXISTS log;

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'});

SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
┌─count()─┐
│       0 │
└─────────┘

hasAnyTokens

Introducido en: v25.10.0

Devuelve 1 si al menos un token en la cadena o matriz needle coincide con la cadena input, y 0 en caso contrario. Si input es una columna, devuelve todas las filas que cumplan esta condición.

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. Si el índice de texto tiene configurada una expresión de preprocesador, el preprocesador se aplica a needle (si se proporciona como String) antes de la tokenización. Si el índice de texto tiene configurada una expresión de posprocesamiento, el posprocesamiento se aplica a los tokens de needle y a los tokens de input (es decir, a ambos después de la tokenización).

Los tokens duplicados se ignoran. Por ejemplo, ['ClickHouse', 'ClickHouse'] se trata igual que ['ClickHouse'].

Sintaxis

hasAnyTokens(input, needles[, tokenizer])

Aliases: hasAnyToken

Argumentos

Valor devuelto

Devuelve 1 si hubo al menos una coincidencia. 0 en caso contrario. UInt8

Ejemplos

Uso básico con una cadena "needle"

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAnyTokens(msg, 'a\\d()');
┌─count()─┐
│       3 │
└─────────┘

Especifique las cadenas (needles) que se buscarán TAL CUAL (sin tokenización) en un array

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAnyTokens(msg, ['a', 'd']);
┌─count()─┐
│       3 │
└─────────┘

Generar needles con la función tokens

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
┌─count()─┐
│       3 │
└─────────┘

Ejemplos de uso de columnas de array y map

DROP TABLE IF EXISTS log;

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'});

Ejemplo con una columna de array

DROP TABLE IF EXISTS log;

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'});

SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
┌─count()─┐
│       1 │
└─────────┘

Ejemplo con mapKeys

DROP TABLE IF EXISTS log;

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'});

SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
┌─count()─┐
│       2 │
└─────────┘

Ejemplo con mapValues

DROP TABLE IF EXISTS log;

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'});

SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
┌─count()─┐
│       2 │
└─────────┘

hasPhrase

Introducido en: v26.4.0

Comprueba si input contiene todos los tokens de phrase en orden consecutivo.

Antes de realizar la búsqueda, la función tokeniza tanto los argumentos input como phrase mediante el tokenizador especificado para el índice de texto. Si la columna no tiene definido ningún índice de texto, se usará en su lugar el tokenizador splitByNonAlpha, a menos que se proporcione un tokenizador como tercer argumento opcional. El argumento tokenizer debe ser uno de splitByNonAlpha, splitByString, splitByRegexp, ngrams, asciiCJK o icu. Ten en cuenta que splitByRegexp no es compatible con hasPhrase cuando el índice de texto también define un posprocesamiento.

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

SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│                                                     1 │
└───────────────────────────────────────────────────────┘

Tokens no contiguos

SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
┌─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

SELECT hasSubsequence('Hello World', 'HlWrd')
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│                                      1 │
└────────────────────────────────────────┘

No se encontró ninguna subsecuencia

SELECT hasSubsequence('Hello World', 'xyz')
┌─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

SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
┌─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

SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
┌─hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА')─┐
│                                                                                                        1 │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────┘

hasSubsequenceUTF8

Introducido en: v23.7.0

Al igual que hasSubsequence, pero asume que el haystack y la subsecuencia 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

SELECT hasSubsequenceUTF8('картошка', 'кошка');
┌─hasSubsequenceUTF8('картошка', 'кошка')─┐
│                                       1 │
└─────────────────────────────────────────┘

Subsecuencia que no coincide

SELECT hasSubsequenceUTF8('картошка', 'апельсин');
┌─hasSubsequenceUTF8('картошка', 'апельсин')─┐
│                                          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

SELECT hasToken('clickhouse test', 'test')
┌─hasToken('clickhouse test', 'test')─┐
│                                   1 │
└─────────────────────────────────────┘

hasTokenCaseInsensitive

Introducido en: v20.1.0

Realiza una búsqueda de subsecuencia 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 subsecuencia en haystack sin distinguir entre mayúsculas y minúsculas mediante el índice tokenbf_v1. Devuelve NULL si la subsecuencia 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

SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
┌─hasTokenOrNull('apple banana cherry', '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

SELECT highlight('The quick brown fox', ['quick', 'fox'])
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The <em>quick</em> brown <em>fox</em>              │
└────────────────────────────────────────────────────┘

Etiquetas personalizadas

SELECT highlight('Hello World', ['hello'], '<b>', '</b>')
┌─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. Admite la cláusula opcional ESCAPE (consulte like).

Sintaxis

ilike(haystack, pattern[, escape_character])
-- haystack ILIKE pattern [ESCAPE 'escape_character']

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
  • escape_character — Cadena opcional de un solo carácter que se usará como carácter de escape en lugar de \. Valor predeterminado: \. 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

SELECT ilike('ClickHouse', '%house%');
┌─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 \.

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.

cláusula ESCAPE

La cláusula opcional ESCAPE especifica un carácter de escape personalizado (debe ser un único carácter ASCII). Cuando se especifica, el carácter de escape personalizado sustituye la barra invertida predeterminada para escapar los metacaracteres % y _. El carácter de escape puede escapar tres elementos: % (porcentaje literal), _ (guion bajo literal) y a sí mismo (carácter de escape literal). Cuando se usa un carácter de escape personalizado, la barra invertida no tiene ningún significado especial y se interpreta como un carácter literal.

Sintaxis

like(haystack, pattern[, escape_character])
-- haystack LIKE pattern [ESCAPE 'escape_character']

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
  • escape_character — Cadena opcional de un solo carácter que se usa como carácter de escape en lugar de \. Valor predeterminado: \. String

Valor devuelto

Devuelve 1 si la cadena coincide con el patrón LIKE; en caso contrario, 0. UInt8

Ejemplos

Ejemplo de uso

SELECT like('ClickHouse', '%House');
┌─like('ClickHouse', '%House')─┐
│                            1 │
└──────────────────────────────┘

Comodín de un solo carácter

SELECT like('ClickHouse', 'Click_ouse');
┌─like('ClickHouse', 'Click_ouse')─┐
│                                1 │
└──────────────────────────────────┘

Patrón no coincidente

SELECT like('ClickHouse', '%SQL%');
┌─like('ClickHouse', '%SQL%')─┐
│                           0 │
└─────────────────────────────┘

Cláusula ESCAPE

SELECT '50%off' LIKE '50#%off' ESCAPE '#';
┌─like('50%off', '50#%off', '#')─┐
│                              1 │
└────────────────────────────────┘

locate

Introducido en: v18.16.0

Igual que position, pero con los argumentos haystack y locate intercambiados.

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

SELECT locate('ca', 'abcabc')
┌─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 subcadenas, 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 o haystack ~ pattern (al estilo PostgreSQL).

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. Puede ser una constante o provenir de una columna. String

Valor devuelto

Devuelve 1 si el patrón coincide, 0 en caso contrario. UInt8

Ejemplos

Coincidencia de patrones básica

SELECT match('Hello World', 'Hello.*')
┌─match('Hello World', 'Hello.*')─┐
│                               1 │
└─────────────────────────────────┘

El patrón no coincide

SELECT match('Hello World', 'goodbye.*')
┌─match('Hello World', 'goodbye.*')─┐
│                                 0 │
└───────────────────────────────────┘

Coincidencia con una subcadena

SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│                      1 │                        0 │
└────────────────────────┴──────────────────────────┘

matchCaseInsensitive

Introducido en: v26.8.0

Similar a match, pero realiza coincidencias sin distinguir entre mayúsculas y minúsculas.

Esta función utiliza la biblioteca de expresiones regulares RE2. Consulta re2 para ver la sintaxis admitida.

Sintaxis alternativa del operador: haystack ~* pattern (estilo PostgreSQL).

Sintaxis

matchCaseInsensitive(haystack, pattern)
-- haystack ~* pattern

Argumentos

  • haystack — Cadena en la que se busca el patrón. String
  • pattern — Patrón de expresión regular. Puede ser una constante o provenir de una columna. String

Valor devuelto

Devuelve 1 si el patrón coincide sin distinguir entre mayúsculas y minúsculas, 0 en caso contrario. UInt8

Ejemplos

Ejemplo de uso

SELECT matchCaseInsensitive('Hello World', 'hello.*'), 'Hello World' ~
┌─matchCaseInsensitive('Hello World', 'hello.*')─┬─matchCaseInsensitive('Hello World', 'HELLO.*')─┐
│                                              1 │                                              1 │
└────────────────────────────────────────────────┴────────────────────────────────────────────────┘

multiFuzzyMatchAllIndices

Introducido en: v20.1.0

Como multiFuzzyMatchAny, pero devuelve el array con todos los índices, en cualquier orden, que coinciden con el haystack 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

SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
┌─multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House'])─┐
│ [3,1,4,2]                                                                                     │
└───────────────────────────────────────────────────────────────────────────────────────────────┘

multiFuzzyMatchAny

Introducido en: v20.1.0

Como multiMatchAny, pero devuelve 1 si algún patrón coincide con 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.

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 haystack dentro de la distancia de edición especificada; de lo contrario, 0. UInt8

Ejemplos

Ejemplo de uso

SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
┌─multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose'])─┐
│                                                                             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

SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
┌─multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse'])─┐
│                                                                                  2 │
└────────────────────────────────────────────────────────────────────────────────────┘

multiMatchAllIndices

Introducido en: v20.1.0

Como multiMatchAny, pero devuelve un array con todos los índices que coinciden con el haystack, 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

SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
┌─multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', '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

SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

No coincide ningún patrón

SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

multiMatchAnyIndex

Introducido en: v20.1.0

Como multiMatchAny, pero devuelve cualquier índice que encuentre una coincidencia en la cadena haystack.

Sintaxis

multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])

Argumentos

  • haystack — cadena 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

SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
┌─multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', '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

SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
┌─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

SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
┌─multiSearchAllPositionsCaseInsensitive('ClickHouse', ['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

SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
┌─multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР'])─┐
│ [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

SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
┌─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

SELECT multiSearchAny('ClickHouse',['C','H'])
┌─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

SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
┌─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

SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
┌─multiSearchAnyCaseInsensitiveUTF8('Здравствуйте', ['з'])─┐
│                                                        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 界

SELECT multiSearchAnyUTF8('你好，世界', ['你', '界']) AS result
┌─result─┐
│      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

SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
┌─multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server'])─┐
│                                                                             1 │
└───────────────────────────────────────────────────────────────────────────────┘

Comportamiento que distingue entre mayúsculas y minúsculas

SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
┌─multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

No se encontró ninguna coincidencia

SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
┌─multiSearchFirstIndex('Hello World', ['goodbye', '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

SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
┌─multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', '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

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server'])─┐
│                                                                                            1 │
└──────────────────────────────────────────────────────────────────────────────────────────────┘

Tratamiento de mayúsculas y minúsculas en UTF-8

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ'])─┐
│                                                                         1 │
└───────────────────────────────────────────────────────────────────────────┘

No se encontró ninguna coincidencia

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', '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

SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
┌─multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте'])─┐
│                                                                      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

SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
┌─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

SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
┌─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

SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])─┐
│                                                                                      1 │
└────────────────────────────────────────────────────────────────────────────────────────┘

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

SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│                                                                       4 │
└─────────────────────────────────────────────────────────────────────────┘

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

SELECT ngramDistance('ClickHouse', 'ClickHouses')
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│                                 0.06666667 │
└────────────────────────────────────────────┘

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

SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
┌─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

SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
┌─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

SELECT ngramDistanceUTF8('abcde','cde')
┌─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

SELECT ngramSearch('ClickHouse', 'Click')
┌─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

SELECT ngramSearchCaseInsensitive('Hello World','hello')
┌─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

SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│                                               0.57142854 │
└──────────────────────────────────────────────────────────┘

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

SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│                                    0.5 │
└────────────────────────────────────────┘

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. Admite la cláusula opcional ESCAPE (consulte like).

Sintaxis

notILike(haystack, pattern[, escape_character])
-- haystack NOT ILIKE pattern [ESCAPE 'escape_character']

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
  • escape_character — Cadena opcional de un solo carácter que se usará como carácter de escape en lugar de \. Predeterminado: \. 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

SELECT notILike('ClickHouse', '%house%');
┌─notILike('ClickHouse', '%house%')─┐
│                                 0 │
└───────────────────────────────────┘

notLike

Introducido en: v1.1.0

Similar a like, pero invierte el resultado. Admite la cláusula opcional ESCAPE (consulta like).

Sintaxis

notLike(haystack, pattern[, escape_character])
-- haystack NOT LIKE pattern [ESCAPE 'escape_character']

Argumentos

  • haystack — cadena donde se realiza la búsqueda. String o FixedString
  • pattern — Patrón LIKE con el que se compara. String
  • escape_character — Cadena opcional de un solo carácter que se usará como carácter de escape en lugar de \. Valor predeterminado: \. String

Valor devuelto

Devuelve 1 si la cadena no coincide con el patrón LIKE; de lo contrario, 0. UInt8

Ejemplos

Ejemplo de uso

SELECT notLike('ClickHouse', '%House%');
┌─notLike('ClickHouse', '%House%')─┐
│                                0 │
└──────────────────────────────────┘

Patrón no coincidente

SELECT notLike('ClickHouse', '%SQL%');
┌─notLike('ClickHouse', '%SQL%')─┐
│                              1 │
└────────────────────────────────┘

notMatch

Introducido en: v26.8.0

Similar a match, pero niega el resultado: comprueba que la cadena no coincida con el patrón de expresión regular.

Esta función utiliza la biblioteca de expresiones regulares RE2. Consulta re2 para ver la sintaxis admitida.

Sintaxis alternativa del operador: haystack !~ pattern (estilo PostgreSQL).

Sintaxis

notMatch(haystack, pattern)
-- haystack !~ pattern

Argumentos

  • haystack — Cadena en la que se busca el patrón. String
  • pattern — Patrón de expresión regular. Puede ser una constante o provenir de una columna. String

Valor devuelto

Devuelve 0 si el patrón coincide, 1 en caso contrario. UInt8

Ejemplos

Ejemplo de uso

SELECT notMatch('Hello World', 'Hello.*'), 'Hello World' !
┌─notMatch('Hello World', 'Hello.*')─┬─notMatch('Hello World', 'goodbye.*')─┐
│                                  0 │                                    1 │
└────────────────────────────────────┴──────────────────────────────────────┘

notMatchCaseInsensitive

Introducido en: v26.8.0

Similar a matchCaseInsensitive, pero niega el resultado: comprueba que la cadena no coincida con el patrón de expresión regular sin distinguir entre mayúsculas y minúsculas.

Esta función utiliza la biblioteca de expresiones regulares RE2. Consulta re2 para ver la sintaxis admitida.

Sintaxis alternativa del operador: haystack !~* pattern (estilo PostgreSQL).

Sintaxis

notMatchCaseInsensitive(haystack, pattern)
-- haystack !~* pattern

Argumentos

  • haystack — Cadena en la que se busca el patrón. String
  • pattern — Patrón de expresión regular. Puede ser una constante o provenir de una columna. String

Valor devuelto

Devuelve 0 si el patrón coincide sin distinguir entre mayúsculas y minúsculas, 1 en caso contrario. UInt8

Ejemplos

Ejemplo de uso

SELECT notMatchCaseInsensitive('Hello World', 'hello.*'), 'Hello World' !
┌─notMatchCaseInsensitive('Hello World', 'hello.*')─┬─notMatchCaseInsensitive('Hello World', 'GOODBYE.*')─┐
│                                                 0 │                                                   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

SELECT position('Hello, world!', '!')
┌─position('Hello, world!', '!')─┐
│                             13 │
└────────────────────────────────┘

Con el argumento start_pos

SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)
┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│                                 5 │                                 9 │
└───────────────────────────────────┴───────────────────────────────────┘

Sintaxis de needle IN haystack

SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘

Subcadena buscada vacía

SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)
┌─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

SELECT positionCaseInsensitive('Hello, world!', 'hello')
┌─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

SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
┌─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

SELECT positionUTF8('Motörhead', 'r')
┌─positionUTF8('Motörhead', 'r')─┐
│                              5 │
└────────────────────────────────┘
Navigation