Behandeln von Ausnahmen¶

In einem Snowflake Scripting-Block können Sie bei Auftreten eines Fehlers eine Ausnahme auslösen. Sie können auch Ausnahmen behandeln, die in Ihrem Snowflake Scripting-Code auftreten.

Einführung in die Behandlung von Ausnahmen in Snowflake Scripting¶

Snowflake Scripting raises an exception if an error occurs while executing a statement. For example, if a statement attempts to drop a table that doesn’t exist, Snowflake Scripting raises an exception.

In a Snowflake Scripting block, you can write exception handlers that catch specific types of exceptions declared in that block and in blocks nested inside that block. In addition, for errors that can occur in your code, you can define your own exceptions that you can raise when errors occur.

Nachdem die Anweisungen im Handler ausgeführt wurden, können Sie den Block verlassen oder die Anweisungen im Block weiter ausführen. Weitere Informationen dazu finden Sie unter Handling an exception in Snowflake Scripting.

When an exception is raised in a Snowflake Scripting block, either by your code or by a statement that fails to execute, Snowflake Scripting attempts to find a handler for that exception:

Wenn der Block, in dem die Ausnahme aufgetreten ist, einen Handler für diese Ausnahme hat, wird die Ausführung am Anfang dieses Handlers fortgesetzt.
If the block doesn’t have its own exception handler, then the exception can be caught by the enclosing block.

Tritt die Ausnahme mehr als eine Ebene tiefer auf, wird die Ausnahme ebenenweise nach oben gesendet, bis entweder:
- Eine Ebene mit einem geeigneten Ausnahme-Handler die Ausnahme behandelt.
- Die äußerste Ebene erreicht ist, in der ein Fehler auftritt.
Wenn es weder im aktuellen Block noch in den umschließenden Blöcken einen Handler für die Ausnahme gibt, wird die Ausführung des Blocks angehalten und der Client, der den Block zur Ausführung vorlegt (z. B. Snowsight, SnowSQL, usw.), meldet dies als Snowflake-Fehler.

Ein Ausnahme-Handler kann seinen eigenen Ausnahme-Handler enthalten, falls eine Ausnahme während der Behandlung einer anderen Ausnahme auftritt.

Declaring an exception in Snowflake Scripting¶

Sie können Ihre eigene Ausnahme im DECLARE-Abschnitt des Blocks deklarieren. Verwenden Sie die unter Syntax der Ausnahmedeklaration beschriebene Syntax. Beispiel:

DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');

Copy

Raising a declared exception in Snowflake Scripting¶

Um eine Ausnahme auszulösen, führen Sie den Befehl RAISE aus. Beispiel:

DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN counter;
END;

Copy

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

EXECUTE IMMEDIATE $$
DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN counter;
END;
$$
;

Copy

If there is no handler, execution stops at the point when the exception is raised. In the example, counter is never incremented and isn’t returned.

The client that submits this block for execution — for example, Snowsight — reports an error and indicates that the exception was not caught:

-20002 (P0001): Uncaught exception of type 'MY_EXCEPTION' on line 8 at position 4 : Raised MY_EXCEPTION.

Copy

Wenn Sie Code hinzufügen möchten, um von Ihnen ausgelöste Ausnahmen zu behandeln (sowie Ausnahmen, die ausgelöst werden, wenn Anweisungen nicht ausgeführt werden können), können Sie Ausnahme-Handler schreiben. Siehe Handling an exception in Snowflake Scripting.

Bemerkung

Für den Fall, dass Sie in einen Ausnahme-Handler die gleiche Ausnahme erneut auslösen müssen, finden Sie entsprechende Informationen unter Raising the same exception again in an exception handler in Snowflake Scripting.

Handling an exception in Snowflake Scripting¶

Sie können eine Ausnahme explizit behandeln, indem Sie sie mit einer EXCEPTION-Klausel abfangen, oder Sie können zulassen, dass der Block die Ausnahme an den umschließenden Block übergibt.

Verwenden Sie innerhalb der EXCEPTION-Klausel eine WHEN-Klausel, um eine Ausnahme nach Namen zu behandeln. Sie können sowohl von Ihnen deklarierte Ausnahmen als auch integrierte Ausnahmen verarbeiten. Derzeit bietet Snowflake die folgenden integrierten Ausnahmen:

