ClickHouse/docs/es/sql_reference/functions/string_search_functions.md

machine_translated	machine_translated_rev	toc_priority	toc_title
true	3e185d24c9	41	Para buscar cadenas

Funciones para buscar cadenas

La búsqueda distingue entre mayúsculas y minúsculas de forma predeterminada en todas estas funciones. Hay variantes separadas para la búsqueda insensible a mayúsculas y minúsculas.

posición (pajar, aguja), localizar (pajar, aguja)

Devuelve la posición (en bytes) de la subcadena encontrada en la cadena, comenzando desde 1.

Funciona bajo el supuesto de que la cadena contiene un conjunto de bytes que representan un texto codificado de un solo byte. Si no se cumple esta suposición y un carácter no se puede representar usando un solo byte, la función no lanza una excepción y devuelve algún resultado inesperado. Si el carácter se puede representar usando dos bytes, usará dos bytes y así sucesivamente.

Para una búsqueda sin distinción de mayúsculas y minúsculas, utilice la función positionCaseInsensitive.

Sintaxis

position(haystack, needle)

Apodo: locate(haystack, needle).

Parámetros

• haystack — string, in which substring will to be searched. Cadena.
• needle — substring to be searched. Cadena.

Valores devueltos

• Posición inicial en bytes (contando desde 1), si se encontró subcadena.
• 0, si no se encontró la subcadena.

Tipo: Integer.

Ejemplos

Frase “Hello, world!” contiene un conjunto de bytes que representan un texto codificado de un solo byte. La función devuelve algún resultado esperado:

Consulta:

SELECT position('Hello, world!', '!')

Resultado:

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

La misma frase en ruso contiene caracteres que no se pueden representar usando un solo byte. La función devuelve algún resultado inesperado (uso PosiciónUTF8 función para texto codificado de varios bytes):

Consulta:

SELECT position('Привет, мир!', '!')

Resultado:

┌─position('Привет, мир!', '!')─┐
│                            21 │
└───────────────────────────────┘

positionCaseInsensitive

Lo mismo que posición devuelve la posición (en bytes) de la subcadena encontrada en la cadena, comenzando desde 1. Utilice la función para una búsqueda que no distingue entre mayúsculas y minúsculas.

Funciona bajo el supuesto de que la cadena contiene un conjunto de bytes que representan un texto codificado de un solo byte. Si no se cumple esta suposición y un carácter no se puede representar usando un solo byte, la función no lanza una excepción y devuelve algún resultado inesperado. Si el carácter se puede representar usando dos bytes, usará dos bytes y así sucesivamente.

Sintaxis

positionCaseInsensitive(haystack, needle)

Parámetros

• haystack — string, in which substring will to be searched. Cadena.
• needle — substring to be searched. Cadena.

Valores devueltos

• Posición inicial en bytes (contando desde 1), si se encontró subcadena.
• 0, si no se encontró la subcadena.

Tipo: Integer.

Ejemplo

Consulta:

SELECT positionCaseInsensitive('Hello, world!', 'hello')

Resultado:

┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│                                                 1 │
└───────────────────────────────────────────────────┘

PosiciónUTF8

Devuelve la posición (en puntos Unicode) de la subcadena encontrada en la cadena, comenzando desde 1.

Funciona bajo el supuesto de que la cadena contiene un conjunto de bytes que representan un texto codificado en UTF-8. Si no se cumple esta suposición, la función no produce una excepción y devuelve algún resultado inesperado. Si el carácter se puede representar usando dos puntos Unicode, usará dos y así sucesivamente.

Para una búsqueda sin distinción de mayúsculas y minúsculas, utilice la función PosiciónCasoInsensitiveUTF8.

Sintaxis

positionUTF8(haystack, needle)

Parámetros

• haystack — string, in which substring will to be searched. Cadena.
• needle — substring to be searched. Cadena.

Valores devueltos

• Posición inicial en puntos Unicode (contando desde 1), si se encontró subcadena.
• 0, si no se encontró la subcadena.

Tipo: Integer.

Ejemplos

Frase “Hello, world!” en ruso contiene un conjunto de puntos Unicode que representan un texto codificado de un solo punto. La función devuelve algún resultado esperado:

Consulta:

SELECT positionUTF8('Привет, мир!', '!')

Resultado:

┌─positionUTF8('Привет, мир!', '!')─┐
│                                12 │
└───────────────────────────────────┘

Frase “Salut, étudiante!”, donde el carácter é puede ser representado usando un un punto (U+00E9) o dos puntos (U+0065U+0301) la función se puede devolver algún resultado inesperado:

Consulta de la carta é, que se representa un punto Unicode U+00E9:

SELECT positionUTF8('Salut, étudiante!', '!')

Resultado:

┌─positionUTF8('Salut, étudiante!', '!')─┐
│                                     17 │
└────────────────────────────────────────┘

Consulta de la carta é, que se representa dos puntos Unicode U+0065U+0301:

SELECT positionUTF8('Salut, étudiante!', '!')

Resultado:

┌─positionUTF8('Salut, étudiante!', '!')─┐
│                                     18 │
└────────────────────────────────────────┘

