Verwenden von Schleifen¶

Snowflake Scripting unterstützt die folgenden Typen von Schleifen:

FOR
WHILE
REPEAT
LOOP

Unter diesem Thema wird erläutert, wie die einzelnen Schleifentypen verwendet werden.

FOR-Schleife¶

Eine FOR-Schleife wiederholt eine Sequenz von Schritten mit der angegebenen Häufigkeit oder für jede Zeile eines Resultsets. Snowflake Scripting unterstützt die folgenden Typen von FOR-Schleifen:

Zählerbasierte FOR-Schleifen
Cursorbasierte FOR-Schleifen
RESULTSET-basierte FOR-Schleifen

In den nächsten Abschnitten wird erläutert, wie diese Typen von FOR-Schleifen verwendet werden:

Zählerbasierte FOR-Schleifen¶

Eine zählerbasierte FOR-Schleife wird eine bestimmte Anzahl von Malen ausgeführt.

Die Syntax für eine zählerbasierte FOR-Schleife lautet:

FOR <counter_variable> IN [ REVERSE ] <start> TO <end> { DO | LOOP }
  <statement>;
  [ <statement>; ... ]
END { FOR | LOOP } [ <label> ] ;

Copy

Die folgende FOR-Schleife wird zum Beispiel 5 Mal ausgeführt:

DECLARE
  counter INTEGER DEFAULT 0;
  maximum_count INTEGER default 5;
BEGIN
  FOR i IN 1 TO maximum_count DO
    counter := counter + 1;
  END FOR;
  RETURN counter;
END;

Copy

Hinweis: Wenn Sie SnowSQL, die Classic Console oder die execute_stream- oder execute_string-Methode im Python-Konnektor-Code verwenden, benutzen Sie stattdessen das folgende Beispiel (siehe Verwenden von Snowflake Scripting in SnowSQL, in der Classic Console und im Python-Konnektor):

EXECUTE IMMEDIATE $$
DECLARE
  counter INTEGER DEFAULT 0;
  maximum_count INTEGER default 5;
BEGIN
  FOR i IN 1 TO maximum_count DO
    counter := counter + 1;
  END FOR;
  RETURN counter;
END;
$$
;

Copy

+-----------------+
| anonymous block |
|-----------------|
|               5 |
+-----------------+

Die vollständige Syntax und weitere Einzelheiten zu FOR-Schleifen finden Sie unter FOR (Snowflake Scripting).

Cursorbasierte FOR-Schleifen¶

Eine cursorbasierte FOR-Schleife iteriert über einem Resultset. Die Anzahl der Iterationen wird durch die Anzahl der Zeilen im Cursor bestimmt.

Die Syntax für eine cursorbasierte FOR-Schleife lautet:

FOR <row_variable> IN <cursor_name> DO
  <statement>;
  [ <statement>; ... ]
END FOR [ <label> ] ;

Copy

Für die Beispiele in diesem Abschnitt werden die Daten der folgenden Tabelle invoices verwendet:

CREATE OR REPLACE TABLE invoices (price NUMBER(12, 2));
INSERT INTO invoices (price) VALUES
  (11.11),
  (22.22);

Copy

Das folgende Beispiel verwendet eine FOR-Schleife, die über die Zeilen in einem Cursor der Tabelle invoices iteriert:

DECLARE
  total_price FLOAT;
  c1 CURSOR FOR SELECT price FROM invoices;
BEGIN
  total_price := 0.0;
  FOR record IN c1 DO
    total_price := total_price + record.price;
  END FOR;
  RETURN total_price;
END;

Copy

EXECUTE IMMEDIATE $$
DECLARE
  total_price FLOAT;
  c1 CURSOR FOR SELECT price FROM invoices;
BEGIN
  total_price := 0.0;
  FOR record IN c1 DO
    total_price := total_price + record.price;
  END FOR;
  RETURN total_price;
END;
$$
;

Copy

+-----------------+
| anonymous block |
|-----------------|
|           33.33 |
+-----------------+

Die vollständige Syntax und weitere Einzelheiten zu FOR-Schleifen finden Sie unter FOR (Snowflake Scripting).

RESULTSET-basierte FOR-Schleifen¶

Eine RESULTSET-basierte FOR-Schleife iteriert über einem Resultset. Die Anzahl der Iterationen wird durch die Anzahl der Zeilen bestimmt, die von der RESULTSET-Abfrage zurückgegeben werden.

Die Syntax für eine RESULTSET-basierte FOR-Schleife lautet:

FOR <row_variable> IN <RESULTSET_name> DO
  <statement>;
  [ <statement>; ... ]
END FOR [ <label> ] ;

Copy

Für die Beispiele in diesem Abschnitt werden die Daten der folgenden Tabelle invoices verwendet:

CREATE OR REPLACE TABLE invoices (price NUMBER(12, 2));
INSERT INTO invoices (price) VALUES
  (11.11),
  (22.22);

Copy

