PostgreSQL 8.4 - en to de translation catalogue (610 entries)

en: 
    Connection options:
de: 
    Verbindungsoptionen:

en: 
    For more information, type "\?" (for internal commands) or "\help" (for SQL
    commands) from within psql, or consult the psql section in the PostgreSQL
    documentation.
de: 
    Für mehr Informationen, geben Sie »\?« (für interne Anweisungen) oder
    »\help« (für SQL-Anweisungen) in psql ein oder schauen Sie in den psql-
    Abschnitt der PostgreSQL-Dokumentation.

en: 
    Input and output options:
de: 
    Eingabe- und Ausgabeoptionen:

en: 
    Output format options:
de: 
    Ausgabeformatoptionen:

en: 
    Parser: "%s"
de: 
    Parser: »%s«

en: 
    Parser: "%s.%s"
de: 
    Parser: »%s.%s«

en:   (options: S = show system objects, + = additional detail)
de:   (Optionen: S = Systemobjekte zeigen, + = zusätzliche Details zeigen)

en:   --help                   show this help, then exit
de:   --help                   diese Hilfe anzeigen, dann beenden

en:   --version                output version information, then exit
de:   --version                Versionsinformationen anzeigen, dann beenden

en:   -1 ("one"), --single-transaction
                               execute command file as a single transaction
de:   -1 (»eins«), --single-transaction
                               Befehlsdatei als eine einzige Transaktion ausführen

en:   -A, --no-align           unaligned table output mode
de:   -A, --no-align           unausgerichteter Tabellenausgabemodus

en:   -E, --echo-hidden        display queries that internal commands generate
de:   -E, --echo-hidden        von internen Anweisungen erzeugte Anfragen zeigen

en:   -F, --field-separator=STRING
                               set field separator (default: "%s")
de:   -F, --field-separator=ZEICHEN
                               Feldtrennzeichen setzen (Standard: »%s«)

en:   -H, --html               HTML table output mode
de:   -H, --html               HTML-Tabellenausgabemodus

en:   -L, --log-file=FILENAME  send session log to file
de:   -L, --log-file=DATEINAME
                               Sitzungslog in Datei senden

en:   -P, --pset=VAR[=ARG]     set printing option VAR to ARG (see \pset command)
de:   -P, --pset=VAR[=ARG]     Ausgabeoption VAR auf ARG setzen (siehe
                               \pset-Anweisung)

en:   -R, --record-separator=STRING
                               set record separator (default: newline)
de:   -R, --record-separator=ZEICHEN
                               Satztrennzeichen setzen (Standard: Newline)

en:   -S, --single-line        single-line mode (end of line terminates SQL command)
de:   -S, --single-line        Einzelzeilenmodus (Zeilenende beendet SQL-Anweisung)

en:   -T, --table-attr=TEXT    set HTML table tag attributes (e.g., width, border)
de:   -T, --table-attr=TEXT    HTML »table«-Tag-Attribute setzen (z.B. width)

en:   -U, --username=USERNAME  database user name (default: "%s")
de:   -U, --username=NAME      Datenbank-Benutzername (Standard: »%s«)

en:   -W, --password           force password prompt (should happen automatically)
de:   -W, --password           nach Passwort fragen (sollte automatisch geschehen)

en:   -X, --no-psqlrc          do not read startup file (~/.psqlrc)
de:   -X, --no-psqlrc          Startdatei (~/.psqlrc) nicht lesen

en:   -a, --echo-all           echo all input from script
de:   -a, --echo-all           Skript-Inhalt wiedergeben

en:   -c, --command=COMMAND    run only single command (SQL or internal) and exit
de:   -c, --command=ANWEISUNG   einzelne Anweisung ausführen und beenden

en:   -d, --dbname=DBNAME      database name to connect to (default: "%s")
de:   -d, --dbname=DBNAME      Datenbank, zu der verbunden werden soll
                               (Standard: »%s«)

en:   -e, --echo-queries       echo commands sent to server
de:   -e, --echo-queries       an den Server geschickte Anweisungen zeigen

en:   -f, --file=FILENAME      execute commands from file, then exit
de:   -f, --file=DATEINAME     Anweisungen aus Datei ausführen und danach beenden

en:   -h, --host=HOSTNAME      database server host or socket directory (default: "%s")
de:   -h, --host=HOSTNAME      Hostname des Datenbankservers oder
                               Socket-Verzeichnis (Standard: »%s«)

en:   -l, --list               list available databases, then exit
de:   -l, --list               verfügbare Datenbanken auflisten und beenden

en:   -n, --no-readline        disable enhanced command line editing (readline)
de:   -n, --no-readline        erweiterte Zeilenbearbeitung (Readline) ausschalten

en:   -o, --output=FILENAME    send query results to file (or |pipe)
de:   -o, --output=DATEINAME   Anfrageergebnisse in Datei (oder |Pipe) senden

en:   -p, --port=PORT          database server port (default: "%s")
de:   -p, --port=PORT          Port des Datenbankservers (Standard: »%s«)

en:   -q, --quiet              run quietly (no messages, only query output)
de:   -q, --quiet              stille Ausführung (keine Mitteilungen, nur
                               Anfrageergebnisse)

en:   -s, --single-step        single-step mode (confirm each query)
de:   -s, --single-step        Einzelschrittmodus (jede Anfrage bestätigen)

en:   -t, --tuples-only        print rows only
de:   -t, --tuples-only        nur Datenzeilen ausgeben

en:   -v, --set=, --variable=NAME=VALUE
                               set psql variable NAME to VALUE
de:   -v, --set=, --variable=NAME=WERT
                               psql-Variable NAME auf WERT setzen

en:   -w, --no-password        never prompt for password
de:   -w, --no-password        niemals nach Passwort fragen

en:   -x, --expanded           turn on expanded table output
de:   -x, --expanded           erweiterte Tabellenausgabe einschalten

en:   \! [COMMAND]           execute command in shell or start interactive shell
de:   \! [BEFEHL]            Befehl in Shell ausführen oder interaktive Shell starten

en:   \C [STRING]            set table title, or unset if none
de:   \C [TEXT]              Tabellentitel setzen oder löschen

en:   \H                     toggle HTML output mode (currently %s)
de:   \H                     HTML-Ausgabemodus umschalten (gegenwärtig %s)

en:   \T [STRING]            set HTML <table> tag attributes, or unset if none
de:   \T [TEXT]              HTML <table>-Tag-Attribute setzen oder löschen

en:   \a                     toggle between unaligned and aligned output mode
de:   \a                     zwischen unausgerichtetem und ausgerichtetem Ausgabemodus
                             umschalten

en:   \c[onnect] [DBNAME|- USER|- HOST|- PORT|-]
                             connect to new database (currently "%s")
de:   \c[onnect] [DBNAME|- BENUTZER|- HOST|- PORT|-]
                             mit neuer Datenbank verbinden (aktuell »%s«)

en:   \cd [DIR]              change the current working directory
de:   \cd [VERZ]             Arbeitsverzeichnis wechseln

en:   \copy ...              perform SQL COPY with data stream to the client host
de:   \copy ...              SQL COPY mit Datenstrom auf Client-Host ausführen

en:   \copyright             show PostgreSQL usage and distribution terms
de:   \copyright             PostgreSQL-Urheberrechtsinformationen zeigen

en:   \dC     [PATTERN]      list casts
de:   \dC     [MUSTER]       Typumwandlungen (Casts) auflisten

en:   \dD[S]  [PATTERN]      list domains
de:   \dD[S]  [MUSTER]       Domänen auflisten

en:   \dF[+]  [PATTERN]      list text search configurations
de:   \dF[+]  [MUSTER]       Textsuchekonfigurationen auflisten

en:   \dFd[+] [PATTERN]      list text search dictionaries
de:   \dFd[+] [MUSTER]       Textsuchewörterbücher auflisten

en:   \dFp[+] [PATTERN]      list text search parsers
de:   \dFp[+] [MUSTER]       Textsucheparser auflisten

en:   \dFt[+] [PATTERN]      list text search templates
de:   \dFt[+] [MUSTER]       Textsuchevorlagen auflisten

en:   \dT[S+] [PATTERN]      list data types
de:   \dT[S+] [MUSTER]       Datentypen auflisten

en:   \d[S+]                 list tables, views, and sequences
de:   \d[S+]                 Tabellen, Sichten und Sequenzen auflisten

en:   \d[S+]  NAME           describe table, view, sequence, or index
de:   \d[S+]  NAME           Tabelle, Sicht, Sequenz oder Index beschreiben

en:   \da[+]  [PATTERN]      list aggregates
de:   \da[+]  [MUSTER]       Aggregatfunktionen auflisten

en:   \db[+]  [PATTERN]      list tablespaces
de:   \db[+]  [MUSTER]       Tablespaces auflisten

en:   \dc[S]  [PATTERN]      list conversions
de:   \dc[S]  [MUSTER]       Konversionen auflisten

en:   \dd[S]  [PATTERN]      show comments on objects
de:   \dd[S]  [MUSTER]       Kommentar für Objekt zeigen

en:   \des[+] [PATTERN]      list foreign servers
de:   \des[+] [MUSTER]       Fremdserver auflisten

en:   \deu[+] [PATTERN]      list user mappings
de:   \deu[+] [MUSTER]       Benutzerabbildungen auflisten

en:   \dew[+] [PATTERN]      list foreign-data wrappers
de:   \dew[+] [MUSTER]       Fremddaten-Wrapper auflisten

en:   \df[antw][S+] [PATRN]  list [only agg/normal/trigger/window] functions
de:   \df[antw][S+] [MUSTR]  Funktionen [nur Agg/normale/Trigger/Fenster] auflisten

en:   \dg[+]  [PATTERN]      list roles (groups)
de:   \dg[+]  [MUSTER]       Rollen (Gruppen) auflisten

en:   \di[S+] [PATTERN]      list indexes
de:   \di[S+] [MUSTER]       Indexe auflisten

en:   \dl                    list large objects, same as \lo_list
de:   \dl                    Large Objects auflisten, wie \lo_list

en:   \dn[+]  [PATTERN]      list schemas
de:   \dn[+]  [MUSTER]       Schemas auflisten

en:   \do[S]  [PATTERN]      list operators
de:   \do[S]  [MUSTER]       Operatoren auflisten

en:   \dp     [PATTERN]      list table, view, and sequence access privileges
de:   \dp     [MUSTER]       Zugriffsprivilegien für Tabellen, Sichten und
                             Sequenzen auflisten

en:   \ds[S+] [PATTERN]      list sequences
de:   \ds[S+] [MUSTER]       Sequenzen auflisten

en:   \dt[S+] [PATTERN]      list tables
de:   \dt[S+] [MUSTER]       Tabellen auflisten

en:   \du[+]  [PATTERN]      list roles (users)
de:   \du[+]  [MUSTER]       Rollen (Benutzer) auflisten

en:   \dv[S+] [PATTERN]      list views
de:   \dv[S+] [MUSTER]       Sichten auflisten

en:   \e [FILE]              edit the query buffer (or file) with external editor
de:   \e [DATEI]             Anfragepuffer (oder Datei) mit externem Editor bearbeiten

en:   \echo [STRING]         write string to standard output
de:   \echo [TEXT]           Text auf Standardausgabe schreiben

en:   \ef [FUNCNAME]         edit function definition with external editor
de:   \ef [FUNKNAME]         Funktionsdefinition mit externem Editor bearbeiten

en:   \encoding [ENCODING]   show or set client encoding
de:   \encoding [KODIERUNG]  Client-Kodierung zeigen oder setzen

en:   \f [STRING]            show or set field separator for unaligned query output
de:   \f [ZEICHEN]           Feldtrennzeichen zeigen oder setzen

en:   \g [FILE] or ;         execute query (and send results to file or |pipe)
de:   \g [DATEI] oder ;      SQL-Anweisung ausführen (und Ergebnis in Datei oder
                             |Pipe schreiben)

en:   \h [NAME]              help on syntax of SQL commands, * for all commands
de:   \h [NAME]              Syntaxhilfe über SQL-Anweisung, * für alle Anweisungen

en:   \i FILE                execute commands from file
de:   \i DATEI               Befehle aus Datei ausführen

en:   \l[+]                  list all databases
de:   \l[+]                  alle Datenbanken auflisten

en:   \lo_export LOBOID FILE
      \lo_import FILE [COMMENT]
      \lo_list
      \lo_unlink LOBOID      large object operations
de:   \lo_export LOBOID DATEI
      \lo_import DATEI [KOMMENTAR]
      \lo_list
      \lo_unlink LOBOID      Large-Object-Operationen

en:   \o [FILE]              send all query results to file or |pipe
de:   \o [DATEI]             alle Anfrageergebnisse in Datei oder |Pipe schreiben

en:   \p                     show the contents of the query buffer
de:   \p                     aktuellen Inhalt der Anfragepuffers zeigen

en:   \password [USERNAME]   securely change the password for a user
de:   \password [BENUTZERNAME]
                             sicheres Ändern eines Benutzerpasswortes

en:   \prompt [TEXT] NAME    prompt user to set internal variable
de:   \prompt [TEXT] NAME    interne Variable vom Benutzer abfragen

en:   \pset NAME [VALUE]     set table output option
                             (NAME := {format|border|expanded|fieldsep|footer|null|
                             numericlocale|recordsep|tuples_only|title|tableattr|pager})
de:   \pset NAME [WERT]      Tabellenausgabeoption setzen
                             (NAME := {format|border|expanded|fieldsep|footer|null|
                             numericlocale|recordsep|tuples_only|title|tableattr|pager})

en:   \q                     quit psql
de:   \q                     psql beenden

en:   \qecho [STRING]        write string to query output stream (see \o)
de:   \qecho [TEXT]          Text auf Ausgabestrom für Anfrageergebnisse schreiben
                             (siehe \o)

en:   \r                     reset (clear) the query buffer
de:   \r                     Anfragepuffer löschen

