SQLdb Tutorial3/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		Dans ce tutoriel, vous allez apprendre comment :
4	4
5	5		- Rendre votre application adapté à de multiples bases de données, y compris avec une fiche de connexion.
6	6		- Obtenir des données de la base dans des contrôle normaux (au lieu de contrôles sensibles aux données).
7	7		- Extraire les données des contrôles et les retourner dans la base de données
8	8		- Exécuter des requêtes paramétrées.
9	9
10	10		## Support Multi-database
11	11
12	12		En utilisant n'importe quelle base de données et une fiche de connexion, vous pouvez prendre en charge plusieurs serveurs de base de données/bibliothèques intégrées compatibles avec SQLDB.
13	13
14	14		Avantages :
15	15
16	16		- L'utilisateur/programmeur peut utiliser dynamiquement toute T*Connection de SQLdb, donc il peut choisir entre plusieurs SGBD.
17	17
18	18		Inconvénients :
19	19
20	20		- Un SQL plus compliqué sera demandé pour être encore adapté. Chaque SGBD a son propre dialecte ; c'est bien sûr possible d'appeler du SQL spécifique au SGBD, mais cela peut augmenter les problèmes de maintenance.
21	21		- Vous ne pouvez pas utiliser les propriétés spécifiques des TConnection (telles que TIBConnection.Dialect* pour définir le dialecte Firebird).
22	22
23	23		Pour utiliser la prise en charge des bases multiples, à la place de votre TConnection spécifique tel que TIBConnection, utilisez TSQLConnector* (et non pas TSQLConnection), qui, à l'exécution du programme, choisit le TConnection spécifique qui doit être utilisé dans sa propriété ConnectorType* :
24	24
25	25		``` pascal
26	26		uses
27	27		...
28	28		var
29	29		Conn: TSQLConnector;
30	30		begin
31	31		Conn:=TSQLConnector.Create(nil);
32	32		try
33	33		// ...actual connector type is determined by this property.
34	34		// Make sure the ChosenConfig.DBType string matches
35	35		// the connectortype (e.g. see the string in the
36	36		// T*ConnectionDef.TypeName for that connector .
37	37		Conn.ConnectorType:=ChosenConfig.DBType;
38	38		// the rest is as usual:
39	39		Conn.HostName:='DBSERVER';
40	40		Conn.DatabaseName:='bigdatabase.fdb';
41	41		Conn.UserName:='SYSDBA';
42	42		Conn.Password:='masterkey';
43	43		try
44	44		Conn.Open;
45	45		```
46	46
47	47		## Fiche de connexion
48	48
49	49		Comme indiqué dans [[SQLdb Tutorial1/fr\|SQLdb Tutorial1]], un utilisateur devrait se connecter à une base de données via une fiche (ou peut-être un fichier de configuration enregistré de manière sécurisée), et non à travers des accréditations (credentials) dans l'application. Outre les considérations de sécurité, avoir à recompiler l'application dès que les informations de sécurité sur serveur de base de données changent n'est pas une bonne idée.
50	50
51	51		Dans dbconfiggui.pas, nous implanterons une fiche de connexion qui tire les valeurs par défaut d'un fichier ini, s'il existe. Cela vous permet de configurer une connexion par défaut avec quelques détails (serveur et nom de la base de données) rempli pour les dépliements en entreprise p.ex.
52	52
53	53		Dans la fiche, l'utilisateur peut ajouter/modifier son nom d'utilisateur et son mot de passe et tester la connexion avant d'aller plus loin.
54	54
55		-	~~<figure>~~
56		-	~~<img src="dbloginform.png" title="dbloginform.png" />~~
57		-	~~<figcaption>dbloginform.png</figcaption>~~
58		-	~~</figure>~~
	55	+	![](/wiki-images/b/b2/Dbloginform.png)
