snow sql

Führt eine Snowflake-Abfrage aus. Verwenden Sie entweder die Option Abfrage, Dateiname oder Eingabe. Die auszuführende Abfrage kann mit der Option „query“, der Option „filename“ (alle Abfragen aus der Datei werden ausgeführt) oder über „stdin“ durch Weiterleiten der Ausgabe eines anderen Befehls angegeben werden. Beispiel: cat my.sql | snow sql -i. Der Befehl unterstützt die clientseitige Variablenersetzung.

Syntax

snow sql
  --query <query>
  --filename <files>
  --stdin
  --variable <data_override>
  --retain-comments
  --single-transaction / --no-single-transaction
  --project <project_definition>
  --env <env_overrides>
  --connection <connection>
  --host <host>
  --port <port>
  --account <account>
  --user <user>
  --password <password>
  --authenticator <authenticator>
  --private-key-file <private_key_file>
  --token-file-path <token_file_path>
  --database <database>
  --schema <schema>
  --role <role>
  --warehouse <warehouse>
  --temporary-connection
  --mfa-passcode <mfa_passcode>
  --enable-diag
  --diag-log-path <diag_log_path>
  --diag-allowlist-path <diag_allowlist_path>
  --oauth-client-id <oauth_client_id>
  --oauth-client-secret <oauth_client_secret>
  --oauth-authorization-url <oauth_authorization_url>
  --oauth-token-request-url <oauth_token_request_url>
  --oauth-redirect-uri <oauth_redirect_uri>
  --oauth-scope <oauth_scope>
  --oauth-disable-pkce
  --oauth-enable-refresh-tokens
  --oauth-enable-single-use-refresh-tokens
  --client-store-temporary-credential
  --format <format>
  --verbose
  --debug
  --silent
  --enhanced-exit-codes
Copy

Argumente

Keine

Optionen

--query, -q TEXT

Auszuführende Abfrage.

--filename, -f FILE

Auszuführende Datei. Standard: [].

--stdin, -i

Abfrage wird von der Standardeingabe gelesen. Verwenden Sie diese Option, wenn Sie Eingaben an diesen Befehl weiterleiten. Standard: false

--variable, -D TEXT

Zeichenfolge im Format von Schlüssel=Wert. Falls angegeben, wird der SQL-Inhalt als Vorlage behandelt und mit den bereitgestellten Daten gerendert.

--retain-comments

Behält Kommentare in Abfragen bei, die an Snowflake übergeben werden. Standard: false

--single-transaction / --no-single-transaction

Verbindet mit deaktiviertem Autocommit. Setzt BEGIN/COMMIT um Anweisungen, um sie als eine einzige Transaktion auszuführen, wobei sichergestellt wird, dass alle Befehle erfolgreich abgeschlossen werden oder keine Änderungen vorgenommen werden. Standard: false

-p, --project TEXT

Pfad, unter dem das Snowflake-Projekt gespeichert ist. Standardmäßig wird das aktuelle Verzeichnis als Arbeitsverzeichnis verwendet.

--env TEXT

Zeichenfolge im Format Schlüssel=Wert. Überschreibt die Variablen aus dem Abschnitt env, die für Vorlagen verwendet werden. Standard: [].

--connection, -c, --environment TEXT

Name der Verbindung, wie in Ihrer config.toml-Datei definiert. Standard: Standard.

--host TEXT

Host-Adresse für die Verbindung. Überschreibt den für die Verbindung angegebenen Wert.

--port INTEGER

Port für die Verbindung. Überschreibt den für die Verbindung angegebenen Wert.

--account, --accountname TEXT

Name, der Ihrem Snowflake-Konto zugewiesen wurde. Überschreibt den für die Verbindung angegebenen Wert.

--user, --username TEXT

Benutzername für die Verbindung zu Snowflake. Überschreibt den für die Verbindung angegebenen Wert.

--password TEXT

Snowflake-Kennwort. Überschreibt den für die Verbindung angegebenen Wert.

