|
|
<!--
|
|
|
<!DOCTYPE appendix PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd">
|
|
|
-->
|
|
|
|
|
|
<appendix id="database">
|
|
|
<title
|
|
|
>Introduction aux bases de données</title>
|
|
|
|
|
|
<sect1 id="what-is-a-database">
|
|
|
<title
|
|
|
>Une base de données, qu'est-ce que c'est ?</title>
|
|
|
<para
|
|
|
>On peut définir une base de données comme un ensemble de données sur un sujet. Cet ensemble est organisé de façon à permettre facilement de parcourir les informations, les modifier ou ajouter de nouveaux éléments. </para>
|
|
|
<para
|
|
|
>Regardez ce diagramme représentant un des exemples ci-dessus : un simple annuaire téléphonique. </para>
|
|
|
<screenshot>
|
|
|
<screeninfo
|
|
|
>Un diagramme d'une base de données d'annuaire téléphonique</screeninfo>
|
|
|
<mediaobject>
|
|
|
<imageobject>
|
|
|
<imagedata fileref="contact-example.png" format="PNG"/>
|
|
|
</imageobject>
|
|
|
<textobject>
|
|
|
<phrase
|
|
|
>Un diagramme d'une base de données d'un annuaire téléphonique</phrase>
|
|
|
</textobject>
|
|
|
</mediaobject>
|
|
|
</screenshot>
|
|
|
<para
|
|
|
>L'image ci-dessus montre un ensemble de deux contacts présentés chacun sur une carte. Une telle carte peut constituer une rangée d'une table : </para>
|
|
|
|
|
|
<para
|
|
|
><emphasis
|
|
|
>La table <guilabel
|
|
|
>Contacts</guilabel
|
|
|
></emphasis
|
|
|
></para>
|
|
|
<informaltable>
|
|
|
<tgroup cols="2">
|
|
|
<tbody>
|
|
|
<row>
|
|
|
<entry
|
|
|
><guilabel
|
|
|
>Nom</guilabel
|
|
|
></entry>
|
|
|
<entry
|
|
|
><guilabel
|
|
|
>No. Tel</guilabel
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Joan</entry>
|
|
|
<entry
|
|
|
>699 23 43 12</entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Adam</entry>
|
|
|
<entry
|
|
|
>711 19 77 21</entry>
|
|
|
</row>
|
|
|
</tbody>
|
|
|
</tgroup>
|
|
|
</informaltable>
|
|
|
|
|
|
<para
|
|
|
><emphasis
|
|
|
>Termes et définitions</emphasis
|
|
|
> : Une donnée qui constitue une partie d'un ensemble plus grand peut être appelée une <firstterm
|
|
|
>ligne</firstterm
|
|
|
> ou de manière plus professionnelle un <firstterm
|
|
|
>enregistrement</firstterm
|
|
|
>. L'ensemble est normalement appelé une <firstterm
|
|
|
>table</firstterm
|
|
|
>. Le nom le plus naturel d'une table est un nom décrivant les données qu'elle contient, <guilabel
|
|
|
>Contacts</guilabel
|
|
|
> dans cet exemple. De plus, chaque ligne de la table est constituée de <firstterm
|
|
|
>colonnes</firstterm
|
|
|
>, souvent appelées aussi <firstterm
|
|
|
>champs</firstterm
|
|
|
>. Dans la table <guilabel
|
|
|
>Contacts</guilabel
|
|
|
>, il y a deux colonnes (champs) :<guilabel
|
|
|
>Nom</guilabel
|
|
|
> et <guilabel
|
|
|
>No. Tel</guilabel
|
|
|
>. </para>
|
|
|
<para
|
|
|
>Pour les cas simples, une table peut constituer à elle toute seule une <firstterm
|
|
|
>base de données</firstterm
|
|
|
>. Beaucoup de personnes considèrent les deux comme équivalents. Comme vous le verrez, pour des bases de données réelles, on a besoin le plus souvent de plusieurs tables. </para>
|
|
|
<para
|
|
|
>Pour résumer, vous avez déjà une base de données simple, constituée d'une table <guilabel
|
|
|
>Contacts</guilabel
|
|
|
>. </para>
|
|
|
</sect1>
|
|
|
|
|
|
|
|
|
<sect1 id="database-and-spreadsheet">
|
|
|
<title
|
|
|
>Bases de données et tableurs</title>
|
|
|
<para
|
|
|
>Vous avez très probablement déjà utilisé des tableurs comme KSpread, OpenOffice.org Calc ou Microsoft Excel. Dans ce cas, vous vous demandez sûrement pourquoi utiliser une base de données, puisque les feuilles des tableurs et les bases de données sont toutes les deux constituées de tables. </para>
|
|
|
<para
|
|
|
>En comparant les base de données et les feuilles des tableurs, vous allez aborder les problèmes suivants, que nous étudierons ensuite plus précisément : </para>
|
|
|
<itemizedlist>
|
|
|
<listitem
|
|
|
><para
|
|
|
><link linkend="referential-data-integrity"
|
|
|
>Intégrité référentielle des données</link
|
|
|
></para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><link linkend="data-redundyncy"
|
|
|
>Redondance des données</link>
|
|
|
</para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><link linkend="data-integrity-and-validity"
|
|
|
>Intégrité et validité des données</link
|
|
|
></para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><link linkend="data-limiting"
|
|
|
>Limiter la vue des données</link
|
|
|
></para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><link linkend="performance-and-capacity"
|
|
|
>Performances et capacités</link
|
|
|
></para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><link linkend="convenient-data-entry"
|
|
|
>Saisie pratique de données</link
|
|
|
></para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><link linkend="reports"
|
|
|
>Rapports</link
|
|
|
></para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><link linkend="programming"
|
|
|
>Programmation</link
|
|
|
></para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><link linkend="multiuse"
|
|
|
>Utilisation simultanée</link
|
|
|
></para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><link linkend="security"
|
|
|
>Sécurité</link
|
|
|
></para
|
|
|
></listitem>
|
|
|
</itemizedlist>
|
|
|
|
|
|
<sect2 id="difference-database-and-spreadsheet">
|
|
|
<title
|
|
|
>En quoi une base de données est-elle différente d'une feuille de calcul ?</title>
|
|
|
|
|
|
<para
|
|
|
>En dépassant progressivement la capacité d'un téléphone portable, étendez votre table <guilabel
|
|
|
>Contacts</guilabel
|
|
|
> en ajoutant une colonne (champ) <guilabel
|
|
|
>Adresse</guilabel
|
|
|
>. Ajoutez plusieurs numéros de téléphone par personne (bureau, maison) et ajoutez les prénoms aux noms. Pour simplifier la situation, nous allons supposer : </para>
|
|
|
<itemizedlist>
|
|
|
<listitem
|
|
|
><para
|
|
|
>que la table est limitée à deux personnes (bien sûr, il peut y en avoir des milliers dans une base de données en pratique)</para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
>Il n'y a pas deux personnes avec les même noms et prénoms.</para>
|
|
|
</listitem>
|
|
|
</itemizedlist>
|
|
|
<para
|
|
|
><emphasis
|
|
|
>La table Contacts</emphasis
|
|
|
></para>
|
|
|
<informaltable>
|
|
|
<tgroup cols="3">
|
|
|
<tbody>
|
|
|
<row>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Nom et prénom</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Téléphone</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Adresse</emphasis
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Joan Smith</entry>
|
|
|
<entry
|
|
|
>699 23 43 12</entry>
|
|
|
<entry
|
|
|
>Western Gate 1, Warsaw</entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Adam Willson</entry>
|
|
|
<entry
|
|
|
>711 19 77 21</entry>
|
|
|
<entry
|
|
|
>London, Frogs Drive 5</entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Joan Smith</entry>
|
|
|
<entry
|
|
|
>110 98 98 00</entry>
|
|
|
<entry
|
|
|
>Western Gate 1</entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Smith Joan</entry>
|
|
|
<entry
|
|
|
>312 43 42 22</entry>
|
|
|
<entry
|
|
|
>Warsaw, Western Gate 1</entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>ADAM Willson</entry>
|
|
|
<entry
|
|
|
>231 83 02 04</entry>
|
|
|
<entry
|
|
|
>Frogs Drive 5, London</entry>
|
|
|
</row>
|
|
|
</tbody>
|
|
|
</tgroup>
|
|
|
</informaltable>
|
|
|
|
|
|
<para
|
|
|
>Une telle table peut être faite dans un tableur ou une application de base de données. Utiliser un tableur est très facile, bien sûr. Mais quels sont les problèmes que l'on peut rencontrer à ce stade ? </para>
|
|
|
|
|
|
<sect3 id="referential-data-integrity">
|
|
|
<title
|
|
|
>Intégrité des données référencées</title>
|
|
|
<para
|
|
|
>Supposez que vous utilisez un tableur et que vous avez besoin de changer l'adresse d'au moins une personne. Vous avez alors un petit problème : vous devez alors changer l'adresse dans de nombreuse lignes. Par exemple, Joan prend trois lignes. Un vrai problème apparaît si vous oubliez de changer une des lignes – l'adresse assignée à cette personne sera <emphasis
|
|
|
>ambigüe</emphasis
|
|
|
>, donc <emphasis
|
|
|
>vos données perdent leur intégrité</emphasis
|
|
|
>. </para>
|
|
|
<para
|
|
|
>De plus, il n'y a aucun moyen simple de supprimer une personne donnée de la table, puisque vous devez vous retrouver toutes les lignes liées à cette personne pour les supprimer. </para>
|
|
|
</sect3>
|
|
|
|
|
|
|
|
|
<sect3 id="data-redundyncy">
|
|
|
<title
|
|
|
>Redondance des données</title>
|
|
|
<para
|
|
|
>C'est relié directement au problème précédent. Dans les colonnes <guilabel
|
|
|
>Nom et prénom</guilabel
|
|
|
> et <guilabel
|
|
|
>Adresse</guilabel
|
|
|
>, la même donnée est entrée à de nombreuses reprises. C'est typique de la manière inefficace de stocker des données dans un tableur car la base de données grossit inutilement, demandant donc plus de ressources informatiques (à cause d'une masse de données plus importante et d'un accès plus lent). </para>
|
|
|
<para
|
|
|
>Comment pouvez -vous résoudre ces problèmes avec une base de données ? Vous pouvez diviser l'information en plus petits morceaux en créant une table additionnelle <emphasis
|
|
|
>Personnes</emphasis
|
|
|
>, avec seulement deux colonnes : <guilabel
|
|
|
>Prénom et nom</guilabel
|
|
|
> et <guilabel
|
|
|
>Adresse</guilabel
|
|
|
> : </para>
|
|
|
|
|
|
<para
|
|
|
><emphasis
|
|
|
>la table <guilabel
|
|
|
>Personnes</guilabel
|
|
|
></emphasis
|
|
|
></para>
|
|
|
<informaltable>
|
|
|
<tgroup cols="2">
|
|
|
<tbody>
|
|
|
<row>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Nom et prénom</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Adresse</emphasis
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Joan Smith</entry>
|
|
|
<entry
|
|
|
>Western Gate 1, Warsaw</entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Adam Willson</entry>
|
|
|
<entry
|
|
|
>Frogs Drive 5, London</entry>
|
|
|
</row>
|
|
|
</tbody>
|
|
|
</tgroup>
|
|
|
</informaltable>
|
|
|
|
|
|
<para
|
|
|
>Chaque ligne de la table <guilabel
|
|
|
>Personnes</guilabel
|
|
|
> correspond à <emphasis
|
|
|
>une seule personne</emphasis
|
|
|
>. La table <guilabel
|
|
|
>Contacts</guilabel
|
|
|
> est à partir de maintenant en relation avec la table <guilabel
|
|
|
>Personnes</guilabel
|
|
|
>. </para>
|
|
|
|
|
|
</sect3>
|
|
|
|
|
|
<sect3 id="data-integrity-and-validity">
|
|
|
<title
|
|
|
>Intégrité et validité des données</title>
|
|
|
<para
|
|
|
>Notez que la façon dont sont entrées les données dans les champs <guilabel
|
|
|
>Nom et prénom</guilabel
|
|
|
> et <guilabel
|
|
|
>Adresse</guilabel
|
|
|
>. Les gens entrant des données peuvent se tromper, ou même parfois être négligents. Dans nos exemples de données, nous avons deux différentes manières pour saisir des noms et des prénoms (Joan Smith et Smith Joan, Adam et ADAM) et encore plus de manières de saisir la même adresse. Vous pouvez sûrement en imaginer bien d'autres. </para>
|
|
|
<para
|
|
|
>Le problème ci-dessus montre que &pex; lorsqu'on recherche le numéro de téléphone d'une personne dont l'adresse est "Western Gate 1, Warsaw", on n'obtient pas tous les résultats. On n'obtient qu'une seule ligne au lieu de trois. De plus, on ne trouve pas non plus tous les numéros de téléphone en cherchant pour la valeur "Joan Smith" dans le champ <guilabel
|
|
|
>Nom et prénom</guilabel
|
|
|
>, car "Smith Joan" ne correspond pas à "Joan Smith". </para>
|
|
|
<para
|
|
|
>Comment pouvez-vous résoudre ces problèmes en utilisant une base de données ? Vous pouvez les résoudre en modifiant la structure de la table <guilabel
|
|
|
>Personnes</guilabel
|
|
|
> comme ceci : </para>
|
|
|
<orderedlist>
|
|
|
<listitem
|
|
|
><para
|
|
|
>En <emphasis
|
|
|
>divisant les données</emphasis
|
|
|
> dans le champ <guilabel
|
|
|
>Nom et prénom</guilabel
|
|
|
> en deux champs séparés : <guilabel
|
|
|
>Nom</guilabel
|
|
|
> et <guilabel
|
|
|
>Prénom</guilabel
|
|
|
>. </para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
>En <emphasis
|
|
|
>divisant les données</emphasis
|
|
|
> dans le champ <guilabel
|
|
|
>Adresse</guilabel
|
|
|
> en trois champs séparés : <guilabel
|
|
|
>Rue</guilabel
|
|
|
>, <guilabel
|
|
|
>Numéro</guilabel
|
|
|
> et <guilabel
|
|
|
>Ville</guilabel
|
|
|
>. </para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
>En <emphasis
|
|
|
>garantissant la validité des données</emphasis
|
|
|
> : en s'assurant que les champs ne restent pas vides, &pex; vous devez toujours saisir le numéro de maison. </para
|
|
|
></listitem>
|
|
|
</orderedlist>
|
|
|
|
|
|
<para
|
|
|
>La nouvelle version de la table ressemble à cela : </para>
|
|
|
|
|
|
<para
|
|
|
><emphasis
|
|
|
>Tables des personnes</emphasis
|
|
|
></para>
|
|
|
<informaltable>
|
|
|
<tgroup cols="5">
|
|
|
<colspec colnum="1" colname="c1"
|
|
|
></colspec>
|
|
|
<colspec colnum="2" colname="c2"
|
|
|
></colspec>
|
|
|
<colspec colnum="3" colname="c3"
|
|
|
></colspec>
|
|
|
<colspec colnum="4" colname="c4"
|
|
|
></colspec>
|
|
|
<colspec colnum="5" colname="c5"
|
|
|
></colspec>
|
|
|
<tbody>
|
|
|
<row>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Prénom</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Nom</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Rue</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Numéro</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Ville</emphasis
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Joan</entry>
|
|
|
<entry
|
|
|
>Smith</entry>
|
|
|
<entry
|
|
|
>Western Gate</entry>
|
|
|
<entry
|
|
|
>1</entry>
|
|
|
<entry
|
|
|
>Warsaw</entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Adam</entry>
|
|
|
<entry
|
|
|
>Willson</entry>
|
|
|
<entry
|
|
|
>Frogs Drive</entry>
|
|
|
<entry
|
|
|
>5</entry>
|
|
|
<entry
|
|
|
>London</entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry namest="c1" nameend="c5"
|
|
|
><emphasis
|
|
|
>Conditions</emphasis
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Champs requis</entry>
|
|
|
<entry
|
|
|
>Champs requis</entry>
|
|
|
<entry
|
|
|
>Champs requis</entry>
|
|
|
<entry
|
|
|
>Champs requis</entry>
|
|
|
<entry
|
|
|
>Champs requis</entry>
|
|
|
</row>
|
|
|
</tbody>
|
|
|
</tgroup>
|
|
|
</informaltable>
|
|
|
|
|
|
<para
|
|
|
>Grâce à l'introduction de la condition <guilabel
|
|
|
>champ requis</guilabel
|
|
|
>, on peut être sûr que les données saisies sont complètes. Dans le cas des autres tables, vous pouvez bien sûr permettre de ne pas remplir certains champs en entrant des données. </para>
|
|
|
|
|
|
</sect3>
|
|
|
|
|
|
<sect3 id="data-limiting">
|
|
|
<title
|
|
|
>Limiter la vue des données</title>
|
|
|
<para
|
|
|
>Un tableur affiche toutes les lignes et toutes les colonnes de la table, ce qui est encombrant pour de très grandes tables. Vous pouvez bien sûr filtrer et trier les lignes dans les feuilles, mais vous devrez être très soigneux. Les utilisateurs de tableurs risquent d'oublier que leur données ont été filtrées, ce qui conduire à des erreurs. Par exemple, en calculant des sommes, vous pouvez croireque vous avez 100 lignes de données alors qu'en fait il y en a 20 de plus, cachées. </para>
|
|
|
<para
|
|
|
>Si vous voulez travailler sur un petit échantillon de données, &pex; pour l'envoyer à quelqu'un d'autre, vous pouvez le copier et le coller dans une autre feuille et après qu'il l'ait édité, recoller les données éditées dans la base principale. De telles manipulations "manuelles" peuvent amener des pertes de données et causer des erreurs de calcul. </para>
|
|
|
<para
|
|
|
>Pour limiter la <emphasis
|
|
|
>vue des données</emphasis
|
|
|
>, les applications de base de données proposent les <emphasis
|
|
|
>requêtes</emphasis
|
|
|
>, les <emphasis
|
|
|
>formulaires</emphasis
|
|
|
> et les <emphasis
|
|
|
>rapports</emphasis
|
|
|
>. </para>
|
|
|
<para
|
|
|
>Une façon très pratique de limiter la vue est illustrée par la table suivante, version étendue de la table <guilabel
|
|
|
>Personnes</guilabel
|
|
|
> : </para>
|
|
|
|
|
|
<para
|
|
|
><emphasis
|
|
|
>Tables des personnes</emphasis
|
|
|
></para>
|
|
|
<informaltable>
|
|
|
<tgroup cols="6">
|
|
|
<tbody>
|
|
|
<row>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Prénom</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Nom</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Rue</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Numéro</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Ville</emphasis
|
|
|
></entry>
|
|
|
<entry
|
|
|
><emphasis
|
|
|
>Revenus</emphasis
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Joan</entry>
|
|
|
<entry
|
|
|
>Smith</entry>
|
|
|
<entry
|
|
|
>Western Gate</entry>
|
|
|
<entry
|
|
|
>1</entry>
|
|
|
<entry
|
|
|
>Warsaw</entry>
|
|
|
<entry
|
|
|
>2300</entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
>Adam</entry>
|
|
|
<entry
|
|
|
>Willson</entry>
|
|
|
<entry
|
|
|
>Frogs Drive</entry>
|
|
|
<entry
|
|
|
>5</entry>
|
|
|
<entry
|
|
|
>London</entry>
|
|
|
<entry
|
|
|
>1900</entry>
|
|
|
</row>
|
|
|
</tbody>
|
|
|
</tgroup>
|
|
|
</informaltable>
|
|
|
|
|
|
<para
|
|
|
>Supposons que la colonne <guilabel
|
|
|
>Revenus</guilabel
|
|
|
> que l'on vient d'introduire contient des données confidentielles. Comment peut-on partager &pex; les informations pour contacter les personnes avec vos collègues mais sans <emphasis
|
|
|
>révéler leurs revenus</emphasis
|
|
|
> ? C'est possible si vous <emphasis
|
|
|
>partagez uniquement une requête et non la table complète</emphasis
|
|
|
>. La requête peut sélectionner toutes les colonnes à part la colonne <guilabel
|
|
|
>Revenus</guilabel
|
|
|
>. Dans une base de données, une telle requête est souvent appelée une <guilabel
|
|
|
>vue</guilabel
|
|
|
>. </para>
|
|
|
|
|
|
</sect3>
|
|
|
|
|
|
<sect3 id="performance-and-capacity">
|
|
|
<title
|
|
|
>Performances et capacités</title>
|
|
|
<para
|
|
|
>Votre ordinateur est probablement assez rapide, mais vous verrez facilement que cela ne suffit pas pour des feuilles de calcul grandes et lentes. Leur faible efficacité est tout d'abord due au manque d'index accélérant le processus de recherche de données (les databases les proposent). De plus, si vous vous servez de systèmes comme le presse-papier de votre système d'exploitation, même la copie de données peut causer des problèmes au bout d'un moment. </para>
|
|
|
<para
|
|
|
>les feuilles de calcul contenant de grands ensembles de données peuvent prendre énormément de temps à s'ouvrir. Un tableur charge beaucoup de données dans la mémoire de l'ordinateur au cours de l'ouverture. La plus grande partie de ces données chargées en mémoire est probablement inutile pour vous à cet instant. Au contraire, les bases de données ne vont chercher les données sur le lieu de stockage de l'ordinateur que si cela est nécessaire. </para>
|
|
|
<para
|
|
|
>Dans la plupart des cas, vous n'avez pas à vous soucier de la manière dont la base de données stocke ses données. Cela signifie que contrairement aux tableurs, les bases de données ne se préoccupent pas de : </para>
|
|
|
<itemizedlist>
|
|
|
<listitem
|
|
|
><para
|
|
|
>L'ordre des lignes, puisque vous pouvez les ordonner selon vos besoins. De plus, vous pouvez visualiser les mêmes données dans différents ordres avec différentes vues. </para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
>Cela vaut aussi pour les colonnes (champs) de la table. </para
|
|
|
></listitem>
|
|
|
</itemizedlist>
|
|
|
|
|
|
<para
|
|
|
>Combinées avec <link linkend="data-limiting"
|
|
|
>la limitation de la vue des données</link
|
|
|
> décrite dans le paragraphe précédent, ces qualités constituent les avantages des bases de données </para>
|
|
|
|
|
|
</sect3>
|
|
|
|
|
|
<sect3 id="convenient-data-entry">
|
|
|
<title
|
|
|
>Entrée des données</title>
|
|
|
<para
|
|
|
>les plus récentes des applications pour créer des feuilles de calculs vous permettent de concevoir des formulaires d'entrée de données. De tels formulaires sont très utiles si vos données ne peuvent pas être affichées de manière convenable en mode tableau, &pex; si le texte occupe de trop nombreuses lignes ou s'il y a trop de colonnes pour les afficher toutes à l'écran. </para>
|
|
|
<para
|
|
|
>Dans ces situations, la façon même dont les tableurs fonctionnent est problématiques. Les champs pour l'entrée des données sont placés de manière imprécise dans la feuille de calcul et très souvent ne sont pas protégés contre les interventions de l'utilisateur (intentionelles ou accidentelles). </para>
|
|
|
</sect3>
|
|
|
|
|
|
<sect3 id="reports">
|
|
|
<title
|
|
|
>Rapports</title>
|
|
|
<para
|
|
|
>Les bases de données permettent de choisir, grouper et sommer les données sous la forme de <emphasis
|
|
|
>rapports</emphasis
|
|
|
>. Les feuilles de calcul sont le plus souvent éditées sous la forme de petites tables sans contrôle sur les divisions en pages et la mise en page des champs. </para>
|
|
|
</sect3>
|
|
|
|
|
|
<sect3 id="programming">
|
|
|
<title
|
|
|
>Programmation</title>
|
|
|
<para
|
|
|
>Les applications permettant de créer des bases de données comportent souvent des langages de programmation complets. Les tableurs les plus récents ont aussi cette capacité mais les actions se résument à la modification des champs de la feuille de calcul et à copier des données, sans se soucier des règles de pertinence et d'intégrité mentionnées dans les paragraphes précédents. </para>
|
|
|
<para
|
|
|
>Dans un tableur, on manipule le plus souvent les données grâce à une interface graphique, qui peut causer des ralentissements dans ce traitement. Les bases de données sont capables de travailler un arrière-plan, sans nécessiter d'interface graphique. </para>
|
|
|
</sect3>
|
|
|
|
|
|
<sect3 id="multiuse">
|
|
|
<title
|
|
|
>Utilisation simultanée</title>
|
|
|
<para
|
|
|
>La manipulation par plusieurs utilisateurs en même temps d'une même feuille de données paraît difficile à imaginer. Même si c'est techniquement possible dans les tableurs les plus récents, cela exige énormément de discipline et de connaissances de la part des utilisateurs, ce qu'on ne peut jamais garantir. </para>
|
|
|
<para
|
|
|
>Un méthode classique de partage de données enregistrées dans un tableur est d'envoyer tout le fichier (habituellement par courrier électronique) ou distribuer le fichier sur un réseau. Cette façon de travailler n'est pas efficace pour de grands groupes d'utilisateurs – les données dont on a besoin à un instant donnée sont peut être verouillées par une autre personne. </para>
|
|
|
<para
|
|
|
>Au contraire, les concepteurs des bases de données pensaient principalement à un accès distribué entre plusieurs utilisateurs. Même les versions les plus simples peuvent verouiller les données </para>
|
|
|
</sect3>
|
|
|
|
|
|
<sect3 id="security">
|
|
|
<title
|
|
|
>Sécurité</title>
|
|
|
<para
|
|
|
>Sécuriser une feuille de calcul ou une de ses parties par un mot de passe n'a qu'une valeur symbolique. Après avoir fourni le fichier sur un réseau, toutes les personnes capables de copier le fichier peuvent essayer de casser la protection. Dans certains cas, c'est même relativement facile car le mot de passe est stocké dans le même fichier que la feuille de calcul. </para>
|
|
|
<para
|
|
|
>Les fonctionnalités permettant de restreindre l'édition ou la copie d'une feuille de calcul ou d'une partie d'une feuille sont aussi faciles à contourner. </para>
|
|
|
<para
|
|
|
>Les bases de données (à part celle enregistrées sur un fichier au lieu d'un serveur) n'ont pas besoin d'être disponible dans un seul fichier. On y accède par un réseau informatique, le plus souvent en fournissant un nom d'utilisateur et un mot de passe. On n'a donc accès qu'aux zones (tables, formulaires, ou même seulement certaines lignes et colonnes) qui ont été assignées en choisissant des droits d'accès appropriés. </para>
|
|
|
<para
|
|
|
>Les droits d'accès peuvent affecter la capacité d'éditer les données ou de les lire. Si une donnée n'est pas accessible, elle ne sera même pas envoyée à l'ordinateur donc ce ne sera pas possible d'en faire une copie aussi facilement qu'avec une feuille de calcul. </para>
|
|
|
|
|
|
</sect3>
|
|
|
</sect2>
|
|
|
</sect1>
|
|
|
|
|
|
<sect1 id="database-design">
|
|
|
<title
|
|
|
>Conception d'une base de données</title>
|
|
|
<para
|
|
|
>la conception d'une base de donnée nécessite une étude approfondie. La modification de l'organisation de la table <guilabel
|
|
|
>Contacts</guilabel
|
|
|
> proposée dans la section 1.2 peut provoquer des problèmes lorsque la table est pleine de données. Il est facile de renommer un champ mais diviser le champ <guilabel
|
|
|
>Adresse</guilabel
|
|
|
> en plusieurs champs distincts demande un travail long et pénible. </para>
|
|
|
<para
|
|
|
>Pour éviter une telle situation, <emphasis
|
|
|
>planifiez soigneusement votre projet de base de données</emphasis
|
|
|
> avant de la créer sur votre ordinateur. Ainsi, en y consacrant un peu de temps au début, vous allez probablement gagner du temps lors de l'utilisation quotidienne. </para>
|
|
|
</sect1>
|
|
|
|
|
|
<sect1 id="who-needs-a-database">
|
|
|
<title
|
|
|
>Qui a besoin des bases de données ?</title>
|
|
|
<itemizedlist>
|
|
|
<title
|
|
|
>Continuez à utiliser un tableur si :</title>
|
|
|
<listitem
|
|
|
><para
|
|
|
>Vos besoins sont limités et vos données ne vont jamais augmenter de manière importante (pouvez-vous réellement prédire cela maintenant ?) </para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
>Vous êtes incapable de maîtriser les méthodes de construction de bases de données. Vous pouvez cependant demander à quelqu'un d'autre ou envisager d'utiliser un outil plus simple. </para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
>Vous utilisez des feuilles de calcul compliquées et vous n'avez pas le temps et l'argent pour passer à des bases de données. Réfléchissez ou demandez à quelqu'un pour savoir si cela ne vous conduit pas dans une impasse. Ne comptez pas sur des outils miracles qui serait capables de transformer votre feuille de calcul (si bien faite soit elle) en une base de données. </para
|
|
|
></listitem>
|
|
|
</itemizedlist>
|
|
|
|
|
|
<itemizedlist>
|
|
|
<title
|
|
|
>Envisagez d'utiliser des bases de données si :</title>
|
|
|
<listitem
|
|
|
><para
|
|
|
>Votre ensemble de données grossit chaque semaine.</para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
>Vous créez souvent de nouvelles feuilles de calcul et copiez des données dedans, et vous trouvez ce travail de plus en plus fastidieux. Dans ce cas, l'effort de passer aux bases de données peut rapidement être rentabilisé. </para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
>Vous créez des rapports et des comptes-rendus pour lesquels les tables d'une feuille ne sont pas adaptées. Vous pouvez alors considérer l'utilisation d'une base de données avec des formulaires. </para
|
|
|
></listitem>
|
|
|
</itemizedlist>
|
|
|
</sect1>
|
|
|
|
|
|
<sect1 id="database-software">
|
|
|
<title
|
|
|
>Logiciels de création de base de données</title>
|
|
|
<para
|
|
|
>Pour l'instant, vous avez appris les caractéristiques générales des bases de données sans rentrer dans le détail concernant les applications pour les concevoir. </para>
|
|
|
<para
|
|
|
>Les premières bases de données ont été construites en même temps que les énormes ordinateurs "mainframes" IBM System/360, dans les années 1960. Ce n'était pas encore l'époque des PC, donc ces bases de données demandaient un personnel hautement spécialisé. Bien que le matériel de ces anciens ordinateurs soit peu fiable, qu'ils étaient bien plus lent et avaient moins de capacité de stockage, une possibilité offerte par les bases de données est encore maintenant très intéressante : l'accès aux données par de nombreux utilisateurs en passant par un réseau. </para>
|
|
|
<para
|
|
|
>Dans les années 1970, les chercheurs ont créé la théorie des bases de données relationnelles (des termes comme <firstterm
|
|
|
>table</firstterm
|
|
|
>, <firstterm
|
|
|
>enregistrement</firstterm
|
|
|
>, <firstterm
|
|
|
>colonne (champ)</firstterm
|
|
|
>, <firstterm
|
|
|
>relation</firstterm
|
|
|
> et de nombreux autres). En se basant sur cette théorie, les bases de données d'IBM DB2 et Oracle ont été créées. Ces bases de données sont développées et utilisées encore maintenant. Vers la fin des années 1970, les premiers PC ont été fabriqués. Leurs utilisateurs ont pu (progressivement) utiliser de nombreux types d'applications, y compris celles destinées à la construction de bases de données. </para>
|
|
|
<para
|
|
|
>Quand on en arrive à de grandes bases de données d'entreprises, la situation n'a pas changée. Elles nécessitent encore des ordinateurs puissants ou des assemblements d'ordinateurs appelée <firstterm
|
|
|
>grappes</firstterm
|
|
|
>. Ce sujet est cependant hors de portée de ce manuel. </para>
|
|
|
<para
|
|
|
>Dans le secteur des bases de données « accessibles » pour PC, avec une interface graphique, vous pouvez choisir parmi les suivantes : </para>
|
|
|
|
|
|
<itemizedlist>
|
|
|
<listitem
|
|
|
><para
|
|
|
><ulink url="http://www.dbase.com/"
|
|
|
>DBase</ulink
|
|
|
> – un outil pour des opérations sur des bases de données pour DOS, populaire dans les années 1980. On utilise encore des fichiers au format DBase dans certains cas spécifiques, pour leur simplicité. </para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><ulink url="http://msdn.microsoft.com/vfoxpro/productinfo/overview/"
|
|
|
>FoxPro</ulink
|
|
|
> – une application similaire à DBase (début des année 1990). Après que Microsoft ait pris le contrôle, les interfaces utilisateurs graphiques ont été introduites et il est par conséquent utilisé pour créer des bases de données sur PC. Ce produit est toujours disponibles, bien qu'il semble maintenant un peu dépassé. </para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><ulink url="http://office.microsoft.com/access/"
|
|
|
>Microsoft Access</ulink
|
|
|
> – une application de bases de données (organisation des données et conception de l'interface utilisateur) avec de nombreuses simplifications, donc adaptée aux débutants, conçue à la fin des années 1980, basée sur une architecture 16 bit. Ce produit est encore offert et très utilisé, particulièrement par de petites sociétés, pour qui l'efficacité et les exigeances de gestion multiutilisateur ne sont pas très importantes. </para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><ulink url="http://www.filemaker.com/"
|
|
|
>FileMaker</ulink
|
|
|
> – une application populaire, similaire à MS Access en simplicité, fonctionnant sous Windows et Macintosh, proposée depuis 1985. </para
|
|
|
></listitem>
|
|
|
<listitem
|
|
|
><para
|
|
|
><ulink url="http://www.kexi.pl/"
|
|
|
>&kexi;</ulink
|
|
|
> – une application multi plate-forme (Unix/Linux, Windows, Mac OS X) développée depuis 2003 selon les principes du logiciel libre, faisant partie du projet <ulink url="http://www.kde.org/"
|
|
|
>K Desktop Environment</ulink
|
|
|
>, &cad; un environnement graphique pour les systèmes Unix/Linux. L'entreprise OpenOffice Pologne est un contributeur important au développement de &kexi;. </para
|
|
|
></listitem>
|
|
|
</itemizedlist>
|
|
|
|
|
|
</sect1>
|
|
|
|
|
|
</appendix>
|
