> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-parallel-read-in-order-multi-part.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Documentación sobre funciones de cadena

# Funciones para trabajar con cadenas

export const VersionBadge = ({minVersion}) => <div className="versionBadge">
    <div className="versionIcon" style={{
  marginRight: "8px",
  marginTop: "4px"
}}>
      <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
        <path d="M5 14C5.82843 14 6.5 13.3284 6.5 12.5C6.5 11.6716 5.82843 11 5 11C4.17157 11 3.5 11.6716 3.5 12.5C3.5 13.3284 4.17157 14 5 14Z" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="1.25" />
        <path d="M5 5C5.82843 5 6.5 4.32843 6.5 3.5C6.5 2.67157 5.82843 2 5 2C4.17157 2 3.5 2.67157 3.5 3.5C3.5 4.32843 4.17157 5 5 5Z" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="1.25" />
        <path d="M13 10.5C13.8284 10.5 14.5 9.82843 14.5 9C14.5 8.17157 13.8284 7.5 13 7.5C12.1716 7.5 11.5 8.17157 11.5 9C11.5 9.82843 12.1716 10.5 13 10.5Z" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="1.25" />
        <path d="M11.5 9H9.5C9.03426 9 8.57493 8.89157 8.15836 8.68328C7.74179 8.475 7.37944 8.17259 7.1 7.8L5 5V11" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="1.25" />
      </svg>
    </div>
    Disponible a partir de la versión {minVersion}
  </div>;

Las funciones para [buscar](/es/reference/functions/regular-functions/string-search-functions) en cadenas y para [reemplazar](/es/reference/functions/regular-functions/string-replace-functions) en cadenas se describen por separado.

<Note>
  La documentación siguiente se genera a partir de la tabla del sistema `system.functions`.
</Note>

## CRC32

Introducido en: v20.1.0

Calcula la suma de comprobación CRC32 de una cadena mediante el polinomio CRC-32-IEEE 802.3 y el valor inicial `0xffffffff` (implementación de zlib).

**Sintaxis**

```sql theme={null}
CRC32(s)
```

**Argumentos**

