psql-fr - en to fr translation catalogue (470 entries)

en: Warning: This syntax is deprecated.
fr: Attention : cette syntaxe est obsolète.

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

en: invalid command \%s
fr: commande non valable \%s

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

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

en: \%s: could not change directory to "%s": %s
fr: \%s : n'a pas pu changer le répertoire courant en «%s» : %s

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

en: %s: invalid encoding name or conversion procedure not found
fr: %s : nom d'encodage non valable ou procédure de conversion non trouvée

en: \%s: missing required argument
fr: \%s : argument nécessaire manquant

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: Wrote history to file "%s".
fr: Historique sauvegardé dans «%s».

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

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

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

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

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

en: Password:
fr: Mot de passe :

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

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

en: You are now connected as new user "%s".
fr: Vous êtes maintenant connecté en tant qu'utilisateur «%s».

en: You are now connected to database "%s" as user "%s".
fr: Vous êtes maintenant connecté à la base de données «%s» en tant qu'utilisateur «%s».

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

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

en: cannot locate temporary directory: %s
fr: n'a pas pu localiser le répertoire temporaire : %s

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

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

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

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

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

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

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

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

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

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

en: Showing only tuples.
fr: Afficher seulement les tuples.

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

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

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

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: Pager is used for long output.
fr: Le pagineur est utilisé pour les affichages importants.

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

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

en: Default footer is on.
fr: Bas de page activé.

en: Default footer is off.
fr: Bas de page désactivé.

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

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

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

en: out of memory
fr: mémoire insuffisant

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

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

en: Failed.
fr: Echec.

en: Succeeded.
fr: Succès.

en: INTERNAL ERROR: unexpected statement position "%s"
fr: ERREUR INTERNE : position inattendue dans l'instruction «%s»

en: LINE %d:
fr: LIGNE %d :

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

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

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

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

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

en: \copy: parse error at "%s"
fr: \copy : erreur de syntaxe sur «%s»

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

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

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

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

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

en: on
fr: activé

en: off
fr: désactivé

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

en: This is psql %s, the PostgreSQL interactive terminal.
fr: Bienvenue dans psql %s, l'interface interactive de PostgreSQL.

en: Usage:
fr: Utilisation :

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

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

en:   -d DBNAME       specify database name to connect to (default: "%s")
fr:   -d NOM_BASE        spécifiez le nom de la base de données à laquelle vous souhaitez vous connecter (par défaut: %s)

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

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

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

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

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

en:   --help          show this help, then exit
fr:   --help          afficher cette aide, puis quitter

en:   --version       output version information, then exit
fr:   -V              afficher la version du programme, puis quitter

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

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

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

en:   -E              display queries that internal commands generate
fr:   -E              afficher les requêtes générées par les commandes internes

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

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

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

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

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

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

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

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

en:   -t              print rows only (-P tuples_only)
fr:   -t              afficher seulement les lignes (-P tuples_only)

en:   -T TEXT         set HTML table tag attributes (width, border) (-P tableattr=)
fr:   -T TEXT         initialiser les attributs des balises HTML de table (largeur, bordure) (-P tableattr=)

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

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

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

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

en: 
    Connection options:
fr: 
    Options de connexion :

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

en: local socket
fr: socket local

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

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

en:   -W              prompt for password (should happen automatically)
fr:   -W              demander le mot de passe (devrait survenir automatiquement)

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.
    
    Report bugs to <pgsql-bugs@postgresql.org>.
fr: 
    Pour en savoir davantage, tapez «\?» (pour des commandes internes) ou
    «\help» (pour des commandes SQL) une fois dans psql, ou consultez la
    section de psql dans la documentation de PostgreSQL.
    
    Rapporter les bogues à <pgsql-bugs@postgresql.org>.

en: General
fr: Général

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

en:   \cd [DIR]      change the current working directory
fr:  \cd [REPERTOIRE]   changer de répertoire courant

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

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

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:   \q             quit psql
fr:  \q             quitte psql

en:   \set [NAME [VALUE]]
                     set internal variable, or list all if no parameters
fr:   \set [NOM [VALEUR]]
                     initialiser la variable interne ou les afficher toutes s'il n'y a aucun paramètre

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

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

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

en: Query Buffer
fr: Tampon de requête

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:   \g [FILE]      send query buffer to server (and results to file or |pipe)
fr:   \g [FICHIER]      envoie le tampon de requêtes au serveur (et les résultats au fichier
                              ou |tube)

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

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

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

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

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

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

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

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

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

en: Informational
fr: Information

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

en:   \d{t|i|s|v|S} [PATTERN] (add "+" for more detail)
                     list tables/indexes/sequences/views/system tables
fr:   \d{t|i|s|v|S} [MODELE] (ajoutez "+" pour plus de détails)
                     liste les tables/index/séquences/vues/tables système

en:   \da [PATTERN]  list aggregate functions
fr:   \da [MODELE]  afficher la liste des fonctions d'aggrégation

en:   \db [PATTERN]  list tablespaces (add "+" for more detail)
fr:   \dn [MODELE]  affiche la liste des espaces logiques (ajoutez «+» pour plus de détails)