--authenticator TEXT

Snowflake-Authentifikator. Überschreibt den für die Verbindung angegebenen Wert.

--private-key-file, --private-key-path TEXT

Dateipfad zum privaten Snowflake-Schlüssel. Überschreibt den für die Verbindung angegebenen Wert.

--token-file-path TEXT

Pfad zur Datei mit einem OAuth-Token, das bei der Verbindung mit Snowflake verwendet werden soll.

--database, --dbname TEXT

Zu verwendende Datenbank. Überschreibt den für die Verbindung angegebenen Wert.

--schema, --schemaname TEXT

Zu verwendendes Datenbankschema. Überschreibt den für die Verbindung angegebenen Wert.

--role, --rolename TEXT

Zu verwendende Rolle. Überschreibt den für die Verbindung angegebenen Wert.

--warehouse TEXT

Zu verwendendes Warehouse. Überschreibt den für die Verbindung angegebenen Wert.

--temporary-connection, -x

Verwendet eine mit Befehlszeilenparametern definierte Verbindung anstelle einer in config definierten. Standard: false

--mfa-passcode TEXT

Für die mehrstufige Authentifizierung (MFA) zu verwendendes Token.

--enable-diag

Ob ein Verbindungsdiagnosebericht erstellt werden soll. Standard: false

--diag-log-path TEXT

Pfad für den generierten Bericht. Standardmäßig wird das temporäre Verzeichnis des Systems verwendet. Standard: <system_temporary_directory>.

--diag-allowlist-path TEXT

Pfad zu einer JSON-Datei, die allowlist-Parameter enthält.

--oauth-client-id TEXT

Wert der Client-ID, die vom Identitätsanbieter für die Snowflake-Integration bereitgestellt wird.

--oauth-client-secret TEXT

Wert des Client-Geheimnisses, das vom Identitätsanbieter für die Snowflake-Integration bereitgestellt wird.

--oauth-authorization-url TEXT

Endpunkt des Identitätsanbieters, der den Autorisierungscode an den Treiber liefert.

--oauth-token-request-url TEXT

Endpunkt des Identitätsanbieters, der die Zugriffstoken für den Treiber bereitstellt.

--oauth-redirect-uri TEXT

Für die Umleitung des Autorisierungscodes zu verwendende URI.

--oauth-scope TEXT

Bereich, der in der Autorisierungsanfrage des Identitätsanbieters angefordert wird.

--oauth-disable-pkce

Deaktiviert den Proof Key For Code Exchange (PKCE). Standard: False.

--oauth-enable-refresh-tokens

Ermöglicht eine stille Neuauthentifizierung, wenn das aktuelle Zugriffstoken veraltet ist. Standard: False.

--oauth-enable-single-use-refresh-tokens

Ob Sie sich für die Semantik des einmaligen Aktualisierungs-Tokens entscheiden. Standard: False.

--client-store-temporary-credential

Speichern der temporären Anmeldeinformationen.

--format [TABLE|JSON]

Gibt das Ausgabeformat an. Standard: TABLE.

--verbose, -v

Zeigt Protokolleinträge für die Protokolliergrade info und höher an. Standard: false

--debug

Zeigt Protokolleinträge für die Protokollebenen debug und höher an; Debug-Protokolle enthalten zusätzliche Informationen. Standard: false

--silent

Schaltet Zwischenausgaben auf der Konsole aus. Standard: false

--enhanced-exit-codes

Exit-Fehlercodes nach Art des Fehlers unterscheiden. Standard: false

--help

Zeigt den Hilfetext für diesen Befehl an.

Nutzungshinweise