59	56
60	57		Nous utilisons une unité dbconfig.pas séparée avec une classe TDBConnectionConfig pour stocker les détails de notre connexion choisie. Cette classe prend en charge la lecture des réglages par défaut du fichier ini.
61	58
62	59		Ceci permet l'emploi sans fiche de connexion IHM (p.ex. l'exécution d'opérations batch), et permet la réutilisation dans les applications Web.
63	60
64	61		Cette classe TDBConnectionConfig apparaît dans la fiche de connexion comme propriété Config, afin que le programme principal puisse afficher le formulaire de configuration de manière modale, détecter un clic OK par l'utilisateur et récupérer la configuration sélectionnée avant de fermer le formulaire de configuration.
65	62
66	63		### Fonction de rappel de test de connexion
67	64
68	65		Pour garder la fiche de connexion flexible (elle pourrait être utilisée avec d'autres couches d'accès aux données comme Zeos), nous implémentons la section test comme une fonction de rappel et laissons le programme principal traiter avec.
69	66
70	67		La définition dans la fiche de connexion dans dbconfiggui.pas:
71	68
72	69		``` pascal
73	70		type
74	71		TConnectionTestFunction = function(ChosenConfig: TDBConnectionConfig): boolean of object;
75	72		```
76	73
77	74		La fiche principale doit implémenter une fonction avec la même signature pour gérer la requête de test depuis la fiche de configuration.
78	75
79	76		La fonction de rappel prend l'objet config transmis par la fiche de configuration et l'utilise pour construire une connexion avec le type de base de données choisie. Il essaie simplement de se connecter au serveur ; si il réussit, le résultat de la fonction prend la valeur True, sinon le résultat reste False.
80	77
81	78		Parce que des essais de connexion de base de données à es serveurs inexistant peut avoir de longs temps morts (timeout), nous indiquons à l'utilisateur qu'il doit attendre en mettant le sablier comme curseur de souris.
82	79
83	80		``` pascal
84	81		uses
85	82		...
86	83		dbconfig, dbconfiggui
87	84		...
88	85		procedure TForm1.FormCreate(Sender: TObject);
89	86		LoginForm:=TDBConfigForm.Create(self);
90	87		try
91	88		// The test button on dbconfiggui will link to this procedure:
92	89		... this links the callback in ''dbconfiggui.pas'' to the ConnectionTest function here...
93	90		LoginForm.ConnectionTestCallback:=@ConnectionTest;
94	91		...
95	92		function TForm1.ConnectionTest(ChosenConfig: TDBConnectionConfig): boolean;
96	93		// Callback function that uses the info in dbconfiggui to test a connection
97	94		// and return the result of the test to dbconfiggui
98	95		var
99	96		// Generic database connector...
100	97		Conn: TSQLConnector;
101	98		begin
102	99		result:=false;
103	100		Conn:=TSQLConnector.Create(nil);
104	101		Screen.Cursor:=crHourglass;
105	102		try
106	103		// ...actual connector type is determined by this property.
107	104		// Make sure the ChosenConfig.DBType string matches
108	105		// the connectortype (e.g. see the string in the
109	106		// T*ConnectionDef.TypeName for that connector .
110	107		Conn.ConnectorType:=ChosenConfig.DBType;
111	108		Conn.HostName:=ChosenConfig.DBHost;
112	109		Conn.DatabaseName:=ChosenConfig.DBPath;
113	110		Conn.UserName:=ChosenConfig.DBUser;
114	111		Conn.Password:=ChosenConfig.DBPassword;
115	112		try
116	113		Conn.Open;
117	114		result:=Conn.Connected;
118	115		except
119	116		// Result is already false
120	117		end;
121	118		Conn.Close;
122	119		finally
123	120		Screen.Cursor:=crDefault;
124	121		Conn.Free;
125	122		end;
126	123		end;
127	124		```
128	125
129	126		Finalement, le code dans dbconfiggui.pas qui appelle réellement la fonction de rappel est relie au bouton de Test. Il test si la fonction de rappel est affectée (pour éviter les plantages), pour la complétude, contrôlez aussi qu'il y a un objet de configuration valide et puis appelez la fonction de rappel :
130	127
131	128		``` pascal
132	129		...
133	130		TDBConfigForm = class(TForm)
134	131		...
135	132		private
136	133		FConnectionTestFunction: TConnectionTestFunction;
137	134		public
138	135		property ConnectionTestCallback: TConnectionTestFunction write FConnectionTestFunction;
139	136		...
140	137		procedure TDBConfigForm.TestButtonClick(Sender: TObject);
141	138		begin
142	139		// Call callback with settings, let it figure out if connection succeeded and
143	140		// get test result back
144	141		if assigned(FConnectionTestFunction) and assigned(FConnectionConfig) then
145	142		if FConnectionTestFunction(FConnectionConfig) then
146	143		showmessage('Connection test succeeded.')
147	144		else
148	145		showmessage('Connection test failed.')
149	146		else
150	147		showmessage('Error: connection test code has not been implemented.');
151	148		end;
152	149		```
153	150
154	151		### Ajouts/modifications
155	152
156	153		Possibles ajouts/modifications pour la fiche de connexion :
157	154
158	155		- Ajouter les arguments de ligne de commande pour dbconfig pour pré-charger les valeurs par défaut adaptées, ainsi le programme peut être utilisé dans des scripts batch, raccourcis, etc...
159	156		- Ajout d'une combobox "Sélection de profil" dans la fiche de connexion : utiliser de multiples profils dans le fichier ini qui spécifient le type de base de données et les détais de connexion.
160	157		- Masquer la combobox type de base de données quand celle-ci est unique.
161	158		- Masquer les nom de connexion/mot de passe quand vous êtes sûr qu'une base de données incorporée est sélectionnée.
162	159		- Ajouter la prise en charge du numéro de port ou du nom d'instance avec le connecteur MS SQL Server.
163	160		- Ajouter la prise en charge de l'authentification de confiance (trusted authentication) pour la prise en charge des SGBD qui la supporte (Firebird, MS SQL) : désactiver les contrôles nom de connexion/mot de passe.
164	161		- Si une base de donnée incorporée est sélectionnée mais que le fichier n'existe pas : Montrer une boîte de confirmation et créer la base de données.
165	162		- Créer une version en ligne de commande (Text UI) de la fiche de connexion (p.ex. en utilisant la bibliothèque Curses) pour les applications en mode console.
166	163
167	164		Mettre à jour cet article/le code serait chaleureusement apprécié.
168	165
169	166		## Obtention de données de la base dans des contrôles non liés aux données
170	167
171	168		> Note: Before starting this section, please make sure you have set up the sample employee database as specified in [[SQLdb Tutorial0\|SQLdb Tutorial0#Requirements]]
172	169
173	170		In previous tutorials, data-bound controls were covered: special controls such as the [[TDBGrid]] that can bind its contents to a [[TDataSource]], get updates from that source and send user edits back.
174	171
175	172		It is also possible to programmatically retrieve database content and fill any kind of control (or variable) with that content. As an example, we will look at filling a stringgrid with some salary details for the sample employee database table.
176	173
177	174		On the main form, let's add a [[TStringGrid]] and retrieve the data (e.g. via a procedure LoadSalaryGrid called in the OnCreate event):
178	175
179	176		``` pascal
180	177		// Load from DB
181	178		try
182	179		if not FConn.Connected then
183	180		FConn.Open;
184	181		if not FConn.Connected then
185	182		begin
186	183		ShowMessage('Error connecting to the database. Aborting data loading.');
187	184		exit;
188	185		end;
189	186
190	187		// Lowest salary
191	188		// Note: we would like to only retrieve 1 row, but unfortunately the SQL
192	189		// used differs for various dbs. As we'll deal with db dependent SQL later
193	190		// in the tutorial, we leave this for now.
194	191		// MS SQL: 'select top 1 '...
195	192		FQuery.SQL.Text:='select ' +
196	193		' e.first_name, ' +
197	194		' e.last_name, ' +
198	195		' e.salary ' +
199	196		'from employee e ' +
200	197		'order by e.salary asc ';
201	198		// ISO SQL+Firebird SQL: add
202	199		//'rows 1 '; here and below... won't work on e.g. PostgreSQL though
203	200		FTran.StartTransaction;
204	201		FQuery.Open;
205	202		SalaryGrid.Cells[1,1]:=FQuery.Fields[0].AsString; // i.e. Cells[Col,Row]
206	203		SalaryGrid.Cells[2,1]:=FQuery.Fields[1].AsString;
207	204		SalaryGrid.Cells[3,1]:=FQuery.Fields[2].AsString;
208	205		FQuery.Close;
209	206		// Always commit(retain) an opened transaction, even if only reading
210	207		// this will allow updates by others to be seen when reading again
211	208		FTran.Commit;
212	209		...
213	210		end;
214	211		except
215	212		on D: EDatabaseError do
216	213		begin
217	214		MessageDlg('Error', 'A database error has occurred. Technical error message: ' +
218	215		D.Message, mtError, [mbOK], 0);
219	216		end;
220	217		end;
221	218		```
222	219
223	220		Things to note: we catch database errors using try..except. You'll notice we forgot to roll back the transaction in case of errors - which is left as an exercise to the reader.
224	221
225	222		We Open the query object, thereby asking FQuery to query the database via its SQL statement. Once this is done, we're on the first row of data. We simply assume there is data now; this is actually a programming error: it would be tidier to check for FQuery.EOF being true (or FQuery.RecordCount being \>0).
226	223
227	224		Next, we retrieve the data from the first row of results. If we wanted to move to the next row, we'd use FQuery.Next, but that is not necessary here. We put the results in the stringgrid, giving the lowest salary in the list. A similar approach can be taken for the highest salary.
228	225
229	226		## Adaptations du SQL aux divers SGBD
230	227
231	228		As we noticed above, various databases support various versions of SQL (either in addition to or in contradiction to the official ISO SQL standards). Fortunately, you can customize your application based on which DB it ends up using, which will be demonstrated by getting the standard deviation of the employees' salaries - built into e.g. PostgreSQL SQL but not available by default in e.g. Firebird.
232	229
233	230		In our LoadSalaryGrid procedure, we'll use the SQL for PostgreSQL and build a code solution for all other databases. First detect which database is loaded, below the other lines add:
234	231
235	232		``` pascal
236	233		...
237	234		SalaryGrid.Cells[3,2]:=FQuery.Fields[2].AsString;
238	235		FQuery.Close;
239	236		// Always commit(retain) an opened transaction, even if only reading
240	237		FTran.Commit;
241	238		//end of existing code
242	239
243	240		if FConn.ConnectorType = 'PostGreSQL' then
244	241		begin
245	242		// For PostgreSQL, use a native SQL solution:
246	243		FQuery.SQL.Text:='select stddev_pop(salary) from employee ';
247	244		FTran.StartTransaction;
248	245		FQuery.Open;
249	246		if not FQuery.EOF then
250	247		SalaryGrid.Cells[3,3]:=FQuery.Fields[0].AsString;
251	248		FQuery.Close;
252	249		// Always commit(retain) an opened transaction, even if only reading
253	250		FTran.Commit;
254	251		end
255	252		else
256	253		begin
257	254		// For other database, use the code approach:
258	255		....see below...
259	256		end;
260	257		```
261	258
262	259		Notice the use of ConnectorType; the string used must match exactly. We also properly check for empty results from the query (which might happen if the employee table is empty).
263	260
264	261		... now let's implement a code-based solution for other databases that do not support standard deviation:
265	262
266	263		``` pascal
267	264		// For other databases, use the code approach:
268	265		// 1. Get average of values
269	266		FQuery.SQL.Text:='select avg(salary) from employee ';
270	267		FQuery.Open;
271	268		if FQuery.EOF then
272	269		SalaryGrid.Cells[3,3]:='No data'
273	270		else
274	271		begin
275	272		Average:=FQuery.Fields[0].AsFloat;
276	273		FQuery.Close;
277	274		// 2. For each value, calculate the square of (value-average), and add it up
278	275		FQuery.SQL.Text:='select salary from employee where salary is not null ';
279	276		FQuery.Open;
280	277		while not FQuery.EOF do
281	278		begin
282	279		DifferencesSquared:=DifferencesSquared+Sqr(FQuery.Fields[0].AsFloat-Average);
283	280		Count:=Count+1;
284	281		FQuery.Next;
285	282		end;
286	283		// 3. Now calculate the average "squared difference" and take the square root
287	284		if Count>0 then //avoid division by 0
288	285		SalaryGrid.Cells[3,3]:=FloatToStr(Sqrt(DifferencesSquared/Count))
289	286		else
290	287		SalaryGrid.Cells[3,3]:='No data';
291	288		end;
292	289		FQuery.Close;
293	290		```
294	291
295	292		Note that we use FQuery.EOF to check for empty data (and avoid division by zero errors etc). The loop shows how to:
296	293
297	294		- retrieve a database value into a variable
298	295		- use FQuery.Next to move to the next record
299	296		- properly check if the query dataset has hit the last record, then stop retrieving data.
300	297
301	298		The resulting screen should show something like this - note the use of a decimal comma - while your computer may show a decimal point depending on your locale:
302	299
303		-	~~<figure>~~
304		-	~~<img src="sqldbtutorial3mainform.png" title="sqldbtutorial3mainform.png" />~~
305		-	~~<figcaption>sqldbtutorial3mainform.png</figcaption>~~
306		-	~~</figure>~~
	300	+	![](/wiki-images/6/6a/Sqldbtutorial3mainform.png)
307	301
308	302		### Repenser notre salaire plus élévé/plus bas
309	303
310	304		This section gives some more useful details on SQL but is not required to work through for the rest of the tutorial
311	305
312	306		Now we know how to deal with detecting various database connections, we can adjust the SQL that gets the lowest and highest salary as well to make use of db specific functionality.
313	307
314	308		An example: this would work for MS SQL Server by limiting the number of returned rows to just the first:
315	309
316	310		``` SQL
317	311		select top 1
318	312		e.first_name, e.last_name, e.salary
319	313		from employee e
320	314		order by e.salary asc
321	315		```
322	316
323	317		to get the lowest salary.
324	318
325	319		This efficiently returns one record. Other databases use other syntax, such as the ISO ROWS 1. The diligent SQL student will soon learn not to miss out that important part and request entire large recordsets just for one required record!
326	320
327	321		Let's briefly examine other ways to achieve the same thing, that are worth knowing.
328	322
329	323		Another way to retrieve the record(s) with the minimum salary would be :''
330	324
331	325		``` SQL
332	326		SELECT e.first_name, e.last_name, e.salary FROM employee e WHERE e.salary=(SELECT min(salary) FROM employee)
333	327		```
334	328
335	329		SQL students would greatly benefit from researching Common Table Expressions.
336	330
337	331		A CTE allows a virtual temporary table to be used in a following expression, allowing you to clearly code some very complex queries that otherwise may not be possible. Knowing about CTEs will catapult you ahead of colleagues who have never heard of them! For example the above may be rewritten (example in Microsoft SQL Server syntax) as : ''
338	332
339	333		``` SQL
340	334		WITH TheMinimum as
341	335		(
342	336		SELECT min(salary) as MinimumPay FROM Employee
343	337		)
344	338		SELECT e.first_name, e.last_name, e.salary FROM Employee e WHERE e.salary=(SELECT MinimumPay FROM TheMinimum)
345	339		```
346	340
347	341		Several such temporary tables may be chained together, each using the results from the previous tables. You can treat these virtual tables as though they were real tables in the database, using JOINs to link recordsets together. And it can be very useful for quick tests using hardcoded data - this can be run without any database connection :
348	342
349	343		``` SQL
350	344		WITH TestEmployee as
351	345		(
352	346		SELECT 'Fred' as first_name, 'Bloggs' as last_name, 10500 as salary
353	347		UNION
354	348		SELECT 'Joe' as first_name, 'Public' as last_name, 10000 as salary
355	349		UNION
356	350		SELECT 'Mike' as first_name, 'Mouse' as last_name, 11000 as salary
357	351		),
358	352		TheMinimum as
359	353		(
360	354		SELECT min(salary) as MinimumPay FROM TestEmployee
361	355		)
362	356		SELECT e.first_name, e.last_name, e.salary FROM TestEmployee e WHERE e.salary=(SELECT MinimumPay FROM TheMinimum)
363	357		```
364	358
365	359		You can end up with quite long strings for the code of such SQL queries, but it is only one query and may be called from anywhere where you are limited to a simple single expression - it can be useful to answer complex queries without resorting to functions or stored procedures.
366	360
367	361		## Obtention de données hors des contrôles normaux dans la base de données
368	362
369	363		Previously, we have seen:
370	364
371	365		- how to let SQLDB update the database with data-bound controls (earlier tutorials)
372	366		- how to get data out of the database using queries (the section above)
373	367
374	368		You can also execute SQL to get arbitrary data back into the database via code. This allows you to use variables or controls that have no db aware equivalent such as sliders or custom controls to enter data into the database, at the expense of a bit more coding.
375	369
376	370		As an example, we are going to allow the user to change the lowest and highest salary in the stringgrid.
377	371
378	372		For ease of editing, set the grid's Options/goEditing to true; then assign the procedure below to the OnValidate event for the grid, which will be called every time a user has finished updating the grid.
379	373
380	374		### Requête paramétrée
381	375
382	376		The following code also demonstrates how to use parameterized queries to avoid SQL injection, fiddling with quoting for string values, date formatting, etc.
383	377
384	378		As you can see in the code, you can name your parameters whatever you wish and prefix them with : in the SQL. In code, you can set/get their values by \<somequery\>.Params.ParamByName('\<thename\>').As'\<variabletype\>'; the code demonstrates.AsFloatand.AsString''.
385	379
386	380		Parameterized queries are especially useful (and can be much faster) if you run the same query, only with different parameters, in a loop (think e.g. bulk loading of data).
387	381
388	382		Continuing with our example: after having set up the query SQL and parameters, the transaction is started (and later on committed) as usual, then the query is run by calling ExecSQL (which does not return a result set; if the SQL statement were e.g. a SELECT or INSERT...RETURNING that does return data, you would use Open as in the examples above):
389	383
390	384		``` pascal
391	385		procedure TForm1.SalaryGridValidateEntry(sender: TObject; aCol, aRow: Integer;
392	386		const OldValue: string; var NewValue: String);
393	387		begin
394	388		// Only these cells have min and max salary:
395	389		if (aCol=3) and ((aRow=1) or (aRow=2)) then
396	390		begin
397	391		// Allow updates to min and max salary if positive numerical data is entered
398	392		if StrToFloatDef(NewValue,-1)>0 then
399	393		begin
400	394		// Storing the primary key in e.g. a hidden cell in the grid and using that in our
401	395		// update query would be cleaner, but we can do it the hard way as well:
402	396		FQuery.SQL.Text:='update employee set salary=:newsalary '+
403	397		' where first_name=:firstname and last_name=:lastname and salary=:salary ';
404	398		FQuery.Params.ParamByName('newsalary').AsFloat:=StrToFloatDef(NewValue,0);
405	399		FQuery.Params.ParamByName('firstname').AsString:=SalaryGrid.Cells[1,aRow];
406	400		FQuery.Params.ParamByName('lastname').AsString:=SalaryGrid.Cells[2,aRow];
407	401		FQuery.Params.ParamByName('salary').AsFloat:=StrToFloatDef(OldValue,0);
408	402		FTran.StartTransaction;
409	403		FQuery.ExecSQL;
410	404		FTran.Commit;
411	405		LoadSalaryGrid; //reload standard deviation
412	406		end
413	407		else
414	408		begin
415	409		// Notify user that his input was wrong... he'll be wondering otherwise:
416	410		Showmessage('Invalid salary entered.');
417	411		NewValue:=OldValue;
418	412		end;
419	413		end
420	414		else
421	415		begin
422	416		// Silently discard edits to any other cells
423	417		NewValue:=OldValue;
424	418		end;
425	419		end;
426	420		```
427	421
428	422		Note how we forgot to add a try..except block to this code to nicely catch database errors and display a sensible error message. If you are running the Firebird sample EMPLOYEE database for this tutorial, try to change the salary to a very low value (say 1) and see what happens.
429	423
430	424		Finally, while this example showed an UPDATE SQL query, you could just as well run INSERT queries to insert new data programmatically. Also, you can use parameters in any kind of SQL query (SELECT, UPDATE, etc) as long as you use them for fields, not for table/view/procedure names.
431	425
432	426		## Résumé
433	427
434	428		Ce tutoriel a expliqué :
435	429
436	430		- Comment coder pour de multiples types de base de données.
437	431		- Comment utiliser un fiche de connexion pour découpler votre programme la configuration de l'accès à la base de données.
438	432		- comment récupérer et mettre à jour vos données par la programmation.
439	433
440	434		## Code
441	435
442	436		Depuis Novembre 2012, le code peur être trouvé dans \$(lazarusdir)examples/database/sqldbtutorial3.
443	437
444	438		Si vous avez une version plus ancienne (p.ex. Lazarus 1.0.2), vous pouvez aussi télécharger le code via le [site web SVN de Lazarus](http://svn.freepascal.org/svn/lazarus/trunk/examples/database/sqldbtutorial3/).
445	439
446	440		## Voir aussi
447	441
448	442		- [[SQLdb Tutorial0/fr\|SQLdb Tutorial0]] : Instructions pour configurer les tables et les données d'exemple pour la série de tutoriels.
449	443		- [[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.
450	444		- [[SQLdb Tutorial2/fr\|SQLdb Tutorial2]] : 2e partie de la série de tutoriels, montrant l'édition, l'insertion, etc.
451	445		- [[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.
452	446		- [[SQLdb Tutorial4/fr\|SQLdb Tutorial4]] : 4e partie de la série de tutoriels, montrant comment utiliser les modules de données.
453	447		- [[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.
454	448		- [[SQLdb Package/fr\|Paquet SQLdb]] : Information sur le paquetage SQLdb.
455	449		- [[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.
456	450		- [[SqlDBHowto/fr\|SqlDBHowto]] : Information sur l'utilisation du paquet SQLdb.
457	451		- [[Working With TSQLQuery/fr\|Travailler avec TSQLQuery]] : Informations sur TSQLQuery.
458	452		- [utilisation des paramètres](http://www.freepascal.org/docs-html/fcl/sqldb/usingparams.html)
459	453
460	454		---
461	455		From the Free Pascal wiki, page "SQLdb Tutorial3/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