| 4.0
Configurer vos Tables
Tout d'abord, nous
créerons les tables pour notre exemple de base de données.
Cette table CAFE, contient les informations essentielles concernant les
cafés vendus chez The Coffee Break, incluant le nom du café,
son prix, le nombre de livres vendues dans la semaine courante, et le
nombre de livres vendues jusqu'à maintenant. La table CAFE, que
nous décrirons plus en détails plus tard, est la suivante
:
| NOM_CAFE |
FO_ID |
PRIX |
VENTES |
TOTAL |
| Colombian |
101 |
7.99 |
0 |
0 |
| French_Roast
|
49 |
8.99 |
0 |
0 |
| Espresso |
150 |
9.99 |
0 |
0 |
| Colombian_Decaf
|
101 |
8.99 |
0 |
0 |
| French_Roast_Decaf |
49 |
9.99 |
0 |
0 |
La colonne qui contient
le nom du café est NOM_CAFE, elle supporte des valeurs de type
VARCHAR et a un maximum de 32 caractères de long. Comme nous utiliserons
un nom différent pour chaque type de café vendu, le nom
identifiera un café de façon unique, et pourra donc servir
de clé primaire à notre table. La seconde colonne, FO_ID,
contient un nombre qui identifie le fournisseur de café, cette
variable SQL est de type INTEGER. La troisième colonne, appelée
PRIX, contient des valeurs FLOAT, car nous avons besoin de valeurs supportants
le point décimal. (Notez bien que cette valeur monétaire
devrait être normalement conservée dans une variable SQL
DECIMAL ou NUMERIC, mais, pour éviter les incompatibilités
avec les anciennes versions de JDBC, nous utiliserons le type FLOAT (plus
standard.). La colonne appelée VENTES contient des valeurs SQL
de type INTEGER, et indique le nombre de livres de café vendues
durant la semaine. La dernière colonne, TOTAL, contient un INTEGER
SQL qui donne le nombre de livres de café vendues jusqu'à
maintenant.
FOURNISSEURS, la seconde
table de notre base de données, donne des informations pour chaque
fournisseur :
| FO_ID |
NOM_FO |
RUE |
VILLE |
ETAT |
CODE_POSTALE |
| 101 |
Acme,
Inc |
99
Market Street |
GroundVille |
CA |
95199 |
| 49 |
Superior
Coffee |
1
Party Place |
Mendocino |
CA |
95460 |
| 150 |
The
High Ground |
100
Coffee Lane |
Meadows |
CA |
93966 |
Les tables CAFE et
FOURNISSEURS contiennent toutes deux la colonne FO_ID, cela veux dire
que ces deux tables peuvent être utilisées dans une instruction
SELECT pour prendre l'information basée sur ces deux tables. La
colonne FO_ID est la clé primaire dans la table FOURNISSEURS, elle
identifie de façon unique chacun des fournisseurs de café.
Dans la table CAFE, FO_ID est appelée une clé étrangère.(Vous
pouvez vous imaginez que la clé étrangère est étrangère
dans le sens qu'elle est importée d'une autre table.) Notez que
chacun des nombres dans FO_ID apparaît une seule fois dans la table
FOURNISSEURS; il faut pour cela qu'elle soit clé primaire. Dans
la table CAFE, ou cette colonne est clé étrangère,
cela démontre qu'un fournisseur peu vendre plusieurs types de café.
Plus tard dans le chapitre, nous verrons un exemple qui montre comment
utiliser une clé primaire et une clé étrangère
dans une instruction SELECT.
L'instruction SQL
qui suit crée la table CAFE. Les entrées entre les parenthèses
sont le nom de chacune des colonnes suivit d'un espace puis du type de
données que la colonne peut recevoir. Une virgule sépare
chacune des colonnes les unes des autres. Le type VARCHAR est créer
avec une longueur maximum de 32 caractères.
CREATE TABLE COFFEES
(COF_NAME VARCHAR(32),
SUP_ID INTEGER,
PRICE FLOAT,
SALES INTEGER,
TOTAL INTEGER)
Ce code ne se termine
pas par une fin d'instruction car il peut varier d'un SGBD à un
autre. Par exemple, Oracle utilise un point virgule (;) pour mettre fin
à une instruction, Sybase utilise le mot go. Le pilote que vous
utilisez apportera automatiquement le symbole qui mettra fin à
l'instruction, et vous n'aurez pas besoin de l'inclure dans votre code
JDBC.
Une autre chose à
remarquer au sujet de l'instruction SQL dans sa forme. Dans l'instruction
CREATE TABLE, les mots clés sont mis en lettres capitales, et chacun
des items sont sur une ligne séparée. SQL ne nécessite
pas de telles arrangements, mais ces conventions les rendent plus facile
à lire. Le standard d'SQL est que les mots clés ne regardent
pas la case, donc, par exemple, l'instruction SELECT qui suit peut être
écrite de différentes façons :
SELECT Nom, Prenom
FROM Employees
WHERE Nom LIKE "Washington"
select Nom, Prenom from Employees
where
Nom like "Washington"
Les chaînes
de caractères par contre, sont sensibles à la casse : dans
le nom " Washington, " "W" doit être en lettre
capitale et le reste en minuscules.
Ces spécifications
peuvent varier d'un SGBD à un autre quand il s'agit d'identifier
des noms. Par exemple, certain SGBD demandent que les colonnes et les
tables soient données exactement telles qu'elles ont été
crées dans l'instruction CREATE TABLE, quand d'autres non. Par
sécurité, nous utilisons les identifiants tel que CAFE et
FOURNISSEURS en lettres majuscules car c'est ainsi que nous les avons
crées.
Donc nous avons écrit
l'instruction SQL pour créer la table CAFE. Maintenant, mettons
le entre guillemet (pour en faire une chaîne de caractères)
et assignons ce String à une variable creerTableCafe que nous utiliserons
plus tard dans notre code JDBC. Tel que montré précédemment,
les SGBD se fichent de savoir si l'instruction qui leurs est donné
se fait sur plusieurs lignes, mais dans le langage de programmation Java,
un objet String qui s'étend sur plus d'une ligne ne compilera pas.
Par conséquent, quand vous attribuerez une chaîne de caractères,
vous aurez besoin d'inclure chaques lignes entre guillemet et d'utiliser
le signe plus (+) pour concaténer le tout.
String creerTableCafe = "CREATE
TABLE CAFE" +
"(NOM_CAFE VARCHAR(32), FO_ID INTEGER, PRIX FLOAT, " +
"VENTES INTEGER, TOTAL INTEGER)";
Le type de données
que nous avons utilisé dans notre CREATE TABLE est le type SQL
(aussi appelé type JDBC) générique qui est défini
dans java.sql.Types. Les SGBD utilisent généralement ces
types standards, donc quand sera venu le temps d'essayer certaines applications
JDBC, vous aurez juste à utiliser l'application CreerCafe.java,
qui utilise l'instruction CREATE TABLE.
Avant de lancer n'importe
quelle application, nous allons traverser des bases de JDBC.
4.1 Créer
une instruction JDBC
Un objet Statement est ce que votre instruction SQL envoie vers le SGBD.
Vous créerez simplement un objet Statement puis, l'exécuterez,
lui fournissant la méthode d'exécution appropriée
avec l'instruction SQL que vous voulez envoyer.Pour
une instruction SELECT, la méthode à utiliser est executeQuery.
Pour les instructions visant à créer ou modifier des tables,
la méthode est executeUpdate.
Vous devez avoir l'instance
d'une connexion active pour créer un objet Statement. Dans l'exemple
suivant, nous utilisons notre objet Connection conn, pour créer
l'objet Statement stmt :
Statement
stmt = conn.createStatement();
A ce niveau, stmt
existe, mais il n'a aucune instruction SQL à passer au SGBD. Nous
devrons la fournir dans la méthode que nous utiliserons pour exécuter
stmt. Par exemple, dans le bout de code suivant, nous proposons executeUpdate
avec l'instruction SQL :
stmt.executeUpdate(("CREATE
TABLE CAFE(NOM_CAFE VARCHAR(32),FO_ID
INTEGER,"+ "PRIX FLOAT, VENTES INTEGER, TOTAL INTEGER)"));
Si nous avons fait de l'instruction SQL un string et que nous l'avons
assigné à la variable creerTableCafe, nous pouvons écrire
le code comme il suit :
stmt.executeUpdate(creerTableCafe);
4.2 Executer une
instruction
Nous avons utilisé
la méthode executeUpdate car l'instruction SQL contenue dans creerTableCafe
est une DDL (Data Definition Language). Les instructions consistants à
créer des tables, modifier des tables ou effacer des tables sont
des exemples d'instructions DDL et sont exécuter avec la méthode
executeUpdate. La méthode executeUpdate est utilisée pour
exécuter les instruction SQL qui mettent à jour une table.
En pratique, executeUpdate est utilisé le plus souvent pour mettre
des tables à jour plutôt que pour les créer, car une
table ne peut être créer qu'une seule fois, mais mise à
jour plusieurs fois.
4.3 L'entrée
de donnée dans une table
Nous vous avons montré
comment créer la table CAFE en spécifiant le nom des colonnes
et le type de données qu'elles contiennent, mais cela ne fait que
construire la structure de la table. Elle ne contient aucune donnée.
Nous allons entrer nos données dans une table une ligne à
la fois, fournissant l'information à stocker dans chacune des colonnes
de cette ligne. Notez que les valeurs insérées dans les
colonnes doivent être dans le même ordre que les colonnes
à leur création.
Le code suivant insère
une ligne de données, Colombian dans la colonne NOM_CAFE, 101 dans
FO_ID, 7.99 dans PRIX, 0 dans VENTES et 0 dans TOTAL.(The Coffee Break
vient juste de commencer, c'est pourquoi certaines valeurs sont misent
à 0.). Comme nous l'avons fait pour créer des tables, nous
allons déclarer un objet Statement, et l'exécuter en utilisant
la méthode executeUpdate.
Portez attention qu'il
faut un espace entre CAFE et VALUES. Cet espace doit être entre
les guillemets, et peut être insérer après CAFE ou
avant VALUES, sans cet espace, l'instruction serait erronée : "
INSERT INTO CAFEVALUES . . ." , donc le SGBD cherchera la table CAFEVALUES.
Statement stmt = conn.createStatement();
stmt.executeUpdate(
"INSERT INTO CAFE VALUES ('Colombian', 101, 7.99, 0, 0)");
Le code qui suit insère
une deuxième ligne dans la table CAFE. Nous réutilisons
l'objet Statement stmt plutôt que d'en créer un nouveau pour
chaque exécution.
stmt.executeUpdate("INSERT
INTO CAFE" +
"VALUES ('French_Roast', 49, 8.99, 0, 0)");
Les valeurs pour les
lignes restantes peuvent être insérées comme il suit
:
stmt.executeUpdate("INSERT
INTO CAFE" +
"VALUES ('Espresso', 150, 9.99, 0, 0)");
stmt.executeUpdate("INSERT INTO CAFE" +
"VALUES ('Colombian_Decaf', 101, 8.99, 0, 0)");
stmt.executeUpdate("INSERT INTO CAFE" +
"VALUES ('French_Roast_Decaf', 49, 9.99, 0, 0)");
4.4 Accéder
aux données d'une table.
Maintenant que la
table CAFE contient des valeurs, nous pouvons écrire une instruction
SELECT pour avoir accès à ces valeurs. L'étoile (*)
dans l'instruction SQL qui suit indique que toutes les colonnes devront
être sélectionnées. N'ayant pas de clause WHERE définissant
la restriction, nous effectuons la sélection sur toute la table.
SELECT
* FROM CAFE
Le résultat,
désignant la table entière, devrait ressembler à
ceci :
| NOM_CAFE |
FO_ID |
PRIX |
VENTES |
TOTAL |
| Colombian |
101 |
7.99 |
0 |
0 |
| French_Roast |
49 |
8.99 |
0 |
0 |
| Espresso |
150 |
9.99 |
0 |
0 |
| Colombian_Decaf |
101 |
8.99 |
0 |
0 |
| French_Roast_Decaf |
49 |
9.99 |
0 |
0 |
Le résultat
ci-dessus est ce que vous devriez voir sur votre terminal si vous avez
entré la requêtes SQL directement dans le système
de la base de données. Lorsque nous accéderons à
une base de données au travers d'une application Java, nous aurons
besoin de prendre les résultats, pour que nous puissions les utiliser.
Nous verrons comment faire tout ça dans la prochaine section.
Précédent
Suivant
|