en:   \dc [PATTERN]  list conversions
fr:   \dc [MODELE]  afficher la liste des conversions

en:   \dC            list casts
fr:   \dC           afficher la liste des conversions explicites

en:   \dd [PATTERN]  show comment for object
fr:   \dd [MODELE]  afficher les commentaires pour un objet

en:   \dD [PATTERN]  list domains
fr:   \dD [MODELE]  afficher la liste des domaines

en:   \df [PATTERN]  list functions (add "+" for more detail)
fr:   \df [MODELE]  afficher la liste des fonctions (ajoutez «+» pour plus de détails)

en:   \dg [PATTERN]  list groups
fr:   \dg [MODELE]  affiche la liste des groupes

en:   \dn [PATTERN]  list schemas (add "+" for more detail)
fr:   \dn [MODELE]  afficher la liste des schémas (ajoutez «+» pour plus de détails)

en:   \do [NAME]     list operators
fr:  \do [MODELE]   afficher la liste des operateurs

en:   \dl            list large objects, same as \lo_list
fr:   \dl           afficher la liste des objets larges, identique à \lo_list

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

en:   \dT [PATTERN]  list data types (add "+" for more detail)
fr:   \dT [MODELE]  afficher la liste des types de données (ajoutez «+» 
                              pour plus de détails)

en:   \du [PATTERN]  list users
fr:   \du [MODELE]  afficher la liste des utilisateurs

en:   \l             list all databases (add "+" for more detail)
fr:  \l             afficher toutes les bases de données (ajoutez «+» pour plus de détails)

en:   \z [PATTERN]   list table, view, and sequence access privileges (same as \dp)
fr:   \z [MODÈLE]    affiche la liste des privilèges d'accès aux tables, vues et
                      séquences (identique à \dp)

en: Formatting
fr: Formatage

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

en:   \C [STRING]    set table title, or unset if none
fr:   \C [CHAINE]    initialiser le titre d'une table, ou initialise à rien si sans argument

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

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

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

en:   \t             show only rows (currently %s)
fr:   \t             afficher seulement les lignes (actuellement %s)

en:   \T [STRING]    set HTML <table> tag attributes, or unset if none
fr:   \T [CHAINE]    initialise les attributs HTML de la balise <table>, ou l'annule si aucun argument

en:   \x             toggle expanded output (currently %s)
fr:   \x             basculer l'affichage étendu (actuellement %s)

en: Copy, Large Object
fr: Copie, gros objets

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

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

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

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

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

en: could not save history to file "%s": %s
fr: n'a pas pu écrire l'historique dans %s: %s

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

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

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

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

en: Large objects
fr: Gros objets

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

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

en: (1 row)
fr: (1 ligne)

en: (%d rows)
fr: (%d lignes)

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

en: User name:
fr: Nom d'utilisateur :

en: Welcome to %s %s, the PostgreSQL interactive terminal.
    
    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: Bienvenue dans %s %s, l'interface interactive de PostgreSQL.
    
    Tapez:  \copyright pour les termes de distribution
            \h pour l'aide-mémoire sur les commandes SQL
            \? pour l'aide-mémoire sur les commandes internes
            \g ou terminez avec un point-virgule pour exécuter une requête
            \q pour quitter

en: %s: couldn't set printing parameter "%s"
fr: %s : impossible d'initialiser le paramètre d'impression «%s»

en: %s: could not delete variable "%s"
fr: %s : impossible d'effacer la variable «%s»

en: %s: could not set variable "%s"
fr: %s : impossible d'initialiser la variable «%s»

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

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

en: %s: Warning: The -u option is deprecated. Use -U.
fr: %s : Attention : l'option -u est obsolète. Utilisez -U.

en: contains support for command-line editing
fr: contient le support pour l'édition de la ligne de commande

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

en: Schema
fr: Schéma

en: Name
fr: Nom

en: (all types)
fr: (tous les types)

en: Data type
fr: Type de données

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

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

en: Owner
fr: Propriétaire

en: Location
fr: Emplacement

en: Access privileges
fr: Privilèges d'accès

en: List of tablespaces
fr: Liste des espaces logiques

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

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

en: Language
fr: Langage

en: Source code
fr: Code source

en: List of functions
fr: Liste des fonctions

en: Internal name
fr: Nom interne

en: Size
fr: Taille

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

en: Left arg type
fr: Type d'arg. gauche

en: Right arg type
fr: Type d'arg. droit

en: Result type
fr: Type de résultat

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

en: Encoding
fr: Encodage

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

en: view
fr: vue

en: sequence
fr: séquence

en: Access privileges for database "%s"
fr: Privilèges d'accès de la base de données «%s»

en: Object
fr: Objet

en: aggregate
fr: agrégation

en: function
fr: fonction

en: operator
fr: opérateur

en: data type
fr: type de données

en: rule
fr: règle

en: trigger
fr: déclencheur

en: Object descriptions
fr: Descriptions des objets

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: Column
fr: Colonne

en: Modifiers
fr: Modificateurs

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

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

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

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

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

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

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

en: ?%c? "%s.%s"
fr: ?%c? «%s.%s»

en: primary key,
fr: clé primaire,

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

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

en: , clustered
fr: , en cluster

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

