As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Funções de string
Funções de string processam e manipulam strings de caracteres ou expressões que avaliam para strings de caracteres. Quando o argumento *string* nessas funções é um valor literal, ele deve ser envolvido por aspas simples. Os tipos de dados compatíveis incluem CHAR e VARCHAR.
A próxima seção fornece os nomes de função, sintaxe e descrições para as funções compatíveis. Todos os deslocamentos em strings são baseados em um.
**Topics**
+ [Operador \$1\$1 (Concatenação)](concat_op.md)
+ [Função BTRIM](BTRIM.md)
+ [Função CONCAT](CONCAT.md)
+ [função FORMAT\$1STRING](FORMAT_STRING.md)
+ [Funções LEFT e RIGHT](LEFT.md)
+ [Função LENGTH](LENGTH.md)
+ [Função LOWER](LOWER.md)
+ [Funções LPAD e RPAD](LPAD.md)
+ [Função LTRIM](LTRIM.md)
+ [Função POSITION](POSITION.md)
+ [Função REGEXP\$1COUNT](REGEXP_COUNT.md)
+ [Função REGEXP\$1INSTR](REGEXP_INSTR.md)
+ [Função REGEXP\$1REPLACE](REGEXP_REPLACE.md)
+ [Função REGEXP\$1SUBSTR](REGEXP_SUBSTR.md)
+ [Função REPEAT](REPEAT.md)
+ [Função REPLACE](REPLACE.md)
+ [Função REVERSE](REVERSE.md)
+ [Função RTRIM](RTRIM.md)
+ [Função SPLIT](split.md)
+ [Função SPLIT\$1PART](SPLIT_PART.md)
+ [Função SUBSTRING](SUBSTRING.md)
+ [Função TRANSLATE](TRANSLATE.md)
+ [Função TRIM](TRIM.md)
+ [Função UPPER](UPPER.md)
+ [Função UUID](UUID.md)
# Operador \$1\$1 (Concatenação)
Concatena duas expressões em ambos os lados do símbolo \$1\$1 e retorna a expressão concatenada.
O operador de concatenação é semelhante a [Função CONCAT](CONCAT.md).
**nota**
Tanto para a função CONCAT como para o operador de concatenação, se uma ou ambas as expressões forem nulas, o resultado da concatenação será null.
## Sintaxe
```
expression1 || expression2
```
## Argumentos
*expression1*, *expression2*
Ambos os argumentos podem ser strings de caracteres ou expressões de comprimento fixo ou variável.
## Tipo de retorno
O operador \$1\$1 retorna uma string. O tipo de string é igual ao tipo dos argumentos de entrada.
## Exemplo
O seguinte exemplo concatena os campos FIRSTNAME e LASTNAME da tabela 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 colunas que possam conter nulos, use a expressão [Funções NVL e COALESCE](NVL_function.md). O seguinte exemplo usa NVL para retornar um 0 sempre que NULL for encontrado.
```
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
```
# Função BTRIM
A função BTRIM apara uma string removendo os espaços em branco iniciais e finais ou removendo caracteres iniciais ou finais que correspondem a uma string opcional especificada.
## Sintaxe
```
BTRIM(string [, trim_chars ] )
```
## Argumentos
*string*
A string VARCHAR de entrada a ser cortada.
*trim\$1chars*
A string VARCHAR que contém os caracteres a serem correspondidos.
## Tipo de retorno
A função BTRIM retorna uma string VARCHAR.
## Exemplos
O seguinte exemplo apara espaços em branco inicias e finais da string `' abc '`:
```
select ' abc ' as untrim, btrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
O exemplo a seguir remove a string `'xyz'` inicial e final da string `'xyzaxyzbxyzcxyz'`. As ocorrências inicial e final de `'xyz'` são removidas, mas as ocorrências internas da string não são removidas.
```
select 'xyzaxyzbxyzcxyz' as untrim,
btrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | axyzbxyzc
```
O exemplo a seguir remove as partes iniciais e finais da string `'setuphistorycassettes'` que correspondem a qualquer um dos caracteres na lista *trim\$1chars* `'tes'`. Qualquer `t`, `e` ou `s` que ocorra antes que outro caractere que não esteja na lista *trim\$1chars* no início ou no final da string de entrada seja removido.
```
SELECT btrim('setuphistorycassettes', 'tes');
btrim
-----------------
uphistoryca
```
# Função CONCAT
A função CONCAT concatena duas expressões e retorna a expressão resultante. Para concatenar mais de duas strings, use funções CONCAT aninhadas. O operador de concatenação (`||`) entre duas expressões produz os mesmos resultados que a função CONCAT.
**nota**
Tanto para a função CONCAT como para o operador de concatenação, se uma ou ambas as expressões forem nulas, o resultado da concatenação será null.
## Sintaxe
```
CONCAT ( expression1, expression2 )
```
## Argumentos
*expression1*, *expression2*
Os dois argumentos podem ser uma cadeia de caracteres de comprimento fixo, uma cadeia de caracteres de comprimento variável, uma expressão binária ou uma expressão que é avaliada para uma dessas entradas.
## Tipo de retorno
CONCAT retorna uma expressão. O tipo de dados da expressão é o mesmo tipo dos argumentos de entrada.
Se as expressões de entrada forem de tipos diferentes, AWS Clean Rooms tentará digitar implicitamente uma das expressões. Se os valores não puderem ser convertidos, será retornado um erro.
## Exemplos
O seguinte exemplo concatena dois literais de caracteres:
```
select concat('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
A seguinte consulta, usando o operador `||` em vez de CONCAT, produz o mesmo resultado:
```
select 'December 25, '||'2008';
concat
-------------------
December 25, 2008
(1 row)
```
O seguinte exemplo usa duas funções CONCAT para concatenar três strings de caracteres:
```
select concat('Thursday, ', concat('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Para concatenar colunas que possam conter nulos, use a [Funções NVL e COALESCE](NVL_function.md). O seguinte exemplo usa NVL para retornar um 0 sempre que NULL for encontrado.
```
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)
```
A seguinte consulta concatena os valores CITY e STATE da tabela VENUE:
```
select concat(venuecity, venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
-------------------
DenverCO
Kansas CityMO
East RutherfordNJ
LandoverMD
(4 rows)
```
A seguinte consulta usa funções CONCAT aninhadas. A consulta concatena os valores CITY e STATE da tabela VENUE, mas delimita a string resultante com uma vírgula e um espaço:
```
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)
```
# função FORMAT\$1STRING
A função FORMAT\$1STRING cria uma string formatada substituindo os espaços reservados em uma string de modelo pelos argumentos fornecidos. Ele retorna uma string formatada de strings de formato no estilo printf.
A função FORMAT\$1STRING funciona substituindo os espaços reservados na string do modelo pelos valores correspondentes passados como argumentos. Esse tipo de formatação de string pode ser útil quando você precisa construir dinamicamente cadeias de caracteres que incluam uma mistura de texto estático e dados dinâmicos, como ao gerar mensagens de saída, relatórios ou outros tipos de texto informativo. A função FORMAT\$1STRING fornece uma maneira concisa e legível de criar esses tipos de strings formatadas, facilitando a manutenção e a atualização do código que gera a saída.
## Sintaxe
```
format_string(strfmt, obj, ...)
```
## Argumentos
*strfmt*
Uma expressão STRING.
*obj*
Uma STRING ou expressão numérica.
## Tipo de retorno
FORMAT\$1STRING retorna uma STRING.
## Exemplo
O exemplo a seguir contém uma string de modelo que contém dois espaços reservados: `%d` para um valor decimal (inteiro) e `%s` para um valor de string. O `%d` espaço reservado é substituído pelo valor decimal (inteiro) () e o espaço reservado %s é substituído pelo valor da string (`100`). `"days"` A saída é uma string de modelo com os espaços reservados substituídos pelos argumentos fornecidos:`"Hello World 100 days"`.
```
SELECT format_string("Hello World %d %s", 100, "days");
Hello World 100 days
```
# Funções LEFT e RIGHT
Essas funções retornam o número especificado de caracteres mais à esquerda ou mais à direita de uma string de caracteres.
O número é baseado no número de caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples.
## Sintaxe
```
LEFT ( string, integer )
RIGHT ( string, integer )
```
## Argumentos
*string*
Qualquer string de caracteres ou qualquer expressão que avalie para uma string de caracteres.
*inteiro*
Um inteiro positivo.
## Tipo de retorno
LEFT e RIGHT retornam uma string VARCHAR.
## Exemplo
O exemplo a seguir retorna os 5 caracteres mais à esquerda e os 5 caracteres mais à direita de nomes de eventos que têm IDs entre 1000 e 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)
```
# Função LENGTH
# Função LOWER
Converte uma string em letras minúsculas. LOWER é compatível com caracteres UTF-8 multibyte, até o máximo de quatro bytes por caractere.
## Sintaxe
```
LOWER(string)
```
## Argumento
*string*
O parâmetro de entrada é uma string VARCHAR (ou qualquer outro tipo de dados, como CHAR, que pode ser convertido implicitamente para VARCHAR).
## Tipo de retorno
A função LOWER retorna uma string de caractere no mesmo tipo de dados que a string de entrada.
## Exemplos
O exemplo a seguir converte o campo CATNAME em 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)
```
# Funções LPAD e RPAD
Essas funções inserem caracteres no início ou final de uma string com base em um comprimento especificado.
## Sintaxe
```
LPAD (string1, length, [ string2 ])
```
```
RPAD (string1, length, [ string2 ])
```
## Argumentos
*string1*
Uma string de caracteres ou uma expressão que avalie para uma string de caracteres, tal como o nome de uma coluna de caracteres.
*length*
Um inteiro que define o comprimento dos resultados da função. O comprimento de uma string é baseado no número de caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples. Se *string1* for mais longa que o comprimento especificado, ela será truncada (à direita). Se *length* for um número negativo, o resultado da função será uma string vazia.
*string2*
Um ou mais caracteres inseridos no início ou no fim da *string1*. Este argumento é opcional; se ele não é especificado, espaços são usados.
## Tipo de retorno
Essas funções retornam um tipo de dados VARCHAR.
## Exemplos
Trunque um conjunto específico de nomes de eventos para 20 caracteres e insira espaços no início dos nomes mais curtos:
```
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)
```
Trunque o mesmo conjunto de nomes de eventos para 20 caracteres, mas insira no início dos nomes mais curtos `0123456789`.
```
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)
```
# Função LTRIM
Corta caracteres do início de uma string. Remove a string mais longa que contém somente caracteres que estão na lista de caracteres de corte. O corte é concluído quando um caractere de corte não aparece na string de entrada.
## Sintaxe
```
LTRIM( string [, trim_chars] )
```
## Argumentos
*string*
Uma coluna, expressão ou literal de string a ser cortado.
*trim\$1chars*
Uma coluna, expressão ou literal de string que representa os caracteres a serem cortados do começo da *string*. Se não for especificado, um espaço será usado como caractere de corte.
## Tipo de retorno
A função LTRIM retorna uma string no mesmo tipo de dado que a *string* de entrada (CHAR ou VARCHAR).
## Exemplos
O exemplo a seguir corta o ano da coluna `listime`. Os caracteres de corte no literal de string `'2008-'` indicam os caracteres a serem cortados da esquerda. Se você usar os caracteres de corte `'028-'`, obterá o mesmo 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 remove qualquer um dos caracteres em *trim\$1chars* quando eles aparecem no início da *string*. O seguinte exemplo apara os caracteres “C”, “D” e “G” quando eles aparecem no início de VENUENAME, que é uma coluna 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
```
O exemplo a seguir usa o caractere de corte `2` que é recuperado da coluna `venueid`.
```
select ltrim('2008-01-24 06:43:29', venueid)
from venue where venueid=2;
ltrim
------------------
008-01-24 06:43:29
```
O exemplo a seguir não corta nenhum caractere porque `2` é encontrado antes do caractere de corte `'0'`.
```
select ltrim('2008-01-24 06:43:29', '0');
ltrim
-------------------
2008-01-24 06:43:29
```
O exemplo a seguir usa o caractere de corte de espaço padrão e corta os dois espaços do início da string.
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# Função POSITION
Retorna a localização da substring especificada dentro de uma string.
## Sintaxe
```
POSITION(substring IN string )
```
## Argumentos
*substring*
A substring a procurar dentro da *string*.
*string*
A string ou coluna a ser procurada.
## Tipo de retorno
A função POSITION retorna um inteiro correspondente à posição da substring (baseada em 1, não baseada em zero). A posição é baseada no número de caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples.
## Observações de uso
POSITION retornará 0 se a substring não for localizada dentro da string:
```
select position('dog' in 'fish');
position
----------
0
(1 row)
```
## Exemplos
O seguinte exemplo mostra a posição da string `fish` na palavra `dogfish`:
```
select position('fish' in 'dogfish');
position
----------
4
(1 row)
```
O seguinte exemplo retorna o número de transações de vendas com uma COMMISSION acima de 999,00 da tabela 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)
```
# Função REGEXP\$1COUNT
Pesquisa uma string quanto a um padrão de expressão regular e retorna um inteiro que indica o número de vezes que o padrão ocorre na string. Se nenhuma correspondência for encontrada, a função retornará 0.
## Sintaxe
```
REGEXP_COUNT ( source_string, pattern [, position [, parameters ] ] )
```
## Argumentos
*source\$1string*
Uma expressão de string, tal como um nome de coluna, a ser procurada.
*pattern*
Um literal de string que representa um padrão de expressão regular.
*position*
Um inteiro positivo que indica a posição em *source\$1string* para começar a pesquisar. A posição é baseada no número de caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples. O padrão é um. Se a *posição* for menor que 1, a pesquisa começará no primeiro caractere da *source\$1string*. Se *position* for maior que o número de caracteres na *source\$1string*, o resultado será 0.
*parameters*
Uma ou mais literais de sequências que indicam como a função corresponde o padrão. Os valores possíveis são os seguintes:
+ c – Executa a correspondência diferenciando maiúsculas e minúsculas. O padrão é usar a correspondência diferenciando maiúsculas e minúsculas.
+ i – Executa a correspondência sem diferenciar maiúsculas de minúsculas.
+ p — Interpreta o padrão com o dialeto de expressão regular compatível com Perl (PCRE - Perl Compatible Regular Expression).
## Tipo de retorno
Inteiro
## Exemplo
O seguinte exemplo conta o número de vezes que uma sequência de três letra ocorre.
```
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
regexp_count
--------------
8
```
O seguinte exemplo conta o número de vezes que nome de domínio de nível superior é `org` ou `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
```
O exemplo a seguir conta as ocorrências da string `FOX` usando a correspondência sem diferenciar maiúsculas de minúsculas.
```
SELECT regexp_count('the fox', 'FOX', 1, 'i');
regexp_count
--------------
1
```
O exemplo a seguir usa um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula. Ele usa o operador `?=`, que tem uma conotação específica look-ahead em PCRE. Este exemplo conta o número de ocorrências de tais palavras, com correspondência diferenciando maiúsculas de minúsculas.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
regexp_count
--------------
2
```
O exemplo a seguir usa um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula. Ele usa o operador `?=`, que tem uma conotação específica em PCRE. Este exemplo conta o número de ocorrências de tais palavras, mas difere do exemplo anterior na medida em que usa correspondência sem diferenciar maiúsculas dee minúsculas.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
regexp_count
--------------
3
```
# Função REGEXP\$1INSTR
Pesquisa um padrão de expressão regular em uma sequência e retorna um inteiro que indica a posição inicial ou final da subsequência correspondente. Se nenhuma correspondência for encontrada, a função retornará 0. REGEXP\$1INSTR é semelhante à função [POSITION](POSITION.md), mas permite que você pesquise um padrão de expressão regular em uma sequência.
## Sintaxe
```
REGEXP_INSTR ( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Argumentos
*source\$1string*
Uma expressão de string, tal como um nome de coluna, a ser procurada.
*pattern*
Um literal de string que representa um padrão de expressão regular.
*position*
Um inteiro positivo que indica a posição em *source\$1string* para começar a pesquisar. A posição é baseada no número de caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples. O padrão é um. Se a *posição* for menor que 1, a pesquisa começará no primeiro caractere da *source\$1string*. Se *position* for maior que o número de caracteres na *source\$1string*, o resultado será 0.
*occurrence*
Um inteiro positivo que indica qual ocorrência do padrão usar. REGEXP\$1INSTR ignora as primeiras correspondências de *occurrence* -1. O padrão é um. Se *ocurrence* for menor que 1 ou maior que o número de caracteres em *source\$1string*, a pesquisa será ignorada e o resultado será 0.
*option*
Um valor que indica se retornar a posição do primeiro caractere da correspondência (`0`) ou a posição do primeiro caractere seguinte ao final da correspondência (`1`). Um valor diferente de zero é o mesmo que 1. O valor padrão é 0.
*parameters*
Uma ou mais literais de sequências que indicam como a função corresponde o padrão. Os valores possíveis são os seguintes:
+ c – Executa a correspondência diferenciando maiúsculas e minúsculas. O padrão é usar a correspondência diferenciando maiúsculas e minúsculas.
+ i – Executa a correspondência sem diferenciar maiúsculas de minúsculas.
+ e – Extrai uma subsequência usando uma subexpressão.
Se o *padrão* incluir uma subexpressão, REGEXP\$1INSTR corresponderá uma subsequência usando a primeira subexpressão em *padrão*. REGEXP\$1INSTR considera apenas a primeira subexpressão. As subexpressões adicionais são ignoradas. Se o padrão não tiver uma subexpressão, REGEXP\$1INSTR ignorará o parâmetro 'e'.
+ p — Interpreta o padrão com o dialeto de expressão regular compatível com Perl (PCRE - Perl Compatible Regular Expression).
## Tipo de retorno
Inteiro
## Exemplo
O seguinte exemplo procura pelo caractere `@` que inicia o nome de um domínio e retorna a posição inicial da primeira correspondência.
```
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
```
O seguinte exemplo procura por variações da palavra `Center` e retorna a posição inicial da primeira correspondência.
```
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
```
O exemplo a seguir encontra a posição inicial da primeira ocorrência da string `FOX` usando lógica de correspondência sem diferenciar maiúsculas de minúsculas.
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
O exemplo a seguir usa um padrão escrito em dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula. Ele usa o operador `?=`, que tem uma conotação específica look-ahead em PCRE. Este exemplo encontra a posição inicial da segunda palavra.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
regexp_instr
--------------
21
```
O exemplo a seguir usa um padrão escrito em dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula. Ele usa o operador `?=`, que tem uma conotação específica look-ahead em PCRE. Este exemplo localiza a posição inicial da segunda palavra, mas difere do exemplo anterior na medida em que usa correspondência sem diferenciar maiúsculas de minúsculas.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
regexp_instr
--------------
15
```
# Função REGEXP\$1REPLACE
Pesquisa uma string quanto a um padrão de expressão regular e substitui cada ocorrência do padrão pela string especificada. REGEXP\$1REPLACE é semelhante a [Função REPLACE](REPLACE.md), mas permite que você pesquise uma string quanto a um padrão de expressão regular.
REGEXP\$1REPLACE é semelhante a [Função TRANSLATE](TRANSLATE.md) e [Função REPLACE](REPLACE.md), exceto que TRANSLATE faz várias substituições de caractere único e REPLACE substitui uma string inteira por outra string, enquanto REGEXP\$1REPLACE permite que você pesquise uma string quanto a um padrão de expressão regular.
## Sintaxe
```
REGEXP_REPLACE ( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## Argumentos
*source\$1string*
Uma expressão de string, tal como um nome de coluna, a ser procurada.
*pattern*
Um literal de string que representa um padrão de expressão regular.
*replace\$1string*
Uma expressão de string, tal como um nome de coluna, que substituirá cada ocorrência do padrão. O padrão é uma string vazia ( "" ).
*position*
Um inteiro positivo que indica a posição em *source\$1string* para começar a pesquisar. A posição é baseada no número de caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples. O padrão é um. Se a *posição* for menor que 1, a pesquisa começará no primeiro caractere da *source\$1string*. Se *position* for maior que o número de caracteres na *source\$1string*, o resultado será *source\$1string*.
*parameters*
Uma ou mais literais de sequências que indicam como a função corresponde o padrão. Os valores possíveis são os seguintes:
+ c – Executa a correspondência diferenciando maiúsculas e minúsculas. O padrão é usar a correspondência diferenciando maiúsculas e minúsculas.
+ i – Executa a correspondência sem diferenciar maiúsculas de minúsculas.
+ p — Interpreta o padrão com o dialeto de expressão regular compatível com Perl (PCRE - Perl Compatible Regular Expression).
## Tipo de retorno
VARCHAR
Se *pattern* ou *replace\$1string* for NULL, o retorno será NULL.
## Exemplo
O seguinte exemplo exclui o `@` e o nome de domínio dos endereços de e-mail.
```
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
```
O seguinte exemplo substitui os nomes de domínio de endereços de e-mail por esse 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
```
O exemplo a seguir conta as ocorrências da string `FOX` no valor `quick brown fox` usando a correspondência sem diferenciar maiúsculas de minúsculas.
```
SELECT regexp_replace('the fox', 'FOX', 'quick brown fox', 1, 'i');
regexp_replace
---------------------
the quick brown fox
```
O exemplo a seguir usa um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula. Ele usa o operador `?=`, que tem uma conotação específica look-ahead em PCRE. Este exemplo substitui cada ocorrência de tal palavra pelo valor `[hidden]`.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
regexp_replace
-------------------------------
[hidden] plain A1234 [hidden]
```
O exemplo a seguir usa um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula. Ele usa o operador `?=`, que tem uma conotação específica look-ahead em PCRE. Este exemplo substitui cada ocorrência de tal palavra pelo valor`[hidden]`, mas difere do exemplo anterior na medida em que ele usa correspondência sem diferenciar maiúsculas de minúsculas.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
regexp_replace
----------------------------------
[hidden] plain [hidden] [hidden]
```
# Função REGEXP\$1SUBSTR
Retorna os caracteres de uma string ao procurar por um padrão de expressão regular. REGEXP\$1SUBSTR é semelhante a função [Função SUBSTRING](SUBSTRING.md), mas permite que você pesquise uma string quanto a um padrão de expressão regular. Se a função não conseguir corresponder a expressão regular com nenhum caractere na string, ela retornará uma string vazia.
## Sintaxe
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Argumentos
*source\$1string*
Uma expressão de string a ser pesquisada.
*pattern*
Um literal de string que representa um padrão de expressão regular.
*position*
Um inteiro positivo que indica a posição em *source\$1string* para começar a pesquisar. A posição é baseada no número de caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples. O padrão é um. Se a *posição* for menor que 1, a pesquisa começará no primeiro caractere da *source\$1string*. Se *position* for maior que o número de caracteres na *source\$1string*, o resultado será uma string vazia ("").
*occurrence*
Um inteiro positivo que indica qual ocorrência do padrão usar. REGEXP\$1SUBSTR ignora as primeiras correspondências de *occurrence* -1. O padrão é um. Se a *ocorrência* for menor que 1 ou maior que o número de caracteres em *source\$1string*, a pesquisa será ignorada e o resultado será NULL.
*parameters*
Uma ou mais literais de sequências que indicam como a função corresponde o padrão. Os valores possíveis são os seguintes:
+ c – Executa a correspondência diferenciando maiúsculas e minúsculas. O padrão é usar a correspondência diferenciando maiúsculas e minúsculas.
+ i – Executa a correspondência sem diferenciar maiúsculas de minúsculas.
+ e – Extrai uma subsequência usando uma subexpressão.
Se o *padrão* incluir uma subexpressão, REGEXP\$1SUBSTR corresponderá uma subsequência usando a primeira subexpressão em *padrão*. Uma subexpressão é uma expressão dentro do padrão que está entre parênteses. Por exemplo, para o padrão `'This is a (\\w+)'` faz correspondência com a primeira expressão com a string `'This is a '` seguida por uma palavra. Em vez de retornar o *padrão*, REGEXP\$1SUBSTR com o parâmetro `e` retorna somente a string dentro da subexpressão.
REGEXP\$1SUBSTR considera apenas a primeira subexpressão. As subexpressões adicionais são ignoradas. Se o padrão não tiver uma subexpressão, REGEXP\$1SUBSTR ignorará o parâmetro 'e'.
+ p — Interpreta o padrão com o dialeto de expressão regular compatível com Perl (PCRE - Perl Compatible Regular Expression).
## Tipo de retorno
VARCHAR
## Exemplo
O seguinte exemplo retorna a porção de um endereço de e-mail entre o caractere @ e a extensão de domínio.
```
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
```
O exemplo a seguir retorna a porção da entrada correspondente à primeira ocorrência da string `FOX` com a correspondência sem diferenciar maiúsculas de minúsculas.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
O exemplo a seguir retorna a primeira parte da entrada que começa com letras minúsculas. Isso é funcionalmente idêntico à mesma instrução SELECT sem o parâmetro `c`.
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
O exemplo a seguir usa um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula. Ele usa o operador `?=`, que tem uma conotação específica look-ahead em PCRE. Este exemplo retorna a parte da entrada correspondente à segunda palavra.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
O exemplo a seguir usa um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula. Ele usa o operador `?=`, que tem uma conotação específica look-ahead em PCRE. Este exemplo retorna a parte da entrada correspondente à segunda palavra, mas difere do exemplo anterior na medida em que usa a correspondência sem diferenciar maiúsculas de minúsculas.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
O exemplo a seguir usa uma subexpressão para encontrar a segunda string correspondente ao padrão `'this is a (\\w+)'` usando a correspondência que não diferencia letras maiúsculas de minúsculas. Ele retorna a subexpressão dentro dos parênteses.
```
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
```
# Função REPEAT
Repete uma string pelo número especificado de vezes. Se o parâmetro de entrada for numérico, REPEAT o tratará como uma string.
## Sintaxe
```
REPEAT(string, integer)
```
## Argumentos
*string*
O primeiro parâmetro de entrada é a string a ser repetida.
*inteiro*
O segundo parâmetro é um inteiro indicando o número de vezes a repetir a string.
## Tipo de retorno
A função REPEAT retorna uma string.
## Exemplos
O seguinte exemplo repete o valor da coluna CATID na tabela CATEGORY três vezes:
```
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)
```
# Função REPLACE
Substitui todas as ocorrências de um conjunto de caracteres em uma string existente por outros caracteres especificados.
REPLACE é semelhante a [Função TRANSLATE](TRANSLATE.md) e [Função REGEXP\$1REPLACE](REGEXP_REPLACE.md), exceto que TRANSLATE faz várias substituições de caractere único e REGEXP\$1REPLACE permite que você pesquise uma string quanto a um padrão de expressão regular, enquanto REPLACE substitui uma string inteira por outra string.
## Sintaxe
```
REPLACE(string1, old_chars, new_chars)
```
## Argumentos
*string*
String CHAR ou VARCHAR a ser procurada.
*old\$1chars*
String CHAR ou VARCHAR a substituir.
*new\$1chars*
Nova string CHAR ou VARCHAR que substitui *old\$1string*.
## Tipo de retorno
VARCHAR
Se *old\$1chars* ou *new\$1chars* for NULL, o retorno será NULL.
## Exemplos
O seguinte exemplo converte a string `Shows` em `Theatre` no 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)
```
# Função REVERSE
A função REVERSE opera em uma string e retorna os caracteres na ordem reversa. Por exemplo, `reverse('abcde')` retorna `edcba`. Essa função funciona em tipos de dados numéricos e de data, assim como nos tipos de dados de caracteres; no entanto, na maioria dos casos ela possui um valor prático para strings de caracteres.
## Sintaxe
```
REVERSE ( expression )
```
## Argumento
*expressão*
Uma expressão com um tipo de dados de caractere, data, timestamp ou numérico que representa o destino da reversão de caracteres. Todas as expressões são convertidas implicitamente em strings de comprimento variável. Os espaços em branco finais em strings de caracteres de largura fixa são ignorados.
## Tipo de retorno
REVERSE retorna um VARCHAR.
## Exemplos
Selecione cinco nomes de cidade distintos e seus nomes invertidos correspondentes da tabela 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)
```
Selecione cinco vendas IDs e seu IDs elenco invertido correspondente como sequências 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)
```
# Função RTRIM
A função RTRIM apara um conjunto específico de caracteres do final de uma string. Remove a string mais longa que contém somente caracteres que estão na lista de caracteres de corte. O corte é concluído quando um caractere de corte não aparece na string de entrada.
## Sintaxe
```
RTRIM( string, trim_chars )
```
## Argumentos
*string*
Uma coluna, expressão ou literal de string a ser cortado.
*trim\$1chars*
Uma coluna, expressão ou literal de string que representa os caracteres a serem cortados do final da *string*. Se não for especificado, um espaço será usado como caractere de corte.
## Tipo de retorno
Uma string no mesmo tipo de dados que o argumento da *string*.
## Exemplo
O seguinte exemplo apara espaços em branco inicias e finais da string `' abc '`:
```
select ' abc ' as untrim, rtrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
O exemplo a seguir remove a string `'xyz'` final da string `'xyzaxyzbxyzcxyz'`. As ocorrências iniciais de `'xyz'` são removidas, mas as ocorrências internas da string não são removidas.
```
select 'xyzaxyzbxyzcxyz' as untrim,
rtrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | xyzaxyzbxyzc
```
O exemplo a seguir remove as partes finais da string `'setuphistorycassettes'` que correspondem a qualquer um dos caracteres na lista *trim\$1chars* `'tes'`. Qualquer `t`, `e` ou `s` que ocorra antes que outro caractere que não esteja na lista *trim\$1chars* no final da string de entrada é removido.
```
SELECT rtrim('setuphistorycassettes', 'tes');
rtrim
-----------------
setuphistoryca
```
O seguinte exemplo apara os caracteres "Park" do final de VENUENAME, onde presente:
```
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
```
Observe que RTRIM remove qualquer um dos caracteres `P`, `a`, `r` ou `k` que aparecem no final de um VENUENAME.
# Função SPLIT
A função SPLIT permite extrair substrings de uma string maior e trabalhar com elas como uma matriz. A função SPLIT é útil quando você precisa dividir uma string em componentes individuais com base em um delimitador ou padrão específico.
## Sintaxe
```
split(str, regex, limit)
```
## Argumentos
*str*
Uma expressão de string para dividir.
*regex*
Uma string representando uma expressão regular. A string *regex* deve ser uma expressão regular Java.
*limit*
Uma expressão inteira que controla o número de vezes que o *regex é aplicado*.
+ limite > 0: o comprimento da matriz resultante não será maior que o limite, e a última entrada da matriz resultante conterá todas as entradas além da última *regex* correspondente.
+ limit <= 0: o *regex* será aplicado quantas vezes for possível, e a matriz resultante pode ser de qualquer tamanho.
## Tipo de retorno
A função SPLIT retorna um ARRAY.
Se`limit > 0`: O comprimento da matriz resultante não será maior que o limite, e a última entrada da matriz resultante conterá todas as entradas além da última regex correspondente.
If`limit <= 0`: regex será aplicado quantas vezes for possível e a matriz resultante poderá ser de qualquer tamanho.
## Exemplo
Neste exemplo, a função SPLIT divide a string de entrada `'oneAtwoBthreeC'` sempre que encontra os caracteres `'A'``'B'`, ou `'C'` (conforme especificado pelo padrão de expressão regular). `'[ABC]'` A saída resultante é uma matriz de quatro elementos:`"one"`, `"two"``"three"`, e uma string vazia`""`.
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# Função SPLIT\$1PART
Divide uma string no delimitador especificado e retorna a parte na posição especificada.
## Sintaxe
```
SPLIT_PART(string, delimiter, position)
```
## Argumentos
*string*
Uma coluna, expressão ou literal de string a ser dividido. A string pode ser CHAR ou VARCHAR.
*delimitador*
A string delimitadora que indica seções da *string* de entrada.
Se o *delimitador* for um literal, coloque-o entre aspas simples.
*position*
Posição da porção da *string* a retornar (contando de 1). Deve ser um número inteiro maior que 0. Se *position* for maior que o número de porções de string, SPLIT\$1PART retornará uma string vazia. Se *delimiter* não for encontrado em *string*, o valor retornado conterá o conteúdo da parte especificada, que poderá ser toda a *string* ou um valor vazio.
## Tipo de retorno
Uma string CHAR ou VARCHAR, o mesmo que o parâmetro da *string*.
## Exemplos
O exemplo a seguir divide uma string literal em partes usando o delimitador `$` e retorna a segunda parte.
```
select split_part('abc$def$ghi','$',2)
split_part
----------
def
```
O exemplo a seguir divide uma string literal em partes usando o delimitador `$`. Ele retorna uma string vazia porque a parte `4` não foi encontrada.
```
select split_part('abc$def$ghi','$',4)
split_part
----------
```
O exemplo a seguir divide uma string literal em partes usando o delimitador `#`. Ele retorna a string inteira, que é a primeira parte, porque o delimitador não foi encontrado.
```
select split_part('abc$def$ghi','#',1)
split_part
------------
abc$def$ghi
```
O exemplo a seguir divide o campo de timestamp LISTTIME em componentes de ano, mês e dia.
```
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
```
O seguinte exemplo seleciona o campo de timestamp LISTTIME e o divide no caractere `'-'` para obter o mês (a segunda parte da string LISTTIME) e, então, conta o número de entradas para cada mês:
```
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
```
# Função SUBSTRING
Retorna o subconjunto de uma string com base na posição inicial especificada da string.
Se a entrada for uma cadeia de caracteres, a posição inicial e o número de caracteres extraídos são baseados nos caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples. Se a entrada for uma expressão binária, a posição inicial e a substring extraída são baseadas em bytes. Você não pode especificar um comprimento negativo, mas pode especificar uma posição inicial negativa.
## Sintaxe
```
SUBSTRING(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Argumentos
*cadeia de caracteres*
A string a ser pesquisada. Tipos de dados não caracteres são tratados como uma string.
*start\$1position*
A posição dentro da sequência para começar a extração, começando em 1. A *start\$1position* é baseada no número de caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples. Esse número pode ser negativo.
*caracteres numéricos*
O número de caracteres a extrair (o comprimento da substring). Os *caracteres numéricos* são baseados no número de caracteres, não em bytes, de modo que os caracteres de vários bytes sejam contados como caracteres únicos. Esse número não pode ser negativo.
*start\$1byte*
A posição dentro da expressão binária para começar a extração, começando por 1. Esse número pode ser negativo.
*número de bytes*
O número de bytes a serem extraídos, ou seja, o comprimento da substring. Esse número não pode ser negativo.
## Tipo de retorno
VARCHAR
## Notas de uso para cadeias de caracteres
O seguinte exemplo retorna uma string de quatro caracteres começando com o sexto caractere.
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
*Se os caracteres *start\$1position* \$1 *numbecharacters* excederem o comprimento da *string, SUBSTRING retornará uma substring* começando da start\$1position até o final da string.* Por exemplo:
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
Se `start_position` for negativa ou 0, a função SUBSTRING retornará uma substring começando no primeiro caractere da string com um comprimento de `start_position` \$1 `numbecharacters` -1. Por exemplo:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Se `start_position` \$1 `numbecharacters` -1 for menor ou igual a zero, a SUBSTRING retornará uma string vazia. Por exemplo:
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## Exemplos
O seguinte exemplo retorna o mês da string LISTTIME na tabela 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)
```
O seguinte exemplo é o mesmo que o exemplo acima, mas usa a opção 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)
```
Não é possível usar a SUBSTRING para extrair previsivelmente o prefixo de uma string que possa conter caracteres multibyte, pois é necessário especificar o comprimento de uma string multibyte com base no número de bytes, e não no número de caracteres. Para extrair o segmento inicial de uma sequência com base no comprimento em bytes, você pode CAST a string como VARCHAR (*byte\$1length*) para truncar a string, onde *byte\$1length* é o tamanho exigido. O seguinte exemplo extrai os primeiros cinco bytes da string `'Fourscore and seven'`.
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
O exemplo a seguir retorna o nome `Ana` que aparece após o último espaço na string de entrada `Silva, Ana`.
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# Função TRANSLATE
Para dada expressão, substitui todas as ocorrências dos caracteres especificados pelos substitutos especificados. Os caracteres existentes são mapeados aos caracteres de substituição pelas suas posições nos argumentos *characters\$1to\$1replace* e *characters\$1to\$1substitute*. Se mais caracteres estiverem especificados no argumento *characters\$1to\$1replace* que no argumento *characters\$1to\$1substitute*, os caracteres adicionais do argumento *characters\$1to\$1replace* serão omitidos do valor de retorno.
TRANSLATE é semelhante a [Função REPLACE](REPLACE.md) e [Função REGEXP\$1REPLACE](REGEXP_REPLACE.md), exceto que REPLACE substitui uma string inteira por outra string e REGEXP\$1REPLACE permite que você pesquise uma string quanto a um padrão de expressão regular, enquanto TRANSLATE faz várias substituições de caracteres simples.
Se qualquer um dos argumentos for nulo, o retorno será NULL.
## Sintaxe
```
TRANSLATE ( expression, characters_to_replace, characters_to_substitute )
```
## Argumentos
*expressão*
A expressão a ser traduzida.
*characters\$1to\$1replace*
Uma string contendo os caracteres a serem substituídos.
*characters\$1to\$1substitute*
Uma string contendo os caracteres a substituir.
## Tipo de retorno
VARCHAR
## Exemplos
O seguinte exemplo substitui vários caracteres em uma string:
```
select translate('mint tea', 'inea', 'osin');
translate
-----------
most tin
```
O seguinte exemplo substitui o sinal (@) por um ponto final para todos os valores em uma coluna:
```
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
```
O seguinte exemplo substitui espaços por sublinhados e remove pontos finais de todos os valores em uma coluna:
```
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
```
# Função TRIM
Apara uma string removendo os espaços em branco iniciais e finais ou removendo caracteres iniciais ou finais que correspondem a uma string opcional especificada.
## Sintaxe
```
TRIM( [ BOTH ] [ trim_chars FROM ] string
```
## Argumentos
*trim\$1chars*
(Opcional) Os caracteres a serem aparados da string. Se este parâmetro for omitido, espaços em branco serão aparados.
*string*
A string a ser aparada.
## Tipo de retorno
A função TRIM retorna uma string VARCHAR ou CHAR. Se você usar a função TRIM com um comando SQL, converte AWS Clean Rooms implicitamente os resultados em VARCHAR. Se você usar a função TRIM na lista SELECT para uma função SQL, AWS Clean Rooms isso não converte implicitamente os resultados e talvez seja necessário realizar uma conversão explícita para evitar um erro de incompatibilidade de tipos de dados. Consulte a [Função CAST](CAST_function.md) função para obter informações sobre conversões explícitas.
## Exemplo
O seguinte exemplo apara espaços em branco inicias e finais da string `' abc '`:
```
select ' abc ' as untrim, trim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
O seguinte exemplo remove as aspas duplas que cercam a string `"dog"`:
```
select trim('"' FROM '"dog"');
btrim
-------
dog
```
TRIM remove qualquer um dos caracteres em *trim\$1chars* quando eles aparecem no início da *string*. O seguinte exemplo apara os caracteres “C”, “D” e “G” quando eles aparecem no início de VENUENAME, que é uma coluna 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
```
# Função UPPER
Converte uma string em letras maiúsculas. UPPER é compatível com caracteres UTF-8 multibyte, até o máximo de quatro bytes por caractere.
## Sintaxe
```
UPPER(string)
```
## Argumentos
*string*
O parâmetro de entrada é uma string VARCHAR (ou qualquer outro tipo de dados, como CHAR, que pode ser convertido implicitamente para VARCHAR).
## Tipo de retorno
A função UPPER retorna uma string de caracteres que é o mesmo tipo de dados da string de entrada.
## Exemplos
O seguinte exemplo converte o campo CATNAME para maiú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)
```
# Função UUID
A função UUID gera um Identificador Único Universal (UUID).
UUIDs são identificadores globais exclusivos que são comumente usados para fornecer identificadores exclusivos para várias finalidades, como:
+ Identificação de registros de banco de dados ou outras entidades de dados.
+ Gerando nomes ou chaves exclusivos para arquivos, diretórios ou outros recursos.
+ Rastreamento e correlação de dados em sistemas distribuídos.
+ Fornecendo identificadores exclusivos para pacotes de rede, componentes de software ou outros ativos digitais.
A função UUID gera um valor de UUID que é exclusivo com uma probabilidade muito alta, mesmo em sistemas distribuídos e por longos períodos de tempo. UUIDs normalmente são gerados usando uma combinação do timestamp atual, do endereço de rede do computador e outros dados aleatórios ou pseudo-aleatórios, garantindo que é altamente improvável que cada UUID gerado entre em conflito com qualquer outro UUID.
No contexto de uma consulta SQL, a função UUID pode ser usada para gerar identificadores exclusivos para novos registros inseridos em um banco de dados ou para fornecer chaves exclusivas para particionamento de dados, indexação ou outras finalidades em que um identificador exclusivo seja necessário.
**nota**
A função UUID não é determinística.
## Sintaxe
```
uuid()
```
## Argumentos
A função UUID não aceita argumentos.
## Tipo de retorno
O UUID retorna uma string de identificador exclusivo universal (UUID). O valor é retornado como uma string canônica de 36 caracteres do UUID.
## Exemplo
O exemplo a seguir gera um Identificador Único Universal (UUID). A saída é uma string de 36 caracteres representando um identificador universal exclusivo.
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```