Navigation

← Previous Changeset
Next Changeset →

Changeset 872

Timestamp:

01/07/08 13:31:50 (1 year ago)

Author:

sas

Message:

Fin relecture geqo et application branches 81 et 82.
close #181

Files:

traduc/branches/bv81x/manuel/geqo.xml (modified) (17 diffs)
traduc/branches/bv82x/manuel/func.xml (modified) (576 diffs)
traduc/branches/bv82x/manuel/geqo.xml (modified) (17 diffs)
traduc/trunk/manuel/geqo.xml (modified) (7 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

traduc/branches/bv81x/manuel/geqo.xml

r232	r872
4	4	Genetic Optimizer
5	5	-->
	6	<!-- SAS : 20080107, PG8111 -->
6	7
7	8	<chapter id="geqo">
…	…
38	39	<para>
39	40	Écrit par Martin Utesch (<email>utesch@aut.tu-freiberg.de</email>)
40		de l'~~institut de contrôle automatique de l'université des m~~ines et de
41		technologie de Freiberg, Allemagne.
	41	de l'Institut de Contrôle Automatique à l'Université des Mines et de
	42	Technologie de Freiberg, Allemagne.
42	43	</para>
43	44	</note>
…	…
45	46
46	47	<sect1 id="geqo-intro">
47		<title>G~~estion des requêtes comme un problème complexe d'optimisation~~</title>
48
49		<para>
50		~~Parmi~~ tous les opérateurs relationnels, le plus difficile à exécuter et à
	48	<title>Gérer les requêtes, un problème d'optimisation complexe</title>
	49
	50	<para>
	51	De tous les opérateurs relationnels, le plus difficile à exécuter et à
51	52	optimiser est la jointure (<firstterm>join</firstterm>). Le nombre de plans
52	53	alternatifs pour répondre à une requête croît de façon exponentielle avec le
53		nombre de jointures ~~inclus~~. Un effort supplémentaire d'optimisation est dû
	54	nombre de jointures. Un effort supplémentaire d'optimisation est dû
54	55	au support d'une variété de <firstterm>méthodes de jointure</firstterm>
55		(par exemple les boucles imbriquées, les jointures de découpage, les
56		jointures d'assemblage dans <productname>PostgreSQL</productname>) pour
	56	(boucles imbriquées, jointures de hachage, jointures de fusion...) pour
57	57	exécuter des jointures individuelles et une diversité
58		d'<firstterm>index</firstterm> (par exemple R-tree, B-tree, découpage
59		dans <productname>PostgreSQL</productname>) comme chemins d'accès des
60		relations.
61		</para>
62
63		<para>
64		L'implémentation de l'optimiseur de <productname>PostgreSQL</productname>
65		réalise une <firstterm>recherche pratiquement exhaustive</firstterm> sur
66		tout l'espace des stratégies alternatives. Cet algorithme, tout d'abord
67		introduit dans la base de données <quote>System R</quote>, produit un ordre
68		de jointure presque optimal mais peut prendre beaucoup de temps et d'espace
69		mémoire lorsque le nombre de jointures dans une requête devient important.
70		Ceci rend inapproprié l'optimiseur ordinaire de requêtes de
71		<productname>PostgreSQL</productname> pour les requêtes établissant une
72		jointure entre un grand nombre de tables.
73		</para>
74
75		<para>
76		L'institut de contrôle automatique de l'université des mines et de
77		technologie, basé à Freiberg, Allemagne, a rencontré les problèmes décrits
78		car ces employés voulaient utiliser le DBMS
	58	d'<firstterm>index</firstterm> (par exemple R-tree, B-tree, découpage...)
	59	comme chemins d'accès des relations.
	60	</para>
	61
	62	<para>
	63	L'implantation de l'optimiseur de <productname>PostgreSQL</productname>
	64	réalise une <firstterm>recherche quasi-exhaustive</firstterm> sur
	65	l'ensemble des stratégies alternatives. Cet algorithme, tout d'abord
	66	introduit à l'origine dans la base de données <quote>System R</quote> d'IBM,
	67	produit un ordre de jointure quasi-optimal mais peut prendre beaucoup de temps et d'espace
	68	mémoire à mesure que le nombre de jointures grandit.
	69	L'optimiseur ordinaire de requêtes de
	70	<productname>PostgreSQL</productname> devient donc inapproprié pour les
	71	requêtes qui joignent un grand nombre de tables.
	72	</para>
	73
	74	<para>
	75	L'Institut de Contrôle Automatique de l'Université des Mines et de
	76	Technologie, basé à Freiberg, en Allemagne, a rencontré des difficultés
	77	lorsque ses employés ont voulu utiliser le SGBD
79	78	<productname>PostgreSQL</productname> comme moteur pour leur système de
80		support pour la maintenance d'une grille de courant électrique. Le ~~DBMS~~
81		avait besoin de gérer des requêtes comprenant de~~s jointures larg~~es pour la
	79	support pour la maintenance d'une grille de courant électrique. Le SGBD
	80	avait besoin de gérer des requêtes comprenant de nombreuses jointures pour la
82	81	machine d'inférence du système de connaissances.
83	82	</para>
84	83
85	84	<para>
	85	<!-- Supprimé dans la v83 et v82 -->
86	86	Les difficultés en terme de performance pour l'exploration des plans de
87	87	requêtes possibles ont créé la demande du développement d'une nouvelle
…	…
89	89	</para>
90	90
91		~~<para~~>
92		~~Dans la suite, nous décrivons l'implémentation d'un <firstterm>algorithme~~
93		~~génétique</firstterm> pour résoudre le problème des ordres de jointur~~e
94		~~d'une façon efficace pour les requêtes impliquant un grand nombre de c~~es
95		~~jointur~~es.
	91	<!-- Mais je n'ai pas les sources de PG81 sous la main -->
	92	<para>
	93	La suite du document décrit le codage d'un <firstterm>algorithme
	94	génétique</firstterm> de résolution de l'ordonnancement des jointures
	95	efficace pour les requêtes à jointures nombreuses.
96	96	</para>
97	97	</sect1>
…	…
100	100	<title>Algorithmes génétiques</title>
101	101
	102	<!-- fitness : ? Je doute qu'il s'agisse de forme physique :-/
	103	to fit : s'intégrer, entrer, s'encastrer...
	104	adaptation me semble convenir -->
102	105	<para>
103	106	L'algorithme génétique (<acronym>GA</acronym>) est une méthode
104		~~heuristique d'optimisation qui opère via des recherches non déterministes au~~
105		~~hasard. L'ensemble des solutions possibles pour le~~ problème d'optimisation
	107	d'optimisation heuristique qui opère par recherches non déterministes,
	108	aléatoires. L'ensemble des solutions possibles au problème d'optimisation
106	109	est considéré comme une <firstterm>population</firstterm>
107	110	d'<firstterm>individus</firstterm>. Le degré d'adaptation d'un individu
108		~~dans son environnement est spécifié par sa <firstterm>forme~~
109		~~physique</firstterm>~~.
	111	à son environnement est indiqué par sa <firstterm>valeur d'adaptation</firstterm>
	112	(<foreignphrase>fitness</foreignphrase>).
110	113	</para>
111	114
…	…
113	116	Les coordonnées d'un individu dans l'espace de recherche sont représentées
114	117	par des <firstterm>chromosomes</firstterm>, en fait un ensemble de chaînes
115		de caractères. Un <firstterm>gène</firstterm> est une sous-section d~~'un~~
116		chromosome qui code la valeur d'un ~~seul paramètr~~e en cours d'optimisation.
117		Les codages ~~typiques pour un gène pourraient être~~
	118	de caractères. Un <firstterm>gène</firstterm> est une sous-section de
	119	chromosome qui code la valeur d'un paramètre simple en cours d'optimisation.
	120	Les codages habituels d'un gène sont
118	121	<firstterm>binary</firstterm> ou <firstterm>integer</firstterm>.
119	122	</para>
120	123
121	124	<para>
122		~~À travers la simulation des opérations évolutives~~
	125	La simulation des opérations d'évolution
123	126	(<firstterm>recombinaison</firstterm>, <firstterm>mutation</firstterm> et
124		<firstterm>sélection</firstterm>)~~, de nouvelles générations de points de~~
125		~~recherche sont trouvées affichant une meilleure forme physique que leurs~~
126		ancêtres.
127		</para>
128
129		<para>
130		~~D'après~~ la <acronym>FAQ</acronym> de <systemitem
131		class="resource">comp.ai.genetic</systemitem>, ~~il ne peut pas être dit plus fort~~ement
132		~~qu'un <acronym>GA</acronym> n'est pas une recherche effectuée seulement au~~
133		~~hasard. Un <acronym>GA</acronym> utilise des processus stochastiques~~ mais
134		le résultat ~~n'est pas du tout dû au hasard (mieux que cela~~).
	127	<firstterm>sélection</firstterm>) permet de trouver de nouvelles
	128	générations de points de recherche qui présentent une meilleure adaptation
	129	moyenne que leurs ancêtres.
	130	</para>
	131
	132	<para>
	133	Selon la <acronym>FAQ</acronym> de <systemitem
	134	class="resource">comp.ai.genetic</systemitem>, on ne peut pas réellement
	135	affirmer qu'un <acronym>GA</acronym> n'est pas purement une recherche
	136	aléatoire. Un <acronym>GA</acronym> utilise des processus stochastiques, mais
	137	le résultat est assurément non-aléatoire (il est mieux qu'aléatoire).
135	138	</para>
136	139
…	…
162	165	\| INITIALISE P(t) \|
163	166	+=========================================+
164		\| évalue ~~FORMEPHYSIQUE de P(t)~~ \|
165		+=========================================+
166		\| tant que pas ~~ARRET CRITERE~~ faire \|
	167	\| évalue ADAPTATION de P(t) \|
	168	+=========================================+
	169	\| tant que pas CRITERE ARRET faire \|
167	170	\| +-------------------------------------+
168	171	\| \| P'(t) := RECOMBINAISON{P(t)} \|
…	…
172	175	\| \| P(t+1) := SELECTION{P''(t) + P(t)} \|
173	176	\| +-------------------------------------+
174		\| \| évalue ~~FORMEPHYSIQUE de P''(t)~~ \|
	177	\| \| évalue ADAPTATION de P''(t) \|
175	178	\| +-------------------------------------+
176	179	\| \| t := t + 1 \|
…	…
181	184
182	185	<sect1 id="geqo-pg-intro">
183		<title>Optimisation génétique des requêtes (<acronym>GEQO</acronym>) ~~avec~~
	186	<title>Optimisation génétique des requêtes (<acronym>GEQO</acronym>) dans
184	187	PostgreSQL</title>
185	188
186	189	<para>
187		Le module <acronym>GEQO</acronym> est la solution du problème
188		d'optimisation des requêtes, une solution similaire au problème du voyageur
189		de commerce (<acronym>TSP</acronym>). L'approche du module
190		<acronym>GEQO</acronym> concernant le problème d'optimisation de requêtes
191		revient au problème bien connu du marchand de commerce
192		(<acronym>TSP</acronym>). Les plans de requêtes possibles sont
	190	Le module <acronym>GEQO</acronym> utilise une approche du problème
	191	d'optimisation des requêtes similaire à celui du voyageur
	192	de commerce (<acronym>TSP</acronym>). Les plans de requêtes possibles sont
193	193	codés comme des chaînes d'entiers. Chaque chaîne représente l'ordre de
194	194	jointure d'une relation de la requête à une autre. Par exemple, l'arbre de
…	…
207	207
208	208	<para>
209		Des parties du module <acronym>GEQO</acronym> sont adaptées de l'algorithme
	209	Diverses parties du module <acronym>GEQO</acronym> sont adaptées de l'algorithme
210	210	Genitor de D. Whitley.
211	211	</para>
212	212
213	213	<para>
214		Les caractéristiques spécifiques de l'implémentation de
215		<acronym>GEQO</acronym> dans <productname>PostgreSQL</productname>
216		sont :
	214	Les caractéristiques spécifiques de l'implantation du
	215	<acronym>GEQO</acronym> sont :
217	216
218	217	<itemizedlist spacing="compact" mark="bullet">
219	218	<listitem>
220	219	<para>
221		Utilisation d'un <firstterm>état d'équilibre</firstterm> du
222		<acronym>GA</acronym> (remplacement des individus les moins performants
223		d'une population, pas un remplacement d'une génération complète) qui
224		permet une convergence rapide vers les plans de requêtes améliorés. C'est
225		essentiel pour une gestion des requêtes sur un temps raisonnable ;
	220	<!-- least fit : plus divergent ? -->
	221	l'utilisation d'un algorithme génétique monostable (ou à état stable)
	222	(remplacement des individus les moins ciblés au lieu d'un remplacement
	223	global de génération) permet une convergence rapide vers des plans de
	224	requêtes améliorés ; c'est indispensable au traitement des requêtes dans un
	225	temps raisonnable ;
226	226	</para>
227	227	</listitem>
…	…
229	229	<listitem>
230	230	<para>
231		Utilisation d'un <firstterm>croisement de recombinaison de
232		bord</firstterm> qui convient tout spécialement pour garder bas le
233		nombre de pertes aux bords pour la solution du <acronym>TSP</acronym> en
234		utilisant un <acronym>GA</acronym>;
	231	<!-- Je me souviens maintenant pourquoi j'avais déjà buté sur cette
	232	relecture du temps de la 8.0... -->
	233	<!-- edge recombination crossover et edge losses ? -->
	234	l'utilisation de croisements (recombinaisons) aux limites est particulièrement
	235	adapté pour la restriction des pertes aux limites lors de la résolution
	236	du problème du voyageur de commerce par un algorithme génétique ;
235	237	</para>
236	238	</listitem>
…	…
238	240	<listitem>
239	241	<para>
240		~~La mutation comme opérateur génétique est obsolète d'une telle faço~~n
241		~~qu'aucun mécanisme de réparation n'est nécessaire pour générer des tours~~
242		~~<acronym>TSP</acronym> légaux~~.
	242	la mutation en tant qu'opérateur génétique est rendue obsolète afin
	243	d'éviter la nécessité de mécanismes de réparation lors de la génération
	244	de tournées valides du problème du voyageur de commerce.
243	245	</para>
244	246	</listitem>
…	…
254	256
255	257	<sect2 id="geqo-future">
256		<title>Tâches ~~pour la future implémentation de <acronym>GEQO</acronym> pour~~
257		<~~productname>PostgreSQL</productname><~~/title>
	258	<title>Tâches à réaliser pour la future implantation du <acronym>GEQO</acronym>
	259	</title>
258	260
259	261	<para>
…	…
263	265	<filename>src/backend/optimizer/geqo/geqo_main.c</filename>,
264	266	pour les routines <function>gimme_pool_size</function> et
265		<function>gimme_number_generations</function>, ~~nous devons~~ trouver un
266		compromis ~~dans les paramètres pour satisfaire deux demande~~s
267		concurrentes :
	267	<function>gimme_number_generations</function>, il faut trouver un
	268	compromis pour que les paramètres satisfassent deux besoins
	269	concurrents :
268	270	<itemizedlist spacing="compact">
269	271	<listitem>
270	272	<para>
271		~~Plan de requête optimum~~
	273	l'optimisation du plan de requête ;
272	274	</para>
273	275	</listitem>
274	276	<listitem>
275	277	<para>
276		~~Temps de calcul~~
	278	le temps de calcul.
277	279	</para>
278	280	</listitem>
…	…
281	283
282	284	<para>
283		À un niveau plus basique, il n'est pas clair que résoudre l'optimisation
284		d'une requête avec un algorithme GA conçu pour TSP soit appropriée. Dans
285		le cas TSP, le coût associé avec toute sous-chaîne (tour partiel) est
286		indépendant du reste du tour mais ceci n'est certainement pas vrai pour
287		l'optimisation de requêtes. Du coup, la question reste posée quant au fait
	285	À un niveau plus basique, il n'est pas certain qu'optimiser
	286	une requête avec un algorithme génétique conçu pour le problème du
	287	voyageur de commerce approprié. Dans le cas du voyageur de commerce, le
	288	coût associé à une sous-chaîne quelconque (tour partiel) est
	289	indépendant du reste du tour, mais cela n'est certainement plus vrai dans
	290	le cas de l'optimisation de requêtes. Du coup, la question reste posée quant au fait
288	291	que la recombinaison soit la procédure de mutation la plus efficace.
289	292	</para>
…	…
304	307	<ulink url="http://www.cs.bham.ac.uk/Mirrors/ftp.de.uu.net/EC/clife/www/location.htm">The
305	308	Hitch-Hiker's Guide to Evolutionary Computation</ulink> (FAQ de <ulink
306		url="news://comp.ai.genetic"></ulink>)
	309	url="news://comp.ai.genetic"></ulink>) ;
