PostgreSQL 8.4 - en to fr translation catalogue (642 entries)

en: 
    Connection options:
fr: 
    Options de connexion :

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.
fr: 
    Pour en savoir davantage, saisissez « \? » (pour les commandes internes) ou
    « \help » (pour les commandes SQL) dans psql, ou consultez la section psql
    de la documentation de PostgreSQL.

en: 
    Input and output options:
fr: 
    Options d'entrée/sortie :

en: 
    Output format options:
fr: 
    Options de formattage de la sortie :

en: 
    Parser: "%s"
fr: 
    Analyseur : « %s »

en: 
    Parser: "%s.%s"
fr: 
    Analyseur : « %s.%s »

en:   (options: S = show system objects, + = additional detail)
fr:   (options : S = affiche les objets systèmes, + = informations supplémentaires)

en:   --help                   show this help, then exit
fr:   --help          affiche cette aide, puis quitte

en:   --version                output version information, then exit
fr:   --version       affiche la version, puis quitte

en:   -1 ("one"), --single-transaction
                               execute command file as a single transaction
fr:   -1 (« un »), --single-transaction
                      exécute un fichier de commande dans une transaction unique

en:   -A, --no-align           unaligned table output mode
fr:   -A, --no-align  active le mode d'affichage non aligné des tables (-P
                      format=unaligned)

en:   -E, --echo-hidden        display queries that internal commands generate
fr:   -E, --echo-hidden
                      affiche les requêtes engendrées par les commandes internes

en:   -F, --field-separator=STRING
                               set field separator (default: "%s")
fr:   -F, --field-separator=CHAINE
                      initialise le séparateur de champs (par défaut : « %s »)
                      (-P fieldsep=)

en:   -H, --html               HTML table output mode
fr:   -H, --html      active le mode d'affichage HTML des tables (-P                  format=html)

en:   -L, --log-file=FILENAME  send session log to file
fr:   -L, --log-file=FICHIER
                      envoie les traces dans le fichier

en:   -P, --pset=VAR[=ARG]     set printing option VAR to ARG (see \pset command)
fr:   -P, --pset=VAR[=ARG]
                      initialise l'option d'impression VAR à ARG (voir la
                      commande \pset)

en:   -R, --record-separator=STRING
                               set record separator (default: newline)
fr:   -R, --record-separator=CHAINE
                      initialise le séparateur d'enregistrements (par défaut :
                      saut de ligne) (-P recordsep=)

en:   -S, --single-line        single-line mode (end of line terminates SQL command)
fr:   -S, --single-line
                      active le mode ligne par ligne (EOL termine la commande
                      SQL)

en:   -T, --table-attr=TEXT    set HTML table tag attributes (e.g., width, border)
fr:   -T, --table-attr=TEXTE
                      initialise les attributs des balises HTML de tableau
                      (largeur, bordure) (-P tableattr=)

en:   -U, --username=USERNAME  database user name (default: "%s")
fr:   -U, --username=NOM
                      nom d'utilisateur de la base de données (par défaut :
                      « %s »)

en:   -W, --password           force password prompt (should happen automatically)
fr:   -W, --password  force la demande du mot de passe (devrait survenir
                      automatiquement)

en:   -X, --no-psqlrc          do not read startup file (~/.psqlrc)
fr:   -X, --no-psqlrc ne lit pas le fichier de démarrage (~/.psqlrc)

en:   -a, --echo-all           echo all input from script
fr:   -a, --echo-all  affiche les lignes du script

en:   -c, --command=COMMAND    run only single command (SQL or internal) and exit
fr:   -c, --command=COMMANDE
                      exécute une commande unique (SQL ou interne), puis quitte

en:   -d, --dbname=DBNAME      database name to connect to (default: "%s")
fr:   -d, --dbname=NOM_BASE
                      indique le nom de la base de données à laquelle se
                      connecter (par défaut : « %s »)

en:   -e, --echo-queries       echo commands sent to server
fr:   -e, --echo-queries
                      affiche les commandes envoyées au serveur

en:   -f, --file=FILENAME      execute commands from file, then exit
fr:   -f, --file=FICHIER
                      exécute les commandes du fichier, puis quitte

en:   -h, --host=HOSTNAME      database server host or socket directory (default: "%s")
fr:   -h, --host=HOTE nom d'hôte du serveur de la base de données ou répertoire
                      de la socket (par défaut : %s)

en:   -l, --list               list available databases, then exit
fr:   -l, --list      affiche les bases de données disponibles, puis quitte

en:   -n, --no-readline        disable enhanced command line editing (readline)
fr:   -n, --no-readline
                      désactive l'édition avancée de la ligne de commande
                      (readline)

en:   -o, --output=FILENAME    send query results to file (or |pipe)
fr:   -o, --output=FICHIER
                      écrit les résultats des requêtes dans un fichier (ou
                      |tube)

en:   -p, --port=PORT          database server port (default: "%s")
fr:   -p, --port=PORT port du serveur de la base de données (par défaut :
                      « %s »)

en:   -q, --quiet              run quietly (no messages, only query output)
fr:   -q, --quiet     s'exécute silencieusement (pas de messages, uniquement le
                      résultat des requêtes)

en:   -s, --single-step        single-step mode (confirm each query)
fr:   -s, --single-step
                      active le mode étape par étape (confirmation pour chaque
                      requête)

en:   -t, --tuples-only        print rows only
fr:   -t, --tuples-only
                      affiche seulement les lignes (-P tuples_only)

en:   -v, --set=, --variable=NAME=VALUE
                               set psql variable NAME to VALUE
fr:   -v, --set, --variable NOM=VALEUR
                      initialise la variable psql NOM à VALEUR

en:   -w, --no-password        never prompt for password
fr:   -w, --no-password
                      ne demande jamais un mot de passe

en:   -x, --expanded           turn on expanded table output
fr:   -x, --expanded  active l'affichage étendu des tables (-P expanded)

en:   \! [COMMAND]           execute command in shell or start interactive shell
fr:   \! [COMMANDE]        exécute la commande dans un shell ou exécute un
                            shell interactif

en:   \C [STRING]            set table title, or unset if none
fr:   \C [CHAÎNE]          initialise le titre d'une table, ou le désactive en
                            l'absence d'argument

en:   \H                     toggle HTML output mode (currently %s)
fr:   \H                   bascule le mode de sortie HTML (actuellement %s)

en:   \T [STRING]            set HTML <table> tag attributes, or unset if none
fr:   \T [CHAÎNE]          initialise les attributs HTML de la balise <table>,
                            ou l'annule en l'absence d'argument

en:   \a                     toggle between unaligned and aligned output mode
fr:   \a                   bascule entre les modes de sortie alignée et non
                            alignée

en:   \c[onnect] [DBNAME|- USER|- HOST|- PORT|-]
                             connect to new database (currently "%s")
fr:   \c[onnect] [NOM_BASE|- UTILISATEUR|- HOTE|- PORT|-]
                            se connecte à une autre base de données
                            (actuellement « %s »)

en:   \cd [DIR]              change the current working directory
fr:   \cd [RÉPERTOIRE]     change de répertoire de travail

en:   \copy ...              perform SQL COPY with data stream to the client host
fr:   \copy ...            exécute SQL COPY avec le flux de données dirigé vers
                           l'hôte client

en:   \copyright             show PostgreSQL usage and distribution terms
fr:   \copyright           affiche les conditions d'utilisation et de
                           distribution de PostgreSQL

en:   \dC     [PATTERN]      list casts
fr:   \dC    [MODÈLE]      affiche la liste des transtypages

en:   \dD[S]  [PATTERN]      list domains
fr:   \dD[S] [MODÈLE]      affiche la liste des domaines

en:   \dF[+]  [PATTERN]      list text search configurations
fr:   \dF[+] [MODÈLE]      affiche la liste des configurations de la recherche
                            plein texte

en:   \dFd[+] [PATTERN]      list text search dictionaries
fr:   \dFd[+] [MODÈLE]     affiche la liste des dictionnaires de la recherche de
                            texte

en:   \dFp[+] [PATTERN]      list text search parsers
fr:   \dFp[+] [MODÈLE]        affiche la liste des analyseurs de la recherche de
                           texte

en:   \dFt[+] [PATTERN]      list text search templates
fr:   \dFt[+] [MODÈLE]     affiche la liste des modèles de la recherche de
                            texte

en:   \dT[S+] [PATTERN]      list data types
fr:   \dT[S+] [MODÈLE]     affiche la liste des types de données

en:   \d[S+]                 list tables, views, and sequences
fr:   \d[S+]               affiche la liste des tables, vues et séquences

en:   \d[S+]  NAME           describe table, view, sequence, or index
fr:   \d[S+] NOM           affiche la description de la table, de la vue,
                           de la séquence ou de l'index

en:   \da[+]  [PATTERN]      list aggregates
fr:   \da[+] [MODÈLE]      affiche la liste des aggrégats

en:   \db[+]  [PATTERN]      list tablespaces
fr:   \db[+] [MODÈLE]      affiche la liste des tablespaces

en:   \dc[S]  [PATTERN]      list conversions
fr:   \dc[S] [MODÈLE]      affiche la liste des conversions

en:   \dd[S]  [PATTERN]      show comments on objects
fr:   \dd[S] [MODÈLE]      affiche les commentaires de l'objet

en:   \des[+] [PATTERN]      list foreign servers
fr:   \des[+] [MODÈLE]     affiche la liste des serveurs distants

en:   \deu[+] [PATTERN]      list user mappings
fr:   \deu[+] [MODÈLE]     affiche la liste des correspondances utilisateurs

en:   \dew[+] [PATTERN]      list foreign-data wrappers
fr:   \dew[+] [MODÈLE]     affiche la liste des wrappers de données distantes

en:   \df[antw][S+] [PATRN]  list [only agg/normal/trigger/window] functions
fr:   \df[antw][S+] [PATRN] affiche la liste des fonctions
                            [seulement agg/normal/trigger/window]

en:   \dg[+]  [PATTERN]      list roles (groups)
fr:   \dg[+]  [MODÈLE]     affiche la liste des groupes

en:   \di[S+] [PATTERN]      list indexes
fr:   \di[S+] [MODÈLE]     affiche la liste des index

en:   \dl                    list large objects, same as \lo_list
fr:   \dl                  affiche la liste des « Large Objects », identique à
                            \lo_list

en:   \dn[+]  [PATTERN]      list schemas
fr:   \dn[+]  [MODÈLE]     affiche la liste des schémas

en:   \do[S]  [PATTERN]      list operators
fr:   \do[S]  [MODÈLE]     affiche la liste des opérateurs

en:   \dp     [PATTERN]      list table, view, and sequence access privileges
fr:   \dp     [MODÈLE]     affiche la liste des droits d'accès aux tables,
                            vues, séquences

en:   \ds[S+] [PATTERN]      list sequences
fr:   \ds[S+] [MODÈLE]     affiche la liste des séquences

en:   \dt[S+] [PATTERN]      list tables
fr:   \dt[S+] [MODÈLE]     affiche la liste des tables

en:   \du[+]  [PATTERN]      list roles (users)
fr:   \du[+]  [MODÈLE]     affiche la liste des rôles (utilisateurs)

en:   \dv[S+] [PATTERN]      list views
fr:   \dv[S+] [MODÈLE]     affiche la liste des vues

en:   \e [FILE]              edit the query buffer (or file) with external editor
fr:   \e [FICHIER]         édite le tampon de requête ou le fichier avec un
                            éditeur externe

en:   \echo [STRING]         write string to standard output
fr:   \echo [TEXTE]        écrit un texte sur la sortie standard

en:   \ef [FUNCNAME]         edit function definition with external editor
fr:   \ef [FONCTION]       édite la définition de fonction avec un éditeur
                            externe

en:   \encoding [ENCODING]   show or set client encoding
fr:   \encoding [ENCODAGE] affiche ou initialise l'encodage du client

en:   \f [STRING]            show or set field separator for unaligned query output
fr:   \f [CHAÎNE]          affiche ou initialise le séparateur de champ pour
                            une sortie non alignée des requêtes

