O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Funções de string
**Topics**
+ [Operador \$1\$1 (Concatenação)](r_concat_op.md)
+ [Função ASCII](r_ASCII.md)
+ [Função BPCHARCMP](r_BPCHARCMP.md)
+ [Função BTRIM](r_BTRIM.md)
+ [Função BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md)
+ [Função CHAR\$1LENGTH](r_CHAR_LENGTH.md)
+ [Função CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md)
+ [Função CHARINDEX](r_CHARINDEX.md)
+ [Função CHR](r_CHR.md)
+ [Função COLLATE](r_COLLATE.md)
+ [Função CONCAT](r_CONCAT.md)
+ [Função CRC32](crc32-function.md)
+ [Função DIFFERENCE](DIFFERENCE.md)
+ [Função INITCAP](r_INITCAP.md)
+ [Funções LEFT e RIGHT](r_LEFT.md)
+ [Função LEN](r_LEN.md)
+ [Função LENGTH](r_LENGTH.md)
+ [Função LOWER](r_LOWER.md)
+ [Funções LPAD e RPAD](r_LPAD.md)
+ [Função LTRIM](r_LTRIM.md)
+ [Função OCTETINDEX](OCTETINDEX.md)
+ [Função OCTET\$1LENGTH](r_OCTET_LENGTH.md)
+ [Função POSITION](r_POSITION.md)
+ [Função QUOTE\$1IDENT](r_QUOTE_IDENT.md)
+ [Função QUOTE\$1LITERAL](r_QUOTE_LITERAL.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](r_REPEAT.md)
+ [Função REPLACE](r_REPLACE.md)
+ [Função REPLICATE](r_REPLICATE.md)
+ [Função REVERSE](r_REVERSE.md)
+ [Função RTRIM](r_RTRIM.md)
+ [Função SOUNDEX](SOUNDEX.md)
+ [Função SPLIT\$1PART](SPLIT_PART.md)
+ [Função STRPOS](r_STRPOS.md)
+ [Função STRTOL](r_STRTOL.md)
+ [Função SUBSTRING](r_SUBSTRING.md)
+ [Função TEXTLEN](r_TEXTLEN.md)
+ [Função TRANSLATE](r_TRANSLATE.md)
+ [Função TRIM](r_TRIM.md)
+ [Função UPPER](r_UPPER.md)
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.
**Funções somente nó de liderança defasadas**
As seguintes funções de string estão defasadas, pois são executadas somente no nó líder. Para obter mais informações, consulte . [Função de apenas nó líder](c_SQL_functions_leader_node_only.md)
+ GET\$1BYTE
+ SET\$1BIT
+ SET\$1BYTE
+ TO\$1ASCII
# Operador \$1\$1 (Concatenação)
Concatena duas expressões em ambos os lados do símbolo `||` e retorna a expressão concatenada.
Similar a [Função CONCAT](r_CONCAT.md).
**nota**
Se uma ou ambas as expressões forem nulas, o resultado da concatenação será `NULL`.
## Sintaxe
```
expression1 || expression2
```
## Argumentos
*expression1*
Uma string `CHAR`, uma string `VARCHAR`, uma expressão binária ou uma expressão avaliada como um desses tipos.
*expression2*
Uma string `CHAR`, uma string `VARCHAR`, uma expressão binária ou uma expressão avaliada como um desses tipos.
## Tipo de retorno
O tipo retornado da string é o mesmo que o dos argumentos de entrada. Por exemplo, concatenar duas strings do tipo `VARCHAR` retorna uma string do tipo `VARCHAR`.
## Exemplos
Os exemplos a seguir usam as tabelas USERS e VENUE do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para concatenar os campos FIRSTNAME e LASTNAME da tabela USERS no banco de dados de amostra, use o exemplo a seguir.
```
SELECT (firstname || ' ' || lastname) as fullname
FROM users
ORDER BY 1
LIMIT 10;
+-----------------+
| fullname |
+-----------------+
| Aaron Banks |
| Aaron Booth |
| Aaron Browning |
| Aaron Burnett |
| Aaron Casey |
| Aaron Cash |
| Aaron Castro |
| Aaron Dickerson |
| Aaron Dixon |
| Aaron Dotson |
+-----------------+
```
Para concatenar colunas que possam conter nulos, use a expressão [Funções NVL e COALESCE](r_NVL_function.md). O exemplo a seguir usa NVL para retornar um `0` sempre que `NULL` for encontrado.
```
SELECT (venuename || ' seats ' || NVL(venueseats, 0)) as seating
FROM venue
WHERE venuestate = 'NV' or venuestate = 'NC'
ORDER BY 1
LIMIT 10;
+-------------------------------------+
| seating |
+-------------------------------------+
| Ballys Hotel seats 0 |
| Bank of America Stadium seats 73298 |
| Bellagio Hotel seats 0 |
| Caesars Palace seats 0 |
| Harrahs Hotel seats 0 |
| Hilton Hotel seats 0 |
| Luxor Hotel seats 0 |
| Mandalay Bay Hotel seats 0 |
| Mirage Hotel seats 0 |
| New York New York seats 0 |
+-------------------------------------+
```
# Função ASCII
A função ASCII retorna o código ASCII, ou o ponto de código Unicode, do primeiro caractere na string que você especificar. A função retornará `0` se a string estiver vazia. Será retornado `NULL` se a string for nula.
## Sintaxe
```
ASCII('string')
```
## Argumento
*string*
Uma string `CHAR` ou uma string `VARCHAR`.
## Tipo de retorno
INTEGER
## Exemplos
Para retornar `NULL`, use o exemplo a seguir. A função NULLIF retornará `NULL` se os dois argumentos forem iguais, então o argumento de entrada da função ASCII será `NULL`. Para obter mais informações, consulte [Função NULLIF](r_NULLIF_function.md).
```
SELECT ASCII(NULLIF('',''));
+-------+
| ascii |
+-------+
| NULL |
+-------+
```
Para retornar o código ASCII 0, use o exemplo a seguir.
```
SELECT ASCII('');
+-------+
| ascii |
+-------+
| 0 |
+-------+
```
Para retornar o código ASCII 97 para a primeira letra da palavra amazon, use o exemplo a seguir.
```
SELECT ASCII('amazon');
+-------+
| ascii |
+-------+
| 97 |
+-------+
```
Para retornar o código ASCII 65 para a primeira letra da palavra Amazon, use o exemplo a seguir.
```
SELECT ASCII('Amazon');
+-------+
| ascii |
+-------+
| 65 |
+-------+
```
# Função BPCHARCMP
Compara o valor de duas strings e retorna um número inteiro. Se as strings forem idênticas, a função retornará `0`. Se a primeira string for alfabeticamente posterior, a função retornará `1`. Se a segunda string for posterior, a função retornará `-1`.
Para caracteres multibyte, a comparação é baseada na codificação de byte.
Sinônimo de [Função BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md).
## Sintaxe
```
BPCHARCMP(string1, string2)
```
## Argumentos
*string1*
Uma string `CHAR` ou uma string `VARCHAR`.
*string2*
Uma string `CHAR` ou uma string `VARCHAR`.
## Tipo de retorno
INTEGER
## Exemplos
Os exemplos a seguir usam a tabela USERS do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para determinar se o primeiro nome de um usuário é alfabeticamente posterior ao sobrenome do usuário para as dez primeiras entradas na tabela USERS, use o exemplo a seguir. Para entradas em que a string de FIRSTNAME for alfabeticamente posterior à string de LASTNAME, a função retornará `1`. Se LASTNAME for alfabeticamente posterior a FIRSTNAME, a função retornará `-1`.
```
SELECT userid, firstname, lastname, BPCHARCMP(firstname, lastname)
FROM users
ORDER BY 1, 2, 3, 4
LIMIT 10;
+--------+-----------+-----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+-----------+-----------+
| 1 | Rafael | Taylor | -1 |
| 2 | Vladimir | Humphrey | 1 |
| 3 | Lars | Ratliff | -1 |
| 4 | Barry | Roy | -1 |
| 5 | Reagan | Hodge | 1 |
| 6 | Victor | Hernandez | 1 |
| 7 | Tamekah | Juarez | 1 |
| 8 | Colton | Roy | -1 |
| 9 | Mufutau | Watkins | -1 |
| 10 | Naida | Calderon | 1 |
+--------+-----------+-----------+-----------+
```
Para retornar todas as entradas na tabela USERS em que a função retorna `0`, use o exemplo a seguir. A função retorna `0` quando FIRSTNAME é idêntico a LASTNAME.
```
SELECT userid, firstname, lastname,
BPCHARCMP(firstname, lastname)
FROM users
WHERE BPCHARCMP(firstname, lastname)=0
ORDER BY 1, 2, 3, 4;
+--------+-----------+----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+----------+-----------+
| 62 | Chase | Chase | 0 |
| 4008 | Whitney | Whitney | 0 |
| 12516 | Graham | Graham | 0 |
| 13570 | Harper | Harper | 0 |
| 16712 | Cooper | Cooper | 0 |
| 18359 | Chase | Chase | 0 |
| 27530 | Bradley | Bradley | 0 |
| 31204 | Harding | Harding | 0 |
+--------+-----------+----------+-----------+
```
# 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 BTTEXT\$1PATTERN\$1CMP
Sinônimo da função BPCHARCMP.
Para mais detalhes, consulte [Função BPCHARCMP](r_BPCHARCMP.md).
# Função CHAR\$1LENGTH
Sinônimo da função LEN.
Consulte [Função LEN](r_LEN.md).
# Função CHARACTER\$1LENGTH
Sinônimo da função LEN.
Consulte [Função LEN](r_LEN.md).
# Função CHARINDEX
Retorna a localização da substring especificada dentro de uma string.
Consulte [Função POSITION](r_POSITION.md) e [Função STRPOS](r_STRPOS.md) para ver funções semelhantes.
## Sintaxe
```
CHARINDEX( substring, string )
```
## Argumentos
*substring*
A substring a procurar dentro da *string*.
*string*
A string ou coluna a ser procurada.
## Tipo de retorno
INTEGER
A função CHARINDEX retorna um `INTEGER` correspondente à posição da substring (baseada em um, 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. CHARINDEX retornará `0` se a substring não for localizada dentro da string.
## Exemplos
Para retornar a posição da string `fish` na palavra `dog`, use o exemplo a seguir.
```
SELECT CHARINDEX('fish', 'dog');
+-----------+
| charindex |
+-----------+
| 0 |
+-----------+
```
Para retornar a posição da string `fish` na palavra `dogfish`, use o exemplo a seguir.
```
SELECT CHARINDEX('fish', 'dogfish');
+-----------+
| charindex |
+-----------+
| 4 |
+-----------+
```
O exemplo a seguir usa a tabela SALES do exemplo de banco de dados TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para retornar o número de transações de vendas distinta com uma comissão acima de 999,00 da tabela SALES, use o exemplo a seguir. Esse comando conta comissões maiores que 999,00 verificando se o decimal está acima de quatro casas a partir do início do valor da comissão.
```
SELECT DISTINCT CHARINDEX('.', commission), COUNT (CHARINDEX('.', commission))
FROM sales
WHERE CHARINDEX('.', commission) > 4
GROUP BY CHARINDEX('.', commission)
ORDER BY 1,2;
+-----------+-------+
| charindex | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# Função CHR
A função CHR retorna o caractere que as corresponde ao valor de ponto do código ASCII especificado pelo parâmetro de entrada.
## Sintaxe
```
CHR(number)
```
## Argumento
*Número da*
O parâmetro de entrada é um `INTEGER` que representa um valor de ponto do código ASCII.
## Tipo de retorno
CHAR
A função CHR retornará uma string `CHAR` se um caractere ASCII corresponder ao valor de entrada. Se o número de entrada não tiver nenhuma correspondência ASCII, a função retornará `NULL`.
## Exemplos
Para retornar o caractere correspondente ao ponto 0 do código ASCII, use o exemplo a seguir. A função CHR retorna `NULL` para a entrada `0`.
```
SELECT CHR(0);
+-----+
| chr |
+-----+
| |
+-----+
```
Para retornar o caractere que corresponde ao ponto 65 do código ASCII, use o exemplo a seguir.
```
SELECT CHR(65);
+-----+
| chr |
+-----+
| A |
+-----+
```
Para retornar os nomes de eventos distintos que começam com um A maiúsculo (ponto de código ASCII 65), use o exemplo a seguir. O exemplo a seguir usa a tabela EVENT do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
```
SELECT DISTINCT eventname FROM event
WHERE SUBSTRING(eventname, 1, 1)=CHR(65) LIMIT 5;
+-----------------------+
| eventname |
+-----------------------+
| A Catered Affair |
| As You Like It |
| A Man For All Seasons |
| Alan Jackson |
| Armando Manzanero |
+-----------------------+
```
# Função COLLATE
A função COLATE substitui o agrupamento de uma coluna de string ou expressão.
Para obter informações sobre como criar tabelas usando o agrupamento de banco de dados, consulte [CRIAR TABELA](r_CREATE_TABLE_NEW.md).
Para obter informações sobre como criar banco de dados usando o agrupamento de banco de dados, consulte [CREATE DATABASE](r_CREATE_DATABASE.md).
## Sintaxe
```
COLLATE( string, 'case_sensitive' | 'cs' | 'case_insensitive' | 'ci');
```
## Argumentos
*string*
Uma coluna de string ou expressão que você deseja substituir.
*'case\$1sensitive'* \$1 *'cs'* \$1 *'case\$1insensitive'* \$1 *'ci'*
Uma constante de string de um nome de agrupamento. O Amazon Redshift permite somente os seguintes valores para esse parâmetro:
+ *case\$1sensitive*
+ *cs*
+ *case\$1insensitive*
+ *ci*
*case\$1sensitive* e *cs* são intercambiáveis e geram os mesmos resultados. Da mesma forma, *case\$1insensitive* e *ci* são intercambiáveis e geram os mesmos resultados.
## Tipo de retorno
A função COLLATE exibe `VARCHAR`, `CHAR` ou `SUPER` dependendo do primeiro tipo de expressão de entrada. Esta função altera apenas o agrupamento do primeiro argumento de entrada e não altera o seu valor de saída.
## Exemplos
Para criar a tabela T e definir a col1 na tabela T como `case_sensitive`, use o exemplo a seguir.
```
CREATE TABLE T ( col1 Varchar(20) COLLATE case_sensitive );
INSERT INTO T VALUES ('john'),('JOHN');
```
Quando você executa a primeira consulta, o Amazon Redshift retorna apenas `john`. Depois que a função COLLATE é executada em col1, o agrupamento se torna `case_insensitive`. A segunda consulta retorna `john` e `JOHN`.
```
SELECT * FROM T WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
+------+
SELECT * FROM T WHERE COLLATE(col1, 'case_insensitive') = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
```
Para criar a tabela A e definir a col1 na tabela A como `case_insensitive`, use o exemplo a seguir.
```
CREATE TABLE A ( col1 Varchar(20) COLLATE case_insensitive );
INSERT INTO A VALUES ('john'),('JOHN');
```
Quando você executa a primeira consulta, o Amazon Redshift retorna `john` e `JOHN`. Depois que a função COLLATE é executada em col1, o agrupamento se torna `case_sensitive`. A segunda consulta retorna somente `john`.
```
SELECT * FROM A WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
SELECT * FROM A WHERE COLLATE(col1, 'case_sensitive') = 'john';
+------+
| col1 |
+------+
| john |
+------+
```
# 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.
## 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, o Amazon Redshift tentará converter implicitamente o tipo de uma das expressões. Se os valores não puderem ser convertidos, será retornado um erro.
## Observações de uso
+ 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.
## 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';
?column?
-------------------
December 25, 2008
(1 row)
```
O exemplo a seguir usa uma função CONCAT aninhada dentro de outra função CONCAT para concatenar três strings:
```
SELECT CONCAT('Thursday, ', CONCAT('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Para concatenar colunas que possam conter NULLs, use [Funções NVL e COALESCE](r_NVL_function.md), que retorna determinado valor quando encontra NULL. 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)
```
O exemplo a seguir concatena duas expressões binárias. Onde `abc` é um valor binário (com uma representação hexadecimal de `616263`) e `def` é um valor binário (com representação hexadecimal de `646566`). O resultado é exibido automaticamente como a representação hexadecimal do valor binário.
```
SELECT CONCAT('abc'::VARBYTE, 'def'::VARBYTE);
concat
-------------------
616263646566
```
# Função CRC32
CRC32 é uma função usada para detecção de erros. A função usa um algoritmo CRC32 para detectar alterações entre os dados de origem e destino. A função CRC32 converte uma string de comprimento variável em uma string de 8 caracteres que é uma representação de texto de valor hexadecimal de uma sequência binária de 32 bits. Para detectar alterações entre os dados de origem e de destino, use a função CRC32 nos dados de origem e armazene a saída. Depois, use a função CRC32 nos dados de destino e compare essa saída com a dos dados de origem. As saídas serão as mesmas se os dados não tiverem sido modificados e serão diferentes se os dados forem modificados.
## Sintaxe
```
CRC32(string)
```
## Argumentos
*string*
Uma string `CHAR`, uma string `VARCHAR` ou uma expressão que é avaliada implicitamente como um tipo `CHAR` ou `VARCHAR`.
## Tipo de retorno
A função CRC32 retorna uma string 8 caracteres que é uma representação de texto de valor hexadecimal de uma sequência binária de 32 bits. A função CRC32 do Amazon Redshift é baseada em no polinomial CRC-32C.
## Exemplos
Para mostrar o valor de 8 bits da string `Amazon Redshift`.
```
SELECT CRC32('Amazon Redshift');
+----------+
| crc32 |
+----------+
| f2726906 |
+----------+
```
# Função DIFFERENCE
A função DIFFERENCE compara os códigos American Soundex de duas strings. A função retorna um `INTEGER` para indicar o número de caracteres correspondentes entre os códigos Soundex.
Um código Soundex é uma string com quatro caracteres. Um código Soundex representa como uma palavra soa em vez de como ela é escrita. Por exemplo, `Smith` e `Smyth` têm o mesmo código Soundex.
## Sintaxe
```
DIFFERENCE(string1, string2)
```
## Argumentos
*string1*
Uma string `CHAR`, uma string `VARCHAR` ou uma expressão que é avaliada implicitamente como um tipo `CHAR` ou `VARCHAR`.
*string2*
Uma string `CHAR`, uma string `VARCHAR` ou uma expressão que é avaliada implicitamente como um tipo `CHAR` ou `VARCHAR`.
## Tipo de retorno
INTEGER
A função DIFFERENCE retorna um valor `INTEGER` de 0 a 4 que conta o número de caracteres correspondentes nos códigos American Soundex das duas strings. Um código Soundex tem quatro caracteres, então a função DIFFERENCE retornará `4` quando todos os quatro caracteres dos valores do código American Soundex das strings forem iguais. DIFFERENCE retornará `0` se uma das duas strings estiver vazia. A função retornará `1` se nenhuma string contiver caracteres válidos. A função DIFFERENCE converte apenas caracteres ASCII em letras minúsculas ou maiúsculas em inglês, incluindo a–z e A–Z. A DIFFERENCE ignora outros caracteres.
## Exemplos
Para comparar os valores do Soundex das strings `%` e `@`, use o exemplo a seguir. A função retornará `1` porque nenhuma string contém caracteres válidos.
```
SELECT DIFFERENCE('%', '@');
+------------+
| difference |
+------------+
| 1 |
+------------+
```
Para comparar os valores do Soundex de `Amazon` e uma string vazia, use o exemplo a seguir. A função retornará `0` porque uma das duas strings está vazia.
```
SELECT DIFFERENCE('Amazon', '');
+------------+
| difference |
+------------+
| 0 |
+------------+
```
Para comparar os valores do Soundex das strings `Amazon` e `Ama`, use o exemplo a seguir. A função retornará `2` porque dois caracteres dos valores do Soundex das strings são iguais.
```
SELECT DIFFERENCE('Amazon', 'Ama');
+------------+
| difference |
+------------+
| 2 |
+------------+
```
Para comparar os valores do Soundex das strings `Amazon` e `+-*/%Amazon`, use o exemplo a seguir. A função retornará `4` porque todos os quatro caracteres dos valores do Soundex das strings são iguais. Observe que a função ignora os caracteres inválidos `+-*/%` na segunda string.
```
SELECT DIFFERENCE('Amazon', '+-*/%Amazon');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
Para comparar os valores do Soundex das strings `AC/DC` e `Ay See Dee See`, use o exemplo a seguir. A função retornará `4` porque todos os quatro caracteres dos valores do Soundex das strings são iguais.
```
SELECT DIFFERENCE('AC/DC', 'Ay See Dee See');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
# Função INITCAP
Capitaliza a primeira letra de cada palavra de uma string especificada. INITCAP é compatível com caracteres UTF-8 multibyte, até o máximo de quatro bytes por caractere.
## Sintaxe
```
INITCAP(string)
```
## Argumento
*string*
Uma string `CHAR`, uma string `VARCHAR` ou uma expressão que é avaliada implicitamente como um tipo `CHAR` ou `VARCHAR`.
## Tipo de retorno
VARCHAR
## Observações de uso
A função INITCAP transforma em maiúscula a primeira letra de cada palavra em uma string e quaisquer letras subsequentes são transformadas (ou deixadas) em minúsculo. Portanto, é importante compreender quais caracteres (além de caracteres de espaço) funcionam como separadores de palavras. Um caractere *separador de palavras* é qualquer caractere não alfanumérico, incluindo marcas de pontuação, símbolos e caracteres de controle. Todos os seguintes caracteres são separadores de palavras:
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Guias, caracteres de nova linha, alimentações de formulário e retornos de carro também são separadores de palavras.
## Exemplos
Os exemplos a seguir usam dados da tabela CATEGORY e USERS do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para capitalizar as iniciais de cada palavra na coluna CATDESC, use o exemplo a seguir.
```
SELECT catid, catdesc, INITCAP(catdesc)
FROM category
ORDER BY 1, 2, 3;
+-------+--------------------------------------------+--------------------------------------------+
| catid | catdesc | initcap |
+-------+--------------------------------------------+--------------------------------------------+
| 1 | Major League Baseball | Major League Baseball |
| 2 | National Hockey League | National Hockey League |
| 3 | National Football League | National Football League |
| 4 | National Basketball Association | National Basketball Association |
| 5 | Major League Soccer | Major League Soccer |
| 6 | Musical theatre | Musical Theatre |
| 7 | All non-musical theatre | All Non-Musical Theatre |
| 8 | All opera and light opera | All Opera And Light Opera |
| 9 | All rock and pop music concerts | All Rock And Pop Music Concerts |
| 10 | All jazz singers and bands | All Jazz Singers And Bands |
| 11 | All symphony, concerto, and choir concerts | All Symphony, Concerto, And Choir Concerts |
+-------+--------------------------------------------+--------------------------------------------+
```
Para mostrar que a função INITCAP não preserva caracteres maiúsculos quando eles não começam palavras, use o exemplo a seguir. Por exemplo, a string `MLB` torna-se `Mlb`.
```
SELECT INITCAP(catname)
FROM category
ORDER BY catname;
+-----------+
| initcap |
+-----------+
| Classical |
| Jazz |
| Mlb |
| Mls |
| Musicals |
| Nba |
| Nfl |
| Nhl |
| Opera |
| Plays |
| Pop |
+-----------+
```
Para mostrar que caracteres não alfanuméricos, exceto espaços, funcionam como separadores de palavras, use o exemplo a seguir. Várias letras em cada string serão maiúsculas.
```
SELECT email, INITCAP(email)
FROM users
ORDER BY userid DESC LIMIT 5;
+------------------------------------+------------------------------------+
| email | initcap |
+------------------------------------+------------------------------------+
| urna.Ut@egetdictumplacerat.edu | Urna.Ut@Egetdictumplacerat.Edu |
| nibh.enim@egestas.ca | Nibh.Enim@Egestas.Ca |
| in@Donecat.ca | In@Donecat.Ca |
| sodales@blanditviverraDonec.ca | Sodales@Blanditviverradonec.Ca |
| sociis.natoque.penatibus@vitae.org | Sociis.Natoque.Penatibus@Vitae.Org |
+------------------------------------+------------------------------------+
```
# 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*
Uma string `CHAR`, uma string `VARCHAR` ou qualquer expressão que seja avaliada como uma string `CHAR` ou `VARCHAR`.
*integer*
Um inteiro positivo.
## Tipo de retorno
VARCHAR
## Exemplos
O exemplo a seguir usa dados da tabela EVENT do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para retornar os cinco caracteres mais à esquerda e os cinco caracteres mais à direita dos nomes de eventos com IDs entre 1000 e 1005, use o exemplo a seguir.
```
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 |
+---------+----------------+--------+---------+
```
# Função LEN
Retorna o tamanho da string especificada como número de caracteres.
## Sintaxe
LEN é um sinônimo de [Função LENGTH](r_LENGTH.md), [Função CHAR\$1LENGTH](r_CHAR_LENGTH.md), [Função CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md) e [Função TEXTLEN](r_TEXTLEN.md).
```
LEN(expression)
```
## Argumento
*expressão*
Uma string `CHAR`, uma string `VARCHAR`, uma expressão `VARBYTE` ou uma expressão que é avaliada implicitamente como um tipo `CHAR`, `VARCHAR` ou `VARBYTE`.
## Tipo de retorno
INTEGER
A função LEN retorna um inteiro indicando o número de caracteres em string de entrada.
Se a string de entrada for uma cadeia de caracteres, a função LEN retornará o número real de caracteres em strings multibyte, e não o número de bytes. Por exemplo, uma coluna `VARCHAR(12)` deve armazenar três caracteres chineses de quatro bytes. A função LEN retornará `3` para essa mesma string. Para obter o tamanho de uma string em bytes, use a função [OCTET\$1LENGTH](r_OCTET_LENGTH.md).
## Observações de uso
Se a *expressão* for uma string `CHAR`, os espaços finais não serão contados.
Se a *expressão* for uma string `VARCHAR`, os espaços finais serão contados.
## Exemplos
Para retornar o número de bytes e o número de caracteres na string `français`, use o exemplo a seguir.
```
SELECT OCTET_LENGTH('français'),
LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Para retornar o número de bytes e o número de caracteres na string `français` sem usar a função OCTET\$1LENGTH, use o exemplo a seguir. Para obter mais informações, consulte a [Função CAST](r_CAST_function.md).
```
SELECT LEN(CAST('français' AS VARBYTE)) as bytes, LEN('français');
+-------+-----+
| bytes | len |
+-------+-----+
| 9 | 8 |
+-------+-----+
```
Para retornar o número de caracteres nas strings `cat` sem espaços finais, `cat ` com três espaços finais, `cat ` com três espaços finais lançados como um `CHAR` de comprimento 6 e `cat ` com três espaços finais lançados como um `VARCHAR` de comprimento 6, use o exemplo a seguir. Observe que a função não conta os espaços finais para strings `CHAR`, mas conta esses espaços para strings `VARCHAR`.
```
SELECT LEN('cat'), LEN('cat '), LEN(CAST('cat ' AS CHAR(6))) AS len_char, LEN(CAST('cat ' AS VARCHAR(6))) AS len_varchar;
+-----+-----+----------+-------------+
| len | len | len_char | len_varchar |
+-----+-----+----------+-------------+
| 3 | 6 | 3 | 6 |
+-----+-----+----------+-------------+
```
O exemplo a seguir usa dados da tabela VENUE do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para retornar os dez nomes de locais mais longos na tabela VENUE, use o exemplo a seguir.
```
SELECT venuename, LEN(venuename)
FROM venue
ORDER BY 2 DESC, 1
LIMIT 10;
+-----------------------------------------+-----+
| venuename | len |
+-----------------------------------------+-----+
| Saratoga Springs Performing Arts Center | 39 |
| Lincoln Center for the Performing Arts | 38 |
| Nassau Veterans Memorial Coliseum | 33 |
| Jacksonville Municipal Stadium | 30 |
| Rangers BallPark in Arlington | 29 |
| University of Phoenix Stadium | 29 |
| Circle in the Square Theatre | 28 |
| Hubert H. Humphrey Metrodome | 28 |
| Oriole Park at Camden Yards | 27 |
| Dick's Sporting Goods Park | 26 |
+-----------------------------------------+-----+
```
# Função LENGTH
Sinônimo da função LEN.
Consulte [Função LEN](r_LEN.md).
# 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*
Uma string `VARCHAR` ou uma expressão que avalia como o tipo `VARCHAR`.
## Tipo de retorno
string
A função LOWER retorna uma string do mesmo tipo de dados que a string de entrada. Por exemplo, se a entrada for uma string `CHAR`, a função retornará uma string `CHAR`.
## Exemplos
O exemplo a seguir usa dados da tabela CATEGORY do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para converter as strings `VARCHAR` na coluna CATNAME em letras minúsculas, use o exemplo a seguir.
```
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 |
+-----------+-----------+
```
# 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 `CHAR`, uma string `VARCHAR` ou uma expressão que é avaliada implicitamente como um tipo `CHAR` ou `VARCHAR`.
*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 zero ou um número negativo, o resultado da função será uma string vazia.
*string2*
(Opcional) Um ou mais caracteres inseridos no início ou no fim da *string1*. Se esse argumento não é especificado, são usados espaços.
## Tipo de retorno
VARCHAR
## Exemplos
Os exemplos a seguir usam dados da tabela EVENT do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para truncar um conjunto específico de nomes de eventos para 20 caracteres e inserir espaços no início dos nomes mais curtos, use o exemplo a seguir.
```
SELECT LPAD(eventname, 20) FROM event
WHERE eventid BETWEEN 1 AND 5 ORDER BY 1;
+---------------------+
| lpad |
+---------------------+
| Salome |
| Il Trovatore |
| Boris Godunov |
| Gotterdammerung |
|La Cenerentola (Cind |
+-----------------------+
```
Para truncar o mesmo conjunto de nomes de eventos para 20 caracteres, mas inserir `0123456789` no início dos nomes mais curtos, use o exemplo a seguir.
```
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 |
+----------------------+
```
# 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 nenhum caractere de corte 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 OCTETINDEX
A função OCTETINDEX retorna a localização de uma substring dentro de uma string como um número de bytes.
## Sintaxe
```
OCTETINDEX(substring, string)
```
## Argumentos
*substring*
Uma string `CHAR`, uma string `VARCHAR` ou uma expressão que é avaliada implicitamente como um tipo `CHAR` ou `VARCHAR`.
*string*
Uma string `CHAR`, uma string `VARCHAR` ou uma expressão que é avaliada implicitamente como um tipo `CHAR` ou `VARCHAR`.
## Tipo de retorno
INTEGER
A função OCTETINDEX exibe um valor `INTEGER` correspondente à posição da *substring* dentro da *string* como um número de bytes, em que o primeiro caractere na *string* é contado como 1. Se a *string* não contiver caracteres multibyte, o resultado será igual ao resultado da função CHARINDEX. Se a *string* não contiver a *substring*, a função retornará `0`. Se a *substring* estiver vazia, a função retornará `1`.
## Exemplos
Para exibir a posição da substring `q` na string `Amazon Redshift`, use o exemplo a seguir. Esse exemplo retornará `0` porque a *substring* não está na *string*.
```
SELECT OCTETINDEX('q', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 0 |
+------------+
```
Para exibir a posição de uma substring vazia na string `Amazon Redshift`, use o exemplo a seguir. Este exemplo retornará `1` porque a *substring* está vazia.
```
SELECT OCTETINDEX('', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 1 |
+------------+
```
Para exibir a posição da substring `Redshift` na string `Amazon Redshift`, use o exemplo a seguir. Esse exemplo retorna `8` porque a *substring* começa no oitavo byte da *string*.
```
SELECT OCTETINDEX('Redshift', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 8 |
+------------+
```
Para exibir a posição da substring `Redshift` na string `Amazon Redshift`, use o exemplo a seguir. O exemplo a seguir retorna `21` porque os primeiros seis caracteres da *string* são caracteres de byte duplo.
```
SELECT OCTETINDEX('Redshift', 'Άμαζον Amazon Redshift');
+------------+
| octetindex |
+------------+
| 21 |
+------------+
```
# Função OCTET\$1LENGTH
Retorna o tamanho da string especificada como número de bytes.
## Sintaxe
```
OCTET_LENGTH(expression)
```
## Argumento
*expressão*
Uma string `CHAR`, uma string `VARCHAR`, uma expressão `VARBYTE` ou uma expressão que é avaliada implicitamente como um tipo `CHAR`, `VARCHAR` ou `VARBYTE`.
## Tipo de retorno
INTEGER
A função OCTET\$1LENGTH retorna um número inteiro indicando o número de bytes na string de entrada.
Se a string de entrada for uma cadeia de caracteres, a função [LEN](r_LEN.md) retornará o número real de caracteres em strings multibyte, e não o número de bytes. Por exemplo, uma coluna `VARCHAR(12)` deve armazenar três caracteres chineses de quatro bytes. A função OCTET\$1LENGTH retornará `12` para essa string, e a função LEN retornará `3` para essa mesma string.
## Observações de uso
Se a *expressão* for uma string `CHAR`, a função retornará o comprimento da string `CHAR`. Por exemplo, a saída de uma entrada `CHAR(6)` é `CHAR(6)`.
Se a *expressão* for uma string `VARCHAR`, os espaços finais serão contados.
## Exemplos
Para retornar o número de bytes quando a string `francais` com três espaços finais é lançada em um tipo `CHAR` e `VARCHAR`, use o exemplo a seguir. Para obter mais informações, consulte a [Função CAST](r_CAST_function.md).
```
SELECT OCTET_LENGTH(CAST('francais ' AS CHAR(15))) AS octet_length_char, OCTET_LENGTH(CAST('francais ' AS VARCHAR(15))) AS octet_length_varchar;
+-------------------+----------------------+
| octet_length_char | octet_length_varchar |
+-------------------+----------------------+
| 15 | 11 |
+-------------------+----------------------+
```
Para retornar o número de bytes e o número de caracteres na string `français`, use o exemplo a seguir.
```
SELECT OCTET_LENGTH('français'), LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Para retornar o número de bytes quando a string `français` é transmitida como um `VARBYTE`, use o exemplo a seguir.
```
SELECT OCTET_LENGTH(CAST('français' AS VARBYTE));
+--------------+
| octet_length |
+--------------+
| 9 |
+--------------+
```
# Função POSITION
Retorna a localização da substring especificada dentro de uma string.
Consulte [Função CHARINDEX](r_CHARINDEX.md) e [Função STRPOS](r_STRPOS.md) para ver funções semelhantes.
## 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 `INTEGER` 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. POSITION retornará `0` se a substring não for localizada dentro da string.
## Exemplos
Para retornar a posição da string `fish` na palavra `dog`, use o exemplo a seguir.
```
SELECT POSITION('fish' IN 'dog');
+-----------+
| position |
+-----------+
| 0 |
+-----------+
```
Para retornar a posição da string `fish` na palavra `dogfish`, use o exemplo a seguir.
```
SELECT POSITION('fish' IN 'dogfish');
+-----------+
| position |
+-----------+
| 4 |
+-----------+
```
O exemplo a seguir usa a tabela SALES do exemplo de banco de dados TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para retornar o número de transações de vendas distinta com uma comissão acima de 999,00 da tabela SALES, use o exemplo a seguir. Esse comando conta comissões maiores que 999,00 verificando se o decimal está acima de quatro casas a partir do início do valor da comissão.
```
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 |
+-----------+-------+
```
# Função QUOTE\$1IDENT
A função QUOTE\$1IDENT retorna a string especificada como uma string entre aspas duplas iniciais e uma aspa dupla final. A saída da função pode ser usada como um identificador em uma instrução SQL. A função duplica apropriadamente quaisquer aspas duplas incorporadas.
QUOTE\$1IDENT adiciona aspas duplas apenas quando necessário para criar um identificador válido, quando a string contém caracteres não identificadores ou seria dobrada em minúsculas. Para sempre retornar uma sequência entre aspas simples, use [QUOTE\$1LITERAL](r_QUOTE_LITERAL.md).
## Sintaxe
```
QUOTE_IDENT(string)
```
## Argumento
*string*
Uma string `CHAR` ou `VARCHAR`.
## Tipo de retorno
A função QUOTE\$1IDENT retorna o mesmo tipo de string da entrada *string*.
## Exemplos
Para retornar a string `"CAT"` com aspas duplas, use o exemplo a seguir.
```
SELECT QUOTE_IDENT('"CAT"');
+-------------+
| quote_ident |
+-------------+
| """CAT""" |
+-------------+
```
O exemplo a seguir usa dados da tabela CATEGORY do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para retornar a coluna CATNAME entre aspas use o exemplo a seguir.
```
SELECT catid, QUOTE_IDENT(catname)
FROM category
ORDER BY 1,2;
+-------+-------------+
| catid | quote_ident |
+-------+-------------+
| 1 | "MLB" |
| 2 | "NHL" |
| 3 | "NFL" |
| 4 | "NBA" |
| 5 | "MLS" |
| 6 | "Musicals" |
| 7 | "Plays" |
| 8 | "Opera" |
| 9 | "Pop" |
| 10 | "Jazz" |
| 11 | "Classical" |
+-------+-------------+
```
# Função QUOTE\$1LITERAL
A função QUOTE\$1LITERAL retorna a string especificada como uma string entre aspas únicas para que ela possa ser usada como um literal de string em uma instrução SQL. Se o parâmetro de entrada for um número, QUOTE\$1LITERAL o tratará como uma string. Duplica apropriadamente quaisquer aspas simples e barras invertidas incorporadas.
## Sintaxe
```
QUOTE_LITERAL(string)
```
## Argumento
*string*
Uma string `CHAR` ou `VARCHAR`.
## Tipo de retorno
A função QUOTE\$1LITERAL retorna uma string `CHAR` ou `VARCHAR` do mesmo tipo de dados que a entrada *string*.
## Exemplos
Para retornar a string `''CAT''` com aspas SIMPLES, use o exemplo a seguir.
```
SELECT QUOTE_LITERAL('''CAT''');
+---------------+
| quote_literal |
+---------------+
| '''CAT''' |
+---------------+
```
Os exemplos a seguir usam dados da tabela CATEGORY do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para retornar a coluna CATNAME entre aspas únicas, use o exemplo a seguir.
```
SELECT catid, QUOTE_LITERAL(catname)
FROM category
ORDER BY 1,2;
+-------+---------------+
| catid | quote_literal |
+-------+---------------+
| 1 | 'MLB' |
| 2 | 'NHL' |
| 3 | 'NFL' |
| 4 | 'NBA' |
| 5 | 'MLS' |
| 6 | 'Musicals' |
| 7 | 'Plays' |
| 8 | 'Opera' |
| 9 | 'Pop' |
| 10 | 'Jazz' |
| 11 | 'Classical' |
+-------+---------------+
```
Para retornar a coluna CATID entre aspas únicas, use o exemplo a seguir.
```
SELECT QUOTE_LITERAL(catid), catname
FROM category
ORDER BY 1,2;
+---------------+-----------+
| quote_literal | catname |
+---------------+-----------+
| '1' | MLB |
| '10' | Jazz |
| '11' | Classical |
| '2' | NHL |
| '3' | NFL |
| '4' | NBA |
| '5' | MLS |
| '6' | Musicals |
| '7' | Plays |
| '8' | Opera |
| '9' | Pop |
+---------------+-----------+
```
# 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 especificado ocorre na string. Se nenhuma correspondência for encontrada, a função retornará `0`. Para ter mais informações sobre expressões regulares, consulte [Operadores POSIX](pattern-matching-conditions-posix.md) e [Expressão regular](https://en.wikipedia.org/wiki/Regular_expression) na Wikipédia.
## Sintaxe
```
REGEXP_COUNT( source_string, pattern [, position [, parameters ] ] )
```
## Argumentos
*source\$1string*
Uma string `CHAR` ou `VARCHAR`.
*Padrão*
Um literal de string UTF-8 que representa um padrão de expressão regular. Para obter mais informações, consulte [Operadores POSIX](pattern-matching-conditions-posix.md).
*position*
(Opcional) Um `INTEGER` 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 é `1`. Se a *posição* for menor que `1`, a pesquisa começará no primeiro caractere da *source\$1string*. Se a *posição* for maior que o número de caracteres na *source\$1string*, o resultado será `0`.
*parameters*
(Opcional) Uma ou mais literais de string que indicam como a função corresponde ao 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). Para ter mais informações sobre PCRE, consulte [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) na Wikipédia.
## Tipo de retorno
INTEGER
## Exemplos
Para contar o número de vezes em que uma sequência de três letras ocorre, use o exemplo a seguir.
```
SELECT REGEXP_COUNT('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------+
| regexp_count |
+--------------+
| 8 |
+--------------+
```
Para contar as ocorrências da string `FOX` usando correspondência sem diferenciar letras maiúsculas de minúsculas, use o exemplo a seguir.
```
SELECT REGEXP_COUNT('the fox', 'FOX', 1, 'i');
+--------------+
| regexp_count |
+--------------+
| 1 |
+--------------+
```
Para usar um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula, use o exemplo a seguir. O exemplo 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 |
+--------------+
```
Para usar um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula, use o exemplo a seguir. 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 |
+--------------+
```
O exemplo a seguir usa dados da tabela USERS do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para contar o número de vezes que nome de domínio de nível superior é `org` ou `edu`, use o exemplo a seguir.
```
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 |
+-----------------------------------------------+--------------+
```
# 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](r_POSITION.md), mas permite que você pesquise um padrão de expressão regular em uma sequência. Para ter mais informações sobre expressões regulares, consulte [Operadores POSIX](pattern-matching-conditions-posix.md) e [Expressão regular](https://en.wikipedia.org/wiki/Regular_expression) na Wikipédia.
## 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.
*Padrão*
Um literal de string UTF-8 que representa um padrão de expressão regular. Para obter mais informações, consulte [Operadores POSIX](pattern-matching-conditions-posix.md).
*position*
(Opcional) Um `INTEGER` 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 é `1`. Se a *posição* for menor que `1`, a pesquisa começará no primeiro caractere da *source\$1string*. Se a *posição* for maior que o número de caracteres na *source\$1string*, o resultado será `0`.
*occurrence*
(Opcional) Um `INTEGER` positivo que indica qual ocorrência do padrão usar. REGEXP\$1INSTR ignora as primeiras correspondências de `occurrence-1`. O padrão é `1`. 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á `0`.
*option*
(Opcional) 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*
(Opcional) Uma ou mais literais de string que indicam como a função corresponde ao 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). Para ter mais informações sobre PCRE, consulte [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) na Wikipédia.
## Tipo de retorno
Inteiro
## Exemplos
Os exemplos a seguir usam dados da tabela USERS do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para pesquisar o caractere `@` que inicia o nome de um domínio e retorna a posição de início da primeira correspondência, use o exemplo a seguir.
```
SELECT email, REGEXP_INSTR(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_instr |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 21 |
| Suspendisse.tristique@nonnisiAenean.edu | 22 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 17 |
| sed@lacusUtnec.ca | 4 |
+-----------------------------------------------+--------------+
```
Para pesquisar as variantes da palavra `Center` e retornar a posição inicial da primeira correspondência, use o exemplo a seguir.
```
SELECT venuename, REGEXP_INSTR(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE REGEXP_INSTR(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
+-----------------------+--------------+
| venuename | regexp_instr |
+-----------------------+--------------+
| The Home Depot Center | 16 |
| Izod Center | 6 |
| Wachovia Center | 10 |
| Air Canada Centre | 12 |
+-----------------------+--------------+
```
Para encontrar a posição inicial da primeira ocorrência da string `FOX`, utilizando a lógica de correspondência que não diferencia letras maiúsculas de minúsculas, use o exemplo a seguir.
```
SELECT REGEXP_INSTR('the fox', 'FOX', 1, 1, 0, 'i');
+--------------+
| regexp_instr |
+--------------+
| 5 |
+--------------+
```
Para usar um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula, use o exemplo a seguir. 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 |
+--------------+
```
Para usar um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula, use o exemplo a seguir. 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](r_REPLACE.md), mas permite que você pesquise uma string quanto a um padrão de expressão regular. Para ter mais informações sobre expressões regulares, consulte [Operadores POSIX](pattern-matching-conditions-posix.md) e [Expressão regular](https://en.wikipedia.org/wiki/Regular_expression) na Wikipédia.
REGEXP\$1REPLACE é semelhante a [Função TRANSLATE](r_TRANSLATE.md) e [Função REPLACE](r_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 `CHAR` ou `VARCHAR`, tal como um nome de coluna, a ser pesquisada.
*Padrão*
Um literal de string UTF-8 que representa um padrão de expressão regular. Para obter mais informações, consulte [Operadores POSIX](pattern-matching-conditions-posix.md).
*replace\$1string*
(Opcional) Uma expressão de string `CHAR` ou `VARCHAR`, tal como um nome de coluna, que substituirá cada ocorrência do padrão. O padrão é uma string vazia ( "" ).
*position*
(Opcional) 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 é `1`. 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*
(Opcional) Uma ou mais literais de string que indicam como a função corresponde ao 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). Para ter mais informações sobre PCRE, consulte [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) na Wikipédia.
## Tipo de retorno
VARCHAR
Se o *padrão* ou *replace\$1string* for `NULL`, a função retornará `NULL`.
## Exemplos
Para substituir todas as ocorrências da string `FOX` no valor `quick brown fox` usando a correspondência que não diferencia letras maiúsculas de minúsculas, use o exemplo a seguir.
```
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. Para substituir cada ocorrência de tal palavra pelo valor `[hidden]`, use o exemplo a seguir.
```
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. Para substituir cada ocorrência de tal palavra pelo valor `[hidden]`, mas que difere do exemplo anterior porque que ele usa correspondência sem diferenciar letras maiúsculas de minúsculas, use o exemplo a seguir.
```
SELECT REGEXP_REPLACE('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
+----------------------------------+
| regexp_replace |
+----------------------------------+
| [hidden] plain [hidden] [hidden] |
+----------------------------------+
```
Os exemplos a seguir usam dados da tabela USERS do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para excluir o `@` e o nome de domínio dos endereços de e-mail, use o exemplo a seguir.
```
SELECT email, REGEXP_REPLACE(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+-----------------------+
| email | regexp_replace |
+-----------------------------------------------+-----------------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero |
| Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique |
| amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut |
| sed@lacusUtnec.ca | sed |
+-----------------------------------------------+-----------------------+
```
Para substituir os nomes de domínio de endereços de e-mail por `internal.company.com`, use o exemplo a seguir.
```
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 |
+-----------------------------------------------+--------------------------------------------+
```
# 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](r_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. Para ter mais informações sobre expressões regulares, consulte [Operadores POSIX](pattern-matching-conditions-posix.md) e [Expressão regular](https://en.wikipedia.org/wiki/Regular_expression) na Wikipédia.
## Sintaxe
```
REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Argumentos
*source\$1string*
Uma expressão de string a ser pesquisada.
*Padrão*
Um literal de string UTF-8 que representa um padrão de expressão regular. Para obter mais informações, consulte [Operadores POSIX](pattern-matching-conditions-posix.md).
*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 é 1. 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 é 1. 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á vazio.
*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). Para ter mais informações sobre PCRE, consulte [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) na Wikipédia.
## Tipo de retorno
VARCHAR
## Exemplos
O seguinte exemplo retorna a porção de um endereço de e-mail entre o caractere @ e a extensão de domínio. Os dados de `users` consultados são dos dados de amostra do Amazon Redshift. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
Cum@accumsan.com | @accumsan
```
O exemplo a seguir retorna a porção da entrada correspondente à primeira ocorrência da string `FOX` com a correspondência sem diferenciar letras maiúsculas de minúsculas.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
O exemplo a seguir retorna a porção da entrada correspondente à segunda ocorrência da string `FOX` usando a correspondência que não diferencia letras maiúsculas de minúsculas. O resultado é vazio (não nulo, tamanho 0) porque não há uma segunda ocorrência.
```
SELECT regexp_substr('the fox', 'FOX', 1, 2, 'i');
regexp_substr
---------------
```
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.
Sinônimo de [Função REPLICATE](r_REPLICATE.md).
## Sintaxe
```
REPEAT(string, integer)
```
## Argumentos
*string*
O primeiro parâmetro de entrada é a string a ser repetida.
*integer*
O segundo parâmetro é um `INTEGER` indicando o número de vezes a repetir a string.
## Tipo de retorno
VARCHAR
## Exemplos
O exemplo a seguir usa dados da tabela CATEGORY do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para repetir o valor da coluna CATID na tabela CATEGORY três vezes, use o exemplo a seguir.
```
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 |
+-------+--------+
```
O exemplo a seguir demonstra a geração de strings de até 16 milhões de bytes:
```
SELECT
LEN(REPEAT('X', 5000000)) AS five_million_bytes,
LEN(REPEAT('Y', 16000000)) AS sixteen_million_bytes;
five_million_bytes | sixteen_million_bytes
----------+-----------
5000000 | 16000000
```
# 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](r_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(string, old_chars, new_chars)
```
## Argumentos
*string*
String `CHAR` ou `VARCHAR` a ser pesquisada
*old\$1chars*
A string `CHAR` ou `VARCHAR` a ser substituída.
*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 exemplo a seguir usa dados da tabela CATEGORY do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para converter a string `Shows` em `Theatre` no campo CATGROUP, use o exemplo a seguir.
```
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 |
+-------+----------+----------+
```
# Função REPLICATE
Sinônimo da função REPEAT.
Consulte [Função REPEAT](r_REPEAT.md).
# Função REVERSE
A função REVERSE opera em uma string e retorna os caracteres na ordem reversa. Por exemplo, `reverse('abcde')` exibe `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 `VARCHAR`. Espaços em branco finais em strings `CHAR` são ignorados.
## Tipo de retorno
VARCHAR
## Exemplos
Os exemplos a seguir usam dados da tabela USERS e SALES do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para selecionar cinco nomes de cidade distintos e seus nomes invertidos correspondentes da tabela USERS, use o exemplo a seguir.
```
SELECT DISTINCT city AS cityname, REVERSE(cityname)
FROM users
ORDER BY city LIMIT 5;
+----------+----------+
| cityname | reverse |
+----------+----------+
| Aberdeen | needrebA |
| Abilene | enelibA |
| Ada | adA |
| Agat | tagA |
| Agawam | mawagA |
+----------+----------+
```
Para selecionar cinco IDs de vendas e seus IDs invertidos correspondentes convertidos como strings de caracteres, use o exemplo a seguir.
```
SELECT salesid, REVERSE(salesid)
FROM sales
ORDER BY salesid DESC LIMIT 5;
+---------+---------+
| salesid | reverse |
+---------+---------+
| 172456 | 654271 |
| 172455 | 554271 |
| 172454 | 454271 |
| 172453 | 354271 |
| 172452 | 254271 |
+---------+---------+
```
# 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 nenhum caractere de corte 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 SOUNDEX
A função SOUNDEX retorna o valor American Soundex consistindo na primeira letra da string de entrada seguida de uma codificação de três dígitos dos sons que representam a pronúncia em inglês da string especificada. Por exemplo, `Smith` e `Smyth` têm o mesmo valor do Soundex.
## Sintaxe
```
SOUNDEX(string)
```
## Argumentos
*string*
Especificar uma string de caracteres `CHAR` ou `VARCHAR` que pretende converter em um valor de código American Soundex.
## Tipo de retorno
VARCHAR(4)
## Observações de uso
A função DIFFERENCE converte apenas caracteres ASCII em letras minúsculas ou maiúsculas em inglês, incluindo a–z e A–Z. SOUNDEX ignora outros caracteres. SOUNDEX retorna um único valor Soundex para uma string de várias palavras separadas por espaços.
```
SELECT SOUNDEX('AWS Amazon');
+---------+
| soundex |
+---------+
| A252 |
+---------+
```
SOUNDEX retorna uma string vazia se a string de entrada não contém letras inglesas.
```
SELECT SOUNDEX('+-*/%');
+---------+
| soundex |
+---------+
| |
+---------+
```
## Exemplos
Para retornar o valor do Soundex para `Amazon`, use o exemplo a seguir.
```
SELECT SOUNDEX('Amazon');
+---------+
| soundex |
+---------+
| A525 |
+---------+
```
Para retornar o valor do Soundex para `smith` e `smyth`, use o exemplo a seguir. Observe que os valores do Soundex são os mesmos.
```
SELECT SOUNDEX('smith'), SOUNDEX('smyth');
+-------+-------+
| smith | smyth |
+-------+-------+
| S530 | S530 |
+-------+-------+
```
# 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 STRPOS
Retorna a posição de uma substring em uma string especificada.
Consulte [Função CHARINDEX](r_CHARINDEX.md) e [Função POSITION](r_POSITION.md) para ver funções semelhantes.
## Sintaxe
```
STRPOS(string, substring )
```
## Argumentos
*string*
O primeiro parâmetro de entrada é a string `CHAR` ou `VARCHAR` a ser pesquisada.
*substring*
O segundo parâmetro é a substring a procurar dentro da *string*.
## Tipo de retorno
INTEGER
A função STRPOS retorna um `INTEGER` 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
STRPOS retornará `0` se a *substring* não for localizada dentro da *string*.
```
SELECT STRPOS('dogfish', 'fist');
+--------+
| strpos |
+--------+
| 0 |
+--------+
```
## Exemplos
Para mostrar a posição de `fish` em `dogfish`, use o exemplo a seguir.
```
SELECT STRPOS('dogfish', 'fish');
+--------+
| strpos |
+--------+
| 4 |
+--------+
```
O exemplo a seguir usa dados da tabela SALES do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para retornar o número de transações de vendas com uma COMMISSION acima de 999,00 da tabela SALES, use o exemplo a seguir.
```
SELECT DISTINCT STRPOS(commission, '.'),
COUNT (STRPOS(commission, '.'))
FROM sales
WHERE STRPOS(commission, '.') > 4
GROUP BY STRPOS(commission, '.')
ORDER BY 1, 2;
+--------+-------+
| strpos | count |
+--------+-------+
| 5 | 629 |
+--------+-------+
```
# Função STRTOL
Converte a expressão de string de um número da base especificada ao valor inteiro equivalente. O valor convertido deve estar dentro do intervalo de 64 bits assinado.
## Sintaxe
```
STRTOL(num_string, base)
```
## Argumentos
*num\$1string*
Expressão de string de um número a ser convertido. Se *num\$1string* estiver vazia ( `''` ) ou começar com o caractere nulo (`'\0'`), o valor convertido será `0`. Se *num\$1string* for uma coluna que contém um valor NULL, STRTOL retornará `NULL`. A string pode começar com qualquer quantidade de espaços em branco seguida, opcionalmente seguida por um sinal de mais ''`+`" ou menos ''`-`" para indicar positivo ou negativo. O padrão é '`+`'. Se *base* for `16`, a string pode opcionalmente começar com "`0x`".
*base*
`INTEGER` entre 2 e 36.
## Tipo de retorno
BIGINT
Se *num\$1string* for nulo, a função retornará `NULL`.
## Exemplos
Para converter pares de valores de string e base para números inteiros, use os exemplos a seguir.
```
SELECT STRTOL('0xf',16);
+--------+
| strtol |
+--------+
| 15 |
+--------+
SELECT STRTOL('abcd1234',16);
+------------+
| strtol |
+------------+
| 2882343476 |
+------------+
SELECT STRTOL('1234567', 10);
+---------+
| strtol |
+---------+
| 1234567 |
+---------+
SELECT STRTOL('1234567', 8);
+--------+
| strtol |
+--------+
| 342391 |
+--------+
SELECT STRTOL('110101', 2);
+--------+
| strtol |
+--------+
| 53 |
+--------+
SELECT STRTOL('\0', 2);
+--------+
| strtol |
+--------+
| 0 |
+--------+
```
# 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(character_string FROM start_position [ FOR number_characters ] )
```
```
SUBSTRING(character_string, start_position, number_characters )
```
```
SUBSTRING(binary_expression, start_byte, number_bytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Argumentos
*character\$1string*
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.
*number\$1characters*
O número de caracteres a extrair (o comprimento da substring). O *number\$1characters* é baseado no número de caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples. Esse número não pode ser negativo.
*binary\$1expression*
O binary\$1expression do tipo de dados VARBYTE a ser pesquisado.
*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.
*number\$1bytes*
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 ou VARBYTE, de acordo com a entrada.
## Observações sobre o uso
Veja a seguir alguns exemplos de como você pode usar *start\$1position* e *number\$1characters* para extrair substrings de várias posições em uma string.
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 *start\$1position* \$1 *number\$1characters* exceder o comprimento da *string*, SUBSTRING exibirá uma substring que começa na *start\$1position* e vai 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 `number_characters` -1. Por exemplo:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Se `start_position` \$1 `number_characters` -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 seguinte exemplo mostra uma posição inicial negativa de um valor binário `abc`. Como a posição inicial é -3, a substring é extraída do início do valor binário. O resultado é exibido automaticamente como a representação hexadecimal da substring binária.
```
select substring('abc'::varbyte, -3);
substring
-----------
616263
```
O seguinte exemplo mostra 1 para a posição inicial de um valor binário `abc`. Como não há tamanho especificado, a string é extraída da posição inicial até o final da string. O resultado é exibido automaticamente como a representação hexadecimal da substring binária.
```
select substring('abc'::varbyte, 1);
substring
-----------
616263
```
O exemplo a seguir mostra 3 para a posição inicial de um valor binário `abc`. Como não há tamanho especificado, a string é extraída da posição inicial até o final da string. O resultado é exibido automaticamente como a representação hexadecimal da substring binária.
```
select substring('abc'::varbyte, 3);
substring
-----------
63
```
O exemplo a seguir mostra 2 para a posição inicial de um valor binário `abc`. A string é extraída da posição inicial para a posição 10, mas o final da string está na posição 3. O resultado é exibido automaticamente como a representação hexadecimal da substring binária.
```
select substring('abc'::varbyte, 2, 10);
substring
-----------
6263
```
O exemplo a seguir mostra 2 para a posição inicial de um valor binário `abc`. A string é extraída da posição inicial por 1 byte. O resultado é exibido automaticamente como a representação hexadecimal da substring binária.
```
select substring('abc'::varbyte, 2, 1);
substring
-----------
62
```
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 TEXTLEN
Sinônimo da função LEN.
Consulte [Função LEN](r_LEN.md).
# 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](r_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
Para substituir vários caracteres em uma string, use o exemplo a seguir.
```
SELECT TRANSLATE('mint tea', 'inea', 'osin');
+-----------+
| translate |
+-----------+
| most tin |
+-----------+
```
Os exemplos a seguir usam dados da tabela USERS do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para substituir o sinal (@) por um ponto final para todos os valores de uma coluna, use o exemplo a seguir.
```
SELECT email, TRANSLATE(email, '@', '.') as obfuscated_email
FROM users LIMIT 10;
+---------------------------------------+---------------------------------------+
| email | obfuscated_email |
+---------------------------------------+---------------------------------------+
| Cum@accumsan.com | Cum.accumsan.com |
| lorem.ipsum@Vestibulumante.com | lorem.ipsum.Vestibulumante.com |
| non.justo.Proin@ametconsectetuer.edu | non.justo.Proin.ametconsectetuer.edu |
| non.ante.bibendum@porttitortellus.org | non.ante.bibendum.porttitortellus.org |
| eros@blanditatnisi.org | eros.blanditatnisi.org |
| augue@Donec.ca | augue.Donec.ca |
| cursus@pedeacurna.edu | cursus.pedeacurna.edu |
| at@Duis.com | at.Duis.com |
| quam@facilisisvitaeorci.ca | quam.facilisisvitaeorci.ca |
| mi.lorem@nunc.edu | mi.lorem.nunc.edu |
+---------------------------------------+---------------------------------------+
```
Para substituir espaços por sublinhados e remover pontos finais de todos os valores em uma coluna, use o exemplo a seguir.
```
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
Corta da string os espaços em branco ou caracteres especificados.
## Sintaxe
```
TRIM( [ BOTH | LEADING | TRAILING ] [trim_chars FROM ] string )
```
## Argumentos
BOTH \$1 LEADING \$1 TRAILING
(Opcional) Especifica de onde cortar os caracteres. Use BOTH para remover caracteres iniciais e finais, use LEADING para remover somente caracteres iniciais e use TRAILING para remover somente caracteres finais. Se esse parâmetro for omitido, os caracteres iniciais e finais serão cortados.
*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, o Amazon Redshift converterá implicitamente os resultados em `VARCHAR`. Se você usar a função TRIM na lista SELECT para uma função SQL, o Amazon Redshift não converterá implicitamente os resultados e poderá ser necessário realizar uma conversão explícita para evitar um erro de incompatibilidade de tipo de dados. Consulte as funções [Função CAST](r_CAST_function.md) e [Função CONVERT](r_CONVERT_function.md) para obter informações sobre conversões explícitas.
## Exemplos
Para remover espaços em branco inicias e finais da string ` dog `, use o exemplo a seguir.
```
SELECT TRIM(' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Para remover espaços em branco inicias e finais da string ` dog `, use o exemplo a seguir.
```
SELECT TRIM(BOTH FROM ' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Para remover as aspas duplas iniciais da string `"dog"`, use o exemplo a seguir.
```
SELECT TRIM(LEADING '"' FROM'"dog"');
+-------+
| ltrim |
+-------+
| dog" |
+-------+
```
Para remover as aspas duplas finais da string `"dog"`, use o exemplo a seguir.
```
SELECT TRIM(TRAILING '"' FROM'"dog"');
+-------+
| rtrim |
+-------+
| "dog |
+-------+
```
TRIM remove qualquer um dos caracteres em *trim\$1chars* quando eles aparecem no início ou no final da *string*. O exemplo a seguir apara os caracteres “C”, “D” e “G” quando eles aparecem no início de VENUENAME, que é uma coluna `VARCHAR`. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
```
SELECT venueid, venuename, TRIM('CDG' FROM venuename)
FROM venue
WHERE venuename LIKE '%Park'
ORDER BY 2
LIMIT 7;
+---------+----------------------------+---------------------------+
| venueid | venuename | btrim |
+---------+----------------------------+---------------------------+
| 121 | AT&T Park | AT&T Park |
| 109 | Citizens Bank Park | itizens Bank Park |
| 102 | Comerica Park | omerica Park |
| 9 | Dick's Sporting Goods Park | ick's Sporting Goods Park |
| 97 | Fenway Park | Fenway Park |
| 112 | Great American Ball Park | reat American Ball Park |
| 114 | Miller Park | Miller Park |
+---------+----------------------------+---------------------------+
```
# 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 em `VARCHAR`.
## Tipo de retorno
A função UPPER retorna uma string de caracteres que é o mesmo tipo de dados da string de entrada. Por exemplo, a função retornará uma string `VARCHAR` se a entrada for uma string `VARCHAR`.
## Exemplos
O exemplo a seguir usa dados da tabela CATEGORY do banco de dados de amostra TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
Para converter o campo CATNAME em maiúsculas, use o exemplo a seguir.
```
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 |
+-----------+-----------+
```