# Referência SQL para o Amazon S3 Select
<a name="s3-select-sql-reference"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Essa referência contém uma descrição de elementos de linguagem de consulta estruturada (SQL) que são compatíveis com o Amazon S3 Select.

**Topics**
+ [

# SELECTComando
](s3-select-sql-reference-select.md)
+ [

# Tipos de dados
](s3-select-sql-reference-data-types.md)
+ [

# Operadores
](s3-select-sql-reference-operators.md)
+ [

# Palavras-chave reservadas
](s3-select-sql-reference-keyword-list.md)
+ [

# Funções SQL
](s3-select-sql-reference-sql-functions.md)

# SELECTComando
<a name="s3-select-sql-reference-select"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

O Amazon S3 Select só oferece suporte ao comando SQL `SELECT`. As seguintes cláusulas padrão ANSI são compatíveis com `SELECT`: 


+ `SELECT` lista
+ `FROM`Cláusula 
+ `WHERE`Cláusula 
+ `LIMIT`Cláusula 

**nota**  
As consultas do Amazon S3 Select não oferecem suporte a subconsultas ou junções no momento.

## SELECT lista
<a name="s3-select-sql-reference-select-list"></a>

A lista `SELECT` nomeia as colunas, as funções e as expressões que a consulta deve retornar. A lista representa o resultado da consulta. 

```
SELECT *
SELECT projection1 AS column_alias_1, projection2 AS column_alias_2
```

O primeiro formulário de `SELECT` com o `*` (asterisco) retorna todas as linhas que passaram na cláusula `WHERE`, da maneira como estão. O segundo formulário de `SELECT` cria uma linha com as expressões escalares de saída definidas pelo usuário **`projection1`** e **`projection2`** para cada coluna.

## FROMCláusula
<a name="s3-select-sql-reference-from"></a>

O Amazon S3 Select oferece suporte aos seguintes formatos de cláusula `FROM`:

```
FROM table_name
FROM table_name alias
FROM table_name AS alias
```

Em cada forma da cláusula `FROM`, `table_name` é o `S3Object` que está sendo consultado. Os usuários provenientes de bancos de dados relacionais tradicionais podem pensar nisso como um esquema de banco de dados que contém várias visualizações em uma tabela.

Seguindo o SQL padrão, a cláusula `FROM` cria linhas filtradas na cláusula `WHERE` e projetadas na lista `SELECT`. 

Para objetos JSON armazenados no Amazon S3 Select, você também pode usar as seguintes formas da cláusula `FROM`:

```
FROM S3Object[*].path
FROM S3Object[*].path alias
FROM S3Object[*].path AS alias
```

Com essa forma da cláusula `FROM`, você pode selecionar entre matrizes ou objetos em um objeto JSON. É possível especificar `path` usando uma das formas a seguir:
+ Por nome (em um objeto): `.name` ou `['name']`
+ Por índice (em uma matriz): `[index]`
+ Por caractere curinga (em um objeto): `.*`
+ Por caractere curinga (em uma matriz): `[*]`

**nota**  
Essa forma da cláusula `FROM` funciona apenas com objetos JSON.
Caracteres curingas sempre emitem pelo menos um registro. Se não houver correspondência com nenhum registro, o Amazon S3 Select emitirá o valor `MISSING`. Durante a serialização de saída (após a execução da consulta), o Amazon S3 Select substituirá os valores `MISSING` por registros vazios.
Funções agregadas (`AVG`, `COUNT`, `MAX`, `MIN`, and `SUM`) ignoram valores `MISSING`.
Se não fornecer um alias ao usar um caractere curinga, você poderá consultar a linha usando o último elemento do caminho. Por exemplo, você pode selecionar todos os preços em uma lista de livros usando a consulta `SELECT price FROM S3Object[*].books[*].price`. Se o caminho terminar com um caractere curinga em vez de um nome, você poderá usar o valor `_1` para consultar a linha. Por exemplo, em vez de `SELECT price FROM S3Object[*].books[*].price`, você pode usar a consulta `SELECT _1.price FROM S3Object[*].books[*]`.
O Amazon S3 Select sempre trata um documento JSON como uma matriz de valores no nível da raiz. Dessa forma, mesmo se o objeto JSON que você estiver consultando tiver apenas um elemento raiz, a cláusula `FROM` deverá começar com `S3Object[*]`. No entanto, por razões de compatibilidade, o Amazon S3 Select permite omitir o caractere curinga caso você não inclua um caminho. Dessa forma, a cláusula completa `FROM S3Object` é equivalente a `FROM S3Object[*] as S3Object`. Se você incluir um caminho, também deverá usar o caractere curinga. Portanto, `FROM S3Object` e `FROM S3Object[*].path` são clausulas válidas, mas `FROM S3Object.path` não.

**Example**  
**Examples:**  
*Exemplo \$11*  
Este exemplo mostra resultados ao usar o seguinte conjunto de dados e consulta:  

```
{ "Rules": [ {"id": "1"}, {"expr": "y > x"}, {"id": "2", "expr": "z = DEBUG"} ]}
{ "created": "June 27", "modified": "July 6" }
```

```
SELECT id FROM S3Object[*].Rules[*].id
```

```
{"id":"1"}
{}
{"id":"2"}
{}
```
O Amazon S3 Select produz cada resultado pelos seguintes motivos:  
+ `{"id":"id-1"}`: `S3Object[0].Rules[0].id` produziu uma correspondência.
+ `{}`: `S3Object[0].Rules[1].id` não teve correspondência com um registro. Portanto, o Amazon S3 Select emitiu `MISSING`, que foi, então, alterado para um registro vazio durante a serialização de saída e retornou.
+ `{"id":"id-2"}`: `S3Object[0].Rules[2].id` produziu uma correspondência.
+ `{}`: `S3Object[1]` não teve correspondência em `Rules`. Portanto, o Amazon S3 Select emitiu `MISSING`, que foi, então, alterado para um registro vazio durante a serialização de saída e retornou.
Se você não quiser que o Amazon S3 Select retorne registros vazios quando não encontrar uma correspondência, você poderá testar o valor `MISSING`. A consulta a seguir retorna os mesmos resultados que a consulta anterior, mas com os valores vazios omitidos:  

