Devuelve 1 para una cadena vacía o 0 para una cadena no vacía.
El tipo de resultado es UInt8.
Una cadena se considera no vacía si contiene al menos un byte, incluso si se trata de un espacio o un byte nulo.
La función también funciona para matrices.
## notEmpty {#notempty}
Devuelve 0 para una cadena vacía o 1 para una cadena no vacía.
El tipo de resultado es UInt8.
La función también funciona para matrices.
## longitud {#length}
Devuelve la longitud de una cadena en bytes (no en caracteres y no en puntos de código).
El tipo de resultado es UInt64.
La función también funciona para matrices.
## longitudUTF8 {#lengthutf8}
Devuelve la longitud de una cadena en puntos de código Unicode (no en caracteres), suponiendo que la cadena contiene un conjunto de bytes que componen texto codificado en UTF-8. Si no se cumple esta suposición, devuelve algún resultado (no arroja una excepción).
El tipo de resultado es UInt64.
## char\_length, CHAR\_LENGTH {#char-length}
Devuelve la longitud de una cadena en puntos de código Unicode (no en caracteres), suponiendo que la cadena contiene un conjunto de bytes que componen texto codificado en UTF-8. Si no se cumple esta suposición, devuelve algún resultado (no arroja una excepción).
Devuelve la longitud de una cadena en puntos de código Unicode (no en caracteres), suponiendo que la cadena contiene un conjunto de bytes que componen texto codificado en UTF-8. Si no se cumple esta suposición, devuelve algún resultado (no arroja una excepción).
El tipo de resultado es UInt64.
## inferior, lcase {#lower}
Convierte símbolos latinos ASCII en una cadena a minúsculas.
## superior, ucase {#upper}
Convierte los símbolos latinos ASCII en una cadena a mayúsculas.
## Método de codificación de datos: {#lowerutf8}
Convierte una cadena en minúsculas, suponiendo que la cadena contiene un conjunto de bytes que componen un texto codificado en UTF-8.
No detecta el idioma. Entonces, para el turco, el resultado podría no ser exactamente correcto.
Si la longitud de la secuencia de bytes UTF-8 es diferente para mayúsculas y minúsculas de un punto de código, el resultado puede ser incorrecto para este punto de código.
Si la cadena contiene un conjunto de bytes que no es UTF-8, entonces el comportamiento no está definido.
Convierte una cadena en mayúsculas, suponiendo que la cadena contiene un conjunto de bytes que componen un texto codificado en UTF-8.
No detecta el idioma. Entonces, para el turco, el resultado podría no ser exactamente correcto.
Si la longitud de la secuencia de bytes UTF-8 es diferente para mayúsculas y minúsculas de un punto de código, el resultado puede ser incorrecto para este punto de código.
Si la cadena contiene un conjunto de bytes que no es UTF-8, entonces el comportamiento no está definido.
## Sistema abierto. {#isvalidutf8}
Devuelve 1, si el conjunto de bytes es válido codificado en UTF-8, de lo contrario 0.
## Acerca de Nosotros {#tovalidutf8}
Reemplaza los caracteres UTF-8 no válidos por `<60>` (U+FFFD) carácter. Todos los caracteres no válidos que se ejecutan en una fila se contraen en el único carácter de reemplazo.
``` sql
toValidUTF8( input_string )
```
Parámetros:
- input\_string — Cualquier conjunto de bytes representados como el [Cadena](../../data_types/string.md) objeto de tipo de datos.
Valor devuelto: cadena UTF-8 válida.
**Ejemplo**
``` sql
SELECT toValidUTF8('\x61\xF0\x80\x80\x80b')
```
``` text
┌─toValidUTF8('a<><61><EFBFBD><EFBFBD>b')─┐
│ a<>b │
└───────────────────────┘
```
## repetir {#repeat}
Repite una cadena tantas veces como se especifique y concatena los valores replicados como una única cadena.
**Sintaxis**
``` sql
repeat(s, n)
```
**Parámetros**
-`s` — La cadena de repetir. [Cadena](../../data_types/string.md).
-`n` — El número de veces para repetir la cadena. [UInt](../../data_types/int_uint.md).
**Valor devuelto**
La cadena única, que contiene la cadena `s` repetir `n` tiempo. Si `n` \< 1, la función devuelve cadena vacía.
Invierte una secuencia de puntos de código Unicode, suponiendo que la cadena contiene un conjunto de bytes que representan un texto UTF-8. De lo contrario, hace otra cosa (no arroja una excepción).
## Formato (patrón, s0, s1, …) {#format}
Formatear el patrón constante con la cadena enumerada en los argumentos. `pattern` es un patrón de formato de Python simplificado. La cadena de formato contiene “replacement fields” rodeado de llaves `{}`. Cualquier cosa que no esté contenida entre llaves se considera texto literal, que se copia sin cambios en la salida. Si necesita incluir un carácter de llave en el texto literal, se puede escapar duplicando: `{{ '{{' }}` y `{{ '}}' }}`. Los nombres de campo pueden ser números (comenzando desde cero) o vacíos (luego se tratan como números de consecuencia).
``` sql
SELECT format('{1} {0} {1}', 'World', 'Hello')
```
``` text
┌─format('{1} {0} {1}', 'World', 'Hello')─┐
│ Hello World Hello │
└─────────────────────────────────────────┘
```
``` sql
SELECT format('{} {}', 'Hello', 'World')
```
``` text
┌─format('{} {}', 'Hello', 'World')─┐
│ Hello World │
└───────────────────────────────────┘
```
## concat {#concat}
Concatena las cadenas enumeradas en los argumentos, sin un separador.
**Sintaxis**
``` sql
concat(s1, s2, ...)
```
**Parámetros**
Valores de tipo String o FixedString.
**Valores devueltos**
Devuelve la cadena que resulta de concatenar los argumentos.
Si alguno de los valores de argumento `NULL`, `concat` devoluciones `NULL`.
**Ejemplo**
Consulta:
``` sql
SELECT concat('Hello, ', 'World!')
```
Resultado:
``` text
┌─concat('Hello, ', 'World!')─┐
│ Hello, World! │
└─────────────────────────────┘
```
## ConcatAssumeInjective {#concatassumeinjective}
Lo mismo que [concat](#concat), la diferencia es que usted necesita asegurar eso `concat(s1, s2, ...) → sn` es inyectivo, se utilizará para la optimización de GROUP BY.
La función se llama “injective” si siempre devuelve un resultado diferente para diferentes valores de argumentos. En otras palabras: diferentes argumentos nunca arrojan un resultado idéntico.
**Sintaxis**
``` sql
concatAssumeInjective(s1, s2, ...)
```
**Parámetros**
Valores de tipo String o FixedString.
**Valores devueltos**
Devuelve la cadena que resulta de concatenar los argumentos.
Si alguno de los valores de argumento `NULL`, `concatAssumeInjective` devoluciones `NULL`.
Devuelve una subcadena que comienza con el byte ‘offset’ índice que es ‘length’ bytes de largo. La indexación de caracteres comienza desde uno (como en SQL estándar). El ‘offset’ y ‘length’ los argumentos deben ser constantes.
Lo mismo que ‘substring’, pero para puntos de código Unicode. Funciona bajo el supuesto de que la cadena contiene un conjunto de bytes que representan un texto codificado en UTF-8. Si no se cumple esta suposición, devuelve algún resultado (no arroja una excepción).
## Aquí hay algunas opciones) {#appendtrailingcharifabsent}
Si el ‘s’ cadena no está vacía y no contiene el ‘c’ carácter al final, se añade el ‘c’ carácter hasta el final.
## convertirCharset(s), de, a) {#convertcharset}
Devuelve la cadena ‘s’ que se convirtió de la codificación en ‘from’ a la codificación en ‘to’.
-`trim_character` — caracteres especificados para el recorte. [Cadena](../../data_types/string.md).
-`input_string` — cuerda para el acabado. [Cadena](../../data_types/string.md).
**Valor devuelto**
Una cadena sin caracteres especificados iniciales y (o) finales.
Tipo: `String`.
**Ejemplo**
Consulta:
``` sql
SELECT trim(BOTH ' ()' FROM '( Hello, world! )')
```
Resultado:
``` text
┌─trim(BOTH ' ()' FROM '( Hello, world! )')─┐
│ Hello, world! │
└───────────────────────────────────────────────┘
```
## trimLeft {#trimleft}
Quita todas las apariciones consecutivas de espacios en blanco comunes (carácter ASCII 32) desde el principio de una cadena. No elimina otros tipos de caracteres de espacio en blanco (tab, espacio sin interrupción, etc.).
**Sintaxis**
``` sql
trimLeft(input_string)
```
Apodo: `ltrim(input_string)`.
**Parámetros**
-`input_string` — cuerda para recortar. [Cadena](../../data_types/string.md).
**Valor devuelto**
Una cadena sin espacios en blanco comunes iniciales.
Tipo: `String`.
**Ejemplo**
Consulta:
``` sql
SELECT trimLeft(' Hello, world! ')
```
Resultado:
``` text
┌─trimLeft(' Hello, world! ')─┐
│ Hello, world! │
└─────────────────────────────────────┘
```
## trimRight {#trimright}
Quita todas las apariciones consecutivas de espacios en blanco comunes (carácter ASCII 32) del final de una cadena. No elimina otros tipos de caracteres de espacio en blanco (tab, espacio sin interrupción, etc.).
**Sintaxis**
``` sql
trimRight(input_string)
```
Apodo: `rtrim(input_string)`.
**Parámetros**
-`input_string` — cuerda para recortar. [Cadena](../../data_types/string.md).
**Valor devuelto**
Una cadena sin espacios en blanco comunes finales.
Tipo: `String`.
**Ejemplo**
Consulta:
``` sql
SELECT trimRight(' Hello, world! ')
```
Resultado:
``` text
┌─trimRight(' Hello, world! ')─┐
│ Hello, world! │
└──────────────────────────────────────┘
```
## AjusteTanto {#trimboth}
Quita todas las apariciones consecutivas de espacios en blanco comunes (carácter ASCII 32) de ambos extremos de una cadena. No elimina otros tipos de caracteres de espacio en blanco (tab, espacio sin interrupción, etc.).
**Sintaxis**
``` sql
trimBoth(input_string)
```
Apodo: `trim(input_string)`.
**Parámetros**
-`input_string` — cuerda para recortar. [Cadena](../../data_types/string.md).
**Valor devuelto**
Una cadena sin espacios en blanco comunes iniciales y finales.
