Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Funciones de cadena
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.
**Topics**
+ [\$1\$1 Operador (concatenación)](concat_op.md)
+ [Función BTRIM](BTRIM.md)
+ [Función CONCAT](CONCAT.md)
+ [Función FORMAT\$1STRING](FORMAT_STRING.md)
+ [Funciones LEFT y RIGHT](LEFT.md)
+ [Función LENGTH](LENGTH.md)
+ [Función LOWER](LOWER.md)
+ [Funciones LPAD y RPAD](LPAD.md)
+ [Función LTRIM](LTRIM.md)
+ [Función POSITION](POSITION.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](REPEAT.md)
+ [Función REPLACE](REPLACE.md)
+ [Función REVERSE](REVERSE.md)
+ [Función RTRIM](RTRIM.md)
+ [Función SPLIT](split.md)
+ [Función SPLIT\$1PART](SPLIT_PART.md)
+ [Función SUBSTRING](SUBSTRING.md)
+ [Función TRANSLATE](TRANSLATE.md)
+ [Función TRIM](TRIM.md)
+ [Función UPPER](UPPER.md)
+ [Función UUID](UUID.md)
# \$1\$1 Operador (concatenación)
Concatena dos expresiones a ambos extremos del símbolo \$1\$1 y devuelve una expresión concatenada.
El operador de concatenación es similar a [Función CONCAT](CONCAT.md).
**nota**
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á.
## Sintaxis
```
expression1 || expression2
```
## Argumentos
*expression1*, *expression2*
Ambos argumentos pueden ser cadenas de caracteres o expresiones de longitud fija o variable.
## Tipo de devolución
El operador \$1\$1 devuelve una cadena. El tipo de cadena es el mismo que los argumentos de entrada.
## Ejemplo
En el siguiente ejemplo, se concatenan los campos FIRSTNAME y LASTNAME de la tabla USERS:
```
select firstname || ' ' || lastname
from users
order by 1
limit 10;
concat
-----------------
Aaron Banks
Aaron Booth
Aaron Browning
Aaron Burnett
Aaron Casey
Aaron Cash
Aaron Castro
Aaron Dickerson
Aaron Dixon
Aaron Dotson
(10 rows)
```
Para concatenar columnas que puedan llegar a tener valores nulos, use la expresión [Funciones NVL y COALESCE](NVL_function.md). En el siguiente ejemplo, se usa NVL para devolver un 0 siempre que se encuentre un NULL.
```
select venuename || ' seats ' || nvl(venueseats, 0)
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 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
*string*
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 devolución
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 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.
**nota**
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á.
## 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 devolución
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 tipos diferentes, AWS Clean Rooms intenta escribir implícitamente convierte una de las expresiones. Si no se pueden convertir los valores, se devuelve un error.
## 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';
concat
-------------------
December 25, 2008
(1 row)
```
En el siguiente ejemplo, se usan dos funciones 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 llegar a tener valores nulos, use [Funciones NVL y COALESCE](NVL_function.md). 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)
```
# Función FORMAT\$1STRING
La función FORMAT\$1STRING crea una cadena formateada sustituyendo los marcadores de posición de una cadena de plantilla por los argumentos proporcionados. Devuelve una cadena formateada a partir de cadenas de formato de estilo printf.
La función FORMAT\$1STRING funciona sustituyendo los marcadores de posición de la cadena de la plantilla por los valores correspondientes pasados como argumentos. Este tipo de formato de cadena puede resultar útil cuando se necesitan construir cadenas de forma dinámica que incluyan una combinación de texto estático y datos dinámicos, como cuando se generan mensajes de salida, informes u otros tipos de texto informativo. La función FORMAT\$1STRING proporciona una forma concisa y legible de crear estos tipos de cadenas formateadas, lo que facilita el mantenimiento y la actualización del código que genera la salida.
## Sintaxis
```
format_string(strfmt, obj, ...)
```
## Argumentos
*strfmt*
Una expresión de cadena.
*obj*
Una cadena o expresión numérica.
## Tipo de devolución
FORMAT\$1STRING devuelve una cadena.
## Ejemplo
El siguiente ejemplo contiene una cadena de plantilla que contiene dos marcadores de posición: `%d` para un valor decimal (entero) y `%s` para un valor de cadena. El `%d` marcador de posición se reemplaza por el valor decimal (entero) (`100`) y el marcador de posición %s se reemplaza por el valor de cadena (). `"days"` El resultado es una cadena de plantilla en la que los marcadores de posición se sustituyen por los argumentos proporcionados:. `"Hello World 100 days"`
```
SELECT format_string("Hello World %d %s", 100, "days");
Hello World 100 days
```
# 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
*string*
Cualquier cadena de caracteres o cualquier expresión que tome como valor una cadena de caracteres.
*integer*
Un número entero.
## Tipo de devolución
LEFT y RIGHT devuelven una cadena VARCHAR.
## Ejemplo
El siguiente ejemplo devuelve los 5 caracteres situados más a la izquierda y los 5 más a la derecha de los nombres de eventos que tengan IDs entre 1000 y 1005:
```
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
(6 rows)
```
# Función LENGTH
# 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
*string*
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 devolución
La función LOWER devuelve una cadena de caracteres que presenta el mismo tipo de datos que la cadena de entrada.
## Ejemplos
En el siguiente ejemplo, se convierte el campo CATNAME a minúsculas:
```
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
(11 rows)
```
# 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 de caracteres o una expresión toma el valor de una cadena de caracteres, como el nombre de una columna de caracteres.
*longitud*
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 *length (longitud)* es un número negativo, el resultado de la función es una cadena vacía.
*string2 (cadena2)*
Uno o varios caracteres que se anteponen o anexan a *string1 (cadena1)*. Este argumento es opcional; si no se especifica, se utilizan espacios.
## Tipo de devolución
Estas funciones devuelven un tipo de datos VARCHAR.
## Ejemplos
Truncar un conjunto especificado de nombres de eventos a 20 caracteres y anteponga espacios a los nombres más cortos:
```
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
(5 rows)
```
Truncar el mismo conjunto de nombres de eventos a 20 caracteres, pero anexar `0123456789` a los nombres más cortos.
```
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
(5 rows)
```
# 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 se completa cuando no aparece ningún carácter de recorte en la cadena de entrada.
## Sintaxis
```
LTRIM( string [, trim_chars] )
```
## Argumentos
*string*
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 devolución
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 POSITION
Devuelve la ubicación de la subcadena especificada dentro de una cadena.
## Sintaxis
```
POSITION(substring IN string )
```
## Argumentos
*subcadena*
Subcadena que se va a buscar dentro de la *cadena*.
*string*
La cadena o columna que se buscará.
## Tipo de devolución
La función POSITION devuelve un valor entero correspondiente a la posición de la subcadena (basado en 1, 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
POSITION devuelve 0 si no se encuentra subcadena dentro de la cadena:
```
select position('dog' in 'fish');
position
----------
0
(1 row)
```
## Ejemplos
En el siguiente ejemplo, se muestra la posición de la cadena `fish` dentro de la palabra `dogfish`:
```
select position('fish' in 'dogfish');
position
----------
4
(1 row)
```
El siguiente ejemplo devuelve la cantidad de transacciones de venta con un parámetro COMMISSION que supere los 999,00 de la tabla SALES:
```
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
(1 row)
```
# 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 aparece en la cadena. Si no se encuentra coincidencia, la función devuelve 0.
## Sintaxis
```
REGEXP_COUNT ( source_string, pattern [, position [, parameters ] ] )
```
## Argumentos
*source\$1string*
Una expresión de cadena, como un nombre de columna, que se buscará.
*pattern*
Un literal de cadena que representa un patrón de expresión regular.
*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 de 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 0.
*parameters*
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).
## Tipo de devolución
Entero
## Ejemplo
En el siguiente ejemplo, se cuenta la cantidad de veces en que aparece una secuencia de tres letras.
```
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
regexp_count
--------------
8
```
En el siguiente ejemplo, se cuenta la cantidad de veces en que el nombre del dominio de nivel superior es `org` o `edu`.
```
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
```
En el siguiente ejemplo, se cuenta cuántas veces aparece la cadena `FOX`, con una coincidencia que no distingue entre mayúsculas y minúsculas.
```
SELECT regexp_count('the fox', 'FOX', 1, 'i');
regexp_count
--------------
1
```
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 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
```
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 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
```
# 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](POSITION.md), pero le permite buscar un patrón de expresión regular en una cadena.
## 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á.
*pattern*
Un literal de cadena que representa un patrón de expresión regular.
*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 de 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 0.
*occurrence*
Un número entero positivo que indica qué coincidencia del patrón se va a utilizar. REGEXP\$1INSTR omite las primeras coincidencias especificadas por el valor de *occurrence* menos uno. El valor predeterminado de 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.
*option*
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.
*parameters*
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).
## Tipo de devolución
Entero
## Ejemplo
En el siguiente ejemplo, se busca el carácter `@` que comience un nombre de dominio y se devuelve la posición inicial de la primera coincidencia.
```
SELECT email, regexp_instr(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_instr
-----------------------------------------------+--------------
Etiam.laoreet.libero@example.com | 21
Suspendisse.tristique@nonnisiAenean.edu | 22
amet.faucibus.ut@condimentumegetvolutpat.ca | 17
sed@lacusUtnec.ca | 4
```
En el siguiente ejemplo, se buscan variantes de la palabra `Center` y se devuelve la posición inicial de la primera coincidencia.
```
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
```
En el siguiente ejemplo, se encuentra 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.
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
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 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
```
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 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](REPLACE.md), pero le permite buscar un patrón de expresión regular en una cadena.
REGEXP\$1REPLACE es similar a [Función TRANSLATE](TRANSLATE.md) y a [Función REPLACE](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, como un nombre de columna, que se buscará.
*pattern*
Un literal de cadena que representa un patrón de expresión regular.
*replace\$1string*
Una expresión de cadena, como un nombre de columna, que reemplazará cada coincidencia del patrón. El valor predeterminado es una cadena vacía ( "" ).
*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 de 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 la cantidad de caracteres de *source-string (cadena\$1de\$1origen)*, el resultado es *source\$1string (cadena\$1de\$1origen)*.
*parameters*
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).
## Tipo de devolución
VARCHAR
Si el valor de *pattern* o la *replace\$1string* es NULL, el valor devuelto es NULL.
## Ejemplo
En el siguiente ejemplo, se elimina el `@` y el nombre de dominio de direcciones de correo electrónico.
```
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
```
En el siguiente ejemplo, se reemplazan los nombres de dominio de las direcciones de email con este valor: `internal.company.com`.
```
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
```
En el siguiente ejemplo, se reemplazan 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.
```
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. En este ejemplo, se reemplaza cada vez que aparece una palabra que reúne esas características con el valor `[hidden]`.
```
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. En este ejemplo, se reemplaza 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.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
regexp_replace
----------------------------------
[hidden] plain [hidden] [hidden]
```
# 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](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.
## Sintaxis
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Argumentos
*source\$1string*
Una expresión de cadena que se va a buscar.
*pattern*
Un literal de cadena que representa un patrón de expresión regular.
*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 de 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 de 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 NULL.
*parameters*
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).
## Tipo de devolución
VARCHAR
## Ejemplo
El siguiente ejemplo devuelve la parte de una dirección de correo electrónico entre el carácter @ y la extensión de dominio.
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
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 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.
## Sintaxis
```
REPEAT(string, integer)
```
## Argumentos
*string*
El primer parámetro de entrada es la cadena que se repetirá.
*integer*
El segundo parámetro es un valor entero que indica la cantidad de veces que se repite la cadena.
## Tipo de devolución
La función REPEAT devuelve una cadena.
## Ejemplos
En el siguiente ejemplo, se repite tres veces el valor de la columna CATID en la tabla CATEGORY:
```
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
(11 rows)
```
# 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](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(string1, old_chars, new_chars)
```
## Argumentos
*string*
Cadena CHAR o VARCHAR que se buscará
*old\$1chars*
Cadena CHAR o VARCHAR que se reemplazará.
*new\$1chars*
Nueva cadena CHAR o VARCHAR que reemplaza a *old\$1string (cadena\$1anterior)*.
## Tipo de devolución
VARCHAR
Si *old\$1chars* o *new\$1chars* es NULL, el valor devuelto es NULL.
## Ejemplos
En el siguiente ejemplo, se convierte la cadena `Shows` en `Theatre` en el campo CATGROUP:
```
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
(11 rows)
```
# 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 a cadenas de caracteres de longitud variable. Se ignoran los espacios a la derecha en cadenas de caracteres de ancho fijo.
## Tipo de devolución
REVERSE devuelve un VARCHAR.
## Ejemplos
Seleccione cinco nombres distintos de ciudades y sus correspondientes nombres invertidos de la tabla USERS:
```
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
(5 rows)
```
Seleccione cinco números de venta IDs y su correspondiente distribución invertida IDs como cadenas de caracteres:
```
select salesid, reverse(salesid)::varchar
from sales order by salesid desc limit 5;
salesid | reverse
--------+---------
172456 | 654271
172455 | 554271
172454 | 454271
172453 | 354271
172452 | 254271
(5 rows)
```
# 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 se completa cuando un carácter de recorte no aparece en la cadena de entrada.
## Sintaxis
```
RTRIM( string, trim_chars )
```
## Argumentos
*string*
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 devolución
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 SPLIT
La función SPLIT permite extraer subcadenas de una cadena más grande y trabajar con ellas como una matriz. La función DIVIDIR resulta útil cuando se necesita dividir una cadena en componentes individuales en función de un patrón o delimitador específico.
## Sintaxis
```
split(str, regex, limit)
```
## Argumentos
*estrella*
Una expresión de cadena para dividir.
*regex*
Una cadena que representa una expresión regular. La cadena de *expresiones* regulares debe ser una expresión regular de Java.
*limit*
Una expresión entera que controla el número de veces que se aplica la expresión *regular.*
+ *límite > 0: la longitud de la matriz resultante no superará el límite y la última entrada de la matriz resultante contendrá todas las entradas más allá de la última expresión regular coincidente.*
+ límite <= 0: la *expresión regular* se aplicará tantas veces como sea posible y la matriz resultante puede ser de cualquier tamaño.
## Tipo de devolución
La función DIVIDIR devuelve una MATRIZ.
Si`limit > 0`: la longitud de la matriz resultante no superará el límite y la última entrada de la matriz resultante contendrá todas las entradas más allá de la última expresión regular coincidente.
Si`limit <= 0`: la expresión regular se aplicará tantas veces como sea posible y la matriz resultante puede ser de cualquier tamaño.
## Ejemplo
En este ejemplo, la función SPLIT divide la cadena de entrada `'oneAtwoBthreeC'` siempre que encuentre los caracteres `'A'` o `'C'` (según lo especificado en el patrón de expresiones regulares). `'B'` `'[ABC]'` El resultado es una matriz de cuatro elementos:`"one"`, `"two"``"three"`, y una cadena `""` vacía.
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# 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
*string*
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 devolución
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 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(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Argumentos
*cadena de caracteres*
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.
*numerar caracteres*
La cantidad de caracteres para extraer (la longitud de la subcadena). El *número* de caracteres se basa en el número de caracteres, no en bytes, de modo que los caracteres de varios bytes se cuentan como caracteres individuales. Este número no puede ser negativo.
*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.
*bytes numéricos*
La cantidad de bytes para extraer, es decir, la longitud de la subcadena. Este número no puede ser negativo.
## Tipo de devolución
VARCHAR
## Notas de uso de cadenas de caracteres
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 la *posición inicial \$1* el *número de caracteres* supera la longitud de la *cadena, SUBSTRING devuelve una subcadena* desde la posición inicial 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 `numbecharacters` -1. Por ejemplo:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Si `start_position` \$1 `numbecharacters` -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
```
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 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](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
*expresión*
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 devolución
VARCHAR
## Ejemplos
En el siguiente ejemplo, se reemplazan varios caracteres en una cadena:
```
select translate('mint tea', 'inea', 'osin');
translate
-----------
most tin
```
En el siguiente ejemplo, se reemplaza el signo (@) con un punto para todos los valores en una columna:
```
select email, translate(email, '@', '.') as obfuscated_email
from users limit 10;
email obfuscated_email
-------------------------------------------------------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu Etiam.laoreet.libero.sodalesMaurisblandit.edu
amet.faucibus.ut@condimentumegetvolutpat.ca amet.faucibus.ut.condimentumegetvolutpat.ca
turpis@accumsanlaoreet.org turpis.accumsanlaoreet.org
ullamcorper.nisl@Cras.edu ullamcorper.nisl.Cras.edu
arcu.Curabitur@senectusetnetus.com arcu.Curabitur.senectusetnetus.com
ac@velit.ca ac.velit.ca
Aliquam.vulputate.ullamcorper@amalesuada.org Aliquam.vulputate.ullamcorper.amalesuada.org
vel.est@velitegestas.edu vel.est.velitegestas.edu
dolor.nonummy@ipsumdolorsit.ca dolor.nonummy.ipsumdolorsit.ca
et@Nunclaoreet.ca et.Nunclaoreet.ca
```
En el siguiente ejemplo, se reemplazan espacios con guiones bajos y se quitan los puntos para todos los valores en una columna:
```
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 al eliminar espacios o caracteres a la izquierda y a la derecha que coincidan con una cadena específica opcional.
## Sintaxis
```
TRIM( [ BOTH ] [ trim_chars FROM ] string
```
## Argumentos
*trim\$1chars*
(Opcional) Los caracteres que se recortarán de la cadena. Si se omite este parámetro, se recortan los espacios en blanco.
*string*
La cadena que se recortará.
## Tipo de devolución
La función TRIM devuelve una cadena VARCHAR o CHAR. Si utiliza la función TRIM con un comando SQL, convierte implícitamente los resultados en VARCHAR. AWS Clean Rooms Si utiliza la función TRIM de la lista SELECT para una función SQL, AWS Clean Rooms no convierte los resultados de forma implícita y es posible que necesite realizar una conversión explícita para evitar un error de discordancia en los tipos de datos. Consulte la [Función CAST](CAST_function.md) función para obtener información sobre las conversiones explícitas.
## Ejemplo
En el siguiente ejemplo, se recortan espacios a la izquierda y a la derecha de la cadena `' abc '`:
```
select ' abc ' as untrim, trim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
En el siguiente ejemplo, se eliminan las comillas dobles que rodean la cadena `"dog"`:
```
select trim('"' FROM '"dog"');
btrim
-------
dog
```
TRIM elimina cualquiera de los caracteres de *trim\$1chars* cuando aparecen al principio del *string*. 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, trim(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
```
# 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
*string*
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 devolución
La función UPPER devuelve una cadena de caracteres que tiene el mismo tipo de datos que la cadena de entrada.
## Ejemplos
El siguiente ejemplo convierte el campo CATNAME a mayúsculas:
```
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
(11 rows)
```
# Función UUID
La función UUID genera un identificador único universal (UUID).
UUIDs son identificadores únicos a nivel mundial que se utilizan habitualmente para proporcionar identificadores únicos con diversos fines, como:
+ Identificar registros de bases de datos u otras entidades de datos.
+ Generar nombres o claves únicos para archivos, directorios u otros recursos.
+ Rastrear y correlacionar datos en sistemas distribuidos.
+ Proporcionar identificadores únicos para paquetes de red, componentes de software u otros activos digitales.
La función UUID genera un valor UUID que es único con una probabilidad muy alta, incluso en sistemas distribuidos y durante largos períodos de tiempo. UUIDs se generan normalmente mediante una combinación de la marca de tiempo actual, la dirección de red del ordenador y otros datos aleatorios o pseudoaleatorios, lo que garantiza que es muy poco probable que cada UUID generado entre en conflicto con cualquier otro UUID.
En el contexto de una consulta SQL, la función UUID se puede utilizar para generar identificadores únicos para los nuevos registros que se insertan en una base de datos, o para proporcionar claves únicas para la partición de datos, la indexación u otros fines en los que se requiera un identificador único.
**nota**
La función UUID no es determinista.
## Sintaxis
```
uuid()
```
## Argumentos
La función UUID no admite ningún argumento.
## Tipo de devolución
El UUID devuelve una cadena de identificador único universal (UUID). El valor se devuelve como una cadena canónica de 36 caracteres del UUID.
## Ejemplo
El siguiente ejemplo genera un identificador único universal (UUID). El resultado es una cadena de 36 caracteres que representa un identificador único universal.
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```