Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Documentazione di riferimento su SQL per Amazon S3 Select
<a name="s3-select-sql-reference"></a>

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Questa documentazione di riferimento contiene una descrizione degli elementi SQL supportati da Amazon S3 Select.

**Topics**
+ [

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

# Tipi di dati
](s3-select-sql-reference-data-types.md)
+ [

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

# Parole chiave riservate
](s3-select-sql-reference-keyword-list.md)
+ [

# Funzioni SQL
](s3-select-sql-reference-sql-functions.md)

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

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select supporta soltanto il comando SQL `SELECT`. Le seguenti clausole standard ANSI sono supportate per `SELECT`: 


+ `SELECT` Elenco
+ `FROM`Clausola 
+ `WHERE`Clausola 
+ `LIMIT`Clausola 

**Nota**  
Al momento, le query di Amazon S3 Select non supportano query secondarie o join.

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

L'elenco `SELECT` assegna un nome a colonne, funzioni ed espressioni che la query deve restituire. L'elenco rappresenta l'output della query. 

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

La prima forma di `SELECT` con `*` (asterisco) restituisce ogni riga che ha passato la clausola , così com'è. Il secondo formato di `SELECT` crea una riga con espressioni scalari di output definite dall’utente **`projection1`** e **`projection2`** per ogni colonna.

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

Amazon S3 Select supporta i seguenti formati della clausola `FROM`:

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

In ogni forma della clausola `FROM`, `table_name` è il `S3Object` che viene interrogato. Gli utenti abituati a database relazionali tradizionali possono considerare questo come uno schema di database che contiene più viste di una tabella.

Nel linguaggio SQL standard, la clausola `FROM` crea righe che vengono filtrate nella clausola `WHERE` e proiettate nell'elenco `SELECT`. 

Per tutti gli oggetti JSON archiviati in Amazon S3 Select, puoi anche utilizzare i seguenti moduli della clausola `FROM`:

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

Utilizzando questo modulo della clausola `FROM`, puoi selezionare da array o oggetti inclusi in un oggetto JSON. Puoi specificare `path` mediante uno dei seguenti moduli:
+ Per nome (in un oggetto): `.name` o `['name']`
+ Per indice (in un array): `[index]`
+ Per carattere jolly (in un oggetto): `.*`
+ Per carattere jolly (in un array): `[*]`

**Nota**  
Questo modulo della clausola `FROM` è utilizzabile solo con oggetti JSON.
I caratteri jolly emettono sempre almeno un record. Se nessun record corrisponde, Amazon S3 Select emette il valore `MISSING`. Durante la serializzazione dell'output (dopo che la query è stata completata), Amazon S3 Select sostituisce i valori `MISSING` con record vuoti.
Le funzioni di aggregazione (`AVG`, `COUNT`, `MAX`, `MIN` e `SUM`) ignorano i valori `MISSING`.
Se non fornisci un alias quando utilizzi un carattere jolly, puoi fare riferimento alla riga utilizzando l'ultimo elemento nel percorso. Ad esempio, puoi selezionare tutti i prezzi da un elenco di libri utilizzando la query `SELECT price FROM S3Object[*].books[*].price`. Se il percorso termina con un carattere jolly anziché con un nome, puoi utilizzare il valore `_1` per fare riferimento alla riga. Ad esempio, anziché `SELECT price FROM S3Object[*].books[*].price`, puoi usare la query `SELECT _1.price FROM S3Object[*].books[*]`.
Amazon S3 Select considera sempre un documento JSON come un array di valori a livello di radice. Pertanto, anche se l'oggetto JSON che stai interrogando ha solo un elemento radice, la clausola `FROM` deve iniziare con `S3Object[*]`. Tuttavia, per motivi di compatibilità, Amazon S3 Select consente di omettere il carattere jolly se non si include un percorso. Pertanto, la clausola completa `FROM S3Object` è equivalente a `FROM S3Object[*] as S3Object`. Se includi un percorso, devi utilizzare anche il carattere jolly. Pertanto `FROM S3Object` e `FROM S3Object[*].path` sono entrambe clausole valide, ma `FROM S3Object.path` non è valida.