en:   \s [FILE]              display history or save it to file
de:   \s [DATEI]             Befehlsgeschichte ausgeben oder in Datei schreiben

en:   \set [NAME [VALUE]]    set internal variable, or list all if no parameters
de:   \set [NAME [WERT]]     interne Variable setzen, oder alle anzeigen

en:   \t [on|off]            show only rows (currently %s)
de:   \t [on|off]            nur Datenzeilen zeigen (gegenwärtig %s)

en:   \timing [on|off]       toggle timing of commands (currently %s)
de:   \timing [on|off]       Zeitmessung umschalten (gegenwärtig %s)

en:   \unset NAME            unset (delete) internal variable
de:   \unset NAME            interne Variable löschen

en:   \w FILE                write query buffer to file
de:   \w DATEI               Anfragepuffer in Datei schreiben

en:   \x [on|off]            toggle expanded output (currently %s)
de:   \x [on|off]            erweiterte Ausgabe umschalten (gegenwärtig %s)

en:   \z      [PATTERN]      same as \dp
de:   \z      [MUSTER]       äquivalent zu \dp

en:   psql [OPTION]... [DBNAME [USERNAME]]
de:   psql [OPTION]... [DBNAME [BENUTZERNAME]]

en:  as user "%s"
de:  als Benutzer »%s«

en:  at port "%s"
de:  auf Port »%s«

en:  on host "%s"
de:  auf Host »%s«

en: %d connection | %d connections
de[0]: %d Verbindung
de[1]: %d Verbindungen

en: %s (%s, server %s)
de: %s (%s, Server %s)

en: %s: cannot copy from/to a directory
de: %s: ein Verzeichnis kann nicht kopiert werden

en: %s: could not delete variable "%s"
de: %s: konnte Variable »%s« nicht löschen

en: %s: could not open log file "%s": %s
de: %s: konnte Logdatei »%s« nicht öffnen: %s

en: %s: could not set printing parameter "%s"
de: %s: konnte Ausgabeparameter »%s« nicht setzen

en: %s: could not set variable "%s"
de: %s: konnte Variable »%s« nicht setzen

en: %s: current transaction is aborted
de: %s: aktuelle Transaktion is abgebrochen

en: %s: invalid encoding name or conversion procedure not found
de: %s: ungültiger Kodierungsname oder Umwandlungsprozedur nicht gefunden

en: %s: not connected to a database
de: %s: nicht mit einer Datenbank verbunden

en: %s: pg_strdup: cannot duplicate null pointer (internal error)
de: %s: pg_strdup: kann NULL-Zeiger nicht kopieren (interner Fehler)

en: %s: unknown transaction status
de: %s: unbekannter Transaktionsstatus

en: %s: warning: extra command-line argument "%s" ignored
de: %s: Warnung: überflüssiges Kommandozeilenargument »%s« ignoriert

en: (%lu row) | (%lu rows)
de[0]: (%lu Zeile)
de[1]: (%lu Zeilen)

en: (No rows)
de: (keine Zeilen)

en: ***(Single step mode: verify command)*******************************************
    %s
    ***(press return to proceed or enter x and return to cancel)********************
de: ***(Einzelschrittmodus: Anfrage bestätigen)*************************************
    %s
    ***(Drücken Sie die Eingabetaste um fortzufahren oder »x« um abzubrechen)*******

en: ********* QUERY **********
    %s
    **************************
de: ******** ANFRAGE *********
    %s
    **************************

en: , clustered
de: , geclustert

en: , invalid
de: , ungültig

en: , predicate (%s)
de: , Prädikat (%s)

en: , tablespace "%s"
de: , Tablespace »%s«

en: ALTER AGGREGATE name ( type [ , ... ] ) RENAME TO new_name
    ALTER AGGREGATE name ( type [ , ... ] ) OWNER TO new_owner
    ALTER AGGREGATE name ( type [ , ... ] ) SET SCHEMA new_schema
de: ALTER AGGREGATE name ( typ [ , ... ] ) RENAME TO neuer_name
    ALTER AGGREGATE name ( typ [ , ... ] ) OWNER TO neuer_eigentümer
    ALTER AGGREGATE name ( typ [ , ... ] ) SET SCHEMA neues_schema

en: ALTER CONVERSION name RENAME TO newname
    ALTER CONVERSION name OWNER TO newowner
de: ALTER CONVERSION name RENAME TO neuer_name
    ALTER CONVERSION name OWNER TO neuer_eigentümer

en: ALTER DATABASE name [ [ WITH ] option [ ... ] ]
    
    where option can be:
    
        CONNECTION LIMIT connlimit
    
    ALTER DATABASE name RENAME TO newname
    
    ALTER DATABASE name OWNER TO new_owner
    
    ALTER DATABASE name SET TABLESPACE new_tablespace
    
    ALTER DATABASE name SET configuration_parameter { TO | = } { value | DEFAULT }
    ALTER DATABASE name SET configuration_parameter FROM CURRENT
    ALTER DATABASE name RESET configuration_parameter
    ALTER DATABASE name RESET ALL
de: ALTER DATABASE name [ [ WITH ] option [ ... ] ]
    
    wobei option Folgendes sein kann:
    
        CONNECTION LIMIT verbindungslimit
    
    ALTER DATABASE name RENAME TO neuer_name
    
    ALTER DATABASE name OWNER TO neuer_eigentümer
    
    ALTER DATABASE name SET TABLESPACE neuer_tablespace
    
    ALTER DATABASE name SET konfigurationsparameter { TO | = } { wert | DEFAULT }
    ALTER DATABASE name SET konfigurationsparameter FROM CURRENT
    ALTER DATABASE name RESET konfigurationsparameter
    ALTER DATABASE name RESET ALL

en: ALTER DOMAIN name
        { SET DEFAULT expression | DROP DEFAULT }
    ALTER DOMAIN name
        { SET | DROP } NOT NULL
    ALTER DOMAIN name
        ADD domain_constraint
    ALTER DOMAIN name
        DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
    ALTER DOMAIN name
        OWNER TO new_owner 
    ALTER DOMAIN name
        SET SCHEMA new_schema
de: ALTER DOMAIN name
        { SET DEFAULT ausdruck | DROP DEFAULT }
    ALTER DOMAIN name
        { SET | DROP } NOT NULL
    ALTER DOMAIN name
        ADD domänen_constraint
    ALTER DOMAIN name
        DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
    ALTER DOMAIN name
        OWNER TO neuer_eigentümer 
    ALTER DOMAIN name
        SET SCHEMA neues_schema

en: ALTER FOREIGN DATA WRAPPER name
        [ VALIDATOR valfunction | NO VALIDATOR ]
        [ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ]) ]
    ALTER FOREIGN DATA WRAPPER name OWNER TO new_owner
de: ALTER FOREIGN DATA WRAPPER name
        [ VALIDATOR valfunktion | NO VALIDATOR ]
        [ OPTIONS ( [ ADD | SET | DROP ] option ['wert'] [, ... ]) ]
    ALTER FOREIGN DATA WRAPPER name OWNER TO neuer_eigentümer

en: ALTER FUNCTION name ( [ [ argmode ] [ argname ] argtype [, ...] ] )
        action [ ... ] [ RESTRICT ]
    ALTER FUNCTION name ( [ [ argmode ] [ argname ] argtype [, ...] ] )
        RENAME TO new_name
    ALTER FUNCTION name ( [ [ argmode ] [ argname ] argtype [, ...] ] )
        OWNER TO new_owner
    ALTER FUNCTION name ( [ [ argmode ] [ argname ] argtype [, ...] ] )
        SET SCHEMA new_schema
    
    where action is one of:
    
        CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
        IMMUTABLE | STABLE | VOLATILE
        [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
        COST execution_cost
        ROWS result_rows
        SET configuration_parameter { TO | = } { value | DEFAULT }
        SET configuration_parameter FROM CURRENT
        RESET configuration_parameter
        RESET ALL
de: ALTER FUNCTION name ( [ [ argmodus ] [ argname ] argtyp [, ...] ] )
        aktion [, ... ] [ RESTRICT ]
    ALTER FUNCTION name ( [ [ argmodus ] [ argname ] argtyp [, ...] ] )
        RENAME TO neuer_name
    ALTER FUNCTION name ( [ [ argmodus ] [ argname ] argtyp [, ...] ] )
        OWNER TO neuer_eigentümer
    ALTER FUNCTION name ( [ [ argmodus ] [ argname ] argtyp [, ...] ] )
        SET SCHEMA neues_schema
    
    wobei aktion Folgendes sein kann:
    
        CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
        IMMUTABLE | STABLE | VOLATILE
        [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
        COST ausführungskosten
        ROWS ergebniszeilen
        SET konfigurationsparameter { TO | = } { wert | DEFAULT }
        SET konfigurationsparameter FROM CURRENT
        RESET konfigurationsparameter
        RESET ALL

en: ALTER GROUP groupname ADD USER username [, ... ]
    ALTER GROUP groupname DROP USER username [, ... ]
    
    ALTER GROUP groupname RENAME TO newname
de: ALTER GROUP gruppenname ADD USER benutzername [, ... ]
    ALTER GROUP gruppenname DROP USER benutzername [, ... ]
    
    ALTER GROUP gruppenname RENAME TO neuer_name

en: ALTER INDEX name RENAME TO new_name
    ALTER INDEX name SET TABLESPACE tablespace_name
    ALTER INDEX name SET ( storage_parameter = value [, ... ] )
    ALTER INDEX name RESET ( storage_parameter [, ... ] )
de: ALTER INDEX name RENAME TO neuer_name
    ALTER INDEX name SET TABLESPACE tablespace_name
    ALTER INDEX name SET ( storage_parameter = wert [, ... ] )
    ALTER INDEX name RESET ( storage_parameter [, ... ] )

en: ALTER OPERATOR CLASS name USING index_method RENAME TO newname
    ALTER OPERATOR CLASS name USING index_method OWNER TO newowner
de: ALTER OPERATOR CLASS name USING indexmethode RENAME TO neuer_name
    ALTER OPERATOR CLASS name USING indexmethode OWNER TO neuer_eigentümer

en: ALTER OPERATOR FAMILY name USING index_method ADD
      {  OPERATOR strategy_number operator_name ( op_type, op_type )
       | FUNCTION support_number [ ( op_type [ , op_type ] ) ] funcname ( argument_type [, ...] )
      } [, ... ]
    ALTER OPERATOR FAMILY name USING index_method DROP
      {  OPERATOR strategy_number ( op_type [ , op_type ] )
       | FUNCTION support_number ( op_type [ , op_type ] )
      } [, ... ]
    ALTER OPERATOR FAMILY name USING index_method RENAME TO newname
    ALTER OPERATOR FAMILY name USING index_method OWNER TO newowner
de: ALTER OPERATOR FAMILY name USING indexmethode ADD
      {  OPERATOR strategienummer operatorname ( optyp, optyp )
       | FUNCTION supportnummer [ ( optyp [ , optyp ] ) ] funkname ( argumenttyp [, ...] )
      } [, ... ]
    ALTER OPERATOR FAMILY name USING indexmethode DROP
      {  OPERATOR strategienummer ( optyp [ , optyp ] )
       | FUNCTION supportnummer ( optyp [ , optyp ] )
      } [, ... ]
    ALTER OPERATOR FAMILY name USING indexmethode RENAME TO neuer_name
    ALTER OPERATOR FAMILY name USING indexmethode OWNER TO neuer_eigentümer

en: ALTER OPERATOR name ( { lefttype | NONE } , { righttype | NONE } ) OWNER TO newowner
de: ALTER OPERATOR name ( { linker_typ | NONE } , { rechter_typ | NONE } ) OWNER TO neuer_eigentümer

en: ALTER ROLE name [ [ WITH ] option [ ... ] ]
    
    where option can be:
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT connlimit
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
        | VALID UNTIL 'timestamp' 
    
    ALTER ROLE name RENAME TO newname
    
    ALTER ROLE name SET configuration_parameter { TO | = } { value | DEFAULT }
    ALTER ROLE name SET configuration_parameter FROM CURRENT
    ALTER ROLE name RESET configuration_parameter
    ALTER ROLE name RESET ALL
de: ALTER ROLE name [ [ WITH ] option [ ... ] ]
    
    wobei option Folgendes sein kann:
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT verbindungslimit
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'passwort'
        | VALID UNTIL 'zeit' 
    
    ALTER ROLE name RENAME TO neuer_name
    
    ALTER ROLE name SET konfigurationsparameter { TO | = } { wert | DEFAULT }
    ALTER ROLE name SET konfigurationsparameter FROM CURRENT
    ALTER ROLE name RESET konfigurationsparameter
    ALTER ROLE name RESET ALL

en: ALTER SCHEMA name RENAME TO newname
    ALTER SCHEMA name OWNER TO newowner
de: ALTER SCHEMA name RENAME TO neuer_name
    ALTER SCHEMA name OWNER TO neuer_eigentümer

en: ALTER SEQUENCE name [ INCREMENT [ BY ] increment ]
        [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
        [ START [ WITH ] start ]
        [ RESTART [ [ WITH ] restart ] ]
        [ CACHE cache ] [ [ NO ] CYCLE ]
        [ OWNED BY { table.column | NONE } ]
    ALTER SEQUENCE name OWNER TO new_owner
    ALTER SEQUENCE name RENAME TO new_name
    ALTER SEQUENCE name SET SCHEMA new_schema
de: ALTER SEQUENCE name [ INCREMENT [ BY ] inkrement ]
        [ MINVALUE minwert | NO MINVALUE ] [ MAXVALUE maxwert | NO MAXVALUE ]
        [ START [ WITH ] start ]
        [ RESTART [ WITH ] start ]
        [ CACHE cache ] [ [ NO ] CYCLE ]
        [ OWNED BY { tabelle.spalte | NONE } ]
    ALTER SEQUENCE name OWNER TO neuer_eigentümer
    ALTER SEQUENCE name RENAME TO neuer_name
    ALTER SEQUENCE name SET SCHEMA neues_schema

en: ALTER SERVER servername [ VERSION 'newversion' ]
        [ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] ) ]
    ALTER SERVER servername OWNER TO new_owner
de: ALTER SERVER servername [ VERSION 'neue_version' ]
        [ OPTIONS ( [ ADD | SET | DROP ] option ['wert'] [, ... ] ) ]
    ALTER SERVER servername OWNER TO neuer_eigentümer

en: ALTER TABLE [ ONLY ] name [ * ]
        action [, ... ]
    ALTER TABLE [ ONLY ] name [ * ]
        RENAME [ COLUMN ] column TO new_column
    ALTER TABLE name
        RENAME TO new_name
    ALTER TABLE name
        SET SCHEMA new_schema
    
    where action is one of:
    
        ADD [ COLUMN ] column type [ column_constraint [ ... ] ]
        DROP [ COLUMN ] column [ RESTRICT | CASCADE ]
        ALTER [ COLUMN ] column [ SET DATA ] TYPE type [ USING expression ]
        ALTER [ COLUMN ] column SET DEFAULT expression
        ALTER [ COLUMN ] column DROP DEFAULT
        ALTER [ COLUMN ] column { SET | DROP } NOT NULL
        ALTER [ COLUMN ] column SET STATISTICS integer
        ALTER [ COLUMN ] column SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN }
        ADD table_constraint
        DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
        DISABLE TRIGGER [ trigger_name | ALL | USER ]
        ENABLE TRIGGER [ trigger_name | ALL | USER ]
        ENABLE REPLICA TRIGGER trigger_name
        ENABLE ALWAYS TRIGGER trigger_name
        DISABLE RULE rewrite_rule_name
        ENABLE RULE rewrite_rule_name
        ENABLE REPLICA RULE rewrite_rule_name
        ENABLE ALWAYS RULE rewrite_rule_name
        CLUSTER ON index_name
        SET WITHOUT CLUSTER
        SET WITH OIDS
        SET WITHOUT OIDS
        SET ( storage_parameter = value [, ... ] )
        RESET ( storage_parameter [, ... ] )
        INHERIT parent_table
        NO INHERIT parent_table
        OWNER TO new_owner
        SET TABLESPACE new_tablespace