307	310	</para>
308	311	</listitem>
…	…
312	315	<ulink url="http://www.red3d.com/cwr/evolve.html">Evolutionary
313	316	Computation and its application to art and design</ulink>, par
314		Craig Reynolds
	317	Craig Reynolds ;
315	318	</para>
316	319	</listitem>

traduc/branches/bv82x/manuel/func.xml

r853	r872
4	4
5	5	<chapter id="functions">
6		<title>Fonctions et opérateurs</title>
	6	<title>Fonctions et opï¿œrateurs</title>
7	7
8	8	<indexterm zone="functions">
…	…
11	11
12	12	<indexterm zone="functions">
13		<primary>opérateur</primary>
	13	<primary>opï¿œrateur</primary>
14	14	</indexterm>
15	15
16	16	<para>
17	17	<productname>PostgreSQL</productname> fournit un grand nombre de fonctions
18		et d'op~~érateurs pour les types de données intégré~~s. Les utilisateurs peuvent
19		aussi d~~éfinir leurs propres fonctions et opérateurs comme dé~~crit dans
	18	et d'opï¿œrateurs pour les types de donnï¿œes intï¿œgrï¿œs. Les utilisateurs peuvent
	19	aussi dï¿œfinir leurs propres fonctions et opï¿œrateurs comme dï¿œcrit dans