Sie können für die SQL-Abfrage, die ausgeführt werden soll, eine der folgenden Optionen angeben:

  • Geben Sie die Zeichenfolge für die Abfrage mit der Option --query an.

  • Verwenden Sie die Option --filename, um eine oder mehrere Dateien mit einer oder mehreren SQL-Abfragen auszuführen. Beispiel:

    • snow sql -f myfile.sql

    • snow sql -f file1.sql -f file2.sql

  • Geben Sie die Abfrage als stdin an und leiten Sie sie an den Befehl snow sql weiter, etwa cat my.sql | snow sql.

  • Wenn Ihre Abfrage Sonderzeichen enthält, wie z. B. das Dollarzeichen in den SYSTEM-Funktionen, die die Shell nicht interpretieren soll, können Sie eine der folgenden Möglichkeiten nutzen:

    • Schließen Sie die Abfrage in einfache Anführungszeichen statt in doppelte Anführungszeichen ein, wie in:

      snow sql -q 'SELECT SYSTEM$CLIENT_VERSION_INFO()'

    • Verwenden Sie ein Escape-Zeichen für das Sonderzeichen aus, wie in:

      snow sql -q "SELECT SYSTEM\$CLIENT_VERSION_INFO()"

  • Verwenden Sie Variablen für die Erstellung von SQL-Abfragen mit einer Kombination aus einem <% variable_name %>-Platzhalter in Ihren SQL Abfragen und einer -D-Befehlszeilenoption im Format:

    snow sql -q "select * from my-database order by <% column_name %>" -D "column_name=Country"
    
    Copy

    Bemerkung

    Sie können derzeit die Syntax SnowSQL &variable_name und <% variable_name %> für Vorlagen verwenden. Snowflake empfiehlt jedoch die Verwendung der Syntax <% variable_name %>.

  • Geben Sie in Abfragen einen Skriptblock an. Beispiel:

    EXECUTE IMMEDIATE $$
    -- Snowflake Scripting code
    DECLARE
      radius_of_circle FLOAT;
      area_of_circle FLOAT;
    BEGIN
      radius_of_circle := 3;
      area_of_circle := pi() * radius_of_circle * radius_of_circle;
      RETURN area_of_circle;
    END;
    $$
    ;
    
    Copy

    Bemerkung

    Wenn Sie den Scripting-Block direkt in der Snowflake CLI-Befehlszeile angeben, funktionieren die Trennzeichen $$ bei einigen Shells möglicherweise nicht, da sie dieses Trennzeichen als etwas anderes interpretieren. Die Shells bash und zsh zum Beispiel interpretieren es als die Prozess-ID (PID). Um diese Beschränkung zu umgehen, können Sie die folgenden Alternativen verwenden:

    • Wenn Sie den Skriptblock dennoch in der Befehlszeile angeben möchten, können Sie die $$-Begrenzungszeichen maskieren, wie in \$\$.

    • Sie können den Skriptblock auch mit den standardmäßigen $$-Begrenzungszeichen in eine separate Datei schreiben und mit dem Befehl snow sql -f <filename> aufrufen.

Erweiterte Fehlercodes

Die Option --enhanced-exit-codes liefert Informationen, mit deren Hilfe Sie feststellen können, ob Probleme durch die Ausführung von Abfragen oder durch ungültige Befehlsoptionen entstanden sind. Mit dieser Option liefert der Befehl snow sql die folgenden Rückgabewerte:

  • 0: Erfolgreiche Ausführung

  • 2: Probleme mit Befehlsparametern

  • 5: Probleme bei der Ausführung von Abfragen

  • 1: Andere Arten von Problemen

Nachdem der Befehl ausgeführt wurde, können Sie den Shell-Befehl echo $? verwenden, um den Rückgabecode zu sehen.

In diesem Beispiel enthält der Befehl sowohl einen Abfrageparameter (-q 'select 1') als auch einen Abfragedateiparameter (-f my.query), was eine ungültige Parameterkombination darstellt:

snow sql --enhanced-exit-codes -q 'select 1' -f my.query

echo $?
Copy
2