STATEMENT_ERROR: Diese Ausnahme weist auf einen Fehler bei der Ausführung einer Anweisung hin. Wenn Sie zum Beispiel versuchen, eine Tabelle zu löschen, die nicht existiert, wird diese Ausnahme ausgelöst.
EXPRESSION_ERROR: Diese Ausnahme zeigt einen Fehler im Zusammenhang mit einem Ausdruck an. Wenn Sie z. B. einen Ausdruck erstellen, der als VARCHAR ausgewertet wird, und versuchen, den Wert des Ausdrucks einem FLOAT zuzuweisen, wird dieser Fehler ausgelöst.

Jede WHEN-Klausel in einem Ausnahmeblock kann einer der folgenden Typen sein:

EXIT: Der Block führt die Anweisungen im Handler aus und beendet dann den aktuellen Block. Wenn der Block eine Ausnahme dieses Typs ausführt und der Block Anweisungen nach der Anweisung enthält, die den Fehler verursacht hat, werden diese Anweisungen nicht ausgeführt.

Wenn der Block ein innerer Block ist und der Ausnahme-Handler keine RETURN-Anweisung enthält, verlässt die Ausführung den inneren Block und fährt mit dem Code im äußeren Block fort.

EXIT ist der Standard.
CONTINUE: Der Block führt die Anweisungen im Ausnahmeblock aus und fährt mit der Anweisung fort, die unmittelbar auf die Anweisung folgt, die den Fehler verursacht hat.

Ein CONTINUE-Handler kann Ausnahmen abfangen und verarbeiten, ohne den Anweisungsblock zu beenden, der die Ausnahme ausgelöst hat. Mit dem standardmäßigen EXIT-Handler wird bei Auftreten eines Fehlers in einem Block der Ablauf unterbrochen und der Fehler an den Aufrufenden zurückgegeben. Sie können einen CONTINUE-Handler allerdings verwenden, wenn die Fehlerbedingung nicht schwerwiegend genug ist, um eine Unterbrechung des Ablaufs zu rechtfertigen.

Eine EXCEPTION-Klausel kann WHEN-Klauseln beider Typen enthalten, EXIT und CONTINUE.

Wenn eine Ausnahme auftritt, können Sie Informationen über die Ausnahme erhalten, indem Sie die folgenden drei integrierten Variablen auslesen:

SQLCODE: Dies ist eine 5-stellige, vorzeichenbehaftete Ganzzahl. Bei benutzerdefinierten Ausnahmen ist dies die exception_number (Ausnahmenummer), die in der Syntax zum Deklarieren von Ausnahmen angegeben ist.
SQLERRM: Dies ist eine Fehlermeldung. Bei benutzerdefinierten Ausnahmen ist dies die exception_message (Ausnahmenummer), die in der Syntax zum Deklarieren von Ausnahmen angegeben ist.
SQLSTATE: Dies ist ein 5-Zeichen-Code, der auf dem ANSI-SQL-Standard SQLSTATE basiert. Snowflake verwendet zusätzliche Werte, die über die Werte des ANSI-SQL-Standards hinausgehen.

Wenn Sie eine WHEN-Klausel des Typs CONTINUE verwenden, spiegeln diese integrierten Variablen den Fehler wider, der die Ausnahme in der WHEN-Klausel verursacht hat. Nachdem die Anweisungen in der WHEN-Klausel abgeschlossen wurden und die Ausführung der Anweisung im Block fortgesetzt wird, geben die Werte dieser Variablen die Werte zurück, die sie vor dem Auslösen der Ausnahme hatten.

To handle all other exceptions that aren’t built-in or declared, use a WHEN OTHER THEN clause. The WHEN OTHER THEN clause can be of type EXIT or CONTINUE.

Nehmen Sie zum Beispiel an, dass Sie die folgende Fehlerprotokolltabelle haben, um Ihre Ausnahmen zu verfolgen:

CREATE OR REPLACE TABLE test_error_log(
  error_type VARCHAR,
  error_code VARCHAR,
  error_message VARCHAR,
  error_state VARCHAR,
  error_timestamp TIMESTAMP);