```
SELECT id FROM S3Object[*].Rules[*].id WHERE id IS NOT MISSING
```

```
{"id":"1"}
{"id":"2"}
```
*Exemplo \$12*  
Este exemplo mostra resultados ao usar o seguinte conjunto de dados e consultas:  

```
{ "created": "936864000", "dir_name": "important_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": ".aws" }, { "name": "downloads" } ], "owner": "Amazon S3" }
{ "created": "936864000", "dir_name": "other_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": "my stuff" }, { "name": "backup" } ], "owner": "User" }
```

```
SELECT d.dir_name, d.files FROM S3Object[*] d
```

```
{"dir_name":"important_docs","files":[{"name":"."},{"name":".."},{"name":".aws"},{"name":"downloads"}]}
{"dir_name":"other_docs","files":[{"name":"."},{"name":".."},{"name":"my stuff"},{"name":"backup"}]}
```

```
SELECT _1.dir_name, _1.owner FROM S3Object[*]
```

```
{"dir_name":"important_docs","owner":"Amazon S3"}
{"dir_name":"other_docs","owner":"User"}
```

## WHERECláusula
<a name="s3-select-sql-reference-where"></a>

A cláusula `WHERE` segue esta sintaxe: 

```
WHERE condition
```

A cláusula `WHERE` filtra as linhas com base na `condition`. Uma condição é uma expressão com um valor booliano. Somente linhas para as quais a condição é avaliada como `TRUE` são retornadas no resultado.

## LIMITCláusula
<a name="s3-select-sql-reference-limit"></a>

A cláusula `LIMIT` segue esta sintaxe: 

```
LIMIT number
```

A cláusula `LIMIT` limita o número de registros que você deseja que a consulta retorne com base no `number`.

## Acesso ao atributo
<a name="s3-select-sql-reference-attribute-access"></a>

As cláusulas `SELECT` e `WHERE` podem se referir a dados de registro usando um dos métodos nas seções a seguir, dependendo se o arquivo que está sendo consultado está no formato CSV ou JSON.

### CSV
<a name="s3-select-sql-reference-attribute-access-csv"></a>
+ **Números da coluna**: você pode se referir à coluna *Nth* de uma linha com o nome da coluna `_N`, em que *`N`* é a posição da coluna. A contagem da posição começa em 1. Por exemplo, a primeira coluna é denominada `_1` e a segunda coluna é denominada `_2`.

  Você pode se referir a uma coluna como `_N` ou `alias._N`. Por exemplo, `_2` e `myAlias._2` são maneiras válidas de fazer referência a uma coluna na lista `SELECT` e na cláusula `WHERE`.
+ **Cabeçalhos da coluna** — Para objetos no formato CSV que possuem uma linha de cabeçalho, os cabeçalhos estão disponíveis para a lista `SELECT` e a cláusula `WHERE`. Especificamente, como no SQL tradicional, nas expressões de cláusula `SELECT` e `WHERE`, você pode consultar as colunas por `alias.column_name` ou `column_name`.

### JSON
<a name="s3-select-sql-reference-attribute-access-json"></a>
+ **Documento** — você pode acessar os campos do documentos JSON como `alias.name`. Também é possível acessar os campos aninhados, por exemplo, `alias.name1.name2.name3`.
+ **Lista**: é possível acessar elementos em uma lista JSON usando índices baseados em zero com o operador `[]`. Por exemplo, você pode acessar o segundo elemento de uma lista como `alias[1]`. É possível combinar elementos da lista de acesso com campos, por exemplo, `alias.name1.name2[1].name3`.
+ **Exemplos:** considere esse objeto JSON como um exemplo de conjunto de dados:

  ```
  {"name": "Susan Smith",
  "org": "engineering",
  "projects":
      [
       {"project_name":"project1", "completed":false},
       {"project_name":"project2", "completed":true}
      ]
  }
  ```

  *Exemplo \$11*

  A consulta a seguir retorna estes resultados:

  ```
  Select s.name from S3Object s
  ```

  ```
  {"name":"Susan Smith"}
  ```

  *Exemplo \$12*

  A consulta a seguir retorna estes resultados:

  ```
  Select s.projects[0].project_name from S3Object s
  ```

  ```
  {"project_name":"project1"}
  ```

## Diferenciação de letras maiúsculas e minúsculas de cabeçalho e nomes de atributo
<a name="s3-select-sql-reference-case-sensitivity"></a>

Com o Amazon S3 Select, você pode usar aspas duplas para indicar que cabeçalhos de coluna (para objetos CSV) e atributos (para objetos JSON) fazem diferenciação entre letras maiúsculas e minúsculas. Sem as aspas duplas, os cabeçalhos e atributos de objeto não diferenciam letras maiúsculas de minúsculas. Um erro ocorre em casos de ambiguidade.

Os exemplos a seguir são 1) objetos do Amazon S3 no formato CSV com os cabeçalhos de coluna especificados e com `FileHeaderInfo` definido como `"Use"` para a solicitação de consulta; ou 2) objetos do Amazon S3 no formato JSON com os atributos especificados.

*Exemplo 1:* o objeto consultado tem o cabeçalho ou atributo `NAME`.
+ A expressão a seguir retorna com êxito valores do objeto. Como não há aspas, a consulta não diferencia letras maiúsculas de minúsculas.

  ```
  SELECT s.name from S3Object s
  ```
+ A expressão a seguir resulta em um erro 400 `MissingHeaderName`. Como há aspas, a consulta diferencia letras maiúsculas de minúsculas. 

  ```
  SELECT s."name" from S3Object s
  ```

*Exemplo 2:* o objeto do Amazon S3 que está sendo consultado tem um cabeçalho ou atributo com `NAME` e outro cabeçalho/atributo com `name`.
+ A expressão a seguir resulta em um erro 400 `AmbiguousFieldName`. Como não há aspas, a consulta não diferencia letras maiúsculas de minúsculas, mas há duas correspondências, então o erro é gerado.

  ```
  SELECT s.name from S3Object s
  ```
