1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
| package dbManagement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
/**
*
* Classe permettant la manipulation de HSQLDB.
*
* @author Antoine Neveux
*/
public class DbManager {
private Connection dbConnection;
public DbManager() {
}
public DbManager(Connection dbCon) {
this.dbConnection = dbCon;
}
/**
* Méthode permettant de se connecter à une base de données
*
* @pre Aucune connexion en cours sur la base
* @post La connexion est établie si il n'y a pas eu d'exception attrapée.
*/
public void dbConnect() {
try {
// On charge le driver JDBC fourni par HSQLDB
Class.forName("org.hsqldb.jdbcDriver").newInstance();
// On récupère la connexion à la base HSQLDB choisie, ici
// "database".
this.dbConnection = DriverManager.getConnection(
"jdbc:hsqldb:file:database", "sa", "");
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* Méthode permettant de se déconnecter d'une base de données
*
* @pre Il faut être connecté à la base de données
* @post La connexion est fermée, et dans le cas d'HSQLDB, la base est
* enregistrée sur le disque dur.
*/
public void dbDisconnect() {
try {
// Un objet Statement permet d'exécuter des requêtes SQL.
Statement statement = this.dbConnection.createStatement();
// On exécute la requête "SHUTDOWN", pour signifier à HSQLDB que
// l'on se déconnecte.
statement.execute("SHUTDOWN");
// On oublie pas de fermer la requête
statement.close();
// Et de fermer la connexion.
this.dbConnection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* Méthode permettant la création d'une table dans la base de données.
*
* @param sqlQuery
* La requête SQL permettant de créer une table dans la base de
* données.
*
* @pre sqlQuery est une requête SQL qui permet la création d'une table dans
* la base de données, et sa syntaxe est correcte.
* @pre La connexion à la base de données est établie
* @post La table est créée dans la base de données
*/
public void createTable(String sqlQuery) {
try {
Statement statement = this.dbConnection.createStatement();
// Dans cet exemple, pour faciliter la compréhension du code, la
// procédure permettant la création d'une table est en fait
// une simple exécution de requête. La requête SQL pour créer la
// table ne sera donc pas gérée dans cette procédure.
statement.executeUpdate(sqlQuery);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* Méthode permettant la suppression d'une table de la base de données.
*
* @param tableName
* est le nom de la table à supprimer de la base de données
*
* @pre tableName est le nom de la table à supprimer de la base de données
* @pre La connexion à la base de données est établie
* @post La table est supprimée
*/
public void dropTable(String tableName) {
try {
Statement statement = this.dbConnection.createStatement();
// On exécute simplement la requête "DROP TABLE " suivie du nom de
// la table à supprimer. Toutes les données contenues dans la table
// sont supprimées également.
statement.executeUpdate("DROP TABLE " + tableName);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* Méthode permettant l'insertion de données dans une table.
*
* @param sqlQuery
* est une requête permettant l'insertion de données dans une
* table
*
* @pre sqlQuery est une requête permettant l'insertion de données dans une
* table
* @pre La connexion à la base de données est établie
* @post L'enregistrement est ajouté
*/
public void insertValues(String sqlQuery) {
try {
Statement statement = this.dbConnection.createStatement();
statement.executeUpdate(sqlQuery);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* Méthode permettant l'insertion de données dans la table Personne
*
* @param pName
* est le nom de la personne à enregistrer
* @param pSurname
* est le prénom de la personne à enregistrer
*
* Pour cet exemple, nous supposerons que le champ ID de la table
* PERSONNE est un identificateur unique auto-incrémenté, Nous
* n'avons donc pas besoin de nous occuper de cette colonne de la
* table.
*
* @pre La table PERSONNE existe, et est correctement formatée
* @pre pName est le nom de la personne à enregistrer, et fait moins de 255
* caractères
* @pre pSurname est le prénom de la personne à enregistrer, et fait moins
* de 255 caractères
* @pre La Connexion à la base de données est établie
* @post L'enregistrement est ajouté dans la table PERSONNE
*/
public void insertValuesIntoPersonne(String pName, String pSurname) {
try {
Statement statement = this.dbConnection.createStatement();
// Cette fois, la requête d'insertion dans la base de données est
// écrite directement dans le code, et on utilise les
// paramètres de la procédure pour insérer les valeurs dans la
// table.
statement
.executeUpdate("INSERT INTO PERSONNE (NOM, PRENOM) VALUES ('"
+ pName + "','" + pSurname + "')");
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* Méthode permettant la suppression d'un enregistrement de la base de
* données.
*
* @param tableName
* est le nom de la table de la base de données dans laquelle
* nous supprimerons un enregistrement
* @param id
* est l'identifiant unique permettant d'identifier
* l'enregistrement à supprimer
*
* Pour cet exemple, nous supposerons que l'identifiant unique de
* la table utilisé se nomme "ID".
*
* @pre tableName est le nom de la table où se trouve l'enregistrement à
* supprimer, et cette table existe.
* @pre id est l'identifiant unique de l'enregistrement à supprimer
* @pre La connexion à la base de données est établie
* @post L'enregistrement est supprimé de la table
*/
public void deleteFrom(String tableName, String id) {
try {
Statement statement = this.dbConnection.createStatement();
// On utilise une requête DELETE, en supposant que le champ ID
// existe dans la table choisie.
statement.executeUpdate("DELETE FROM " + tableName + " WHERE ID='"
+ id + "'");
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* Méthode permettant d'afficher le contenu d'une table sans connaître sa
* structure.
*
* @param tableName
* est le nom de la table à afficher
*
* @pre tableName est le nom de la table à afficher. Cette table existe, et
* elle est correctement formatée
* @pre La connexion à la base de données est établie
* @post Le contenu de la table est affiché à l'écran
*/
public void printTable(String tableName) {
try {
Statement statement = this.dbConnection.createStatement();
// Nous utiliserons ici un ResultSet, qui est un ensemble
// d'enregistrements qui représente le résutat d'une requête SQL
// sur la base de données. Le format du résultat obtenu peut être
// parcouru facilement, puisqu'il se présente comme un tableau
// à deux dimensions, ou chaque ligne représente un enregistrement
// de la base de données.
ResultSet result = statement.executeQuery("SELECT * FROM "
+ tableName);
// Il faut maintenant parcourir et afficher le ResultSet.
// Attention, dans cet exemple, nous partirons du principe que nous
// ne connaissons pas le nom des différentes colonnes,
// Afin de développer une fonction assez générique. La syntaxe qui
// suit est donc un peu particulière.
ResultSetMetaData resultMeta = result.getMetaData();
// On récupère le nombre de colonnes :
int nbColumns = resultMeta.getColumnCount();
// Le code qui suit n'est pas réellement propre, mais suffira pour
// l'exemple. Encore une fois, le but est de comprendre le principe,
// pas de traiter un cas particulier. Vous adapterez le code à votre
// propre projet.
int i;
Object o;
// Grâce à cette boucle, nous allons pouvoir traiter tous les
// enregistrements récupérés.
while (result.next()) {
// Grâce à cette boucle, nous allons traiter chaque champ de
// l'enregistement courant.
for (i = 0; i < nbColumns; i++) {
// On récupère sous forme d'objet l'élément au champ i
o = result.getObject(i + 1);
// Puis on affiche la colonne récupérée, suivie d'une
// tabulation, pour la lisibilité de l'affichage
System.out.print(o.toString() + "\t");
}
// On effectue ensuite un saut à la ligne, pour l'affichage de
// l'enregistrement suivant
System.out.println();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* Méthode permettant la mise à jour d'un enregistrement dans une table de
* la base de données.
*
* @param tableName
* est le nom de la table dans lequel se situe l'enregistrement à
* mettre à jour.
* @param id
* est l'identifiant unique permettant d'identifier
* l'enregistrement à mettre à jour.
* @param columnName
* est le nom du champ à mettre à jour dans l'enregistrement.
* @param newValue
* est la nouvelle valeur du champ.
*
* @pre tableName est le nom de la table dans lequel se situe
* l'enregistrement à mettre à jour. Cette table existe, et est
* correctement formatée.
* @pre id est l'identifiant unique de l'enregistrement à modifier
* @pre columnName est le nom de la colonne à mettre à jour. Ce champ
* existe.
* @pre newValue est la nouvelle valeur du champ, et elle respecte les
* prérequis de ce champ (type, taille, etc.)
* @pre La connexion à la base de données est établie
* @post L'enregistrement est modifié
*/
public void updateValues(String tableName, String id, String columnName,
String newValue) {
try {
Statement statement = this.dbConnection.createStatement();
statement.executeUpdate("UPDATE " + tableName + " SET "
+ columnName + " = '" + newValue + "' WHERE ID = '" + id
+ "'");
} catch (SQLException e) {
e.printStackTrace();
}
}
} |