PosiciónCasoInsensitiveUTF8

Lo mismo que PosiciónUTF8, pero no distingue entre mayúsculas y minúsculas. Devuelve la posición (en puntos Unicode) de la subcadena encontrada en la cadena, comenzando desde 1.

Funciona bajo el supuesto de que la cadena contiene un conjunto de bytes que representan un texto codificado en UTF-8. Si no se cumple esta suposición, la función no produce una excepción y devuelve algún resultado inesperado. Si el carácter se puede representar usando dos puntos Unicode, usará dos y así sucesivamente.

Sintaxis

positionCaseInsensitiveUTF8(haystack, needle)

Parámetros

• haystack — string, in which substring will to be searched. Cadena.
• needle — substring to be searched. Cadena.

Valor devuelto

• Posición inicial en puntos Unicode (contando desde 1), si se encontró subcadena.
• 0, si no se encontró la subcadena.

Tipo: Integer.

Ejemplo

Consulta:

SELECT positionCaseInsensitiveUTF8('Привет, мир!', 'Мир')

Resultado:

┌─positionCaseInsensitiveUTF8('Привет, мир!', 'Мир')─┐
│                                                  9 │
└────────────────────────────────────────────────────┘

multiSearchAllPositions

Lo mismo que posición pero devuelve Array posiciones (en bytes) de las subcadenas correspondientes encontradas en la cadena. Las posiciones se indexan a partir de 1.

La búsqueda se realiza en secuencias de bytes sin respecto a la codificación de cadenas y la intercalación.

• Para la búsqueda ASCII sin distinción de mayúsculas y minúsculas, utilice la función multiSearchAllPositionsCaseInsensitive.
• Para buscar en UTF-8, use la función MultiSearchAllPositionsUTF8.
• Para la búsqueda UTF-8 sin distinción de mayúsculas y minúsculas, utilice la función multiSearchAllPositionsCaseInsensitiveUTF8.

Sintaxis

multiSearchAllPositions(haystack, [needle1, needle2, ..., needlen])

Parámetros

• haystack — string, in which substring will to be searched. Cadena.
• needle — substring to be searched. Cadena.

Valores devueltos

• Matriz de posiciones iniciales en bytes (contando desde 1), si se encontró la subcadena correspondiente y 0 si no se encuentra.

Ejemplo

Consulta:

SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])

Resultado:

┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0]                                                          │
└───────────────────────────────────────────────────────────────────┘

MultiSearchAllPositionsUTF8

Ver multiSearchAllPositions.

multiSearchFirstPosition(pajar, [aguja₁, aguja₂, …, needle_y])

Lo mismo que position pero devuelve el desplazamiento más a la izquierda de la cadena haystack que se corresponde con algunas de las agujas.

Para una búsqueda que no distingue entre mayúsculas y minúsculas o / y en formato UTF-8, use funciones multiSearchFirstPositionCaseInsensitive, multiSearchFirstPositionUTF8, multiSearchFirstPositionCaseInsensitiveUTF8.

multiSearchFirstIndex(pajar, [aguja₁, aguja₂, …, needle_y])

Devuelve el índice i (a partir de 1) de la aguja encontrada más a la izquierda_me en la cadena haystack y 0 de lo contrario.

Para una búsqueda que no distingue entre mayúsculas y minúsculas o / y en formato UTF-8, use funciones multiSearchFirstIndexCaseInsensitive, multiSearchFirstIndexUTF8, multiSearchFirstIndexCaseInsensitiveUTF8.

multiSearchAny(pajar, [aguja₁, aguja₂, …, needle_y])

Devuelve 1, si al menos una aguja de cuerda_me coincide con la cadena haystack y 0 de lo contrario.

Para una búsqueda que no distingue entre mayúsculas y minúsculas o / y en formato UTF-8, use funciones multiSearchAnyCaseInsensitive, multiSearchAnyUTF8, multiSearchAnyCaseInsensitiveUTF8.

!!! note "Nota" En todos multiSearch* el número de agujas debe ser inferior a 2⁸ debido a la especificación de implementación.

match (pajar, patrón)

Comprueba si la cadena coincide con la pattern expresión regular. Un re2 expresión regular. El sintaxis de la re2 expresiones regulares es más limitada que la sintaxis de las expresiones regulares de Perl.

Devuelve 0 si no coincide, o 1 si coincide.

Tenga en cuenta que el símbolo de barra invertida (\) se utiliza para escapar en la expresión regular. El mismo símbolo se usa para escapar en literales de cadena. Por lo tanto, para escapar del símbolo en una expresión regular, debe escribir dos barras invertidas (\) en un literal de cadena.

La expresión regular funciona con la cadena como si fuera un conjunto de bytes. La expresión regular no puede contener bytes nulos. Para que los patrones busquen subcadenas en una cadena, es mejor usar LIKE o ‘position’, ya que trabajan mucho más rápido.

multiMatchAny(pajar, [patrón₁, patrón₂, …, pattern_y])

Lo mismo que match, pero devuelve 0 si ninguna de las expresiones regulares coincide y 1 si alguno de los patrones coincide. Se utiliza hyperscan biblioteca. Para que los patrones busquen subcadenas en una cadena, es mejor usar multiSearchAny ya que funciona mucho más rápido.