en: Rules:
fr: Règles :

en: Indexes:
fr: Index :

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

en: Check constraints:
fr: Contraintes :

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

en: Foreign-key constraints:
fr: Contraintes de clés secondaires :

en: Triggers:
fr: Déclencheurs :

en: Inherits
fr: Hérite de

en: Has OIDs
fr: Contient des OID

en: yes
fr: oui

en: no
fr: non

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

en: User name
fr: Nom d'utilisateur

en: User ID
fr: Identifiant utilisateur

en: superuser, create database
fr: superutilisateur, création des bases de données

en: superuser
fr: superutilisateur

en: create database
fr: création des bases de données

en: Attributes
fr: Attributs

en: Groups
fr: Groupes

en: List of users
fr: Liste des utilisateurs

en: Group name
fr: Nom du groupe

en: Group ID
fr: Identifiant du groupe

en: List of groups
fr: Liste des groupes

en: special
fr: spécial

en: No matching relations found.
fr: Pas de relations correspondantes trouvées.

en: No relations found.
fr: Pas de relations trouvées.

en: List of relations
fr: Liste des relations

en: Modifier
fr: Modifications

en: List of domains
fr: Liste des domaines

en: Source
fr: Code source

en: Default?
fr: Par défaut?

en: List of conversions
fr: Liste des conversions

en: Source type
fr: Type de la source

en: Target type
fr: Type de la cible

en: (binary compatible)
fr: (compatible au niveau binaire)

en: Function
fr: Fonction

en: in assignment
fr: assigné

en: Implicit?
fr: Implicite ?

en: List of casts
fr: Liste des conversions explicites

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

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

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

en: ALTER AGGREGATE name ( type ) RENAME TO newname
    ALTER AGGREGATE name ( type ) OWNER TO newowner
fr: ALTER AGGREGATE nom ( type ) RENAME TO nouveau_nom
    ALTER AGGREGATE nom ( type ) OWNER TO nouveau_propriétaire

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

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_proprietaire

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

en: ALTER DATABASE name SET parameter { TO | = } { value | DEFAULT }
    ALTER DATABASE name RESET parameter
    
    ALTER DATABASE name RENAME TO newname
    
    ALTER DATABASE name OWNER TO new_owner
fr: ALTER DATABASE nom SET paramètre { TO | = } { valeur | DEFAULT }
    ALTER DATABASE nom RESET paramètre
    
    ALTER DATABASE nom RENAME TO nouveau_nom 
    ALTER DATABASE nom OWNER TO nouveau_propriétaire

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

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
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 contrainte_domaine [ RESTRICT | CASCADE ]
    ALTER DOMAIN nom
        OWNER TO nouveau_propriétaire

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

en: ALTER FUNCTION name ( [ type [, ...] ] ) RENAME TO newname
    ALTER FUNCTION name ( [ type [, ...] ] ) OWNER TO newowner
fr: ALTER FUNCTION nom ( [ type [, ...] ] ) RENAME TO nouveau_nom
    ALTER FUNCTION nom ( [ type [, ...] ] ) OWNER TO nouveau_propriétaire

en: change a user group
fr: modifier un groupe d'utilisateurs

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: change the definition of an index
fr: modifier la définition d'un index

en: ALTER INDEX name 
        action [, ... ]
    ALTER INDEX name
        RENAME TO new_name
    
    where action is one of:
    
        OWNER TO new_owner
        SET TABLESPACE indexspace_name
fr: ALTER INDEX nom 
        action [, ... ]
    ALTER INDEX nom
        RENAME TO nouveau_nom
    
    où action fait partie de :
    
        OWNER TO nouveau_propriétaire
        SET TABLESPACE nom_espace_index

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

en: ALTER LANGUAGE name RENAME TO newname
fr: ALTER LANGUAGE nom RENAME TO nouveau_nom

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

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: change the definition of an operator
fr: modifier la définition d'un opérateur

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: change the definition of a schema
fr: modifier la définition d'un schéma

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: change the definition of a sequence generator
fr: modifier la définition d'un générateur de séquence

en: ALTER SEQUENCE name [ INCREMENT [ BY ] increment ]
        [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
        [ RESTART [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]
fr: ALTER SEQUENCE nom [ INCREMENT [ BY ] incrémentation ]
        [ MINVALUE valeur_minimum | NO MINVALUE ] [ MAXVALUE valeur_maximum | NO MAXVALUE ]
        [ RESTART [ WITH ] démarrage ] [ CACHE cache ] [ [ NO ] CYCLE ]

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

en: ALTER TABLE [ ONLY ] name [ * ]
        action [, ... ]
    ALTER TABLE [ ONLY ] name [ * ]
        RENAME [ COLUMN ] column TO new_column
    ALTER TABLE name
        RENAME TO new_name
    
    where action is one of:
    
        ADD [ COLUMN ] column type [ column_constraint [ ... ] ]
        DROP [ COLUMN ] column [ RESTRICT | CASCADE ]
        ALTER [ COLUMN ] column 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 ]
        CLUSTER ON index_name
        SET WITHOUT CLUSTER
        SET WITHOUT OIDS
        OWNER TO new_owner
        SET TABLESPACE tablespace_name
fr: ALTER TABLE [ ONLY ] nom [ * ]
        action [, ... ]
    ALTER TABLE [ ONLY ] nom [ * ]
        RENAME [ COLUMN ] colonne TO nouvelle_colonne
    ALTER TABLE nom
        RENAME TO nouveau_nom
    
    où action est parmi :
    
        ADD [ COLUMN ] colonne type [ column_constraint [ ... ] ]
        DROP [ COLUMN ] colonne RESTRICT | CASCADE ]
        ALTER [ COLUMN ] colonne 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 integer
        ALTER [ COLUMN ] colonne SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN }
        ADD contrainte_table
        DROP CONSTRAINT nom_contrainte [ RESTRICT | CASCADE ]
        CLUSTER ON nom_index
        SET WITHOUT CLUSTER
        SET WITHOUT OIDS
        OWNER TO nouveau_propriétaire
        SET TABLESPACE nom_espacelogique