+ A expressão a seguir retorna com êxito valores do objeto. Como há aspas, a consulta diferencia letras maiúsculas de minúsculas, portanto, não há ambiguidade.

  ```
  SELECT s."NAME" from S3Object s
  ```

## Usar palavras-chave reservadas como termos definidos pelo usuário
<a name="s3-select-sql-reference-using-keywords"></a>

O Amazon S3 Select possui um conjunto de palavras-chave reservadas que são necessárias para executar as expressões SQL usadas para consultar o conteúdo do objeto. As palavras-chave reservadas incluem nomes de função, tipos de dados, operadores, e assim por diante. Em alguns casos, os termos definidos pelo usuário como os cabeçalhos de coluna (para arquivos CSV) ou os atributos (para objetos JSON) podem entrar em conflito com uma palavra-chave reservada. Quando isso ocorrer, é necessário usar as aspas duplas para indicar que você está usando intencionalmente um termo definido pelo usuário que entra em conflito com uma palavra-chave reservada. Caso contrário, ocorrerá um erro de análise 400.

Para obter a lista completa de palavras-chave reservadas, consulte [Palavras-chave reservadas](s3-select-sql-reference-keyword-list.md).

O exemplo a seguir é 1) um objeto do Amazon S3 no formato CSV com os cabeçalhos de coluna especificados, com `FileHeaderInfo` definido como `"Use"` para a solicitação de consulta ou 2) um objeto do Amazon S3 no formato JSON com os atributos especificados.

*Exemplo:* o objeto consultado tem o cabeçalho ou atributo nomeado como `CAST`, que é uma palavra-chave reservada.
+ A expressão a seguir retorna com êxito valores do objeto. Como as aspas são usadas na consulta, o S3 Select usa o cabeçalho ou atributo definido pelo usuário.

  ```
  SELECT s."CAST" from S3Object s
  ```
+ A expressão a seguir resulta em um erro de análise 400. Como nenhuma aspa é usada na consulta, `CAST` colide com uma palavra-chave reservada.

  ```
  SELECT s.CAST from S3Object s
  ```

## Expressões escalares
<a name="s3-select-sql-reference-scalar"></a>

Na cláusula `WHERE` e na lista `SELECT`, você tem *expressões escalares* SQL, que são expressões que retornam valores escalares. Elas têm o seguinte formato:
+ ***`literal`*** 

  Um literal SQL. 
+ ***`column_reference`*** 

  Uma referência a uma coluna no formulário `column_name` ou `alias.column_name`. 
+ **`unary_op`** **`expression`** 

  Nesse caso, ****`unary_op`**** é um operador unário SQL.
+ **`expression`** **`binary_op`** ***`expression`*** 

   Nesse caso, ****`binary_op`**** é um operador binário SQL. 
+ **`func_name`** 

   Nesse caso, **`func_name`** é o nome da função escalar a ser invocada. 
+ ***`expression`*** `[ NOT ] BETWEEN` ****`expression`**** `AND` ****`expression`****
+ ***`expression`*** `LIKE` ****`expression`**** [ `ESCAPE` ***`expression`*** ]

# Tipos de dados
<a name="s3-select-sql-reference-data-types"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

O Amazon S3 Select oferece suporte a vários tipos de dados primitivos.

## Conversões de tipos de dados
<a name="s3-select-sql-reference-data-conversion"></a>

A regra geral é seguir a função `CAST` se for definida. Se `CAST` não estiver definido, todos os dados de entrada serão tratados como uma string. Nesse caso, é necessário converter seus dados de entrada em tipos de dados relevantes quando necessário.

