Verwenden von SnowSQL

Unter diesem Thema wird die Verwendung von SnowSQL beschrieben, einschließlich Starten/Stoppen des Clients, Verwenden von Befehlen und Variablen innerhalb des Clients und weiteren allgemeinen Nutzungsinformationen.

Unter diesem Thema:

Ausführen von Befehlen

In einer Snowflake-Sitzung können Sie Befehle starten, um bestimmte Aktionen auszuführen. Alle Befehle in SnowSQL beginnen mit einem Ausrufezeichen (!), gefolgt von dem Befehlsnamen.

Beispiel:

user#> !help

+------------+-------------------------------------------+-------------+--------------------------------------------------------------------------------------------+
| Command    | Use                                       | Aliases     | Description                                                                                |
|------------+-------------------------------------------+-------------+--------------------------------------------------------------------------------------------|
| !abort     | !abort <query id>                         |             | Abort a query                                                                              |
| !connect   | !connect <connection_name>                |             | Create a new connection                                                                    |
| !define    | !define <variable>=<value>                |             | Define a variable as the given value                                                       |
| !edit      | !edit <query>                             |             | Opens up a text editor. Useful for writing longer queries. Defaults to last query          |
| !exit      | !exit                                     | !disconnect | Drop the current connection                                                                |
| !help      | !help                                     | !helps, !h  | Show the client help.                                                                      |
| !options   | !options                                  | !opts       | Show all options and their values                                                          |
| !pause     | !pause                                    |             | Pauses running queries.                                                                    |
| !print     | !print <message>                          |             | Print given text                                                                           |
| !queries   | !queries help, <filter>=<value>, <filter> |             | Lists queries matching the specified filters. Write <!queries> help for a list of filters. |
| !quit      | !quit                                     | !q          | Drop all connections and quit SnowSQL                                                      |
| !rehash    | !rehash                                   |             | Refresh autocompletion                                                                     |
| !result    | !result <query id>                        |             | See the result of a query                                                                  |
| !set       | !set <option>=<value>                     |             | Set an option to the given value                                                           |
| !source    | !source <filename>, <url>                 | !load       | Execute given sql file                                                                     |
| !spool     | !spool <filename>, off                    |             | Turn on or off writing results to file                                                     |
| !system    | !system <system command>                  |             | Run a system command in the shell                                                          |
| !variables | !variables                                | !vars       | Show all variables and their values                                                        |
+------------+-------------------------------------------+-------------+--------------------------------------------------------------------------------------------+
Copy

Eine detaillierte Beschreibung der einzelnen Befehle finden Sie unter Befehlsreferenz (unter diesem Thema).

Verwenden von Variablen

Sie können Variablen verwenden, um Werte in einer Snowflake-Sitzung zu speichern und wiederzuverwenden. Mithilfe von Variablen können Sie benutzerdefinierte und Datenbankwerte in Abfragen verwenden.

In den nächsten Abschnitten wird erklärt, wie Sie Variablen definieren und verwenden:

Definieren von Variablen

Sie können Variablen für SnowSQL auf verschiedene Weise definieren:

Definieren von Variablen vor dem Verbinden (Konfigurationsdatei)

Um Variablen vor dem Verbinden mit Snowflake zu definieren, fügen Sie die Variablen der Konfigurationsdatei config hinzu:

  1. Öffnen Sie die SnowSQL-Konfigurationsdatei (mit dem Namen config) in einem Texteditor. Der Standardspeicherort der Datei ist:

    Linux/macOS:

    ~/.snowsql/

    Windows:

    %USERPROFILE%\.snowsql\

    Bemerkung

    Sie können den Standardspeicherort ändern, indem Sie beim Start von SnowSQL das Befehlszeilenflag --config path angeben.

  1. Definieren Sie im Abschnitt [variables] alle Variablen, die Sie verwenden möchten:

    [variables]
    <variable_name>=<variable_value>
    
    Copy

    Wobei:

    • variable_name ist eine Zeichenfolge aus alphanumerischen Zeichen (Groß-/Kleinschreibung ist nicht relevant), die den Namen der Variablen darstellt.

    • variable_value ist eine Zeichenfolge, die den Wert für die Variable darstellt. Bei Bedarf kann die Zeichenfolge in einfache oder doppelte Anführungszeichen eingeschlossen werden.

    Beispiel:

    [variables]
    tablename=CENUSTRACKONE
    
    Copy

