Verwenden von Schleifen

Snowflake Scripting unterstützt die folgenden Typen von Schleifen:

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

Unter diesem Thema:

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:

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 oder die klassische Weboberfläche verwenden, benutzen Sie stattdessen dieses Beispiel (siehe Verwenden von Snowflake Scripting in SnowSQL und über die klassische Weboberfläche):

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

Die vollständige Syntax und Einzelheiten zu FOR-Anweisungen 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

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

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

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

Hinweis: Wenn Sie SnowSQL oder die klassische Weboberfläche verwenden, benutzen Sie stattdessen dieses Beispiel (siehe Verwenden von Snowflake Scripting in SnowSQL und über die klassische Weboberfläche):

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

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

Die vollständige Syntax und Einzelheiten zu FOR-Anweisungen 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

Hinweis: Wenn Sie SnowSQL oder die klassische Weboberfläche verwenden, benutzen Sie stattdessen dieses Beispiel (siehe Verwenden von Snowflake Scripting in SnowSQL und über die klassische Weboberfläche):

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

Die vollständige Syntax und Einzelheiten zu WHILE-Anweisungen 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

Hinweis: Wenn Sie SnowSQL oder die klassische Weboberfläche verwenden, benutzen Sie stattdessen dieses Beispiel (siehe Verwenden von Snowflake Scripting in SnowSQL und über die klassische Weboberfläche):

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

Die vollständige Syntax und Einzelheiten zu REPEAT-Anweisungen 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

Hinweis: Wenn Sie SnowSQL oder die klassische Weboberfläche verwenden, benutzen Sie stattdessen dieses Beispiel (siehe Verwenden von Snowflake Scripting in SnowSQL und über die klassische Weboberfläche):

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

Die vollständige Syntax und Einzelheiten zu LOOP-Anweisungen 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

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 eines IF (oder CASE).

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

Hinweis: Wenn Sie SnowSQL oder die klassische Weboberfläche verwenden, benutzen Sie stattdessen dieses Beispiel (siehe Verwenden von Snowflake Scripting in SnowSQL und über die klassische Weboberfläche):

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

Weiteres 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             |
| ]               |
+-----------------+
Copy

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 auf 5 erhöht.

  • 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.

Sprache: Deutsch