MySQLDatabases/de: what changed

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

Old	New		Line
1	1		Work in progress
2	2
3	3		## Einleitung
4	4
5	5		Im [[Lazarus Database Tutorial\|Datenbank Tutorial]] sahen wir einen ersten Versuch, eine Verbindung zu einem MySQL Server herzustellen. Wir verwendeten zu diesem Zeitpunkt keine Komponenten, weder visuelle oder nichtvisuelle. Hier soll erklärt werden, wie man sich auf eine (vielleicht) einfachere Weise mit einem MySQL Server verbindet.
6	6
7	7		## Verfügbare Komponenten
8	8
9	9		### SQLdb Komponenten
10	10
11	11		Eine andere Möglichkeit ist die Installation der Packages im Verzeichnis \$Lazarus/components/sqldb. In diesem Verzeichnis können sie eine Packagedatei mit Namen sqldblaz.lpk sehen. Sie müssen dieses Package und das mysql4connlaz.lpk Package aus dem Verzeichnis \$Lazarus/components/sqldb/mysql installieren. Das erste Package enthält einige allgemeine Komponenten, die für alle Datenbanken verwendet werden. Diese Komponenten sind TSQLTransaction und TSQLQuery und sind auf dem neuen SQLdb Tab zu finden. Nach der Installation von mysql4connlaz.lpk werden sie eine dritte Komponente auf dem SQLdb Tab mit Namen TMySQLConnection finden(dargestellt durch einen Delphin).
12	12
13	13		Wenn sie das Verzeichnis \$Lazarus/components/sqldb/mysql und mysql4connlaz.lpk nicht finden, dann bedeutet dies, dass sie eine neuere Version benutzen, in welcher mysql4connlaz.lpk mit sqldblaz.lpk fusioniert wurde. Das ist in Ordnung. Die Installation von sqldblaz.lpk wird ihnen alle erwähnten Komponenten im selben Lazarus IDE toolbar TAB bieten.
14	14
15	15		Wenn sie nicht wissen, wie man Komponenten / Packages installiert, dann schauen sie auf dieser [[Install Packages/de\|Seite]] nach. Da die SQLdb Komponenten allgemeiner sind und auch für andere Datenbanken verwendet werden können, indem man zum Beispiel TMySQLConnection durch TIBConnection ersetzt, werden wir mit den SQLdb Komponenten ein Programm entwickeln.
16	16
17	17		Übrigens - (und das ist ziemlich wichtig!) die SQLdb Komponenten können nur die MySQL Client Bibliotheken Version 4.0 verwenden, andere Versionen wie 3.x, 4.x, etc. werden nicht funktionieren! Aber Anwendungen sollten in der Lage sein, eine Verbindung zu einem MySQL Server jeglicher Version herzustellen.
18	18
19	19		## Erläuterung der verwendeten Komponenten
20	20
21	21		### TMySQLConnection
22	22
23	23		TMySQLConnection wird verwendet, um Parameter für die Verbindung zum Datenbank Server aufzubewahren. Sie erlaubt ihnen den Server, den Nutzer und das Kennwort zu setzen. Eine andere Eigenschaft von TMySQLConnection bennent die Datenbank, die sie verwenden wollen. Da das "LoginPrompt" noch funktionslos ist, sollten sie vor Verbindungsaufbau sicherstellen, dass HostName, DatabaseName sowie UserName und Password mit Werten belegt sind. Desweiteren benötigen sie noch eine Komponente vom Typ TSQLTransaction, die in der Transaction-Eigenschaft von TMySQLConnectio eintragen werden muss, da sie sonst keine Anfragen stellen können.
24	24
25	25		Hinweis: In der neuesten SVN Version von Lazarus finden sie 3 MySQLConnection Komponenten. Dies sind TMySQL40Connection, TMySQL41Connection und TMySQL50Connection. Wählen Sie diese gemäss der Serverversion aus, mit welcher Sie sich verbinden wollen. Wenn z.B. bei ihnen MySQL 4.1 läuft, dann verwenden sie TMySQL41Connection.
26	26
27	27		### TSQLTransaction
28	28
29	29		Eine SQLTransaction wird für die interne Organisation benötigt. Eine SQLTransaction wird automatisch aktiviert, wenn sie ein Dataset öffnen, welches diese benutzt. Wenn sie aber die SQLConnection schließen wollen, müssen sie zuerst sicherstellen, dass die SQLTransaction nicht aktiv ist. Da seit Version 1.2.2 kein AutoCommit mehr stattfindet, muß nach Zugriffen auf die Datenbank ein Transaction.Commit durchgeführt werden, um die Änderungen zu speichern bzw. abgefragte Daten zu aktualisieren. z.B.
30	30
31	31		``` pascal
32	32		...
33	33		SQLQuery1.ExecSQL;
34	34		SQLTransaction1.Commit;
35	35		...
36	36		```
37	37
38	38		oder
39	39
40	40		``` pascal
41	41		SQLQuery1.SQL.Text:='SELECT text FROM testtab';
42	42		SQLTransaction.StartTransaction;//Falls die Funktionalität der Transaction nicht benötigt wird, kann das in SQLQuery1BeforeOpen ausgeführt werden.
43	43		SQLQuery1.Open;
44	44		while not SQLQuery1.EOF do
45	45		begin
46	46		ListBox1.Items.Add(SQLQuery1.Fields[0].AsString);
47	47		SQLQuery1.Next;
48	48		end;
49	49		SQLQuery1.Close;
50	50		SQLTransaction.Commit;//Falls die Funktionalität der Transaction nicht benötigt wird, kann das in SQLQuery1AfterClose ausgeführt werden.
51	51		```
52	52
53	53		### TSQLQuery
54	54
55	55		TSQLQuery wird verwendet, um SQL Anweisungen auf dem Server auszuführen. Sie können Daten abrufen, indem sie die SQL Eigenschaft auf einige SELECT Anweisungen setzen und die Open Methode aufrufen. Oder sie können Daten manipulieren, indem sie einige INSERT, DELETE oder UPDATE Anweisungen erstellen. Im letzteren Fall sollten sie nicht die Open Methode benutzen, sondern die ExecSQL Methode.
56	56
57	57		### TDataSource
58	58
59	59		Ein TDataSource bietet die Verbindung zwischen den sichtbaren datensensitiven Komponenten wie DBEdit, DBGrid und einem TDataset. Es macht die Daten für die datensensitiven Komponenten zum Anzeigen verfügbar. Ein TDatasource kann zur selben Zeit nur mit einem einzigen Dataset verbunden werden, aber es können mehrere datensensitive Komponenten verbunden werden.
60	60
61	61		### TDBGrid
62	62
63	63		Ein DBGrid kann benutzt werden, um die Daten zu präsentieren, die man von einem Dataset erhalten hat. Das DBGrid benötigt eine Datasource für die Verbindung zu einem Dataset. Wenn das Dataset geöffnet wird, dann wird das DBGrid automatisch mit den Daten bestückt.
64	64
65	65		## Unser Programm
66	66
67	67		### Die Grundlagen
68	68
69	69		Wir werden versuchen, ein Programm zu erstellen, das auf diesem [[Lazarus Database Tutorial/nl\|hier (auf holländisch)]] basiert, welches auf dem [[Lazarus Database Tutorial\|Original (auf englisch)]] von Chris basiert.
70	70
71	71		### Das Hauptformular
72	72
73	73		Wir werden den selben Hauptbildschirm verwenden und die gesamte Funktionalität von Anfang an erstellen :) Wie sie sehen werden, muss man sich nicht um vieles kümmern, weil die Komponenten die schwierigen Details erledingen! Fangen wir mit einer Seite an, die so aussieht.\
74	74		![](/wiki-images/2/28/Trymysql.png)\
75	75		Vom SQLdb-Tab platzieren sie eine TMySQLConnection, eine TSQLTransaction und eine TSQLQuery ![](/wiki-images/6/6d/Components.png) auf diesem Formular. Ändern sie die vorgegebenen Namen dieser Komponenten nicht, ausgenommen die Connection Komponente. Um diesen Artikel für alle Versionen von MySQL verwenden zu können, benennen sie ihre MySQL??Connection Komponente in MySQLConnection1 um. Wir müssen diese Komponenten miteinander verbinden, damit sie ihren Job erledigen können. Daher müssen die folgenden Eigenschaften gesetzt werden:
76	76
77	77		\| \| \| \|
78	78		\|------------------\|-----------------\|------------------\|
79	79		\| Komponente \| Eigenschaft \| Wert \|
80	80		\| MySQLConnection1 \| Transaction \| SQLTransaction1 \|
81	81		\| SQLTransaction1 \| Database \| MySQLConnection1 \|
82	82		\| SQLQuery1 \| Database \| MySQLConnection1 \|
83	83		\| SQLQuery1 \| Transaction \| SQLTransaction1 \|
84	84
85	85		Die Transaction-Eigenschaft von SQLQuery1 wird automatisch gesetzt, wenn sie zuerst die Transaction-Eigenschaft von MySQLConnection1 setzen. Wenn sie diese setzen, dann werden sie feststellen, dass SQLTransaction1.Database auf MySQLConnection1 gesetzt wurde.
86	86
87	87		### Der Code
88	88
89	89		Wie sie in der Bildschirmanzeige sehen können, sind beim Start des Programms nur die Schaltflächen "Connect to server" und "Exit" verfügbar. Um mit den anderen Schaltflächen arbeiten zu können, benötigen wir weitere Informationen; daher sind sie gesperrt. Wir könnten auch entscheiden, "Connect to Server" ebenfalls zu sperren, bis die Informationen für host, username und password eingegeben wurden. Ich habe mich dagegen entschieden, weil unser Benutzer denken könnte: "Nichts scheint möglich zu sein, ich drücke auf Exit." :)
90	90
91	91		Bevor ich damit beginne, ihnen den Code mitzuteilen, möchte ich betonen, dass es mehr Fehlerbehandlung im Code geben sollte. Kritische Abschnitte sollten in
92	92
93		-	~~`try ... finally`~~
	93	+	```text
	94	+	try ... finally
	95	+	```
