SqlDBHowto/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		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		-	\
7	6
8	7		## Verbinden mit einem Datenbankserver
9	8
10	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.\
11	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.\
12		-	\
	11	+
13	12		Zum Beispiel kann man sich:
14	13
15	14		- mit der Komponente TIBConnection mit einer Firebird/Interbase Datenbank verbinden
16	15		- mit der Komponente TPQConnection mit einer PostgreSQL Datenbank verbinden
17	16		- mit der Komponente TMySQL56Connection mit einer MySQL Datenbank verbinden
18	17		- usw.
19	18
20	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.\
21		-	\
	20	+
22	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.
23	22
24	23		``` pascal
25	24		Program ConnectDB
26	25
27	26		var AConnection : TSQLConnection;
28	27
29	28		Procedure CreateConnection;
30	29		begin
31	30		AConnection := TIBConnection.Create(nil);
32	31		AConnection.Hostname := 'localhost';
33	32		AConnection.DatabaseName := '/opt/firebird/examples/employee.fdb';
34	33		AConnection.UserName := 'sysdba';
35	34		AConnection.Password := 'masterkey';
36	35		end;
37	36
38	37		begin
39	38		CreateConnection;
40	39		AConnection.Open;
41	40		if Aconnection.Connected then
42	41		writeln('Erfolgreich verbunden!')
43	42		else
44	43		writeln('Es konnte keine Verbindung zur Datenbank erstellt werden. ' +
45	44		'Wenn Sie in Ihrem Programm hier weitermachen, dann lösen Sie eine Exception aus.');
46	45		AConnection.Close;
47	46		AConnection.Free;
48	47		end.
49	48		```
50	49
51		-	\
52	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.\
53	51
54	52		## Abfragen direkt ausführen / Eine Tabelle erstellen
55	53
56	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.\
57		-	\
	55	+
58	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.\
59		-	\
	57	+
60	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.\
61		-	\
	59	+
62	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.
63	61
64	62		``` pascal
65	63		program CreateTable;
66	64
67	65		var AConnection : TSQLConnection;
68	66		ATransaction : TSQLTransaction;
69	67
70	68		procedure CreateTransaction;
71	69		begin
72	70		ATransaction := TSQLTransaction.Create(nil);
73	71		ATransaction.Database := AConnection;
74	72		end;
75	73
76	74		begin
77	75		CreateConnection;
78	76		CreateTransaction;
79	77		AConnection.Transaction := ATransaction;
80	78		AConnection.Open;
81	79		ATransaction.StartTransaction;
82	80		AConnection.ExecuteDirect('create table TBLNAMES (ID integer, NAME varchar(40));');
83	81
84	82		// Einige Datenbankserver benöigen ein commit, bevor sie eine neu erzeugte Tabelle nutzen können. (Firebird)
85	83		// Mit .Commit schließen sie auch die Transaktion.
86	84		ATransaction.Commit;
87	85
88	86		ATransaction.StartTransaction;
89	87		AConnection.ExecuteDirect('insert into TBLNAMES (ID,NAME) values (1,'Name1');');
90	88		AConnection.ExecuteDirect('insert into TBLNAMES (ID,NAME) values (2,'Name2');');
91	89		ATransaction.Commit;
92	90		AConnection.Close;
93	91		AConnection.Free;
94	92		ATransaction.Free;
95	93		end.
96	94		```
97	95
98	96		## Daten aus einer Tabelle lesen
99	97
100	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.\
101	99		Die Themen TSQLConnection und TSQLTransaction wurden in den Abschnitten Verbinden mit einem Datenbankserver und Abfragen direkt ausführen / Eine Tabelle erstellen behandelt.\
102		-	\
	100	+