**Example**  
**Esempi:**  
*Esempio 1*  
Questo esempio mostra i risultati utilizzando i seguenti set di dati e query:  

```
{ "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"}
{}
```
Amazon S3 Select produce ciascun risultato per i seguenti motivi:  
+ `{"id":"id-1"}`— `S3Object[0].Rules[0].id` ha prodotto una corrispondenza.
+ `{}` - `S3Object[0].Rules[1].id` non ha prodotto una corrispondenza con un record, quindi Amazon S3 Select ha emesso un valore `MISSING`, che è stato quindi modificato in un record vuoto durante la serializzazione dell'output e restituito.
+ `{"id":"id-2"}`— `S3Object[0].Rules[2].id` ha prodotto una corrispondenza.
+ `{}`-`S3Object[1]` non ha prodotto una corrispondenza in `Rules`, quindi Amazon S3 Select ha emesso un valore `MISSING`, che è stato quindi modificato in un record vuoto durante la serializzazione dell'output e restituito.
Se non desideri che Amazon S3 Select restituisca record vuoti quando non trova una corrispondenza, puoi testare il valore `MISSING`. La seguente query restituisce gli stessi risultati della query precedente, ma con i valori vuoti omessi:  

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

```
{"id":"1"}
{"id":"2"}
```
*Esempio 2*  
Questo esempio mostra i risultati utilizzando i seguenti set di dati e query:  

```
{ "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"}
```

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

La sintassi della clausola `WHERE` è la seguente: 

```
WHERE condition
```

La clausola `WHERE` filtra le righe in base alla `condition`. Una condizione è un'espressione che genera un risultato booleano. Solo le righe per le quali la condizione è `TRUE` sono restituite nel risultato.

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

La sintassi della clausola `LIMIT` è la seguente: 

```
LIMIT number
```

La clausola `LIMIT` limita il numero di record che desideri vengano restituiti dalla query in base al `number` specificato.

## Accesso agli attributi
<a name="s3-select-sql-reference-attribute-access"></a>

Le clausole `SELECT` e `WHERE` possono fare riferimento a record di dati utilizzando uno dei metodi descritti nelle seguenti sezioni, a seconda che il file su cui viene eseguita la query sia in formato CSV o JSON.

### CSV
<a name="s3-select-sql-reference-attribute-access-csv"></a>
+ **Numeri di colonna**: puoi fare riferimento alla *N-esima* colonna di una riga con il nome di colonna `_N`, dove *`N`* è la posizione della colonna. La numerazione delle posizioni inizia da 1. Ad esempio, la prima colonna è denominata `_1` e la seconda è denominata `_2`.

  Puoi fare riferimento a una colonna con `_N` o `alias._N`. Ad esempio, `_2` e `myAlias._2` sono entrambi modi validi di fare riferimento a una colonna nell'elenco `SELECT` e nella clausola `WHERE`.
+ **Intestazioni di colonna**: per gli oggetti in formato CSV che hanno una riga di intestazione, le intestazioni sono disponibili per l'elenco `SELECT` e la clausola `WHERE`. In particolare, come nel linguaggio SQL classico, all'interno di espressioni con le clausole `SELECT` e `WHERE` è possibile fare riferimento alle colonne in base a `alias.column_name` o `column_name`.

### JSON
<a name="s3-select-sql-reference-attribute-access-json"></a>
+ **Documento**: puoi accedere ai campi di documento JSON con `alias.name`. È inoltre possibile accedere ai campi nidificati, ad esempio `alias.name1.name2.name3`.
+ **Elenco**: puoi accedere agli elementi in un elenco JSON utilizzando indici a base zero con l'operatore `[]`. Ad esempio, puoi accedere al secondo elemento di un elenco con `alias[1]`. È possibile abbinare l'accesso agli elementi dell'elenco con i campi, `alias.name1.name2[1].name3`, ad esempio.
+ **Esempi:** considera questo oggetto JSON come un set di dati di esempio:

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

  *Esempio 1*

  La seguente query restituisce questi risultati:

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

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

  *Esempio 2*

  La seguente query restituisce questi risultati:

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

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