en:   \g [FILE] or ;         execute query (and send results to file or |pipe)
fr:   \g [FICHIER] ou ;    envoie le tampon de requêtes au serveur (et les
                           résultats au fichier ou |tube)

en:   \h [NAME]              help on syntax of SQL commands, * for all commands
fr:   \h [NOM]             aide-mémoire pour les commandes SQL, * pour toutes
                           les commandes

en:   \i FILE                execute commands from file
fr:   \i FICHIER           exécute les commandes du fichier

en:   \l[+]                  list all databases
fr:   \l[+]                affiche la liste des bases de données

en:   \lo_export LOBOID FILE
      \lo_import FILE [COMMENT]
      \lo_list
      \lo_unlink LOBOID      large object operations
fr:   \lo_export OIDLOB FICHIER
      \lo_import FICHIER [COMMENTAIRE]
      \lo_list
      \lo_unlink OIDLOB
                            opérations sur les « Large Objects »

en:   \o [FILE]              send all query results to file or |pipe
fr:   \o [FICHIER]         envoie les résultats de la requête vers un fichier
                           ou un |tube

en:   \p                     show the contents of the query buffer
fr:   \p                   affiche le contenu du tampon de requête

en:   \password [USERNAME]   securely change the password for a user
fr:   \password [UTILISATEUR]
                            modifie de façon sécurisé le mot de passe d'un
                            utilisateur

en:   \prompt [TEXT] NAME    prompt user to set internal variable
fr:   \prompt [TEXTE] NOM  demande à l'utilisateur de configurer la variable
                            interne

en:   \pset NAME [VALUE]     set table output option
                             (NAME := {format|border|expanded|fieldsep|footer|null|
                             numericlocale|recordsep|tuples_only|title|tableattr|pager})
fr:   \pset NOM [VALEUR]   régler l'affichage de la table
                            (NOM := {format|border|expanded|fieldsep|footer|
                                     null|numericlocale|recordsep|tuples_only|
                                     title|tableattr|pager})

en:   \q                     quit psql
fr:   \q                   quitte psql

en:   \qecho [STRING]        write string to query output stream (see \o)
fr:   \qecho [TEXTE]       écrit un texte sur la sortie des résultats des
                           requêtes (voir \o)

en:   \r                     reset (clear) the query buffer
fr:   \r                   efface le tampon de requêtes

en:   \s [FILE]              display history or save it to file
fr:   \s [FICHIER]         affiche l'historique ou le sauvegarde dans un
                           fichier

en:   \set [NAME [VALUE]]    set internal variable, or list all if no parameters
fr:   \set [NOM [VALEUR]]  initialise une variable interne ou les affiche
                            toutes en l'absence de paramètre

en:   \t [on|off]            show only rows (currently %s)
fr:   \t                   affiche uniquement les lignes (actuellement %s)

en:   \timing [on|off]       toggle timing of commands (currently %s)
fr:   \timing [on|off]     bascule l'activation du chronométrage des commandes
                            (actuellement %s)

en:   \unset NAME            unset (delete) internal variable
fr:   \unset NOM           désactive (supprime) la variable interne

en:   \w FILE                write query buffer to file
fr:   \w [FICHIER]         écrit le contenu du tampon de requêtes dans un
                           fichier

en:   \x [on|off]            toggle expanded output (currently %s)
fr:   \x                   bascule l'affichage étendu (actuellement %s)

en:   \z      [PATTERN]      same as \dp
fr:   \z      [MODÈLE]     identique à \dp

en:   psql [OPTION]... [DBNAME [USERNAME]]
fr:   psql [OPTIONS]... [NOM_BASE [NOM_UTILISATEUR]]

en:  as user "%s"
fr:  comme utilisateur « %s »

en:  at port "%s"
fr:  sur le port « %s »

en:  on host "%s"
fr:  sur l'hôte « %s »

en: %d connection | %d connections
fr[0]: %d connexion
fr[1]: %d connexions

en: %s (%s, server %s)
fr: %s (%s, serveur %s)

en: %s: %s
fr: %s : %s

en: %s: cannot copy from/to a directory
fr: %s : ne peut pas copier à partir de/vers un répertoire

en: %s: could not delete variable "%s"
fr: %s : n'a pas pu effacer la variable « %s »

en: %s: could not open log file "%s": %s
fr: %s : n'a pas pu ouvrir le journal applicatif « %s » : %s

en: %s: could not set printing parameter "%s"
fr: %s : n'a pas pu configurer le paramètre d'impression « %s »

en: %s: could not set variable "%s"
fr: %s : n'a pas pu initialiser la variable « %s »

en: %s: current transaction is aborted
fr: %s : la transaction en cours est abandonnée

en: %s: invalid encoding name or conversion procedure not found
fr: %s : nom d'encodage invalide ou procédure de conversion introuvable

en: %s: not connected to a database
fr: %s : non connecté à une base de données

en: %s: pg_strdup: cannot duplicate null pointer (internal error)
fr: %s : pg_strdup : ne peut pas dupliquer le pointeur null (erreur interne)

en: %s: unknown transaction status
fr: %s : état de la transaction inconnu

en: %s: warning: extra command-line argument "%s" ignored
fr: %s : attention : option supplémentaire « %s » ignorée

en: (%lu row) | (%lu rows)
fr[0]: (%lu ligne)
fr[1]: (%lu lignes)

en: (No rows)
fr: (Aucune ligne)

en: ***(Single step mode: verify command)*******************************************
    %s
    ***(press return to proceed or enter x and return to cancel)********************
fr: ***(Mode étape par étape: vérifiez la commande)*********************************
    %s
    ***(appuyez sur entrée pour l'exécuter ou tapez x puis entrée pour annuler)***

en: ********* QUERY **********
    %s
    **************************
fr: ******** REQUÊTE *********
    %s
    **************************

en: , clustered
fr: , en cluster

en: , invalid
fr: , invalide

en: , predicate (%s)
fr: , prédicat (%s)

en: , tablespace "%s"
fr: , 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
fr: ALTER AGGREGATE nom ( type [ , ... ] ) RENAME TO nouveau_nom
    ALTER AGGREGATE nom ( type [ , ... ] ) OWNER TO nouveau_propriétaire
    ALTER AGGREGATE nom ( type [ , ... ] ) SET SCHEMA nouveau_schéma

en: ALTER CONVERSION name RENAME TO newname
    ALTER CONVERSION name OWNER TO newowner
fr: ALTER CONVERSION nom RENAME TO nouveau_nom
    ALTER CONVERSION nom OWNER TO nouveau_propriétaire

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
fr: ALTER DATABASE nom [ [ WITH ] option [ ... ] ]
    
    où option peut être:
    
        CONNECTION LIMIT limite_connexion
    
    ALTER DATABASE nom RENAME TO nouveau_nom
    
    ALTER DATABASE nom OWNER TO nouveau_propriétaire
    
    ALTER DATABASE nom SET TABLESPACE nouveau_tablespace
    
    ALTER DATABASE nom SET paramètre_configuration { TO | = } { valeur | DEFAULT }
    ALTER DATABASE nom SET paramètre_configuration FROM CURRENT
    ALTER DATABASE nom RESET paramètre_configuration
    ALTER DATABASE nom 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
fr: ALTER DOMAIN nom
        { SET DEFAULT expression | DROP DEFAULT }
    ALTER DOMAIN nom
        { SET | DROP } NOT NULL
    ALTER DOMAIN nom
        ADD contrainte_domaine
    ALTER DOMAIN nom
        DROP CONSTRAINT nom_contrainte [ RESTRICT | CASCADE ]
    ALTER DOMAIN nom
        OWNER TO nouveau_propriétaire 
    ALTER DOMAIN nom
        SET SCHEMA nouveau_schéma

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
fr: ALTER FOREIGN DATA WRAPPER nom
        [ VALIDATOR fonction_validation | NO VALIDATOR ]
        [ OPTIONS ( [ ADD | SET | DROP ] option ['valeur'] [, ... ]) ]
    ALTER FOREIGN DATA WRAPPER nom OWNER TO nouveau_propriétaire

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
fr: ALTER FUNCTION nom ( [ [ mode_arg ] [ nom_arg ] type_arg [, ...] ] )
        action [, ... ] [ RESTRICT ]
    ALTER FUNCTION nom ( [ [ mode_arg ] [ nom_arg ] type_arg [, ...] ] )
        RENAME TO nouveau_nom
    ALTER FUNCTION nom ( [ [ mode_arg ] [ nom_arg ] type_arg [, ...] ] )
        OWNER TO nouveau_proprietaire
    ALTER FUNCTION nom ( [ [ mode_arg ] [ nom_arg ] type_arg [, ...] ] )
        SET SCHEMA nouveau_schema
    
    où action peut être :
    
        CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
        IMMUTABLE | STABLE | VOLATILE
        [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
        COST cout_execution
        ROWS lignes_resultats
        SET paramètre { TO | = } { valeur | DEFAULT }
        SET paramètre FROM CURRENT
        RESET paramètre
        RESET ALL

en: ALTER GROUP groupname ADD USER username [, ... ]
    ALTER GROUP groupname DROP USER username [, ... ]
    
    ALTER GROUP groupname RENAME TO newname
fr: ALTER GROUP nom_groupe ADD USER nom_utilisateur [, ... ]
    ALTER GROUP nom_groupe DROP USER nom_utilisateur [, ... ]
    
    ALTER GROUP nom_groupe RENAME TO nouveau_nom

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 [, ... ] )
fr: ALTER INDEX nom RENAME TO nouveau_nom
    ALTER INDEX nom SET TABLESPACE nom_tablespace
    ALTER INDEX nom SET ( paramètre_stockage = valeur [, ... ] )
    ALTER INDEX nom RESET ( paramètre_stockage [, ... ] )

en: ALTER OPERATOR CLASS name USING index_method RENAME TO newname
    ALTER OPERATOR CLASS name USING index_method OWNER TO newowner
fr: ALTER OPERATOR CLASS nom USING méthode_indexation
      RENAME TO nouveau_nom
    ALTER OPERATOR CLASS nom USING méthode_indexation
      OWNER TO nouveau_propriétaire

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
fr: ALTER OPERATOR FAMILY nom USING méthode_indexage ADD
      {  OPERATOR numéro_stratégie nom_opérateur ( type_op, type_op ) 
        | FUNCTION numéro_support [ ( type_op [ , type_op ] ) ]
          nom_fonction ( type_argument [, ...] )
      } [, ... ]
    ALTER OPERATOR FAMILY nom USING méthode_indexage DROP
      {  OPERATOR numéro_stratégie ( type_op [ , type_op ] )
        | FUNCTION numéro_support ( type_op [ , type_op ] )
      } [, ... ]
    ALTER OPERATOR FAMILY nom USING méthode_indexage
      RENAME TO nouveau_nom
    ALTER OPERATOR FAMILY nom USING méthode_indexage
      OWNER TO nouveau_propriétaire

en: ALTER OPERATOR name ( { lefttype | NONE } , { righttype | NONE } ) OWNER TO newowner
fr: ALTER OPERATOR nom ( { lefttype | NONE } , { righttype | NONE } )
      OWNER TO nouveau_propriétaire

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
fr: ALTER ROLE nom [ [ WITH ] option [ ... ] ]
    
    où option peut être :
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT limite_connexions
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'mot de passe'
        | VALID UNTIL 'timestamp' 
    
    ALTER ROLE nom RENAME TO nouveau_nom
    
    ALTER ROLE nom SET paramètre { TO | = } { valeur | DEFAULT }
    ALTER ROLE name SET paramètre FROM CURRENT
    ALTER ROLE nom RESET paramètre
    ALTER ROLE name RESET ALL

en: ALTER SCHEMA name RENAME TO newname
    ALTER SCHEMA name OWNER TO newowner
fr: ALTER SCHEMA nom RENAME TO nouveau_nom
    ALTER SCHEMA nom OWNER TO nouveau_propriétaire

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
fr: ALTER SEQUENCE nom [ INCREMENT [ BY ] incrément ]
        [ MINVALUE valeur_min | NO MINVALUE ] [ MAXVALUE valeur_max | NO MAXVALUE ]
        [ START [ WITH ] valeur_début ]
        [ RESTART [ [ WITH ] valeur_redémarrage ] ]
        [ CACHE cache ] [ [ NO ] CYCLE ]
        [ OWNED BY { table.colonne | NONE } ]
    ALTER SEQUENCE nom OWNER TO new_propriétaire
    ALTER SEQUENCE nom RENAME TO new_nom
    ALTER SEQUENCE nom SET SCHEMA new_schéma

en: ALTER SERVER servername [ VERSION 'newversion' ]
        [ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] ) ]
    ALTER SERVER servername OWNER TO new_owner
