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
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.
**Topics**
+ [\$1\$1 (Concatenamento) Operatore](concat_op.md)
+ [Funzione BTRIM](BTRIM.md)
+ [Funzione CONCAT](CONCAT.md)
+ [Funzione FORMAT\$1STRING](FORMAT_STRING.md)
+ [Funzioni LEFT e RIGHT](LEFT.md)
+ [Funzione LENGTH](LENGTH.md)
+ [Funzione LOWER](LOWER.md)
+ [Funzioni LPAD e RPAD](LPAD.md)
+ [Funzione LTRIM](LTRIM.md)
+ [Funzione POSITION](POSITION.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](REPEAT.md)
+ [Funzione REPLACE](REPLACE.md)
+ [Funzione REVERSE](REVERSE.md)
+ [Funzione RTRIM](RTRIM.md)
+ [Funzione SPLIT](split.md)
+ [Funzione SPLIT\$1PART](SPLIT_PART.md)
+ [Funzione SUBSTRING](SUBSTRING.md)
+ [Funzione TRANSLATE](TRANSLATE.md)
+ [Funzione TRIM](TRIM.md)
+ [Funzione UPPER](UPPER.md)
+ [Funzione UUID](UUID.md)
# \$1\$1 (Concatenamento) Operatore
Concatena due espressioni su entrambi i lati del simbolo \$1\$1 e restituisce l'espressione concatenata.
L'operatore di concatentazione è simile a. [Funzione CONCAT](CONCAT.md)
**Nota**
Sia per la funzione CONCAT sia per l'operatore di concatenazione, se una o entrambe le espressioni sono nulle, il risultato della concatenazione è nullo.
## Sintassi
```
expression1 || expression2
```
## Argomenti
*expression1*, *expression2*
Entrambi gli argomenti possono essere stringhe di caratteri o espressioni a lunghezza fissa o a lunghezza variabile.
## Tipo restituito
L'operatore \$1\$1 restituisce una stringa. Il tipo di stringa è lo stesso degli argomenti di input.
## Esempio
L'esempio seguente concatena i campi FIRSTNAME e LASTNAME dalla tabella USERS:
```
select firstname || ' ' || lastname
from users
order by 1
limit 10;
concat
-----------------
Aaron Banks
Aaron Booth
Aaron Browning
Aaron Burnett
Aaron Casey
Aaron Cash
Aaron Castro
Aaron Dickerson
Aaron Dixon
Aaron Dotson
(10 rows)
```
Per concatenare le colonne che potrebbero contenere valori null, utilizzare l'espressione [Funzioni NVL e COALESCE](NVL_function.md). Il seguente esempio utilizza NVL per restituire uno 0 ogni volta che si incontra NULL.
```
select venuename || ' seats ' || nvl(venueseats, 0)
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 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 ] )
```
## 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 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.
**Nota**
Sia per la funzione CONCAT sia per l'operatore di concatenazione, se una o entrambe le espressioni sono nulle, il risultato della concatenazione è nullo.
## Sintassi
```
CONCAT ( expression1, expression2 )
```
## 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 tipi diversi, AWS Clean Rooms prova a digitare implicitamente genera una delle espressioni. Se non è possibile eseguire il cast di valori, viene restituito il valore 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';
concat
-------------------
December 25, 2008
(1 row)
```
Nell'esempio seguente vengono utilizzate due funzioni CONCAT per concatenare tre stringhe di caratteri:
```
select concat('Thursday, ', concat('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Per concatenare le colonne che potrebbero contenere valori null, utilizzare la [Funzioni NVL e COALESCE](NVL_function.md). 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)
```
# Funzione FORMAT\$1STRING
La funzione FORMAT\$1STRING crea una stringa formattata sostituendo i segnaposto in una stringa modello con gli argomenti forniti. Restituisce una stringa formattata da stringhe di formato in stile printf.
La funzione FORMAT\$1STRING funziona sostituendo i segnaposto nella stringa del modello con i valori corrispondenti passati come argomenti. Questo tipo di formattazione delle stringhe può essere utile quando è necessario creare dinamicamente stringhe che includono una combinazione di testo statico e dati dinamici, ad esempio quando si generano messaggi di output, report o altri tipi di testo informativo. La funzione FORMAT\$1STRING fornisce un modo conciso e leggibile per creare questi tipi di stringhe formattate, semplificando la manutenzione e l'aggiornamento del codice che genera l'output.
## Sintassi
```
format_string(strfmt, obj, ...)
```
## Argomenti
*strfmt*
Un'espressione STRING.
*obj*
Una STRINGA o un'espressione numerica.
## Tipo restituito
FORMAT\$1STRING restituisce una STRING.
## Esempio
L'esempio seguente contiene una stringa modello che contiene due segnaposto: `%d` per un valore decimale (intero) e per un valore di stringa. `%s` Il `%d` segnaposto viene sostituito con il valore decimale (intero) () e il segnaposto %s viene sostituito con il valore di stringa (`100`). `"days"` L'output è una stringa modello con i segnaposto sostituiti dagli argomenti forniti:. `"Hello World 100 days"`
```
SELECT format_string("Hello World %d %s", 100, "days");
Hello World 100 days
```
# 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 )
```
## Argomenti
*stringa*
Qualsiasi stringa di caratteri o espressione che valuti una stringa di caratteri.
*integer*
Un integer positivo.
## Tipo restituito
LEFT e RIGHT restituiscono una stringa VARCHAR.
## Esempio
L'esempio seguente restituisce i 5 caratteri più a sinistra e i 5 caratteri più a destra dei nomi di eventi con un valore compreso tra 1000 e 1005: 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
(6 rows)
```
# Funzione LENGTH
# 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*
Il parametro di input è una stringa VARCHAR (o qualsiasi altro tipo di dati, ad esempio CHAR, che può essere convertito implicitamente in VARCHAR).
## Tipo restituito
La funzione LOWER restituisce una stringa di caratteri che appartiene allo stesso tipo di dati della stringa di input.
## Esempi
L'esempio seguente converte il campo CATNAME in lettere minuscole:
```
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
(11 rows)
```
# 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 ])
```
## Argomenti
*string1*
Una stringa di caratteri o un'espressione che valuta una stringa di caratteri, come il nome di una colonna di caratteri.
*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 *lunghezza* è un numero negativo, il risultato della funzione è una stringa vuota.
*string2*
Uno o più caratteri anteposti o aggiunti a *string1*. Questo argomento è facoltativo; se non è specificato, gli spazi vengono usati.
## Tipo restituito
Queste funzioni restituiscono un tipo di dati VARCHAR.
## Esempi
Troncare un insieme specificato di nomi di eventi a 20 caratteri e anteporre ai nomi più brevi gli spazi:
```
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
(5 rows)
```
Troncare lo stesso insieme specificato di nomi di eventi a 20 caratteri ma aggiungere ai nomi più brevi `0123456789`.
```
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
(5 rows)
```
# 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] )
```
## 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 POSITION
Restituisce la posizione della sottostringa specificata all'interno di una stringa.
## Sintassi
```
POSITION(substring IN string )
```
## Argomenti
*sottostringa*
La sottostringa da cercare all'interno della *stringa*.
*stringa*
La stringa o colonna da ricercare.
## Tipo restituito
La funzione POSITION restituisce un 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
POSITION restituisce 0 se la sottostringa non si trova all'interno della stringa:
```
select position('dog' in 'fish');
position
----------
0
(1 row)
```
## Esempi
L'esempio seguente mostra la posizione della stringa `fish` all'interno della parola `dogfish`:
```
select position('fish' in 'dogfish');
position
----------
4
(1 row)
```
L'esempio seguente restituisce il numero di transazioni di vendita con una COMMISSION superiore a 999,00 dalla tabella SALES:
```
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
(1 row)
```
# Funzione REGEXP\$1COUNT
Cerca una stringa per un modello di espressione regolare e restituisce un integer che indica il numero di volte in cui il modello si verifica nella stringa. Se non viene trovata alcuna corrispondenza, la funzione restituisce 0.
## Sintassi
```
REGEXP_COUNT ( source_string, pattern [, position [, parameters ] ] )
```
## Argomenti
*source\$1string*
Un'espressione di stringa, come ad esempio un nome di colonna, da cercare.
*pattern*
Un valore letterale di stringa che rappresenta un modello di espressione regolare.
*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 è 0.
*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.
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE).
## Tipo restituito
Numero intero
## Esempio
L'esempio seguente conta il numero di volte in cui si verifica una sequenza di tre lettere.
```
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
regexp_count
--------------
8
```
L'esempio seguente conta il numero di volte in cui il nome di dominio di livello superiore è `org` oppure `edu`.
```
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
```
Nell'esempio seguente vengono conteggiate le ricorrenze della stringa `FOX` utilizzando una corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_count('the fox', 'FOX', 1, 'i');
regexp_count
--------------
1
```
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 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
```
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 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
```
# 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](POSITION.md), ma consente di cercare una stringa per un modello di espressione regolare.
## Sintassi
```
REGEXP_INSTR ( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Argomenti
*source\$1string*
Un'espressione di stringa, come ad esempio un nome di colonna, da cercare.
*pattern*
Un valore letterale di stringa che rappresenta un modello di espressione regolare.
*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 è 0.
*occorrenza*
Un integer positivo che indica quale occorrenza del modello utilizzare. REGEXP\$1INSTR salta le prime corrispondenze *occorrenza* -1. Il valore di default è 1. Se *occorrenza* è inferiore a 1 oppure maggiore rispetto al numero di caratteri in *source\$1string*, la ricerca viene ignorata e il risultato è 0.
*option*
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*
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).
## Tipo restituito
Numero intero
## Esempio
Nell'esempio seguente viene cercato il carattere `@` che inizia un nome di dominio e restituisce la posizione iniziale della prima corrispondenza.
```
SELECT email, regexp_instr(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_instr
-----------------------------------------------+--------------
Etiam.laoreet.libero@example.com | 21
Suspendisse.tristique@nonnisiAenean.edu | 22
amet.faucibus.ut@condimentumegetvolutpat.ca | 17
sed@lacusUtnec.ca | 4
```
Nell'esempio seguente vengono cercate le varianti della parola `Center` e viene restituita la posizione iniziale della prima corrispondenza.
```
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
```
Nell'esempio seguente viene trovata la posizione iniziale della prima ricorrenza della stringa `FOX` utilizzando una logica di associazione senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
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 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
```
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 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](REPLACE.md), ma consente di cercare una stringa per un modello di espressione regolare.
REGEXP\$1REPLACE è simile a [Funzione TRANSLATE](TRANSLATE.md) e a [Funzione REPLACE](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 ] ] ] )
```
## Argomenti
*source\$1string*
Un'espressione di stringa, come ad esempio un nome di colonna, da cercare.
*pattern*
Un valore letterale di stringa che rappresenta un modello di espressione regolare.
*replace\$1string*
Un'espressione di stringa, ad esempio un nome di colonna, che sostituirà ogni occorrenza del modello. L'impostazione predefinita è una stringa vuota ( "" ).
*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 è *source\$1string*.
*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.
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE).
## Tipo restituito
VARCHAR
Se *modello* oppure *replace\$1string* è NULL, il risultato è NULL.
## Esempio
L'esempio seguente elimina `@` e il nome di dominio dagli indirizzi email.
```
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
```
Nell'esempio seguente sono sostituiti i nomi di dominio degli indirizzi e-mail con questo valore: `internal.company.com`.
```
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
```
Nell'esempio seguente vengono sostituite tutte le ricorrenze della stringa `FOX` con il valore `quick brown fox` utilizzando una corrispondenza senza distinzione tra maiuscole e minuscole.
```
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. In questo esempio viene sostituita ogni ricorrenza di tale parola con il valore `[hidden]`.
```
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. In questo esempio viene sostituita ogni ricorrenza di tale parola con il valore `[hidden]`, ma differisce dall'esempio precedente in quanto utilizza la corrispondenza senza distinzione tra maiuscole e minuscole.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
regexp_replace
----------------------------------
[hidden] plain [hidden] [hidden]
```
# Funzione REGEXP\$1SUBSTR
Restituisce i caratteri da una stringa cercando un modello di espressione regolare. REGEXP\$1SUBSTR è simile alla funzione [Funzione SUBSTRING](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.
## Sintassi
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Argomenti
*source\$1string*
Un'espressione della stringa da ricercare.
*pattern*
Un valore letterale di stringa che rappresenta un modello di espressione regolare.
*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* è inferiore a 1 oppure maggiore rispetto al numero di caratteri in *source\$1string*, la ricerca viene ignorata e il risultato è NULL.
*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).
## Tipo restituito
VARCHAR
## Esempio
L'esempio seguente restituisce la porzione di un indirizzo email tra il carattere @ e l'estensione del dominio.
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
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
```
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.
## Sintassi
```
REPEAT(string, integer)
```
## Argomenti
*stringa*
Il primo parametro di input è la stringa da ripetere.
*integer*
Il secondo parametro è un integer che indica il numero di volte in cui ripetere la stringa.
## Tipo restituito
La funzione REPEAT restituisce una stringa.
## Esempi
L'esempio seguente ripete il valore della colonna CATID nella tabella CATEGORY tre volte:
```
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
(11 rows)
```
# 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](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(string1, old_chars, new_chars)
```
## 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 la *old\$1string*.
## Tipo restituito
VARCHAR
Se *old\$1chars* oppure *new\$1chars* è NULL, il risultato è NULL.
## Esempi
L'esempio seguente converte la stringa `Shows` in `Theatre` nel campo CATGROUP:
```
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
(11 rows)
```
# 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 sono implicitamente convertite in stringhe di caratteri a lunghezza variabile. Gli spazi finali in stringhe di caratteri a larghezza fissa vengono ignorati.
## Tipo restituito
REVERSE restituisce una VARCHAR.
## Esempi
Selezionare cinque nomi di città distinti e i corrispondenti nomi invertiti dalla tabella USERS:
```
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
(5 rows)
```
Seleziona cinque vendite IDs e il corrispondente IDs cast invertito come stringhe di caratteri:
```
select salesid, reverse(salesid)::varchar
from sales order by salesid desc limit 5;
salesid | reverse
--------+---------
172456 | 654271
172455 | 554271
172454 | 454271
172453 | 354271
172452 | 254271
(5 rows)
```
# 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 )
```
## 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 SPLIT
La funzione SPLIT consente di estrarre sottostringhe da una stringa più grande e utilizzarle come matrice. La funzione SPLIT è utile quando è necessario suddividere una stringa in singoli componenti in base a un delimitatore o uno schema specifico.
## Sintassi
```
split(str, regex, limit)
```
## Argomenti
*str*
Un'espressione stringa da dividere.
*regex*
Una stringa che rappresenta un'espressione regolare. La stringa *regex* deve essere un'espressione regolare Java.
*limite*
Un'espressione intera che controlla il numero di volte in cui viene applicata l'espressione *regolare.*
+ *limit > 0: la lunghezza dell'array risultante non sarà superiore al limite e l'ultima voce dell'array risultante conterrà tutti gli input oltre l'ultima espressione regolare corrispondente.*
+ limit <= 0: l'*espressione regolare* verrà applicata il maggior numero di volte possibile e l'array risultante può essere di qualsiasi dimensione.
## Tipo restituito
La funzione SPLIT restituisce un ARRAY.
Se`limit > 0`: la lunghezza dell'array risultante non sarà superiore al limite e l'ultima voce dell'array risultante conterrà tutti gli input oltre l'ultima espressione regolare corrispondente.
If`limit <= 0`: regex verrà applicato il maggior numero di volte possibile e l'array risultante può essere di qualsiasi dimensione.
## Esempio
In questo esempio, la funzione SPLIT divide la stringa di input `'oneAtwoBthreeC'` ovunque incontri i caratteri `'A'` o `'C'` (come specificato dal modello di espressione regolare). `'B'` `'[ABC]'` L'output risultante è una matrice di quattro elementi:`"one"`, `"two"``"three"`, e una stringa vuota. `""`
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# Funzione SPLIT\$1PART
Divide una stringa sul delimitatore specificato e restituisce la parte nella posizione specificata.
## Sintassi
```
SPLIT_PART(string, delimiter, position)
```
## 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 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(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Argomenti
*stringa di caratteri*
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.
*caratteri numerici*
Il numero di caratteri da estrarre (la lunghezza della sottostringa). Il *numbecharacters* si basa sul numero di caratteri, non sui byte, in modo che i caratteri multibyte vengano contati come caratteri singoli. Questo numero non può essere negativo.
*start\$1byte*
La posizione all'interno dell'espressione binaria per iniziare l'estrazione, a partire da 1. Questo numero può essere negativo.
*numero di byte*
Il numero di byte da estrarre, ovvero, la lunghezza della sottostringa. Questo numero non può essere negativo.
## Tipo restituito
VARCHAR
## Note di utilizzo per le stringhe di caratteri
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 *numbecharacters* supera la lunghezza della stringa, SUBSTRING restituisce una *sottostringa* a partire da start\$1position fino alla fine della stringa.* Per 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 `numbecharacters` -1. Ad esempio:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Se `start_position` \$1 `numbecharacters` -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 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 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](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, la restituzione è NULL.
## Sintassi
```
TRANSLATE ( expression, characters_to_replace, characters_to_substitute )
```
## 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
L'esempio seguente sostituisce diversi caratteri in una stringa:
```
select translate('mint tea', 'inea', 'osin');
translate
-----------
most tin
```
L'esempio seguente sostituisce il simbolo at (@) con un punto per tutti i valori in una colonna:
```
select email, translate(email, '@', '.') as obfuscated_email
from users limit 10;
email obfuscated_email
-------------------------------------------------------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu Etiam.laoreet.libero.sodalesMaurisblandit.edu
amet.faucibus.ut@condimentumegetvolutpat.ca amet.faucibus.ut.condimentumegetvolutpat.ca
turpis@accumsanlaoreet.org turpis.accumsanlaoreet.org
ullamcorper.nisl@Cras.edu ullamcorper.nisl.Cras.edu
arcu.Curabitur@senectusetnetus.com arcu.Curabitur.senectusetnetus.com
ac@velit.ca ac.velit.ca
Aliquam.vulputate.ullamcorper@amalesuada.org Aliquam.vulputate.ullamcorper.amalesuada.org
vel.est@velitegestas.edu vel.est.velitegestas.edu
dolor.nonummy@ipsumdolorsit.ca dolor.nonummy.ipsumdolorsit.ca
et@Nunclaoreet.ca et.Nunclaoreet.ca
```
L'esempio seguente sostituisce gli spazi con caratteri di sottolineatura ed elimina i punti per tutti i valori in una colonna:
```
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
Riduce una stringa rimuovendo spazi vuoti iniziali e finali o rimuovendo i caratteri iniziali e finali che corrispondono a una stringa specificata facoltativa.
## Sintassi
```
TRIM( [ BOTH ] [ trim_chars FROM ] string
```
## Argomenti
*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 si utilizza la funzione TRIM con un comando SQL, converte implicitamente i risultati in VARCHAR. AWS Clean Rooms Se si utilizza la funzione TRIM nell'elenco SELECT per una funzione SQL, AWS Clean Rooms non converte implicitamente i risultati e potrebbe essere necessario eseguire una conversione esplicita per evitare un errore di mancata corrispondenza del tipo di dati. Vedi la [Funzione CAST](CAST_function.md) funzione per informazioni sulle conversioni esplicite.
## Esempio
L'esempio seguente riduce gli spazi vuoti iniziali e finali dalla stringa `' abc '`:
```
select ' abc ' as untrim, trim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
Nell'esempio seguente vengono rimosse le virgolette doppie che circondano la stringa `"dog"`:
```
select trim('"' FROM '"dog"');
btrim
-------
dog
```
TRIM 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, trim(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
```
# 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)
```
## Argomenti
*stringa*
Il parametro di input è una stringa VARCHAR (o qualsiasi altro tipo di dati, ad esempio CHAR, che può essere convertito implicitamente in VARCHAR).
## Tipo restituito
La funzione UPPER restituisce una stringa di caratteri che appartiene allo stesso tipo di dati della stringa di input.
## Esempi
L'esempio seguente converte il campo CATNAME in lettere maiuscole:
```
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
(11 rows)
```
# Funzione UUID
La funzione UUID genera un identificatore univoco universale (UUID).
UUIDs sono identificatori univoci globali che vengono comunemente utilizzati per fornire identificatori univoci per vari scopi, come:
+ Identificazione dei record del database o di altre entità di dati.
+ Generazione di nomi o chiavi univoci per file, directory o altre risorse.
+ Monitoraggio e correlazione dei dati tra sistemi distribuiti.
+ Fornitura di identificatori univoci per pacchetti di rete, componenti software o altre risorse digitali.
La funzione UUID genera un valore UUID unico con una probabilità molto elevata, anche su sistemi distribuiti e per lunghi periodi di tempo. UUIDs vengono generalmente generati utilizzando una combinazione del timestamp corrente, dell'indirizzo di rete del computer e di altri dati casuali o pseudo-casuali, garantendo che è altamente improbabile che ogni UUID generato entri in conflitto con altri UUID.
Nel contesto di una query SQL, la funzione UUID può essere utilizzata per generare identificatori univoci per nuovi record da inserire in un database o per fornire chiavi univoche per il partizionamento dei dati, l'indicizzazione o altri scopi in cui è richiesto un identificatore univoco.
**Nota**
La funzione UUID non è deterministica.
## Sintassi
```
uuid()
```
## Argomenti
La funzione UUID non accetta argomenti.
## Tipo restituito
UUID restituisce una stringa di identificazione univoca universale (UUID). Il valore viene restituito come stringa UUID canonica di 36 caratteri.
## Esempio
L'esempio seguente genera un identificatore univoco universale (UUID). L'output è una stringa di 36 caratteri che rappresenta un identificatore univoco universale.
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```