## Distinzione tra maiuscole e minuscole nei nomi di intestazioni/attributi
<a name="s3-select-sql-reference-case-sensitivity"></a>

Con Amazon S3 Select puoi utilizzare le virgolette doppie per indicare che nelle intestazioni di colonna (per gli oggetti CSV) e negli attributi (per gli oggetti JSON) si applica la distinzione tra maiuscole e minuscole. In assenza delle virgolette doppie, le intestazioni e gli attributi degli oggetti non prevedono distinzione tra maiuscole e minuscole. In caso di ambiguità viene generato un errore.

I seguenti esempi sono 1) oggetti Amazon S3 in formato CSV con le intestazioni di colonna specificate e con impostato su `"Use"` per la richiesta di query oppure 2) oggetti Amazon S3 in formato JSON con gli attributi specificati.

*Esempio \$11:* l'oggetto su cui viene eseguita la query ha intestazione o attributo `NAME`.
+ La seguente espressione restituisce correttamente i valori dall'oggetto. Poiché non sono presenti virgolette, la query non fa distinzione tra maiuscole e minuscole.

  ```
  SELECT s.name from S3Object s
  ```
+ La seguente espressione genera un errore 400 `MissingHeaderName`. Poiché sono presenti le virgolette, la query fa distinzione tra maiuscole e minuscole. 

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

*Esempio 2:* l'oggetto Amazon S3 su cui viene eseguita la query ha un'intestazione o attributo con `NAME` e un'altra intestazione o attributo con `name`.
+ La seguente espressione genera un errore 400 `AmbiguousFieldName`. Poiché senza virgolette, senza distinzione tra maiuscole e minuscole, ma ci sono due corrispondenze, quindi viene generato un errore.

  ```
  SELECT s.name from S3Object s
  ```
+ La seguente espressione restituisce correttamente i valori dall'oggetto. Poiché sono presenti le virgolette, la query fa distinzione tra maiuscole e minuscole, quindi non vi è alcuna ambiguità.

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

## Utilizzo di parole chiave riservate come termini definiti dall'utente
<a name="s3-select-sql-reference-using-keywords"></a>

Amazon S3 Select dispone di un set di parole chiave riservate, necessarie per eseguire le espressioni SQL utilizzate per le query sul contenuto degli oggetti. Tali parole chiave riservate includono nomi di funzioni, tipi di dati, operatori e così via. In alcuni casi, i termini definiti dall'utente, ad esempio le intestazioni di colonna (per i file CSV) o gli attributi (per gli oggetti JSON) possono essere in conflitto con una parola chiave riservata. Quando ciò si verifica, devi utilizzare le virgolette doppie per indicare che stai intenzionalmente utilizzando un termine definito dall'utente in conflitto con una parola chiave riservata. In caso contrario, verrà generato un errore di analisi 400.

Per l'elenco completo delle parole chiave riservate, consulta [Parole chiave riservate](s3-select-sql-reference-keyword-list.md).

Il seguente esempio è 1) un oggetto Amazon S3 in formato CSV con le intestazioni di colonna specificate e con `FileHeaderInfo` impostato su `"Use"` per la richiesta di query oppure 2) un oggetto Amazon S3 in formato JSON con gli attributi specificati.

*Esempio:* l'oggetto su cui viene eseguita la query ha un'intestazione o attributo denominato `CAST`, che è una parola chiave riservata.
+ La seguente espressione restituisce correttamente i valori dall'oggetto. Poiché nella query vengono utilizzate le virgolette, S3 Select utilizza l'intestazione o l'attributo definiti dall'utente.

  ```
  SELECT s."CAST" from S3Object s
  ```
+ La seguente espressione genera un errore 400 di analisi. Poiché nella query non vengono utilizzate virgolette, `CAST` entra in conflitto con una parola chiave riservata.

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

## Espressioni scalari
<a name="s3-select-sql-reference-scalar"></a>