Definieren von Variablen beim Verbinden (Befehlszeilenflag -D oder --variable)

Um Variablen während der Verbindung mit Snowflake zu definieren, geben Sie in der Terminalbefehlszeile das Befehlszeilenflag -D oder --variable an. Als Argument für dieses Flag geben Sie den Variablennamen und -wert in der Form variable_name=variable_value an.

Beispiel:

Linux/macOS:
$ snowsql ... -D tablename=CENUSTRACKONE --variable db_key=$DB_KEY
Copy
Windows:
$ snowsql ... -D tablename=CENUSTRACKONE --variable db_key=%DB_KEY%
Copy

Im obigen Beispiel bedeutet:

  • -D setzt eine Variable mit dem Namen tablename auf CENUSTRACKONE.

  • --variable weist der Umgebungsvariablen DB_KEY eine Snowflake-Variable namens db_key zu.

Definieren von Variablen innerhalb einer Sitzung (Befehl !define)

Um eine Variable nach dem Verbinden mit Snowflake zu definieren, führen Sie den Befehl !define in der Sitzung aus.

Beispiel:

user#> !define tablename=CENUSTRACKONE
Copy

Aktivieren der Variablensubstitution

Damit SnowSQL-Werte für die Variablen ersetzen kann, müssen Sie die Konfigurationsoption variable_substitution auf eine der folgenden Arten auf true setzen:

  • Um diese Option vor dem Start von SnowSQL einzustellen, öffnen Sie die SnowSQL-Konfigurationsdatei in einem Texteditor und stellen diese Option im Abschnitt [options] ein:

    [options]
    variable_substitution = True
    
    Copy
  • Um diese Option beim Start von SnowSQL festzulegen, geben Sie das Befehlszeilenflag -o an:

    $ snowsql ... -o variable_substitution=true
    
    Copy
  • Um diese Option in einer SnowSQL-Sitzung zu aktivieren, führen Sie den Befehl !set in der Sitzung aus:

    user#> !set variable_substitution=true
    
    Copy

    Bemerkung

    Es gibt derzeit keine Option wie unset, mit der ein Optionswert wie variable_substitution rückgängig gemacht werden kann. Wenn Sie die Variablensubstitution deaktivieren müssen, führen Sie den Befehl !set variable_substitution=false aus.

Ersetzen von Variablen in einer Sitzung

Nachdem Sie die Variablensubstitution aktiviert haben, können Sie Variablen in SQL-Anweisungen verwenden.

Um eine Variable in einer Anweisung zu verwenden, verwenden Sie die Syntax &variable_name. Beachten Sie, dass bei Variablennamen die Groß- und Kleinschreibung nicht beachtet wird. Beispiel:

user#> !define snowshell=bash

user#> !set variable_substitution=true

user#> select '&snowshell';

+--------+
| 'BASH' |
|--------|
| bash   |
+--------+
Copy

Wenn die Option variable_substitution nicht aktiviert ist, erfolgt keine Variablenersetzung. Beispiel:

user#> !define snowshell=bash

user#> !set variable_substitution=false

user#> select '&snowshell';

+--------------+
| '&SNOWSHELL' |
|--------------|
| &snowshell   |
+--------------+
Copy

Wenn Sie auf eine Variable verweisen, die nicht definiert wurde, zeigt SnowSQL einen Fehler an. Beispiel:

select '&z';