94	96
95	97		oder
96	98
97		-	~~`try ... except`~~
	99	+	```text
	100	+	try ... except
	101	+	```
98	102
99	103		Konstruktionen platziert werden .
100	104
101	105		#### Verbinden mit einem Server
102	106
103	107		Das erste, was wir tun müssen, ist, eine Verbindung zum Server herzustellen. Da man nicht weiss, welche Datenbanken auf dem Server verfügbar sind, wenn man sich verbindet, werden wir beim Verbinden nach einer Liste der Datenbanken fragen. Der Haken dabei ist, aber dass man für eine Verbindung einen gültigen DatabaseName in den Eigenschaften von MySQLConnection angeben muss. Sie werden im Code sehen, dass ich die "mysql" Datenbank verwende. Diese Datenbank wird von MySQL zur Organisation verwendet und wird daher immer da sein.
104	108
105	109		``` pascal
106	110		procedure TFormTryMySQL.ConnectButtonClick(Sender: TObject);
107	111		begin
108	112		// Prüfen, ob wir eine aktive Verbindung haben. Falls ja, schliessen wir sie.
109	113		if MySQLConnection1.Connected then CloseConnection(Sender);
110	114		// Die Verbindungsparameter setzen.
111	115		MySQLConnection1.HostName := HostEdit.Text;
112	116		MySQLConnection1.UserName := UserEdit.Text;
113	117		MySQLConnection1.Password := PasswdEdit.Text;
114	118		MySQLConnection1.DatabaseName := 'mysql'; // MySQL ist immer vorhanden!
115	119		ShowString('Opening a connection to server: ' + HostEdit.Text);
116	120		MySQLConnection1.Open;
117	121		// Zuerst eine Liste der verfügbaren Datenbanken abfragen.
118	122		if MySQLConnection1.Connected then begin
119	123		ShowString('Connected to server: ' + HostEdit.Text);
120	124		ShowString('Retrieving list of available databases.');
121	125		SQLTransaction1.Starttransaction;
122	126		SQLQuery1.SQL.Text := 'show databases';
123	127		SQLQuery1.Open;
124	128		while not SQLQuery1.EOF do begin
125	129		DatabaseComboBox.Items.Add(SQLQuery1.Fields[0].AsString);
126	130		SQLQuery1.Next;
127	131		end;
128	132		SQLQuery1.Close;
129	133		SQLTransaction1.Commit;
130	134		ShowString('List of databases received!');
131	135		end;
132	136		end;
133	137		```
134	138
135	139		Zuerst prüfen wir, ob wir mit einem Server verbunden sind. Falls ja, dann rufen wir eine private Methode "CloseConnection" auf. In dieser Methode wird noch etwas mehr aufgeräumt, Schaltflächen deaktiviert und Comboboxen und Listboxen zurück gesetzt. Dann setzen wir die notwendigen Parameter für die Verbindung zum Server.
136	140
137	141
138	142		Überall in unserem Programm werden sie Aufrufe von ShowString sehen. Diese Methode fügt eine Zeile zu dem Memo auf unserem Formular hinzu, die wie ein Log wirkt.
139	143
140	144		Mit der Parameterzusammenstellung können wir mit dem Server verbinden. Dies wird durch den Aufruf von
141	145
142		-	~~`MySQLConnection1.Open; erreicht.`~~
	146	+	```text
	147	+	MySQLConnection1.Open; erreicht.
	148	+	```