Nella clausola `WHERE` e nell'elenco `SELECT`, puoi avere *espressioni scalari* di SQL, ovvero espressioni che restituiscono valori scalari. Queste espressioni hanno la seguente forma:
+ ***`literal`*** 

  Un valore letterale SQL. 
+ ***`column_reference`*** 

  Un riferimento a una colonna nel modulo `column_name` o`alias.column_name`. 
+ **`unary_op`** **`expression`** 

  In questo caso, ****`unary_op`**** è un operatore SQL unario.
+ **`expression`** **`binary_op`** ***`expression`*** 

   In questo caso, ****`binary_op`**** è un operatore binario SQL. 
+ **`func_name`** 

   In questo caso, **`func_name`** è il nome della funzione scalare da richiamare. 
+ ***`expression`*** `[ NOT ] BETWEEN` ****`expression`**** `AND` ****`expression`****
+ ***`expression`*** `LIKE` ****`expression`**** [ `ESCAPE` ***`expression`*** ]

# Tipi di dati
<a name="s3-select-sql-reference-data-types"></a>

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select supporta diversi tipi di dati primitivi.

## Conversioni dei tipi di dati
<a name="s3-select-sql-reference-data-conversion"></a>

La regola generale è di seguire la funzione `CAST` se definita. Se `CAST` non è definita, tutti i dati di input vengono trattati come stringa. In tal caso, è necessario inserire i dati di input ai tipi di dati pertinenti quando necessario.