Variable z is not defined
Copy

Um eine Variable mit Text zu kombinieren, schließen Sie die Variablenreferenz in geschweifte Klammern ein. Beispiel:

user#> !define snowshell=bash

user#> !set variable_substitution=true

select '&{snowshell}_shell';

+--------------+
| 'BASH_SHELL' |
|--------------|
| bash_shell   |
+--------------+
Copy

Um ein kaufmännisches Und-Zeichen ohne Ersetzung zu verwenden, schließen Sie das kaufmännische Und-Zeichen mit einem zweiten kaufmännischen Und-Zeichen als Escapezeichen ein:

&&variable

Beispiel:

user#> !set variable_substitution=true

user#> select '&notsubstitution';

Variable notsubstitution is not defined

user#> select '&&notsubstitution';

+--------------------+
| '&NOTSUBSTITUTION' |
|--------------------|
| &notsubstitution   |
+--------------------+
Copy

Auflisten von Variablen

Um Variablen aufzulisten, führen Sie den Befehl !variables oder !vars in der Sitzung aus:

user#> !variables

+-----------+-------+
| Name      | Value |
|-----------+-------|
| snowshell | bash  |
+-----------+-------+
Copy

Verwenden von integrierten Variablen

SnowSQL enthält einen Satz integrierter Variablen, die Metadaten über Anweisungen zurückgeben, die in der aktuellen Benutzersitzung ausgeführt wurden.

Jeder dieser Variablennamen beginnt mit zwei Unterstrichzeichen („__“).

__rowcount

Gibt die Anzahl der Zeilen zurück, die von der zuletzt vom Benutzer ausgeführten DML-Anweisung betroffen sind.

user#> insert into a values(1),(2),(3);

+-------------------------+
| number of rows inserted |
|-------------------------|
|                       3 |
+-------------------------+
3 Row(s) produced. Time Elapsed: 0.950s

user#> !set variable_substitution=true

user#> select &__rowcount;

+---+
| 3 |
|---|
| 3 |
+---+
Copy
__sfqid

Gibt die Abfrage-ID für die zuletzt vom Benutzer ausgeführte Abfrage zurück.

user#> !set variable_substitution=true

user#> select * from a;

user#> select '&__sfqid';

+----------------------------------------+
| 'A5F35B56-49A2-4437-BA0E-998496CE793E' |
|----------------------------------------|
| a5f35b56-49a2-4437-ba0e-998496ce793e   |
+----------------------------------------+
Copy

Verwenden der automatischen Vervollständigung

Verschiedene SQL-Funktionen, Tabellennamen und Variablen werden in SnowSQL gespeichert und im interaktiven Modus automatisch ergänzt. Um einen Vorschlag zur automatischen Vervollständigung auszuwählen, drücken Sie die Taste Tab. Um einen anderen Vorschlag auszuwählen, verwenden Sie die Tasten und zum Markieren der gewünschten Option, und drücken Sie dann die Taste Tab.

Um die automatische Vervollständigung interaktiv zu deaktivieren, setzen Sie die Konfigurationsoption auto_completion in der Konfigurationsdatei auf False.

Anzeigen des Befehlszeilenverlaufs

Ihr aktueller Befehlszeilenverlauf kann mit der Taste abgerufen werden. Drücken Sie die Taste wiederholt, um durch den Puffer zu blättern.

Verlaufsdatei

Die interaktive Befehlszeilenprotokolldatei hat den Namen history und befindet sich in ~/.snowsql/history.

Ausführen von Batchskripten

Sie können Batchskripte auf zwei Arten ausführen:

  • Verwendung von Verbindungsparametern (beim Verbinden mit Snowflake)

  • Ausführen von Befehlen (in der Befehlszeile aus einer Snowflake-Sitzung heraus)

Ausführen beim Verbinden (Verbindungsparameter -f)