fr: ALTER SERVER nom [ VERSION 'nouvelleversion' ]
        [ OPTIONS ( [ ADD | SET | DROP ] option ['valeur'] [, ... ] ) ]
    ALTER SERVER nom OWNER TO nouveau_propriétaire

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
fr: ALTER TABLE [ ONLY ] nom [ * ]
        action [, ... ]
    ALTER TABLE [ ONLY ] nom [ * ]
        RENAME [ COLUMN ] colonne TO nouvelle_colonne
    ALTER TABLE nom
        RENAME TO nouveau_nom
    ALTER TABLE nom
        SET SCHEMA nouveau_schema
    
    où action peut être :
    
        ADD [ COLUMN ] colonne type [ contrainte_colonne [ ... ] ]
        DROP [ COLUMN ] colonne [ RESTRICT | CASCADE ]
        ALTER [ COLUMN ] colonne [ SET DATA ] TYPE type [ USING expression ]
        ALTER [ COLUMN ] colonne SET DEFAULT expression
        ALTER [ COLUMN ] colonne DROP DEFAULT
        ALTER [ COLUMN ] colonne { SET | DROP } NOT NULL
        ALTER [ COLUMN ] colonne SET STATISTICS entier
        ALTER [ COLUMN ] colonne SET STORAGE
            { PLAIN | EXTERNAL | EXTENDED | MAIN }
        ADD contrainte_table
        DROP CONSTRAINT nom_contrainte [ RESTRICT | CASCADE ]
        DISABLE TRIGGER [ nom_trigger | ALL | USER ]
        ENABLE TRIGGER [ nom_trigger | ALL | USER ]
        ENABLE REPLICA TRIGGER nom_trigger
        ENABLE ALWAYS TRIGGER nom_trigger
        DISABLE RULE nom_règle_réécriture
        ENABLE RULE nom_règle_réécriture
        ENABLE REPLICA RULE nom_règle_réécriture
        ENABLE ALWAYS RULE nom_règle_réécriture
        CLUSTER ON nom_index
        SET WITHOUT CLUSTER
        SET WITH OIDS
        SET WITHOUT OIDS
        SET ( paramètre_stockage = valeur [, ... ] )
        RESET ( paramètre_stockage [, ... ] )
        INHERIT table_parent
        NO INHERIT table_parent
        OWNER TO nouveau_propriétaire
        SET TABLESPACE nouveau_tablespace

en: ALTER TABLESPACE name RENAME TO newname
    ALTER TABLESPACE name OWNER TO newowner
fr: ALTER TABLESPACE nom RENAME TO nouveau_nom
    ALTER TABLESPACE nom OWNER TO nouveau_propriétaire

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
fr: ALTER TEXT SEARCH CONFIGURATION nom
        ADD MAPPING FOR type_jeton [, ... ] WITH nom_dictionnaire [, ... ]
    ALTER TEXT SEARCH CONFIGURATION nom
        ALTER MAPPING FOR type_jeton [, ... ] WITH nom_dictionnaire [, ... ]
    ALTER TEXT SEARCH CONFIGURATION nom
        ALTER MAPPING REPLACE ancien_dictionnaire WITH nouveau_dictionnaire
    ALTER TEXT SEARCH CONFIGURATION nom
        ALTER MAPPING FOR type_jeton [, ... ]
        REPLACE ancien_dictionnaire WITH nouveau_dictionnaire
    ALTER TEXT SEARCH CONFIGURATION nom
        DROP MAPPING [ IF EXISTS ] FOR type_jeton [, ... ]
    ALTER TEXT SEARCH CONFIGURATION nom RENAME TO nouveau_nom
    ALTER TEXT SEARCH CONFIGURATION nom OWNER TO nouveau_propriétaire

en: ALTER TEXT SEARCH DICTIONARY name (
        option [ = value ] [, ... ]
    )
    ALTER TEXT SEARCH DICTIONARY name RENAME TO newname
    ALTER TEXT SEARCH DICTIONARY name OWNER TO newowner
fr: ALTER TEXT SEARCH DICTIONARY nom (
        option [ = valeur ] [, ... ]
    )
    ALTER TEXT SEARCH DICTIONARY nom RENAME TO nouveau_nom
    ALTER TEXT SEARCH DICTIONARY nom OWNER TO nouveau_propriétaire

en: ALTER TEXT SEARCH PARSER name RENAME TO newname
fr: ALTER TEXT SEARCH PARSER nom RENAME TO nouveau_nom

en: ALTER TEXT SEARCH TEMPLATE name RENAME TO newname
fr: ALTER TEXT SEARCH TEMPLATE nom RENAME TO nouveau_nom

en: ALTER TRIGGER name ON table RENAME TO newname
fr: ALTER TRIGGER nom ON table RENAME TO nouveau_nom

en: ALTER TYPE name RENAME TO new_name
    ALTER TYPE name OWNER TO new_owner 
    ALTER TYPE name SET SCHEMA new_schema
fr: ALTER TYPE nom RENAME TO nouveau_nom
    ALTER TYPE nom OWNER TO nouveau_propriétaire
    ALTER TYPE nom SET SCHEMA nouveau_schéma

en: ALTER USER MAPPING FOR { username | USER | CURRENT_USER | PUBLIC }
        SERVER servername
        OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
fr: ALTER USER MAPPING FOR { nom_utilisateur | USER | CURRENT_USER | PUBLIC }
        SERVER nom_serveur
        OPTIONS ( [ ADD | SET | DROP ] option ['valeur'] [, ... ] )

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
fr: ALTER USER nom [ [ WITH ] option [ ... ] ]
    
    où option peut être :
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT limite_connexion
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'motdepasse'
        | VALID UNTIL 'timestamp' 
    
    ALTER USER nom RENAME TO nouveau_nom
    
    ALTER USER nom SET paramètre { TO | = } { valeur | DEFAULT }
    ALTER USER name SET paramètre FROM CURRENT
    ALTER USER nom RESET paramètre
    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
fr: ALTER VIEW nom ALTER [ COLUMN ] colonne SET DEFAULT expression
    ALTER VIEW nom ALTER [ COLUMN ] colonne DROP DEFAULT
    ALTER VIEW nom OWNER TO nouveau_propriétaire
    ALTER VIEW nom RENAME TO nouveau_nom
    ALTER VIEW nom SET SCHEMA nouveau_schéma

en: ALTER [ PROCEDURAL ] LANGUAGE name RENAME TO newname
    ALTER [ PROCEDURAL ] LANGUAGE name OWNER TO new_owner
fr: ALTER [ PROCEDURAL ] LANGUAGE nom RENAME TO nouveau_nom
    ALTER [ PROCEDURAL ] LANGUAGE nom OWNER TO nouveau_propriétaire

en: ANALYZE [ VERBOSE ] [ table [ ( column [, ...] ) ] ]
fr: ANALYZE [ VERBOSE ] [ table [ ( colonne [, ...] ) ] ]

en: Access privileges
fr: Droits d'accès

en: Argument data types
fr: Type de données des paramètres

en: Asynchronous notification "%s" received from server process with PID %d.
fr: Notification asynchrone « %s » reçue en provenance du processus serveur de
    PID %d.

en: Attributes
fr: Attributs

en: Available help:
fr: Aide-mémoire disponible :

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
fr: BEGIN [ WORK | TRANSACTION ] [ transaction_mode [, ...] ]
    
    où transaction_mode peut être :
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ |
                          READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY

en: Border style is %d.
fr: Le style de bordure est %d.

en: CLOSE { name | ALL }
fr: CLOSE { nom | ALL }

en: CLUSTER [VERBOSE] tablename [ USING indexname ]
    CLUSTER [VERBOSE]
fr: CLUSTER [VERBOSE] nom_table [ USING nom_index ]
    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'
fr: COMMENT ON
    {
      TABLE nom_objet |
      COLUMN nom_table.nom_colonne |
      AGGREGATE nom_agg (type_agg [, ...] ) |
      CAST (type_source AS type_cible) |
      CONSTRAINT nom_contrainte ON nom_table |
      CONVERSION nom_objet |
      DATABASE nom_objet |
      DOMAIN nom_objet |
      FUNCTION nom_fonction ( [ [ mode_arg ] [ nom_arg ] type_arg [, ...] ] ) |
      INDEX nom_objet |
      LARGE OBJECT oid_LO |
      OPERATOR op (type_operande_gauche, type_operande_droit) |
      OPERATOR CLASS nom_objet USING methode_indexage |
      OPERATOR FAMILY nom_objet USING methode_indexage |
      [ PROCEDURAL ] LANGUAGE nom_objet |
      ROLE nom_objet |
      RULE nom_regle ON nom_table |
      SCHEMA nom_objet |
      SEQUENCE nom_objet |
      TABLESPACE nom_objet |
      TEXT SEARCH CONFIGURATION nom_objet |
      TEXT SEARCH DICTIONARY nom_objet |
      TEXT SEARCH PARSER nom_objet |
      TEXT SEARCH TEMPLATE nom_objet |
      TRIGGER nom_trigger ON nom_objet |
      TYPE nom_objet |
      VIEW nom_objet
    } IS 'text'

en: COMMIT PREPARED transaction_id
fr: COMMIT PREPARED id_transaction

en: COPY data transfer failed: %s
fr: Échec du transfert de données COPY : %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 [, ...] ]
fr: COPY nom_table [ ( colonne [, ...] ) ]
        FROM { 'nom_fichier' | STDIN }
        [ [ WITH ] 
              [ BINARY ]
              [ OIDS ]
              [ DELIMITER [ AS ] 'délimiteur' ]
              [ NULL [ AS ] 'chaîne null' ]
              [ CSV [ HEADER ]
                    [ QUOTE [ AS ] 'guillemet' ] 
                    [ ESCAPE [ AS ] 'échappement' ]
                    [ FORCE NOT NULL colonne [, ...] ]
    
    COPY { nom_table [ ( colonne [, ...] ) ] | ( requête ) }
        TO { 'nom_fichier' | STDOUT }
        [ [ WITH ] 
              [ BINARY ]
              [ OIDS ]
              [ DELIMITER [ AS ] 'délimiteur' ]
              [ NULL [ AS ] 'chaîne null' ]
              [ CSV [ HEADER ]
                    [ QUOTE [ AS ] 'guillemet' ] 
                    [ ESCAPE [ AS ] 'échappement' ]
                    [ FORCE QUOTE colonne [, ...] ]

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 ]
    )
fr: CREATE AGGREGATE nom ( type_données_en_entrée [ , ... ] ) (
        SFUNC = sfonction,
        STYPE = type_données_état
        [ , FINALFUNC = fonction_f ]
        [ , INITCOND = condition_initiale ]
        [ , SORTOP = opérateur_tri ]
    )
    
    ou l'ancienne syntaxe
    
    CREATE AGGREGATE nom (
        BASETYPE = type_base,
        SFUNC = fonction_s,
        STYPE = type_données_état
        [ , FINALFUNC = fonction_f ]
        [ , INITCOND = condition_initiale ]
        [ , SORTOP = opérateur_tri ]
    )

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 ]
fr: CREATE CAST (type_source AS type_cible)
        WITH FUNCTION nom_fonction (type_argument)
        [ AS ASSIGNMENT | AS IMPLICIT ]
    
    CREATE CAST (type_source AS type_cible)
        WITHOUT FUNCTION
        [ AS ASSIGNMENT | AS IMPLICIT ]
    
    CREATE CAST (type_source AS type_cible)
        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 )
