Lazarus Database Tutorial/de: what changed

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

Old	New		Line
1	1		Zurück zu den [[Additional information/de\|Zusätzlichen Informationen]].\
2	2
3	3		== Überblick ==
4	4
5	5		Das Thema dieses Tutorial ist, wie Lazarus mit einer Auswahl von existierenden Datenbanken zusammenarbeiten kann.
6	6
7	7		Bitte erweitern sie diesen Bereich.
8	8
9	9		## Lazarus und MySQL
10	10
11	11		### MySQL unter Linux oder Windows zum Laufen bringen
12	12
13	13		Folgen sie den Anweisungen im MySQL Benutzerhandbuch. Stellen sie sicher, dass der mysqld Daemon zuverlässig läuft (zumindest bei Linux), und dass alle potentiellen Benutzer (inclusive root, mysql, sie selbst und jeder sonst, der es benötigen könnte) so viele Rechte (privileges) wie nötig hat, von so vielen Hosts wie nötig (inclusive 'localhost', dem lokalen Host Namen, jedem anderen Host in ihrem Netzwerk) so weit es mit der Sicherheit vereinbar ist. Auch haben viele benötigte Dateien im fpcsrc- und im lazarus-Ordner stark eingeschränkte Schreibrechte, die root erst ändern muss, wenn andere User damit arbeiten sollen. Mangelnde Schreibrechte in Units zeigt Lazarus durch die Fehlermeldung "Error while linking" an. Es ist wünschenswert, dass alle Benutzer inclusive root Passwörter haben. Testen sie die Wirkung des Datenbanksystems bei der Benutzung der Beispiele aus dem Handbuch, und prüfen sie, dass alle Benutzer wirklich einen zuverlässigen Zugriff haben.
14	14
15	15		### MySQL für FPC im Textmodus zum Laufen bringen
16	16
17	17		MySQL-Sourcen einbinden Es gibt ein Verzeichnis mit einem Beispielprogramm in \$(fpcsrcdir)/packages/base/mysql/. Sie können das FPC Quellverzeichnis in Lazarus wie folgt finden: Werkzeuge -\> Einstellungen -\> Umgebung -\> Dateien -\> FPC-Quelltextverzeichnis. Mögliche Pfade für das mysql Verzeichnis sind /usr/share/fpcsrc/packages/base/mysql/ (rpm Installation) oder C:\lazarus\fpcsrc\packages\base\mysql\\ (Windows). Dieses Verzeichnis enthält auch die Units mysql.pp, mysql_com.pp und mysql_version.pp.
18	18
19	19		Datenbank vorbereiten Bevor sie das Testscript starten, müssen sie eine Datenbank mit dem Namen testdb anlegen: Tun sie dies, indem sie sich in den mysql Monitor einloggen (als root mit allen Rechten (privileges)) und das folgende SQL Statement eingeben
20	20
21		-	~~`CREATE DATABASE testdb;`~~
	21	+	```text
	22	+	CREATE DATABASE testdb;
	23	+	```
22	24
23	25		Dann müssen sie sicherstellen, dass alle relevanten Benutzer einen passenden Zugriff darauf haben
24	26
25		-	~~`GRANT ALL ON testdb TO johnny@localhost IDENTIFIED BY 'johnnyspassword'; `~~
	27	+	```text
	28	+	GRANT ALL ON testdb TO johnny@localhost IDENTIFIED BY 'johnnyspassword';
	29	+	```
26	30
27	31		Es gibt ein Script namens mkdb, welches sie nun starten sollten:
28	32
29		-	~~`sh ./mkdb`~~
	33	+	```text
	34	+	sh ./mkdb
	35	+	```
30	36
31	37		Dies wird wahrscheinlich fehlschlagen, weil das System keinem anonymen Benutzer den Zugriff auf die Datenbank erlauben wird. Ändern sie deshalb das Script mit einem Editor, so dass die Zeile, in der mysql aufgerufen wird, wie folgt aussieht:
32	38
33		-	~~`mysql -u root -p ${1-testdb} << EOF >/dev/null`~~
	39	+	```text
	40	+	mysql -u root -p ${1-testdb} << EOF >/dev/null
	41	+	```
34	42
35	43		und versuchen sie, es erneut zu starten. Geben sie ihr Passwort ein, wenn danach verlangt wird. Mit etwas Glück ist es ihnen gelungen, die Testdatenbank anzulegen: testen sie es (während sie im mysql Monitor eingeloggt sind) unter Verwendung der mysql Anweisung
36	44
37		-	~~`select * from FPdev;`~~
	45	+	```text
	46	+	select * from FPdev;
	47	+	```
38	48
39	49		Sie sollten eine Tabelle sehen, welche die ID, den Benutzernamen und die Emailadresse von einem der FPC Entwickler enthält.
40	50
41	51		Testprogramm starten Versuchen sie nun, das Testprogramm testdb.pp zu starten (dieses muss evtl. noch kompiliert werden, und wird beinahe sicher beim ersten Versuch fehlschlagen!!).
42	52
43	53		Ich habe herausgefunden, dass das Programm aus verschiedenen Gründen nicht mit mysql verbinden konnte:
44	54
45	55		- Mein System (SuSE Linux v9.0) installiert mysql v4.0.15, nicht die Version 3, für welche das Package bestimmt war.
46	56
47	57		- Das Programm benötigt Benutzernamen und Passwörter, um Zugriff auf die Datenbank zu erhalten.
48	58
49	59		- Der Compiler muss wissen, wo die mysql Bibliotheken zu finden sind. (Wenn sie die mysql Entwicklungs-Bibliotheken nicht installiert haben, dann tun sie es jetzt!)
50	60
51	61		Ich erzeugte eine Kopie von testdb.pp mit dem Namen trydb.pp, eher als das Original zu bearbeiten - das bedeutet, dass die originalen Dateien in späteren CVS Updates noch bereinigt werden. Ich kopierte auch die Dateien aus dem Unterverzeichnis mysql/ver40/ in das Haupt- mysql/ Unterverzeichnis, benannte sie in mysql_v4.pp, mysql_com_v4.pp und mysql_version_v4.pp um, um sicher zu sein, die Units mit jeder Datei entsprechend umzubenennen. Ich änderte die uses Anweisung in trydb.pp zu
52	62
53		-	~~`uses mysql_v4`~~
	63	+	``` pascal
	64	+	uses mysql_v4
	65	+	```
54	66
55	67		und die Anweisung in mysql_v4.pp zu
56	68
57		-	~~`uses mysql_com_v4`~~
	69	+	``` pascal
	70	+	uses mysql_com_v4
	71	+	```
58	72
59	73		Ich fügte eine Zeile zu /etc/fpc.cfg hinzu, um auf meine Bibliotheken zu zeigen:
60	74
61		-	~~`-Fl/lib;/usr/lib`~~
	75	+	```text
	76	+	-Fl/lib;/usr/lib
	77	+	```
62	78
63	79		Der folgende Schritt mag nicht notwendig sein, wenn die devel-Biblitheken installiert sind wie die Links für sie erzeugt sind, aber es kann nie schaden, es zu prüfen. Ich musste den tatsächlichen Namen der mysqlclint Bibliothek im /usr/lib Verzeichnis finden und in meinem Fall das folgende shell-Kommando eingeben:
64	80
65		-	~~`ln -s libmysqlclient.so.12.0.0 lmysqlclient`~~
	81	+	```text
	82	+	ln -s libmysqlclient.so.12.0.0 lmysqlclient
	83	+	```
66	84
67	85		um einen symbolischen Link zu erstellen, um FPC zu erlauben, die Bibliothek zu finden. Für ein gutes Maß erzeugte ich auch den Link
68	86
69		-	~~`ln -s libmysqlclient.so.12.0.0 mysqlclient`~~
	87	+	```text
	88	+	ln -s libmysqlclient.so.12.0.0 mysqlclient
	89	+	```