Um ein SQL-Skript während des Verbindens mit Snowflake auszuführen, verwenden Sie den Verbindungsparameter -f <Eingabedateiname>.

Eine Ausgabedatei für das Skript kann mit -o output_file=<Ausgabedateiname> angegeben werden. Darüber hinaus können Sie mit -o quiet=true die Standardausgabe und mit -o friendly=false die Start- und Endemeldungen deaktivieren.

Beispiel:

snowsql -a myorganization-myaccount -u jsmith -f /tmp/input_script.sql -o output_file=/tmp/output.csv -o quiet=true -o friendly=false -o header=false -o output_format=csv
Copy

Weitere Informationen zu allen Verbindungsparametern finden Sie unter Übersicht der Verbindungsparameter.

Ausführen in einer Sitzung (Befehl !source oder !load)

Um ein SQL-Skript nach dem Verbinden mit Snowflake auszuführen, führen Sie den Befehl !source (oder !load) in der Sitzung aus.

Beispiel:

user#> !source example.sql
Copy

Exportieren von Daten

So erfolgt die Ausgabe der Abfrageergebnisse in eine Datei in einem definierten Format unter Verwendung der folgenden Konfigurationsoptionen:

  • output_format=output_format

  • output_file=output_filename

Um den Begrüßungstext, den Kopftext, die Zeitangaben und die Abschiedsmeldung aus der Ausgabe zu entfernen, setzen Sie zudem die folgenden Optionen:

  • friendly=false

  • header=false

  • timing=false

Wie bei allen Konfigurationsoptionen können Sie diese mit einer der folgenden Methoden einstellen:

  • In der Konfigurationsdatei (vor dem Verbinden mit Snowflake)

  • Verwenden des Verbindungsparameters -o oder --options (beim Verbinden mit Snowflake)

  • Ausführen des Befehls !set (in der Befehlszeile aus eine Snowflake-Sitzung heraus)

Beachten Sie, dass aufeinanderfolgende Abfragen an die Ausgabedatei angehängt werden. Um die Abfrageausgabe in eine Datei umzuleiten und die Datei mit jeder neuen Anweisung zu überschreiben, verwenden Sie alternativ in einem Skript das Zeichen größer als (>).

Im folgenden Beispiel verbindet sich SnowSQL über eine benannte Verbindung mit einem Konto und fragt eine Tabelle ab. Die Ausgabe wird in eine CSV-Datei namens output_file.csv geschrieben, die sich im aktuellen lokalen Verzeichnis befindet:

Linux/macOS:

snowsql -c my_example_connection -d sales_db -s public -q 'select * from mytable limit 10' -o output_format=csv -o header=false -o timing=false -o friendly=false  > output_file.csv
Copy
Windows:

snowsql -c my_example_connection -d sales_db -s public -q "select * from mytable limit 10" -o output_format=csv -o header=false -o timing=false -o friendly=false  > output_file.csv
Copy

Ändern des SnowSQL-Eingabeaufforderungsformats

Die SnowSQL-Eingabeaufforderung zeigt dynamisch Kontextinformationen zur aktuellen Sitzung an:

  • Wenn Sie sich bei Snowflake anmelden, zeigt die Eingabeaufforderung Ihren Benutzernamen sowie das Standard-Warehouse, die Datenbank und das Schema an (wenn Standardeinstellungen festgelegt wurden).

  • Wenn Sie einen USE-Befehl in der Sitzung verwenden, um das Warehouse, die Datenbank oder das Schema festzulegen oder zu ändern, ändert sich die Eingabeaufforderung entsprechend dem Kontext.

Sie können Aussehen und Struktur der Eingabeaufforderung mithilfe der Konfigurationsoption prompt_format und einem Pygments-Token in Klammern für jeden Objekttyp in der Form [token] (z. B. [user] oder [warehouse]) steuern.

Das Token beeinflusst, wie sich die Eingabeaufforderung danach verhält. Sie können die Reihenfolge und Farbe für jedes Token sowie die Trennzeichen zwischen den Token ändern.

