Kategorien:

Zeichenfolgen- und Binärfunktionen (Allgemein)

RPAD

Füllt eine Zeichenfolge rechts mit Zeichen aus einer anderen Zeichenfolge auf oder füllt einen Binärwert rechts mit Bytes aus einem anderen Binärwert auf.

Das Argument (base) wird mit Zeichen/Bytes aus dem Argument length_expr auf die Länge pad aufgefüllt.

Siehe auch:

LPAD

Syntax

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

Argumente

base

Ein VARCHAR- oder BINARY-Wert.

length_expr

Ein Ausdruck, der zu einer Ganzzahl ausgewertet wird. Er legt Folgende fest:

  • Die Anzahl der zurückzugebenden UTF-8 Zeichen, wenn die Eingabe VARCHAR lautet.

  • Die Anzahl der zurückzugebenden Bytes, wenn die Eingabe BINARY ist.

pad

Ein VARCHAR- oder BINARY-Wert. Der Typ muss mit dem Datentyp des base-Arguments übereinstimmen. Die Zeichen (oder Bytes) aus diesem Argument werden zum Auffüllen der base verwendet.

Rückgabewerte

Der Datentyp des zurückgegebenen Wertes entspricht dem Datentyp des base Eingabewerts (VARCHAR oder BINARY).

Nutzungshinweise

  • Wenn das base-Argument länger als length_expr ist, wird es auf die Länge length_expr gekürzt.

  • Das Argument pad kann mehrere Zeichen/Bytes lang sein. Das pad-Argument wird im Ergebnis wiederholt, bis die gewünschte Länge (length_expr) erreicht ist. Alle überflüssigen Zeichen/Bytes im pad-Argument werden abgeschnitten. Wenn das pad-Argument leer ist, werden keine Zeichen zum Auffüllen eingefügt. Das Ergebnis wird jedoch trotzdem auf die Länge length_expr gekürzt.

  • Wenn base eine Zeichenfolge ist, lautet die Standardzeichenfolge pad ' ' (ein einzelnes Leerzeichen). Wenn base ein Binärwert ist, muss das pad-Argument explizit angegeben werden.

Sortierungsdetails

  • Sortierung gilt für VARCHAR-Eingaben. Sortierung wird nicht angewendet, wenn der Eingabedatentyp des ersten Arguments BINARY ist.

  • No impact. Obwohl Sortierungen syntaktisch akzeptiert werden, haben sie keine Auswirkungen auf die Verarbeitung. Beispielsweise zählen Sprachen mit zwei- und dreistelligen Buchstaben (z. B. „dzs“ im Ungarischen, „ch“ im Tschechischen) weiterhin zwei oder drei Zeichen (nicht ein Zeichen) für das Längenargument.

  • The collation of the result is the same as the collation of the input. Dies kann nützlich sein, wenn der zurückgegebene Wert als Teil verschachtelter Funktionsaufrufe an eine andere Funktion übergeben wird.

  • Derzeit können die base- und pad-Argumente in Snowflake unterschiedliche Sortierungsspezifizierer haben. Die einzelnen Sortierkriterien können jedoch nicht beide beibehalten werden, da der zurückgegebene Wert nur ein Sortierkriterium enthält. Snowflake empfiehlt, dass Sie keine pad Zeichenfolgen verwenden, die eine andere Sortierung als die base-Zeichenfolge haben.

Beispiele

Diese Beispiele verwenden die RPAD-Funktion, um von VARCHAR- und BINARY-Daten auf der rechten Seite aufzufüllen.

Erstellen Sie eine Tabelle, und füllen Sie diese:

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');
Copy

Fragen Sie die Tabelle ab, um die Daten anzuzeigen:

SELECT * FROM padding_example;
Copy
+----------------+------------------------------+
| V              | B                            |
|----------------+------------------------------|
| Hi             | 4869                         |
| -123.00        | 2D3132332E3030               |
| Twelve Dollars | 5477656C766520446F6C6C617273 |
+----------------+------------------------------+

Dieses Beispiel zeigt, wie Sie mit der Funktion RPAD VARCHAR-Werte nach rechts einfügen, wobei die Ergebnisse auf 10 Zeichen begrenzt sind:

SELECT v,
       RPAD(v, 10, '_') AS pad_with_underscore,
       RPAD(v, 10, '$') AS pad_with_dollar_sign
  FROM padding_example
  ORDER BY v;
Copy
+----------------+---------------------+----------------------+
| V              | PAD_WITH_UNDERSCORE | PAD_WITH_DOLLAR_SIGN |
|----------------+---------------------+----------------------|
| -123.00        | -123.00___          | -123.00$$$           |
| Hi             | Hi________          | Hi$$$$$$$$           |
| Twelve Dollars | Twelve Dol          | Twelve Dol           |
+----------------+---------------------+----------------------+

Dieses Beispiel zeigt, wie Sie mit der Funktion RPAD BINARY-Werte nach rechts einfügen, wobei die Ergebnisse auf 10 Bytes begrenzt sind:

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;
Copy
+------------------------------+----------------------+----------------------+
| B                            | PAD_WITH_UNDERSCORE  | PAD_WITH_DOLLAR_SIGN |
|------------------------------+----------------------+----------------------|
| 2D3132332E3030               | 2D3132332E30305F5F5F | 2D3132332E3030242424 |
| 4869                         | 48695F5F5F5F5F5F5F5F | 48692424242424242424 |
| 5477656C766520446F6C6C617273 | 5477656C766520446F6C | 5477656C766520446F6C |
+------------------------------+----------------------+----------------------+

Dieses Beispiel zeigt das rechte Auffüllen, wenn mehrere Zeichen verwendet werden und das Auffüllen kein gerades Vielfaches der Länge der aus mehreren Zeichen bestehenden Auffüllzeichenfolge ist:

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

Die Ausgabe zeigt, dass 19 Zeichen zurückgegeben wurden und das letzte *-Zeichen kein begleitendes _-Zeichen hat.

Sprache: Deutsch