SQLRPAD()

En SQL, RPAD() est utilisé pour remplir la partie droite d'une chaîne avec un caractère spécifié. La fonction peut être utilisée sur des chaînes et des nombres, bien que selon le SGBD, les nombres doivent être passés sous forme de chaîne avant de pouvoir être remplis.

Les SGBD qui ont un RPAD() incluent MySQL, MariaDB, PostgreSQL et Oracle.

Les SGBD qui ne le font pas avoir un RPAD() fonction incluent SQL Server et SQLite.

Exemple

Voici un exemple pour démontrer le RPAD() fonction :

SELECT RPAD('Look Right', 40);

Résultat :

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

Ici, la partie droite de la chaîne est complétée par un espace (le caractère de remplissage par défaut), et la chaîne résultante fait 40 caractères (parce que j'ai spécifié 40 comme second argument).

Oracle fonctionne de la même manière, mais nous devons utiliser FROM DUAL lors d'une requête comme celle-ci (sans interroger une table réelle) :

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

Résultat :

                       RPAD('LOOKRIGHT',40) 
___________________________________________ 
Look Right                                 

Dans les exemples ci-dessus, j'ai utilisé beaucoup de rembourrage afin de rendre le rembourrage apparent.

Voici un autre exemple qui peut démontrer plus clairement le bon rembourrage :

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

Résultat :

abc def

Dans ce cas, j'ai concaténé abc avec def mais abc avait un rembourrage droit appliqué avec le RPAD() fonction.

Spécifiez un caractère de remplissage

Le rembourrage ne doit pas nécessairement être un espace. Nous pouvons éventuellement ajouter un troisième argument pour spécifier le caractère (ou les caractères) à utiliser dans le padding.

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

Résultat :

Ratt

Il peut également être utilisé pour corriger les numéros avec des zéros (ou un autre chiffre) :

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

Résultat :

700

Cela change évidemment le nombre et dans ce cas, la même chose aurait pu être obtenue simplement en multipliant le nombre par 100. Cependant, multiplier un nombre ne lui applique pas réellement de rembourrage.

L'exemple suivant illustre ce que je veux dire :

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

Résultat :

770

Multiplier 77 par 100 aurait eu un mauvais résultat.

Dans les exemples ci-dessus, j'ai passé le nombre sous forme de chaîne.

Dans certains SGBD (tels que MariaDB et MySQL), nous pouvons transmettre le numéro sous forme de nombre, ainsi que le numéro avec lequel le remplir :

SELECT RPAD(7, 3, 0);

Résultat :

700

Nous pouvons également le faire dans Oracle :

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

Résultat :

700

Mais PostgreSQL a un problème avec ceci :

SELECT RPAD(7, 3, 0);

Résultat :

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

SQL Server

SQL Server n'a pas de RPAD() fonction, mais cela ne nous empêche pas d'ajouter du rembourrage aux nombres et aux chaînes.

Numéros

Si le nombre a une partie fractionnaire, le FORMAT() fonction suffira :

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

Résultat :

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

La façon dont cela fonctionne est que nous transmettons le nombre, suivi d'une chaîne de format. Dans l'exemple ci-dessus, la chaîne de format se compose de spécificateurs de format numériques personnalisés qui font que le nombre d'origine a des chiffres ajoutés à sa partie fractionnaire. S'il n'y a pas déjà autant de chiffres dans le numéro d'origine, il est rempli de zéros.

Mais si le nombre n'a pas de partie fractionnaire, alors nous pouvons utiliser le REPLACE() fonction pour supprimer le séparateur décimal appliqué avec le FORMAT() fonction :

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

Résultat :

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

Cette méthode peut également être utilisée pour ajouter des zéros non significatifs si nécessaire. Ajoutez-les simplement à gauche de la virgule décimale dans la chaîne de format.

Ici, j'ai explicitement utilisé en-US comme troisième argument (facultatif) pour s'assurer que le séparateur décimal est un point/point, ce qui est la convention utilisée par le en-US locale.

Texte

Voici une technique qui peut être utilisée sur des données textuelles :

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

Résultat :

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

Bien que vous deviez faire attention à ne pas couper accidentellement une partie de la chaîne ou à ajouter des espaces indésirables.