LPAD¶

Sintaxe¶

LPAD( <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¶

A função LPAD pode preencher uma cadeia de caracteres com caracteres à esquerda para que os valores estejam em conformidade com um formato específico. O exemplo a seguir pressupõe que os valores de id em uma coluna devem ter oito caracteres e ser preenchidos com zeros à esquerda para atender a esse padrão.

Crie uma tabela com uma coluna id e insira valores:

CREATE OR REPLACE TABLE demo_lpad_ids (id VARCHAR);

INSERT INTO demo_lpad_ids VALUES
  ('5'),
  ('50'),
  ('500');

Execute uma consulta usando a função LPAD para que os valores na saída atendam ao padrão:

SELECT id, LPAD(id, 8, '0') AS padded_ids
  FROM demo_lpad_ids;

+-----+------------+
| ID  | PADDED_IDS |
|-----+------------|
| 5   | 00000005   |
| 50  | 00000050   |
| 500 | 00000500   |
+-----+------------+

Os exemplos adicionais a seguir usam a função LPAD para preencher os dados de VARCHAR e BINARY à esquerda.

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 à esquerda dos valores de VARCHAR usando a função LPAD, com os resultados limitados a 10 caracteres:

SELECT v,
       LPAD(v, 10, ' ') AS pad_with_blank,
       LPAD(v, 10, '$') AS pad_with_dollar_sign
  FROM padding_example
  ORDER BY v;

+----------------+----------------+----------------------+
| V              | PAD_WITH_BLANK | PAD_WITH_DOLLAR_SIGN |
|----------------+----------------+----------------------|
| -123.00        |    -123.00     | $$$-123.00           |
| Hi             |         Hi     | $$$$$$$$Hi           |
| Twelve Dollars | Twelve Dol     | Twelve Dol           |
+----------------+----------------+----------------------+

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

SELECT b,
       LPAD(b, 10, TO_BINARY(HEX_ENCODE(' '))) AS pad_with_blank,
       LPAD(b, 10, TO_BINARY(HEX_ENCODE('$'))) AS pad_with_dollar_sign
  FROM padding_example
  ORDER BY b;

+------------------------------+----------------------+----------------------+
| B                            | PAD_WITH_BLANK       | PAD_WITH_DOLLAR_SIGN |
|------------------------------+----------------------+----------------------|
| 2D3132332E3030               | 2020202D3132332E3030 | 2424242D3132332E3030 |
| 4869                         | 20202020202020204869 | 24242424242424244869 |
| 5477656C766520446F6C6C617273 | 5477656C766520446F6C | 5477656C766520446F6C |
+------------------------------+----------------------+----------------------+

Este exemplo mostra o preenchimento à esquerda 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 LPAD('123.50', 19, '*_');

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

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