Lazarus Tdbf Tutorial/de: what changed

Revision 1 to 2. 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		Dieses Tutorial behandelt die grundlegende Datenbank Entwicklung unter Verwendung der [TDbf](https://tdbf.sf.net) Komponente (entwickelt von Micha Nelissen) mit Lazarus. Zusätzliche Dokumentation für TDbf ist verfügbar. Diese Seite wurde erstellt von Tony Maro aber auch andere Mitwirkende sind willkommen!
6	6
7	7		Für ein TDbf Dokumentation PDF gehen sie zur [SourceForge](https://sourceforge.net/project/showfiles.php?group_id=34085&package_id=26371) Seite. Es mag hilfreich sein, während des Lesens das PDF neben dieses Dokument zu halten.
8	8
9	9		### Was sie benötigen werden
10	10
11	11		Das DBFLaz Package wird inzwischen standardmäßig bei der Installation von Lazarus mitinstalliert. Die TDbf Komponente befindet sich auf der 'Data Access' Seite in der Komponentenpalette.
12	12
13	13		### Was TDbf bietet
14	14
15	15		TDbf bietet Zugriff auf dBase und FoxPro Datenbank Tabellen für Lazarus (und andere). Es erlaubt das Lesen, Schreiben und Erzeugen von dBase III+, dBase IV, Visual dBase VII und FoxPro Tabellen. Es tut alles das, ohne zusätzliche Bibliotheken oder Datenbank Engines zu benötigen. Einfach TDbf auf ihrem Formular ablegen und sie haben sofortigen Zugriff auf eine cross-platform Datenbank-Umgebung. TDbf funktioniert unter Windows und Linux unter Verwendung von Lazarus.
16	16
17	17		## Wie man eine neue Datenbank Tabelle erzeugt
18	18
19	19		Da es noch keine "Datenbank Desktop" Anwendung für Lazarus gibt, müssen wir eine neue Datenbank im Code erzeugen.
20	20
21	21		### Setzen des Pfades
22	22
23	23		Es ist eine gute Idee, der Datenbank ihrer Anwendung ein eigenes Verzeichnis zu spendieren. Dies vereinfacht das Erstellen von Backups der Daten. Es gibt zwei Wege, um den Pfad zu setzen. Sie können den vollständigen Pfad setzen, indem sie die FilePathFull Eigenschaft nutzen, oder sie können einen Pfad relativ zur aktuellen Anwendung setzen mit FilePath. Zum Beispiel, das Setzen von FilePath zur Laufzeit auf "data/" würde ein data Unterverzeichnis nutzen einfach unter der .EXE Datei. Das Setzen der FilePathFull Eignschaft auf "/var/data/" würde alles in diesem bestimmten Ordner platzieren, den Ort der Anwendung ignorierend.
24	24
25	25		### Wählen eines Tabellenlevels
26	26
27	27		Per Voreinstellung wird TDbf dBase IV Tabellen erzeugen. Während dies sehr kompatibel ist, gibt es Features, die sie benutzen möchten, die aber nicht unterstützt werden. Um auto-incrementing Felder zu unterstützen, müssen sie etwas neueres benutzen. Die Tabellentypen sind:
28	28
29	29		- 3 dBase III+
30	30		- 4 dBase IV
31	31		- 7 Visual dBase VII
32	32		- 25 FoxPro
33	33
34	34		Sie wählen einen Tabellentyp, indem sie die TableLevel Eigenschaft entsprechend setzen.
35	35
36	36		### Hinzufügen von Feldern
37	37
38	38		Das Erzeugen von Feldern für ihre neue Tabelle zur Laufzeit folgt so ziemlich dem alten Delphi Standard. Sobald sie die FilePath, TableLevel, und TableName Eigenschaften gesetzt haben, manipulieren sie die FieldDefs Eigenschaft, um die Struktur festzulegen. Zum Beispiel:
39	39
40	40		``` pascal
41	41		MyDbf.FilePathFull := '/Ort/für/meine/Daten';
42	42		MyDbf.TableLevel := 7;
43	43		MyDbf.TableName := 'customers.dbf'; // Notiz: Wird .dbf wirklich benötigt?
44	44		With MyDbf.FieldDefs do begin
45	45		Add('Id', ftAutoInc, 0, True);
46	46		Add('Name', ftString, 80, True);
47	47		End;
48	48		```
49	49
50	50		Feld Typen sind definiert als:
51	51
52	52		- ftUnknown
53	53		- ftString
54	54		- ftSmallInt
55	55		- ftInteger
56	56		- ftWord
57	57		- ftBoolean
58	58		- ftFloat
59	59		- ftCurrency (TableLevel 25)
60	60		- ftBCD (TableLevel 25)
61	61		- ftDate
62	62		- ftTime
63	63		- ftDateTime
64	64		- ftBytes (TableLevel 25)
65	65		- ftVarBytes
66	66		- ftAutoInc (TableLevel 7 oder 25)
67	67		- ftBlob
68	68		- ftMemo
69	69		- ftGraphic
70	70		- ftFmtMemo
71	71		- ftParadoxOle
72	72		- ftDBaseOle
73	73		- ftTypedBinary
74	74		- ftCursor
75	75		- ftFixedChar
76	76		- ftWideString
77	77		- ftLargeInt
78	78		- ftADT
79	79		- ftArray
80	80		- ftReference
81	81		- ftDataSet
82	82		- ftOraBlob
83	83		- ftOraClob
84	84		- ftVariant
85	85		- ftInterface
86	86		- ftIDispatch
87	87		- ftGuid
88	88		- ftTimeStamp
89	89		- ftFMTBcd
90	90
91	91		Fett geschriebene Typen werden gegenwärtig unterstützt.
92	92
93	93		### Erzeugen sie die Tabelle !
94	94
95	95		Sobald sie die Felder definiert haben, die sie in ihrer neuen Tabelle benutzen wollen, können sie vorangehen und sie mit:
96	96
97	97		``` pascal
98	98		MyDbf.CreateTable;
99	99		```
100	100
101	101		erzeugen.
102	102
103	103		## Wie man einen Index zu einer Tabelle hinzufügt
104	104
105	105		Wenn ihre Datenbank größer ist als ein paar Datensätze, wollen sie möglicherweise Indizes definieren, um das Suchen zu beschleunigen. Um die Indexstruktur einer Tabelle zu ändern, benötigen wir exklusiven Zugriff auf die Tabelle - welchen wir ohnehin haben, während wir ihn erzeugen.
106	106
107	107		``` pascal
108	108		MyDbf.Exclusive := True;
109	109		MyDbf.Open;
110	110		```
111	111
112	112		Nun, müssen wir einfach den Index hinzufügen.
113	113
114	114		``` pascal
115	115		MyDbf.AddIndex('custid', 'Id', [ixPrimary, ixUnique]);
116	116		MyDbf.AddIndex('custname','Name', [ixCaseInsensitive]);
117	117		MyDbf.Close;
118	118		```
119	119
120	120		## Alles zusammen ergibt...
121	121
122	122		Das folgende Beispiel erzeugt eine neue Tabelle "customers" im Code. Dies muss natürlich nur einmal getan werden, und danach öffnen sie die Tabelle nur, erzeugen sie sie nicht (erneut) ;-)
123	123
124	124		``` pascal
125	125		{$MODE OBJFPC}
126	126		Program DatabaseTest;
127	127		{ Wir benötigen die folgenden Units im USES Abschnitt: }
128	128		uses Dbf, db, Dbf_Common;
129	129		{ Dbf wird automatisch eingetragen wenn TDbf auf einem Formular abgelegt }
130	130		{ wird... aber sie benötigen db für das DataSet Objekt und }
131	131		{ Dbf_Common für Dinge wie die Feldtyp Definitionen }
132	132
133	133		var
134	134		MyDbf: TDbf;
135	135		begin
136	136		MyDbf := TDbf.Create(nil);
137	137		try
138	138		{ benutzen sie relative Pfade zum "data" Verzeichnis}
139	139		MyDbf.FilePath := 'data/';
140	140
141	141		{ wir wollen Visual dBase VII kompatible Tabellen benutzen }
142	142		MyDbf.TableLevel := 7;
143	143		MyDbf.Exclusive := True;
144	144		MyDbf.TableName := 'customers.dbf';
145	145		With MyDbf.FieldDefs do begin
146	146		Add('Id', ftAutoInc, 0, True);
147	147		Add('Name', ftString, 80, True);
148	148		End;
149	149		MyDbf.CreateTable;
150	150
151	151		MyDbf.Open;
152	152		MyDbf.AddIndex('custid', 'Id', [ixPrimary, ixUnique]);
153	153		{ fügt einen sekundären Index hinzu }
154	154		MyDbf.AddIndex('custname','Name', [ixCaseInsensitive]);
155	155		MyDbf.Close;
156	156		finally
157	157		MyDbf.Free;
158	158		end;
159	159		end.
160	160		```
161	161
162	162		## Externe Index Dateien
163	163
164	164		TDbf unterstützt auch das Speichern von Sekundärindexen in einer separaten Datei. Dies mag hilfreich sein, wenn die Datenbank sehr groß ist. Sekundärindex Dateien werden fast identisch erzeugt wie normale Indexe, aber mit dem Anhängen der '.ndx' Dateierweiterung:
165	165
166	166		``` pascal
167	167		MyDbf.AddIndex('custname.ndx','Name', [ixCaseInsensitive]);
168	168		```
169	169
170	170		Jedes Mal wenn TDbf geöffnet wird, muss die Indexdatei geladen werden:
171	171
172	172		``` pascal
173	173		MyDbf.OpenIndexFile('custname.ndx');
174	174		```
175	175
176	176		Und Indexe müssen referenziert werden inklusive der Erweiterung:
177	177
178	178		``` pascal
179	179		MyDbf.IndexName := 'custname.ndx';
180	180		```
181	181
182	182		Index Dateien werden separat komprimiert mit:
183	183
184	184		``` pascal
185	185		MyDbf.CompactIndexFile('custname.ndx');
186	186		```
187	187
188	188		## Wie man TDbf mit datensensitiven Komponenten verbindet
189	189
190	190		Das Beispiel oberhalb zeigt wie man eine neue Datenbank Tabelle erzeugt im Code. Das Benutzen dieser Tabelle ist sogar noch einfacher.
191	191
192	192		Datensensitive Komponenten in Lazarus (so wie das TDbEdit Bedienelement) verbinden sich mit einer TDataSource Komponente unter Verwendung ihrer DataSource und DataField Eigenschaften. Die TDataSource Komponente wickelt die Kommunikation zwischen der Datenbank-Engine und den datensensitiven Komponenten ab. Eine TDataSource verbindet sich dann mit der TDbf Komponente unter Verwendung ihrer DataSet Eigenschaft. Die Verbindung sieht wie folgt aus:
193	193
194		-	~~`TDbEdit-------`\~~
195		-	~~` \|`\~~
196		-	~~`TDbEdit------\|-->TDataSource-->TDbf`\~~
197		-	~~` \|`\~~
198		-	~~`TDbNavigator--`~~
	194	+	```text
	195	+	TDbEdit-------
	196	+	\|
	197	+	TDbEdit------\|-->TDataSource-->TDbf
	198	+	\|
	199	+	TDbNavigator--
	200	+	```
199	201
200	202		Stellen sie sicher, die FilePath (oder FilePathFull), TableLevel, und TableName Eigenschaften ihrer TDbf Komponente zu setzen bevor sie
201	203
202		-	~~`TDbf.Active := True;`~~
	204	+	``` pascal
	205	+	TDbf.Active := True;
	206	+	```
203	207
204	208		aufrufen.
205	209
206	210		Es gibt viel mehr als gesagt werden kann über die Programmierung mit Datenbanken in Lazarus, und ich würde ein gutes Delphi Datenbank Programmierung Buch oder zwei empfehlen da die grundlegenden Konzepte die selben sind. Ich verweise ständig auf mein Exemplar von "Delphi 2 Unleashed" weil die Konzepte und der wesentliche Code sich in 8 Jahren nicht sehr geändert haben.
207	211
208	212		## Komprimieren und Erneuern der Tabellen
209	213
210	214		Wenn ein Datensatz gelöscht wird, ist er nicht wirklich aus der physikalischen Tabelle entfernt. Periodisch müssen sie eine Tabelle komprimieren, um diesen verlorenen Platz wiederzuerlangen. Dies sollte getan werden mit der Exklusivmodus Einstellung.
211	215
212	216		``` pascal
213	217		MyDbf.Exclusive := True;
214	218		MyDbf.Open;
215	219		MyDbf.PackTable;
216	220		// erneuert auch alle Indexe
217	221		MyDbf.RegenerateIndexes;
218	222		MyDbf.Close;
219	223		MyDbf.Exclusive := False;
220	224		```
221	225
222	226		## Master Tabellen Beziehungen
223	227
224	228		Wirkliche Leistung bei der Datenbank Programmierung beginnt wenn sie mehrere Tabellen haben, die sich auf einander beziehen. Während TDbf die referentielle Integrität noch nicht unterstützt, unterstützt es eine Master / Detail Beziehung zwischen TDbf's.
225	229
226	230		Wenn zwei Tabellen in Beziehung stehen, zum Beispiel:
227	231
228		-	~~`[Kunden]`\~~
229		-	~~`Id <----\|`\~~
230		-	~~`Name \|`\~~
231		-	~~`Phone \|`\~~
232		-	~~`Address \|`\~~
233		-	~~` \| Die CustID in Rechnungen bezieht sich auf ein Kunden Primärfeld`\~~
234		-	~~`[Rechnungen] \|`\~~
235		-	~~`Id \|`\~~
236		-	~~`Amount \|`\~~
237		-	~~`CustID -----\| * Diese Feld ist als as "idxcustid" indiziert`~~
	232	+	```text
	233	+	[Kunden]
	234	+	Id <----\|
	235	+	Name \|
	236	+	Phone \|
	237	+	Address \|
	238	+	\| Die CustID in Rechnungen bezieht sich auf ein Kunden Primärfeld
	239	+	[Rechnungen] \|
	240	+	Id \|
	241	+	Amount \|
	242	+	CustID -----\| * Diese Feld ist als as "idxcustid" indiziert
	243	+	```
238	244
239	245		Wenn sie alle Rechnungen zu einem bestimmten Kunden anzeigen wollen, kann die Detailtabelle (Rechnungen) automatisch in Synchronizität mit der Mastertabelle (Kunden) bleiben.
240	246
241	247		In der Rechnungen TDbf Komponente stellen sie das Folgende ein:
242	248
243	249		``` pascal
244	250		InvDbf.IndexName := 'idxcustid'; // unser Feld, das der Kunden Tabellen ID entsprechen wird
245	251		InvDbf.MasterSource := dsCustomers; // Datasource die mit der Kunden TDbf verbunden ist
246	252		InvDbf.MasterFields := 'Id'; // Feld in der Kunden Tabelle, das wir gegen unseren Index abgleichen
247	253		```
248	254
249	255		## Beispielanwendung - DB Browser
250	256
251	257		Ich habe eine einfache Anwendung geschrieben, welche TDbf benutzt, um Datenbank Tabellen unter Verwendung des dbGrid Bedienelements zu öffnen und anzuzeigen. Das Linux executable zusammen mit den Projektquellen, welche auch unter Windows kompilieren sollten, ist verfügbar von: [tony.maro.net](http://tony.maro.net/mod.php?mod=downloads&op=showcat&id=3&level=1)
252	258
253	259		## Dinge, deren sie sich bewusst sein müssen
254	260
255	261		Gegenwärtig gibt es keine Unterstützung für referentielle Integrität oder intern verschlüsselte .dbf Dateien.
256	262
257	263		## See also
258	264
259	265		- [[Example: TDbf (creating table and indexes, selecting of index)]]
260	266
261	267		---
262	268		From the Free Pascal wiki, page "Lazarus Tdbf 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