SqlDBHowto/de: what changed

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

Old	New		Line
1	1		## Einleitung
2	2
3	3		Diese Seite ist eine Übersetzung der Seite [[SqlDBHowto/nl]]. Der niederländische Text ist für die Übersetzung massgeblich, auch wenn ich mir die Freiheit genommen habe, einige Korrekturen (meiner Meinung nach kleinere Korrekturen) zu machen.\
4	4
5	5		Ich entschied mich für diese Art der Darstellung um einige Fragen zu beantworten und um zu zeigen, wie Sie ein Problem lösen können. Alle diese Fragen eine Frage nach der anderen zeigen auch, wie ein Tutorial erstellt wird.\
6	6
7	7		## Verbinden mit einem Datenbankserver
8	8
9	9		SqlDB verbindet sich nicht direkt mit einem Datenbankserver sondern verwendet einen Client, der mit dem verwendeten Datenbankserver kommuniziert. (Dieser Client wird meist vom Hersteller der Datenbank geliefert und wird lokal auf dem Computer installiert, der sich mit der Datenbank verbinden soll.) SqlDB sendet die Kommandos an die Client-Bibliothek, die sich mit der Datenbank verbindet und ihr die Kommandos übergibt. Unter Windows ist der Client üblicherweise eine .dll Datei, unter Linux eine .so und unter OS/X eine .dylib Datei.\
10	10		Wenn die Client-Bibliothek richtig installiert ist, kann man sich über eineTSQLConnection Komponente mit der Datenbank verbinden. Für den Zugriff auf die unterschiedlichen Datenbankserver gibt es eine Vielzahl von TSQLConnection Komponenten.\
11	11
12	12		Zum Beispiel kann man sich:
13	13
14	14		- mit der Komponente TIBConnection mit einer Firebird/Interbase Datenbank verbinden
15	15		- mit der Komponente TPQConnection mit einer PostgreSQL Datenbank verbinden
16	16		- mit der Komponente TMySQL56Connection mit einer MySQL Datenbank verbinden
17	17		- usw.
18	18
19	19		Wenn auf ihrem Computer zum Beispiel die MySQL-Client-Bibliothek Version 4.1 installiert ist, sollte eine TMySQL41Connection verwendet werden, unabhängig von der Version des MySQL-Servers.\
20	20
21	21		Obwohl die Details für die verschiedenen Datenbanken differieren, muss man im allgemeinen nur vier Eigenschaften setzen für die Verbindung zum Datenbankserver: den Namen der Datenbank, den Server-Namen oder die IP Adresse, den Benutzernamen und das Passwort. Wenn diese Eigenschaften gesetzt sind, können sie eine Verbindung mit der 'open' Methode herstellen. Wenn die Verbindung fehlschlägt, wird eine EDatabaseError Exception ausgelöst. Verwenden sie die 'connected' Eigenschaft um zu testen, ob die Verbindung zum Datenbank-Server hergestellt wurde. Mit der 'close' Methode beenden sie die Verbindung zum Server.
22	22
23	23		``` pascal
24	24		Program ConnectDB
25	25
26	26		var AConnection : TSQLConnection;
27	27
28	28		Procedure CreateConnection;
29	29		begin
30	30		AConnection := TIBConnection.Create(nil);
31	31		AConnection.Hostname := 'localhost';
32	32		AConnection.DatabaseName := '/opt/firebird/examples/employee.fdb';
33	33		AConnection.UserName := 'sysdba';
34	34		AConnection.Password := 'masterkey';
35	35		end;
36	36
37	37		begin
38	38		CreateConnection;
39	39		AConnection.Open;
40	40		if Aconnection.Connected then
41	41		writeln('Erfolgreich verbunden!')
42	42		else
43	43		writeln('Es konnte keine Verbindung zur Datenbank erstellt werden. ' +
44	44		'Wenn Sie in Ihrem Programm hier weitermachen, dann lösen Sie eine Exception aus.');
45	45		AConnection.Close;
46	46		AConnection.Free;
47	47		end.
48	48		```
49	49
50	50		Wird eine Exception ausgelöst, dann lesen Sie bitte die Fehlermeldung sorgfältig. Möglicherweise geht der Datenbankserver nicht oder der Benutzername oder das Kennwort ist falsch, oder der Datenbankname oder die IP-Adresse wurden falsch geschrieben. Sagt zum Beispiel, die Fehlermeldung, dass die Client-Bibliothek der Datenbank nicht gefunden wurde, dann überprüfen Sie bitte, ob die Client-Bibliothek der Datenbank korrekt installiert ist.\
51	51
52	52		## Abfragen direkt ausführen / Eine Tabelle erstellen
53	53
54	54		SQLdb - der Name sagt es bereits - funktioniert nur mit Datenbankservern, die Gebrauch von SQL machen. SQL steht für 'Structured Query Language'. SQL ist eine Sprache die entwickelt wurde, um das Arbeiten mit relationalen Datenbanken zu ermöglichen. Jedes Datenbanksystem benutzt einen eigenen Dialekt. Aber die überwiegende Anzahl von SQL Anweisungen ist für alle Datenbanksysteme gleich. Man unterscheidet zwischen Anweisungen, die Informationen zurückgeben, und Anweisungen, die keine Informationen zurückgeben. Wenn sie die Informationen nutzen wollen, die von einer SQL Anweisung zurückgegeben werden, dann müssen die TSQLQuery Komponente verwenden (siehe Daten aus einer Tabelle lesen). Wollen Sie dagegen keine Informationen von Ihrem Datenbankserver verarbeiten, dann müssen Sie die Methode 'ExecuteDirect' der Klasse TSQLConnection verwenden.\
55	55
56	56		Die meisten Datenbank-Server können in einer Transaktion SQL Anweisungen auszuführen. Sie können auch mehrere SQL Anweisungen zu einer Transaktion zusammenfassen. Transaktionen werden mit einem 'StartTransaction' begonnen und mit einem 'commit' beendet. Um Transkationen durchführen zu können enthält sqldb die Komponente TSQLTransaction. Eine SQL-Anweisung, die von sqldb ausgeführt wird, muss immer innerhalb einer Transaktion ausgeführt werden. Auch dann, wenn das Datenbanksystem keine Transaktionen unterstützt.\
57	57
58	58		Wenn Sie einen SQL-Befehl mit TSQLConnection.ExecuteDirect ausführen möchten, müssen Sie zunächst angeben, welche Transkation (TSQLTransaction) verwendet werden soll. Der Transaktion (TSQLTransaction) wiederum, müssen Sie angeben, welche Verbindung (TSQLConnection) verwendet werden soll.\
59	59
60	60		Das folgende Beispiel erstellt eine Tabelle 'TBLNAMES' mit den Feldern 'NAME' und 'ID' und fügt zwei Datensätze ein. Die verwendeten SQL Anweisungen sind nicht erläutert. Für weitere Informationen über die SQL Anweisungen, ihre Verwendung und Schreibweise schauen sie bitte in der Dokumentation ihres Datenbanksystems nach. Die Prozedur 'CreateConnection' ist im Code-Beispiel im Abschnitt Verbinden mit einem Datenbankserver definiert.
61	61
62	62		``` pascal
63	63		program CreateTable;
64	64
65	65		var AConnection : TSQLConnection;
66	66		ATransaction : TSQLTransaction;
67	67
68	68		procedure CreateTransaction;
69	69		begin
70	70		ATransaction := TSQLTransaction.Create(nil);
71	71		ATransaction.Database := AConnection;
72	72		end;
73	73
74	74		begin
75	75		CreateConnection;
76	76		CreateTransaction;
77	77		AConnection.Transaction := ATransaction;
78	78		AConnection.Open;
79	79		ATransaction.StartTransaction;
80	80		AConnection.ExecuteDirect('create table TBLNAMES (ID integer, NAME varchar(40));');
81	81
82	82		// Einige Datenbankserver benöigen ein commit, bevor sie eine neu erzeugte Tabelle nutzen können. (Firebird)
83	83		// Mit .Commit schließen sie auch die Transaktion.
84	84		ATransaction.Commit;
85	85
86	86		ATransaction.StartTransaction;
87	87		AConnection.ExecuteDirect('insert into TBLNAMES (ID,NAME) values (1,'Name1');');
88	88		AConnection.ExecuteDirect('insert into TBLNAMES (ID,NAME) values (2,'Name2');');
89	89		ATransaction.Commit;
90	90		AConnection.Close;
91	91		AConnection.Free;
92	92		ATransaction.Free;
93	93		end.
94	94		```
95	95
96	96		## Daten aus einer Tabelle lesen
97	97
98	98		Verwenden sie die TSQLQuery Komponente, um Daten aus einer Tabelle zu lesen. Eine TSQLQuery Komponente muss mit einer TSQLConnection und einer TSQLTransaction Komponente verbunden werden, damit sie funktionieren kann.\
99	99		Die Themen TSQLConnection und TSQLTransaction wurden in den Abschnitten Verbinden mit einem Datenbankserver und Abfragen direkt ausführen / Eine Tabelle erstellen behandelt.\
100	100
101	101		Wenn TSQLConnection, TSQLTransaction und TSQLQuery verbunden sind, dann werden weitere Einstellungen für TSQLQuery benötigt. TSQLQuery besitzt eine 'SQL' Eigenschaft, die ein TStrings Objekt enthält. Die 'SQL' Eigenschaft enthält eine SQL Anweisung, die ausgeführt werden muss. Wenn alle Daten aus einer Tabelle gelesen werden sollen, dann setzten sie die 'SQL' Eigenschaft auf 'SELECT * FROM tablename;'. Verwenden sie 'open', um die Tabelle auf dem Server auszulesen und die Daten im TSQLQuery dataset abzulegen. Auf die Daten kann über TSQLQuery zugegriffen werden, bis diese mittels 'close' geschlossen wird. TSQLQuery ist eine Unterklasse von TDataset. TDataset besitzt eine 'Fields' Kollektion, die alle Spalten der Tabelle enthält. Das TDataset behält auch den aktuellen Datensatz im Auge. Verwenden sie die Eigenschaften '.First', '.Next', '.Prior' und '.Last', um den aktuellen Datensatz zu ändern. 'Bof' gibt 'True' zurück, wenn der erste Datensatz erreicht ist und 'Eof' gibt 'True' zurück, wenn der letzte Datensatz erreicht ist. Um den Wert eines Feldes im aktuellen Datensatz zu lesen müssen sie zunächst das richtige 'TField' Objekt herausfinden und dann 'AsString', 'AsInteger', etc. verwenden.
102	102
103	103		Hier ist ein Beispiel, das alle Werte aus der im Abschnitt Abfragen direkt ausführen / Eine Tabelle erstellen selbst erstellten Tabelle ausliest.
104	104
105	105		``` pascal
106	106		Program ShowData;
107	107
108	108		var
109	109		AConnection : TSQLConnection;
110	110		ATransaction : TSQLTransaction;
111	111
112	112		function GetQuery : TSQLQuery;
113	113		var
114	114		AQuery : TSQLQuery;
115	115		begin
116	116		AQuery := TSQLQuery.Create(nil);
117	117		AQuery.Database := AConnection;
118	118		AQuery.Transaction := ATransaction;
119	119		Result := AQuery;
120	120		end;
121	121
122	122		var
123	123		Query : TSQLQuery;
124	124
125	125		begin
126	126		CreateConnection;
127	127		CreateTransaction;
128	128		Query := GetQuery;
129	129		Query.SQL.Text := 'select * from tblNames';
130	130		AConnection.Open;
131	131		Query.Open;
132	132		while not Query.Eof do
133	133		begin
134	134		Writeln('ID: ', Query.FieldByName('Name').AsInteger, 'Name: ' +
135	135		Query.FieldByName('Name').AsString);
136	136		Query.Next;
137	137		end;
138	138		Query.Close;
139	139		AConnection.Close;
140	140		Query.Free;
141	141		ATransaction.Free;
142	142		AConnection.Free;
143	143		end.
144	144		```
145	145
146	146		(Dieser Code ist natürlich noch nicht komplett. So fehlen z.B. 'try...finally' Blöcke. Wie auch immer der obige Code zeigt den reinen Datenbankcode.) Beachten sie, dass 'TSQLTransaction.StartTransaction' nicht verwendet wird. Das ist nicht notwendig. Wenn TSQLQuery geöffnet wird, wird die SQL Anweisung ausgeführt und wenn keine Transaktion verfügbar ist, dann wird eine Transaktion automatisch gestartet. Der Programmierer muss die Transaktion nicht explizit starten. Das selbe gilt für die von TSQLConnection gehaltene Verbindung. Die Verbindung wird bei Bedarf geöffnet. Die Zeile 'Aconnection.Open' wird nicht wirklich benötigt. Wenn eine TSQLTransaction gelöscht wird, dann wird ein automatischer 'rollback' ausgeführt. Die Änderungen an den Daten im Rahmen der Transaktion gehen verloren.
147	147
148	148		### Warum gibt TSQLQuery.RecordCount immer 10 zurück?
149	149
150	150		Um die Datensätze in einer Datenbank zu zählen verwenden sie '.RecordCount'. Jedoch zeigt '.RecordCount' die Anzahl von Datensätzen, die bereits vom Server geladen sind. Sqldb liest (per Voreinstellung) nicht alle Datensätze ein, wenn TSQLQuery geöffnet wird, sondern nur die ersten 10. Erst wenn auf den elften Datensatz zugegriffen wird, werden die nächsten 10 Datensätze geladen. Durch die Verwendung von '.Last' werden alle Datensätze geladen.
151	151
152	152		Wenn sie die tatsächliche Anzahl von Datensätzen auf dem Server wissen müssen, dann rufen sie erst '.Last' auf und dann '.RecordCount'. Es gibt aber auch eine Alternative. Die Anzahl von Datensätzen, die der Server zurückgibt, wird mit der Methode '.PacketRecords' festgelegt. Der Vorgabewert ist 10. Wenn sie den Wert auf -1 setzen, dann werden alle Datensätze auf einmal geladen.
153	153
154	154		### Lazarus
155	155
156	156		Um die Daten einer Tabelle anzuzeigen können Sie diese (statt mit einer While-Schleife und mit einer Writeln Ausgabe anzuzeigen) die Komponenten von Lazarus verwenden. Gehen sie dazu in der Lazarus IDE in das Register 'SQLdb'. Legen Sie eine TSQLConnection, eine TSQLTransaction und eine TSQLQuery Komponente auf ein Formular. Verbinden Sie die Komponenten über Ihre Eigenschaften (Wie in den obigen Abschnitten bereits erwähnt.). Danach benötigen Sie noch eine TDatasource Komponente aus dem Register 'Data Access'. Diese verbinden Sie über die Eigenschaft 'TDatasource.DataSet' mit der Komponente TSQLQuery. Anschliessend legen Sie ein TDBGrid aus dem Register 'Data Controls' auf das Formular und verbinden die Eigenschaft 'TDBGrid.Datasource' mit der Komponente TDatasource.\
157	157
158	158		Um zu sehen, ob alles funktioniert, stellen Sie in der Lazarus IDE die "Verbunden"-Eigenschaft der TSQLConnection auf 'True'. Die IDE wird sofort versuchen, sich mit dem Datenbankserver zu verbinden. Wenn das funktioniert, können Sie die 'TSQLQuery.Active-Eigenschaft auf 'True' setzen. Ist alles in Ordnung, dann sehen Sie - in der IDE - alle Daten aus der Tabelle auf dem Bildschirm.\
159	159
160	160		## Daten in einer Tabelle ändern
161	161
162	162		Um die Daten in einem Datensatz zu bearbeiten, muss TDataset (von dem TSQLQuery abgeleitet ist) in den Bearbeitungsmodus versetzt werden. Dies kann durch Aufrufen der Methoden '.Edit', '.Insert' oder '.Append' geschehen. Verwenden sie die Methode '.Edit', um den aktuellen Datensatz zu ändern. Verwenden sie die Methode '.Insert', um einen neuen Datensatz an der aktuellen Position einzufügen. Verwenden sie die Methode '.Append', um einen neuen Datensatz am Ende der Tabelle einzufügen. Im Bearbeitungsmodus können sie die Werte der Felder mit der Methode '.Fields' ändern. Verwenden Sie die Methode '.Post', um die neuen Daten auf ihre Gültigkeit zu prüfen. Sind die Daten gültig, dann wird der Bearbeitungsmodus automatisch verlassen. Wenn Sie zu einem anderen Datensatz wechseln - zum Beispiel durch die Verwendung der Methode'.Next' - und der Datensatz befindet sich im Bearbeitungsmodus, dann wird als erstes die Methode '.Post' aufgerufen. Verwenden sie die Methode '.Cancel', um alle Änderungen seit dem letzten Aufruf der Methode '.Post' zu verwerfen und um den Bearbeitungsmodus zu verlassen.
163	163
164	164		``` pascal
165	165		Query.Edit;
166	166		Query.FieldByName('NAME').AsString := 'Edited name';
167	167		Query.Post;
168	168		```
169	169
170	170		Die Klasse TSQLQuery leitet die Verwendung der gepufferten Updates von der Klasse TBufDataset ab. Gepuffertes Update bedeutet, dass Sie nachdem Sie die Methode '.Post' angewendet haben, die Änderungen im Client sofort sichtbar sind, und zwar bevor diese Daten an dem Datenbankserver gesendet wurden. Erst wenn Sie die Methode '.ApplyUpdates' aufrufen, werden die Änderungen an den Datenbankserver und damit an die Datenbank gesendet. Nur dann erlangt der Datenbankserver Kenntnis von allen Änderungen. Die Änderungen werden innerhalb einer Transaktion von TSQLTransaction an den Datenbankserver gesendet. Stellen sie sicher, dass die richtige Transaktion eingestellt ist, bevor Sie die Methode '.ApplyUpdates' aufrufen. Nach dem Ausführen des Updates muss ein Commit ausgeführt werden um die Änderungen dauerhaft in der Datenbank zu speichern.\
171	171
172	172		Das folgende Beispiel zeigt, wie sie die Daten in einer Tabelle ändern und die geänderten Daten mit einer Transaktion an den Datenbankserver senden und mit einem Commit dauerhaft in der Datenbank speichern.\
173	173
174	174		``` pascal
175	175		Program EditData;
176	176
177	177		var AConnection : TSQLConnection;
178	178		ATransaction : TSQLTransaction;
179	179		Query : TSQLQuery;
180	180
181	181		begin
182	182		CreateConnection;
183	183		CreateTransaction;
184	184		AConnection.Transaction := ATransaction;
185	185		Query := GetQuery;
186	186		Query.SQL.Text := 'select * from tblNames';
187	187		Query.Open;
188	188		Query.Edit;
189	189		Query.FieldByName('NAME').AsString := 'Edited name';
190	190		Query.Post;
191	191		Query.UpdateMode := upWhereAll;
192	192		Query.ApplyUpdates;
193	193		AConnection.Transaction.Commit;
194	194		Query.Free;
195	195		ATransaction.Free;
196	196		AConnection.Free;
197	197		end.
198	198		```
199	199
200	200		## Wie Sqldb Änderungen an den Datenbankserver sendet
201	201
202	202		In dem Code-Beispiel in Daten in einer Tabelle ändern finden sie die Zeile
203	203
204	204		``` pascal
205	205		Query.UpdateMode := upWhereAll;
206	206		```
207	207
208	208		ohne Erläuterung, was dieser Befehl macht. Der beste Weg es herauszufinden besteht darin, die Zeile wegzulassen. Wenn sie die Anweisung weglassen und sich ansonsten genau an den Beispielcode halten, dann erhalten sie die folgende Fehlermeldung:
209	209
210		-	~~`No update query specified and failed to generate one. (No fields for inclusion in where statement found)`~~
	210	+	```text
	211	+	No update query specified and failed to generate one. (No fields for inclusion in where statement found)
	212	+	```