70	90
71	91		und plazierte einfache Links in verschiedenen anderen Verzeichnissen: nicht unbedingt notwendig, aber für alle Fälle ...! Einige Benutzer müssen evtl. den folgenden Link hinzufügen:
72	92
73		-	~~`ln -s libmysqlclient.so.12.0.0 libmysqlclient.so`~~
	93	+	```text
	94	+	ln -s libmysqlclient.so.12.0.0 libmysqlclient.so
	95	+	```
74	96
75	97		Ich modifizierte trydb.pp, um Benutzerdetails einzubeziehen, zunächst indem ich host, Benutzer und Passwort als Konstanten hinzufügte:
76	98
77		-	~~`const`\~~
78		-	~~` host : Pchar= 'localhost';`\~~
79		-	~~` user : Pchar= 'myusername';`\~~
80		-	~~` passwd: Pchar = 'mypassword';`~~
	99	+	``` pascal
	100	+	const
	101	+	host : Pchar= 'localhost';
	102	+	user : Pchar= 'myusername';
	103	+	passwd: Pchar = 'mypassword';
	104	+	```
81	105
82	106		Ich habe auch herausgefunden, dass ich keine Verbindung zu mysql mit der Benutzung des mysql_connect() Aufrufs bekam, aber mit mysql_real_connect(), das mehr Parameter hat. Um die Dinge weiter zu komplizieren, scheint die Anzahl der Parameter zwischen Version3 (wo es sieben sind) und Version4 (wo es acht sind) geändert werden zu müssen. Vor der Benutzung von using mysql_real_connect musste ich mysql_init() verwenden, das nicht in der originalen mysql.pp zu finden ist, aber in mysql_v4.pp.
83	107
84	108		Daher ist der Code für die Verbindung zur Datenbank jetzt:
85	109
86	110		``` pascal
87	111		{ einige extra Variablen}
88	112		var
89	113		alloc : PMYSQL;
90	114
91	115		{Teil des Hauptprogramms}
92	116
93	117		begin
94	118		if paramcount=1 then
95	119		begin
96	120		Dummy:=Paramstr(1)+#0;
97	121		DataBase:=@Dummy[1];
98	122		end;
99	123
100	124		Writeln ('Allocating Space...');
101	125		alloc := mysql_init(PMYSQL(@qmysql));
102	126		Write ('Connecting to MySQL...');
103	127		sock := mysql_real_connect(alloc, host, user, passwd, database, 0, nil, 0);
104	128		if sock=Nil then
105	129		begin
106	130		Writeln (stderr,'Couldn''t connect to MySQL.');
107	131		Writeln (stderr, 'Error was: ', mysql_error(@qmysql));
108	132		halt(1);
109	133		end;
110	134		Writeln ('Done.');
111	135		Writeln ('Connection data:');
112	136		{$ifdef Unix}
113	137		writeln ('Mysql_port : ',mysql_port);
114	138		writeln ('Mysql_unix_port : ',mysql_unix_port);
115	139		{$endif}
116	140		writeln ('Host info : ',mysql_get_host_info(sock));
117	141		writeln ('Server info : ',mysql_stat(sock));
118	142		writeln ('Client info : ',mysql_get_client_info);
119	143
120	144		Writeln ('Selecting Database ',DataBase,'...');
121	145		if mysql_select_db(sock,DataBase) < 0 then
122	146		begin
123	147		Writeln (stderr,'Couldn''t select database ',Database);
124	148		Writeln (stderr,mysql_error(sock));
125	149		halt (1);
126	150		end;
127	151		{... wie die Originalinhalte von testdb.pp}
128	152		```
129	153
130	154		Jetzt - sind sie bereit, um die Kompilierung von trydb.pp zu starten?
131	155
132		-	~~` fpc trydb`~~
	156	+	```text
	157	+	fpc trydb
	158	+	```
133	159
134	160		Erfolg! Jetzt starten sie es:
135	161
136		-	~~` ./trydb`~~
	162	+	```text
	163	+	./trydb
	164	+	```
137	165
138	166		whoopee! Ich erhielt die Auflistung der FPC Entwickler!
139	167
140	168		Einige zusätzliche Feinheiten: Machen sie die Eingabe der Benutzerdetails und der mysql Befehle interaktiv; benutzen sie eher Variablen als Konstanten und erlauben sie die Eingabe verschiedener SQL Befehle, bis wir den quit Befehl geben: schauen sie in der [[Lazarus Database Tutorial/TryDbpp\|vollen Programmauflistung]] nach, wo Benutzerdetails von der Konsole aus eingegeben werden und das Programm in eine Schleife geht; wo SQL-Befehle von der Konsole aus eingegeben werden (ohne das abschließende Semikolon) und die Antworten ausgedruckt werden, bis 'quit' über die Tastatur eingegeben wird.
141	169
142	170		Siehe [[Lazarus Database Tutorial/SampleListing\|Einfaches Konsole Listing]] .
143	171
144	172		### Verbindung zu MySQL von einer Lazarus Anwendung aus
145	173
146	174		Dieses Tutorial zeigt, wie man Lazarus bei einer MySQL Datenbank anmelden und einfache Abfragen ausführen kann, lediglich unter Verwendung der Lazarus Grundkomponenten; es benutzt keine datensensitiven Komponenten, aber es illustriert die Prinzipien der Kopplung mit der Datenbank.
147	175
148	176		Achtung bei Windows: wir benötigen die libmysql.dll in der rightigen Version. Welche version benötigt wird erfahren Sie aus den Sourcen (üblicherweise aus der mysql_version.pp).
149	177
150	178		Erzeugen sie ein neues Projekt in Lazarus:
151	179
152		-	~~`Projekt -> Neues Projekt -> Anwendung`~~
	180	+	```text
	181	+	Projekt -> Neues Projekt -> Anwendung
	182	+	```