* `s` — Cadena para la que se calcula CRC32. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la suma de comprobación CRC32 de la cadena. [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT CRC32('ClickHouse')
```

```response title=Response theme={null}
┌─CRC32('ClickHouse')─┐
│          1538217360 │
└─────────────────────┘
```

## CRC32IEEE

Introducida en: v20.1.0

Calcula la suma de comprobación CRC32 de una cadena utilizando el polinomio CRC-32-IEEE 802.3.

**Sintaxis**

```sql theme={null}
CRC32IEEE(s)
```

**Argumentos**

* `s` — Cadena para la que se calcula CRC32. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la suma de comprobación CRC32 de la cadena. [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT CRC32IEEE('ClickHouse');
```

```response title=Response theme={null}
┌─CRC32IEEE('ClickHouse')─┐
│              3089448422 │
└─────────────────────────┘
```

## CRC64

Introducido en: v20.1.0

Calcula la suma de comprobación CRC64 de una cadena utilizando el polinomio CRC-64-ECMA.

**Sintaxis**

```sql theme={null}
CRC64(s)
```

**Argumentos**

* `s` — Cadena para la que se calcula CRC64. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la suma de comprobación CRC64 de la cadena. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT CRC64('ClickHouse');
```

```response title=Response theme={null}
┌──CRC64('ClickHouse')─┐
│ 12126588151325169346 │
└──────────────────────┘
```

## appendTrailingCharIfAbsent

Introducido en: v1.1.0

Añade el carácter `c` a la cadena `s` si `s` no está vacía y no termina con el carácter `c`.

**Sintaxis**

```sql theme={null}
appendTrailingCharIfAbsent(s, c)
```

**Argumentos**

* `s` — Cadena de entrada. [`String`](/es/reference/data-types/string)
* `c` — Carácter que se añade si no está presente. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la cadena `s` con el carácter `c` añadido si `s` no termina en `c`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT appendTrailingCharIfAbsent('https://example.com', '/');
```

```response title=Response theme={null}
┌─appendTrailingCharIfAbsent('https://example.com', '/')─┐
│ https://example.com/                                   │
└────────────────────────────────────────────────────────┘
```

## ascii

Introducido en: v22.11.0

Devuelve el punto de código ASCII del primer carácter de la cadena `s` como un valor `Int32`.

**Sintaxis**

```sql theme={null}
ascii(s)
```

**Argumentos**

* `s` — Cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el código ASCII del primer carácter. Si `s` está vacío, el resultado es `0`. Si el primer carácter no es un carácter ASCII o no pertenece al rango de suplemento Latin-1 de UTF-16, el resultado no está definido. [`Int32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT ascii('234')
```

```response title=Response theme={null}
┌─ascii('234')─┐
│           50 │
└──────────────┘
```

## base32Decode

Introducido en: v25.6.0

Decodifica una cadena en [Base32](https://datatracker.ietf.org/doc/html/rfc4648#section-6) (RFC 4648).
Si la cadena no es una codificación Base32 válida, se lanza una excepción.

**Sintaxis**

```sql theme={null}
base32Decode(encoded)
```

**Argumentos**

* `encoded` — columna de tipo String o constante. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena que contiene el valor decodificado del argumento. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT base32Decode('IVXGG33EMVSA====');
```

```response title=Response theme={null}
┌─base32Decode('IVXGG33EMVSA====')─┐
│ Encoded                          │
└──────────────────────────────────┘
```

## base32Encode

Introducido en: v25.6.0

Codifica una cadena en [Base32](https://datatracker.ietf.org/doc/html/rfc4648#section-6).

**Sintaxis**

```sql theme={null}
base32Encode(plaintext)
```

**Argumentos**

* `plaintext` — texto plano que se va a codificar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena que contiene el valor codificado del argumento. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT base32Encode('Encoded')
```

```response title=Response theme={null}
┌─base32Encode('Encoded')─┐
│ IVXGG33EMVSA====        │
└─────────────────────────┘
```

## base58Decode

Introducido en: v22.7.0

Decodifica una cadena [Base58](https://datatracker.ietf.org/doc/html/draft-msporny-base58-03#section-3).
Si la cadena no es una codificación Base58 válida, se lanza una excepción.
Se puede proporcionar un segundo argumento opcional, `expected_size`, para exigir un tamaño decodificado: una entrada que
no se decodifique en exactamente esa cantidad de bytes se rechaza y la función lanza una excepción (o
devuelve una cadena vacía en `tryBase58Decode`). El requisito se aplica a cualquier tamaño y `0` significa
que no hay ningún requisito.

**Sintaxis**

```sql theme={null}
base58Decode(encoded[, expected_size])
```

**Argumentos**

* `encoded` — Columna `String` o constante para decodificar. [`String`](/es/reference/data-types/string)
* `expected_size` — Opcional. Tamaño requerido del valor decodificado en bytes: se rechaza una entrada que se decodifique a cualquier otro tamaño. `0` no impone ningún requisito. [`UInt8, UInt16, UInt32, or UInt64`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una cadena con el valor decodificado del argumento. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT base58Decode('JxF12TrwUP45BMd');
```

```response title=Response theme={null}
┌─base58Decode('JxF12TrwUP45BMd')─┐
│ Hello World                     │
└─────────────────────────────────┘
```

## base58Encode

Introducido en: v22.7.0

Codifica una cadena en [Base58](https://datatracker.ietf.org/doc/html/draft-msporny-base58-01).

**Sintaxis**

```sql theme={null}
base58Encode(plaintext)
```

**Argumentos**

* `plaintext` — texto plano que se va a codificar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena que contiene el valor codificado del argumento. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT base58Encode('ClickHouse');
```

```response title=Response theme={null}
┌─base58Encode('ClickHouse')─┐
│ 4nhk8K7GHXf6zx             │
└────────────────────────────┘
```

## base64Decode

Introducido en: v18.16.0

Decodifica una cadena a partir de su representación en [Base64](https://en.wikipedia.org/wiki/Base64), de acuerdo con RFC 4648.
Desde la versión 26.7, se ignoran en la entrada los caracteres de espacio en blanco: espacio, tabulación (`\t`), salto de línea (`\n`), retorno de carro (`\r`) y avance de página (`\f`) (las versiones anteriores rechazaban las entradas que los contenían). La tabulación vertical (`\v`) y cualquier otro carácter fuera del alfabeto Base64 se rechazan.
Lanza una excepción en caso de error.

**Sintaxis**

```sql theme={null}
base64Decode(encoded)
```

**Alias**: `FROM_BASE64`

**Argumentos**

* `encoded` — Columna `String` o constante que se debe decodificar. Si la cadena no está codificada en Base64 de forma válida, se genera una excepción. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la cadena decodificada. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT base64Decode('Y2xpY2tob3VzZQ==')
```

```response title=Response theme={null}
┌─base64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse                       │
└──────────────────────────────────┘
```

## base64Encode

Introducido en: v18.16.0

Codifica una cadena en formato [Base64](https://en.wikipedia.org/wiki/Base64), según la RFC 4648.

**Sintaxis**

```sql theme={null}
base64Encode(plaintext)
```

**Alias**: `TO_BASE64`

**Argumentos**

* `plaintext` — Columna o constante de texto plano que se va a decodificar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena que contiene el valor codificado del argumento. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT base64Encode('clickhouse')
```

```response title=Response theme={null}
┌─base64Encode('clickhouse')─┐
│ Y2xpY2tob3VzZQ==           │
└────────────────────────────┘
```

## base64URLDecode

Introducido en: v24.6.0

Decodifica una cadena desde su representación en [Base64](https://en.wikipedia.org/wiki/Base64) usando un alfabeto seguro para URL, de acuerdo con la RFC 4648.
El alfabeto estándar (`+` y `/`) también se acepta al decodificar.
Desde la versión 26.7, se ignoran en la entrada los caracteres de espacio en blanco: espacio, tabulación (`\t`), salto de línea (`\n`), retorno de carro (`\r`) y salto de página (`\f`) (las versiones anteriores rechazaban las entradas que los contenían). La tabulación vertical (`\v`) y cualquier otro carácter que no pertenezca al alfabeto Base64 se rechazan.
Lanza una excepción en caso de error.

**Sintaxis**

```sql theme={null}
base64URLDecode(encoded)
```

**Argumentos**

* `encoded` — Columna String o constante para codificar. Si la cadena no está codificada en Base64 de forma válida, se lanza una excepción. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena que contiene el valor decodificado del argumento. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')
```

```response title=Response theme={null}
┌─base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')─┐
│ https://clickhouse.com                            │
└───────────────────────────────────────────────────┘
```

## base64URLEncode

Introducido en: v18.16.0

Codifica una cadena utilizando la representación [Base64](https://datatracker.ietf.org/doc/html/rfc4648#section-4) (RFC 4648) con un alfabeto apto para URL.

**Sintaxis**

```sql theme={null}
base64URLEncode(plaintext)
```

**Argumentos**

* `plaintext` — Columna o constante de texto plano para codificar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena con el valor codificado del argumento. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT base64URLEncode('https://clickhouse.com')
```

```response title=Response theme={null}
┌─base64URLEncode('https://clickhouse.com')─┐
│ aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ            │
└───────────────────────────────────────────┘
```

## basename

Introducido en: v20.1.0

Extrae la parte final de una cadena tras la última barra o barra invertida.
Esta función se utiliza a menudo para extraer el nombre del archivo de una ruta.

**Sintaxis**

```sql theme={null}
basename(expr)
```

**Argumentos**

* `expr` — Una expresión de tipo cadena. Las barras invertidas deben escaparse. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la parte final de la cadena de entrada después de la última barra o barra invertida. Si la cadena de entrada termina con una barra o una barra invertida, la función devuelve una cadena vacía. Devuelve la cadena original si no contiene barras ni barras invertidas. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Extraer el nombre de archivo de una ruta de Unix**

```sql title=Query theme={null}
SELECT 'some/long/path/to/file' AS a, basename(a)
```

```response title=Response theme={null}
┌─a──────────────────────┬─basename(a)─┐
│ some/long/path/to/file │ file        │
└────────────────────────┴─────────────┘
```

**Extraer el nombre de archivo de una ruta de Windows**

```sql title=Query theme={null}
SELECT 'some\\long\\path\\to\\file' AS a, basename(a)
```

```response title=Response theme={null}
┌─a──────────────────────┬─basename(a)─┐
│ some\long\path\to\file │ file        │
└────────────────────────┴─────────────┘
```

**Cadena sin separadores de ruta**

```sql title=Query theme={null}
SELECT 'some-file-name' AS a, basename(a)
```

```response title=Response theme={null}
┌─a──────────────┬─basename(a)────┐
│ some-file-name │ some-file-name │
└────────────────┴────────────────┘
```

## byteHammingDistance

Introducido en: v23.9.0

Calcula la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre dos cadenas de bytes.

**Sintaxis**

```sql theme={null}
byteHammingDistance(s1, s2)
```

**Alias**: `mismatches`

**Argumentos**

* `s1` — Primera cadena de entrada. [`String`](/es/reference/data-types/string)
* `s2` — Segunda cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la distancia de Hamming entre ambas cadenas. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT byteHammingDistance('karolin', 'kathrin')
```

```response title=Response theme={null}
┌─byteHammingDistance('karolin', 'kathrin')─┐
│                                         3 │
└───────────────────────────────────────────┘
```

## caseFoldUTF8

Introducido en: v26.3.0

Aplica el case folding de Unicode a una cadena UTF-8, convirtiéndola en una forma normalizada similar a minúsculas adecuada para comparaciones sin distinción entre mayúsculas y minúsculas.

Aplica el case folding estándar de Unicode. Conserva los caracteres de compatibilidad que no se ven afectados por el case folding
(p. ej., números romanos, números con círculo), pero tenga en cuenta que algunas ligaduras, como `ffi`, siguen descomponiéndose porque el propio case folding de Unicode las expande.

**Sintaxis**

```sql theme={null}
caseFoldUTF8(str)
```

**Argumentos**

* `str` — Cadena de entrada codificada en UTF-8. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Cadena UTF-8 con normalización de mayúsculas y minúsculas. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Normalización básica de mayúsculas y minúsculas**

```sql title=Query theme={null}
SELECT caseFoldUTF8('Straße')
```

```response title=Response theme={null}
┌─caseFoldUTF8('Straße')─┐
│ strasse                │
└────────────────────────┘
```

## compareSubstrings

Introducido en: v25.2.0

Compara dos cadenas en orden lexicográfico.

**Sintaxis**

```sql theme={null}
compareSubstrings(s1, s2, s1_offset, s2_offset, num_bytes)
```

**Argumentos**

* `s1` — La primera cadena que se comparará. [`String`](/es/reference/data-types/string)
* `s2` — La segunda cadena que se comparará. [`String`](/es/reference/data-types/string)
* `s1_offset` — La posición (indexada desde cero) en `s1` a partir de la cual comienza la comparación. [`UInt*`](/es/reference/data-types/int-uint)
* `s2_offset` — La posición (índice basado en cero) en `s2` a partir de la cual comienza la comparación. [`UInt*`](/es/reference/data-types/int-uint)
* `num_bytes` — El número máximo de bytes que se comparará en ambas cadenas. Si `s1_offset` (o `s2_offset`) + `num_bytes` supera el final de una cadena de entrada, `num_bytes` se reducirá en consecuencia. [`UInt*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve:

* `-1` si `s1`\[`s1_offset` : `s1_offset` + `num_bytes`] \< `s2`\[`s2_offset` : `s2_offset` + `num_bytes`].
* `0` si `s1`\[`s1_offset` : `s1_offset` + `num_bytes`] = `s2`\[`s2_offset` : `s2_offset` + `num_bytes`].
* `1` si `s1`\[`s1_offset` : `s1_offset` + `num_bytes`] > `s2`\[`s2_offset` : `s2_offset` + `num_bytes`].
  [`Int8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT compareSubstrings('Saxony', 'Anglo-Saxon', 0, 6, 5) AS result
```

```response title=Response theme={null}
┌─result─┐
│      0 │
└────────┘
```

## concat

Introducido en: v1.1.0

Concatena los argumentos especificados.

Los argumentos que no son de tipo [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) se convierten en cadenas mediante su serialización predeterminada.
Como esto reduce el rendimiento, no se recomienda usar argumentos distintos de String/FixedString.

**Sintaxis**

```sql theme={null}
concat([s1, s2, ...])
```

**Argumentos**

* `s1, s2, ...` — Cualquier cantidad de valores de cualquier tipo. [`Any`](/es/reference/data-types/index)

**Valor devuelto**

Devuelve la cadena creada al concatenar los argumentos. Si alguno de los argumentos es `NULL`, la función devuelve `NULL`. Si no hay argumentos, devuelve una cadena vacía. [`Nullable(String)`](/es/reference/data-types/nullable)

**Ejemplos**

**Concatenación de cadenas**

```sql title=Query theme={null}
SELECT concat('Hello, ', 'World!')
```

```response title=Response theme={null}
┌─concat('Hello, ', 'World!')─┐
│ Hello, World!               │
└─────────────────────────────┘
```

**Concatenación de números**

```sql title=Query theme={null}
SELECT concat(42, 144)
```

```response title=Response theme={null}
┌─concat(42, 144)─┐
│ 42144           │
└─────────────────┘
```

## concatAssumeInjective

Introducido en: v1.1.0

Como [`concat`](#concat), pero asume que `concat(s1, s2, ...) → sn` es inyectiva,
es decir, que devuelve resultados distintos para argumentos distintos.

Puede utilizarse para optimizar `GROUP BY`.

**Sintaxis**

```sql theme={null}
concatAssumeInjective([s1, s2, ...])
```

**Argumentos**

* `s1, s2, ...` — Cualquier cantidad de valores de tipo arbitrario. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve la cadena resultante de concatenar los argumentos. Si alguno de los valores de los argumentos es `NULL`, la función devuelve `NULL`. Si no se pasa ningún argumento, devuelve una cadena vacía. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Optimización de GROUP BY**

```sql title=Query theme={null}
CREATE TABLE key_val (key1 String, key2 String, value UInt32) ENGINE = Memory;
INSERT INTO key_val VALUES ('Hello, ', 'World!', 1), ('Hello, ', 'World!', 2), ('Hello, ', 'World', 3);

SELECT concatAssumeInjective(key1, key2) AS key, sum(value) FROM key_val GROUP BY key ORDER BY key;
```

```response title=Response theme={null}
┌─key───────────┬─sum(value)─┐
│ Hello, World  │          3 │
│ Hello, World! │          3 │
└───────────────┴────────────┘
```

## concatWithSeparator

Introducido en: v22.12.0

Concatena las cadenas proporcionadas, separadas por el separador especificado.

**Sintaxis**

```sql theme={null}
concatWithSeparator(sep[, exp1, exp2, ...])
```

**Alias**: `concat_ws`

**Argumentos**

* `sep` — El separador que se usará. [`const String`](/es/reference/data-types/string) o [`const FixedString`](/es/reference/data-types/fixedstring)
* `exp1, exp2, ...` — Expresiones que se concatenarán. Los argumentos que no sean de tipo `String` o `FixedString` se convierten en cadenas mediante su serialización predeterminada. Como esto reduce el rendimiento, no se recomienda usar argumentos distintos de `String`/`FixedString`. [`Any`](/es/reference/data-types/index)

**Valor devuelto**

Devuelve la cadena creada al concatenar los argumentos. Si alguno de los valores de los argumentos es `NULL`, la función devuelve `NULL`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT concatWithSeparator('a', '1', '2', '3', '4')
```

```response title=Response theme={null}
┌─concatWithSeparator('a', '1', '2', '3', '4')─┐
│ 1a2a3a4                                      │
└──────────────────────────────────────────────┘
```

## concatWithSeparatorAssumeInjective

Introducido en: v22.12.0

Como [`concatWithSeparator`](#concatWithSeparator), pero asume que `concatWithSeparator(sep[,exp1, exp2, ... ]) → result` es inyectiva.
Se considera inyectiva una función si devuelve resultados distintos para argumentos distintos.

Puede usarse para optimizar `GROUP BY`.

**Sintaxis**

```sql theme={null}
concatWithSeparatorAssumeInjective(sep[, exp1, exp2, ... ])
```

**Argumentos**

* `sep` — El separador que se va a utilizar. [`const String`](/es/reference/data-types/string) o [`const FixedString`](/es/reference/data-types/fixedstring)
* `exp1, exp2, ...` — Expresión que se va a concatenar. Los argumentos que no sean de tipo `String` o `FixedString` se convierten en cadenas mediante su serialización predeterminada. Como esto reduce el rendimiento, no se recomienda usar argumentos que no sean `String`/`FixedString`. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve la cadena creada al concatenar los argumentos. Si alguno de los valores de los argumentos es `NULL`, la función devuelve `NULL`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
CREATE TABLE user_data (
user_id UInt32,
first_name String,
last_name String,
score UInt32
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO user_data VALUES
(1, 'John', 'Doe', 100),
(2, 'Jane', 'Smith', 150),
(3, 'John', 'Wilson', 120),
(4, 'Jane', 'Smith', 90);

SELECT
    concatWithSeparatorAssumeInjective('-', first_name, last_name) as full_name,
    sum(score) as total_score
FROM user_data
GROUP BY concatWithSeparatorAssumeInjective('-', first_name, last_name);
```

```response title=Response theme={null}
┌─full_name───┬─total_score─┐
│ Jane-Smith  │         240 │
│ John-Doe    │         100 │
│ John-Wilson │         120 │
└─────────────┴─────────────┘
```

## conv

Introducido en: v25.10.0

Convierte números entre distintas bases numéricas.

La función convierte un número de una base a otra. Admite bases de 2 a 36.
Para bases superiores a 10, se usan las letras A-Z (sin distinguir entre mayúsculas y minúsculas) para representar los dígitos del 10 al 35.

Esta función es compatible con la función CONV() de MySQL.

**Sintaxis**

```sql theme={null}
conv(number, from_base, to_base)
```

**Argumentos**

* `number` — El número que se va a convertir. Puede ser una cadena o un tipo numérico. - `from_base` — La base de origen (2-36). Debe ser un entero. - `to_base` — La base de destino (2-36). Debe ser un entero.

**Valor devuelto**

Representación textual del número en la base de destino.

**Ejemplos**

**Convertir de decimal a binario**

```sql title=Query theme={null}
SELECT conv('10', 10, 2)
```

```response title=Response theme={null}
1010
```

**Convertir de hexadecimal a decimal**

```sql title=Query theme={null}
SELECT conv('FF', 16, 10)
```

```response title=Response theme={null}
255
```

**Conversión con número negativo**

```sql title=Query theme={null}
SELECT conv('-1', 10, 16)
```

```response title=Response theme={null}
FFFFFFFFFFFFFFFF
```

**Convertir de binario a octal**

```sql title=Query theme={null}
SELECT conv('1010', 2, 8)
```

```response title=Response theme={null}
12
```

## convertCharset

Introducido en: v1.1.0

Devuelve la cadena `s` convertida desde la codificación `from` a la codificación `to`.

**Sintaxis**

```sql theme={null}
convertCharset(s, from, to)
```

**Argumentos**

* `s` — Cadena de entrada. [`String`](/es/reference/data-types/string)
* `from` — Codificación de caracteres de origen. [`String`](/es/reference/data-types/string)
* `to` — Codificación de caracteres de destino. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la cadena `s` convertida de la codificación `from` a `to`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT convertCharset('Café', 'UTF-8', 'ISO-8859-1');
```

```response title=Response theme={null}
┌─convertCharset('Café', 'UTF-8', 'ISO-8859-1')─┐
│ Caf�                                           │
└───────────────────────────────────────────────┘
```

## damerauLevenshteinDistance

Introducido en: v24.1.0

Calcula la [distancia de Damerau-Levenshtein](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance) entre dos cadenas de bytes.

**Sintaxis**

```sql theme={null}
damerauLevenshteinDistance(s1, s2)
```

**Argumentos**

* `s1` — Primera cadena de entrada. [`String`](/es/reference/data-types/string)
* `s2` — Segunda cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la distancia de Damerau-Levenshtein entre las dos cadenas. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT damerauLevenshteinDistance('clickhouse', 'mouse')
```

```response title=Response theme={null}
┌─damerauLevenshteinDistance('clickhouse', 'mouse')─┐
│                                                 6 │
└───────────────────────────────────────────────────┘
```

## decodeHTMLComponent

Introducido en: v23.9.0

Decodifica las entidades HTML de una cadena y las convierte en sus caracteres correspondientes.

**Sintaxis**

```sql theme={null}
decodeHTMLComponent(s)
```

**Argumentos**

* `s` — Cadena que contiene entidades HTML que se deben decodificar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la cadena con las entidades HTML decodificadas. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT decodeHTMLComponent('&lt;div&gt;Hello &amp; &quot;World&quot;&lt;/div&gt;')
```

```response title=Response theme={null}
┌─decodeHTMLComponent('&lt;div&gt;Hello &amp; &quot;World&quot;&lt;/div&gt;')─┐
│ <div>Hello & "World"</div>                                                  │
└─────────────────────────────────────────────────────────────────────────────┘
```

## decodeXMLComponent

Introducido en: v21.2.0

Decodifica las entidades XML de una cadena en sus caracteres correspondientes.

**Sintaxis**

```sql theme={null}
decodeXMLComponent(s)
```

**Argumentos**

* `s` — Cadena que contiene entidades XML que se deben decodificar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la cadena proporcionada con las entidades XML decodificadas. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT decodeXMLComponent('&lt;tag&gt;Hello &amp; World&lt;/tag&gt;')
```

```response title=Response theme={null}
┌─decodeXMLComponent('&lt;tag&gt;Hello &amp; World&lt;/tag&gt;')─┐
│ <tag>Hello & World</tag>                                       │
└────────────────────────────────────────────────────────────────┘
```

## editDistance

Introducido en: v23.9.0

Calcula la [distancia de edición](https://en.wikipedia.org/wiki/Edit_distance) entre dos cadena de bytes.

**Sintaxis**

```sql theme={null}
editDistance(s1, s2)
```

**Alias**: `levenshteinDistance`

**Argumentos**

* `s1` — Primera cadena de entrada. [`String`](/es/reference/data-types/string)
* `s2` — Segunda cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la distancia de edición entre ambas cadenas. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT editDistance('clickhouse', 'mouse')
```

```response title=Response theme={null}
┌─editDistance('clickhouse', 'mouse')─┐
│                                   6 │
└─────────────────────────────────────┘
```

## editDistanceUTF8

Introducido en: v24.6.0

Calcula la [distancia de edición](https://en.wikipedia.org/wiki/Edit_distance) entre dos cadenas en UTF-8.

**Sintaxis**

```sql theme={null}
editDistanceUTF8(s1, s2)
```

**Alias**: `levenshteinDistanceUTF8`

**Argumentos**

* `s1` — Primera cadena de entrada. [`String`](/es/reference/data-types/string)
* `s2` — Segunda cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la distancia de edición entre las dos cadenas UTF-8. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT editDistanceUTF8('我是谁', '我是我') AS distance
```

```response title=Response theme={null}
┌─distance─┐
│        1 │
└──────────┘
```

## encodeXMLComponent

Introducido en: v21.1.0

Escapa caracteres para insertar una cadena en un nodo de texto XML o en un atributo.

**Sintaxis**

```sql theme={null}
encodeXMLComponent(s)
```

**Argumentos**

* `s` — Cadena que se debe escapar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la cadena escapada. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    '<tag>Hello & "World"</tag>' AS original,
    encodeXMLComponent('<tag>Hello & "World"</tag>') AS xml_encoded;
```

```response title=Response theme={null}
┌─original───────────────────┬─xml_encoded──────────────────────────────────────────┐
│ <tag>Hello & "World"</tag> │ &lt;tag&gt;Hello &amp; &quot;World&quot;&lt;/tag&gt; │
└────────────────────────────┴──────────────────────────────────────────────────────┘
```

## endsWith

Introducido en: v1.1.0

Comprueba si una cadena termina con el sufijo indicado.

**Sintaxis**

```sql theme={null}
endsWith(s, suffix)
```

**Argumentos**

* `s` — Cadena a comprobar. [`String`](/es/reference/data-types/string)
* `suffix` — Sufijo a comprobar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `1` si `s` termina con `suffix`; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT endsWith('ClickHouse', 'House');
```

```response title=Response theme={null}
┌─endsWith('ClickHouse', 'House')─┐
│                               1 │
└─────────────────────────────────┘
```

## endsWithCaseInsensitive

Introducido en: v25.10.0

Verifica si una cadena termina con el sufijo especificado sin distinguir entre mayúsculas y minúsculas.

**Sintaxis**

```sql theme={null}
endsWithCaseInsensitive(s, suffix)
```

**Argumentos**

* `s` — Cadena que se va a comprobar. [`String`](/es/reference/data-types/string)
* `suffix` — Sufijo sin distinguir entre mayúsculas y minúsculas que se va a comprobar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `1` si `s` termina con el `suffix` sin distinguir entre mayúsculas y minúsculas; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT endsWithCaseInsensitive('ClickHouse', 'HOUSE');
```

```response title=Response theme={null}
┌─endsWithCaseInsensitive('ClickHouse', 'HOUSE')─┐
│                                              1 │
└────────────────────────────────────────────────┘
```

## endsWithCaseInsensitiveUTF8

Introducido en: v25.10.0

Devuelve si la cadena `s` termina con el `suffix` sin distinguir entre mayúsculas y minúsculas.
Asume que la cadena contiene texto válido codificado en UTF-8.
Si no se cumple esta condición, no se lanza ninguna excepción y el resultado es indefinido.

**Sintaxis**

```sql theme={null}
endsWithCaseInsensitiveUTF8(s, suffix)
```

**Argumentos**

* `s` — String que se debe comprobar. [`String`](/es/reference/data-types/string)
* `suffix` — Sufijo que se debe comprobar sin distinguir entre mayúsculas y minúsculas. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `1` si `s` termina con el `suffix` sin distinguir entre mayúsculas y minúsculas; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT endsWithCaseInsensitiveUTF8('данных', 'ых');
```

```response title=Response theme={null}
┌─endsWithCaseInsensitiveUTF8('данных', 'ых')─┐
│                                           1 │
└─────────────────────────────────────────────┘
```

## endsWithUTF8

Introducido en: v23.8.0

Devuelve si la cadena `s` termina con suffix.
Asume que la cadena contiene texto válido codificado en UTF-8.
Si no se cumple esta suposición, no se lanza ninguna excepción y el resultado es indefinido.

**Sintaxis**

```sql theme={null}
endsWithUTF8(s, suffix)
```

**Argumentos**

* `s` — String que se va a comprobar. [`String`](/es/reference/data-types/string)
* `suffix` — Sufijo que se va a comprobar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `1` si `s` termina con `suffix`; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT endsWithUTF8('данных', 'ых');
```

```response title=Response theme={null}
┌─endsWithUTF8('данных', 'ых')─┐
│                            1 │
└──────────────────────────────┘
```

## extractTextFromHTML

Introducido en: v21.3.0

Extrae el contenido de texto de HTML o XHTML.

Esta función elimina las etiquetas HTML, los comentarios y los elementos script/style, y deja únicamente el contenido de texto. Gestiona lo siguiente:

* La eliminación de todas las etiquetas HTML/XML
* La eliminación de comentarios (`{/* */}`)
* La eliminación de los elementos script y style junto con su contenido
* El procesamiento de secciones CDATA (copiadas literalmente)
* El tratamiento y la normalización correctos de los espacios en blanco

Nota: las entidades HTML no se decodifican y deben procesarse con una función aparte si es necesario.

**Sintaxis**

```sql theme={null}
extractTextFromHTML(html)
```

**Argumentos**

* `html` — Cadena con contenido HTML del que se extrae el texto. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el contenido de texto extraído con espacios en blanco normalizados. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT extractTextFromHTML('
<html>
    <head><title>Page Title</title></head>
    <body>
        <p>Hello <b>World</b>!</p>
        <script>alert("test");</script>
        <!-- comment -->
    </body>
</html>
');
```

```response title=Response theme={null}
┌─extractTextFromHTML('\n<html>\n    <head><title>Page Title</title></head>\n    <body>\n        <p>Hello <b>World</b>!</p>\n        <script>alert("test");</script>\n        <!-- comment -->\n    </body>\n</html>\n')─┐
│ Page Title Hello World !                                                                                                                                                                                               │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```

## firstLine

Introducido en: v23.7.0

Devuelve la primera línea de una cadena multilínea.

**Sintaxis**

```sql theme={null}
firstLine(s)
```

**Argumentos**

* `s` — Cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la primera línea de la cadena de entrada o la cadena completa si no hay separadores de línea. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT firstLine('foo\\nbar\\nbaz')
```

```response title=Response theme={null}
┌─firstLine('foo\\nbar\\nbaz')─┐
│ foo\nbar\nbaz                │
└──────────────────────────────┘
```

## idnaDecode

Introducido en: v24.1.0

Devuelve la representación Unicode (UTF-8) (algoritmo ToUnicode) de un nombre de dominio según el mecanismo [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA).
En caso de error (por ejemplo, porque la entrada no es válida), se devuelve la cadena de entrada.
Tenga en cuenta que el uso repetido de [`idnaEncode()`](#idnaEncode) y [`idnaDecode()`](#idnaDecode) no devuelve necesariamente la cadena original debido a la normalización de mayúsculas y minúsculas.

**Sintaxis**

```sql theme={null}
idnaDecode(s)
```

**Argumentos**

* `s` — Cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una representación Unicode (UTF-8) de la cadena de entrada según el mecanismo IDNA correspondiente al valor de entrada. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')
```

```response title=Response theme={null}
┌─idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')─┐
│ straße.münchen.de                             │
└───────────────────────────────────────────────┘
```

## idnaEncode

Introducido en: v24.1.0

Devuelve la representación ASCII (algoritmo ToASCII) de un nombre de dominio según el mecanismo [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA).
La cadena de entrada debe estar codificada en UTF y poder convertirse en una cadena ASCII; de lo contrario, se lanza una excepción.

<Note>
  No se realiza ninguna decodificación de porcentajes ni se eliminan tabulaciones, espacios o caracteres de control.
</Note>

**Sintaxis**

```sql theme={null}
idnaEncode(s)
```

**Argumentos**

* `s` — Cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una representación ASCII de la cadena de entrada conforme al mecanismo IDNA. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT idnaEncode('straße.münchen.de')
```

```response title=Response theme={null}
┌─idnaEncode('straße.münchen.de')─┐
│ xn--strae-oqa.xn--mnchen-3ya.de │
└─────────────────────────────────┘
```

## initcap

Introducido en: v23.7.0

Convierte la primera letra de cada palabra en mayúscula y el resto en minúsculas.
Las palabras son secuencias de caracteres alfanuméricos separadas por caracteres no alfanuméricos.

<Note>
  Como `initcap` solo convierte a mayúscula la primera letra de cada palabra, es posible que observe un comportamiento inesperado en palabras que contienen apóstrofos o letras mayúsculas.
  Este es un comportamiento conocido y actualmente no está previsto corregirlo.
</Note>

**Sintaxis**

```sql theme={null}
initcap(s)
```

**Argumentos**

* `s` — Cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `s` con la primera letra de cada palabra en mayúscula. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT initcap('building for fast')
```

```response title=Response theme={null}
┌─initcap('building for fast')─┐
│ Building For Fast            │
└──────────────────────────────┘
```

**Ejemplo del comportamiento conocido con palabras que contienen apóstrofos o letras mayúsculas**

```sql title=Query theme={null}
SELECT initcap('John''s cat won''t eat.');
```

```response title=Response theme={null}
┌─initcap('John\'s cat won\'t eat.')─┐
│ John'S Cat Won'T Eat.              │
└────────────────────────────────────┘
```

## initcapUTF8

Introducido en: v23.7.0

Al igual que [`initcap`](#initcap), `initcapUTF8` convierte la primera letra de cada palabra en mayúscula y el resto en minúsculas.
Se asume que la cadena contiene texto válido codificado en UTF-8.
Si no se cumple esta suposición, no se lanza ninguna excepción y el resultado no está definido.

<Note>
  Esta función no detecta el idioma; por ejemplo, para el turco, el resultado podría no ser exactamente correcto (i/İ vs. i/I).
  Si la longitud de la secuencia de bytes UTF-8 difiere entre las formas en mayúsculas y minúsculas de un punto de código, el resultado puede ser incorrecto para ese punto de código.
</Note>

**Sintaxis**

```sql theme={null}
initcapUTF8(s)
```

**Argumentos**

* `s` — Cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `s` con la primera letra de cada palabra en mayúscula. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT initcapUTF8('не тормозит')
```

```response title=Response theme={null}
┌─initcapUTF8('не тормозит')─┐
│ Не Тормозит                │
└────────────────────────────┘
```

## isValidASCII

Introducido en: v25.9.0

Devuelve 1 si el valor de entrada de tipo String o FixedString contiene solo bytes ASCII (0x00–0x7F); en caso contrario, 0. Está optimizado para el caso positivo (la entrada *es* ASCII válida).

**Sintaxis**

```sql theme={null}
isValidASCII(str)
```

**Alias**: `isASCII`

**Argumentos**

* Ninguno.

**Valor devuelto**

**Ejemplos**

**isValidASCII**

```sql title=Query theme={null}
SELECT isValidASCII('hello') AS is_ascii, isValidASCII('你好') AS is_not_ascii
```

```response title=Response theme={null}
┌─is_ascii─┬─is_not_ascii─┐
│        1 │            0 │
└──────────┴──────────────┘
```

## isValidUTF8

Introducido en: v20.1.0

Comprueba si la secuencia de bytes forma un texto válido codificado en UTF-8.

**Sintaxis**

```sql theme={null}
isValidUTF8(s)
```

**Argumentos**

* `s` — La cadena cuya validez de codificación UTF-8 se comprobará. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `1` si el conjunto de bytes constituye texto válido codificado en UTF-8; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT isValidUTF8('\\xc3\\xb1') AS valid, isValidUTF8('\\xc3\\x28') AS invalid
```

```response title=Response theme={null}
┌─valid─┬─invalid─┐
│     1 │       1 │
└───────┴─────────┘
```

## jaroSimilarity

Introducido en: v24.1.0

Calcula la [similitud de Jaro](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance#Jaro_similarity) entre dos cadenas de bytes.

**Sintaxis**

```sql theme={null}
jaroSimilarity(s1, s2)
```

**Argumentos**

* `s1` — Primera cadena de entrada. [`String`](/es/reference/data-types/string)
* `s2` — Segunda cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la similitud Jaro entre ambas cadenas. [`Float64`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT jaroSimilarity('clickhouse', 'click')
```

```response title=Response theme={null}
┌─jaroSimilarity('clickhouse', 'click')─┐
│                    0.8333333333333333 │
└───────────────────────────────────────┘
```

## jaroWinklerSimilarity

Introducido en: v24.1.0

Calcula la [similitud de Jaro-Winkler](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance) entre dos cadenas de bytes.

**Sintaxis**

```sql theme={null}
jaroWinklerSimilarity(s1, s2)
```

**Argumentos**

* `s1` — Primera cadena de entrada. [`String`](/es/reference/data-types/string)
* `s2` — Segunda cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la similitud de Jaro-Winkler entre ambas cadenas. [`Float64`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT jaroWinklerSimilarity('clickhouse', 'click')
```

```response title=Response theme={null}
┌─jaroWinklerSimilarity('clickhouse', 'click')─┐
│                           0.8999999999999999 │
└──────────────────────────────────────────────┘
```

## left

Introducido en: v22.1.0

Devuelve una subcadena de la cadena `s` con un `offset` especificado, a partir de la izquierda.

**Sintaxis**

```sql theme={null}
left(s, offset)
```

**Argumentos**

* `s` — La cadena a partir de la cual se calcula una subcadena. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `offset` — La cantidad de bytes de desplazamiento. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve:

* Para `offset` positivo, una subcadena de `s` de `offset` bytes, empezando por la izquierda de la cadena.
* Para `offset` negativo, una subcadena de `s` de `length(s) - |offset|` bytes, empezando por la izquierda de la cadena.
* Una cadena vacía si `length` es `0`.
  [`String`](/es/reference/data-types/string)

**Ejemplos**

**Desplazamiento positivo**

```sql title=Query theme={null}
SELECT left('Hello World', 5)
```

```response title=Response theme={null}
Hello
```

**Offset negativo**

```sql title=Query theme={null}
SELECT left('Hello World', -6)
```

```response title=Response theme={null}
Hello
```

## leftPad

Introducido en: v21.8.0

Rellena una cadena por la izquierda con espacios o con una cadena especificada (varias veces, si es necesario) hasta que la cadena resultante alcance la `length` especificada.

**Sintaxis**

```sql theme={null}
leftPad(string, length[, pad_string])
```

**Alias**: `lpad`

**Argumentos**

* `string` — Cadena de entrada que debe rellenarse. [`String`](/es/reference/data-types/string)
* `length` — Longitud de la cadena resultante. Si el valor es menor que la longitud de la cadena de entrada, esta se acorta a `length` caracteres. [`(U)Int*`](/es/reference/data-types/int-uint)
* `pad_string` — Opcional. Cadena utilizada para rellenar la cadena de entrada. Si no se especifica, la cadena de entrada se rellena con espacios. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena rellenada por la izquierda con la longitud indicada. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT leftPad('abc', 7, '*'), leftPad('def', 7)
```

```response title=Response theme={null}
┌─leftPad('abc', 7, '*')─┬─leftPad('def', 7)─┐
│ ****abc                │     def           │
└────────────────────────┴───────────────────┘
```

## leftPadUTF8

Introducido en: v21.8.0

Rellena una cadena UTF-8 por la izquierda con espacios o con una cadena especificada (repetida varias veces, si es necesario) hasta que la cadena resultante alcance la longitud indicada.
A diferencia de [`leftPad`](#leftPad), que mide la longitud de la cadena en bytes, aquí la longitud de la cadena se mide en puntos de código.

**Sintaxis**

```sql theme={null}
leftPadUTF8(string, length[, pad_string])
```

**Argumentos**

* `string` — Cadena de entrada que se debe rellenar. [`String`](/es/reference/data-types/string)
* `length` — La longitud de la cadena resultante. Si el valor es menor que la longitud de la cadena de entrada, esta se acorta a `length` caracteres. [`(U)Int*`](/es/reference/data-types/int-uint)
* `pad_string` — Opcional. La cadena con la que se rellena la cadena de entrada. Si no se especifica, la cadena de entrada se rellena con espacios. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena rellenada por la izquierda con la longitud indicada. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT leftPadUTF8('абвг', 7, '*'), leftPadUTF8('дежз', 7)
```

```response title=Response theme={null}
┌─leftPadUTF8('абвг', 7, '*')─┬─leftPadUTF8('дежз', 7)─┐
│ ***абвг                     │    дежз                │
└─────────────────────────────┴────────────────────────┘
```

## leftUTF8

Introducido en: v22.1.0

Devuelve una subcadena de una cadena `s` codificada en UTF-8, con un `offset` especificado desde la izquierda.

**Sintaxis**

```sql theme={null}
leftUTF8(s, offset)
```

**Argumentos**

* `s` — La cadena codificada en UTF-8 a partir de la cual se calcula una subcadena. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `offset` — El desplazamiento en bytes. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve:

* Para un `offset` positivo, una subcadena de `s` de `offset` bytes, empezando desde la izquierda de la cadena.\n"
* Para un `offset` negativo, una subcadena de `s` de `length(s) - |offset|` bytes, empezando desde la izquierda de la cadena.\n"
* Una cadena vacía si `length` es 0.
  [`String`](/es/reference/data-types/string)

**Ejemplos**

**Desplazamiento positivo**

```sql title=Query theme={null}
SELECT leftUTF8('Привет', 4)
```

```response title=Response theme={null}
Прив
```

**Offset negativo**

```sql title=Query theme={null}
SELECT leftUTF8('Привет', -4)
```

```response title=Response theme={null}
Пр
```

## lengthUTF8

Introducido en: v1.1.0

Devuelve la longitud de una cadena en puntos de código Unicode en lugar de en bytes o caracteres.
Para calcular la longitud de una cadena en bytes, use la función [`length`](/es/reference/functions/regular-functions/array-functions#length).
Supone que la cadena contiene texto válido codificado en UTF-8.
Si no se cumple esta suposición, no se lanza ninguna excepción y el resultado es indefinido.

**Sintaxis**

```sql theme={null}
lengthUTF8(s)
```

**Alias**: `CHARACTER_LENGTH`, `CHAR_LENGTH`

**Argumentos**

* `s` — Cadena que contiene texto codificado en UTF-8 válido. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Longitud de la cadena `s` en puntos de código Unicode. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT lengthUTF8('Здравствуй, мир!')
```

```response title=Response theme={null}
┌─lengthUTF8('Здравствуй, мир!')─┐
│                             16 │
└────────────────────────────────┘
```

## lower

Introducido en: v1.1.0

Convierte una cadena ASCII en minúsculas.

**Sintaxis**

```sql theme={null}
lower(s)
```

**Alias**: `lcase`

**Argumentos**

* `s` — Una cadena para convertir a minúsculas. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `s` en minúsculas. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT lower('CLICKHOUSE')
```

```response title=Response theme={null}
┌─lower('CLICKHOUSE')─┐
│ clickhouse          │
└─────────────────────┘
```

## lowerUTF8

Introducido en: v1.1.0

Convierte una cadena a minúsculas, suponiendo que contiene texto válido codificado en UTF-8. Si no se cumple esta suposición, no se lanza ninguna excepción y el resultado es indefinido.

**Sintaxis**

```sql theme={null}
lowerUTF8(input)
```

**Argumentos**

* `input` — Cadena de entrada que se convierte a minúsculas. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena en minúsculas. [`String`](/es/reference/data-types/string)

**Ejemplos**

**primero**

```sql title=Query theme={null}
SELECT lowerUTF8('München') as Lowerutf8;
```

```response title=Response theme={null}
münchen
```

## naturalSortKey

Introducido en: v26.3.0

La función se utiliza para realizar una ordenación natural.

**Sintaxis**

```sql theme={null}
naturalSortKey(s)
```

**Alias**: `NATURAL_SORT_KEY`

**Argumentos**

* `s` — Una cadena para convertirla en una clave de ordenación natural. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena con la clave de ordenación natural de `s`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
CREATE TABLE t (s String) ENGINE = Memory;
INSERT INTO t VALUES ('a1'), ('a02');

SELECT s FROM t ORDER BY naturalSortKey(s);
```

```response title=Response theme={null}
┌─s───┐
│ a1  │
│ a02 │
└─────┘
```

## normalizeUTF8NFC

Introducida en: v21.11.0

Normaliza una cadena UTF-8 de acuerdo con la [forma de normalización NFC](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).

**Sintaxis**

```sql theme={null}
normalizeUTF8NFC(str)
```

**Argumentos**

* `str` — cadena de entrada codificada en UTF-8. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la forma normalizada NFC de la cadena UTF-8. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
'é' AS original, -- e + acento agudo combinado (U+0065 + U+0301)
length(original),
normalizeUTF8NFC('é') AS nfc_normalized, -- é (U+00E9)
length(nfc_normalized);
```

```response title=Response theme={null}
┌─original─┬─length(original)─┬─nfc_normalized─┬─length(nfc_normalized)─┐
│ é        │                2 │ é              │                      2 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘
```

## normalizeUTF8NFD

Introducido en: v21.11.0

Normaliza una cadena UTF-8 según la [forma de normalización NFD](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).

**Sintaxis**

```sql theme={null}
normalizeUTF8NFD(str)
```

**Argumentos**

* `str` — cadena de entrada codificada en UTF-8. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la forma normalizada NFD de la cadena en UTF-8. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    'é' AS original, -- é (U+00E9)
    length(original),
    normalizeUTF8NFD('é') AS nfd_normalized, -- e + acento combinatorio (U+0065 + U+0301)
    length(nfd_normalized);
```

```response title=Response theme={null}
┌─original─┬─length(original)─┬─nfd_normalized─┬─length(nfd_normalized)─┐
│ é        │                2 │ é              │                      3 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘
```

## normalizeUTF8NFKC

Introducido en: v21.11.0

Normaliza una cadena en UTF-8 según la [forma de normalización NFKC](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).

**Sintaxis**

```sql theme={null}
normalizeUTF8NFKC(str)
```

**Argumentos**

* `str` — cadena de entrada codificada en UTF-8. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la forma NFKC normalizada de la cadena UTF-8. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    '① ② ③' AS original,                           -- Circled number characters
    normalizeUTF8NFKC('① ② ③') AS nfkc_normalized  -- Converts to 1 2 3
```

```response title=Response theme={null}
┌─original─┬─nfkc_normalized─┐
│ ① ② ③    │ 1 2 3           │
└──────────┴─────────────────┘
```

## normalizeUTF8NFKCCasefold

Introducido en: v26.3.0

Normaliza una cadena UTF-8 según la [forma de normalización NFKC\_Casefold](https://unicode.org/reports/tr44/#NFKC_Casefold), que aplica la normalización NFKC y, a continuación, realiza el case folding.
Esto resulta útil para la comparación de identificadores sin distinción entre mayúsculas y minúsculas.

**Sintaxis**

```sql theme={null}
normalizeUTF8NFKCCasefold(str)
```

**Argumentos**

* `str` — cadena de entrada codificada en UTF-8. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la forma normalizada NFKC\_Casefold de la cadena codificada en UTF-8. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    'Ä ① Hello' AS original,
    normalizeUTF8NFKCCasefold('Ä ① Hello') AS nfkc_cf_normalized;
```

```response title=Response theme={null}
┌─original──┬─nfkc_cf_normalized─┐
│ Ä ① Hello │ ä 1 hello          │
└───────────┴────────────────────┘
```

## normalizeUTF8NFKD

Introducido en: v21.11.0

Normaliza una cadena UTF-8 de acuerdo con la [forma de normalización NFKD](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).

**Sintaxis**

```sql theme={null}
normalizeUTF8NFKD(str)
```

**Argumentos**

* `str` — Cadena de entrada codificada en UTF-8. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la forma normalizada NFKD de la cadena codificada en UTF-8. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    'H₂O²' AS original,                           -- H + subscript 2 + O + superscript 2
    normalizeUTF8NFKD('H₂O²') AS nfkd_normalized  -- Converts to H 2 O 2
```

```response title=Response theme={null}
┌─original─┬─nfkd_normalized─┐
│ H₂O²     │ H2O2            │
└──────────┴─────────────────┘
```

## punycodeDecode

Introducido en: v24.1.0

Devuelve el texto sin formato codificado en UTF-8 de una cadena codificada en [Punycode](https://en.wikipedia.org/wiki/Punycode).
Si no se proporciona una cadena válida codificada en Punycode, se genera una excepción.

**Sintaxis**

```sql theme={null}
punycodeDecode(s)
```

**Argumentos**

* `s` — Cadena codificada en Punycode. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el texto sin formato del valor de entrada. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT punycodeDecode('Mnchen-3ya')
```

```response title=Response theme={null}
┌─punycodeDecode('Mnchen-3ya')─┐
│ München                      │
└──────────────────────────────┘
```

## punycodeEncode

Introducido en: v24.1.0

Devuelve la representación en [Punycode](https://en.wikipedia.org/wiki/Punycode) de una cadena.
La cadena debe estar codificada en UTF-8; de lo contrario, el comportamiento no está definido.

**Sintaxis**

```sql theme={null}
punycodeEncode(s)
```

**Argumentos**

* `s` — Valor de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la representación en Punycode del valor de entrada. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT punycodeEncode('München')
```

```response title=Response theme={null}
┌─punycodeEncode('München')─┐
│ Mnchen-3ya                │
└───────────────────────────┘
```

## regexpExtract

Introducido en: v23.2.0

Extrae la primera cadena de `haystack` que coincide con el patrón de expresión regular y corresponde al índice del grupo de la expresión regular.

**Sintaxis**

```sql theme={null}
regexpExtract(haystack, pattern[, index])
```

**Alias**: `REGEXP_EXTRACT`, `REGEXP_SUBSTR`

**Argumentos**

* `haystack` — String, donde se buscará la coincidencia con el patrón regexp. [`String`](/es/reference/data-types/string)
* `pattern` — String, expresión regular. `pattern` puede contener varios grupos regexp; `index` indica qué grupo de la expresión regular se extraerá. Un índice de `0` significa que se extrae la coincidencia de la expresión regular completa. [`const String`](/es/reference/data-types/string)
* `index` — Opcional. Un entero no negativo que indica qué grupo de la expresión regular se extraerá. El valor predeterminado es `1` si `pattern` contiene al menos un grupo de captura, y `0` (la coincidencia completa) si `pattern` no tiene ningún grupo de captura. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una coincidencia como cadena [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    regexpExtract('100-200', '(\\d+)-(\\d+)', 1),
    regexpExtract('100-200', '(\\d+)-(\\d+)', 2),
    regexpExtract('100-200', '(\\d+)-(\\d+)', 0),
    regexpExtract('100-200', '(\\d+)-(\\d+)'),
    regexpExtract('100-200', '\\d+');
```

```response title=Response theme={null}
┌─regexpExtract('100-200', '(\\d+)-(\\d+)', 1)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 2)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 0)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)')─┬─regexpExtract('100-200', '\\d+')─┐
│ 100                                          │ 200                                          │ 100-200                                      │ 100                                       │ 100                              │
└──────────────────────────────────────────────┴──────────────────────────────────────────────┴──────────────────────────────────────────────┴───────────────────────────────────────────┴──────────────────────────────────┘
```

## regexpPosition

Introducido en: v26.5.0

Devuelve la posición en bytes (basada en 1) de la coincidencia número `occurrence` de `pattern` en `haystack`, comenzando la búsqueda en la posición en bytes `position`.

Si `return_option` es 0 (valor predeterminado), devuelve la posición del primer byte de la coincidencia. Si es 1, devuelve la posición del primer byte *después* de la coincidencia.

Si `subexpression` es mayor que 0, devuelve la posición del grupo de captura correspondiente en lugar de la coincidencia completa.

Devuelve 0 si no se encuentra ninguna coincidencia o si el grupo de captura solicitado no participó en la coincidencia.

Se proporciona por compatibilidad con `regexp_instr` de PostgreSQL (también disponible con ese alias). Ten en cuenta que las posiciones se basan en bytes, en consonancia con otras funciones de expresiones regulares de ClickHouse; `regexp_instr` de PostgreSQL se basa en caracteres.

**Sintaxis**

```sql theme={null}
regexpPosition(haystack, pattern[, position[, occurrence[, return_option[, flags[, subexpression]]]]])
```

**Alias**: `regexpInstr`, `regexp_instr`

**Argumentos**

* `haystack` — Cadena en la que buscar. [`String`](/es/reference/data-types/string)
* `pattern` — Patrón de expresión regular. [`const String`](/es/reference/data-types/string)
* `position` — Opcional. Posición en bytes, basada en 1, desde la que se inicia la búsqueda. Valor predeterminado: 1. [`(U)Int*`](/es/reference/data-types/int-uint)
* `occurrence` — Opcional. Qué coincidencia devolver. Valor predeterminado: 1. [`(U)Int*`](/es/reference/data-types/int-uint)
* `return_option` — Opcional. 0 devuelve la posición de inicio de la coincidencia; 1 devuelve la posición inmediatamente posterior a la coincidencia. Valor predeterminado: 0. [`(U)Int*`](/es/reference/data-types/int-uint)
* `flags` — Opcional. Banderas de regex. Compatibles: `i` (sin distinción entre mayúsculas y minúsculas), `c` (con distinción entre mayúsculas y minúsculas), `m`/`n` (anclajes multilínea), `s` (el punto coincide con el salto de línea). Valor predeterminado: vacío. [`const String`](/es/reference/data-types/string)
* `subexpression` — Opcional. Índice del grupo de captura cuya posición se devolverá. 0 significa la coincidencia completa. Valor predeterminado: 0. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve la posición en bytes de la coincidencia, o 0 si no se encuentra. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT
    regexpPosition('hello world', 'world'),
    regexpPosition('aXbXcXd', 'X', 1, 2),
    regexpPosition('aXbXcXd', 'X', 1, 2, 1),
    regexpPosition('Hello WORLD', 'world', 1, 1, 0, 'i'),
    regexpPosition('foo123bar456', '([a-z]+)([0-9]+)', 1, 2, 0, '', 2);
```

```response title=Response theme={null}
┌─regexpPosition('hello world', 'world')─┬─regexpPosition('aXbXcXd', 'X', 1, 2)─┬─regexpPosition('aXbXcXd', 'X', 1, 2, 1)─┬─regexpPosition('Hello WORLD', 'world', 1, 1, 0, 'i')─┬─regexpPosition('foo123bar456', '([a-z]+)([0-9]+)', 1, 2, 0, '', 2)─┐
│                                      7 │                                    4 │                                       5 │                                                    7 │                                                                 10 │
└────────────────────────────────────────┴──────────────────────────────────────┴─────────────────────────────────────────┴──────────────────────────────────────────────────────┴────────────────────────────────────────────────────────────────────┘
```

## removeDiacriticsUTF8

Introducido en: v26.3.0

Elimina las marcas diacríticas (acentos) de una cadena UTF-8 al descomponer los caracteres mediante NFD,
eliminar las marcas de combinación (categoría Unicode Mn) y volver a componerlos mediante NFC.

**Sintaxis**

```sql theme={null}
removeDiacriticsUTF8(str)
```

**Alias**: `removeAccentsUTF8`

**Argumentos**

* `str` — cadena de entrada codificada en UTF-8. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Cadena UTF-8 sin diacríticos. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Eliminación básica de acentos**

```sql title=Query theme={null}
SELECT removeDiacriticsUTF8('café résumé naïve')
```

```response title=Response theme={null}
┌─removeDiacriticsUTF8('café résumé naïve')─┐
│ cafe resume naive                         │
└───────────────────────────────────────────┘
```

## repeat

Introducido en: v20.1.0

Concatena una cadena consigo misma tantas veces como se indique.

**Sintaxis**

```sql theme={null}
repeat(s, n)
```

**Argumentos**

* `s` — La cadena que se debe repetir. [`String`](/es/reference/data-types/string)
* `n` — El número de veces que se debe repetir la cadena. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Una cadena que contiene `s` repetida `n` veces. Si `n` es negativo, la función devuelve una cadena vacía. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT repeat('abc', 10)
```

```response title=Response theme={null}
┌─repeat('abc', 10)──────────────┐
│ abcabcabcabcabcabcabcabcabcabc │
└────────────────────────────────┘
```

## reverseUTF8

Introducido en: v1.1.0

Invierte una secuencia de puntos de código Unicode en una cadena.
Supone que la cadena contiene texto válido codificado en UTF-8.
Si no se cumple esta suposición, no se lanza ninguna excepción y el resultado es indefinido.

**Sintaxis**

```sql theme={null}
reverseUTF8(s)
```

**Argumentos**

* `s` — Cadena que contiene texto válido codificado en UTF-8. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena con la secuencia de puntos de código Unicode invertida. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT reverseUTF8('ClickHouse')
```

```response title=Response theme={null}
esuoHkcilC
```

## right

Introducido en: v22.1.0

Devuelve una subcadena de la cadena `s` con un `offset` especificado a partir de la derecha.

**Sintaxis**

```sql theme={null}
right(s, offset)
```

**Argumentos**

* `s` — La cadena a partir de la cual se calculará una subcadena. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `offset` — El número de bytes de desplazamiento. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve:

* Para un `offset` positivo, una subcadena de `s` de `offset` bytes, empezando por la derecha de la cadena.
* Para un `offset` negativo, una subcadena de `s` de `length(s) - |offset|` bytes, empezando por la derecha de la cadena.
* Una cadena vacía si `length` es `0`.
  [`String`](/es/reference/data-types/string)

**Ejemplos**

**Desplazamiento positivo**

```sql title=Query theme={null}
SELECT right('Hello', 3)
```

```response title=Response theme={null}
llo
```

**Offset negativo**

```sql title=Query theme={null}
SELECT right('Hello', -3)
```

```response title=Response theme={null}
lo
```

## rightPad

Introducido en: v21.8.0

Rellena una cadena por la derecha con espacios o con una cadena especificada (repitiéndola varias veces, si es necesario) hasta que la cadena resultante alcance la `length` especificada.

**Sintaxis**

```sql theme={null}
rightPad(string, length[, pad_string])
```

**Alias**: `rpad`

**Argumentos**

* `string` — Cadena de entrada que se debe rellenar. [`String`](/es/reference/data-types/string)
* `length` — La longitud de la cadena resultante. Si el valor es menor que la longitud de la cadena de entrada, esta se acorta a `length` caracteres. [`(U)Int*`](/es/reference/data-types/int-uint)
* `pad_string` — Opcional. La cadena con la que se rellena la cadena de entrada. Si no se especifica, la cadena de entrada se rellena con espacios. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena rellenada por la derecha con la longitud especificada. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT rightPad('abc', 7, '*'), rightPad('abc', 7)
```

```response title=Response theme={null}
┌─rightPad('abc', 7, '*')─┬─rightPad('abc', 7)─┐
│ abc****                 │ abc                │
└─────────────────────────┴────────────────────┘
```

## rightPadUTF8

Introducido en: v21.8.0

Rellena la cadena por la derecha con espacios o con una cadena especificada (varias veces, si es necesario) hasta que la cadena resultante alcance la longitud indicada.
A diferencia de [`rightPad`](#rightPad), que mide la longitud de la cadena en bytes, aquí la longitud de la cadena se mide en puntos de código.

**Sintaxis**

```sql theme={null}
rightPadUTF8(string, length[, pad_string])
```

**Argumentos**

* `string` — Cadena de entrada que se debe rellenar. [`String`](/es/reference/data-types/string)
* `length` — La longitud de la cadena resultante. Si el valor es menor que la longitud de la cadena de entrada, esta se acorta a `length` caracteres. [`(U)Int*`](/es/reference/data-types/int-uint)
* `pad_string` — Opcional. La cadena con la que se rellena la cadena de entrada. Si no se especifica, la cadena de entrada se rellena con espacios. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena de la longitud indicada, rellenada por la derecha. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT rightPadUTF8('абвг', 7, '*'), rightPadUTF8('абвг', 7)
```

```response title=Response theme={null}
┌─rightPadUTF8('абвг', 7, '*')─┬─rightPadUTF8('абвг', 7)─┐
│ абвг***                      │ абвг                    │
└──────────────────────────────┴─────────────────────────┘
```

## rightUTF8

Introducido en: v22.1.0

Devuelve una subcadena de la cadena `s`, codificada en UTF-8, con un `offset` especificado desde la derecha.

**Sintaxis**

```sql theme={null}
rightUTF8(s, offset)
```

**Argumentos**

* `s` — La cadena codificada en UTF-8 de la que se calcula una subcadena. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `offset` — El número de bytes del desplazamiento. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve:

* Para `offset` positivo, una subcadena de `s` de `offset` bytes, empezando por la derecha de la cadena.
* Para `offset` negativo, una subcadena de `s` de `length(s) - |offset|` bytes, empezando por la derecha de la cadena.
* Una cadena vacía si `length` es `0`.
  [`String`](/es/reference/data-types/string)

**Ejemplos**

**Desplazamiento positivo**

```sql title=Query theme={null}
SELECT rightUTF8('Привет', 4)
```

```response title=Response theme={null}
ивет
```

**Desplazamiento negativo**

```sql title=Query theme={null}
SELECT rightUTF8('Привет', -4)
```

```response title=Response theme={null}
ет
```

## soundex

Introducido en: v23.4.0

Devuelve el [código Soundex](https://en.wikipedia.org/wiki/Soundex) de una cadena.

**Sintaxis**

```sql theme={null}
soundex(s)
```

**Argumentos**

* `s` — Cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el código Soundex de la cadena de entrada. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT soundex('aksel')
```

```response title=Response theme={null}
┌─soundex('aksel')─┐
│ A240             │
└──────────────────┘
```

## space

Introducido en: v23.5.0

Concatena un espacio (` `) consigo mismo tantas veces como se indique.

**Sintaxis**

```sql theme={null}
space(n)
```

**Argumentos**

* `n` — El número de veces que se repite el carácter de espacio. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una cadena que contiene un espacio repetido `n` veces. Si `n <= 0`, la función devuelve la cadena vacía. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT space(3) AS res, length(res);
```

```response title=Response theme={null}
┌─res─┬─length(res)─┐
│     │           3 │
└─────┴─────────────┘
```

## sparseGrams

Introducido en: v25.5.0

Encuentra todas las subcadenas de una cadena dada que tengan una longitud de al menos `n`,
donde los hashes de los (n-1)-gramas en los extremos de la subcadena
son estrictamente mayores que los de cualquier (n-1)-grama dentro de ella.
Usa `CRC32` como función hash.

**Sintaxis**

```sql theme={null}
sparseGrams(s[, min_ngram_length[, max_ngram_length[, min_cutoff_length]]])
```

**Argumentos**

* `s` — Una cadena de entrada. [`String`](/es/reference/data-types/string)
* `min_ngram_length` — Opcional. La longitud mínima del ngrama extraído. El valor predeterminado, que también es el mínimo, es 3. [`UInt*`](/es/reference/data-types/int-uint)
* `max_ngram_length` — Opcional. La longitud máxima del ngrama extraído. El valor predeterminado es 100. No debe ser menor que `min_ngram_length`. [`UInt*`](/es/reference/data-types/int-uint)
* `min_cutoff_length` — Opcional. Si se especifica, solo se devuelven n-gramas cuya longitud sea mayor o igual que `min_cutoff_length`. El valor predeterminado es el mismo que `min_ngram_length`. No debe ser menor que `min_ngram_length` ni mayor que `max_ngram_length`. [`UInt*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un array de subcadenas seleccionadas. [`Array(String)`](/es/reference/data-types/array)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT sparseGrams('alice', 3)
```

```response title=Response theme={null}
┌─sparseGrams('alice', 3)────┐
│ ['ali','lic','ice','lice'] │
└────────────────────────────┘
```

## sparseGramsHashes

Introducido en: v25.5.0

Encuentra los valores hash de todas las subcadenas de una cadena dada que tengan una longitud de al menos `n`,
donde los valores hash de los ngramas de longitud `n-1` en los bordes de la subcadena
sean estrictamente mayores que los de cualquier ngrama de longitud `n-1` dentro de la subcadena.
Usa `CRC32` como función hash.

**Sintaxis**

```sql theme={null}
sparseGramsHashes(s[, min_ngram_length, max_ngram_length])
```

**Argumentos**

* `s` — Una cadena de entrada. [`String`](/es/reference/data-types/string)
* `min_ngram_length` — Opcional. La longitud mínima del ngrama extraído. El valor predeterminado y mínimo es 3. [`UInt*`](/es/reference/data-types/int-uint)
* `max_ngram_length` — Opcional. La longitud máxima del ngrama extraído. El valor predeterminado es 100. No debe ser inferior a `min_ngram_length`. [`UInt*`](/es/reference/data-types/int-uint)
* `min_cutoff_length` — Opcional. Si se especifica, solo se devuelven los ngramas con una longitud mayor o igual que `min_cutoff_length`. El valor predeterminado es el mismo que `min_ngram_length`. No debe ser inferior a `min_ngram_length` ni superior a `max_ngram_length`. [`UInt*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un array de hash CRC32 de las subcadenas seleccionadas. [`Array(UInt32)`](/es/reference/data-types/array)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT sparseGramsHashes('alice', 3)
```

```response title=Response theme={null}
┌─sparseGramsHashes('alice', 3)────────────────┐
│ [3851133533,3120039944,646693941,2577359366] │
└──────────────────────────────────────────────┘
```

## sparseGramsHashesUTF8

Introducido en: v25.5.0

Encuentra los hashes de todas las subcadenas de una cadena UTF-8 dada con una longitud de al menos `n`, donde los hashes de los (n-1)-gramas en los bordes de la subcadena son estrictamente mayores que los de cualquier (n-1)-grama dentro de la subcadena.
Espera una cadena UTF-8 y lanza una excepción en caso de secuencia UTF-8 no válida.
Usa `CRC32` como función hash.

**Sintaxis**

```sql theme={null}
sparseGramsHashesUTF8(s[, min_ngram_length, max_ngram_length])
```

**Argumentos**

* `s` — Una cadena de entrada. [`String`](/es/reference/data-types/string)
* `min_ngram_length` — Opcional. La longitud mínima del ngrama extraído. El valor predeterminado y mínimo es 3. [`UInt*`](/es/reference/data-types/int-uint)
* `max_ngram_length` — Opcional. La longitud máxima del ngrama extraído. El valor predeterminado es 100. No debe ser inferior a `min_ngram_length`. [`UInt*`](/es/reference/data-types/int-uint)
* `min_cutoff_length` — Opcional. Si se especifica, solo se devuelven n-gramas con una longitud igual o mayor que `min_cutoff_length`. El valor predeterminado es el mismo que `min_ngram_length`. No debe ser inferior a `min_ngram_length` ni superior a `max_ngram_length`. [`UInt*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un Array de hashes CRC32 de las subcadenas UTF-8 seleccionadas. [`Array(UInt32)`](/es/reference/data-types/array)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT sparseGramsHashesUTF8('алиса', 3)
```

```response title=Response theme={null}
┌─sparseGramsHashesUTF8('алиса', 3)───────────────────────┐
│ [1328958118,547287748,4155892324,2403052185,1673399070] │
└─────────────────────────────────────────────────────────┘
```

## sparseGramsUTF8

Introducido en: v25.5.0

Encuentra todas las subcadenas de una cadena UTF-8 dada que tengan una longitud de al menos `n`, donde los valores hash de los (n-1)-ngramas en los extremos de la subcadena son estrictamente mayores que los de cualquier (n-1)-ngrama dentro de la subcadena.
Espera una cadena UTF-8 y genera una excepción si la secuencia UTF-8 no es válida.
Usa `CRC32` como función hash.

**Sintaxis**

```sql theme={null}
sparseGramsUTF8(s[, min_ngram_length[, max_ngram_length[, min_cutoff_length]]])
```

**Argumentos**

* `s` — Una cadena de entrada. [`String`](/es/reference/data-types/string)
* `min_ngram_length` — Opcional. La longitud mínima del ngrama extraído. El valor predeterminado y mínimo es 3. [`UInt*`](/es/reference/data-types/int-uint)
* `max_ngram_length` — Opcional. La longitud máxima del ngrama extraído. El valor predeterminado es 100. No debe ser inferior a `min_ngram_length`. [`UInt*`](/es/reference/data-types/int-uint)
* `min_cutoff_length` — Opcional. Si se especifica, solo se devuelven los ngramas con una longitud mayor o igual que `min_cutoff_length`. El valor predeterminado es el mismo que `min_ngram_length`. No debe ser inferior a `min_ngram_length` ni superior a `max_ngram_length`. [`UInt*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un array de subcadenas UTF-8 seleccionadas. [`Array(String)`](/es/reference/data-types/array)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT sparseGramsUTF8('алиса', 3)
```

```response title=Response theme={null}
┌─sparseGramsUTF8('алиса', 3)────────┐
│ ['али','лис','иса','лиса','алиса'] │
└────────────────────────────────────┘
```

## startsWith

Introducido en: v1.1.0

Comprueba si una cadena empieza por la cadena proporcionada.

**Sintaxis**

```sql theme={null}
startsWith(s, prefix)
```

**Argumentos**

* `s` — Cadena que se va a comprobar. [`String`](/es/reference/data-types/string)
* `prefix` — Prefijo que se va a comprobar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `1` si `s` comienza con `prefix`; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT startsWith('ClickHouse', 'Click');
```

```response title=Response theme={null}
┌─startsWith('ClickHouse', 'Click')─┐
│                                 1 │
└───────────────────────────────────┘
```

## startsWithCaseInsensitive

Introducido en: v25.10.0

Comprueba si una cadena empieza por la cadena proporcionada sin distinguir entre mayúsculas y minúsculas.

**Sintaxis**

```sql theme={null}
startsWithCaseInsensitive(s, prefix)
```

**Argumentos**

* `s` — Cadena que se comprobará. [`String`](/es/reference/data-types/string)
* `prefix` — Prefijo sin distinción entre mayúsculas y minúsculas que se comprobará. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `1` si `s` comienza por el `prefix` sin distinguir entre mayúsculas y minúsculas; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT startsWithCaseInsensitive('ClickHouse', 'CLICK');
```

```response title=Response theme={null}
┌─startsWithCaseInsensitive('ClickHouse', 'CLICK')─┐
│                                                1 │
└──────────────────────────────────────────────────┘
```

## startsWithCaseInsensitiveUTF8

Introducido en: v25.10.0

Comprueba si una cadena comienza con el prefijo proporcionado sin distinguir entre mayúsculas y minúsculas.
Se asume que la cadena contiene texto válido codificado en UTF-8.
Si no se cumple esta suposición, no se lanza ninguna excepción y el resultado es indefinido.

**Sintaxis**

```sql theme={null}
startsWithCaseInsensitiveUTF8(s, prefix)
```

**Argumentos**

* `s` — Cadena que se debe comprobar. [`String`](/es/reference/data-types/string)
* `prefix` — Prefijo, sin distinguir entre mayúsculas y minúsculas, cuya coincidencia se debe comprobar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `1` si `s` empieza por `prefix` sin distinguir entre mayúsculas y minúsculas; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT startsWithCaseInsensitiveUTF8('приставка', 'при')
```

```response title=Response theme={null}
┌─startsWithCaseInsensitiveUTF8('приставка', 'при')─┐
│                                                 1 │
└───────────────────────────────────────────────────┘
```

## startsWithUTF8

Introducido en: v23.8.0

Comprueba si una cadena empieza por el prefijo proporcionado.
Asume que la cadena contiene texto válido codificado en UTF-8.
Si no se cumple esta suposición, no se lanza ninguna excepción y el resultado es indefinido.

**Sintaxis**

```sql theme={null}
startsWithUTF8(s, prefix)
```

**Argumentos**

* `s` — Cadena que se va a comprobar. [`String`](/es/reference/data-types/string)
* `prefix` — Prefijo que se va a comprobar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `1` si `s` empieza por `prefix`; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT startsWithUTF8('приставка', 'при')
```

```response title=Response theme={null}
┌─startsWithUTF8('приставка', 'при')─┐
│                                  1 │
└────────────────────────────────────┘
```

## stringBytesEntropy

Introducido en: v25.6.0

Calcula la entropía de Shannon de la distribución de bytes de una cadena.

**Sintaxis**

```sql theme={null}
stringBytesEntropy(s)
```

**Argumentos**

* `s` — La cadena que se va a analizar. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la entropía de Shannon de la distribución de bytes de la cadena. [`Float64`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT stringBytesEntropy('Hello, world!')
```

```response title=Response theme={null}
┌─stringBytesEntropy('Hello, world!')─┐
│                   3.180832987205441 │
└─────────────────────────────────────┘
```

## stringBytesUniq

Introducido en: v25.6.0

Cuenta el número de bytes distintos de una cadena.

**Sintaxis**

```sql theme={null}
stringBytesUniq(s)
```

**Argumentos**

* `s` — La cadena que se analizará. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el número de bytes distintos de la cadena. [`UInt16`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT stringBytesUniq('Hello')
```

```response title=Response theme={null}
┌─stringBytesUniq('Hello')─┐
│                        4 │
└──────────────────────────┘
```

## stringJaccardIndex

Introducido en: v23.11.0

Calcula el [índice de similitud de Jaccard](https://en.wikipedia.org/wiki/Jaccard_index) entre dos cadenas de bytes.

**Sintaxis**

```sql theme={null}
stringJaccardIndex(s1, s2)
```

**Argumentos**

* `s1` — Primera cadena de entrada. [`String`](/es/reference/data-types/string)
* `s2` — Segunda cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el índice de similitud de Jaccard entre ambas cadenas. [`Float64`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT stringJaccardIndex('clickhouse', 'mouse')
```

```response title=Response theme={null}
┌─stringJaccardIndex('clickhouse', 'mouse')─┐
│                                       0.4 │
└───────────────────────────────────────────┘
```

## stringJaccardIndexUTF8

Introducido en: v23.11.0

Igual que [`stringJaccardIndex`](#stringJaccardIndex), pero para cadenas codificadas en UTF-8.

**Sintaxis**

```sql theme={null}
stringJaccardIndexUTF8(s1, s2)
```

**Argumentos**

* `s1` — Primera cadena UTF-8 de entrada. [`String`](/es/reference/data-types/string)
* `s2` — Segunda cadena UTF-8 de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el índice de similitud de Jaccard entre las dos cadenas UTF-8. [`Float64`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT stringJaccardIndexUTF8('我爱你', '我也爱你') AS jaccard_index
```

```response title=Response theme={null}
┌─jaccard_index─┐
│          0.75 │
└───────────────┘
```

## substring

Introducido en: v1.1.0

Devuelve la subcadena de una cadena `s` que comienza en el índice de bytes `offset` especificado.
El recuento de bytes comienza en 1 con la siguiente lógica:

* Si `offset` es `0`, se devuelve una cadena vacía.
* Si `offset` es negativo, la subcadena comienza `offset` caracteres desde el final de la cadena, en lugar de hacerlo desde el principio.

Un argumento opcional, `length`, especifica el número máximo de bytes que puede tener la subcadena devuelta.

Vea también la función [`digits`](/es/reference/functions/regular-functions/other-functions#digits), que realiza la operación análoga sobre los dígitos de un número.

**Sintaxis**

```sql theme={null}
substring(s, offset[, length])
```

**Alias**: `byteSlice`, `mid`, `substr`

**Argumentos**

* `s` — La cadena de la que se extrae una subcadena. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`Enum`](/es/reference/data-types/enum)
* `offset` — La posición inicial de la subcadena en `s`. [`(U)Int*`](/es/reference/data-types/int-uint)
* `length` — Opcional. La longitud máxima de la subcadena. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una subcadena de `s` de `length` bytes, a partir del índice `offset`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT 'database' AS db, substr(db, 5), substr(db, 5, 1)
```

```response title=Response theme={null}
┌─db───────┬─substr(db, 5)─┬─substr(db, 5, 1)─┐
│ database │ base          │ b                │
└──────────┴───────────────┴──────────────────┘
```

## substringIndex

Introducido en: v23.7.0

Devuelve la subcadena de `s` situada antes de la `count`-ésima aparición del delimitador `delim`, como en Spark o MySQL.

**Sintaxis**

```sql theme={null}
substringIndex(s, delim, count)
```

**alias**: `SUBSTRING_INDEX`

**Argumentos**

* `s` — La cadena de la que se extrae la subcadena. [`String`](/es/reference/data-types/string)
* `delim` — El carácter delimitador. [`String`](/es/reference/data-types/string)
* `count` — El número de apariciones del delimitador que se cuentan antes de extraer la subcadena. Si `count` es positivo, se devuelve todo lo que está a la izquierda del delimitador final (contando desde la izquierda). Si `count` es negativo, se devuelve todo lo que está a la derecha del delimitador final (contando desde la derecha). [`UInt`](/es/reference/data-types/int-uint) o [`Int`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una subcadena de `s` situada antes de `count` apariciones de `delim`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT substringIndex('www.clickhouse.com', '.', 2)
```

```response title=Response theme={null}
┌─substringIndex('www.clickhouse.com', '.', 2)─┐
│ www.clickhouse                               │
└──────────────────────────────────────────────┘
```

## substringIndexUTF8

Introducido en: v23.7.0

Devuelve la subcadena de `s` anterior a `count` apariciones del delimitador `delim`, específicamente para puntos de código Unicode.
Asume que la cadena contiene texto válido codificado en UTF-8.
Si no se cumple esta suposición, no se lanza ninguna excepción y el resultado es indefinido.

**Sintaxis**

```sql theme={null}
substringIndexUTF8(s, delim, count)
```

**Argumentos**

* `s` — La cadena de la que se extrae la subcadena. [`String`](/es/reference/data-types/string)
* `delim` — El carácter delimitador. [`String`](/es/reference/data-types/string)
* `count` — El número de apariciones del delimitador que se cuentan antes de extraer la subcadena. Si `count` es positivo, se devuelve todo lo que queda a la izquierda del delimitador final (contando desde la izquierda). Si `count` es negativo, se devuelve todo lo que queda a la derecha del delimitador final (contando desde la derecha). [`UInt`](/es/reference/data-types/int-uint) o [`Int`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una subcadena de `s` situada antes de `count` apariciones de `delim`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de UTF8**

```sql title=Query theme={null}
SELECT substringIndexUTF8('www.straßen-in-europa.de', '.', 2)
```

```response title=Response theme={null}
www.straßen-in-europa
```

## substringUTF8

Introducido en: v1.1.0

Devuelve la subcadena de una cadena `s` que comienza en el índice de punto de código `offset` especificado.
El recuento de puntos de código comienza en `1` con la siguiente lógica:

* Si `offset` es `0`, se devuelve una cadena vacía.
* Si `offset` es negativo, la subcadena comienza `offset` puntos de código antes del final de la cadena, en lugar de hacerlo desde el principio.

Un argumento opcional, `length`, especifica el número máximo de puntos de código que puede tener la subcadena devuelta.

<Note>
  Esta función asume que la cadena contiene texto válido codificado en UTF-8.
  Si no se cumple esta suposición, no se lanza ninguna excepción y el resultado es indefinido.
</Note>

**Sintaxis**

```sql theme={null}
substringUTF8(s, offset[, length])
```

**Argumentos**

* `s` — La cadena de la que se extraerá una subcadena. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`Enum`](/es/reference/data-types/enum)
* `offset` — La posición inicial de la subcadena en `s`. [`Int`](/es/reference/data-types/int-uint) o [`UInt`](/es/reference/data-types/int-uint)
* `length` — La longitud máxima de la subcadena. Opcional. [`Int`](/es/reference/data-types/int-uint) o [`UInt`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una subcadena de `s` de hasta `length` puntos de código, a partir del índice de punto de código `offset`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT 'Täglich grüßt das Murmeltier.' AS str, substringUTF8(str, 9), substringUTF8(str, 9, 5)
```

```response title=Response theme={null}
Täglich grüßt das Murmeltier.	grüßt das Murmeltier.	grüßt
```

## toValidUTF8

Introducido en: v20.1.0

Convierte una cadena a una codificación UTF-8 válida sustituyendo cualquier carácter UTF-8 no válido por el carácter de reemplazo `�` (U+FFFD).
Cuando se encuentran varios caracteres no válidos consecutivos, se sustituyen por un único carácter de reemplazo.

**Sintaxis**

```sql theme={null}
toValidUTF8(s)
```

**Argumentos**

* `s` — Cualquier conjunto de bytes representado como un objeto del tipo de dato String. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena UTF-8 válida. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT toValidUTF8('\\x61\\xF0\\x80\\x80\\x80b')
```

```response title=Response theme={null}
\\x61\\xF0\\x80\\x80\\x80b
```

## trimBoth

Introducido en: v20.1.0

Elimina los caracteres especificados del principio y del final de una cadena.
De forma predeterminada, elimina los caracteres comunes de espacio en blanco (ASCII).

**Sintaxis**

```sql theme={null}
trimBoth(s[, trim_characters])
```

**Alias**: `trim`

**Argumentos**

* `s` — Cadena que se recortará. [`String`](/es/reference/data-types/string)
* `trim_characters` — Opcional. Caracteres que se recortarán. Si no se especifica, se eliminan los caracteres de espacio en blanco habituales. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la cadena tras recortar los caracteres especificados de ambos extremos. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT trimBoth('$$ClickHouse$$', '$')
```

```response title=Response theme={null}
┌─trimBoth('$$ClickHouse$$', '$')─┐
│ ClickHouse                      │
└─────────────────────────────────┘
```

## trimLeft

Introducido en: v20.1.0

Elimina los caracteres especificados del principio de una cadena.
De forma predeterminada, elimina los caracteres de espacio en blanco (ASCII) más comunes.

**Sintaxis**

```sql theme={null}
trimLeft(input[, trim_characters])
```

**Alias**: `ltrim`

**Argumentos**

* `input` — Cadena a recortar. [`String`](/es/reference/data-types/string)
* `trim_characters` — Opcional. Caracteres a recortar. Si no se especifican, se eliminan los caracteres de espacio en blanco habituales. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la cadena con los caracteres especificados eliminados del extremo izquierdo. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT trimLeft('ClickHouse', 'Click');
```

```response title=Response theme={null}
┌─trimLeft('ClickHouse', 'Click')─┐
│ House                           │
└─────────────────────────────────┘
```

## trimRight

Introducido en: v20.1.0

Elimina los caracteres especificados del final de una cadena.
De forma predeterminada, elimina los caracteres comunes de espacios en blanco (ASCII).

**Sintaxis**

```sql theme={null}
trimRight(s[, trim_characters])
```

**Alias**: `rtrim`

**Argumentos**

* `s` — Cadena a recortar. [`String`](/es/reference/data-types/string)
* `trim_characters` — Caracteres opcionales que se eliminarán. Si no se especifican, se eliminan los caracteres de espacio en blanco habituales. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve la cadena con los caracteres especificados eliminados del extremo derecho. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT trimRight('ClickHouse','House');
```

```response title=Response theme={null}
┌─trimRight('ClickHouse', 'House')─┐
│ Click                            │
└──────────────────────────────────┘
```

## tryBase32Decode

Introducida en: v25.6.0

Acepta una cadena y la decodifica mediante el esquema de codificación [Base32](https://datatracker.ietf.org/doc/html/rfc4648#section-6).

**Sintaxis**

```sql theme={null}
tryBase32Decode(encoded)
```

**Argumentos**

* `encoded` — Columna de tipo `String` o constante que se va a decodificar. Si la cadena no es una codificación Base32 válida, devuelve una cadena vacía en caso de error. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena que contiene el valor decodificado del argumento. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT tryBase32Decode('IVXGG33EMVSA====');
```

```response title=Response theme={null}
┌─tryBase32Decode('IVXGG33EMVSA====')─┐
│ Encoded                             │
└─────────────────────────────────────┘
```

## tryBase58Decode

Introducido en: v22.10.0

Igual que [`base58Decode`](#base58Decode), pero devuelve una cadena vacía en caso de error.

**Sintaxis**

```sql theme={null}
tryBase58Decode(encoded[, expected_size])
```

**Argumentos**

* `encoded` — Columna de tipo String o constante. Si la cadena no está codificada en Base58 de forma válida, devuelve una cadena vacía en caso de error. [`String`](/es/reference/data-types/string)
* `expected_size` — Opcional. Tamaño requerido tras la decodificación, en bytes: se rechaza cualquier entrada que se decodifique a un tamaño distinto. `0` no impone ningún requisito. [`UInt8, UInt16, UInt32 o UInt64`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una cadena que contiene el valor decodificado del argumento. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT tryBase58Decode('3dc8KtHrwM') AS res, tryBase58Decode('invalid') AS res_invalid;
```

```response title=Response theme={null}
┌─res─────┬─res_invalid─┐
│ Encoded │             │
└─────────┴─────────────┘
```

## tryBase64Decode

Introducido en: v18.16.0

Igual que [`base64Decode`](#base64Decode), pero devuelve una cadena vacía en caso de error.

**Sintaxis**

```sql theme={null}
tryBase64Decode(encoded)
```

**Argumentos**

* `encoded` — Columna o constante de tipo `String` que se va a decodificar. Si la cadena no está codificada en Base64 de forma válida, devuelve una cadena vacía en caso de error. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena que contiene el valor decodificado del argumento. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT tryBase64Decode('Y2xpY2tob3VzZQ==')
```

```response title=Response theme={null}
┌─tryBase64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse                          │
└─────────────────────────────────────┘
```

## tryBase64URLDecode

Introducido en: v18.16.0

Igual que [`base64URLDecode`](#base64URLDecode), pero devuelve una cadena vacía en caso de error.

**Sintaxis**

```sql theme={null}
tryBase64URLDecode(encoded)
```

**Argumentos**

* `encoded` — columna `String` o constante que se va a decodificar. Si la cadena no es una codificación Base64 válida, devuelve una cadena vacía en caso de error. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena que contiene el valor decodificado del argumento. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')
```

```response title=Response theme={null}
┌─tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')─┐
│ https://clickhouse.com                               │
└──────────────────────────────────────────────────────┘
```

## tryIdnaEncode

Introducido en: v24.1.0

Devuelve la representación Unicode (UTF-8) (algoritmo ToUnicode) de un nombre de dominio según el mecanismo [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA).
En caso de error, devuelve una cadena vacía en lugar de lanzar una excepción.

**Sintaxis**

```sql theme={null}
tryIdnaEncode(s)
```

**Argumentos**

* `s` — Cadena de entrada. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una representación ASCII de la cadena de entrada conforme al mecanismo IDNA del valor de entrada, o una cadena vacía si la entrada no es válida. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT tryIdnaEncode('straße.münchen.de')
```

```response title=Response theme={null}
┌─tryIdnaEncode('straße.münchen.de')─┐
│ xn--strae-oqa.xn--mnchen-3ya.de    │
└────────────────────────────────────┘
```

## tryPunycodeDecode

Introducido en: v24.1.0

Como `punycodeDecode`, pero devuelve una cadena vacía si no se proporciona una cadena codificada en Punycode válida.

**Sintaxis**

```sql theme={null}
tryPunycodeDecode(s)
```

**Argumentos**

* `s` — Cadena codificada en Punycode. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el texto plano del valor de entrada, o una cadena vacía si la entrada no es válida. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT tryPunycodeDecode('Mnchen-3ya')
```

```response title=Response theme={null}
┌─tryPunycodeDecode('Mnchen-3ya')─┐
│ München                         │
└─────────────────────────────────┘
```

## upper

Introducido en: v1.1.0

Convierte a mayúsculas los caracteres latinos ASCII de una cadena.

**Sintaxis**

```sql theme={null}
upper(s)
```

**Alias**: `ucase`

**Argumentos**

* `s` — La cadena que se convertirá a mayúsculas. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una cadena en mayúsculas a partir de `s`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT upper('clickhouse')
```

```response title=Response theme={null}
┌─upper('clickhouse')─┐
│ CLICKHOUSE          │
└─────────────────────┘
```

## upperUTF8

Introducido en: v1.1.0

Convierte una cadena a mayúsculas, suponiendo que contiene texto válido codificado en UTF-8.
Si no se cumple esta condición, no se lanza ninguna excepción y el resultado es indefinido.

<Note>
  Esta función no detecta el idioma; por ejemplo, en turco, el resultado podría no ser del todo correcto (i/İ vs. i/I).
  Si la longitud de la secuencia de bytes UTF-8 difiere entre mayúsculas y minúsculas para un punto de código (como `ẞ` y `ß`), el resultado puede ser incorrecto para ese punto de código.
</Note>

**Sintaxis**

```sql theme={null}
upperUTF8(s)
```

**Argumentos**

* `s` — Un tipo String. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Un valor de tipo de dato String. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT upperUTF8('München') AS Upperutf8
```

```response title=Response theme={null}
┌─Upperutf8─┐
│ MÜNCHEN   │
└───────────┘
```