20	20	la <xref linkend="server-programming"/>.
21	21	</para>
22	22	<para>
23	23	Les commandes <command>\df</command> et
24		<command>\do</command> de <application>psql</application> sont utilisées
	24	<command>\do</command> de <application>psql</application> sont utilisï¿œes
25	25	pour afficher respectivement la liste des fonctions et des
26		opérateurs.
	26	opï¿œrateurs.
27	27	</para>
28	28
29	29	<para>
30		Lorsque l'on consid~~ère la portabilité~~, il est important de savoir que la
31		plupart des fonctions et op~~érateurs décrits dans ce chapitre, à l'exception des opé~~rateurs
32		arithmétiques et logiques les plus triviaux et de quelques fonctions
33		sp~~écifiquement indiqué~~es, ne font pas partie du standard
34		<acronym>SQL</acronym>. Quelques fonctionnalit~~és é~~tendues sont
35		pr~~ésentes dans d'autres systèmes de gestion de bases de donné~~es
36		<acronym>SQL</acronym> et dans la plupart des cas, ces fonctionnalités sont
37		compatibles et coh~~érentes à~~ de nombreuses implantations. Ce chapitre n'est
38		pas exhaustif ; des fonctions supplémentaires apparaissent dans les
39		sections adéquates du manuel.
	30	Lorsque l'on considï¿œre la portabilitï¿œ, il est important de savoir que la
	31	plupart des fonctions et opï¿œrateurs dï¿œcrits dans ce chapitre, ï¿œ l'exception des opï¿œrateurs
	32	arithmï¿œtiques et logiques les plus triviaux et de quelques fonctions
	33	spï¿œcifiquement indiquï¿œes, ne font pas partie du standard
	34	<acronym>SQL</acronym>. Quelques fonctionnalitï¿œs ï¿œtendues sont
	35	prï¿œsentes dans d'autres systï¿œmes de gestion de bases de donnï¿œes
	36	<acronym>SQL</acronym> et dans la plupart des cas, ces fonctionnalitï¿œs sont
	37	compatibles et cohï¿œrentes ï¿œ de nombreuses implantations. Ce chapitre n'est
	38	pas exhaustif ; des fonctions supplï¿œmentaires apparaissent dans les
	39	sections adï¿œquates du manuel.