Wie bei allen Konfigurationsoptionen können Sie die Eingabeaufforderung mit einer der folgenden Methoden festlegen:

  • In der Konfigurationsdatei (vor dem Verbinden mit Snowflake)

  • Verwenden des Verbindungsparameters -o oder --options (beim Verbinden mit Snowflake)

  • Ausführen des Befehls !set (in der Befehlszeile aus eine Snowflake-Sitzung heraus)

Bemerkung

Wenn Sie die Eingabeaufforderung über den Verbindungsparameter oder direkt über die Befehlszeile ändern, gilt die Änderung nur für die aktuelle Sitzung. Um die Änderung in zukünftigen Sitzungen beizubehalten, legen Sie die Option in der Konfigurationsdatei fest.

Unterstützte Token

SnowSQL unterstützt die folgenden Objekttypen als Token:

  • user

  • account

  • role

  • database

  • schema

  • warehouse

Standardeingabeaufforderung

Die Standardeingabeaufforderung von SnowSQL verwendet die folgenden Token und Strukturen:

[user]#[warehouse]@[database].[schema]>
Copy

Beispiel:

jdoe#DATALOAD@BOOKS_DB.PUBLIC>
Copy

Beispiel für Eingabeaufforderung

In Fortsetzung des obigen Beispiels fügt der folgende !set-Befehl, der in der Befehlszeile ausgeführt wird, das Rollentoken hinzu und ändert die Tokenreihenfolge in user und role, database und schema, dann warehouse. Er ändert auch das Trennzeichen für jedes Token in einen Punkt (.) und setzt die Token so, dass sie verschiedene Farben verwenden:

jdoe#DATALOAD@BOOKS_DB.PUBLIC> !set prompt_format=[#FF0000][user].[role].[#00FF00][database].[schema].[#0000FF][warehouse]>
Copy

Dieses Beispiel führt zu der folgenden Eingabeaufforderung für die Sitzung:

SnowSQL-Eingabeaufforderungsformat

Trennen der Verbindung zu Snowflake und Anhalten von SnowSQL

SnowSQL stellt separate Befehle bereit für:

  • Beenden einzelner Verbindungen (z. B. Sitzungen) ohne Anhalten von SnowSQL.

  • Beenden von SnowSQL, wodurch auch automatisch alle Verbindungen beendet werden.

Um eine Verbindung/Sitzung zu beenden, verwenden Sie den Befehl !exit (oder seinen Alias !disconnect). Sie können sich dann wieder mittels !connect <Verbindungsname> verbinden, wenn Sie mehrere Verbindungen in der SnowSQL-Datei config definieren können. Wenn Sie nur eine Verbindung geöffnet haben, müssen Sie beachten, dass der Befehl !exit auch SnowSQL beendet.

Um alle Verbindungen zu schließen und dann SnowSQL zu beenden, verwenden Sie den Befehl !quit (oder seinen Alias !q). Sie können auch CTRL d über Ihre Tastatur eingeben.

Exitcodes

Es gibt mehrere mögliche Exitcodes, die zurückgegeben werden, wenn SnowSQL beendet wird:

0:

Alles lief reibungslos.

1:

Es gab ein Problem mit dem Client.

2:

Es gab ein Problem mit den Befehlszeilenargumenten.

3:

SnowSQL konnte den Server nicht kontaktieren.

4:

SnowSQL konnte nicht ordnungsgemäß mit dem Server kommunizieren.

5:

Die Konfigurationsoption exit_on_error wurde gesetzt und SnowSQL wegen eines Fehlers beendet.

Standard-Tastenbelegungen

Tab

Akzeptieren Sie den aktuellen Vorschlag zur automatischen Vervollständigung.

CTRL + d

Beenden/Stoppen von SnowSQL.

Befehlsreferenz

!abort