de: ALTER TABLE [ ONLY ] name [ * ]
        aktion [, ... ]
    ALTER TABLE [ ONLY ] name [ * ]
        RENAME [ COLUMN ] spalte TO neue_spalte
    ALTER TABLE name
        RENAME TO neuer_name
    ALTER TABLE name
        SET SCHEMA neues_schema
    
    wobei aktion Folgendes sein kann:
    
        ADD [ COLUMN ] spalte typ [ spalten_constraint [ ... ] ]
        DROP [ COLUMN ] spalte [ RESTRICT | CASCADE ]
        ALTER [ COLUMN ] spalte [ SET DATA ] TYPE typ [ USING ausdruck ]
        ALTER [ COLUMN ] spalte SET DEFAULT ausdruck
        ALTER [ COLUMN ] spalte DROP DEFAULT
        ALTER [ COLUMN ] spalte { SET | DROP } NOT NULL
        ALTER [ COLUMN ] spalte SET STATISTICS integer
        ALTER [ COLUMN ] spalte SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN }
        ADD tabellen_constraint
        DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
        DISABLE TRIGGER [ trigger_name | ALL | USER ]
        ENABLE TRIGGER [ trigger_name | ALL | USER ]
        ENABLE REPLICA TRIGGER triggername
        ENABLE ALWAYS TRIGGER triggername
        DISABLE RULE regelname
        ENABLE RULE regelname
        ENABLE REPLICA RULE regelname
        ENABLE ALWAYS RULE regelname
        CLUSTER ON index_name
        SET WITHOUT CLUSTER
        SET WITHOUT OIDS
        SET ( storage_parameter = wert [, ... ] )
        RESET ( storage_parameter [, ... ] )
        INHERIT vatertabelle
        NO INHERIT vatertabelle
        OWNER TO neuer_eigentümer
        SET TABLESPACE tablespace_name

en: ALTER TABLESPACE name RENAME TO newname
    ALTER TABLESPACE name OWNER TO newowner
de: ALTER TABLESPACE name RENAME TO neuer_name
    ALTER TABLESPACE name OWNER TO neuer_eigentümer

en: ALTER TEXT SEARCH CONFIGURATION name
        ADD MAPPING FOR token_type [, ... ] WITH dictionary_name [, ... ]
    ALTER TEXT SEARCH CONFIGURATION name
        ALTER MAPPING FOR token_type [, ... ] WITH dictionary_name [, ... ]
    ALTER TEXT SEARCH CONFIGURATION name
        ALTER MAPPING REPLACE old_dictionary WITH new_dictionary
    ALTER TEXT SEARCH CONFIGURATION name
        ALTER MAPPING FOR token_type [, ... ] REPLACE old_dictionary WITH new_dictionary
    ALTER TEXT SEARCH CONFIGURATION name
        DROP MAPPING [ IF EXISTS ] FOR token_type [, ... ]
    ALTER TEXT SEARCH CONFIGURATION name RENAME TO newname
    ALTER TEXT SEARCH CONFIGURATION name OWNER TO newowner
de: ALTER TEXT SEARCH CONFIGURATION name
        ADD MAPPING FOR tokentyp [, ... ] WITH wörterbuchname [, ... ]
    ALTER TEXT SEARCH CONFIGURATION name
        ALTER MAPPING FOR tokentyp [, ... ] WITH wörterbuchname [, ... ]
    ALTER TEXT SEARCH CONFIGURATION name
        ALTER MAPPING REPLACE altes_wörterbuch WITH neues_wörterbuch
    ALTER TEXT SEARCH CONFIGURATION name
        ALTER MAPPING FOR tokentyp [, ... ] REPLACE altes_wörterbuch WITH neues_wörterbuch
    ALTER TEXT SEARCH CONFIGURATION name
        DROP MAPPING [ IF EXISTS ] FOR tokentyp [, ... ]
    ALTER TEXT SEARCH CONFIGURATION name RENAME TO neuer_name
    ALTER TEXT SEARCH CONFIGURATION name OWNER TO neuer_eigentümer

en: ALTER TEXT SEARCH DICTIONARY name (
        option [ = value ] [, ... ]
    )
    ALTER TEXT SEARCH DICTIONARY name RENAME TO newname
    ALTER TEXT SEARCH DICTIONARY name OWNER TO newowner
de: ALTER TEXT SEARCH DICTIONARY name (
        option [ = wert ] [, ... ]
    )
    ALTER TEXT SEARCH DICTIONARY name RENAME TO neuer_name
    ALTER TEXT SEARCH DICTIONARY name OWNER TO neuer_eigentümer

en: ALTER TEXT SEARCH PARSER name RENAME TO newname
de: ALTER TEXT SEARCH PARSER name RENAME TO neuer_name

en: ALTER TEXT SEARCH TEMPLATE name RENAME TO newname
de: ALTER TEXT SEARCH TEMPLATE name RENAME TO neuer_name

en: ALTER TRIGGER name ON table RENAME TO newname
de: ALTER TRIGGER name ON tabelle RENAME TO neuer_name

en: ALTER TYPE name RENAME TO new_name
    ALTER TYPE name OWNER TO new_owner 
    ALTER TYPE name SET SCHEMA new_schema
de: ALTER TYPE name RENAME TO neuer_name
    ALTER TYPE name OWNER TO neuer_eigentümer
    ALTER TYPE name SET SCHEMA neues_schema

en: ALTER USER MAPPING FOR { username | USER | CURRENT_USER | PUBLIC }
        SERVER servername
        OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
de: ALTER USER MAPPING FOR { benutzername | USER | CURRENT_USER | PUBLIC }
        SERVER servername
        OPTIONS ( [ ADD | SET | DROP ] option ['wert'] [, ... ] )

en: ALTER USER name [ [ WITH ] option [ ... ] ]
    
    where option can be:
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT connlimit
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
        | VALID UNTIL 'timestamp' 
    
    ALTER USER name RENAME TO newname
    
    ALTER USER name SET configuration_parameter { TO | = } { value | DEFAULT }
    ALTER USER name SET configuration_parameter FROM CURRENT
    ALTER USER name RESET configuration_parameter
    ALTER USER name RESET ALL
de: ALTER USER name [ [ WITH ] option [ ... ] ]
    
    wobei option Folgendes sein kann:
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT verbindungslimit
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'passwort'
        | VALID UNTIL 'zeit' 
    
    ALTER USER name RENAME TO neuer_name
    
    ALTER USER name SET konfigurationsparameter { TO | = } { wert | DEFAULT }
    ALTER USER name SET konfigurationsparameter FROM CURRENT
    ALTER USER name RESET konfigurationsparameter
    ALTER USER name RESET ALL

en: ALTER VIEW name ALTER [ COLUMN ] column SET DEFAULT expression
    ALTER VIEW name ALTER [ COLUMN ] column DROP DEFAULT
    ALTER VIEW name OWNER TO new_owner
    ALTER VIEW name RENAME TO new_name
    ALTER VIEW name SET SCHEMA new_schema
de: ALTER VIEW name ALTER [ COLUMN ] spalte SET DEFAULT ausdruck
    ALTER VIEW name ALTER [ COLUMN ] spalte DROP DEFAULT
    ALTER VIEW name OWNER TO neuer_eigentümer
    ALTER VIEW name RENAME TO neuer_name
    ALTER VIEW name SET SCHEMA neues_schema

en: ALTER [ PROCEDURAL ] LANGUAGE name RENAME TO newname
    ALTER [ PROCEDURAL ] LANGUAGE name OWNER TO new_owner
de: ALTER [ PROCEDURAL ] LANGUAGE name RENAME TO neuer_name
    ALTER [ PROCEDURAL ] LANGUAGE name OWNER TO neuer_eigentümer

en: ANALYZE [ VERBOSE ] [ table [ ( column [, ...] ) ] ]
de: ANALYZE [ VERBOSE ] [ tabelle [ ( spalte [, ...] ) ] ]

en: Access privileges
de: Zugriffsprivilegien

en: Argument data types
de: Argumentdatentypen

en: Asynchronous notification "%s" received from server process with PID %d.
de: Asynchrone Benachrichtigung »%s« vom Serverprozess mit PID %d empfangen.

en: Attributes
de: Attribute

en: Available help:
de: Verfügbare Hilfe:

en: BEGIN [ WORK | TRANSACTION ] [ transaction_mode [, ...] ]
    
    where transaction_mode is one of:
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY
de: BEGIN [ WORK | TRANSACTION ] [ transaktionsmodus [, ...] ]
    
    wobei Transaktionsmodus Folgendes sein kann:
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY

en: Border style is %d.
de: Rahmenstil ist %d.

en: CLUSTER [VERBOSE] tablename [ USING indexname ]
    CLUSTER [VERBOSE]
de: CLUSTER [VERBOSE] tabellenname [ USING indexname ]
    CLUSTER [VERBOSE]

en: COMMENT ON
    {
      TABLE object_name |
      COLUMN table_name.column_name |
      AGGREGATE agg_name (agg_type [, ...] ) |
      CAST (sourcetype AS targettype) |
      CONSTRAINT constraint_name ON table_name |
      CONVERSION object_name |
      DATABASE object_name |
      DOMAIN object_name |
      FUNCTION func_name ( [ [ argmode ] [ argname ] argtype [, ...] ] ) |
      INDEX object_name |
      LARGE OBJECT large_object_oid |
      OPERATOR op (leftoperand_type, rightoperand_type) |
      OPERATOR CLASS object_name USING index_method |
      OPERATOR FAMILY object_name USING index_method |
      [ PROCEDURAL ] LANGUAGE object_name |
      ROLE object_name |
      RULE rule_name ON table_name |
      SCHEMA object_name |
      SEQUENCE object_name |
      TABLESPACE object_name |
      TEXT SEARCH CONFIGURATION object_name |
      TEXT SEARCH DICTIONARY object_name |
      TEXT SEARCH PARSER object_name |
      TEXT SEARCH TEMPLATE object_name |
      TRIGGER trigger_name ON table_name |
      TYPE object_name |
      VIEW object_name
    } IS 'text'
de: COMMENT ON
    {
      TABLE objektname |
      COLUMN tabellenname.spaltenname |
      AGGREGATE aggname (aggtyp [, ...] ) |
      CAST (quelltyp AS zieltyp) |
      CONSTRAINT constraintname ON tabellenname |
      CONVERSION objektname |
      DATABASE objektname |
      DOMAIN objektname |
      FUNCTION funkname ( [ [ argmodus ] [ argname ]  argtyp [, ...] ] ) |
      INDEX objektname |
      LARGE OBJECT large_object_oid |
      OPERATOR op (linker_op_typ, rechter_op_typ) |
      OPERATOR CLASS objektname USING indexmethode |
      OPERATOR FAMILY objektname USING indexmethode |
      [ PROCEDURAL ] LANGUAGE objektname |
      ROLE objektname |
      RULE regelname ON tabellenname |
      SCHEMA objektname |
      SEQUENCE objektname |
      TABLESPACE objektname |
      TEXT SEARCH CONFIGURATION objektname |
      TEXT SEARCH DICTIONARY objektname |
      TEXT SEARCH PARSER objektname |
      TEXT SEARCH TEMPLATE objektname |
      TRIGGER triggername ON tabellenname |
      TYPE objektname |
      VIEW objektname
    } IS 'text'

en: COMMIT PREPARED transaction_id
de: COMMIT PREPARED transaktions_id

en: COPY data transfer failed: %s
de: Datentransfer mit COPY fehlgeschlagen: %s