40	40	</para>
41	41
42	42
43	43	<sect1 id="functions-logical">
44		<title>Opérateurs logiques</title>
	44	<title>Opï¿œrateurs logiques</title>
45	45
46	46	<indexterm zone="functions-logical">
47		<primary>opérateur</primary>
	47	<primary>opï¿œrateur</primary>
48	48	<secondary>logique</secondary>
49	49	</indexterm>
50	50
51	51	<indexterm>
52		<primary>booléen</primary>
53		<secondary>opérateurs</secondary>
54		<see>opérateurs, logique</see>
55		</indexterm>
56
57		<para>
58		Opérateurs logiques habituels :
	52	<primary>boolï¿œen</primary>
	53	<secondary>opï¿œrateurs</secondary>
	54	<see>opï¿œrateurs, logique</see>
	55	</indexterm>
	56
	57	<para>
	58	Opï¿œrateurs logiques habituels :
59	59
60	60	<indexterm>
61		<primary>AND (opérateur)</primary>
	61	<primary>AND (opï¿œrateur)</primary>
62	62	</indexterm>
63	63
64	64	<indexterm>
65		<primary>OR (opérateur)</primary>
	65	<primary>OR (opï¿œrateur)</primary>
66	66	</indexterm>
67	67
68	68	<indexterm>
69		<primary>NOT (opérateur)</primary>
	69	<primary>NOT (opï¿œrateur)</primary>
70	70	</indexterm>
71	71
…	…
79	79
80	80	<indexterm>
81		<primary>négation</primary>
	81	<primary>nï¿œgation</primary>
82	82	</indexterm>
83	83
…	…
88	88	</simplelist>
89	89
90		<acronym>SQL</acronym> utilise une logique bool~~éenne à~~ trois valeurs dans
91		laquelle la valeur NULL représente <quote>inconnu</quote>. Les tables de
92		v~~érité à considé~~rer sont les suivantes :
	90	<acronym>SQL</acronym> utilise une logique boolï¿œenne ï¿œ trois valeurs dans
	91	laquelle la valeur NULL reprï¿œsente <quote>inconnu</quote>. Les tables de
	92	vï¿œritï¿œ ï¿œ considï¿œrer sont les suivantes :
93	93
94	94	<informaltable>
…	…
181	181
182	182	<para>
183		Les opérateurs <literal>AND</literal> et <literal>OR</literal> sont
184		commutatifs, c'est-~~à-dire que l'échange des opé~~randes gauche et
185		droit n'affecte pas le résultat. Voir la <xref
	183	Les opï¿œrateurs <literal>AND</literal> et <literal>OR</literal> sont
	184	commutatifs, c'est-ï¿œ-dire que l'ï¿œchange des opï¿œrandes gauche et
	185	droit n'affecte pas le rï¿œsultat. Voir la <xref