Bricht eine Abfrage (spezifiziert durch die Abfrage-ID) ab. Die Abfrage-ID kann von der Seite History Registerkarte „Verlauf“ der Weboberfläche abgerufen werden.

Beispiel:

user#> !abort 77589bd1-bcbf-4ec8-9ebc-6c949b00614d;
Copy

!connect

SnowSQL unterstützt mehrere Sitzungen (d. h. Verbindungen) mit !connect <Verbindungsname>:

  • Die mit connection_name im Zusammenhang stehenden Verbindungsparameter und Optionen werden in der SnowSQL-Konfigurationsdatei im zugehörigen Abschnitt [connections.<Verbindungsname>] gespeichert.

  • Wenn im Abschnitt [connections.<Verbindungsname>] weder Parameter noch Option angegeben sind, werden für die nicht spezifizierten Parameter standardmäßig die unter [connections] angegebenen Parameterwerte verwendet.

Beim Verbinden wird die Verbindung zu Ihrem Verbindungsstack hinzugefügt, und beim Beenden kehren Sie zu Ihrer vorherigen Verbindung zurück. Beim Verlassen werden alle Ihre Verbindungen geschlossen, egal wie viele Verbindungen Sie haben.

Beispiel:

Konfigurationsdatei:

[connections.my_example_connection]
...
Copy

Befehlszeile:

user#> !connect my_example_connection
Copy

!define

Setzt eine Variable auf einen bestimmten Wert, wobei das folgende Format verwendet wird:

!define <Variablenname>=<Variablenwert>

Name und Wert müssen durch ein einzelnes = ohne Leerzeichen getrennt werden. Gültige Zeichen, die in der Variable verwendet werden können, sind:

0-9a-zA-Z_

Weitere Informationen zum Definieren und Verwenden von Variablen finden Sie unter Verwenden von Variablen.

!edit

Öffnet den Editor, der mit dem Verbindungsparameter editor eingestellt wurde (wenn kein Editor eingestellt wurde, ist die Voreinstellung vim). Der Befehl akzeptiert eine Abfrage als Argument. Wenn kein Argument übergeben wird, wird die zuletzt ausgeführte Abfrage geöffnet.

Bemerkung

Vor oder beim Verlassen des Editors müssen Sie speichern, da sonst im Editor vorgenommenen Texteingaben und Textänderungen verloren gehen.

!exit, !disconnect

Löscht die aktuelle Verbindung. Wenn es sich um die letzte Verbindung handelte, wird auch SnowSQL beendet.

!help, !helps, !h

Zeigt die Hilfe zu SnowSQL-Befehlen an.

!options, !opts

Gibt eine Liste aller Konfigurationsoptionen von SnowSQL mit deren aktuellen Werten zurück. Diese Optionen können mit dem Befehl !set in der aktuellen SnowSQL-Sitzung eingestellt werden.

Bemerkung

Diese Optionen können auch in der Konfigurationsdatei für SnowSQL oder als Konnektorparameter in der Befehlszeile beim Aufrufen von SnowSQL eingestellt werden.

!pause

Hält aktive Abfragen an. Drücken Sie die Eingabetaste, um fortzufahren.

!print

Gibt den angegebenen Text auf dem Bildschirm und in alle Dateien aus, auf die Sie gerade zugreifen.

Beispiel:

user#> !print Include This Text
Copy

!queries

Listet alle Abfragen auf, die den angegebenen Filtern entsprechen. Die Standardfilter sind session und amount=25, die die letzten 25 Abfragen der aktuellen Sitzung zurückgeben.

Beispiel:

  • Liefert die letzten 25 Abfragen, die in der aktuellen Sitzung ausgeführt wurden:

    !queries session
    
    Copy
  • Liefert die letzten 20 Abfragen, die im Kontos ausgeführt wurden:

    !queries amount=20
    
    Copy
  • Liefert die letzten 20 Abfragen, die im Konto ausgeführt wurden und länger als 200 Millisekunden gedauert haben:

    !queries amount=20 duration=200
    
    Copy
  • Liefert die letzten 25 Abfragen, die im angegebenen Warehouse ausgeführt wurden:

    !queries warehouse=mywh
    
    Copy

