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                                                        |
+------------+-------------------------------------------+-------------+--------------------------------------------------------------------------------------------+

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.

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

  • In der Konfigurationsdatei (vor der Verbindung zu Snowflake)

  • Verwendung von Verbindungsparametern (beim Verbinden mit Snowflake)

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

Darüber hinaus können Sie Variablen in einer Sitzung ersetzen, und Snowflake bietet auch integrierte Variablen.

Definieren 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 config-Konfigurationsdatei in einem Texteditor. Der Standardspeicherort der Datei ist:

    Linux/macOS

    ~/.snowsql/

    Windows

    %USERPROFILE%\.snowsql\

    Bemerkung

    Sie können einen anderen Speicherort angeben, indem Sie beim Starten von SnowSQL den Verbindungsparameter --config <Pfad> angeben.

  2. Fügen Sie die Variablen dem Abschnitt [variables] hinzu:

    [variables]
    <variable_name>=<variable_value>
    

    Wobei:

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

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

Definieren beim Verbinden (Verbindungsparameter -D oder --variable)

Um Variablen während des Verbindens mit Snowflake zu definieren, geben Sie in der Terminalbefehlszeile die Verbindungsparameter -D oder --variable gefolgt von Variablenname und Variablenwert in der Form <Variablenname>=<Variablenwert> an.

Beispiel:

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

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 in 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

Ersetzen in einer Sitzung

Wenn die Konfigurationsoption variable_substitution aktiviert ist, können definierte Variablen in SnowSQL referenziert und deren Werte durch Abfragen unter Verwendung der Syntax &<Variable> ersetzt werden. Beim Referenzieren der Variablen ist die Groß-/Kleinschreibung nicht relevant.

Beispiel:

user#> !define snowshell=bash

user#> !set variable_substitution=true

user#> select '&snowshell';

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

Wenn variable_substitution deaktiviert ist, werden keine Variablen ersetzt.

Beispiel:

user#> !define snowshell=bash

user#> !set variable_substitution=false

user#> select '&snowshell';

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

Wenn die Option variable_substitution aktiviert ist, aber keine Variable definiert ist, zeigt SnowSQL außerdem einen Fehler an.

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   |
+--------------+

Um ein kaufmännisches Und-Zeichen ohne Ersetzung zu verwenden, escapen Sie das kaufmännische Und-Zeichen mit einem zweiten kaufmännischen Und-Zeichen:

&&<Variable>

Beispiel:

user#> !set variable_substitution=true

user#> select '&notsubstitution';

Variable notsubstitution is not defined

user#> select '&&notsubstitution';

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

Bemerkung

Es gibt derzeit keine Option, um einen Optionswert aufzuheben, wie beispielsweise die Option variable_substitution. Um den Wert einer Option zu ändern, führen Sie den Befehl !set erneut mit dem gewünschten Wert aus.

Integrierte 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

Liefert die Anzahl der Zeilen, 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 |
+---+
__sfqid

Liefert die Abfrage-ID für die zuletzt vom Benutzer ausgeführte Abfrage.

user#> !set variable_substitution=true

user#> select * from a;

user#> select '&__sfqid';

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

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 [Pfeil nach oben] und [Pfeil nach unten], um die gewünschte Option zu markieren, und drücken Sie dann [Tabulator]-Taste.

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 [Pfeil nach oben] 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 unter ~/.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 xy12345 -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

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

Exportieren von Daten

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

  • output_format=Ausgabeformat

  • output_file=Ausgabedateiname

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

Ä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]>

Beispiel:

marie#DATALOAD@DEMO_DB.PUBLIC>

Beispiel für Eingabeaufforderung

In Fortsetzung des obigen Beispiels ändert der folgende !set-Befehl, der in der Befehlszeile ausgeführt wird, die Tokenreihenfolge in user, 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:

marie#DATALOAD@DEMO_DB.PUBLIC> !set prompt_format=[#FF0000][user].[#00FF00][database].[schema].[#0000FF][warehouse]>

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

SnowSQL prompt format

Trennen von 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 History tab der Weboberfläche abgerufen werden.

Beispiel:

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

!connect

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

  • Die mit Verbindungsname 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 Verbindungsstapel 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]
...

Befehlszeile:

user#> !connect my_example_connection

!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\_

!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 und ihrer aktuell eingestellten Werte 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

Aktive Abfragen anhalten. Drücken Sie die Eingabetaste, um fortzufahren.

!print

Druckt den angegebenen Text auf den Bildschirm und alle Dateien, auf die Sie gerade zugreifen.

Beispiel:

user#> !print Include This Text

!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
    
  • Liefert die letzten 20 Abfragen, die im Kontos ausgeführt wurden:

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

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

    !queries warehouse=mywh
    

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 |
+---+

!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

Liefert das Ergebnis einer abgeschlossenen Abfrage (spezifiziert durch die Abfrage-ID). Abfrage-IDs können von der Seite History History tab 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;

!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              |
 ...
+-----------------------+-------------------+

Wichtig

Zwischen einer Option und ihrem 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

!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 Spoolen 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 |
+---+

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

  • custom

  • 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

!system

Führt einen Shell-Befehl aus.

!system <Befehl>

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

user#> !system ls ~

!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 |
+-----+

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

Problembehandlung

Fehlermeldung: Variable is not defined

Ursache

In einigen Fällen kann dies durch die Verwendung des kaufmännisches Und-Zeichens (variables Substitutionszeichen) innerhalb eines CREATE FUNCTION-Befehls verursacht werden.

create function mask_bits(...)
    ...
    as
    $$
    var masked = (x & y);
    ...
    $$;
Lösung

Es gibt keine Lösung für dieses Problem, die in allen Situationen funktioniert. Wenn Sie jedoch nicht beabsichtigen, die Variablenersetzung zu verwenden, können Sie das Problem vermeiden, indem Sie die Variablenersetzung ausschalten. Um die Variablenersetzung auszuschalten, führen Sie den folgenden Befehl aus:

!set variable_substitution=false;

Weitere Informationen zur Variablenersetzung finden Sie unter Verwenden von Variablen.