186	186	linkend="syntax-express-eval"/> pour plus d'informations sur l'ordre
187		d'évaluation des sous-expressions.
	187	d'ï¿œvaluation des sous-expressions.
188	188	</para>
189	189	</sect1>
190	190
191	191	<sect1 id="functions-comparison">
192		<title>Opérateurs de comparaison</title>
	192	<title>Opï¿œrateurs de comparaison</title>
193	193
194	194	<indexterm zone="functions-comparison">
195	195	<primary>comparaison</primary>
196		<secondary>opérateurs</secondary>
197		</indexterm>
198
199		<para>
200		Les opérateurs de comparaison habituels sont disponibles, comme l'indique
	196	<secondary>opï¿œrateurs</secondary>
	197	</indexterm>
	198
	199	<para>
	200	Les opï¿œrateurs de comparaison habituels sont disponibles, comme l'indique
201	201	le <xref linkend="functions-comparison-table"/>.
202	202	</para>
203	203
204	204	<table id="functions-comparison-table">
205		<title>Opérateurs de comparaison</title>
	205	<title>Opï¿œrateurs de comparaison</title>
206	206	<tgroup cols="2">
207	207	<thead>
208	208	<row>
209		<entry>Opérateur</entry>
	209	<entry>Opï¿œrateur</entry>
210	210	<entry>Description</entry>
211	211	</row>
…	…
215	215	<row>
216	216	<entry><literal><</literal> </entry>
217		<entry>inf~~érieur à~~</entry>
	217	<entry>infï¿œrieur ï¿œ</entry>
218	218	</row>
219	219
220	220	<row>
221	221	<entry><literal>></literal> </entry>
222		<entry>sup~~érieur à~~</entry>
	222	<entry>supï¿œrieur ï¿œ</entry>
223	223	</row>
224	224
225	225	<row>
226	226	<entry><literal><=</literal> </entry>
227		<entry>inf~~érieur ou égal à~~</entry>
	227	<entry>infï¿œrieur ou ï¿œgal ï¿œ</entry>
228	228	</row>
229	229
230	230	<row>
231	231	<entry><literal>>=</literal> </entry>
232		<entry>sup~~érieur ou égal à~~</entry>
	232	<entry>supï¿œrieur ou ï¿œgal ï¿œ</entry>
233	233	</row>
234	234
235	235	<row>
236	236	<entry><literal>=</literal> </entry>
237		<entry>~~égal à~~</entry>
	237	<entry>ï¿œgal ï¿œ</entry>
238	238	</row>
239	239
240	240	<row>
241	241	<entry><literal><></literal> ou <literal>!=</literal> </entry>
242		<entry>différent de</entry>
	242	<entry>diffï¿œrent de</entry>
243	243	</row>
244	244	</tbody>
…	…
248	248	<note>
249	249	<para>
250		L'opérateur <literal>!=</literal> est converti en
	250	L'opï¿œrateur <literal>!=</literal> est converti en
251	251	<literal><></literal> au moment de l'analyse. Il n'est pas possible
252		d'implanter des opérateurs <literal>!=</literal> et
253		<literal><></literal> r~~éalisant des opérations diffé~~rentes.
	252	d'implanter des opï¿œrateurs <literal>!=</literal> et
	253	<literal><></literal> rï¿œalisant des opï¿œrations diffï¿œrentes.
254	254	</para>
255	255	</note>
256	256
257	257	<para>
258		Les opérateurs de comparaison sont disponibles pour tous les types de
259		donn~~ées pour lesquels cela a du sens. Tous les opé~~rateurs de comparaison sont des
260		opérateurs binaires renvoyant des valeurs du type <type>boolean</type> ;
	258	Les opï¿œrateurs de comparaison sont disponibles pour tous les types de
	259	donnï¿œes pour lesquels cela a du sens. Tous les opï¿œrateurs de comparaison sont des
	260	opï¿œrateurs binaires renvoyant des valeurs du type <type>boolean</type> ;
261	261	des expressions comme <literal>1 < 2 < 3</literal> ne sont pas valides
262		(car il n'existe pas d'opérateur <literal><</literal> de comparaison d'une
263		valeur booléenne avec <literal>3</literal>).
	262	(car il n'existe pas d'opï¿œrateur <literal><</literal> de comparaison d'une
	263	valeur boolï¿œenne avec <literal>3</literal>).
264	264	</para>
265	265
…	…
269	269	<primary>between</primary>
270	270	</indexterm>
271		En plus des op~~érateurs de comparaison, on trouve la construction spé~~ciale
	271	En plus des opï¿œrateurs de comparaison, on trouve la construction spï¿œciale
272	272	<token>BETWEEN</token>.
273	273	<synopsis><replaceable>a</replaceable> BETWEEN <replaceable>x</replaceable> AND <replaceable>y</replaceable></synopsis>
274		est ~~équivalent à~~
	274	est ï¿œquivalent ï¿œ
275	275	<synopsis><replaceable>a</replaceable> >= <replaceable>x</replaceable> AND <replaceable>a</replaceable> <= <replaceable>y</replaceable></synopsis>
276		De même,
	276	De mï¿œme,
277	277	<synopsis><replaceable>a</replaceable> NOT BETWEEN <replaceable>x</replaceable> AND <replaceable>y</replaceable></synopsis>
278		est ~~équivalent à~~
	278	est ï¿œquivalent ï¿œ
279	279	<synopsis><replaceable>a</replaceable> < <replaceable>x</replaceable> OR <replaceable>a</replaceable> > <replaceable>y</replaceable></synopsis>
280		Il n'y a pas de différence entre les deux formes respectives si ce n'est
281		les cycles <acronym>CPU</acronym> requis pour r~~é-é~~crire en interne la
282		première sous la forme de la seconde.
	280	Il n'y a pas de diffï¿œrence entre les deux formes respectives si ce n'est
	281	les cycles <acronym>CPU</acronym> requis pour rï¿œ-ï¿œcrire en interne la
	282	premiï¿œre sous la forme de la seconde.