Die folgenden Beispiele zeigen die Auswirkungen der Option --enhanced-exit-codes, wenn der Befehl eine ungültige Abfrage enthält (slect ist falsch geschrieben):

  • Mit der Option --enhanced-exit-codes gibt der Befehl einen Exitcode 5 zurück, um einen Abfragefehler anzuzeigen:

    snow sql --enhanced-exit-codes -q 'slect 1'
    
    echo $?
    
    Copy
    5
    
  • Ohne die Option --enhanced-exit-codes gibt der Befehl einen Exitcode 1 zurück, um einen allgemeinen (anderen) Fehler anzuzeigen:

    snow sql --enhanced-exit-codes -q 'slect 1'
    
    echo $?
    
    Copy
    1
    

Alternativ können Sie die Umgebungsvariable SNOWFLAKE_ENHANCED_EXIT_CODES auf 1 setzen, um die erweiterten Rückgabecodes für alle snow sql-Befehle zu senden.

Interaktiver Modus

Der Befehl snow sql unterstützt einen interaktiven Modus, in dem Sie SQL-Befehle einzeln eingeben können. Der interaktive Modus bietet die folgenden Features:

  • Syntax-Hervorhebung

    Syntax-Hervorhebung im interaktiven Modus
  • Code-Vervollständigung beim Tippen

    Code-Vervollständigung im interaktiven Modus
  • Durchsuchbarer Verlauf

    Um Ihren Befehlsverlauf zu durchsuchen, drücken Sie CTRL-R:

    Interaktiver Modus, durchsuchbarer Verlauf
  • Mehrzeilige Eingabe

    Wenn Sie ENTER in einer Zeile drücken, die nicht mit einem Semikolon endet (;), springt der Cursor für weitere Befehle in die nächste Zeile, bis eine Anweisung mit einem Semikolon endet.

    Interaktiver Modus, mehrzeilige Eingabe

Um den interaktiven Modus zu verwenden, geben Sie den Befehl snow sql ein, gefolgt von ENTER, wie gezeigt:

snow sql
Copy

Der Befehl öffnet eine Sub-Shell mit einer >-Eingabeaufforderung, an der Sie interaktiv SQL-Befehle eingeben können:

$ snow sql
  ╭───────────────────────────────────────────────────────────────────────────────────╮
  │ Welcome to Snowflake-CLI REPL                                                   │
  │ Type 'exit' or 'quit' to leave                                                  │
  ╰───────────────────────────────────────────────────────────────────────────────────╯
  >

Sie können dann SQL-Befehle eingeben, wie gezeigt:

> create table my_table (c1 int);
Copy
+-------------------------------------+
| status                              |
|-------------------------------------|
| Table MY_TABLE successfully created.|
+-------------------------------------+

Bemerkung

Sie müssen jede SQL-Anweisung mit einem Semikolon beenden (;).

Um den interaktiven Modus zu verlassen, geben Sie exit, quit, oder CTRL-D ein.

Mehrere Befehle in einer einzigen Transaktion

Mit der Option --single-transaction können Sie mehrere SQL-Befehle eingeben, die als Alles-oder-Nichts-Satz von Befehlen ausgeführt werden. Indem Sie die Befehle in einer einzigen Transaktion ausführen, können Sie sicherstellen, dass alle Befehle erfolgreich abgeschlossen werden, bevor Sie die Änderungen festschreiben. Wenn einer der Befehle fehlschlägt, bleibt keine der Änderungen aus den erfolgreichen Befehlen erhalten.

