PostgreSQL - Funzione String
Le funzioni di stringa PostgreSQL sono utilizzate principalmente per la manipolazione delle stringhe. La tabella seguente descrive in dettaglio le importanti funzioni delle stringhe:
| S. No. | Nome e descrizione |
|---|---|
| 1 | ASCII () Restituisce il valore numerico del carattere più a sinistra |
| 2 | BIT_LENGTH () Restituisce la lunghezza dell'argomento in bit |
| 3 | CHAR_LENGTH () Restituisce il numero di caratteri nell'argomento |
| 4 | CHARACTER_LENGTH () Un sinonimo di CHAR_LENGTH () |
| 5 | CONCAT_WS () Restituisce concatenato con separatore |
| 6 | CONCAT () Restituisce una stringa concatenata |
| 7 | LCASE () Sinonimo di INFERIORE () |
| 8 | SINISTRA() Restituisce il numero di caratteri più a sinistra come specificato |
| 9 | LUNGHEZZA() Restituisce la lunghezza di una stringa in byte |
| 10 | INFERIORE() Restituisce l'argomento in minuscolo |
| 11 | LPAD () Restituisce l'argomento della stringa, riempito a sinistra con la stringa specificata |
| 12 | LTRIM () Rimuove gli spazi iniziali |
| 13 | MID () Restituisce una sottostringa a partire dalla posizione specificata |
| 14 | POSIZIONE() Un sinonimo di LOCATE () |
| 15 | CITAZIONE() Evita l'argomento per l'uso in un'istruzione SQL |
| 16 | REGEXP Pattern matching utilizzando espressioni regolari |
| 17 | RIPETERE() Ripete una stringa il numero di volte specificato |
| 18 | SOSTITUIRE() Sostituisce le occorrenze di una stringa specificata |
| 19 | INVERSIONE() Inverti i caratteri in una stringa |
| 20 | DESTRA() Restituisce il numero di caratteri più a destra specificato |
| 21 | RPAD () Aggiunge la stringa il numero di volte specificato |
| 22 | RTRIM () Rimuove gli spazi finali |
| 24 | SUBSTRING (), SUBSTR () Restituisce la sottostringa come specificato |
| 25 | TRIM () Rimuove gli spazi iniziali e finali |
| 26 | UCASE () Sinonimo di UPPER () |
| 27 | SUPERIORE() Converte in maiuscolo |
ASCII (str)
Restituisce il valore numerico del carattere più a sinistra della stringa str. Restituisce 0 se str è una stringa vuota. Restituisce NULL se str è NULL. ASCII () funziona per i caratteri con valori numerici compresi tra 0 e 255.
testdb=# SELECT ASCII('2');
+---------------------------------------------------------+
| ASCII('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
testdb=# SELECT ASCII('dx');
+---------------------------------------------------------+
| ASCII('dx') |
+---------------------------------------------------------+
| 100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_LENGTH (str)
Restituisce la lunghezza della stringa str in bit.
testdb=# SELECT BIT_LENGTH('text');
+---------------------------------------------------------+
| BIT_LENGTH('text') |
+---------------------------------------------------------+
| 32 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHAR_LENGTH (str)
Restituisce la lunghezza della stringa str, misurata in caratteri. Un carattere multibyte conta come un singolo carattere. Ciò significa che per una stringa contenente cinque caratteri a due byte, LENGTH () restituisce 10, mentre CHAR_LENGTH () restituisce 5.
testdb=# SELECT CHAR_LENGTH('text');
+---------------------------------------------------------+
| CHAR_LENGTH('text') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHARACTER_LENGTH (str)
CHARACTER_LENGTH () è un sinonimo di CHAR_LENGTH ().
CONCAT (str1, str2, ...)
Restituisce la stringa che risulta dalla concatenazione degli argomenti. Può avere uno o più argomenti. Se tutti gli argomenti sono stringhe non binarie, il risultato è una stringa non binaria. Se gli argomenti includono stringhe binarie, il risultato è una stringa binaria. Un argomento numerico viene convertito nella sua forma di stringa binaria equivalente; se vuoi evitarlo, puoi usare un cast di tipo esplicito, come in questo esempio -
testdb=# SELECT CONCAT('My', 'S', 'QL');
+---------------------------------------------------------+
| CONCAT('My', 'S', 'QL') |
+---------------------------------------------------------+
| MySQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONCAT_WS (separatore, str1, str2, ...)
CONCAT_WS () sta per Concatenate With Separator ed è una forma speciale di CONCAT (). Il primo argomento è il separatore per il resto degli argomenti. Il separatore viene aggiunto tra le stringhe da concatenare. Il separatore può essere una stringa, così come il resto degli argomenti. Se il separatore è NULL, il risultato è NULL.
testdb=# SELECT CONCAT_WS(',','First name','Last Name' );
+---------------------------------------------------------+
| CONCAT_WS(',','First name','Last Name' ) |
+---------------------------------------------------------+
| First name, Last Name |
+---------------------------------------------------------+
1 row in set (0.00 sec)LCASE (str)
LCASE () è un sinonimo di LOWER ().
SINISTRA (str, len)
Restituisce i caratteri len più a sinistra dalla stringa str o NULL se un argomento è NULL.
testdb=# SELECT LEFT('foobarbar', 5);
+---------------------------------------------------------+
| LEFT('foobarbar', 5) |
+---------------------------------------------------------+
| fooba |
+---------------------------------------------------------+
1 row in set (0.00 sec)LUNGHEZZA (str)
Restituisce la lunghezza della stringa str, misurata in byte. Un carattere multibyte conta come più byte. Ciò significa che per una stringa contenente cinque caratteri a due byte, LENGTH () restituisce 10, mentre CHAR_LENGTH () restituisce 5.
testdb=# SELECT LENGTH('text');
+---------------------------------------------------------+
| LENGTH('text') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)INFERIORE (str)
Restituisce la stringa str con tutti i caratteri modificati in minuscolo in base alla mappatura del set di caratteri corrente.
testdb=# SELECT LOWER('QUADRATICALLY');
+---------------------------------------------------------+
| LOWER('QUADRATICALLY') |
+---------------------------------------------------------+
| quadratically |
+---------------------------------------------------------+
1 row in set (0.00 sec)LPAD (str, len, padstr)
Restituisce la stringa str, riempita a sinistra con la stringa padstr a una lunghezza di caratteri len. Se str è più lungo di len, il valore restituito viene abbreviato in caratteri len.
testdb=# SELECT LPAD('hi',4,'??');
+---------------------------------------------------------+
| LPAD('hi',4,'??') |
+---------------------------------------------------------+
| ??hi |
+---------------------------------------------------------+
1 row in set (0.00 sec)LTRIM (str)
Restituisce la stringa str con i caratteri di spazio iniziali rimossi.
testdb=# SELECT LTRIM(' barbar');
+---------------------------------------------------------+
| LTRIM(' barbar') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)MID (str, pos, len)
MID (str, pos, len) è sinonimo di SUBSTRING (str, pos, len).
POSITION (substr IN str)
POSITION (substr IN str) è un sinonimo di LOCATE (substr, str).
QUOTE_IDENT (stringa di testo), QUOTE_LITERAL (stringa di testo), QUOTE_LITERAL (valore qualsiasi elemento), QUOTE_NULLABLE (valore qualsiasi elemento)
Tutte queste funzioni restituiscono la stringa data opportunamente citata per essere utilizzata come identificatore in una stringa di istruzioni SQL. Nella funzione QUOTE_IDENT le virgolette vengono aggiunte solo se necessario. Nella funzione QUOTE_LITERAL, le virgolette singole e le barre rovesciate incorporate vengono raddoppiate correttamente. Se viene passato un valore, forza il valore dato in testo e quindi lo cita come letterale. La funzione QUOTE_NULLABLE, forza il valore dato in testo e poi lo cita come letterale; oppure, se l'argomento è null, restituisce NULL.
Di seguito sono riportati gli esempi per tutte queste funzioni:
testdb=# SELECT QUOTE_IDENT('Foo bar');
quote_ident
-------------
"Foo bar"
(1 row)
testdb=# SELECT QUOTE_LITERAL(E'O\'Reilly');
quote_literal
---------------
'O''Reilly'
(1 row)
testdb=# SELECT QUOTE_LITERAL(42.5);
quote_literal
---------------
'42.5'
(1 row)
testdb=# SELECT QUOTE_NULLABLE(42.5);
quote_nullable
----------------
'42.5'
(1 row)expr modello REGEXP
La funzione REGEXP_MATCHES (string text, pattern text [, flags text]) esegue un pattern match di expr contro pattern. Restituisce 1 se expr corrisponde a pat; altrimenti restituisce 0. Se espr o pat è NULL, il risultato è NULL. REGEXP_MATCHES non distingue tra maiuscole e minuscole, tranne quando viene utilizzato con stringhe binarie.
La funzione REGEXP_REPLACE (testo stringa, testo modello, testo sostitutivo [, testo contrassegni]) sostituisce le sottostringhe che corrispondono a un'espressione regolare POSIX.
REGEXP_SPLIT_TO_ARRAY (string text, pattern text [, flags text]), Split string utilizzando un'espressione regolare POSIX come delimitatore.
REGEXP_SPLIT_TO_TABLE (string text, pattern text [, flags text]), divide la stringa utilizzando un'espressione regolare POSIX come delimitatore.
Di seguito sono riportati gli esempi per tutte queste funzioni:
testdb=# SELECT REGEXP_MATCHES('ABCDEF','A%C%%');
regexp_matches
----------------
(0 rows)
testdb=# SELECT REGEXP_REPLACE('Thomas', '.[mN]a.', 'M');
regexp_replace
----------------
ThM
(1 row)
testdb=# SELECT REGEXP_SPLIT_TO_ARRAY('hello world', E'\\s+');
regexp_split_to_array
-----------------------
{hello,world}
(1 row)
testdb=# SELECT REGEXP_SPLIT_TO_TABLE('hello world', E'\\s+');
regexp_split_to_table
-----------------------
hello
world
(2 rows)REPEAT (str, count)
Restituisce una stringa composta dalla stringa str ripetuta il conteggio delle volte. Se count è minore di 1, restituisce una stringa vuota. Restituisce NULL se str o count sono NULL.
testdb=# SELECT REPEAT('SQL', 3);
repeat
-----------
SQLSQLSQL
(1 row)SOSTITUISCI (str, from_str, to_str)
Restituisce la stringa str con tutte le occorrenze della stringa from_str sostituite dalla stringa to_str. REPLACE () esegue una corrispondenza con distinzione tra maiuscole e minuscole durante la ricerca di from_str.
testdb=# SELECT REPLACE('www.mysql.com', 'w', 'Ww');
replace
------------------
WwWwWw.mysql.com
(1 row)REVERSE (str)
Restituisce la stringa str con l'ordine dei caratteri invertito.
testdb=# SELECT REVERSE('abcd');
reverse
---------
dcba
(1 row)DESTRA (str, len)
Restituisce i caratteri len più a destra dalla stringa str o NULL se un argomento è NULL.
testdb=# SELECT RIGHT('foobarbar', 4);
right
-------
rbar
(1 row)RPAD (str, len, padstr)
Restituisce la stringa str, riempita a destra con la stringa padstr a una lunghezza di caratteri len. Se str è più lungo di len, il valore restituito viene abbreviato in caratteri len.
testdb=# SELECT RPAD('hi',5,'?');
rpad
-------
hi???
(1 row)RTRIM (str)
Restituisce la stringa str con i caratteri spazio finali rimossi.
testdb=# SELECT RTRIM('barbar ');
rtrim
--------
barbar
(1 row)SUBSTRING (str, pos), SUBSTRING (str FROM pos), SUBSTRING (str, pos, len), SUBSTRING (str FROM pos FOR len)
Le forme senza un argomento len restituiscono una sottostringa dalla stringa str a partire dalla posizione pos. Le forme con un argomento len restituiscono una sottostringa len caratteri lunghi dalla stringa str, a partire dalla posizione pos. I moduli che utilizzano FROM sono la sintassi SQL standard. È anche possibile utilizzare un valore negativo per pos. In questo caso, l'inizio della sottostringa è costituito da caratteri pos dalla fine della stringa, piuttosto che dall'inizio. Un valore negativo può essere utilizzato per pos in una qualsiasi delle forme di questa funzione.
testdb=# SELECT SUBSTRING('Quadratically',5);
substring
-----------
ratically
(1 row)
testdb=# SELECT SUBSTRING('foobarbar' FROM 4);
substring
-----------
barbar
(1 row)
testdb=# SELECT SUBSTRING('Quadratically',5,6);
substring
-----------
ratica
(1 row)TRIM ([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM ([remstr FROM] str)
Restituisce la stringa str con tutti i prefissi o suffissi remstr rimossi. Se non viene fornito nessuno degli specificatori BOTH, LEADING o TRAILING, si presume ENTRAMBI. remstr è facoltativo e, se non specificato, gli spazi vengono rimossi.
testdb=# SELECT TRIM(' bar ');
btrim
-------
bar
(1 row)
testdb=# SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
ltrim
--------
barxxx
(1 row)
testdb=# SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
btrim
-------
bar
(1 row)
testdb=# SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
rtrim
-------
bar
(1 row)UCASE (str)
UCASE () è un sinonimo di UPPER ().
SUPERIORE (str)
Restituisce la stringa str con tutti i caratteri modificati in maiuscolo in base alla mappatura del set di caratteri corrente.
testdb=# SELECT UPPER('manisha');
upper
---------
MANISHA
(1 row)