Dieser Befehl erstellt eine Variable für jede zurückgegebene Abfrage ID. Beachten Sie, dass die Variablenersetzung aktiviert sein muss, damit Sie diese Variablen verwenden können. Beispiel:

user#> !queries session

+-----+--------------------------------------+----------+-----------+----------+
| VAR | QUERY ID                             | SQL TEXT | STATUS    | DURATION |
|-----+--------------------------------------+----------+-----------+----------|
| &0  | acbd6778-c68c-4e79-a977-510b2d8c08f1 | select 1 | SUCCEEDED |       19 |
+-----+--------------------------------------+----------+-----------+----------+

user#> !result &0

+---+
| 1 |
|---|
| 1 |
+---+

user#> !result acbd6778-c68c-4e79-a977-510b2d8c08f1

+---+
| 1 |
|---|
| 1 |
+---+
Copy

!quit, !q (auch CTRL + d)

Löscht alle Verbindungen und beendet SnowSQL.

!rehash

Synchronisiert die Auto-Vervollständigungs-Token neu.

Für den normalen Gebrauch ist keine Neusynchronisierung der Auto-Vervollständigungs-Token erforderlich. Das Erzwingen einer Aktualisierung der serverseitigen Token kann jedoch in bestimmten Szenarien sinnvoll sein (z. B. wenn in einer anderen Sitzung eine neue benutzerdefinierte Funktion erstellt wird).

!result

Gibt das Ergebnis einer abgeschlossenen Abfrage zurück (spezifiziert durch die Abfrage-ID). Abfrage-IDs können von der Seite History Registerkarte „Verlauf“ der Weboberfläche oder mit dem Befehl !queries abgerufen werden.

Wenn die Abfrage noch ausgeführt wird, wartet der Befehl, bis die Abfrage abgeschlossen ist.

Beispiel:

user#> !result 77589bd1-bcbf-4ec8-9ebc-6c949b00614d;
Copy

!set

Setzt die angegebene Konfigurationsoption von SnowSQL auf einen bestimmten Wert unter Verwendung der Form <Option>=<Wert>.

Beachten Sie, dass es derzeit keine Option wie unset gibt, mit der ein Optionswert rückgängig gemacht werden kann. Um den Wert einer Option zu ändern, führen Sie den Befehl !set erneut mit dem gewünschten Wert aus.

Beispiel:

user#> !options

+-----------------------+-------------------+
| Name                  | Value             |
|-----------------------+-------------------|
 ...
| rowset_size           | 1000              |
 ...
+-----------------------+-------------------+

user#> !set rowset_size=500

user#> !options

+-----------------------+-------------------+
| Name                  | Value             |
|-----------------------+-------------------|
 ...
| rowset_size           | 500               |
 ...
+-----------------------+-------------------+

user#> !set rowset_size=1000

user#> !options

+-----------------------+-------------------+
| Name                  | Value             |
|-----------------------+-------------------|
 ...
| rowset_size           | 1000              |
 ...
+-----------------------+-------------------+
Copy

Wichtig

Zwischen einer Option und dem zugehörigen Wert sind Leerzeichen nicht zulässig. Einige Optionen unterstützen einen definierten Satz von Werten. SnowSQL gibt einen Fehler zurück, wenn der angegebene Wert nicht unterstützt wird. Sie können keine neuen Optionen erstellen.

Eine Liste aller Konfigurationsoptionen, die Sie einstellen können, erhalten Sie mit dem Befehl !options.

!source, !load

Führt SQL aus einer Datei aus. Sie können SQL aus lokalen Dateien oder über eine URL aufrufen.