!!! note "Nota" La longitud de cualquiera de los haystack cadena debe ser inferior a 2³² bytes de lo contrario, se lanza la excepción. Esta restricción tiene lugar debido a la API de hiperscan.

multiMatchAnyIndex(pajar, [patrón₁, patrón₂, …, pattern_y])

Lo mismo que multiMatchAny, pero devuelve cualquier índice que coincida con el pajar.

¿Cómo puedo obtener más información?₁, patrón₂, …, pattern_y])

Lo mismo que multiMatchAny, pero devuelve la matriz de todas las indicaciones que coinciden con el pajar en cualquier orden.

multiFuzzyMatchAny(pajar, distancia, [patrón₁, patrón₂, …, pattern_y])

Lo mismo que multiMatchAny, pero devuelve 1 si algún patrón coincide con el pajar dentro de una constante editar distancia. Esta función también está en modo experimental y puede ser extremadamente lenta. Para obtener más información, consulte documentación de hyperscan.

multiFuzzyMatchAnyIndex(pajar, distancia, [patrón₁, patrón₂, …, pattern_y])

Lo mismo que multiFuzzyMatchAny, pero devuelve cualquier índice que coincida con el pajar dentro de una distancia de edición constante.

multiFuzzyMatchAllIndices(pajar, distancia, [patrón₁, patrón₂, …, pattern_y])

Lo mismo que multiFuzzyMatchAny, pero devuelve la matriz de todos los índices en cualquier orden que coincida con el pajar dentro de una distancia de edición constante.

!!! note "Nota" multiFuzzyMatch* las funciones no admiten expresiones regulares UTF-8, y dichas expresiones se tratan como bytes debido a la restricción de hiperscan.

!!! note "Nota" Para desactivar todas las funciones que utilizan hyperscan, utilice la configuración SET allow_hyperscan = 0;.

extracto(pajar, patrón)

Extrae un fragmento de una cadena utilizando una expresión regular. Si ‘haystack’ no coincide con el ‘pattern’ regex, se devuelve una cadena vacía. Si la expresión regular no contiene subpatrones, toma el fragmento que coincide con toda la expresión regular. De lo contrario, toma el fragmento que coincide con el primer subpatrón.

extractAll(pajar, patrón)

Extrae todos los fragmentos de una cadena utilizando una expresión regular. Si ‘haystack’ no coincide con el ‘pattern’ regex, se devuelve una cadena vacía. Devuelve una matriz de cadenas que consiste en todas las coincidencias con la expresión regular. En general, el comportamiento es el mismo que el ‘extract’ función (toma el primer subpatrón, o la expresión completa si no hay un subpatrón).

como (pajar, patrón), operador de patrón COMO pajar

Comprueba si una cadena coincide con una expresión regular simple. La expresión regular puede contener los metasímbolos % y _.

% indica cualquier cantidad de bytes (incluidos cero caracteres).

_ indica cualquier byte.

Utilice la barra invertida (\) para escapar de metasímbolos. Vea la nota sobre el escape en la descripción del ‘match’ función.

Para expresiones regulares como %needle%, el código es más óptimo y trabaja tan rápido como el position función. Para otras expresiones regulares, el código es el mismo que para ‘match’ función.

notLike(haystack, pattern), haystack NOT LIKE operador de patrón

Lo mismo que ‘like’ pero negativo.

ngramDistance(pajar, aguja)

Calcula la distancia de 4 gramos entre haystack y needle: counts the symmetric difference between two multisets of 4-grams and normalizes it by the sum of their cardinalities. Returns float number from 0 to 1 – the closer to zero, the more strings are similar to each other. If the constant needle o haystack es más de 32Kb, arroja una excepción. Si algunos de los no constantes haystack o needle Las cadenas son más de 32Kb, la distancia es siempre una.

Para la búsqueda sin distinción de mayúsculas y minúsculas o / y en formato UTF-8, use funciones ngramDistanceCaseInsensitive, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8.

ngramSearch(pajar, aguja)

Lo mismo que ngramDistance pero calcula la diferencia no simétrica entre needle y haystack – the number of n-grams from needle minus the common number of n-grams normalized by the number of needle n-gramas. Cuanto más cerca de uno, más probable es needle está en el haystack. Puede ser útil para la búsqueda de cadenas difusas.

Para la búsqueda sin distinción de mayúsculas y minúsculas o / y en formato UTF-8, use funciones ngramSearchCaseInsensitive, ngramSearchUTF8, ngramSearchCaseInsensitiveUTF8.

!!! note "Nota" For UTF-8 case we use 3-gram distance. All these are not perfectly fair n-gram distances. We use 2-byte hashes to hash n-grams and then calculate the (non-)symmetric difference between these hash tables – collisions may occur. With UTF-8 case-insensitive format we do not use fair tolower function – we zero the 5-th bit (starting from zero) of each codepoint byte and first bit of zeroth byte if bytes more than one – this works for Latin and mostly for all Cyrillic letters.

Artículo Original