143	149
144	150		In einer ordentlichen Anwendung würde man dies in eine Ausnahmebehandlungskonstruktion platzieren, um dem Benutzer eine freundliche Botschaft zu präsentieren, falls die Verbindung fehlgeschlagen ist. Wenn wir verbunden sind, wollen wir eine Liste der Datenbanken vom Server erhalten. Um die Daten vom Server zu erhalten, wird eine TSQLQuery verwendet. Die SQL Eigenschaft wird verwendet, um die SQL-Anweisung aufzubewahren, die an den Server gesendet wird. MySQL kennt das SHOW DATABASES Kommando, um die Liste der Datenbanken zu erhalten. Nachdem wir den SQL-Text eingegeben haben, rufen wir
145	151
146		-	~~`SQLQuery1.Open;`~~
	152	+	```text
	153	+	SQLQuery1.Open;
	154	+	```
147	155
148	156		auf. Die Ergebnismenge einer SQLQuery kann durch die fields Eigenschaft geprüft werden. Wie sie sehen, iterieren wir durch die Datensätze durch den Aufruf von
149	157
150		-	~~`SQLQuery1.Next;`~~
	158	+	```text
	159	+	SQLQuery1.Next;
	160	+	```
151	161
152	162		Wenn wir alle verfügbaren Datenbanken zu unserer Combobox hinzugefügt haben, schließen wir die SQLQuery wieder.
153	163
154	164		#### Auswahl einer Datenbank
155	165
156	166		Wenn der Benutzer eine Datenbank in der DatabaseComboBox auswählt, aktivieren wir die "Select Database" Schaltfläche. In dem OnClick Ereignis dieser Schaltfläche setzen wir DatabaseName der MySQLConnection1, und fordern eine Liste der Tabellen an. Die letzte Anweisung dieser Prozedur aktiviert die "Open Query" Schaltfläche, so dass der Benutzer eine Abfrage in der "Command" Editbox eingeben kann und diese an den Server sendet.
157	167
158	168		``` pascal
159	169		procedure TFormTryMySQL.SelectDBButtonClick(Sender: TObject);
160	170		begin
161	171		// Eine Datenbank wurde ausgewählt, lassen sie uns die Tabellen darin abfragen.
162	172		CloseConnection(Sender);
163	173		if DatabaseComboBox.ItemIndex <> -1 then begin
164	174		with DatabaseComboBox do
165	175		MySQLConnection1.DatabaseName := Items[ItemIndex];
166	176		ShowString('Retreiving list of tables');
167	177		SQLTransaction1.Starttransaction;
168	178		SQLQuery1.SQL.Text := 'show tables';
169	179		SQLQuery1.Open;
170	180		while not SQLQuery1.EOF do begin
171	181		TableComboBox.Items.Add(SQLQuery1.Fields[0].AsString);
172	182		SQLQuery1.Next;
173	183		end;
174	184		SQLQuery1.Close;
175	185		SQLTransaction1.Commit;
176	186		ShowString('List of tables received');
177	187		end;
178	188		OpenQueryButton.Enabled := True;
179	189		end;
180	190		```
181	191
182	192		MySQL hat ein spezielles Kommando, um eine Liste der Tabellen zu erhalten, vergleichbar dem Erhalten einer Liste der Datenbanken, show tables. Das Ergebnis dieser Abfrage wird auf die selbe Weise gehandhabt wie die Liste der Datenbanken und alle Tabellen werden zur TableComboBox hinzugefügt. Sie wundern sich vielleicht, warum wir die Verbindung nicht erneut öffnen, bevor wir die Abfrage auslösen? Nun, dies wird automatisch erledigt (falls notwendig), wenn wir die SQLQuery aktivieren.
183	193
184	194		#### Felder in einer Tabelle
185	195
186	196		In MySQL können sie erneut eine Form von "SHOW" verwenden, um die Felder in einer Tabelle zu erhalten. In diesem Fall "SHOW COLUMNS FROM \<Tabellenname\>". Wenn der Benutzer eine Tabelle aus der TableComboBox auswählt, wird das OnChange Ereignis dieser ComboBox ausgelöst, das die FieldListbox füllt.
187	197
188	198		``` pascal
189	199		procedure TFormTryMySQL.TableComboBoxChange(Sender: TObject);
190	200		begin
191	201		FieldListBox.Clear;
192	202		SQLTransaction1.Starttransaction;
193	203		SQLQuery1.SQL.Text := 'show columns from ' + TableComboBox.Text;
194	204		SQLQuery1.Open;
195	205		while not SQLQuery1.EOF do begin
196	206		FieldListBox.Items.Add(SQLQuery1.Fields[0].AsString);
197	207		SQLQuery1.Next;
198	208		end;
199	209		SQLQuery1.Close;
200	210		SQLTransaction1.Commit;
201	211		end;
202	212		```
203	213
204	214		Ebenso wie die Namen der Felder, enthält die Ergebnismenge Informationen über den Typ des Feldes, ob das Feld ein Schlüssel ist, ob Nullwerte erlaubt sind und einiges mehr.
205	215
206	216		#### Anzeigen der Daten
207	217
208	218		Wie bereits erwähnt, wollen wir Komponenten verwenden, um eine Verbindung zur Datenbank zu bekommen. Lassen sie uns ebenso einige Komponenten verwenden, um die Daten zu zeigen. Wir werden ein zweites Formular verwenden, um ein Raster mit den vom Benutzer angeforderten Daten zu zeigen. Dieses Formular wird gezeigt, wenn der Benutzer ein SQL Kommando in der "Command" Editbox eingegeben und danach auf die "Open Query" Schaltfläche geklickt hat. Dies ist das OnClick Ereignis:
209	219
210	220		``` pascal
211	221		procedure TFormTryMySQL.OpenQueryButtonClick(Sender: TObject);
212	222		begin
213	223		ShowQueryForm := TShowQueryForm.Create(self);
214	224		ShowQueryForm.Datasource1.DataSet := SQLQuery1;
215	225		SQLQuery1.SQL.Text := CommandEdit.Text;
216	226		SQLQuery1.Open;
217	227		ShowQueryForm.ShowModal;
218	228		ShowQueryForm.Free;
219	229		SQLQuery1.Close;
220	230		end;
221	231		```
222	232
223	233		Das ShowQuery Formular sieht etwa so aus:
224	234
225	235		![](/wiki-images/4/47/Mysqlshow.png)
226	236
227	237		und enthält ein
228	238
229	239		\| \| \| \|
230	240		\|-------------\|------------\|-------------\|
231	241		\| TPanel \| Align \| alBottom \|
232	242		\| TDataSource \| \| \|
233	243		\| TDBGrid \| Align \| alClient \|
234	244		\| \| DataSource \| DataSource1 \|
235	245		\| TButton \| Caption \| Close \|
236	246
237	247		Die Schaltfläche wird auf dem Panel plaziert. Was im "Open Query" OnClick Ereignis passiert, ist folgendes. Zuerst erzeugen wir eine Instanz von TShowQueryForm. Zweitens setzen wir die DataSet Eigenschaft der DataSource auf unsere SQLQuery1. Dann setzen wir das SQLQuery SQL Kommando auf die Benutzereingabe in der "Command" Editbox und öffnen es. Dann wird das ShowQuery Formular modal gezeigt. Das bedeutet, dass wir den Fokus unseres Programms haben, bis dieses geschlossen wird. Wenn sie geschlossen wird, geben wir sie "frei" und schließen SQLQuery1 erneut.
238	248
239	249		The Form can be further enhanced by inserting a method for modifying the content of the DataSet and ultimately the DataBase. A full version can be downloaded from <http://digitus.itk.ppke.hu/~janma/lazarus/MySql5Test.tar.gz> (with thanks to Arwen and JZombi from the Lazarus MySQL Forum) but the relevant details are as follows:
240	250
241	251		Add a Button at the bottom of the ShowQuery Form named AddButton and with Caption 'Add'. Erzeugen sie eine Methode für AddButtonClick wie diese:
242	252
243		-	~~`procedure TShowQueryForm.AddButtonClick(Sender: TObject);`\~~
244		-	~~`begin`\~~
245		-	~~` DataSource1.DataSet.Append;`\~~
246		-	~~`end; `~~
	253	+	``` pascal
	254	+	procedure TShowQueryForm.AddButtonClick(Sender: TObject);
	255	+	begin
	256	+	DataSource1.DataSet.Append;
	257	+	end;
	258	+	```