103	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.
104	102
105	103		Hier ist ein Beispiel, das alle Werte aus der im Abschnitt Abfragen direkt ausführen / Eine Tabelle erstellen selbst erstellten Tabelle ausliest.
106	104
107	105		``` pascal
108	106		Program ShowData;
109	107
110	108		var
111	109		AConnection : TSQLConnection;
112	110		ATransaction : TSQLTransaction;
113	111
114	112		function GetQuery : TSQLQuery;
115	113		var
116	114		AQuery : TSQLQuery;
117	115		begin
118	116		AQuery := TSQLQuery.Create(nil);
119	117		AQuery.Database := AConnection;
120	118		AQuery.Transaction := ATransaction;
121	119		Result := AQuery;
122	120		end;
123	121
124	122		var
125	123		Query : TSQLQuery;
126	124
127	125		begin
128	126		CreateConnection;
129	127		CreateTransaction;
130	128		Query := GetQuery;
131	129		Query.SQL.Text := 'select * from tblNames';
132	130		AConnection.Open;
133	131		Query.Open;
134	132		while not Query.Eof do
135	133		begin
136	134		Writeln('ID: ', Query.FieldByName('Name').AsInteger, 'Name: ' +
137	135		Query.FieldByName('Name').AsString);
138	136		Query.Next;
139	137		end;
140	138		Query.Close;
141	139		AConnection.Close;
142	140		Query.Free;
143	141		ATransaction.Free;
144	142		AConnection.Free;
145	143		end.
146	144		```
147	145
148	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.
149	147
150	148		### Warum gibt TSQLQuery.RecordCount immer 10 zurück?
151	149
152	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.
153	151
154	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.
155	153
156	154		### Lazarus
157	155
158	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.\
159		-	\
	157	+
160	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.\
161		-	\
162	159
163	160		## Daten in einer Tabelle ändern
164	161
165	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.
166	163
167	164		``` pascal
168	165		Query.Edit;
169	166		Query.FieldByName('NAME').AsString := 'Edited name';
170	167		Query.Post;
171	168		```
172	169
173	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.\
174		-	\
	171	+
175	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.\
176	173
177	174		``` pascal
178	175		Program EditData;
179	176
180	177		var AConnection : TSQLConnection;
181	178		ATransaction : TSQLTransaction;
182	179		Query : TSQLQuery;
183	180
184	181		begin
185	182		CreateConnection;
186	183		CreateTransaction;
187	184		AConnection.Transaction := ATransaction;
188	185		Query := GetQuery;
189	186		Query.SQL.Text := 'select * from tblNames';
190	187		Query.Open;
191	188		Query.Edit;
192	189		Query.FieldByName('NAME').AsString := 'Edited name';
193	190		Query.Post;
194	191		Query.UpdateMode := upWhereAll;
195	192		Query.ApplyUpdates;
196	193		AConnection.Transaction.Commit;
197	194		Query.Free;
198	195		ATransaction.Free;
199	196		AConnection.Free;
200	197		end.
201	198		```
202	199
203		-	\
204		-
205	200		## Wie Sqldb Änderungen an den Datenbankserver sendet
206	201
207	202		In dem Code-Beispiel in Daten in einer Tabelle ändern finden sie die Zeile
208	203
209	204		``` pascal
210	205		Query.UpdateMode := upWhereAll;
211	206		```
212	207
213	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:
214	209
215	210		`No update query specified and failed to generate one. (No fields for inclusion in where statement found)`
216	211
217	212		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:
218	213
219	214		``` sql
220	215		update TBLNAMES set NAME='Edited name' where ID=1;
221	216		```
222	217
223	218		Um eine Änderung an den Datenbank-Server zu senden, muss sqldb eine Aktualisierungsabfrage erstellen. Um diese Aktualisierungsabfrage zu erstellen, sind drei Dinge erforderlich:\
224	219		; Der Name der Tabelle: Der Tabellenname wird durch das Parsen (Durchsuchen, Analysieren) der SELECT-Abfrage ermittelt.
225	220
226	221		`UPDATE` oder `INSERT` Abschnitt
227	222		Dieser enthält die Felder, die geändert werden sollen.
228	223
229	224		`WHERE` Abschnitt
230	225		Dieser enthält die Felder, die bestimmen, welche Datensätze geändert werden sollen.
231	226
232	227		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.
233	228
234		-	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' (<i>pfInWhere, pfInUpdate, pfInKey, pfHidden</i>) ab. Felder, die mit dem ProviderFlag <i>pfInKey</i> als Schlüsselfelder gekennzeichnet sind müssen in der `WHERE`-Klausel verwendet werden.\
235		-	Ist ein Feld Teil eines Primärschlüssels der Datenbanktabelle, dann ist für die Eigenschaft '.ProviderFlags' das Flag <i>pfInKey</i> automatisch eingestellt und die Eigenschaft '.UsePrimaryKeyAsKey' gibt den Wert '<i>True</i>' zurück.\
236		-	\
237		-	Der Standardwert für die Eigenschaft '.UpdateMode' ihrer Abfrage ist der Wert <i>upWhereKeyOnly</i>. In diesem Update-Modus wird in der WHERE-Klausel über die Eigenschaft '.ProviderFlags' mit dem Wert <i>pfInKey</i> eine oder mehrere Spalte(n) als Schlüsselfeld(er) gekennzeichnet. Wenn Sie für keines der Felder das Flag <i>pfInKey</i> gesetzt haben, dann kommt es zu einer Fehlermeldung. Sie können das Problem auf folgende Weise lösen:\
	229	+	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	+	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	+
	232	+	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:\