Beispiel:

user#> !source example.sql

user#> !load /tmp/scripts/example.sql

user#> !load http://www.example.com/sql_text.sql
Copy

!spool

Dieser Befehl kann auf zwei Arten ausgeführt werden:

  • Aktivieren Sie das Spooling, und schreiben Sie die Ergebnisse aller nachfolgenden Anweisungen/Abfragen in die angegebene Datei:

    !spool <Dateiname>

  • Deaktivieren Sie das Spooling von Ergebnissen (wenn es aktiviert ist):

    !spool off

Beispiel:

user#> select 1 num;

+-----+
| NUM |
|-----|
|   1 |
+-----+

user#> !spool /tmp/spool_example

user#> select 2 num;

+---+
| 2 |
|---|
| 2 |
+---+

user#> !spool off

user#> select 3 num;

+---+
| 3 |
|---|
| 3 |
+---+

user#> !exit

Goodbye!

$ cat /tmp/spool_example

+---+
| 2 |
|---|
| 2 |
+---+
Copy

Sie können das Ausgabeformat ändern, indem Sie zuerst den Befehl !set output_format=<Format> ausführen. Die Option unterstützt die folgenden Werte:

  • expanded

  • fancy_grid

  • grid

  • html

  • latex

  • latex_booktabs

  • mediawiki

  • orgtbl

  • pipe

  • plain

  • psql

  • rst

  • simple

  • tsv

Empfohlener Wert: psql, fancy_grid oder grid

Beispiel für die Ausgabe im CSV-Format:

user#> !set output_format=csv

user#> !spool /tmp/spool_example
Copy

!system

Führt einen Shell-Befehl aus.

!system <Befehl>

Das folgende Beispiel führt den Befehl ls im Stammverzeichnis des Benutzers aus:

user#> !system ls ~
Copy

!variables, !vars

Listet alle aktuellen Variablen auf. Gibt jedes aktuell definierte <Variablenname>=<Variablenwert>-Paar zurück.

Sobald eine Variable zugewiesen wurde, kann sie nicht mehr gelöscht werden, aber ihr Wert kann durch Angabe des Variablennamens ohne Wert entfernt werden. Beispiel:

user#> !set variable_substitution=true

user#> !define SnowAlpha=_ALPHA_

user#> !variables

+------------------+---------+
| Name             | Value   |
|------------------+---------|
| snowalpha        | _ALPHA_ |
+------------------+---------+

user#> !define SnowAlpha

user#> !variables

+------------------+-------+
| Name             | Value |
|------------------+-------|
| snowalpha        |       |
+------------------+-------+

user#> !define snowalpha=456

user#> select &snowalpha;

+-----+
| 456 |
|-----|
| 456 |
+-----+
Copy

Weitere Informationen zum Festlegen von Variablen finden Sie unter Verwenden von Variablen (unter diesem Thema).

Problembehandlung

Fehlermeldung: Variable is not defined

Ursache:

Wenn beim Ausführen von Befehle in SnowSQL diese Fehlermeldung angezeigt wird, könnte die Ursache ein kaufmännisches Und (&) innerhalb eines CREATE FUNCTION-Befehls sein. (Das kaufmännische Und ist das Variablen-Ersatzzeichen in SnowSQL). Die Ausführung des folgenden Befehls in SnowSQL führt beispielsweise zu diesem Fehler:

create function mask_bits(...)
    ...
    as
    $$
    var masked = (x & y);
    ...
    $$;
Copy

Der Fehler tritt auf, wenn die Funktion erstellt wird, nicht wenn sie aufgerufen wird.

Lösung:

Wenn Sie die Variablenersetzung in SnowSQL nicht verwenden möchten, können Sie diese mit folgendem Befehl explizit deaktivieren:

!set variable_substitution=false;
Copy

Weitere Informationen zur Variablenersetzung finden Sie unter Verwenden von Variablen.