247	259
248	260		Ändern sie den Code für OpenQueryButtonClick, to allow for updates to the database when we finish with the Query Form.
249	261
250		-	~~`procedure TFormTryMySQL.OpenQueryButtonClick(Sender: TObject);`\~~
251		-	~~`begin`\~~
252		-	~~` ShowQueryForm := TShowQueryForm.Create(nil);`\~~
253		-	~~` try`\~~
254		-	~~` ShowQueryForm.DataSource1.DataSet := SQLQuery1;`\~~
255		-	~~` // We will write in the database, so let's set ReadOnly to false, `\~~
256		-	~~` // and for that we need to set ParseSQL true`\~~
257		-	~~` SQLQuery1.ParseSQL:=true;`\~~
258		-	~~` SQLQuery1.ReadOnly:=false;`\~~
259		-	~~` SQLQuery1.SQL.Text := CommandEdit.Text;`\~~
260		-	~~` SQLQuery1.Open;`\~~
261		-	~~` ShowQueryForm.ShowModal;`\~~
262		-	~~` finally`\~~
263		-	~~` // set up update mode, and update database`\~~
264		-	~~` SQLQuery1.UpdateMode:=upWhereChanged;`\~~
265		-	~~` SQLQuery1.ApplyUpdates;`\~~
266		-	~~` SQLTransaction1.Commit;`\~~
267		-	~~` ShowQueryForm.Free;`\~~
268		-	~~` SQLQuery1.Close;`\~~
269		-	~~` // set read-only and parsesql back to default`\~~
270		-	~~` SQLQuery1.ParseSQL:=false;`\~~
271		-	~~` SQLQuery1.ReadOnly:=true;`\~~
272		-	~~` end;`\~~
273		-	~~`end;`\~~
274		-	~~` `~~
	262	+	``` pascal
	263	+	procedure TFormTryMySQL.OpenQueryButtonClick(Sender: TObject);
	264	+	begin
	265	+	ShowQueryForm := TShowQueryForm.Create(nil);
	266	+	try
	267	+	ShowQueryForm.DataSource1.DataSet := SQLQuery1;
	268	+	// We will write in the database, so let's set ReadOnly to false,
	269	+	// and for that we need to set ParseSQL true
	270	+	SQLQuery1.ParseSQL:=true;
	271	+	SQLQuery1.ReadOnly:=false;
	272	+	SQLQuery1.SQL.Text := CommandEdit.Text;
	273	+	SQLQuery1.Open;
	274	+	ShowQueryForm.ShowModal;
	275	+	finally
	276	+	// set up update mode, and update database
	277	+	SQLQuery1.UpdateMode:=upWhereChanged;
	278	+	SQLQuery1.ApplyUpdates;
	279	+	SQLTransaction1.Commit;
	280	+	ShowQueryForm.Free;
	281	+	SQLQuery1.Close;
	282	+	// set read-only and parsesql back to default
	283	+	SQLQuery1.ParseSQL:=false;
	284	+	SQLQuery1.ReadOnly:=true;
	285	+	end;
	286	+	end;
	287	+	```
275	288
276	289		Wir können jetzt Datensätze zur Datenbank hinzufügen. Wenn wir ein TDBNavigator zu der ShowQuery Form hinzufügen,können wir im Data Grid besser navigieren,Datensätze einfügen.Die Datenbank wird jedesmal aktualisiert, wenn die ShowQueryForm geschlossen wird und das können wir nachprüfen,wenn wir ShowQueryForm wieder öffnen.
277	290
278	291		## Quellen
279	292
280	293		Die Quellen für dieses Projekt können von [hier](http://prdownloads.sourceforge.net/lazarus-ccr/mysql_demo_20050408.tar.gz?download) heruntergeladen werden. Für mehr Demoprojekte siehe [Sourceforge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=148359).
281	294
282	295		---
283	296		From the Free Pascal wiki, page "MySQLDatabases/de", as it stood on 2020-02-20 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