Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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 stringa
**Topics**
+ [\$1\$1 (Concatenamento) Operatore](r_concat_op.md)
+ [Funzione ASCII](r_ASCII.md)
+ [Funzione BPCHARCMP](r_BPCHARCMP.md)
+ [Funzione BTRIM](r_BTRIM.md)
+ [Funzione BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md)
+ [Funzione CHAR\$1LENGTH](r_CHAR_LENGTH.md)
+ [Funzione CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md)
+ [Funzione CHARINDEX](r_CHARINDEX.md)
+ [Funzione CHR](r_CHR.md)
+ [Funzione COLLATE](r_COLLATE.md)
+ [Funzione CONCAT](r_CONCAT.md)
+ [CRC32 funzione](crc32-function.md)
+ [Funzione DIFFERENCE](DIFFERENCE.md)
+ [Funzione INITCAP](r_INITCAP.md)
+ [Funzioni LEFT e RIGHT](r_LEFT.md)
+ [Funzione LEN](r_LEN.md)
+ [Funzione LENGTH](r_LENGTH.md)
+ [Funzione LOWER](r_LOWER.md)
+ [Funzioni LPAD e RPAD](r_LPAD.md)
+ [Funzione LTRIM](r_LTRIM.md)
+ [Funzione OCTETINDEX](OCTETINDEX.md)
+ [Funzione OCTET\$1LENGTH](r_OCTET_LENGTH.md)
+ [Funzione POSITION](r_POSITION.md)
+ [Funzione QUOTE\$1IDENT](r_QUOTE_IDENT.md)
+ [Funzione QUOTE\$1LITERAL](r_QUOTE_LITERAL.md)
+ [Funzione REGEXP\$1COUNT](REGEXP_COUNT.md)
+ [Funzione REGEXP\$1INSTR](REGEXP_INSTR.md)
+ [Funzione REGEXP\$1REPLACE](REGEXP_REPLACE.md)
+ [Funzione REGEXP\$1SUBSTR](REGEXP_SUBSTR.md)
+ [Funzione REPEAT](r_REPEAT.md)
+ [Funzione REPLACE](r_REPLACE.md)
+ [Funzione REPLICATE](r_REPLICATE.md)
+ [Funzione REVERSE](r_REVERSE.md)
+ [Funzione RTRIM](r_RTRIM.md)
+ [Funzione SOUNDEX](SOUNDEX.md)
+ [Funzione SPLIT\$1PART](SPLIT_PART.md)
+ [Funzione STRPOS](r_STRPOS.md)
+ [Funzione STRTOL](r_STRTOL.md)
+ [Funzione SUBSTRING](r_SUBSTRING.md)
+ [Funzione TEXTLEN](r_TEXTLEN.md)
+ [Funzione TRANSLATE](r_TRANSLATE.md)
+ [Funzione TRIM](r_TRIM.md)
+ [Funzione UPPER](r_UPPER.md)
Le funzioni di stringa elaborano e manipolano stringhe di caratteri o espressioni che valutano le stringhe di caratteri. Quando l'argomento *stringa* in queste funzioni è un valore letterale, deve essere racchiuso tra virgolette singole. I tipi di dati supportati includono CHAR e VARCHAR.
La seguente sezione fornisce i nomi della funzione, la sintassi e le descrizioni per le funzioni supportate. Tutti gli offset in stringhe sono basati su uno.
**Funzioni solo sul nodo principale obsolete**
Le seguenti funzioni di stringa sono deprecate perché vengono eseguite solo sul nodo principale. Per ulteriori informazioni, consultare [Nodo principale: solo funzioni](c_SQL_functions_leader_node_only.md)
+ GET\$1BYTE
+ SET\$1BIT
+ SET\$1BYTE
+ TO\$1ASCII
# \$1\$1 (Concatenamento) Operatore
Concatena due espressioni su entrambi i lati del simbolo `||` e restituisce l'espressione concatenata.
Simile a [Funzione CONCAT](r_CONCAT.md).
**Nota**
Se una o entrambe le espressioni sono nulle, il risultato della concatenazione è `NULL`.
## Sintassi
```
expression1 || expression2
```
## Arguments (Argomenti)
*expression1*
Una stringa `CHAR`, una stringa `VARCHAR`, un'espressione binaria o un'espressione che restituisce uno di questi tipi.
*expression2*
Una stringa `CHAR`, una stringa `VARCHAR`, un'espressione binaria o un'espressione che restituisce uno di questi tipi.
## Tipo restituito
Il tipo di dati della stringa è lo stesso tipo degli argomenti di input. Ad esempio, concatenando due stringhe di tipo `VARCHAR` restituisce una stringa di tipo `VARCHAR`.
## Esempi
Gli esempi seguenti utilizzano la tabella USERS e VENUE dal database di esempio di TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per concatenare i campi FIRSTNAME e LASTNAME dalla tabella USERS nel database di esempio, usa l'esempio seguente.
```
SELECT (firstname || ' ' || lastname) as fullname
FROM users
ORDER BY 1
LIMIT 10;
+-----------------+
| fullname |
+-----------------+
| Aaron Banks |
| Aaron Booth |
| Aaron Browning |
| Aaron Burnett |
| Aaron Casey |
| Aaron Cash |
| Aaron Castro |
| Aaron Dickerson |
| Aaron Dixon |
| Aaron Dotson |
+-----------------+
```
Per concatenare le colonne che potrebbero contenere valori null, utilizzare l'espressione [Funzioni NVL e COALESCE](r_NVL_function.md). Il seguente esempio utilizza NVL per restituire uno `0` ogni volta che si incontra `NULL`.
```
SELECT (venuename || ' seats ' || NVL(venueseats, 0)) as seating
FROM venue
WHERE venuestate = 'NV' or venuestate = 'NC'
ORDER BY 1
LIMIT 10;
+-------------------------------------+
| seating |
+-------------------------------------+
| Ballys Hotel seats 0 |
| Bank of America Stadium seats 73298 |
| Bellagio Hotel seats 0 |
| Caesars Palace seats 0 |
| Harrahs Hotel seats 0 |
| Hilton Hotel seats 0 |
| Luxor Hotel seats 0 |
| Mandalay Bay Hotel seats 0 |
| Mirage Hotel seats 0 |
| New York New York seats 0 |
+-------------------------------------+
```
# Funzione ASCII
La funzione ASCII restituisce il codice ASCII, o il punto di codice Unicode, del primo carattere della stringa specificata. Se la stringa è vuota la funzione restituisce `0`. Restituisce `NULL` se la stringa è null.
## Sintassi
```
ASCII('string')
```
## Argomento
*stringa*
Una stringa `CHAR` o una stringa `VARCHAR`.
## Tipo restituito
INTEGER
## Esempi
Per restituire `NULL`, utilizza l'esempio seguente. La funzione NULLIF restituisce `NULL` se i due argomenti sono uguali, pertanto l'argomento di input per la funzione ASCII è `NULL`. Per ulteriori informazioni, consulta [Funzione NULLIF](r_NULLIF_function.md).
```
SELECT ASCII(NULLIF('',''));
+-------+
| ascii |
+-------+
| NULL |
+-------+
```
Per restituire il codice ASCII 0, utilizza l'esempio seguente.
```
SELECT ASCII('');
+-------+
| ascii |
+-------+
| 0 |
+-------+
```
Per restituire il codice ASCII 97 per la prima lettera della parola amazon, utilizza l'esempio seguente.
```
SELECT ASCII('amazon');
+-------+
| ascii |
+-------+
| 97 |
+-------+
```
Per restituire il codice ASCII 65 per la prima lettera della parola Amazon, utilizza l'esempio seguente.
```
SELECT ASCII('Amazon');
+-------+
| ascii |
+-------+
| 65 |
+-------+
```
# Funzione BPCHARCMP
Confronta il valore di due stringhe e restituisce un integer. Se le stringhe sono identiche, la funzione restituisce `0`. Se la prima stringa è alfabeticamente posteriore, la funzione restituisce `1`. Se la seconda stringa è maggiore, la funzione restituisce `-1`.
Per i caratteri multibyte, il confronto si basa sulla codifica dei byte.
Sinonimo di [Funzione BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md).
## Sintassi
```
BPCHARCMP(string1, string2)
```
## Arguments (Argomenti)
*string1*
Una stringa `CHAR` o una stringa `VARCHAR`.
*string2*
Una stringa `CHAR` o una stringa `VARCHAR`.
## Tipo restituito
INTEGER
## Esempi
Gli esempi seguenti utilizzano la tabella USERS dal database di esempio di TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per determinare se il nome di un utente è alfabeticamente maggiore rispetto al cognome dell'utente per le prime dieci voci nella tabella USERS, utilizza l'esempio seguente. È possibile vedere che per le voci in cui la stringa per FIRSTNAME è successiva in ordine alfabetico rispetto a LASTNAME, la funzione restituisce `1`. Se LASTNAME in ordine alfabetico viene dopo FIRSTNAME, la funzione restituisce `-1`.
```
SELECT userid, firstname, lastname, BPCHARCMP(firstname, lastname)
FROM users
ORDER BY 1, 2, 3, 4
LIMIT 10;
+--------+-----------+-----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+-----------+-----------+
| 1 | Rafael | Taylor | -1 |
| 2 | Vladimir | Humphrey | 1 |
| 3 | Lars | Ratliff | -1 |
| 4 | Barry | Roy | -1 |
| 5 | Reagan | Hodge | 1 |
| 6 | Victor | Hernandez | 1 |
| 7 | Tamekah | Juarez | 1 |
| 8 | Colton | Roy | -1 |
| 9 | Mufutau | Watkins | -1 |
| 10 | Naida | Calderon | 1 |
+--------+-----------+-----------+-----------+
```
Per restituire tutte le voci nella tabella USERS in cui la funzione restituisce `0`, utilizza l'esempio seguente. La funzione restituisce `0` quando FIRSTNAME è identico a LASTNAME.
```
SELECT userid, firstname, lastname,
BPCHARCMP(firstname, lastname)
FROM users
WHERE BPCHARCMP(firstname, lastname)=0
ORDER BY 1, 2, 3, 4;
+--------+-----------+----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+----------+-----------+
| 62 | Chase | Chase | 0 |
| 4008 | Whitney | Whitney | 0 |
| 12516 | Graham | Graham | 0 |
| 13570 | Harper | Harper | 0 |
| 16712 | Cooper | Cooper | 0 |
| 18359 | Chase | Chase | 0 |
| 27530 | Bradley | Bradley | 0 |
| 31204 | Harding | Harding | 0 |
+--------+-----------+----------+-----------+
```
# Funzione BTRIM
La funzione BTRIM riduce una stringa rimuovendo spazi vuoti iniziali e finali o rimuovendo i caratteri iniziali e finali che corrispondono a una stringa specificata facoltativa.
## Sintassi
```
BTRIM(string [, trim_chars ] )
```
## Arguments (Argomenti)
*stringa*
La stringa VARCHAR di input da ridurre.
*trim\$1chars*
La stringa VARCHAR contenente i caratteri da abbinare.
## Tipo restituito
La funzione BTRIM restituisce una stringa VARCHAR.
## Esempi
L'esempio seguente riduce gli spazi vuoti iniziali e finali dalla stringa `' abc '`:
```
select ' abc ' as untrim, btrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
L'esempio seguente rimuove le stringhe `'xyz'` iniziali e finali dalla stringa `'xyzaxyzbxyzcxyz'`. Le occorrenze iniziali e finali di `'xyz'` vengono rimosse, ma le occorrenze interne alla stringa non vengono rimosse.
```
select 'xyzaxyzbxyzcxyz' as untrim,
btrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | axyzbxyzc
```
L'esempio seguente rimuove le parti iniziale e finale dalla stringa `'setuphistorycassettes'` che corrispondono a uno qualsiasi dei caratteri nell'elenco `'tes'` *trim\$1chars*. Qualsiasi carattere `t`, `e` o `s` che si verifica prima di un altro carattere che non è nell'elenco *trim\$1chars* all'inizio o alla fine della stringa di input viene rimosso.
```
SELECT btrim('setuphistorycassettes', 'tes');
btrim
-----------------
uphistoryca
```
# Funzione BTTEXT\$1PATTERN\$1CMP
Sinonimo della funzione BPCHARCMP.
Per informazioni dettagliate, consultare [Funzione BPCHARCMP](r_BPCHARCMP.md).
# Funzione CHAR\$1LENGTH
Sinonimo della funzione LEN.
Per informazioni, consulta [Funzione LEN](r_LEN.md).
# Funzione CHARACTER\$1LENGTH
Sinonimo della funzione LEN.
Per informazioni, consulta [Funzione LEN](r_LEN.md).
# Funzione CHARINDEX
Restituisce la posizione della sottostringa specificata all'interno di una stringa.
Per funzioni simili, consulta [Funzione POSITION](r_POSITION.md) e [Funzione STRPOS](r_STRPOS.md).
## Sintassi
```
CHARINDEX( substring, string )
```
## Arguments (Argomenti)
*sottostringa*
La sottostringa da cercare all'interno della *stringa*.
*stringa*
La stringa o colonna da ricercare.
## Tipo restituito
INTEGER
La funzione CHARINDEX restituisce un valore `INTEGER` corrispondente alla posizione della sottostringa (basata su uno, non su zero). La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. CHARINDEX restituisce `0` se la sottostringa non si trova all'interno della stringa.
## Esempi
Per restituire la posizione della stringa `fish` all'interno della parola `dog`, utilizza l'esempio seguente.
```
SELECT CHARINDEX('fish', 'dog');
+-----------+
| charindex |
+-----------+
| 0 |
+-----------+
```
Per restituire la posizione della stringa `fish` all'interno della parola `dogfish`, utilizza l'esempio seguente.
```
SELECT CHARINDEX('fish', 'dogfish');
+-----------+
| charindex |
+-----------+
| 4 |
+-----------+
```
Nell'esempio seguente viene utilizzata la tabella SALES del database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per restituire il numero di transazioni di vendita distinte con una commissione superiore a 999,00 dalla tabella SALES, utilizza l'esempio seguente. Questo comando conta le commissioni superiori a 999,00 controllando se il valore decimale è superiore a 4 posizioni dall'inizio del valore della commissione.
```
SELECT DISTINCT CHARINDEX('.', commission), COUNT (CHARINDEX('.', commission))
FROM sales
WHERE CHARINDEX('.', commission) > 4
GROUP BY CHARINDEX('.', commission)
ORDER BY 1,2;
+-----------+-------+
| charindex | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# Funzione CHR
La funzione CHR restituisce il carattere che corrisponde al valore del punto di codice ASCII specificato dal parametro di input.
## Sintassi
```
CHR(number)
```
## Argomento
*numero*
Il parametro di input è un valore `INTEGER` che rappresenta un valore del punto di codice ASCII.
## Tipo restituito
CHAR
La funzione CHR restituisce una stringa `CHAR` se un carattere ASCII corrisponde al valore di input. Se il numero di input non ha corrispondenza ASCII, la funzione restituisce `NULL`.
## Esempi
Per restituire il carattere che corrisponde al punto 0 del codice ASCII, utilizza l'esempio seguente. La funzione CHR restituisce `NULL` per l'input `0`.
```
SELECT CHR(0);
+-----+
| chr |
+-----+
| |
+-----+
```
Per restituire il carattere che corrisponde al punto 65 del codice ASCII, utilizza l'esempio seguente.
```
SELECT CHR(65);
+-----+
| chr |
+-----+
| A |
+-----+
```
Per restituire nomi di eventi distinti che iniziano con la A maiuscola (punto 65 del codice ASCII), utilizza l'esempio seguente. Nell'esempio seguente viene utilizzata la tabella EVENT del database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
```
SELECT DISTINCT eventname FROM event
WHERE SUBSTRING(eventname, 1, 1)=CHR(65) LIMIT 5;
+-----------------------+
| eventname |
+-----------------------+
| A Catered Affair |
| As You Like It |
| A Man For All Seasons |
| Alan Jackson |
| Armando Manzanero |
+-----------------------+
```
# Funzione COLLATE
La funzione COLLATE sovrascrive il confronto di una colonna o di un'espressione stringa.
Per informazioni su come creare le tabelle mediante il confronto di database, consultare [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Per informazioni su come creare i database mediante il confronto di database, consultare [CREATE DATABASE](r_CREATE_DATABASE.md).
## Sintassi
```
COLLATE( string, 'case_sensitive' | 'cs' | 'case_insensitive' | 'ci');
```
## Arguments (Argomenti)
*stringa*
Una colonna o un'espressione di stringa che desideri sovrascrivere.
*'case\$1sensitive'* \$1 *'cs'* \$1 *'case\$1insensitive'* \$1 *'ci'*
Una costante di stringa di un nome di confronto. Amazon Redshift supporta solo i valori seguenti per questo parametro:
+ *case\$1sensitive*
+ *cs*
+ *case\$1insensitive*
+ *ci*
*case\$1sensitive* e *cs* sono intercambiabili e producono gli stessi risultati. Allo stesso modo *case\$1insensitive* e *ci* sono intercambiabili e producono gli stessi risultati.
## Tipo restituito
La funzione COLLATE restituisce `VARCHAR`, `CHAR` o `SUPER` a seconda del primo tipo di espressione di input. Questa funzione modifica il confronto solo del primo argomento di input e non ne modifica il valore di output.
## Esempi
Per creare la tabella T e definire col1 nella tabella T come `case_sensitive`, utilizza il seguente esempio.
```
CREATE TABLE T ( col1 Varchar(20) COLLATE case_sensitive );
INSERT INTO T VALUES ('john'),('JOHN');
```
Quando esegui la prima query, Amazon Redshift restituisce solo `john`. Dopo che la funzione COLLATE viene eseguita su col1, il confronto diventa `case_insensitive`. La seconda query restituisce sia `john` che `JOHN`.
```
SELECT * FROM T WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
+------+
SELECT * FROM T WHERE COLLATE(col1, 'case_insensitive') = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
```
Per creare la tabella A e definire col1 nella tabella A come `case_insensitive`, utilizza il seguente esempio.
```
CREATE TABLE A ( col1 Varchar(20) COLLATE case_insensitive );
INSERT INTO A VALUES ('john'),('JOHN');
```
Quando esegui la prima query, Amazon Redshift restituisce sia `john` che `JOHN`. Dopo che la funzione COLLATE viene eseguita su col1, il confronto diventa `case_sensitive`. La seconda query restituisce solo `john`.
```
SELECT * FROM A WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
SELECT * FROM A WHERE COLLATE(col1, 'case_sensitive') = 'john';
+------+
| col1 |
+------+
| john |
+------+
```
# Funzione CONCAT
La funzione CONCAT concatena due espressioni e restituisce l'espressione risultante. Per concatenare più di due espressioni, utilizzare le funzioni CONCAT nidificate. L'operatore di concatenazione (`||`) tra due espressioni produce gli stessi risultati della funzione CONCAT.
## Sintassi
```
CONCAT ( expression1, expression2 )
```
## Arguments (Argomenti)
*expression1*, *expression2*
Entrambi gli argomenti possono essere una stringa di caratteri a lunghezza fissa, una stringa di caratteri a lunghezza variabile, un'espressione binaria o un'espressione che valuta uno di questi input.
## Tipo restituito
CONCAT restituisce un'espressione. Il tipo di dati dell'espressione è lo stesso tipo degli argomenti di input.
Se le espressioni di input sono di tipo diverso, Amazon Redshift tenta di digitare implicitamente una delle espressioni. Se non è possibile eseguire il cast di valori, viene restituito il valore nullo.
## Note per l'utilizzo
+ Sia per la funzione CONCAT sia per l'operatore di concatenazione, se una o entrambe le espressioni sono nulle, il risultato della concatenazione è nullo.
## Esempi
L'esempio seguente concatena due letterali di caratteri:
```
SELECT CONCAT('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
La seguente query, utilizzando l'operatore `||` invece di CONCAT, produce lo stesso risultato:
```
SELECT 'December 25, '||'2008';
?column?
-------------------
December 25, 2008
(1 row)
```
L'esempio seguente utilizza una funzione CONCAT nidificata all'interno di un'altra funzione CONCAT per concatenare tre stringhe di caratteri:
```
SELECT CONCAT('Thursday, ', CONCAT('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Per concatenare colonne che potrebbero contenere NULLs, usa il[Funzioni NVL e COALESCE](r_NVL_function.md), che restituisce un determinato valore quando incontra NULL. Il seguente esempio utilizza NVL per restituire uno 0 ogni volta che si incontra NULL.
```
SELECT CONCAT(venuename, CONCAT(' seats ', NVL(venueseats, 0))) AS seating
FROM venue WHERE venuestate = 'NV' OR venuestate = 'NC'
ORDER BY 1
LIMIT 5;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
(5 rows)
```
La query seguente concatena i valori CITY e STATE dalla tabella VENUE:
```
SELECT CONCAT(venuecity, venuestate)
FROM venue
WHERE venueseats > 75000
ORDER BY venueseats;
concat
-------------------
DenverCO
Kansas CityMO
East RutherfordNJ
LandoverMD
(4 rows)
```
La seguente query utilizza funzioni CONCAT nidificate. La query concatena i valori CITY e STATE dalla tabella VENUE ma delimita la stringa risultante con una virgola e uno spazio:
```
SELECT CONCAT(CONCAT(venuecity,', '),venuestate)
FROM venue
WHERE venueseats > 75000
ORDER BY venueseats;
concat
---------------------
Denver, CO
Kansas City, MO
East Rutherford, NJ
Landover, MD
(4 rows)
```
L'esempio seguente concatena due espressioni binarie. Dove `abc` è un valore binario (con una rappresentazione esadecimale di `616263`) e `def` è un valore binario (con rappresentazione esadecimale di `646566`). Il risultato viene visualizzato automaticamente come rappresentazione esadecimale del valore binario.
```
SELECT CONCAT('abc'::VARBYTE, 'def'::VARBYTE);
concat
-------------------
616263646566
```
# CRC32 funzione
CRC32 è una funzione utilizzata per il rilevamento degli errori. La funzione utilizza un CRC32 algoritmo per rilevare le modifiche tra i dati di origine e quelli di destinazione. La CRC32 funzione converte una stringa di lunghezza variabile in una stringa di 8 caratteri che è una rappresentazione testuale del valore esadecimale di una sequenza binaria a 32 bit. Per rilevare le modifiche tra i dati di origine e di destinazione, utilizzate la funzione sui dati di origine e memorizzate l'output CRC32 . Quindi, utilizzate la CRC32 funzione sui dati di destinazione e confrontate l'output con l'output dei dati di origine. Se i dati non sono stati modificati, gli output saranno gli stessi, altrimenti, gli output saranno diversi.
## Sintassi
```
CRC32(string)
```
## Arguments (Argomenti)
*stringa*
Una stringa `CHAR`, una stringa `VARCHAR` o un'espressione che restituisce implicitamente un tipo `CHAR` o `VARCHAR`.
## Tipo restituito
La CRC32 funzione restituisce una stringa di 8 caratteri che è una rappresentazione testuale del valore esadecimale di una sequenza binaria a 32 bit. La CRC32 funzione Amazon Redshift si basa sul polinomio CRC-32C.
## Esempi
Mostrare il valore a 8 bit per la stringa `Amazon Redshift`.
```
SELECT CRC32('Amazon Redshift');
+----------+
| crc32 |
+----------+
| f2726906 |
+----------+
```
# Funzione DIFFERENCE
La funzione DIFFERENCE confronta i codici American Soundex di due stringhe. La funzione restituisce un valore `INTEGER` per indicare il numero di caratteri corrispondenti tra i codici Soundex.
Un codice Soundex è una stringa lunga quattro caratteri. Un codice Soundex rappresenta la fonetica di una parola anziché il modo in cui viene scritta. Ad esempio `Smith` e `Smyth` hanno lo stesso codice Soundex.
## Sintassi
```
DIFFERENCE(string1, string2)
```
## Arguments (Argomenti)
*string1*
Una stringa `CHAR`, una stringa `VARCHAR` o un'espressione che restituisce implicitamente un tipo `CHAR` o `VARCHAR`.
*string2*
Una stringa `CHAR`, una stringa `VARCHAR` o un'espressione che restituisce implicitamente un tipo `CHAR` o `VARCHAR`.
## Tipo restituito
INTEGER
La funzione DIFFERENCE restituisce un valore `INTEGER` da 0 a 4 che conta il numero di caratteri corrispondenti nei codici American Soundex delle due stringhe. Un codice Soundex ha 4 caratteri, quindi la funzione DIFFERENCE restituisce `4` quando tutti e 4 i caratteri dei valori del codice American Soundex delle stringhe sono uguali. DIFFERENCE restituisce `0` se una delle due stringhe è vuota. La funzione restituisce `1` se nessuna stringa contiene caratteri validi. La funzione DIFFERENCE converte solo caratteri ASCII alfabetici minuscoli o maiuscoli inglesi, inclusi a-z e A-Z. DIFFERENCE ignora gli altri caratteri.
## Esempi
Per confrontare i valori Soundex delle stringhe `%` e `@`, utilizza l'esempio seguente. La funzione restituisce `1` poiché nessuna stringa contiene caratteri validi.
```
SELECT DIFFERENCE('%', '@');
+------------+
| difference |
+------------+
| 1 |
+------------+
```
Per confrontare i valori Soundex di `Amazon` e di una stringa vuota, utilizza l'esempio seguente. La funzione restituisce `0` poiché una delle due stringhe è vuota.
```
SELECT DIFFERENCE('Amazon', '');
+------------+
| difference |
+------------+
| 0 |
+------------+
```
Per confrontare i valori Soundex delle stringhe `Amazon` e `Ama`, utilizza l'esempio seguente. La funzione restituisce `2` perché 2 caratteri dei valori Soundex delle stringhe sono uguali.
```
SELECT DIFFERENCE('Amazon', 'Ama');
+------------+
| difference |
+------------+
| 2 |
+------------+
```
Per confrontare i valori Soundex delle stringhe `Amazon` e `+-*/%Amazon`, utilizza l'esempio seguente. La funzione restituisce `4` perché tutti e 4 i caratteri dei valori Soundex delle stringhe sono uguali. Tieni presente che la funzione ignora i caratteri `+-*/%` non validi nella seconda stringa.
```
SELECT DIFFERENCE('Amazon', '+-*/%Amazon');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
Per confrontare i valori Soundex delle stringhe `AC/DC` e `Ay See Dee See`, utilizza l'esempio seguente. La funzione restituisce `4` perché tutti e 4 i caratteri dei valori Soundex delle stringhe sono uguali.
```
SELECT DIFFERENCE('AC/DC', 'Ay See Dee See');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
# Funzione INITCAP
Scrive con la lettera maiuscola la prima lettera di ogni parola in una stringa specificata. INITCAP supporta caratteri multibyte UTF-8, fino a un massimo di quattro byte per carattere.
## Sintassi
```
INITCAP(string)
```
## Argomento
*stringa*
Una stringa `CHAR`, una stringa `VARCHAR` o un'espressione che restituisce implicitamente un tipo `CHAR` o `VARCHAR`.
## Tipo restituito
VARCHAR
## Note per l'utilizzo
La funzione INITCAP rende maiuscola la prima lettera di ogni parola in una stringa e rende (o lascia) minuscole tutte le lettere successive. Pertanto, è importante capire quali caratteri (diversi dai caratteri di spazio) fungono da separatori di parole. Un carattere *separatore di parole* è un carattere non alfanumerico, compresi i segni di punteggiatura, i simboli e i caratteri di controllo. Tutti i seguenti caratteri sono separatori di parole:
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Le schede, i caratteri di nuova riga, i feed del modulo, i feed di riga e i rimandi a capo sono anch'essi separatori di parole.
## Esempi
Gli esempi seguenti utilizzano i dati delle tabelle CATEGORY e USERS dal database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per scrivere in maiuscolo le iniziali di ciascuna parola nella colonna CATDESC, utilizza l'esempio seguente.
```
SELECT catid, catdesc, INITCAP(catdesc)
FROM category
ORDER BY 1, 2, 3;
+-------+--------------------------------------------+--------------------------------------------+
| catid | catdesc | initcap |
+-------+--------------------------------------------+--------------------------------------------+
| 1 | Major League Baseball | Major League Baseball |
| 2 | National Hockey League | National Hockey League |
| 3 | National Football League | National Football League |
| 4 | National Basketball Association | National Basketball Association |
| 5 | Major League Soccer | Major League Soccer |
| 6 | Musical theatre | Musical Theatre |
| 7 | All non-musical theatre | All Non-Musical Theatre |
| 8 | All opera and light opera | All Opera And Light Opera |
| 9 | All rock and pop music concerts | All Rock And Pop Music Concerts |
| 10 | All jazz singers and bands | All Jazz Singers And Bands |
| 11 | All symphony, concerto, and choir concerts | All Symphony, Concerto, And Choir Concerts |
+-------+--------------------------------------------+--------------------------------------------+
```
Per mostrare che la funzione INITCAP non conserva i caratteri maiuscoli quando non si trovano all'inizio delle parole, utilizza l'esempio seguente. Ad esempio, la stringa `MLB` diventa `Mlb`.
```
SELECT INITCAP(catname)
FROM category
ORDER BY catname;
+-----------+
| initcap |
+-----------+
| Classical |
| Jazz |
| Mlb |
| Mls |
| Musicals |
| Nba |
| Nfl |
| Nhl |
| Opera |
| Plays |
| Pop |
+-----------+
```
Per mostrare che i caratteri non alfanumerici diversi dagli spazi funzionano come separatori di parole, utilizza l'esempio seguente. Diverse lettere di ogni stringa verranno scritte in maiuscolo.
```
SELECT email, INITCAP(email)
FROM users
ORDER BY userid DESC LIMIT 5;
+------------------------------------+------------------------------------+
| email | initcap |
+------------------------------------+------------------------------------+
| urna.Ut@egetdictumplacerat.edu | Urna.Ut@Egetdictumplacerat.Edu |
| nibh.enim@egestas.ca | Nibh.Enim@Egestas.Ca |
| in@Donecat.ca | In@Donecat.Ca |
| sodales@blanditviverraDonec.ca | Sodales@Blanditviverradonec.Ca |
| sociis.natoque.penatibus@vitae.org | Sociis.Natoque.Penatibus@Vitae.Org |
+------------------------------------+------------------------------------+
```
# Funzioni LEFT e RIGHT
Queste funzioni restituiscono il numero specificato di caratteri più a sinistra o più a destra da una stringa di caratteri.
Il numero si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli.
## Sintassi
```
LEFT( string, integer )
RIGHT( string, integer )
```
## Arguments (Argomenti)
*stringa*
Una stringa `CHAR`, una stringa `VARCHAR` o un'espressione che restituisce una stringa `CHAR` o `VARCHAR`.
*integer*
Un integer positivo.
## Tipo restituito
VARCHAR
## Esempi
Nell'esempio seguente vengono utilizzati i dati della tabella EVENT del database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per restituire i 5 caratteri più a sinistra e i 5 caratteri più a destra dei nomi di eventi con eventi compresi tra 1000 e 1005, usa il seguente esempio. IDs
```
SELECT eventid, eventname,
LEFT(eventname,5) AS left_5,
RIGHT(eventname,5) AS right_5
FROM event
WHERE eventid BETWEEN 1000 AND 1005
ORDER BY 1;
+---------+----------------+--------+---------+
| eventid | eventname | left_5 | right_5 |
+---------+----------------+--------+---------+
| 1000 | Gypsy | Gypsy | Gypsy |
| 1001 | Chicago | Chica | icago |
| 1002 | The King and I | The K | and I |
| 1003 | Pal Joey | Pal J | Joey |
| 1004 | Grease | Greas | rease |
| 1005 | Chicago | Chica | icago |
+---------+----------------+--------+---------+
```
# Funzione LEN
Restituisce la lunghezza della stringa specificata come numero di caratteri.
## Sintassi
LEN è un sinonimo di [Funzione LENGTH](r_LENGTH.md), [Funzione CHAR\$1LENGTH](r_CHAR_LENGTH.md), [Funzione CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md), e [Funzione TEXTLEN](r_TEXTLEN.md).
```
LEN(expression)
```
## Argomento
*espressione*
Una stringa `CHAR`, una stringa `VARCHAR`, un'espressione `VARBYTE` o un'espressione che restituisce implicitamente un tipo `CHAR`, `VARCHAR` o `VARBYTE`.
## Tipo restituito
INTEGER
La funzione LEN restituisce un integer che indica il numero di caratteri nella stringa di input.
Se la stringa di input è una stringa di caratteri, la funzione LEN restituisce il numero effettivo di caratteri nelle stringhe multi-byte, non il numero di byte. Ad esempio, è necessaria una colonna `VARCHAR(12)` per archiviare tre caratteri cinesi a quattro byte. La funzione LEN restituirà `3` per quella stessa stringa. Per ottenere la lunghezza di una stringa in byte, utilizzare la funzione [OCTET\$1LENGTH](r_OCTET_LENGTH.md).
## Note per l'utilizzo
Se *expression* è una stringa `CHAR`, gli spazi finali non vengono contati.
Se *expression* è una stringa `VARCHAR`, gli spazi finali vengono contati.
## Esempi
Per restituire il numero di byte e il numero di caratteri nella stringa `français`, utilizza l'esempio seguente.
```
SELECT OCTET_LENGTH('français'),
LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Per restituire il numero di byte e il numero di caratteri nella stringa `français` senza utilizzare la funzione OCTET\$1LENGTH, utilizza l'esempio seguente. Per ulteriori informazioni, consulta [Funzione CAST](r_CAST_function.md).
```
SELECT LEN(CAST('français' AS VARBYTE)) as bytes, LEN('français');
+-------+-----+
| bytes | len |
+-------+-----+
| 9 | 8 |
+-------+-----+
```
Per restituire il numero di caratteri nelle stringhe `cat` senza spazi finali, `cat ` con tre spazi finali, `cat ` con conversione di tre spazi finali come `CHAR` di lunghezza 6 e `cat ` con conversione di tre spazi finali come `VARCHAR` di lunghezza 6, utilizza l'esempio seguente. Tieni presente che la funzione non conta gli spazi finali per le stringhe `CHAR`, ma conta gli spazi finali per le stringhe `VARCHAR`.
```
SELECT LEN('cat'), LEN('cat '), LEN(CAST('cat ' AS CHAR(6))) AS len_char, LEN(CAST('cat ' AS VARCHAR(6))) AS len_varchar;
+-----+-----+----------+-------------+
| len | len | len_char | len_varchar |
+-----+-----+----------+-------------+
| 3 | 6 | 3 | 6 |
+-----+-----+----------+-------------+
```
Nell'esempio seguente vengono utilizzati i dati della tabella VENUE database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per restituire i dieci nomi VENUE più lunghi nella tabella VENUE, utilizza l'esempio seguente.
```
SELECT venuename, LEN(venuename)
FROM venue
ORDER BY 2 DESC, 1
LIMIT 10;
+-----------------------------------------+-----+
| venuename | len |
+-----------------------------------------+-----+
| Saratoga Springs Performing Arts Center | 39 |
| Lincoln Center for the Performing Arts | 38 |
| Nassau Veterans Memorial Coliseum | 33 |
| Jacksonville Municipal Stadium | 30 |
| Rangers BallPark in Arlington | 29 |
| University of Phoenix Stadium | 29 |
| Circle in the Square Theatre | 28 |
| Hubert H. Humphrey Metrodome | 28 |
| Oriole Park at Camden Yards | 27 |
| Dick's Sporting Goods Park | 26 |
+-----------------------------------------+-----+
```
# Funzione LENGTH
Sinonimo della funzione LEN.
Per informazioni, consulta [Funzione LEN](r_LEN.md).
# Funzione LOWER
Converte una stringa in minuscolo. LOWER supporta caratteri multibyte UTF-8, fino a un massimo di quattro byte per carattere.
## Sintassi
```
LOWER(string)
```
## Argomento
*stringa*
Una stringa `VARCHAR` o qualsiasi espressione che restituisce il tipo `VARCHAR`.
## Tipo restituito
stringa
La funzione LOWER restituisce una stringa che appartiene allo stesso tipo di dati della stringa di input. Ad esempio, se l'input è una stringa `CHAR`, la funzione restituirà una stringa `CHAR`.
## Esempi
Nell'esempio seguente vengono utilizzati i dati della tabella CATEGORY database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per convertire le stringhe `VARCHAR` nella colonna CATNAME in lettere minuscole, utilizza l'esempio seguente.
```
SELECT catname, LOWER(catname) FROM category ORDER BY 1,2;
+-----------+-----------+
| catname | lower |
+-----------+-----------+
| Classical | classical |
| Jazz | jazz |
| MLB | mlb |
| MLS | mls |
| Musicals | musicals |
| NBA | nba |
| NFL | nfl |
| NHL | nhl |
| Opera | opera |
| Plays | plays |
| Pop | pop |
+-----------+-----------+
```
# Funzioni LPAD e RPAD
Queste funzioni antepongono o aggiungono caratteri a una stringa, in base a una lunghezza specificata.
## Sintassi
```
LPAD(string1, length, [ string2 ])
```
```
RPAD(string1, length, [ string2 ])
```
## Arguments (Argomenti)
*string1*
Una stringa `CHAR`, una stringa `VARCHAR` o un'espressione che restituisce implicitamente un tipo `CHAR` o `VARCHAR`.
*length*
Un integer che definisce la lunghezza del risultato della funzione. La lunghezza di una stringa si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Se *string1* è più lunga della lunghezza specificata, viene troncata (a destra). Se *length* è un numero negativo, il risultato della funzione è una stringa vuota.
*string2*
(Facoltativo) Uno o più caratteri anteposti o aggiunti a *string1*. Questo argomento non è specificato, vengono usati gli spazi.
## Tipo restituito
VARCHAR
## Esempi
Negli esempi seguenti vengono utilizzati i dati della tabella EVENT del database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per troncare un set specificato di nomi di eventi a 20 caratteri e anteporre ai nomi più brevi gli spazi, utilizza l'esempio seguente.
```
SELECT LPAD(eventname, 20) FROM event
WHERE eventid BETWEEN 1 AND 5 ORDER BY 1;
+---------------------+
| lpad |
+---------------------+
| Salome |
| Il Trovatore |
| Boris Godunov |
| Gotterdammerung |
|La Cenerentola (Cind |
+-----------------------+
```
Per troncare lo stesso set di nomi di eventi a 20 caratteri ma aggiungere ai nomi più brevi `0123456789`, utilizza l'esempio seguente.
```
SELECT RPAD(eventname, 20,'0123456789') FROM event
WHERE eventid BETWEEN 1 AND 5 ORDER BY 1;
+----------------------+
| rpad |
+----------------------+
| Boris Godunov0123456 |
| Gotterdammerung01234 |
| Il Trovatore01234567 |
| La Cenerentola (Cind |
| Salome01234567890123 |
+----------------------+
```
# Funzione LTRIM
Taglia i caratteri dall'inizio di una stringa. Rimuove la stringa più lunga contenente solo i caratteri nell'elenco dei caratteri di taglio. Il taglio è completo quando un carattere di taglio non appare nella stringa di input.
## Sintassi
```
LTRIM( string [, trim_chars] )
```
## Arguments (Argomenti)
*stringa*
Una stringa, una colonna, un'espressione o una stringa letterale da tagliare.
*trim\$1chars*
Una colonna o un'espressione di stringhe o un valore letterale di stringa che rappresenta i caratteri da tagliare dall'inizio della *stringa*. Se non specificato, viene utilizzato uno spazio come carattere di taglio.
## Tipo restituito
La funzione LTRIM restituisce una stringa di caratteri che appartiene allo stesso tipo di dati della *stringa* di input (CHAR o VARCHAR).
## Esempi
L'esempio seguente taglia l'anno dalla colonna `listime`. I caratteri di taglio nel valore letterale di stringa `'2008-'` indicano i caratteri da tagliare da sinistra. Se si utilizzano i caratteri di taglio `'028-'`, si ottiene lo stesso risultato.
```
select listid, listtime, ltrim(listtime, '2008-')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | ltrim
-------+---------------------+----------------
1 | 2008-01-24 06:43:29 | 1-24 06:43:29
2 | 2008-03-05 12:25:29 | 3-05 12:25:29
3 | 2008-11-01 07:35:33 | 11-01 07:35:33
4 | 2008-05-24 01:18:37 | 5-24 01:18:37
5 | 2008-05-17 02:29:11 | 5-17 02:29:11
6 | 2008-08-15 02:08:13 | 15 02:08:13
7 | 2008-11-15 09:38:15 | 11-15 09:38:15
8 | 2008-11-09 05:07:30 | 11-09 05:07:30
9 | 2008-09-09 08:03:36 | 9-09 08:03:36
10 | 2008-06-17 09:44:54 | 6-17 09:44:54
```
LTRIM rimuove tutti i caratteri in *trim\$1chars* se questi si trovano all'inizio di *stringa*. L'esempio seguente riduce i caratteri "C", "D" e "G" quando si trovano all'inizio di VENUENAME che è una colonna VARCHAR.
```
select venueid, venuename, ltrim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
L'esempio seguente utilizza il carattere di taglio `2` che viene recuperato dalla colonna `venueid`.
```
select ltrim('2008-01-24 06:43:29', venueid)
from venue where venueid=2;
ltrim
------------------
008-01-24 06:43:29
```
L'esempio seguente non taglia alcun carattere perché prima del carattere di taglio `'0'` è presente un `2`.
```
select ltrim('2008-01-24 06:43:29', '0');
ltrim
-------------------
2008-01-24 06:43:29
```
L'esempio seguente utilizza il carattere di taglio dello spazio predefinito e taglia i due spazi dall'inizio della stringa.
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# Funzione OCTETINDEX
La funzione OCTETINDEX restituisce la posizione di una sottostringa all'interno di una stringa come un numero di byte.
## Sintassi
```
OCTETINDEX(substring, string)
```
## Arguments (Argomenti)
*sottostringa*
Una stringa `CHAR`, una stringa `VARCHAR` o un'espressione che restituisce implicitamente un tipo `CHAR` o `VARCHAR`.
*stringa*
Una stringa `CHAR`, una stringa `VARCHAR` o un'espressione che restituisce implicitamente un tipo `CHAR` o `VARCHAR`.
## Tipo restituito
INTEGER
La funzione OCTETINDEX restituisce un valore `INTEGER` corrispondente alla posizione della *sottostringa* all’interno della *stringa* come un numero di byte, in cui il primo carattere della *stringa* viene conteggiato come 1. Se la *stringa* non contiene caratteri multibyte, il risultato è uguale al risultato della funzione CHARINDEX. Se la *stringa* non contiene la *sottostringa*, la funzione restituisce `0`. Se la *sottostringa* è vuota la funzione restituisce `1`.
## Esempi
Per restituire la posizione della sottostringa `q` nella stringa, utilizzate l'esempio seguente. `Amazon Redshift` Questo esempio restituisce `0` perché la *sottostringa* non è nella *stringa*.
```
SELECT OCTETINDEX('q', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 0 |
+------------+
```
Per restituire la posizione di una sottostringa vuota nella stringa`Amazon Redshift`, utilizzate l'esempio seguente. Questo esempio restituisce `1` perché la *sottostringa* è vuota.
```
SELECT OCTETINDEX('', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 1 |
+------------+
```
Per restituire la posizione della sottostringa `Redshift` nella stringa`Amazon Redshift`, utilizzate l'esempio seguente. Nell'esempio seguente viene restituito `8` perché la *sottostringa* inizia dall'ottavo byte della *stringa*.
```
SELECT OCTETINDEX('Redshift', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 8 |
+------------+
```
Per restituire la posizione della sottostringa `Redshift` nella stringa`Amazon Redshift`, utilizzate l'esempio seguente. Questo esempio restituisce `21` perché i primi sei caratteri della *stringa* sono caratteri a doppio byte.
```
SELECT OCTETINDEX('Redshift', 'Άμαζον Amazon Redshift');
+------------+
| octetindex |
+------------+
| 21 |
+------------+
```
# Funzione OCTET\$1LENGTH
Restituisce la lunghezza della stringa specificata come numero di byte.
## Sintassi
```
OCTET_LENGTH(expression)
```
## Argomento
*espressione*
Una stringa `CHAR`, una stringa `VARCHAR`, un'espressione `VARBYTE` o un'espressione che restituisce implicitamente un tipo `CHAR`, `VARCHAR` o `VARBYTE`.
## Tipo restituito
INTEGER
La funzione OCTET\$1LENGTH restituisce un integer che indica il numero di byte nella stringa di input.
Se la stringa di input è una stringa di caratteri, la funzione [LEN](r_LEN.md) restituisce il numero effettivo di caratteri nelle stringhe multi-byte, non il numero di byte. Ad esempio, è necessaria una colonna `VARCHAR(12)` per archiviare tre caratteri cinesi a quattro byte. La funzione OCTET\$1LENGTH restituirà `12` per quella stringa e la funzione LEN restituirà `3` per la stessa stringa.
## Note per l'utilizzo
Se *expression* è una stringa `CHAR`, la funzione restituisce la lunghezza della stringa `CHAR`. Ad esempio, l'output di un input `CHAR(6)` è `CHAR(6)`.
Se *expression* è una stringa `VARCHAR`, gli spazi finali vengono contati.
## Esempi
Per restituire il numero di byte quando la stringa `francais` con tre spazi finali viene convertita in un tipo `CHAR` e `VARCHAR`, utilizza l'esempio seguente. Per ulteriori informazioni, consulta [Funzione CAST](r_CAST_function.md).
```
SELECT OCTET_LENGTH(CAST('francais ' AS CHAR(15))) AS octet_length_char, OCTET_LENGTH(CAST('francais ' AS VARCHAR(15))) AS octet_length_varchar;
+-------------------+----------------------+
| octet_length_char | octet_length_varchar |
+-------------------+----------------------+
| 15 | 11 |
+-------------------+----------------------+
```
Per restituire il numero di byte e il numero di caratteri nella stringa `français`, utilizza l'esempio seguente.
```
SELECT OCTET_LENGTH('français'), LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Per restituire il numero di byte quando la stringa `français` viene convertita in `VARBYTE`, utilizza l'esempio seguente.
```
SELECT OCTET_LENGTH(CAST('français' AS VARBYTE));
+--------------+
| octet_length |
+--------------+
| 9 |
+--------------+
```
# Funzione POSITION
Restituisce la posizione della sottostringa specificata all'interno di una stringa.
Per funzioni simili, consulta [Funzione CHARINDEX](r_CHARINDEX.md) e [Funzione STRPOS](r_STRPOS.md).
## Sintassi
```
POSITION(substring IN string )
```
## Arguments (Argomenti)
*sottostringa*
La sottostringa da cercare all'interno della *stringa*.
*stringa*
La stringa o colonna da ricercare.
## Tipo restituito
La funzione POSITION restituisce un valore `INTEGER` corrispondente alla posizione della sottostringa (basata su uno, non su zero). La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. POSITION restituisce `0` se la sottostringa non si trova all'interno della stringa.
## Esempi
Per restituire la posizione della stringa `fish` all'interno della parola `dog`, utilizza l'esempio seguente.
```
SELECT POSITION('fish' IN 'dog');
+-----------+
| position |
+-----------+
| 0 |
+-----------+
```
Per restituire la posizione della stringa `fish` all'interno della parola `dogfish`, utilizza l'esempio seguente.
```
SELECT POSITION('fish' IN 'dogfish');
+-----------+
| position |
+-----------+
| 4 |
+-----------+
```
Nell'esempio seguente viene utilizzata la tabella SALES del database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per restituire il numero di transazioni di vendita distinte con una commissione superiore a 999,00 dalla tabella SALES, utilizza l'esempio seguente. Questo comando conta le commissioni superiori a 999,00 controllando se il valore decimale è superiore a 4 posizioni dall'inizio del valore della commissione.
```
SELECT DISTINCT POSITION('.' IN commission), COUNT (POSITION('.' IN commission))
FROM sales
WHERE POSITION('.' IN commission) > 4
GROUP BY POSITION('.' IN commission)
ORDER BY 1,2;
+-----------+-------+
| position | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# Funzione QUOTE\$1IDENT
La funzione QUOTE\$1IDENT restituisce la stringa specificata come una stringa con virgolette doppie iniziali e virgolette doppie finali. L'output della funzione può essere utilizzato come identificatore in un'istruzione SQL. La funzione raddoppia in modo appropriato qualsiasi virgoletta doppia incorporata.
QUOTE\$1IDENT aggiunge le doppie virgolette solo quando è necessario per creare un identificatore valido, quando la stringa contiene caratteri non identificativi o sarebbe altrimenti espressa in minuscolo. Per restituire sempre una stringa con virgoletta singola, utilizzare [QUOTE\$1LITERAL](r_QUOTE_LITERAL.md).
## Sintassi
```
QUOTE_IDENT(string)
```
## Argomento
*stringa*
Una stringa `CHAR` o `VARCHAR`.
## Tipo restituito
La funzione QUOTE\$1IDENT restituisce lo stesso tipo di stringa della *stringa* di input.
## Esempi
Per restituire la stringa `"CAT"` con virgolette doppie, utilizza l'esempio seguente.
```
SELECT QUOTE_IDENT('"CAT"');
+-------------+
| quote_ident |
+-------------+
| """CAT""" |
+-------------+
```
Nell'esempio seguente vengono utilizzati i dati della tabella CATEGORY del database TICKIT di esempio. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per restituire la colonna CATNAME racchiusa tra virgolette, utilizza l'esempio seguente.
```
SELECT catid, QUOTE_IDENT(catname)
FROM category
ORDER BY 1,2;
+-------+-------------+
| catid | quote_ident |
+-------+-------------+
| 1 | "MLB" |
| 2 | "NHL" |
| 3 | "NFL" |
| 4 | "NBA" |
| 5 | "MLS" |
| 6 | "Musicals" |
| 7 | "Plays" |
| 8 | "Opera" |
| 9 | "Pop" |
| 10 | "Jazz" |
| 11 | "Classical" |
+-------+-------------+
```
# Funzione QUOTE\$1LITERAL
La funzione QUOTE\$1LITERAL restituisce la stringa specificata come una stringa con virgoletta singola in modo che possa essere utilizzata come letterale di stringa in un'istruzione SQL. Se il parametro di input è un numero, QUOTE\$1LITERAL lo considera come una stringa. Raddoppia in modo appropriato qualsiasi virgoletta singola incorporata e barra rovesciata.
## Sintassi
```
QUOTE_LITERAL(string)
```
## Argomento
*stringa*
Una stringa `CHAR` o `VARCHAR`.
## Tipo restituito
La funzione QUOTE\$1LITERAL restituisce una stringa `CHAR` o `VARCHAR` che appartiene allo stesso tipo di dati della *stringa* di input.
## Esempi
Per restituire la stringa `''CAT''` con virgolette SINGOLE, utilizza l'esempio seguente.
```
SELECT QUOTE_LITERAL('''CAT''');
+---------------+
| quote_literal |
+---------------+
| '''CAT''' |
+---------------+
```
Negli esempi seguenti vengono utilizzati i dati della tabella CATEGORY database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per restituire la colonna CATNAME racchiusa tra virgolette singole, utilizza l'esempio seguente.
```
SELECT catid, QUOTE_LITERAL(catname)
FROM category
ORDER BY 1,2;
+-------+---------------+
| catid | quote_literal |
+-------+---------------+
| 1 | 'MLB' |
| 2 | 'NHL' |
| 3 | 'NFL' |
| 4 | 'NBA' |
| 5 | 'MLS' |
| 6 | 'Musicals' |
| 7 | 'Plays' |
| 8 | 'Opera' |
| 9 | 'Pop' |
| 10 | 'Jazz' |
| 11 | 'Classical' |
+-------+---------------+
```
Per restituire la colonna CATID racchiusa tra virgolette singole, utilizza l'esempio seguente.
```
SELECT QUOTE_LITERAL(catid), catname
FROM category
ORDER BY 1,2;
+---------------+-----------+
| quote_literal | catname |
+---------------+-----------+
| '1' | MLB |
| '10' | Jazz |
| '11' | Classical |
| '2' | NHL |
| '3' | NFL |
| '4' | NBA |
| '5' | MLS |
| '6' | Musicals |
| '7' | Plays |
| '8' | Opera |
| '9' | Pop |
+---------------+-----------+
```
# Funzione REGEXP\$1COUNT
Cerca una stringa per un modello di espressione regolare e restituisce un numero intero che indica il numero di volte in cui il modello si verifica nella stringa. Se non viene trovata alcuna corrispondenza, la funzione restituisce `0`. Per ulteriori informazioni sulle espressioni regolari, consulta [Operatori POSIX](pattern-matching-conditions-posix.md) ed [Espressione regolare](https://en.wikipedia.org/wiki/Regular_expression) in Wikipedia.
## Sintassi
```
REGEXP_COUNT( source_string, pattern [, position [, parameters ] ] )
```
## Arguments (Argomenti)
*source\$1string*
Una stringa `CHAR` o `VARCHAR`.
*pattern*
Un valore letterale di stringa UTF-8 che rappresenta un modello di espressione regolare. Per ulteriori informazioni, consulta [Operatori POSIX](pattern-matching-conditions-posix.md).
*posizione*
(Facoltativo) Un valore `INTEGER` positivo che indica la posizione all'interno di *source\$1string* per iniziare la ricerca. La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Il valore predefinito è `1`. Se *position* è inferiore a `1`, la ricerca inizia con il primo carattere di *source\$1string*. Se *position* è maggiore rispetto al numero di caratteri in *source\$1string*, il risultato è `0`.
*parameters*
(Facoltativo) Uno o più letterali di stringa che indicano come la funzione corrisponde al modello. Di seguito sono riportati i valori possibili:
+ c: eseguire una corrispondenza in base a maiuscole e minuscole. L'impostazione predefinita è utilizzare la corrispondenza con distinzione tra maiuscole e minuscole.
+ i: eseguire una corrispondenza senza distinzione tra maiuscole e minuscole.
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE). Per ulteriori informazioni su PCRE, consulta [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) in Wikipedia.
## Tipo restituito
INTEGER
## Esempi
Per contare il numero di volte in cui si verifica una sequenza di tre lettere, utilizza l'esempio seguente.
```
SELECT REGEXP_COUNT('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------+
| regexp_count |
+--------------+
| 8 |
+--------------+
```
Per contare le occorrenze della stringa `FOX` utilizzando una corrispondenza senza distinzione tra maiuscole e minuscole, utilizza l'esempio seguente.
```
SELECT REGEXP_COUNT('the fox', 'FOX', 1, 'i');
+--------------+
| regexp_count |
+--------------+
| 1 |
+--------------+
```
Per utilizzare un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola, utilizza l'esempio seguente. L'esempio utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene contato il numero di ricorrenze di tali parole, con la corrispondenza tra maiuscole e minuscole.
```
SELECT REGEXP_COUNT('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
+--------------+
| regexp_count |
+--------------+
| 2 |
+--------------+
```
Per utilizzare un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola, utilizza l'esempio seguente. Utilizza l'operatore `?=`, che ha una connotazione specifica in PCRE. In questo esempio viene contato il numero di ricorrenze di tali parole, ma differisce dall'esempio precedente in quanto utilizza la corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT REGEXP_COUNT('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
+--------------+
| regexp_count |
+--------------+
| 3 |
+--------------+
```
Nell'esempio seguente vengono utilizzati i dati della tabella USERS database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per contare il numero di volte in cui il nome di dominio di livello superiore è `org` oppure `edu`, utilizza l'esempio seguente.
```
SELECT email, REGEXP_COUNT(email,'@[^.]*\.(org|edu)') FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_count |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1 |
| Suspendisse.tristique@nonnisiAenean.edu | 1 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 0 |
| sed@lacusUtnec.ca | 0 |
+-----------------------------------------------+--------------+
```
# Funzione REGEXP\$1INSTR
Cerca una stringa per un modello di espressione regolare e restituisce un integer che indica la posizione iniziale o finale della sottostringa corrispondente. Se non viene trovata alcuna corrispondenza, la funzione restituisce `0`. REGEXP\$1INSTR è simile alla funzione [POSITION](r_POSITION.md), ma consente di cercare una stringa per un modello di espressione regolare. Per ulteriori informazioni sulle espressioni regolari, consulta [Operatori POSIX](pattern-matching-conditions-posix.md) ed [Espressione regolare](https://en.wikipedia.org/wiki/Regular_expression) in Wikipedia.
## Sintassi
```
REGEXP_INSTR( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Arguments (Argomenti)
*source\$1string*
Un'espressione di stringa, come ad esempio un nome di colonna, da cercare.
*pattern*
Un valore letterale di stringa UTF-8 che rappresenta un modello di espressione regolare. Per ulteriori informazioni, consulta [Operatori POSIX](pattern-matching-conditions-posix.md).
*posizione*
(Facoltativo) Un valore `INTEGER` positivo che indica la posizione all'interno di *source\$1string* per iniziare la ricerca. La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Il valore predefinito è `1`. Se *position* è inferiore a `1`, la ricerca inizia con il primo carattere di *source\$1string*. Se *position* è maggiore rispetto al numero di caratteri in *source\$1string*, il risultato è `0`.
*occorrenza*
(Facoltativo) Un valore `INTEGER` positivo che indica quale occorrenza del modello utilizzare. REGEXP\$1INSTR ignora le prime corrispondenze `occurrence-1`. Il valore predefinito è `1`. Se *occurrence* è inferiore a `1` oppure maggiore rispetto al numero di caratteri in *source\$1string*, la ricerca viene ignorata e il risultato è `0`.
*option*
(Facoltativo) Un valore che indica se restituire la posizione del primo carattere della corrispondenza (`0`) o la posizione del primo carattere dopo la fine della corrispondenza (`1`). Un valore diverso da zero equivale a `1`. Il valore predefinito è `0`.
*parameters*
(Facoltativo) Uno o più letterali di stringa che indicano come la funzione corrisponde al modello. Di seguito sono riportati i valori possibili:
+ c: eseguire una corrispondenza in base a maiuscole e minuscole. L'impostazione predefinita è utilizzare la corrispondenza con distinzione tra maiuscole e minuscole.
+ i: eseguire una corrispondenza senza distinzione tra maiuscole e minuscole.
+ e: estrarre una sottostringa usando una sottoespressione.
Se *modello* include una sottoespressione, REGEXP\$1INSTR corrisponde a una sottostringa che utilizza la prima sottoespressione in *modello*. REGEXP\$1INSTR considera solo la prima sottoespressione; le sottoespressioni aggiuntive vengono ignorate. Se il modello non ha una sottoespressione, REGEXP\$1INSTR ignora il parametro "e".
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE). Per ulteriori informazioni su PCRE, consulta [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) in Wikipedia.
## Tipo restituito
Numero intero
## Esempi
Negli esempi seguenti vengono utilizzati i dati della tabella USERS database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per ricercare il carattere `@` che inizia un nome di dominio e restituisce la posizione iniziale della prima corrispondenza, utilizza l'esempio seguente.
```
SELECT email, REGEXP_INSTR(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_instr |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 21 |
| Suspendisse.tristique@nonnisiAenean.edu | 22 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 17 |
| sed@lacusUtnec.ca | 4 |
+-----------------------------------------------+--------------+
```
Per ricercare le varianti della parola `Center` e restituire la posizione iniziale della prima corrispondenza, utilizza l'esempio seguente.
```
SELECT venuename, REGEXP_INSTR(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE REGEXP_INSTR(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
+-----------------------+--------------+
| venuename | regexp_instr |
+-----------------------+--------------+
| The Home Depot Center | 16 |
| Izod Center | 6 |
| Wachovia Center | 10 |
| Air Canada Centre | 12 |
+-----------------------+--------------+
```
Per trovare la posizione iniziale della prima occorrenza della stringa `FOX` utilizzando una logica di associazione senza distinzione tra maiuscole e minuscole, utilizza l'esempio seguente.
```
SELECT REGEXP_INSTR('the fox', 'FOX', 1, 1, 0, 'i');
+--------------+
| regexp_instr |
+--------------+
| 5 |
+--------------+
```
Per utilizzare un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola, utilizza l'esempio seguente. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene trovata la posizione iniziale della seconda parola di questo tipo.
```
SELECT REGEXP_INSTR('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
+--------------+
| regexp_instr |
+--------------+
| 21 |
+--------------+
```
Per utilizzare un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola, utilizza l'esempio seguente. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene trovata la posizione iniziale della seconda parola, ma differisce dall'esempio precedente in quanto utilizza la corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT REGEXP_INSTR('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
+--------------+
| regexp_instr |
+--------------+
| 15 |
+--------------+
```
# Funzione REGEXP\$1REPLACE
Cerca una stringa per un modello di espressione regolare e sostituisce ogni occorrenza del modello con la stringa specificata. REGEXP\$1REPLACE è simile a [Funzione REPLACE](r_REPLACE.md), ma consente di cercare una stringa per un modello di espressione regolare. Per ulteriori informazioni sulle espressioni regolari, consulta [Operatori POSIX](pattern-matching-conditions-posix.md) ed [Espressione regolare](https://en.wikipedia.org/wiki/Regular_expression) in Wikipedia.
REGEXP\$1REPLACE è simile a [Funzione TRANSLATE](r_TRANSLATE.md) e a [Funzione REPLACE](r_REPLACE.md), ad eccezione del fatto che TRANSLATE esegue più sostituzioni a carattere singolo e REPLACE sostituisce un'intera stringa con un'altra stringa, mentre REGEXP\$1REPLACE consente di cercare una stringa per un modello di espressione regolare.
## Sintassi
```
REGEXP_REPLACE( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## Arguments (Argomenti)
*source\$1string*
Un'espressione di stringa `CHAR` o `VARCHAR`, come ad esempio un nome di colonna, da cercare.
*pattern*
Un valore letterale di stringa UTF-8 che rappresenta un modello di espressione regolare. Per ulteriori informazioni, consulta [Operatori POSIX](pattern-matching-conditions-posix.md).
*replace\$1string*
(Facoltativo) Un'espressione di stringa `CHAR` or `VARCHAR`, ad esempio un nome di colonna, che sostituirà ogni occorrenza del modello. L'impostazione predefinita è una stringa vuota ( "" ).
*posizione*
(Facoltativo) Un numero intero positivo che indica la posizione all'interno di *source\$1string* per iniziare la ricerca. La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Il valore predefinito è `1`. Se *position* è inferiore a `1`, la ricerca inizia con il primo carattere di *source\$1string*. Se *posizione* è maggiore rispetto al numero di caratteri in *source\$1string*, il risultato è *source\$1string*.
*parameters*
(Facoltativo) Uno o più letterali di stringa che indicano come la funzione corrisponde al modello. Di seguito sono riportati i valori possibili:
+ c: eseguire una corrispondenza in base a maiuscole e minuscole. L'impostazione predefinita è utilizzare la corrispondenza con distinzione tra maiuscole e minuscole.
+ i: eseguire una corrispondenza senza distinzione tra maiuscole e minuscole.
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE). Per ulteriori informazioni su PCRE, consulta [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) in Wikipedia.
## Tipo restituito
VARCHAR
Se *pattern* o *replace\$1string* è `NULL`, la funzione restituisce `NULL`.
## Esempi
Per sostituire tutte le ricorrenze della stringa `FOX` nel valore `quick brown fox` usando una corrispondenza senza distinzione tra maiuscole e minuscole, utilizza l'esempio seguente.
```
SELECT REGEXP_REPLACE('the fox', 'FOX', 'quick brown fox', 1, 'i');
+---------------------+
| regexp_replace |
+---------------------+
| the quick brown fox |
+---------------------+
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. Per sostituire ogni occorrenza di tale parola con il valore `[hidden]`, utilizza l'esempio seguente.
```
SELECT REGEXP_REPLACE('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
+-------------------------------+
| regexp_replace |
+-------------------------------+
| [hidden] plain A1234 [hidden] |
+-------------------------------+
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. Per sostituire ogni ricorrenza di tale parola con il valore `[hidden]`, ma diversamente dall'esempio precedente in quanto utilizza la corrispondenza senza distinzione tra maiuscole e minuscole, utilizza l'esempio seguente.
```
SELECT REGEXP_REPLACE('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
+----------------------------------+
| regexp_replace |
+----------------------------------+
| [hidden] plain [hidden] [hidden] |
+----------------------------------+
```
Negli esempi seguenti vengono utilizzati i dati della tabella USERS database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per eliminare `@` e il nome di dominio dagli indirizzi e-mail, utilizza l'esempio seguente.
```
SELECT email, REGEXP_REPLACE(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+-----------------------+
| email | regexp_replace |
+-----------------------------------------------+-----------------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero |
| Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique |
| amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut |
| sed@lacusUtnec.ca | sed |
+-----------------------------------------------+-----------------------+
```
Per sostituire i nomi di dominio degli indirizzi e-mail con `internal.company.com`, utilizza l'esempio seguente.
```
SELECT email, REGEXP_REPLACE(email, '@.*\\.[[:alpha:]]{2,3}','@internal.company.com')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------------------------------------+
| email | regexp_replace |
+-----------------------------------------------+--------------------------------------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero@internal.company.com |
| Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique@internal.company.com |
| amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut@internal.company.com |
| sed@lacusUtnec.ca | sed@internal.company.com |
+-----------------------------------------------+--------------------------------------------+
```
# Funzione REGEXP\$1SUBSTR
Restituisce i caratteri da una stringa cercando un modello di espressione regolare. REGEXP\$1SUBSTR è simile alla funzione [Funzione SUBSTRING](r_SUBSTRING.md) ma consente di cercare una stringa per un modello di espressione regolare. Se la funzione non riesce a far corrispondere l'espressione regolare ad alcun carattere della stringa, restituisce una stringa vuota. Per ulteriori informazioni sulle espressioni regolari, consulta [Operatori POSIX](pattern-matching-conditions-posix.md) ed [Espressione regolare](https://en.wikipedia.org/wiki/Regular_expression) in Wikipedia.
## Sintassi
```
REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Arguments (Argomenti)
*source\$1string*
Un'espressione della stringa da ricercare.
*pattern*
Un valore letterale di stringa UTF-8 che rappresenta un modello di espressione regolare. Per ulteriori informazioni, consulta [Operatori POSIX](pattern-matching-conditions-posix.md).
*posizione*
Un integer positivo che indica la posizione all'interno di *source\$1string* per iniziare la ricerca. La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Il valore di default è 1. Se *posizione* è inferiore a 1, la ricerca inizia con il primo carattere di *source\$1string*. Se *posizione* è maggiore rispetto al numero di caratteri in *source\$1string*, il risultato è una stringa vuota ("").
*occorrenza*
Un integer positivo che indica quale occorrenza del modello utilizzare. REGEXP\$1SUBSTR salta le prime corrispondenze *occorrenza* -1. Il valore di default è 1. Se *occorrenza* è minore di 1 o maggiore del numero di caratteri in *source\$1string*, la ricerca viene ignorata e il risultato è vuoto.
*parameters*
Uno o più letterali di stringa che indicano come la funzione corrisponde al modello. Di seguito sono riportati i valori possibili:
+ c: eseguire una corrispondenza in base a maiuscole e minuscole. L'impostazione predefinita è utilizzare la corrispondenza con distinzione tra maiuscole e minuscole.
+ i: eseguire una corrispondenza senza distinzione tra maiuscole e minuscole.
+ e: estrarre una sottostringa usando una sottoespressione.
Se *modello* include una sottoespressione, REGEXP\$1SUBSTR corrisponde a una sottostringa che utilizza la prima sottoespressione in *modello*. Un'espressione secondaria è un'espressione all'interno del modello racchiusa tra parentesi. Ad esempio, per il modello `'This is a (\\w+)'` corrisponde alla prima espressione con la stringa `'This is a '` seguita da una parola. Invece di restituire un *modello*, REGEXP\$1SUBSTR con il parametro `e` restituisce solo la stringa all'interno dell'espressione secondaria.
REGEXP\$1SUBSTR considera solo la prima sottoespressione; le sottoespressioni aggiuntive vengono ignorate. Se il modello non ha una sottoespressione, REGEXP\$1SUBSTR ignora il parametro "e".
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE). Per ulteriori informazioni su PCRE, consulta [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) in Wikipedia.
## Tipo restituito
VARCHAR
## Esempi
L'esempio seguente restituisce la porzione di un indirizzo email tra il carattere @ e l'estensione del dominio. I dati `users` richiesti provengono dai dati di esempio di Amazon Redshift. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
Cum@accumsan.com | @accumsan
```
Nell'esempio seguente viene restituita la porzione dell'input corrispondente alla prima ricorrenza della stringa `FOX` utilizzando una corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
Nell'esempio seguente viene restituita la porzione dell'input corrispondente alla seconda occorrenza della stringa `FOX` utilizzando una corrispondenza senza distinzione tra maiuscole e minuscole. Il risultato è vuoto (non null, lunghezza 0) perché non esiste una seconda occorrenza.
```
SELECT regexp_substr('the fox', 'FOX', 1, 2, 'i');
regexp_substr
---------------
```
L'istruzione di esempio seguente restituisce la prima parte dell'input che inizia con lettere minuscole. Dal punto di vista funzionale è identica alla medesima istruzione SELECT senza il parametro `c`.
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene restituita la parte dell'input corrispondente alla seconda parola di questo tipo.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
Nell'esempio seguente viene utilizzato un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene restituita la parte di input corrispondente alla seconda parola, ma differisce dall'esempio precedente in quanto si utilizza la corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
L'esempio seguente utilizza un'espressione secondaria per trovare la seconda stringa che corrisponde al modello `'this is a (\\w+)'` utilizzando la corrispondenza senza distinzione tra maiuscole e minuscole. Restituisce l'espressione secondaria tra parentesi.
```
SELECT regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```
# Funzione REPEAT
Ripete una stringa il numero specificato di volte. Se il parametro di input è numerico, REPEAT lo considera come una stringa.
Sinonimo di [Funzione REPLICATE](r_REPLICATE.md).
## Sintassi
```
REPEAT(string, integer)
```
## Arguments (Argomenti)
*stringa*
Il primo parametro di input è la stringa da ripetere.
*integer*
Il secondo parametro è un valore `INTEGER` che indica il numero di volte in cui ripetere la stringa.
## Tipo restituito
VARCHAR
## Esempi
Nell'esempio seguente vengono utilizzati i dati della tabella CATEGORY database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per ripetere il valore della colonna CATID nella tabella CATEGORY tre volte, utilizza l'esempio seguente.
```
SELECT catid, REPEAT(catid,3)
FROM category
ORDER BY 1,2;
+-------+--------+
| catid | repeat |
+-------+--------+
| 1 | 111 |
| 2 | 222 |
| 3 | 333 |
| 4 | 444 |
| 5 | 555 |
| 6 | 666 |
| 7 | 777 |
| 8 | 888 |
| 9 | 999 |
| 10 | 101010 |
| 11 | 111111 |
+-------+--------+
```
L'esempio seguente dimostra la generazione di stringhe fino a 16.000.000 di byte:
```
SELECT
LEN(REPEAT('X', 5000000)) AS five_million_bytes,
LEN(REPEAT('Y', 16000000)) AS sixteen_million_bytes;
five_million_bytes | sixteen_million_bytes
----------+-----------
5000000 | 16000000
```
# Funzione REPLACE
Sostituisce tutte le occorrenze di un insieme di caratteri all'interno di una stringa esistente con altri caratteri specificati.
REPLACE è simile a [Funzione TRANSLATE](r_TRANSLATE.md) e a [Funzione REGEXP\$1REPLACE](REGEXP_REPLACE.md), ad eccezione del fatto che TRANSLATE esegue più sostituzioni a carattere singolo e REGEXP\$1REPLACE consente di cercare una stringa per un modello di espressione regolare, mentre REPLACE sostituisce un'intera stringa con un'altra stringa.
## Sintassi
```
REPLACE(string, old_chars, new_chars)
```
## Arguments (Argomenti)
*stringa*
La stringa `CHAR` o `VARCHAR` da cercare in ricerca
*old\$1chars*
La stringa `CHAR` o `VARCHAR` da sostituire.
*new\$1chars*
Nuova stringa `CHAR` o `VARCHAR` che sostituisce *old\$1string*.
## Tipo restituito
VARCHAR
Se *old\$1chars* o *new\$1chars* è `NULL`, il risultato è `NULL`.
## Esempi
Nell'esempio seguente vengono utilizzati i dati della tabella CATEGORY database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per convertire la stringa `Shows` in `Theatre` nel campo CATGROUP, utilizza l'esempio seguente.
```
SELECT catid, catgroup, REPLACE(catgroup, 'Shows', 'Theatre')
FROM category
ORDER BY 1,2,3;
+-------+----------+----------+
| catid | catgroup | replace |
+-------+----------+----------+
| 1 | Sports | Sports |
| 2 | Sports | Sports |
| 3 | Sports | Sports |
| 4 | Sports | Sports |
| 5 | Sports | Sports |
| 6 | Shows | Theatre |
| 7 | Shows | Theatre |
| 8 | Shows | Theatre |
| 9 | Concerts | Concerts |
| 10 | Concerts | Concerts |
| 11 | Concerts | Concerts |
+-------+----------+----------+
```
# Funzione REPLICATE
Sinonimo della funzione REPEAT.
Per informazioni, consultare [Funzione REPEAT](r_REPEAT.md).
# Funzione REVERSE
La funzione REVERSE funziona su una stringa e restituisce i caratteri in ordine inverso. Ad esempio, `reverse('abcde')` restituisce `edcba`. Questa funzione funziona su tipi di dati numerici e di date, così come su tipi di dati di carattere; tuttavia, nella maggior parte dei casi ha un valore pratico per le stringhe di caratteri.
## Sintassi
```
REVERSE( expression )
```
## Argomento
*espressione*
Un'espressione con un carattere, una data, un timestamp o un tipo di dati numerici che rappresenta la destinazione dell'inversione di caratteri. Tutte le espressioni vengono convertite implicitamente in stringhe `VARCHAR`. Spazi vuoti finali nelle stringhe `CHAR` vengono ignorati.
## Tipo restituito
VARCHAR
## Esempi
Gli esempi seguenti utilizzano i dati delle tabelle USERS e SALES database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per selezionare cinque nomi di città distinti e i corrispondenti nomi invertiti dalla tabella USERS, utilizza l'esempio seguente.
```
SELECT DISTINCT city AS cityname, REVERSE(cityname)
FROM users
ORDER BY city LIMIT 5;
+----------+----------+
| cityname | reverse |
+----------+----------+
| Aberdeen | needrebA |
| Abilene | enelibA |
| Ada | adA |
| Agat | tagA |
| Agawam | mawagA |
+----------+----------+
```
Per selezionare cinque vendite IDs e il corrispondente IDs cast invertito come stringhe di caratteri, utilizzate l'esempio seguente.
```
SELECT salesid, REVERSE(salesid)
FROM sales
ORDER BY salesid DESC LIMIT 5;
+---------+---------+
| salesid | reverse |
+---------+---------+
| 172456 | 654271 |
| 172455 | 554271 |
| 172454 | 454271 |
| 172453 | 354271 |
| 172452 | 254271 |
+---------+---------+
```
# Funzione RTRIM
La funzione RTRIM riduce un insieme specificato di caratteri dalla fine di una stringa. Rimuove la stringa più lunga contenente solo i caratteri nell'elenco dei caratteri di taglio. Il taglio è completo quando un carattere di taglio non appare nella stringa di input.
## Sintassi
```
RTRIM( string, trim_chars )
```
## Arguments (Argomenti)
*stringa*
Una stringa, una colonna, un'espressione o una stringa letterale da tagliare.
*trim\$1chars*
Una colonna o un'espressione di stringa o un valore letterale di stringa che rappresenta i caratteri da tagliare dall'inizio della *stringa*. Se non specificato, viene utilizzato uno spazio come carattere di taglio.
## Tipo restituito
Una stringa che è lo stesso tipo di dati dell'argomento *stringa*.
## Esempio
L'esempio seguente riduce gli spazi vuoti iniziali e finali dalla stringa `' abc '`:
```
select ' abc ' as untrim, rtrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
L'esempio seguente rimuove le stringhe `'xyz'` iniziali dalla stringa `'xyzaxyzbxyzcxyz'`. Le occorrenze finali di `'xyz'` vengono rimosse, ma le occorrenze interne alla stringa non vengono rimosse.
```
select 'xyzaxyzbxyzcxyz' as untrim,
rtrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | xyzaxyzbxyzc
```
L'esempio seguente rimuove le parti finali dalla stringa `'setuphistorycassettes'` che corrispondono a uno qualsiasi dei caratteri nell'elenco `'tes'` *trim\$1chars*. Qualsiasi carattere `t`, `e` o `s` che si verifica prima di un altro carattere che non è nell'elenco *trim\$1chars* alla fine della stringa di input viene rimosso.
```
SELECT rtrim('setuphistorycassettes', 'tes');
rtrim
-----------------
setuphistoryca
```
L'esempio seguente riduce i caratteri "Parco"dalla fine di VENUENAME laddove presente:
```
select venueid, venuename, rtrim(venuename, 'Park')
from venue
order by 1, 2, 3
limit 10;
venueid | venuename | rtrim
--------+----------------------------+-------------------------
1 | Toyota Park | Toyota
2 | Columbus Crew Stadium | Columbus Crew Stadium
3 | RFK Stadium | RFK Stadium
4 | CommunityAmerica Ballpark | CommunityAmerica Ballp
5 | Gillette Stadium | Gillette Stadium
6 | New York Giants Stadium | New York Giants Stadium
7 | BMO Field | BMO Field
8 | The Home Depot Center | The Home Depot Cente
9 | Dick's Sporting Goods Park | Dick's Sporting Goods
10 | Pizza Hut Park | Pizza Hut
```
Si noti che RTRIM rimuove tutti i caratteri in `P`, `a` , `r` oppure `k` quando appaiono alla fine di un VENUENAME.
# Funzione SOUNDEX
La funzione SOUNDEX restituisce il valore American Soundex costituito dalla prima lettera della stringa di input seguita da una codifica a 3 cifre dei suoni che rappresentano la pronuncia inglese della stringa specificata. Ad esempio `Smith` e `Smyth` hanno lo stesso valore Soundex.
## Sintassi
```
SOUNDEX(string)
```
## Arguments (Argomenti)
*stringa*
Specifica una stringa `CHAR` o `VARCHAR` che desideri convertire in un valore di codice American Soundex.
## Tipo restituito
VARCHAR(4)
## Note per l'utilizzo
La funzione SOUNDEX converte solo caratteri ASCII alfabetici minuscoli o maiuscoli inglesi, inclusi a-z e A-Z. SOUNDEX ignora gli altri caratteri. SOUNDEX restituisce un singolo valore Soundex per una stringa di più parole separate da spazi.
```
SELECT SOUNDEX('AWS Amazon');
+---------+
| soundex |
+---------+
| A252 |
+---------+
```
SOUNDEX restituisce una stringa vuota se la stringa di input non contiene lettere inglesi.
```
SELECT SOUNDEX('+-*/%');
+---------+
| soundex |
+---------+
| |
+---------+
```
## Esempi
Per restituire il valore Soundex per `Amazon`, utilizza l'esempio seguente.
```
SELECT SOUNDEX('Amazon');
+---------+
| soundex |
+---------+
| A525 |
+---------+
```
Per restituire il valore Soundex per `smith` e `smyth`, utilizza l'esempio seguente. Tieni presente che i valori di Soundex sono gli stessi.
```
SELECT SOUNDEX('smith'), SOUNDEX('smyth');
+-------+-------+
| smith | smyth |
+-------+-------+
| S530 | S530 |
+-------+-------+
```
# Funzione SPLIT\$1PART
Divide una stringa sul delimitatore specificato e restituisce la parte nella posizione specificata.
## Sintassi
```
SPLIT_PART(string, delimiter, position)
```
## Arguments (Argomenti)
*stringa*
Una stringa, una colonna, un'espressione o una stringa letterale da dividere. La stringa può essere CHAR o VARCHAR.
*delimiter*
La stringa del delimitatore che indica le sezioni della *stringa* di input.
Se *delimiter* è un letterale, racchiuderlo tra virgolette singole.
*posizione*
Posizione della porzione di *stringa* da restituire (contando da 1). Deve essere un integer superiore a 0. Se *posizione* è maggiore del numero di porzioni di stringa, SPLIT\$1PART restituisce una stringa vuota. Se il *delimitatore* non si trova nella *stringa*, il valore restituito contiene i contenuti della parte specificata, che possono essere l'intera *stringa* o un valore vuoto.
## Tipo restituito
Una stringa CHAR o VARCHAR, uguale al parametro di *stringa*.
## Esempi
L'esempio seguente divide una stringa letterale in parti utilizzando il delimitatore `$` e restituisce la seconda parte.
```
select split_part('abc$def$ghi','$',2)
split_part
----------
def
```
L'esempio seguente divide una stringa letterale in parti utilizzando il delimitatore `$`. Restituisce una stringa vuota perché la parte `4` non viene trovata.
```
select split_part('abc$def$ghi','$',4)
split_part
----------
```
L'esempio seguente divide una stringa letterale in parti utilizzando il delimitatore `#`. Restituisce l'intera stringa, che è la prima parte, perché il delimitatore non è stato trovato.
```
select split_part('abc$def$ghi','#',1)
split_part
------------
abc$def$ghi
```
L'esempio seguente divide il campo timestamp LISTTIME in componenti anno, mese e data.
```
select listtime, split_part(listtime,'-',1) as year,
split_part(listtime,'-',2) as month,
split_part(split_part(listtime,'-',3),' ',1) as day
from listing limit 5;
listtime | year | month | day
---------------------+------+-------+------
2008-03-05 12:25:29 | 2008 | 03 | 05
2008-09-09 08:03:36 | 2008 | 09 | 09
2008-09-26 05:43:12 | 2008 | 09 | 26
2008-10-04 02:00:30 | 2008 | 10 | 04
2008-01-06 08:33:11 | 2008 | 01 | 06
```
L'esempio seguente seleziona il campo timestamp LISTTIME e lo divide sul carattere `'-'` per ottenere il mese (la seconda parte della stringa LISTTIME), quindi conta il numero di voci per ogni mese:
```
select split_part(listtime,'-',2) as month, count(*)
from listing
group by split_part(listtime,'-',2)
order by 1, 2;
month | count
-------+-------
01 | 18543
02 | 16620
03 | 17594
04 | 16822
05 | 17618
06 | 17158
07 | 17626
08 | 17881
09 | 17378
10 | 17756
11 | 12912
12 | 4589
```
# Funzione STRPOS
Restituisce la posizione di una sottostringa specificata all'interno di una stringa specificata.
Per funzioni simili, consulta [Funzione CHARINDEX](r_CHARINDEX.md) e [Funzione POSITION](r_POSITION.md).
## Sintassi
```
STRPOS(string, substring )
```
## Arguments (Argomenti)
*stringa*
Il primo parametro di input è la stringa `CHAR` o `VARCHAR` da cercare.
*sottostringa*
Il secondo parametro è la sottostringa da cercare all'interno della *stringa*.
## Tipo restituito
INTEGER
La funzione STRPOS restituisce un valore `INTEGER` corrispondente alla posizione della *sottostringa* (basata su uno, non su zero). La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli.
## Note per l'utilizzo
STRPOS restituisce `0` se la *sottostringa* non si trova all'interno della *stringa*.
```
SELECT STRPOS('dogfish', 'fist');
+--------+
| strpos |
+--------+
| 0 |
+--------+
```
## Esempi
Per mostrare la posizione di `fish` in `dogfish`, utilizza l'esempio seguente.
```
SELECT STRPOS('dogfish', 'fish');
+--------+
| strpos |
+--------+
| 4 |
+--------+
```
Nell'esempio seguente vengono utilizzati i dati della tabella SALES del database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per restituire il numero di transazioni di vendita con COMMISSION superiore a 999,00 dalla tabella SALES, utilizza l'esempio seguente.
```
SELECT DISTINCT STRPOS(commission, '.'),
COUNT (STRPOS(commission, '.'))
FROM sales
WHERE STRPOS(commission, '.') > 4
GROUP BY STRPOS(commission, '.')
ORDER BY 1, 2;
+--------+-------+
| strpos | count |
+--------+-------+
| 5 | 629 |
+--------+-------+
```
# Funzione STRTOL
Converte un'espressione di stringa di un numero della base specificata nel valore intero equivalente. Il valore convertito deve essere compreso nell'intervallo 64-bit firmato.
## Sintassi
```
STRTOL(num_string, base)
```
## Arguments (Argomenti)
*num\$1string*
Espressione di stringa di un numero da convertire. Se *num\$1string* è vuoto (`''`) o inizia con il carattere null (`'\0'`), il valore convertito è `0`. Se *num\$1string* è una colonna contenente un valore NULL, STRTOL restituisce `NULL`. La stringa può iniziare con qualsiasi quantità di spazio bianco, opzionalmente seguita da un singolo segno più '`+`' o meno '`-`' per indicare il positivo o il negativo. Il valore di default è '`+`'. Se *base* è `16`, la stringa può opzionalmente iniziare con '`0x`'.
*base*
`INTEGER` tra 2 e 36.
## Tipo restituito
BIGINT
Se *num\$1string* è null, la funzione restituisce `NULL`.
## Esempi
Per convertire le coppie di valori di stringa e di base in numeri interi, utilizza l'esempio seguente.
```
SELECT STRTOL('0xf',16);
+--------+
| strtol |
+--------+
| 15 |
+--------+
SELECT STRTOL('abcd1234',16);
+------------+
| strtol |
+------------+
| 2882343476 |
+------------+
SELECT STRTOL('1234567', 10);
+---------+
| strtol |
+---------+
| 1234567 |
+---------+
SELECT STRTOL('1234567', 8);
+--------+
| strtol |
+--------+
| 342391 |
+--------+
SELECT STRTOL('110101', 2);
+--------+
| strtol |
+--------+
| 53 |
+--------+
SELECT STRTOL('\0', 2);
+--------+
| strtol |
+--------+
| 0 |
+--------+
```
# Funzione SUBSTRING
Restituisce il sottoinsieme di una stringa basata su una posizione iniziale specificata.
Se l'input è una stringa di carattere, la posizione iniziale e il numero di caratteri estratti si basano sui caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Se l'input è un'espressione binaria, la posizione iniziale e la sottostringa estratta sono basate su byte. Non è possibile specificare una lunghezza negativa, ma è possibile specificare una posizione di partenza negativa.
## Sintassi
```
SUBSTRING(character_string FROM start_position [ FOR number_characters ] )
```
```
SUBSTRING(character_string, start_position, number_characters )
```
```
SUBSTRING(binary_expression, start_byte, number_bytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Arguments (Argomenti)
*character\$1string*
La stringa da cercare. I tipi di dati non carattere sono trattati come una stringa.
*start\$1position*
La posizione all'interno della stringa per iniziare l'estrazione, a partire da 1. La *start\$1position* si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Questo numero può essere negativo.
*number\$1characters*
Il numero di caratteri da estrarre (la lunghezza della sottostringa). Il *number\$1characters* si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Questo numero non può essere negativo.
*binary\$1expression*
L'espressione binaria del tipo di dati VARBYTE da cercare.
*start\$1byte*
La posizione all'interno dell'espressione binaria per iniziare l'estrazione, a partire da 1. Questo numero può essere negativo.
*number\$1byte*
Il numero di byte da estrarre, ovvero, la lunghezza della sottostringa. Questo numero non può essere negativo.
## Tipo restituito
VARCHAR o VARBYTE a seconda dell'input
## Note per l'utilizzo
Di seguito sono riportati alcuni esempi di come è possibile utilizzare *start\$1position* e *number\$1characters* per estrarre sottostringhe da varie posizioni in una stringa.
L'esempio seguente restituisce una stringa di quattro caratteri che inizia con il sesto carattere.
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
Se *start\$1position* \$1 *number\$1characters* supera la lunghezza della *stringa*, SUBSTRING restituisce una sottostringa che inizia da *start\$1position* fino alla fine della stringa. Ad esempio:
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
Se la `start_position` è negativa o pari a 0, la funzione SUBSTRING restituisce una sottostringa che inizia dal primo carattere di stringa con una lunghezza di `start_position` \$1 `number_characters` -1. Ad esempio:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Se `start_position` \$1 `number_characters` -1 è inferiore o pari a zero, SUBSTRING restituisce una stringa vuota. Ad esempio:
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## Esempi
L'esempio seguente restituisce il mese dalla stringa LISTTIME nella tabella LISTING:
```
select listid, listtime,
substring(listtime, 6, 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
L'esempio seguente è lo stesso di sopra, ma utilizza l'opzione FROM...FOR:
```
select listid, listtime,
substring(listtime from 6 for 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
Non è possibile utilizzare SUBSTRING per estrarre in modo prevedibile il prefisso di una stringa che potrebbe contenere caratteri multibyte poiché è necessario specificare la lunghezza di una stringa multibyte in base al numero di byte, non al numero di caratteri. Per estrarre il segmento iniziale di una stringa in base alla lunghezza in byte, è possibile eseguire il CAST della stringa come VARCHAR(*byte\$1length*) per troncare la stringa, laddove *byte\$1length* è la lunghezza necessaria. L'esempio seguente estrae i primi 5 byte dalla stringa `'Fourscore and seven'`.
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
L'esempio seguente mostra una posizione iniziale negativa di un valore binario `abc`. Poiché la posizione iniziale è -3, la sottostringa viene estratta dall'inizio del valore binario. Il risultato viene visualizzato automaticamente come rappresentazione esadecimale della sottostringa binaria.
```
select substring('abc'::varbyte, -3);
substring
-----------
616263
```
L'esempio seguente mostra un valore 1 per la posizione iniziale di un valore binario `abc`. Poiché non è specificata la lunghezza, la stringa viene estratta dalla posizione iniziale alla fine della stringa. Il risultato viene visualizzato automaticamente come rappresentazione esadecimale della sottostringa binaria.
```
select substring('abc'::varbyte, 1);
substring
-----------
616263
```
L'esempio seguente mostra un 3 per la posizione iniziale di un valore binario `abc`. Poiché non è specificata la lunghezza, la stringa viene estratta dalla posizione iniziale alla fine della stringa. Il risultato viene visualizzato automaticamente come rappresentazione esadecimale della sottostringa binaria.
```
select substring('abc'::varbyte, 3);
substring
-----------
63
```
L'esempio seguente mostra un 2 per la posizione iniziale di un valore binario `abc`. La stringa viene estratta dalla posizione iniziale alla posizione 10, ma la fine della stringa si trova nella posizione 3. Il risultato viene visualizzato automaticamente come rappresentazione esadecimale della sottostringa binaria.
```
select substring('abc'::varbyte, 2, 10);
substring
-----------
6263
```
L'esempio seguente mostra un 2 per la posizione iniziale di un valore binario `abc`. La stringa viene estratta dalla posizione iniziale per 1 byte. Il risultato viene visualizzato automaticamente come rappresentazione esadecimale della sottostringa binaria.
```
select substring('abc'::varbyte, 2, 1);
substring
-----------
62
```
L'esempio seguente restituisce il nome `Ana` che appare dopo l'ultimo spazio nella stringa di input `Silva, Ana`.
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# Funzione TEXTLEN
Sinonimo della funzione LEN.
Per informazioni, consultare [Funzione LEN](r_LEN.md).
# Funzione TRANSLATE
Per una data espressione, sostituisce tutte le occorrenze di caratteri specificati con sostituti specificati. I caratteri esistenti sono mappati per i caratteri sostitutivi in base alla loro posizione negli argomenti *characters\$1to\$1replace* e *characters\$1to\$1substitute*. Se vengono specificati più caratteri nell'argomento *characters\$1to\$1replace* rispetto all'argomento *characters\$1to\$1substitute*, i caratteri extra dall'argomento *characters\$1to\$1replace* vengono omessi nel valore di restituzione.
TRANSLATE è simile a [Funzione REPLACE](r_REPLACE.md) e a [Funzione REGEXP\$1REPLACE](REGEXP_REPLACE.md), ad eccezione del fatto che REPLACE sostituisce un'intera stringa con un'altra stringa e REGEXP\$1REPLACE consente di cercare una stringa per un modello di espressione regolare, mentre TRANSLATE realizza più sostituzioni a carattere singolo.
Se qualsiasi argomento è null, il risultato è `NULL`.
## Sintassi
```
TRANSLATE( expression, characters_to_replace, characters_to_substitute )
```
## Arguments (Argomenti)
*espressione*
L'espressione da tradurre.
*characters\$1to\$1replace*
Una stringa contenente i caratteri da sostituire.
*characters\$1to\$1substitute*
Una stringa contenente i caratteri da sostituire.
## Tipo restituito
VARCHAR
## Esempi
Per sostituire vari caratteri in una stringa, utilizza l'esempio seguente.
```
SELECT TRANSLATE('mint tea', 'inea', 'osin');
+-----------+
| translate |
+-----------+
| most tin |
+-----------+
```
Negli esempi seguenti vengono utilizzati i dati della tabella USERS database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per sostituire il simbolo at (@) con un punto per tutti i valori in una colonna, utilizza l'esempio seguente.
```
SELECT email, TRANSLATE(email, '@', '.') as obfuscated_email
FROM users LIMIT 10;
+---------------------------------------+---------------------------------------+
| email | obfuscated_email |
+---------------------------------------+---------------------------------------+
| Cum@accumsan.com | Cum.accumsan.com |
| lorem.ipsum@Vestibulumante.com | lorem.ipsum.Vestibulumante.com |
| non.justo.Proin@ametconsectetuer.edu | non.justo.Proin.ametconsectetuer.edu |
| non.ante.bibendum@porttitortellus.org | non.ante.bibendum.porttitortellus.org |
| eros@blanditatnisi.org | eros.blanditatnisi.org |
| augue@Donec.ca | augue.Donec.ca |
| cursus@pedeacurna.edu | cursus.pedeacurna.edu |
| at@Duis.com | at.Duis.com |
| quam@facilisisvitaeorci.ca | quam.facilisisvitaeorci.ca |
| mi.lorem@nunc.edu | mi.lorem.nunc.edu |
+---------------------------------------+---------------------------------------+
```
Per sostituire gli spazi con caratteri di sottolineatura ed eliminare i punti per tutti i valori in una colonna, utilizza l'esempio seguente.
```
SELECT city, TRANSLATE(city, ' .', '_')
FROM users
WHERE city LIKE 'Sain%' OR city LIKE 'St%'
GROUP BY city
ORDER BY city;
+----------------+---------------+
| city | translate |
+----------------+---------------+
| Saint Albans | Saint_Albans |
| Saint Cloud | Saint_Cloud |
| Saint Joseph | Saint_Joseph |
| Saint Louis | Saint_Louis |
| Saint Paul | Saint_Paul |
| St. George | St_George |
| St. Marys | St_Marys |
| St. Petersburg | St_Petersburg |
| Stafford | Stafford |
| Stamford | Stamford |
| Stanton | Stanton |
| Starkville | Starkville |
| Statesboro | Statesboro |
| Staunton | Staunton |
| Steubenville | Steubenville |
| Stevens Point | Stevens_Point |
| Stillwater | Stillwater |
| Stockton | Stockton |
| Sturgis | Sturgis |
+----------------+---------------+
```
# Funzione TRIM
Taglia una stringa in base agli spazi vuoti o ai caratteri specificati.
## Sintassi
```
TRIM( [ BOTH | LEADING | TRAILING ] [trim_chars FROM ] string )
```
## Arguments (Argomenti)
BOTH \$1 LEADING \$1 TRAILING
(Facoltativo) Specifica da dove tagliare i caratteri. Utilizza BOTH per rimuovere i caratteri iniziali e finali, LEADING per rimuovere solo i caratteri iniziali e TRAILING per rimuovere solo i caratteri finali. Se questo parametro viene omesso, vengono tagliati sia i caratteri iniziali che quelli finali.
*trim\$1chars*
(Facoltativo) I caratteri da ridurre dalla stringa. Se questo parametro viene omesso, gli spazi vuoti vengono ridotti.
*stringa*
La stringa da ridurre.
## Tipo restituito
La funzione TRIM restituisce una stringa `VARCHAR` o `CHAR`. Se utilizzi la funzione TRIM con un comando SQL, Amazon Redshift converte implicitamente i risultati in `VARCHAR`. Se si utilizza la funzione TRIM nell'elenco SELECT per una funzione SQL, Amazon Redshift non converte implicitamente i risultati e potrebbe essere necessario eseguire una conversione esplicita per evitare un errore di mancata corrispondenza del tipo di dati. Consultare le funzioni [Funzione CAST](r_CAST_function.md) e [Funzione CONVERT](r_CONVERT_function.md) per informazioni sulle conversioni esplicite.
## Esempi
Per tagliare gli spazi vuoti iniziali e finali dalla stringa ` dog `, utilizza l'esempio seguente.
```
SELECT TRIM(' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Per tagliare gli spazi vuoti iniziali e finali dalla stringa ` dog `, utilizza l'esempio seguente.
```
SELECT TRIM(BOTH FROM ' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Per rimuovere le virgolette doppie iniziali dalla stringa `"dog"`, utilizza l'esempio seguente.
```
SELECT TRIM(LEADING '"' FROM'"dog"');
+-------+
| ltrim |
+-------+
| dog" |
+-------+
```
Per rimuovere le virgolette doppie finali dalla stringa `"dog"`, utilizza l'esempio seguente.
```
SELECT TRIM(TRAILING '"' FROM'"dog"');
+-------+
| rtrim |
+-------+
| "dog |
+-------+
```
TRIM rimuove tutti i caratteri in *trim\$1chars* se questi si trovano all'inizio o alla fine della *stringa*. L'esempio seguente ritaglia i caratteri "C", "D" e "G" quando si trovano all'inizio o alla fine di VENUENAME che è una colonna `VARCHAR`. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
```
SELECT venueid, venuename, TRIM('CDG' FROM venuename)
FROM venue
WHERE venuename LIKE '%Park'
ORDER BY 2
LIMIT 7;
+---------+----------------------------+---------------------------+
| venueid | venuename | btrim |
+---------+----------------------------+---------------------------+
| 121 | AT&T Park | AT&T Park |
| 109 | Citizens Bank Park | itizens Bank Park |
| 102 | Comerica Park | omerica Park |
| 9 | Dick's Sporting Goods Park | ick's Sporting Goods Park |
| 97 | Fenway Park | Fenway Park |
| 112 | Great American Ball Park | reat American Ball Park |
| 114 | Miller Park | Miller Park |
+---------+----------------------------+---------------------------+
```
# Funzione UPPER
Converte una stringa in maiuscolo. UPPER supporta caratteri multibyte UTF-8, fino a un massimo di quattro byte per carattere.
## Sintassi
```
UPPER(string)
```
## Arguments (Argomenti)
*stringa*
Il parametro di input è una stringa `VARCHAR` o qualsiasi altro tipo di dati, ad esempio `CHAR`, che è possibile convertire implicitamente in `VARCHAR`.
## Tipo restituito
La funzione UPPER restituisce una stringa di caratteri che appartiene allo stesso tipo di dati della stringa di input. Ad esempio, se l'input è una stringa `VARCHAR`, la funzione restituirà una stringa `VARCHAR`.
## Esempi
Nell'esempio seguente vengono utilizzati i dati della tabella CATEGORY database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md).
Per convertire il campo CATNAME in lettere maiuscole, utilizza l'esempio seguente.
```
SELECT catname, UPPER(catname)
FROM category
ORDER BY 1,2;
+-----------+-----------+
| catname | upper |
+-----------+-----------+
| Classical | CLASSICAL |
| Jazz | JAZZ |
| MLB | MLB |
| MLS | MLS |
| Musicals | MUSICALS |
| NBA | NBA |
| NFL | NFL |
| NHL | NHL |
| Opera | OPERA |
| Plays | PLAYS |
| Pop | POP |
+-----------+-----------+
```