Der folgende Block verwendet eine FOR-Schleife, um über die Zeilen in einem RESULTSET für die Tabelle invoices zu iterieren:

DECLARE
  total_price FLOAT;
  rs RESULTSET;
BEGIN
  total_price := 0.0;
  rs := (SELECT price FROM invoices);
  FOR record IN rs DO
    total_price := total_price + record.price;
  END FOR;
  RETURN total_price;
END;

Copy

EXECUTE IMMEDIATE $$
DECLARE
  total_price FLOAT;
  rs RESULTSET;
BEGIN
  total_price := 0.0;
  rs := (SELECT price FROM invoices);
  FOR record IN rs DO
    total_price := total_price + record.price;
  END FOR;
  RETURN total_price;
END;
$$
;

Copy

+-----------------+
| anonymous block |
|-----------------|
|           33.33 |
+-----------------+

Die vollständige Syntax und weitere Einzelheiten zu FOR-Schleifen finden Sie unter FOR (Snowflake Scripting).

WHILE-Schleife¶

Eine WHILE-Schleife wird wiederholt, solange eine Bedingung erfüllt ist. Bei einer WHILE-Schleife wird die Bedingung unmittelbar vor Ausführung des Schleifeninhalts geprüft. Wenn die Bedingung vor der ersten Iteration nicht erfüllt ist, wird der Schleifeninhalt nicht ein einziges Mal ausgeführt.

Die Syntax für eine WHILE-Schleife lautet:

WHILE ( <condition> ) { DO | LOOP }
  <statement>;
  [ <statement>; ... ]
END { WHILE | LOOP } [ <label> ] ;

Copy

Beispiel:

BEGIN
  LET counter := 0;
  WHILE (counter < 5) DO
    counter := counter + 1;
  END WHILE;
  RETURN counter;
END;

Copy

EXECUTE IMMEDIATE $$
BEGIN
  LET counter := 0;
  WHILE (counter < 5) DO
    counter := counter + 1;
  END WHILE;
  RETURN counter;
END;
$$
;

Copy

+-----------------+
| anonymous block |
|-----------------|
|               5 |
+-----------------+

Die vollständige Syntax und weitere Einzelheiten zu WHILE-Schleifen finden Sie unter WHILE (Snowflake Scripting).

REPEAT-Schleife¶

Eine REPEAT-Schleife wird solange wiederholt, bis eine Bedingung erfüllt ist. In einer REPEAT-Schleife wird die Bedingung unmittelbar nach Ausführung des Schleifeninhalts geprüft. Das hat zur Folge, dass der Inhalt der Schleifen immer mindestens einmal ausgeführt wird.

Die Syntax für eine REPEAT-Schleife lautet:

REPEAT
  <statement>;
  [ <statement>; ... ]
UNTIL ( <condition> )
END REPEAT [ <label> ] ;

Copy

Beispiel:

BEGIN
  LET counter := 5;
  LET number_of_iterations := 0;
  REPEAT
    counter := counter - 1;
    number_of_iterations := number_of_iterations + 1;
  UNTIL (counter = 0)
  END REPEAT;
  RETURN number_of_iterations;
END;

Copy

EXECUTE IMMEDIATE $$
BEGIN
  LET counter := 5;
  LET number_of_iterations := 0;
  REPEAT
    counter := counter - 1;
    number_of_iterations := number_of_iterations + 1;
  UNTIL (counter = 0)
  END REPEAT;
  RETURN number_of_iterations;
END;
$$
;

Copy

+-----------------+
| anonymous block |
|-----------------|
|               5 |
+-----------------+

Die vollständige Syntax und weitere Einzelheiten zu REPEAT-Schleifen finden Sie unter REPEAT (Snowflake Scripting).

LOOP-Schleife¶

Eine LOOP-Schleife wird solange ausgeführt, bis ein BREAK-Befehl ausgeführt wird. Ein solcher BREAK-Befehl ist normalerweise in eine Verzweigungslogik eingebettet (z. B. IF-Anweisungen oder CASE-Anweisungen).

Die Syntax für eine LOOP-Anweisung lautet:

LOOP
  <statement>;
  [ <statement>; ... ]
END LOOP [ <label> ] ;

Copy

Beispiel:

BEGIN
  LET counter := 5;
  LOOP
    IF (counter = 0) THEN
      BREAK;
    END IF;
    counter := counter - 1;
  END LOOP;
  RETURN counter;
END;

Copy

EXECUTE IMMEDIATE $$
BEGIN
  LET counter := 5;
  LOOP
    IF (counter = 0) THEN
      BREAK;
    END IF;
    counter := counter - 1;
  END LOOP;
  RETURN counter;
END;
$$
;

Copy

+-----------------+
| anonymous block |
|-----------------|
|               0 |
+-----------------+

Die vollständige Syntax und weitere Einzelheiten zu LOOP-Schleifen finden Sie unter LOOP (Snowflake Scripting).

Beenden einer Schleife oder Iteration¶

