Database tutorial SQLdb1/de: what changed

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

Old	New		Line
1	1		## Einleitung
2	2
3	3		Dieses Tutorial hat das Ziel, die Verwendung des [[SQLdb Package\|SQLdb Packages]] anhand praktischer Beispiele zu demonstrieren. Es richtet sich vor allem an Einsteiger. Wer nach Grundlageninformationen über Datenbanken und SQL sucht, dem seien die einschlägigen Bücher empfohlen. Für das Tutorial greife ich auf Firebird mit der Beispieldatenbank employee.fdb zurück.
4	4
5	5		Bedanken möchte ich mich bei Joost und Michael, ohne deren Hilfe das Tutorial wahrscheinlich nicht zustande gekommen wäre.
6	6
7	7		## Voraussetzungen
8	8
9	9		Für dieses Tutorial sollten sie möglichst eine aktuelle Lazarus Version verwenden (mit FPC 2.6.2 oder höher). Sollte das SQLdb Package noch nicht installiert sein, dann holen sie das jetzt nach (Package -\> Installierte Packages einrichten ... -\> SQLDBLaz 1.0.2). Außerdem wird [Firebird](http://sourceforge.net/project/showfiles.php?group_id=9028) (möglichst Version 2.5 oder höher) benötigt. Die Beispiele gehen davon aus, dass die Standardvorgaben (SYSDBA und masterkey) nicht verändert wurden.
10	10
11	11		## Beispiel 1
12	12
13	13		Starten sie ein neues Projekt in Lazarus. Für den Zugriff auf die Datenbank benötigen wir je eine TIBConnection, TSQLTransaction und [[Working With TSQLQuery\|TSQLQuery]] von der Seite 'SQLdb' in der Komponentenpalette. Die erste Komponente ist spezifisch für den Zugriff auf Firebird-Datenbanken. Die beiden anderen Komponenten kommen bei allen Datenbanken zum Einsatz, auf die sie mit SQLdb zugreifen können. Für die Anzeige der Daten verwenden wir eine TDBGrid Komponente, die sie auf der Seite 'Data Controls' finden. Für die Verbindung mit den Datenbankkomponenten benötigen wir noch eine TDatasource Komponente von der Seite 'Data Access'. Zum Auslösen der Aktionen verwenden wir einen TButton von der Seite 'Standard'. Damit haben wir alle Komponenten, die wir für das erste Beispiel benötigen. Vergrößern sie das TDBGrid noch etwas, damit genügend Platz für die Anzeige der Daten zur Verfügung steht.
14	14
15	15		Als nächstes müssen wir die Komponenten miteinander verbinden. Am einfachsten geht das im Objektinspektor. Man kann die Zuweisungen aber auch im Quelltext vornehmen. Ändern sie die 'Transaction' Eigenschaft von IBConnection1 auf 'SQLTransaction1'. Damit wird die 'Database' Eigenschaft von SQLTransaction1 automatisch auf 'IBConnection1' eingestellt. Als nächstes setzen sie die 'Database' Eigenschaft von SQLQuery1 auf 'IBConnection1'. Lazarus ergänzt dann automatisch die 'Transaction' Eigenschaft. Die 'Dataset' Eigenschaft von Datasource1 ändern sie auf 'SQLQuery1'. Zum Schluss müssen sie noch die 'Datasource' Eigenschaft von DBGrid1 auf 'Datasource1' ändern.
16	16
17	17		Wie kommen jetzt die Daten aus der Datenbank auf den Bildschirm? Zunächst müssen wir IBConnection1 mitteilen, wo sich die employee.fdb befindet (üblicherweise im .../examples/empbuild/ Unterverzeichnis ihrer Firebird-Installation). Sie haben jetzt wieder die Wahl, ob sie auf den Objektinspektor zurückgreifen wollen, oder das Verzeichnis im Quelltext zuweisen wollen. Wir entscheiden uns hier für den Objektinspektor. Ändern sie die 'DatabaseName' Eigenschaft von IBConnection1 auf den Pfad zur Datei employee.fdb (z.B. C:\Programme\Firebird\Firebird_2_5\examples\empbuild\EMPLOYEE.FDB). Wenn sie sich den Pfad nicht merken können, dann können sie ihn idR. auch aus ihrem Dateimanager mittels 'kopieren und einfügen' eintragen. Bevor der Datenbank-Server Daten herausrückt, wird er die Berechtigung über Benutzername und Passwort abfragen. Eine ernsthafte Datenbank-Anwendung wird daher beim Programmstart den Benutzer danach fragen, um die Daten im geeigneten Moment an den Datenbank-Server weiterzureichen. Wir werden der Einfachheit halber wieder auf den Objektinspektor zurückgreifen. Ändern sie die 'UserName' Eigenschaft auf 'SYSDBA' und 'Password' auf 'masterkey'. Um zu prüfen, ob die bisher vorgenommenen Einstellungen formal korrekt sind, können sie die 'Connected' Eigenschaft auf 'True' setzen. Ist der Pfad nicht richtig oder stimmt der Benutzername oder das Passwort nicht, dann erscheint eine Fehlermeldung. War die Verbindung erfolgreich, dann trennen sie diese jetzt wieder (auf 'False' setzen).
18	18
19	19		Trotz der erfolgreichen Verbindung wurden aber immer noch keine Daten angezeigt. Das erklärt sich dadurch, dass wir dem Datenbank-Server auch noch nicht mitgeteilt haben, was er anzeigen soll. Die Datenbank employee.fdb enthält mehrere Tabellen. Wenn sie im Vorfeld die Struktur einer Datenbank nicht kennen, dann können sie auf Werkzeuge wie [FlameRobin](http://www.flamerobin.org/index.php) zurückgreifen, um sich die Inhalte anzuzeigen. Aber auch Lazarus bietet ein Hilfsmittel - den Datenbank-Desktop. Sie finden ihn im /tools/lazdatadesktop/ Unterverzeichnis von Lazarus. Öffnen sie das Projekt lazdatadesktop.lpi und kompilieren sie es (setzt FPC 2.6.2 voraus) (unser Beispielprojekt haben sie natürlich vorher gesichert).
20	20
21	21		[framed\|center\|Der Datenbank-Desktop in Aktion](/wiki-images/d/df/Datadesktop.png)
22	22
23	23		Zurück zu unserem Beispiel. Wir wollen alle Daten aus der Tabelle 'CUSTOMER' anzeigen. Der SQL Befehl dazu lautet:
24	24
25		-	~~`select * from CUSTOMER`~~
	25	+	```text
	26	+	select * from CUSTOMER
	27	+	```
26	28
27	29		Diesen Befehl müssen wir der 'SQL' Eigenschaft von SQLQuery1 zuweisen. Im Quelltext unseres Programms würde das so aussehen:
28	30
29		-	~~`SQLQuery1.SQL.Text := 'select * from CUSTOMER';`~~
	31	+	``` pascal
	32	+	SQLQuery1.SQL.Text := 'select * from CUSTOMER';
	33	+	```
30	34
31	35		Wird der Befehl in Textform angegeben, dann muss er in einfache Anführungszeichen eingeschlossen werden. Man könnte natürlich auch den Inhalt einer anderen Komponente zuweisen.
32	36
33	37		Die Abfrage der Daten soll erfolgen, wenn der Benutzer auf den Button klickt. Mit einem Doppelklick auf Button1 erzeugt Lazarus das Grundgerüst der dafür notwendigen Prozedur. In ihrem Quelltext sollte jetzt folgendes stehen:
34	38
35	39		``` pascal
36	40		procedure TForm1.Button1Click(Sender: TObject);
37	41		begin
38	42
39	43		end;
40	44		```
41	45
42	46		Zwischen begin und end müssen wir jetzt die Anweisungen eingeben, die zum Anzeigen der Daten erforderlich sind. Die 'SQL' Eigenschaft von SQLQuery1 kann nur geändert werden, wenn SQLQuery1 nicht aktiv ist. Daher schließen wir die Komponente zunächst:
43	47
44		-	~~`SQLQuery1.Close;`~~
	48	+	```text
	49	+	SQLQuery1.Close;
	50	+	```
45	51
46	52		Da wir nicht sicher sein können, ob SQLQuery1 noch irgendwelche Daten enthält, rufen wir die 'Clear' Prozedur auf:
47	53
48		-	~~`SQLQuery1.SQl.Clear;`~~
	54	+	```text
	55	+	SQLQuery1.SQl.Clear;
	56	+	```
49	57
50	58		Dann weisen wir der 'SQL' Eigenschaft unsere SQL Anweisung zu:
51	59
52		-	~~`SQLQuery1.SQL.Text := 'select * from CUSTOMER';`~~
	60	+	``` pascal
	61	+	SQLQuery1.SQL.Text := 'select * from CUSTOMER';
	62	+	```
53	63
54	64		Jetzt müssen wir die Verbindung zur Datenbank herstellen sowie die Transaktion aktivieren und dann die Abfrage öffnen:
55	65
56		-	~~`IBConnection1.Connected := True;`\~~
57		-	~~`SQLTransaction1.Active := True;`\~~
58		-	~~`SQLQuery1.Open;`~~
	66	+	``` pascal
	67	+	IBConnection1.Connected := True;
	68	+	SQLTransaction1.Active := True;
	69	+	SQLQuery1.Open;
	70	+	```
59	71
60	72		Die ersten beiden Anweisungen können auch weggelassen werden, da sie von der dritten Anweisung automatisch erledigt werden (dies gilt aber nicht im umgekehrten Fall beim Trennen der Verbindung). Es wird aber empfohlen, die Anweisungen nicht wegzulassen, da es sonst in einigen Fällen bei einem ROLLBACK zu Problemen kommen kann. Wenn sie jetzt ihr Programm kompilieren würden, dann würden die Daten aus der Tabelle 'CUSTOMER' bereits angezeigt werden. Ein ordentliches Programm wird aber spätestens beim Beenden dafür sorgen, dass noch offene Verbindungen zur Datenbank geschlossen werden. Die Nebenwirkungen wären sonst nicht absehbar. Wir verwenden das OnClose Ereignis unseres Formulars (mittels Doppelklick im Objektinspektor erzeugen):
61	73
62	74		``` pascal
63	75		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
64	76		begin
65	77
66	78		end;
67	79		```
68	80
69	81		Beim Trennen verwenden wir die umgekehrte Reihenfolge wie beim Verbinden:
70	82
71		-	~~`SQLQuery1.Close;`\~~
72		-	~~`SQLTransaction1.Active := False;`\~~
73		-	~~`IBConnection1.Connected := False;`~~
	83	+	``` pascal
	84	+	SQLQuery1.Close;
	85	+	SQLTransaction1.Active := False;
	86	+	IBConnection1.Connected := False;
	87	+	```
74	88
75	89		### Zusammenfassung
76	90
77	91		Wir haben bisher gelernt, wie man mit dem SQLdb Package eine Verbindung zu einer Firebird Datenbank herstellt und die Daten einer Tabelle am Bildschirm anzeigt.
78	92
79	93		## Erweiterung von Beispiel 1
80	94
81	95		Wenn sie sich an die bisherigen Schritte gehalten haben, dann sollte ihr Quelltext etwa so aussehen:
82	96
83	97		``` pascal
84	98		unit Unit1;
85	99
86	100		{$mode objfpc}{$H+}
87	101
88	102		interface
89	103
90	104		uses
91	105		Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs,
92	106		IBConnection, sqldb, DBGrids, db, StdCtrls;
93	107
94	108		type
95	109
96	110		{ TForm1 }
97	111
98	112		TForm1 = class(TForm)
99	113		Button1: TButton;
100	114		Datasource1: TDatasource;
101	115		DBGrid1: TDBGrid;
102	116		IBConnection1: TIBConnection;
103	117		SQLQuery1: TSQLQuery;
104	118		SQLTransaction1: TSQLTransaction;
105	119		procedure Button1Click(Sender: TObject);
106	120		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
107	121		private
108	122		{ private declarations }
109	123		public
110	124		{ public declarations }
111	125		end;
112	126
113	127		var
114	128		Form1: TForm1;
115	129
116	130		implementation
117	131
118	132		{ TForm1 }
119	133
120	134		procedure TForm1.Button1Click(Sender: TObject);
121	135		begin
122	136		SQLQuery1.Close;
123	137		SQLQuery1.SQL.Clear;
124	138		SQLQuery1.SQL.Text:= 'select * from CUSTOMER';
125	139		IBConnection1.Connected:= True;
126	140		SQLTransaction1.Active:= True;
127	141		SQLQuery1.Open;
128	142		end;
129	143
130	144		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
131	145		begin
132	146		SQLQuery1.Close;
133	147		SQLTransaction1.Active:= False;
134	148		IBConnection1.Connected:= False;
135	149		end;
136	150
137	151		initialization
138	152		{$I unit1.lrs}
139	153
140	154		end.
141	155		```
142	156
143	157		Nun wird man aber in den seltensten Fällen den kompletten Inhalt einer Tabelle benötigen. Nehmen wir an, es sollen nur die Kunden aus den USA angezeigt werden. Dafür müsste die SQL Anweisung wie folgt lauten:
144	158
145		-	~~`select * from CUSTOMER where COUNTRY = 'USA'`~~
	159	+	```text
	160	+	select * from CUSTOMER where COUNTRY = 'USA'
	161	+	```
146	162
147	163		Diese Anweisung werden wir aus zwei Gründen nicht für unser Beispielprogramm verwenden: Zum einen gibt es ein Problem bei der Verwendung des einfachen Anführungszeichens. Der Compiler würde das Anführungszeichen vor USA als schließendes Zeichen betrachten (das erste Zeichen steht ja vor select from...) und damit die SQL Anweisung ungültig machen. Der zweite und gewichtigere Grund ist die Tatsache, dass bei der Entwicklung des Programms noch gar nicht bekannt ist, welche Einschränkung der Anzeige später vorgenommen werden soll. Der Benutzer soll in seiner Flexibilität nicht eingeschränkt werden. Dazu ersetzen wir zunächst 'USA' durch einen Platzhalter:
148	164
149		-	~~`select * from CUSTOMER where COUNTRY = :COUNTRY`~~
	165	+	```text
	166	+	select * from CUSTOMER where COUNTRY = :COUNTRY
	167	+	```
150	168
151	169		Die Platzhalter sind durch den führenden Doppelpunkt gekennzeichnet. Um dem Benutzer die Eingabe des Filterwertes zu ermöglichen, platzieren sie eine TEdit Komponente (Seite 'Standard' in der Komponentenpalette) auf ihrem Formular. Löschen sie den Wert der 'Text' Eigenschaft. Über die 'Params' Eigenschaft von TSQLQuery können wir nun mit dem in TEdit eingegebenem Text unseren Platzhalter ersetzen:
152	170
153		-	~~`SQLQuery1.Params.ParamByName('COUNTRY').AsString := Edit1.Text;`~~
	171	+	``` pascal
	172	+	SQLQuery1.Params.ParamByName('COUNTRY').AsString := Edit1.Text;
	173	+	```
154	174
155	175		Der Parameter kann sowohl über seine Position als auch seinen Namen spezifiziert werden. Letzteres dürfte vor allem die Lesbarkeit des Quelltextes verbessern. Insgesamt sollte die Prozedur jetzt so aussehen:
156	176
157	177		``` pascal
158	178		procedure TForm1.Button1Click(Sender: TObject);
159	179		begin
160	180		SQLQuery1.Close;
161	181		SQLQuery1.SQL.Clear;
162	182		SQLQuery1.SQL.Text:= 'select * from CUSTOMER where COUNTRY = :COUNTRY';
163	183		SQLQuery1.Params.ParamByName('COUNTRY').AsString := Edit1.Text;
164	184		IBConnection1.Connected:= True;
165	185		SQLTransaction1.Active:= True;
166	186		SQLQuery1.Open;
167	187		end;
168	188		```
169	189
170	190		Sie können jetzt ruhig mit den Einstellungen ein wenig herumspielen. Wenn sie einen Filterwert eingeben, der in der Datenbank nicht vorhanden ist, dann wird eine leere Tabelle angezeigt. Es können jedoch auch ernsthafte Probleme auftreten. Da bei einer Client-Server-Anwendung üblicherweise Client und Server räumlich getrennt sind, ist meist nicht auf den ersten Blick ersichtlich, warum es zu einem Problem gekommen ist. Ist der Server heruntergefahren worden oder hat nur jemand einen Stecker gezogen? Zugriffe auf eine Datenbank sollten daher immer in eine try ... except und/oder try ... finally Schleife eingebunden werden. Nur so ist sichergestellt, dass Datenbankfehler abgefangen werden können und der Anwender nicht im Regen stehen gelassen wird. Für unsere Beispielanwendung könnte eine rudimentäre Behandlungsroutine wie folgt aussehen:
171	191
172	192		``` pascal
173	193		begin
174	194		try
175	195		SQLQuery1.Close;
176	196		...
177	197		SQLQuery1.Open;
178	198		except
179	199		on EDatabaseError do
180	200		begin
181	201		MessageDlg('Fehler','Es ist ein Datenbankfehler aufgetreten.',mtError,[mbOK],0);
182	202		Edit1.Text:='';
183	203		end;
184	204		end;
185	205		end;
186	206		```
187	207
188	208		Hier wird jedoch nur eine einfache Meldung ausgegeben.
189	209
190	210		## Siehe auch
191	211
192	212		- [[SQLdb Package]]: Informationen über das SQLdb Package
193	213		- [[SQLdb Programming Reference]]: eine Übersicht über das Zusammenspiel der Datenbankkomponenten von SQLdb
194	214		- [[SqlDBHowto/de]]: Informationen zur Verwendung des SQLdb Packages
195	215		- [LazInfos](http://sourceforge.net/project/showfiles.php?group_id=203326): enthält allgemeine Informationen zu Lazarus sowie über Datenbanken
196	216		- [[Working With TSQLQuery]]: Informationen über TSQLQuery
197	217
198	218		---
199	219		From the Free Pascal wiki, page "Database tutorial SQLdb1/de", as it stood on 2022-01-12 after a change by Crore, 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