283	283	<indexterm>
284	284	<primary>BETWEEN SYMMETRIC</primary>
285	285	</indexterm>
286		<token>BETWEEN SYMMETRIC</token> est identique à <literal>BETWEEN</literal> sauf qu'il
287		n'est pas n~~écessaire que l'argument à~~ gauche de <literal>AND</literal> soit plus
288		petit ou ~~égal à l'argument à sa droite ; la bonne é~~chelle de valeurs
289		est d~~éterminé~~e automatiquement.
	286	<token>BETWEEN SYMMETRIC</token> est identique ï¿œ <literal>BETWEEN</literal> sauf qu'il
	287	n'est pas nï¿œcessaire que l'argument ï¿œ gauche de <literal>AND</literal> soit plus
	288	petit ou ï¿œgal ï¿œ l'argument ï¿œ sa droite ; la bonne ï¿œchelle de valeurs
	289	est dï¿œterminï¿œe automatiquement.
290	290	</para>
291	291
…	…
303	303	<primary>NOTNULL</primary>
304	304	</indexterm>
305		Pour vérifier si une valeur est NULL ou non, on utilise les constructions
	305	Pour vï¿œrifier si une valeur est NULL ou non, on utilise les constructions
306	306	<synopsis><replaceable>expression</replaceable> IS NULL
307	307	<replaceable>expression</replaceable> IS NOT NULL</synopsis>
308		ou la construction équivalente, non standard,
	308	ou la construction ï¿œquivalente, non standard,
309	309	<synopsis><replaceable>expression</replaceable> ISNULL
310	310	<replaceable>expression</replaceable> NOTNULL</synopsis>
…	…
313	313
314	314	<para>
315		On <emphasis>ne</emphasis> peut <emphasis>pas</emphasis> écrire
	315	On <emphasis>ne</emphasis> peut <emphasis>pas</emphasis> ï¿œcrire
316	316	<literal><replaceable>expression</replaceable> = NULL</literal>
317		parce que <literal>NULL</literal> n'est pas <quote>~~égal à~~</quote>
318		<literal>NULL</literal> (la valeur NULL représente une valeur inconnue
319		et il est impossible de dire si deux valeurs inconnues sont égales). Ce
	317	parce que <literal>NULL</literal> n'est pas <quote>ï¿œgal ï¿œ</quote>
	318	<literal>NULL</literal> (la valeur NULL reprï¿œsente une valeur inconnue
	319	et il est impossible de dire si deux valeurs inconnues sont ï¿œgales). Ce
320	320	comportement est conforme au standard SQL.
321	321	</para>
…	…
323	323	<tip>
324	324	<para>
325		Il se peut que des applications s'attendent à voir
	325	Il se peut que des applications s'attendent ï¿œ voir
326	326	<literal><replaceable>expression</replaceable> = NULL</literal>
327		~~évaluée à vrai (<foreignphrase>true</foreignphrase>) si <replaceable>expression</replaceable> s'é~~value comme
328		la valeur NULL. Il est chaudement recommandé que ces applications
329		soient modifi~~ées pour se conformer au standard SQL. Né~~anmoins, si cela
330		n'est pas possible, le paramètre de configuration <xref
331		linkend="guc-transform-null-equals"/> peut ~~être utilisé. S'il est activé~~,
	327	ï¿œvaluï¿œe ï¿œ vrai (<foreignphrase>true</foreignphrase>) si <replaceable>expression</replaceable> s'ï¿œvalue comme
	328	la valeur NULL. Il est chaudement recommandï¿œ que ces applications
	329	soient modifiï¿œes pour se conformer au standard SQL. Nï¿œanmoins, si cela
	330	n'est pas possible, le paramï¿œtre de configuration <xref
	331	linkend="guc-transform-null-equals"/> peut ï¿œtre utilisï¿œ. S'il est activï¿œ,
332	332	<productname>PostgreSQL</productname> convertit les clauses <literal>x =
333		NULL</literal> en <literal>x IS NULL</literal>. Tel était le comportement par
334		d~~éfaut dans les versions 6.5 à~~ 7.1 de <productname>PostgreSQL</productname>.
	333	NULL</literal> en <literal>x IS NULL</literal>. Tel ï¿œtait le comportement par
	334	dï¿œfaut dans les versions 6.5 ï¿œ 7.1 de <productname>PostgreSQL</productname>.
335	335	</para>
336	336	</tip>
…	…
339	339	<para>
340	340	Si l'<replaceable>expression</replaceable> est une valeur de ligne, alors
341		<literal>IS NULL</literal> est vrai quand l'expression même de la ligne est
	341	<literal>IS NULL</literal> est vrai quand l'expression mï¿œme de la ligne est
342	342	NULL ou quand tous les champs de la ligne sont NULL alors que
343		<literal>IS NOT NULL</literal> est vrai quand l'expression même de la ligne est
	343	<literal>IS NOT NULL</literal> est vrai quand l'expression mï¿œme de la ligne est
344	344	non NULL et que tous les champs de la ligne sont non NULL.
345		Cette définition, conforme au standard SQL, est un changement du
346		comportement incohérent des versions de <productname>PostgreSQL</productname>
347		ant~~érieures à~~ la 8.2.
	345	Cette dï¿œfinition, conforme au standard SQL, est un changement du
	346	comportement incohï¿œrent des versions de <productname>PostgreSQL</productname>
	347	antï¿œrieures ï¿œ la 8.2.
