[Trad] [svn:pgfr] r1316 - in traduc/trunk/postgresql: . ref
admin at listes.postgresql.fr
admin at listes.postgresql.fr
Sam 2 Mai 17:22:39 CEST 2009
Author: gleu
Date: 2009-05-02 17:22:39 +0200 (Sat, 02 May 2009)
New Revision: 1316
Modified:
traduc/trunk/postgresql/libpq.xml
traduc/trunk/postgresql/monitoring.xml
traduc/trunk/postgresql/plpgsql.xml
traduc/trunk/postgresql/ref/create_server.xml
Log:
Suite de la traduction 8.4, dont un fichier de Florence Cousin.
Modified: traduc/trunk/postgresql/libpq.xml
===================================================================
--- traduc/trunk/postgresql/libpq.xml 2009-04-30 21:53:48 UTC (rev 1315)
+++ traduc/trunk/postgresql/libpq.xml 2009-05-02 15:22:39 UTC (rev 1316)
@@ -740,7 +740,8 @@
<term><function>PQconninfoParse</function><indexterm><primary>PQconninfoParse</primary></indexterm></term>
<listitem>
<para>
- Returns parsed connection options from the provided connection string.
+ Renvoit les options de connexions analysées d'après la chaîne de
+ connexion fournie.
<synopsis>
PQconninfoOption *PQconninfoParse(const char *conninfo, char **errmsg);
@@ -748,35 +749,37 @@
</para>
<para>
- Parses a connection string and returns the resulting options as an
- array; or returns NULL if there is a problem with the connection
- string. This can be used to determine
- the <function>PQconnectdb</function> options in the provided
- connection string. The return value points to an array of
- <structname>PQconninfoOption</structname> structures, which ends
- with an entry having a null <structfield>keyword</structfield> pointer.
+ Analyse une chaîne de connexion et renvoie les options résultantes
+ dans un tableau ; renvoit NULL si un problème a été détecté avec
+ la chaîne de connexion. Ceci peut être utilisé pour déterminer les
+ options de <function>PQconnectdb</function> dans la chaîne de connexion
+ fournie. La valeur de retour pointe vers un tableau de structures
+ <structname>PQconninfoOption</structname> et termine avec une entrée
+ ayant un pointeur <structfield>keyword</structfield> nul.
</para>
<para>
- Note that only options explicitly specified in the string will have
- values set in the result array; no defaults are inserted.
+ Notez que seules les options explicitement spécifiées dans la chaîne
+ auront une valeur initialisée dans le tableau résultant ; aucune
+ valeur par défaut ne sera insérée.
</para>
<para>
- If <literal>errmsg</literal> is not NULL, then
- <literal>*errmsg</literal> is set
- to NULL on success, else to a malloc'd error string explaining
- the problem. (It is also possible for <literal>*errmsg</literal> to be
- set to NULL even when NULL is returned; this indicates an out-of-memory
- situation.)
+ Si <literal>errmsg</literal> n'est pas NULL, alors
+ <literal>*errmsg</literal> est configuré à NULL en cas de succès et sinon
+ à un message d'erreur (alloué via un appel à malloc) expliquant le
+ problèm. (Il est aussi possible pour <literal>*errmsg</literal> d'être
+ configuré à NULL même quand NULL est renvoyée ; cela indique un
+ cas de mémoire épuisée.)
</para>
<para>
- After processing the options array, free it by passing it to
- <function>PQconninfoFree</function>. If this is not done, some memory
- is leaked for each call to <function>PQconninfoParse</function>.
- Conversely, if an error occurs and <literal>errmsg</literal> is not NULL,
- be sure to free the error string using <function>PQfreemem</function>.
+ Après avoir traité le tableau des options, libérez-le en le passant à
+ <function>PQconninfoFree</function>. Si ce n'est pas fait, de la mémoire
+ sera perdu à chaque appel à <function>PQconninfoParse</function>.
+ Réciproquement, si une erreur survient et que <literal>errmsg</literal>
+ n'est pas NULL, assurez-vous de libérer la chaîne d'erreur en utilisant
+ <function>PQfreemem</function>.
</para>
</listitem>
@@ -4183,29 +4186,31 @@
<listitem>
<para>
- Constructs an empty <structname>PGresult</structname> object with the given status.
+ Construit un objet <structname>PGresult</structname> vide avec la statut
+ indiqué.
<synopsis>
PGresult *PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status);
</synopsis>
</para>
<para>
- This is <application>libpq</application>'s internal function to allocate and
- initialize an empty <structname>PGresult</structname> object. This
- function returns NULL if memory could not be allocated. It is
- exported because some applications find it useful to generate result
- objects (particularly objects with error status) themselves. If
- <parameter>conn</parameter> is not null and <parameter>status</parameter>
- indicates an error, the current error message of the specified
- connection is copied into the <structname>PGresult</structname>.
- Also, if <parameter>conn</parameter> is not null, any event procedures
- registered in the connection are copied into the
- <structname>PGresult</structname>. (They do not get
- <literal>PGEVT_RESULTCREATE</literal> calls, but see
+ C'est une fonction interne de la <application>libpq</application> pour
+ allouer et initialiser un objet <structname>PGresult</structname> vide.
+ Cette fonction renvoit NULL si la mémoire n'a pas pu être allouée. Elle
+ est exportée car certaines applications trouveront utiles de générer
+ eux-mêmes des objets de résultat (tout particulièrement ceux avec des
+ statuts d'erreur). Si <parameter>conn</parameter> n'est pas NULL et que
+ <parameter>status</parameter> indique une erreur, le message d'erreur
+ actuel de la connexion indiquée est copié dans
+ <structname>PGresult</structname>. De plus, si
+ <parameter>conn</parameter> n'est pas NULL, toute procédure d'événement
+ enregistrée dans la connexion est copiée dans le
+ <structname>PGresult</structname>. (Elles n'obtiennent pas d'appels
+ <literal>PGEVT_RESULTCREATE</literal>, mais jetez un œil à
<function>PQfireResultCreateEvents</function>.)
- Note that <function>PQclear</function> should eventually be called
- on the object, just as with a <structname>PGresult</structname>
- returned by <application>libpq</application> itself.
+ Notez que <function>PQclear</function> devra être appelé sur l'objet,
+ comme pour un <structname>PGresult</structname> renvoyé par
+ <application>libpq</application> lui-même.
</para>
</listitem>
</varlistentry>
@@ -4219,10 +4224,10 @@
</term>
<listitem>
<para>
- Fires a <literal>PGEVT_RESULTCREATE</literal> event (see <xref
- linkend="libpq-events"/>) for each event procedure registered in the
- <structname>PGresult</structname> object. Returns non-zero for success,
- zero if any event procedure fails.
+ Déclenche un événement <literal>PGEVT_RESULTCREATE</literal> (voir <xref
+ linkend="libpq-events"/>) pour chaque procédure d'événement enregistré
+ dans l'objet <structname>PGresult</structname>. Renvoit autre chose que
+ zéro en cas de succès, zéro si la procédure d'événement échoue.
<synopsis>
int PQfireResultCreateEvents(PGconn *conn, PGresult *res);
@@ -4230,23 +4235,23 @@
</para>
<para>
- The <literal>conn</literal> argument is passed through to event procedures
- but not used directly. It can be <literal>NULL</literal> if the event
- procedures won't use it.
+ L'argument <literal>conn</literal> est passé aux procédures d'événement
+ mais n'est pas utilisé directement. Il peut être <literal>NULL</literal>
+ si les procédures de l'événement ne l'utiliseront pas.
</para>
<para>
- Event procedures that have already received a
- <literal>PGEVT_RESULTCREATE</literal> or
-<literal>PGEVT_RESULTCOPY</literal> event
- for this object are not fired again.
+ Les procédures d'événements qui ont déjà reçu un événement
+ <literal>PGEVT_RESULTCREATE</literal> ou
+ <literal>PGEVT_RESULTCOPY</literal> pour cet objet ne sont pas déclenchées
+ de nouveau.
</para>
<para>
- The main reason that this function is separate from
- <function>PQmakeEmptyPGResult</function> is that it is often appropriate
- to create a <structname>PGresult</structname> and fill it with data
- before invoking the event procedures.
+ La raison principale pour séparer cette fonction de
+ <function>PQmakeEmptyPGResult</function> est qu'il est souvent approprié
+ de créer un <structname>PGresult</structname> et de le remplir avec des
+ données avant d'appeler les procédures d'événement.
</para>
</listitem>
</varlistentry>
@@ -4261,10 +4266,10 @@
<listitem>
<para>
- Makes a copy of a <structname>PGresult</structname> object. The copy is
- not linked to the source result in any way and
- <function>PQclear</function> must be called when the copy is no longer
- needed. If the function fails, NULL is returned.
+ Fait une copie de l'objet <structname>PGresult</structname>. La copie
+ n'est liée en aucune façon au résultat source et
+ <function>PQclear</function> doit être appelée dans que la copie n'est
+ plus nécessaire. Si la fonction échoue, NULL est renvoyé.
<synopsis>
PGresult *PQcopyResult(const PGresult *src, int flags);
@@ -4272,20 +4277,20 @@
</para>
<para>
- This is not intended to make an exact copy. The returned result is
- always put into <literal>PGRES_TUPLES_OK</literal> status, and does not
- copy any error message in the source. (It does copy the command status
- string, however.) The <parameter>flags</parameter> argument determines
- what else is copied. It is a bitwise OR of several flags.
- <literal>PG_COPYRES_ATTRS</literal> specifies copying the source
- result's attributes (column definitions).
- <literal>PG_COPYRES_TUPLES</literal> specifies copying the source
- result's tuples. (This implies copying the attributes, too.)
- <literal>PG_COPYRES_NOTICEHOOKS</literal> specifies
- copying the source result's notify hooks.
- <literal>PG_COPYRES_EVENTS</literal> specifies copying the source
- result's events. (But any instance data associated with the source
- is not copied.)
+ Cela n'a pas pour but de faire une copie exacte. Le résultat renvoyé a
+ toujours le statut <literal>PGRES_TUPLES_OK</literal>, et ne copie aucun
+ message d'erreur dans la source. (Néanmoins, il copie la chaîne de statut
+ de commande.) L'argument <parameter>flags</parameter> détermine le reste
+ à copier. C'est un OR bit à bit de plusieurs drapeaux.
+ <literal>PG_COPYRES_ATTRS</literal> indique la copie des attributs du
+ résultat source (définition des colonnes).
+ <literal>PG_COPYRES_TUPLES</literal> indique la copie des lignes du
+ résultat source. (Cela implique de copier aussi les attributs.)
+ <literal>PG_COPYRES_NOTICEHOOKS</literal> indique la copie des
+ gestionnaires de notification du résultat source.
+ <literal>PG_COPYRES_EVENTS</literal> indique la copie des événements du
+ résultat source. (Mais toute instance de données associée avec la source
+ n'est pas copiée.)
</para>
</listitem>
</varlistentry>
@@ -4300,20 +4305,20 @@
<listitem>
<para>
- Sets the attributes of a <structname>PGresult</structname> object.
+ Initialise les attributs d'un objet <structname>PGresult</structname>.
<synopsis>
int PQsetResultAttrs(PGresult *res, int numAttributes, PGresAttDesc *attDescs);
</synopsis>
</para>
<para>
- The provided <parameter>attDescs</parameter> are copied into the result.
- If the <parameter>attDescs</parameter> pointer is NULL or
- <parameter>numAttributes</parameter> is less than one, the request is
- ignored and the function succeeds. If <parameter>res</parameter>
- already contains attributes, the function will fail. If the function
- fails, the return value is zero. If the function succeeds, the return
- value is non-zero.
+ Les <parameter>attDescs</parameter> fournis sont copiés dans le résultat.
+ Si le pointeur <parameter>attDescs</parameter> est NULL ou si
+ <parameter>numAttributes</parameter> est inférieur à 1, la requête est
+ ignorée et la fonction réussit. Si <parameter>res</parameter> contient
+ déjà les attributs, la fonction échouera. Si la fonction échoue, la valeur
+ de retour est zéro. Si la fonction réussit, la valeur de retour est
+ différente de zéro.
</para>
</listitem>
</varlistentry>
@@ -4328,26 +4333,28 @@
<listitem>
<para>
- Sets a tuple field value of a <structname>PGresult</structname> object.
+ Initialise la valeur d'un champ d'une ligne d'un objet
+ <structname>PGresult</structname>.
<synopsis>
int PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len);
</synopsis>
</para>
<para>
- The function will automatically grow the result's internal tuples array
- as needed. However, the <parameter>tup_num</parameter> argument must be
- less than or equal to <function>PQntuples</function>, meaning this
- function can only grow the tuples array one tuple at a time. But any
- field of any existing tuple can be modified in any order. If a value at
- <parameter>field_num</parameter> already exists, it will be overwritten.
- If <parameter>len</parameter> is <literal>-1</literal> or
- <parameter>value</parameter> is <literal>NULL</literal>, the field value
- will be set to an SQL <literal>NULL</literal>. The
- <parameter>value</parameter> is copied into the result's private storage,
- thus is no longer needed after the function
- returns. If the function fails, the return value is zero. If the
- function succeeds, the return value is non-zero.
+ La fonction fera automatiquement grossir le tableau de lignes internes des
+ résultats, si nécessaire. Néanmoins, l'argument
+ <parameter>tup_num</parameter> doit être inférieur ou égal à
+ <function>PQntuples</function>, ceci signifiant que la fonction peut
+ seulement faire grossir le tableau des lignes une ligne à la fois. Mais
+ tout champ d'une ligne existante peut être modifié dans n'importe quel
+ ordre. Si une valeur à <parameter>field_num</parameter> existe déjà, elle
+ sera écrasée. Si <parameter>len</parameter> vaut <literal>-1</literal> ou
+ si <parameter>value</parameter> est <literal>NULL</literal>, la valeur
+ du champ sera configurée à la valeur SQL <literal>NULL</literal>.
+ <parameter>value</parameter> est copié dans le stockage privé du résultat,
+ donc n'est plus nécessaire au retour de la fonction. Si la fonction échoue,
+ la valeur de retour est zéro. Dans le cas contraire, elle a une valeur
+ différente de zéro.
</para>
</listitem>
</varlistentry>
@@ -4362,18 +4369,19 @@
<listitem>
<para>
- Allocate subsidiary storage for a <structname>PGresult</structname> object.
+ Alloue un stockage supplémentaire pour un objet
+ <structname>PGresult</structname>.
<synopsis>
void *PQresultAlloc(PGresult *res, size_t nBytes);
</synopsis>
</para>
<para>
- Any memory allocated with this function will be freed when
- <parameter>res</parameter> is cleared. If the function fails,
- the return value is <literal>NULL</literal>. The result is
- guaranteed to be adequately aligned for any type of data,
- just as for <function>malloc</function>.
+ Toute mémoire allouée avec cette fonction est libérée quand
+ <parameter>res</parameter> est effacée. Si la fonction échoue, la valeur
+ de retour vaut <literal>NULL</literal>. Le résultat est garanti d'être
+ correctement aligné pour tout type de données, comme pour un
+ <function>malloc</function>.
</para>
</listitem>
</varlistentry>
@@ -4488,54 +4496,53 @@
</sect1>
<sect1 id="libpq-events">
- <title>Event System</title>
+ <title>Système d'événements</title>
<para>
- <application>libpq</application>'s event system is designed to notify
- registered event handlers about interesting
- <application>libpq</application> events, such as the creation or
- destruction of <structname>PGconn</structname> and
- <structname>PGresult</structname> objects. A principal use case is that
- this allows applications to associate their own data with a
- <structname>PGconn</structname> or <structname>PGresult</structname>
- and ensure that that data is freed at an appropriate time.
+ Le système d'événements de <application>libpq</application> est conçu pour
+ notifier les gestionnaires d'événements enregistrés de l'arrivée d'événements
+ intéressants de la <application>libpq</application>, comme par exemple la
+ création ou la destruction d'objets <structname>PGconn</structname> et
+ <structname>PGresult</structname>. Un cas d'utilisation principal est de
+ permettre aux applications d'associer leur propres données avec un
+ <structname>PGconn</structname> ou un <structname>PGresult</structname> et
+ de s'assurer que les données soient libérées au bon moment.
</para>
<para>
- Each registered event handler is associated with two pieces of data,
- known to <application>libpq</application> only as opaque <literal>void
- *</literal>
- pointers. There is a <firstterm>passthrough</firstterm> pointer that is provided
- by the application when the event handler is registered with a
- <structname>PGconn</structname>. The passthrough pointer never changes for the
- life of the <structname>PGconn</structname> and all
- <structname>PGresult</structname>s
- generated from it; so if used, it must point to long-lived data.
- In addition there is an <firstterm>instance data</firstterm> pointer, which starts
- out NULL in every <structname>PGconn</structname> and
- <structname>PGresult</structname>.
- This pointer can be manipulated using the
- <function>PQinstanceData</function>,
- <function>PQsetInstanceData</function>,
- <function>PQresultInstanceData</function> and
- <function>PQsetResultInstanceData</function> functions. Note that
- unlike the passthrough pointer, instance data of a
- <structname>PGconn</structname>
- is not automatically inherited by <structname>PGresult</structname>s created from
- it. <application>libpq</application> does not know what passthrough
- and instance data pointers point to (if anything) and will never attempt
- to free them — that is the responsibility of the event handler.
+ Chaque gestionnaire d'événement enregistré est associé avec deux types de
+ données, connus par <application>libpq</application> comme des pointeurs
+ opaques, c'est-à-dire <literal>void *</literal>. Il existe un pointeur
+ <firstterm>passthrough</firstterm> fournie par l'application quand le
+ gestionnaire d'événements est enregistré avec un <structname>PGconn</structname>.
+ Le pointeur passthrough ne change jamais pendant toute la durée du
+ <structname>PGconn</structname> et des <structname>PGresult</structname>
+ générés grâce à lui ; donc s'il est utilisé, il doit pointer vers
+ des données vivantes. De plus, il existe une pointeur de <firstterm>données
+ instanciées</firstterm>, qui commence à NULL dans chaque objet
+ <structname>PGconn</structname> et <structname>PGresult</structname>. Ce
+ pointeur peut être manipulé en utilisant les fonctions
+ <function>PQinstanceData</function>, <function>PQsetInstanceData</function>,
+ <function>PQresultInstanceData</function> et
+ <function>PQsetResultInstanceData</function>. Notez que, contrairement au
+ pointeur passthrough, les <structname>PGresult</structname> n'héritent pas
+ automatiquement des données instanciées d'un
+ <structname>PGconn</structname>. <application>libpq</application> ne sait
+ pas vers quoi pointent les pointeurs passthrough et de données instanciées,
+ et n'essaiera hamais de les libérer — cela tient de la responsabilité
+ du gestionnaire d'événements.
</para>
<sect2 id="libpq-events-types">
- <title>Event Types</title>
+ <title>Types d'événements</title>
<para>
- The enum <literal>PGEventId</literal> names the types of events handled by
- the event system. All its values have names beginning with
- <literal>PGEVT</literal>. For each event type, there is a corresponding
- event info structure that carries the parameters passed to the event
- handlers. The event types are:
+ La variable <literal>PGEventId</literal> de type enum précise tous les types
+ d'événements gérés par le système d'événements. Toutes ces valeurs ont des
+ noms commençant avec <literal>PGEVT</literal>. Pour chaque type d'événement,
+ il existe une structure d'informations sur l'événement, précisant les
+ paramètres passés aux gestionnaires d'événement. Les types d'événements
+ sont :
</para>
<variablelist>
@@ -4543,11 +4550,12 @@
<term><literal>PGEVT_REGISTER</literal></term>
<listitem>
<para>
- The register event occurs when <function>PQregisterEventProc</function>
- is called. It is the ideal time to initialize any
- <literal>instanceData</literal> an event procedure may need. Only one
- register event will be fired per event handler per connection. If the
- event procedure fails, the registration is aborted.
+ L'événement d'enregistrement survient quand <function>PQregisterEventProc</function>
+ est appelé.; C'est le moment idéal pour initialiser toute structure
+ <literal>instanceData</literal> qu'une procédure d'événement pourrait avoir
+ besoin. Seul un événement d'enregistrement sera déclenché par gestionnaire
+ d'évévenement sur une connexion. Si la procédure échoue, l'enregistrement
+ est annulé.
<synopsis>
typedef struct
@@ -4556,15 +4564,15 @@
} PGEventRegister;
</synopsis>
- When a <literal>PGEVT_REGISTER</literal> event is received, the
- <parameter>evtInfo</parameter> pointer should be cast to a
- <structname>PGEventRegister *</structname>. This structure contains a
- <structname>PGconn</structname> that should be in the
- <literal>CONNECTION_OK</literal> status; guaranteed if one calls
- <function>PQregisterEventProc</function> right after obtaining a good
- <structname>PGconn</structname>. When returning a failure code, all
- cleanup must be performed as no <literal>PGEVT_CONNDESTROY</literal>
- event will be sent.
+ Quand un événement <literal>PGEVT_REGISTER</literal> est reçu, le pointeur
+ <parameter>evtInfo</parameter> doit être converti en un
+ <structname>PGEventRegister *</structname>. Cette structure contient un
+ <structname>PGconn</structname> qui doit être dans le statut
+ <literal>CONNECTION_OK</literal> ; garanti si
+ <function>PQregisterEventProc</function> est appelé juste après avoir
+ obtenu un bon <structname>PGconn</structname>. Lorsqu'elle renvoit
+ un code d'erreur, le nettoyage doit être réalisé car aucun événement
+ <literal>PGEVT_CONNDESTROY</literal> ne sera envoyé.
</para>
</listitem>
</varlistentry>
@@ -4573,13 +4581,13 @@
<term><literal>PGEVT_CONNRESET</literal></term>
<listitem>
<para>
- The connection reset event is fired on completion of
- <function>PQreset</function> or <function>PQresetPoll</function>. In
- both cases, the event is only fired if the reset was successful. If
- the event procedure fails, the entire connection reset will fail; the
- <structname>PGconn</structname> is put into
- <literal>CONNECTION_BAD</literal> status and
- <function>PQresetPoll</function> will return
+ L'événement de réinitialisation de connexion est déclenché après un
+ <function>PQreset</function> ou un <function>PQresetPoll</function>. Dans
+ les deux cas, l'événement est seulement déclenché si la ré-initialisation
+ est réussie. Si la procédure échoue, la réinitialisation de connexion
+ échouera ; la structure <structname>PGconn</structname> est placée
+ dans le statut <literal>CONNECTION_BAD</literal> et
+ <function>PQresetPoll</function> renverra
<literal>PGRES_POLLING_FAILED</literal>.
<synopsis>
@@ -4589,15 +4597,15 @@
} PGEventConnReset;
</synopsis>
- When a <literal>PGEVT_CONNRESET</literal> event is received, the
- <parameter>evtInfo</parameter> pointer should be cast to a
- <structname>PGEventConnReset *</structname>. Although the contained
- <structname>PGconn</structname> was just reset, all event data remains
- unchanged. This event should be used to reset/reload/requery any
- associated <literal>instanceData</literal>. Note that even if the
- event procedure fails to process <literal>PGEVT_CONNRESET</literal>, it will
- still receive a <literal>PGEVT_CONNDESTROY</literal> event when the connection
- is closed.
+ Quand un événement <literal>PGEVT_CONNRESET</literal> est reçu, le
+ pointeur <parameter>evtInfo</parameter> doit être converti en un
+ <structname>PGEventConnReset *</structname>. Bien que le
+ <structname>PGconn</structname> a été réinitialisé, toutes les données
+ de l'événement restent inchangées. Cet événement doit être utilisé pour
+ ré-initialiser/recharger/re-requêter tout <literal>instanceData</literal>
+ associé. Notez que même si la procédure d'événement échoue à traiter
+ <literal>PGEVT_CONNRESET</literal>, elle recevra toujours un événement
+ <literal>PGEVT_CONNDESTROY</literal> à la fermeture de la connexion.
</para>
</listitem>
</varlistentry>
@@ -4606,11 +4614,11 @@
<term><literal>PGEVT_CONNDESTROY</literal></term>
<listitem>
<para>
- The connection destroy event is fired in response to
- <function>PQfinish</function>. It is the event procedure's
- responsibility to properly clean up its event data as libpq has no
- ability to manage this memory. Failure to clean up will lead
- to memory leaks.
+ L'événement de destruction de la connexion est déclenchée en réponse
+ à <function>PQfinish</function>. Il est de la responsabilité de la
+ procédure de l'événement de nettoyer proprement ses données car
+ libpq n'a pas les moyens de gérer cette mémoire. Un échec du
+ nettoyage amènera des pertes mémoire.
<synopsis>
typedef struct
@@ -4619,14 +4627,14 @@
} PGEventConnDestroy;
</synopsis>
- When a <literal>PGEVT_CONNDESTROY</literal> event is received, the
- <parameter>evtInfo</parameter> pointer should be cast to a
- <structname>PGEventConnDestroy *</structname>. This event is fired
- prior to <function>PQfinish</function> performing any other cleanup.
- The return value of the event procedure is ignored since there is no
- way of indicating a failure from <function>PQfinish</function>. Also,
- an event procedure failure should not abort the process of cleaning up
- unwanted memory.
+ Quand un événement <literal>PGEVT_CONNDESTROY</literal> est reçu, le
+ pointeur <parameter>evtInfo</parameter> doit être converti en un
+ <structname>PGEventConnDestroy *</structname>. Cet événement est
+ déclenché avant que <function>PQfinish</function> ne réalise d'autres
+ nettoyages. La valeur de retour de la procédure est ignorée car il
+ n'y a aucun moyen d'indiquer un échec de <function>PQfinish</function>.
+ De plus, un échec de la procédure ne doit pas annuler le nettoyage de
+ la mémoire non désirée.
</para>
</listitem>
</varlistentry>
@@ -4635,10 +4643,10 @@
<term><literal>PGEVT_RESULTCREATE</literal></term>
<listitem>
<para>
- The result creation event is fired in response to any query execution
- function that generates a result, including
- <function>PQgetResult</function>. This event will only be fired after
- the result has been created successfully.
+ L'événement de création de résultat est déclenché en réponse à
+ l'utilisation d'une fonction d'exécution d'une requête, par exemple
+ <function>PQgetResult</function>. Cet événement sera déclenché seulement
+ après la création réussie du résultat.
<synopsis>
typedef struct
@@ -4648,17 +4656,17 @@
} PGEventResultCreate;
</synopsis>
- When a <literal>PGEVT_RESULTCREATE</literal> event is received, the
- <parameter>evtInfo</parameter> pointer should be cast to a
- <structname>PGEventResultCreate *</structname>. The
- <parameter>conn</parameter> is the connection used to generate the
- result. This is the ideal place to initialize any
- <literal>instanceData</literal> that needs to be associated with the
- result. If the event procedure fails, the result will be cleared and
- the failure will be propagated. The event procedure must not try to
- <function>PQclear</function> the result object for itself. When returning a
- failure code, all cleanup must be performed as no
- <literal>PGEVT_RESULTDESTROY</literal> event will be sent.
+ Quand un événement <literal>PGEVT_RESULTCREATE</literal> est reçu, le
+ pointeur <parameter>evtInfo</parameter> doit être converti en un
+ <structname>PGEventResultCreate *</structname>. Le paramètre
+ <parameter>conn</parameter> est la connexion utilisée pour générer le
+ résultat. C'est le moment idéal pour initialiser tout
+ <literal>instanceData</literal> qui doit être associé avec le résultat.
+ Si la procédure échoue, le résultat sera effacé et l'échec sera propagé.
+ Le procédure d'événement ne doit pas tenter un <function>PQclear</function>
+ sur l'objet résultat lui-même. Lors du renvoi d'un code d'échec, tout le
+ nettoyage doit être fait car aucun événement
+ <literal>PGEVT_RESULTDESTROY</literal> ne sera envoyé.
</para>
</listitem>
</varlistentry>
@@ -4667,12 +4675,12 @@
<term><literal>PGEVT_RESULTCOPY</literal></term>
<listitem>
<para>
- The result copy event is fired in response to
- <function>PQcopyResult</function>. This event will only be fired after
- the copy is complete. Only event procedures that have
- successfully handled the <literal>PGEVT_RESULTCREATE</literal>
- or <literal>PGEVT_RESULTCOPY</literal> event for the source result
- will receive <literal>PGEVT_RESULTCOPY</literal> events.
+ L'événement de copie du résultat est déclenché en réponse à un
+ <function>PQcopyResult</function>. Cet événement se déclenchera
+ seulement une fois la copie terminée. Seules les procédures qui ont
+ gérées avec succès l'événement <literal>PGEVT_RESULTCREATE</literal>
+ ou <literal>PGEVT_RESULTCOPY</literal> pour le résultat source recevront
+ les événements <literal>PGEVT_RESULTCOPY</literal>.
<synopsis>
typedef struct
@@ -4682,18 +4690,19 @@
} PGEventResultCopy;
</synopsis>
- When a <literal>PGEVT_RESULTCOPY</literal> event is received, the
- <parameter>evtInfo</parameter> pointer should be cast to a
- <structname>PGEventResultCopy *</structname>. The
- <parameter>src</parameter> result is what was copied while the
- <parameter>dest</parameter> result is the copy destination. This event
- can be used to provide a deep copy of <literal>instanceData</literal>,
- since <literal>PQcopyResult</literal> cannot do that. If the event
- procedure fails, the entire copy operation will fail and the
- <parameter>dest</parameter> result will be cleared. When returning a
- failure code, all cleanup must be performed as no
- <literal>PGEVT_RESULTDESTROY</literal> event will be sent for the
- destination result.
+ Quand un événement <literal>PGEVT_RESULTCOPY</literal> est reçu, le
+ pointeur <parameter>evtInfo</parameter> doit être converti en un
+ <structname>PGEventResultCopy *</structname>. Le résultat
+ résultat <parameter>src</parameter> correspond à ce qui a été copié
+ alors que le résultat <parameter>dest</parameter> correspond à la
+ destination. Cet événement peut être utilisé pour fournir une copie
+ complète de <literal>instanceData</literal>, ce que
+ <literal>PQcopyResult</literal> ne peut pas faire. Si la procédure
+ échoue, l'opération complète de copie échouera et le résultat
+ <parameter>dest</parameter> sera effacé. Au renvoi d'un code d'échec,
+ tout le nettoyage doit être réalisé car aucun événement
+ <literal>PGEVT_RESULTDESTROY</literal> ne sera envoyé pour le résultat
+ de destination.
</para>
</listitem>
</varlistentry>
@@ -4702,11 +4711,11 @@
<term><literal>PGEVT_RESULTDESTROY</literal></term>
<listitem>
<para>
- The result destroy event is fired in response to a
- <function>PQclear</function>. It is the event procedure's
- responsibility to properly clean up its event data as libpq has no
- ability to manage this memory. Failure to clean up will lead
- to memory leaks.
+ L'événement de destruction de résultat est déclenché en réponse à la
+ fonction <function>PQclear</function>. C'est de la responsabilité de
+ l'événement de nettoyer proprement les données de l'événement car libpq
+ n'a pas cette capacité en matière de gestion de mémoire. Si le nettoyage
+ échoue, cela sera la cause de pertes mémoire.
<synopsis>
typedef struct
@@ -4715,14 +4724,14 @@
} PGEventResultDestroy;
</synopsis>
- When a <literal>PGEVT_RESULTDESTROY</literal> event is received, the
- <parameter>evtInfo</parameter> pointer should be cast to a
- <structname>PGEventResultDestroy *</structname>. This event is fired
- prior to <function>PQclear</function> performing any other cleanup.
- The return value of the event procedure is ignored since there is no
- way of indicating a failure from <function>PQclear</function>. Also,
- an event procedure failure should not abort the process of cleaning up
- unwanted memory.
+ Quand un événement <literal>PGEVT_RESULTDESTROY</literal> est reçu, le
+ pointeur <parameter>evtInfo</parameter> doit être converti en un
+ <structname>PGEventResultDestroy *</structname>. Cet événement est
+ déclenché avant que <function>PQclear</function> ne puisse faire de
+ nettoyage. La valeur de retour de la procédure est ignorée car il
+ n'existe aucun moyen d'indiquer un échec à partir de
+ <function>PQclear</function>. De plus, un échec de la procédure ne doit
+ pas annuler le nettoyage de la mémoire non désirée.
</para>
</listitem>
</varlistentry>
@@ -4730,7 +4739,7 @@
</sect2>
<sect2 id="libpq-events-proc">
- <title>Event Callback Procedure</title>
+ <title>Procédure de rappel de l'événement</title>
<variablelist>
<varlistentry>
@@ -4743,40 +4752,43 @@
<listitem>
<para>
- <literal>PGEventProc</literal> is a typedef for a pointer to an
- event procedure, that is, the user callback function that receives
- events from libpq. The signature of an event procedure must be
+ <literal>PGEventProc</literal> est une définition de type pour un pointeur
+ vers une procédure d'événement, c'est-à-dire la fonction utilisateur
+ appelée pour les événements de la libpq. La signature d'une telle fonction
+ doit être :
<synopsis>
int eventproc(PGEventId evtId, void *evtInfo, void *passThrough)
</synopsis>
- The <parameter>evtId</parameter> parameter indicates which
- <literal>PGEVT</literal> event occurred. The
- <parameter>evtInfo</parameter> pointer must be cast to the appropriate
- structure type to obtain further information about the event.
- The <parameter>passThrough</parameter> parameter is the pointer
- provided to <function>PQregisterEventProc</function> when the event
- procedure was registered. The function should return a non-zero value
- if it succeeds and zero if it fails.
+ Le paramètre <parameter>evtId</parameter> indique l'événement
+ <literal>PGEVT</literal> qui est survenu. Le pointeur
+ <parameter>evtInfo</parameter> doit être converti vers le type
+ de structure approprié pour obtenir plus d'informations sur l'événement.
+ Le paramètre <parameter>passThrough</parameter> est le pointeur fourni
+ à <function>PQregisterEventProc</function> quand la procédure de
+ l'événement a été enregistrée. La fonction doit renvoyer une valeur
+ différente de zéro en cas de succès et zéro en cas d'échec.
</para>
<para>
- A particular event procedure can be registered only once in any
- <structname>PGconn</structname>. This is because the address of the procedure
- is used as a lookup key to identify the associated instance data.
+ Une procédure d'événement particulière peut être enregistrée une fois
+ seulement pour un <structname>PGconn</structname>. Ceci est dû au fait
+ que l'adresse de la procédure est utilisée comme clé de recherche pour
+ identifier les données instanciées associées.
</para>
<caution>
<para>
- On Windows, functions can have two different addresses: one visible
- from outside a DLL and another visible from inside the DLL. One
- should be careful that only one of these addresses is used with
- <application>libpq</application>'s event-procedure functions, else confusion will
- result. The simplest rule for writing code that will work is to
- ensure that event procedures are declared <literal>static</literal>. If the
- procedure's address must be available outside its own source file,
- expose a separate function to return the address.
+ Sur Windows, les fonctions peuvent avoir deux adresses différentes :
+ une visible de l'extérieur de la DLL et une visible de l'intérieur. Il
+ faut faire attention que seule une de ces adresses est utilisée avec les
+ fonctions d'événement de la <application>libpq</application>, sinon une
+ confusion en résultera. La règle la plus simple pour écrire du code qui
+ fonctionnera est de s'assurer que les procédures d'événements sont
+ déclarées <literal>static</literal>. Si l'adresse de la procédure doit
+ être disponible en dehors de son propre fichier source, il faut exposer
+ une fonction séparée pour renvoyer l'adresse.
</para>
</caution>
</listitem>
@@ -4785,7 +4797,7 @@
</sect2>
<sect2 id="libpq-events-funcs">
- <title>Event Support Functions</title>
+ <title>Fonctions de support des événements</title>
<variablelist>
<varlistentry>
@@ -4798,7 +4810,7 @@
<listitem>
<para>
- Registers an event callback procedure with libpq.
+ Enregistre une procédure de rappel pour les événements avec libpq.
<synopsis>
int PQregisterEventProc(PGconn *conn, PGEventProc proc,
@@ -4807,23 +4819,25 @@
</para>
<para>
- An event procedure must be registered once on each
- <structname>PGconn</structname> you want to receive events about. There is no
- limit, other than memory, on the number of event procedures that
- can be registered with a connection. The function returns a non-zero
- value if it succeeds and zero if it fails.
+ Une procédure d'évenement doit être enregistré une fois pour chaque
+ <structname>PGconn</structname> pour lequel vous souhaitez recevoir des
+ événements. Il n'existe pas de limites, autre que la mémoire, sur le
+ nombre de procédures d'événements qui peuvent être enregistrées avec
+ une connexion. La fonction renvoie une valeur différente de zéro en cas
+ de succès, et zéro en cas d'échec.
</para>
<para>
- The <parameter>proc</parameter> argument will be called when a libpq
- event is fired. Its memory address is also used to lookup
- <literal>instanceData</literal>. The <parameter>name</parameter>
- argument is used to refer to the event procedure in error messages.
- This value cannot be NULL or a zero-length string. The name string is
- copied into the <structname>PGconn</structname>, so what is passed need not be
- long-lived. The <parameter>passThrough</parameter> pointer is passed
- to the <parameter>proc</parameter> whenever an event occurs. This
- argument can be NULL.
+ L'argument <parameter>proc</parameter> sera appelé quand se déclenchera
+ un événement libpq. Son adresse mémoire est aussi utilisée pour rechercher
+ <literal>instanceData</literal>. L'argument <parameter>name</parameter>
+ est utilisé pour faire référence à la procédure d'évenement dans les
+ messages d'erreur. Cette valeur ne peut pas être NULL ou une chaîne de
+ longueur nulle. La chaîne du nom est copiée dans
+ <structname>PGconn</structname>, donc ce qui est passé n'a pas besoin de
+ durer longtemps. Le pointeur <parameter>passThrough</parameter> est
+ passé à <parameter>proc</parameter> à chaque arrivée d'un événement. Cet
+ argument peut être NULL.
</para>
</listitem>
</varlistentry>
@@ -4837,9 +4851,10 @@
</term>
<listitem>
<para>
- Sets the conn's instanceData for proc to data. This returns non-zero
- for success and zero for failure. (Failure is only possible if
- the proc has not been properly registered in the conn.)
+ Initialise instanceData de la connexion pour la procédure proc avec data.
+ Cette fonction renvoit zéro en cas d'échec et autre chose en cas de réussite.
+ (L'échec est seulement possible si proc n'a pas été correctement
+ enregistré dans le résultat.)
<synopsis>
int PQsetInstanceData(PGconn *conn, PGEventProc proc, void *data);
@@ -4857,8 +4872,8 @@
</term>
<listitem>
<para>
- Returns the conn's instanceData associated with proc, or NULL
- if there is none.
+ Renvoie le instanceData de la connexion associée avec proc ou NULL s'il
+ n'y en a pas.
<synopsis>
void *PQinstanceData(const PGconn *conn, PGEventProc proc);
@@ -4876,9 +4891,10 @@
</term>
<listitem>
<para>
- Sets the result's instanceData for proc to data. This returns non-zero
- for success and zero for failure. (Failure is only possible if the
- proc has not been properly registered in the result.)
+ Initialise le instanceData du résultat pour la procédure proc avec data.
+ Cette fonction renvoit zéro en cas d'échec et autre chose en cas de réussite.
+ (L'échec est seulement possible si proc n'a pas été correctement
+ enregistré dans le résultat.)
<synopsis>
int PQresultSetInstanceData(PGresult *res, PGEventProc proc, void *data);
@@ -4896,8 +4912,8 @@
</term>
<listitem>
<para>
- Returns the result's instanceData associated with proc, or NULL
- if there is none.
+ Renvoie le instanceData du résultat associé avec proc ou NULL s'il n'y
+ en a pas.
<synopsis>
void *PQresultInstanceData(const PGresult *res, PGEventProc proc);
@@ -4909,19 +4925,19 @@
</sect2>
<sect2 id="libpq-events-example">
- <title>Event Example</title>
+ <title>Exemple d'un événement</title>
<para>
- Here is a skeleton example of managing private data associated with
- libpq connections and results.
+ Voici un exemple d'une gestion de données privées associée aux connexions
+ et aux résultats de la libpq.
</para>
<programlisting>
<![CDATA[
-/* required header for libpq events (note: includes libpq-fe.h) */
+/* en-tête nécssaire pour les événements de la libpq (note : inclut libpq-fe.h) */
#include <libpq-events.h>
-/* The instanceData */
+/* la donnée instanciée : instanceData */
typedef struct
{
int n;
@@ -4946,8 +4962,8 @@
return 1;
}
- /* called once on any connection that should receive events.
- * Sends a PGEVT_REGISTER to myEventProc.
+ /* appelée une fois pour toute connexion qui doit recevoir des événements.
+ * Envoit un PGEVT_REGISTER à myEventProc.
*/
if (!PQregisterEventProc(conn, myEventProc, "mydata_proc", NULL))
{
@@ -4956,28 +4972,28 @@
return 1;
}
- /* conn instanceData is available */
+ /* la connexion instanceData est disponible */
data = PQinstanceData(conn, myEventProc);
- /* Sends a PGEVT_RESULTCREATE to myEventProc */
+ /* Envoit un PGEVT_RESULTCREATE à myEventProc */
res = PQexec(conn, "SELECT 1 + 1");
- /* result instanceData is available */
+ /* le résultat instanceData est disponible */
data = PQresultInstanceData(res, myEventProc);
- /* If PG_COPYRES_EVENTS is used, sends a PGEVT_RESULTCOPY to myEventProc */
+ /* Si PG_COPYRES_EVENTS est utilisé, envoit un PGEVT_RESULTCOPY à myEventProc */
res_copy = PQcopyResult(res, PG_COPYRES_TUPLES | PG_COPYRES_EVENTS);
- /* result instanceData is available if PG_COPYRES_EVENTS was
- * used during the PQcopyResult call.
+ /* le résultat instanceData est disponible si PG_COPYRES_EVENTS a été
+ * utilisé lors de l'appel à PQcopyResult.
*/
data = PQresultInstanceData(res_copy, myEventProc);
- /* Both clears send a PGEVT_RESULTDESTROY to myEventProc */
+ /* Les deux fonctions de nettoyage envoient PGEVT_RESULTDESTROY à myEventProc */
PQclear(res);
PQclear(res_copy);
- /* Sends a PGEVT_CONNDESTROY to myEventProc */
+ /* Envoit un PGEVT_CONNDESTROY à myEventProc */
PQfinish(conn);
return 0;
@@ -4993,7 +5009,7 @@
PGEventRegister *e = (PGEventRegister *)evtInfo;
mydata *data = get_mydata(e->conn);
- /* associate app specific data with connection */
+ /* associe des données spécifiques de l'application avec la connexion */
PQsetInstanceData(e->conn, myEventProc, data);
break;
}
@@ -5013,7 +5029,7 @@
PGEventConnDestroy *e = (PGEventConnDestroy *)evtInfo;
mydata *data = PQinstanceData(e->conn, myEventProc);
- /* free instance data because the conn is being destroyed */
+ /* libère les données instanciées car la connexion est en cours de destruction */
if (data)
free_mydata(data);
break;
@@ -5025,7 +5041,7 @@
mydata *conn_data = PQinstanceData(e->conn, myEventProc);
mydata *res_data = dup_mydata(conn_data);
- /* associate app specific data with result (copy it from conn) */
+ /* associe des données spécifiques à l'application avec les résultats (copié de la connexion) */
PQsetResultInstanceData(e->result, myEventProc, res_data);
break;
}
@@ -5036,7 +5052,7 @@
mydata *src_data = PQresultInstanceData(e->src, myEventProc);
mydata *dest_data = dup_mydata(src_data);
- /* associate app specific data with result (copy it from a result) */
+ /* associe des données spécifiques à l'application avec les résultats (copié d'un résultat) */
PQsetResultInstanceData(e->dest, myEventProc, dest_data);
break;
}
@@ -5046,7 +5062,7 @@
PGEventResultDestroy *e = (PGEventResultDestroy *)evtInfo;
mydata *data = PQresultInstanceData(e->result, myEventProc);
- /* free instance data because the result is being destroyed */
+ /* libère les données instanciées car le résultat est en cours de destruction */
if (data)
free_mydata(data);
break;
@@ -5652,17 +5668,19 @@
</table>
<para>
- If your application initializes <literal>libssl</literal> and/or
- <literal>libcrypto</literal> libraries and <application>libpq</application>
- is built with <acronym>SSL</acronym> support, you should call
- <function>PQinitOpenSSL</function> to tell <application>libpq</application>
- that the <literal>libssl</literal> and/or <literal>libcrypto</literal> libraries
- have been initialized by your application, so that
- <application>libpq</application> will not also initialize those libraries.
+ Si votre application initialise les bibliothèques <literal>libssl</literal>
+ et/ou <literal>libcrypto</literal> et que <application>libpq</application>
+ est construit avec le support de <acronym>SSL</acronym>, vous devez appeler
+ la fonction <function>PQinitOpenSSL</function> pour indiquer à
+ <application>libpq</application> que les bibliothèques
+ <literal>libssl</literal> et/ou <literal>libcrypto</literal> ont été
+ initialisées par votre application, de façon à ce que
+ <application>libpq</application> n'initialise pas elle-aussi ces
+ bibliothèques.
<!-- If this URL changes replace it with a URL to www.archive.org. -->
- See <ulink
+ Voir <ulink
url="http://h71000.www7.hp.com/doc/83final/BA554_90007/ch04.html"></ulink>
- for details on the SSL API.
+ pour plus de détails sur l'API SSL.
</para>
<para>
@@ -5677,30 +5695,31 @@
<listitem>
<para>
- Allows applications to select which security libraries to initialize.
+ Permet aux applications de sélectionner les bibliothèques de sécurité
+ à initialiser.
<synopsis>
void PQinitOpenSSL(int do_ssl, init do_crypto);
</synopsis>
</para>
<para>
- When <parameter>do_ssl</parameter> is non-zero, <application>libpq</application>
- will initialize the <application>OpenSSL</application> library before first
- opening a database connection. When <parameter>do_crypto</parameter> is
- non-zero, the <literal>libcrypto</literal> library will be initialized. By
- default (if <function>PQinitOpenSSL</function> is not called), both libraries
- are initialized. When SSL support is not compiled in, this function is
- present but does nothing.
+ Quand <parameter>do_ssl</parameter> est différent de zéro,
+ <application>libpq</application> initialisera la bibliothèque
+ <application>OpenSSL</application> avant d'ouvrir une connexion à la base
+ de données. Quand <parameter>do_crypto</parameter> est différent de
+ zéro, la bibliothèque <literal>libcrypto</literal> sera initialisée. Par
+ défaut (si <function>PQinitOpenSSL</function> n'est pas appelé), les deux
+ bibliothèques sont initialisées. Quand le support de SSL n'est pas
+ intégré, cette fonction est présente mais ne fait rien.
</para>
<para>
- If your application uses and initializes either
- <application>OpenSSL</application>
- or its underlying <literal>libcrypto</literal> library, you
- <emphasis>must</emphasis>
- call this function with zeroes for the appropriate parameter(s)
- before first opening a database connection. Also be sure that you
- have done that initialization before opening a database connection.
+ Si votre application utilise et initialise soit
+ <application>OpenSSL</application> soit <literal>libcrypto</literal>,
+ vous <emphasis>devez</emphasis> appeler cette fonction avec des zéros
+ pour les paramètres appropriés avant d'ouvrir la première connexion à la
+ base de données. De plus, assurez-vous que vous avez fait cette
+ initialisation avant d'ouvrir une connexion à la base de données.
</para>
</listitem>
</varlistentry>
@@ -5715,27 +5734,28 @@
<listitem>
<para>
- Allows applications to select which security libraries to initialize.
+ Permet aux applications de sélectionner les bibliothèques de sécurité
+ à initialiser.
<synopsis>
void PQinitSSL(int do_ssl);
</synopsis>
</para>
<para>
- This function is equivalent to
- <literal>PQinitOpenSSL(do_ssl, do_ssl)</literal>.
- It is sufficient for applications that initialize both or neither
- of <application>OpenSSL</application> and <literal>libcrypto</literal>.
+ Cette fonction est équivalent à
+ <literal>PQinitOpenSSL(do_ssl, do_ssl)</literal>. C'est suffisant pour les
+ applications qui initialisent à la fois <application>OpenSSL</application>
+ et<literal>libcrypto</literal> ou aucune des deux.
</para>
<para>
- <function>PQinitSSL</function> has been present since
- <productname>PostgreSQL</productname> 8.0, while
- <function>PQinitOpenSSL</function>
- was added in <productname>PostgreSQL</productname> 8.4, so
- <function>PQinitSSL</function>
- might be preferable for applications that need to work with older
- versions of <application>libpq</application>.
+ <function>PQinitSSL</function> est présente depuis
+ <productname>PostgreSQL</productname> 8.0, alors que
+ <function>PQinitOpenSSL</function> a été ajoutée dans
+ <productname>PostgreSQL</productname> 8.4, donc
+ <function>PQinitSSL</function> peut être préférée pour les applications
+ qui ont besoin de fonctionner avec les anciennes versions de
+ <application>libpq</application>.
</para>
</listitem>
</varlistentry>
Modified: traduc/trunk/postgresql/monitoring.xml
===================================================================
--- traduc/trunk/postgresql/monitoring.xml 2009-04-30 21:53:48 UTC (rev 1315)
+++ traduc/trunk/postgresql/monitoring.xml 2009-05-02 15:22:39 UTC (rev 1316)
@@ -1198,331 +1198,361 @@
<row>
<entry>statement-status</entry>
<entry>(const char *)</entry>
- <entry>Sonde qui se déclenche anytime the server process updates its
- <structname>pg_stat_activity</structname>.<structfield>current_query</structfield> status.
- arg0 is the new status string.</entry>
+ <entry>Sonde qui se déclenche à chaque fois que le processus serveur met à
+ jour son statut dans
+ <structname>pg_stat_activity</structname>.<structfield>current_query</structfield>.
+ arg0 est la nouvelle chaîne de statut.</entry>
</row>
<row>
<entry>checkpoint-start</entry>
<entry>(int)</entry>
- <entry>Sonde qui se déclenche when a checkpoint is started.
- arg0 holds the bitwise flags used to distinguish different checkpoint
- types, such as shutdown, immediate or force.</entry>
+ <entry>Sonde qui se déclenche quand un point de retournement commence son
+ exécution.
+ arg0 détient les drapeaux bit à bit utilisés pour distingurer les
+ différents types de points de retournement, comme un point suite à un
+ arrêt, un point immédiat ou un point forcé.</entry>
</row>
<row>
<entry>checkpoint-done</entry>
<entry>(int, int, int, int, int)</entry>
- <entry>Sonde qui se déclenche when a checkpoint is complete.
- (The probes listed next fire in sequence during checkpoint processing.)
- arg0 is the number of buffers written. arg1 is the total number of
- buffers. arg2, arg3 and arg4 contain the number of xlog file(s) added,
- removed and recycled respectively.</entry>
+ <entry>Sonde qui se déclenche quand un point de retournement a terminé son
+ exécution (les sondes listées après se déclenchent en séquence lors du
+ traitement d'un point de retournement).
+ arg0 est le nombre de tampons mémoires écrits. arg1 est le nombre total
+ de tampons mémoires. arg2, arg3 et arg4 contiennent respectivement le
+ nombre de journaux de transactions ajoutés, supprimés et recyclés.</entry>
</row>
<row>
<entry>clog-checkpoint-start</entry>
<entry>(bool)</entry>
- <entry>Sonde qui se déclenche when the CLOG portion of a checkpoint is started.
- arg0 is true for normal checkpoint, false for shutdown
- checkpoint.</entry>
+ <entry>Sonde qui se déclenche quand la portion CLOG d'un point de
+ retournement commence.
+ arg0 est true pour un point de retournement normal, false pour un point
+ de retournement suite à un arrêt.</entry>
</row>
<row>
<entry>clog-checkpoint-done</entry>
<entry>(bool)</entry>
- <entry>Sonde qui se déclenche when the CLOG portion of a checkpoint is
- complete. arg0 has the same meaning as for clog-checkpoint-start.</entry>
+ <entry>Sonde qui se déclenche quand la portion CLOG d'un point de
+ retournement commence.
+ arg0 a la même signification que pour clog-checkpoint-start.</entry>
</row>
<row>
<entry>subtrans-checkpoint-start</entry>
<entry>(bool)</entry>
- <entry>Sonde qui se déclenche when the SUBTRANS portion of a checkpoint is
- started.
- arg0 is true for normal checkpoint, false for shutdown
- checkpoint.</entry>
+ <entry>Sonde qui se déclenche quand la portion SUBTRANS d'un point de
+ retournement commence.
+ arg0 est true pour un point de retournement normal, false pour un point
+ de retournement suite à un arrêt.</entry>
</row>
<row>
<entry>subtrans-checkpoint-done</entry>
<entry>(bool)</entry>
- <entry>Sonde qui se déclenche when the SUBTRANS portion of a checkpoint is
- complete. arg0 has the same meaning as for
- subtrans-checkpoint-start.</entry>
+ <entry>Sonde qui se déclenche quand la portion SUBTRANS d'un point de
+ retournement se termine.
+ arg0 a la même signification que pour subtrans-checkpoint-start.</entry>
</row>
<row>
<entry>multixact-checkpoint-start</entry>
<entry>(bool)</entry>
- <entry>Sonde qui se déclenche when the MultiXact portion of a checkpoint is
- started.
- arg0 is true for normal checkpoint, false for shutdown
- checkpoint.</entry>
+ <entry>Sonde qui se déclenche quand la portion MultiXact d'un point de
+ retournement commence.
+ arg0 est true pour un point de retournement normal, false pour un point
+ de retournement suite à un arrêt.</entry>
</row>
<row>
<entry>multixact-checkpoint-done</entry>
<entry>(bool)</entry>
- <entry>Sonde qui se déclenche when the MultiXact portion of a checkpoint is
- complete. arg0 has the same meaning as for
- multixact-checkpoint-start.</entry>
+ <entry>Sonde qui se déclenche quand la portion MultiXact d'un point de
+ retournement se termine.
+ arg0 a la même signification que pour multixact-checkpoint-start.</entry>
</row>
<row>
<entry>buffer-checkpoint-start</entry>
<entry>(int)</entry>
- <entry>Sonde qui se déclenche when the buffer-writing portion of a checkpoint
- is started.
- arg0 holds the bitwise flags used to distinguish different checkpoint
- types, such as shutdown, immediate or force.</entry>
+ <entry>Sonde qui se déclenche quand la portion d'écriture de tampons d'un
+ point de retournement commence.
+ arg0 contient les drapeaux bit à bit pour distinguer différents types de
+ point de retournement comme le point après arrêt, un point immédiat, un
+ point forcé.</entry>
</row>
<row>
<entry>buffer-sync-start</entry>
<entry>(int, int)</entry>
- <entry>Sonde qui se déclenche when we begin to write dirty buffers during
- checkpoint (after identifying which buffers must be written).
- arg0 is the total number of buffers.
- arg1 is the number that are currently dirty and need to be written.</entry>
+ <entry>Sonde qui se déclenche quand nous commençons d'écrire les tampons
+ modifiés pendant un point de retournement (après identification des
+ tampons qui doivent être écrits).
+ arg0 est le nombre total de tampons.
+ arg1 est le nombre de tampons qui sont modifiés et n'ont pas besoin
+ d'être écrits.</entry>
</row>
<row>
<entry>buffer-sync-written</entry>
<entry>(int)</entry>
- <entry>Sonde qui se déclenche after each buffer is written during checkpoint.
- arg0 is the ID number of the buffer.</entry>
+ <entry>Sonde qui se déclenche après chaque écriture d'un tampon lors d'un
+ point de retournement.
+ arg0 est le numéro d'identifiant du tampon.</entry>
</row>
<row>
<entry>buffer-sync-done</entry>
<entry>(int, int, int)</entry>
- <entry>Sonde qui se déclenche when all dirty buffers have been written.
- arg0 is the total number of buffers.
- arg1 is the number of buffers actually written by the checkpoint process.
- arg2 is the number that were expected to be written (arg1 of
- buffer-sync-start); any difference reflects other processes flushing
- buffers during the checkpoint.</entry>
+ <entry>Sonde qui se déclenche quand tous les tampons modifiés ont été
+ écrits.
+ arg0 est le nombre total de tampons.
+ arg1 est le nombre de tampons réellement écrits par le processus de point
+ de retournement.
+ arg2 est le nombre attendu de tampons à écrire (arg1 de
+ buffer-sync-start) ; toute différence reflète d'autres processus
+ écrivant des tampons lors du point de retournement.</entry>
</row>
<row>
<entry>buffer-checkpoint-sync-start</entry>
<entry>()</entry>
- <entry>Sonde qui se déclenche after dirty buffers have been written to the
- kernel, and before starting to issue fsync requests.</entry>
+ <entry>Sonde qui se déclenche une fois les tampons modifiés écrits par le
+ noyau et avant de commencer à lancer des requêtes fsync.</entry>
</row>
<row>
<entry>buffer-checkpoint-done</entry>
<entry>()</entry>
- <entry>Sonde qui se déclenche when syncing of buffers to disk is
- complete.</entry>
+ <entry>Sonde qui se déclenche après la fin de la synchronisation des
+ tampons sur le disque.</entry>
</row>
<row>
<entry>twophase-checkpoint-start</entry>
<entry>()</entry>
- <entry>Sonde qui se déclenche when the two-phase portion of a checkpoint is
- started.</entry>
+ <entry>Sonde qui se déclenche quand la portion deux-phases d'un point de
+ retournement est commencée.</entry>
</row>
<row>
<entry>twophase-checkpoint-done</entry>
<entry>()</entry>
- <entry>Sonde qui se déclenche when the two-phase portion of a checkpoint is
- complete.</entry>
+ <entry>Sonde qui se déclenche quand la portion deux-phases d'un point de
+ retournement est terminée.</entry>
</row>
<row>
<entry>buffer-read-start</entry>
<entry>(ForkNumber, BlockNumber, Oid, Oid, Oid, bool, bool)</entry>
- <entry>Sonde qui se déclenche when a buffer read is started.
- arg0 and arg1 contain the fork and block numbers of the page (but
- arg1 will be -1 if this is a relation extension request).
- arg2, arg3, and arg4 contain the tablespace, database, and relation OIDs
- identifying the relation.
- arg5 is true for a local buffer, false for a shared buffer.
- arg6 is true for a relation extension request, false for normal
- read.</entry>
+ <entry>Sonde qui se déclenche quand la lecture d'un tampon commence.
+ arg0 et arg1 contiennent les numéros de fork et de bloc de la page (arg1
+ vaudra -1 s'il s'agit de demande d'extension de la relation).
+ arg2, arg3 et arg4 contiennent respectivement l'OID du tablespace, de la
+ base de données et de la relation identifiant ainsi précisément la
+ relation.
+ arg5 est true pour un tampon local, false pour un tampon partagé.
+ arg6 est true pour une demande d'extension de la relation, false pour
+ une lecture ordinaire.</entry>
</row>
<row>
<entry>buffer-read-done</entry>
<entry>(ForkNumber, BlockNumber, Oid, Oid, Oid, bool, bool, bool)</entry>
- <entry>Sonde qui se déclenche when a buffer read is complete.
- arg0 and arg1 contain the fork and block numbers of the page (if this
- is a relation extension request, arg1 now contains the block number
- of the newly added block).
- arg2, arg3, and arg4 contain the tablespace, database, and relation OIDs
- identifying the relation.
- arg5 is true for a local buffer, false for a shared buffer.
- arg6 is true for a relation extension request, false for normal
- read.
- arg7 is true if the buffer was found in the pool, false if not.</entry>
+ <entry>Sonde qui se déclenche quand la lecture d'un tampon se termine.
+ arg0 et arg1 contiennent les numéros de fork et de bloc de la page (arg1
+ contient le numéro de bloc du nouveau bloc ajouté s'il s'agit de demande
+ d'extension de la relation).
+ arg2, arg3 et arg4 contiennent respectivement l'OID du tablespace, de la
+ base de données et de la relation identifiant ainsi précisément la
+ relation.
+ arg5 est true pour un tampon local, false pour un tampon partagé.
+ arg6 est true pour une demande d'extension de la relation, false pour
+ une lecture ordinaire.
+ arg7 est true si la tampon était disponible en mémoire, false sinon.</entry>
</row>
<row>
<entry>buffer-flush-start</entry>
<entry>(ForkNumber, BlockNumber, Oid, Oid, Oid)</entry>
- <entry>Sonde qui se déclenche before issuing any write request for a shared
- buffer.
- arg0 and arg1 contain the fork and block numbers of the page.
- arg2, arg3, and arg4 contain the tablespace, database, and relation OIDs
- identifying the relation.</entry>
+ <entry>Sonde qui se déclenche avant de lancer une demande d'écriture pour
+ un bloc partagé.
+ arg2, arg3 et arg4 contiennent respectivement l'OID du tablespace, de la
+ base de données et de la relation identifiant ainsi précisément la
+ relation.</entry>
</row>
<row>
<entry>buffer-flush-done</entry>
<entry>(ForkNumber, BlockNumber, Oid, Oid, Oid)</entry>
- <entry>Sonde qui se déclenche when a write request is complete. (Note
- that this just reflects the time to pass the data to the kernel;
- it's typically not actually been written to disk yet.)
- The arguments are the same as for buffer-flush-start.</entry>
+ <entry>Sonde qui se déclenche quand une demande d'écriture se termine.
+ (Notez que ceci ne reflète que le temps passé pour fournir la donnée au
+ noyau ; ce n'est habituellement pas encore écrit sur le disque.)
+ Les arguments sont identiques à ceux de buffer-flush-start.</entry>
</row>
<row>
<entry>buffer-write-dirty-start</entry>
<entry>(ForkNumber, BlockNumber, Oid, Oid, Oid)</entry>
- <entry>Sonde qui se déclenche when a server process begins to write a dirty
- buffer. (If this happens often, it implies that
- <xref linkend="guc-shared-buffers"/> is too
- small or the bgwriter control parameters need adjustment.)
- arg0 and arg1 contain the fork and block numbers of the page.
- arg2, arg3, and arg4 contain the tablespace, database, and relation OIDs
- identifying the relation.</entry>
+ <entry>Sonde qui se déclenche quand un processus serveur commence à écrire
+ un tampon modifié sur disque. Si cela arrive souvent, cela implique que
+ <xref linkend="guc-shared-buffers"/> est trop petit ou que les paramètres
+ de contrôle de bgwriter ont besoin d'un ajustement.)
+ arg0 et arg1 contiennent les numéros de fork et de bloc de la page.
+ arg2, arg3 et arg4 contiennent respectivement l'OID du tablespace, de la
+ base de données et de la relation identifiant ainsi précisément la
+ relation.</entry>
</row>
<row>
<entry>buffer-write-dirty-done</entry>
<entry>(ForkNumber, BlockNumber, Oid, Oid, Oid)</entry>
- <entry>Sonde qui se déclenche when a dirty-buffer write is complete.
- The arguments are the same as for buffer-write-dirty-start.</entry>
+ <entry>Sonde qui se déclenche quand l'écriture d'un tampon modifié est
+ terminé.
+ Les arguments sont identiques à ceux de buffer-write-dirty-start.</entry>
</row>
<row>
<entry>wal-buffer-write-dirty-start</entry>
<entry>()</entry>
- <entry>Sonde qui se déclenche when when a server process begins to write a
- dirty WAL buffer because no more WAL buffer space is available.
- (If this happens often, it implies that
- <xref linkend="guc-wal-buffers"/> is too small.)</entry>
+ <entry>Sonde qui se déclenche quand un processus serveur commence à écrire
+ un tampon modifié d'un journal de transactions parce qu'il n'y a plus
+ d'espace disponible dans le cache des journaux de transactions. (Si cela
+ arrive souvent, cela implique que <xref linkend="guc-wal-buffers"/> est
+ trop petit.)</entry>
</row>
<row>
<entry>wal-buffer-write-dirty-done</entry>
<entry>()</entry>
- <entry>Sonde qui se déclenche when a dirty WAL buffer write is complete.</entry>
+ <entry>Sonde qui se déclenche quand l'écriture d'un tampon modifié d'un
+ journal de transactions est terminé.</entry>
</row>
<row>
<entry>xlog-insert</entry>
<entry>(unsigned char, unsigned char)</entry>
- <entry>Sonde qui se déclenche when a WAL record is inserted.
- arg0 is the resource manager (rmid) for the record.
- arg1 contains the info flags.</entry>
+ <entry>Sonde qui se déclenche quand un enregistrement est inséré dans un
+ journal de transactions.
+ arg0 est le gestionnaire de ressource (rmid) pour l'enregistrement.
+ arg1 contient des informations supplémentaires.</entry>
</row>
<row>
<entry>xlog-switch</entry>
<entry>()</entry>
- <entry>Sonde qui se déclenche when a WAL segment switch is requested.</entry>
+ <entry>Sonde qui se déclenche quand une bascule du journal de transactions
+ est demandée.</entry>
</row>
<row>
<entry>smgr-md-read-start</entry>
<entry>(ForkNumber, BlockNumber, Oid, Oid, Oid)</entry>
- <entry>Sonde qui se déclenche when beginning to read a block from a relation.
- arg0 and arg1 contain the fork and block numbers of the page.
- arg2, arg3, and arg4 contain the tablespace, database, and relation OIDs
- identifying the relation.</entry>
+ <entry>Sonde qui se déclenche au début de la lecture d'un bloc d'une
+ relation.
+ arg0 et arg1 contiennent les numéros de fork et de bloc de la page.
+ arg2, arg3 et arg4 contiennent respectivement l'OID du tablespace, de la
+ base de données et de la relation identifiant ainsi précisément la
+ relation.</entry>
</row>
<row>
<entry>smgr-md-read-done</entry>
<entry>(ForkNumber, BlockNumber, Oid, Oid, Oid, int, int)</entry>
- <entry>Sonde qui se déclenche when a block read is complete.
- arg0 and arg1 contain the fork and block numbers of the page.
- arg2, arg3, and arg4 contain the tablespace, database, and relation OIDs
- identifying the relation.
- arg5 is the number of bytes actually read, while arg6 is the number
- requested (if these are different it indicates trouble).</entry>
+ <entry>Sonde qui se déclenche à la fin de la lecture d'un bloc.
+ arg0 et arg1 contiennent les numéros de fork et de bloc de la page.
+ arg2, arg3 et arg4 contiennent respectivement l'OID du tablespace, de la
+ base de données et de la relation identifiant ainsi précisément la
+ relation.
+ arg5 est le nombre d'octets réellement lus, alors qu'arg6 est le nombre
+ d'octets demandés (s'il y a une différence, il y a un problème).</entry>
</row>
<row>
<entry>smgr-md-write-start</entry>
<entry>(ForkNumber, BlockNumber, Oid, Oid, Oid)</entry>
- <entry>Sonde qui se déclenche when beginning to write a block to a relation.
- arg0 and arg1 contain the fork and block numbers of the page.
- arg2, arg3, and arg4 contain the tablespace, database, and relation OIDs
- identifying the relation.</entry>
+ <entry>Sonde qui se déclenche au début de l'écriture d'un bloc dans une
+ relation.
+ arg0 et arg1 contiennent les numéros de fork et de bloc de la page.
+ arg2, arg3 et arg4 contiennent respectivement l'OID du tablespace, de la
+ base de données et de la relation identifiant ainsi précisément la
+ relation.</entry>
</row>
<row>
<entry>smgr-md-write-done</entry>
<entry>(ForkNumber, BlockNumber, Oid, Oid, Oid, int, int)</entry>
- <entry>Sonde qui se déclenche when a block write is complete.
- arg0 and arg1 contain the fork and block numbers of the page.
- arg2, arg3, and arg4 contain the tablespace, database, and relation OIDs
- identifying the relation.
- arg5 is the number of bytes actually written, while arg6 is the number
- requested (if these are different it indicates trouble).</entry>
+ <entry>Sonde qui se déclenche à la fin de l'écriture d'un bloc.
+ arg0 et arg1 contiennent les numéros de fork et de bloc de la page.
+ arg2, arg3 et arg4 contiennent respectivement l'OID du tablespace, de la
+ base de données et de la relation identifiant ainsi précisément la
+ relation.
+ arg5 est le nombre d'octets réellement écrits, alors qu'arg6 est le nombre
+ d'octets demandés (si ces nombres sont différents, cela indique un
+ problème).</entry>
</row>
<row>
<entry>sort-start</entry>
<entry>(int, bool, int, int, bool)</entry>
- <entry>Sonde qui se déclenche when a sort operation is started.
- arg0 indicates heap, index or datum sort.
- arg1 is true for unique-value enforcement.
- arg2 is the number of key columns.
- arg3 is the number of kilobytes of work memory allowed.
- arg4 is true if random access to the sort result is required.</entry>
+ <entry>Sonde qui se déclenche quand une opération de tri est démarré.
+ arg0 indique un tri de la table, de l'index ou d'un datum.
+ arg1 est true si on force les valeurs uniques.
+ arg2 est le nombre de colonnes clés.
+ arg3 est le nombre de Ko de mémoire autorisé pour ce travail.
+ arg4 est true si un accès aléatoire au résultat du tri est requis.</entry>
</row>
<row>
<entry>sort-done</entry>
<entry>(bool, long)</entry>
- <entry>Sonde qui se déclenche when a sort is complete.
- arg0 is true for external sort, false for internal sort.
- arg1 is the number of disk blocks used for an external sort,
- or kilobytes of memory used for an internal sort.</entry>
+ <entry>Sonde qui se déclenche quand un tri est terminé.
+ arg0 est true pour un tri externe, false pour un tri interne.
+ arg1 est le nombre de blocs disque utilisés pour un tri externe, ou le
+ nombre de Ko de mémoire utilisés pour un tri interne.</entry>
</row>
<row>
<entry>lwlock-acquire</entry>
<entry>(LWLockId, LWLockMode)</entry>
- <entry>Sonde qui se déclenche when an LWLock has been acquired.
- arg0 is the LWLock's ID.
- arg1 is the requested lock mode, either exclusive or shared.</entry>
+ <entry>Sonde qui se déclenche quand un LWLock a été acquis.
+ arg0 est l'identifiant du LWLock.
+ arg1 est le mode de verrou demandé, soit exclusif soit partagé.</entry>
</row>
<row>
<entry>lwlock-release</entry>
<entry>(LWLockId)</entry>
- <entry>Sonde qui se déclenche when an LWLock has been released (but note
- that any released waiters have not yet been awakened).
- arg0 is the LWLock's ID.</entry>
+ <entry>Sonde qui se déclenche quand un LWLock a été relâché (mais notez
+ que tout processus en attente n'a pas encore été réveillé).
+ arg0 est l'identifiant du LWLock.</entry>
</row>
<row>
<entry>lwlock-wait-start</entry>
<entry>(LWLockId, LWLockMode)</entry>
- <entry>Sonde qui se déclenche when an LWLock was not immediately available and
- a server process has begun to wait for the lock to become available.
- arg0 is the LWLock's ID.
- arg1 is the requested lock mode, either exclusive or shared.</entry>
+ <entry>Sonde qui se déclenche quand un LWLock n'était pas immédiatement
+ disponible et qu'un processus serveur a commencé à attendre la
+ disponibilité du verrou.
+ arg0 est l'identifiant du LWLock.
+ arg1 est le mode de verrou demandé, soit exclusif soit partagé.</entry>
</row>
<row>
<entry>lwlock-wait-done</entry>
<entry>(LWLockId, LWLockMode)</entry>
- <entry>Sonde qui se déclenche when a server process has been released from its
- wait for an LWLock (it does not actually have the lock yet).
- arg0 is the LWLock's ID.
- arg1 is the requested lock mode, either exclusive or shared.</entry>
+ <entry>Sonde qui se déclenche quand un processus serveur n'est plus en
+ attente d'un LWLock (il n'a pas encore le verrou).
+ arg0 est l'identifiant du LWLock.
+ arg1 est le mode de verrou demandé, soit exclusif soit partagé.</entry>
</row>
<row>
<entry>lwlock-condacquire</entry>
<entry>(LWLockId, LWLockMode)</entry>
- <entry>Sonde qui se déclenche when an LWLock was successfully acquired when the
- caller specified no waiting.
- arg0 is the LWLock's ID.
- arg1 is the requested lock mode, either exclusive or shared.</entry>
+ <entry>Sonde qui se déclenche quand un LWLock a été acquis avec succès
+ malgré le fait que l'appelant ait demandé de ne pas attendre.
+ arg0 est l'identifiant du LWLock.
+ arg1 est le mode de verrou demandé, soit exclusif soit partagé.</entry>
</row>
<row>
<entry>lwlock-condacquire-fail</entry>
<entry>(LWLockId, LWLockMode)</entry>
- <entry>Sonde qui se déclenche when an LWLock was not successfully acquired when
- the caller specified no waiting.
- arg0 is the LWLock's ID.
- arg1 is the requested lock mode, either exclusive or shared.</entry>
+ <entry>Sonde qui se déclenche quand un LWLock, demandé sans attente, n'est
+ pas accepté.
+ arg0 est l'identifiant du LWLock.
+ arg1 est le mode de verrou demandé, soit exclusif soit partagé.</entry>
</row>
<row>
<entry>lock-wait-start</entry>
<entry>(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, LOCKMODE)</entry>
- <entry>Sonde qui se déclenche when a request for a heavyweight lock (lmgr lock)
- has begun to wait because the lock is not available.
- arg0 through arg3 are the tag fields identifying the object being
- locked. arg4 indicates the type of object being locked.
- arg5 indicates the lock type being requested.</entry>
+ <entry>Sonde qui se déclenche quand une demande d'un gros verrou
+ (<foreignphrase>lmgr lock</foreignphrase>) a commencé l'attente parce que
+ le verrou n'était pas disponible.
+ arg0 à arg3 sont les chmps identifiant l'objet en cours de verrouillage.
+ arg4 indique le type d'objet à verrouiller.
+ arg5 indique le type du verrou demandé.</entry>
</row>
<row>
<entry>lock-wait-done</entry>
<entry>(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, LOCKMODE)</entry>
- <entry>Sonde qui se déclenche when a request for a heavyweight lock (lmgr lock)
- has finished waiting (i.e., has acquired the lock).
- The arguments are the same as for lock-wait-start.</entry>
+ <entry>Sonde qui se déclenche quand une demande d'un gros verrou
+ (<foreignphrase>lmgr lock</foreignphrase>) a fini d'attendre (c'est-à-dire
+ que le verrou a été accepté).
+ Les arguments sont identiques à ceux de lock-wait-start.</entry>
</row>
<row>
<entry>deadlock-found</entry>
<entry>()</entry>
- <entry>Sonde qui se déclenche when a deadlock is found by the deadlock
- detector.</entry>
+ <entry>Sonde qui se déclenche quand un verrou mortel est trouvé par le
+ détecteur.</entry>
</row>
</tbody>
Modified: traduc/trunk/postgresql/plpgsql.xml
===================================================================
--- traduc/trunk/postgresql/plpgsql.xml 2009-04-30 21:53:48 UTC (rev 1315)
+++ traduc/trunk/postgresql/plpgsql.xml 2009-05-02 15:22:39 UTC (rev 1316)
@@ -1213,22 +1213,24 @@
</para>
<para>
- As always, care must be taken to ensure that null values in a query do
- not deliver unintended results. For example the <literal>WHERE</literal> clause
+ Comme toujours, il faut s'assurer que les valeurs NULL d'une requête ne
+ ramènent pas des valeurs inattendues. Par exemple, la clause
+ <literal>WHERE</literal>
<programlisting>
- 'WHERE key = ' || quote_nullable(keyvalue)
+ 'WHERE key = ' || quote_nullable(valeur_clé)
</programlisting>
- will never succeed if <literal>keyvalue</literal> is null, because the
- result of using the equality operator <literal>=</literal> with a null operand
- is always null. If you wish null to work like an ordinary key value,
- you would need to rewrite the above as
+ ne sera jamais vrai si <literal>valeur_clé</literal> est NULL car le résultat
+ de l'opérateur d'égalité, <literal>=</literal>, avec au moins un des opérandes
+ NULL est toujours NULL. Si vous souhaitez que NULL fonctionne comme toute
+ autre valeur de clé ordinaire, vous devez ré-écrire la clause ci-dessus de
+ cette façon :
<programlisting>
'WHERE key IS NOT DISTINCT FROM ' || quote_nullable(keyvalue)
</programlisting>
- (At present, <literal>IS NOT DISTINCT FROM</literal> is handled much less
- efficiently than <literal>=</literal>, so don't do this unless you must.
- See <xref linkend="functions-comparison"/> for
- more information on nulls and <literal>IS DISTINCT</literal>.)
+ (Actuellement, <literal>IS NOT DISTINCT FROM</literal> est géré moins
+ efficacement que <literal>=</literal>, donc ne l'utilisez pas sauf en cas
+ d'extrême nécessité. Voir <xref linkend="functions-comparison"/> pour plus
+ d'informations sur les NULL et <literal>IS DISTINCT</literal>.)
</para>
<para>
@@ -1772,17 +1774,19 @@
</synopsis>
<para>
- The simple form of <command>CASE</command> provides conditional execution
- based on equality of operands. The <replaceable>search-expression</replaceable>
- is evaluated (once) and successively compared to each
- <replaceable>expression</replaceable> in the <literal>WHEN</literal> clauses.
- If a match is found, then the corresponding
- <replaceable>statements</replaceable> are executed, and then control
- passes to the next statement after <literal>END CASE</literal>. (Subsequent
- <literal>WHEN</literal> expressions are not evaluated.) If no match is
- found, the <literal>ELSE</literal> <replaceable>statements</replaceable> are
- executed; but if <literal>ELSE</literal> is not present, then a
- <literal>CASE_NOT_FOUND</literal> exception is raised.
+ La forme simple de <command>CASE</command> fournit une exécution
+ conditionnelle basée sur l'égalité des opérandes.
+ L'<replaceable>expression-recherche</replaceable> est évaluée (une fois)
+ puis comparée successivement à chaque <replaceable>expression</replaceable>
+ dans les clauses <literal>WHEN</literal>. Si une correspondance est
+ trouvée, alors les <replaceable>instructions</replaceable> correspondantes
+ sont exécutées, puis le contrôle est passé à la prochaine instruction
+ après <literal>END CASE</literal>. (Les autres expressions
+ <literal>WHEN</literal> ne sont pas testées.) Si aucune correspondance
+ n'est trouvée, les <replaceable>instructions</replaceable> du bloc
+ <literal>ELSE</literal> sont exécutées ; s'il n'y a pas de bloc
+ <literal>ELSE</literal>, une exception <literal>CASE_NOT_FOUND</literal>
+ est levée.
</para>
<para>
@@ -1815,18 +1819,18 @@
</synopsis>
<para>
- The searched form of <command>CASE</command> provides conditional execution
- based on truth of boolean expressions. Each <literal>WHEN</literal> clause's
- <replaceable>boolean-expression</replaceable> is evaluated in turn,
- until one is found that yields <literal>true</literal>. Then the
- corresponding <replaceable>statements</replaceable> are executed, and
- then control passes to the next statement after <literal>END
- CASE</literal>.
- (Subsequent <literal>WHEN</literal> expressions are not evaluated.)
- If no true result is found, the <literal>ELSE</literal>
- <replaceable>statements</replaceable> are executed;
- but if <literal>ELSE</literal> is not present, then a
- <literal>CASE_NOT_FOUND</literal> exception is raised.
+ La forme recherché de <command>CASE</command> fournit une exécution
+ conditionnelle basée sur la vérification d'expressions booléennes.
+ Chaque <replaceable>expression-booléenne</replaceable> de la clause
+ <literal>WHEN</literal> est évaluée à son tour jusqu'à en trouver
+ une qui est validée (<literal>true</literal>). Les
+ <replaceable>instructions</replaceable> correspondantes sont exécutées,
+ puis le contrôle est passé à la prochaine instruction après <literal>END
+ CASE</literal>. (Les expressions <literal>WHEN</literal> suivantes ne
+ sont pas testées.) Si aucun résultat vrai n'est trouvé, les
+ <replaceable>instructions</replaceable> du bloc <literal>ELSE</literal>
+ sont exécutées. Si aucun bloc <literal>ELSE</literal> n'est présent, une
+ exception <literal>CASE_NOT_FOUND</literal> est levée.
</para>
<para>
@@ -2871,24 +2875,24 @@
</para>
<para>
- You can attach additional information to the error report by writing
- <literal>USING</literal> followed by <replaceable
+ Vous pouvez attacher des informations supplémentaires au rapport d'erreur
+ en écrivant <literal>USING</literal> suivi par des éléments <replaceable
class="parameter">option</replaceable> = <replaceable
- class="parameter">expression</replaceable> items. The allowed
- <replaceable class="parameter">option</replaceable> keywords are
+ class="parameter">expression</replaceable>. Les mots clés autorisées pour
+ <replaceable class="parameter">option</replaceable> sont
<literal>MESSAGE</literal>, <literal>DETAIL</literal>,
- <literal>HINT</literal>, and
- <literal>ERRCODE</literal>, while each <replaceable
- class="parameter">expression</replaceable> can be any string-valued
- expression.
- <literal>MESSAGE</literal> sets the error message text (this option can't
- be used in the form of <command>RAISE</command> that includes a format
- string before <literal>USING</literal>).
- <literal>DETAIL</literal> supplies an error detail message, while
- <literal>HINT</literal> supplies a hint message.
- <literal>ERRCODE</literal> specifies the error code (SQLSTATE) to report,
- either by condition name as shown in <xref linkend="errcodes-appendix"/>,
- or directly as a five-character SQLSTATE code.
+ <literal>HINT</literal> et
+ <literal>ERRCODE</literal>, alors que chaque <replaceable
+ class="parameter">expression</replaceable> peut être une expression de type
+ chaîne. <literal>MESSAGE</literal> configure le texte de l'erreur (cette
+ option ne peut pas être utilisée sous la forme de <command>RAISE</command>
+ qui inclut une chaîne de format avant <literal>USING</literal>).
+ <literal>DETAIL</literal> fournit un message détaillé de l'erreur,
+ <literal>HINT</literal> propose une astuce.
+ <literal>ERRCODE</literal> indique le code d'erreur (SQLSTATE) à rapporter,
+ soit par le nom de la condition comme indiquée dans <xref
+ linkend="errcodes-appendix"/>, soit directement sous la forme d'un code
+ SQLSTATE à cinq caractères.
</para>
<para>
Modified: traduc/trunk/postgresql/ref/create_server.xml
===================================================================
--- traduc/trunk/postgresql/ref/create_server.xml 2009-04-30 21:53:48 UTC (rev 1315)
+++ traduc/trunk/postgresql/ref/create_server.xml 2009-05-02 15:22:39 UTC (rev 1316)
@@ -1,18 +1,18 @@
<?xml version="1.0" encoding="ISO-8859-15"?>
-<!-- Dernière modification
+<!-- Dernière modification
le $Date: 2009-04-13 17:20:17 +0200 (lun 13 avr 2009) $
par $Author: gleu $
- révision $Revision: 1293 $ -->
+ révision $Revision: 1293 $ -->
<refentry id="sql-createserver">
<refmeta>
<refentrytitle id="sql-createserver-title">CREATE SERVER</refentrytitle>
- <refmiscinfo>SQL - Language Statements</refmiscinfo>
+ <refmiscinfo>SQL - Instructions du langage</refmiscinfo>
</refmeta>
<refnamediv>
<refname>CREATE SERVER</refname>
- <refpurpose>define a new foreign server</refpurpose>
+ <refpurpose>Définir un nouveau serveur distant</refpurpose>
</refnamediv>
<indexterm zone="sql-createserver">
@@ -21,9 +21,9 @@
<refsynopsisdiv>
<synopsis>
-CREATE SERVER <replaceable class="parameter">servername</replaceable> [ TYPE 'servertype' ] [ VERSION 'serverversion' ]
- FOREIGN DATA WRAPPER <replaceable class="parameter">fdwname</replaceable>
- [ OPTIONS ( <replaceable class="PARAMETER">option</replaceable> '<replaceable class="PARAMETER">value</replaceable>' [, ... ] ) ]
+CREATE SERVER <replaceable class="parameter">nomserveur</replaceable> [ TYPE 'typeserveur' ] [ VERSION 'versionserveur' ]
+ FOREIGN DATA WRAPPER <replaceable class="parameter">nomfdw</replaceable>
+ [ OPTIONS ( <replaceable class="PARAMETER">option</replaceable> '<replaceable class="PARAMETER">valeur</replaceable>' [, ... ] ) ]
</synopsis>
</refsynopsisdiv>
@@ -31,68 +31,67 @@
<title>Description</title>
<para>
- <command>CREATE SERVER</command> defines a new foreign server. The
- user who defines the server becomes its owner.
+ <command>CREATE SERVER</command> définit un nouveau serveur de données
+ distantes. L'utilisateur qui définit le serveur devient son propriétaire.
</para>
<para>
- The server name must be unique within the database.
+ Le nom du serveur doit être unique dans la base de données.
</para>
<para>
- Creating a server requires <literal>USAGE</literal> privilege on the
- foreign-data wrapper being used.
+ La création d'un serveur nécessite d'avoir le droit <literal>USAGE</literal>
+ sur le wrapper de données distant qui est utilisé.
</para>
</refsect1>
<refsect1>
- <title>Parameters</title>
+ <title>Paramètres</title>
<variablelist>
<varlistentry>
- <term><replaceable class="parameter">servername</replaceable></term>
+ <term><replaceable class="parameter">nomserveur</replaceable></term>
<listitem>
<para>
- The name of the foreign server to be created.
+ Nom du serveur de données distant qui sera créé.
</para>
</listitem>
</varlistentry>
<varlistentry>
- <term><replaceable class="parameter">servertype</replaceable></term>
+ <term><replaceable class="parameter">typeserveur</replaceable></term>
<listitem>
<para>
- Optional server type.
+ Type de serveur (optionnel).
</para>
</listitem>
</varlistentry>
<varlistentry>
- <term><replaceable class="parameter">serverversion</replaceable></term>
+ <term><replaceable class="parameter">versionserveur</replaceable></term>
<listitem>
<para>
- Optional server version.
+ Version du serveur (optionnel).
</para>
</listitem>
</varlistentry>
<varlistentry>
- <term><replaceable class="parameter">fdwname</replaceable></term>
+ <term><replaceable class="parameter">nomfdw</replaceable></term>
<listitem>
<para>
- The name of the foreign-data wrapper that manages the server.
+ Nom du wrapper de données distantes qui gère le serveur.
</para>
</listitem>
</varlistentry>
<varlistentry>
- <term><literal>OPTIONS ( <replaceable class="PARAMETER">option</replaceable> '<replaceable class="PARAMETER">value</replaceable>' [, ... ] )</literal></term>
+ <term><literal>OPTIONS ( <replaceable class="PARAMETER">option</replaceable> '<replaceable class="PARAMETER">valeur</replaceable>' [, ... ] )</literal></term>
<listitem>
<para>
- This clause specifies the options for the server. The options
- typically define the connection details of the server, but the
- actual names and values are dependent on the server's
- foreign-data wrapper.
+ Cette clause spécifie les options pour le serveur. Typiquement, les
+ options définissent les détails de connexion au serveur, mais les noms et
+ valeurs réelles dépendent du wrapper de données distantes du serveur.
</para>
</listitem>
</varlistentry>
@@ -100,35 +99,35 @@
</refsect1>
<refsect1>
- <title>Examples</title>
+ <title>Exemples</title>
<para>
- Create a server <literal>foo</literal> that uses the built-in foreign-data
- wrapper <literal>default</literal>:
+ Créer un serveur <literal>truc</literal> qui utilise le wrapper de données
+ distantes inclus <literal>default</literal> :
<programlisting>
-CREATE SERVER foo FOREIGN DATA WRAPPER "default";
+CREATE SERVER truc FOREIGN DATA WRAPPER "default";
</programlisting>
</para>
<para>
- Create a server <literal>myserver</literal> that uses the
- foreign-data wrapper <literal>pgsql</literal>:
+ Créer un serveur <literal>monserveur</literal> qui utilise le wrapper de
+ données distantes <literal>pgsql</literal> :
<programlisting>
-CREATE SERVER myserver FOREIGN DATA WRAPPER pgsql OPTIONS (host 'foo', dbname 'foodb', port '5432');
+CREATE SERVER monserveur FOREIGN DATA WRAPPER pgsql OPTIONS (host 'truc', dbname 'trucdb', port '5432');
</programlisting>
</para>
</refsect1>
<refsect1>
- <title>Compatibility</title>
+ <title>Compatibilité</title>
<para>
- <command>CREATE SERVER</command> conforms to ISO/IEC 9075-9 (SQL/MED).
+ <command>CREATE SERVER</command> est conforme à ISO/IEC 9075-9 (SQL/MED).
</para>
</refsect1>
<refsect1>
- <title>See Also</title>
+ <title>Voir aussi</title>
<simplelist type="inline">
<member><xref linkend="sql-alterserver" endterm="sql-alterserver-title"/></member>
Plus d'informations sur la liste de diffusion Trad