SQL RPAD()

In SQL, RPAD() viene utilizzato per riempire la parte destra di una stringa con un carattere specificato. La funzione può essere utilizzata su stringhe e numeri, anche se, a seconda del DBMS, potrebbe essere necessario passare i numeri come stringa prima di poter essere riempiti.

DBMS che hanno un RPAD() funzioni includono MySQL, MariaDB, PostgreSQL e Oracle.

DBMS che non avere un RPAD() funzione includono SQL Server e SQLite.

Esempio

Ecco un esempio per dimostrare il RPAD() funzione:

SELECT RPAD('Look Right', 40);

Risultato:

+------------------------------------------+
| RPAD('Look Right', 40)                   |
+------------------------------------------+
| Look Right                               |
+------------------------------------------+

Qui, la parte destra della stringa è riempita con uno spazio (il carattere di riempimento predefinito) e la stringa risultante è lunga 40 caratteri (perché ho specificato 40 come secondo argomento).

Oracle funziona allo stesso modo, ma dobbiamo usare FROM DUAL quando si esegue una query come questa (senza interrogare una tabella reale):

SELECT RPAD('Look Right', 40) 
FROM DUAL;

Risultato:

                       RPAD('LOOKRIGHT',40) 
___________________________________________ 
Look Right                                 

Negli esempi precedenti, ho usato molta imbottitura per renderla evidente.

Ecco un altro esempio che può dimostrare più chiaramente la giusta imbottitura:

SELECT CONCAT(RPAD('abc', 4), 'def');

Risultato:

abc def

In questo caso, ho concatenato abc con def ma abc aveva il padding destro applicato con RPAD() funzione.

Specifica un carattere di riempimento

L'imbottitura non deve necessariamente essere uno spazio. Possiamo opzionalmente aggiungere un terzo argomento per specificare il carattere (oi caratteri) da utilizzare nel riempimento.

SELECT RPAD('Rat', 4, 't');

Risultato:

Ratt

Può essere utilizzato anche per inserire a destra i numeri con zeri (o un'altra cifra):

SELECT RPAD('7', 3, '0');

Risultato:

700

Questo ovviamente cambia il numero e, in questo caso, lo stesso si sarebbe potuto ottenere semplicemente moltiplicando il numero per 100. Tuttavia, moltiplicare un numero in realtà non applica il riempimento ad esso.

L'esempio seguente mostra cosa intendo:

SELECT RPAD('77', 3, '0');

Risultato:

770

Moltiplicare 77 per 100 avrebbe avuto un risultato sbagliato.

Negli esempi precedenti ho passato il numero come stringa.

In alcuni DBMS (come MariaDB e MySQL) possiamo passare il numero come numero, così come il numero con cui riempirlo:

SELECT RPAD(7, 3, 0);

Risultato:

700

Possiamo farlo anche in Oracle:

SELECT RPAD(7, 3, 0) 
FROM DUAL;

Risultato:

700

Ma PostgreSQL ha un problema con questo:

SELECT RPAD(7, 3, 0);

Risultato:

ERROR:  function rpad(integer, integer, integer) does not exist

SQL Server

SQL Server non ha un RPAD() funzione, ma questo non ci impedisce di aggiungere padding a numeri e stringhe.

Numeri

Se il numero ha una parte frazionaria, il FORMAT() la funzione sarà sufficiente:

SELECT 
    FORMAT(0.7, '.000') AS "1",
    FORMAT(0.7, '0.00') AS "2",
    FORMAT(7.0, '0.00') AS "3";

Risultato:

+------+------+------+
| 1    | 2    | 3    |
|------+------+------|
| .700 | 0.70 | 7.00 |
+------+------+------+

Il modo in cui funziona è passare il numero, seguito da una stringa di formato. Nell'esempio precedente, la stringa di formato è costituita da identificatori di formato numerico personalizzati che fanno sì che il numero originale abbia cifre aggiunte alla sua parte frazionaria. Se non ci sono già tante cifre nel numero originale, viene riempito con zeri.

Ma se il numero non ha una parte frazionaria, allora possiamo usare il REPLACE() funzione per rimuovere il separatore decimale applicato con FORMAT() funzione:

SELECT 
    REPLACE(FORMAT(7, '.00', 'en-US'), '.', '') AS "1",
    REPLACE(FORMAT(17, '.00', 'en-US'), '.', '') AS "2",
    REPLACE(FORMAT(73.5, '.00', 'en-US'), '.', '') AS "3";

Risultato:

+-----+------+------+
| 1   | 2    | 3    |
|-----+------+------|
| 700 | 1700 | 7350 |
+-----+------+------+

Questo metodo può essere utilizzato anche per aggiungere zeri iniziali, se necessario. Basta aggiungerli a sinistra della virgola decimale nella stringa di formato.

Qui, ho usato esplicitamente en-US come terzo argomento (facoltativo) per garantire che il separatore decimale sia un punto/punto, che è la convenzione utilizzata da en-US locale.

Testo

Ecco una tecnica che può essere utilizzata sui dati testuali:

SELECT 
    LEFT('Dog' + '.........', 9) AS "1",
    LEFT('Horse' + '.........', 9) AS "2",
    LEFT('Crocodile' + '.........', 9) AS "3";

Risultato:

+-----------+-----------+-----------+
| 1         | 2         | 3         |
|-----------+-----------+-----------|
| Dog...... | Horse.... | Crocodile |
+-----------+-----------+-----------+

Anche se dovrai fare attenzione a non tagliare accidentalmente parte della corda o aggiungere spazi indesiderati.