SQLdb Tutorial2/fr: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Vue d'ensemble
2	2
3	3		Si vous avez suivi le [[SQLdb Tutorial1/fr\|Tutoriel SQLdb 1]], vous avez un grille basique montrant des informations provenant de la base de données. Maintenant que votre application marche, vous pouvez y ajouter certains raffinements.
4	4
5	5		### Connexion dynamique à une base de données
6	6
7	7		Jusqu'à maintenant, nous utilisions des nom de base de données, emplacement de base de données, nom d'utilisateur et mot de passe fixé pour simplifier. Comme indiqué, des applications "réelles" laissent normalement les utilisateurs spécifier leur propres nom d'utilisateur et mot de passe.
8	8
9	9		Changeons la fiche de façon à pouvoir les spécifier : ajoutez deux [[TEdit/fr\|TEdits]] depuis l'onglet standard. Mettez leur propriété Name à 'Username' et 'Password'. Définissez la propriété PasswordChar de 'Password' à * (l'astérisque) par sécurité vis à vis de personne qui regarderait par dessus votre épaule.
10	10
11	11		Si vous voulez rendre plus facile (et moins sécurisé, bien sûr) de se connecter, vous pouvez définir la propriété Text de UserName avec un nom d'utilisateur valide de la base de données, tel que SYSDBA. Vous pouvez même définir la propriété Text de Password à une valeur par défaut telle que masterkey, simple pour le test sur une machine de développement si la sécurité n'est pas une préoccupation...
12	12
13	13		Cosmétiquement, l'ajout de quelques étiquettes (Label) pour que les gens sachent ce qu'ils sont censés taper est utile.
14	14
15	15		Aussi pour rendre plus facile la connexion à toute base de données exemple sur tout serveur Firebird/Interbase, nous ajoutons deux zone de texte pour le serveur et le chemin à la base de données. Ajoutons ces deux autres zones de texte et appelons-les ServerName et DatabaseName.
16	16
17	17		Si vous voulez, vous pouvez définir la propriété 'Text' à des valeurs sensibles dans votre situation, p.ex. localhost et `C:\Program Files\Firebird\Firebird_2_5\examples\empbuild\EMPLOYEE.FDB`. Des étiquettes (Labels) pour expliquer ce que doit entrer l'utilisateur peuvent aider aussi.
18	18
19	19		Pour clarifier, nous allons supprimer les informations de connexion de nos composants en conception : Dans le composant [[TSQLConnector/fr\|TSQLConnector]], retirez tout les textes des propriétés UserName, Password, DatabaseName et HostName.
20	20
21	21		Maintenant, finalement, nous avons besoin d'indiquer à notre composant de connexion à la base de données comment se connecter. Cela est uniquement nécessaire au début de l'exécution de l'application. Dans notre cas, le bouton existant 'Button1' est une bonne manière de mettre en place la connexion.
22	22
23	23		Ajoutez le code :
24	24
25	25		``` pascal
26	26		procedure TForm1.Button1Click(Sender: TObject);
27	27		begin
28	28		SQLQuery1.Close;
29	29		//Connection settings for Firebird/Interbase database
30	30		//only needed when we have not yet connected:
31	31		if not DBConnection.Connected then
32	32		begin
33	33		DBConnection.HostName := ServerName.Text;
34	34		DBConnection.DatabaseName := DatabaseName.Text;
35	35		DBConnection.Username := UserName.Text;
36	36		DBConnection.Password := Password.Text;
37	37		// Now we've set up our connection, visually show that
38	38		// changes are not possibly any more
39	39		ServerName.ReadOnly:=true;
40	40		DatabaseName.ReadOnly:=true;
41	41		UserName.ReadOnly:=true;
42	42		Password.ReadOnly:=true;
43	43		end;
44	44		SQLQuery1.SQL.Text:= 'select * from CUSTOMER';
45	45		DBConnection.Connected:= True;
46	46		SQLTransaction1.Active:= True;
47	47		SQLQuery1.Open;
48	48		end;
49	49		```
50	50
51	51		Maintenant exécutez et testez si vous êtes connectés.
52	52
53	53		#### SQLite, autres bases de données
54	54
55	55		Adaptez la propriété Text dans le TEdit comme demandé ; p.ex. `employee.sqlite` pour SQLite.
56	56
57	57		For SQLite, la spécification des HostName, Username et password n'a pas de sens, donc vous pouvez omettre ces TEddits, commentez l'affectation des valeurs correspondantes dans DBConnection dans le code du dessus. Pour FireBird incorporé, forcez en dur le UserName à SYSDBA ; cela ne fera aucun mal si SQLite est utilisé.
58	58
59	59		Le code ressemblera à quelque chose comme cela :
60	60
61	61		``` pascal
62	62		procedure TForm1.Button1Click(Sender: TObject);
63	63		begin
64	64		SQLQuery1.Close;
65	65		//Connection settings for embedded databases
66	66		//only needed when we have not yet connected:
67	67		if not DBConnection.Connected then
68	68		begin
69	69		DBConnection.DatabaseName := DatabaseName.Text;
70	70		DBConnection.UserName := 'SYSDBA'; //Firebird embedded needs this; doesn't harm if using SQLite
71	71		// Now we've set up our connection, visually show that
72	72		// changes are not possibly any more
73	73		DatabaseName.ReadOnly:=true;
74	74		end;
75	75		SQLQuery1.SQL.Text:= 'select * from CUSTOMER';
76	76		DBConnection.Connected:= True;
77	77		SQLTransaction1.Active:= True;
78	78		SQLQuery1.Open;
79	79		end;
80	80		```
81	81
82	82		### Filtrage de données
83	83
84	84		Souvent, une table contient une énorme quantité de données que l'utilisateur ne veut(ou ne doit) pas voir (et cela prend beaucoup de temps à requêter et voyage à travers le réseau). Supposons que seuls les clients des USA devraient être affichés. En conséquence, l'ordre SQL dans 'SQLQuery1' ressemblera à quelque chose comme ceci :
85	85
86	86		``` SQL
87	87		select * from CUSTOMER where COUNTRY = 'USA'
88	88		```
89	89
90	90		... qui devrait être transformé en quelque chose comme cela dans notre code :
91	91
92	92		``` pascal
93	93		SQLQuery1.SQL.Text := 'select * from CUSTOMER where COUNTRY = 'USA'';
94	94		```
95	95
96	96		Il y a deux raisons pour lesquelles nous n'utilisaeraon pas cette ordre dans notre exemple d'application :
97	97
98	98		D'abord il y a un problème avec l'emploi des aapostrophes. Le compilateur interprétera cela l'apostrophe avant USA comme une apostrophe de fermeture (la première apostrophe est devant le SELECT * FROM...), ainsi l'ordre SQL va devenir invalide. Solution : il faut doubler les apostrophes intérieures :
99	99
100	100		``` pascal
101	101		SQLQuery1.SQL.Text := 'select * from CUSTOMER where COUNTRY = ''USA''';
102	102		```
103	103
104	104		Ensuite, raison plus importante dans les faits, nous ignorons probablement ce quelles contraintes l'utilisateur voudra filtrer. Nous ns voulons pas limiter la flexibilité de l'utilisateur.
105	105
106	106		Pour obtenir cette flexibilité, nous changeons en premier notre ordre SQL et remplaçons 'USA' par une marque substitutive (placeholder, un paramètre pour parler SQL) : changez la procédure Button1click et remplacez :
107	107
108	108		``` pascal
109	109		SQLQuery1.SQL.Text := 'select * from CUSTOMER';
110	110		```
111	111
112	112		par :
113	113
114	114		``` pascal
115	115		SQLQuery1.SQL.Text:= 'select * from CUSTOMER where COUNTRY = :COUNTRY';
116	116		```
117	117
118	118		Dasn SQLDB de FPC, le paramètre SQL est marqué par un caractère deux-points (d'autres langages/environnements utilisent une autre convention comme ?). Pour permettre à l'utilisateur d'entrer une valeur pour le filtre, nous plaçons un composant TEdit sur notre fiche. Supprimez a valeur dans la propriété 'Text'. Nous pouvons maintenant prendre le texte entré dans le TEdit et remplir le paramètre SQL COUNTRY en utilisant la propriété 'Params' du TSQLQuery. Ajoutez ce qui suit dans l'instruction précédente :
119	119
120	120		``` pascal
121	121		SQLQuery1.Params.ParamByName('COUNTRY').AsString := Edit1.Text;
122	122		```
123	123
124	124		Le paramètre peut être spécifié par sa position ou son nom. L'utilisation du nom améliorera la lisibilité du code source, et évidemment aide si vous insérez plus de paramètre au milieu des paramètres existants.
125	125
126	126		Nous utilisons '.AsString' pour affecter une valeur chaîne au paramètre ; il y a des affectation de propriété équivalente pour les paramètres entiers, booléens etc.
127	127
128	128		Jusqu'à maintenant, le code nous forçe à utiliser un filtre. Si un utilisateur spécifie une valeur vide dans la zone de saisie, aucun enregistrement ne sera affiché. Ce n'est sans doute pas ce que nous voulons. Testons la valeur vide et construisons la requête en conséquence. Nous devrions nous retrouver avec une procédure comme celle-ci :
129	129
130	130		``` pascal
131	131		procedure TForm1.Button1Click(Sender: TObject);
132	132		begin
133	133		SQLQuery1.Close;
134	134		//Connection settings for Firebird/Interbase database
135	135		//only needed when we have not yet connected:
136	136		if not DBConnection.Connected then
137	137		begin
138	138		DBConnection.HostName := ServerName.Text;
139	139		DBConnection.DatabaseName := DatabaseName.Text;
140	140		DBConnection.Username := UserName.Text;
141	141		DBConnection.Password := Password.Text;
142	142		// Now we've set up our connection, visually show that
143	143		// changes are not possibly any more
144	144		ServerName.ReadOnly:=true;
145	145		DatabaseName.ReadOnly:=true;
146	146		UserName.ReadOnly:=true;
147	147		Password.ReadOnly:=true;
148	148		end;
149	149		// Show all records, or filter if user specified a filter criterium
150	150		if Edit1.Text='' then
151	151		SQLQuery1.SQL.Text := 'select * from CUSTOMER'
152	152		else
153	153		begin
154	154		SQLQuery1.SQL.Text := 'select * from CUSTOMER where COUNTRY = :COUNTRY';
155	155		SQLQuery1.Params.ParamByName('COUNTRY').AsString := Edit1.Text;
156	156		end;
157	157		DBConnection.Connected:= True;
158	158		SQLTransaction1.Active:= True;
159	159		SQLQuery1.Open;
160	160		end;
161	161		```
162	162
163	163		Maintenant vous pouvez jouer un peu avec le filtrage en utilisant Edit1. Si vous entrez un pays qui n'est pas présent dans la base de données, une grille affichée est vide.
164	164
165	165		### Gestion des erreurs
166	166
167	167		L'application devrait tourner mais parfois des problèmes arrivent. Les bases de données, même les bases incorporées, peuvent planter (i.e. quand le serveur de base de données plante, le disque est plein, ou juste provoqué par un bug), laissant l'application en suspens.
168	168
169	169		L'accès à une base de données (tout processus externe, en vrai) devrait donc toujours être intégré dans une construction try ... except et/ou try ... finally. Cela garantit que les erreurs de bases de données sont traitées et que l'utilisateur n'est pas laissé à l'abandon. Une routine rudimentaire pour notre exemple peut ressembler à ceci :
170	170
171	171		``` pascal
172	172		begin
173	173		try
174	174		SQLQuery1.Close;
175	175		...
176	176		SQLQuery1.Open;
177	177		except
178	178		//We could use EDatabaseError which is a general database error, but we're dealing with Firebird/Interbase, so:
179	179		on E: EDatabaseError do
180	180		begin
181	181		MessageDlg('Error','A database error has occurred. Technical error message: ' + E.Message,mtError,[mbOK],0);
182	182		Edit1.Text:='';
183	183		end;
184	184		end;
185	185		end;
186	186		```
187	187
188	188		#### SQLite, PostgreSQL, autres bases de données
189	189
190	190		Vous pouvez soit utiliser la plus générique EDatabaseError, ou, si disponible, votre propre dérivé de EDatabaseError, si vous avez besoin de plus de détail. P.ex. SQLite et le pilote PostgreSQL dans FPC 2.6.1 et antérieur n'ont pas de E*DatabaseError spécialisé; vous devez utiliser EDatabaseError. PostgreSQL sur FPC du tronc (version de développement) a un dérivé EPQDatabaseError.
191	191
192	192		## Edition des données utilisant la grille
193	193
194	194		### Edition
195	195
196	196		Jusqu'à maintenant, si vous essayiez d'éditer des données dans la grille, les modifications ne pourront pas être enregistrés. Ceci parce que le SQLQuery1 n'est pas construit pour envoyer les changements vers la transaction de base de données au bon moment.
197	197
198	198		Nous avons besion de corriger cela et donc de faire le commit de la base de données, ainsi tous les changements seront écrit. Pour ceci, vous devrez utiliser du code comme ceci :
199	199
200	200		``` pascal
201	201		SQLQuery1.ApplyUpdates; //Pass user-generated changes back to database...
202	202		SQLTransaction1.Commit; //... and commit them using the transaction.
203	203		//SQLTransaction1.Active now is false
204	204		```
205	205
206	206		Nous voulons garantir que toutes les éditions (insertions, mises à jour, suppressions) sont écrites dans la base de données :
207	207
208	208		- quand l'utilisateur change le critère de filtrage et presse le bouton poutr interroger la base de données.
209	209		- quand la fiche est fermée.
210	210
211	211		Il est pertinent de faire une procédure séparée pour ceci qui est appelée pour ces deux instances. Allez au code et ajoutez une ligne vide ici :
212	212
213	213		``` pascal
214	214		TForm1 = class(TForm)
215	215		Button1: TButton;
216	216		Datasource1: TDatasource;
217	217		DBGrid1: TDBGrid;
218	218		Edit1: TEdit;
219	219		DBConnection: TIBConnection;
220	220		SQLQuery1: TSQLQuery;
221	221		SQLTransaction1: TSQLTransaction;
222	222		***insert the empty line here**
223	223		procedure Button1click(Sender: TObject);
224	224		procedure Formclose(Sender: TObject; var Closeaction: Tcloseaction);
225	225		private
226	226		```
227	227
228	228		puis tapez :
229	229
230	230		``` pascal
231	231		procedure SaveChanges;
232	232		```
233	233
234	234		pressez shift-ctrl-c (combinaison par défaut) pour laisser la complétion de code créer le corps de la procédure correspondante.
235	235
236	236		Nous avons besoin d'ajouter la gestion d'erreur et contrôler que la transaction est active - souvenez-vous, ce code est aussi appelé quand le bouton est actionné la première fois, quand la transaction n'est pas encore active. Nous obtenons :
237	237
238	238		``` pascal
239	239		procedure Tform1.SaveChanges;
240	240		// Saves edits done by user, if any.
241	241		begin
242	242		try
243	243		if SQLTransaction1.Active then
244	244		// Only if we are within a started transaction;
245	245		// otherwise you get "Operation cannot be performed on an inactive dataset"
246	246		begin
247	247		SQLQuery1.ApplyUpdates; //Pass user-generated changes back to database...
248	248		SQLTransaction1.Commit; //... and commit them using the transaction.
249	249		//SQLTransaction1.Active now is false
250	250		end;
251	251		except
252	252		on E: EDatabaseError do
253	253		begin
254	254		MessageDlg('Error', 'A database error has occurred. Technical error message: ' +
255	255		E.Message, mtError, [mbOK], 0);
256	256		Edit1.Text := '';
257	257		end;
258	258		end;
259	259		end;
260	260		```
261	261
262	262		Maintenant nous avons besoin d'appeler cette procédure aux moments appropriés :
263	263
264	264		``` pascal
265	265		procedure Tform1.Button1click(Sender: TObject);
266	266		begin
267	267		SaveChanges; //Saves changes and commits transaction
268	268		try
269	269		SQLQuery1.Close;
270	270		....
271	271		```
272	272
273	273		et
274	274
275	275		``` pascal
276	276		procedure Tform1.Formclose(Sender: TObject; var Closeaction: Tcloseaction);
277	277		begin
278	278		SaveChanges; //Saves changes and commits transaction
279	279		SQLQuery1.Close;
280	280		....
281	281		```
282	282
283	283		Maintenant testez et voyez si les modifications réalisées dans la grille sont enregistrées dans la base de données.
284	284
285	285		### Masquage de la colonne de clé primaire
286	286
287	287		Souvent, vous ne voulez pas que vos utilisateurs voient les clés primaires auto-incrémentées car elles ne servent qu'à maintenir l'intégrité référentielle. Si les utilisateurs les voient, ils voudront peut-être essayer de modifier les numéros, se fâcher lorsque les chiffres changent, qu'il y ait des lacunes dans les chiffres, etc.
288	288
289	289		Dans notre exemple, CUST_NO est la clé primaire, avec du contenu auto-généré par Firebird en utilisant des triggers et un générateur (séquence). ,Ceci veut dire que vous pouvez insérer un nouvel enregistrement sans spécifier le champ CUST_NO ; Firebird créera la valeur du champ automatiquement.
290	290
291	291		Nous pouvons changer simplement notre propriété SQLQuery1.SQL.Text pour ne pas inclure CUST_NO, mais cela amènera à des problèmes lors de l'édition des données - la clé primaire est demandée pour identifier l'enregistement/ ligne en question.
292	292
293	293		Donc utilisons une astuce pour récupérer toutes les colonnes/champs mais empêcher la grille d'afficher le premier champ, CUST_NO : dans la procédure Button1Click, ajoutez le code comme cela :
294	294
295	295		``` pascal
296	296		procedure Tform1.Button1click(Sender: TObject);
297	297		begin
298	298		...
299	299		SQLQuery1.Open;
300	300		// Hide the primary key column which is the first column in our queries.
301	301		// We can only do this once the DBGrid has created the columns
302	302		DBGrid1.Columns[0].Visible:=false;
303	303		```
304	304
305	305		Recompilez et contrôlez pour voir si la colonne de clé primaire est effectivement cachée.
306	306
307	307		#### SQLite, autres bases de données
308	308
309	309		- Autres base de données : de nombreuses autres bases de données utilisent un type de champ 'autonumber' ou 'autoinc' pour fournir du contenu de champ auto-généré. Essayez de changer votre définition de table pour voir si cela fonctionne.
310	310		- Sqlite : l'exmple du dessus fonctionne pour SQLite car nous utilisons une clé primaire entière. Voir la the [documentation](http://www.sqlite.org/autoinc.html) pour des détails.
311	311
312	312		### Insertion de nouvelles données
313	313
314	314		Si vous insérez de nouveaux enregistements/lignes sans aucune information CUST_NO, vous pouvez avoir remarqué que vous obtenez le message d'erreur : `Field CUST_NO is required, but not supplied`. Ceci survient aussi si vous cachez la colonne CUST_NO comme dans la section précédente.
315	315
316	316		La raison : Lazarus pense que CUST_NO est requis. Cela n'est pas étrange, car c'est une clé primaire et la définition de table sous-jacente dans la base de données dit qu'il est requis.
317	317
318	318		Si nous pouvons intimer à Lazarus que ce champ n'est pas actuellement requis, nous pouvons passer des valeurs vides (=valeurs à NULL) à la base de données. Heureusement, un objet champ de requête a une propriété Required qui sert exactement à cela.
319	319
320	320		Modifiez le code en quelque chose comme :
321	321
322	322		``` pascal
323	323		SQLQuery1.Open;
324	324		{
325	325		Make sure we don't get problems with inserting blank (=NULL) CUST_NO values, e.g.:
326	326		Field CUST_NO is required, but not supplied
327	327		We need to tell Lazarus that, while CUST_NO is a primary key, it is not required
328	328		when inserting new records.
329	329		}
330	330		SQLQuery1.FieldByName('CUST_NO').Required:=false;
331	331		// Hide the primary key column which is the first column in our queries.
332	332		// We can only do this once the DBGrid has created the columns
333	333		DBGrid1.Columns[0].Visible:=false;
334	334		```
335	335
336	336		### Suppression de données
337	337
338	338		Vous pouvez laisser les utilisateurs employer la souris pour cela. Vous n'avez même pas besoin de code une seule ligne pour cette fonctionnalité.
339	339
340	340		Sur l'onglet 'Data controls', sélectionner le composant TDBNavigator et posez-le sur la fiche, au dessus de la grille.
341	341
342	342		Pour indiquer à quoi est relié le navigateur, mettez votre composant DataSource (DataSource1) dans sa propriété DataSource en utilisant l'inspecteur d'objet.
343	343
344	344		Maintenant vous pouvez utiliser le bouton sur le DBNavigator pour supprimer des enregistrements, mais aussi pour en insérer et vous déplacer parmi les enregistrements. Aussi, en éditant les cellules/champs, vous pouvez utiliser le bouton Cancel pour annuler vos éditions.
345	345
346		-	Pour permettre à l'utilisateur de supprimer la ligne sur laquelle ils sont dans la grille en utilisant la touche <span class="kbd">Delete</span>, ajoutez l'unité LCLType (elle contient les définitions des codes de touche) à votre clause uses :
	346	+	Pour permettre à l'utilisateur de supprimer la ligne sur laquelle ils sont dans la grille en utilisant la touche `Delete`, ajoutez l'unité LCLType (elle contient les définitions des codes de touche) à votre clause uses :
347	347
348	348		``` pascal
349	349		uses
350	350		Classes, SysUtils, sqldb, pqconnection, DB, FileUtil, Forms,
351	351		Controls, Graphics, Dialogs, DBGrids, StdCtrls, DbCtrls, LCLType;
352	352		```
353	353
354		-	... il faut coder l'événement KeyUppour la grille, qui survient quand une touche est relâchée dans la grille. Toutefois; nous avons besoin de contrôler que l'utilisateur n'est pas en train de modifier un champ - comme il peut utiliser la touche <span class="kbd">Delete</span> pour supprimer des lettres plutôt que l'enregistrement sur lequel il travaille.
	354	+	... il faut coder l'événement KeyUppour la grille, qui survient quand une touche est relâchée dans la grille. Toutefois; nous avons besoin de contrôler que l'utilisateur n'est pas en train de modifier un champ - comme il peut utiliser la touche `Delete` pour supprimer des lettres plutôt que l'enregistrement sur lequel il travaille.
355	355
356	356		Sélectionnez la grille et allez sur les événements pour créer l'événement OnKeyUp comme ceci :
357	357
358	358		``` pascal
359	359		procedure TForm1.DBGrid1KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState
360	360		);
361	361		begin
362	362		// Check for del key being hit and delete the current record in response
363	363		// as long as we're not editing data
364	364		if (key=VK_DELETE) and (not(DBGrid1.EditorMode)) then
365	365		begin
366	366		//... delete current record and apply updates to db:
367	367		SQLQuery1.Delete;
368	368		SQLQuery1.ApplyUpdates;
369	369		end;
370	370		end;
371	371		```
372	372
373		-	> Note: Par défaut, dans la propriété Options du TDBGrid, dgDisableDelete est mise à False, ce qui veut dire que l'utilisateur peut supprimer un enregistrement avec la combinaison <span class="kbd">ctrl</span>+<span class="kbd">delete</span>. Vous pouvez ne pas désirer ce comportement.
	373	+	> Note: Par défaut, dans la propriété Options du TDBGrid, dgDisableDelete est mise à False, ce qui veut dire que l'utilisateur peut supprimer un enregistrement avec la combinaison `ctrl`+`delete`. Vous pouvez ne pas désirer ce comportement.
374	374
375	375		## Résumé
376	376
377	377		Si vous avez tout suivi jusqu'à maintenant, vous pouvez récupérer des données de la base, les filtrer, les modifier, les supprimer dans la grille. Votre code ressemble à quelque chose comme cela.
378	378
379	379		``` pascal
380	380		unit sqldbtutorial1unit;
381	381
382	382		{$mode objfpc}{$H+}
383	383
384	384		interface
385	385
386	386		uses
387	387		Classes, SysUtils, sqldb, pqconnection, DB, FileUtil, Forms,
388	388		Controls, Graphics, Dialogs, DBGrids, StdCtrls, DbCtrls, LCLType;
389	389		type
390	390
391	391		{ TForm1 }
392	392
393	393		TForm1 = class(TForm)
394	394		Button1: TButton;
395	395		DatabaseName: TEdit;
396	396		Datasource1: TDatasource;
397	397		DBGrid1: TDBGrid;
398	398		Dbnavigator1: Tdbnavigator;
399	399		Edit1: TEdit;
400	400		Label2: Tlabel;
401	401		Label3: Tlabel;
402	402		Label4: Tlabel;
403	403		Label5: Tlabel;
404	404		Password: TEdit;
405	405		UserName: TEdit;
406	406		ServerName: TEdit;
407	407		DBConnection: TIBConnection;
408	408		Label1: TLabel;
409	409		SQLQuery1: TSQLQuery;
410	410		SQLTransaction1: TSQLTransaction;
411	411		procedure SaveChanges;
412	412		procedure Button1click(Sender: TObject);
413	413		procedure Formclose(Sender: TObject; var Closeaction: Tcloseaction);
414	414		private
415	415		{ private declarations }
416	416		public
417	417		{ public declarations }
418	418		end;
419	419
420	420		var
421	421		Form1: TForm1;
422	422
423	423		implementation
424	424
425	425		{$R *.lfm}
426	426
427	427		{ TForm1 }
428	428
429	429		procedure Tform1.Savechanges;
430	430		// Saves edits done by user, if any.
431	431		begin
432	432		try
433	433		if SQLTransaction1.Active then
434	434		// Only if we are within a started transaction
435	435		// otherwise you get "Operation cannot be performed on an inactive dataset"
436	436		begin
437	437		SQLQuery1.ApplyUpdates; //Pass user-generated changes back to database...
438	438		SQLTransaction1.Commit; //... and commit them using the transaction.
439	439		//SQLTransaction1.Active now is false
440	440		end;
441	441		except
442	442		on E: EDatabaseError do
443	443		begin
444	444		MessageDlg('Error', 'A database error has occurred. Technical error message: ' +
445	445		E.Message, mtError, [mbOK], 0);
446	446		Edit1.Text := '';
447	447		end;
448	448		end;
449	449		end;
450	450
451	451		procedure TForm1.DBGrid1KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState
452	452		);
453	453		begin
454	454		// Check for del key being hit and delete the current record in response
455	455		// as long as we're not editing data
456	456		if (key=VK_DELETE) and (not(DBGrid1.EditorMode)) then
457	457		begin
458	458		//... delete current record and apply updates to db:
459	459		SQLQuery1.Delete;
460	460		SQLQuery1.ApplyUpdates;
461	461		end;
462	462		end;
463	463
464	464		procedure Tform1.Button1click(Sender: TObject);
465	465		begin
466	466		SaveChanges; //Saves changes and commits transaction
467	467		try
468	468		SQLQuery1.Close;
469	469		//Connection settings for Firebird/Interbase database
470	470		//only needed when we have not yet connected:
471	471		if not DBConnection.Connected then
472	472		begin
473	473		DBConnection.HostName := ServerName.Text;
474	474		DBConnection.DatabaseName := DatabaseName.Text;
475	475		DBConnection.Username := UserName.Text;
476	476		DBConnection.Password := Password.Text;
477	477		// Now we've set up our connection, visually show that
478	478		// changes are not possibly any more
479	479		ServerName.ReadOnly:=true;
480	480		DatabaseName.ReadOnly:=true;
481	481		UserName.ReadOnly:=true;
482	482		Password.ReadOnly:=true;
483	483		end;
484	484		// Show all records, or filter if user specified a filter criterium
485	485		if Edit1.Text='' then
486	486		SQLQuery1.SQL.Text := 'select * from CUSTOMER'
487	487		else
488	488		begin
489	489		SQLQuery1.SQL.Text := 'select * from CUSTOMER where COUNTRY = :COUNTRY';
490	490		SQLQuery1.Params.ParamByName('COUNTRY').AsString := Edit1.Text;
491	491		end;
492	492		DBConnection.Connected := True;
493	493		SQLTransaction1.Active := True; //Starts a new transaction
494	494		SQLQuery1.Open;
495	495		{
496	496		Make sure we don't get problems with inserting blank (=NULL) CUST_NO values, i.e. error message:
497	497		"Field CUST_NO is required, but not supplied"
498	498		We need to tell Lazarus that, while CUST_NO is a primary key, it is not required
499	499		when inserting new records.
500	500		}
501	501		SQLQuery1.FieldByName('CUST_NO').Required:=false;
502	502		{
503	503		Hide the primary key column which is the first column in our queries.
504	504		We can only do this once the DBGrid has created the columns
505	505		}
506	506		DBGrid1.Columns[0].Visible:=false;
507	507		except
508	508		// EDatabaseError is a general error;
509	509		// you could also use one for your specific db, e.g.
510	510		// use EIBDatabaseError for Firebird/Interbase
511	511		on E: EDatabaseError do
512	512		begin
513	513		MessageDlg('Error', 'A database error has occurred. Technical error message: ' +
514	514		E.Message, mtError, [mbOK], 0);
515	515		Edit1.Text := '';
516	516		end;
517	517		end;
518	518		end;
519	519
520	520		procedure Tform1.Formclose(Sender: TObject; var Closeaction: Tcloseaction);
521	521		begin
522	522		SaveChanges; //Saves changes and commits transaction
523	523		SQLQuery1.Close;
524	524		SQLTransaction1.Active := False;
525	525		DBConnection.Connected := False;
526	526		end;
527	527
528	528		end.
529	529		```
530	530
531	531		## Base de données incorporée sans modification de code
532	532
533	533		### Firebird sur Windows
534	534
535	535		Un bonus pour les utilisateurs de Firebird sur Windows ; si vous avez suivi ce tutoriel (même si vous n'avez fait que l'exemple de base), vous avez renommé la bibliothèque incorporée de Firebird `fbembed.dll` en `fbclient.dll`. avec ceci, Lazarus se connectera aux serveurs Firebird normaux (sur une machine distante ou sur votre machine locale). Toutefois, vous pouvez aussi copier la base de données `employee.fdb` dans votre dossier d'application, exécuter l'application, effacer le TEdit Server name et utiliser Firebird incorporé pour vous connecter directement au fichier de la base de données, sans configuration de serveur.
536	536
537	537		Ceci est génial si vous souhaitez déployer des applications de base de données vers les utilisateurs finaux, mais ne souhaitez pas avoir du mal à installer des serveurs (vérifier si un serveur est déjà installé, s'il s'agit de la bonne version, faire en sorte que les utilisateurs vérifient les pare-feu, etc.).
538	538
539	539		Voir [[Firebird embedded/fr\|Firebird incorporé]] pour plus de détails.
540	540
541	541		Note (non vérifiée) : Depuis 2011, FPC tente de charger d'abord `fbembed.dll`, donc vous n'avez pas besoin de renommer `fbclient.dll` pour que cela fonctionne.
542	542
543	543		### Firebird sur Linux/OSX/Unix
544	544
545	545		Il doit y avoir un moyen pour que cela fonctionne sur Linux / OSX. Voir [[Firebird/fr\|Firebird]] pour les conseils et les liens. Les mises à jour du wiki sont les bienvenues.
546	546
547	547		### SQLite
548	548
549	549		Certes, SQLite offre une fonctionnalité incorporée mais d'un autre côté, il ne permet pas de configuration client/serveur. En suivant le tutoriel du haut, vous pouvez voir cela qu'en basculant les bases de données (p.ex. SQLite et Firebird) ne fait pas tant de travail que cela.
550	550
551	551		### Autres bases de données
552	552
553	553		Votre base de données peut offrir des fonctionnalités similaires. Des mises à jour de ce Wiki pour d'autres SGBD sont les bienvenues.
554	554
555	555		## Voir aussi
556	556
557	557		- [[SQLdb Tutorial0/fr\|SQLdb Tutorial0]] : Instructions pour configurer les tables et les données d'exemple pour la série de tutoriels.
558	558		- [[SQLdb Tutorial1/fr\|SQLdb Tutorial1]] : 1re partie de la série de tutoriels sur les bases de données, montrant comment configurer une grille pour afficher les données.
559	559		- [[SQLdb Tutorial2/fr\|SQLdb Tutorial2]] : 2e partie de la série de tutoriels, montrant l'édition, l'insertion, etc.
560	560		- [[SQLdb Tutorial3/fr\|SQLdb Tutorial3]] : 3e partie de la série de tutoriels, montrant comment développer pour des bases de données multiples et utiliser une fiche de connexion.
561	561		- [[SQLdb Tutorial4/fr\|SQLdb Tutorial4]] : 4e partie de la série de tutoriels, montrant comment utiliser les modules de données.
562	562		- [[Lazarus Database Overview/fr\|Vue d'ensemble des bases de données pour Lazarus]] : Information sur les bases de données supportées par Lazarus. Redirige vers des notes spécifiques à certaines bases de données.
563	563		- [[SQLdb Package/fr\|Paquet SQLdb]] : Information sur le paquetage SQLdb.
564	564		- [[SQLdb Programming Reference/fr\|Référence de programmation SQLdb]] : Une vue d'ensemble de l'interaction entre les composants de bases de données SQLdb.
565	565		- [[SqlDBHowto/fr\|SqlDBHowto]] : Information sur l'utilisation du paquet SQLdb.
566	566		- [[Working With TSQLQuery/fr\|Travailler avec TSQLQuery]] : Informations sur TSQLQuery.
567	567		- [utilisation des paramètres](http://www.freepascal.org/docs-html/fcl/sqldb/usingparams.html)
568	568
569	569		---
570	570		From the Free Pascal wiki, page "SQLdb Tutorial2/fr", as it stood on 2020-02-26 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history