211	213
212	214		Um zu verstehen, was schief gegangen ist, müssen sie wissen, wie Änderungen an den Datenbankserver gesendet werden. Der einzige Weg, um Daten in einen SQL-Server zu bekommen, besteht im Ausführen von SQL-Anweisungen. SQL kennt drei Typen von Anweisungen für drei verschiedene Wege der Manipulierung eines Datensatzes. Um einen (neuen) Datensatz zu erstellen, zu ändern oder zu löschen werden die insert, update und delete Anweisungen entsprechend ausgeführt. Eine update Anweisung könnte wie folgt aussehen:
213	215
214	216		``` sql
215	217		update TBLNAMES set NAME='Edited name' where ID=1;
216	218		```
217	219
218	220		Um eine Änderung an den Datenbank-Server zu senden, muss sqldb eine Aktualisierungsabfrage erstellen. Um diese Aktualisierungsabfrage zu erstellen, sind drei Dinge erforderlich:\
219	221		; Der Name der Tabelle: Der Tabellenname wird durch das Parsen (Durchsuchen, Analysieren) der SELECT-Abfrage ermittelt.
220	222
221	223		`UPDATE` oder `INSERT` Abschnitt
222	224		Dieser enthält die Felder, die geändert werden sollen.
223	225
224	226		`WHERE` Abschnitt
225	227		Dieser enthält die Felder, die bestimmen, welche Datensätze geändert werden sollen.
226	228
227	229		Jedes Feld (jedes TField in Fields) besitzt eine ProviderFlags Eigenschaft. Nur Felder mit pfInUpdate in ProviderFlags werden in dem update oder insert Abschnitt einer query verwendet. Vorgabemäßig ist pfInUpdate bei allen Feldern in deren ProviderFlags Eigenschaft gesetzt.
228	230
229	231		Welche Felder in der `WHERE`-Klausel verwendet werden müssen hängt vom Abschnitt Update der SQL-Abfrage (Eigenschaft '.SQL.Text') und von der Eigenschaft '.ProviderFlags' (pfInWhere, pfInUpdate, pfInKey, pfHidden) ab. Felder, die mit dem ProviderFlag pfInKey als Schlüsselfelder gekennzeichnet sind müssen in der `WHERE`-Klausel verwendet werden.\
230	232		Ist ein Feld Teil eines Primärschlüssels der Datenbanktabelle, dann ist für die Eigenschaft '.ProviderFlags' das Flag pfInKey automatisch eingestellt und die Eigenschaft '.UsePrimaryKeyAsKey' gibt den Wert 'True' zurück.\
231	233
232	234		Der Standardwert für die Eigenschaft '.UpdateMode' ihrer Abfrage ist der Wert upWhereKeyOnly. In diesem Update-Modus wird in der WHERE-Klausel über die Eigenschaft '.ProviderFlags' mit dem Wert pfInKey eine oder mehrere Spalte(n) als Schlüsselfeld(er) gekennzeichnet. Wenn Sie für keines der Felder das Flag pfInKey gesetzt haben, dann kommt es zu einer Fehlermeldung. Sie können das Problem auf folgende Weise lösen:\
233	235		* Hinzufügen eines Primärschlüssels zur Tabelle und setzen des Wertes von TSQLQuery.UsePrimaryKeyAsKey auf 'True'. Beispiel für das Erstellen eines Primärschlüssels:
234	236
235	237		``` pascal
236	238		Query.UsePrimaryKeyAsKey := True;
237	239		```
238	240
239	241		- Setzen des Flags pfInKey für ein oder mehrere Felder im Code. Beispiel für einen zusammengesetzten Schlüssel:
240	242
241	243		``` pascal
242	244		Query.FieldByName('Name').ProviderFlags := [pfInKey];
243	245		Query.FieldByName('Vorname').ProviderFlags := [pfInKey];
244	246		```
245	247
246	248		Die UpdateMode Eigenschaft kennt zwei weitere mögliche Werte:
247	249
248	250		- 'upWhereAll': Der Wert 'upWhereAll' versorgt alle Felder mit dem Flag 'pfInWhere'. Damit werden alle Felder zur `WHERE`-Klausel hinzugefügt. Als Standard ist dieses Flag bei allen Feldern gesetzt.
249	251		- 'upWhereChanged': Der Wert 'upWhereChanged' sorgt dafür, dass nur die Felder in der `WHERE`-Klausel verwendet werden, die das Flag 'pfInWhere' haben und die im aktuellen Datensatz verwendet wurden.
250	252
251	253		## Wie führt man eine Abfrage unter der Verwendung von TSQLQuery aus?
252	254
253	255		Neben den Anweisungen, die Daten zurückgeben (siehe Daten in einer Tabelle ändern), gibt es bei SQL Anweisungen, die keine Daten zurückgeben, zum Beispiel `INSERT`, `UPDATE` und `DELETE`. Diese Anweisungen können mittels TSQLConnection.ExecuteDirect ausgeführt werden, aber TSQLQuery kann ebenso verwendet werden. Wenn keine Daten zurückgegeben werden, dann verwenden sie TSQLQuery.ExecSQL anstatt TSQLQuery.Open. Die Methode TSQLQuery.Open wird verwendet um ein von einem SQL-Statement zurück gegebenes Dataset zu öffnen.\
254	256		Die folgende Prozedur erzeugt eine Tabelle mittels TSQLQuery und fügt zwei Datensätze ein.
255	257
256	258		``` pascal
257	259		procedure CreateTable;
258	260
259	261		var Query : TSQLQuery;
260	262
261	263		begin
262	264		Query := GetQuery;
263	265		Query.SQL.Text := 'create table TBLNAMES (ID integer, NAME varchar(40));';
264	266		Query.ExecSQL;
265	267
266	268		Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (1,'Name1');';
267	269		Query.ExecSQL;
268	270
269	271		Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (2,'Name2');';
270	272		Query.ExecSQL;
271	273
272	274		Query.Close;
273	275		Query.Free;
274	276		end;
275	277		```
276	278
277	279		## Verwendung von Parametern in einer Abfrage
278	280
279	281		Im Code-Beispiel von Wie führt man eine Abfrage unter der Verwendung von TSQLQuery aus? wird die selbe Abfrage zweimal verwendet, nur mit anderen einzusetzenden Werten. Eine bessere Möglichkeit dies zu erledigen ist die Verwendung von Parametern in der Abfrage.
280	282
281	283		Die Syntax von Parametern in Abfragen ist je nach verwendeter Datenbank unterschiedlich. Aber diese Unterschiede können von TSQLQuery gehandhabt werden. Ersetzen sie die Werte in der Abfrage mit einem Doppelpunkt gefolgt von dem Namen des Parameters, den sie verwenden wollen.\
282	284		Zum Beispiel:
283	285
284	286		``` pascal
285	287		Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (:ID,:NAME);';
286	288		```
287	289
288	290		Diese Abfrage enthält zwei Parameter: 'ID' und 'NAME'. Um die Parameter zu bestimmen, wird die Abfrage in dem Moment analysiert, wenn der Text von TSQLQuery.SQL zugewiesen oder geändert wird. Alle existierenden Parameter werden entfernt und die neuen Parameter zur 'TSQLQuery.Params' Eigenschaft hinzugefügt. Einem Parameter einen Wert zuzuweisen ist ähnlich der Zuweisung eines Werts zu einem Feld im Dataset:
289	291
290	292		``` pascal
291	293		Query.Params.ParamByName('Name').AsString := 'Name1';
292	294		```
293	295
294	296		Sie können der Abfrage mitteilen, welche Art von Daten in dem Parameter gespeichert werden sollen. Der Datentyp des Parameters wird in dem Moment bestimmt, wenn ein Wert das erste Mal dem Parameter zugewiesen wird. Durch die Zuweisung eines Wertes mittels '.AsString', erhält der Parameter den Datentyp 'ftString'. Sie können den Datentyp auch direkt über die 'DataType' Eigenschaft bestimmen. Wenn dem Parameter ein falscher Datentyp zugewiesen wird, dann werden Probleme auftauchen, wenn die Abfrage geöffnet bzw. ausgeführt wird.
295	297
296	298		Das folgende Beispiel erzeugt die selbe Tabelle wie im vorherigen Beispiel, jetzt aber unter Verwendung von Parametern:
297	299
298	300		``` pascal
299	301		procedure CreateTableUsingParameters;
300	302
301	303		var Query : TSQLQuery;
302	304		Param_ID,Param_Name: TParam;
303	305
304	306		begin
305	307		Query := GetQuery;
306	308		Query.SQL.Text := 'create table TBLNAMES (ID integer, NAME varchar(40));';
307	309		Query.ExecSQL;
308	310
309	311		Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (:ID,:NAME);';
310	312
311	313		Param_ID:=TParam.Create(Query.Params,ptInput);
312	314		Param_ID.Name:='ID';
313	315		Query.Params.AddParam(Param_ID);
314	316
315	317		Param_Name:=TParam.Create(Query.Params,ptInput);
316	318		Param_Name.Name:='Name';
317	319		Query.Params.AddParam(Param_Name);
318	320
319	321		Query.Params.ParamByName('ID').AsInteger := 1;
320	322		Query.Params.ParamByName('NAME').AsString := 'Name1';
321	323		Query.ExecSQL;
322	324
323	325		Query.Params.ParamByName('ID').AsInteger := 2;
324	326		Query.Params.ParamByName('NAME').AsString := 'Name2';
325	327		Query.ExecSQL;
326	328
327	329		Query.Close;
328	330		Query.Free;
329	331		end;
330	332		```
331	333
332	334		Was sofort auffällt, ist, dass dieses Beispiel mehr Code verwendet, als das Beispiel das keine Parameter verwendet. Was ist dann der Vorteil der Verwendung von Parametern? Einer der Gründe ist Geschwindigkeit. Die meisten Datenbankserver unterstützen Parameter.\
333	335		Mit 'TSQLQuery.Prepare' bestimmen Sie, dass der Datenbankserver bereits reservierte Ressourcen nutzen soll. Der Aufruf der Methode '.Prepare' ist sinnvoll, wenn Sie mehrere Datensätze auf einmal bearbeiten wollen. Mit 'TSQLQuery.unPrepare' bestimmen Sie, dass der Datenbankserver reservierte Resourcen freigeben soll (Das geschieht automatisch.).\
334	336		Beispiel für '.Prepare':
335	337
336	338		``` pascal
337	339		for i := 1 to j do
338	340		begin
339	341		Query.paramByName('ID').AsInteger := i;
340	342		Query.paramByName('Name').AsString := 'Name...';
341	343		Query.Prepare;
342	344		Query.ExecSQL;
343	345		end;
344	346		```
345	347
346	348		Ein anderer Grund für die Verwendung von prepared statements ist die Vermeidung von [SQL-Injection](http://de.wikipedia.org/wiki/SQL-Injection). Aber in manchen Fällen vereinfacht es auch nur die Programmierung.\
347	349
348	350		## Siehe auch
349	351
350		-	~~`* `[[Working With TSQLQuery]]`.`~~
	352	+	```text
	353	+	* Working_With_TSQLQuery.
	354	+	```
351	355
352	356		---
353	357		From the Free Pascal wiki, page "SqlDBHowto/de", as it stood on 2020-02-27 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