Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Funciones de cadena
**Topics**
+ [\$1\$1 Operador (concatenación)](r_concat_op.md)
+ [Función ASCII](r_ASCII.md)
+ [Función BPCHARCMP](r_BPCHARCMP.md)
+ [Función BTRIM](r_BTRIM.md)
+ [Función BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md)
+ [Función CHAR\$1LENGTH](r_CHAR_LENGTH.md)
+ [Función CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md)
+ [Función CHARINDEX](r_CHARINDEX.md)
+ [Función CHR](r_CHR.md)
+ [Función COLLATE](r_COLLATE.md)
+ [Función CONCAT](r_CONCAT.md)
+ [Función CRC32](crc32-function.md)
+ [Función DIFFERENCE](DIFFERENCE.md)
+ [Función INITCAP](r_INITCAP.md)
+ [Funciones LEFT y RIGHT](r_LEFT.md)
+ [Función LEN](r_LEN.md)
+ [Función LENGTH](r_LENGTH.md)
+ [Función LOWER](r_LOWER.md)
+ [Funciones LPAD y RPAD](r_LPAD.md)
+ [Función LTRIM](r_LTRIM.md)
+ [Función OCTETINDEX](OCTETINDEX.md)
+ [Función OCTET\$1LENGTH](r_OCTET_LENGTH.md)
+ [Función POSITION](r_POSITION.md)
+ [Función QUOTE\$1IDENT](r_QUOTE_IDENT.md)
+ [Función QUOTE\$1LITERAL](r_QUOTE_LITERAL.md)
+ [Función REGEXP\$1COUNT](REGEXP_COUNT.md)
+ [Función REGEXP\$1INSTR](REGEXP_INSTR.md)
+ [Función REGEXP\$1REPLACE](REGEXP_REPLACE.md)
+ [Función REGEXP\$1SUBSTR](REGEXP_SUBSTR.md)
+ [Función REPEAT](r_REPEAT.md)
+ [Función REPLACE](r_REPLACE.md)
+ [Función REPLICATE](r_REPLICATE.md)
+ [Función REVERSE](r_REVERSE.md)
+ [Función RTRIM](r_RTRIM.md)
+ [Función SOUNDEX](SOUNDEX.md)
+ [Función SPLIT\$1PART](SPLIT_PART.md)
+ [Función STRPOS](r_STRPOS.md)
+ [Función STRTOL](r_STRTOL.md)
+ [Función SUBSTRING](r_SUBSTRING.md)
+ [Función TEXTLEN](r_TEXTLEN.md)
+ [Función TRANSLATE](r_TRANSLATE.md)
+ [Función TRIM](r_TRIM.md)
+ [Función UPPER](r_UPPER.md)
Las funciones de cadena procesan y administran cadenas de caracteres o expresiones que tomen el valor de cadenas de caracteres. Cuando el argumento *string* de estas funciones es un valor literal, debe incluirse entre comillas simples. Entre los tipos de datos compatibles, se incluyen CHAR y VARCHAR.
En la sección siguiente, se proporcionan los nombres de función, la sintaxis y las descripciones para las funciones compatibles. Todos los desplazamientos en cadenas se basan en uno.
**Funciones específicas del nodo principal obsoletas**
Las siguientes funciones de cadena son obsoletas porque se ejecutan únicamente en el nodo principal. Para obtener más información, consulte [Funciones específicas del nodo principal](c_SQL_functions_leader_node_only.md)
+ GET\$1BYTE
+ SET\$1BIT
+ SET\$1BYTE
+ TO\$1ASCII
# \$1\$1 Operador (concatenación)
Concatena dos expresiones a ambos extremos del símbolo `||` y devuelve una expresión concatenada.
Similar a [Función CONCAT](r_CONCAT.md).
**nota**
Si una o ambas expresiones son nulas, el resultado de la concatenación es `NULL`.
## Sintaxis
```
expression1 || expression2
```
## Argumentos
*expression1*
Una cadena `CHAR`, una cadena `VARCHAR`, una expresión binaria o una expresión que se evalúa como uno de estos tipos.
*expression2*
Una cadena `CHAR`, una cadena `VARCHAR`, una expresión binaria o una expresión que se evalúa como uno de estos tipos.
## Tipo de retorno
El tipo de devolución de la cadena es el mismo que el de los argumentos de entrada. Por ejemplo, la concatenación de dos cadenas de tipo `VARCHAR` devuelve una cadena de tipo `VARCHAR`.
## Ejemplos
En los siguientes ejemplos se utilizan las tablas USERS y VENUE de la base de datos de muestra de TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para concatenar los campos FIRSTNAME y LASTNAME de la tabla USERS de la base de datos de muestra, utilice el siguiente ejemplo.
```
SELECT (firstname || ' ' || lastname) as fullname
FROM users
ORDER BY 1
LIMIT 10;
+-----------------+
| fullname |
+-----------------+
| Aaron Banks |
| Aaron Booth |
| Aaron Browning |
| Aaron Burnett |
| Aaron Casey |
| Aaron Cash |
| Aaron Castro |
| Aaron Dickerson |
| Aaron Dixon |
| Aaron Dotson |
+-----------------+
```
Para concatenar columnas que puedan llegar a tener valores nulos, use la expresión [Funciones NVL y COALESCE](r_NVL_function.md). En el siguiente ejemplo se utiliza NVL para devolver `0` siempre que se encuentre `NULL`.
```
SELECT (venuename || ' seats ' || NVL(venueseats, 0)) as seating
FROM venue
WHERE venuestate = 'NV' or venuestate = 'NC'
ORDER BY 1
LIMIT 10;
+-------------------------------------+
| seating |
+-------------------------------------+
| Ballys Hotel seats 0 |
| Bank of America Stadium seats 73298 |
| Bellagio Hotel seats 0 |
| Caesars Palace seats 0 |
| Harrahs Hotel seats 0 |
| Hilton Hotel seats 0 |
| Luxor Hotel seats 0 |
| Mandalay Bay Hotel seats 0 |
| Mirage Hotel seats 0 |
| New York New York seats 0 |
+-------------------------------------+
```
# Función ASCII
La función ASCII devuelve el código ASCII, o el punto de código Unicode, del primer carácter de la cadena especificada. La función devuelve `0` si la cadena está vacía. Si la cadena es nula, se devuelve `NULL`.
## Sintaxis
```
ASCII('string')
```
## Argumento
*cadena*
Una cadena `CHAR` o `VARCHAR`.
## Tipo de retorno
INTEGER
## Ejemplos
Para devolver `NULL`, use el siguiente ejemplo. La función NULLIF devuelve `NULL` si los dos argumentos son iguales, así que el argumento de entrada de la función ASCII es `NULL`. Para obtener más información, consulte [Función NULLIF](r_NULLIF_function.md).
```
SELECT ASCII(NULLIF('',''));
+-------+
| ascii |
+-------+
| NULL |
+-------+
```
Para devolver el código ASCII de 0, utilice el siguiente ejemplo.
```
SELECT ASCII('');
+-------+
| ascii |
+-------+
| 0 |
+-------+
```
Para devolver el código ASCII 97 para la primera letra de la palabra Amazon, use el siguiente ejemplo.
```
SELECT ASCII('amazon');
+-------+
| ascii |
+-------+
| 97 |
+-------+
```
Para devolver el código ASCII 65 para la primera letra de la palabra Amazon, use el siguiente ejemplo.
```
SELECT ASCII('Amazon');
+-------+
| ascii |
+-------+
| 65 |
+-------+
```
# Función BPCHARCMP
Compara el valor de dos cadenas y devuelve un valor entero. Si las cadenas son idénticas, la función devuelve `0`. Si la primera cadena es mayor alfabéticamente, la función devuelve `1`. Si la segunda cadena es mayor, la función devuelve `-1`.
Para caracteres multibyte, la comparación se basa en la codificación del byte.
Sinónimo de [Función BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md).
## Sintaxis
```
BPCHARCMP(string1, string2)
```
## Argumentos
*string1*
Una cadena `CHAR` o `VARCHAR`.
*string2 (cadena2*
Una cadena `CHAR` o `VARCHAR`.
## Tipo de retorno
INTEGER
## Ejemplos
En los siguientes ejemplos se utiliza la tabla VENUE de la base de datos de muestra de TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para determinar si el nombre de un usuario es alfabéticamente mayor que el apellido del usuario para las primeras diez entradas en la tabla USERS, use el siguiente ejemplo. Para las entradas en las que la cadena de FIRSTNAME es posterior alfabéticamente a la cadena de LASTNAME, la función devuelve `1`. Si LASTNAME es alfabéticamente posterior a FIRSTNAME, la función devuelve `-1`.
```
SELECT userid, firstname, lastname, BPCHARCMP(firstname, lastname)
FROM users
ORDER BY 1, 2, 3, 4
LIMIT 10;
+--------+-----------+-----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+-----------+-----------+
| 1 | Rafael | Taylor | -1 |
| 2 | Vladimir | Humphrey | 1 |
| 3 | Lars | Ratliff | -1 |
| 4 | Barry | Roy | -1 |
| 5 | Reagan | Hodge | 1 |
| 6 | Victor | Hernandez | 1 |
| 7 | Tamekah | Juarez | 1 |
| 8 | Colton | Roy | -1 |
| 9 | Mufutau | Watkins | -1 |
| 10 | Naida | Calderon | 1 |
+--------+-----------+-----------+-----------+
```
Para devolver todas las entradas de la tabla USERS en las que la función devuelve `0`, use el siguiente ejemplo. La función devuelve `0` cuando FIRSTNAME es idéntico a LASTNAME.
```
SELECT userid, firstname, lastname,
BPCHARCMP(firstname, lastname)
FROM users
WHERE BPCHARCMP(firstname, lastname)=0
ORDER BY 1, 2, 3, 4;
+--------+-----------+----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+----------+-----------+
| 62 | Chase | Chase | 0 |
| 4008 | Whitney | Whitney | 0 |
| 12516 | Graham | Graham | 0 |
| 13570 | Harper | Harper | 0 |
| 16712 | Cooper | Cooper | 0 |
| 18359 | Chase | Chase | 0 |
| 27530 | Bradley | Bradley | 0 |
| 31204 | Harding | Harding | 0 |
+--------+-----------+----------+-----------+
```
# Función BTRIM
La función BTRIM recorta una cadena al eliminar espacios o caracteres a la izquierda y a la derecha que coincidan con una cadena específica opcional.
## Sintaxis
```
BTRIM(string [, trim_chars ] )
```
## Argumentos
*cadena*
Es la cadena VARCHAR de entrada que se va a recortar.
*trim\$1chars*
Es la cadena VARCHAR que contiene los caracteres que deben coincidir.
## Tipo de retorno
La función BTRIM devuelve una cadena VARCHAR.
## Ejemplos
En el siguiente ejemplo, se recortan espacios a la izquierda y a la derecha de la cadena `' abc '`:
```
select ' abc ' as untrim, btrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
En el siguiente ejemplo, se eliminan las cadenas `'xyz'` a la izquierda y a la derecha de la cadena `'xyzaxyzbxyzcxyz'`. Las coincidencias a la izquierda y a la derecha de `'xyz'` se eliminan, pero las coincidencias internas dentro de la cadena no se eliminan.
```
select 'xyzaxyzbxyzcxyz' as untrim,
btrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | axyzbxyzc
```
En el siguiente ejemplo, se eliminan las partes a la izquierda y a la derecha de la cadena `'setuphistorycassettes'` que coinciden con cualquiera de los caracteres de la lista *trim\$1chars* `'tes'`. Cualquier `t`, `e` o `s` que aparcezca antes de cualquier carácter que no esté en la lista *trim\$1chars* a la izquierda o a la derecha de la cadena de entrada se eliminará.
```
SELECT btrim('setuphistorycassettes', 'tes');
btrim
-----------------
uphistoryca
```
# Función BTTEXT\$1PATTERN\$1CMP
Sinónimo para la función BPCHARCMP.
Para obtener más información, consulte [Función BPCHARCMP](r_BPCHARCMP.md).
# Función CHAR\$1LENGTH
Sinónimo de la función LEN.
Consulte [Función LEN](r_LEN.md).
# Función CHARACTER\$1LENGTH
Sinónimo de la función LEN.
Consulte [Función LEN](r_LEN.md).
# Función CHARINDEX
Devuelve la ubicación de la subcadena especificada dentro de una cadena.
Consulte [Función POSITION](r_POSITION.md) y [Función STRPOS](r_STRPOS.md) para ver funciones similares.
## Sintaxis
```
CHARINDEX( substring, string )
```
## Argumentos
*subcadena*
Subcadena que se va a buscar dentro de la *cadena*.
*cadena*
La cadena o columna que se buscará.
## Tipo de retorno
INTEGER
La función CHARINDEX devuelve un valor `INTEGER` correspondiente a la posición de la subcadena (basado en uno, no basado en cero). La posición se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples. CHARINDEX devuelve `0` si no se encuentra una subcadena dentro de la cadena.
## Ejemplos
Para devolver la posición de la cadena `fish` dentro de la palabra `dog`, use el siguiente ejemplo.
```
SELECT CHARINDEX('fish', 'dog');
+-----------+
| charindex |
+-----------+
| 0 |
+-----------+
```
Para devolver la posición de la cadena `fish` dentro de la palabra `dogfish`, use el siguiente ejemplo.
```
SELECT CHARINDEX('fish', 'dogfish');
+-----------+
| charindex |
+-----------+
| 4 |
+-----------+
```
En el siguiente ejemplo, se utiliza la tabla SALES de la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para devolver la cantidad de transacciones de venta distintas con un parámetro de comisión que supere los 999 de la tabla SALES, use el siguiente ejemplo. Este comando cuenta las comisiones superiores a 999 comprobando si el decimal está a más de 4 lugares del principio del valor de la comisión.
```
SELECT DISTINCT CHARINDEX('.', commission), COUNT (CHARINDEX('.', commission))
FROM sales
WHERE CHARINDEX('.', commission) > 4
GROUP BY CHARINDEX('.', commission)
ORDER BY 1,2;
+-----------+-------+
| charindex | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# Función CHR
La función CHR devuelve el carácter que coincida con el valor de punto de código ASCII especificado por el parámetro de entrada.
## Sintaxis
```
CHR(number)
```
## Argumento
*número*
El parámetro de entrada es un valor `INTEGER` que representa un valor de punto de código ASCII.
## Tipo de retorno
CHAR
La función CHR devuelve una cadena `CHAR` si el carácter ASCII coincide con el valor de entrada. Si el número de entrada no tiene una coincidencia ASCII, la función devuelve un valor `NULL`.
## Ejemplos
Para devolver el carácter que corresponde al punto 0 del código ASCII, utilice el siguiente ejemplo. Tenga en cuenta que la función CHR devuelve `NULL` para la entrada `0`.
```
SELECT CHR(0);
+-----+
| chr |
+-----+
| |
+-----+
```
Para devolver el carácter que corresponde al punto 65 del código ASCII, utilice el siguiente ejemplo.
```
SELECT CHR(65);
+-----+
| chr |
+-----+
| A |
+-----+
```
Para devolver distintos nombres de eventos que comienzan con una A mayúscula (punto de código ASCII 65). use el siguiente ejemplo. En el siguiente ejemplo se utiliza la tabla EVENT de la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
```
SELECT DISTINCT eventname FROM event
WHERE SUBSTRING(eventname, 1, 1)=CHR(65) LIMIT 5;
+-----------------------+
| eventname |
+-----------------------+
| A Catered Affair |
| As You Like It |
| A Man For All Seasons |
| Alan Jackson |
| Armando Manzanero |
+-----------------------+
```
# Función COLLATE
La función COLLATE anula la intercalación de una expresión o una columna de cadenas.
Para obtener información sobre cómo crear tablas mediante la intercalación de bases de datos, consulte [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Para obtener información sobre cómo crear bases de datos mediante la intercalación de bases de datos, consulte [CREATE DATABASE](r_CREATE_DATABASE.md).
## Sintaxis
```
COLLATE( string, 'case_sensitive' | 'cs' | 'case_insensitive' | 'ci');
```
## Argumentos
*cadena*
Una expresión o una columna de cadenas que desea invalidar.
*'case\$1sensitive'* \$1 *'cs'* \$1 *'case\$1insensitive'* \$1 *'ci'*
Una constante de cadena de un nombre de intercalación. Amazon Redshift solo admite los siguientes valores para este parámetro:
+ *case\$1sensitive*
+ *cs*
+ *case\$1insensitive*
+ *ci*
*case\$1sensitive* y *cs* son intercambiables y producen los mismos resultados. Del mismo modo, *case\$1insensitive* y *ci* son intercambiables y producen los mismos resultados.
## Tipo de retorno
La función COLLATE devuelve `VARCHAR`, `CHAR` o `SUPER` de acuerdo con el primer tipo de expresión de entrada. Esta función solo cambia la intercalación del primer argumento de entrada y no modifica su valor de salida.
## Ejemplos
Para crear la tabla T y definir col1 en la tabla T como `case_sensitive`, utilice el ejemplo siguiente.
```
CREATE TABLE T ( col1 Varchar(20) COLLATE case_sensitive );
INSERT INTO T VALUES ('john'),('JOHN');
```
Al ejecutar la primera consulta, Amazon Redshift solo devuelve `john`. Después de que la función COLLATE se ejecuta en col1, la intercalación se vuelve `case_insensitive`. La segunda consulta devuelve `john` y `JOHN`.
```
SELECT * FROM T WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
+------+
SELECT * FROM T WHERE COLLATE(col1, 'case_insensitive') = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
```
Para crear la tabla A y definir col1 en la tabla A como `case_insensitive`, utilice el ejemplo siguiente.
```
CREATE TABLE A ( col1 Varchar(20) COLLATE case_insensitive );
INSERT INTO A VALUES ('john'),('JOHN');
```
Al ejecutar la primera consulta, Amazon Redshift devuelve `john` y `JOHN`. Después de que la función COLLATE se ejecuta en col1, la intercalación se vuelve `case_sensitive`. La segunda consulta solo devuelve `john`.
```
SELECT * FROM A WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
SELECT * FROM A WHERE COLLATE(col1, 'case_sensitive') = 'john';
+------+
| col1 |
+------+
| john |
+------+
```
# Función CONCAT
La función CONCAT concatena dos expresiones y devuelve la expresión resultante. Para concatenar más de dos expresiones, utilice las funciones CONCAT anidadas. El operador de concatenación (`||`) entre dos expresiones produce los mismos resultados que la función CONCAT.
## Sintaxis
```
CONCAT ( expression1, expression2 )
```
## Argumentos
*expression1*, *expression2*
Ambos argumentos pueden consistir en una cadena de caracteres de longitud fija, una cadena de caracteres de longitud variable, una expresión binaria o una expresión que tiene como valor una de estas entradas de datos.
## Tipo de retorno
CONCAT devuelve una expresión. El tipo de datos de la expresión es igual al de los argumentos de entrada.
Si las expresiones de entrada son de diferentes tipos, Amazon Redshift intenta realizar una conversión de tipo de manera implícita en una de las expresiones. Si no se pueden convertir los valores, se devuelve un error.
## Notas de uso
+ Para la función CONCAT y el operador de concatenación, si una o ambas expresiones son nulas, el resultado de la concatenación también lo será.
## Ejemplos
En el siguiente ejemplo, se concatenan dos literales de caracteres:
```
SELECT CONCAT('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
La siguiente consulta, utilizando el operador `||` en lugar de CONCAT, produce el mismo resultado:
```
SELECT 'December 25, '||'2008';
?column?
-------------------
December 25, 2008
(1 row)
```
El siguiente ejemplo utiliza una función CONCAT anidada dentro de otra función CONCAT para concatenar tres cadenas de caracteres:
```
SELECT CONCAT('Thursday, ', CONCAT('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Para concatenar columnas que puedan contener NULL, utilice la función [Funciones NVL y COALESCE](r_NVL_function.md), que devuelve un valor determinado cuando encuentra un valor NULL. En el siguiente ejemplo, se usa NVL para devolver un 0 siempre que se encuentre un NULL.
```
SELECT CONCAT(venuename, CONCAT(' seats ', NVL(venueseats, 0))) AS seating
FROM venue WHERE venuestate = 'NV' OR venuestate = 'NC'
ORDER BY 1
LIMIT 5;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
(5 rows)
```
En la siguiente consulta, se concatenan valores CITY y STATE de la tabla VENUE:
```
SELECT CONCAT(venuecity, venuestate)
FROM venue
WHERE venueseats > 75000
ORDER BY venueseats;
concat
-------------------
DenverCO
Kansas CityMO
East RutherfordNJ
LandoverMD
(4 rows)
```
La siguiente consulta utiliza funciones CONCAT anidadas. La consulta concatena los valores CITY y STATE de la tabla VENUE pero delimita la cadena resultado con una coma y un espacio:
```
SELECT CONCAT(CONCAT(venuecity,', '),venuestate)
FROM venue
WHERE venueseats > 75000
ORDER BY venueseats;
concat
---------------------
Denver, CO
Kansas City, MO
East Rutherford, NJ
Landover, MD
(4 rows)
```
En el siguiente ejemplo, se concatenan dos expresiones binarias. Donde `abc` es un valor binario (con una representación hexadecimal de `616263`) y `def` es un valor binario (con representación hexadecimal de `646566`). El resultado se muestra automáticamente como representación hexadecimal del valor binario.
```
SELECT CONCAT('abc'::VARBYTE, 'def'::VARBYTE);
concat
-------------------
616263646566
```
# Función CRC32
CRC32 es una función que se utiliza para la detección de errores. La función utiliza un algoritmo CRC32 para detectar cambios entre datos de origen y de destino. La función CRC32 convierte una cadena de longitud variable en una cadena de 8 caracteres que es una representación textual del valor hexadecimal de una secuencia binaria de 32 bits. Para detectar cambios entre los datos de origen y de destino, utilice la función CRC32 en los datos de origen y almacene la salida. A continuación, utilice la función CRC32 en los datos de destino y compare esa salida con la salida de los datos de origen. Las salidas serán las mismas si los datos no se modificaron y las salidas serán diferentes si se modificaron los datos.
## Sintaxis
```
CRC32(string)
```
## Argumentos
*cadena*
Una cadena `CHAR`, una cadena `VARCHAR` o una expresión que se evalúe de forma implícita como un tipo `CHAR` o `VARCHAR`.
## Tipo de retorno
La función CRC32 devuelve una cadena de 8 caracteres que es una representación textual del valor hexadecimal de una secuencia binaria de 32 bits. La función CRC32 de Amazon Redshift se basa en el polinomio CRC-32C.
## Ejemplos
Para mostrar el valor de 8 bits de la cadena `Amazon Redshift`.
```
SELECT CRC32('Amazon Redshift');
+----------+
| crc32 |
+----------+
| f2726906 |
+----------+
```
# Función DIFFERENCE
La función DIFFERENCE compara los códigos de American Soundex de dos cadenas. La función devuelve un `INTEGER` para indicar el número de caracteres coincidentes entre los códigos de Soundex.
Un código de Soundex es una cadena de cuatro caracteres. Un código de Soundex representa cómo suena una palabra en lugar de cómo se deletrea. Por ejemplo, `Smith` y `Smyth` tienen el mismo código de Soundex.
## Sintaxis
```
DIFFERENCE(string1, string2)
```
## Argumentos
*string1*
Una cadena `CHAR`, una cadena `VARCHAR` o una expresión que se evalúe de forma implícita como un tipo `CHAR` o `VARCHAR`.
*string2 (cadena2*
Una cadena `CHAR`, una cadena `VARCHAR` o una expresión que se evalúe de forma implícita como un tipo `CHAR` o `VARCHAR`.
## Tipo de retorno
INTEGER
La función DIFFERENCE devuelve un valor `INTEGER` de 0 a 4 que cuenta el número de caracteres coincidentes en los códigos American Soundex de las dos cadenas. Un código de Soundex tiene 4 caracteres, por lo que la función DIFFERENCE devuelve `4` cuando los 4 caracteres de los valores de código de American Soundex de las cadenas son iguales. DIFFERENCE devuelve `0` si una de las dos cadenas está vacía. La función devuelve `1` si ninguna cadena contiene caracteres válidos. La función DIFFERENCE solo convierte caracteres ASCII alfabéticos en minúsculas o mayúsculas en inglés, incluidas las letras a-z y A-Z. DIFFERENCE omite otros caracteres.
## Ejemplos
Para comparar los valores de Soundex de las cadenas `%` y `@`, utilice el ejemplo siguiente. La función devuelve `1` porque ninguna cadena contiene caracteres válidos.
```
SELECT DIFFERENCE('%', '@');
+------------+
| difference |
+------------+
| 1 |
+------------+
```
Para comparar los valores de Soundex de `Amazon` y una cadena vacía, utilice el ejemplo siguiente. La función devuelve `0` porque una de las dos cadenas está vacía.
```
SELECT DIFFERENCE('Amazon', '');
+------------+
| difference |
+------------+
| 0 |
+------------+
```
Para comparar los valores de Soundex de las cadenas `Amazon` y `Ama`, utilice el ejemplo siguiente. La función devuelve `2` porque 2 caracteres de los valores de Soundex de las cadenas son iguales.
```
SELECT DIFFERENCE('Amazon', 'Ama');
+------------+
| difference |
+------------+
| 2 |
+------------+
```
Para comparar los valores de Soundex de las cadenas `Amazon` y `+-*/%Amazon`, utilice el ejemplo siguiente. La función devuelve `4` porque 4 caracteres de los valores de Soundex de las cadenas son iguales. Observe que la función ignora los caracteres no válidos `+-*/%` en la segunda cadena.
```
SELECT DIFFERENCE('Amazon', '+-*/%Amazon');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
Para comparar los valores de Soundex de las cadenas `AC/DC` y `Ay See Dee See`, utilice el ejemplo siguiente. La función devuelve `4` porque 4 caracteres de los valores de Soundex de las cadenas son iguales.
```
SELECT DIFFERENCE('AC/DC', 'Ay See Dee See');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
# Función INITCAP
Pone en mayúsculas la primera letra de cada palabra en una cadena especificada. INITCAP admite caracteres multibyte UTF-8 de hasta un máximo de cuatro bytes por carácter.
## Sintaxis
```
INITCAP(string)
```
## Argumento
*cadena*
Una cadena `CHAR`, una cadena `VARCHAR` o una expresión que se evalúe de forma implícita como un tipo `CHAR` o `VARCHAR`.
## Tipo de retorno
VARCHAR
## Notas de uso
La función INITCAP hace que la primera letra de cada palabra en una cadena esté en mayúsculas y todas las letras subsiguientes (o hacia la izquierda) estén en minúsculas. Por lo tanto, es importante comprender qué caracteres (que no sean espacios) funcionan como separadores de palabras. Un carácter *separador de palabra* es cualquier carácter no alfanumérico, incluidos los signos de puntuación, los símbolos y los caracteres de control. Todos los siguientes caracteres son separadores de palabras:
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Tabulaciones, caracteres en línea nueva, fuentes de forma, fuentes de línea y saltos de línea también son separadores de palabra.
## Ejemplos
En los siguientes ejemplos se utilizan datos de las tablas CATEGORY y USERS en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para escribir en mayúsculas las iniciales de cada palabra en la columna CATDESC, use el siguiente ejemplo.
```
SELECT catid, catdesc, INITCAP(catdesc)
FROM category
ORDER BY 1, 2, 3;
+-------+--------------------------------------------+--------------------------------------------+
| catid | catdesc | initcap |
+-------+--------------------------------------------+--------------------------------------------+
| 1 | Major League Baseball | Major League Baseball |
| 2 | National Hockey League | National Hockey League |
| 3 | National Football League | National Football League |
| 4 | National Basketball Association | National Basketball Association |
| 5 | Major League Soccer | Major League Soccer |
| 6 | Musical theatre | Musical Theatre |
| 7 | All non-musical theatre | All Non-Musical Theatre |
| 8 | All opera and light opera | All Opera And Light Opera |
| 9 | All rock and pop music concerts | All Rock And Pop Music Concerts |
| 10 | All jazz singers and bands | All Jazz Singers And Bands |
| 11 | All symphony, concerto, and choir concerts | All Symphony, Concerto, And Choir Concerts |
+-------+--------------------------------------------+--------------------------------------------+
```
Para mostrar que la función INITCAP no preserva caracteres en mayúsculas donde no comienzan palabras, use el siguiente ejemplo. Por ejemplo, la cadena `MLB` se convierte en `Mlb`.
```
SELECT INITCAP(catname)
FROM category
ORDER BY catname;
+-----------+
| initcap |
+-----------+
| Classical |
| Jazz |
| Mlb |
| Mls |
| Musicals |
| Nba |
| Nfl |
| Nhl |
| Opera |
| Plays |
| Pop |
+-----------+
```
Para mostrar que los caracteres no alfanuméricos distintos de los espacios funcionan como separadores de palabras, utilice el siguiente ejemplo. Se escribirán en mayúscula varias letras de cada cadena.
```
SELECT email, INITCAP(email)
FROM users
ORDER BY userid DESC LIMIT 5;
+------------------------------------+------------------------------------+
| email | initcap |
+------------------------------------+------------------------------------+
| urna.Ut@egetdictumplacerat.edu | Urna.Ut@Egetdictumplacerat.Edu |
| nibh.enim@egestas.ca | Nibh.Enim@Egestas.Ca |
| in@Donecat.ca | In@Donecat.Ca |
| sodales@blanditviverraDonec.ca | Sodales@Blanditviverradonec.Ca |
| sociis.natoque.penatibus@vitae.org | Sociis.Natoque.Penatibus@Vitae.Org |
+------------------------------------+------------------------------------+
```
# Funciones LEFT y RIGHT
Estas funciones devuelven la cantidad especificada de caracteres más a la izquierda o más a la derecha de una cadena de caracteres.
La cantidad se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples.
## Sintaxis
```
LEFT( string, integer )
RIGHT( string, integer )
```
## Argumentos
*cadena*
Una cadena `CHAR`, una cadena `VARCHAR` o cualquier expresión que se evalúe como una cadena `CHAR` o `VARCHAR`.
*entero*
Un número entero.
## Tipo de retorno
VARCHAR
## Ejemplos
En el siguiente ejemplo se utilizan datos de la tabla EVENT en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para devolver los 5 caracteres más a la izquierda y los 5 más a la derecha de nombres de eventos que tienen ID de eventos entre 1000 y 1005, use el siguiente ejemplo.
```
SELECT eventid, eventname,
LEFT(eventname,5) AS left_5,
RIGHT(eventname,5) AS right_5
FROM event
WHERE eventid BETWEEN 1000 AND 1005
ORDER BY 1;
+---------+----------------+--------+---------+
| eventid | eventname | left_5 | right_5 |
+---------+----------------+--------+---------+
| 1000 | Gypsy | Gypsy | Gypsy |
| 1001 | Chicago | Chica | icago |
| 1002 | The King and I | The K | and I |
| 1003 | Pal Joey | Pal J | Joey |
| 1004 | Grease | Greas | rease |
| 1005 | Chicago | Chica | icago |
+---------+----------------+--------+---------+
```
# Función LEN
Devuelve la longitud de la cadena especificada como el número de caracteres.
## Sintaxis
LEN es sinónimo de [Función LENGTH](r_LENGTH.md), [Función CHAR\$1LENGTH](r_CHAR_LENGTH.md), [Función CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md) y [Función TEXTLEN](r_TEXTLEN.md).
```
LEN(expression)
```
## Argumento
*expresión*
Una cadena `CHAR`, una cadena `VARCHAR`, una expresión `VARBYTE` o una expresión que se evalúe de forma implícita como un tipo `CHAR`, `VARCHAR` o `VARBYTE`.
## Tipo de retorno
INTEGER
La función LEN devuelve un valor entero que indica la cantidad de caracteres en la cadena de entrada.
Si la cadena de entrada es una cadena de caracteres, la función LEN devuelve una cantidad real de caracteres en cadenas multibyte y no la cantidad de bytes. Por ejemplo, una columna `VARCHAR(12)` necesita almacenar tres caracteres chinos de cuatro bytes. La función LEN devolverá `3` para esa misma cadena. Para obtener la longitud de la cadena en bytes, use la función [OCTET\$1LENGTH](r_OCTET_LENGTH.md).
## Notas de uso
Si la *expresión* es una cadena `CHAR`, los espacios finales no se cuentan.
Si la *expresión* es una cadena `VARCHAR`, los espacios finales se cuentan.
## Ejemplos
Para devolver el número de bytes y el número de caracteres de la cadena `français`, use el siguiente ejemplo.
```
SELECT OCTET_LENGTH('français'),
LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Para que se devuelva el número de bytes y el número de caracteres de la cadena `français` sin utilizar la función OCTET\$1LENGTH, utilice el siguiente ejemplo. Para obtener más información, consulte la [Función CAST](r_CAST_function.md).
```
SELECT LEN(CAST('français' AS VARBYTE)) as bytes, LEN('français');
+-------+-----+
| bytes | len |
+-------+-----+
| 9 | 8 |
+-------+-----+
```
Para devolver el número de caracteres de las cadenas `cat` sin espacios finales, `cat ` con tres espacios finales, `cat ` con tres espacios finales configurados como `CHAR` de 6 de longitud y `cat ` con tres espacios finales moldeados a modo de `VARCHAR` de longitud 6, utilice el siguiente ejemplo. Observe que la función no cuenta los espacios finales para las cadenas `CHAR`, pero sí cuenta los espacios finales para las cadenas `VARCHAR`.
```
SELECT LEN('cat'), LEN('cat '), LEN(CAST('cat ' AS CHAR(6))) AS len_char, LEN(CAST('cat ' AS VARCHAR(6))) AS len_varchar;
+-----+-----+----------+-------------+
| len | len | len_char | len_varchar |
+-----+-----+----------+-------------+
| 3 | 6 | 3 | 6 |
+-----+-----+----------+-------------+
```
En el siguiente ejemplo se utilizan datos de la tabla VENUE en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para devolver los 10 nombres de lugares más largos en la tabla VENUE, utilice el siguiente ejemplo.
```
SELECT venuename, LEN(venuename)
FROM venue
ORDER BY 2 DESC, 1
LIMIT 10;
+-----------------------------------------+-----+
| venuename | len |
+-----------------------------------------+-----+
| Saratoga Springs Performing Arts Center | 39 |
| Lincoln Center for the Performing Arts | 38 |
| Nassau Veterans Memorial Coliseum | 33 |
| Jacksonville Municipal Stadium | 30 |
| Rangers BallPark in Arlington | 29 |
| University of Phoenix Stadium | 29 |
| Circle in the Square Theatre | 28 |
| Hubert H. Humphrey Metrodome | 28 |
| Oriole Park at Camden Yards | 27 |
| Dick's Sporting Goods Park | 26 |
+-----------------------------------------+-----+
```
# Función LENGTH
Sinónimo de la función LEN.
Consulte [Función LEN](r_LEN.md).
# Función LOWER
Convierte una cadena de caracteres a minúsculas. LOWER admite caracteres multibyte UTF-8 de hasta un máximo de cuatro bytes por carácter.
## Sintaxis
```
LOWER(string)
```
## Argumento
*cadena*
Una cadena o expresión `VARCHAR` que se evalúa como el tipo `VARCHAR`.
## Tipo de retorno
cadena
La función LOWER devuelve una cadena que presenta el mismo tipo de datos que la cadena de entrada. Por ejemplo, si la entrada es una cadena `CHAR`, la función devolverá una cadena `CHAR`.
## Ejemplos
En el siguiente ejemplo se utilizan datos de la tabla CATEGORY en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para convertir las cadenas `VARCHAR` de la columna CATNAME en minúsculas, utilice el siguiente ejemplo.
```
SELECT catname, LOWER(catname) FROM category ORDER BY 1,2;
+-----------+-----------+
| catname | lower |
+-----------+-----------+
| Classical | classical |
| Jazz | jazz |
| MLB | mlb |
| MLS | mls |
| Musicals | musicals |
| NBA | nba |
| NFL | nfl |
| NHL | nhl |
| Opera | opera |
| Plays | plays |
| Pop | pop |
+-----------+-----------+
```
# Funciones LPAD y RPAD
Estas funciones anteponen o anexan caracteres a una cadena, según una longitud especificada.
## Sintaxis
```
LPAD(string1, length, [ string2 ])
```
```
RPAD(string1, length, [ string2 ])
```
## Argumentos
*string1*
Una cadena `CHAR`, una cadena `VARCHAR` o una expresión que se evalúe de forma implícita como un tipo `CHAR` o `VARCHAR`.
*length*
Un valor entero que define la longitud del resultado de la función. La longitud de una cadena se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples. Si *string1 (cadena1)* tiene una longitud mayor que la especificada, se trunca (a la derecha). Si el valor de *longitud* es cero o un número negativo, el resultado de la función es una cadena vacía.
*string2 (cadena2*
(Opcional) Uno o varios caracteres que se anteponen o anexan a *string1*. Si este argumento no se especifica, se utilizan espacios.
## Tipo de retorno
VARCHAR
## Ejemplos
En los siguientes ejemplos se utilizan datos de la tabla EVENT en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para truncar un conjunto especificado de nombres de eventos a 20 caracteres y anteponer espacios a los nombres más cortos, use el siguiente ejemplo.
```
SELECT LPAD(eventname, 20) FROM event
WHERE eventid BETWEEN 1 AND 5 ORDER BY 1;
+---------------------+
| lpad |
+---------------------+
| Salome |
| Il Trovatore |
| Boris Godunov |
| Gotterdammerung |
|La Cenerentola (Cind |
+-----------------------+
```
Para truncar el mismo conjunto de nombres de eventos a 20 caracteres, pero anexar los nombres más cortos con `0123456789`, use el siguiente ejemplo.
```
SELECT RPAD(eventname, 20,'0123456789') FROM event
WHERE eventid BETWEEN 1 AND 5 ORDER BY 1;
+----------------------+
| rpad |
+----------------------+
| Boris Godunov0123456 |
| Gotterdammerung01234 |
| Il Trovatore01234567 |
| La Cenerentola (Cind |
| Salome01234567890123 |
+----------------------+
```
# Función LTRIM
Recorta los caracteres desde el principio de una cadena. Elimina la cadena más larga que contiene solo caracteres de la lista de caracteres de recorte. El recorte finaliza cuando no aparece ningún carácter de recorte en la cadena de entrada.
## Sintaxis
```
LTRIM( string [, trim_chars] )
```
## Argumentos
*cadena*
Una columna de cadena, una expresión o un literal de cadena que se va a recortar.
*trim\$1chars*
Una columna de cadena, expresión o literal de cadena que representa los caracteres que se van a recortar desde el principio de la *cadena*. Si no se especifica, se utiliza un espacio como carácter de recorte.
## Tipo de retorno
La función LTRIM devuelve una cadena de caracteres con el mismo tipo de datos que la *cadena* de entrada (CHAR o VARCHAR).
## Ejemplos
En el siguiente ejemplo, se recorta el año de la columna `listime`. Los caracteres de recorte del literal de cadena `'2008-'` indican los caracteres que se recortarán desde la izquierda. Si utiliza los caracteres de recorte `'028-'`, obtendrá el mismo resultado.
```
select listid, listtime, ltrim(listtime, '2008-')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | ltrim
-------+---------------------+----------------
1 | 2008-01-24 06:43:29 | 1-24 06:43:29
2 | 2008-03-05 12:25:29 | 3-05 12:25:29
3 | 2008-11-01 07:35:33 | 11-01 07:35:33
4 | 2008-05-24 01:18:37 | 5-24 01:18:37
5 | 2008-05-17 02:29:11 | 5-17 02:29:11
6 | 2008-08-15 02:08:13 | 15 02:08:13
7 | 2008-11-15 09:38:15 | 11-15 09:38:15
8 | 2008-11-09 05:07:30 | 11-09 05:07:30
9 | 2008-09-09 08:03:36 | 9-09 08:03:36
10 | 2008-06-17 09:44:54 | 6-17 09:44:54
```
LTRIM elimina cualquiera de los caracteres de *trim\$1chars* cuando aparecen al principio de la *cadena*. En el siguiente ejemplo, se recortan los caracteres «C», «D» y «G» cuando aparecen al principio de VENUENAME, que es una columna VARCHAR.
```
select venueid, venuename, ltrim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
En el siguiente ejemplo. se utiliza el carácter de recorte `2` que se recupera de la columna `venueid`.
```
select ltrim('2008-01-24 06:43:29', venueid)
from venue where venueid=2;
ltrim
------------------
008-01-24 06:43:29
```
En el siguiente ejemplo, no se recorta ningún carácter porque se encuentra un `2` antes del carácter de recorte `'0'`.
```
select ltrim('2008-01-24 06:43:29', '0');
ltrim
-------------------
2008-01-24 06:43:29
```
En el siguiente ejemplo, se utiliza el carácter de recorte de espacio predeterminado y se recortan los dos espacios desde el principio de la cadena.
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# Función OCTETINDEX
La función OCTETINDEX devuelve la ubicación de una subcadena dentro de una cadena como un número de bytes.
## Sintaxis
```
OCTETINDEX(substring, string)
```
## Argumentos
*subcadena*
Una cadena `CHAR`, una cadena `VARCHAR` o una expresión que se evalúe de forma implícita como un tipo `CHAR` o `VARCHAR`.
*cadena*
Una cadena `CHAR`, una cadena `VARCHAR` o una expresión que se evalúe de forma implícita como un tipo `CHAR` o `VARCHAR`.
## Tipo de retorno
INTEGER
La función OCTETINDEX devuelve un valor `INTEGER` que corresponde a la posición de la *subcadena* dentro de la *cadena* como un número de bytes, donde el primer carácter de la *cadena* se cuenta como 1. Si la *cadena* no contiene caracteres multibyte, el resultado es igual al resultado de la función CHARINDEX. Si la *cadena* no contiene la *subcadena*, la función devuelve `0`. Si la *subcadena* está vacía, la función devuelve `1`.
## Ejemplos
Para devolver la posición de la subcadena `q` en la cadena `Amazon Redshift`, utilice el siguiente ejemplo. Este ejemplo devuelve `0` porque la *subcadena* no está en la *cadena*.
```
SELECT OCTETINDEX('q', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 0 |
+------------+
```
Para devolver la posición de una subcadena vacía en la cadena `Amazon Redshift`, utilice el siguiente ejemplo. Este ejemplo devuelve `1` porque la *subcadena* está vacía.
```
SELECT OCTETINDEX('', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 1 |
+------------+
```
Para devolver la posición de la subcadena `Redshift` en la cadena `Amazon Redshift`, utilice el siguiente ejemplo. En este ejemplo se devuelve `8` porque la *subcadena* comienza en el octavo byte de la *cadena*.
```
SELECT OCTETINDEX('Redshift', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 8 |
+------------+
```
Para devolver la posición de la subcadena `Redshift` en la cadena `Amazon Redshift`, utilice el siguiente ejemplo. Este ejemplo devuelve `21` porque los seis primeros caracteres de la *cadena* son caracteres de dos bytes.
```
SELECT OCTETINDEX('Redshift', 'Άμαζον Amazon Redshift');
+------------+
| octetindex |
+------------+
| 21 |
+------------+
```
# Función OCTET\$1LENGTH
Devuelve la longitud de la cadena especificada como el número de bytes.
## Sintaxis
```
OCTET_LENGTH(expression)
```
## Argumento
*expresión*
Una cadena `CHAR`, una cadena `VARCHAR`, una expresión `VARBYTE` o una expresión que se evalúe de forma implícita como un tipo `CHAR`, `VARCHAR` o `VARBYTE`.
## Tipo de retorno
INTEGER
La función OCTET\$1LENGTH devuelve un valor entero que indica la cantidad de bytes en la cadena de entrada.
Si la cadena de entrada es una cadena de caracteres, la función [LEN](r_LEN.md) devuelve una cantidad real de caracteres en cadenas multibyte y no la cantidad de bytes. Por ejemplo, una columna `VARCHAR(12)` necesita almacenar tres caracteres chinos de cuatro bytes. La función OCTET\$1LENGTH devolverá `12` para esa cadena, y la función LEN devolverá `3` para esa misma cadena.
## Notas de uso
Si *expresión* es una `CHAR`, la función devuelve la longitud de la cadena `CHAR`. Por ejemplo, la salida de una entrada `CHAR(6)` es `CHAR(6)`.
Si la *expresión* es una cadena `VARCHAR`, los espacios finales se cuentan.
## Ejemplos
Para devolver el número de bytes cuando la cadena `francais` con tres espacios finales se convierte en `CHAR` y un tipo de `VARCHAR`, utilice el siguiente ejemplo. Para obtener más información, consulte la [Función CAST](r_CAST_function.md).
```
SELECT OCTET_LENGTH(CAST('francais ' AS CHAR(15))) AS octet_length_char, OCTET_LENGTH(CAST('francais ' AS VARCHAR(15))) AS octet_length_varchar;
+-------------------+----------------------+
| octet_length_char | octet_length_varchar |
+-------------------+----------------------+
| 15 | 11 |
+-------------------+----------------------+
```
Para devolver el número de bytes y el número de caracteres de la cadena `français`, use el siguiente ejemplo.
```
SELECT OCTET_LENGTH('français'), LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Para devolver el número de bytes cuando la cadena `français` se convierte en `VARBYTE`, utilice el siguiente ejemplo.
```
SELECT OCTET_LENGTH(CAST('français' AS VARBYTE));
+--------------+
| octet_length |
+--------------+
| 9 |
+--------------+
```
# Función POSITION
Devuelve la ubicación de la subcadena especificada dentro de una cadena.
Consulte [Función CHARINDEX](r_CHARINDEX.md) y [Función STRPOS](r_STRPOS.md) para ver funciones similares.
## Sintaxis
```
POSITION(substring IN string )
```
## Argumentos
*subcadena*
Subcadena que se va a buscar dentro de la *cadena*.
*cadena*
La cadena o columna que se buscará.
## Tipo de retorno
La función POSITION devuelve un valor `INTEGER` correspondiente a la posición de la subcadena (basado en uno, no basado en cero). La posición se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples. POSITION devuelve `0` si no se encuentra subcadena dentro de la cadena.
## Ejemplos
Para devolver la posición de la cadena `fish` dentro de la palabra `dog`, use el siguiente ejemplo.
```
SELECT POSITION('fish' IN 'dog');
+-----------+
| position |
+-----------+
| 0 |
+-----------+
```
Para devolver la posición de la cadena `fish` dentro de la palabra `dogfish`, use el siguiente ejemplo.
```
SELECT POSITION('fish' IN 'dogfish');
+-----------+
| position |
+-----------+
| 4 |
+-----------+
```
En el siguiente ejemplo, se utiliza la tabla SALES de la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para devolver la cantidad de transacciones de venta distintas con un parámetro de comisión que supere los 999 de la tabla SALES, use el siguiente ejemplo. Este comando cuenta las comisiones superiores a 999 comprobando si el decimal está a más de 4 lugares del principio del valor de la comisión.
```
SELECT DISTINCT POSITION('.' IN commission), COUNT (POSITION('.' IN commission))
FROM sales
WHERE POSITION('.' IN commission) > 4
GROUP BY POSITION('.' IN commission)
ORDER BY 1,2;
+-----------+-------+
| position | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# Función QUOTE\$1IDENT
La función QUOTE\$1IDENT devuelve la cadena especificada como una cadena con comillas dobles al principio y al final. La salida de la función se puede utilizar como un identificador en una instrucción SQL. La función duplica de forma adecuada todas las comillas dobles integradas.
QUOTE\$1IDENT agrega comillas dobles solo donde sean necesarias para crear un identificador válido, si la cadena contiene caracteres que no son identificadores o que, de otro modo, se pasarían a minúsculas. Para devolver siempre una cadena con comillas simples, utilice [QUOTE\$1LITERAL](r_QUOTE_LITERAL.md).
## Sintaxis
```
QUOTE_IDENT(string)
```
## Argumento
*cadena*
Una cadena `CHAR` o `VARCHAR`.
## Tipo de retorno
La función QUOTE\$1IDENT devuelve el mismo tipo de cadena que la *cadena* de entrada.
## Ejemplos
Para devolver la cadena `"CAT"` con comillas dobles, utilice el siguiente ejemplo.
```
SELECT QUOTE_IDENT('"CAT"');
+-------------+
| quote_ident |
+-------------+
| """CAT""" |
+-------------+
```
En el siguiente ejemplo se utilizan datos de la tabla CATEGORY en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para devolver la columna CATNAME entre comillas, use el siguiente ejemplo.
```
SELECT catid, QUOTE_IDENT(catname)
FROM category
ORDER BY 1,2;
+-------+-------------+
| catid | quote_ident |
+-------+-------------+
| 1 | "MLB" |
| 2 | "NHL" |
| 3 | "NFL" |
| 4 | "NBA" |
| 5 | "MLS" |
| 6 | "Musicals" |
| 7 | "Plays" |
| 8 | "Opera" |
| 9 | "Pop" |
| 10 | "Jazz" |
| 11 | "Classical" |
+-------+-------------+
```
# Función QUOTE\$1LITERAL
La función QUOTE\$1LITERAL devuelve la cadena específica como una cadena con comillas simples para que se puede utilizar como un literal de cadena en una instrucción SQL. Si el parámetro de entrada es un número, QUOTE\$1LITERAL lo trata como una cadena. Duplica de forma adecuada todas las comillas simples y las barras inversas integradas.
## Sintaxis
```
QUOTE_LITERAL(string)
```
## Argumento
*cadena*
Una cadena `CHAR` o `VARCHAR`.
## Tipo de retorno
La función QUOTE\$1LITERAL devuelve una cadena `CHAR` o `VARCHAR` que es el mismo tipo de datos que la *cadena* de entrada.
## Ejemplos
Para devolver la cadena `''CAT''` con comillas SIMPLES, utilice el siguiente ejemplo.
```
SELECT QUOTE_LITERAL('''CAT''');
+---------------+
| quote_literal |
+---------------+
| '''CAT''' |
+---------------+
```
En los siguientes ejemplos se utilizan datos de la tabla CATEGORY en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para devolver la columna CATNAME entre comillas, use el siguiente ejemplo.
```
SELECT catid, QUOTE_LITERAL(catname)
FROM category
ORDER BY 1,2;
+-------+---------------+
| catid | quote_literal |
+-------+---------------+
| 1 | 'MLB' |
| 2 | 'NHL' |
| 3 | 'NFL' |
| 4 | 'NBA' |
| 5 | 'MLS' |
| 6 | 'Musicals' |
| 7 | 'Plays' |
| 8 | 'Opera' |
| 9 | 'Pop' |
| 10 | 'Jazz' |
| 11 | 'Classical' |
+-------+---------------+
```
Para devolver la columna CATID entre comillas, use el siguiente ejemplo.
```
SELECT QUOTE_LITERAL(catid), catname
FROM category
ORDER BY 1,2;
+---------------+-----------+
| quote_literal | catname |
+---------------+-----------+
| '1' | MLB |
| '10' | Jazz |
| '11' | Classical |
| '2' | NHL |
| '3' | NFL |
| '4' | NBA |
| '5' | MLS |
| '6' | Musicals |
| '7' | Plays |
| '8' | Opera |
| '9' | Pop |
+---------------+-----------+
```
# Función REGEXP\$1COUNT
Busca una cadena para un patrón de expresión regular y devuelve un valor entero que indica la cantidad de veces que el patrón especificado aparece en la cadena. Si no se encuentra coincidencia, la función devuelve `0`. Para obtener más información sobre las expresiones regulares, consulte [Operadores POSIX](pattern-matching-conditions-posix.md) y [Expresión regular](https://en.wikipedia.org/wiki/Regular_expression) en la Wikipedia.
## Sintaxis
```
REGEXP_COUNT( source_string, pattern [, position [, parameters ] ] )
```
## Argumentos
*source\$1string*
Una cadena `CHAR` o `VARCHAR`.
*Patrón*
Un literal de cadena UTF-8 que representa un patrón de expresión regular. Para obtener más información, consulte [Operadores POSIX](pattern-matching-conditions-posix.md).
*position*
(Opcional) Un número `INTEGER` que indica la posición dentro de *source\$1string* para comenzar la búsqueda. La posición se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples. El valor predeterminado es `1`. Si el valor de *posición* es menor que `1`, la búsqueda comienza en el primer carácter de *source\$1string*. Si el valor de *posición* es mayor que el número de caracteres de *source\$1string*, el resultado es `0`.
*Parámetros*
(Opcional) Uno o varios literales de cadena que indican el grado de coincidencia de la función con el patrón. Los valores posibles son los siguientes:
+ c: aplica la coincidencia que distingue entre mayúsculas y minúsculas. El comportamiento predeterminado es utilizar la coincidencia que distingue entre mayúsculas y minúsculas.
+ i: aplica la coincidencia que no distingue entre mayúsculas y minúsculas.
+ p: interpreta el patrón con el dialecto de expresión regular compatible con Perl (PCRE). Para obtener más información sobre PCRE, consulte [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) en la Wikipedia.
## Tipo de retorno
INTEGER
## Ejemplos
Para contar la cantidad de veces en que aparece una secuencia de tres letras, use el siguiente ejemplo.
```
SELECT REGEXP_COUNT('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------+
| regexp_count |
+--------------+
| 8 |
+--------------+
```
Para contar cuántas veces aparece la cadena `FOX`, con una coincidencia que no distingue entre mayúsculas y minúsculas, use el siguiente ejemplo.
```
SELECT REGEXP_COUNT('the fox', 'FOX', 1, 'i');
+--------------+
| regexp_count |
+--------------+
| 1 |
+--------------+
```
Para usar un patrón escrito en el dialecto de PCRE para localizar palabras que contengan al menos un número y una letra en minúsculas, use el siguiente ejemplo. El ejemplo utiliza el operador `?=`, que tiene una connotación específica de anticipación en PCRE. En este ejemplo, se cuenta cuántas veces aparecen dichas palabras, con una coincidencia que distingue entre mayúsculas y minúsculas.
```
SELECT REGEXP_COUNT('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
+--------------+
| regexp_count |
+--------------+
| 2 |
+--------------+
```
Para usar un patrón escrito en el dialecto de PCRE para localizar palabras que contengan al menos un número y una letra en minúsculas, use el siguiente ejemplo. Se utiliza el operador `?=`, que tiene una connotación específica en PCRE. En este ejemplo, se cuenta cuántas veces aparecen dichas palabras, pero difiere del ejemplo anterior, ya que se utiliza una coincidencia sin distinción entre mayúsculas y minúsculas.
```
SELECT REGEXP_COUNT('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
+--------------+
| regexp_count |
+--------------+
| 3 |
+--------------+
```
En el siguiente ejemplo se utilizan datos de la tabla USERS en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para contar la cantidad de veces en que el nombre del dominio de nivel superior es `org` o `edu`, use el siguiente ejemplo.
```
SELECT email, REGEXP_COUNT(email,'@[^.]*\.(org|edu)') FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_count |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1 |
| Suspendisse.tristique@nonnisiAenean.edu | 1 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 0 |
| sed@lacusUtnec.ca | 0 |
+-----------------------------------------------+--------------+
```
# Función REGEXP\$1INSTR
Busca una cadena para un patrón de expresión regular y devuelve un valor entero que indica la posición de inicio o de finalización de la subcadena coincidente. Si no se encuentra coincidencia, la función devuelve `0`. REGEXP\$1INSTR es similar a la función [POSITION](r_POSITION.md), pero le permite buscar un patrón de expresión regular en una cadena. Para obtener más información sobre las expresiones regulares, consulte [Operadores POSIX](pattern-matching-conditions-posix.md) y [Expresión regular](https://en.wikipedia.org/wiki/Regular_expression) en la Wikipedia.
## Sintaxis
```
REGEXP_INSTR( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Argumentos
*source\$1string*
Una expresión de cadena, como un nombre de columna, que se buscará.
*Patrón*
Un literal de cadena UTF-8 que representa un patrón de expresión regular. Para obtener más información, consulte [Operadores POSIX](pattern-matching-conditions-posix.md).
*position*
(Opcional) Un número `INTEGER` que indica la posición dentro de *source\$1string* para comenzar la búsqueda. La posición se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples. El valor predeterminado es `1`. Si el valor de *posición* es menor que `1`, la búsqueda comienza en el primer carácter de *source\$1string*. Si el valor de *posición* es mayor que el número de caracteres de *source\$1string*, el resultado es `0`.
*occurrence*
(Opcional) Un número `INTEGER` positivo que indica qué coincidencia del patrón se va a utilizar. REGEXP\$1INSTR omite las primeras coincidencias `occurrence-1`. El valor predeterminado es `1`. Si *occurrence* es menor que `1` o mayor que el número de caracteres de *source\$1string*, la búsqueda se omite y el resultado es `0`.
*Opción*
(Opcional )Valor que indica si se va a devolver la posición del primer carácter de la coincidencia (`0`) o la posición del primer carácter situado a continuación del final de la coincidencia (`1`). Un valor distinto de cero es lo mismo que `1`. El valor predeterminado es `0`.
*Parámetros*
(Opcional) Uno o varios literales de cadena que indican el grado de coincidencia de la función con el patrón. Los valores posibles son los siguientes:
+ c: aplica la coincidencia que distingue entre mayúsculas y minúsculas. El comportamiento predeterminado es utilizar la coincidencia que distingue entre mayúsculas y minúsculas.
+ i: aplica la coincidencia que no distingue entre mayúsculas y minúsculas.
+ e: extrae una subcadena mediante una subexpresión.
Si *pattern* incluye una subexpresión, REGEXP\$1INSTR realiza la comparación con una subcadena utilizando la primera subexpresión de *pattern*. REGEXP\$1INSTR solo tiene en cuenta la primera subexpresión; las subexpresiones adicionales se omiten. Si el patrón no incluye una subexpresión, REGEXP\$1INSTR omite el parámetro 'e'.
+ p: interpreta el patrón con el dialecto de expresión regular compatible con Perl (PCRE). Para obtener más información sobre PCRE, consulte [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) en la Wikipedia.
## Tipo de retorno
Entero
## Ejemplos
En los siguientes ejemplos se utilizan datos de la tabla USERS en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para buscar el carácter `@` que comienza un nombre de dominio y devolver la posición inicial de la primera coincidencia, use el siguiente ejemplo.
```
SELECT email, REGEXP_INSTR(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_instr |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 21 |
| Suspendisse.tristique@nonnisiAenean.edu | 22 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 17 |
| sed@lacusUtnec.ca | 4 |
+-----------------------------------------------+--------------+
```
Para buscar variantes de la palabra `Center` y devolver la posición inicial de la primera coincidencia, use el siguiente ejemplo..
```
SELECT venuename, REGEXP_INSTR(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE REGEXP_INSTR(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
+-----------------------+--------------+
| venuename | regexp_instr |
+-----------------------+--------------+
| The Home Depot Center | 16 |
| Izod Center | 6 |
| Wachovia Center | 10 |
| Air Canada Centre | 12 |
+-----------------------+--------------+
```
Para encontrar la posición inicial de la primera vez que aparece la cadena `FOX`, con una lógica que no distingue entre mayúsculas y minúsculas, use el siguiente ejemplo.
```
SELECT REGEXP_INSTR('the fox', 'FOX', 1, 1, 0, 'i');
+--------------+
| regexp_instr |
+--------------+
| 5 |
+--------------+
```
Para usar un patrón escrito en el dialecto de PCRE para localizar palabras que contengan al menos un número y una letra en minúsculas, use el siguiente ejemplo. Se utiliza el operador `?=`, que tiene una connotación específica de anticipación en PCRE. En este ejemplo, se encuentra la posición inicial de la segunda palabra que reúne esas características.
```
SELECT REGEXP_INSTR('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
+--------------+
| regexp_instr |
+--------------+
| 21 |
+--------------+
```
Para usar un patrón escrito en el dialecto de PCRE para localizar palabras que contengan al menos un número y una letra en minúsculas, use el siguiente ejemplo. Se utiliza el operador `?=`, que tiene una connotación específica de anticipación en PCRE. En este ejemplo, se encuentra la posición inicial de la segunda palabra que reúne esas características, pero difiere del ejemplo anterior, ya que se utiliza una coincidencia sin distinción entre mayúsculas y minúsculas.
```
SELECT REGEXP_INSTR('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
+--------------+
| regexp_instr |
+--------------+
| 15 |
+--------------+
```
# Función REGEXP\$1REPLACE
Busca una cadena para un patrón de expresión regular y reemplaza cada coincidencia del patrón con una cadena especificada. REGEXP\$1REPLACE es similar a [Función REPLACE](r_REPLACE.md), pero le permite buscar un patrón de expresión regular en una cadena. Para obtener más información sobre las expresiones regulares, consulte [Operadores POSIX](pattern-matching-conditions-posix.md) y [Expresión regular](https://en.wikipedia.org/wiki/Regular_expression) en la Wikipedia.
REGEXP\$1REPLACE es similar a [Función TRANSLATE](r_TRANSLATE.md) y a [Función REPLACE](r_REPLACE.md), salvo que TRANSLATE realiza varias sustituciones de caracteres únicos y REPLACE sustituye una cadena entera por otra cadena, mientras que REGEXP\$1REPLACE le permite buscar un patrón de expresión regular en una cadena.
## Sintaxis
```
REGEXP_REPLACE( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## Argumentos
*source\$1string*
Una expresión de cadena `CHAR` o `VARCHAR`, como un nombre de columna, que se buscará.
*Patrón*
Un literal de cadena UTF-8 que representa un patrón de expresión regular. Para obtener más información, consulte [Operadores POSIX](pattern-matching-conditions-posix.md).
*replace\$1string*
(Opcional) Una expresión de cadena `CHAR` o `VARCHAR`, como un nombre de columna, que reemplazará cada coincidencia del patrón. El valor predeterminado es una cadena vacía ( "" ).
*position*
(Opcional) Valor entero positivo que indica la posición dentro de *source\$1string* para comenzar la búsqueda. La posición se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples. El valor predeterminado es `1`. Si el valor de *posición* es menor que `1`, la búsqueda comienza en el primer carácter de *source\$1string*. Si el valor de *position (posición)* es mayor que la cantidad de caracteres de *source-string (cadena\$1de\$1origen)*, el resultado es *source\$1string (cadena\$1de\$1origen)*.
*Parámetros*
(Opcional) Uno o varios literales de cadena que indican el grado de coincidencia de la función con el patrón. Los valores posibles son los siguientes:
+ c: aplica la coincidencia que distingue entre mayúsculas y minúsculas. El comportamiento predeterminado es utilizar la coincidencia que distingue entre mayúsculas y minúsculas.
+ i: aplica la coincidencia que no distingue entre mayúsculas y minúsculas.
+ p: interpreta el patrón con el dialecto de expresión regular compatible con Perl (PCRE). Para obtener más información sobre PCRE, consulte [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) en la Wikipedia.
## Tipo de retorno
VARCHAR
Si *patrón* o *replace\$1string* es `NULL`, la función devuelve `NULL`.
## Ejemplos
Para reemplazar todas las veces que aparece la cadena `FOX` en el valor `quick brown fox`, con una coincidencia que no distingue entre mayúsculas y minúsculas, use el siguiente ejemplo.
```
SELECT REGEXP_REPLACE('the fox', 'FOX', 'quick brown fox', 1, 'i');
+---------------------+
| regexp_replace |
+---------------------+
| the quick brown fox |
+---------------------+
```
En el siguiente ejemplo, se utiliza un patrón escrito en el dialecto de PCRE para localizar palabras que contengan al menos un número y una letra en minúsculas. Se utiliza el operador `?=`, que tiene una connotación específica de anticipación en PCRE. Para sustituir cada palabra que reúne esas características con el valor `[hidden]`, use el siguiente ejemplo.
```
SELECT REGEXP_REPLACE('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
+-------------------------------+
| regexp_replace |
+-------------------------------+
| [hidden] plain A1234 [hidden] |
+-------------------------------+
```
En el siguiente ejemplo, se utiliza un patrón escrito en el dialecto de PCRE para localizar palabras que contengan al menos un número y una letra en minúsculas. Se utiliza el operador `?=`, que tiene una connotación específica de anticipación en PCRE. Para reemplazar cada vez que aparece una palabra que reúne esas características con el valor `[hidden]`, pero difiere del ejemplo anterior, ya que se utiliza una coincidencia sin distinción entre mayúsculas y minúsculas, use el siguiente ejemplo.
```
SELECT REGEXP_REPLACE('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
+----------------------------------+
| regexp_replace |
+----------------------------------+
| [hidden] plain [hidden] [hidden] |
+----------------------------------+
```
En los siguientes ejemplos se utilizan datos de la tabla USERS en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para eliminar `@` y el nombre de dominio de direcciones de correo electrónico, use el siguiente ejemplo.
```
SELECT email, REGEXP_REPLACE(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+-----------------------+
| email | regexp_replace |
+-----------------------------------------------+-----------------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero |
| Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique |
| amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut |
| sed@lacusUtnec.ca | sed |
+-----------------------------------------------+-----------------------+
```
Para reemplazar los nombres de dominio de las direcciones de correo electrónico con `internal.company.com`, use el siguiente ejemplo.
```
SELECT email, REGEXP_REPLACE(email, '@.*\\.[[:alpha:]]{2,3}','@internal.company.com')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------------------------------------+
| email | regexp_replace |
+-----------------------------------------------+--------------------------------------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero@internal.company.com |
| Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique@internal.company.com |
| amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut@internal.company.com |
| sed@lacusUtnec.ca | sed@internal.company.com |
+-----------------------------------------------+--------------------------------------------+
```
# Función REGEXP\$1SUBSTR
Devuelve los caracteres de una cadena al buscar un patrón de expresión regular. REGEXP\$1SUBSTR es similar a la función [Función SUBSTRING](r_SUBSTRING.md), pero le permite buscar un patrón de expresión regular en una cadena. Si la función no puede hacer coincidir la expresión regular con ningún carácter de la cadena, devuelve una cadena vacía. Para obtener más información sobre las expresiones regulares, consulte [Operadores POSIX](pattern-matching-conditions-posix.md) y [Expresión regular](https://en.wikipedia.org/wiki/Regular_expression) en la Wikipedia.
## Sintaxis
```
REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Argumentos
*source\$1string*
Una expresión de cadena que se va a buscar.
*Patrón*
Un literal de cadena UTF-8 que representa un patrón de expresión regular. Para obtener más información, consulte [Operadores POSIX](pattern-matching-conditions-posix.md).
*position*
Valor entero positivo que indica la posición dentro de *source\$1string (cadena\$1de\$1origen)* para comenzar la búsqueda. La posición se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples. El valor predeterminado es 1. Si el valor de *position (posición)* es menor que 1, la búsqueda comienza en el primer carácter de *source-string (cadena\$1de\$1origen)*. Si el valor de *position (posición)* es mayor que el número de caracteres de *source-string (cadena\$1de\$1origen)*, el resultado es una cadena vacía ("").
*occurrence*
Un número entero positivo que indica qué coincidencia del patrón se va a utilizar. REGEXP\$1SUBSTR omite las primeras coincidencias especificadas por el valor de *occurrence* menos uno. El valor predeterminado es 1. Si *occurrence* es menor que 1 o mayor que el número de caracteres de *source\$1string*, la búsqueda se omite y el resultado está vacío.
*Parámetros*
Uno o varios literales de cadena que indican el grado de coincidencia de la función con el patrón. Los valores posibles son los siguientes:
+ c: aplica la coincidencia que distingue entre mayúsculas y minúsculas. El comportamiento predeterminado es utilizar la coincidencia que distingue entre mayúsculas y minúsculas.
+ i: aplica la coincidencia que no distingue entre mayúsculas y minúsculas.
+ e: extrae una subcadena mediante una subexpresión.
Si *pattern* incluye una subexpresión, REGEXP\$1SUBSTR realiza la comparación con una subcadena utilizando la primera subexpresión de *pattern*. Una subexpresión es una expresión dentro del patrón que está entre paréntesis. Por ejemplo, para que el patrón `'This is a (\\w+)'` coincida con la primera expresión con la cadena `'This is a '` seguida de una palabra. En lugar de devolver el *patrón*, REGEXP\$1SUBSTR con el parámetro `e` devuelve solo la cadena dentro de la subexpresión.
REGEXP\$1SUBSTR solo tiene en cuenta la primera subexpresión; las subexpresiones adicionales se omiten. Si el patrón no incluye una subexpresión, REGEXP\$1SUBSTR omite el parámetro 'e'.
+ p: interpreta el patrón con el dialecto de expresión regular compatible con Perl (PCRE). Para obtener más información sobre PCRE, consulte [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) en la Wikipedia.
## Tipo de retorno
VARCHAR
## Ejemplos
El siguiente ejemplo devuelve la parte de una dirección de correo electrónico entre el carácter @ y la extensión de dominio. Los datos de `users` consultados proceden de los datos de muestra de Amazon Redshift. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
Cum@accumsan.com | @accumsan
```
El siguiente ejemplo devuelve la parte de la entrada que corresponde a la primera vez que aparece la cadena `FOX` con una coincidencia que no distingue entre mayúsculas y minúsculas.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
El siguiente ejemplo devuelve la parte de la entrada que corresponde a la segunda vez que aparece la cadena `FOX` con una coincidencia que no distingue entre mayúsculas y minúsculas. El resultado está vacío (no es nulo, longitud 0) porque no aparece por segunda vez.
```
SELECT regexp_substr('the fox', 'FOX', 1, 2, 'i');
regexp_substr
---------------
```
El ejemplo siguiente devuelve la primera parte de la entrada que comienza en minúscula. Esto es funcionalmente idéntico a la misma instrucción SELECT sin el parámetro `c`.
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
En el siguiente ejemplo, se utiliza un patrón escrito en el dialecto de PCRE para localizar palabras que contengan al menos un número y una letra en minúsculas. Se utiliza el operador `?=`, que tiene una connotación específica de anticipación en PCRE. En este ejemplo, se devuelve la parte de la entrada que corresponde a la segunda palabra que reúne esas características.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
En el siguiente ejemplo, se utiliza un patrón escrito en el dialecto de PCRE para localizar palabras que contengan al menos un número y una letra en minúsculas. Se utiliza el operador `?=`, que tiene una connotación específica de anticipación en PCRE. En este ejemplo, se devuelve la parte de la entrada que corresponde a la segunda palabra que reúne esas características, pero difiere del ejemplo anterior, ya que se utiliza una coincidencia sin distinción entre mayúsculas y minúsculas.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
En el ejemplo siguiente se utiliza una subexpresión para buscar la segunda cadena que coincida con el patrón `'this is a (\\w+)'` con una coincidencia que no distingue entre mayúsculas y minúsculas. Devuelve la subexpresión entre paréntesis.
```
SELECT regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```
# Función REPEAT
Repite una cadena la cantidad especificada de veces. Si el parámetro de entrada es numérico, REPEAT lo trata como una cadena.
Sinónimo de [Función REPLICATE](r_REPLICATE.md).
## Sintaxis
```
REPEAT(string, integer)
```
## Argumentos
*cadena*
El primer parámetro de entrada es la cadena que se repetirá.
*entero*
El segundo parámetro es un valor `INTEGER` que indica la cantidad de veces que se repite la cadena.
## Tipo de retorno
VARCHAR
## Ejemplos
En el siguiente ejemplo se utilizan datos de la tabla CATEGORY en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para repetir tres veces el valor de la columna CATID en la tabla CATEGORY, use el siguiente ejemplo.
```
SELECT catid, REPEAT(catid,3)
FROM category
ORDER BY 1,2;
+-------+--------+
| catid | repeat |
+-------+--------+
| 1 | 111 |
| 2 | 222 |
| 3 | 333 |
| 4 | 444 |
| 5 | 555 |
| 6 | 666 |
| 7 | 777 |
| 8 | 888 |
| 9 | 999 |
| 10 | 101010 |
| 11 | 111111 |
+-------+--------+
```
En el siguiente ejemplo, se muestra la generación de cadenas de hasta 16 000 000 bytes:
```
SELECT
LEN(REPEAT('X', 5000000)) AS five_million_bytes,
LEN(REPEAT('Y', 16000000)) AS sixteen_million_bytes;
five_million_bytes | sixteen_million_bytes
----------+-----------
5000000 | 16000000
```
# Función REPLACE
Reemplaza todas las coincidencias de un conjunto de caracteres dentro de una cadena existente con otros caracteres especificados.
REPLACE es similar a [Función TRANSLATE](r_TRANSLATE.md) y a [Función REGEXP\$1REPLACE](REGEXP_REPLACE.md), salvo que TRANSLATE realiza varias sustituciones de caracteres únicos y REGEXP\$1REPLACE le permite buscar un patrón de expresión regular en una cadena, mientras que REPLACE sustituye una cadena entera por otra cadena.
## Sintaxis
```
REPLACE(string, old_chars, new_chars)
```
## Argumentos
*cadena*
Cadena `CHAR` o `VARCHAR` que se buscará
*old\$1chars*
La cadena `CHAR` o `VARCHAR` que se va a sustituir.
*new\$1chars*
Nueva cadena `CHAR` o `VARCHAR` que sustituye *old\$1string*.
## Tipo de retorno
VARCHAR
Si *old\$1chars* o *new\$1chars* es `NULL`, el valor devuelto es `NULL`.
## Ejemplos
En el siguiente ejemplo se utilizan datos de la tabla CATEGORY en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para convertir la cadena `Shows` en `Theatre` en el campo CATGROUP, use el siguiente ejemplo.
```
SELECT catid, catgroup, REPLACE(catgroup, 'Shows', 'Theatre')
FROM category
ORDER BY 1,2,3;
+-------+----------+----------+
| catid | catgroup | replace |
+-------+----------+----------+
| 1 | Sports | Sports |
| 2 | Sports | Sports |
| 3 | Sports | Sports |
| 4 | Sports | Sports |
| 5 | Sports | Sports |
| 6 | Shows | Theatre |
| 7 | Shows | Theatre |
| 8 | Shows | Theatre |
| 9 | Concerts | Concerts |
| 10 | Concerts | Concerts |
| 11 | Concerts | Concerts |
+-------+----------+----------+
```
# Función REPLICATE
Sinónimo para la función REPEAT.
Consulte [Función REPEAT](r_REPEAT.md).
# Función REVERSE
La función REVERSE opera en una cadena y devuelve los caracteres en orden inverso. Por ejemplo, `reverse('abcde')` devuelve `edcba`. Esta función trabaja sobre tipos de datos numéricos y de fecha, además de tipos de datos de caracteres; no obstante, en la mayoría de los casos, tiene valor práctico para las cadenas de caracteres.
## Sintaxis
```
REVERSE( expression )
```
## Argumento
*expresión*
Una expresión con un tipo de datos de carácter, fecha, marca temporal o número que representa el destino de la reversión de carácter. Todas las expresiones se convierten implícitamente en cadenas `VARCHAR`. Los espacios en blanco en las cadenas `CHAR` se ignoran.
## Tipo de retorno
VARCHAR
## Ejemplos
En los siguientes ejemplos se utilizan datos de las tablas USERS y SALES en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para seleccionar cinco nombres distintos de ciudades y sus correspondientes nombres invertidos de la tabla USERS, use el siguiente ejemplo.
```
SELECT DISTINCT city AS cityname, REVERSE(cityname)
FROM users
ORDER BY city LIMIT 5;
+----------+----------+
| cityname | reverse |
+----------+----------+
| Aberdeen | needrebA |
| Abilene | enelibA |
| Ada | adA |
| Agat | tagA |
| Agawam | mawagA |
+----------+----------+
```
Para seleccionar cinco ID de ventas y sus correspondientes ID invertidos vinculados convertidos a cadenas de caracteres, use el siguiente ejemplo.
```
SELECT salesid, REVERSE(salesid)
FROM sales
ORDER BY salesid DESC LIMIT 5;
+---------+---------+
| salesid | reverse |
+---------+---------+
| 172456 | 654271 |
| 172455 | 554271 |
| 172454 | 454271 |
| 172453 | 354271 |
| 172452 | 254271 |
+---------+---------+
```
# Función RTRIM
La función RTRIM recorta un conjunto especificado de caracteres desde el final de una cadena. Elimina la cadena más larga que contiene solo caracteres de la lista de caracteres de recorte. El recorte finaliza cuando no aparece ningún carácter de recorte en la cadena de entrada.
## Sintaxis
```
RTRIM( string, trim_chars )
```
## Argumentos
*cadena*
Una columna de cadena, una expresión o un literal de cadena que se va a recortar.
*trim\$1chars*
Es una columna de cadena, expresión o literal de cadena que representa los caracteres que se deben recortar desde el final de *string*. Si no se especifica, se utiliza un espacio como carácter de recorte.
## Tipo de retorno
Cadena que es del mismo tipo de datos que el argumento *string*.
## Ejemplo
En el siguiente ejemplo, se recortan espacios a la izquierda y a la derecha de la cadena `' abc '`:
```
select ' abc ' as untrim, rtrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
En el siguiente ejemplo, se eliminan las cadenas `'xyz'` a la derecha de la cadena `'xyzaxyzbxyzcxyz'`. Las coincidencias a la derecha de `'xyz'` se eliminan, pero las coincidencias internas dentro de la cadena no se eliminan.
```
select 'xyzaxyzbxyzcxyz' as untrim,
rtrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | xyzaxyzbxyzc
```
En el siguiente ejemplo, se eliminan las partes a la derecha de la cadena `'setuphistorycassettes'` que coinciden con cualquiera de los caracteres de la lista *trim\$1chars* `'tes'`. Cualquier `t`, `e` o `s` que aparezca antes de cualquier carácter que no esté en la lista *trim\$1chars* al final de la cadena de entrada se eliminará.
```
SELECT rtrim('setuphistorycassettes', 'tes');
rtrim
-----------------
setuphistoryca
```
En el siguiente ejemplo, se recortan los caracteres "Park" del final de VENUENAME, cuando corresponde:
```
select venueid, venuename, rtrim(venuename, 'Park')
from venue
order by 1, 2, 3
limit 10;
venueid | venuename | rtrim
--------+----------------------------+-------------------------
1 | Toyota Park | Toyota
2 | Columbus Crew Stadium | Columbus Crew Stadium
3 | RFK Stadium | RFK Stadium
4 | CommunityAmerica Ballpark | CommunityAmerica Ballp
5 | Gillette Stadium | Gillette Stadium
6 | New York Giants Stadium | New York Giants Stadium
7 | BMO Field | BMO Field
8 | The Home Depot Center | The Home Depot Cente
9 | Dick's Sporting Goods Park | Dick's Sporting Goods
10 | Pizza Hut Park | Pizza Hut
```
Tenga en cuenta que RTRIM elimina cualquiera de los caracteres `P`, `a`, `r` o `k` cuando aparecen al final de un VENUENAME.
# Función SOUNDEX
La función SOUNDEX devuelve el valor American Soundex que consiste en la primera letra de la cadena de entrada seguida de una codificación de 3 dígitos de los sonidos que representan la pronunciación en inglés de la cadena especificada. Por ejemplo, `Smith` y `Smyth` tienen el mismo valor de Soundex.
## Sintaxis
```
SOUNDEX(string)
```
## Argumentos
*cadena*
Especifica una cadena `CHAR` o `VARCHAR` que desea convertir en un valor de código American Soundex.
## Tipo de retorno
VARCHAR(4)
## Notas de uso
La función SOUNDEX solo convierte caracteres ASCII alfabéticos en minúsculas y mayúsculas en inglés, incluidas las letras a-z y A-Z. SOUNDEX omite otros caracteres. SOUNDEX devuelve un único valor Soundex para una cadena de varias palabras separadas por espacios.
```
SELECT SOUNDEX('AWS Amazon');
+---------+
| soundex |
+---------+
| A252 |
+---------+
```
SOUNDEX devuelve una cadena vacía si la cadena de entrada no contiene ninguna letra en inglés.
```
SELECT SOUNDEX('+-*/%');
+---------+
| soundex |
+---------+
| |
+---------+
```
## Ejemplos
Para devolver el valor de Soundex de `Amazon`, utilice el ejemplo siguiente.
```
SELECT SOUNDEX('Amazon');
+---------+
| soundex |
+---------+
| A525 |
+---------+
```
Para devolver el valor de Soundex de `smith` y `smyth`, utilice el ejemplo siguiente. Tenga en cuenta que los valores de Soundex son los mismos.
```
SELECT SOUNDEX('smith'), SOUNDEX('smyth');
+-------+-------+
| smith | smyth |
+-------+-------+
| S530 | S530 |
+-------+-------+
```
# Función SPLIT\$1PART
Divide una cadena en el delimitador especificado y devuelve la parte en la posición especificada.
## Sintaxis
```
SPLIT_PART(string, delimiter, position)
```
## Argumentos
*cadena*
Es una columna de cadena, una expresión o un literal de cadena que se va a dividir. La cadena puede ser CHAR o VARCHAR.
*delimiter*
Es la cadena delimitadora que indica las secciones del *string* de entrada.
Si el *delimitador* es un literal, enciérrelo entre comillas simples.
*position*
Posición de la porción de *string* a devolver (contando desde 1). Debe ser un número entero mayor que 0. Si *position* es mayor que la cantidad de porciones de la cadena, SPLIT\$1PART devuelve una cadena vacía. Si no se encuentra el *delimitador* en *cadena*, entonces el valor devuelto contiene el contenido de la parte especificado, que podría ser la *cadena* completa o un valor vacío.
## Tipo de retorno
Una cadena CHAR o VARCHAR, igual que el parámetro *string*.
## Ejemplos
En el siguiente ejemplo, se divide un literal de cadena en partes mediante el uso del delimitador `$` que devuelve la segunda parte.
```
select split_part('abc$def$ghi','$',2)
split_part
----------
def
```
En el siguiente ejemplo, se divide un literal de cadena en partes mediante el uso del delimitador `$` que devuelve la segunda parte. Devuelve una cadena vacía porque no se encuentra la parte `4`.
```
select split_part('abc$def$ghi','$',4)
split_part
----------
```
En el siguiente ejemplo, se divide un literal de cadena en partes mediante el uso del delimitador `#` que devuelve la segunda parte. Devuelve la cadena completa, que es la primera parte, porque no se encuentra el delimitador.
```
select split_part('abc$def$ghi','#',1)
split_part
------------
abc$def$ghi
```
En el siguiente ejemplo, se divide el campo de la marca temporal LISTTIME entre los componentes de año, mes y día.
```
select listtime, split_part(listtime,'-',1) as year,
split_part(listtime,'-',2) as month,
split_part(split_part(listtime,'-',3),' ',1) as day
from listing limit 5;
listtime | year | month | day
---------------------+------+-------+------
2008-03-05 12:25:29 | 2008 | 03 | 05
2008-09-09 08:03:36 | 2008 | 09 | 09
2008-09-26 05:43:12 | 2008 | 09 | 26
2008-10-04 02:00:30 | 2008 | 10 | 04
2008-01-06 08:33:11 | 2008 | 01 | 06
```
En el siguiente ejemplo, se selecciona el campo de la marca temporal LISTTIME y se lo divide teniendo en cuenta el carácter `'-'` para obtener el mes (la segunda parte de la cadena LISTTIME). Luego, se cuenta la cantidad de entradas para cada mes:
```
select split_part(listtime,'-',2) as month, count(*)
from listing
group by split_part(listtime,'-',2)
order by 1, 2;
month | count
-------+-------
01 | 18543
02 | 16620
03 | 17594
04 | 16822
05 | 17618
06 | 17158
07 | 17626
08 | 17881
09 | 17378
10 | 17756
11 | 12912
12 | 4589
```
# Función STRPOS
Devuelve la posición de una subcadena dentro de una cadena especificada.
Consulte [Función CHARINDEX](r_CHARINDEX.md) y [Función POSITION](r_POSITION.md) para ver funciones similares.
## Sintaxis
```
STRPOS(string, substring )
```
## Argumentos
*cadena*
El primer parámetro de entrada es la cadena `CHAR` o `VARCHAR` que se buscará.
*subcadena*
El segundo parámetro es la subcadena que se va a buscar dentro de *string (cadena)*.
## Tipo de retorno
INTEGER
La función STRPOS devuelve un valor `INTEGER` correspondiente a la posición de la *subcadena* (basado en uno, no basado en cero). La posición se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples.
## Notas de uso
STRPOS devuelve `0` si no se encuentra la *subcadena* dentro de *cadena*.
```
SELECT STRPOS('dogfish', 'fist');
+--------+
| strpos |
+--------+
| 0 |
+--------+
```
## Ejemplos
Para mostrar la posición de `fish` dentro de `dogfish`, utilice el ejemplo siguiente.
```
SELECT STRPOS('dogfish', 'fish');
+--------+
| strpos |
+--------+
| 4 |
+--------+
```
En el siguiente ejemplo se utilizan datos de la tabla SALES en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para devolver la cantidad de transacciones de venta con un parámetro COMMISSION que supere los 999 de la tabla SALES, use el siguiente ejemplo.
```
SELECT DISTINCT STRPOS(commission, '.'),
COUNT (STRPOS(commission, '.'))
FROM sales
WHERE STRPOS(commission, '.') > 4
GROUP BY STRPOS(commission, '.')
ORDER BY 1, 2;
+--------+-------+
| strpos | count |
+--------+-------+
| 5 | 629 |
+--------+-------+
```
# Función STRTOL
Convierte una expresión de cadena de un número de la base especificada al valor entero equivalente. El valor convertido debe estar dentro del rango señalado de 64 bits.
## Sintaxis
```
STRTOL(num_string, base)
```
## Argumentos
*num\$1string*
La expresión de cadena de un número que se convertirá. Si *num\$1string* está vacío (`''`) o comienza con el carácter nulo (`'\0'`), el valor convertido es `0`. Si *num\$1string* es una columna que tiene un valor NULL, STRTOL devuelve `NULL`. La cadena puede comenzar con cualquier cantidad de espacio en blanco, opcionalmente seguido de un signo más "`+`" o menos "`-`" único para indicar positivo o negativo. El valor predeterminado es '`+`'. Si *base* es `16`, la cadena puede comenzar opcionalmente por "`0x`".
*base*
`INTEGER` entre 2 y 36.
## Tipo de retorno
BIGINT
Si *num\$1string* es nulo, la función devuelve `NULL`.
## Ejemplos
Para convertir pares de cadenas y valores base a valores enteros, use los ejemplos siguientes.
```
SELECT STRTOL('0xf',16);
+--------+
| strtol |
+--------+
| 15 |
+--------+
SELECT STRTOL('abcd1234',16);
+------------+
| strtol |
+------------+
| 2882343476 |
+------------+
SELECT STRTOL('1234567', 10);
+---------+
| strtol |
+---------+
| 1234567 |
+---------+
SELECT STRTOL('1234567', 8);
+--------+
| strtol |
+--------+
| 342391 |
+--------+
SELECT STRTOL('110101', 2);
+--------+
| strtol |
+--------+
| 53 |
+--------+
SELECT STRTOL('\0', 2);
+--------+
| strtol |
+--------+
| 0 |
+--------+
```
# Función SUBSTRING
Devuelve el subconjunto de una cadena basado en la posición inicial especificada.
Si la entrada es una cadena de caracteres, la posición inicial y el número de caracteres extraídos se basan en caracteres, y no en bytes, de modo tal que los caracteres de varios bytes se cuentan como si fueran simples. Si la entrada es una expresión binaria, la posición inicial y la subcadena extraída se basan en bytes. No puede especificar una longitud negativa, pero puede especificar una posición de inicio negativa.
## Sintaxis
```
SUBSTRING(character_string FROM start_position [ FOR number_characters ] )
```
```
SUBSTRING(character_string, start_position, number_characters )
```
```
SUBSTRING(binary_expression, start_byte, number_bytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Argumentos
*character\$1string*
La cadena que se buscará. Los tipos de datos que no son caracteres se tratan como una cadena.
*start\$1position*
La posición dentro de la cadena para comenzar la extracción, comenzando en 1. En valor de *start\$1position (posición\$1de\$1inicio)* se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples. Este número puede ser negativo.
*number\$1characters*
La cantidad de caracteres para extraer (la longitud de la subcadena). El valor de *number\$1characters (número\$1de\$1caracteres)* se basa en la cantidad de caracteres, no bytes, por lo que los caracteres multibyte se cuentan como caracteres simples. Este número no puede ser negativo.
*binary\$1expression*
La expresión\$1binaria del tipo de datos VARBYTE que se buscará.
*start\$1byte*
La posición dentro de la expresión binaria desde donde comienza la extracción, con punto de partida en 1. Este número puede ser negativo.
*number\$1bytes*
La cantidad de bytes para extraer, es decir, la longitud de la subcadena. Este número no puede ser negativo.
## Tipo de retorno
VARCHAR o VARBYTE en función de la entrada.
## Notas de uso
A continuación, encontrará algunos ejemplos de cómo puede utilizar *start\$1position* y *number\$1characters* para extraer subcadenas desde varias posiciones de una cadena.
El siguiente ejemplo devuelve una cadena de cuatro caracteres comenzando con el sexto carácter.
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
Si *start\$1position* \$1 *number\$1characters* supera la longitud de la *cadena*, SUBSTRING devuelve una subcadena que comienza en *start\$1position* y llega hasta el final de la cadena. Por ejemplo:
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
Si `start_position` es negativo o 0, la función SUBSTRING devuelve una cadena que comienza en el primer carácter de la cadena con una longitud de `start_position` \$1 `number_characters` -1. Por ejemplo:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Si `start_position` \$1 `number_characters` -1 es menor o igual a cero, SUBSTRING devuelve una cadena vacía. Por ejemplo:
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## Ejemplos
El siguiente ejemplo devuelve el mes de la cadena LISTTIME en la tabla LISTING:
```
select listid, listtime,
substring(listtime, 6, 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
El siguiente ejemplo es igual al anterior, pero utiliza la opción FROM...FOR:
```
select listid, listtime,
substring(listtime from 6 for 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
No se puede utilizar SUBSTRING para extraer de forma predecible el prefijo de una cadena que pueda contener caracteres de varios bytes, ya que es necesario especificar la longitud de una cadena de varios bytes en función de la cantidad de bytes, y no de la cantidad de caracteres. Para extraer el segmento inicial de una cadena en función de la longitud en bytes, puede utilizar CAST y convertir la cadena en VARCHAR(*byte\$1length*) para truncarla, donde *byte\$1length* es la longitud requerida. En el siguiente ejemplo, se extraen los 5 primeros bytes de la cadena `'Fourscore and seven'`.
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
En el siguiente ejemplo, se muestra una posición inicial negativa de un valor binario `abc`. Dado que la posición inicial es -3, la subcadena se extrae desde el principio del valor binario. El resultado se muestra automáticamente como representación hexadecimal de la subcadena binaria.
```
select substring('abc'::varbyte, -3);
substring
-----------
616263
```
En el siguiente ejemplo, se muestra un 1 en la posición inicial de un valor binario `abc`. Debido a que no se especifica la longitud, la cadena se extrae desde la posición inicial hasta el final de la cadena. El resultado se muestra automáticamente como representación hexadecimal de la subcadena binaria.
```
select substring('abc'::varbyte, 1);
substring
-----------
616263
```
En el siguiente ejemplo, se muestra un 3 en la posición inicial de un valor binario `abc`. Debido a que no se especifica la longitud, la cadena se extrae desde la posición inicial hasta el final de la cadena. El resultado se muestra automáticamente como representación hexadecimal de la subcadena binaria.
```
select substring('abc'::varbyte, 3);
substring
-----------
63
```
En el siguiente ejemplo, se muestra un 2 en la posición inicial de un valor binario `abc`. La cadena se extrae desde la posición inicial hasta la posición 10; no obstante, el final de la cadena se encuentra en la posición 3. El resultado se muestra automáticamente como representación hexadecimal de la subcadena binaria.
```
select substring('abc'::varbyte, 2, 10);
substring
-----------
6263
```
En el siguiente ejemplo, se muestra un 2 en la posición inicial de un valor binario `abc`. La cadena se extrae a partir de la posición inicial de 1 byte. El resultado se muestra automáticamente como representación hexadecimal de la subcadena binaria.
```
select substring('abc'::varbyte, 2, 1);
substring
-----------
62
```
El ejemplo siguiente devuelve el nombre `Ana` que aparece después del último espacio de la cadena de entrada `Silva, Ana`.
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# Función TEXTLEN
Sinónimo de la función LEN.
Consulte [Función LEN](r_LEN.md).
# Función TRANSLATE
Para una expresión dada, reemplaza todas las coincidencias de caracteres especificados con sustitutos especificados. Los caracteres existentes se asignan a caracteres de reemplazo en función de su posición en los argumentos *characters\$1to\$1replace* y *characters\$1to\$1substitute*. Si se especifican más caracteres en el argumento *characters\$1to\$1replace* que en el argumento *characters\$1to\$1substitute*, los caracteres adicionales del argumento *characters\$1to\$1replace* se omiten en el valor devuelto.
TRANSLATE es similar a [Función REPLACE](r_REPLACE.md) y a [Función REGEXP\$1REPLACE](REGEXP_REPLACE.md), salvo que REPLACE sustituye una cadena entera por otra cadena y REGEXP\$1REPLACE le permite buscar un patrón de expresión regular en una cadena para, mientras que TRANSLATE realiza varias sustituciones de caracteres únicos.
Si un argumento es nulo, el valor de retorno es `NULL`.
## Sintaxis
```
TRANSLATE( expression, characters_to_replace, characters_to_substitute )
```
## Argumentos
*expression*
La expresión que se traducirá.
*characters\$1to\$1replace*
Una cadena que tiene los caracteres que se reemplazarán.
*characters\$1to\$1substitute*
Una cadena que tiene los caracteres que se sustituirán.
## Tipo de retorno
VARCHAR
## Ejemplos
Para sustituir varios caracteres en una cadena, use el siguiente ejemplo.
```
SELECT TRANSLATE('mint tea', 'inea', 'osin');
+-----------+
| translate |
+-----------+
| most tin |
+-----------+
```
En los siguientes ejemplos se utilizan datos de la tabla USERS en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para reemplazar el signo (@) con un punto para todos los valores en una columna, use el siguiente ejemplo.
```
SELECT email, TRANSLATE(email, '@', '.') as obfuscated_email
FROM users LIMIT 10;
+---------------------------------------+---------------------------------------+
| email | obfuscated_email |
+---------------------------------------+---------------------------------------+
| Cum@accumsan.com | Cum.accumsan.com |
| lorem.ipsum@Vestibulumante.com | lorem.ipsum.Vestibulumante.com |
| non.justo.Proin@ametconsectetuer.edu | non.justo.Proin.ametconsectetuer.edu |
| non.ante.bibendum@porttitortellus.org | non.ante.bibendum.porttitortellus.org |
| eros@blanditatnisi.org | eros.blanditatnisi.org |
| augue@Donec.ca | augue.Donec.ca |
| cursus@pedeacurna.edu | cursus.pedeacurna.edu |
| at@Duis.com | at.Duis.com |
| quam@facilisisvitaeorci.ca | quam.facilisisvitaeorci.ca |
| mi.lorem@nunc.edu | mi.lorem.nunc.edu |
+---------------------------------------+---------------------------------------+
```
Para reemplazar espacios con guiones bajos y quitar los puntos para todos los valores en una columna, use el siguiente ejemplo.
```
SELECT city, TRANSLATE(city, ' .', '_')
FROM users
WHERE city LIKE 'Sain%' OR city LIKE 'St%'
GROUP BY city
ORDER BY city;
+----------------+---------------+
| city | translate |
+----------------+---------------+
| Saint Albans | Saint_Albans |
| Saint Cloud | Saint_Cloud |
| Saint Joseph | Saint_Joseph |
| Saint Louis | Saint_Louis |
| Saint Paul | Saint_Paul |
| St. George | St_George |
| St. Marys | St_Marys |
| St. Petersburg | St_Petersburg |
| Stafford | Stafford |
| Stamford | Stamford |
| Stanton | Stanton |
| Starkville | Starkville |
| Statesboro | Statesboro |
| Staunton | Staunton |
| Steubenville | Steubenville |
| Stevens Point | Stevens_Point |
| Stillwater | Stillwater |
| Stockton | Stockton |
| Sturgis | Sturgis |
+----------------+---------------+
```
# Función TRIM
Recorta una cadena mediante los espacios en blanco o los caracteres específicos.
## Sintaxis
```
TRIM( [ BOTH | LEADING | TRAILING ] [trim_chars FROM ] string )
```
## Argumentos
BOTH \$1 LEADING \$1 TRAILING
(Opcional) Especifica el lugar desde el que se van a recortar los caracteres. Utilice BOTH para eliminar los caracteres iniciales y finales, utilice LEADING para eliminar solo los caracteres principales y utilice TRAILING para eliminar solo los caracteres finales. Si se omite este parámetro, se recortan los caracteres iniciales y finales.
*trim\$1chars*
(Opcional) Los caracteres que se recortarán de la cadena. Si se omite este parámetro, se recortan los espacios en blanco.
*cadena*
La cadena que se recortará.
## Tipo de retorno
La función TRIM devuelve una cadena `VARCHAR` o `CHAR`. Si utiliza la función TRIM con un comando SQL, Amazon Redshift convierte de forma implícita los resultados a `VARCHAR`. Si utiliza la función TRIM en la lista SELECT para una función SQL, Amazon Redshift no convierte de forma implícita los resultados y es posible que necesite realizar una conversión explícita para evitar un error de incompatibilidad con el tipo de dato. Consulte las funciones [Función CAST](r_CAST_function.md) y [Función CONVERT](r_CONVERT_function.md) para obtener información acerca de conversiones explícitas.
## Ejemplos
Para recortar espacios a la izquierda y a la derecha de la cadena ` dog `, use el siguiente ejemplo.
```
SELECT TRIM(' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Para recortar espacios a la izquierda y a la derecha de la cadena ` dog `, use el siguiente ejemplo.
```
SELECT TRIM(BOTH FROM ' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Para eliminar las comillas dobles de inicio de la cadena `"dog"`, utilice el siguiente ejemplo.
```
SELECT TRIM(LEADING '"' FROM'"dog"');
+-------+
| ltrim |
+-------+
| dog" |
+-------+
```
Para eliminar las dobles comillas finales de la cadena `"dog"`, utilice el siguiente ejemplo.
```
SELECT TRIM(TRAILING '"' FROM'"dog"');
+-------+
| rtrim |
+-------+
| "dog |
+-------+
```
TRIM elimina cualquiera de los caracteres de *trim\$1chars* cuando aparecen al principio o al final de *cadena*. En el siguiente ejemplo, se recortan los caracteres “C”, “D” y “G” cuando aparecen al principio o al final de VENUENAME, que es una columna `VARCHAR`. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
```
SELECT venueid, venuename, TRIM('CDG' FROM venuename)
FROM venue
WHERE venuename LIKE '%Park'
ORDER BY 2
LIMIT 7;
+---------+----------------------------+---------------------------+
| venueid | venuename | btrim |
+---------+----------------------------+---------------------------+
| 121 | AT&T Park | AT&T Park |
| 109 | Citizens Bank Park | itizens Bank Park |
| 102 | Comerica Park | omerica Park |
| 9 | Dick's Sporting Goods Park | ick's Sporting Goods Park |
| 97 | Fenway Park | Fenway Park |
| 112 | Great American Ball Park | reat American Ball Park |
| 114 | Miller Park | Miller Park |
+---------+----------------------------+---------------------------+
```
# Función UPPER
Convierte una cadena a mayúsculas. UPPER admite caracteres multibyte UTF-8 de hasta un máximo de cuatro bytes por carácter.
## Sintaxis
```
UPPER(string)
```
## Argumentos
*cadena*
El parámetro de entrada es una cadena `VARCHAR` o cualquier otro tipo de datos, como `CHAR`, que se pueda convertir de forma implícita a `VARCHAR`.
## Tipo de retorno
La función UPPER devuelve una cadena de caracteres que tiene el mismo tipo de datos que la cadena de entrada. Por ejemplo, la función devolverá una cadena `VARCHAR` si la entrada es una cadena `VARCHAR`.
## Ejemplos
En el siguiente ejemplo se utilizan datos de la tabla CATEGORY en la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
Para convertir el campo CATNAME a mayúsculas, use lo siguiente.
```
SELECT catname, UPPER(catname)
FROM category
ORDER BY 1,2;
+-----------+-----------+
| catname | upper |
+-----------+-----------+
| Classical | CLASSICAL |
| Jazz | JAZZ |
| MLB | MLB |
| MLS | MLS |
| Musicals | MUSICALS |
| NBA | NBA |
| NFL | NFL |
| NHL | NHL |
| Opera | OPERA |
| Plays | PLAYS |
| Pop | POP |
+-----------+-----------+
```