SQLRPAD()

Em SQL, RPAD() é usado para preencher a parte direita de uma string com um caractere especificado. A função pode ser usada em strings e números, embora dependendo do DBMS, os números podem ter que ser passados como uma string antes de serem preenchidos.

DBMSs que possuem um RPAD() incluem MySQL, MariaDB, PostgreSQL e Oracle.

SGBDs que não tem um RPAD() função incluem SQL Server e SQLite.

Exemplo

Aqui está um exemplo para demonstrar o RPAD() função:

SELECT RPAD('Look Right', 40);

Resultado:

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

Aqui, a parte direita da string é preenchida com um espaço (o caractere de preenchimento padrão) e a string resultante tem 40 caracteres (porque eu especifiquei 40 como segundo argumento).

Oracle funciona da mesma forma, mas precisamos usar FROM DUAL ao fazer uma consulta como esta (sem consultar uma tabela real):

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

Resultado:

                       RPAD('LOOKRIGHT',40) 
___________________________________________ 
Look Right

Nos exemplos acima, usei muito preenchimento para tornar o preenchimento aparente.

Aqui está outro exemplo que pode demonstrar o preenchimento correto de forma mais clara:

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

Resultado:

abc def

Neste caso, concatenei abc com def mas abc tinha preenchimento direito aplicado com o RPAD() função.

Especifique um caractere de preenchimento

O preenchimento não precisa necessariamente ser um espaço. Opcionalmente, podemos adicionar um terceiro argumento para especificar o caractere (ou caracteres) a ser usado no preenchimento.

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

Resultado:

Ratt

Também pode ser usado para padronizar números com zeros (ou outro dígito):

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

Resultado:

Isso obviamente altera o número e, neste caso, o mesmo poderia ter sido alcançado simplesmente multiplicando o número por 100. No entanto, multiplicar um número não aplica preenchimento a ele.

O exemplo a seguir demonstra o que quero dizer:

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

Resultado:

Multiplicar 77 por 100 teria o resultado errado.

Nos exemplos acima eu passei o número como uma string.

Em alguns SGBDs (como MariaDB e MySQL) podemos passar o número como um número, assim como o número para preenchê-lo:

SELECT RPAD(7, 3, 0);

Resultado:

Também podemos fazer isso no Oracle:

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

Resultado:

Mas o PostgreSQL tem um problema com isso:

SELECT RPAD(7, 3, 0);

Resultado:

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

SQL Server

SQL Server não tem um RPAD() função, mas isso não nos impede de adicionar preenchimento a números e strings.

Números

Se o número tiver uma parte fracionária, o FORMAT() função será suficiente:

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

Resultado:

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

A forma como funciona é que passamos o número, seguido por uma string de formato. No exemplo acima, a string de formato consiste em especificadores de formato numérico personalizados que resultam no número original com dígitos adicionados à sua parte fracionária. Se ainda não houver tantos dígitos no número original, ele será preenchido com zeros.

Mas se o número não tiver uma parte fracionária, podemos usar o REPLACE() função para remover o separador decimal que é aplicado com o FORMAT() função:

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

Resultado:

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

Este método também pode ser usado para adicionar zeros à esquerda, se necessário. Basta adicioná-los à esquerda do ponto decimal na string de formato.

Aqui, eu usei explicitamente en-US como o terceiro argumento (opcional) para garantir que o separador decimal seja um ponto/ponto final, que é a convenção usada pelo en-US localidade.

Texto

Aqui está uma técnica que pode ser usada em dados textuais:

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

Resultado:

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

Embora você precise ter cuidado para não cortar acidentalmente parte da string ou adicionar espaços indesejados.