In einem Schleifenkonstrukt können Sie angeben, wann die Schleife oder eine Iteration der Schleife vorzeitig abgebrochen werden soll. In den nächsten Abschnitten wird dies näher erläutert:

Beenden einer Schleife
Beenden einer Iteration ohne Beendigung der Schleife
Festlegen, wo die Ausführung nach Schleifenende fortgesetzt wird

Beenden einer Schleife¶

Sie können eine Schleife explizit vorzeitig beenden, indem Sie den Befehl BREAK ausführen. BREAK (und sein Synonym EXIT) hält die aktuelle Iteration sofort an und überspringt alle weiteren Iterationen. Sie können sich BREAK als Sprung zur ersten ausführbaren Anweisung nach dem Ende der Schleife vorstellen.

BREAK ist in LOOP erforderlich, in WHILE, FOR und REPEAT aber nicht. Wenn Sie bestimmte Anweisungen überspringen möchten, können Sie in den meisten Fällen Standardkonstrukte zur Verzweigung (IF-Anweisungen und CASE-Anweisungen) verwenden, um zu steuern, welche Anweisungen innerhalb einer Schleife ausgeführt werden.

Ein BREAK-Befehl selbst befindet sich normalerweise innerhalb einer IF- oder CASE-Anweisung.

Beenden einer Iteration ohne Beendigung der Schleife¶

Sie können mit dem Befehl CONTINUE (oder ITERATE) an das Ende einer Schleifeniteration springen und so die restlichen Anweisungen in der Schleife überspringen. Die Schleife wird mit dem Anfang der nächsten Iteration fortgesetzt.

Solche Sprünge sind selten erforderlich. Wenn Sie bestimmte Anweisungen überspringen möchten, können Sie in den meisten Fällen Standardkonstrukte zur Verzweigung (IF-Anweisungen und CASE-Anweisungen) verwenden, um zu steuern, welche Anweisungen innerhalb einer Schleife ausgeführt werden.

Ein CONTINUE- oder ITERATE-Befehl wird normalerweise innerhalb einer IF- oder CASE-Anweisung verwendet.

Festlegen, wo die Ausführung nach Schleifenende fortgesetzt wird¶

Wenn Sie nach einem BREAK- oder CONTINUE-Befehl die Ausführung an einem bestimmten Punkt im Code fortsetzen müssen (z. B. die äußere Schleife bei einer verschachtelten Schleife), geben Sie im Befehl ein Label an, das den Punkt angibt, an dem die Ausführung fortgesetzt werden soll.

Im folgenden Beispiel wird dies für eine verschachtelte Schleife gezeigt:

BEGIN
  LET inner_counter := 0;
  LET outer_counter := 0;
  LOOP
    LOOP
      IF (inner_counter < 5) THEN
        inner_counter := inner_counter + 1;
        CONTINUE OUTER;
      ELSE
        BREAK OUTER;
      END IF;
    END LOOP INNER;
    outer_counter := outer_counter + 1;
    BREAK;
  END LOOP OUTER;
  RETURN ARRAY_CONSTRUCT(outer_counter, inner_counter);
END;

Copy

EXECUTE IMMEDIATE $$
BEGIN
  LET inner_counter := 0;
  LET outer_counter := 0;
  LOOP
    LOOP
      IF (inner_counter < 5) THEN
        inner_counter := inner_counter + 1;
        CONTINUE OUTER;
      ELSE
        BREAK OUTER;
      END IF;
    END LOOP INNER;
    outer_counter := outer_counter + 1;
    BREAK;
  END LOOP OUTER;
  RETURN ARRAY_CONSTRUCT(outer_counter, inner_counter);
END;
$$;

Copy

In diesem Beispiel:

In diesem Beispiel gibt es eine Schleife mit der Bezeichnung INNER, die in einer Schleife mit der Bezeichnung OUTER verschachtelt ist.
CONTINUE OUTER startet eine weitere Iteration der Schleife mit dem Label OUTER.
BREAK OUTER beendet die innere Schleife und übergibt die Kontrolle an das Ende der äußeren Schleife (gekennzeichnet mit OUTER).

Die Ausgabe dieses Befehls lautet:

+-----------------+
| anonymous block |
|-----------------|
| [               |
|   0,            |
|   5             |
| ]               |
+-----------------+

Die Ausgabe zeigt Folgendes:

inner_counter wird bis 5 inkrementiert. CONTINUE OUTER startet eine neue Iteration der äußeren Schleife, die eine neue Iteration der inneren Schleife startet, die diesen Zähler bis 5 hochzählt. Diese Iterationen werden fortgesetzt, bis der Wert von inner_counter gleich 5 ist und BREAK OUTER die innere Schleife beendet.
outer_counter wird nie inkrementiert. Die Anweisung, die diesen Zähler inkrementiert, wird nie erreicht, da BREAK OUTER die Kontrolle an das Ende der äußeren Schleife übergibt.