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à.

# 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!@#$'
```