348	348	</para>
349	349	</note>
…	…
356	356	<primary>IS NOT DISTINCT FROM</primary>
357	357	</indexterm>
358		L'opérateur standard de comparaison renvoie NULL (ce qui signifie
359		<quote>inconnu</quote>) si l'une des entr~~ées est NULL. Une autre faç~~on
	358	L'opï¿œrateur standard de comparaison renvoie NULL (ce qui signifie
	359	<quote>inconnu</quote>) si l'une des entrï¿œes est NULL. Une autre faï¿œon
360	360	d'effectuer les comparaisons utilise la syntaxe <literal>IS <optional>NOT</optional> DISTINCT FROM</literal> :
361	361	<synopsis>
…	…
363	363	<replaceable>expression</replaceable> IS NOT DISTINCT FROM <replaceable>expression</replaceable>
364	364	</synopsis>
365		Pour des entrées non NULL, <literal>IS DISTINCT FROM</literal> est
366		identique ~~à l'opérateur <literal><></literal>. Cependant, si les deux entré~~es
367		sont NULL, alors cela retourne faux et si une des deux entrées est NULL,
368		alors cela retourne vrai. De la m~~ême faç~~on, <literal>IS NOT DISTINCT
369		FROM</literal> est identique ~~à <literal>=</literal> pour les entré~~es non NULL
370		mais il renvoie true si les deux entrées sont NULL et false quand une seule
371		est NULL. Dans ces constructions, NULL n'est plus consid~~éré~~ comme
372		un état inconnu mais comme une valeur.
	365	Pour des entrï¿œes non NULL, <literal>IS DISTINCT FROM</literal> est
	366	identique ï¿œ l'opï¿œrateur <literal><></literal>. Cependant, si les deux entrï¿œes
	367	sont NULL, alors cela retourne faux et si une des deux entrï¿œes est NULL,
	368	alors cela retourne vrai. De la mï¿œme faï¿œon, <literal>IS NOT DISTINCT
	369	FROM</literal> est identique ï¿œ <literal>=</literal> pour les entrï¿œes non NULL
	370	mais il renvoie true si les deux entrï¿œes sont NULL et false quand une seule
	371	est NULL. Dans ces constructions, NULL n'est plus considï¿œrï¿œ comme
	372	un ï¿œtat inconnu mais comme une valeur.
373	373	</para>
374	374
…	…
392	392	<primary>IS NOT UNKNOWN</primary>
393	393	</indexterm>
394		Les valeurs bool~~éennes peuvent aussi être testé~~es en utilisant les
	394	Les valeurs boolï¿œennes peuvent aussi ï¿œtre testï¿œes en utilisant les
395	395	constructions
396	396	<synopsis><replaceable>expression</replaceable> IS TRUE
…	…
400	400	<replaceable>expression</replaceable> IS UNKNOWN
401	401	<replaceable>expression</replaceable> IS NOT UNKNOWN</synopsis>
402		Elles retournent toujours true ou false, jamais une valeur NULL, même si
403		l'op~~érande est NULL. Une entrée NULL est traité~~e comme la valeur logique
	402	Elles retournent toujours true ou false, jamais une valeur NULL, mï¿œme si
	403	l'opï¿œrande est NULL. Une entrï¿œe NULL est traitï¿œe comme la valeur logique
404	404	<quote>inconnue</quote>. <literal>IS UNKNOWN</literal> et <literal>IS
405		NOT UNKNOWN</literal> sont r~~éellement identiques à~~ <literal>IS NULL</literal> et
	405	NOT UNKNOWN</literal> sont rï¿œellement identiques ï¿œ <literal>IS NULL</literal> et
406	406	<literal>IS NOT NULL</literal>, respectivement, sauf que l'expression en
407		entr~~ée doit être de type boolé~~en.
	407	entrï¿œe doit ï¿œtre de type boolï¿œen.
408	408	</para>
409	409	</sect1>
410	410
411	411	<sect1 id="functions-math">
412		<title>Fonctions et op~~érateurs mathé~~matiques</title>
413
414		<para>
415		Des op~~érateurs mathé~~matiques sont fournis pour un grand nombre de types
	412	<title>Fonctions et opï¿œrateurs mathï¿œmatiques</title>
	413
	414	<para>
	415	Des opï¿œrateurs mathï¿œmatiques sont fournis pour un grand nombre de types
416	416	<productname>PostgreSQL</productname>. Pour les types sans convention
417		math~~ématique commune à~~ toutes les permutations possibles (les types
418		dates/time, par exemple), le comportement r~~éel est dé~~crit dans les
419		sections appropriées.
420		</para>
421
422		<para>
423		Le <xref linkend="functions-math-op-table"/> affiche les opérateurs
424		mathématiques disponibles.
	417	mathï¿œmatique commune ï¿œ toutes les permutations possibles (les types
	418	dates/time, par exemple), le comportement rï¿œel est dï¿œcrit dans les
	419	sections appropriï¿œes.
	420	</para>
	421
	422	<para>
	423	Le <xref linkend="functions-math-op-table"/> affiche les opï¿œrateurs
	424	mathï¿œmatiques disponibles.
425	425	</para>
426	426
427	427	<table id="functions-math-op-table">
428		<title>Op~~érateurs mathé~~matiques</title>
	428	<title>Opï¿œrateurs mathï¿œmatiques</title>
429	429
430	430	<tgroup cols="4">
…	…
435	435	<thead>
436	436	<row>
437		<entry>Opérateur</entry>
	437	<entry>Opï¿œrateur</entry>
438	438	<entry>Description</entry>
439	439	<entry>Exemple</entry>
440		<entry>Résultat</entry>
	440	<entry>Rï¿œsultat</entry>
441	441	</row>
442	442	</thead>
…	…
466	466	<row>
467	467	<entry><literal>/</literal> </entry>
468		<entry>division (la division enti~~ère tronque les ré~~sultats)</entry>
	468	<entry>division (la division entiï¿œre tronque les rï¿œsultats)</entry>