en: COPY tablename [ ( column [, ...] ) ]
        FROM { 'filename' | STDIN }
        [ [ WITH ] 
              [ BINARY ]
              [ OIDS ]
              [ DELIMITER [ AS ] 'delimiter' ]
              [ NULL [ AS ] 'null string' ]
              [ CSV [ HEADER ]
                    [ QUOTE [ AS ] 'quote' ] 
                    [ ESCAPE [ AS ] 'escape' ]
                    [ FORCE NOT NULL column [, ...] ]
    
    COPY { tablename [ ( column [, ...] ) ] | ( query ) }
        TO { 'filename' | STDOUT }
        [ [ WITH ] 
              [ BINARY ]
              [ OIDS ]
              [ DELIMITER [ AS ] 'delimiter' ]
              [ NULL [ AS ] 'null string' ]
              [ CSV [ HEADER ]
                    [ QUOTE [ AS ] 'quote' ] 
                    [ ESCAPE [ AS ] 'escape' ]
                    [ FORCE QUOTE column [, ...] ]
de: COPY tabellenname [ ( spalte [, ...] ) ]
        FROM { 'dateiname' | STDIN }
        [ [ WITH ] 
              [ BINARY ]
              [ OIDS ]
              [ DELIMITER [ AS ] 'trennzeichen' ]
              [ NULL [ AS ] 'null-zeichenkette' ]
              [ CSV [ HEADER ]
                    [ QUOTE [ AS ] 'quote' ] 
                    [ ESCAPE [ AS ] 'escape' ]
                    [ FORCE NOT NULL spalte [, ...] ]
    
    COPY { tabellenname [ ( spalte [, ...] ) ] | ( anfrage ) }
        TO { 'dateiname' | STDOUT }
        [ [ WITH ] 
              [ BINARY ]
              [ OIDS ]
              [ DELIMITER [ AS ] 'trennzeichen' ]
              [ NULL [ AS ] 'null-zeichenkette' ]
              [ CSV [ HEADER ]
                    [ QUOTE [ AS ] 'quote' ] 
                    [ ESCAPE [ AS ] 'escape' ]
                    [ FORCE QUOTE spalte [, ...] ]

en: CREATE AGGREGATE name ( input_data_type [ , ... ] ) (
        SFUNC = sfunc,
        STYPE = state_data_type
        [ , FINALFUNC = ffunc ]
        [ , INITCOND = initial_condition ]
        [ , SORTOP = sort_operator ]
    )
    
    or the old syntax
    
    CREATE AGGREGATE name (
        BASETYPE = base_type,
        SFUNC = sfunc,
        STYPE = state_data_type
        [ , FINALFUNC = ffunc ]
        [ , INITCOND = initial_condition ]
        [ , SORTOP = sort_operator ]
    )
de: CREATE AGGREGATE name ( eingabedatentyp [ , ... ] ) (
        SFUNC = übergangsfunktion,
        STYPE = zustandsdatentyp
        [ , FINALFUNC = abschlussfunktion ]
        [ , INITCOND = anfangswert ]
        [ , SORTOP = sortieroperator ]
    )
    
    oder die alte Syntax
    
    CREATE AGGREGATE name (
        BASETYPE = eingabedatentyp,
        SFUNC = übergangsfunktion,
        STYPE = zustandsdatentyp
        [ , FINALFUNC = abschlussfunktion ]
        [ , INITCOND = anfangswert ]
        [ , SORTOP = sortieroperator ]
    )

en: CREATE CAST (sourcetype AS targettype)
        WITH FUNCTION funcname (argtypes)
        [ AS ASSIGNMENT | AS IMPLICIT ]
    
    CREATE CAST (sourcetype AS targettype)
        WITHOUT FUNCTION
        [ AS ASSIGNMENT | AS IMPLICIT ]
    
    CREATE CAST (sourcetype AS targettype)
        WITH INOUT
        [ AS ASSIGNMENT | AS IMPLICIT ]
de: CREATE CAST (quelltyp AS zieltyp)
        WITH FUNCTION funktionsname (argumenttypen)
        [ AS ASSIGNMENT | AS IMPLICIT ]
    
    CREATE CAST (quelltyp AS zieltyp)
        WITHOUT FUNCTION
        [ AS ASSIGNMENT | AS IMPLICIT ]
    
    CREATE CAST (quelltyp AS zieltyp)
        WITH INOUT
        [ AS ASSIGNMENT | AS IMPLICIT ]

en: CREATE CONSTRAINT TRIGGER name
        AFTER event [ OR ... ]
        ON table_name
        [ FROM referenced_table_name ]
        { NOT DEFERRABLE | [ DEFERRABLE ] { INITIALLY IMMEDIATE | INITIALLY DEFERRED } }
        FOR EACH ROW
        EXECUTE PROCEDURE funcname ( arguments )
de: CREATE CONSTRAINT TRIGGER name
        AFTER ereignis [ OR ... ]
        ON tabellenname
        [ FROM verwiesener_tabellenname ]
        { NOT DEFERRABLE | [ DEFERRABLE ] { INITIALLY IMMEDIATE | INITIALLY DEFERRED } }
        FOR EACH ROW
        EXECUTE PROCEDURE funktionsname ( argumente )

en: CREATE DATABASE name
        [ [ WITH ] [ OWNER [=] dbowner ]
               [ TEMPLATE [=] template ]
               [ ENCODING [=] encoding ]
               [ LC_COLLATE [=] lc_collate ]
               [ LC_CTYPE [=] lc_ctype ]
               [ TABLESPACE [=] tablespace ]
               [ CONNECTION LIMIT [=] connlimit ] ]
de: CREATE DATABASE name
        [ [ WITH ] [ OWNER [=] eigentümer ]
               [ TEMPLATE [=] template ]
               [ ENCODING [=] kodierung ]
               [ LC_COLLATE [=] lc_collate ]
               [ LC_CTYPE [=] lc_ctype ]
               [ TABLESPACE [=] tablespace ]
               [ CONNECTION LIMIT [=] verbindungslimit ] ]

en: CREATE DOMAIN name [ AS ] data_type
        [ DEFAULT expression ]
        [ constraint [ ... ] ]
    
    where constraint is:
    
    [ CONSTRAINT constraint_name ]
    { NOT NULL | NULL | CHECK (expression) }
de: CREATE DOMAIN name [ AS ] datentyp
        [ DEFAULT ausdruck ]
        [ constraint [ ... ] ]
    
    wobei constraint Folgendes ist:
    
    [ CONSTRAINT constraint_name ]
    { NOT NULL | NULL | CHECK (ausdruck) }

en: CREATE FOREIGN DATA WRAPPER name
        [ VALIDATOR valfunction | NO VALIDATOR ]
        [ OPTIONS ( option 'value' [, ... ] ) ]
de: CREATE FOREIGN DATA WRAPPER name
        [ VALIDATOR valfunktion | NO VALIDATOR ]
        [ OPTIONS ( option 'wert' [, ... ] ) ]

en: CREATE GROUP name [ [ WITH ] option [ ... ] ]
    
    where option can be:
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
        | VALID UNTIL 'timestamp' 
        | IN ROLE rolename [, ...]
        | IN GROUP rolename [, ...]
        | ROLE rolename [, ...]
        | ADMIN rolename [, ...]
        | USER rolename [, ...]
        | SYSID uid
de: CREATE GROUP name [ [ WITH ] option [ ... ] ]
    
    wobei option Folgendes sein kann:
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'passwort'
        | VALID UNTIL 'zeit' 
        | IN ROLE rollenname [, ...]
        | IN GROUP rollenname [, ...]
        | ROLE rollenname [, ...]
        | ADMIN rollenname [, ...]
        | USER rollenname [, ...]
        | SYSID uid

en: CREATE OPERATOR CLASS name [ DEFAULT ] FOR TYPE data_type
      USING index_method [ FAMILY family_name ] AS
      {  OPERATOR strategy_number operator_name [ ( op_type, op_type ) ]
       | FUNCTION support_number [ ( op_type [ , op_type ] ) ] funcname ( argument_type [, ...] )
       | STORAGE storage_type
      } [, ... ]
de: CREATE OPERATOR CLASS name [ DEFAULT ] FOR TYPE datentyp
      USING indexmethode [ FAMILY familienname ] AS
      {  OPERATOR strategienummer operatorname [ ( optyp, optyp ) ]
       | FUNCTION unterst_nummer [ ( optyp [, optyp ] ) ] funcname ( argumenttyp [, ...] )
       | STORAGE storage_typ
      } [, ... ]

en: CREATE OPERATOR FAMILY name USING index_method
de: CREATE OPERATOR FAMILY name USING indexmethode

en: CREATE OPERATOR name (
        PROCEDURE = funcname
        [, LEFTARG = lefttype ] [, RIGHTARG = righttype ]
        [, COMMUTATOR = com_op ] [, NEGATOR = neg_op ]
        [, RESTRICT = res_proc ] [, JOIN = join_proc ]
        [, HASHES ] [, MERGES ]
    )
de: CREATE OPERATOR name (
        PROCEDURE = funktionsname
        [, LEFTARG = linker_typ ] [, RIGHTARG = rechter_typ ]
        [, COMMUTATOR = kommutator_op ] [, NEGATOR = umkehrungs_op ]
        [, RESTRICT = res_funktion ] [, JOIN = join_funktion ]
        [, HASHES ] [, MERGES ]
    )

en: CREATE ROLE name [ [ WITH ] option [ ... ] ]
    
    where option can be:
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT connlimit
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
        | VALID UNTIL 'timestamp' 
        | IN ROLE rolename [, ...]
        | IN GROUP rolename [, ...]
        | ROLE rolename [, ...]
        | ADMIN rolename [, ...]
        | USER rolename [, ...]
        | SYSID uid
de: CREATE ROLE name [ [ WITH ] option [ ... ] ]
    
    wobei option Folgendes sein kann:
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT verbindungslimit
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'passwort'
        | VALID UNTIL 'zeit' 
        | IN ROLE rollenname [, ...]
        | IN GROUP rollenname [, ...]
        | ROLE rollenname [, ...]
        | ADMIN rollenname [, ...]
        | USER rollenname [, ...]
        | SYSID uid

en: CREATE SCHEMA schemaname [ AUTHORIZATION username ] [ schema_element [ ... ] ]
    CREATE SCHEMA AUTHORIZATION username [ schema_element [ ... ] ]
de: CREATE SCHEMA schemaname [ AUTHORIZATION benutzername ] [ schemaelement [ ... ] ]
    CREATE SCHEMA AUTHORIZATION benutzername [ schemaelement [ ... ] ]

en: CREATE SERVER servername [ TYPE 'servertype' ] [ VERSION 'serverversion' ]
        FOREIGN DATA WRAPPER fdwname
        [ OPTIONS ( option 'value' [, ... ] ) ]
de: CREATE SERVER servername [ TYPE 'servertyp' ] [ VERSION 'serverversion' ]
        FOREIGN DATA WRAPPER fdwname
        [ OPTIONS ( option 'wert' [, ... ] ) ]

en: CREATE TABLESPACE tablespacename [ OWNER username ] LOCATION 'directory'
de: CREATE TABLESPACE tablespacename [ OWNER benutzername ] LOCATION 'verzeichnis'

en: CREATE TEXT SEARCH CONFIGURATION name (
        PARSER = parser_name |
        COPY = source_config
    )
de: CREATE TEXT SEARCH CONFIGURATION name (
        PARSER = parsername |
        COPY = quellkonfig
    )

en: CREATE TEXT SEARCH DICTIONARY name (
        TEMPLATE = template
        [, option = value [, ... ]]
    )
de: CREATE TEXT SEARCH DICTIONARY name (
        TEMPLATE = vorlage
        [, option = wert [, ... ]]
    )

en: CREATE TEXT SEARCH PARSER name (
        START = start_function ,
        GETTOKEN = gettoken_function ,
        END = end_function ,
        LEXTYPES = lextypes_function
        [, HEADLINE = headline_function ]
    )
de: CREATE TEXT SEARCH PARSER name (
        START = startfunktion ,
        GETTOKEN = gettoken_funktion ,
        END = endefunktion ,
        LEXTYPES = lextypenfunktion
        [, HEADLINE = headline_funktion ]
    )

en: CREATE TEXT SEARCH TEMPLATE name (
        [ INIT = init_function , ]
        LEXIZE = lexize_function
    )
de: CREATE TEXT SEARCH TEMPLATE name (
        [ INIT = init_funktion , ]
        LEXIZE = lexize_funktion
    )

en: CREATE TRIGGER name { BEFORE | AFTER } { event [ OR ... ] }
        ON table [ FOR [ EACH ] { ROW | STATEMENT } ]
        EXECUTE PROCEDURE funcname ( arguments )
de: CREATE TRIGGER name { BEFORE | AFTER } { ereignis [ OR ... ] }
        ON tabelle [ FOR [ EACH ] { ROW | STATEMENT } ]
        EXECUTE PROCEDURE funktionsname ( argumente )

en: CREATE TYPE name AS
        ( attribute_name data_type [, ... ] )
    
    CREATE TYPE name AS ENUM
        ( 'label' [, ... ] )
    
    CREATE TYPE name (
        INPUT = input_function,
        OUTPUT = output_function
        [ , RECEIVE = receive_function ]
        [ , SEND = send_function ]
        [ , TYPMOD_IN = type_modifier_input_function ]
        [ , TYPMOD_OUT = type_modifier_output_function ]
        [ , ANALYZE = analyze_function ]
        [ , INTERNALLENGTH = { internallength | VARIABLE } ]
        [ , PASSEDBYVALUE ]
        [ , ALIGNMENT = alignment ]
        [ , STORAGE = storage ]
        [ , LIKE = like_type ]
        [ , CATEGORY = category ]
        [ , PREFERRED = preferred ]
        [ , DEFAULT = default ]
        [ , ELEMENT = element ]
        [ , DELIMITER = delimiter ]
    )
    
    CREATE TYPE name
de: CREATE TYPE name AS
        ( attributname datentyp [, ... ] )
    
    CREATE TYPE name AS ENUM
        ( 'label' [, ... ] )
    
    CREATE TYPE name (
        INPUT = eingabefunktion,
        OUTPUT = ausgabefunktion
        [ , RECEIVE = empfangsfunktion ]
        [ , SEND = sendefunktion ]
        [ , TYPMOD_IN = typmod_eingabefunktion ]
        [ , TYPMOD_OUT = typmod_ausgabefunktion ]
        [ , ANALYZE = analyze_funktion ]
        [ , INTERNALLENGTH = { interne_länge | VARIABLE } ]
        [ , PASSEDBYVALUE ]
        [ , ALIGNMENT = ausrichtung ]
        [ , STORAGE = speicherung ]
        [ , LIKE = wie_typ ]
        [ , CATEGORY = kategorie ]
        [ , PREFERRED = bevorzugt ]
        [ , DEFAULT = vorgabewert ]
        [ , ELEMENT = element ]
        [ , DELIMITER = trennzeichen ]
    )
    
    CREATE TYPE name

en: CREATE USER MAPPING FOR { username | USER | CURRENT_USER | PUBLIC }
        SERVER servername
        [ OPTIONS ( option 'value' [ , ... ] ) ]
de: CREATE USER MAPPING FOR { benutzername | USER | CURRENT_USER | PUBLIC }
        SERVER servername
        [ OPTIONS ( option 'wert' [ , ... ] ) ]

en: CREATE USER name [ [ WITH ] option [ ... ] ]
    
    where option can be:
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT connlimit
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
        | VALID UNTIL 'timestamp' 
        | IN ROLE rolename [, ...]
        | IN GROUP rolename [, ...]
        | ROLE rolename [, ...]
        | ADMIN rolename [, ...]
        | USER rolename [, ...]
        | SYSID uid
de: CREATE USER name [ [ WITH ] option [ ... ] ]
    
    wobei option Folgendes sein kann:
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT verbindungslimit
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'passwort'
        | VALID UNTIL 'zeit' 
        | IN ROLE rollenname [, ...]
        | IN GROUP rollenname [, ...]
        | ROLE rollenname [, ...]
        | ADMIN rollenname [, ...]
        | USER rollenname [, ...]
        | SYSID uid

en: CREATE [ DEFAULT ] CONVERSION name
        FOR source_encoding TO dest_encoding FROM funcname
de: CREATE [ DEFAULT ] CONVERSION name
        FOR quellkodierung TO zielkodierung FROM funktionsname

en: CREATE [ OR REPLACE ] FUNCTION
        name ( [ [ argmode ] [ argname ] argtype [ { DEFAULT | = } defexpr ] [, ...] ] )
        [ RETURNS rettype
          | RETURNS TABLE ( colname coltype [, ...] ) ]
      { LANGUAGE langname
        | WINDOW
        | IMMUTABLE | STABLE | VOLATILE
        | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
        | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
        | COST execution_cost
        | ROWS result_rows
        | SET configuration_parameter { TO value | = value | FROM CURRENT }
        | AS 'definition'
        | AS 'obj_file', 'link_symbol'
      } ...
        [ WITH ( attribute [, ...] ) ]
de: CREATE [ OR REPLACE ] FUNCTION
        name ( [ [ argmode ] [ argname ] argtyp [ { DEFAULT | = } def_ausdruck] [, ...] ] )
        [ RETURNS rückgabetyp
          | RETURNS TABLE ( spaltenname spaltentyp [, ...] ) ]
      { LANGUAGE sprachname
        | WINDOW
        | IMMUTABLE | STABLE | VOLATILE
        | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
        | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
        | COST ausführungskosten
        | ROWS ergebniszeilen
        | SET konfigurationsparameter { TO wert | = wert | FROM CURRENT }
        | AS 'definition'
        | AS 'objektdatei', 'linksymbol'
      } ...
        [ WITH ( attribut [, ...] ) ]

en: CREATE [ OR REPLACE ] RULE name AS ON event
        TO table [ WHERE condition ]
        DO [ ALSO | INSTEAD ] { NOTHING | command | ( command ; command ... ) }
de: CREATE [ OR REPLACE ] RULE name AS ON ereignis
        TO tabelle [ WHERE bedingung ]
        DO [ ALSO | INSTEAD ] { NOTHING | befehl | ( befehl ; befehl ... ) }

en: CREATE [ OR REPLACE ] [ TEMP | TEMPORARY ] VIEW name [ ( column_name [, ...] ) ]
        AS query
de: CREATE [ OR REPLACE ] [ TEMP | TEMPORARY ] VIEW name [ ( spaltenname [, ...] ) ]
        AS anfrage

en: CREATE [ PROCEDURAL ] LANGUAGE name
    CREATE [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
        HANDLER call_handler [ VALIDATOR valfunction ]
de: CREATE [ PROCEDURAL ] LANGUAGE name
    CREATE [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
        HANDLER handler [ VALIDATOR valfunktion ]

en: CREATE [ TEMPORARY | TEMP ] SEQUENCE name [ INCREMENT [ BY ] increment ]
        [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
        [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]
        [ OWNED BY { table.column | NONE } ]
de: CREATE [ TEMPORARY | TEMP ] SEQUENCE name [ INCREMENT [ BY ] inkrement ]
        [ MINVALUE minwert | NO MINVALUE ] [ MAXVALUE maxwert | NO MAXVALUE ]
        [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]
        [ OWNED BY { tabelle.spalte | NONE } ]

en: CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] name ON table [ USING method ]
        ( { column | ( expression ) } [ opclass ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...] )
        [ WITH ( storage_parameter = value [, ... ] ) ]
        [ TABLESPACE tablespace ]
        [ WHERE predicate ]
de: CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] name ON tabelle [ USING methode ]
        ( { spalte | ( ausdruck ) } [ opklasse ] [ ASC | DESC ] [ NULLS { FRIST | LAST } ] [, ...] )
        [ WITH ( storage_parameter = wert [, ... ] ) ]
        [ TABLESPACE tablespace ]
        [ WHERE prädikat ]

en: CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name
        [ (column_name [, ...] ) ]
        [ WITH ( storage_parameter [= value] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
        [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
        [ TABLESPACE tablespace ]
        AS query
        [ WITH [ NO ] DATA ]
de: CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE tabellenname
        [ (spaltenname [, ...] ) ]
        [ WITH ( storage_parameter [= wert] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
        [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
        [ TABLESPACE tablespace ]
        AS anfrage
        [ WITH [ NO ] DATA ]

en: CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name ( [
      { column_name data_type [ DEFAULT default_expr ] [ column_constraint [ ... ] ]
        | table_constraint
        | LIKE parent_table [ { INCLUDING | EXCLUDING } { DEFAULTS | CONSTRAINTS | INDEXES } ] ... }
        [, ... ]
    ] )
    [ INHERITS ( parent_table [, ... ] ) ]
    [ WITH ( storage_parameter [= value] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
    [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
    [ TABLESPACE tablespace ]
    
    where column_constraint is:
    
    [ CONSTRAINT constraint_name ]
    { NOT NULL | 
      NULL | 
      UNIQUE index_parameters |
      PRIMARY KEY index_parameters |
      CHECK ( expression ) |
      REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
        [ ON DELETE action ] [ ON UPDATE action ] }
    [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
    
    and table_constraint is:
    
    [ CONSTRAINT constraint_name ]
    { UNIQUE ( column_name [, ... ] ) index_parameters |
      PRIMARY KEY ( column_name [, ... ] ) index_parameters |
      CHECK ( expression ) |
      FOREIGN KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ... ] ) ]
        [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON UPDATE action ] }
    [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
    
    index_parameters in UNIQUE and PRIMARY KEY constraints are:
    
    [ WITH ( storage_parameter [= value] [, ... ] ) ]
    [ USING INDEX TABLESPACE tablespace ]
de: CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE tabellenname ( [
      { spaltenname datentyp [ DEFAULT default_ausdruck ] [ spalten_constraint [ ... ] ]
        | tabellen_constraint
        | LIKE vatertabelle [ { INCLUDING | EXCLUDING } { DEFAULTS | CONSTRAINTS | INDEXES } ] ... }
        [, ... ]
    ] )
    [ INHERITS ( vatertabelle [, ... ] ) ]
    [ WITH ( storage_parameter [= wert] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
    [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
    [ TABLESPACE tablespace ]
    
    wobei spalten_constraint Folgendes ist:
    
    [ CONSTRAINT constraint_name ]
    { NOT NULL | 
      NULL | 
      UNIQUE indexparameter |
      PRIMARY KEY indexparameter |
      CHECK ( ausdruck ) |
      REFERENCES reftabelle [ ( refspalte ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
        [ ON DELETE action ] [ ON UPDATE aktion ] }
    [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
    
    und tabellen_constraint Folgendes ist:
    
    [ CONSTRAINT constraint_name ]
    { UNIQUE ( spaltenname [, ... ] ) indexparameter |
      PRIMARY KEY ( spaltenname [, ... ] ) indexparameter |
      CHECK ( ausdruck ) |
      FOREIGN KEY ( spaltenname [, ... ] ) REFERENCES reftabelle [ ( refspalte [, ... ] ) ]
        [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE aktion ] [ ON UPDATE aktion ] }
    [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
    
    indexparameter bei UNIQUE und PRIMARY KEY Constraints sind:
    
    [ WITH ( storage_parameter [= wert] [, ... ] ) ]
    [ USING INDEX TABLESPACE tablespace ]

en: Cannot add cell to table content: total cell count of %d exceeded.
de: Cann keine weitere Zelle zur Tabelle hinzufügen: Zellengesamtzahl %d überschritten.

en: Cannot add header to table content: column count of %d exceeded.
de: Kann keinen weiteren Spaltenkopf zur Tabelle hinzufügen: Spaltenzahl %d überschritten.

en: Cannot login
de: kann nicht einloggen

en: Check constraints:
de: Check-Constraints:

en: Collation
de: Sortierfolge

en: Column
de: Spalte

en: Column access privileges
de: Spalten-Zugriffsprivilegien

en: Command:     %s
    Description: %s
    Syntax:
    %s
de: Anweisung:    %s
    Beschreibung: %s
    Syntax:
    %s

en: Composite type "%s.%s"
de: Zusammengesetzter Typ »%s.%s«

en: Connection
de: Verbindung

en: Create DB
de: DB erzeugen

en: Create role
de: Rolle erzeugen

en: Ctype
de: Zeichentyp

en: DECLARE name [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
        CURSOR [ { WITH | WITHOUT } HOLD ] FOR query
de: DECLARE name [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
        CURSOR [ { WITH | WITHOUT } HOLD ] FOR anfrage

en: DELETE FROM [ ONLY ] table [ * ] [ [ AS ] alias ]
        [ USING usinglist ]
        [ WHERE condition | WHERE CURRENT OF cursor_name ]
        [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]
de: DELETE FROM [ ONLY ] tabelle [ * ] [ [ AS ] alias ]
        [ USING using-liste ]
        [ WHERE bedingung | WHERE CURRENT OF cursorname ]
        [ RETURNING * | ausgabeausdruck [ [ AS ] ausgabename ] [, ...] ]

en: DROP AGGREGATE [ IF EXISTS ] name ( type [ , ... ] ) [ CASCADE | RESTRICT ]
de: DROP AGGREGATE [ IF EXISTS ] name ( typ [ , ... ] ) [ CASCADE | RESTRICT ]

en: DROP CAST [ IF EXISTS ] (sourcetype AS targettype) [ CASCADE | RESTRICT ]
de: DROP CAST [ IF EXISTS ] (quelltyp AS zieltyp) [ CASCADE | RESTRICT ]

en: DROP FUNCTION [ IF EXISTS ] name ( [ [ argmode ] [ argname ] argtype [, ...] ] )
        [ CASCADE | RESTRICT ]
de: DROP FUNCTION [ IF EXISTS ] name ( [ [ argmodus ] [ argname ] argtyp [, ...] ] )
        [ CASCADE | RESTRICT ]

en: DROP OPERATOR CLASS [ IF EXISTS ] name USING index_method [ CASCADE | RESTRICT ]
de: DROP OPERATOR CLASS [ IF EXISTS ] name USING indexmethode [ CASCADE | RESTRICT ]

en: DROP OPERATOR FAMILY [ IF EXISTS ] name USING index_method [ CASCADE | RESTRICT ]
de: DROP OPERATOR FAMILY [ IF EXISTS ] name USING indexmethode [ CASCADE | RESTRICT ]

en: DROP OPERATOR [ IF EXISTS ] name ( { lefttype | NONE } , { righttype | NONE } ) [ CASCADE | RESTRICT ]
de: DROP OPERATOR [ IF EXISTS ] name ( { linker_typ | NONE } , { rechter_typ | NONE } ) [ CASCADE | RESTRICT ]

en: DROP TRIGGER [ IF EXISTS ] name ON table [ CASCADE | RESTRICT ]
de: DROP TRIGGER [ IF EXISTS ] name ON tabelle [ CASCADE | RESTRICT ]

en: DROP USER MAPPING [ IF EXISTS ] FOR { username | USER | CURRENT_USER | PUBLIC } SERVER servername
de: DROP USER MAPPING [ IF EXISTS ] FOR { benutzername | USER | CURRENT_USER | PUBLIC } SERVER servername

en: Default footer is off.
de: Standardfußzeile ist aus.

en: Default footer is on.
de: Standardfußzeile ist an.

en: Default?
de: Standard?

en: Description
de: Beschreibung

en: Destination
de: Ziel

en: Dictionaries
de: Wörterbücher

en: Did not find any relation named "%s".
de: Keine Relationen namens »%s« gefunden

en: Did not find any relation with OID %s.
de: Keine Relation mit OID %s gefunden.

en: Did not find any text search configuration named "%s".
de: Keine Textsuchekonfiguration namens »%s« gefunden

en: Did not find any text search parser named "%s".
de: Kein Textsucheparser namens »%s« gefunden

en: Disabled rules:
de: Abgeschaltete Regeln:

en: Disabled triggers:
de: Abgeschaltete Trigger:

en: EXPLAIN [ ANALYZE ] [ VERBOSE ] statement
de: EXPLAIN [ ANALYZE ] [ VERBOSE ] befehl

en: Elements
de: Elemente

en: Encoding
de: Kodierung

en: End parse
de: Parsen beenden

en: Enter data to be copied followed by a newline.
    End with a backslash and a period on a line by itself.
de: Geben Sie die zu kopierenden Daten ein, gefolgt von einem Zeilenende.
    Beenden Sie mit einem Backslash und einem Punkt alleine auf einer Zeile.

en: Enter it again:
de: Geben Sie es noch einmal ein:

en: Enter new password:
de: Neues Passwort eingeben:

en: Expanded display is off.
de: Erweiterte Anzeige ist aus.

en: Expanded display is on.
de: Erweiterte Anzeige ist an.

en: FETCH [ direction { FROM | IN } ] cursorname
    
    where direction can be empty or one of:
    
        NEXT
        PRIOR
        FIRST
        LAST
        ABSOLUTE count
        RELATIVE count
        count
        ALL
        FORWARD
        FORWARD count
        FORWARD ALL
        BACKWARD
        BACKWARD count
        BACKWARD ALL
de: FETCH [ richtung { FROM | IN } ] cursorname
    
    wobei richtung leer sein kann oder Folgendes:
    
        NEXT
        PRIOR
        FIRST
        LAST
        ABSOLUTE anzahl
        RELATIVE anzahl
        anzahl
        ALL
        FORWARD
        FORWARD anzahl
        FORWARD ALL
        BACKWARD
        BACKWARD anzahl
        BACKWARD ALL

en: Failed.
de: Fehlgeschlagen.

en: Field separator is "%s".
de: Feldtrennzeichen ist »%s«.

en: Foreign-data wrapper
de: Fremddaten-Wrapper

en: Foreign-key constraints:
de: Fremdschlüssel-Constraints:

en: Formatting
de: Formatierung

en: Function
de: Funktion

en: GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
        [,...] | ALL [ PRIVILEGES ] }
        ON [ TABLE ] tablename [, ...]
        TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { SELECT | INSERT | UPDATE | REFERENCES } ( column [, ...] )
        [,...] | ALL [ PRIVILEGES ] ( column [, ...] ) }
        ON [ TABLE ] tablename [, ...]
        TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { USAGE | SELECT | UPDATE }
        [,...] | ALL [ PRIVILEGES ] }
        ON SEQUENCE sequencename [, ...]
        TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { CREATE | CONNECT | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
        ON DATABASE dbname [, ...]
        TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN DATA WRAPPER fdwname [, ...]
        TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN SERVER servername [, ...]
        TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { EXECUTE | ALL [ PRIVILEGES ] }
        ON FUNCTION funcname ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [, ...]
        TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { USAGE | ALL [ PRIVILEGES ] }
        ON LANGUAGE langname [, ...]
        TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
        ON SCHEMA schemaname [, ...]
        TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { CREATE | ALL [ PRIVILEGES ] }
        ON TABLESPACE tablespacename [, ...]
        TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT role [, ...] TO rolename [, ...] [ WITH ADMIN OPTION ]
de: GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
        [,...] | ALL [ PRIVILEGES ] }
        ON [ TABLE ] tabellenname [, ...]
        TO { [ GROUP ] rollenname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { SELECT | INSERT | UPDATE | REFERENCES } ( spalte [, ...] )
        [,...] | ALL [ PRIVILEGES ] ( spalte [, ...] ) }
        ON [ TABLE ] tabellenname [, ...]
        TO { [ GROUP ] rollenname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { USAGE | SELECT | UPDATE }
        [,...] | ALL [ PRIVILEGES ] }
        ON SEQUENCE sequenzname [, ...]
        TO { [ GROUP ] rollenname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { CREATE | CONNECT | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
        ON DATABASE datenbankname [, ...]
        TO { [ GROUP ] rollenname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN DATA WRAPPER fdwname [, ...]
        TO { [ GROUP ] rollenname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN SERVER servername [, ...]
        TO { [ GROUP ] rollenname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { EXECUTE | ALL [ PRIVILEGES ] }
        ON FUNCTION funktionsname ( [ [ argmodus ] [ argname ] argtyp [, ...] ] ) [, ...]
        TO { [ GROUP ] rollenname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { USAGE | ALL [ PRIVILEGES ] }
        ON LANGUAGE sprachname [, ...]
        TO { [ GROUP ] rollenname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
        ON SCHEMA schemaname [, ...]
        TO { [ GROUP ] rollenname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { CREATE | ALL [ PRIVILEGES ] }
        ON TABLESPACE tablespacename [, ...]
        TO { [ GROUP ] rollenname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT rolle [, ...] TO rollenname [, ...] [ WITH ADMIN OPTION ]

en: General
de: Allgemein

en: General options:
de: Allgemeine Optionen:

en: Get headline
de: Überschrift ermitteln

en: Get next token
de: Nächstes Token lesen

en: Get token types
de: Tokentypen ermitteln

en: Has OIDs
de: Hat OIDs

en: INSERT INTO table [ ( column [, ...] ) ]
        { DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) [, ...] | query }
        [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]
de: INSERT INTO tabelle [ ( spalte [, ...] ) ]
        { DEFAULT VALUES | VALUES ( { ausdruck | DEFAULT } [, ...] ) [, ...] | anfrage }
        [ RETURNING * | ausgabeausdruck [ [ AS ] ausgabename ] [, ...] ]

en: Implicit?
de: Implizit?

en: Index "%s.%s"
de: Index »%s.%s«

en: Indexes:
de: Indexe:

en: Informational
de: Informationen

en: Inherits
de: Erbt von

en: Init options
de: Initialisierungsoptionen

en: Input/Output
de: Eingabe/Ausgabe

en: Internal name
de: Interner Name

en: Interrupted
de: Unterbrochen

en: Invalid command \%s. Try \? for help.
de: Ungültige Anweisung \%s.  Versuchen Sie \? für Hilfe.

en: LOAD 'filename'
de: LOAD 'dateiname'

en: LOCK [ TABLE ] [ ONLY ] name [ * ] [, ...] [ IN lockmode MODE ] [ NOWAIT ]
    
    where lockmode is one of:
    
        ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE
        | SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE
de: LOCK [ TABLE ] [ ONLY ] name [ * ] [, ...] [ IN sperrmodus MODE ] [ NOWAIT ]
    
    wobei sperrmodus Folgendes sein kann:
    
        ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE
        | SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE

en: Language
de: Sprache

en: Large objects
de: Large Objects

en: Left arg type
de: Linker Typ

en: List of aggregate functions
de: Liste der Aggregatfunktionen

en: List of casts
de: Liste der Typumwandlungen

en: List of conversions
de: Liste der Konversionen

en: List of data types
de: Liste der Datentypen

en: List of databases
de: Liste der Datenbanken

en: List of domains
de: Liste der Domänen

en: List of foreign servers
de: Liste der Fremdserver

en: List of foreign-data wrappers
de: Liste der Fremddaten-Wrapper

en: List of functions
de: Liste der Funktionen

en: List of operators
de: Liste der Operatoren

en: List of relations
de: Liste der Relationen

en: List of roles
de: Liste der Rollen

en: List of schemas
de: Liste der Schemas

en: List of tablespaces
de: Liste der Tablespaces

en: List of text search configurations
de: Liste der Textsuchekonfigurationen

en: List of text search dictionaries
de: Liste der Textsuchewörterbücher

en: List of text search parsers
de: Liste der Textsucheparser

en: List of text search templates
de: Liste der Textsuchevorlagen

en: List of user mappings
de: Liste der Benutzerabbildungen

en: Locale-adjusted numeric output is off.
de: Lokalisiertes Format für numerische Daten ist aus.

en: Location
de: Pfad

en: MOVE [ direction { FROM | IN } ] cursorname
de: MOVE [ richtung { FROM | IN } ] cursorname

en: Member of
de: Mitglied von

en: Method
de: Methode

en: Modifier
de: Attribut

en: Modifiers
de: Attribute

en: No changes
de: keine Änderungen

en: No connections
de: keine Verbindungen

en: No help available for "%-.*s".
    Try \h with no arguments to see available help.
de: Keine Hilfe verfügbar für »%-.*s«.
    Versuchen Sie \h ohne Argumente, um die verfügbare Hilfe zu sehen.

en: No inheritance
de: keine Vererbung

en: No matching relations found.
de: Keine passenden Relationen gefunden

en: No relations found.
de: Keine Relationen gefunden

en: Null display is "%s".
de: Null-Anzeige ist »%s«.

en: Object
de: Objekt

en: Object descriptions
de: Objektbeschreibungen

en: Operating System
de: Betriebssystem

en: Options
de: Optionen

en: Output format is %s.
de: Ausgabeformat ist »%s«.

en: Owner
de: Eigentümer

en: PREPARE TRANSACTION transaction_id
de: PREPARE TRANSACTION transaktions_id

en: PREPARE name [ ( datatype [, ...] ) ] AS statement
de: PREPARE name [ ( datentyp [, ...] ) ] AS befehl

en: Pager is always used.
de: Pager wird immer verwendet.

en: Pager is used for long output.
de: Pager wird für lange Ausgaben verwendet.

en: Pager usage is off.
de: Pager-Verwendung ist aus.

en: Password encryption failed.
de: Passwortverschlüsselung ist fehlgeschlagen.

en: Password for user %s:
de: Passwort für Benutzer %s:

en: Password:
de: Passwort:

en: Passwords didn't match.
de: Passwörter stimmten nicht überein.

en: Previous connection kept
de: Vorherige Verbindung wurde behalten

en: Query Buffer
de: Anfragepuffer

en: Query buffer is empty.
de: Anfragepuffer ist leer.

en: Query buffer reset (cleared).
de: Anfragepuffer wurde gelöscht.

en: REASSIGN OWNED BY old_role [, ...] TO new_role
de: REASSIGN OWNED BY alte_rolle [, ...] TO neue_rolle

en: RESET configuration_parameter
    RESET ALL
de: RESET konfigurationsparameter
    RESET ALL

en: REVOKE [ GRANT OPTION FOR ]
        { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
        [,...] | ALL [ PRIVILEGES ] }
        ON [ TABLE ] tablename [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { SELECT | INSERT | UPDATE | REFERENCES } ( column [, ...] )
        [,...] | ALL [ PRIVILEGES ] ( column [, ...] ) }
        ON [ TABLE ] tablename [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { USAGE | SELECT | UPDATE }
        [,...] | ALL [ PRIVILEGES ] }
        ON SEQUENCE sequencename [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { CREATE | CONNECT | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
        ON DATABASE dbname [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN DATA WRAPPER fdwname [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN SERVER servername [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { EXECUTE | ALL [ PRIVILEGES ] }
        ON FUNCTION funcname ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON LANGUAGE langname [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
        ON SCHEMA schemaname [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { CREATE | ALL [ PRIVILEGES ] }
        ON TABLESPACE tablespacename [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ ADMIN OPTION FOR ]
        role [, ...] FROM rolename [, ...]
        [ CASCADE | RESTRICT ]
de: REVOKE [ GRANT OPTION FOR ]
        { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
        [,...] | ALL [ PRIVILEGES ] }
        ON [ TABLE ] tabellenname [, ...]
        FROM { [ GROUP ] rollenname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { SELECT | INSERT | UPDATE | REFERENCES } ( spalte [, ...] )
        [,...] | ALL [ PRIVILEGES ] ( spalte [, ...] ) }
        ON [ TABLE ] tabellenname [, ...]
        FROM { [ GROUP ] rollenname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { USAGE | SELECT | UPDATE }
        [,...] | ALL [ PRIVILEGES ] }
        ON SEQUENCE sequenzname [, ...]
        FROM { [ GROUP ] rollenname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { CREATE | CONNECT | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
        ON DATABASE datenbankname [, ...]
        FROM { [ GROUP ] rollenname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN DATA WRAPPER fdwname [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN SERVER servername [, ...]
        FROM { [ GROUP ] rolename | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { EXECUTE | ALL [ PRIVILEGES ] }
        ON FUNCTION funktionsname ( [ [ argmodus ] [ argname ] argtyp [, ...] ] ) [, ...]
        FROM { [ GROUP ] rollenname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON LANGUAGE sprachname [, ...]
        FROM { [ GROUP ] rollenname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
        ON SCHEMA schemaname [, ...]
        FROM { [ GROUP ] rollenname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { CREATE | ALL [ PRIVILEGES ] }
        ON TABLESPACE tablespacename [, ...]
        FROM { [ GROUP ] rollenname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ ADMIN OPTION FOR ]
        rolle [, ...] FROM rollenname [, ...]
        [ CASCADE | RESTRICT ]

en: ROLLBACK PREPARED transaction_id
de: ROLLBACK PREPARED transaktions_id

en: Record separator is "%s".
de: Satztrennzeichen ist »%s«.

en: Record separator is <newline>.
de: Satztrennzeichen ist <newline>.

en: Referenced by:
de: Fremdschlüsselverweise von:

en: Report bugs to <pgsql-bugs@postgresql.org>.
de: Berichten Sie Fehler an <pgsql-bugs@postgresql.org>.

en: Result data type
de: Ergebnisdatentyp

en: Result type
de: Ergebnistyp

en: Right arg type
de: Rechter Typ

en: Role name
de: Rollenname

en: Rules firing always:
de: Regeln, die immer aktiv werden:

en: Rules firing on replica only:
de: Regeln, die nur im Replikat aktiv werden:

en: Rules:
de: Regeln:

en: SET TRANSACTION transaction_mode [, ...]
    SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode [, ...]
    
    where transaction_mode is one of:
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY
de: SET TRANSACTION transaktionsmodus [, ...]
    SET SESSION CHARACTERISTICS AS TRANSACTION transaktionsmodus [, ...]
    
    wobei transaktionsmodus Folgendes sein kann:
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY

en: SET [ SESSION | LOCAL ] ROLE rolename
    SET [ SESSION | LOCAL ] ROLE NONE
    RESET ROLE
de: SET [ SESSION | LOCAL ] ROLE rollenname
    SET [ SESSION | LOCAL ] ROLE NONE
    RESET ROLE

en: SET [ SESSION | LOCAL ] SESSION AUTHORIZATION username
    SET [ SESSION | LOCAL ] SESSION AUTHORIZATION DEFAULT
    RESET SESSION AUTHORIZATION
de: SET [ SESSION | LOCAL ] SESSION AUTHORIZATION benutzername
    SET [ SESSION | LOCAL ] SESSION AUTHORIZATION DEFAULT
    RESET SESSION AUTHORIZATION

en: SET [ SESSION | LOCAL ] configuration_parameter { TO | = } { value | 'value' | DEFAULT }
    SET [ SESSION | LOCAL ] TIME ZONE { timezone | LOCAL | DEFAULT }
de: SET [ SESSION | LOCAL ] konfigurationsparameter { TO | = } { wert | 'wert' | DEFAULT }
    SET [ SESSION | LOCAL ] TIME ZONE { zeitzone | LOCAL | DEFAULT }

en: SSL connection (cipher: %s, bits: %i)
de: SSL-Verbindung (Verschlüsselungsmethode: %s, Bits: %i)

en: SSL connection (unknown cipher)
de: SSL-Verbindung (unbekannte Verschlüsselungsmethode)

en: START TRANSACTION [ transaction_mode [, ...] ]
    
    where transaction_mode is one of:
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY
de: START TRANSACTION [ transaktionsmodus [, ...] ]
    
    wobei transaktionsmodus Folgendes sein kann:
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY

en: Sequence "%s.%s"
de: Sequenz »%s.%s«

en: Showing locale-adjusted numeric output.
de: Zeige numerische Daten in lokalisiertem Format.

en: Showing only tuples.
de: Zeige nur Datenzeilen.

en: Size
de: Größe

en: Source
de: Quelle

en: Source code
de: Quelltext

en: Source type
de: Quelltyp

en: Special relation "%s.%s"
de: Spezielle Relation »%s.%s«

en: Start parse
de: Parsen starten

en: Storage
de: Speicherung

en: Succeeded.
de: Erfolgreich.

en: TOAST table "%s.%s"
de: TOAST-Tabelle »%s.%s«

en: Table
de: Tabelle

en: Table "%s.%s"
de: Tabelle »%s.%s«

en: Table attribute is "%s".
de: Tabellenattribut ist »%s«.

en: Table attributes unset.
de: Tabellenattribute sind nicht gesetzt.

en: Tablespace: "%s"
de: Tablespace: »%s«

en: Target type
de: Zieltyp

en: Target width for "wrapped" format is %d.
de: Zielbreite für Format »wrapped« ist %d.

en: Template
de: Vorlage

en: Text search configuration "%s"
de: Textsuchekonfiguration »%s«

en: Text search configuration "%s.%s"
de: Textsuchekonfiguration »%s.%s«

en: Text search parser "%s"
de: Textsucheparser »%s«

en: Text search parser "%s.%s"
de: Textsucheparser »%s.%s«

en: The connection to the server was lost. Attempting reset:
de: Die Verbindung zum Server wurde verloren.  Versuche Reset:

en: The server (version %d.%d) does not support editing function source.
de: Der Server (Version %d.%d) unterstützt das Bearbeiten des Funktionsquelltextes nicht.

en: The server (version %d.%d) does not support foreign servers.
de: Der Server (Version %d.%d) unterstützt keine Fremdserver.

en: The server (version %d.%d) does not support foreign-data wrappers.
de: Der Server (Version %d.%d) unterstützt keine Fremddaten-Wrapper.

en: The server (version %d.%d) does not support full text search.
de: Der Server (Version %d.%d) unterstützt keine Volltextsuche.

en: The server (version %d.%d) does not support savepoints for ON_ERROR_ROLLBACK.
de: Der Server (Version %d.%d) unterstützt keine Sicherungspunkte für ON_ERROR_ROLLBACK.

en: The server (version %d.%d) does not support tablespaces.
de: Der Server (Version %d.%d) unterstützt keine Tablespaces.

en: The server (version %d.%d) does not support user mappings.
de: Der Server (Version %d.%d) unterstützt keine Benutzerabbildungen.

en: Time: %.3f ms
de: Zeit: %.3f ms

en: Timing is off.
de: Zeitmessung ist aus.

en: Timing is on.
de: Zeitmessung ist an.

en: Title is "%s".
de: Titel ist »%s«.

en: Title is unset.
de: Titel ist nicht gesetzt.

en: Token name
de: Tokenname

en: Token types for parser "%s"
de: Tokentypen für Parser »%s«

en: Token types for parser "%s.%s"
de: Tokentypen für Parser »%s.%s«

en: Triggers firing always:
de: Trigger, die immer aktiv werden:

en: Triggers firing on replica only:
de: Trigger, die nur im Replikat aktiv werden:

en: Triggers:
de: Trigger:

en: Try "%s --help" for more information.
de: Versuchen Sie »%s --help« für weitere Informationen.

en: Tuples only is off.
de: Nur Datenzeilen ist aus.

en: Type
de: Typ

en: Type "help" for help.
de: Geben Sie »help« für Hilfe ein.

en: Type:  \copyright for distribution terms
           \h for help with SQL commands
           \? for help with psql commands
           \g or terminate with semicolon to execute query
           \q to quit
de: Geben Sie ein:  \copyright für Urheberrechtsinformationen
                    \h für Hilfe über SQL-Anweisungen
                    \? für Hilfe über interne Anweisungen
                    \g oder Semikolon, um eine Anfrage auszuführen
                    \q um zu beenden

en: UPDATE [ ONLY ] table [ * ] [ [ AS ] alias ]
        SET { column = { expression | DEFAULT } |
              ( column [, ...] ) = ( { expression | DEFAULT } [, ...] ) } [, ...]
        [ FROM fromlist ]
        [ WHERE condition | WHERE CURRENT OF cursor_name ]
        [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]
de: UPDATE [ ONLY ] tabelle [ * ] [ [ AS ] alias ]
        SET { spalte = { ausdruck | DEFAULT } |
              ( spalte [, ...] ) = ( { ausdruck | DEFAULT } [, ...] ) } [, ...]
        [ FROM from-liste ]
        [ WHERE bedingung | WHERE CURRENT OF cursorname ]
        [ RETURNING * | ausgabeausdruck [ [ AS ] ausgabename ] [, ...] ]

en: Usage:
de: Aufruf:

en: Use "\q" to leave %s.
de: Verwenden Sie »\q«, um %s zu verlassen.

en: User name
de: Benutzername

en: VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ table ]
    VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] ANALYZE [ table [ (column [, ...] ) ] ]
de: VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ tabelle ]
    VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] ANALYZE [ tabelle [ (spalte [, ...] ) ] ]

en: VALUES ( expression [, ...] ) [, ...]
        [ ORDER BY sort_expression [ ASC | DESC | USING operator ] [, ...] ]
        [ LIMIT { count | ALL } ]
        [ OFFSET start [ ROW | ROWS ] ]
        [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
de: VALUES ( ausdruck [, ...] ) [, ...]
        [ ORDER BY sortierausdruck [ ASC | DESC | USING operator ] [, ...] ]
        [ LIMIT { anzahl | ALL } ]
        [ OFFSET start [ ROW | ROWS ] ]
        [ FETCH { FIRST | NEXT } [ anzahl ] { ROW | ROWS } ONLY ]

en: Value
de: Wert

en: Variables
de: Variablen

en: View "%s.%s"
de: Sicht »%s.%s«

en: View definition:
de: Sichtdefinition:

en: Volatility
de: Volatilität

en: WARNING: %s version %d.%d, server version %d.%d.
             Some psql features might not work.
de: WARNUNG: %s-Version %d.%d, Serverversion %d.%d.
             Einige Features von psql werden eventuell nicht funktionieren.

en: WARNING: Console code page (%u) differs from Windows code page (%u)
             8-bit characters might not work correctly. See psql reference
             page "Notes for Windows users" for details.
de: Warnung: Konsolencodeseite (%u) unterscheidet sich von der Windows-
             Codeseite (%u). 8-Bit-Zeichen funktionieren möglicherweise nicht
             richtig. Einzelheiten finden Sie auf der psql-Handbuchseite unter
             »Notes for Windows users«.

en: Wrote history to file "%s/%s".
de: Befehlsgeschichte in Datei »%s/%s« geschrieben.

en: You are currently not connected to a database.
de: Sie sind gegenwärtig nicht mit einer Datenbank verbunden.

en: You are now connected to database "%s"
de: Sie sind jetzt verbunden mit der Datenbank »%s«

en: You are using psql, the command-line interface to PostgreSQL.
de: Dies ist psql, die Kommandozeilenschnittstelle für PostgreSQL.

en: [ WITH [ RECURSIVE ] with_query [, ...] ]
    SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
        * | expression [ [ AS ] output_name ] [, ...]
        INTO [ TEMPORARY | TEMP ] [ TABLE ] new_table
        [ FROM from_item [, ...] ]
        [ WHERE condition ]
        [ GROUP BY expression [, ...] ]
        [ HAVING condition [, ...] ]
        [ WINDOW window_name AS ( window_definition ) [, ...] ]
        [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
        [ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
        [ LIMIT { count | ALL } ]
        [ OFFSET start [ ROW | ROWS ] ]
        [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
        [ FOR { UPDATE | SHARE } [ OF table_name [, ...] ] [ NOWAIT ] [...] ]
de: [ WITH [ RECURSIVE ] with_anfrage [, ...] ]
    SELECT [ ALL | DISTINCT [ ON ( ausdruck [, ...] ) ] ]
        * | ausdruck [ AS ausgabename ] [, ...]
        INTO [ TEMPORARY | TEMP ] [ TABLE ] neue_tabelle
        [ FROM from_element [, ...] ]
        [ WHERE bedingung ]
        [ GROUP BY ausdruck [, ...] ]
        [ HAVING bedingung [, ...] ]
        [ WINDOW window_name AS ( window_definition ) [, ...] ]
        [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
        [ ORDER BY ausdruck [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
        [ LIMIT { anzahl | ALL } ]
        [ OFFSET start [ ROW | ROWS ] ]
        [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
        [ FOR { UPDATE | SHARE } [ OF tabellenname [, ...] ] [ NOWAIT ] [...] ]

en: [ WITH [ RECURSIVE ] with_query [, ...] ]
    SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
        * | expression [ [ AS ] output_name ] [, ...]
        [ FROM from_item [, ...] ]
        [ WHERE condition ]
        [ GROUP BY expression [, ...] ]
        [ HAVING condition [, ...] ]
        [ WINDOW window_name AS ( window_definition ) [, ...] ]
        [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
        [ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
        [ LIMIT { count | ALL } ]
        [ OFFSET start [ ROW | ROWS ] ]
        [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
        [ FOR { UPDATE | SHARE } [ OF table_name [, ...] ] [ NOWAIT ] [...] ]
    
    where from_item can be one of:
    
        [ ONLY ] table_name [ * ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
        ( select ) [ AS ] alias [ ( column_alias [, ...] ) ]
        with_query_name [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
        function_name ( [ argument [, ...] ] ) [ AS ] alias [ ( column_alias [, ...] | column_definition [, ...] ) ]
        function_name ( [ argument [, ...] ] ) AS ( column_definition [, ...] )
        from_item [ NATURAL ] join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]
    
    and with_query is:
    
        with_query_name [ ( column_name [, ...] ) ] AS ( select )
    
    TABLE { [ ONLY ] table_name [ * ] | with_query_name }
de: [ WITH [ RECURSIVE ] with_anfrage [, ...] ]
    SELECT [ ALL | DISTINCT [ ON ( ausdruck [, ...] ) ] ]
        * | ausdruck [ AS ausgabename ] [, ...]
        [ FROM from_element [, ...] ]
        [ WHERE bedingung ]
        [ GROUP BY ausdruck [, ...] ]
        [ HAVING bedingung [, ...] ]
        [ WINDOW window_name AS ( window_definition ) [, ...] ]
        [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
        [ ORDER BY ausdruck [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
        [ LIMIT { anzahl | ALL } ]
        [ OFFSET start [ ROW | ROWS ] ]
        [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
        [ FOR { UPDATE | SHARE } [ OF tabellenname [, ...] ] [ NOWAIT ] [...] ]
    
    wobei from_element Folgendes sein kann:
    
        [ ONLY ] tabellenname [ * ] [ [ AS ] alias [ ( spaltenalias [, ...] ) ] ]
        ( select ) [ AS ] alias [ ( spaltenalias [, ...] ) ]
        with_anfragenname [ [ AS ] alias [ ( spaltenalias [, ...] ) ] ]
        funktionsname ( [ argument [, ...] ] ) [ AS ] alias [ ( spaltenalias [, ...] | spaltendefinition [, ...] ) ]
        funktionsname ( [ argument [, ...] ] ) AS ( spaltendefinition [, ...] )
        from_element [ NATURAL ] verbundtyp from_element [ ON verbundbedingung | USING ( verbundspalte [, ...] ) ]
    
    und with_anfrage ist:
    
        with_anfragenname [ ( spaltenname [, ...] ) ] AS ( select )
    
    TABLE { [ ONLY ] tabellenname [ * ] | with_anfragenname }

en: \!: failed
de: \!: fehlgeschlagen

en: \%s: could not change directory to "%s": %s
de: \%s: konnte nicht in das Verzeichnis »%s« wechseln: %s

en: \%s: error
de: \%s: Fehler

en: \%s: extra argument "%s" ignored
de: \%s: überflüssiges Argument »%s« ignoriert

en: \%s: missing required argument
de: \%s: notwendiges Argument fehlt

en: \copy: arguments required
de: \copy: benötigt Argumente

en: \copy: parse error at "%s"
de: \copy: Parse-Fehler bei »%s«

en: \copy: parse error at end of line
de: \copy: Parse-Fehler am Zeilenende

en: \copy: unexpected response (%d)
de: \copy: unerwartete Antwort (%d)

en: \df does not take a "w" option with server version %d.%d
de: \df akzeptiert die Option »w« nicht mit Serverversion %d.%d

en: \df only takes [antwS+] as options
de: \df akzeptiert nur [antwS+] als Optionen

en: \pset: allowed formats are unaligned, aligned, wrapped, html, latex, troff-ms
de: \pset: zulässige Formate sind unaligned, aligned, wrapped, html, latex, troff-ms

en: \pset: unknown option: %s
de: \pset: unbekannte Option: %s

en: abort the current transaction
de: bricht die aktuelle Transaktion ab

en: aborted because of read failure
de: abgebrochen wegen Lesenfehlers

en: agg
de: Agg

en: aggregate
de: Aggregat

en: cancel a transaction that was earlier prepared for two-phase commit
de: storniert eine Transaktion, die vorher für Two-Phase-Commit vorbereitet worden war

en: canceled by user
de: vom Benutzer abgebrochen

en: cannot locate temporary directory: %s
de: konnte temporäres Verzeichnis nicht finden: %s

en: change a database
de: ändert eine Datenbank

en: change a database role
de: ändert eine Datenbankrolle

en: change a run-time parameter
de: ändert einen Konfigurationsparameter

en: change role name or membership
de: ändert Rollenname oder -mitglieder

en: change the definition of a conversion
de: ändert die Definition einer Zeichensatzkonversion

en: change the definition of a domain
de: ändert die Definition einer Domäne

en: change the definition of a foreign server
de: ändert die Definition eines Fremdservers

en: change the definition of a foreign-data wrapper
de: ändert die Definition eines Fremddaten-Wrappers

en: change the definition of a function
de: ändert die Definition einer Funktion

en: change the definition of a procedural language
de: ändert die Definition einer prozeduralen Sprache

en: change the definition of a schema
de: ändert die Definition eines Schemas

en: change the definition of a sequence generator
de: ändert die Definition eines Sequenzgenerators

en: change the definition of a table
de: ändert die Definition einer Tabelle

en: change the definition of a tablespace
de: ändert die Definition eines Tablespace

en: change the definition of a text search configuration
de: ändert die Definition einer Textsuchekonfiguration

en: change the definition of a text search dictionary
de: ändert die Definition eines Textsuchewörterbuchs

en: change the definition of a text search parser
de: ändert die Definition eines Textsucheparsers

en: change the definition of a text search template
de: ändert die Definition einer Textsuchevorlage

en: change the definition of a trigger
de: ändert die Definition eines Triggers

en: change the definition of a type
de: ändert die Definition eines Typs

en: change the definition of a user mapping
de: ändert die Definition einer Benutzerabbildung

en: change the definition of a view
de: ändert die Definition einer Sicht

en: change the definition of an aggregate function
de: ändert die Definition einer Aggregatfunktion

en: change the definition of an index
de: ändert die Definition eines Index

en: change the definition of an operator
de: ändert die Definition eines Operators

en: change the definition of an operator class
de: ändert die Definition einer Operatorklasse

en: change the definition of an operator family
de: ändert die Definition einer Operatorfamilie

en: change the ownership of database objects owned by a database role
de: ändert den Eigentümer der der Rolle gehörenden Datenbankobjekte

en: child process exited with exit code %d
de: Kindprozess hat mit Code %d beendet

en: child process exited with unrecognized status %d
de: Kindprozess hat mit unbekanntem Status %d beendet

en: child process was terminated by exception 0x%X
de: Kindprozess wurde durch Ausnahme 0x%X beendet

en: child process was terminated by signal %d
de: Kindprozess wurde von Signal %d beendet

en: child process was terminated by signal %s
de: Kindprozess wurde von Signal %s beendet

en: close a cursor
de: schließt einen Cursor

en: cluster a table according to an index
de: clustert eine Tabelle nach einem Index

en: collect statistics about a database
de: sammelt Statistiken über eine Datenbank

en: commit a transaction that was earlier prepared for two-phase commit
de: schließt eine Transaktion ab, die vorher für Two-Phase-Commit vorbereitet worden war

en: commit the current transaction
de: schließt die aktuelle Transaktion ab

en: compute a set of rows
de: berechnet eine Zeilenmenge

en: connection to server was lost
de: Verbindung zum Server wurde verloren

en: contains support for command-line editing
de: enthält Unterstützung für Kommandozeilenbearbeitung

en: copy data between a file and a table
de: kopiert Daten zwischen einer Datei und einer Tabelle

en: could not change directory to "%s"
de: konnte nicht in Verzeichnis »%s« wechseln

en: could not find a "%s" to execute
de: konnte kein »%s« zum Ausführen finden

en: could not get current user name: %s
de: konnte aktuellen Benutzernamen nicht ermitteln: %s

en: could not get home directory: %s
de: konnte Home-Verzeichnis nicht ermitteln: %s

en: could not identify current directory: %s
de: konnte aktuelles Verzeichnis nicht ermitteln: %s

en: could not open temporary file "%s": %s
de: konnte temporäre Datei »%s« nicht öffnen: %s

en: could not read binary "%s"
de: konnte Programmdatei »%s« nicht lesen

en: could not read from input file: %s
de: konnte nicht aus Eingabedatei lesen: %s

en: could not read symbolic link "%s"
de: konnte symbolische Verknüpfung »%s« nicht lesen

en: could not save history to file "%s": %s
de: konnte Befehlsgeschichte nicht in »%s« speichern: %s

en: could not start /bin/sh
de: konnte /bin/sh nicht starten

en: could not start editor "%s"
de: konnte Editor »%s« nicht starten

en: could not write COPY data: %s
de: konnte COPY-Daten nicht schreiben: %s

en: create a new database
de: erzeugt eine neue Datenbank

en: create new rows in a table
de: erzeugt neue Zeilen in einer Tabelle

en: data type
de: Datentyp

en: deallocate a prepared statement
de: gibt einen vorbereiteten Befehl frei

en: default %s
de: Vorgabewert %s

en: define a cursor
de: definiert einen Cursor

en: define a new aggregate function
de: definiert eine neue Aggregatfunktion

en: define a new cast
de: definiert eine neue Typumwandlung

en: define a new constraint trigger
de: definiert einen neuen Constraint-Trigger

en: define a new data type
de: definiert einen neuen Datentyp

en: define a new database role
de: definiert eine neue Datenbankrolle

en: define a new domain
de: definiert eine neue Domäne

en: define a new encoding conversion
de: definiert eine neue Kodierungskonversion

en: define a new foreign server
de: definiert einen neuen Fremdserver

en: define a new foreign-data wrapper
de: definiert einen neuen Fremddaten-Wrapper

en: define a new function
de: definiert eine neue Funktion

en: define a new index
de: definiert einen neuen Index

en: define a new mapping of a user to a foreign server
de: definiert eine neue Abbildung eines Benutzers auf einen Fremdserver

en: define a new operator
de: definiert einen neuen Operator

en: define a new operator class
de: definiert eine neue Operatorklasse

en: define a new operator family
de: definiert eine neue Operatorfamilie

en: define a new procedural language
de: definiert eine neue prozedurale Sprache

en: define a new rewrite rule
de: definiert eine neue Umschreiberegel

en: define a new savepoint within the current transaction
de: definiert einen neuen Savepoint in der aktuellen Transaktion

en: define a new schema
de: definiert ein neues Schema

en: define a new sequence generator
de: definiert einen neuen Sequenzgenerator

en: define a new table
de: definiert eine neue Tabelle

en: define a new table from the results of a query
de: definiert eine neue Tabelle aus den Ergebnissen einer Anfrage

en: define a new tablespace
de: definiert einen neuen Tablespace

en: define a new text search configuration
de: definiert eine neue Textsuchekonfiguration

en: define a new text search dictionary
de: definiert ein neues Textsuchewörterbuch

en: define a new text search parser
de: definiert einen neuen Textsucheparser

en: define a new text search template
de: definiert eine neue Textsuchevorlage

en: define a new trigger
de: definiert einen neuen Trigger

en: define a new view
de: definiert eine neue Sicht

en: define access privileges
de: definiert Zugriffsprivilegien

en: define or change the comment of an object
de: definiert oder ändert den Kommentar von einem Objekt

en: delete rows of a table
de: löscht Zeilen einer Tabelle

en: destroy a previously defined savepoint
de: gibt einen zuvor definierten Savepoint frei

en: discard session state
de: verwirft den Sitzungszustand

en: empty a table or set of tables
de: leert eine oder mehrere Tabellen

en: execute a prepared statement
de: führt einen vorbereiteten Befehl aus

en: for table "%s.%s"
de: für Tabelle »%s.%s«

en: force a transaction log checkpoint
de: erzwingt einen Checkpoint im Transaktionslog

en: function
de: Funktion

en: garbage-collect and optionally analyze a database
de: säubert und analysiert eine Datenbank

en: generate a notification
de: erzeugt eine Benachrichtigung

en: history is not supported by this installation
de: Befehlsgeschichte wird von dieser Installation nicht unterstützt

en: immutable
de: unveränderlich

en: in assignment
de: in Zuweisung

en: index
de: Index

en: invalid binary "%s"
de: ungültige Programmdatei »%s«

en: invalid command \%s
de: ungültige Anweisung \%s

en: invalid output format (internal error): %d
de: ungültiges Ausgabeformat (interner Fehler): %d

en: listen for a notification
de: hört auf eine Benachrichtigung

en: load a shared library file
de: lädt eine dynamische Bibliotheksdatei

en: local socket
de: lokales Socket

en: lock a table
de: sperrt eine Tabelle

en: no
de: nein

en: no query buffer
de: kein Anfragepuffer

en: off
de: aus

en: on
de: an

en: operator
de: Operator

en: out of memory
de: Speicher aufgebraucht

en: position a cursor
de: positioniert einen Cursor

en: prepare a statement for execution
de: bereitet einen Befehl zur Ausführung vor

en: prepare the current transaction for two-phase commit
de: bereitet die aktuelle Transaktion für Two-Phase-Commit vor

en: primary key,
de: Primärschlüssel,

en: psql is the PostgreSQL interactive terminal.
de: psql ist das interaktive PostgreSQL-Terminal.

en: rebuild indexes
de: baut Indexe neu

en: remove a cast
de: entfernt eine Typumwandlung

en: remove a conversion
de: entfernt eine Zeichensatzkonversion

en: remove a data type
de: entfernt einen Datentyp

en: remove a database
de: entfernt eine Datenbank

en: remove a database role
de: entfernt eine Datenbankrolle

en: remove a domain
de: entfernt eine Domäne

en: remove a foreign server descriptor
de: entfernt einen Fremdserverdeskriptor

en: remove a foreign-data wrapper
de: entfernt einen Fremddaten-Wrapper

en: remove a function
de: entfernt eine Funktion

en: remove a procedural language
de: entfernt eine prozedurale Sprache

en: remove a rewrite rule
de: entfernt eine Umschreiberegel

en: remove a schema
de: entfernt ein Schema

en: remove a sequence
de: entfernt eine Sequenz

en: remove a table
de: entfernt eine Tabelle

en: remove a tablespace
de: entfernt einen Tablespace

en: remove a text search configuration
de: entfernt eine Textsuchekonfiguration

en: remove a text search dictionary
de: entfernt ein Textsuchewörterbuch

en: remove a text search parser
de: entfernt einen Textsucheparser

en: remove a text search template
de: entfernt eine Textsuchevorlage

en: remove a trigger
de: entfernt einen Trigger

en: remove a user mapping for a foreign server
de: entfernt eine Benutzerabbildung für einen Fremdserver

en: remove a view
de: entfernt eine Sicht

en: remove access privileges
de: entfernt Zugriffsprivilegien

en: remove an aggregate function
de: entfernt eine Aggregatfunktion

en: remove an index
de: entfernt einen Index

en: remove an operator
de: entfernt einen Operator

en: remove an operator class
de: entfernt eine Operatorklasse

en: remove an operator family
de: entfernt eine Operatorfamilie

en: remove database objects owned by a database role
de: entfernt die einer Datenbankrolle gehörenden Datenbankobjekte

en: restore the value of a run-time parameter to the default value
de: setzt einen Konfigurationsparameter auf die Voreinstellung zurück

en: retrieve rows from a query using a cursor
de: liest Zeilen aus einer Anfrage mit einem Cursor

en: retrieve rows from a table or view
de: liest Zeilen aus einer Tabelle oder Sicht

en: roll back to a savepoint
de: rollt eine Transaktion bis zu einem Savepoint zurück

en: rule
de: Rule

en: sequence
de: Sequenz

en: set constraint checking modes for the current transaction
de: setzt die Constraint-Modi der aktuellen Transaktion

en: set the characteristics of the current transaction
de: setzt die Charakteristika der aktuellen Transaktion

en: set the current user identifier of the current session
de: setzt den aktuellen Benutzernamen der aktuellen Sitzung

en: set the session user identifier and the current user identifier of the current session
de: setzt den Sitzungsbenutzernamen und den aktuellen Benutzernamen der aktuellen Sitzung

en: show the execution plan of a statement
de: zeigt den Ausführungsplan eines Befehls

en: show the value of a run-time parameter
de: zeigt den Wert eines Konfigurationsparameters

en: special
de: speziell

en: stable
de: stabil

en: start a transaction block
de: startet einen Transaktionsblock

en: stop listening for a notification
de: beendet das Hören auf eine Benachrichtigung

en: table
de: Tabelle

en: trigger
de: Trigger

en: trying to exit copy mode
de: versuche, den COPY-Modus zu verlassen

en: unique,
de: eindeutig,

en: update rows of a table
de: aktualisiert Zeilen einer Tabelle

en: view
de: Sicht

en: volatile
de: volatil

en: window
de: Fenster

en: yes
de: ja