Copy

Der folgende anonyme Block fügt Informationen über die Ausnahmen in die Tabelle ein und gibt dem Benutzer Informationen über sie zurück:

Tipp

Das Beispiel definiert eine Ausnahme im Abschnitt DECLARE und behandelt dann diese Ausnahme. Für ein Beispiel, das eine STATEMENT_ERROR-Ausnahme behandelt, entfernen Sie die Kommentare (--) aus dieser Zeile:

-- SELECT 1/0;

Copy

Für ein Beispiel, das andere Fehler behandelt, entfernen Sie die Kommentare aus dieser Zeile:

-- LET var := 1/0;

Copy

DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  -- SELECT 1/0;
  -- LET var := 1/0;
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN 'My counter value: ' || counter;
EXCEPTION
  WHEN STATEMENT_ERROR THEN
    INSERT INTO test_error_log VALUES(
      'STATEMENT_ERROR', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'STATEMENT_ERROR',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
  WHEN my_exception THEN
    INSERT INTO test_error_log VALUES(
      'MY_EXCEPTION', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'MY_EXCEPTION',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
  WHEN OTHER THEN
    INSERT INTO test_error_log VALUES(
      'OTHER', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'Other error',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
END;

Copy

EXECUTE IMMEDIATE $$
DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  -- SELECT 1/0;
  -- LET var := 1/0;
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN 'My counter value: ' || counter;
EXCEPTION
  WHEN STATEMENT_ERROR THEN
    INSERT INTO test_error_log VALUES(
      'STATEMENT_ERROR', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'STATEMENT_ERROR',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
  WHEN my_exception THEN
    INSERT INTO test_error_log VALUES(
      'MY_EXCEPTION', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'MY_EXCEPTION',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
  WHEN OTHER THEN
    INSERT INTO test_error_log VALUES(
      'OTHER', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'Other error',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
END;
$$
;

Copy

Für den zurückgegebenen Wert behandelt dieses Beispiel jede Art von Ausnahme, indem es OBJECT_CONSTRUCT aufruft, um ein Objekt zu erstellen und zurückzugeben, das die Details über die Ausnahme enthält. Das Beispiel ergibt die folgende Ausgabe:

+--------------------------------------+
| anonymous block                      |
|--------------------------------------|
| {                                    |
|   "Error type": "MY_EXCEPTION",      |
|   "SQLCODE": -20002,                 |
|   "SQLERRM": "Raised MY_EXCEPTION.", |
|   "SQLSTATE": "P0001"                |
| }                                    |
+--------------------------------------+

Sie können die test_error_log-Tabelle abfragen, um zu bestätigen, dass der Fehler protokolliert wurde:

SELECT * FROM test_error_log;

Copy

+--------------+------------+----------------------+-------------+-------------------------+
| ERROR_TYPE   | ERROR_CODE | ERROR_MESSAGE        | ERROR_STATE | ERROR_TIMESTAMP         |
|--------------+------------+----------------------+-------------+-------------------------|
| MY_EXCEPTION | -20002     | Raised MY_EXCEPTION. | P0001       | 2025-09-05 12:15:00.068 |
+--------------+------------+----------------------+-------------+-------------------------+

Im vorherigen Beispiel wurden WHEN-Klauseln des Standardtyps (EXIT) verwendet. Wenn einer der WHEN-Klauseln eine Ausnahme abfängt, führt sie die Anweisungen in der WHEN-Klausel aus und wird dann beendet. Daher wird der folgende Code nicht ausgeführt:

counter := counter + 1;
RETURN 'My counter value: ' || counter;

Copy

Wenn Sie eine Ausnahme behandeln und dann den Code im Block weiter ausführen möchten, geben Sie WHEN-Klauseln von CONTINUE-Typ an. Das folgende Beispiel ist dasselbe wie das vorherige, aber es gibt WHEN-Klauseln des Typs CONTINUE an und entfernt die RETURN-Anweisung von jeder WHEN-Klausel:

DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  -- SELECT 1/0;
  -- LET var := 1/0;
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN 'My counter value: ' || counter;
EXCEPTION
  WHEN STATEMENT_ERROR CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'STATEMENT_ERROR', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
  WHEN my_exception CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'MY_EXCEPTION', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
  WHEN OTHER CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'OTHER', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
END;

Copy

EXECUTE IMMEDIATE $$
DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  -- SELECT 1/0;
  -- LET var := 1/0;
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN 'My counter value: ' || counter;
EXCEPTION
  WHEN STATEMENT_ERROR CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'STATEMENT_ERROR', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
  WHEN my_exception CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'MY_EXCEPTION', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
  WHEN OTHER CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'OTHER', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
END;
$$
;

Copy

+---------------------+
| anonymous block     |
|---------------------|
| My counter value: 1 |
+---------------------+

Die Ausgabe zeigt, dass das Beispiel den folgenden Code weiter ausgeführt hat, nachdem die Ausnahme ausgelöst wurde:

counter := counter + 1;
RETURN counter;

Copy

For more information about CONTINUE handlers, see EXCEPTION (Snowflake Scripting).

In rare cases, you might want to explicitly handle an exception by doing nothing. This enables you to continue, rather than terminate, when the exception occurs. For more information, see the NULL command.

Bemerkung

Für den Fall, dass Sie denselben Ausnahme-Handler noch einmal auslösen müssen, finden Sie entsprechende Informationen unter Raising the same exception again in an exception handler in Snowflake Scripting.

If you don’t set up a handler for an exception, the client that submits the block for execution; for example, Snowsight reports an error as explained in Raising a declared exception in Snowflake Scripting.

-20002 (P0001): Uncaught exception of type 'MY_EXCEPTION' on line 8 at position 4 : Raised MY_EXCEPTION.

Copy

Raising the same exception again in an exception handler in Snowflake Scripting¶

In manchen Fällen müssen Sie die gleiche Ausnahme auslösen, die Sie in Ihrem Ausnahme-Handler abgefangen haben. In diesen Fällen führen Sie den Befehl RAISE ohne Angabe von Argumenten aus.

Angenommen, dass Sie während der Ausnahmebehandlung einige Details über die Ausnahme erfassen müssen, bevor Sie die gleiche Ausnahme erneut auslösen. Nach der Erfassung der Details führen Sie den Befehl RAISE aus:

BEGIN
  SELECT * FROM non_existent_table;
EXCEPTION
  WHEN OTHER THEN
    LET LINE := SQLCODE || ': ' || SQLERRM;
    INSERT INTO myexceptions VALUES (:line);
    RAISE; -- Raise the same exception that you are handling.
END;

Copy

EXECUTE IMMEDIATE $$
BEGIN
  SELECT * FROM non_existent_table;
EXCEPTION
  WHEN OTHER THEN
    LET LINE := SQLCODE || ': ' || SQLERRM;
    INSERT INTO myexceptions VALUES (:line);
    RAISE; -- Raise the same exception that you are handling.
END;
$$;

Copy

Passing variables to an exception handler in Snowflake Scripting¶

Sie können Variablen an einen Ausnahme-Handler übergeben. Der Ausnahme-Handle kann Code auf der Grundlage des Wertes der Variable ausführen, und der Wert der Variable kann in Fehlermeldungen zurückgegeben werden.

Damit eine Variable an einen Handler im EXCEPTION-Abschnitt übergeben werden kann, muss die Variable im DECLARE-Abschnitt deklariert werden. Wenn eine Variable im BEGIN … END-Abschnitt des Blocks deklariert wird, kann im EXCEPTION-Abschnitt nicht auf sie zugegriffen werden.

Wenn Sie eine Snowflake Scripting gespeicherte Prozedur schreiben, die Argumente akzeptiert, können Sie diese Argumente auch in einem Ausnahme-Handler verwenden.

Der folgende anonyme Block übergibt zum Beispiel den Wert der counter_val-Variable an den Handler der Ausnahme:

DECLARE
  counter_val INTEGER DEFAULT 0;
  my_exception EXCEPTION (-20002, 'My exception text');
BEGIN
  WHILE (counter_val < 12) DO
    counter_val := counter_val + 1;
    IF (counter_val > 10) THEN
      RAISE my_exception;
    END IF;
  END WHILE;
  RETURN counter_val;
EXCEPTION
  WHEN my_exception THEN
    RETURN 'Error ' || sqlcode || ': Counter value ' || counter_val || ' exceeds the limit of 10.';
END;

Copy

EXECUTE IMMEDIATE $$
DECLARE
  counter_val INTEGER DEFAULT 0;
  my_exception EXCEPTION (-20002, 'My exception text');
BEGIN
  WHILE (counter_val < 12) DO
    counter_val := counter_val + 1;
    IF (counter_val > 10) THEN
      RAISE my_exception;
    END IF;
  END WHILE;
  RETURN counter_val;
EXCEPTION
  WHEN my_exception THEN
    RETURN 'Error ' || sqlcode || ': Counter value ' || counter_val || ' exceeds the limit of 10.';
END;
$$
;

Copy

Der Block gibt die folgende Fehlermeldung zurück:

+---------------------------------------------------------+
| anonymous block                                         |
|---------------------------------------------------------|
| Error -20002: Counter value 11 exceeds the limit of 10. |
+---------------------------------------------------------+

Im Folgenden finden Sie ein Beispiel für eine Snowflake Scripting gespeicherte Prozedur, die ein Argument übergibt. Das Beispiel zeigt, wie Sie das Argument in einem Ausnahme-Handler verwenden können:

CREATE OR REPLACE PROCEDURE exception_test_vars(amount INT)
  RETURNS TEXT
  LANGUAGE SQL
AS
DECLARE
  my_exception_1 EXCEPTION (-20002, 'Value too low');
  my_exception_2 EXCEPTION (-20003, 'Value too high');
BEGIN
  CREATE OR REPLACE TABLE test_order_insert(units INT);
  IF (amount < 1) THEN
    RAISE my_exception_1;
  ELSEIF (amount > 10) THEN
    RAISE my_exception_2;
  ELSE
    INSERT INTO test_order_insert VALUES (:amount);
  END IF;
  RETURN 'Order inserted successfully.';
EXCEPTION
  WHEN my_exception_1 THEN
    RETURN 'Error ' || sqlcode || ': Submitted amount ' || amount || ' is too low (1 or greater required).';
  WHEN my_exception_2 THEN
    RETURN 'Error ' || sqlcode || ': Submitted amount ' || amount || ' is too high (exceeds limit of 10).';
END;

Copy

CREATE OR REPLACE PROCEDURE exception_test_vars(amount INT)
  RETURNS TEXT
  LANGUAGE SQL
AS
$$
DECLARE
  my_exception_1 EXCEPTION (-20002, 'Value too low');
  my_exception_2 EXCEPTION (-20003, 'Value too high');
BEGIN
  CREATE OR REPLACE TABLE test_order_insert(units INT);
  IF (amount < 1) THEN
    RAISE my_exception_1;
  ELSEIF (amount > 10) THEN
    RAISE my_exception_2;
  ELSE
    INSERT INTO test_order_insert VALUES (:amount);
  END IF;
  RETURN 'Order inserted successfully.';
EXCEPTION
  WHEN my_exception_1 THEN
    RETURN 'Error ' || sqlcode || ': Submitted amount ' || amount || ' is too low (1 or greater required).';
  WHEN my_exception_2 THEN
    RETURN 'Error ' || sqlcode || ': Submitted amount ' || amount || ' is too high (exceeds limit of 10).';
END;
$$
;

Copy

Die folgenden Aufrufe der gespeicherten Prozedur zeigen die erwartete Ausgabe:

CALL exception_test_vars(7);

Copy

+------------------------------+
| EXCEPTION_TEST_VARS          |
|------------------------------|
| Order inserted successfully. |
+------------------------------+

CALL exception_test_vars(-3);

Copy

+-----------------------------------------------------------------------+
| EXCEPTION_TEST_VARS                                                   |
|-----------------------------------------------------------------------|
| Error -20002: Submitted amount -3 is too low (1 or greater required). |
+-----------------------------------------------------------------------+

CALL exception_test_vars(20);

Copy

+----------------------------------------------------------------------+
| EXCEPTION_TEST_VARS                                                  |
|----------------------------------------------------------------------|
| Error -20003: Submitted amount 20 is too high (exceeds limit of 10). |
+----------------------------------------------------------------------+