Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Amazon-Redshift-RSQL-Metabefehle
Amazon-Redshift-RSQL-Metabefehle geben Informationsdatensätze über Datenbanken oder bestimmte Datenbankobjekte zurück. Die Ergebnisse können verschiedene Spalten und Metadaten enthalten. Andere Befehle führen bestimmte Aktionen aus. Diesen Befehlen geht ein umgekehrter Schrägstrich voraus.
## \$1d[S\$1]
Listet lokal vom Benutzer erstellte Tabellen, reguläre Ansichten, späte Bindungsansichten und materialisierte Ansichten auf. `\dS ` listet wie `\d` auch Tabellen und Ansichten auf, aber in den zurückgegebenen Datensätzen sind Systemobjekte enthalten. Das `+` ergibt die zusätzliche Metadatenspalte `description` für alle aufgelisteten Objekte. Im Folgenden werden Beispieldatensätze angezeigt, die als Ergebnis des Befehls zurückgegeben wurden.
```
List of relations
schema | name | type | owner
--------+-----------+-------+---------
public | category | table | awsuser
public | date | table | awsuser
public | event | table | awsuser
public | listing | table | awsuser
public | sales | table | awsuser
public | users | table | awsuser
public | venue | table | awsuser
(7 rows)
```
## \$1d[S\$1] NAME
Beschreibt eine Tabelle, eine Ansicht oder einen Index. Beinhaltet die Spaltennamen und -typen. Bietet auch Diststyle, Backup-Konfiguration, Erstellungsdatum (Tabellen, die nach Oktober 2018 erstellt wurden) und Einschränkungen. Zum Beispiel gibt `\dS+ sample` Objekteigenschaften zurück. Angabe von `S+` ergibt zusätzliche Spalten, die in den zurückgegebenen Datensätzen enthalten sind.
```
Table "public.sample"
Column | Type | Collation | Nullable | Default Value | Encoding | DistKey | SortKey
--------+-----------------------------+----------------+----------+---------------+-----------+---------+---------
col1 | smallint | | NO | | none | t | 1
col2 | character(100) | case_sensitive | YES | | none | f | 2
col3 | character varying(100) | case_sensitive | YES | | text32k | f | 3
col4 | timestamp without time zone | | YES | | runlength | f | 0
col5 | super | | YES | | zstd | f | 0
col6 | bigint | | YES | | az64 | f | 0
Diststyle: KEY
Backup: YES
Created: 2021-07-20 19:47:27.997045
Unique Constraints:
"sample_pkey" PRIMARY KEY (col1)
"sample_col2_key" UNIQUE (col2)
Foreign-key constraints:
"sample_col2_fkey" FOREIGN KEY (col2) REFERENCES lineitem(l_orderkey)
```
Der Verteilungsstil oder *Diststyle* der Tabelle kann KEY, AUTO, EVEN oder ALL sein.
*Backup* gibt an, ob die Tabelle gesichert wird, wenn ein Snapshot erstellt wird. Gültige Werte sind `YES` oder `NO`.
*Created* (erstellt) ist der Zeitstempel für die Erstellung der Tabelle. Das Erstellungsdatum ist für Amazon-Redshift-Tabellen, die vor November 2018 erstellt wurden, nicht verfügbar. Tabellen, die vor diesem Datum erstellt wurden, werden angezeigt n/a (nicht verfügbar).
*Unique Constraints* (eindeutige Einschränkungen) listet eindeutige und Primärschlüsseleinschränkungen für die Tabelle auf.
*Foreign-key constraints* (Fremdschlüsseleinschränkungen) listet fremde Schlüsseleinschränkungen für die Tabelle auf.
## \$1dC[\$1] [MUSTER]
Listet Casts auf. Beinhaltet den Quelltyp, den Zieltyp und ob der Cast implizit ist.
Im Folgenden wird eine Teilmenge der Ergebnisse von `\dC+` angezeigt.
```
List of casts
source type | target type | function | implicit? | description
-----------------------------+-----------------------------+---------------------+---------------+-------------
"char" | character | bpchar | in assignment |
"char" | character varying | text | in assignment |
"char" | integer | int4 | no |
"char" | text | text | yes |
"path" | point | point | no |
"path" | polygon | polygon | in assignment |
abstime | date | date | in assignment |
abstime | integer | (binary coercible) | no |
abstime | time without time zone | time | in assignment |
abstime | timestamp with time zone | timestamptz | yes |
abstime | timestamp without time zone | timestamp | yes |
bigint | bit | bit | no |
bigint | boolean | bool | yes |
bigint | character | bpchar | in assignment |
bigint | character varying | text | in assignment |
bigint | double precision | float8 | yes |
bigint | integer | int4 | in assignment |
bigint | numeric | numeric | yes |
bigint | oid | oid | yes |
bigint | real | float4 | yes |
bigint | regclass | oid | yes |
bigint | regoper | oid | yes |
bigint | regoperator | oid | yes |
bigint | regproc | oid | yes |
bigint | regprocedure | oid | yes |
bigint | regtype | oid | yes |
bigint | smallint | int2 | in assignment |
bigint | super | int8_partiql | in assignment |
```
## \$1dd[S] [MUSTER]
Zeigt Objektbeschreibungen an, die an anderer Stelle nicht angezeigt werden
## \$1de
Listet externe Tabellen auf. Dazu gehören Tabellen im Hive Metastore und verbundene Tabellen aus Amazon RDS/Aurora MySQL- AWS Glue Data Catalog, Amazon RDS/Aurora PostgreSQL- und Amazon Redshift Redshift-Datashare-Tabellen.
## \$1de NAME
Beschreibt eine externe Tabelle.
Das folgende Beispiel zeigt eine externe Tabelle. AWS Glue
```
# \de spectrum.lineitem
Glue External table "spectrum.lineitem"
Column | External Type | Redshift Type | Position | Partition Key | Nullable
-----------------+---------------+---------------+----------+---------------+----------
l_orderkey | bigint | bigint | 1 | 0 |
l_partkey | bigint | bigint | 2 | 0 |
l_suppkey | int | int | 3 | 0 |
l_linenumber | int | int | 4 | 0 |
l_quantity | decimal(12,2) | decimal(12,2) | 5 | 0 |
l_extendedprice | decimal(12,2) | decimal(12,2) | 6 | 0 |
l_discount | decimal(12,2) | decimal(12,2) | 7 | 0 |
l_tax | decimal(12,2) | decimal(12,2) | 8 | 0 |
l_returnflag | char(1) | char(1) | 9 | 0 |
l_linestatus | char(1) | char(1) | 10 | 0 |
l_shipdate | date | date | 11 | 0 |
l_commitdate | date | date | 12 | 0 |
l_receiptdate | date | date | 13 | 0 |
l_shipinstruct | char(25) | char(25) | 14 | 0 |
l_shipmode | char(10) | char(10) | 15 | 0 |
l_comment | varchar(44) | varchar(44) | 16 | 0 |
Location: s3://redshiftbucket/kfhose2019/12/31
Input_format: org.apache.hadoop.mapred.TextInputFormat
Output_format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
Serialization_lib: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
Serde_parameters: {"field.delim":"|","serialization.format":"|"}
Parameters: {"EXTERNAL":"TRUE","numRows":"178196721475","transient_lastDdlTime":"1577771873"}
```
Eine Hive-Metastore-Tabelle.
```
# \de emr.lineitem
Hive Metastore External Table "emr.lineitem"
Column | External Type | Redshift Type | Position | Partition Key | Nullable
-----------------+---------------+---------------+----------+---------------+----------
l_orderkey | bigint | bigint | 1 | 0 |
l_partkey | bigint | bigint | 2 | 0 |
l_suppkey | int | int | 3 | 0 |
l_linenumber | int | int | 4 | 0 |
l_quantity | decimal(12,2) | decimal(12,2) | 5 | 0 |
l_extendedprice | decimal(12,2) | decimal(12,2) | 6 | 0 |
l_discount | decimal(12,2) | decimal(12,2) | 7 | 0 |
l_tax | decimal(12,2) | decimal(12,2) | 8 | 0 |
l_returnflag | char(1) | char(1) | 9 | 0 |
l_linestatus | char(1) | char(1) | 10 | 0 |
l_commitdate | date | date | 11 | 0 |
l_receiptdate | date | date | 12 | 0 |
l_shipinstruct | char(25) | char(25) | 13 | 0 |
l_shipmode | char(10) | char(10) | 14 | 0 |
l_comment | varchar(44) | varchar(44) | 15 | 0 |
l_shipdate | date | date | 16 | 1 |
Location: s3://redshiftbucket/cetas
Input_format: org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat
Output_format: org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat
Serialization_lib: org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe
Serde_parameters: {"serialization.format":"1"}
Parameters: {"EXTERNAL":"TRUE", "numRows":"4307207", "transient_lastDdlTime":"1626990007"}
```
Eine externe PostgreSQL-Tabelle.
```
# \de pgrsql.alltypes
Postgres Federated Table "pgrsql.alltypes"
Column | External Type | Redshift Type | Position | Partition Key | Nullable
--------+-----------------------------+-----------------------------+----------+---------------+----------
col1 | bigint | bigint | 1 | 0 |
col2 | bigint | bigint | 2 | 0 |
col5 | boolean | boolean | 3 | 0 |
col6 | box | varchar(65535) | 4 | 0 |
col7 | bytea | varchar(65535) | 5 | 0 |
col8 | character(10) | character(10) | 6 | 0 |
col9 | character varying(10) | character varying(10) | 7 | 0 |
col10 | cidr | varchar(65535) | 8 | 0 |
col11 | circle | varchar(65535) | 9 | 0 |
col12 | date | date | 10 | 0 |
col13 | double precision | double precision | 11 | 0 |
col14 | inet | varchar(65535) | 12 | 0 |
col15 | integer | integer | 13 | 0 |
col16 | interval | varchar(65535) | 14 | 0 |
col17 | json | varchar(65535) | 15 | 0 |
col18 | jsonb | varchar(65535) | 16 | 0 |
col19 | line | varchar(65535) | 17 | 0 |
col20 | lseg | varchar(65535) | 18 | 0 |
col21 | macaddr | varchar(65535) | 19 | 0 |
col22 | macaddr8 | varchar(65535) | 20 | 0 |
col23 | money | varchar(65535) | 21 | 0 |
col24 | numeric | numeric(38,20) | 22 | 0 |
col25 | path | varchar(65535) | 23 | 0 |
col26 | pg_lsn | varchar(65535) | 24 | 0 |
col28 | point | varchar(65535) | 25 | 0 |
col29 | polygon | varchar(65535) | 26 | 0 |
col30 | real | real | 27 | 0 |
col31 | smallint | smallint | 28 | 0 |
col32 | smallint | smallint | 29 | 0 |
col33 | integer | integer | 30 | 0 |
col34 | text | varchar(65535) | 31 | 0 |
col35 | time without time zone | varchar(65535) | 32 | 0 |
col36 | time with time zone | varchar(65535) | 33 | 0 |
col37 | timestamp without time zone | timestamp without time zone | 34 | 0 |
col38 | timestamp with time zone | timestamp with time zone | 35 | 0 |
col39 | tsquery | varchar(65535) | 36 | 0 |
col40 | tsvector | varchar(65535) | 37 | 0 |
col41 | txid_snapshot | varchar(65535) | 38 | 0 |
col42 | uuid | varchar(65535) | 39 | 0 |
col43 | xml | varchar(65535) | 40 | 0 |
```
## \$1df[anptw][S\$1] [MUSTER]
Listet Funktionen verschiedener Typen auf. Der Befehl `\df` gibt beispielsweise eine Liste von Funktionen zurück. Zu den Ergebnissen gehören Eigenschaften wie Name, zurückgegebener Datentyp, Zugriffsberechtigungen und zusätzliche Metadaten. Funktionstypen können Trigger, gespeicherte Prozeduren, Fensterfunktionen und andere Typen umfassen. Wenn Sie `S+` an den Befehl anhängen, zum Beispiel `\dfantS+`, sind zusätzliche Metadatenspalten wie `owner`, `security` und `access privileges` enthalten.
## \$1dL[S\$1] [MUSTER]
Listet Daten zu Prozedursprachen auf, die mit der Datenbank verknüpft sind. Die Informationen umfassen den Namen, z. B. plpgsql, und zusätzliche Metadaten, unter anderem Vertrauenswürdigkeit, Zugriffsrechte und Beschreibung. Ein Beispielaufruf ist `\dLS+`, der Sprachen und ihre Eigenschaften auflistet. Wenn Sie `S+` an den Befehl anhängen, sind zusätzliche Metadatenspalten wie `call handler` und `access privileges` enthalten.
Beispielergebnisse:
```
List of languages
name | trusted | internal language | call handler | validator | access privileges | description
-----------+---------+-------------------+-------------------------+------------------------------------------------------------+-------------------+--------------------------------
c | f | t | - | fmgr_c_validator(oid) | | Dynamically-loaded C functions
exfunc | f | f | exfunc_call_handler() | - | rdsdb=U/rdsdb |
internal | f | t | - | fmgr_internal_validator(oid) | | Built-in functions
mlfunc | f | f | mlfunc_call_handler() | - | rdsdb=U/rdsdb |
plpgsql | t | f | plpgsql_call_handler() | plpgsql_validator(oid) | |
plpythonu | f | f | plpython_call_handler() | plpython_compiler(cstring,cstring,cstring,cstring,cstring) | rdsdb=U/rdsdb |
sql | t | t | - | fmgr_sql_validator(oid) | =U/rdsdb | SQL-language functions
```
## \$1dm[S\$1] [MUSTER]
Listet materialisierte Ansichten auf. Zum Beispiel listet `\dmS+` materialisierte Ansichten und ihre Eigenschaften auf. Wenn Sie `S+` an den Befehl anhängen, sind zusätzliche Metadatenspalten enthalten.
## \$1dn[S\$1] [MUSTER]
Listet Schemata auf Wenn Sie `S+` an den Befehl anhängen, zum Beispiel `\dnS+`, sind zusätzliche Metadatenspalten wie `description` und `access privileges` enthalten.
## \$1dp [MUSTER]
Listet Zugriffsberechtigungen für Tabellen, Anzeigen und Sequenzen auf.
## \$1dt[S\$1] [MUSTER]
Listet Tabellen auf. Wenn Sie `S+` an den Befehl anhängen, zum Beispiel `\dtS+`, sind zusätzliche Metadatenspalten wie `description` enthalten.
## \$1du
Listet die Benutzer für die Datenbank auf. Enthält deren Namen und Rollen, z. B. Superuser, und Attribute.
## \$1dv[S\$1] [MUSTER]
Listet Ansichten auf. Umfasst Schema, Typ und Besitzerdaten. Wenn Sie `S+` an den Befehl anhängen, zum Beispiel `\dvS+`, sind zusätzliche Metadatenspalten enthalten.
## \$1H
Schaltet die HTML-Ausgabe ein. Dies ist hilfreich, um schnell formatierte Ergebnisse zurückzugeben. Zum Beispiel gibt `select * from sales; \H` Ergebnisse aus der Verkaufstabelle in HTML zurück. Um zurück zu tabellarischen Ergebnissen zu wechseln, verwenden Sie `\q` oder verlassen Sie die Anzeige.
## \$1i
Führt Befehle aus einer Datei aus. Angenommen, Sie haben rsql\$1steps.sql in Ihrem Arbeitsverzeichnis, dann führen Sie die Befehle in der Datei `\i rsql_steps.sql` wie folgt aus.
## \$1l[\$1] [MUSTER]
Listet Datenbanken auf. Beinhaltet Besitzer, Kodierung und zusätzliche Informationen.
## \$1q
Das Beenden oder der `\q`-Befehl meldet Datenbanksitzungen ab und beendet RSQL.
## \$1sv[\$1] VIEWNAME
Zeigt die Definition einer Ansicht an.
## \$1timing
Zeigt beispielsweise die Laufzeit für eine Abfrage an.
## \$1z [MUSTER]
Dieselbe Ausgabe wie\$1 dp.
## \$1?
Zeigt Hilfeinformationen an. Der optionale Parameter gibt das zu erklärende Element an.
## \$1VERLASSEN
Meldet alle Datenbanksitzungen ab und beendet Amazon-Redshift-RSQL. Darüber hinaus können Sie einen optionalen Beendigungscode angeben. Zum Beispiel beendet `\EXIT 15` das Amazon-Redshift-RSQL-Terminal und gibt den Beendigungscode 15 zurück.
Das folgende Beispiel zeigt die Ausgabe einer Verbindung und das Beenden von RSQL.
```
% rsql -D testuser
DSN Connected
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.34.1000
Rsql Version: 1.0.1
Redshift Version: 1.0.29306
Type "help" for help.
(testcluster) user1@dev=# \exit 15
% echo $?
15
```
## \$1EXPORT
Gibt den Namen einer Exportdatei an, die RSQL zum Speichern von Datenbankinformationen verwendet, die von einer nachfolgenden SQL-SELECT-Anweisung zurückgegeben werden.
export\$101.sql
```
\export report file='E:\\accounts.out'
\rset rformat off
\rset width 1500
\rset heading "General Title"
\rset titledashes on
select * from td_dwh.accounts;
\export reset
```
Konsolenausgabe
```
Rformat is off.
Target width is 1500.
Heading is set to: General Title
Titledashes is on.
(exported 40 rows)
```
## \$1ANMELDUNG
Verbindung zu einer Datenbank herstellen. Sie können Verbindungsparameter mithilfe der Positionssyntax oder als Verbindungszeichenfolge angeben.
Die Befehlssyntax ist wie folgt: `\logon {[DBNAME|- USERNAME|- HOST|- PORT|- [PASSWORD]] | conninfo}`
`DBNAME` ist der Name der Datenbank, mit der eine Verbindung hergestellt werden soll. `USERNAME` ist der Benutzername für die Verbindung. Der Standardwert `HOST` ist `localhost`. Der Standardwert `PORT` ist `5439`.
Wird ein Hostname in einem `\LOGON`-Befehl angegeben, wird dies der Standard-Hostname für zusätzliche `\LOGON`-Befehle. Um den Standard-Hostnamen zu ändern, geben Sie einen neuen `HOST` mit einem zusätzlichen `\LOGON`-Befehl an.
Beispielausgabe des `\LOGON`-Befehls für `user1` siehe unten.
```
(testcluster) user1@redshiftdb=# \logon dev
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
You are now connected to database "dev" as user "user1".
(testcluster) user1@dev=#
```
Beispielausgabe für *user2* (Benutzer 2).
```
(testcluster) user1@dev=# \logon dev user2 testcluster2.example.com
Password for user user2:
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
You are now connected to database "dev" as user "user2" on host "testcluster2.example.com" at port "5439".
(testcluster2) user2@dev=#
```
## \$1ANMERKUNG
Eine Erweiterung des `\echo`-Befehls. `\REMARK` gibt die angegebene Zeichenfolge in den Ausgabestream aus. `\REMARK ` erweitert `\echo`, indem die Möglichkeit hinzugefügt wird, die Ausgabe über separate Zeilen zu verteilen.
Das folgende Beispiel zeigt die Ausgabe des Befehls.
```
(testcluster) user1@dev=# \remark 'hello//world'
hello
world
```
## \$1RSET
Der Befehl `\rset` legt Befehlsparameter und Variablen fest. `\rset` hat sowohl einen interaktiven als auch einen Batch-Modus. Es unterstützt keine Optionen als Bash-Optionen, wie *-x* oder Argumente zum Beispiel *--*.
Es legt Variablen wie die folgenden fest:
+ ERRORLEVEL
+ HEADING und RTITLE
+ RFORMAT
+ MAXERROR
+ TITLEDASHES
+ WIDTH
Das folgende Beispiel gibt eine Überschrift an.
```
\rset heading "Winter Sales Report"
```
Weitere Beispiele für die Verwendung von `\rset` finden Sie in den [Amazon-Redshift-RSQL-Variablen](rsql-query-tool-variables.md)-Themen.
## \$1AUSFÜHREN
Führt das Amazon-Redshift-RSQL-Skript aus, das in der angegebenen Datei enthalten ist. `\RUN` ist eine Erweiterung des `\i`-Befehls durch Hinzufügen einer Option zum Überspringen von Kopfzeilen in einer Datei.
Wenn der Dateiname ein Komma, ein Semikolon oder ein Leerzeichen enthält, schließen Sie ihn in einfache Anführungszeichen ein. Wenn dem Dateinamen Text folgt, schließen Sie ihn ebenfalls in Anführungszeichen ein. Unter UNIX muss bei den Dateinamen die Groß- und Kleinschreibung beachtet werden. Unter Windows wird nicht zwischen Groß- und Kleinschreibung unterschieden.
Das folgende Beispiel zeigt die Ausgabe des Befehls.
```
(testcluster) user1@dev=# \! cat test.sql
select count(*) as lineitem_cnt from lineitem;
select count(*) as customer_cnt from customer;
select count(*) as orders_cnt from orders;
(testcluster) user1@dev=# \run file=test.sql
lineitem_cnt
--------------
4307207
(1 row)
customer_cnt
--------------
37796166
(1 row)
orders_cnt
------------
0
(1 row)
(testcluster) user1@dev=# \run file=test.sql skip=2
2 records skipped in RUN file.
orders_cnt
------------
0
(1 row)
```
## \$1BS
Ein Alias für den `\!`-Befehl. `\OS` führt den Betriebssystembefehl aus, der als Parameter übergeben wird. Der Controller kehrt nach Ausführung des Befehls zu Amazon-Redshift-RSQL zurück. Sie können z. B. den folgenden Befehl ausführen, um die aktuelle Systemzeit zu drucken und zum RSQL-Terminal zurückzukehren: `\os date`.
```
(testcluster) user1@dev=# \os date
Tue Sep 7 20:47:54 UTC 2021
```
## \$1GOTO
Ein neuer Befehl für Amazon-Redshift-RSQL. `\GOTO` überspringt alle dazwischenliegenden Befehle und setzt die Verarbeitung am angegebenen `\LABEL` fort. `\LABEL` muss eine Vorwärtsreferenz sein. Sie können nicht zu einem `\LABEL` springen, das `\GOTO` lexikalisch vorangeht.
Das folgende Beispiel zeigt die Beispielausgabe.
```
(testcluster) user1@dev=# \! cat test.sql
select count(*) as cnt from lineitem \gset
select :cnt as cnt;
\if :cnt > 100
\goto LABELB
\endif
\label LABELA
\remark 'this is label LABELA'
\label LABELB
\remark 'this is label LABELB'
(testcluster) user1@dev=# \i test.sql
cnt
---------
4307207
(1 row)
\label LABELA ignored
\label LABELB processed
this is label LABELB
```
## \$1LABEL
Ein neuer Befehl für Amazon-Redshift-RSQL. `\LABEL` legt einen Einstiegspunkt für die Ausführung des Programms als Ziel für einen `\GOTO`-Befehl fest.
Das folgende Beispiel zeigt die Ausgabe des Befehls.
```
(testcluster) user1@dev=# \! cat test.sql
select count(*) from lineitem limit 5;
\goto LABELB
\remark "this step was skipped by goto label";
\label LABELA
\remark 'this is label LABELA'
\label LABELB
\remark 'this is label LABELB'
(testcluster) user1@dev=# \i testgoto.sql
count
4307193
(1 row)
\label LABELA ignored
\label LABELB processed
this is label LABELB
```
## \$1IF (\$1ELSEIF, \$1ELSE, \$1ENDIF)
`\IF` und verwandte Befehle führen bedingt Teile des Eingabeskripts aus. Eine Erweiterung des PSQL `\if`-Befehls (`\elif`, `\else`, `\endif`). `\IF` und `\ELSEIF` unterstützt boolesche Ausdrücke einschließlich Bedingungen `AND`, `OR` und `NOT`.
Das folgende Beispiel zeigt die Ausgabe der Befehle.
```
(testcluster) user1@dev=# \! cat test.sql
SELECT query FROM stv_inflight LIMIT 1 \gset
select :query as query;
\if :query > 1000000
\remark 'Query id is greater than 1000000'
\elseif :query = 1000000
\remark 'Query id is equal than 1000000'
\else
\remark 'Query id is less than 1000000'
\endif
(testcluster) user1@dev=# \i test.sql
query
--------
994803
(1 row)
Query id is less than 1000000
```
Verwenden von `ERRORCODE` in Ihrer Verzweigungslogik.
```
\if :'ERRORCODE' = '00000'
\remark 'The statement was executed without error'
\else
\remark :LAST_ERROR_MESSAGE
\endif
```
Verwenden von `\GOTO` innerhalb eines `\IF`-Blocks, um zu steuern, wie Code ausgeführt wird.