238	233		* 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:
239	234
240	235		``` pascal
241	236		Query.UsePrimaryKeyAsKey := True;
242	237		```
243	238
244		-	~~- Setzen des Flags <i>pfInKey</i> für ein oder mehrere Felder im Code. Beispiel für einen zusammengesetzten Schlüssel:~~
	239	+	- Setzen des Flags pfInKey für ein oder mehrere Felder im Code. Beispiel für einen zusammengesetzten Schlüssel:
245	240
246	241		``` pascal
247	242		Query.FieldByName('Name').ProviderFlags := [pfInKey];
248	243		Query.FieldByName('Vorname').ProviderFlags := [pfInKey];
249	244		```
250	245
251	246		Die UpdateMode Eigenschaft kennt zwei weitere mögliche Werte:
252	247
253	248		- '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.
254	249		- '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.
255	250
256		-	\
257		-
258	251		## Wie führt man eine Abfrage unter der Verwendung von TSQLQuery aus?
259	252
260	253		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.\
261	254		Die folgende Prozedur erzeugt eine Tabelle mittels TSQLQuery und fügt zwei Datensätze ein.
262	255
263	256		``` pascal
264	257		procedure CreateTable;
265	258
266	259		var Query : TSQLQuery;
267	260
268	261		begin
269	262		Query := GetQuery;
270	263		Query.SQL.Text := 'create table TBLNAMES (ID integer, NAME varchar(40));';
271	264		Query.ExecSQL;
272	265
273	266		Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (1,'Name1');';
274	267		Query.ExecSQL;
275	268
276	269		Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (2,'Name2');';
277	270		Query.ExecSQL;
278	271
279	272		Query.Close;
280	273		Query.Free;
281	274		end;
282	275		```
283		-
284		-	\
285	276
286	277		## Verwendung von Parametern in einer Abfrage
287	278
288	279		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.
289	280
290	281		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.\
291	282		Zum Beispiel:
292	283
293	284		``` pascal
294	285		Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (:ID,:NAME);';
295	286		```
296	287
297	288		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:
298	289
299	290		``` pascal
300	291		Query.Params.ParamByName('Name').AsString := 'Name1';
301	292		```
302	293
303	294		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.
304	295
305	296		Das folgende Beispiel erzeugt die selbe Tabelle wie im vorherigen Beispiel, jetzt aber unter Verwendung von Parametern:
306	297
307	298		``` pascal
308	299		procedure CreateTableUsingParameters;
309	300
310	301		var Query : TSQLQuery;
311	302		Param_ID,Param_Name: TParam;
312	303
313	304		begin
314	305		Query := GetQuery;
315	306		Query.SQL.Text := 'create table TBLNAMES (ID integer, NAME varchar(40));';
316	307		Query.ExecSQL;
317	308
318	309		Query.SQL.Text := 'insert into TBLNAMES (ID,NAME) values (:ID,:NAME);';
319	310
320	311		Param_ID:=TParam.Create(Query.Params,ptInput);
321	312		Param_ID.Name:='ID';
322	313		Query.Params.AddParam(Param_ID);
323	314
324	315		Param_Name:=TParam.Create(Query.Params,ptInput);
325	316		Param_Name.Name:='Name';
326	317		Query.Params.AddParam(Param_Name);
327	318
328	319		Query.Params.ParamByName('ID').AsInteger := 1;
329	320		Query.Params.ParamByName('NAME').AsString := 'Name1';
330	321		Query.ExecSQL;
331	322
332	323		Query.Params.ParamByName('ID').AsInteger := 2;
333	324		Query.Params.ParamByName('NAME').AsString := 'Name2';
334	325		Query.ExecSQL;
335	326
336	327		Query.Close;
337	328		Query.Free;
338	329		end;
339	330		```
340	331
341	332		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.\
342	333		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.).\
343	334		Beispiel für '.Prepare':
344	335
345	336		``` pascal
346	337		for i := 1 to j do
347	338		begin
348	339		Query.paramByName('ID').AsInteger := i;
349	340		Query.paramByName('Name').AsString := 'Name...';
350	341		Query.Prepare;
351	342		Query.ExecSQL;
352	343		end;
353	344		```
354	345
355	346		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.\
356	347
357	348		## Siehe auch
358	349
359	350		`* `[[Working With TSQLQuery]]`.`
360	351
361	352		---
362	353		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