RPAD¶

Sintaxe¶

RPAD( <base>, <length_expr> [, <pad>] )

Argumentos¶

base

Um valor VARCHAR ou BINARY.

length_expr

Uma expressão que é avaliada como um inteiro. Especifica:

• O número de caracteres UTF-8 a retornar se a entrada for VARCHAR.

• O número de bytes a retornar se a entrada for BINARY.

pad

Um valor VARCHAR ou BINARY. O tipo deve corresponder ao tipo de dados do argumento base. Os caracteres (ou bytes) desse argumento são usados para preencher o endereço base.

Retornos¶

O tipo de dados do valor retornado é o mesmo que o tipo de dados do valor de entrada base (VARCHAR ou BINARY).

Notas de uso¶

• Se o argumento base for mais longo que length_expr, ele é truncado no comprimento length_expr.

• O argumento pad pode ser de múltiplos caracteres/bytes. O argumento pad é repetido no resultado até atingir a extensão desejada (length_expr) ser alcançada, truncando quaisquer caracteres/bytes supérfluos no argumento pad. Se o argumento pad estiver vazio, nenhum preenchimento é inserido, mas o resultado ainda é truncado no comprimento length_expr.

• Quando base é uma cadeia de caracteres, a cadeia padrão pad é ' ' (um único espaço em branco). Quando base é um valor binário, o argumento pad deve ser fornecido explicitamente.

Detalhes do agrupamento¶

• O agrupamento se aplica às entradas VARCHAR. O agrupamento não se aplica se o tipo de dados de entrada do primeiro argumento for BINARY.

• No impact. Embora o agrupamento seja aceito sintaticamente, os agrupamentos não têm impacto no processamento. Por exemplo, idiomas com letras de dois e três caracteres (por exemplo, «dzs» em húngaro, «ch» em tcheco) ainda contam como dois ou três caracteres (não um caractere) para o argumento de comprimento.

• The collation of the result is the same as the collation of the input. Isso pode ser útil se o valor retornado for passado para outra função como parte de chamadas de funções aninhadas.

• Atualmente, o Snowflake permite que os argumentos base e pad tenham diferentes especificadores de agrupamento. No entanto, os especificadores de agrupamento individuais não podem ser mantidos porque o valor retornado tem apenas um especificador de agrupamento. A Snowflake recomenda que você evite usar cadeias de caracteres pad que tenham um agrupamento diferente da cadeia de caracteres base.

Exemplos¶

Esses exemplos usam a função RPAD para preencher os dados de VARCHAR e BINARY à direita.

Criar e preencher uma tabela:

CREATE OR REPLACE TABLE padding_example (v VARCHAR, b BINARY);

INSERT INTO padding_example (v, b)
  SELECT
    'Hi',
    HEX_ENCODE('Hi');

INSERT INTO padding_example (v, b)
  SELECT
    '-123.00',
    HEX_ENCODE('-123.00');

INSERT INTO padding_example (v, b)
  SELECT
    'Twelve Dollars',
    TO_BINARY(HEX_ENCODE('Twelve Dollars'), 'HEX');

Consulte a tabela para mostrar os dados:

SELECT * FROM padding_example;

+----------------+------------------------------+
| V              | B                            |
|----------------+------------------------------|
| Hi             | 4869                         |
| -123.00        | 2D3132332E3030               |
| Twelve Dollars | 5477656C766520446F6C6C617273 |
+----------------+------------------------------+

Este exemplo demonstra o preenchimento à direita dos valores de VARCHAR usando a função RPAD, com os resultados limitados a 10 caracteres:

SELECT v,
       RPAD(v, 10, '_') AS pad_with_underscore,
       RPAD(v, 10, '$') AS pad_with_dollar_sign
  FROM padding_example
  ORDER BY v;

+----------------+---------------------+----------------------+
| V              | PAD_WITH_UNDERSCORE | PAD_WITH_DOLLAR_SIGN |
|----------------+---------------------+----------------------|
| -123.00        | -123.00___          | -123.00$$$           |
| Hi             | Hi________          | Hi$$$$$$$$           |
| Twelve Dollars | Twelve Dol          | Twelve Dol           |
+----------------+---------------------+----------------------+

Este exemplo demonstra o preenchimento à direita dos valores de BINARY usando a função RPAD, com os resultados limitados a 10 bytes:

SELECT b,
       RPAD(b, 10, TO_BINARY(HEX_ENCODE('_'))) AS pad_with_underscore,
       RPAD(b, 10, TO_BINARY(HEX_ENCODE('$'))) AS pad_with_dollar_sign
  FROM padding_example
  ORDER BY b;

+------------------------------+----------------------+----------------------+
| B                            | PAD_WITH_UNDERSCORE  | PAD_WITH_DOLLAR_SIGN |
|------------------------------+----------------------+----------------------|
| 2D3132332E3030               | 2D3132332E30305F5F5F | 2D3132332E3030242424 |
| 4869                         | 48695F5F5F5F5F5F5F5F | 48692424242424242424 |
| 5477656C766520446F6C6C617273 | 5477656C766520446F6C | 5477656C766520446F6C |
+------------------------------+----------------------+----------------------+

Este exemplo mostra o preenchimento à direita quando vários caracteres são usados e quando o preenchimento não é um múltiplo par do comprimento da cadeia de caracteres de vários caracteres usada para preenchimento:

SELECT RPAD('123.50', 19, '*_');

+--------------------------+
| RPAD('123.50', 19, '*_') |
|--------------------------|
| 123.50*_*_*_*_*_*_*      |
+--------------------------+

A saída mostra que 19 caracteres foram retornados e o último caractere * não tem um caractere _ associado.