Lazarus Database Tutorial/it: what changed

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

Old	New		Line
1	1		## Panoramica
2	2
3	3		Questo tutorial è incentrato sul funzionamento di Lazarus con una serie di database esistenti.
4	4
5	5		Lazarus supporta di base diversi database; in ogni caso lo sviluppatore deve installare il package adeguato per ciascuno di essi. E' possibile accedere al database attraverso il codice oppure disponendo dei componenti su un form. I componenti data-aware rappresentano i campi del database e vengono collegati impostando la proprietà DataSource in modo che punti ad un TDataSource. Il Datasource rappresenta una table ed è collegato ai componenti del database (per esempio: TPSQLDatabase, TSQLiteDataSet) impostando la proprietà DataSet. I componenti data-aware sono situati nel tab "Data Controls" della palette dei componenti di Lazarus. Il componente Datasource e i componenti dei database sono situati nel tab "Data Access".
6	6
7	7		## Lazarus e MySQL
8	8
9	9		### Far funzionare MySQL su Linux o Windows
10	10
11	11		Seguite le istruzioni riportate sul MySQL User Manual. Assicuratevi che il daemon mysqld giri correttamente e che tutti i potenziali utenti (inclusi root, mysql, voi stessi e ognuno che ne abbia bisogno) abbiano i privilegi di cui necessitano, da tutti gli host richiesti (inclusi 'localhost', il nome dell'host locale, qualsiasi altro host della vostra rete) per quanto sia consistente con la sicurezza. E' preferibile che tutti gli utenti, incluso il root, abbiano una password. Controllate il funzionamento del sistema del database utilizzando l'esempio fornito nel manuale e assicuratevi che tutti gli utenti abbiano realmente accesso al database.
12	12
13	13		### Far funzionare MySQL con FPC in modalità testuale
14	14
15	15		C'è una directory con un programma di esempio in \$(fpcsrcdir)/packages/base/mysql/. Potete trovare la directory dei sorgenti del fpc in Lazarus: Environment menu -\> Environment Options -\> Paths tab -\> FPC source directory. Alcuni percorsi tipici per la directory di mysql sono /usr/share/fpcsrc/packages/base/mysql/ (rpm install) oppure C:\lazarus\fpcsrc\packages\base\mysql\\ (windows). Questa directory contiene anche le units mysql.pp, mysql_com.pp e mysql_version.pp. Prima di avviare lo script per il test, avrete bisogno di creare un database chiamato testdb: è possibile fare ciò loggandosi nel monitor mysql (come root con pieni privilegi) e immettendo la seguente linea SQL
16	16
17		-	~~`CREATE DATABASE testdb;`~~
	17	+	```text
	18	+	CREATE DATABASE testdb;
	19	+	```
18	20
19	21		quindi assicurandovi che tutti gli utenti abbiano i privilegi di accesso appropriati
20	22
21		-	~~`GRANT ALL ON testdb TO johnny-user IDENTIFIED BY 'johnnyspassword'; `~~
	23	+	```text
	24	+	GRANT ALL ON testdb TO johnny-user IDENTIFIED BY 'johnnyspassword';
	25	+	```
22	26
23	27		Esiste uno script chiamato mkdb che ora dovreste provare a lanciare:
24	28
25		-	~~`sh ./mkdb`~~
	29	+	```text
	30	+	sh ./mkdb
	31	+	```
26	32
27	33		Probabilmente restituirà un errore, poiché il sistema non permette ad utenti anonimi di accedere al database. Quindi modificate lo script utilizzando un editor di testo in modo tale che la linea che chiama mysql sia:
28	34
29		-	~~`mysql -u root -p ${1-testdb} << EOF >/dev/null`~~
	35	+	```text
	36	+	mysql -u root -p ${1-testdb} << EOF >/dev/null
	37	+	```
30	38
31	39		e provate a lanciarlo di nuovo, immettendo la vostra password quando richiesto. Con un pizzico di fortuna dovreste essere in grado di creare il database di test: provatelo (loggati nel monitor mysql) lanciando la sequenza di comandi mysql
32	40
33		-	~~`select * from FPdev;`~~
	41	+	```text
	42	+	select * from FPdev;
	43	+	```
34	44
35	45		Dovreste vedere una tabella contenente l'ID, lo username e l'indirizzo email di alcuni degli sviluppatori del FPC.
36	46
37	47		Ora provate a lanciare il programma di test testdb.pp (potrebbe essere necessario compilarlo, e quasi sicuramente non andrà a buon fine al primo tentativo!!).
38	48
39	49		Ho scoperto che il programma potrebbe non connettersi a mysql per diverse ragioni:
40	50
41	51		- Il mio sistema (SuSE Linux v9.0) installa mysql v4.0.15, non la versione 3 per la quale il package è stato disegnato.
42	52
43	53		- Il programma ha bisogno di avere nome utente e password per accedere al database.
44	54
45	55		- Il compilatore ha bisogno di sapere dove trovare le librerie di mysql (NEL CASO IN CUI NON ABBIATE PROVVEDUTO AD INSTALLARE LE LIBRERIE DI SVILUPPO DI MYSQL, FATELO ORA!)
46	56
47	57		Ho creato una copia di testdb.pp chiamandola trydb.pp, piuttosto che modificare l'originale - questo significa che i files originali verranno ancora corretti durante gli aggiornamenti successivi da CVS. Ho anche cpiato i files trovati nella sottodirectory mysql/ver40/ nella sottodirectory principale mysql/, rinominandoli mysql_v4.pp, mysql_com_v4.pp e mysql_version_v4.pp, assicurandomi di rinominare le units all'interno di ogni file in maniera corrispondente. Ho cambiato il blocco uses in trydb.pp in
48	58
49		-	~~`uses mysql_v4`~~
	59	+	``` pascal
	60	+	uses mysql_v4
	61	+	```
50	62
51	63		e quello in mysql_v4.pp in
52	64
53		-	~~`uses mysql_com_v4`~~
	65	+	``` pascal
	66	+	uses mysql_com_v4
	67	+	```
54	68
55	69		Ho aggiunto una linea a /etc/fpc.cfg per far puntare il compilatore alle mie librerie:
56	70
57		-	~~`-Fl/lib;/usr/lib`~~
	71	+	```text
	72	+	-Fl/lib;/usr/lib
	73	+	```
58	74
59	75		I passi seguenti potrebbero non essere necessari se le librerie di sviluppo sono state installate, poiché i collegamenti vengono creati automaticamente, ma controllare non fa mai male. Ho dovuto trovare il vero nome della libreria mysqlclint in /usr/lib e, nel mio caso, ho dovuto lanciare il comando da shell:
60	76
61		-	~~`ln -s libmysqlclient.so.12.0.0 lmysqlclient`~~
	77	+	```text
	78	+	ln -s libmysqlclient.so.12.0.0 lmysqlclient
	79	+	```
62	80
63	81		per creare un link simbolico che permettesse a FPC di trovare la libreria. Per buona pratica ho anche creato il link
64	82
65		-	~~`ln -s libmysqlclient.so.12.0.0 mysqlclient`~~
	83	+	```text
	84	+	ln -s libmysqlclient.so.12.0.0 mysqlclient
	85	+	```
66	86
67	87		e posizionato link simili in altre directory: non strettamente necessario, solo per sicurezza...! Alcuni utenti potrebbero aver bisogno di aggiungere il seguente link:
68	88
69		-	~~`ln -s libmysqlclient.so.12.0.0 libmysqlclient.so`~~
	89	+	```text
	90	+	ln -s libmysqlclient.so.12.0.0 libmysqlclient.so
	91	+	```
70	92
71	93		Ho modificato trydb.pp in modo da includere i dettagli dell'utente, inizialmente aggiungendo l'host, l'user e la password come costanti:
72	94
73	95		``` pascal
74	96		const
75	97		host : Pchar= 'localhost';
76	98		user : Pchar= 'myusername';
77	99		passwd: Pchar = 'mypassword';
78	100		```
79	101
80	102		Ho anche scoperto che non posso connettermi a mysql utilizzando mysql_connect(), ma ho dovuto utilizzare mysql_real_connect() che ha molti più parametri. Per complicare le cose ulteriormente il numero di parametri sembra essere cambiato tra la versione 3 (dove erano sette) e la versione 4 (dove sono otto). Prima di utilizzare mysql_real_connect ho dovuto utilizzare mysql_init() che non esiste nel file mysql.pp originale, ma esiste in mysql_v4.pp.
81	103
82	104		Quindi il codice per la connessione al database è:
83	105
84	106		``` pascal
85	107		{ a few extra variables}
86	108		var
87	109		alloc : PMYSQL;
88	110
89	111		{main program fragment}
90	112
91	113		begin
92	114		if paramcount=1 then
93	115		begin
94	116		Dummy:=Paramstr(1)+#0;
95	117		DataBase:=@Dummy[1];
96	118		end;
97	119
98	120		Writeln ('Allocating Space...');
99	121		alloc := mysql_init(PMYSQL(@qmysql));
100	122		Write ('Connecting to MySQL...');
101	123		sock := mysql_real_connect(alloc, host, user, passwd, database, 0, nil, 0);
102	124		if sock=Nil then
103	125		begin
104	126		Writeln (stderr,'Couldn''t connect to MySQL.');
105	127		Writeln (stderr, 'Error was: ', mysql_error(@qmysql));
106	128		halt(1);
107	129		end;
108	130		Writeln ('Done.');
109	131		Writeln ('Connection data:');
110	132		{$ifdef Unix}
111	133		writeln ('Mysql_port : ',mysql_port);
112	134		writeln ('Mysql_unix_port : ',mysql_unix_port);
113	135		{$endif}
114	136		writeln ('Host info : ',mysql_get_host_info(sock));
115	137		writeln ('Server info : ',mysql_stat(sock));
116	138		writeln ('Client info : ',mysql_get_client_info);
117	139
118	140		Writeln ('Selecting Database ',DataBase,'...');
119	141		if mysql_select_db(sock,DataBase) < 0 then
120	142		begin
121	143		Writeln (stderr,'Couldn''t select database ',Database);
122	144		Writeln (stderr,mysql_error(sock));
123	145		halt (1);
124	146		end;
125	147		{... as original contents of testdb.pp}
126	148		```
127	149
128	150		Ora siete pronti per compilare trydb.pp?
129	151
130		-	~~` fpc trydb`~~
	152	+	```text
	153	+	fpc trydb
	154	+	```
131	155
132	156		fatto! Adesso lanciatelo:
133	157
134		-	~~` ./trydb`~~
	158	+	```text
	159	+	./trydb
	160	+	```
135	161
136	162		whoopee! Ho ottenuto l'elenco degli sviluppatori del FPC!
137	163
138	164		Alcuni ulteriori perfezionamenti: rendete interattive l'immissione dei dettagli dell'utente e l'immissione dei comandi, utilizzando variabili piuttosto che costanti, e permettete di inserire diversi comandi SQL, finché non viene rovato il comando quit: controllate il [[Lazarus Database Tutorial/TryDbpp\|listato completo del programma]], dove i dettagli dell'utente sono inseriti da console, e il programma va in un loop dove i comandi SQL sono inseriti sempre da console (senza il punto e virgola finale) e le risposte vengono mostrate a schermo solo quando 'quit' viene inserito dalla tastiera.
139	165
140	166		Vedi [[Lazarus Database Tutorial/SampleListing\|Sample Console Listing]].
141	167
142	168		### Connettersi a MySQL da un'Applicazione Lazarus
143	169
144	170		Questo tutorial mostra come connettere Lazarus a un database MySQL ed eseguire delle semplici interrogazioni, utilizzando solo i componenti di base di Lazarus; non vengono utilizzati componenti Data Aware, ma vengono illustrati i principi dell'interfacciamento con il database.
145	171
146	172		Create un nuovo progetto in Lazarus:
147	173
148		-	~~`Project -> New Project -> Application`~~
	174	+	```text
	175	+	Project -> New Project -> Application
	176	+	```
149	177
150	178		Apparirà un nuovo form generato automaticamente.
151	179
152	180		Ingrandite il form in modo tale che riempia circa metà schermo, quindi rinominate il form e la caption in 'TryMySQL'.
153	181
154	182		Dal tab dei componenti Standard posizionate tre Edit Box nella parte in alto a sinistra del Form e, immediatamente sopra ogni box, posizionate una label. Cambiate name e captions in 'Host' (e HostLLabel, HostEdit), 'UserName' (e UserLabel, UserEdit) e 'Password' (con PasswdLabel e PasswdEdit). In alternativa potreste utilizzare il componente LabelledEdit dal tab Additional.
155	183
156	184		Selezionate l'Edit box Passwd e trovate la proprietà PasswordChar: cambiatela in '' o in un altro carattere, in modo che quando digiterete una password i caratteri non appariranno sullo schermo, ma verrà mostrata una serie di . Assicuratevi che la proprietà Text di ogni edit box sia vuota.
157	185
158	186		Ora posizionate un altro Edit box e un'altra label nell'angolo in alto a destra del form. Cambiate il testo della label in 'Enter SQL Command' e chiamate l'edit box CommandEdit.
159	187
160	188		Mettete tre Button sul form: due a sinistra sotto gli Edit box e uno a destra, sotto il command box.
161	189
162	190		Cambiate il testo dei button sulla sinistra in 'Connect to Database' (ConnectButton) e 'Exit' (ExitButton) e il testo di quello a destra in 'Send Query' (QueryButton).
163	191
164	192		Posizionate un grande Memo Box con una label con il testo 'Results' (ResultMemo) nella parte inferiore destra del form, in modo tale da riempire quasi tutto lo spazio disponibile. Cambiate la proprietà ScrollBars in ssAutoBoth in modo che le scroll bar appaiano automaticamente se il testo riempie lo spazio. Mettete la proprietà WordWrap a True.
165	193
166	194		Posizionate unoa Status Bar (dal tab Common Controls) nella parte bassa del form e cambiate la sua proprietà SimpleText in 'TryMySQL'.
167	195
168	196		Uno screenshot del form può essere visualizzato da qui: [Mysql Example Screenshot](http://lazarus-ccr.sourceforge.net/kbdata/trymysqldb.png)
169	197
170	198		Ora abbiamo bisogno di gestire alcuni eventi.
171	199
172	200		I tre Edit box sulla sinistra serviranno per immettere hostname, username e password. Quando sono stati inseriti, viene premuto il tasto Connect. L'evento OnClick del button è basato su parte del programma FPC in modalità testuale che abbiamo appena visto.
173	201
174	202		Le risposte dal database ora non possono essere scritte con l'ausilio dei comandi pascal write o writeln: piuttosto, le risposte devono essere convertite in string e mostrate nel Memo box. Laddove i comandi Pascal write e writeln sono in grado di effettuare diverse conversioni di tipo 'al volo', l'utilizzo di una memo box per l'output di testo necessita di una conversione esplicita dei tipi di dato in string, così le variabili di tipo Pchar devono essere convertite in string mediante StrPas, gli integer tramite IntToStr.
175	203
176	204		Le string vengono mostrate nel Memo box tramite l'utilizzo di
177	205
178	206		``` pascal
179	207		procedure ShowString (S : string);
180	208		(* display a string in a Memo box *)
181	209		begin
182	210		trymysqlForm1.ResultsMemo.Lines.Add (S)
183	211		end;
184	212		```
185	213
186	214		Così l'evento onClick del ConnectButton diventa:
187	215
188	216		``` pascal
189	217		procedure TtrymysqlForm1.ConnectButtonClick(Sender: TObject);
190	218		(* Connect to MySQL using user data from Text entry boxes on Main Form *)
191	219		var
192	220		strg: string;
193	221		begin
194	222		dummy1 := trymysqlForm1.HostEdit.text+#0;
195	223		host := @dummy1[1];
196	224		dummy2 := trymysqlForm1.UserEdit.text+#0;
197	225		user := @dummy2[1];
198	226		dummy3 := trymysqlForm1.PasswdEdit.text+#0;
199	227		passwd := @dummy3[1];
200	228
201	229		alloc := mysql_init(PMYSQL(@qmysql));
202	230		sock := mysql_real_connect(alloc, host, user, passwd, database, 0, nil, 0);
203	231		if sock=Nil then
204	232		begin
205	233		strg :='Couldn''t connect to MySQL.'; showstring (strg);
206	234		Strg :='Error was: '+ StrPas(mysql_error(@qmysql)); showstring (strg);
207	235		end else
208	236		begin
209	237		trymysqlForm1.statusBar1.simpletext := 'Connected to MySQL';
210	238		strg := 'Now choosing database : ' + database; showstring (strg);
211	239		{$ifdef Unix}
212	240		strg :='Mysql_port : '+ IntToStr(mysql_port); showstring (strg);
213	241		strg :='Mysql_unix_port : ' + StrPas(mysql_unix_port); showstring (strg);
214	242		{$endif}
215	243		Strg :='Host info : ' + StrPas(mysql_get_host_info(sock));
216	244		showstring (strg);
217	245		Strg :='Server info : ' + StrPas(mysql_stat(sock)); showstring (strg);
218	246		Strg :='Client info : ' + Strpas(mysql_get_client_info); showstring (strg);
219	247
220	248		trymysqlForm1.statusbar1.simpletext := 'Selecting Database ' + DataBase +'...';
221	249		if mysql_select_db(sock,DataBase) < 0 then
222	250		begin
223	251		strg :='Couldn''t select database '+ Database; ShowString (strg);
224	252		Strg := mysql_error(sock); ShowString (strg);
225	253		end
226	254		end;
227	255		end;
228	256		```
229	257
230	258		Il Text Box sulla destra permette l'inserimento di un comando SQL, senza il punto e virgola finale; quando si è soddisfatti della query inserita, viene premuto il tasto SendQuery e la query viene processata, il cui risultato verrà mostrato nel box ResultsMemo.
231	259
232	260		Il gestore di eventi SendQuery è ancora una volta basato sulla versione in modalità testo, con l'eccezione che, anche qui, si abbia una conversione esplicita di tipo prima di mostrare le string nel box.
233	261
234	262		Una differenza con il programma in modalità testuale è che, nel caso in cui venga riscontrata una anomalia, il programma non viene terminato e la connessione a MySQL non viene chiusa; invece viene restituito il controllo al form principale e viene data l'opportunità di correggere la query prima di lanciarla di nuovo. L'applicazione viene chiusa (con la chiusura della connessione a MySQL) solo quando il tasto Exit viene premuto.
235	263
236	264		Questo è il codice per SendQuery:
237	265
238	266		``` pascal
239	267		procedure TtrymysqlForm1.QueryButtonClick(Sender: TObject);
240	268		var
241	269		dumquery, strg: string;
242	270		begin
243	271		dumquery := TrymysqlForm1.CommandEdit.text;
244	272		dumquery := dumquery+#0;
245	273		query := @dumquery[1];
246	274		trymysqlForm1.statusbar1.simpletext := 'Executing query : '+ dumQuery +'...';
247	275		strg := 'Executing query : ' + dumQuery; showstring (strg);
248	276		if (mysql_query(sock,Query) < 0) then
249	277		begin
250	278		Strg :='Query failed '+ StrPas(mysql_error(sock)); showstring (strg);
251	279		end else
252	280		begin
253	281		recbuf := mysql_store_result(sock);
254	282		if RecBuf=Nil then
255	283		begin
256	284		Strg :='Query returned nil result.'; showstring (strg);
257	285		end else
258	286		begin
259	287		strg :='Number of records returned : ' + IntToStr(mysql_num_rows (recbuf));
260	288		Showstring (strg);
261	289		Strg :='Number of fields per record : ' + IntToStr(mysql_num_fields(recbuf));
262	290		showstring (strg);
263	291		rowbuf := mysql_fetch_row(recbuf);
264	292		while (rowbuf <>nil) do
265	293		begin
266	294		Strg :='(Id: '+ rowbuf[0]+', Name: ' + rowbuf[1]+ ', Email : ' +
267	295		rowbuf[2] +')';
268	296		showstring (strg);
269	297		rowbuf := mysql_fetch_row(recbuf);
270	298		end;
271	299		end;
272	300		end;
273	301		end;
274	302		```
275	303
276	304		Salvate il progetto e lanciate Run -\> Run.
277	305
278	306		#### Scaricare il codice sorgente MYSQL
279	307
280	308		Un listato completo del programma è disponibile qui: [Sample Source Code](http://lazarus-ccr.sourceforge.net/kbdata/mysqldemo.tar.gz)
281	309
282	310		## Semplice Demo MySQL sull'utilizzo del componente TMySQL50Connection
283	311
284	312		Il seguente codice è una demo veloce su come operare in maniera semplice (testato su Win XP con Lighty2Go). libmysql.dll è stata copiata nelle directory del progetto e di lazarus.exe (disponibile in una directory in Lighty2Go). Non è richiesto il posizionamento sul form di altri componenti aggiuntivi oltre che di tre edit box, un memo box e alcuni button. C'è bisogno di aggiungere mysql50conn e sqldb nella clausola uses. La directory dei componenti di Lazarus deve essere rw per il programmatore. Il dbms mysql utilizzato ha come user 'root' e non è impostata nessuna password; un database test1 con una tabella tPerson contenente tre campi: personid (int), surname (varchar(40)) e dob (datetime). E' stato utilizzato phpMyAdmin (in Lighty2Go) per creare il db, la tabella, i campi e per inserire alcuni dati. Da notare che le date in phpMyAdmin devono essere inserite nel formato YYYY-MM-DD, benché il programma che stiamo creando accetti le date nei formati usuali. Il button btnTest deve essere cliccato per primo, perché crea la connessione con il dbms. Notare la linea che applica gli aggiornamenti - senza di essa i dati modificati o immessi nono verranno scritti sul db anche se risiedono in memoria e possono essere visualizzati tramite btnFirst e btnNext.
285	313
286	314		``` pascal
287	315		unit unt_db;
288	316		//Example based on:
289	317		//http://www.lazarus.freepascal.org/index.php?name=PNphpBB2&file=viewtopic&t=5761
290	318		//from tpglemur on that forum
291	319		{$mode objfpc}{$H+}
292	320		interface
293	321		uses
294	322		Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs,
295	323		mysql50conn, sqldb, StdCtrls;
296	324		type
297	325		{ TForm1 }
298	326		TForm1 = class(TForm)
299	327		btnTest: TButton;
300	328		btnNext: TButton;
301	329		btnFirst: TButton;
302	330		btnNew: TButton;
303	331		edtPersonID: TEdit;
304	332		edtSurname: TEdit;
305	333		edtDOB: TEdit;
306	334		Memo1: TMemo;
307	335		procedure btnFirstClick(Sender: TObject);
308	336		procedure btnNewClick(Sender: TObject);
309	337		procedure btnNextClick(Sender: TObject);
310	338		procedure btnTestClick(Sender: TObject);
311	339		private
312	340		{ private declarations }
313	341		conn : TMySQL50Connection;
314	342		query : TSQLQuery;
315	343		transaction : TSQLTransaction;
316	344		procedure Display;
317	345		public
318	346		{ public declarations }
319	347		end;
320	348		var
321	349		Form1: TForm1;
322	350		implementation
323	351		{ TForm1 }
324	352		procedure TForm1.btnTestClick(Sender: TObject);
325	353		var
326	354		S: String;
327	355		begin
328	356		conn := TMySQL50Connection.Create(nil);
329	357		query := TSQLQuery.Create(nil);
330	358		transaction := TSQLTransaction.Create(nil);
331	359		try
332	360		try
333	361		conn.HostName := '127.0.0.1';
334	362		conn.UserName := 'root';
335	363		conn.Password := '';
336	364		conn.DatabaseName := 'test1';
337	365		conn.Connected := True;
338	366		conn.Transaction := transaction;
339	367		query.DataBase := conn;
340	368		//query.ParseSQL := true; //line not needed - this is the default anyway
341	369		//query.ReadOnly := false; //line not needed - this is the default anyway
342	370		query.SQL.Text := 'select * from tperson';
343	371		query.Open;
344	372
345	373		query.Last;
346	374		S := IntToStr(query.RecordCount) + #13#10;
347	375		query.First;
348	376
349	377		while not query.EOF do
350	378		begin
351	379		S := S + query.FieldByName('surname').AsString + #13#10;
352	380		query.Next;
353	381		end;
354	382		finally
355	383		//query.Free;
356	384		//conn.Free;
357	385		end;
358	386		except
359	387		on E: Exception do
360	388		ShowMessage(E.message);
361	389		end;
362	390		Memo1.Text:= S;
363	391		end;
364	392
365	393		procedure TForm1.Display;
366	394		begin
367	395		edtPersonID.Text := query.FieldByName('personid').AsString;
368	396		edtSurname.Text := query.FieldByName('surname').AsString;
369	397		edtDOB.Text := query.FieldByName('dob').AsString;
370	398		end;
371	399
372	400		procedure TForm1.btnFirstClick(Sender: TObject);
373	401		begin
374	402		query.First;
375	403		Display;
376	404		end;
377	405
378	406		procedure TForm1.btnNewClick(Sender: TObject);
379	407		begin
380	408		query.Append;
381	409		query.FieldValues['personid'] := edtPersonID.Text;
382	410		query.FieldValues['surname'] := edtSurname.Text;
383	411		query.FieldValues['dob'] := edtDOB.Text;
384	412		query.Post;
385	413		query.ApplyUpdates; //to apply update
386	414		//transaction.Commit; //line not needed
387	415		end;
388	416
389	417		procedure TForm1.btnNextClick(Sender: TObject);
390	418		begin
391	419		query.Next;
392	420		Display;
393	421		end;
394	422
395	423		initialization
396	424		{$I unt_db.lrs}
397	425		end.
398	426		```
399	427
400	428		Questa versione utilizza i componenti TMySQL50Connection, TSQLQuery, TSQLTransaction, TDatasource e TDBGrid preventivamente posizionati sul form:
401	429
402	430		``` pascal
403	431		unit unt_mysql2;
404	432		{$mode objfpc}{$H+}
405	433		interface
406	434		uses
407	435		Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs,
408	436		mysql50conn, sqldb, StdCtrls, db, DBGrids, DbCtrls;
409	437		type
410	438		{ TForm1 }
411	439		TForm1 = class(TForm)
412	440		btnConnect: TButton;
413	441		btnSave: TButton;
414	442		btnNext: TButton;
415	443		btnPrior: TButton;
416	444		Datasource1: TDatasource;
417	445		DBGrid1: TDBGrid;
418	446		Memo1: TMemo;
419	447		MySQL50Connection1: TMySQL50Connection;
420	448		SQLQuery1: TSQLQuery;
421	449		SQLTransaction1: TSQLTransaction;
422	450		procedure btnConnectClick(Sender: TObject);
423	451		procedure btnNextClick(Sender: TObject);
424	452		procedure btnPriorClick(Sender: TObject);
425	453		procedure btnSaveClick(Sender: TObject);
426	454		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
427	455		procedure FormCreate(Sender: TObject);
428	456		private
429	457		{ private declarations }
430	458		public
431	459		{ public declarations }
432	460		end;
433	461		var
434	462		Form1: TForm1;
435	463		implementation
436	464		{ TForm1 }
437	465
438	466		procedure TForm1.FormCreate(Sender: TObject);
439	467		begin
440	468		//Set properties of components:
441	469		//(could be done in the Object Inspector)
442	470		MySQL50Connection1.HostName := '127.0.0.1';
443	471		MySQL50Connection1.UserName := 'root';
444	472		MySQL50Connection1.Password := '';
445	473		MySQL50Connection1.DatabaseName := 'test1';
446	474		MySQL50Connection1.Transaction := SQLTransaction1;
447	475		//SQLQuery1.ParseSQL := true; //line not needed - this is the default
448	476		//SQLQuery1.ReadOnly := false; //line not needed - this is the default
449	477		SQLQuery1.SQL.Text := 'select * from tperson';
450	478		SQLQuery1.Transaction := SQLTransaction1;
451	479		SQLQuery1.UpdateMode := upWhereChanged;
452	480		Datasource1.Dataset := SQLQuery1;
453	481		DBGrid1.DataSource := Datasource1;;
454	482		end;
455	483
456	484		procedure TForm1.btnConnectClick(Sender: TObject);
457	485		var
458	486		S : string;
459	487		begin
460	488		try
461	489		MySQL50Connection1.Connected := true;
462	490		SQLQuery1.Open;
463	491
464	492		//Tests to see if all is OK:
465	493		SQLQuery1.Last;
466	494		S := IntToStr(SQLQuery1.RecordCount) + #13#10;
467	495		SQLQuery1.First;
468	496		while not SQLQuery1.EOF do
469	497		begin
470	498		S := S + SQLQuery1.FieldByName('surname').AsString + #13#10;
471	499		SQLQuery1.Next;
472	500		end;
473	501		except
474	502		on E: Exception do
475	503		ShowMessage(E.message);
476	504		end;
477	505		Memo1.Text:= S;
478	506		end;
479	507
480	508		procedure TForm1.btnNextClick(Sender: TObject);
481	509		begin
482	510		SQLQuery1.Next;
483	511		end;
484	512
485	513		procedure TForm1.btnPriorClick(Sender: TObject);
486	514		begin
487	515		SQLQuery1.Prior;
488	516		end;
489	517
490	518		procedure TForm1.btnSaveClick(Sender: TObject);
491	519		begin
492	520		SQLQuery1.ApplyUpdates;
493	521		end;
494	522
495	523		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
496	524		begin
497	525		//Required or get EDatabase error on close:
498	526		MySQL50Connection1.Connected := false;
499	527		end;
500	528
501	529		initialization
502	530		{$I unt_mysql2.lrs}
503	531		end.
504	532		```
505	533
506	534		## Lazarus e PostgreSQL
507	535
508	536		Questa è una guida molto breve che spiega come connettere Lazarus 0.9.12 o successivo a un database PostgreSQL, locale o remoto, tramite l'utilizzo di TPQConnection.
509	537
510	538		Dopo avere correttamente installato il package, seguite questi passi:
511	539
512	540		- Posizionare un PQConnection dal tab SQLdb
513	541		- Posizionare un SQLQuery dal tab SQLdb
514	542		- Posizionare un SQLTransaction dal tab SQLdb
515	543		- Posizionare un DataSource dal tab DataAccess
516	544		- Posizionare un DBGrid dal tab DataControls
517	545
518	546		- In PQConnection modificare le proprietà:
519	547		- transaction con il rispettivo oggetto SQLTransaction
520	548		- Database name
521	549		- HostName
522	550		- UserName + password
523	551
524	552		- Assicurarsi che SQLTransaction sia cambiato automaticamente per puntare a PQConnection
525	553
526	554		- In SQLQuery modificare le proprietà:
527	555		- transaction con il rispettivo oggetto
528	556		- database con il rispettivo oggetto
529	557		- SQL (qualcosa del tipo 'select * from anytable')
530	558
531	559		- Nell'oggetto DataSource assegnate alla proprietà DataSet l'oggetto SQLQuery
532	560
533	561		- In DBGrid assegnate alla proprietà datasource l'oggetto DataSource
534	562
535	563		Posizionare tutti gli switch su connected e active e la DBGrid dovrebbe essere riempita a design time. TDBText e TDBEdit sembrano funzionare, ma (per me) _mostrano_ _dati_ solamente.
536	564
537	565		Per cambiare i contenuti nel database, ho chiamato direttamente il motore DB con il seguente codice:
538	566
539	567		``` pascal
540	568		try
541	569		sql:= 'UPDATE table SET setting=1';
542	570		PQDataBase.Connected:=True;
543	571		PQDataBase.ExecuteDirect('Begin Work;');
544	572		PQDataBase.ExecuteDirect(sql);
545	573		PQDataBase.ExecuteDirect('Commit Work;');
546	574		PQDataBase.Connected:=False;
547	575		except
548	576		on E : EDatabaseError do
549	577		MemoLog.Append('DB ERROR:'+sql+chr(13)+chr(10)+E.ClassName+chr(13)+chr(10)+E.Message);
550	578		on E : Exception do
551	579		MemoLog.Append('ERROR:'+sql+chr(13)+chr(10)+E.ClassName+chr(13)+chr(10)+E.Message);
552	580		end;
553	581		```
554	582
555	583		- Note:
556	584		- Controllato su windows, Lazarus 0.9.12 + PgSQL 8.3.1
557	585		- Alcune prove su linux, Lazarus 0.9.12 and PgSQL 8.0.x
558	586
559	587		- Installazione e errori:
560	588		- Nella verione .12 di Lazarus che ho provato, i campi del tipo "text" e "numeric" hanno dei bugs
561	589		- Ho usato senza problemi char fixed size, int e float8
562	590		- Alcune volte riavviare Lazarus risolve stupidi errori...
563	591		- Dopo alcuni errori, le transaczioni rimangono attive e devono essere disattivate a mano
564	592		- Le modifiche fatte in Lazarus ovviamente non sono visibili finché la transazione non viene passata
565	593		- Il debugger integrato sembra buggato (almeno in windows) - alcune volte far girare l'eseguibile fuori dall'ide può aiutare a scovare errori
566	594		- In linux alcuni messaggi d'errore vengono mostrati nella console -- lanciate il vostro programma da linea di comando, alcune volte ci sono ulteriori informazioni di debug molto utili
567	595		- Error: "Can not load Postgresql client. Is it installed (libpq.so) ?"
568	596		- Aggiungete il percorso per trovare libpq* dall'installazione di PostgreSQL.
569	597		- In linux aggiungete il percorso per trovare il file libpq.so alla sezione delle librerie nel vostro file /etc/fpc.cfg. Per esempio: -Fl/usr/local/pgsql/lib
570	598		- In windows, aggiungete queste librerie dove volete, in una directory indicata nella variabile d'ambiente Path o nella directory del progetto
571	599		- In windows, ho copiato tutte le dll presenti in C:\Program Files\PostgreSQL\8.1\bin in un'altra directory segnata in PATH
572	600		- Oppure aggiungete la directory postgres\bin al path
573	601
574	602		Un buon esempio sulla connessione tra Lazarus e PostgreSQL sotto Windows è [easyDB](http://http://paginas.fe.up.pt/~asousa/wiki/doku.php?id=proj:lazarus_projects).
575	603
576	604		## Lazarus e SQLite
577	605
578	606		di Luiz Américo
579	607
580	608		Visitate la [homepage di sqlite4fpc](http://www.geocities.com/camara_luiz/) per ottenere l'API reference e altre guide.
581	609
582	610		### Introduzione
583	611
584	612		TSqliteDataset e TSqlite3Dataset sono dei discendenti di TDataset che permettono l'accesso, rispettivamente, ai database sqlite 2.8.x e 3.x.x. Di seguito un elenco dei suoi principali vantaggi e svantaggi:
585	613
586	614		Vantaggi:
587	615
588	616		- Flessibilità: il programmatore può scegliere se usare o meno il linguaggio SQL, dando l'opportunità di lavorare su strutture formate da semplici tabelle o su strutture di qualsiasi complessità permesse da SQL/sqlite
589	617		- Aggiornamento automatico del database: nessun bisogno di aggiornare manualmente il database con comandi SQL; un singolo metodo si occupa di farlo
590	618		- Velocità: i dati vengono cacheati in memoria, per velocizzare la navigazione nel dataset
591	619		- Nessuna installazione/configurazione del server: una semplice dll da distribuire assieme al vostro eseguibile
592	620
593	621		Svantaggi:
594	622
595	623		- Richiede un file esterno (la libreria sqlite)
596	624
597	625		### Requisiti
598	626
599	627		- Per il database sqlite2:
600	628		- fpc 2.0.0
601	629		- Lazarus 0.9.10
602	630		- sqlite runtime library 2.8.15 o successivo (scaricabile da www.sqlite.org)
603	631
604	632		- Per il database sqlite3:
605	633		- fpc 2.0.2
606	634		- Lazarus 0.9.11 (revisione svn 8443 o seguente)
607	635		- sqlite runtime library 3.2.1 o successivo (scaricabile da www.sqlite.org)
608	636
609	637		Prima di iniziare un progetto lazarus, assicuratevi che:
610	638
611	639		- la libreria sqlite sia nel PATH di sistema o nella directory dell'eseguibile
612	640		- in Linux, indicate cmem come prima unit nella clausola uses del programma principale
613	641		- In Debian, Ubuntu e in altre distribuzioni Debian-like, per eseguire il build dell'IDE di Lazarus c'è bisogno di installare i package libsqlite-dev/libsqlite3-dev, oltre a sqlite/sqlite3 (vale anche per OpenSuSe)
614	642
615	643		### Come utilizzare SQLite (utilizzo di base)
616	644
617	645		Installate il package che trovate nella directory /components/sqlite ([[Install Packages\|qui]] le istruzioni)
618	646
619	647		A design time impostate le seguenti proprietà:
620	648
621	649		- FileName: percorso del database sqlite \[richiesto\]
622	650		- TableName: nome della table utilizzata nel comando sql \[richiesto\]
623	651		- Sql: un comando select SQL \[opzionale\]
624	652
625	653		Creare una Table (Dataset)
626	654
627	655		Doppio click sull'icona del componente o utilizzate la voce 'Create Table' dal menu popup che compare cliccando col tasto destro del mouse sull'icona del componente. Verrà visualizzato un semplice editor di table.
628	656
629		-	~~` Questi sono tutti i tipi di campi supportati da TSqliteDataset e TSqlite3Dataset: `\~~
630		-	~~` `\~~
631		-	~~` Integer`\~~
632		-	~~` AutoInc`\~~
633		-	~~` String`\~~
634		-	~~` Memo`\~~
635		-	~~` Bool `\~~
636		-	~~` Float`\~~
637		-	~~` Word`\~~
638		-	~~` DateTime`\~~
639		-	~~` Date`\~~
640		-	~~` Time`\~~
641		-	~~` LargeInt`\~~
642		-	~~` Currency`\~~
643		-	~~` `~~
	657	+	```text
	658	+	Questi sono tutti i tipi di campi supportati da TSqliteDataset e TSqlite3Dataset:
	659	+
	660	+	Integer
	661	+	AutoInc
	662	+	String
	663	+	Memo
	664	+	Bool
	665	+	Float
	666	+	Word
	667	+	DateTime
	668	+	Date
	669	+	Time
	670	+	LargeInt
	671	+	Currency
	672	+	```
644	673
645	674		Recuperare dati
646	675
647	676		Dopo aver creato la table o con una table creata in precedenza, aprite il dataset col metodo Open. Se la proprietà SQL non è stata impostata, allora verranno recuperati tutti i records da tutti i campi; stessa cosa se SQL è impostato a:
648	677
649		-	~~` SQL := 'Select * from TABLENAME'; `~~
	678	+	``` pascal
	679	+	SQL := 'Select * from TABLENAME';
	680	+	```
650	681
651	682		Applicare le modifiche al datafile
652	683
653	684		Per utilizzare la funzione ApplyUpdates, il dataset deve contenere almeno un campo che risponda ai requisiti di una Primary Key (i valori devono essere UNIQUE e non NULL)
654	685
655	686		E' possibile fare questo in due modi:
656	687
657	688		- Impostando la proprietà PrimaryKey al nome del campo Primary Key
658	689		- Aggiungendo un campo AutoInc (questo metodo è più semplice, poiché TSqliteDataSet lo gestisce automaticamente come Primary Key)
659	690
660	691		Se una delle due condizioni è soddisfatta basterà chiamare
661	692
662		-	~~` ApplyUpdates;`~~
	693	+	```text
	694	+	ApplyUpdates;
	695	+	```
663	696
664	697		PS1: se entrambe le condizioni sono impostate, il campo corrispondente al PrimaryKey viene utilizzato per apportare le modifiche.
665	698
666	699		PS2: Impostare come PrimaryKey un campo che non lo è porterà ad una perdita di dati chiamando ApplyUpdates, quindi assicuratevi che il campo scelto contenga valori non Null e Unique prima di usarlo.
667	700
668	701		### Note
669	702
670	703		- Benché sia stato testato con 10000 records ed abbia funzionato, TSqliteDataset mantiene tutti i dati in memoria, quindi ricordatevi di recuperare solo i dati necessari (principalmente con in campi Memo).
671	704		- Lo stesso datafile (proprietà Filename) può contenere diverse table/dataset
672	705		- Diversi dataset (diverse combinazioni di field) possono essere create utilizzando la stessa table contemporaneamente
673	706		- E' possibile filtrare i dati tramite il comando SQL WHERE, chiudendo e riaprendo il dataset (o chiamando il metodo RefetchData). Ma in questo caso, l'ordine e il numero dei campi deve rimanere lo stesso
674	707		- E' anche possibile utilizzare comandi SQL complessi come aliases, joins, views in table multiple (ricordate che devono risiedere nello stesso datafile), ma in questo caso ApplyUpdates non funzionerà. Se avete bisogno di utilizzare query complesse e di applicare le modifiche al datafile, inviatemi una mail e vi invierò alcuni consigli su come farlo
675	708		- E' possibile impostare il filename ad un datafile sqlite2.x non creato con TSqliteDataset e aprirlo, ma alcuni per alcuni campi non verrà riconosciuto correttamente il tipo. Verranno trattati come campi stringa.
676	709
677	710		Alcuni esempi generici possono essere trovati nella directory CVS fpc/fcl/db/sqlite
678	711
679	712		Luiz Américo pascalive(at)bol(dot)com(dot)br
680	713
681	714		## Lazarus e MSSQL
682	715
683	716		Funziona tramite Zeoslib (ultima versione da CVS). Controllate i link in fondo alla pagina.
684	717
685	718		Alternativamente, è possibile accedere ai database MSSQL via ODBC - senza nessun bisogno di installare Zeoslib o altre librerie aggiuntive - basta utilizzare il componente SQLdb incluso (l'ho testato con Lazarus v0.9.26.2)
686	719
687	720		Il codice di esempio qui sotto seleziona le righe da una tabella chiamata 'journal_entries' e mostra tutti i valori della colonna 'journal_entry' in un controllo Memo chiamato Memo1.
688	721
689	722		``` pascal
690	723		procedure TForm1.Button1Click(Sender: TObject);
691	724		var
692	725		S: String;
693	726		conn: TODBCConnection;
694	727		query: TSQLQuery;
695	728		transaction: TSQLTransaction;
696	729
697	730		begin
698	731		conn := TODBCCOnnection.Create(nil);
699	732		query := TSQLQuery.Create(nil);
700	733		transaction := TSQLTransaction.Create(nil);
701	734		try
702	735		try
703	736		conn.HostName := '127.0.0.1';
704	737		conn.DatabaseName := 'diary'; {replace this with the name of your database}
705	738		conn.Transaction := transaction;
706	739		conn.UserName:= 'db_username';
707	740		conn.Password:= '';
708	741		query.DataBase := conn;
709	742		query.UsePrimaryKeyAsKey:=false; {required, else you get "could not retrieve primary
710	743		key metadata". I was really stuck on this until I found
711	744		http://bugs.freepascal.org/view.php?id=13241}
712	745		query.SQL.Text := 'select * from diary.dbo.journal_entries';
713	746		query.Open;
714	747		S := '';
715	748		while not query.EOF do
716	749		begin
717	750		S := S + query.FieldByName('journal_entry').AsString + #13#10;
718	751		query.Next;
719	752		end;
720	753		finally
721	754		query.Free;
722	755		conn.Free;
723	756		end;
724	757		except
725	758		on E: Exception do
726	759		ShowMessage(E.message);
727	760		end;
728	761		Memo1.Text:= S;
729	762		end;
730	763		```
731	764
732	765		## Lazarus e Interbase / Firebird
733	766
734	767		Controllate [[Install Packages]]. In questa pagina c'è un piccolo esempio iniziale con una spiegazione su come connettersi a un server IB o FB.
735	768
736	769		Funziona Zeoslib anche con l'ultima versione di Zeoslib (dal CVS).
737	770
738	771		### Libreria FBLib per Firebird
739	772
740	773		[1](http://fblib.altervista.org/%7CFBLib) è una libreria Open Source Non Data Aware per l'accesso diretto al Database Relazionale Firebird da Borland Delphi / Kylix, Freepascal e Lazarus.
741	774
742	775		Caratteristiche attualmente implementate:
743	776
744	777		- Accesso diretto a Firebird 1.0.x 1.5.x Classic o SuperServer
745	778		- Multipiattaforma \[Win32, Gnu/Linux, FreeBSD)
746	779		- Selezione automatica della libreria client 'fbclient' o 'gds32'
747	780		- Query con parametri
748	781		- Supporto del dialetto 1/3 di SQL
749	782		- Licenza LGPL
750	783		- Estrazione di metadata
751	784		- Semplice parser di script
752	785		- Solo 100-150 KB aggiunti al file EXE finale
753	786		- Supporto dei campi BLOB
754	787		- Esportazione dei dati in HTML SQL Script
755	788		- Service manager (backup, ripristino, gfix...)
756	789		- Events Alerter
757	790
758	791		Potete scaricare la documentazione dal [sito di FBLib](http://fblib.altervista.org/).
759	792
760	793		## Lazarus e dBase
761	794
762	795		Tony Maro
763	796
764	797		Potete anche visitare la pagina [[Lazarus Tdbf Tutorial\|TDbf Tutorial]]
765	798
766	799		FPC include un semplice componente per database che funziona in modo simile al componente TTable di Delphi, chiamato "TDbf" ([TDbf Website](http://tdbf.sourceforge.net/)) che supporta un sottoinsieme base di caratteristiche per la gestione di files dBase. Non viene installato di default, quindi per prima cosa dovrete installarne il package dalla directory "lazarus/components/tdbf" ed eseguire il rebuild dell'IDE di Lazarus. Comparirà quindi vicino al componente TDatasource nella palette dei componenti (tab Data Access).
767	800
768	801		Il componente TDbf ha un vantaggio rispetto ad altri componenti per database nel fatto che non richiede nessun tipo di motore database a runtime; comunque non rappresenta la migliore alternativa per applicazioni con database molto grandi.
769	802
770	803		E' molto semplice da utilizzare: basta posizionare un TDbf sul form, impostare il percorso della directory dove si trovano i files del vostro database, impostare il nome della table e collegarlo ad un componente TDatasource.
771	804
772	805		Funzionalità più avanzate richiedono uno sforzo maggiore. Se una table non esiste, avrete bisogno di crearla in qualche modo, a meno che non ci sia qualche table designer compatibile di cui non sono a conoscenza. Nota: la versione corrente di OpenOffice (2.0x) contiene OpenOffice Base, che può creare files dbf in maniera molto semplice.
773	806
774	807		Provare ad aprire una table non esistente genererà un errore. Le table possono essere create tramite il componente dopo aver impostato il runtime path e il nome della table.
775	808
776	809		Per esempio, per creare una table chiamata "dvds" per gestire la vostra collezione di dvd dovrete posizionare il componente su un form, impostare il runtime path e modificare il table name in "dvds". Il risultante file del database verrà chiamato "dvds.dbf".
777	810
778	811		Nel codice, inserite quanto segue:
779	812
780	813		``` pascal
781	814		Dbf1.FilePathFull := '/path/to/my/database';
782	815		Dbf1.TableName := 'dvds';
783	816		With Dbf1.FieldDefs do begin
784	817		Add('Name', ftString, 80, True);
785	818		Add('Description', ftMemo, 0, False);
786	819		Add('Rating', ftString, 5, False);
787	820		end;
788	821		Dbf1.CreateTable;
789	822		```
790	823
791	824		Quando farete girare il programma, la table della vostra collezione di DVD verrà creata. Dopo di ciò, tutti i componenti data aware collegati tramite il TDatasource a questo componente permetteranno di accedere facilmente ai dati.
792	825
793	826		Aggiungere un indice risulta un po' differente da come si gestisce una TTable classica. Deve essere fatto dopo che il database è stato aperto. E' anche lo stesso metodo usato per ricostruire gli indici. Per esempio:
794	827
795	828		``` pascal
796	829		Dbf1.Exclusive := True;
797	830		Dbf1.Open;
798	831		Dbf1.AddIndex('dvdsname','Name',[ixPrimary, ixUnique, ixCaseInsensitive]);
799	832		Dbf1.AddIndex('rating.ndx', 'Rating', [ixCaseInsensitive]);
800	833		Dbf1.Close;
801	834		```
802	835
803	836		Il primo (primary) indice sarà un file chiamato "dvdsname.mdx" e il secondo sarà un file chiamato "rating.ndx", quindi in un database su diverse table dovrete fare attenzione a non utilizzare lo stesso nome di file più di una volta.
804	837
805	838		Proverò ad aggiungere un esempio più articolato in seguito, ma spero che questo permetterà ai vecchi programmatori Delphi di cominciare a lavorare con i database in Lazarus!
806	839
807	840		### Ricerca e Visualizzazione di un insieme di dati
808	841
809	842		Simon Batty
810	843
811	844		In questo esempio ho provato a fare una ricerca su un database di libri per tutti i titoli di un autore e a mostrarli in una memo box
812	845
813	846		``` pascal
814	847		Dbf1.FilePathFull := '/home/somelocatio/database_location/'; // path to the database directory
815	848		Dbf1.TableName := 'books.dbase'; // database file (including extension)
816	849		DbF1.Open;
817	850		memo1.Clear; // clear the memo box
818	851
819	852		Dbf1.FilterOptions := [foCaseInsensitive];
820	853		Df1.Filter := 'AU=' + QuotedStr('anauthor'); // AU is the field name containing the authors
821	854
822	855		Dbf1.Filtered := true; // This selects the filtered set
823	856		Dbf1.First; // moves the the first filtered data
824	857		while not dbf1.EOF do // prints the titles that match the author to the memo box
825	858		begin
826	859		memo1.Append(Dbf1.FieldByName('TI').AsString); // TI is the field name for titles
827	860		dbf1.next; // use .next here NOT .findnext!
828	861		end;
829	862		Dbf1.Close;
830	863		```
831	864
832	865		Notare che è possibile utilizzare Ddf1.findfirst per ottenere il primo record nell'elenco filtrato, quindi utilizzare Dbf1.next per muoversi tra i dati. Ho scoperto che l'utilizzo di Dbf1.Findnext causa un blocco del programma.
833	866
834	867		Questo database è stato generato utilizzando TurboBD che viene distribuito con Kylix 1. Non sono riuscito a far funzionare con Lazarus le table fatte con TurboBD; in ogni caso potete scaricare un tool da linea di comando dal sito di TurboDB che permette di convertire le table di TurboDB in altri formati.
835	868
836	869		## Utilizzare TSdfDataset e TFixedDataset
837	870
838	871		TSdfDataset e TFixedDataset sono due semplici dataset che offrono un formato di memorizzazione testuale molto semplice. Questi dataset sono molto comodi per piccoli database, perché sono totalmente implementati come una unità object pascal, quindi non richiedono librerie esterne, e perché il loro formato testuale permette di modificarli facilmente con un editor di testo.
839	872
840	873		Per iniziare con questi formati, bisogna creare un file per il database iniziale. Il formato è davvero semplice, quindi si può utilizare un editor di testo per farlo.
841	874
842	875		Qui in basso è riportato un database di esempio per TSdfDataset. Notare che la prima linea ha i nomi dei campi e che si stanno utilizzando le virgole come separatori:
843	876
844	877		ID,NAMEEN,NAMEPT,HEIGHT,WIDTH,PINS,DRAWINGCODE
845	878		1,resistor,resistor,1,1,1,LINE
846	879		2,capacitor,capacitor,1,1,1,LINE
847	880		3,transistor npn,transistor npn
848	881
849	882		E di seguito c'è un esempio di database da utilizzare con TFixedDataset. Ogni record occupa una quantità di spazio fissa e, se il campo è più piccolo, si dovranno usare degli spazi per riempirlo.
850	883
851	884		Name = 15 chars; Surname = 15 chars; Tell = 10 chars; e_mail = 20 chars;
852	885		Piet Pompies piet@pompies.net
853	886
854	887		### Utilizzare i dataset direttamente
855	888
856	889		Alcune volte può risultare utile creare un dataset e lavorare su di esso completamente via codice; il codice seguente mostra esattamente come farlo. Notare alcune caratteristiche di TSdfDataset/TFixedDataset:
857	890
858	891		- Le linee nel database possono avere una dimensione massima di circa 300. Si sta cercando un modo per ovviare al problema.
859	892		- E' necessario aggiungere le definizioni dei campi. Alcuni dataset sono in grado di ricavare da soli questa informazione a partire dal file del database
860	893		- Bisogna impostare FirstLineAsSchema a true, per indicare che la prima linea include il nome del campo e le posizioni
861	894		- La proprietà Delimiter contiene il separatore per i campi. Non sarà possibile utilizzare questo carattere nelle stringhe nel database. In maniera simile, non sarà possibile avere dei caratteri di fine riga nel database perché essi segnano il passaggio da un record al successivo. E' possibile ovviare all'inconveniente sostituendo la virgola o il fine riga con un altro carattere poso usato, come ad esempio \#. Quindi, mostrando i dati sullo schermo, tutti i caratteri \# potranno essere convertiti in fine riga; al contrario, memorizzando i dati nel database, tutti i fine riga verranno convertiti in \#. La funzione ReplaceString può tornare utile in questo caso.
862	895
863	896		``` pascal
864	897		constructor TComponentsDatabase.Create;
865	898		begin
866	899		inherited Create;
867	900
868	901		FDataset := TSdfDataset.Create(nil);
869	902		FDataset.FileName := vConfigurations.ComponentsDBFile;
870	903
871	904		// Not necessary with TSdfDataset
872	905		// FDataset.TableName := STR_DB_COMPONENTS_TABLE;
873	906		// FDataset.PrimaryKey := STR_DB_COMPONENTS_ID;
874	907
875	908		// Adds field definitions
876	909		FDataset.FieldDefs.Add('ID', ftString);
877	910		FDataset.FieldDefs.Add('NAMEEN', ftString);
878	911		FDataset.FieldDefs.Add('NAMEPT', ftString);
879	912		FDataset.FieldDefs.Add('HEIGHT', ftString);
880	913		FDataset.FieldDefs.Add('WIDTH', ftString);
881	914		FDataset.FieldDefs.Add('PINS', ftString);
882	915		FDataset.FieldDefs.Add('DRAWINGCODE', ftString);
883	916
884	917		// Necessary for TSdfDataset
885	918		FDataset.Delimiter := ',';
886	919		FDataset.FirstLineAsSchema := True;
887	920
888	921		FDataset.Active := True;
889	922
890	923		// Sets the initial record
891	924		CurrentRecNo := 1;
892	925		FDataset.First;
893	926		end;
894	927		```
895	928
896	929		Quando si usa direttamente TSdfDataset, bisogna tenere presente che RecNo, benché sia implementato, non funziona come modo per muoversi attraverso il dataset sia in lettura che in scrittura dei record. Le funzioni standard di navigazione come First, Next, Prior e Last funzionano come previsto, quindi si dovranno usare quest'ultime piuttosto che RecNo. Se si è soliti utilizzare numeri di record assoluti per navigare in un database, è possibile implementare la propria versione di RecNo. E' sufficiente dichiarare una variabile globale di tipo longint chiamata CurrentRecNo che conterrà il valore corrente di RecNo. Bisogna ricordare che questa variabile seguirà la stessa convenzione di RecNo, quindi il primo record first sarà 1 (non è zero-based). Dopo l'attivazione del database bisogna inizializzarlo al primo record tramite TSdfDataset.First e impostare CurrentRecNo := 1
897	930
898	931		``` pascal
899	932		{@@
900	933		Moves to the desired record using TDataset.Next and TDataset.Prior
901	934		This avoids using TDataset.RecNo which doesn't navigate reliably in any dataset.
902	935
903	936		@param AID Indicates the record number. The first record has number 1
904	937		}
905	938		procedure TComponentsDatabase.GoToRec(AID: Integer);
906	939		begin
907	940		// We are before the desired record, move forward
908	941		if CurrentRecNo < AID then
909	942		begin
910	943		while (not FDataset.EOF) and (CurrentRecNo < AID) do
911	944		begin
912	945		FDataset.Next;
913	946		FDataset.CursorPosChanged;
914	947		Inc(CurrentRecNo);
915	948		end;
916	949		end
917	950		// We are after the desired record, move back
918	951		else if CurrentRecNo > AID then
919	952		begin
920	953		while (CurrentRecNo >= 1) and (CurrentRecNo > AID) do
921	954		begin
922	955		FDataset.Prior;
923	956		FDataset.CursorPosChanged;
924	957		Dec(CurrentRecNo);
925	958		end;
926	959		end;
927	960		end;
928	961		```
929	962
930	963		### Using with data-aware controls
931	964
932	965		## Altri Links
933	966
934	967		- [[Databases\|Creating Databases Applications with Lazarus using the DB-unit]]\
935	968		- [[MySQLDatabases\|Creating a database application using MySQL]]\
936	969		- [[Zeos tutorial\|Creating a database application using the Zeos components]]
937	970		- [Pascal Data Objects](http://pdo.sourceforge.net) is a database API that worked for both FPC and Delphi and utilises native MySQL libraries for version 4.1 and 5.0 and Firebird SQL 1.5, and 2.0. It's inspired by PHP's PDO class.
938	971
939	972		## Contributi e Modifiche
940	973
941	974		Questa pagina è stata convertita dalla [versione](http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusDatabase) di epikwiki.
942	975
943	976		---
944	977		From the Free Pascal wiki, page "Lazarus Database Tutorial/it", as it stood on 2020-02-18 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).
945	978		Category: Italiano

Back to history