469	469	<entry><literal>4 / 2</literal></entry>
470	470	<entry><literal>2</literal></entry>
…	…
487	487	<row>
488	488	<entry><literal>\|/</literal> </entry>
489		<entry>racine carrée</entry>
	489	<entry>racine carrï¿œe</entry>
490	490	<entry><literal>\|/ 25.0</literal></entry>
491	491	<entry><literal>5</literal></entry>
…	…
508	508	<row>
509	509	<entry><literal>!!</literal> </entry>
510		<entry>factoriel (op~~érateur pré~~fixe)</entry>
	510	<entry>factoriel (opï¿œrateur prï¿œfixe)</entry>
511	511	<entry><literal>!! 5</literal></entry>
512	512	<entry><literal>120</literal></entry>
…	…
522	522	<row>
523	523	<entry><literal>&</literal> </entry>
524		<entry>AND bit à bit</entry>
	524	<entry>AND bit ï¿œ bit</entry>
525	525	<entry><literal>91 & 15</literal></entry>
526	526	<entry><literal>11</literal></entry>
…	…
529	529	<row>
530	530	<entry><literal>\|</literal> </entry>
531		<entry>OR bit à bit</entry>
	531	<entry>OR bit ï¿œ bit</entry>
532	532	<entry><literal>32 \| 3</literal></entry>
533	533	<entry><literal>35</literal></entry>
…	…
536	536	<row>
537	537	<entry><literal>#</literal> </entry>
538		<entry>XOR bit à bit</entry>
	538	<entry>XOR bit ï¿œ bit</entry>
539	539	<entry><literal>17 # 5</literal></entry>
540	540	<entry><literal>20</literal></entry>
…	…
543	543	<row>
544	544	<entry><literal>~</literal> </entry>
545		<entry>NOT bit à bit</entry>
	545	<entry>NOT bit ï¿œ bit</entry>
546	546	<entry><literal>~1</literal></entry>
547	547	<entry><literal>-2</literal></entry>
…	…
550	550	<row>
551	551	<entry><literal><<</literal> </entry>
552		<entry>décalage gauche</entry>
	552	<entry>dï¿œcalage gauche</entry>
553	553	<entry><literal>1 << 4</literal></entry>
554	554	<entry><literal>16</literal></entry>
…	…
557	557	<row>
558	558	<entry><literal>>></literal> </entry>
559		<entry>décalage droit</entry>
	559	<entry>dï¿œcalage droit</entry>
560	560	<entry><literal>8 >> 2</literal></entry>
561	561	<entry><literal>2</literal></entry>
…	…
567	567
568	568	<para>
569		Les op~~érateurs bits à bits ne fonctionnent que sur les types de donné~~es
	569	Les opï¿œrateurs bits ï¿œ bits ne fonctionnent que sur les types de donnï¿œes
570	570	entiers alors que les autres sont disponibles pour tous les types de
571		donn~~ées numériques. Les opé~~rateurs bit par bit sont aussi disponibles pour
572		les types de chaînes de bits <type>bit</type> et <type>bit varying</type>
	571	donnï¿œes numï¿œriques. Les opï¿œrateurs bit par bit sont aussi disponibles pour
	572	les types de chaï¿œnes de bits <type>bit</type> et <type>bit varying</type>
573	573	comme le montre le <xref linkend="functions-bit-string-op-table"/>.
574	574	</para>
…	…
576	576	<para>
577	577	Le <xref linkend="functions-math-func-table"/> affiche les fonctions
578		mathématiques disponibles. Dans ce tableau, <literal>dp</literal>
	578	mathï¿œmatiques disponibles. Dans ce tableau, <literal>dp</literal>
579	579	signifie <type>double precision</type>. Beaucoup de ces fonctions sont
580		fournies dans de nombreuses formes avec différents types d'argument.
581		Sauf lorsque c'est indiqu~~é, toute forme donné~~e d'une fonction renvoie le
582		m~~ême type de donné~~es que son argument.
583		Les fonctions utilisant des données de type <type>double
584		precision</type> sont pour la plupart implant~~ées avec la bibliothè~~que C du
585		syst~~ème hôte ; la pré~~cision et le comportement dans les cas
586		particuliers peuvent varier en fonction du syst~~ème hô~~te.
	580	fournies dans de nombreuses formes avec diffï¿œrents types d'argument.
	581	Sauf lorsque c'est indiquï¿œ, toute forme donnï¿œe d'une fonction renvoie le
	582	mï¿œme type de donnï¿œes que son argument.
	583	Les fonctions utilisant des donnï¿œes de type <type>double
	584	precision</type> sont pour la plupart implantï¿œes avec la bibliothï¿œque C du
	585	systï¿œme hï¿œte ; la prï¿œcision et le comportement dans les cas
	586	particuliers peuvent varier en fonction du systï¿œme hï¿œte.
587	587	</para>
588	588
…	…
646	646
647	647	<table id="functions-math-func-table">
648		<title>Fonctions mathématiques</title>
	648	<title>Fonctions mathï¿œmatiques</title>
649	649	<tgroup cols="5">
650	650	<colspec colnum="1" colwidth="0.7*"/>
…	…
656	656	<row>
657	657	<entry>Fonction</entry>
658		<entry>Type renvoyé</entry>
	658	<entry>Type renvoyï¿œ</entry>
659	659	<entry>Description</entry>
660	660	<entry>Exemple</entry>
661		<entry>Résultat</entry>
	661	<entry>Rï¿œsultat</entry>
662	662	</row>
663	663	</thead>
…	…
667	667
668	668	<entry><literal><function>abs</function>(<replaceable>x</replaceable>)</literal></entry>
669		<entry>(identique à <replaceable>x</replaceable>)</entry>
	669	<entry>(identique ï¿œ <replaceable>x</replaceable>)</entry>
670	670	<entry>valeur absolue</entry>