fr: CREATE CONSTRAINT TRIGGER nom
        AFTER événement [ OR ... ]
        ON table
        [ FROM table_référencée ]
        { NOT DEFERRABLE | [ DEFERRABLE ]        { INITIALLY IMMEDIATE | INITIALLY DEFERRED } }
        FOR EACH ROW
        EXECUTE PROCEDURE nom_fonction ( arguments )

en: CREATE DATABASE name
        [ [ WITH ] [ OWNER [=] dbowner ]
               [ TEMPLATE [=] template ]
               [ ENCODING [=] encoding ]
               [ LC_COLLATE [=] lc_collate ]
               [ LC_CTYPE [=] lc_ctype ]
               [ TABLESPACE [=] tablespace ]
               [ CONNECTION LIMIT [=] connlimit ] ]
fr: CREATE DATABASE nom
        [ [ WITH ] [ OWNER [=] nom_propriétaire ]
               [ TEMPLATE [=] modèle ]
               [ ENCODING [=] encodage ]
               [ LC_COLLATE [=] tri_caract ]
               [ LC_CTYPE [=] type_caract ]
               [ TABLESPACE [=] tablespace ]
               [ CONNECTION LIMIT [=] limite_connexion ] ]

en: CREATE DOMAIN name [ AS ] data_type
        [ DEFAULT expression ]
        [ constraint [ ... ] ]
    
    where constraint is:
    
    [ CONSTRAINT constraint_name ]
    { NOT NULL | NULL | CHECK (expression) }
fr: CREATE DOMAIN nom [AS] type_données
        [ DEFAULT expression ]
        [ contrainte [ ... ] ]
    
    avec comme contrainte :
    
    [ CONSTRAINT nom_contrainte ]
    { NOT NULL | NULL | CHECK (expression) }

en: CREATE FOREIGN DATA WRAPPER name
        [ VALIDATOR valfunction | NO VALIDATOR ]
        [ OPTIONS ( option 'value' [, ... ] ) ]
fr: CREATE FOREIGN DATA WRAPPER nom
        [ VALIDATOR fonction_validation | NO VALIDATOR ]
        [ OPTIONS ( option 'valeur' [, ... ] ) ]

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
fr: CREATE GROUP nom [ [ WITH ] option [ ... ] ]
    
    où option peut être :
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'motdepasse'
        | VALID UNTIL 'timestamp' 
        | IN ROLE nom_rôle [, ...]
        | IN GROUP nom_rôle [, ...]
        | ROLE nom_rôle [, ...]
        | ADMIN nom_rôle [, ...]
        | USER nom_rôle [, ...]
        | 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
      } [, ... ]
fr: CREATE OPERATOR CLASS nom [ DEFAULT ] FOR TYPE type_donnée
      USING méthode_indexage [ FAMILY nom_famille ] AS
      { OPERATOR numéro_stratégie nom_operateur [ ( op_type, op_type ) ]
        | FUNCTION numéro_support [ ( type_op [ , type_op ] ) ]
          nom_fonction ( type_argument [, ...] )
        | STORAGE type_stockage
      } [, ... ]

en: CREATE OPERATOR FAMILY name USING index_method
fr: CREATE OPERATOR FAMILY nom USING methode_indexage

en: CREATE OPERATOR name (
        PROCEDURE = funcname
        [, LEFTARG = lefttype ] [, RIGHTARG = righttype ]
        [, COMMUTATOR = com_op ] [, NEGATOR = neg_op ]
        [, RESTRICT = res_proc ] [, JOIN = join_proc ]
        [, HASHES ] [, MERGES ]
    )
fr: CREATE OPERATOR nom (
        PROCEDURE = nom_fonction
        [, LEFTARG = type_gauche ] [, RIGHTARG = type_droit ]
        [, COMMUTATOR = op_com ] [, NEGATOR = op_neg ]
        [, RESTRICT = proc_res ] [, JOIN = proc_join ]
        [, 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
fr: CREATE ROLE nom [ [ WITH ] option [ ... ] ]
    
    où option peut être :
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT limite_connexion
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'motdepasse'
        | VALID UNTIL 'timestamp' 
        | IN ROLE nom_rôle [, ...]
        | IN GROUP nom_rôle [, ...]
        | ROLE nom_rôle [, ...]
        | ADMIN nom_rôle [, ...]
        | USER nom_rôle [, ...]
        | SYSID uid

en: CREATE SCHEMA schemaname [ AUTHORIZATION username ] [ schema_element [ ... ] ]
    CREATE SCHEMA AUTHORIZATION username [ schema_element [ ... ] ]
fr: CREATE SCHEMA nom_schema [ AUTHORIZATION nom_utilisateur ]
      [ element_schema [ ... ] ]
    CREATE SCHEMA AUTHORIZATION nom_utilisateur [ element_schema [ ... ] ]

en: CREATE SERVER servername [ TYPE 'servertype' ] [ VERSION 'serverversion' ]
        FOREIGN DATA WRAPPER fdwname
        [ OPTIONS ( option 'value' [, ... ] ) ]
fr: CREATE SERVER nom [ TYPE 'typeserveur' ] [ VERSION 'versionserveur' ]
        FOREIGN DATA WRAPPER nomfdw
        [ OPTIONS ( option 'valeur' [, ... ] ) ]

en: CREATE TABLESPACE tablespacename [ OWNER username ] LOCATION 'directory'
fr: CREATE TABLESPACE nom_tablespace [ OWNER nom_utilisateur ]
        LOCATION 'répertoire'

en: CREATE TEXT SEARCH CONFIGURATION name (
        PARSER = parser_name |
        COPY = source_config
    )
fr: CREATE TEXT SEARCH CONFIGURATION nom (
        PARSER = nom_analyseur |
        COPY = config_source
    )

en: CREATE TEXT SEARCH DICTIONARY name (
        TEMPLATE = template
        [, option = value [, ... ]]
    )
fr: CREATE TEXT SEARCH DICTIONARY nom (
        TEMPLATE = modèle
        [, option = valeur [, ... ]]
    )

en: CREATE TEXT SEARCH PARSER name (
        START = start_function ,
        GETTOKEN = gettoken_function ,
        END = end_function ,
        LEXTYPES = lextypes_function
        [, HEADLINE = headline_function ]
    )
fr: CREATE TEXT SEARCH PARSER nom (
        START = fonction_debut ,
        GETTOKEN = fonction_jeton ,
        END = fonction_fin ,
        LEXTYPES = fonction_typeslexem
        [, HEADLINE = fonction_entete ]
    )

en: CREATE TEXT SEARCH TEMPLATE name (
        [ INIT = init_function , ]
        LEXIZE = lexize_function
    )
fr: CREATE TEXT SEARCH TEMPLATE nom (
        [ INIT = fonction_init , ]
        LEXIZE = fonction_lexize
    )

en: CREATE TRIGGER name { BEFORE | AFTER } { event [ OR ... ] }
        ON table [ FOR [ EACH ] { ROW | STATEMENT } ]
        EXECUTE PROCEDURE funcname ( arguments )
fr: CREATE TRIGGER nom { BEFORE | AFTER } { événement [ OR ... ] }
        ON table [ FOR [ EACH ] { ROW | STATEMENT } ]
        EXECUTE PROCEDURE nom_fonction ( arguments )

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
fr: CREATE TYPE nom AS
        ( nom_attribut type_donnee [, ... ] )
    
    CREATE TYPE nom AS ENUM
        ( 'label' [, ... ] )
    
    CREATE TYPE nom (
        INPUT = fonction_entrée,
        OUTPUT = fonction_sortie
        [ , RECEIVE = fonction_réception ]
        [ , SEND = fonction_envoi ]
        [ , TYPMOD_IN = fonction_entrée_modif_type ]
        [ , TYPMOD_OUT = fonction_sortie_modif_type ]
        [ , ANALYZE = fonction_analyse ]
        [ , INTERNALLENGTH = { longueur_interne | VARIABLE } ]
        [ , PASSEDBYVALUE ]
        [ , ALIGNMENT = alignement ]
        [ , STORAGE = stockage ]
        [ , LIKE = type_like ]
        [ , CATEGORY = catégorie ]
        [ , PREFERRED = préféré ]
        [ , DEFAULT = valeur_par_défaut ]
        [ , ELEMENT = élément ]
        [ , DELIMITER = délimiteur ]
    )
    
    CREATE TYPE nom

en: CREATE USER MAPPING FOR { username | USER | CURRENT_USER | PUBLIC }
        SERVER servername
        [ OPTIONS ( option 'value' [ , ... ] ) ]
fr: CREATE USER MAPPING FOR { nomutilisateur | USER | CURRENT_USER | PUBLIC }
        SERVER nomserveur
        [ OPTIONS ( option 'valeur' [ , ... ] ) ]

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
fr: CREATE USER nom [ [ WITH ] option [ ... ] ]
    
    où option peut être :
        
          SUPERUSER | NOSUPERUSER
        | CREATEDB | NOCREATEDB
        | CREATEROLE | NOCREATEROLE
        | CREATEUSER | NOCREATEUSER
        | INHERIT | NOINHERIT
        | LOGIN | NOLOGIN
        | CONNECTION LIMIT limite_connexion
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'motdepasse'
        | VALID UNTIL 'timestamp' 
        | IN ROLE nom_rôle [, ...]
        | IN GROUP nom_rôle [, ...]
        | ROLE nom_rôle [, ...]
        | ADMIN nom_rôle [, ...]
        | USER nom_rôle [, ...]
        | SYSID uid

en: CREATE [ DEFAULT ] CONVERSION name
        FOR source_encoding TO dest_encoding FROM funcname
fr: CREATE [DEFAULT] CONVERSION nom
        FOR codage_source TO codage_cible FROM nom_fonction

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 [, ...] ) ]
fr: CREATE [ OR REPLACE ] FUNCTION
        nom ( [ [ mode_arg ] [ nom_arg ] type_arg [ { DEFAULT | = } expr_par_défaut ] [, ...] ] )
        [ RETURNS type_ret
          | RETURNS TABLE ( nom_colonne type_colonne [, ...] ) ]
      { LANGUAGE nom_lang
        | WINDOW
        | IMMUTABLE | STABLE | VOLATILE
        | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
        | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
        | COST coût_exécution
        | ROWS lignes_résultats
        | SET paramètre_configuration { TO valeur | = valeur | FROM CURRENT }
        | AS 'définition'
        | AS 'fichier_obj', 'symbôle_lien'
      } ...
        [ WITH ( attribut [, ...] ) ]

en: CREATE [ OR REPLACE ] RULE name AS ON event
        TO table [ WHERE condition ]
        DO [ ALSO | INSTEAD ] { NOTHING | command | ( command ; command ... ) }
fr: CREATE [ OR REPLACE ] RULE nom AS ON événement
        TO table [ WHERE condition ]
        DO [ ALSO | INSTEAD ] { NOTHING | commande | ( commande ; commande ... ) }

en: CREATE [ OR REPLACE ] [ TEMP | TEMPORARY ] VIEW name [ ( column_name [, ...] ) ]
        AS query
fr: CREATE [ OR REPLACE ] [ TEMP | TEMPORARY ] VIEW nom
        [ ( nom_colonne [, ...] ) ]
        AS requête