Para obter mais informações sobre a função `CAST`, consulte [CAST](s3-select-sql-reference-conversion.md#s3-select-sql-reference-cast).

## Tipos de dados compatíveis
<a name="s3-select-sql-reference-supported-data-types"></a>

O Amazon S3 Select oferece suporte ao conjunto a seguir de tipos de dados primitivos.


|  Name (Nome)  |  Descrição  |  Exemplos  | 
| --- | --- | --- | 
| `bool` | Um valor booliano, `TRUE` ou `FALSE`. | `FALSE` | 
| `int`, `integer` | Um número inteiro assinado de 8 bytes no intervalo de -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807.  | `100000` | 
| `string` | Uma string de tamanho variável codificada por UTF8. O limite padrão é de um caractere. O limite máximo de caracteres é 2.147.483.647.  | `'xyz'` | 
| `float` | Um número de ponto flutuante de 8 bytes.  | `CAST(0.456 AS FLOAT)` | 
| `decimal`, `numeric` |  Um número de base 10, com precisão máxima de 38 (ou seja, a quantidade máxima de dígitos significativos) e com uma escala no intervalo de -231 a 231-1 (ou seja, o expoente de base 10).  O Amazon S3 Select ignora a escala e a precisão quando as duas são fornecidas ao mesmo tempo.   | `123.456 ` | 
| `timestamp` |  Os carimbos de data/hora representam um momento específico, sempre incluem um deslocamento local e são capazes de oferecer precisão arbitrária. No formato de texto, os carimbos de data/hora seguem a [nota W3C sobre formatos de data e hora](https://www.w3.org/TR/NOTE-datetime), mas devem terminar com o literal `T`, se os carimbos de data/hora não forem pelo menos a precisão de dia inteiro. As frações de segundos são permitidas, com pelo menos um dígito de precisão e um máximo ilimitado. Os deslocamentos de hora local podem ser representados como deslocamentos de hora:minuto em UTC ou como o literal `Z` para indicar uma hora local em UTC. Os deslocamentos de horário local são necessários em carimbos de data/hora com hora e não são permitidos em valores de data.  | `CAST('2007-04-05T14:30Z' AS TIMESTAMP)` | 

### Tipos compatíveis de Parquet
<a name="s3-select-sql-reference-supported-data-types-parquet"></a>

O Amazon S3 Select é compatível com os seguintes tipos de Parquet.
+ `DATE`
+ `DECIMAL`
+ `ENUM`
+ `INT(8)`
+ `INT(16)`
+ `INT(32)`
+ `INT(64)`
+ `LIST`
**nota**  
Para a saída do tipo `LIST` do Parquet, o Amazon S3 Select só é compatível com o formato JSON. No entanto, se a consulta limitar os dados a valores simples, o tipo de Parquet `LIST` também poderá ser consultado em formato CSV.
+ `STRING`
+ Precisão compatível de `TIMESTAMP` (`MILLIS`/`MICROS`/`NANOS`)
**nota**  
Não há compatibilidade com carimbos de data/hora salvos como `INT(96)`.   
Devido ao intervalo do tipo `INT(64)`, os carimbos de data/hora que usam a unidade `NANOS` só podem representar valores entre `1677-09-21 00:12:43` e `2262-04-11 23:47:16`. Valores fora desse intervalo não podem ser representados com a unidade `NANOS`.

### Mapeamento de tipos de Parquet para tipos de dados compatíveis no Amazon S3 Select
<a name="s3-select-sql-reference-supported-data-types-parquet-mapping"></a>


| Tipos do Parquet | Tipos de dados compatíveis | 
| --- | --- | 
| `DATE` |  `timestamp`  | 
|  `DECIMAL`  |  `decimal`, `numeric`  | 
|  `ENUM`  |  `string`  | 
|  `INT(8)`  |  `int`, `integer`  | 
|  `INT(16)`  | `int`, `integer` | 
| `INT(32)` | `int`, `integer` | 
|  `INT(64)`  |  `decimal`, `numeric`  | 
|  `LIST`  |  Cada tipo de Parquet na lista é mapeado para o tipo de dados correspondente.  | 
|  `STRING`  |  `string`  | 
|  `TIMESTAMP`  |  `timestamp`  | 

# Operadores
<a name="s3-select-sql-reference-operators"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

O Amazon S3 Select é compatível com os seguintes operadores.

## Operadores lógicos
<a name="s3-select-sql-reference-loical-ops"></a>
+ `AND`
+ `NOT`
+ `OR`

## Operadores de comparação
<a name="s3-select-sql-reference-compare-ops"></a>
+ `<` 
+ `>` 
+ `<=`
+ `>=`
+ `=`
+ `<>`
+ `!=`
+ `BETWEEN`
+ `IN` – Por exemplo: `IN ('a', 'b', 'c')`

  

## Operadores de correspondência de padrões
<a name="s3-select-sql-reference-pattern"></a>
+ `LIKE`
+ `_` (corresponde a qualquer caractere)
+ `%` (corresponde a qualquer sequência de caracteres)

## Operadores unitários
<a name="s3-select-sql-reference-unitary-ops"></a>
+ `IS NULL`
+ `IS NOT NULL`

## Operadores matemáticos
<a name="s3-select-sql-referencemath-ops"></a>

A adição, a subtração, a multiplicação, a divisão e o módulo são compatíveis, como indicado a seguir:
+ \$1
+ -
+ \$1
+ /
+ %

## Precedência do operador
<a name="s3-select-sql-reference-op-Precedence"></a>

A tabela a seguir mostra a precedência dos operadores em ordem decrescente.


|  Operador ou elemento  |  Capacidade de associação |  Obrigatório  | 
| --- | --- | --- | 
| `-`  | direita  | menos unário  | 
| `*`, `/`, `%`  | esquerda  | multiplicação, divisão, módulo  | 
| `+`, `-`  | esquerda  | adição, subtração  | 
| `IN` |  | associação de conjunto  | 
| `BETWEEN` |  | contenção de intervalo  | 
| `LIKE` |  | correspondência de padrões de string  | 
| `<``>` |  | menor que, maior que  | 
| `=` | direita  | igualdade, atribuição | 
| `NOT` | direita | negação lógica  | 
| `AND` | esquerda | conjunção lógica  | 
| `OR` | esquerda | disjunção lógica  | 

# Palavras-chave reservadas
<a name="s3-select-sql-reference-keyword-list"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Veja a seguir a lista de palavras-chave reservadas para o Amazon S3 Select. Essas palavras-chave incluem os nomes de função, tipos de dados, operadores e assim por diante, necessários para executar as expressões SQL usadas para consultar o conteúdo do objeto.

```
absolute
action
add
all
allocate
alter
and
any
are
as
asc
assertion
at
authorization
avg
bag
begin
between
bit
bit_length
blob
bool
boolean
both
by
cascade
cascaded
case
cast
catalog
char
char_length
character
character_length
check
clob
close
coalesce
collate
collation
column
commit
connect
connection
constraint
constraints
continue
convert
corresponding
count
create
cross
current
current_date
current_time
current_timestamp
current_user
cursor
date
day
deallocate
dec
decimal
declare
default
deferrable
deferred
delete
desc
describe
descriptor
diagnostics
disconnect
distinct
domain
double
drop
else
end
end-exec
escape
except
exception
exec
execute
exists
external
extract
false
fetch
first
float
for
foreign
found
from
full
get
global
go
goto
grant
group
having
hour
identity
immediate
in
indicator
initially
inner
input
insensitive
insert
int
integer
intersect
interval
into
is
isolation
join
key
language
last
leading
left
level
like
limit
list
local
lower
match
max
min
minute
missing
module
month
names
national
natural
nchar
next
no
not
null
nullif
numeric
octet_length
of
on
only
open
option
or
order
outer
output
overlaps
pad
partial
pivot
position
precision
prepare
preserve
primary
prior
privileges
procedure
public
read
real
references
relative
restrict
revoke
right
rollback
rows
schema
scroll
second
section
select
session
session_user
set
sexp
size
smallint
some
space
sql
sqlcode
sqlerror
sqlstate
string
struct
substring
sum
symbol
system_user
table
temporary
then
time
timestamp
timezone_hour
timezone_minute
to
trailing
transaction
translate
translation
trim
true
tuple
union
unique
unknown
unpivot
update
upper
usage
user
using
value
values
varchar
varying
view
when
whenever
where
with
work
write
year
zone
```

# Funções SQL
<a name="s3-select-sql-reference-sql-functions"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

O Amazon S3 Select é compatível com as funções SQL a seguir.

**Topics**
+ [

# Funções agregadas
](s3-select-sql-reference-aggregate.md)
+ [

# Funções condicionais
](s3-select-sql-reference-conditional.md)
+ [

# Funções de conversão
](s3-select-sql-reference-conversion.md)
+ [

# Funções de data
](s3-select-sql-reference-date.md)
+ [

# Funções de string
](s3-select-sql-reference-string.md)

# Funções agregadas
<a name="s3-select-sql-reference-aggregate"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

O Amazon S3 Select é compatível com as seguintes funções agregadas.


| Função | Tipo de argumento | Tipo de retorno | 
| --- | --- | --- | 
| `AVG(expression)` | `INT`, `FLOAT`, `DECIMAL` | `DECIMAL` para um argumento `INT`, `FLOAT` para um argumento de ponto flutuante, caso contrário, é igual ao tipo de dados do argumento. | 
| `COUNT` |  `-`  | `INT` | 
| `MAX(expression)` | `INT`, `DECIMAL` | O mesmo que o tipo de argumento. | 
| `MIN(expression)` | `INT`, `DECIMAL` | O mesmo que o tipo de argumento. | 
| `SUM(expression)` | `INT`, `FLOAT`, `DOUBLE`, `DECIMAL` | `INT` para um argumento `INT`, `FLOAT` para um argumento de ponto flutuante; do contrário, é igual ao tipo de dados do argumento. | 

## SUMExemplo de
<a name="s3-select-sql-reference-aggregate-case-examples"></a>

Para agregar os tamanhos totais de objetos de uma pasta em um [relatório do S3 Inventory](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-inventory.html), use uma expressão `SUM`.

O relatório do S3 Inventory a seguir é um arquivo CSV compactado com GZIP. Existem três colunas.
+ A primeira coluna é o nome do bucket do S3 (*`DOC-EXAMPLE-BUCKET`*) para o qual o relatório do S3 Inventory se destina.
+ A segunda coluna é o nome da chave do objeto que identifica exclusivamente o objeto no bucket.

  O valor `example-folder/` na primeira linha é para a pasta `example-folder`. No Amazon S3, quando você cria uma pasta no bucket, o S3 cria um objeto de 0 byte com uma chave definida como o nome da pasta que você forneceu.

  O valor `example-folder/object1` na segunda linha é para o objeto `object1` na pasta `example-folder`.

  O valor `example-folder/object2` na terceira linha é para o objeto `object2` na pasta `example-folder`.

  Para obter mais informações sobre pastas do S3, consulte [Organizar objetos no console do Amazon S3 usando pastas](using-folders.md).
+ A terceira coluna é o tamanho do objeto em bytes.

```
"DOC-EXAMPLE-BUCKET","example-folder/","0"
"DOC-EXAMPLE-BUCKET","example-folder/object1","2011267"
"DOC-EXAMPLE-BUCKET","example-folder/object2","1570024"
```

Para usar uma expressão `SUM` para calcular o tamanho total da pasta `example-folder`, execute a consulta SQL com o Amazon S3 Select.

```
SELECT SUM(CAST(_3 as INT)) FROM s3object s WHERE _2 LIKE 'example-folder/%' AND _2 != 'example-folder/';
```

Resultado da consulta: 

```
3581291
```

# Funções condicionais
<a name="s3-select-sql-reference-conditional"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

O Amazon S3 Select é compatível com as seguintes funções condicionais.

**Topics**
+ [

## CASE
](#s3-select-sql-reference-case)
+ [

## COALESCE
](#s3-select-sql-reference-coalesce)
+ [

## NULLIF
](#s3-select-sql-reference-nullif)

## CASE
<a name="s3-select-sql-reference-case"></a>

A expressão `CASE` é uma expressão condicional, semelhante às instruções `if/then/else` encontradas em outras linguagens. `CASE` é usado para especificar um resultado com várias condições. Há dois tipos de expressões `CASE`: simples e pesquisada.

Em expressões `CASE` simples, uma expressão é comparada a um valor. Quando uma correspondência é encontrada, a ação especificada na cláusula `THEN` é aplicada. Se nenhuma correspondência é encontrada, a ação especificada na cláusula `ELSE` é aplicada.

Em expressões `CASE` pesquisadas, cada `CASE` é avaliado com base em uma expressão booliana e a instrução `CASE` retorna o primeiro `CASE` correspondente. Se nenhuma correspondência de `CASE` for encontrada entre as cláusulas `WHEN`, a ação na cláusula `ELSE` será retornada.

### Sintaxe
<a name="s3-select-sql-reference-case-syntax"></a>

**nota**  
Atualmente, o Amazon S3 Select não é compatível com `ORDER BY` ou consultas que contenham novas linhas. Use consultas sem quebras de linha.

A seguir está uma declaração `CASE` simples usada para corresponder às condições:

```
CASE expression WHEN value THEN result [WHEN...] [ELSE result] END					
```

Veja a seguir uma declaração `CASE` pesquisada usada para avaliar cada condição:

```
CASE WHEN boolean condition THEN result [WHEN ...] [ELSE result] END					
```

### Exemplos
<a name="s3-select-sql-reference-case-examples"></a>

**nota**  
Se você usar o console do Amazon S3 para executar os exemplos a seguir e o arquivo CSV tiver uma linha de cabeçalho, selecione **Excluir a primeira linha de dados do CSV**. 

**Exemplo 1:** use uma expressão `CASE` simples para substituir `New York City` por `Big Apple` em uma consulta. Substitua todos os outros nomes de cidade por `other`.

```
SELECT venuecity, CASE venuecity WHEN 'New York City' THEN 'Big Apple' ELSE 'other' END FROM S3Object;
```

Resultado da consulta: 

```
venuecity        |   case
-----------------+-----------
Los Angeles      | other
New York City    | Big Apple
San Francisco    | other
Baltimore        | other
...
```

**Exemplo 2:** use uma expressão `CASE` pesquisada para atribuir números de grupo com base no valor `pricepaid` para vendas individuais de ingresso:

```
SELECT pricepaid, CASE WHEN CAST(pricepaid as FLOAT) < 10000 THEN 'group 1' WHEN CAST(pricepaid as FLOAT) > 10000 THEN 'group 2' ELSE 'group 3' END FROM S3Object;					
```

Resultado da consulta: 

```
pricepaid |  case
-----------+---------
12624.00 | group 2
10000.00 | group 3
10000.00 | group 3
9996.00 | group 1
9988.00 | group 1
...
```

## COALESCE
<a name="s3-select-sql-reference-coalesce"></a>

`COALESCE` avalia os argumentos na ordem e retorna o primeiro valor não desconhecido, ou seja, o primeiro valor que não for nulo ou ausente. Essa função não propaga valores nulos e ausentes.

### Sintaxe
<a name="s3-select-sql-reference-coalesce-syntax"></a>

```
COALESCE ( expression, expression, ... )
```

### Parâmetros
<a name="s3-select-sql-reference-coalesce-parameters"></a>

 *`expression`*   
A expressão de destino na qual a função opera.

### Exemplos
<a name="s3-select-sql-reference-coalesce-examples"></a>

```
COALESCE(1)                -- 1
COALESCE(null)             -- null
COALESCE(null, null)       -- null
COALESCE(missing)          -- null
COALESCE(missing, missing) -- null
COALESCE(1, null)          -- 1
COALESCE(null, null, 1)    -- 1
COALESCE(null, 'string')   -- 'string'
COALESCE(missing, 1)       -- 1
```

## NULLIF
<a name="s3-select-sql-reference-nullif"></a>

Dadas as duas expressões, `NULLIF` retorna `NULL` se as duas forem avaliadas para o mesmo valor. Caso contrário, `NULLIF` retorna o resultado da avaliação da primeira expressão.

### Sintaxe
<a name="s3-select-sql-reference-nullif-syntax"></a>

```
NULLIF ( expression1, expression2 )
```

### Parâmetros
<a name="s3-select-sql-reference-nullif-parameters"></a>

 `expression1, expression2`   
As expressões de destino nas quais a função opera.

### Exemplos
<a name="s3-select-sql-reference-nullif-examples"></a>

```
NULLIF(1, 1)             -- null
NULLIF(1, 2)             -- 1
NULLIF(1.0, 1)           -- null
NULLIF(1, '1')           -- 1
NULLIF([1], [1])         -- null
NULLIF(1, NULL)          -- 1
NULLIF(NULL, 1)          -- null
NULLIF(null, null)       -- null
NULLIF(missing, null)    -- null
NULLIF(missing, missing) -- null
```

# Funções de conversão
<a name="s3-select-sql-reference-conversion"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

O Amazon S3 Select é compatível com a seguinte função de conversão.

**Topics**
+ [

## CAST
](#s3-select-sql-reference-cast)

## CAST
<a name="s3-select-sql-reference-cast"></a>

A função `CAST` converte uma entidade, como uma expressão que retorna um único valor, de um tipo em outro. 

### Sintaxe
<a name="s3-select-sql-reference-cast-syntax"></a>

```
CAST ( expression AS data_type )
```

### Parâmetros
<a name="s3-select-sql-reference-cast-parameters"></a>

 *`expression`*   
Uma combinação de um ou mais valores, operadores e funções SQL que retornam um valor.

 *`data_type`*   
O tipo de dados de destino, como `INT`, no qual a expressão será convertida. Para obter uma lista dos tipos de dados compatíveis, consulte [Tipos de dados](s3-select-sql-reference-data-types.md).

### Exemplos
<a name="s3-select-sql-reference-cast-examples"></a>

```
CAST('2007-04-05T14:30Z' AS TIMESTAMP)
CAST(0.456 AS FLOAT)
```

# Funções de data
<a name="s3-select-sql-reference-date"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

O Amazon S3 Select é compatível com as seguintes funções de data.

**Topics**
+ [

## DATE\$1ADD
](#s3-select-sql-reference-date-add)
+ [

## DATE\$1DIFF
](#s3-select-sql-reference-date-diff)
+ [

## EXTRACT
](#s3-select-sql-reference-extract)
+ [

## TO\$1STRING
](#s3-select-sql-reference-to-string)
+ [

## TO\$1TIMESTAMP
](#s3-select-sql-reference-to-timestamp)
+ [

## UTCNOW
](#s3-select-sql-reference-utcnow)

## DATE\$1ADD
<a name="s3-select-sql-reference-date-add"></a>

Dada uma parte da data, uma quantidade e um carimbo de data/hora, `DATE_ADD` retorna um carimbo de data/hora atualizado, alterando a parte da data pela quantidade.

### Sintaxe
<a name="s3-select-sql-reference-date-add-syntax"></a>

```
DATE_ADD( date_part, quantity, timestamp )
```

### Parâmetros
<a name="s3-select-sql-reference-date-add-parameters"></a>

*`date_part`*   
Especifica que parte da data deve ser modificada. Pode ser uma das partes a seguir:  
+ year
+ mês
+ dia
+ hora
+ minuto
+ segundos

 *`quantity`*   
O valor a ser aplicado a um carimbo de data/hora atualizado. Os valores positivos para a `quantity` são adicionados à date\$1part do carimbo de data/hora e os valores negativos são subtraídos.

 *`timestamp`*   
O carimbo de data/hora de destino no qual a função opera.

### Exemplos
<a name="s3-select-sql-reference-date-add-examples"></a>

```
DATE_ADD(year, 5, `2010-01-01T`)                -- 2015-01-01 (equivalent to 2015-01-01T)
DATE_ADD(month, 1, `2010T`)                     -- 2010-02T (result will add precision as necessary)
DATE_ADD(month, 13, `2010T`)                    -- 2011-02T
DATE_ADD(day, -1, `2017-01-10T`)                -- 2017-01-09 (equivalent to 2017-01-09T)
DATE_ADD(hour, 1, `2017T`)                      -- 2017-01-01T01:00-00:00
DATE_ADD(hour, 1, `2017-01-02T03:04Z`)          -- 2017-01-02T04:04Z
DATE_ADD(minute, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:05:05.006Z
DATE_ADD(second, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:04:06.006Z
```

## DATE\$1DIFF
<a name="s3-select-sql-reference-date-diff"></a>

Dada uma parte da data e dois carimbos de data/hora válidos, `DATE_DIFF` retorna a diferença nas partes da data. O valor de retorno é um inteiro negativo quando o valor `date_part` do `timestamp1` for maior que o valor `date_part` do `timestamp2`. O valor de retorno é um inteiro positivo quando o valor `date_part` do `timestamp1` for menor que o valor `date_part` do `timestamp2`.

### Sintaxe
<a name="s3-select-sql-reference-date-diff-syntax"></a>

```
DATE_DIFF( date_part, timestamp1, timestamp2 )
```

### Parâmetros
<a name="s3-select-sql-reference-date-diff-parameters"></a>

 **`date_part`**   
Especifica que parte dos carimbos de data/hora deve ser comparada. Para a definição de `date_part`, consulte [DATE\$1ADD](#s3-select-sql-reference-date-add).

 **`timestamp1`**   
O primeiro carimbo de data/hora a ser comparado.

 **`timestamp2`**   
O segundo carimbo de data/hora a ser comparado.

### Exemplos
<a name="s3-select-sql-reference-date-diff-examples"></a>

```
DATE_DIFF(year, `2010-01-01T`, `2011-01-01T`)            -- 1
DATE_DIFF(year, `2010T`, `2010-05T`)                     -- 4 (2010T is equivalent to 2010-01-01T00:00:00.000Z)
DATE_DIFF(month, `2010T`, `2011T`)                       -- 12
DATE_DIFF(month, `2011T`, `2010T`)                       -- -12
DATE_DIFF(day, `2010-01-01T23:00`, `2010-01-02T01:00`) -- 0 (need to be at least 24h apart to be 1 day apart)
```

## EXTRACT
<a name="s3-select-sql-reference-extract"></a>

Dada uma parte da data e um carimbo de data/hora, `EXTRACT` retorna o valor da parte da data do carimbo de data/hora.

### Sintaxe
<a name="s3-select-sql-reference-extract-syntax"></a>

```
EXTRACT( date_part FROM timestamp )
```

### Parâmetros
<a name="s3-select-sql-reference-extract-parameters"></a>

 **`date_part`**   
Especifica que parte dos carimbos de data/hora deve ser extraída. Pode ser uma das partes a seguir:  
+ `YEAR`
+ `MONTH`
+ `DAY`
+ `HOUR`
+ `MINUTE`
+ `SECOND`
+ `TIMEZONE_HOUR`
+ `TIMEZONE_MINUTE`

 **`timestamp`**   
O carimbo de data/hora de destino no qual a função opera.

### Exemplos
<a name="s3-select-sql-reference-extract-examples"></a>

```
EXTRACT(YEAR FROM `2010-01-01T`)                           -- 2010
EXTRACT(MONTH FROM `2010T`)                                -- 1 (equivalent to 2010-01-01T00:00:00.000Z)
EXTRACT(MONTH FROM `2010-10T`)                             -- 10
EXTRACT(HOUR FROM `2017-01-02T03:04:05+07:08`)             -- 3
EXTRACT(MINUTE FROM `2017-01-02T03:04:05+07:08`)           -- 4
EXTRACT(TIMEZONE_HOUR FROM `2017-01-02T03:04:05+07:08`)    -- 7
EXTRACT(TIMEZONE_MINUTE FROM `2017-01-02T03:04:05+07:08`)  -- 8
```

## TO\$1STRING
<a name="s3-select-sql-reference-to-string"></a>

Dado um carimbo de data/hora e um padrão de formato, `TO_STRING` retorna uma representação de string do carimbo de data/hora no formato especificado.

### Sintaxe
<a name="s3-select-sql-reference-size-syntax"></a>

```
TO_STRING ( timestamp time_format_pattern )
```

### Parâmetros
<a name="s3-select-sql-reference-size-parameters"></a>

 *`timestamp`*   
O carimbo de data/hora de destino no qual a função opera.

 *`time_format_pattern`*   
Uma string que possui as seguintes interpretações de caracteres especiais:      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonS3/latest/userguide/s3-select-sql-reference-date.html)

### Exemplos
<a name="s3-select-sql-reference-size-examples"></a>

```
TO_STRING(`1969-07-20T20:18Z`,  'MMMM d, y')                    -- "July 20, 1969"
TO_STRING(`1969-07-20T20:18Z`, 'MMM d, yyyy')                   -- "Jul 20, 1969"
TO_STRING(`1969-07-20T20:18Z`, 'M-d-yy')                        -- "7-20-69"
TO_STRING(`1969-07-20T20:18Z`, 'MM-d-y')                        -- "07-20-1969"
TO_STRING(`1969-07-20T20:18Z`, 'MMMM d, y h:m a')               -- "July 20, 1969 8:18 PM"
TO_STRING(`1969-07-20T20:18Z`, 'y-MM-dd''T''H:m:ssX')           -- "1969-07-20T20:18:00Z"
TO_STRING(`1969-07-20T20:18+08:00Z`, 'y-MM-dd''T''H:m:ssX')     -- "1969-07-20T20:18:00Z"
TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXX')   -- "1969-07-20T20:18:00+0800"
TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXXX')  -- "1969-07-20T20:18:00+08:00"
```

## TO\$1TIMESTAMP
<a name="s3-select-sql-reference-to-timestamp"></a>

Dada uma string, `TO_TIMESTAMP` converte-se em um carimbo de data/hora. `TO_TIMESTAMP` é a operação inversa de `TO_STRING`.

### Sintaxe
<a name="s3-select-sql-reference-to-timestamp-syntax"></a>

```
TO_TIMESTAMP ( string )
```

### Parâmetros
<a name="s3-select-sql-reference-to-timestamp-parameters"></a>

 *`string`*   
A string de destino na qual a função opera.

### Exemplos
<a name="s3-select-sql-reference-to-timestamp-examples"></a>

```
TO_TIMESTAMP('2007T')                         -- `2007T`
TO_TIMESTAMP('2007-02-23T12:14:33.079-08:00') -- `2007-02-23T12:14:33.079-08:00`
```

## UTCNOW
<a name="s3-select-sql-reference-utcnow"></a>

`UTCNOW` retorna o tempo atual em UTC como um carimbo de data/hora.

### Sintaxe
<a name="s3-select-sql-reference-utcnow-syntax"></a>

```
UTCNOW()
```

### Parâmetros
<a name="s3-select-sql-reference-utcnow-parameters"></a>

`UTCNOW` não aceita parâmetros.

### Exemplos
<a name="s3-select-sql-reference-utcnow-examples"></a>

```
UTCNOW() -- 2017-10-13T16:02:11.123Z
```

# Funções de string
<a name="s3-select-sql-reference-string"></a>

**Importante**  
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

O Amazon S3 Select é compatível com as seguintes funções de string.

**Topics**
+ [

## CHAR\$1LENGTH, CHARACTER\$1LENGTH
](#s3-select-sql-reference-char-length)
+ [

## LOWER
](#s3-select-sql-reference-lower)
+ [

## SUBSTRING
](#s3-select-sql-reference-substring)
+ [

## TRIM
](#s3-select-sql-reference-trim)
+ [

## UPPER
](#s3-select-sql-reference-upper)

## CHAR\$1LENGTH, CHARACTER\$1LENGTH
<a name="s3-select-sql-reference-char-length"></a>

`CHAR_LENGTH` (ou `CHARACTER_LENGTH`) conta o número de caracteres na string especificada.

**nota**  
`CHAR_LENGTH` e `CHARACTER_LENGTH` são sinônimos.

### Sintaxe
<a name="s3-select-sql-reference-char-length-syntax"></a>

```
CHAR_LENGTH ( string )
```

### Parâmetros
<a name="s3-select-sql-reference-char-length-parameters"></a>

 *`string`*   
A string de destino na qual a função opera.

### Exemplos
<a name="s3-select-sql-reference-char-length-examples"></a>

```
CHAR_LENGTH('')          -- 0
CHAR_LENGTH('abcdefg')   -- 7
```

## LOWER
<a name="s3-select-sql-reference-lower"></a>

Dada uma string, `LOWER` converte todos os caracteres maiúsculos em minúsculos. Todos os caracteres minúsculos permanecem inalterados.

### Sintaxe
<a name="s3-select-sql-reference-lower-syntax"></a>

```
LOWER ( string )
```

### Parâmetros
<a name="s3-select-sql-reference-lower-parameters"></a>

 **`string`**   
A string de destino na qual a função opera.

### Exemplos
<a name="s3-select-sql-reference-lower-examples"></a>

```
LOWER('AbCdEfG!@#$') -- 'abcdefg!@#$'
```

## SUBSTRING
<a name="s3-select-sql-reference-substring"></a>

Dada uma string, um índice inicial e, opcionalmente, um tamanho, `SUBSTRING` retorna a substring do índice inicial até o final da string ou até o tamanho fornecido.

**nota**  
O primeiro caractere da string de entrada tem uma posição de índice de 1.  
 Se `start` < 1, sem comprimento especificado, a posição do índice será definida como 1. 
 Se `start` for < 1, sem comprimento especificado, a posição do índice será definida como `start + length -1`. 
 Se `start + length -1` < 0, uma string vazia será retornada. 
 Se `start + length -1` > = 0, a substring começando na posição de índice 1 de comprimento `start + length - 1` será retornada. 

### Sintaxe
<a name="s3-select-sql-reference-substring-syntax"></a>

```
SUBSTRING( string FROM start [ FOR length ] )
```

### Parâmetros
<a name="s3-select-sql-reference-substring-parameters"></a>

 **`string`**   
A string de destino na qual a função opera.

 **`start`**   
A posição inicial da string.

 **`length`**   
O tamanho da substring a ser retornada. Se não estiver presente, prossiga para o final da string.

### Exemplos
<a name="s3-select-sql-reference-substring-examples"></a>

```
SUBSTRING("123456789", 0)      -- "123456789"
SUBSTRING("123456789", 1)      -- "123456789"
SUBSTRING("123456789", 2)      -- "23456789"
SUBSTRING("123456789", -4)     -- "123456789"
SUBSTRING("123456789", 0, 999) -- "123456789" 
SUBSTRING("123456789", 1, 5)   -- "12345"
```

## TRIM
<a name="s3-select-sql-reference-trim"></a>

Corta os caracteres iniciais ou finais de uma string. O caractere padrão a ser removido é um espaço (`' '`).

### Sintaxe
<a name="s3-select-sql-reference-trim-syntax"></a>

```
TRIM ( [[LEADING | TRAILING | BOTH remove_chars] FROM] string )
```

### Parâmetros
<a name="s3-select-sql-reference-trim-parameters"></a>

 **`string`**   
A string de destino na qual a função opera.

 `LEADING` \$1 `TRAILING` \$1 `BOTH`   
Esse parâmetro indica se é necessário cortar os caracteres iniciais ou finais, ou ambos.

 **`remove_chars`**   
O conjunto de caracteres a ser removido. `remove_chars` pode ser uma string com tamanho > 1. Essa função retorna a string com qualquer caractere de `remove_chars` encontrado no início ou final da string que foi removida.

### Exemplos
<a name="s3-select-sql-reference-trim-examples"></a>

```
TRIM('       foobar         ')               -- 'foobar'
TRIM('      \tfoobar\t         ')            -- '\tfoobar\t'
TRIM(LEADING FROM '       foobar         ')  -- 'foobar         '
TRIM(TRAILING FROM '       foobar         ') -- '       foobar'
TRIM(BOTH FROM '       foobar         ')     -- 'foobar'
TRIM(BOTH '12' FROM '1112211foobar22211122') -- 'foobar'
```

## UPPER
<a name="s3-select-sql-reference-upper"></a>

Dada uma string, `UPPER` converte todos os caracteres minúsculos em maiúsculos. Todos os caracteres maiúsculos permanecem inalterados.

### Sintaxe
<a name="s3-select-sql-reference-upper-syntax"></a>

```
UPPER ( string )
```

### Parâmetros
<a name="s3-select-sql-reference-upper-parameters"></a>

 **`string`**   
A string de destino na qual a função opera.

### Exemplos
<a name="s3-select-sql-reference-upper-examples"></a>

```
UPPER('AbCdEfG!@#$') -- 'ABCDEFG!@#$'
```