en: change the definition of a tablespace
fr: modifie la définition d'un espace logique

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: change the definition of a trigger
fr: modifier la définition d'un déclencheur

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

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

en: ALTER TYPE name OWNER TO new_owner
fr: ALTER SCHEMA nom OWNER TO nouveau_propriétaire

en: change a database user account
fr: modifier un compte utilisateur de base de données

en: ALTER USER name [ [ WITH ] option [ ... ] ]
    
    where option can be:
    
        [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password' 
        | CREATEDB | NOCREATEDB
        | CREATEUSER | NOCREATEUSER 
        | VALID UNTIL 'abstime'
    
    ALTER USER name RENAME TO newname
    
    ALTER USER name SET parameter { TO | = } { value | DEFAULT }
    ALTER USER name RESET parameter
fr: ALTER USER nom [ [ WITH ] option [ ... ] ]
    
    avec les options suivantes :
    
        [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'mot_de_passe' 
        | CREATEDB | NOCREATEDB
        | CREATEUSER | NOCREATEUSER 
        | VALID UNTIL 'temps'
    
    ALTER USER nom RENAME TO nouveau_nom
    
    ALTER USER nom SET paramètre { TO | = } { valeur | DEFAULT }
    ALTER USER nom RESET paramètre

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

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

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

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 fait partie de :
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY

en: force a transaction log checkpoint
fr: Forcer l'enregistrement immédiat des journaux de transaction

en: close a cursor
fr: fermer un curseur

en: CLOSE name
fr: CLOSE nom

en: cluster a table according to an index
fr: clusteriser une table à partir d'un index

en: CLUSTER indexname ON tablename
    CLUSTER tablename
    CLUSTER
fr: CLUSTER nom_index ON nom_table
    CLUSTER nom_table
    CLUSTER

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

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 (arg1_type, arg2_type, ...) |
      INDEX object_name |
      LARGE OBJECT large_object_oid |
      OPERATOR op (leftoperand_type, rightoperand_type) |
      OPERATOR CLASS object_name USING index_method |
      [ PROCEDURAL ] LANGUAGE object_name |
      RULE rule_name ON table_name |
      SCHEMA object_name |
      SEQUENCE 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 (typesource AS typecible) |
      CONSTRAINT nom_contrainte ON nom_table |
      CONVERSION nom_objet |
      DATABASE nom_objet |
      DOMAIN nom_objet |
      FUNCTION nom_fonction (type_arg1, type_arg2, ...) |
      INDEX nom_objet |
      LARGE OBJECT oid_gros_objet |
      OPERATOR op (type_opérande_gauche, type_opérande_droit) |
      OPERATOR CLASS nom_objet USING méthode_index |
      [ PROCEDURAL ] LANGUAGE nom_objet |
      RULE nom_règle ON nom_table |
      SCHEMA nom_objet |
      SEQUENCE nom_objet |
      TRIGGER nom_déclencheur ON nom_table |
      TYPE nom_objet |
      VIEW nom_objet
    } IS 'text'

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

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

en: COPY tablename [ ( column [, ...] ) ]
        FROM { 'filename' | STDIN }
        [ [ WITH ] 
              [ BINARY ] 
              [ OIDS ]
              [ DELIMITER [ AS ] 'delimiter' ]
              [ NULL [ AS ] 'null string' ]
              [ CSV [ QUOTE [ AS ] 'quote' ] 
                    [ ESCAPE [ AS ] 'escape' ]
                    [ FORCE NOT NULL column [, ...] ]
    
    COPY tablename [ ( column [, ...] ) ]
        TO { 'filename' | STDOUT }
        [ [ WITH ] 
              [ BINARY ]
              [ OIDS ]
              [ DELIMITER [ AS ] 'delimiter' ]
              [ NULL [ AS ] 'null string' ]
              [ CSV [ QUOTE [ AS ] 'quote' ] 
                    [ ESCAPE [ AS ] 'escape' ]
                    [ FORCE QUOTE column [, ...] ]
fr: COPY tablename [ ( colonne [, ...] ) ]
        FROM { 'fichier' | STDIN }
        [ [ WITH ] 
              [ BINARY ] 
              [ OIDS ]
              [ DELIMITER [ AS ] 'délimiteur' ]
              [ NULL [ AS ] 'chaîne null' ]
              [ CSV [ QUOTE [ AS ] 'quote' ] 
                    [ ESCAPE [ AS ] 'escape' ]
                    [ FORCE NOT NULL colonne [, ...] ]
    
    COPY tablename [ ( colonne [, ...] ) ]
        TO { 'fichier' | STDOUT }
        [ [ WITH ] 
              [ BINARY ]
              [ OIDS ]
              [ DELIMITER [ AS ] 'délimiteur' ]
              [ NULL [ AS ] 'chaîne null' ]
              [ CSV [ QUOTE [ AS ] 'quote' ] 
                    [ ESCAPE [ AS ] 'escape' ]
                    [ FORCE QUOTE colonne [, ...] ]

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

en: CREATE AGGREGATE name (
        BASETYPE = input_data_type,
        SFUNC = sfunc,
        STYPE = state_data_type
        [ , FINALFUNC = ffunc ]
        [ , INITCOND = initial_condition ]
    )
fr: CREATE AGGREGATE nom (
        BASETYPE = type_données_entrée,
        SFUNC = sfunc,
        STYPE = type_données_state
        [ , FINALFUNC = ffunc ]
        [ , INITCOND = condition_initiale ]
    )

en: define a new cast
fr: définir une nouvelle conversion explicite

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

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

en: CREATE CONSTRAINT TRIGGER name
        AFTER events ON
        tablename constraint attributes
        FOR EACH ROW EXECUTE PROCEDURE funcname ( args )
fr: CREATE CONSTRAINT TRIGGER nom
        AFTER événements ON
        nom_table attributs_contrainte
        FOR EACH ROW EXECUTE PROCEDURE nom_fontion ( args )

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

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

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

en: CREATE DATABASE name
        [ [ WITH ] [ OWNER [=] dbowner ]
               [ TEMPLATE [=] template ]
               [ ENCODING [=] encoding ]
               [ TABLESPACE [=] tablespace ] ]
fr: CREATE DATABASE nom
        [ [ WITH ] [ OWNER [=] propbase ]
               [ LOCATION [=] 'chemindb' ]
               [ TEMPLATE [=] modèle ]
               [ TABLESPACE [=] encodage ] ]

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

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: define a new function
fr: définir une nouvelle fonction

en: CREATE [ OR REPLACE ] FUNCTION name ( [ [ argname ] argtype [, ...] ] )
        RETURNS rettype
      { LANGUAGE langname
        | IMMUTABLE | STABLE | VOLATILE
        | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
        | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
        | AS 'definition'
        | AS 'obj_file', 'link_symbol'
      } ...
        [ WITH ( attribute [, ...] ) ]
fr: CREATE [ OR REPLACE ] FUNCTION nom ( [ [ nom_argument ] type_argument [, ...] ] )
        RETURNS type_retourné
      { LANGUAGE nom_langage
        | IMMUTABLE | STABLE | VOLATILE
        | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
        | [EXTERNAL] SECURITY INVOKER | [EXTERNAL] SECURITY DEFINER
        | AS 'définition'
        | AS 'fichier_objet', 'symbole_lien'
      } ...
        [ WITH ( attribut [, ...] ) ]

en: define a new user group
fr: définir un nouveau groupe d'utilisateurs

en: CREATE GROUP name [ [ WITH ] option [ ... ] ]
    
    where option can be:
    
         SYSID gid
       | USER  username [, ...]
fr: CREATE GROUP nom [ [ WITH ] option [ ... ] ]
    
    avec les options suivantes :
    
         SYSID gid
       | USER  nom_utilisateur [, ...]

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

en: CREATE [ UNIQUE ] INDEX name ON table [ USING method ]
        ( { column | ( expression ) } [ opclass ] [, ...] )
        [ TABLESPACE tablespace ]
        [ WHERE predicate ]
fr: CREATE [ UNIQUE ] INDEX nom ON table [ USING méthode ]
        ( { colonne | ( expression ) } [ classe_opérateur ] [, ...] )
        [ TABLESPACE espacelogique ]
        [ WHERE prédicat ]

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

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

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

en: CREATE OPERATOR CLASS name [ DEFAULT ] FOR TYPE data_type USING index_method AS
      {  OPERATOR strategy_number operator_name [ ( op_type, op_type ) ] [ RECHECK ]
       | FUNCTION support_number funcname ( argument_type [, ...] )
       | STORAGE storage_type
      } [, ... ]
fr: CREATE OPERATOR CLASS nom [ DEFAULT ] FOR TYPE type_données USING méthode_indexation AS
      {  OPERATOR numéro_stratégie nom_opérateur [ ( type_op, type_op ) ] [ RECHECK ]
       | FUNCTION numéro_support nom_fonction ( type_argument [, ...] )
       | STORAGE type_stockage
      } [, ... ]

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

en: CREATE OPERATOR name (
        PROCEDURE = funcname
        [, LEFTARG = lefttype ] [, RIGHTARG = righttype ]
        [, COMMUTATOR = com_op ] [, NEGATOR = neg_op ]
        [, RESTRICT = res_proc ] [, JOIN = join_proc ]
        [, HASHES ] [, MERGES ]
        [, SORT1 = left_sort_op ] [, SORT2 = right_sort_op ]
        [, LTCMP = less_than_op ] [, GTCMP = greater_than_op ]
    )
fr: CREATE OPERATOR nom (
        PROCEDURE = nom_fonction
        [, LEFTARG = type_gauche ] [, RIGHTARG = type_droit ]
        [, COMMUTATOR = op_commutation ] [, NEGATOR = op_négation ]
        [, RESTRICT = proc_restriction ] [, JOIN = proc_jointure ]
        [, HASHES ] [, MERGES ]
        [, SORT1 = op_tri_droit ] [, SORT2 = op_tri_gauche ]
        [, LTCMP = op_plus_petit_que ] [, GTCMP = op_plus_grand_que ]
    )

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

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: define a new schema
fr: définir un nouveau schéma

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: define a new sequence generator
fr: définir un nouveau générateur de séquence

en: CREATE [ TEMPORARY | TEMP ] SEQUENCE name [ INCREMENT [ BY ] increment ]
        [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
        [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]
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 ]

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

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 ] }  [, ... ]
    )
    [ INHERITS ( parent_table [, ... ] ) ]
    [ WITH OIDS | WITHOUT OIDS ]
    [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
    [ TABLESPACE tablespace ]
    
    where column_constraint is:
    
    [ CONSTRAINT constraint_name ]
    { NOT NULL | 
      NULL | 
      UNIQUE [ USING INDEX TABLESPACE tablespace ] |
      PRIMARY KEY [ USING INDEX TABLESPACE tablespace ] |
      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 [, ... ] ) [ USING INDEX TABLESPACE tablespace ] |
      PRIMARY KEY ( column_name [, ... ] ) [ USING INDEX TABLESPACE tablespace ] |
      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 ]
fr: CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE nom_table (
      { nom_colonne type_données [ DEFAULT expression_par_défaut ] [ contrainte_colonne [ ... ] ]
        | contrainte_table
        | LIKE table_parent [ { INCLUDING | EXCLUDING } DEFAULTS ] }  [, ... ]
    )
    [ INHERITS ( table_parent [, ... ] ) ]
    [ WITH OIDS | WITHOUT OIDS ]
    [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
    [ TABLESPACE espacelogique ]
    
    où contrainte_colonne est :
    
    [ CONSTRAINT nom_contrainte ]
    { NOT NULL | 
      NULL | 
      UNIQUE [ USING INDEX TABLESPACE espacelogique ] |
      PRIMARY KEY [ USING INDEX TABLESPACE espacelogique ] |
      CHECK (expression) |
      REFERENCES table_reference [ ( colonne_reference ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
        [ ON DELETE action ] [ ON UPDATE action ] }
    [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
    
    et contrainte_table est :
    
    [ CONSTRAINT nom_contrainte ]
    { UNIQUE ( nom_colonne [, ... ] ) [ USING INDEX TABLESPACE espacelogique ] |
      PRIMARY KEY ( nom_colonne [, ... ] ) [ USING INDEX TABLESPACE espacelogique ] |
      CHECK ( expression ) |
      FOREIGN KEY ( nom_colonne [, ... ] ) REFERENCES table_reference [ ( colonne_reference [, ... ] ) ]
        [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON UPDATE action ] }
    [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

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: CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name [ (column_name [, ...] ) ] [ [ WITH | WITHOUT ] OIDS ]
        AS query
fr: CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE nom_table [ (nom_colonne [, ...] ) ] [ [ WITH | WITHOUT ] OIDS ]
        AS requête

en: define a new tablespace
fr: définir un nouvel espace logique

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

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

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: define a new data type
fr: définir un nouveau type de données

en: CREATE TYPE name AS
        ( attribute_name data_type [, ... ] )
    
    CREATE TYPE name (
        INPUT = input_function,
        OUTPUT = output_function
        [ , RECEIVE = receive_function ]
        [ , SEND = send_function ]
        [ , ANALYZE = analyze_function ]
        [ , INTERNALLENGTH = { internallength | VARIABLE } ]
        [ , PASSEDBYVALUE ]
        [ , ALIGNMENT = alignment ]
        [ , STORAGE = storage ]
        [ , DEFAULT = default ]
        [ , ELEMENT = element ]
        [ , DELIMITER = delimiter ]
    )
fr: CREATE TYPE nom AS
        ( nom_attribut type_données [, ... ] )
    
    CREATE TYPE nom (
        INPUT = fonction_en_entrée,
        OUTPUT = fonction_en_sortie
        [ , RECEIVE = fonction_recevant_type]
        [ , SEND = fonction_renvoyant_type ]
        [ , ANALYZE = fonction_analyze ]
        [ , INTERNALLENGTH = { longueur_intervalle | VARIABLE } ]
        [ , PASSEDBYVALUE ]
        [ , ALIGNMENT = alignement ]
        [ , STORAGE = stockage ]
        [ , DEFAULT = valeur_par_défaut ]
        [ , ELEMENT = élément ]
        [ , DELIMITER = sépérateur ]
    )

en: define a new database user account
fr: définir un nouveau compte utilisateur de base de données

en: CREATE USER name [ [ WITH ] option [ ... ] ]
    
    where option can be:
        
          SYSID uid 
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
        | CREATEDB | NOCREATEDB
        | CREATEUSER | NOCREATEUSER
        | IN GROUP groupname [, ...]
        | VALID UNTIL 'abstime'
fr: CREATE USER nom [ [ WITH ] option [ ... ] ]
    
    avec comme options :
        
          SYSID uid 
        | [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'mot_de_passe'
        | CREATEDB | NOCREATEDB
        | CREATEUSER | NOCREATEUSER
        | IN GROUP groupe_utilisateur [, ...]
        | VALID UNTIL 'temps_absolu'

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

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

en: deallocate a prepared statement
fr: désactiver une expression préparée à l'avance

en: DEALLOCATE [ PREPARE ] plan_name
fr: DEALLOCATE [ PREPARE ] nom_plan

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

en: DECLARE name [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
        CURSOR [ { WITH | WITHOUT } HOLD ] FOR query
        [ FOR { READ ONLY | UPDATE [ OF column [, ...] ] } ]
fr: DECLARE nom [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
        CURSOR [ { WITH | WITHOUT } HOLD ] FOR requête
        [ FOR { READ ONLY | UPDATE [ OF colonne [, ...] ] } ]

en: delete rows of a table
fr: supprimer des colonnes dans une table

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

en: DROP AGGREGATE name ( type ) [ CASCADE | RESTRICT ]
fr: DROP AGGREGATE nom ( type ) [ CASCADE | RESTRICT ]

en: remove a cast
fr: supprimer une conversion explicite

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

en: remove a conversion
fr: supprimer une conversion

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

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

en: DROP DATABASE name
fr: DROP DATABASE nom

en: remove a domain
fr: supprimer un domaine

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

en: remove a function
fr: supprimer une fonction

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

en: remove a user group
fr: supprimer un groupe d'utilisateurs

en: DROP GROUP name
fr: DROP GROUP nom

en: remove an index
fr: supprimer un index

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

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

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

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

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

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

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

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

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

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

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

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

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

en: remove a table
fr: supprimer une table

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

en: remove a tablespace
fr: supprimer un espace logique

en: DROP TABLESPACE tablespacename
fr: DROP TABLESPACE espacelogique

en: remove a trigger
fr: supprimer un déclencheur

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

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

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

en: remove a database user account
fr: supprimer un compte utilisateur de base de données

en: DROP USER name
fr: DROP USER nom

en: remove a view
fr: supprimer une vue

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

en: execute a prepared statement
fr: exécuter une expression préparée à l'avance

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

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

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

en: retrieve rows from a query using a cursor
fr: extraire des lignes d'une requêtes en utilisant un curseur

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: define access privileges
fr: définir des privilèges d'accès

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

en: INSERT INTO table [ ( column [, ...] ) ]
        { DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) | query }
fr: INSERT INTO table [ ( colonne [, ...] ) ]
        { DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) | requête }

en: listen for a notification
fr: être à l'écoute d'une notification

en: LISTEN name
fr: LISTEN nom

en: load or reload a shared library file
fr: charger ou recharger un fichier de librairie partagée

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

en: lock a table
fr: verrouiller une table

en: LOCK [ TABLE ] 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 ] nom [, ...] [ IN mode_verrouillage MODE ] [ NOWAIT ]
    
    avec un mode_verrouillage parmi les valeurs suivantes :
    
        ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE
        | SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE

en: position a cursor
fr: positionner un curseur

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

en: generate a notification
fr: générer une notification

en: NOTIFY name
fr: NOTIFY nom

en: prepare a statement for execution
fr: préparer à l'avance l'exécution d'une expression

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

en: rebuild indexes
fr: reconstruire des indexes

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

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

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

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

en: RESET name
    RESET ALL
fr: RESET nom
    RESET ALL

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

en: REVOKE [ GRANT OPTION FOR ]
        { { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES | TRIGGER }
        [,...] | ALL [ PRIVILEGES ] }
        ON [ TABLE ] tablename [, ...]
        FROM { username | GROUP groupname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
        ON DATABASE dbname [, ...]
        FROM { username | GROUP groupname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { EXECUTE | ALL [ PRIVILEGES ] }
        ON FUNCTION funcname ([type, ...]) [, ...]
        FROM { username | GROUP groupname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON LANGUAGE langname [, ...]
        FROM { username | GROUP groupname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
        ON SCHEMA schemaname [, ...]
        FROM { username | GROUP groupname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { CREATE | ALL [ PRIVILEGES ] }
        ON TABLESPACE tablespacename [, ...]
        FROM { username | GROUP groupname | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
fr: REVOKE [ GRANT OPTION FOR ]
        { { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES | TRIGGER }
        [,...] | ALL [ PRIVILEGES ] }
        ON [ TABLE ] nom_table [, ...]
        FROM { nom_utilisateur | GROUP nom_groupe | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
        ON DATABASE nom_base [, ...]
        FROM { nom_utilisateur | GROUP nom_groupe | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { EXECUTE | ALL [ PRIVILEGES ] }
        ON FUNCTION nom_fonction ([type, ...]) [, ...]
        FROM { nom_utilisateur | GROUP nom_groupe | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { USAGE | ALL [ PRIVILEGES ] }
        ON LANGUAGE nom_langage [, ...]
        FROM { nom_utilisateur | GROUP nom_groupe | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
        ON SCHEMA nom_schema [, ...]
        FROM { nom_utilisateur | GROUP nom_groupe | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
        { CREATE | ALL [ PRIVILEGES ] }
        ON TABLESPACE nom_espacelogique [, ...]
        FROM { nom_utilisateur | GROUP nom_groupe | PUBLIC } [, ...]
        [ CASCADE | RESTRICT ]

en: roll back to a savepoint
fr: retourner à un point de sauvegarde

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

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

en: SAVEPOINT savepoint_name
fr: SAVEPOINT nom_point_de_sauvegarde

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

en: SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
        * | expression [ AS output_name ] [, ...]
        [ FROM from_item [, ...] ]
        [ WHERE condition ]
        [ GROUP BY expression [, ...] ]
        [ HAVING condition [, ...] ]
        [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
        [ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
        [ LIMIT { count | ALL } ]
        [ OFFSET start ]
        [ FOR UPDATE [ OF table_name [, ...] ] ]
    
    where from_item can be one of:
    
        [ ONLY ] table_name [ * ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
        ( select ) [ 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 [, ...] ) ]
fr: SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
        * | expression [ AS nom_affiché ] [, ...]
        [ FROM depuis_élément [, ...] ]
        [ WHERE condition ]
        [ GROUP BY expression [, ...] ]
        [ HAVING condition [, ...] ]
        [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
        [ ORDER BY expression [ ASC | DESC | USING opérateur ] [, ...] ]
        [ LIMIT { nombre_enregistrements | ALL } ]
        [ OFFSET depuis_enregistrement ]
        [ FOR UPDATE [ OF nom_table [, ...] ] ]
    
    où depuis_élément peut prendre une des valeurs suivantes :
    
        [ ONLY ] nom_table [ * ] [ [ AS ] alias [ ( alias_colonne [, ...] ) ] ]
        ( select ) [ AS ] alias [ ( alias_column [, ...] ) ]
        function_name ( [ argument [, ...] ] ) [ AS ] alias [ ( alias_colonne [, ...] | définition_colonne [, ...] ) ]
        function_name ( [ argument [, ...] ] ) AS ( définition_colonne [, ...] )
        from_item [ NATURAL ] type_jointure depuis_élément [ ON condition_jointure | USING ( colonne_jointure [, ...] ) ]

en: 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 [, ...] ]
        [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
        [ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
        [ LIMIT { count | ALL } ]
        [ OFFSET start ]
        [ FOR UPDATE [ OF tablename [, ...] ] ]
fr: SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
        * | expression [ AS nom_affiché ] [, ...]
        INTO [ TEMPORARY | TEMP ] [ TABLE ] nouvelle_table
        [ FROM depuis_élément [, ...] ]
        [ WHERE condition ]
        [ GROUP BY expression [, ...] ]
        [ HAVING condition [, ...] ]
        [ { UNION | INTERSECT | EXCEPT } [ ALL ] sélection ]
        [ ORDER BY expression [ ASC | DESC | USING opérateur ] [, ...] ]
        [ LIMIT { nombre_extrait | ALL } ]
        [ OFFSET depuis_enregistrement ]
        [ FOR UPDATE [ OF nom_table [, ...] ] ]

en: change a run-time parameter
fr: modifier un paramètre run-time

en: SET [ SESSION | LOCAL ] name { TO | = } { value | 'value' | DEFAULT }
    SET [ SESSION | LOCAL ] TIME ZONE { timezone | LOCAL | DEFAULT }
fr: SET [ SESSION | LOCAL ] nom { TO | = } { value | 'valeur' | DEFAULT }
    SET [ SESSION | LOCAL ] TIME ZONE { zone_horaire | LOCAL | DEFAULT }

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 CONSTRAINTS { ALL | name [, ...] } { DEFERRED | IMMEDIATE }
fr: SET CONSTRAINTS { ALL | nom [, ...] } { DEFERRED | IMMEDIATE }

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

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 the characteristics of the current transaction
fr: définir les caractéristiques de la transaction en cours

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 fait partie de :
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY

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

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

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 fait partie de :
    
        ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
        READ WRITE | READ ONLY

en: empty a table
fr: vider une table

en: TRUNCATE [ TABLE ] name
fr: TRUNCATE [ TABLE ] nom

en: stop listening for a notification
fr: ne plus être à l'écoute des notifications

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

en: update rows of a table
fr: mettre à jour les lignes d'une table

en: UPDATE [ ONLY ] table SET column = { expression | DEFAULT } [, ...]
        [ FROM fromlist ]
        [ WHERE condition ]
fr: UPDATE [ ONLY ] table SET colonne = { expression | DEFAULT } [, ...]
        [ FROM depuis_liste ]
        [ WHERE condition ]

en: garbage-collect and optionally analyze a database
fr: collecte des fragments avec en option la possibilité d'analyser une base de données

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 [, ...] ) ] ]