en: CREATE [ PROCEDURAL ] LANGUAGE name
    CREATE [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
        HANDLER call_handler [ VALIDATOR valfunction ]
fr: CREATE [ PROCEDURAL ] LANGUAGE nom
    CREATE [ TRUSTED ] [ PROCEDURAL ] LANGUAGE nom
        HANDLER gestionnaire_appels [ VALIDATOR fonction_val ]

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 } ]
fr: CREATE [ TEMPORARY | TEMP ] SEQUENCE nom [ INCREMENT [ BY ] incrémentation ]
        [ MINVALUE valeur_mini | NO MINVALUE ]
        [ MAXVALUE valeur_maxi | NO MAXVALUE ]
        [ START [ WITH ] valeur_départ ]
        [ CACHE en_cache ]
        [ [ NO ] CYCLE ]
        [ OWNED BY { table.colonne | 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 ]
fr: CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] nom ON table [ USING methode ]
        ( { colonne | ( expression ) } [ classe_operateur ]
            [ ASC | DESC ]
            [ NULLS { FIRST | LAST } ] [, ...] )
        [ WITH ( parametre_stockage = valeur [, ... ] ) ]
        [ TABLESPACE tablespace ]
        [ WHERE predicat ]

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 ]
fr: CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE nom_table
        [ (nom_colonne [, ...] ) ]
        [ WITH ( paramètre_stockage [= valeur] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
        [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
        [ TABLESPACE tablespace ]
        AS requête    [ 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 ]
fr: CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE nom_table ( [
      { nom_colonne type_données [ DEFAULT expr_par_défaut ]
        [ contrainte_colonne [ ... ] ]
        | contrainte_table
        | LIKE table_parent [ { INCLUDING | EXCLUDING }
          { DEFAULTS | CONSTRAINTS | INDEXES } ] ... }
        [, ... ]
    ] )
    [ INHERITS ( table_parent [, ... ] ) ]
    [ WITH ( paramètre_stockage [= valeur] [, ... ] )  | WITH OIDS | WITHOUT OIDS ]
    [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
    [ TABLESPACE tablespace ]
    
    où colonne_contrainte peut être :
    
    [ CONSTRAINT nom_contrainte ]
    { NOT NULL | 
      NULL | 
      UNIQUE paramètres_index |
      PRIMARY KEY paramètres_index |
      CHECK (expression) |
      REFERENCES table_référée [ ( colonne_referrée ) ]
        [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
        [ ON DELETE action ] [ ON UPDATE action ] }
    [ DEFERRABLE | NOT DEFERRABLE ]
    [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
    
    et contrainte_table peut être :
    
    [ CONSTRAINT nom_contrainte ]
    { UNIQUE ( nom_colonne [, ... ] ) paramètres_index |
      PRIMARY KEY ( nom_colonne [, ... ] ) paramètres_index |
      CHECK ( expression ) |
      FOREIGN KEY ( nom_colonne [, ... ] ) REFERENCES
        table_référée [ ( colonne_référée [, ... ] ) ]
      [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
      [ ON DELETE action ] [ ON UPDATE action ] }
    [ DEFERRABLE | NOT DEFERRABLE ]
    [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
    
    les paramètres_index dans les contraintes UNIQUE et PRIMARY KEY sont :
    
    [ WITH ( paramètre_stockage [= valeur] [, ... ] ) ]
    [ USING INDEX TABLESPACE espace_logique ]

en: Cannot add cell to table content: total cell count of %d exceeded.
fr: Ne peut pas ajouter une cellule au contenu de la table : le nombre total des
    cellules %d est dépassé.

en: Cannot add header to table content: column count of %d exceeded.
fr: Ne peut pas ajouter l'en-tête au contenu de la table : le nombre de colonnes
    %d est dépassé.

en: Cannot login
fr: Ne peut pas se connecter

en: Check
fr: Vérification

en: Check constraints:
fr: Contraintes de vérification :

en: Collation
fr: Tri

en: Column
fr: Colonne

en: Column access privileges
fr: Droits d'accès à la colonne

en: Command:     %s
    Description: %s
    Syntax:
    %s
fr: Commande :    %s
    Description : %s
    Syntaxe :
    %s

en: Composite type "%s.%s"
fr: Type composé « %s.%s »

en: Connection
fr: Connexions

en: Create DB
fr: Créer une base

en: Create role
fr: Créer un rôle

en: Ctype
fr: Type caract.

en: DEALLOCATE [ PREPARE ] { name | ALL }
fr: DEALLOCATE [ PREPARE ] { nom_plan | ALL }

en: DECLARE name [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
        CURSOR [ { WITH | WITHOUT } HOLD ] FOR query
fr: DECLARE nom [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
        CURSOR [ { WITH | WITHOUT } HOLD ] FOR requête

en: DELETE FROM [ ONLY ] table [ * ] [ [ AS ] alias ]
        [ USING usinglist ]
        [ WHERE condition | WHERE CURRENT OF cursor_name ]
        [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]
fr: DELETE FROM [ ONLY ] table [ * ] [ [ AS ] alias ]
        [ USING liste_using ]
        [ WHERE condition | WHERE CURRENT OF nom_curseur ]
        [ RETURNING * | expression_sortie [ [ AS ] nom_sortie ] [, ...] ]

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

en: DROP CAST [ IF EXISTS ] (sourcetype AS targettype) [ CASCADE | RESTRICT ]
fr: DROP CAST [ IF EXISTS ] (type_source AS type_cible) [ CASCADE | RESTRICT ]

en: DROP CONVERSION [ IF EXISTS ] name [ CASCADE | RESTRICT ]
fr: DROP CONVERSION [ IF EXISTS ] nom [ CASCADE | RESTRICT ]

en: DROP DATABASE [ IF EXISTS ] name
fr: DROP DATABASE [ IF EXISTS ] nom

en: DROP DOMAIN [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
fr: DROP DOMAIN [ IF EXISTS ] nom [, ...]  [ CASCADE | RESTRICT ]

en: DROP FOREIGN DATA WRAPPER [ IF EXISTS ] name [ CASCADE | RESTRICT ]
fr: DROP FOREIGN DATA WRAPPER [ IF EXISTS ] nom [ CASCADE | RESTRICT ]

en: DROP FUNCTION [ IF EXISTS ] name ( [ [ argmode ] [ argname ] argtype [, ...] ] )
        [ CASCADE | RESTRICT ]
fr: DROP FUNCTION [IF EXISTS ] nom
        ( [ [ mode_arg ] [ nom_arg ] type_arg [, ...] ] )
        [ CASCADE | RESTRICT ]

en: DROP GROUP [ IF EXISTS ] name [, ...]
fr: DROP GROUP [IF EXISTS ] nom [, ...]

en: DROP INDEX [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
fr: DROP INDEX [IF EXISTS ] nom [, ...] [ CASCADE | RESTRICT ]

en: DROP OPERATOR CLASS [ IF EXISTS ] name USING index_method [ CASCADE | RESTRICT ]
fr: DROP OPERATOR CLASS [IF EXISTS ] nom
        USING méthode_indexage [ CASCADE | RESTRICT ]

en: DROP OPERATOR FAMILY [ IF EXISTS ] name USING index_method [ CASCADE | RESTRICT ]
fr: DROP OPERATOR FAMILY [IF EXISTS ] nom
      USING méthode_indexage [ CASCADE | RESTRICT ]

en: DROP OPERATOR [ IF EXISTS ] name ( { lefttype | NONE } , { righttype | NONE } ) [ CASCADE | RESTRICT ]
fr: DROP OPERATOR [IF EXISTS ] nom
      ( { type_gauche | NONE } , { type_droit | NONE } )
      [ CASCADE | RESTRICT ]

en: DROP OWNED BY name [, ...] [ CASCADE | RESTRICT ]
fr: DROP OWNED BY nom [, ...] [ CASCADE | RESTRICT ]

en: DROP ROLE [ IF EXISTS ] name [, ...]
fr: DROP ROLE [IF EXISTS ] nom [, ...]

en: DROP RULE [ IF EXISTS ] name ON relation [ CASCADE | RESTRICT ]
fr: DROP RULE [IF EXISTS ] nom ON relation [ CASCADE | RESTRICT ]

en: DROP SCHEMA [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
fr: DROP SCHEMA [IF EXISTS ] nom [, ...] [ CASCADE | RESTRICT ]

en: DROP SEQUENCE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
fr: DROP SEQUENCE [IF EXISTS ] nom [, ...] [ CASCADE | RESTRICT ]

en: DROP SERVER [ IF EXISTS ] servername [ CASCADE | RESTRICT ]
fr: DROP SERVER [ IF EXISTS ] nom [ CASCADE | RESTRICT ]

en: DROP TABLE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
fr: DROP TABLE [IF EXISTS ] nom [, ...] [ CASCADE | RESTRICT ]

en: DROP TABLESPACE [ IF EXISTS ] tablespacename
fr: DROP TABLESPACE [IF EXISTS ] nom_tablespace

en: DROP TEXT SEARCH CONFIGURATION [ IF EXISTS ] name [ CASCADE | RESTRICT ]
fr: DROP TEXT SEARCH CONFIGURATION [ IF EXISTS ] nom [ CASCADE | RESTRICT ]

en: DROP TEXT SEARCH DICTIONARY [ IF EXISTS ] name [ CASCADE | RESTRICT ]
fr: DROP TEXT SEARCH DICTIONARY [ IF EXISTS ] nom [ CASCADE | RESTRICT ]

en: DROP TEXT SEARCH PARSER [ IF EXISTS ] name [ CASCADE | RESTRICT ]
fr: DROP TEXT SEARCH PARSER [ IF EXISTS ] nom [ CASCADE | RESTRICT ]

en: DROP TEXT SEARCH TEMPLATE [ IF EXISTS ] name [ CASCADE | RESTRICT ]
fr: DROP TEXT SEARCH TEMPLATE [ IF EXISTS ] nom [ CASCADE | RESTRICT ]

en: DROP TRIGGER [ IF EXISTS ] name ON table [ CASCADE | RESTRICT ]
fr: DROP TRIGGER [IF EXISTS ] nom ON table [ CASCADE | RESTRICT ]

en: DROP TYPE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
fr: DROP TYPE [IF EXISTS ] nom [, ...] [ CASCADE | RESTRICT ]

en: DROP USER MAPPING [ IF EXISTS ] FOR { username | USER | CURRENT_USER | PUBLIC } SERVER servername
fr: DROP USER MAPPING [ IF EXISTS ] FOR { nomutilisateur | USER | CURRENT_USER | PUBLIC } SERVER nomserveur

en: DROP USER [ IF EXISTS ] name [, ...]
fr: DROP USER [IF EXISTS ] nom [, ...]

en: DROP VIEW [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
fr: DROP VIEW [IF EXISTS ] nom [, ...] [ CASCADE | RESTRICT ]

en: DROP [ PROCEDURAL ] LANGUAGE [ IF EXISTS ] name [ CASCADE | RESTRICT ]
fr: DROP [ PROCEDURAL ] LANGUAGE [IF EXISTS ] nom [ CASCADE | RESTRICT ]

en: Default footer is off.
fr: Le bas de page par défaut est désactivé.

en: Default footer is on.
fr: Le bas de page pas défaut est activé.

en: Default?
fr: Par défaut ?

en: Dictionaries
fr: Dictionnaires

en: Did not find any relation named "%s".
fr: Aucune relation nommée « %s » n'a été trouvée.

en: Did not find any relation with OID %s.
fr: Aucune relation avec l'OID « %s » n'a été trouvée.

en: Did not find any text search configuration named "%s".
fr: Aucune configuration de la recherche de texte nommée « %s » n'a été trouvée.

en: Did not find any text search parser named "%s".
fr: Aucun analyseur de la recherche de texte nommé « %s » n'a été trouvé.

en: Disabled rules:
fr: Règles désactivées :

en: Disabled triggers:
fr: Triggers désactivés :

en: EXECUTE name [ ( parameter [, ...] ) ]
fr: EXECUTE nom_plan [ ( paramètre [, ...] ) ]

en: EXPLAIN [ ANALYZE ] [ VERBOSE ] statement
fr: EXPLAIN [ ANALYZE ] [ VERBOSE ] instruction

en: Elements
fr: Éléments

en: Encoding
fr: Encodage

en: End parse
fr: Fin de l'analyse

en: Enter data to be copied followed by a newline.
    End with a backslash and a period on a line by itself.
fr: Saisissez les données à copier suivies d'un saut de ligne.
    Terminez avec un antislash et un point seuls sur une ligne.

en: Enter it again:
fr: Saisissez-le à nouveau :

en: Enter new password:
fr: Saisissez le nouveau mot de passe :

en: Expanded display is off.
fr: Affichage étendu désactivé.

en: Expanded display is on.
fr: Affichage étendu activé.

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
fr: FETCH [ direction { FROM | IN } ] nom_curseur
    
    sans préciser de direction ou en choissant une des directions suivantes :
    
        NEXT
        PRIOR
        FIRST
        LAST
        ABSOLUTE nombre
        RELATIVE nombre
        count
        ALL
        FORWARD
        FORWARD nombre
        FORWARD ALL
        BACKWARD
        BACKWARD nombre
        BACKWARD ALL

en: Failed.
fr: Échec.

en: Field separator is "%s".
fr: Le séparateur de champs est « %s ».

en: Foreign-data wrapper
fr: Wrapper des données distantes

en: Foreign-key constraints:
fr: Contraintes de clés étrangères :

en: Formatting
fr: Formatage

en: Function
fr: Fonction

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 ]
fr: GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
        [,...] | ALL [ PRIVILEGES ] }
        ON [ TABLE ] nom_table [, ...]
        TO { [ GROUP ] nom_rôle | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { SELECT | INSERT | UPDATE | REFERENCES } ( colonne [, ...] )
        [,...] | ALL [ PRIVILEGES ] ( colonne [, ...] ) }
        ON [ TABLE ] nom_table [, ...]
        TO { [ GROUP ] nom_rôle | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { USAGE | SELECT | UPDATE }
        [,...] | ALL [ PRIVILEGES ] }
        ON SEQUENCE nom_séquence [, ...]
        TO { [ GROUP ] nom_rôle | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { CREATE | CONNECT | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
        ON DATABASE nom_base [, ...]
        TO { [ GROUP ] nom_rôle | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN DATA WRAPPER nomfdw [, ...]
        TO { [ GROUP ] nom_rôle | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN SERVER nom_serveur [, ...]
        TO { [ GROUP ] nom_rôle | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { EXECUTE | ALL [ PRIVILEGES ] }
        ON FUNCTION nom_fonction ( [ [ mode_arg ] [ nom_arg ] type_arg [, ...] ] ) [, ...]
        TO { [ GROUP ] nom_rôle | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { USAGE | ALL [ PRIVILEGES ] }
        ON LANGUAGE nom_langage [, ...]
        TO { [ GROUP ] nom_rôle | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
        ON SCHEMA nom_schéma [, ...]
        TO { [ GROUP ] nom_rôle | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { CREATE | ALL [ PRIVILEGES ] }
        ON TABLESPACE nom_tablespace [, ...]
        TO { [ GROUP ] nom_rôle | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT rôle [, ...] TO nom_rôle [, ...] [ WITH ADMIN OPTION ]

en: General
fr: Général

en: General options:
fr: Options générales :

en: Get headline
fr: Obtenir l'en-tête

en: Get next token
fr: Obtenir le prochain jeton

en: Get token types
fr: Obtenir les types de jeton

en: Has OIDs
fr: Contient des OID

en: INSERT INTO table [ ( column [, ...] ) ]
        { DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) [, ...] | query }
        [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]
fr: INSERT INTO table [ ( colonne [, ...] ) ]
        { DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) [, ...] | requête }
        [ RETURNING * | expression_sortie [ [ AS ] nom_sortie ] [, ...] ]

en: Implicit?
fr: Implicite ?

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

en: Indexes:
fr: Index :

en: Informational
fr: Informations

en: Inherits
fr: Hérite de

en: Init
fr: Initialisation

en: Init options
fr: Options d'initialisation :

en: Input/Output
fr: Entrée/Sortie

en: Internal name
fr: Nom interne

en: Interrupted
fr: Interrompu

en: Invalid command \%s. Try \? for help.
fr: Commande \%s invalide. Essayez \? pour l'aide-mémoire.

en: LISTEN name
fr: LISTEN nom

en: LOAD 'filename'
fr: LOAD 'nom_de_fichier'

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
fr: LOCK [ TABLE ] [ ONLY ] nom [ * ] [, ...] [ IN mode_verrouillage MODE ] [ NOWAIT ]
    
    avec mode_verrouillage parmi :
    
        ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE
        | SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE

en: Language
fr: Langage

en: Large Objects
fr: « Large objects »

en: Large objects
fr: « Large objects »

en: Left arg type
fr: Type de l'arg. gauche

en: List of aggregate functions
fr: Liste des fonctions d'agrégation

en: List of casts
fr: Liste des conversions explicites

en: List of conversions
fr: Liste des conversions

en: List of data types
fr: Liste des types de données

en: List of databases
fr: Liste des bases de données

en: List of domains
fr: Liste des domaines

en: List of foreign servers
fr: Liste des serveurs distants

en: List of foreign-data wrappers
fr: Liste des wrappers de données distantes

en: List of functions
fr: Liste des fonctions

en: List of operators
fr: Liste des opérateurs

en: List of relations
fr: Liste des relations

en: List of roles
fr: Liste des rôles

en: List of schemas
fr: Liste des schémas

en: List of tablespaces
fr: Liste des tablespaces

en: List of text search configurations
fr: Liste des configurations de la recherche de texte

en: List of text search dictionaries
fr: Liste des dictionnaires de la recherche de texte

en: List of text search parsers
fr: Liste des analyseurs de la recherche de texte

en: List of text search templates
fr: Liste des modèles de la recherche de texte

en: List of user mappings
fr: Liste des correspondances utilisateurs

en: Locale-adjusted numeric output is off.
fr: L'affichage de la sortie numérique adaptée à la locale est désactivé.

en: Location
fr: Emplacement

en: MOVE [ direction { FROM | IN } ] cursorname
fr: MOVE [ direction { FROM | IN } ] nom_de_curseur

en: Member of
fr: Membre de

en: Method
fr: Méthode

en: Modifier
fr: Modificateur

en: Modifiers
fr: Modificateurs

en: NOTIFY name
fr: NOTIFY nom

en: Name
fr: Nom

en: No changes
fr: Aucun changement

en: No connections
fr: Sans connexions

en: No help available for "%-.*s".
    Try \h with no arguments to see available help.
fr: Aucun aide-mémoire disponible pour « %-.*s ».
    Essayez \h sans arguments pour afficher les aide-mémoires disponibles.

en: No inheritance
fr: Pas d'héritage

en: No matching relations found.
fr: Aucune relation correspondante trouvée.

en: No relations found.
fr: Aucune relation trouvée.

en: Null display is "%s".
fr: L'affichage de null est « %s ».

en: Object
fr: Objet

en: Object descriptions
fr: Descriptions des objets

en: Operating System
fr: Système d'exploitation

en: Output format is %s.
fr: Le format de sortie est %s.

en: Owner
fr: Propriétaire

en: PREPARE TRANSACTION transaction_id
fr: PREPARE TRANSACTION id_transaction

en: PREPARE name [ ( datatype [, ...] ) ] AS statement
fr: PREPARE nom_plan [ ( type_données [, ...] ) ] AS instruction

en: Pager is always used.
fr: Le pagineur est toujours utilisé.

en: Pager is used for long output.
fr: Le pagineur est utilisé pour les affichages importants.

en: Pager usage is off.
fr: Le pagineur n'est pas utilisé.

en: Password encryption failed.
fr: Échec du chiffrement du mot de passe.

en: Password for user %s:
fr: Mot de passe pour l'utilisateur %s :

en: Password:
fr: Mot de passe :

en: Passwords didn't match.
fr: Les mots de passe ne sont pas identiques.

en: Previous connection kept
fr: Connexion précédente conservée

en: Query Buffer
fr: Tampon de requête

en: Query buffer is empty.
fr: Le tampon de requête est vide.

en: Query buffer reset (cleared).
fr: Le tampon de requête a été effacé.

en: REASSIGN OWNED BY old_role [, ...] TO new_role
fr: REASSIGN OWNED BY ancien_role [, ...] TO nouveau_role

en: REINDEX { INDEX | TABLE | DATABASE | SYSTEM } name [ FORCE ]
fr: REINDEX { INDEX | TABLE | DATABASE | SYSTEM } nom [ FORCE ]

en: RELEASE [ SAVEPOINT ] savepoint_name
fr: RELEASE [ SAVEPOINT ] nom_retour

en: RESET configuration_parameter
    RESET ALL
fr: RESET paramètre
    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 ]
fr: REVOKE [ GRANT OPTION FOR ]
        { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
        [,...] | ALL [ PRIVILEGES ] }
        ON [ TABLE ] nom_table [, ...]
        FROM { [ GROUP ] nom_rôle | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { SELECT | INSERT | UPDATE | REFERENCES } ( colonne [, ...] )
        [,...] | ALL [ PRIVILEGES ] ( colonne [, ...] ) }
        ON [ TABLE ] nom_table [, ...]
        FROM { [ GROUP ] nom_rôle | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { USAGE | SELECT | UPDATE }
        [,...] | ALL [ PRIVILEGES ] }
        ON SEQUENCE nom_séquence [, ...]
        FROM { [ GROUP ] nom_rôle | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { CREATE | CONNECT | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
        ON DATABASE nom_base [, ...]
        FROM { [ GROUP ] nom_rôle | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN DATA WRAPPER nom_fdw [, ...]
        FROM { [ GROUP ] nom_rôle | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON FOREIGN SERVER nom_serveur [, ...]
        FROM { [ GROUP ] nom_rôle | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { EXECUTE | ALL [ PRIVILEGES ] }
        ON FUNCTION nom_fonction ( [ [ mode_arg ] [ nom_arg ] type_arg [, ...] ] ) [, ...]
        FROM { [ GROUP ] nom_rôle | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON LANGUAGE nom_langage [, ...]
        FROM { [ GROUP ] nom_rôle | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
        ON SCHEMA nom_schéma [, ...]
        FROM { [ GROUP ] nom_rôle | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { CREATE | ALL [ PRIVILEGES ] }
        ON TABLESPACE nom_tablespace [, ...]
        FROM { [ GROUP ] nom_rôle | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ ADMIN OPTION FOR ]
        role [, ...] FROM nom_rôle [, ...]
        [ CASCADE | RESTRICT ]

en: ROLLBACK PREPARED transaction_id
fr: ROLLBACK PREPARED id_transaction

en: ROLLBACK [ WORK | TRANSACTION ] TO [ SAVEPOINT ] savepoint_name
fr: ROLLBACK [ WORK | TRANSACTION ] TO [ SAVEPOINT ] nom_retour

en: Record separator is "%s".
fr: Le séparateur d'enregistrements est « %s ».

en: Record separator is <newline>.
fr: Le séparateur d'enregistrements est <saut de ligne>.

en: Referenced by:
fr: Référencé par :

en: Report bugs to <pgsql-bugs@postgresql.org>.
fr: Rapportez les bogues à <pgsql-bugs@postgresql.org>.

en: Result data type
fr: Type de données du résultat

en: Result type
fr: Type du résultat

en: Right arg type
fr: Type de l'arg. droit

en: Role name
fr: Nom du rôle

en: Rules firing always:
fr: Règles toujous activées :

en: Rules firing on replica only:
fr: Règles activées uniquement sur le réplica :

en: Rules:
fr: Règles :

en: SAVEPOINT savepoint_name
fr: SAVEPOINT nom_retour

en: SET CONSTRAINTS { ALL | name [, ...] } { DEFERRED | IMMEDIATE }
fr: SET CONSTRAINTS { ALL | nom [, ...] } { DEFERRED | IMMEDIATE }

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
fr: SET TRANSACTION mode_transaction [, ...]
    SET SESSION CHARACTERISTICS AS TRANSACTION mode_transaction [, ...]
    
    où mode_transaction peut être :
    
        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
fr: SET [ SESSION | LOCAL ] ROLE nom_rôle
    SET [ SESSION | LOCAL ] ROLE NONE
    RESET ROLE

en: SET [ SESSION | LOCAL ] SESSION AUTHORIZATION username
    SET [ SESSION | LOCAL ] SESSION AUTHORIZATION DEFAULT
    RESET SESSION AUTHORIZATION
fr: SET [ SESSION | LOCAL ] SESSION AUTHORIZATION nom_utilisateur
    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 }
fr: SET [ SESSION | LOCAL ] paramètre { TO | = } { valeur | 'valeur' | DEFAULT }
    SET [ SESSION | LOCAL ] TIME ZONE { zone_horaire | LOCAL | DEFAULT }

en: SHOW name
    SHOW ALL
fr: SHOW nom
    SHOW ALL

en: SSL connection (cipher: %s, bits: %i)
fr: Connexion SSL (chiffrement : %s, bits : %i)

en: SSL connection (unknown cipher)
fr: Connexion SSL (chiffrement inconnu)

en: START TRANSACTION [ transaction_mode [, ...] ]
    
    where transaction_mode is one of:
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY
fr: START TRANSACTION [ mode_transaction [, ...] ]
    
    où mode_transaction peut être :
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ |
                          READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY

en: Schema
fr: Schéma

en: Sequence "%s.%s"
fr: Séquence « %s.%s »

en: Server
fr: Serveur

en: Showing locale-adjusted numeric output.
fr: Affichage de la sortie numérique adaptée à la locale.

en: Showing only tuples.
fr: Affichage des tuples seuls.

en: Size
fr: Taille

en: Source code
fr: Code source

en: Source type
fr: Type source

en: Special relation "%s.%s"
fr: Relation spéciale « %s.%s »

en: Start parse
fr: Début de l'analyse

en: Storage
fr: Stockage

en: Succeeded.
fr: Succès.

en: Superuser
fr: Superutilisateur

en: TOAST table "%s.%s"
fr: Table TOAST « %s.%s »

en: TRUNCATE [ TABLE ] [ ONLY ] name [ * ] [, ... ]
        [ RESTART IDENTITY | CONTINUE IDENTITY ] [ CASCADE | RESTRICT ]
fr: TRUNCATE [ TABLE ] [ ONLY ] nom [ * ] [, ... ]
        [ RESTART IDENTITY | CONTINUE IDENTITY ] [ CASCADE | RESTRICT ]

en: Table "%s.%s"
fr: Table « %s.%s »

en: Table attribute is "%s".
fr: L'attribut de la table est « %s ».

en: Table attributes unset.
fr: Les attributs de la table ne sont pas définis.

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

en: Target type
fr: Type cible

en: Target width for "wrapped" format is %d.
fr: La largeur cible pour le format « wrapped » est %d.

en: Template
fr: Modèle

en: Text search configuration "%s"
fr: Configuration « %s » de la recherche de texte

en: Text search configuration "%s.%s"
fr: Configuration « %s.%s » de la recherche de texte

en: Text search parser "%s"
fr: Analyseur « %s » de la recherche de texte

en: Text search parser "%s.%s"
fr: Analyseur « %s.%s » de la recherche de texte

en: The connection to the server was lost. Attempting reset:
fr: La connexion au serveur a été perdue. Tentative de réinitialisation :

en: The server (version %d.%d) does not support editing function source.
fr: Le serveur (version %d.%d) ne supporte pas l'édition du code de la fonction.

en: The server (version %d.%d) does not support foreign servers.
fr: Le serveur (version %d.%d) ne supporte pas les serveurs distants.

en: The server (version %d.%d) does not support foreign-data wrappers.
fr: Le serveur (version %d.%d) ne supporte pas les wrappers de données distantes.

en: The server (version %d.%d) does not support full text search.
fr: Le serveur (version %d.%d) ne supporte pas la recherche plein texte.

en: The server (version %d.%d) does not support savepoints for ON_ERROR_ROLLBACK.
fr: Le serveur (version %d.%d) ne supporte pas les points de sauvegarde pour
    ON_ERROR_ROLLBACK.

en: The server (version %d.%d) does not support tablespaces.
fr: Le serveur (version %d.%d) ne supporte pas les tablespaces.

en: The server (version %d.%d) does not support user mappings.
fr: Le serveur (version %d.%d) ne supporte pas les correspondances d'utilisateurs.

en: Time: %.3f ms
fr: Temps : %.3f ms

en: Timing is off.
fr: Chronométrage désactivé.

en: Timing is on.
fr: Chronométrage activé.

en: Title is "%s".
fr: Le titre est « %s ».

en: Title is unset.
fr: Le titre n'est pas défini.

en: Token
fr: Jeton

en: Token name
fr: Nom du jeton

en: Token types for parser "%s"
fr: Types de jeton pour l'analyseur « %s »

en: Token types for parser "%s.%s"
fr: Types de jeton pour l'analyseur « %s.%s »

en: Triggers firing always:
fr: Triggers toujours activés :

en: Triggers firing on replica only:
fr: Triggers activés uniquement sur le réplica :

en: Triggers:
fr: Triggers :

en: Try "%s --help" for more information.
fr: Essayez « %s --help » pour plus d'informations.

en: Tuples only is off.
fr: L'affichage des tuples seuls est désactivé.

en: Type "help" for help.
fr: Saisissez « help » pour l'aide.

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
fr: Saisissez:
        \copyright pour les termes de distribution
        \h pour l'aide-mémoire des commandes SQL
        \? pour l'aide-mémoire des commandes psql
        \g ou point-virgule en fin d'instruction pour exécuter la requête
        \q pour quitter

en: UNLISTEN { name | * }
fr: UNLISTEN { nom | * }

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 ] [, ...] ]
fr: UPDATE [ ONLY ] table [ * ] [ [ AS ] alias ]
        SET { colonne = { expression | DEFAULT } |
              ( colonne [, ...] ) = ( { expression | DEFAULT } [, ...] ) } [, ...]
        [ FROM liste_from ]
        [ WHERE condition | WHERE CURRENT OF nom_curseur ]
        [ RETURNING * | expression_sortie [ [ AS ] nom_sortie ] [, ...] ]

en: Usage:
fr: Usage :

en: Use "\q" to leave %s.
fr: Saisissez « \q » pour quitter %s.

en: User name
fr: Nom de l'utilisateur

en: VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ table ]
    VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] ANALYZE [ table [ (column [, ...] ) ] ]
fr: VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ table ]
    VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] ANALYZE [ table [ (colonne [, ...] ) ] ]

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 ]
fr: VALUES ( expression [, ...] ) [, ...]
        [ ORDER BY expression_tri [ ASC | DESC | USING opérateur ] [, ...] ]
        [ LIMIT { total | ALL } ]
        [ OFFSET début [ ROW | ROWS ] ]
        [ FETCH { FIRST | NEXT } [ total ] { ROW | ROWS } ONLY ]

en: Validator
fr: Validateur

en: Value
fr: Valeur

en: View "%s.%s"
fr: Vue « %s.%s »

en: View definition:
fr: Définition de la vue :

en: Volatility
fr: Volatibilité

en: WARNING: %s version %d.%d, server version %d.%d.
             Some psql features might not work.
fr: ATTENTION : %s version %d.%d, version du serveur %d.%d.
             Certaines fonctionnalités de psql pourraient ne pas fonctionner.

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.
fr: Attention : l'encodage console (%u) diffère de l'encodage Windows (%u).
                Les caractères 8 bits peuvent ne pas fonctionner correctement.
                Voir la section « Notes aux utilisateurs de Windows » de la page
                référence de psql pour les détails.

en: Wrote history to file "%s/%s".
fr: Historique sauvegardé dans le fichier « %s/%s ».

en: You are currently not connected to a database.
fr: Vous n'êtes pas connecté à une base de données.

en: You are now connected to database "%s"
fr: Vous êtes maintenant connecté à la base de données « %s »

en: You are using psql, the command-line interface to PostgreSQL.
fr: Vous utilisez psql, l'interface en ligne de commande de 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 ] [...] ]
fr: [ WITH [ RECURSIVE ] requête_with [, ...] ]
    SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
        * | expression [ [ AS ] nom_sortie ] [, ...]
        INTO [ TEMPORARY | TEMP ] [ TABLE ] nouvelle_table
        [ FROM élément_from [, ...] ]
        [ WHERE condition ]
        [ GROUP BY expression [, ...] ]
        [ HAVING condition [, ...] ]
        [ WINDOW nom_window AS ( définition_window ) [, ...] ]
        [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
        [ ORDER BY expression [ ASC | DESC | USING opérateur ] [ NULLS { FIRST | LAST } ] [, ...] ]
        [ LIMIT { total | ALL } ]
        [ OFFSET début [ ROW | ROWS ] ]
        [ FETCH { FIRST | NEXT } [ total ] { ROW | ROWS } ONLY ]
        [ FOR { UPDATE | SHARE } [ OF nom_table [, ...] ] [ 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 }
fr: [ WITH [ RECURSIVE ] requête_with [, ...] ]
    SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
        * | expression [ [ AS ] nom_sortie ] [, ...]
        [ FROM élément_from [, ...] ]
        [ WHERE condition ]
        [ GROUP BY expression [, ...] ]
        [ HAVING condition [, ...] ]
        [ WINDOW nom_window AS ( définition_window ) [, ...] ]
        [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
        [ ORDER BY expression [ ASC | DESC | USING opérateur ] [ NULLS { FIRST | LAST } ] [, ...] ]
        [ LIMIT { total | ALL } ]
        [ OFFSET début [ ROW | ROWS ] ]
        [ FETCH { FIRST | NEXT } [ total ] { ROW | ROWS } ONLY ]
        [ FOR { UPDATE | SHARE } [ OF nom_table [, ...] ] [ NOWAIT ] [...] ]
    
    avec élément_from faisant parti de :
    
        [ ONLY ] nom_table [ * ] [ [ AS ] alias [ ( alias_colonne [, ...] ) ] ]
        ( select ) [ AS ] alias [ ( alias_colonne [, ...] ) ]
        nom_requête_with [ [ AS ] alias [ ( alias_colonne [, ...] ) ] ]
        nom_fonction ( [ argument [, ...] ] ) [ AS ] alias [ ( alias_colonne [, ...] | définition_colonne [, ...] ) ]
        nom_fonction ( [ argument [, ...] ] ) AS ( définition_colonne [, ...] )
        élément_from [ NATURAL ] type_jointure élément_from [ ON condition_jointure | USING ( colonne_jointure [, ...] ) ]
    
    et requête_with est:
    
        nom_requête_with [ ( nom_colonne [, ...] ) ] AS ( select )
    
    TABLE { [ ONLY ] nom_table [ * ] | nom_requête_with }

en: \!: failed
fr: \! : échec

en: \%s: could not change directory to "%s": %s
fr: \%s : n'a pas pu accéder au répertoire « %s » : %s

en: \%s: error
fr: \%s : erreur

en: \%s: extra argument "%s" ignored
fr: \%s : argument « %s » supplémentaire ignoré

en: \%s: missing required argument
fr: \%s : argument requis manquant

en: \connect: %s
fr: \connect : %s

en: \copy: %s
fr: \copy : %s

en: \copy: arguments required
fr: \copy : arguments requis

en: \copy: parse error at "%s"
fr: \copy : erreur d'analyse sur « %s »

en: \copy: parse error at end of line
fr: \copy : erreur d'analyse à la fin de la ligne

en: \copy: unexpected response (%d)
fr: \copy : réponse inattendue (%d)

en: \df does not take a "w" option with server version %d.%d
fr: \df ne prend pas l'option « w » pour un serveur en version %d.%d.

en: \df only takes [antwS+] as options
fr: \df prends seulement [antwS+] comme options

en: \pset: allowed formats are unaligned, aligned, wrapped, html, latex, troff-ms
fr: \pset : les formats autorisés sont unaligned, aligned, wrapped, html, latex,
    troff-ms

en: \pset: unknown option: %s
fr: \pset : option inconnue : %s

en: abort the current transaction
fr: abandonner la transaction en cours

en: aborted because of read failure
fr: annulé du fait d'une erreur de lecture

en: aggregate
fr: agrégation

en: cancel a transaction that was earlier prepared for two-phase commit
fr: annuler une transaction précédemment préparée pour une validation en deux
    phases

en: canceled by user
fr: annulé par l'utilisateur

en: cannot locate temporary directory: %s
fr: ne peut pas localiser le répertoire temporaire : %s

en: change a database
fr: modifier une base de données

en: change a database role
fr: modifier un rôle

en: change a run-time parameter
fr: modifier un paramètre d'exécution

en: change role name or membership
fr: modifier le nom d'un groupe ou la liste des ses membres

en: change the definition of a conversion
fr: modifier la définition d'une conversion

en: change the definition of a domain
fr: modifier la définition d'un domaine

en: change the definition of a foreign server
fr: modifier la définition d'un serveur distant

en: change the definition of a foreign-data wrapper
fr: modifier la définition d'un wrapper de données distantes

en: change the definition of a function
fr: modifier la définition d'une fonction

en: change the definition of a procedural language
fr: modifier la définition d'un langage procédural

en: change the definition of a schema
fr: modifier la définition d'un schéma

en: change the definition of a sequence generator
fr: modifier la définition d'un générateur de séquence

en: change the definition of a table
fr: modifier la définition d'une table

en: change the definition of a tablespace
fr: modifier la définition d'un tablespace

en: change the definition of a text search configuration
fr: modifier la définition d'une configuration de la recherche de texte

en: change the definition of a text search dictionary
fr: modifier la définition d'un dictionnaire de la recherche de texte

en: change the definition of a text search parser
fr: modifier la définition d'un analyseur de la recherche de texte

en: change the definition of a text search template
fr: modifier la définition d'un modèle de la recherche de texte

en: change the definition of a trigger
fr: modifier la définition d'un trigger

en: change the definition of a type
fr: modifier la définition d'un type

en: change the definition of a user mapping
fr: modifier la définition d'une correspondance d'utilisateur

en: change the definition of a view
fr: modifier la définition d'une vue

en: change the definition of an aggregate function
fr: modifier la définition d'une fonction d'agrégation

en: change the definition of an index
fr: modifier la définition d'un index

en: change the definition of an operator
fr: modifier la définition d'un opérateur

en: change the definition of an operator class
fr: modifier la définition d'une classe d'opérateurs

en: change the definition of an operator family
fr: modifier la définition d'une famille d'opérateur

en: change the ownership of database objects owned by a database role
fr: changer le propriétaire des objets d'un rôle

en: child process exited with exit code %d
fr: le processus fils a quitté avec le code de sortie %d

en: child process exited with unrecognized status %d
fr: le processus fils a quitté avec un statut %d non reconnu

en: child process was terminated by exception 0x%X
fr: le processus fils a été terminé par l'exception 0x%X

en: child process was terminated by signal %d
fr: le processus fils a été terminé par le signal %d

en: child process was terminated by signal %s
fr: le processus fils a été terminé par le signal %s

en: close a cursor
fr: fermer un curseur

en: cluster a table according to an index
fr: réorganiser (cluster) une table en fonction d'un index

en: collect statistics about a database
fr: acquérir des statistiques concernant la base de données

en: commit a transaction that was earlier prepared for two-phase commit
fr: valider une transaction précédemment préparée pour une validation en deux
    phases

en: commit the current transaction
fr: valider la transaction en cours

en: compute a set of rows
fr: calculer un ensemble de lignes

en: connection to server was lost
fr: la connexion au serveur a été perdue

en: contains support for command-line editing
fr: contient une gestion avancée de la ligne de commande

en: copy data between a file and a table
fr: copier des données entre un fichier et une table

en: could not change directory to "%s"
fr: n'a pas pu accéder au répertoire « %s »

en: could not find a "%s" to execute
fr: n'a pas pu trouver un « %s » à exécuter

en: could not get current user name: %s
fr: n'a pas pu obtenir le nom d'utilisateur courant : %s

en: could not get home directory: %s
fr: n'a pas pu obtenir le répertoire de l'utilisateur : %s

en: could not identify current directory: %s
fr: n'a pas pu identifier le répertoire courant : %s

en: could not open temporary file "%s": %s
fr: n'a pas pu ouvrir le fichier temporaire « %s » : %s

en: could not read binary "%s"
fr: n'a pas pu lire le binaire « %s »

en: could not read from input file: %s
fr: n'a pas pu lire à partir du fichier en entrée : %s

en: could not read symbolic link "%s"
fr: n'a pas pu lire le lien symbolique « %s »

en: could not save history to file "%s": %s
fr: n'a pas pu sauvegarder l'historique dans le fichier « %s » : %s

en: could not start /bin/sh
fr: n'a pas pu exécuter /bin/sh

en: could not start editor "%s"
fr: n'a pas pu exécuter l'éditeur « %s »

en: could not write COPY data: %s
fr: n'a pas pu écrire les données du COPY : %s

en: create a new database
fr: créer une nouvelle base de données

en: create new rows in a table
fr: créer de nouvelles lignes dans une table

en: data type
fr: type de données

en: deallocate a prepared statement
fr: désallouer une instruction préparée

en: default %s
fr: Par défaut, %s

en: define a cursor
fr: définir un curseur

en: define a new aggregate function
fr: définir une nouvelle fonction d'agrégation

en: define a new cast
fr: définir un nouveau transtypage

en: define a new constraint trigger
fr: définir une nouvelle contrainte de déclenchement

en: define a new data type
fr: définir un nouveau type de données

en: define a new database role
fr: définir un nouveau rôle

en: define a new domain
fr: définir un nouveau domaine

en: define a new encoding conversion
fr: définir une nouvelle conversion d'encodage

en: define a new foreign server
fr: définir un nouveau serveur distant

en: define a new foreign-data wrapper
fr: définir un nouveau wrapper de données distantes

en: define a new function
fr: définir une nouvelle fonction

en: define a new index
fr: définir un nouvel index

en: define a new mapping of a user to a foreign server
fr: définit une nouvelle correspondance d'un utilisateur vers un serveur distant

en: define a new operator
fr: définir un nouvel opérateur

en: define a new operator class
fr: définir une nouvelle classe d'opérateur

en: define a new operator family
fr: définir une nouvelle famille d'opérateur

en: define a new procedural language
fr: définir un nouveau langage de procédures

en: define a new rewrite rule
fr: définir une nouvelle règle de réécriture

en: define a new savepoint within the current transaction
fr: définir un nouveau point de retournement pour la transaction en cours

en: define a new schema
fr: définir un nouveau schéma

en: define a new sequence generator
fr: définir un nouveau générateur de séquence

en: define a new table
fr: définir une nouvelle table

en: define a new table from the results of a query
fr: définir une nouvelle table à partir des résultats d'une requête

en: define a new tablespace
fr: définir un nouveau tablespace

en: define a new text search configuration
fr: définir une nouvelle configuration de la recherche de texte

en: define a new text search dictionary
fr: définir un nouveau dictionnaire de la recherche de texte

en: define a new text search parser
fr: définir un nouvel analyseur de la recherche de texte

en: define a new text search template
fr: définir un nouveau modèle de la recherche de texte

en: define a new trigger
fr: définir un nouveau trigger

en: define a new view
fr: définir une nouvelle vue

en: define access privileges
fr: définir des privilèges d'accès

en: define or change the comment of an object
fr: définir ou modifier les commentaires d'un objet

en: delete rows of a table
fr: supprimer des lignes d'une table

en: destroy a previously defined savepoint
fr: détruire un point de retournement précédemment défini

en: discard session state
fr: annuler l'état de la session

en: empty a table or set of tables
fr: vider une table ou un ensemble de tables

en: execute a prepared statement
fr: exécuter une instruction préparée

en: for table "%s.%s"
fr: pour la table « %s.%s »

en: force a transaction log checkpoint
fr: forcer un point de vérification des journaux de transaction

en: function
fr: fonction

en: garbage-collect and optionally analyze a database
fr: compacter et optionnellement analyser une base de données

en: generate a notification
fr: engendrer une notification

en: history is not supported by this installation
fr: l'historique n'est pas supportée par cette installation

en: in assignment
fr: assigné

en: invalid binary "%s"
fr: binaire « %s » invalide

en: invalid command \%s
fr: commande \%s invalide

en: invalid output format (internal error): %d
fr: format de sortie invalide (erreur interne) : %d

en: listen for a notification
fr: se mettre à l'écoute d'une notification

en: load a shared library file
fr: charge un fichier de bibliothèque partagée

en: local socket
fr: socket locale

en: lock a table
fr: verrouiller une table

en: no
fr: non

en: no query buffer
fr: aucun tampon de requête

en: not null
fr: non NULL

en: off
fr: désactivé

en: on
fr: activé

en: operator
fr: opérateur

en: out of memory
fr: mémoire épuisée

en: position a cursor
fr: positionner un curseur

en: prepare a statement for execution
fr: préparer une instruction pour exécution

en: prepare the current transaction for two-phase commit
fr: préparer la transaction en cours pour une validation en deux phases

en: primary key,
fr: clé primaire,

en: psql is the PostgreSQL interactive terminal.
fr: psql est l'interface interactive de PostgreSQL.

en: rebuild indexes
fr: reconstruire des index

en: remove a cast
fr: supprimer un transtypage

en: remove a conversion
fr: supprimer une conversion

en: remove a data type
fr: supprimer un type de données

en: remove a database
fr: supprimer une base de données

en: remove a database role
fr: supprimer un rôle de la base de données

en: remove a domain
fr: supprimer un domaine

en: remove a foreign server descriptor
fr: supprimer un descripteur de serveur distant

en: remove a foreign-data wrapper
fr: supprimer un wrapper de données distantes

en: remove a function
fr: supprimer une fonction

en: remove a procedural language
fr: supprimer un langage procédural

en: remove a rewrite rule
fr: supprimer une règle de réécriture

en: remove a schema
fr: supprimer un schéma

en: remove a sequence
fr: supprimer une séquence

en: remove a table
fr: supprimer une table

en: remove a tablespace
fr: supprimer un tablespace

en: remove a text search configuration
fr: supprimer une configuration de la recherche de texte

en: remove a text search dictionary
fr: supprimer un dictionnaire de la recherche de texte

en: remove a text search parser
fr: supprimer un analyseur de la recherche de texte

en: remove a text search template
fr: supprimer un modèle de la recherche de texte

en: remove a trigger
fr: supprimer un trigger

en: remove a user mapping for a foreign server
fr: supprime une correspondance utilisateur pour un serveur distant

en: remove a view
fr: supprimer une vue

en: remove access privileges
fr: supprimer des privilèges d'accès

en: remove an aggregate function
fr: supprimer une fonction d'agrégation

en: remove an index
fr: supprimer un index

en: remove an operator
fr: supprimer un opérateur

en: remove an operator class
fr: supprimer une classe d'opérateur

en: remove an operator family
fr: supprimer une famille d'opérateur

en: remove database objects owned by a database role
fr: supprimer les objets appartenant à un rôle

en: restore the value of a run-time parameter to the default value
fr: réinitialiser un paramètre d'exécution à sa valeur par défaut

en: retrieve rows from a query using a cursor
fr: extraire certaines lignes d'une requête à l'aide d'un curseur

en: retrieve rows from a table or view
fr: extraire des lignes d'une table ou d'une vue

en: roll back to a savepoint
fr: annuler jusqu'au point de retournement

en: rule
fr: règle

en: sequence
fr: séquence

en: set constraint checking modes for the current transaction
fr: définir les modes de vérification de contrainte pour la transaction en cours

en: set the characteristics of the current transaction
fr: définir les caractéristiques de la transaction en cours

en: set the current user identifier of the current session
fr: définir l'identifiant actuel de l'utilisateur de la session courante

en: set the session user identifier and the current user identifier of the current session
fr: définir l'identifiant de l'utilisateur de session et l'identifiant actuel de
    l'utilisateur de la session courante

en: show the execution plan of a statement
fr: afficher le plan d'exécution d'une instruction

en: show the value of a run-time parameter
fr: afficher la valeur d'un paramètre d'exécution

en: special
fr: spécial

en: start a transaction block
fr: débuter un bloc de transaction

en: stop listening for a notification
fr: arrêter l'écoute d'une notification

en: trying to exit copy mode
fr: tente de sortir du mode copy

en: update rows of a table
fr: actualiser les lignes d'une table

en: view
fr: vue

en: yes
fr: oui