153	183
154	184		Ein neues automatisch erzeugtes Formular wird erscheinen.
155	185
156	186		Vergrößern sie das Formular bis es etwa die Hälfte ihres Bildschirms ausfüllt, dann benennen sie das Formular und seine Titelzeile (caption) in 'TryMySQL' um.
157	187
158	188		Von der Standard Komponentenpalette platzieren sie drei Edit Felder oben links auf dem Formular, und platzieren sofort über jedem Feld ein Label. Ändern sie die Namen und Captions zu 'Host' (und HostLLabel,HostEdit), 'UserName' (und UserLabel, UserEdit) und 'Password' (mit PasswdLabel und PasswdEdit). Alternativ können sie LabelledEdit Komponenten von der Additional Palette benutzen.
159	189
160	190		Wählen sie das Passwd Editfeld und finden sie die PasswordChar Eigenschaft: ändern sie diese dies auf * oder ein anderes Zeichen, so dass ihrer Eingaben in diesem Feld nicht erscheinen, sondern nur eine Reihe von * erscheint. Stellen sie sicher, dass die Eigenschaft Text für jedes Editfeld leer ist.
161	191
162	192		Nun platzieren sie eine neues Edit Feld und Label oben rechts auf ihrem Formular. Ändern sie die Label Caption zu 'Enter SQL Command' und nennen sie es CommandEdit.
163	193
164	194		Platzieren sie drei Buttons auf dem Formular: zwei links unter den Edit Feldern, und einen rechts unter dem command Feld.
165	195
166	196		Benennen sie die Buttons auf der linken Seite 'Connect to Database' (ConnectButton) und 'Exit' (ExitButton) und den auf der rechten Seite 'Send Query' (QueryButton).
167	197
168	198		Platzieren sie ein großes Memo Feld mit Label und Namen 'Results' (ResultMemo) unten rechts, um den meisten verfügbaren Platz auszufüllen. Finden sie seine ScrollBars Eigenschaft und wählen sie ssAutoBoth, so dass die Bildlaufleisten automatisch erscheinen wenn Text die Leerstellen füllt. Setzen sie die WordWrap Eigenschaft auf True.
169	199
170	200		Platzieren sie eine Status Bar (von der Common Controls Palette) am unteren Ende des Formulars, und setzen seine SimpleText Eigenschaft auf 'TryMySQL'.
171	201
172	202		Ein Bildschirmfoto des Formulars ist hier zu sehen: [Mysql Beispiel Screenshot](http://lazarus-ccr.sourceforge.net/kbdata/trymysqldb.png)
173	203
174	204		Nun müssen wir einige Ereignis-Handler schreiben.
175	205
176	206		Die drei Edit-Boxen auf der linken sind für die Eingabe von Hostnamen, Benutzernamen und Passwort. Wenn diese zufriedenstellend eingegeben wurden, wird der Connect Button angeklickt. Der OnCLick Ereignis handler für diesen Button beruht auf Teilen des Textmodus FPC Programms oberhalb.
177	207
178	208		Die Antworten von der Datenbank können jetzt nicht mit den Pascal write oder writeln Anweisungen geschrieben werden. Stattdessen müssen die Antworten in Strings konvertiert und in einem Memo Feld angezeigt werden. Wohingegen die Pascal write und writeln Anweisungen geeignet sind, eine Menge von Typumformungen 'on the fly' durchzuführen, die Benutzung eines Memo Felds für die Textausgabe erfordert die explizite Konvertierung von Datentypen in die korrekte Form eines string, daher müssen Pchar Variablen in Strings konvertiert werden mit StrPas, und Integers müssen mit IntToStr konvertiert werden.
179	209
180	210		Strings werden im Memo Feld angezeigt unter Verwendung von
181	211
182		-	~~`procedure ShowString (S : string);`\~~
183		-	~~`(* zeigt einen String in einem Memo Feld an *)`\~~
184		-	~~`begin`\~~
185		-	~~` trymysqlForm1.ResultsMemo.Lines.Add (S)`\~~
186		-	~~`end;`~~
	212	+	``` pascal
	213	+	procedure ShowString (S : string);
	214	+	(* zeigt einen String in einem Memo Feld an *)
	215	+	begin
	216	+	trymysqlForm1.ResultsMemo.Lines.Add (S)
	217	+	end;
	218	+	```
187	219
188	220		Der ConnectButton Ereignis-handler wird daher:
189	221
190	222		``` pascal
191	223		procedure TtrymysqlForm1.ConnectButtonClick(Sender: TObject);
192	224		(* Verbinden zu MySQL unter Verwendung der Benutzerdaten von den Texteingabefeldern auf Main Form *)
193	225		var strg: string;
194	226
195	227		begin
196	228
197	229		dummy1 := trymysqlForm1.HostEdit.text+#0;
198	230		host := @dummy1[1];
199	231		dummy2 := trymysqlForm1.UserEdit.text+#0;
200	232		user := @dummy2[1] ;
201	233		dummy3 := trymysqlForm1.PasswdEdit.text+#0;
202	234		passwd := @dummy3[1] ;
203	235
204	236		alloc := mysql_init(PMYSQL(@qmysql));
205	237		sock := mysql_real_connect(alloc, host, user, passwd, database, 0, nil, 0);
206	238		if sock=Nil then
207	239		begin
208	240		strg :='Couldn''t connect to MySQL.'; showstring (strg);
209	241		Strg :='Error was: '+ StrPas(mysql_error(@qmysql)); showstring (strg);
210	242		end
211	243		else
212	244		begin
213	245		trymysqlForm1.statusBar1.simpletext := 'Connected to MySQL';
214	246		strg := 'Now choosing database : ' + database; showstring (strg);
215	247		{$ifdef Unix}
216	248		strg :='Mysql_port : '+ IntToStr(mysql_port); showstring (strg);
217	249		strg :='Mysql_unix_port : ' + StrPas(mysql_unix_port); showstring (strg);
218	250		{$endif}
219	251		Strg :='Host info : ' + StrPas(mysql_get_host_info(sock));
220	252		showstring (strg);
221	253		Strg :='Server info : ' + StrPas(mysql_stat(sock)); showstring (strg);
222	254		Strg :='Client info : ' + Strpas(mysql_get_client_info); showstring (strg);
223	255
224	256		trymysqlForm1.statusbar1.simpletext := 'Selecting Database ' + DataBase +'...';
225	257		if mysql_select_db(sock,DataBase) < 0 then
226	258		begin
227	259		strg :='Couldn''t select database '+ Database; ShowString (strg);
228	260		Strg := mysql_error(sock); ShowString (strg);
229	261		end
230	262		end;
231	263		end;
232	264		```
233	265
234	266		Das Textfeld rechts erlaubt die Eingabe einer SQL-Anweisung, ohne abschließendes Semikolon. Wenn sie mit seinem Inhalt oder Schreibweise zufrieden sind, drücken sie den SendQuery-Button, und die Abfrage wird abgearbeitet, mit den Ergebnissen, die in das ResultsMemo-Feld geschrieben sind.
235	267
236	268		Der SendQuery Ereignis-Handler basiert wieder auf der FPC Textmodus Version, abgesehen davon, dass eine explizite Typenkonversion erfolgen muss bevor Strings in der Box angezeigt werden.
237	269
238	270		Ein Unterschied zu dem Textmodus FPC Programm ist, dass das Programm nicht stoppt und MySQL nicht geschlossen wird, wenn eine Fehlerbedingung entdeckt wird. Stattdessen geht die Kontrolle an das Hauptformular zurück und eine Gelegenheit wird gegeben, den Eintrag zu berichtigen, bevor das Kommando neu eingereicht wird. Die Anwendung wird schließlich beendet (mit Schliessen von MySQL), wenn der Exit-Button angeklickt wird.
239	271
240	272		Der Code für SendQuery folgt:
241	273
242	274		``` pascal
243	275		procedure TtrymysqlForm1.QueryButtonClick(Sender: TObject);
244	276		var
245	277		dumquery, strg: string;
246	278		begin
247	279		dumquery := TrymysqlForm1.CommandEdit.text;
248	280		dumquery := dumquery+#0;
249	281		query := @dumquery[1];
250	282		trymysqlForm1.statusbar1.simpletext := 'Executing query : '+ dumQuery +'...';
251	283		strg := 'Executing query : ' + dumQuery; showstring (strg);
252	284		if (mysql_query(sock,Query) < 0) then
253	285		begin
254	286		Strg :='Query failed '+ StrPas(mysql_error(sock)); showstring (strg);
255	287		end
256	288		else
257	289		begin
258	290		recbuf := mysql_store_result(sock);
259	291		if RecBuf=Nil then
260	292		begin
261	293		Strg :='Query returned nil result.'; showstring (strg);
262	294		end
263	295		else
264	296		begin
265	297		strg :='Number of records returned : ' + IntToStr(mysql_num_rows (recbuf));
266	298		Showstring (strg);
267	299		Strg :='Number of fields per record : ' + IntToStr(mysql_num_fields(recbuf));
268	300		showstring (strg);
269	301		rowbuf := mysql_fetch_row(recbuf);
270	302		while (rowbuf <>nil) do
271	303		begin
272	304		Strg :='(Id: '+ rowbuf[0]+', Name: ' + rowbuf[1]+ ', Email : ' +
273	305		rowbuf[2] +')';
274	306		showstring (strg);
275	307		rowbuf := mysql_fetch_row(recbuf);
276	308		end;
277	309		end;
278	310		end;
279	311		end;
280	312		```
281	313
282	314		Speichern sie ihr Projekt, und drücken Start -\> Start
283	315
284	316		#### Download des MYSQL Quelltextes
285	317
286	318		Eine volle Auflistung des Programms gibt es hier [Beispiel Quellcode](http://lazarus-ccr.sourceforge.net/kbdata/mysqldemo.tar.gz)
287	319
288	320		### Lazarus, MySQL und UTF-8
289	321
290	322		Das folgende könnte auch für andere Codepages/Zeichensätze erforderlich sein.
291	323
292	324		UTF-8 Unicode ist eine praktische Kodierung eines Multibyte-Zeichensatzes, der es gestattet, mit mehrsprachigen Texten zu arbeiten, ohne dazu WideStrings einzusetzen. Er wird von den Lazarus-SQLdb-Komponenten und von MySQL seit Version 4.1 unterstützt durch die Auswahl eines geeigneten Zeichensatzes.
293	325
294	326		Allerdings gilt: ein einfaches Setzen dieser Kodierung als Vorgabe für Ihre Tabellen und die MySQL-Connection-Komponente resultiert in inkorrekter Speicherung und Rückgabe von UTF-8 Strings, wenn bestimmte akzentuierte/internationale Zeichen als Fragezeichen (?) angezeigt werden. Offensichtlich liegt die Ursache dafür darin, dass die MySQL-Client-Bibliothek mit dem Zeichensatz 'Latin1' als Vorgabe kompiliert wurde.
295	327
296	328		Um eine korrekte Kommunikation zwischen Lazarus, der MySQL-Client-Bibliothek und dem MySQL-Server zu aktivieren, müssen zwei zusätzliche Abfragen jedes Mal ausgeführt werden, wenn eine Verbindung zur Datenbank aufgebaut wird:
297	329
298	330		``` sql
299	331		SET CHARACTER SET `utf8`
300	332		```
301	333
302	334		und
303	335
304	336		``` sql
305	337		SET NAMES 'utf8'
306	338		```
307	339
308	340		Die erste Abfrage stellt sicher, dass Ihre Anwendung die Zeichenketten in korrekter Kodierung empfängt. Und die zweite weist MySQL an, nicht die Strings zu konvertieren, die es von Ihrer Anwendung erhält.
309	341
310	342		## Simple MySQL Demo Using the TMySQL50Connection Component
311	343
312	344		Here is code that functions as a quick demo to get up and running simply (tested on Win XP with Lighty2Go, though xampp would be just as suitable). libmysql.dll was put in the project and lazarus.exe directories (available from a directory in Lighty2Go or xampp - but ensure that you use the correct version of libmysql.dll to match the chosen TMySQL5xxConnection Component - for TMySQL50Connection use the version for MySQL 5.0 (1484kB) and this can connect fine to both MySQL 5.0 and MySQL 5.1 DBMSs. The 5.1 version of libmysql.dll will not function with TMySQL50Connection). There is no requirement to place any components on the form other than the three edit boxes, a memo box and a few buttons. You need to add mysql50conn and sqldb to the uses statement. The Lazarus component directory must be rw for the programmer. The mysql dbms here has a user 'root' with no password, and a database test1 with table tPerson which has three fields: personid (int), surname (varchar(40)) and dob (datetime). phpMyAdmin (in Lighty2Go) was used to create the db, table and fields and insert some sample data. Note that dates in phpMyAdmin should be entered YYYY-MM-DD, though the program created below will accept dates in the usual formats. The button btnTest must be clicked first as it creates the connection with the dbms. Note the line that applies updates - without this the changed or new data will not be written back to the db though they will be in memory and can be viewed using btnFirst and btnNext.
313	345
314	346		``` pascal
315	347		unit unt_db;
316	348		// Example based on:
317	349		// http://www.lazarus.freepascal.org/index.php?name=PNphpBB2&file=viewtopic&t=5761
318	350		// from tpglemur on that forum
319	351		{$mode objfpc}{$H+}
320	352		interface
321	353		uses
322	354		Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs,
323	355		mysql50conn, sqldb, StdCtrls;
324	356		type
325	357		{ TForm1 }
326	358		TForm1 = class(TForm)
327	359		btnTest: TButton;
328	360		btnNext: TButton;
329	361		btnFirst: TButton;
330	362		btnNew: TButton;
331	363		edtPersonID: TEdit;
332	364		edtSurname: TEdit;
333	365		edtDOB: TEdit;
334	366		Memo1: TMemo;
335	367		procedure btnFirstClick(Sender: TObject);
336	368		procedure btnNewClick(Sender: TObject);
337	369		procedure btnNextClick(Sender: TObject);
338	370		procedure btnTestClick(Sender: TObject);
339	371		private
340	372		{ private declarations }
341	373		conn : TMySQL50Connection;
342	374		query : TSQLQuery;
343	375		transaction : TSQLTransaction;
344	376		procedure Display;
345	377		public
346	378		{ public declarations }
347	379		end;
348	380		var
349	381		Form1: TForm1;
350	382		implementation
351	383		{ TForm1 }
352	384		procedure TForm1.btnTestClick(Sender: TObject);
353	385		var
354	386		S: String;
355	387		begin
356	388		conn := TMySQL50Connection.Create(nil);
357	389		query := TSQLQuery.Create(nil);
358	390		transaction := TSQLTransaction.Create(nil);
359	391		try
360	392		try
361	393		conn.HostName := '127.0.0.1';
362	394		conn.UserName := 'root';
363	395		conn.Password := '';
364	396		conn.DatabaseName := 'test1';
365	397		conn.Connected := True;
366	398		conn.Transaction := transaction;
367	399		query.DataBase := conn;
368	400		//query.ParseSQL := true; //line not needed - this is the default anyway
369	401		//query.ReadOnly := false; //line not needed - this is the default anyway
370	402		query.SQL.Text := 'select * from tperson';
371	403		query.Open;
372	404
373	405		query.Last;
374	406		S := IntToStr(query.RecordCount) + #13#10;
375	407		query.First;
376	408
377	409		while not query.EOF do
378	410		begin
379	411		S := S + query.FieldByName('surname').AsString + #13#10;
380	412		query.Next;
381	413		end;
382	414		finally
383	415		//query.Free;
384	416		//conn.Free;
385	417		end;
386	418		except
387	419		on E: Exception do
388	420		ShowMessage(E.message);
389	421		end;
390	422		Memo1.Text:= S;
391	423		end;
392	424
393	425		procedure TForm1.Display;
394	426		begin
395	427		edtPersonID.Text := query.FieldByName('personid').AsString;
396	428		edtSurname.Text := query.FieldByName('surname').AsString;
397	429		edtDOB.Text := query.FieldByName('dob').AsString;
398	430		end;
399	431
400	432		procedure TForm1.btnFirstClick(Sender: TObject);
401	433		begin
402	434		query.First;
403	435		Display;
404	436		end;
405	437
406	438		procedure TForm1.btnNewClick(Sender: TObject);
407	439		begin
408	440		query.Append;
409	441		query.FieldValues['personid'] := edtPersonID.Text;
410	442		query.FieldValues['surname'] := edtSurname.Text;
411	443		query.FieldValues['dob'] := edtDOB.Text;
412	444		query.Post;
413	445		query.ApplyUpdates; //to apply update
414	446		//transaction.Commit; //line not needed
415	447		end;
416	448
417	449		procedure TForm1.btnNextClick(Sender: TObject);
418	450		begin
419	451		query.Next;
420	452		Display;
421	453		end;
422	454
423	455		initialization
424	456		{$I unt_db.lrs}
425	457		end.
426	458		```
427	459
428	460		Here is a version using the TMySQL50Connection, TSQLQuery, TSQLTransaction, TDatasource and TDBGrid components that have been placed on the form:
429	461
430	462		``` pascal
431	463		unit unt_mysql2;
432	464		{$mode objfpc}{$H+}
433	465		interface
434	466		uses
435	467		Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs,
436	468		mysql50conn, sqldb, StdCtrls, db, DBGrids, DbCtrls;
437	469		type
438	470		{ TForm1 }
439	471		TForm1 = class(TForm)
440	472		btnConnect: TButton;
441	473		btnSave: TButton;
442	474		btnNext: TButton;
443	475		btnPrior: TButton;
444	476		Datasource1: TDatasource;
445	477		DBGrid1: TDBGrid;
446	478		Memo1: TMemo;
447	479		MySQL50Connection1: TMySQL50Connection;
448	480		SQLQuery1: TSQLQuery;
449	481		SQLTransaction1: TSQLTransaction;
450	482		procedure btnConnectClick(Sender: TObject);
451	483		procedure btnNextClick(Sender: TObject);
452	484		procedure btnPriorClick(Sender: TObject);
453	485		procedure btnSaveClick(Sender: TObject);
454	486		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
455	487		procedure FormCreate(Sender: TObject);
456	488		private
457	489		{ private declarations }
458	490		public
459	491		{ public declarations }
460	492		end;
461	493		var
462	494		Form1: TForm1;
463	495		implementation
464	496		{ TForm1 }
465	497
466	498		procedure TForm1.FormCreate(Sender: TObject);
467	499		begin
468	500		//Set properties of components:
469	501		//(could be done in the Object Inspector)
470	502		MySQL50Connection1.HostName := '127.0.0.1';
471	503		MySQL50Connection1.UserName := 'root';
472	504		MySQL50Connection1.Password := '';
473	505		MySQL50Connection1.DatabaseName := 'test1';
474	506		MySQL50Connection1.Transaction := SQLTransaction1;
475	507		//SQLQuery1.ParseSQL := true; //line not needed - this is the default
476	508		//SQLQuery1.ReadOnly := false; //line not needed - this is the default
477	509		SQLQuery1.SQL.Text := 'select * from tperson';
478	510		SQLQuery1.Transaction := SQLTransaction1;
479	511		SQLQuery1.UpdateMode := upWhereChanged;
480	512		Datasource1.Dataset := SQLQuery1;
481	513		DBGrid1.DataSource := Datasource1;;
482	514		end;
483	515
484	516		procedure TForm1.btnConnectClick(Sender: TObject);
485	517		var
486	518		S : string;
487	519		begin
488	520		try
489	521		MySQL50Connection1.Connected := true;
490	522		SQLQuery1.Open;
491	523
492	524		//Tests to see if all is OK:
493	525		SQLQuery1.Last;
494	526		S := IntToStr(SQLQuery1.RecordCount) + #13#10;
495	527		SQLQuery1.First;
496	528		while not SQLQuery1.EOF do
497	529		begin
498	530		S := S + SQLQuery1.FieldByName('surname').AsString + #13#10;
499	531		SQLQuery1.Next;
500	532		end;
501	533		except
502	534		on E: Exception do
503	535		ShowMessage(E.message);
504	536		end;
505	537		Memo1.Text:= S;
506	538		end;
507	539
508	540		procedure TForm1.btnNextClick(Sender: TObject);
509	541		begin
510	542		SQLQuery1.Next;
511	543		end;
512	544
513	545		procedure TForm1.btnPriorClick(Sender: TObject);
514	546		begin
515	547		SQLQuery1.Prior;
516	548		end;
517	549
518	550		procedure TForm1.btnSaveClick(Sender: TObject);
519	551		begin
520	552		SQLQuery1.ApplyUpdates;
521	553		end;
522	554
523	555		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
524	556		begin
525	557		//Required or get EDatabase error on close:
526	558		MySQL50Connection1.Connected := false;
527	559		end;
528	560
529	561		initialization
530	562		{$I unt_mysql2.lrs}
531	563		end.
532	564		```
533	565
534	566		## Lazarus und PostgreSQL
535	567
536	568		Dies ist ein sehr kurzes Tutorial, wie man mit Lazarus 0.9.12 oder höher eine Verbindung zu einer PostgreSQL-Datenbank aufbaut, lokal oder entfernt, mittels TPQConnection. Diese Komponente wird zu Lazarus hinzugefügt, wenn das Package 'lazarus/components/sqldb/sqldblaz.lpk' installiert wird.
537	569
538	570		Nach erfolgreicher Installation, befolgen Sie diese Schritte:
539	571
540	572		- Nehmen Sie eine PQConnection aus dem Fach SQLdb
541	573		- Nehmen Sie eine SQLQuery aus dem Fach SQLdb
542	574		- Nehmen Sie eine SQLTransaction aus dem Fach SQLdb
543	575		- Nehmen Sie eine DataSource aus dem Fach DataAccess
544	576		- Nehmen Sie ein DBGrid aus dem Fach DataControls
545	577
546	578		- In der PQConnection setzen Sie ein:
547	579		- die Eigenschaft 'transaction' mit dem jeweiligen SQLTransaction-Object
548	580		- den Datenbanknamen
549	581		- HostName
550	582		- UserName + password
551	583
552	584		- Überprüfen Sie, ob die SQLTransaction automatisch geändert wurde und jetzt auf die PQConnection zeigt
553	585
554	586		- In der SQLQuery setzen Sie ein:
555	587		- die Eigenschaft 'transaction' mit dem jeweiligen Object
556	588		- die Eigenschaft 'database' mit dem jeweiligen Object
557	589		- SQL (irgendetwas wie 'select * from anytable')
558	590
559	591		- Im Objekt 'DataSource' setzen Sie die Eigenschaft 'DataSet' mit dem jeweiligen SQLQuery-Object
560	592
561	593		- Im DBGrid setzen Sie die Datenquelle als DataSource-Object
562	594
563	595		Stellen Sie alles auf verbunden und aktiviert und das DBGrid sollte zur Entwurfszeit gefüllt werden. TDBText und TDBEdit scheinen zu funktionieren, aber zeigen (bei mir) nur die Daten.
564	596
565	597		Um die Inhalte der Datenbank zu ändern, rief ich die DB-Engine direkt mit dem folgenden Code auf:
566	598
567	599		``` pascal
568	600		try
569	601		sql:= 'UPDATE table SET setting=1';
570	602		PQDataBase.Connected:=True;
571	603		PQDataBase.ExecuteDirect('Begin Work;');
572	604		PQDataBase.ExecuteDirect(sql);
573	605		PQDataBase.ExecuteDirect('Commit Work;');
574	606		PQDataBase.Connected:=False;
575	607		except
576	608		on E : EDatabaseError do
577	609		MemoLog.Append('DB ERROR:'+sql+chr(13)+chr(10)+E.ClassName+chr(13)+chr(10)+E.Message);
578	610		on E : Exception do
579	611		MemoLog.Append('ERROR:'+sql+chr(13)+chr(10)+E.ClassName+chr(13)+chr(10)+E.Message);
580	612		end;
581	613		```
582	614
583	615		- Anmerkungen:
584	616		- Getestet unter Windows, Lazarus 0.9.12 + PgSQL 8.3.1
585	617		- Einige Tests unter Linux, Lazarus 0.9.12 and PgSQL 8.0.x
586	618
587	619		- Installation und Fehler:
588	620		- In der getesteten Version of Lazarus .12, haben die Felder vom Typ "text" und "numeric" Fehler
589	621		- Ich verwendete problemlos: char fixed size, int und float8
590	622		- Manchmal beseitigt ein Neustart von Lazarus dumme Fehler...
591	623		- Nach einigen Fehlern bleiben die Transaktionen aktiv und sollten manuell deaktiviert werden
592	624		- Von Lazarus gemachte Änderungen werden natürlich erst dann sichtbar, wenn die Transaktionen abgewickelt sind
593	625		- Der integrierte Debugger scheint fehlerbehaftet (zumindest unter Windows) - manchmal hilft es, ihn außerhalb der IDE zu starten, um Fehler zu finden
594	626		- Unter Linux werden bestimmte Fehlermeldungen über die Konsole ausgegeben -- starten Sie Ihr Programm in der Befehlszeile, manchmal finden Sie dort einige zusätzliche nützliche Infos zu Debuggen
595	627		- Error: "Can not load Postgresql client. Is it installed (libpq.so) ?"
596	628		- Erweitern Sie den Pfad um die Suche nach libpq* aus der PostgreSQL-Installation.
597	629		- Unter Linux fügen Sie den Pfad zur Datei 'libpq.so' zum Abschnitt 'libraries' in Ihrer Datei /etc/fpc.cfg. Zum Beispiel: -Fl/usr/local/pgsql/lib
598	630		- Es ist vielleicht nötig einen symbolischen Link zu erzeugen: ln -s /usr/lib/pqsql.so.5 /usr/lib/pqsql.so
599	631		- Unter Windows fügen Sie diese Bibliotheken irgendwo in der Umgebungsvariablen PATH oder project dir ein
600	632		- Unter Windows kopierte ich alle DLLs aus meinem Verzeichnis 'C:\Program Files\PostgreSQL\8.1\bin' in ein anderes Verzeichnis im Pfad
601	633		- Oder fügen Sie dieses Verzeichnis 'postgres\bin' Ihrem Pfad hinzu
602	634
603	635		Ein gutes Beispiel darüber, wie man unter Windows Lazarus mit PostgreSQL verbindet ist [easyDB](http://paginas.fe.up.pt/~asousa/wiki/doku.php?id=proj:lazarus_projects#easy_db).
604	636
605	637		## Lazarus und SQLite
606	638
607	639		von Luiz Américo
608	640
609	641		Besuchen sie die [sqlite4fpc Homepage](http://sqlite4fpc.yolasite.com/). Dort finden sie die API-Referenz und weitere Tutorials.
610	642
611	643		### Einführung
612	644
613	645		TSqliteDataset und TSqlite3Dataset sind TDataset Abkömmling-Klassen, die jeweils auf sqlite 2.8.x und 3.x.x Datenbanken zugreifen. Nachstehend befindet sich eine Liste der wichtigsten Vor- und Nachteile:
614	646
615	647		Vorteile:
616	648
617	649		- Flexibilität: Programmier können wählen, ob sie die SQL Sprache verwenden oder nicht, erlaubt ihnen mit einfachen Tabellenlayouts zu arbeiten oder jedem komplexen Layout, welches SQL ermöglicht.
618	650		- Automatisches Datenbank Update: Kein Bedarf, die Datenbank manuell mit SQL Anweisungen zu updaten, eine einzelne Methode erledigt dies.
619	651		- Schnelligkeit: Es puffert die Daten im Arbeitsspeicher, was das Browsen im Datenbestand schnell macht.
620	652		- Keine Server Installation/Konfiguration: einfach zusammen verfrachten mit der sqlite dynamic Bibliothek.
621	653
622	654		Nachteile
623	655
624	656		- Benötigt externe Datei (sqlite Bibliothek)
625	657
626	658		### Voraussetzungen
627	659
628	660		- Für sqlite2 Datenbanken:
629	661		- fpc 2.0.0
630	662		- Lazarus 0.9.10
631	663		- sqlite Laufzeitbibliothek 2.8.15 oder höher (von [www.sqlite.org](http://www.sqlite.org))
632	664
633	665		- Für sqlite3 Datenbanken:
634	666		- fpc 2.0.2
635	667		- Lazarus 0.9.11 (SVN Revision 8443 oder höher)
636	668		- sqlite Laufzeitbibliothek 3.2.1 oder höher (von [www.sqlite.org](http://www.sqlite.org))
637	669
638	670		Bevor sie ein Lazarus Projekt beginnen, stellen sie sicher, dass:
639	671
640	672		- die sqlite Bibliothek im Systempfad (PATH) ist oder im Verzeichnis des executable
641	673		- unter Linux, bringen sie cmem als erste Unit in den uses-Abschnitt des Hauptprogramms
642	674
643	675		### Anwendung (grundlegende Verwendung)
644	676
645	677		Installieren sie das Package aus dem /components/sqlite Verzeichnis (siehe Instruktionen [[Install Packages/de\|hier]])
646	678
647	679		Zur Entwicklungszeit setzen sie die folgenen Eigenschaften:
648	680
649	681		- FileName: Pfad der sqlite Datei \[benötigt\]
650	682		- TableName: Name der Tabelle, die in der SQL Anweisung benutzt wird \[benötigt\]
651	683		- Sql: eine SQL select Anweisung \[optional\]
652	684
653	685		Erzeugen einer Tabelle (Dataset)
654	686
655	687		Klicken sie doppelt auf das Komponenten-Icon oder benutzen sie den 'Create Table' Punkt im Popup-Menü, das erscheint, wenn sie mit der rechten Maustaste klicken. Ein einfacher selbsterklärender Tabellen-Editor wird eingeblendet.
656	688
657		-	~~` Hier sind alle Feldtypen, die von TSqliteDataset und TSqlite3Dataset unterstützt werden: `\~~
658		-	~~` `\~~
659		-	~~` Integer`\~~
660		-	~~` AutoInc`\~~
661		-	~~` String`\~~
662		-	~~` Memo`\~~
663		-	~~` Bool `\~~
664		-	~~` Float`\~~
665		-	~~` Word`\~~
666		-	~~` DateTime`\~~
667		-	~~` Date`\~~
668		-	~~` Time`\~~
669		-	~~` LargeInt`\~~
670		-	~~` Currency`\~~
671		-	~~` `~~
	689	+	```text
	690	+	Hier sind alle Feldtypen, die von TSqliteDataset und TSqlite3Dataset unterstützt werden:
	691	+
	692	+	Integer
	693	+	AutoInc
	694	+	String
	695	+	Memo
	696	+	Bool
	697	+	Float
	698	+	Word
	699	+	DateTime
	700	+	Date
	701	+	Time
	702	+	LargeInt
	703	+	Currency
	704	+	```
672	705
673	706		Abrufen der Daten
674	707
675	708		Nach dem Erzeugen der Tabelle oder mit einer vorher erzeugten Tabelle, öffnen sie die Datenmenge mit der Open Methode. Wenn die SQL-Eigenschaft nicht gesetzt wurde, dann werden alle Datensätze von allen Feldern abgerufen, das selbe passiert, wenn sie SQL auf:
676	709
677		-	~~` SQL:='Select * from TABLENAME'; `~~
	710	+	``` pascal
	711	+	SQL:='Select * from TABLENAME';
	712	+	```
678	713
679	714		setzen.
680	715
681	716		Anwendung von Änderungen zur grundlegenden Datendatei
682	717
683	718		Um die Funktion ApplyUpdates zu benutzen, muss der Datenbestand mindestens ein Feld enthalten, das die Anforderungen für einen Primary Key erfüllt (Werte müssen UNIQUE und nicht NULL sein).
684	719
685	720		Es ist möglich, dies auf zwei Wegen zu erreichen:
686	721
687	722		- Setzen sie die Eigenschaft PrimaryKey auf den Namen eines Primary Key Feldes.
688	723		- Fügen sie ein Feld AutoInc hinzu (dies ist einfacher seit TSqliteDataSet es automatisch als Primary Key behandelt)
689	724
690	725		Wenn eine oder zwei Bedingungen gesetzt sind, rufen sie
691	726
692		-	~~` ApplyUpdates;`~~
	727	+	```text
	728	+	ApplyUpdates;
	729	+	```
693	730
694	731		auf.
695	732
696	733		PS1: Wenn beide Bedingungen gesetzt sind, wird das Feld entsprechend dem PrimaryKey genutzt, um die Updates anzuwenden.
697	734
698	735		PS2: Setzen von PrimaryKey auf ein Feld, das kein Primary Key ist, wird zu einem Verlust von Daten führen, wenn ApplyUpdates aufgerufen wird, daher stellen sie sicher, dass das gewählte Feld keinen Null Wert und Unique values enthält, bevor sie es benutzen.
699	736
700	737		### Bemerkungen
701	738
702	739		- Obwohl es mit 10000 Datensätzen getestet wurde und problemlos funktionierte, hält TSqliteDataset alle Daten im Arbeitsspeicher. Denken sie daher daran, nur die notwendigen Daten abzurufen (hauptsächlich mit Memo Feldern).
703	740		- Die selbe Datendatei (Filename Eigenschaft) kann verschiedene Tabllen/Datasets hosten.
704	741		- Verschiedene Datasets (unterschiedliche Kombinationen von Feldern) können unter simultaner Nutzung der selben Tabelle erzeugt werden .
705	742		- Es ist möglich, die Daten mit der WHERE Anweisung in SQL zu filtern, das Dataset zu schliessen und wieder zu öffnen (oder die Methode RefetchData aufrufen). Aber in diesem Fall müssen die Reihenfolge und Anzahl der Felder gleich bleiben.
706	743		- Es ist auch möglich, komplexe SQL-Anweisungen zu verwenden mittels Aliasen, Joins, Views bei mehrfachen Tabellen (denken sie daran, dass sie sich in der selben Datendatei befinden müssen), aber in diesem Fall wird ApplyUpdates nicht funktionieren. Wenn jemand komplexe Abfragen benutzen und die Updates in die Datendatei einsetzen will, soll er mir schreiben und ich werde einige Hinweise geben, wie man das tut.
707	744		- Es ist erlaubt, den Dateinamen zu einer sqlite2.x Datendatei zu setzen, welche nicht von TSqliteDataset erzeugt wurde, aber einige Felder werden nicht den korrekten Feldtyp ermitteln. Diese werden als String-Felder behandelt.
708	745
709	746		Allgemeine Beispiele sind zu finden im fpc/fcl/db/sqlite CVS-Verzeichnis
710	747
711	748		Luiz Américo pascalive(at)bol(dot)com(dot)br
712	749
713	750		## Lazarus und MSSQL
714	751
715	752		Bitte schreiben sie mir!
716	753
717	754		## Lazarus und Interbase / Firebird
718	755
719	756		Schauen Sie auf [[Install Packages/de\|Installation von Packages]] nach. Auf dieser Seite befindet sich ein erstes kleines Beispiel und eine Beschreibung, wie man eine Verbindung zu einem IB- oder FB-Server herstellt. Informationen zu Firebird gibt es auch hier [[Firebird]].
720	757
721	758		Funktioniert auch mit der neuesten Zeoslib (aus dem cvs).
722	759
723	760		### FBLib Firebird-Bibliothek
724	761
725	762		[FBLib](http://fblib.altervista.org) ist eine Open-Source-Bibliothek für den direkten Zugriff auf das relationale Datenbanksystem Firebird. Funtioniert mit Borland Delphi, Kylix, Free Pascal und Lazarus.
726	763
727	764		Folgende Merkmale sind aktuell enthalten:
728	765
729	766		- Direkter Zugriff auf Firebird 1.0.x 1.5.x, 2.x Classic oder SuperServer
730	767		- Multi-Plattform \[Win32, Gnu/Linux, FreeBSD)
731	768		- Automatische Auswahl der Klientenbibliothek 'fbclient' oder 'gds32'
732	769		- Abfragen mit Parametern
733	770		- Unterstützt den SQL-Dialekt 1/3
734	771		- LGPL Lizenz-Vereinbarung
735	772		- Extrahiert Metadaten
736	773		- Einfacher Skript-Parser
737	774		- Fügt nur 100-150 KB zur ausführbaren EXE-Datei hinzu
738	775		- Unterstützt BLOB-Felder
739	776		- Exportiert Daten zu einem HTML SQL Script
740	777		- Service-Manager (Backup, Restore, gfix...)
741	778		- Ereignis-Benachrichtigung
742	779
743	780		Sie können die Dokumentation von der [FBLib Website](http://fblib.altervista.org/) herunterladen.
744	781
745	782		[Hiere](http://www.firebirdnews.org/?p=1769) finden Sie eine aktuelle Version. Oder Sie benutzen SVN: [1](https://tiopf.svn.sourceforge.net/svnroot/tiopf/3rdParty/FBLib/Trunk) (Tipp von [Guionardo](http://wiki.lazarus.freepascal.org/User:Guiosoft))
746	783
747	784		## Lazarus und dBase
748	785
749	786		Tony Maro
750	787
751	788		Sie können auch mit dem Besuch der [[Lazarus Tdbf Tutorial/de\|TDbf Tutorial Seite]] anfangen.
752	789
753	790		FPC enthält eine einfache Datenbank-Komponente, die ähnlich funktioniert wie die Delphi-Komponente TTable, genannt "TDbf" ([TDbf Webseite](http://tdbf.sourceforge.net/)), die eine sehr elementare Teilmenge von Features für dBase-Dateien bietet. Sie wird inzwischen standardmäßig installiert, so dass sie das Lazarus Package aus dem "lazarus/components/tdbf" Verzeichnis nicht mehr manuell installieren und ihre Lazarus IDE neu aufbauen müssen (rebuild). Sie erscheint neben 'TDatasource' in ihrer Komponentenpalette.
754	791
755	792		Die Komponente TDbf hat einen Vorteil gegenüber anderen Datenbank-Komponenten, dass sie keine Art von Datenbank-Laufzeit-engines benötigt. Sie ist aber nicht die beste Option für große Datenbankanwendungen.
756	793
757	794		Sie ist sehr einfach zu benutzen. Nehmen sie einfach eine TDbf und legen sie sie auf ihrem Formular ab, setzen den Laufzeit-Pfad auf das Verzeichnis, wo sich ihre Datenbank-Dateien befinden, setzen den Tabellennamen und verbinden sie mit ihrer TDatasource-Komponente.
758	795
759	796		Wirkliche Funktionalität benötigt ein bißchen mehr Aufwand, wie auch immer. Wenn eine Tabelle nicht bereits schon existiert, müssen sie sie per Programm erzeugen, es sei denn, es gibt einen kompatiblen Tabellen-Designer, mit dem ich nicht vertraut bin.
760	797
761	798		Der Versuch, eine nicht existierende Tabelle zu öffnen, wird einen Fehler erzeugen. Tabellen können per Programm durch die Komponente erzeugt werden, sobald der Laufzeit-Pfad und der Tabellenname gesetzt wurden.
762	799
763	800		Ein Beispiel: Sie erzeugen eine Tabelle mit dem Namen "dvds", um ihre DVD-Kollektion zu speichern, in dem sie sie auf ihrem Formular ablegen, den Laufzeit-Pfad setzen und den Tabellennamen auf "dvds" setzen. Die resultierende Datei heißt "dvds.dbf".
764	801
765	802		Fügen sie das Folgende in ihren Code ein:
766	803
767		-	~~` Dbf1.FilePathFull = '/Pfad/zu/meiner/Datenbank';`\~~
768		-	~~` Dbf1.TableName = 'dvds';`\~~
769		-	~~` With Dbf1.FieldDefs do begin`\~~
770		-	~~` Add('Name', ftString, 80, True);`\~~
771		-	~~` Add('Description', ftMemo, 0, False);`\~~
772		-	~~` Add('Rating', ftString, 5, False);`\~~
773		-	~~` end;`\~~
774		-	~~` Dbf1.CreateTable;`~~
	804	+	``` pascal
	805	+	Dbf1.FilePathFull = '/Pfad/zu/meiner/Datenbank';
	806	+	Dbf1.TableName = 'dvds';
	807	+	With Dbf1.FieldDefs do begin
	808	+	Add('Name', ftString, 80, True);
	809	+	Add('Description', ftMemo, 0, False);
	810	+	Add('Rating', ftString, 5, False);
	811	+	end;
	812	+	Dbf1.CreateTable;
	813	+	```
775	814
776	815		Wenn dieser Code läuft, wird ihre Tabelle DVD-Kollektion erzeugt. Danach werden alle datensensitiven Komponenten, die durch TDatasource mit dieser Komponente verbunden sind, einen einfachen Zugang zu den Daten erlauben.
777	816
778	817		Das Hinzügen von Indexen ist ein wenig unterschiedlich von ihrer typischen TTable. Es muss getan werden, nachdem die Datenbank geöffnet wurde. Es ist auch die selbe Methode, die sie zum Erneuern der Indexe verwenden. Zum Beispiel:
779	818
780		-	~~` Dbf1.Exclusive := True;`\~~
781		-	~~` Dbf1.Open;`\~~
782		-	~~` Dbf1.AddIndex('dvdsname','Name',[ixPrimary, ixUnique, ixCaseInsensitive]);`\~~
783		-	~~` Dbf1.AddIndex('rating.ndx', 'Rating', [ixCaseInsensitive]);`\~~
784		-	~~` Dbf1.Close;`~~
	819	+	``` pascal
	820	+	Dbf1.Exclusive := True;
	821	+	Dbf1.Open;
	822	+	Dbf1.AddIndex('dvdsname','Name',[ixPrimary, ixUnique, ixCaseInsensitive]);
	823	+	Dbf1.AddIndex('rating.ndx', 'Rating', [ixCaseInsensitive]);
	824	+	Dbf1.Close;
	825	+	```
785	826
786	827		Der erste (primary) Index ist eine Datei mit dem Namen "dvdsname.mdx" und der zweite ist die Datei "rating.ndx". Daher müssen sie aufpassen in einer Mehrfach-Tabellen Datenbank, den selben Dateinamen nicht zweimal zu verwenden.
787	828
788	829		Ich will versuchen, ein detaillierteres Beispiel zu einem späteren Zeitpunkt hinzuzufügen, aber hoffentlich wird dies jene 'alten' Delphi-Programmierer anspornen, Datenbankprogramme mit Lazarus zu schreiben!
789	830
790	831		## Verwendung von TSdfDataset und TFixedDataset
791	832
792	833		TSdfDataset and TFixedDataset are two simple datasets which offer a very simple textual storage format. These datasets are very convenient for small databases, because they are fully implemented as an object pascal unit, and thus require no external libraries, and because their textual format allows them to be easely edited with a text editor.
793	834
794	835		To start with this formats, a initial database file should be created. The format is very simple, so use a text editor to do this.
795	836
796	837		Below is a sample database for TSdfDataset. Note that the first line has the names of the fields and that we are using commas as separators:
797	838
798	839		ID,NAMEEN,NAMEPT,HEIGHT,WIDTH,PINS,DRAWINGCODE
799	840		1,resistor,resistor,1,1,1,LINE
800	841		2,capacitor,capacitor,1,1,1,LINE
801	842		3,transistor npn,transistor npn
802	843
803	844		And here is an example database for using with TFixedDataset. Each record occupies a fixed amount of space, and if the field is smaller then it, spaces should be used to fill the remaining size.
804	845
805	846		Name = 15 chars; Surname = 15 chars; Tell = 10 chars; e_mail = 20 chars;
806	847		Piet Pompies piet@pompies.net
807	848
808	849		### Direkte Verwendung der Datasets
809	850
810	851		Sometimes it is useful to create the dataset and work with it completely in code, and the following code will do exactly this. Note some peculiarities of TSdfDataset/TFixedDataset:
811	852
812	853		- The lines in the database can have a maximum size of about 300. A fix is being researched.
813	854		- It is necessary to add the field definitions. Some datasets are able to fill this information alone from the database file
814	855		- One should set FirstLineAsSchema to true, to indicate that the first line includes the field names and positions
815	856		- The Delimiter property holds the separator for the fields. It will not be possible to use this char in strings in the database. Similarly it will not be possible to have lineendings in the database because they mark the change between records. It's possible to overcome this by substituting the needed comma or line ending with another not often used char, like \# for example. So that when showing the data on screen all \# chars could be converted to line endings and the inverse when storing data back to the database. The ReplaceString routine is useful here.
816	857
817	858		``` pascal
818	859		constructor TComponentsDatabase.Create;
819	860		begin
820	861		inherited Create;
821	862
822	863		FDataset := TSdfDataset.Create(nil);
823	864		FDataset.FileName := vConfigurations.ComponentsDBFile;
824	865
825	866		// Not necessary with TSdfDataset
826	867		// FDataset.TableName := STR_DB_COMPONENTS_TABLE;
827	868		// FDataset.PrimaryKey := STR_DB_COMPONENTS_ID;
828	869
829	870		// Adds field definitions
830	871		FDataset.FieldDefs.Add('ID', ftString);
831	872		FDataset.FieldDefs.Add('NAMEEN', ftString);
832	873		FDataset.FieldDefs.Add('NAMEPT', ftString);
833	874		FDataset.FieldDefs.Add('HEIGHT', ftString);
834	875		FDataset.FieldDefs.Add('WIDTH', ftString);
835	876		FDataset.FieldDefs.Add('PINS', ftString);
836	877		FDataset.FieldDefs.Add('DRAWINGCODE', ftString);
837	878
838	879		// Necessary for TSdfDataset
839	880		FDataset.Delimiter := ',';
840	881		FDataset.FirstLineAsSchema := True;
841	882
842	883		FDataset.Active := True;
843	884
844	885		// Sets the initial record
845	886		CurrentRecNo := 1;
846	887		FDataset.First;
847	888		end;
848	889		```
849	890
850	891		When using TSdfDataset directly be careful that althought it is implemented, RecNo does not work correctly, neither for setting nor for reading. The standard movimentation routines like First, Next, Prior and Last work correctly, so it's possible to use them to implement a replacement for RecNo. Keep a variable somewhere called CurrentRecNo which will hold the current RecNo value. Remember that this variable will have the same convention as RecNo, so the first record has number 1. After activating the database initialize the database to the first record with TSdfDataset.First and with CurrentRecNo := 1
851	892
852	893		``` pascal
853	894		{@@
854	895		Moves to the desired record using TDataset.Next and TDataset.Prior
855	896		Avoids using TDataset.RecNo which doesn't work in all datasets
856	897
857	898		@param AID Indicates the record number. The first record has number 1
858	899		}
859	900		procedure TComponentsDatabase.GoToRec(AID: Integer);
860	901		begin
861	902		// We are before the desired record, move forward
862	903		if CurrentRecNo < AID then
863	904		begin
864	905		while (not FDataset.EOF) and (CurrentRecNo < AID) do
865	906		begin
866	907		FDataset.Next;
867	908		FDataset.CursorPosChanged;
868	909		Inc(CurrentRecNo);
869	910		end;
870	911		end
871	912		// We are after the desired record, move back
872	913		else if CurrentRecNo > AID then
873	914		begin
874	915		while (CurrentRecNo >= 1) and (CurrentRecNo > AID) do
875	916		begin
876	917		FDataset.Prior;
877	918		FDataset.CursorPosChanged;
878	919		Dec(CurrentRecNo);
879	920		end;
880	921		end;
881	922		end;
882	923		```
883	924
884	925		### Verwendung mit datensensitiven Komponenten
885	926
886	927		## Siehe auch
887	928
888	929		- [[Databases/de\|Datenbanken (deutsch)]] - Startseite für Datenbankanwendungen mit Lazarus
889	930		- [[Databases in Lazarus/de\|Datenbanken in Lazarus (deutsch)]] - Ein Überblick über die Verwendung von Datenbanken in Lazarus
890	931		- [[How to write in-memory database applications in Lazarus/FPC]] - In-Memory Datenbank-Anwendungen
891	932		- [[MySQLDatabases/de\|MySQLDatenbanken (deutsch)]] - Erstellung einer Datenbankanwendung unter Verwendung von MySQL
892	933		- [[Zeos tutorial/de\|Zeos Tutorial (deutsch)]] - Verwendung der Zeos Komponenten
893	934		- [[Lazarus Tdbf Tutorial]] - Tutorial über einfache Datenbankentwicklung mittels der [TDbf](http://tdbf.sf.net)-Komponente (von Micha Nelissen)
894	935		- [[Lazarus DB Faq/de\|Lazarus DB Faq (deutsch]] - FAQ über Datenbanken in Lazarus
895	936		- [[Firebird]] - Erstellen einer Datenbankanwendung für Firebird
896	937		- [[ODBCConn]] - Verbindung mit ODBC-Datenbanken
897	938		- [[MS Access]] - Wie man auf eine Microsoft Access Datenbank zugreift
898	939
899	940		## Externe Links
900	941
901	942		- [Pascal Data Objects](http://pdo.sourceforge.net) - eine Datenbank API die mit FPC und Delphi funktioniert und die nativen MySQL-Bibliotheken für Version 4.1 und 5.0 sowie Firebird SQL 1.5 und 2.0 verwendet. Sie wurde durch PHP's PDO-Klasse angeregt.
902	943		- [Zeos+SQLite Tutorial](http://lazaruszeos.blogspot.com) - Ein gutes Tutorial mit Screenshots. Es erklärt wie Sie SQLite und Zeos benutzen. Allerdings auf Spanisch - (Google translate hilft bei der Übersetzung ins Deutsche)
903	944
904	945		---
905	946		From the Free Pascal wiki, page "Lazarus Database Tutorial/de", 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).

Back to history