Bienvenue sur PostGIS.fr

Bienvenue sur PostGIS.fr , le site de la communauté des utilisateurs francophones de PostGIS.

PostGIS ajoute le support d'objets géographique à la base de données PostgreSQL. En effet, PostGIS "spatialise" le serverur PostgreSQL, ce qui permet de l'utiliser comme une base de données SIG.

Maintenu à jour, en fonction de nos disponibilités et des diverses sorties des outils que nous testons, nous vous proposons l'ensemble de nos travaux publiés en langue française.

Changeset 19


Ignore:
Timestamp:
23/09/2011 15:36:21 (6 years ago)
Author:
djay
Message:

Ajouter quelques traductions.

Location:
trunk/workshop-foss4g
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/workshop-foss4g/about_data.rst

    r1 r19  
    11.. _about_data: 
    22 
    3 Section 5: About our data 
    4 ========================= 
     3Partie 5 : à propos de nos données 
     4================================== 
    55 
    6 The data for this workshop is four shapefiles for New York City, and one attribute table of sociodemographic variables.  We've loaded our shapefiles as PostGIS tables and will add sociodemographic data later in the workshop. 
     6Les données utilisées dans ces travaux proatiques sont quatre shapefiles de la ville de New York, et une table attributaire des variables sociodémographiques. Nous les avons charger sous forme de tables PostGIS et nous ajouterons les données  sociédémographiques plus tard. 
    77 
    8 The following describes the number of records and table attributes for each of our datasets.  These attribute values and relationships are fundamental to our future analysis.  
     8Cette partie fournit le nombre d'enregistrements et les attributs de chacun de nos ensembles de données. Ces valeurs attributaire et les relation sont essentielles pour nos future analyses. 
    99 
    10 To explore the nature of your tables in pgAdmin, right-click a highlighted table and select **Properties**.  You will find a summary of table properties, including a list of table attributes within the **Columns** tab. 
     10Pour visualiser la nature de vos tables depuis pgAdmin, cliquez avec le bouton droit sur une table et sélectionnez **Properties**. Vous trouverez un résumé des propriétés de la table, incluant la liste des attributs d'une tables dans l'onglet **Columns**. 
    1111 
    1212nyc_census_blocks 
    1313----------------- 
    1414 
    15 A census block is the smallest geography for which census data is reported. All higher level census geographies (block groups, tracts, metro areas, counties, etc) can be built from unions of census blocks. We have attached some demographic data to our collection of blocks. 
     15Un bloque ressencé est la plus petite entité géographique pour laquelle un ressencement est raporté. Toutes les couches représentant les niveaus suppérieurs (régions, zones de métro, comtés) peuvent être contruit à partir de ces bloques. Nous avons attaché des données démographiques au bloques. 
    1616 
    17 Number of records: 36592 
     17Nombre d'enregistrements : 36592 
    1818 
    1919.. list-table:: 
     
    2121 
    2222   * - **blkid** 
    23      - A 15-digit code that uniquely identifies every census **block**. Eg: 360050001009000 
     23     - Un code à 15 chiffres qui permet d'identifier de maniÚre unique chaque bloque **block**. Eg: 360050001009000 
    2424   * - **popn_total** 
    25      - Total number of people in the census block 
     25     - Nombre total de personnes dans le bloque 
    2626   * - **popn_white** 
    27      - Number of people self-identifying as "White" in the block 
     27     - Nombre de personne se déclarant comme de couleur blanche 
    2828   * - **popn_black** 
    29      - Number of people self-identifying as "Black" in the block 
     29     - Nombre de personne se déclarant comme de couleur noire 
    3030   * - **popn_nativ** 
    31      - Number of people self-identifying as "Native American" in the block 
     31     - Nombre de personne se déclarant comme natif d'amérique du nord 
    3232   * - **popn_asian** 
    33      - Number of people self-identifying as "Asian" in the block 
     33     - Nombre de personne se déclarant comme asiatique 
    3434   * - **popn_other** 
    35      - Number of people self-identifying with other categories in the block 
     35     - Nombre de personne se déclarant comme faisant partie d'une autre catégorie 
    3636   * - **hous_total** 
    37      - Number of housing units in the block 
     37     - Nombre de piÚce dans le bloque 
    3838   * - **hous_own** 
    39      - Number of owner-occupied housing units in the block 
     39     - Nombre de propriétaires occupant le bloque 
    4040   * - **hous_rent** 
    41      - Number of renter-occupied housing units in the block 
     41     - Nombre de locataire occupant le bloque 
    4242   * - **boroname** 
    43      - Name of the New York borough. Manhattan, The Bronx, Brooklyn, Staten Island, Queens 
     43     - Nom du quartier. Manhattan, The Bronx, Brooklyn, Staten Island, Queens 
    4444   * - **the_geom** 
    45      - Polygon boundary of the block 
     45     - Polygone représentant les contours d'un bloque 
    4646 
    4747.. figure:: ./screenshots/nyc_census_blocks.png 
    4848    
    49    *Black population as a percentage of Total Population*  
     49   *Pourcentage de la population quiest de couleur noire*  
    5050 
    5151.. note::  
  • trunk/workshop-foss4g/creating_db.rst

    r15 r19  
    11.. _creating_db: 
    22 
    3 Section 3 : Créer une base de données spatiales 
     3Partie 3 : créer une base de données spatiales 
    44=============================================== 
    55 
  • trunk/workshop-foss4g/geometries.rst

    r1 r19  
    11.. _geometries: 
    22 
    3 Section 8: Geometries 
     3Partie 8 : les géometries 
    44===================== 
    55 
     
    77------------ 
    88 
    9 In the previous :ref:`section <loading_data>`, we loaded a variety of data.  Before we start playing with our data lets have a look at some simpler examples.  In pgAdmin, once again select the **nyc** database and open the SQL query tool.  Paste this example SQL code into the pgAdmin SQL Editor window (removing any text that may be there by default) and then execute. 
     9Dans :ref:`une partie précédente<loading_data>` nous avons charger différentes données. Avant de commencer à jouer avec, commençons par regarder quelques exemples simples. Depuis pgAdmin, choisissez encore la base de donnée **nyc** et ouvrez l'outils de requêtage SQL. Copiez cette exemple de code SQL (aprÚs avoir supprimer le contenu présent défaut si nécessaire) puis exécutez-le. 
    1010 
    1111.. code-block:: sql 
     
    2626.. image:: ./geometries/start01.png 
    2727 
    28 The above example CREATEs a table (**geometries**) then INSERTs five geometries: a point, a line, a polygon, a polygon with a hole, and a collection. Finally, the inserted rows are SELECTed and displayed in the Output pane. 
    29  
    30 Metadata Tables 
    31 --------------- 
    32  
    33 In conformance with the Simple Features for SQL (:term:`SFSQL`) specification, PostGIS provides two tables to track and report on the geometry types available in a given database.  
    34  
    35 * The first table, ``spatial_ref_sys``, defines all the spatial reference systems known to the database and will be described in greater detail later 
    36 * The second table, ``geometry_columns``, provides a listing of all "features" (defined as an object with geometric attributes), and the basic details of those features.  
     28L'exemple ci-dessus créé une table (**geometries**) puis y insert cinq géométries : un point, une ligne, un polygone, un polygone avec un trou, et une collection. Au final, les lignes insérées sont sélectionnées et affichées dans le tableau de sortie. 
     29 
     30Les tables de métadonnées 
     31------------------------- 
     32 
     33Dans le respect de la spécification Simple Features for SQL (:term:`SFSQL`), PostGIS fournit deux tables pour récupérer et s'informer sur les types de géométries disponibles dans une base de données spécifique. 
     34 
     35* La premiÚre table, ``spatial_ref_sys``, définit tout les systÚme de projection connu de la base de données et sera décrite plus en détals plus tard 
     36* La seconde table, ``geometry_columns``, fournit une liste de toutes les "entités" (définit comme un objet avec un attribut géométrique) et les détails de base relatives à ces entités.  
    3737 
    3838.. image:: ./geometries/table01.png 
    3939 
    40 In our introductory example, the :command:`Populate_Geometry_Columns()` function finds all the columns in the database that contain geometry and updates the ``geometry_columns`` table to include references to them.   
    41  
    42 Lets have a look at the ``geometry_columns`` table in our database.  Paste this command in the Query Tool as before: 
     40Dans l'exemple founit en introduction, la fonction :command:`Populate_Geometry_Columns()` détecte toute les colonnes de la base de données qui contiennent des géométries et met à jour la table ``geometry_columns`` pour y inclure leurs références. 
     41 
     42Regardons maintenant table ``geometry_columns`` de notre base de données. Copiez cette commande dans la fenêtre de requêtage : 
     43 
    4344 
    4445.. code-block:: sql 
     
    4849.. image:: ./geometries/start08.png 
    4950 
    50 * ``f_table_catalog``, ``f_table_schema``, and ``f_table_name`` provide the fully qualified name of the feature table containing a given geometry.  Because PostgreSQL doesn't make use of catalogs, ``f_table_catalog`` will tend to be empty 
    51 * ``f_geometry_column`` is the name of the column that geometry containing column -- for feature tables with multiple geometry columns, there will be one record for each.   
    52 * ``coord_dimension`` and ``srid`` define the the dimension of the geometry (2-, 3- or 4-dimensional) and the Spatial Reference system identifier that refers to the ``spatial_ref_sys`` table respectively 
    53 * The ``type`` column defines the type of geometry as described below; we've seen Point and Linestring types so far 
    54  
    55 By querying this table, GIS clients and libraries can determine what to expect when retrieving data and can perform any necessary projection, processing or rendering without needing to inspect each geometry. 
    56  
    57 Representing Real World Objects 
    58 ------------------------------- 
    59  
    60 The Simple Features for SQL (:term:`SFSQL`) specification, the original guiding standard for PostGIS development, defines how a real world object is represented.  By taking a continuous shape and digitizing it at a fixed resolution we achieve a passable representation of the object.  SFSQL only handled 2-dimensional representations.  PostGIS has extended that to include 3- and 4-dimensional representations; more recently the SQL-Multimedia Part 3 (:term:`SQL/MM`) specification has officially defined their own representation.   
    61  
    62 Our example table contains a mixture of different geometry types. We can collect general information about each object using functions that read the geometry metadata. 
    63  
    64  * :command:`ST_GeometryType(geometry)` returns the type of the geometry 
    65  * :command:`ST_NDims(geometry)` returns the number of dimensions of the geometry 
    66  * :command:`ST_SRID(geometry)` returns the spatial reference identifier number of the geometry 
     51* ``f_table_catalog``, ``f_table_schema``, et ``f_table_name`` fournissent le nom complet de la table contenant une géométrie donnée. Étant donné que PostgreSQL n'utilise pas de catalogues, ``f_table_catalog`` est toujouts vide 
     52* ``f_geometry_column`` est le nom de la colonne qui contient la géométrie -- pour les tables ayant plusieurs colonnes géométriques, il y a un enregistrement dans cette table pour chacune. 
     53* ``coord_dimension`` et ``srid`` définissent respectivement la dimension de la géométrie (en 2-, 3- or 4-dimensions) et le systÚme de références spatiales qui fait référence à la table ``spatial_ref_sys`` 
     54* La colonne ``type`` définit le type de géométrie comme décrit plus tÃŽt, nous avons déjà vu les points et les lignes 
     55 
     56En interrogeant cette table, les clients SIG et les libraires peuvent déterminer quoi attendre lors de la récupration des données et peuvent réaliser les opération de reprojection, transformation ou rendu sans avoir a inspecter chaque géométrie. 
     57 
     58Réprésenter des objets du mode réel 
     59----------------------------------- 
     60 
     61La spécification Simple Features for SQL (:term:`SFSQL`), le standard ayant guidé le développement de PostGIS, définit comment les objets du monde réel doivent être représentés. En considérant une forme continue à une seule résolution fixe, nous obtenu un piÚtre représentation des objets. SFSQL considÚre uniquement les représentations en 2 dimensions. PostGIS a étendu cela en ajoutant les représentation en 3 et 4 dimensions, plus récemment la spécification SQL-Multimedia Part 3 (:term:`SQL/MM`) a officiellement définit sa propre représenation. 
     62 
     63Notre table exemple contient différents types de géométries Nous pouvons récupérer les informations de chaque objets en utilisant les fonctions qui lisent les métadonnées de la géométrie. 
     64 
     65 * :command:`ST_GeometryType(geometry)` retourne le type de la géométrie 
     66 * :command:`ST_NDims(geometry)` retourne le nombre de dimension d'une géométrie 
     67 * :command:`ST_SRID(geometry)` retourne l'identifiant de référence spatiale de la géométrie 
    6768 
    6869.. code-block:: sql 
     
    8384 
    8485 
    85 Points 
    86 ~~~~~~ 
     86Les points 
     87~~~~~~~~~~~ 
    8788 
    8889.. image:: ./introduction/points.png 
    8990   :align: center 
    9091 
    91 A spatial **point** represents a single location on the Earth.  This point is represented by a single coordinate (including either 2-, 3- or 4-dimensions).  Points are used to represent objects when the exact details, such as shape and size, are not important at the target scale.  For example, cities on a map of the world can be described as points, while a map of a single state might represent cities as polygons.   
     92Un **point** spatiale représente une localisation unique sur la Terre. Ce point est représenté par une seule coordonnée (incluant soit 2, 3 ou 4 dimensions). Les points sont utilisés pour représenter des objets lorsque le détails exact du contour n'est pas important à une échelle donnée. Par exemple, les villes sur une carte du monde pourraient être décrite sous la forme de points alors qu'une carte régionale utiliserait une représentation polygonale des villes. 
    9293 
    9394.. code-block:: sql 
     
    101102  POINT(0 0) 
    102103 
    103 Some of the specific spatial functions for working with points are: 
    104  
    105  * :command:`ST_X(geometry)` returns the X ordinate 
    106  * :command:`ST_Y(geometry)` returns the Y ordinate 
    107  
    108 So, we can read the ordinates from a point like this: 
     104Ceraints des fonctions spécifiques pour travailler avec les points sont : 
     105 
     106 * :command:`ST_X(geometry)` retourne la composante X 
     107 * :command:`ST_Y(geometry)` retourne la composante Y  
     108 
     109Donc, nous pouvons lire les coordonnées d'un point de la maniÚre suivante : 
    109110 
    110111.. code-block:: sql 
     
    114115    WHERE name = 'Point'; 
    115116 
    116 The New York City subway stations (``nyc_subway_stations``) table is a data set represented as points. The following SQL query will return the geometry associated with one point (in the :command:`ST_AsText` column). 
     117La table des stations de métros de la ville de New York  (``nyc_subway_stations``) est un ensemble de données représenté sous la forme de points. La requête SQL suivante reverra la géométrie associée à un point (dans la colonne :command:`ST_AsText`). 
    117118 
    118119.. code-block:: sql 
     
    123124 
    124125 
    125 Linestrings 
     126Les lignes  
    126127~~~~~~~~~~~ 
    127128 
     
    129130   :align: center 
    130131 
    131 A **linestring** is a path between locations.  It takes the form of an ordered series of two or more points.  Roads and rivers are typically represented as linestrings.  A linestring is said to be **closed** if it starts and ends on the same point.  It is said to be **simple** if it does not cross or touch itself (except at its endpoints if it is closed).  A linestring can be both **closed** and **simple**. 
    132  
    133 The street network for New York (``nyc_streets``) was loaded earlier in the workshop.  This dataset contains details such as name, and type.  A single real world street may consist of many linestrings, each representing a segment of road with different attributes. 
    134  
    135 The following SQL query will return the geometry associated with one linestring (in the :command:`ST_AsText` column). 
     132Une **ligne** est un chemin entre plusieurs points. Elle prend la forme d'un tableay ordonné de deux (ou plus) points. Les routes et les riviÚres sont tipyquement représenté sous la forme de lignes. Une ligne est dire **fermée** si elle commence et se fini en un même point. Elle est dite **simple** si elle ne se coupe pas ni se touche elle-même (sauf à ses extrémités si elle est fermée). Une ligne peut être à la fois **fermée** et **simple**. 
     133 
     134Le réseau des rues de New York (``nyc_streets``) a été chargé plus tÃŽt. Cet ensemble de données contient les détails comme le nom et le type. Une rue du monde réelle pourrait être constituée de plusieurs lignes, chacune représentant une file de la avec différents attributs. 
     135 
     136La requête SQL suivante retourne la géométrie associée à une ligne (dans la colonne :command:`ST_AsText`) : 
    136137 
    137138.. code-block:: sql 
     
    145146  LINESTRING(0 0, 1 1, 2 1, 2 2) 
    146147 
    147 Some of the specific spatial functions for working with linestrings are: 
    148  
    149  * :command:`ST_Length(geometry)` returns the length of the linestring 
    150  * :command:`ST_StartPoint(geometry)` returns the first coordinate as a point 
    151  * :command:`ST_EndPoint(geometry)` returns the last coordinate as a point 
    152  * :command:`ST_NPoints(geometry)` returns the number of coordinates in the linestring 
    153  
    154 So, the length of our linestring is: 
     148Les fonctions spatiales permettant de travailler avec les lignes sont les suivantes : 
     149 
     150 * :command:`ST_Length(geometry)` retourne la longueur d'une ligne 
     151 * :command:`ST_StartPoint(geometry)` retourne le premier point d'une ligne 
     152 * :command:`ST_EndPoint(geometry)` retourne le denier point d'une ligne 
     153 * :command:`ST_NPoints(geometry)` retourne le nombre de points dans une ligne 
     154 
     155Donc, la longueur de notre ligne est : 
    155156 
    156157.. code-block:: sql 
     
    165166 
    166167 
    167 Polygons 
    168 ~~~~~~~~ 
     168Les polygones 
     169~~~~~~~~~~~~~~ 
    169170 
    170171.. image:: ./introduction/polygons.png 
    171172  :align: center 
    172173 
    173 A polygon is a representation of an area.  The outer boundary of the polygon is represented by a ring.  This ring is a linestring that is both closed and simple as defined above.  Holes within the polygon are also represented by rings. 
    174  
    175 Polygons are used to represent objects whose size and shape are important.  City limits, parks, building footprints or bodies of water are all commonly represented as polygons when the scale is sufficiently high to see their area.  Roads and rivers can sometimes be represented as polygons. 
    176  
    177 The following SQL query will return the geometry associated with one linestring (in the :command:`ST_AsText` column). 
     174Un polygone est représenté comme une zone. Le contour externe du polygone est représenté par une ligne simple et fermée. Les trous sont représenté de la même maniÚre. 
     175 
     176Les polygones sont utiliser pour représenter les objets dont les tailles et la forme sont importants. Les limites de villes, les parks, les batiments ou les cours d'eau sont habituellement représenté par des polygones lorsque l'échelle est suffisament élevée pour voir distinguer leurs zones. Les routes et les riviÚres peuvent parfois être représenté comme des polygones. 
     177 
     178La requête SQL suivante retournera la géométrie associée à un polygon (dans la colonne :command:`ST_AsText`). 
    178179 
    179180.. code-block:: sql 
     
    185186.. note:: 
    186187 
    187   Rather than using an ``=`` sign in our ``WHERE`` clause, we are using the ``LIKE`` operator to carry out a string matching operation. You may be used to the ``*`` symbol as a "glob" for pattern matching, but in SQL the ``%`` symbol is used, along with the ``LIKE`` operator to tell the system to do globbing. 
     188  PlutÃŽt que d'utiliser le signe ``=`` dans notre clause ``WHERE``, nous avons utilisé l'opérateur ``LIKE`` pour pouvoir définir notre comparaison. Vous auriez sans doute voulu utiliser le symbole ``*`` pour exprimer "n'importe quelle valeur" mais en SQL vous devez utiliser : ``%`` et l'opérateur ``LIKE`` pour informer le systÚme que cette comparaison doit être possible. 
    188189 
    189190:: 
     
    192193 POLYGON((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1)) 
    193194 
    194 The first polygon has only one ring. The second one has an interior "hole". Most graphics systems include the concept of a "polygon", but GIS systems are relatively unique in allowing polygons to explicitly have holes. 
     195Le premier polygon a seulement une ligne. Le second a un "trou". La plupart des systÚmes de rendu graphique supportent le concept de "polygone", mais les systÚme SIG sont les seuls a accepter que les polygones puisse contenir des trous. 
    195196 
    196197.. image:: ./screenshots/polygons.png 
    197198 
    198 Some of the specific spatial functions for working with polygons are: 
    199  
    200  * :command:`ST_Area(geometry)` returns the area of the polygons 
    201  * :command:`ST_NRings(geometry)` returns the number of rings (usually 1, more of there are holes) 
    202  * :command:`ST_ExteriorRing(geometry)` returns the outer ring as a linestring 
    203  * :command:`ST_InteriorRingN(geometry,n)` returns a specified interior ring as a linestring 
    204  * :command:`ST_Perimeter(geometry)` returns the length of all the rings 
    205  
    206 We can calculate the area of our polygons using the area function: 
     199Certaines des fonctions spatiales spécifique de traitement des polygones sont : 
     200 
     201 * :command:`ST_Area(geometry)` retourne l'aire de polygones 
     202 * :command:`ST_NRings(geometry)` retourne le nombre de contour (habituellement 1, plus lorsqu'il y a des trous) 
     203 * :command:`ST_ExteriorRing(geometry)` rentourne le contour extérieur 
     204 * :command:`ST_InteriorRingN(geometry,n)` retourne le contour intérieur numéro n 
     205 * :command:`ST_Perimeter(geometry)` retourne la longueur de tout les contours 
     206 
     207Nous pouvons calculer l'aire de nos polygones en utilisant la fonction area : 
    207208 
    208209.. code-block:: sql 
     
    217218  PolygonWithHole    99 
    218219 
    219 Note that the polygon with a hole has an area that is the area of the outer shell (a 10x10 square) minus the area of the hole (a 1x1 square). 
    220  
    221 Collections 
    222 ~~~~~~~~~~~ 
    223  
    224 There are four collection types, which group multiple simple geometries into sets.   
    225  
    226  * **MultiPoint**, a collection of points 
    227  * **MultiLineString**, a collection of linestrings 
    228  * **MultiPolygon**, a collection of polygons 
    229  * **GeometryCollection**, a heterogeneous collection of any geometry (including other collections) 
    230  
    231 Collections are another concept that shows up in GIS software more than in generic graphics software. They are useful for directly modeling real world objects as spatial objects. For example, how to model a lot that is split by a right-of-way? As a **MultiPolygon**, with a part on either side of the right-of-way. 
     220Remarquez que le polygone contenant un trou a une aire égale à l'aire du contour externe (un carré de 10 sur 10) moins l'aire du trou (un carré de 1 sur 1). 
     221 
     222Les collections 
     223~~~~~~~~~~~~~~~~  
     224 
     225Il y a quatre types de collections, qui regroupe ensembles plusieurs géométries simples. 
     226 
     227 * **MultiPoint**, une collection de points 
     228 * **MultiLineString**, une collection de lignes 
     229 * **MultiPolygon**, une collection de polygones 
     230 * **GeometryCollection**, une collections hétérogÚne de n'importe quelle géométrie (dont d'autre collections) 
     231 
     232Les collections sont un concept présents dans les logiciels SIG  plus que dans les application de rendu graphique générique. Elles sont utiles pour directement modeler  les objets du monde réel comme des objet spatiaux. Par exemple, comment modéliser une parcelle qui é coupée par un chemin ? Comme un **MultiPolygon**, ayant une partie de chaque coté du chemin. 
    232233 
    233234.. image:: ./screenshots/collection2.png 
    234235 
    235 Our example collection contains a polygon and a point: 
     236Notre collection exemple contient un polygon et un point : 
    236237 
    237238.. code-block:: sql 
     
    247248.. image:: ./screenshots/collection.png 
    248249 
    249 Some of the specific spatial functions for working with collections are: 
    250  
    251  * :command:`ST_NumGeometries(geometry)` returns the number of parts in the collection 
    252  * :command:`ST_GeometryN(geometry,n)` returns the specified part 
    253  * :command:`ST_Area(geometry)` returns the total area of all polygonal parts 
    254  * :command:`ST_Length(geometry)` returns the total length of all linear parts 
    255  
    256  
    257  
    258 Geometry Input and Output 
    259 ------------------------- 
     250Certaines des fonctions spatiales spécifiques à la manipulation des collections sont : 
     251 
     252 * :command:`ST_NumGeometries(geometry)` retourne le nombre de composantes d'une collection 
     253 * :command:`ST_GeometryN(geometry,n)` retourne une composante spécifique 
     254 * :command:`ST_Area(geometry)` retourne l'aire totale des composantes de types polygones 
     255 * :command:`ST_Length(geometry)` retourne la longueur totale des composantes de types lignes 
     256 
     257 
     258 
     259Entré / Sortie des géométries 
     260----------------------------- 
    260261 
    261262Within the database, geometries are stored on disk in a format only used by the PostGIS program. In order for external programs to insert and retrieve useful geometries, they need to be converted into a format that other applications can understand. Fortunately, PostGIS supports emitting and consuming geometries in a large number of formats: 
  • trunk/workshop-foss4g/installation.rst

    r16 r19  
    11.. _installation: 
    22 
    3 Section 2 : Installation 
     3Partie 2 : installation 
    44======================= 
    55 
  • trunk/workshop-foss4g/introduction.rst

    r13 r19  
    11.. _introduction: 
    22 
    3 Partie 1 : Introduction  
     3Partie 1 : introduction  
    44************************ 
    55 
  • trunk/workshop-foss4g/loading_data.rst

    r1 r19  
    11.. _loading_data: 
    22 
    3 Section 4: Loading spatial data 
    4 =============================== 
     3Partie 4 : charger des données spatiales 
     4========================================= 
    55 
    6 Supported by a wide variety of libraries and applications, PostGIS provides many options for loading data.  This section will focus on the basics -- loading shapefiles using the PostGIS shapefile loading tool.   
     6Supporté dans une grande variété de librairies et d'applications, PostGIS fournit de nombreux outils pour charger des données. Cette partie traitera uniquement sur du chargement basique de données, chargement de fichiers Shaefile en utilisant l'outil de chargement shapefile de PostGIS. 
    77 
    8 #. First, return to the Dashboard, and click on the **Import shapefiles** link in the PostGIS section. The GUI shapefile importer pgShapeLoader will launch. 
     8#. PremiÚrement, retournez sur le Dashboard et cliquez sur le lien **Import shapefiles** de la section PostGIS. L'interface d'import de données Shapefile pgShapeLoader se lance. 
    99 
    1010   .. image:: ./screenshots/pgshapeloader_01.png 
    1111 
    12 #. Next, open the *Shape File* browser and navigate to the data directory, file:`\\postgisintro\\data`. Select the :file:`nyc_census_blocks.shp` file.  
     12#. Ensuite, ouvrez le navigateur de fichier *Shape File* puis dans le répertoire file:`\\postgisintro\\data` sélectionnez le fichier :file:`nyc_census_blocks.shp`.  
    1313 
    14 #. Fill in the details for the *PostGIS Connection* section and click on the **Test Connection...** button. 
     14#. Saisissez les détails de la section *connexion PostGIS* et cliquez sur le bouton **Test Connection...**. 
    1515 
    1616   .. list-table:: 
     
    2727  .. note::  
    2828   
    29      Setting the port number to **54321** is very important! The OpenGeo PostGIS runs on port 54321, not the default PostgreSQL port of 5432. 
     29     Affecter le numéro de port **54321** est trÚs important ! Le serveur PostGIS d'OpenGeo utilise ce port et non le port par défaut (5432). 
    3030 
    31 #. Fill in the details for the *Configuration* section. 
     31#. Sisissez les détails de la section *Configuration*. 
    3232 
    3333   .. list-table:: 
     
    4242        - ``the_geom`` 
    4343 
    44 #. Click the **Options** button and select "Load data using COPY rather than INSERT." This will make the data load process a little faster. 
     44#. Cliquez sur le bouton **Options** et sélectionnez "Load data using COPY rather than INSERT." Ce qui implique que le chargement des données sera plus rapide. 
    4545 
    4646   .. image:: ./screenshots/pgshapeloader_02.png 
    4747 
    48 #. Finally, click the **Import** button and watch the import process. It may take a few minutes to load, but this is the largest file in our test set. 
     48#. Pour finir, cliquez sur le bouton **Import** et regardez l'importation s'exécuter. Cela peut prendre plusieurs minutes pour charger, mais ce fichier est le plus gros que nous aurons à charger. 
    4949 
    50 #. Repeat the import process for the remaining shapefiles in the data directory. Except for the input file and output table name, all the other fields in pgShapeLoader should remain the same: 
     50#. Repétez la méthode afin d'importer les autres données présentes dans le répertoire data. Ormis le nom du fichier et le nom de la table de sortie, les autres paramÚtres de pgShapeLoader devrait rester les même : 
    5151 
    5252   * ``nyc_streets.shp`` 
     
    5454   * ``nyc_subway_stations.shp`` 
    5555  
    56 #. When all the files are loaded, click the "Refresh" button in pgAdmin to update the tree view. You should see your four tables show up in the **Tables** section of the tree. 
     56#. Lorsque tout les fichiers sont chargé, cliquez sur le bouton "Refresh" de pgAdmin pour mettre à jour l'arbre affiché. Vous devriez voir vos quatre nouvellles tables s'affichées dans la section **Tables** de l'arbre. 
    5757 
    5858   .. image:: ./screenshots/refresh.png 
    5959  
    6060  
    61 Shapefiles? What's that? 
    62 ------------------------ 
     61Shafile ? Qu'est-ce que c'est ? 
     62------------------------------- 
    6363 
    64 You may be asking yourself -- "What's this shapefile thing?"  A "shapefile" commonly refers to a collection of files with ``.shp``, ``.shx``, ``.dbf``, and other extensions on a common prefix name (e.g., nyc_census_blocks). The actual shapefile relates specifically to files with the ``.shp`` extension. However, the ``.shp`` file alone is incomplete for distribution without the required supporting files. 
     64Il est possible que vous vous demandiez "Qu'est-ce que c'est ce shapefile truc ?" On utilise communément le terme "Shapefile" pour parler d'un ensemble de fichiers d'extension ``.shp``, ``.shx``, ``.dbf``, ou autre ayant un nom commun (ex: nyc_census_blocks). Le fichier Shapefile est en réalité le fichier d'extension ``.shp``, mais ce fichier seul n'est pas complet sans ses fichiers associés. 
    6565 
    66 Mandatory files: 
     66Fichiers obligatoires : 
    6767 
    68   * ``.shp`` — shape format; the feature geometry itself 
    69   * ``.shx`` — shape index format; a positional index of the feature geometry  
    70   * ``.dbf`` — attribute format; columnar attributes for each shape, in dBase III 
     68  * ``.shp`` — les formes; les entités géographiques elle-mêmes 
     69  * ``.shx`` — l'index de formes; un index base sur les position des entité géographiques 
     70  * ``.dbf`` — les attributs; les données attributaires associés à chaque formes, au format dBase III 
    7171     
    72 Optional files include: 
     72Les fichiers optionels possibles : 
    7373 
    74   * ``.prj`` — projection format; the coordinate system and projection information, a plain text file describing the projection using well-known text format 
     74  * ``.prj`` — la projection; le systÚme de coordonnées et l'information de projection, un fichier texte décrivant la projection utilisant le format text bien connu (WKT) 
    7575 
    76 In order to analyze a shapefile in PostGIS, you need to convert a shapefile into a series SQL commands.  By running pgShapeLoader, a shapefile converts into a table that PostgreSQL can understand.  
     76Afin d'utiliser un fichier Shapefile dans PostGIS, vous devez le convertir en une série de requêtes SQL. En utilisant pgShapeLoader, un Shapefile est converti en une table que PostgreSQL peut comprendre. 
    7777 
    7878 
    79 SRID 26918? What's with that? 
    80 ----------------------------- 
     79SRID 26918 ? Qu'est que c'est ? 
     80------------------------------- 
    8181 
    82 Most of the import process is self-explanatory, but even experienced GIS professionals can trip over an **SRID**. 
     82La plupart des paramÚtres de l'importation de données sont explicites mais même les proffessionnels du SIG peuvent rencontrer des difficulté à propos du **SRID**. 
    8383 
    84 An "SRID" stands for "Spatial Reference IDentifier." It defines all the parameters of our data's geographic coordinate system and projection. An SRID is convenient because it packs all the information about a map projection (which can be quite complex) into a single number. 
     84"SRID" signifie "IDentifiant de Référénce Spatiale". Il définit tout les paramÚtres de nos données de coordonnées géographiques et la projection. Un SRID est pratique car il encapsule sous la forme d'un nombre toutes les informations à propos de la projection de la carte (ce qui peut être trÚs compliqué). 
    8585 
    86 You can see the definition of our workshop map projection by looking it up either in an online database, 
     86Vou pouvez consultez la définition de la projection de la carte en consultant la base de données en ligne suivante : 
    8787 
    8888  http://spatialreference.org/ref/epsg/26918/ 
    8989 
    90 or directly inside PostGIS with a query to the ``spatial_ref_sys`` table. 
     90ou directement depuis PostGIS en interrogeant la table ``spatial_ref_sys``. 
    9191 
    9292.. code-block:: sql 
     
    9696.. note:: 
    9797 
    98    The PostGIS ``spatial_ref_sys`` table is an OGC-standard table that defines all the spatial reference systems known to the database. The data shipped with PostGIS, lists over 3000 known spatial reference systems and details needed to transform/re-project between them 
     98   La table ``spatial_ref_sys`` de PostGIS est une table standard OGC qui définit tout les systÚmes de références spatiales connus par la base de données. Les données livrées avec PostGIS, contiennent 3000 systÚmes de références spatiales et précise les informations nécessaire à la tranformation ou la reprojection 
    9999    
    100 In both cases, you see a textual representation of the **26918** spatial reference system (pretty-printed here for clarity): 
     100Dans les deux cas, vous obtiendrez une représentation du systÚme de références spatiales **26918** (affiché sur plusieurs lignes ici pour plus de clarté). 
    101101 
    102102:: 
     
    121121    AXIS["Northing",NORTH]] 
    122122 
    123 If you open up the ``nyc_neighborhoods.prj`` file from the data directory, you'll see the same projection definition.  
     123Si vous ouvrez le fichier ``nyc_neighborhoods.prj`` du répertoire data, vous verrez la même définition. 
    124124 
    125 A common problem for people getting started with PostGIS is figuring out what SRID number to use for their data. All they have is a ``.prj`` file. But how do humans translate a ``.prj`` file into the correct SRID number? 
     125Un problÚme auquel se confronte la plupart des débutants en PostGIS est de savoir quel SRID il doit utiliser pour ses données. Tout ce qu'ils ont c'est un fichier ``.prj``. Mais comment un humain peut-il reconnaitre le numéro de SRID correct en lisant le contenu du fichier ``.prj`` ? 
    126126 
    127 The easy answer is to use a computer.  Plug the contents of the ``.prj`` file into http://prj2epsg.org. This will give you the number (or a list of numbers) that most closely match your projection definition. There aren't numbers for *every* map projection in the world, but most common ones are contained within the prj2epsg database of standard numbers. 
     127La réponse simple est d'utiliser un ordinateur. Copiez le contenu du fichier ``.prj`` dans le formulaire du site http://prj2epsg.org. Cela vous donnera le nombre (ou la liste de nombres) qui  correspondent le plus à votre définition de projection. Il n'y a pas de nombre pour *toutes* les projections de cartes existantes dans le monde, mais les plus courants sont disponibles dans la base de données de prj2epsg. 
    128128 
    129129.. image:: ./screenshots/prj2epsg_01.png 
    130130 
    131 Data you receive from local agencies -- such as New York City -- will usually be in a local projection noted by "state plane" or "UTM".  Our projection is "Universal Transverse Mercator (UTM) Zone 18 North" or EPSG:26918.   
     131Les données que vous recevez des agences locales de l'état - comme la ville de New York - utiliseront la plupart du temps des projections locales noté "state plane" ou "UTM". Dans notre cas, la projection est "Universal Transverse Mercator (UTM) Zone 18 North" soit EPSG:26918.   
    132132 
    133133 
    134 Things to Try: Spatially Enable an Existing Database 
    135 ---------------------------------------------------- 
     134Les choses à essayer : rendre spatiale une base de données existante 
     135-------------------------------------------------------------------- 
    136136 
    137 You have already seen how to create a database using the ``postgis_template`` in pgAdmin. However when installing from source or adding PostGIS functionality to an existing database, it is not always appropriate to create a fresh database from the PostGIS template. 
     137Vous avez déjà vue comment créer une base de données en utilisant le modÚle ``postgis_template`` depuis pgAdmin. Néanmoins, lorsque vous installé depuis les sources ou que vous ajoutez le module PostGIS à une base existante, il n'est pas toujours approprié de créer une nouvelle base de données en utilisant le modÚle PostGIS. 
    138138 
    139 Your task in this section is to create a database and add PostGIS types and functions after the fact.  The SQL scripts needed -- :file:`postgis.sql` and :file:`spatial_ref_sys.sql` -- can be found in the :file:`contrib` directory of your PostgreSQL install.  For guidance, refer to the PostGIS documentation on installing from source [#PostGIS_Install]_. 
     139Votre tâche consiste dans cette section à créer une base de données et à ajouter les types et les fonctions PostGIS ensuite. Les script SQL nécessaires - :file:`postgis.sql` et :file:`spatial_ref_sys.sql` - se trouve dans le répertoire :file:`contrib` de votre installation de PostgreSQL. Pour vous guider, vous pouvez consulter la documentation PostGIS expliquant comment installer PostGIS [#PostGIS_Install]_. 
    140140 
    141141.. note:: 
    142142 
    143    Remember to include your username and port number when creating a database from the command line. 
     143   N'oubliez pas saisir le nom de l'utilisateur et le numéro de port losque vous créer une base de données en ligne de command. 
    144144     
    145 Things to Try: View data using uDig 
    146 ----------------------------------- 
     145Les choses à essayer : Visualiser se données avec uDig 
     146------------------------------------------------------ 
    147147 
    148 `uDig <http://udig.refractions.org>`_, (User-friendly Desktop Internet GIS), is a desktop GIS viewer/editor for quickly looking at data. You can view a number of data formats including flat shapefiles and a PostGIS database. Its graphical interface allows for easy exploration of your data, as well as simple testing and fast styling.  
     148`uDig <http://udig.refractions.org>`_, (User-friendly Desktop Internet GIS), est outils bureautique de visualisation/edition SIG permettant de visualiser rapidement se données. Vous pouvez visualiser un grand nombre de formats de données différents dont les Shapefiles et les bases de données PostGIS. Son interface graphique vous permet d'explorer vos données facilement mais aussi de les tester et les syler rapidement. 
    149149 
    150 Use this software to connect your PostGIS database.  The application is included in the ``software`` folder. 
     150Utilisez cette application pour vous connecter à votre base de données PostGIS. L'application est contenu dans le répertoire ``software``. 
    151151 
    152152.. rubric:: Footnotes 
  • trunk/workshop-foss4g/simple_sql.rst

    r1 r19  
    11.. _simple_sql: 
    22 
    3 Section 6: Simple SQL 
    4 ===================== 
     3Partie 6 : requêtes SQL simples 
     4=============================== 
    55 
    6 :term:`SQL`, or "Structured Query Language", is a means of asking questions of, and updating data in, relational databases. You have already seen SQL when we created our first database.  Recall: 
     6:term:`SQL`, pour "Structured Query Language", définit comment interroger et mettre des données dans une base. Vous vez déjà du SQL lorsque nous avons notre premiÚre base de données.  Rappel: 
    77 
    88.. code-block:: sql 
     
    1010   SELECT postgis_full_version(); 
    1111 
    12 But that was a question about the database.  Now that we've loaded data into our database, let's use SQL to ask questions of the data! For example, 
     12Mais ici c'était une question à propose de la base de données. Maintenant que nous avons carger des données dans notre base, essayons d'utiliser SQL pour interroger les données ! Par exemple, 
    1313 
    14   "What are the names of all the neighborhoods in New York City?" 
     14  "Quel sont les noms des quartier de la ville de New York ?" 
    1515   
    16 Open up the SQL query window in pgAdmin by clicking the SQL button 
     16Ouvrez une fenêtre SQL depuis pgAdmin en cliquant sur le bouton SQL 
    1717 
    1818.. image:: ./screenshots/pgadmin_05.png 
    1919 
    20 then enter the following query in to the query window 
     20Puis saisissez la requête suivante dans la fenêtre 
    2121 
    2222.. code-block:: sql 
     
    2424  SELECT name FROM nyc_neighborhoods; 
    2525   
    26 and click the **Execute Query** button (the green triangle). 
     26et cliquez sur le bouton **Execute Query** (le triangle vert). 
    2727   
    2828.. image:: ./screenshots/pgadmin_08.png   
    2929 
    30 The query will run for a few (mili)seconds and return the 129 results. 
     30La requête s'exécutera pendant quelques (mili)secondes et retournera 129 résultats. 
    3131 
    3232.. image:: ./screenshots/pgadmin_09.png   
    3333 
    34 But what exactly happened here?  To understand, let's begin with the four "verbs" of SQL,  
     34Mais que c'est-il exactement passé ici ? Pour le comprendre, commençons par présenter les quatre type de requêtes du SQL : 
    3535 
    36  * ``SELECT``, returns rows in response to a query 
    37  * ``INSERT``, adds new rows to a table 
    38  * ``UPDATE``, alters existing rows in a table 
    39  * ``DELETE``, removes rows from a table 
     36 * ``SELECT``, retourne des lignes en réponse à une requête 
     37 * ``INSERT``, ajoute des lignes dans une table 
     38 * ``UPDATE``, modifit des lignes existantes d'une table 
     39 * ``DELETE``, supprimer des lignes d'une table 
    4040  
    41 We will be working almost exclusively with ``SELECT`` in order to ask questions of tables using spatial functions. 
     41Nous travaillerons principalement avec des requêtes de type ``SELECT``afin d'interroger les tables en utilisant des fonctions spatiales. 
    4242 
    43 SELECT queries 
    44 -------------- 
     43Requête de type SELECT 
     44---------------------- 
    4545 
    46 A select query is generally of the form: 
     46Une requête de type Select est généralement de la forme : 
    4747 
    48   SELECT some_columns FROM some_data_source WHERE some_condition; 
     48  SELECT colonnes FROM données WHERE conditions; 
    4949   
    5050.. note:: 
    5151 
    52     For a synopsis of all ``SELECT`` parameters, see the PostgresSQL `documentation  <http://www.postgresql.org/docs/8.1/interactive/sql-select.html>`_. 
     52    Pour une description exhaustive des paramÚtres possible d'une requête ``SELECT``, consultez la `documentaton de PostgresSQL  <http://www.postgresql.org/docs/8.1/interactive/sql-select.html>`_. 
    5353     
    54 The ``some_columns`` are either column names or functions of column values. The ``some_data_source`` is either a single table, or a composite table created by joining two tables on a key or condition. The ``some_condition`` is a filter that restricts the number of rows to be returned. 
    5554 
    56   "What are the names of all the neighborhoods in Brooklyn?" 
     55Les ``colonnes`` sont soit des noms de colonnes soit des fonctions utilisant les valeurs des colonnes. Les ``données`` sont soit une table seule, ou plusieures tables reliés ensemble en réalisant une jointure sur une clef ou une autre condition. Les ``conditions`` représentent le filtre qui restreint le nombre de lignes a retourner. 
    5756 
    58 We return to our ``nyc_neighborhoods`` table with a filter in hand.  The table contains all the neighborhoods in New York, but we only want the ones in Brooklyn. 
     57  "Quel sont les noms des quartier de Brooklyn ?" 
     58 
     59Nous retournons à notre table ``nyc_neighborhoods`` avec le filtre en main. La table contient tout les quartiers de New Yorl et nous ne voulons que ceux de Brooklyn. 
    5960 
    6061.. code-block:: sql 
     
    6465    WHERE boroname = 'Brooklyn'; 
    6566 
    66 The query will run for even fewer (mili)seconds and return the 23 results. 
     67La requête prendra encore que quelque (mili)secondes et retournera les 23 éléments résultants. 
    6768 
    68 Sometimes we will need to apply a function to the results of our query. For example, 
     69Parfois nous aurons besoin d'appliquer des fonctions sur le résultats d'une de nos requête. Par exemple, 
    6970 
    70   "What is the number of letters in the names of all the neighborhoods in Brooklyn?" 
     71  "Quel est le nombre de lettres dans les noms des quarties de Brooklyn ?" 
    7172   
    72 Fortunately, PostgreSQL has a string length function, :command:`char_length(string)`. 
     73Heureusement PostgreSQL fournit une fonction calculant la langueur d'une chaîne de caractÚres : :command:`char_length(string)`. 
    7374 
    7475.. code-block:: sql 
     
    7879    WHERE boroname = 'Brooklyn'; 
    7980 
    80 Often, we are less interested in the individual rows than in a statistic that applies to all of them. So knowing the lengths of the neighborhood names might be less interesting than knowing the average length of the names. Functions that take in multiple rows and return a single result are called "aggregate" functions.   
     81Bien souvent nous sommes moins interressé par une ligne particuliÚre mais plus par un calcul statistique sur l'ensemble résultant. Donc connaitre la longueur des noms de quartiers serait moins interressant que de calculer la moyenne des ces longueurs. Les fonctions qui renvoit un résultat unique en utilisant un ensemble de valeurs sont appelée des "fonctions d'aggrégations". 
    8182 
    82 PostgreSQL has a series of built-in aggregate functions, including the general purpose :command:`avg()` for average values and :command:`stddev()` for standard deviations. 
     83PostgreSQL fournit un ensemble de fonctions d'aggrégations, parmis lesquelles :command:`avg()` pour calculer la moyenne, and :command:`stddev()` pour l'écart type. 
    8384 
    84   "What is the average number of letters and standard deviation of number of letters in the names of all the neighborhoods in Brooklyn?" 
     85  "Quel est le nombre moyen et l'écart type du nombre de lettre dans le noms des quartier de Brooklyn ?" 
    8586   
    8687.. code-block:: sql 
     
    9697   11.7391304347826087 | 3.9105613559407395 
    9798 
    98 The aggregate functions in our last example were applied to every row in the result set. What if we want the summaries to be carried out over smaller groups within the overall result set? For that we add a ``GROUP BY`` clause. Aggregate functions often need an added ``GROUP BY`` statement to group the result-set by one or more columns.   
     99Les fonctions d'agrégation dans notre dernier exemple sont appliquées à chaque ligne de l'ensemble des résultats. Comment faire si nous voulons rassembler des données ? Pour cela nous utilisons la clause ``GROUP BY``. Les fonctions d'agrégation ont souvent besoin d'une clause ``GROUP BY`` pour regrouper les éléments en utilisant une ou plusieures colonnes. 
    99100 
    100   "What is the average number of letters in the names of all the neighborhoods in New York City, reported by borough?" 
     101  "Quel est la moyenne des les noms de quartier de New York, renvoyer par quartiers ?" 
    101102 
    102103.. code-block:: sql 
     
    106107    GROUP BY boroname; 
    107108  
    108 We include the ``boroname`` column in the output result so we can determine which statistic applies to which borough. In an aggregate query, you can only output columns that are either (a) members of the grouping clause or (b) aggregate functions. 
     109 
     110Nous ajoutons la colonne ``boroname`` dans le résultat afin de pouvoir déterminer quelle valeur statistique s'applique à quel quartier. Dans une requête agrégée, vous pouvez seulement retourner les colonnes qui sont (a) membre de la clause de regroupement ou (b) des fonctions d'agrégation. 
    109111   
    110112:: 
     
    118120   Staten Island | 12.2916666666666667 | 5.2043390480959474 
    119121   
    120 Function List 
    121 ------------- 
     122Liste de fonctions 
     123------------------ 
    122124 
    123 `avg(expression) <http://www.postgresql.org/docs/current/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: PostgreSQL aggregate function that returns the average value of a numeric column. 
     125`avg(expression) <http://www.postgresql.org/docs/current/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: fonction d'agrégation de PostgreSQL  qui retourne la valeur moyenne d'une colonne. 
    124126 
    125 `char_length(string) <http://www.postgresql.org/docs/current/static/functions-string.html>`_: PostgreSQL string function that returns the number of character in a string. 
     127`char_length(string) <http://www.postgresql.org/docs/current/static/functions-string.html>`_: fonction s'applicant aux chaînes de caractÚre de PostgreSQL qui retourne le nombre de lettre dans une chaîne. 
    126128 
    127 `stddev(expression) <http://www.postgresql.org/docs/current/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-STATISTICS-TABLE>`_: PostgreSQL aggregate function that returns the standard deviation of input values. 
     129`stddev(expression) <http://www.postgresql.org/docs/current/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-STATISTICS-TABLE>`_: fonction d'aggrégation de PostgreSQL qui retourne l'écart type d'un ensemble de valeurs. 
    128130   
    129131   
  • trunk/workshop-foss4g/simple_sql_exercises.rst

    r18 r19  
    11.. _simple_sql_exercises: 
    22 
    3 Section 7 : Exercices simple de SQL 
     3Partie 7 : exercices simples de SQL 
    44=================================== 
    55 
Note: See TracChangeset for help on using the changeset viewer.