SQL RPAD()

I SQL, RPAD() används för att fylla den högra delen av en sträng med ett specificerat tecken. Funktionen kan användas på strängar och siffror, men beroende på DBMS kan siffror behöva skickas som en sträng innan de kan utfyllas.

DBMS som har en RPAD() funktioner inkluderar MySQL, MariaDB, PostgreSQL och Oracle.

DBMS som inte gör det har en RPAD() funktioner inkluderar SQL Server och SQLite.

Exempel

Här är ett exempel för att demonstrera RPAD() funktion:

SELECT RPAD('Look Right', 40);

Resultat:

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

Här är den högra delen av strängen utfylld med ett mellanslag (standard utfyllnadstecken), och den resulterande strängen är 40 tecken lång (eftersom jag angav 40 som det andra argumentet).

Oracle fungerar på samma sätt, men vi måste använda FROM DUAL när du gör en fråga som denna (utan att fråga en faktisk tabell):

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

Resultat:

                       RPAD('LOOKRIGHT',40) 
___________________________________________ 
Look Right                                 

I exemplen ovan använde jag mycket stoppning för att göra stoppningen tydlig.

Här är ett annat exempel som kan visa rätt stoppning tydligare:

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

Resultat:

abc def

I det här fallet sammanfogade jag abc med def men abc hade rätt utfyllnad tillämpad med RPAD() funktion.

Ange en utfyllnadstecken

Vadderingen behöver inte nödvändigtvis vara ett mellanslag. Vi kan valfritt lägga till ett tredje argument för att specificera tecknet (eller tecknen) som ska användas i utfyllnaden.

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

Resultat:

Ratt

Den kan också användas för att räta ut nummer med nollor (eller en annan siffra):

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

Resultat:

700

Detta ändrar uppenbarligen talet och i det här fallet kunde detsamma ha uppnåtts helt enkelt genom att multiplicera talet med 100. Men att multiplicera ett tal tillämpar faktiskt inte utfyllnad på det.

Följande exempel visar vad jag menar:

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

Resultat:

770

Att multiplicera 77 med 100 skulle ha fått fel resultat.

I exemplen ovan skickade jag numret som en sträng.

I vissa DBMS:er (som MariaDB och MySQL) kan vi skicka numret som ett nummer, såväl som numret att fylla det med:

SELECT RPAD(7, 3, 0);

Resultat:

700

Vi kan också göra detta i Oracle:

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

Resultat:

700

Men PostgreSQL har ett problem med detta:

SELECT RPAD(7, 3, 0);

Resultat:

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

SQL-server

SQL Server har ingen RPAD() funktion, men det hindrar oss inte från att lägga till utfyllnad till siffror och strängar.

Siffror

Om talet har en bråkdel, FORMAT() funktionen räcker:

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

Resultat:

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

Så det fungerar är att vi skickar numret, följt av en formatsträng. I exemplet ovan består formatsträngen av anpassade numeriska formatspecifikationer som resulterar i att det ursprungliga numret har siffror tillagda i sin bråkdel. Om det inte redan finns så många siffror i det ursprungliga numret är det utfyllt med nollor.

Men om talet inte har en bråkdel kan vi använda REPLACE() funktion för att ta bort decimalavgränsaren som används med FORMAT() funktion:

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";

Resultat:

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

Denna metod kan också användas för att lägga till inledande nollor om det behövs. Lägg bara till dem till vänster om decimaltecknet i formatsträngen.

Här jag använde uttryckligen en-US som det (valfria) tredje argumentet för att säkerställa att decimalavgränsaren är en punkt/punkt, vilket är konventionen som används av en-US språk.

Text

Här är en teknik som kan användas på textdata:

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

Resultat:

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

Även om du måste vara försiktig så att du inte av misstag hugger av en del av snöret eller lägger till oönskade mellanslag.