Die folgenden Beispiele zeigen erfolgreiche und erfolglose Transaktionen:

  • Erfolgreiche Befehlsausführung

    snow sql -q "insert into my_tbl values (123); insert into my_tbl values (124);" --single-transaction
    
    Copy
    BEGIN;
    +----------------------------------+
    | status                           |
    |----------------------------------|
    | Statement executed successfully. |
    +----------------------------------+
    
    insert into my_tbl values (123);
    +-------------------------+
    | number of rows inserted |
    |-------------------------|
    | 1                       |
    +-------------------------+
    
    insert into my_tbl values (124);
    +-------------------------+
    | number of rows inserted |
    |-------------------------|
    | 1                       |
    +-------------------------+
    
    COMMIT
    +----------------------------------+
    | status                           |
    |----------------------------------|
    | Statement executed successfully. |
    +----------------------------------+
    

    Sie können dann überprüfen, ob die Befehle in die Datenbank übertragen wurden:

    snow sql -q "select count(*) from my_tbl"
    
    Copy
    select count(*) from my_tbl
    +----------+
    | COUNT(*) |
    |----------|
    | 2        |
    +----------+
    
  • Erfolglose Einzeltransaktion

    snow sql -q "insert into my_tbl values (123); insert into my_tbl values (124); select BAD;" --single-transaction
    
    Copy
    BEGIN;
    +----------------------------------+
    | status                           |
    |----------------------------------|
    | Statement executed successfully. |
    +----------------------------------+
    
    insert into my_tbl values (123);
    +-------------------------+
    | number of rows inserted |
    |-------------------------|
    | 1                       |
    +-------------------------+
    
    insert into my_tbl values (124);
    +-------------------------+
    | number of rows inserted |
    |-------------------------|
    | 1                       |
    +-------------------------+
    
    select BAD;
    ╭─ Error ───────────────────────────────────────────────────────────────────────────────╮
    │ 000904 (42000): 01bc3b84-0810-0247-0001-c1be14ee11ce: SQL compilation error: error    │
    │ line 1 at position 7                                                                  │
    │ invalid identifier 'BAD'                                                              │
    ╰───────────────────────────────────────────────────────────────────────────────────────╯
    

Sie können dann überprüfen, dass die Befehle nicht in die Datenbank übertragen wurden:

snow sql -q "select count(*) from my_tbl"
Copy
select count(*) from my_tbl
+----------+
| COUNT(*) |
|----------|
| 0        |
+----------+

Beispiele

  • Das folgende Beispiel verwendet die SQL-Systemfunktion SYSTEM$CLIENT_VERSION_INFO, um Versionsinformationen zu Clients und Treibern zurückzugeben.

    snow sql --query 'SELECT SYSTEM$CLIENT_VERSION_INFO();'
    
    Copy
    select current_version();
    +-------------------+
    | CURRENT_VERSION() |
    |-------------------|
    | 8.25.1            |
    +-------------------+
    
  • Das folgende Beispiel zeigt, wie Sie eine Datenbank mithilfe einer clientseitigen Variablen angeben können:

    snow sql -q "select * from <% database %>.logs" -D "database=dev"
    
    Copy

    Bei der Ausführung ersetzt der Befehl den Wert dev in der Variablen <% Datenbank %>, um den Bezeichner dev.logs zu erstellen und sendet dann die select * from dev.logs SQL-Abfrage zur Verarbeitung an Snowflake.

    Bemerkung

    Sie können derzeit die SnowSQL &variable_name und & { variable_name }-Syntax für Vorlagen verwenden. Snowflake empfiehlt jedoch die Verwendung der <% variable_name %>-Syntax.

  • Dieses Beispiel zeigt, wie Sie Umgebungsvariablen mit der Option --env übergeben können:

    snow sql -q "select '<% ctx.env.test %>'" --env test=value_from_cli
    
    Copy
  • Standardmäßig entfernt Snowflake CLI die Kommentare in der SQL-Abfrage aus der Ausgabe. Das folgende Beispiel verwendet die Option --retain-comments, um die Kommentare in die Abfrageergebnisse aufzunehmen.

    Angenommen, die Datei example.sql enthält die folgenden Anweisungen und Kommentare:

    select 'column1';
    -- My comment
    select 'column2';
    
    Copy

    Wenn Sie den folgenden Befehl ausführen, wird -- Mein Kommentar in den Abfrageergebnissen angezeigt.

    snow sql -f example.sql --retain-comments
    
    Copy
    select 'column1';
    +-----------+
    | 'COLUMN1' |
    |-----------|
    | ABC       |
    +-----------+
    
    -- My comment
    select 'bar';
    +-----------+
    | 'COLUMN2' |
    |-----------|
    | 123       |
    +-----------+
    
    Copy