Per ulteriori informazioni sulla funzione `CAST`, consulta [CAST](s3-select-sql-reference-conversion.md#s3-select-sql-reference-cast).

## Tipi di dati supportati
<a name="s3-select-sql-reference-supported-data-types"></a>

Amazon S3 Select supporta il seguente set di tipi di dati primitivi.


|  Nome  |  Descrizione  |  Esempi  | 
| --- | --- | --- | 
| `bool` | Un valore booleano, `TRUE` o `FALSE`. | `FALSE` | 
| `int`, `integer` | Intero con segno da 8 byte compreso nell'intervallo da -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807.  | `100000` | 
| `string` | Una stringa di lunghezza variabile con codifica. UTF8 Il limite di default è 1 carattere. Il limite massimo di caratteri è 2.147.483.647.  | `'xyz'` | 
| `float` | Numero in virgola mobile a 8 byte.  | `CAST(0.456 AS FLOAT)` | 
| `decimal`, `numeric` |  Numero in base 10, con una precisione massima di 38 (ovvero il numero massimo di cifre significative) e con scala compresa nell'intervallo da -231 a 231-1 (ovvero l'esponente in base 10).  Amazon S3 Select ignora il dimensionamento e la precisione quando vengono forniti entrambi contemporaneamente.   | `123.456 ` | 
| `timestamp` |  I time stamp rappresentano un momento specifico nel tempo, includono sempre un offset locale e consentono di stabilire una precisione arbitraria. Nel formato di testo, i timestamp seguono i [formati di data e ora della notazione W3C](https://www.w3.org/TR/NOTE-datetime), ma devono terminare con il letterale `T` se la precisione non è di almeno un giorno completo. Le frazioni di secondo sono consentite, con una precisione di almeno una cifra e un valore massimo illimitato. Gli offset in ora locale possono essere rappresentati con il formato UTC ora:minuto o con il letterale `Z` per indicare un'ora locale UTC. Le differenze per l'ora locale sono obbligatorie nei time stamp che includono l'ora e non sono consentiti nei valori di data.  | `CAST('2007-04-05T14:30Z' AS TIMESTAMP)` | 

### Tipi supportati Parquet
<a name="s3-select-sql-reference-supported-data-types-parquet"></a>

Amazon S3 Select supporta i seguenti tipi di Parquet:
+ `DATE`
+ `DECIMAL`
+ `ENUM`
+ `INT(8)`
+ `INT(16)`
+ `INT(32)`
+ `INT(64)`
+ `LIST`
**Nota**  
Per l'output del tipo `LIST` Parquet, Amazon S3 Select supporta solo il formato JSON. Tuttavia, se la query limita i dati a valori semplici, il tipo di `LIST` Parquet può essere interrogato anche in formato CSV.
+ `STRING`
+ `TIMESTAMP` precisione supportata (`MILLIS`/`MICROS`/`NANOS`)
**Nota**  
I timestamp salvati come `INT(96)` non sono supportati.   
A causa della gamma del tipo `INT(64)`, i timestamp che utilizzano l'unità `NANOS` possono rappresentare solo valori compresi tra `1677-09-21 00:12:43` e `2262-04-11 23:47:16`. I valori al di fuori di questo intervallo non possono essere rappresentati con l'unità `NANOS`.

### Mappatura dei tipi di Parquet ai tipi di dati supportati in Amazon S3 Select
<a name="s3-select-sql-reference-supported-data-types-parquet-mapping"></a>


| Tipi di Parquet | Tipi di dati supportati | 
| --- | --- | 
| `DATE` |  `timestamp`  | 
|  `DECIMAL`  |  `decimal`, `numeric`  | 
|  `ENUM`  |  `string`  | 
|  `INT(8)`  |  `int`, `integer`  | 
|  `INT(16)`  | `int`, `integer` | 
| `INT(32)` | `int`, `integer` | 
|  `INT(64)`  |  `decimal`, `numeric`  | 
|  `LIST`  |  Ogni tipo di Parquet nell'elenco è mappato al tipo di dati corrispondente  | 
|  `STRING`  |  `string`  | 
|  `TIMESTAMP`  |  `timestamp`  | 

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

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select supporta i seguenti operatori.

## Operatori logici
<a name="s3-select-sql-reference-loical-ops"></a>
+ `AND`
+ `NOT`
+ `OR`

## Operatori di confronto
<a name="s3-select-sql-reference-compare-ops"></a>
+ `<` 
+ `>` 
+ `<=`
+ `>=`
+ `=`
+ `<>`
+ `!=`
+ `BETWEEN`
+ `IN` – Ad esempio: `IN ('a', 'b', 'c')`

  

## Operatori di criteri di ricerca
<a name="s3-select-sql-reference-pattern"></a>
+ `LIKE`
+ `_` (Corrisponde a qualsiasi carattere)
+ `%` (Corrisponde a qualsiasi sequenza di caratteri)

## Operatori unitari
<a name="s3-select-sql-reference-unitary-ops"></a>
+ `IS NULL`
+ `IS NOT NULL`

## Operatori matematici
<a name="s3-select-sql-referencemath-ops"></a>

Sono supportati gli operatori di addizione, sottrazione, moltiplicazione, divisione e modulo come segue:
+ \$1
+ -
+ \$1
+ /
+ %

## Precedenza degli operatori
<a name="s3-select-sql-reference-op-Precedence"></a>

Nella tabella seguente è indicata la precedenza degli operatori in ordine decrescente.


|  Operatore o elemento  |  Associatività |  Campo obbligatorio  | 
| --- | --- | --- | 
| `-`  | destra  | meno unario  | 
| `*`, `/`, `%`  | sinistra  | moltiplicazione, divisione, modulo  | 
| `+`, `-`  | sinistra  | addizione, sottrazione  | 
| `IN` |  | appartenenza a un set  | 
| `BETWEEN` |  | limitazione a un intervallo  | 
| `LIKE` |  | criteri di ricerca di stringhe  | 
| `<``>` |  | minore di, maggiore di  | 
| `=` | destra  | uguaglianza, assegnazione | 
| `NOT` | destra | negazione logica  | 
| `AND` | sinistra | congiunzione logica  | 
| `OR` | sinistra | disgiunzione logica  | 

# Parole chiave riservate
<a name="s3-select-sql-reference-keyword-list"></a>

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Di seguito è riportato l'elenco delle parole chiave riservate per Amazon S3 Select. Sono inclusi nomi di funzioni, tipi di dati, operatori e così via, necessari per eseguire le espressioni SQL utilizzate per le query sul contenuto degli oggetti.

```
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
```

# Funzioni SQL
<a name="s3-select-sql-reference-sql-functions"></a>

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select supporta le seguenti funzioni SQL.

**Topics**
+ [

# Funzioni di aggregazione
](s3-select-sql-reference-aggregate.md)
+ [

# Funzioni condizionali
](s3-select-sql-reference-conditional.md)
+ [

# Funzioni di conversione
](s3-select-sql-reference-conversion.md)
+ [

# Funzioni di data
](s3-select-sql-reference-date.md)
+ [

# Funzioni stringa
](s3-select-sql-reference-string.md)

# Funzioni di aggregazione
<a name="s3-select-sql-reference-aggregate"></a>

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select supporta le seguenti funzioni di aggregazione:


| Funzione | Tipo di argomento | Tipo restituito | 
| --- | --- | --- | 
| `AVG(expression)` | `INT`, `FLOAT`, `DECIMAL` | `DECIMAL` per un argomento `INT`, `FLOAT` per un argomento in virgola mobile; in caso contrario, lo stesso tipo di dati dell'argomento. | 
| `COUNT` |  `-`  | `INT` | 
| `MAX(expression)` | `INT`, `DECIMAL` | Lo stesso tipo dell'argomento. | 
| `MIN(expression)` | `INT`, `DECIMAL` | Lo stesso tipo dell'argomento. | 
| `SUM(expression)` | `INT`, `FLOAT`, `DOUBLE`, `DECIMAL` | `INT` per un argomento `INT`, `FLOAT` per un argomento in virgola mobile; in caso contrario, lo stesso tipo di dati dell'argomento. | 

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

Per aggregare le dimensioni totali degli oggetti di una cartella in un [report S3 Inventory](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-inventory.html), usa un'espressione `SUM`.

Il seguente report S3 Inventory è un file CSV compresso con GZIP. Sono disponibili tre colonne.
+ La prima colonna è il nome del bucket S3 (*`DOC-EXAMPLE-BUCKET`*) a cui è destinato il rapporto S3 Inventory.
+ La seconda colonna è il nome della chiave dell'oggetto che identifica in modo univoco l'oggetto nel bucket.

  Il valore `example-folder/` nella prima riga si riferisce alla cartella `example-folder`. Quando crei una cartella nel bucket in Amazon S3, S3 crea un oggetto con dimensioni pari a 0 byte con una chiave impostata sul nome della cartella fornito.

  Il  valore `example-folder/object1` nella seconda riga si riferisce all'oggetto `object1` nella cartella `example-folder`.

  Il  valore `example-folder/object2` nella terza riga si riferisce all'oggetto `object2` nella cartella `example-folder`.

  Per ulteriori informazioni sulle cartelle S3, consulta [Organizzazione degli oggetti nella console di Amazon S3 utilizzando le cartelle](using-folders.md).
+ La terza colonna è la dimensione dell'oggetto in byte.

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

Per utilizzare un'espressione `SUM` per calcolare la dimensione totale della cartella `example-folder`, esegui la query SQL con Amazon S3 Select.

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

Risultato della query: 

```
3581291
```

# Funzioni condizionali
<a name="s3-select-sql-reference-conditional"></a>

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select supporta le seguenti funzioni condizionali.

**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>

L'espressione `CASE` è un'espressione condizionale, simile alle istruzioni `if/then/else` presenti in altre lingue. `CASE` è utilizzata per specificare un risultato quando ci sono condizioni multiple. Esistono due tipi di espressioni `CASE`: semplici e ricercate.

Nelle espressioni `CASE` semplici, un'espressione viene confrontata con un valore. Quando viene trovata una corrispondenza, viene applicata l'azione specificata nella clausola `THEN`. Se non viene trovata una corrispondenza, viene applicata l'azione nella clausola `ELSE`.

Nelle espressioni `CASE` cercate, ogni `CASE` viene valutata in base a un'espressione booleana e l'istruzione `CASE` restituisce la prima `CASE` corrispondente. Se non vengono trovate corrispondenze `CASE` tra le clausole `WHEN`, viene restituita l'operazione nella clausola `ELSE`.

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

**Nota**  
Attualmente Amazon S3 Select non supporta `ORDER BY` o query che contengono nuove righe. Assicurati di utilizzare query senza interruzioni di riga.

Quella che segue è una semplice dichiarazione `CASE`  che viene utilizzata per soddisfare le condizioni:

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

Di seguito è disponibile una  dichiarazione `CASE` ricercata che viene utilizzata per valutare ogni condizione:

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

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

**Nota**  
Se utilizzi la console Amazon S3 per eseguire i seguenti esempi e il file CSV contiene una riga di intestazione, seleziona **Exclude the first line of CSV data (Escludi la prima riga di dati CSV)**. 

**Esempio 1:** utilizza una semplice espressione `CASE` per sostituire `New York City` con `Big Apple` in una query. Sostituire tutti gli altri nomi di città con `other`.

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

Risultato della query: 

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

**Esempio 2:** utilizza un'espressione `CASE` con ricerca per assegnare numeri di gruppo in base al valore `pricepaid` per le vendite di biglietti singoli:

```
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;					
```

Risultato della query: 

```
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` valuta gli argomenti in ordine e restituisce il primo valore non sconosciuto, ovvero il primo non nullo o non mancante. Questa funzione non propaga valori null e mancanti.

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

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

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

 *`expression`*   
L'espressione di destinazione su cui viene eseguita la funzione.

### Esempi
<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>

Date due espressioni, `NULLIF` restituisce `NULL` se le due espressioni restituiscono lo stesso valore. In caso contrario, restituisce il risultato della valutazione della prima espressione.

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

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

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

 `expression1, expression2`   
Le espressioni di destinazione su cui viene eseguita la funzione.

### Esempi
<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
```

# Funzioni di conversione
<a name="s3-select-sql-reference-conversion"></a>

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select supporta le seguenti funzioni di conversione.

**Topics**
+ [

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

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

La funzione `CAST` converte un'entità, ad esempio un'espressione che restituisce un singolo valore, da un tipo a un altro. 

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

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

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

 *`expression`*   
Una combinazione di uno o più valori, operatori e funzioni SQL che restituisce un valore.

 *`data_type`*   
Il tipo di dati di destinazione, ad esempio `INT`, per il quale eseguire il cast dell'espressione. Per un elenco dei tipi di dati supportati, consulta [Tipi di dati](s3-select-sql-reference-data-types.md).

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

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

# Funzioni di data
<a name="s3-select-sql-reference-date"></a>

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select supporta le seguenti funzioni di 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>

Dati una parte di data, una quantità e un timestamp, restituisce un timestamp aggiornato modificando la parte di data in base alla quantità.

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

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

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

*`date_part`*   
Specifica la parte di data da modificare. Può essere una delle seguenti:  
+ anno
+ mese
+ giorno
+ ora
+ minuti
+ secondo

 *`quantity`*   
Il valore da applicare al timestamp aggiornato. I valori positivi per `quantity` vengono aggiunti a date\$1part del timestamp, mentre i valori negativi vengono sottratti.

 *`timestamp`*   
Il timestamp di destinazione su cui viene eseguita la funzione.

### Esempi
<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>

Dati una parte di data e due timestamp validi, `DATE_DIFF` restituisce la differenza in parti di data. Il valore restituito è un numero intero negativo quando il valore `date_part` di `timestamp1` è maggiore del valore `date_part` di `timestamp2`. Il valore restituito è un numero intero positivo quando il valore `date_part` di `timestamp1` è minore del valore `date_part` di `timestamp2`.

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

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

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

 **`date_part`**   
Specifica la parte dei timestamp da confrontare. Per la definizione di `date_part`, consulta [DATE\$1ADD](#s3-select-sql-reference-date-add).

 **`timestamp1`**   
Il primo timestamp da confrontare.

 **`timestamp2`**   
Il secondo timestamp da confrontare.

### Esempi
<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>

Dati una parte di data e un timestamp, `EXTRACT` restituisce il valore della parte di data del timestamp.

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

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

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

 **`date_part`**   
Specifica la parte dei timestamp da estrarre. Può essere una delle seguenti:  
+ `YEAR`
+ `MONTH`
+ `DAY`
+ `HOUR`
+ `MINUTE`
+ `SECOND`
+ `TIMEZONE_HOUR`
+ `TIMEZONE_MINUTE`

 **`timestamp`**   
Il timestamp di destinazione su cui viene eseguita la funzione.

### Esempi
<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>

Dati un timestamp e un pattern di formato, `TO_STRING` restituisce una rappresentazione in formato stringa del timestamp fornito nel formato specificato.

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

```
TO_STRING ( timestamp time_format_pattern )
```

### Parameters
<a name="s3-select-sql-reference-size-parameters"></a>

 *`timestamp`*   
Il timestamp di destinazione su cui viene eseguita la funzione.

 *`time_format_pattern`*   
Una stringa che ha le seguenti interpretazioni di caratteri speciali.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonS3/latest/userguide/s3-select-sql-reference-date.html)

### Esempi
<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>

Data una stringa, `TO_TIMESTAMP` la converte in un timestamp. `TO_TIMESTAMP` è l'operazione inversa di `TO_STRING`.

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

```
TO_TIMESTAMP ( string )
```

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

 *`string`*   
La stringa di destinazione su cui viene eseguita la funzione.

### Esempi
<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>

Restituisce l'ora corrente in UTC come timestamp.

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

```
UTCNOW()
```

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

`UTCNOW` non prende parametri.

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

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

# Funzioni stringa
<a name="s3-select-sql-reference-string"></a>

**Importante**  
Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select supporta le seguenti funzioni di stringa.

**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` (o `CHARACTER_LENGTH`) conta il numero di caratteri della stringa specificata.

**Nota**  
`CHAR_LENGTH` e `CHARACTER_LENGTH` sono sinonimi.

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

```
CHAR_LENGTH ( string )
```

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

 *`string`*   
La stringa di destinazione su cui viene eseguita la funzione.

### Esempi
<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>

Data una stringa, `LOWER` converte tutti i caratteri maiuscoli in minuscoli. I caratteri non maiuscoli rimangono invariati.

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

```
LOWER ( string )
```

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

 **`string`**   
La stringa di destinazione su cui viene eseguita la funzione.

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

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

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

Dati una stringa, un indice iniziale e, facoltativamente, una lunghezza, `SUBSTRING` restituisce la sottostringa dall'indice iniziale fino alla fine della stringa oppure fino alla lunghezza specificata.

**Nota**  
Il primo carattere della stringa di input ha indice 1.  
 Se `start` è < 1, senza una lunghezza specificata allora viene impostato su 1. 
 Se `start` è < 1, con una lunghezza specificata, allora la posizione dell'ndice viene impostata su `start + length -1`. 
 Se `start + length -1` < 0 allora viene restituita una stringa vuota. 
 Se `start + length -1` > = 0 allora viene restituita la sottostringa che inizia dall'indice 1 con lunghezza `start + length - 1`. 

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

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

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

 **`string`**   
La stringa di destinazione su cui viene eseguita la funzione.

 **`start`**   
La posizione iniziale della stringa.

 **`length`**   
La lunghezza della sottostringa da restituire. Se non è presente, procede fino alla fine della stringa.

### Esempi
<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>

Taglia i caratteri iniziali o finali di una stringa. Il carattere di default da rimuovere è uno spazio (`' '`).

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

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

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

 **`string`**   
La stringa di destinazione su cui viene eseguita la funzione.

 `LEADING` \$1 `TRAILING` \$1 `BOTH`   
Il parametro indica se tagliare i caratteri iniziali o finali o entrambi.

 **`remove_chars`**   
Il set di caratteri da rimuovere. `remove_chars` può essere una stringa con lunghezza > 1. Questa funzione restituisce la stringa da cui sono stati rimossi i caratteri specificati in `remove_chars` trovati all'inizio o alla fine della stringa.

### Esempi
<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>

Data una stringa, `UPPER` converte tutti i caratteri minuscoli in maiuscoli. I caratteri non minuscoli rimangono invariati.

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

```
UPPER ( string )
```

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

 **`string`**   
La stringa di destinazione su cui viene eseguita la funzione.

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

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