:Revision=1
:HTML
<<
128.129
SQL-Objekt|SQL
$NoSort
--
Das IP-Objekt SQL erlaubt den Zugriff auf Datendanken ber SQL (Structured Query Language)

Es knnen alle Datenbanken angesprochen werden, auf die per BDE zugegriffen werden kann. Hierzu gehren insbesondere dBase, Paradox und alle ber ODBC erreichbaren Datenbanksysteme, also auch z.B. Access.

Momentan kann nur eine einzelne Datenbank geffnet werden, eine Erweiterung auf mehrere, simultan geffnete Datenbanken ist jedoch geplant. 
Daher muss bei allen Zugriffen als erster Parameter die Datenbanknummer angegeben werden. Im Moment ist dies immer 1 fr die einzig existente Datenbank.

Der Ablauf eines Zugriffes sieht folgendermaen aus:

<ol>
<li>Der SQL Datenbank wird ein Server oder ein Dateipfad zugeordnet - dies geschieht meist statisch in den Grundeinstellungen. An diesem Punkt muss der Server oder der Pfad (noch) nicht existieren.</li>
<li>Die SQL Datenbank wird mit dem Server oder dem Pfad verbunden (connected). Jetzt mssen Server bzw. Pfad vorhanden sein, da die SQL Datenbank bei Server oder Pfad nach vorhandenen Tabellen sucht. Dies ist etwa vergleichbar mit dem ffnen einer Schnittstelle. Das Verbinden kann automatisch erfolgen, wenn in den Grundeinstellungen <i>AutoConnect</i> aktiviert ist. </li>
<li>An die SQL Datenbank wird ein SQL Kommando abgesetzt (<!SW>SELECT, <!SW>INSERT, <!SW>UPDATE, <!SW>DELETE ...). Im Fall eines erfolgreichen <!SW>SELECT Kommandos entsteht eine offene Datenmenge, d.h. quasi eine kleine Tabelle im Speicher, die das Ergebnis des <!SW>SELECT enthlt.</li>
<li>Auf die Datenmenge kann zeilenweise zugegriffen werden. Hierzu dienen die Befehle <!RW>SQL.First und <!RW>SQL.Next. Mit <!RW>SQL.EOF kann geprft werden, ob das Ende der Datenmenge erreicht ist.</li>
<li>Auf die Felder in der gewhlten Zeile kann mit den <!RW>SQL.Field Befehlen zugegriffen werden.</li>
</ol>

Beispiel:
<!CODE>
if SQL.IsActive (1) then begin
  SQL.Connect (1);
  if SQL.Connected (1) then begin
    SQL.Execute (1, 'SELECT Artikelname FROM Bestellung');
    SQL.First (1);
    while not SQL.EOF (1) do begin
      debug.show (1, SQL.Field (1, 'Artikelname'));
      SQL.next(1);
    end;
    SQL.Disconnect (1);
  end;
end;
<!TXT>
>>

<<
128.129.1
Funktionen des SQL Objektes|Funktionen
--
>>

<<
128.129.1.1
SQL.IsActive|IsActive
--
<!DEF>
function <!TW>SQL.IsActive : real;        
<!TXT>
Liefert <!RW>TRUE, wenn die SQL Funktionen in den Grundeinstellungen global aktiviert sind.


<!DEF>
function <!TW>SQL.IsActive (rDBNr : real) : real;
<!TXT>
Liefert <!RW>TRUE, wenn die SQL Datenbank <!PW>rDBNr in den Grundeinstellungenl aktiviert ist.
>>

<<
128.129.1.2
SQL.IsConnected|IsConnected
--
<!DEF>
function <!TW>SQL.IsConnected (rDBNr : real) : real;
<!TXT>
Liefert <!RW>TRUE, wenn die SQL Datenbank <!PW>rDBNr mit ihrer zugrunde liegenden Datenbank (Server oder Dateien) verbunden (Connected) ist.

Eine Datenbank kann nur dann 'Connected' sein, wenn sie in den Grundeinstellungen aktiviert ist.

SQL Kommandos knnen nur an Datenbanken im Zustand 'Connected' abgesetzt werden.
>>

<<
128.129.1.3
SQL.IsOpen|IsOpen
--
<!DEF>
function <!TW>SQL.IsOpen (rDBNr : real) : real;
<!TXT>
Liefert <!RW>TRUE, wenn fr die SQL Datenbank <!PW>rDBNr eine geffnete Datenmenge bereitsteht. Also immer dann, wenn ein SQL SELECT Kommando erfolgreich ausgefhrt wurde und auf die gewonnen Daten zugegriffen werden kann.
>>

<<
128.129.1.4
SQL.Error|Error
--
<!DEF>
function <!TW>SQL.Error (rDBNr : real) : string;
<!TXT>
Liefert einen Fehlertext, wenn beim letzen Kommando an die Datenbank <!PW>rDBNr ein Fehler aufgetreten ist. Liefert einen Leerstring '', wenn kein Fehler auftrat. Die Funktion kann mehrmals aufgerufen werden. Ein Fehlertext wird mit dem nchsten fehlerfreien Kommando gelscht.
>>

<<
128.129.1.5
SQL.EOF|EOF
--
<!DEF>
function <!TW>SQL.EOF (rDBNr : real) : real;
<!TXT>
Liefert <!RW>TRUE, wenn 
<ul indent=12>
<li>die Datenbank <!PW>rDBNr nicht aktiv ist</li>
<li>die Datenbank <!PW>rDBNr nicht Connected ist</li>
<li>die Datenbank <!PW>rDBNr keine offene Datenmenge hat</li>
<li>die Datenbank <!PW>rDBNr eine offene Datenmenge hat, aber diese leer ist</li>
<li>der <!RW>SQL.Next das Ende der offenen Datenmenge erreicht hat</li>
</ul>

anders gesagt:

Liefert <!RW>FALSE, solange aus der offenen Datenmenge noch Daten gelesen werden knnen.
>>

<<
128.129.1.5
SQL.Field|Field
--
<!DEF>
function <!TW>SQL.Field (rDBNr : real; sFieldName : string) : string;
<!TXT>
Liefert den Inhalt des Feldes <!PW>sFieldName aus der aktuellen Zeile der offenen Datenmenge.

Bei <!PW>sFieldname wird nicht auf Gro-/Kleinschreibung geachtet. Ist die Datenmenge nicht geffnet, oder wurde das Ende erreicht, oder existiert kein Feld mit dem Namen <!PW>sFieldname, so wird ein '**SQLError**' geliefert. 


<!DEF>
function <!TW>SQL.Field (rDBNr : real; rFieldNr : real) : string;
<!TXT>
Liefert den Inhalt des <!PW>rFieldNr-ten aus der aktuellen Zeile der offenen Datenmenge. Die Zhlung beginnt bei 1.

Ist die Datenmenge nicht geffnet, oder wurde das Ende erreicht, oder ist <!PW>rFieldNr grer als die Anzahl der Felder, so wird ein '**SQLError**' geliefert.
>>

<<
128.129.1.5.1
SQL.Field.Count|Count
--
<!DEF>
function <!TW>SQL.Field.Count (rDBNr : real) : real;
<!TXT>
Liefert die Anzahl der Felder (= die Anzahl der Spalten) in der offenen Datenmenge der Datenbank <!PW>rDBNr.

Existiert keine offene Datenmenge, wird -1 geliefert.
>>

<<
128.129.1.5.2
SQL.Field.Name|Name
--
<!DEF>
function <!TW>SQL.Field.Name (rDBNr, rIdx : real) : string;
<!TXT>
Liefert den Namen des <!PW>rIdx-ten Feldes (= der <!PW>rIdx-ten Spalte) in der offenen Datenmenge der Datenbank <!PW>rDBNr. Die Zhlung beginnt dabei mit 1.

Existiert keine offene Datenmenge oder ist <!PW>rIdx grer als die Anzahl der Felder, wird '**SQLError**' geliefert.
>>

<<
128.129.1.5.3
SQL.Field.Number|Number
--
<!DEF>
function <!TW>SQL.Field.Number (rDBNr : real; sFieldName : string) : real;
<!TXT>
Liefert den FeldIndex des Feldes mit dem Namen sFieldName in der offenen Datenmenge der Datenbank <!PW>rDBNr. Bei <!PW>sFieldname wird nicht auf Gro-/Kleinschreibung geachtet. Die Zhlung der Indizes beginnt mit 1.

Existiert keine offene Datenmenge oder gibt es kein Feld mit dem Namen <!PW>sFieldName, wird 0 (=<!RW>FALSE) geliefert.

Die Funktion kann daher sowohl zum Anfragen des Feldindexes benutzt werden:
<!CODE>
nIndex:=SQL.Field.Number (1, 'Einzelpreis');
<!TXT>
als auch, um nur die Existenz zu prfen:
<!CODE>
if SQL.Field.Number (1, 'Barcode') then begin
<!TXT>
>>

<<
128.129.2
Prozeduren des SQL Objektes|Prozeduren
--
>>

<<
128.129.2.1
SQL.Execute|Execute
--
<!DEF>
procedure <!TW>SQL.Execute (rDBNr : real; sSQLCommand : string);
<!TXT>
Fhrt das SQL-Kommando <!PW>sSQLCommand auf der Datenbank <!PW>rDBNr aus. Die Datenbank muss dazu im Zustand 'Connected' sein.

Ist das Kommando ein erfolgreicher SELECT Befehl, so entsteht eine geffnete Datenmenge, auf die mit <!RW>SQL.First, <!RW>SQL.Next, <!RW>SQL.EOF, <!RW>SQL.Field etc. zugegriffen werden kann. 

Art und Umfang der mglichen SQL Befehle hngen von dem SQL-Server ab.
>>

<<
128.129.2.2
SQL.First|First
--
<!DEF>
procedure <!TW>SQL.First (rDBNr : real);
<!TXT>
Macht die erste Zeile der geffneten Datenmenge zur ausgewhlten Zeile.

Ist keine offene Datenmenge vorhanden, passiert nichts.
>>

<<
128.129.2.3
SQL.Next|Next
--
<!DEF>
procedure <!TW>SQL.Next (rDBNr : real);
<!TXT>
Geht in der geffneten Datenmenge zur nchsten Zeile.

Ist keine offene Datenmenge vorhanden oder das Ende erreicht, passiert nichts.
>>

<<
128.129.2.4
SQL.Connect|Connect
--
<!DEF>
procedure <!TW>SQL.Connect (rDBNr : real);
<!TXT>
Verbindet (connects) die Datenbank <!PW>rDBNr mit ihrer Datenquelle.
>>

<<
128.129.2.5
SQL.DisConnect|DisConnect
--
<!DEF>
procedure <!TW>SQL.DisConnect (rDBNr : real);
<!TXT>
Lst die Verbindung zwischen der Datenbank <!PW>rDBNr und ihrer Datenquelle.
>>

<<
128.129.3
SQL-Grundlagen|SQL Basics
$NoSort
--
<h2>Was ist SQL?</h2>
<ul indent=10>
<li><B>SQL</B> steht fr <i><B>S</B>tructured <B>Q</B>uery <B>L</B>anguage</i> = Strukturierte Abfrage Sprache</li>
<li><B>SQL</B> erlaubt den Zugriff auf eine Datenbank</li>
<li><B>SQL</B> kann Daten aus einer Datenbank holen</li>
<li><B>SQL</B> kann neue Datenstze in eine Datenbank einfgen</li>
<li><B>SQL</B> kann Datenstze in einer Datenbank verndern</li>
<li><B>SQL</B> kann Datenstze in einer Datenbank lschen</li>
</ul>

<h3>SQL ist ein Standard - aber...</h3>

SQL wurde vom ANSI (American National Standards Institute) als eine Standard Sprache zum Zugriff und zur Vernderung von Datenbank Systemen definiert.

Leider haben die Hersteller, die SQL als Zugriffssprache auf ihre Datenbanken einsetzen, jeweils herstellerspezifische Erweiterungen der Standardsprache eingebaut. Auch die Standard Sprachelemente unterscheiden sich teilweise in feinen, aber gemeinen Details.

<h3>Tabellen</h3>
Jede Datenbank besteht aus einer oder mehreren Tabellen.
Jede Tabelle hat einen eindeutigen Namen (&quot;Kunden&quot;, &quot;Bestellungen&quot;),
Tabellen enthalten Datenstze (Zeilen) mit Daten.

Beispiel fr eine Tabelle mit dem Namen &quot;Personen&quot;
<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><td colspan=4>Tabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Joachim<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Hamburg<!>
<!ETBL>

Die Tabelle enthlt 3 Datenstze (Zeilen - eine pro Person) und 4 Spalten (Vorname, Nachname, Alter, Ort).

<h3>SQL Abfragen</h3>
Mit SQL knnen Abfragen an eine Datenbank gestellt werden und man erhlt eine Datenmenge zurck.

Beispiel:
<!CODE>
SELECT Nachname FROM Personen
<!TXT>

Als Ergebnis erhlt man:
<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=1>Ergebnistabelle<!>
<!><B>Nachname</B><!>
<!>Meier<!>
<!>Klein<!>
<!>Schmidt<!>
<!ETBL>

<!REM>
Hinweis: 
manche SQL Systeme erwarten ein Semikolon am Ende eines Befehls!
<!TXT>

<h3>SQL Data Manipulation Language (DML)</h3>
Mit SQL knen aber nicht nur Abfrage gestartet werden, sondern die Daten in der Datenbank knnen auch manipuliert werden.

Die Abfrage und Manipulations Kommandos bilden zusammen den DML Teil von SQL:
<ul indent=12>
<li><!SW>SELECT - Daten extrahieren</li>
<li><!SW>UPDATE - Daten ndern</li>
<li><!SW>DELETE - Datenstze lschen</li>
<li><!SW>INSERT <!SW>INTO - neue Datenstze einfgen</li>
</ul>

<h3>SQL Data Definition Language (DDL)</h3>
Befehle der Data Definition Language (DDL) erlauben es auch, nicht nur die Daten, sondern auch die Struktur der Datenbank selber zu verndern.

Die wichtigsten Befehle der DDL sind:
<ul indent=12>
<li><!SW>CREATE <!SW>TABLE - neue Tabelle anlegen</li>
<li><!SW>ALTER <!SW>TABLE - Tabellenstruktur ndern</li>
<li><!SW>DROP <!SW>TABLE - komplette Tabelle entfernen</li>
<li><!SW>CREATE <!SW>INDEX - Index anlegen</li>
<li><!SW>DROP <!SW>INDEX - Index lschen</li>
</ul>
>>

<<
128.129.3.1
SELECT (SQL Befehl)|SELECT
--
Der <!SW>SELECT Befehl wird benutzt, um Daten aus der Datenbank zu extrahieren. Die Daten werden in Form einer Ergebnis-Tabelle geliefert.

Syntax
<!CODE>
SELECT spaltenname/n FROM tabellenname
<!TXT>
<h4>Einzelne Spalten auswhlen</h4>
Um die Spalten 'Vorname' und 'Nachname' auszuwhlen, wrde folgender SQL Befehl benutzt:
<!CODE>
SELECT Vorname,Nachname FROM Personen
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ausgangstabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Vorname</b><!><b>Nachname</b><!>
<!>Walter<!>Meier<!>
<!>Werner<!>Klein<!>
<!>Petra<!>Schmidt<!>
<!ETBL>

<h4>Alle Spalten auswhlen</h4>
Um alle Spalten zu erhalten wird ein * statt der Spaltennamen angegeben.
<!CODE>
SELECT * FROM Personen
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ergebnistabelle<!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>

<h4>Die Ergebnis-Tabelle</h4>
Der Zugriff auf die Daten der Ergebnis-Tabelle ist nicht mehr Teil von SQL. Hierzu stellt das Interpreter-Objekt SQL die Befehl <!RW>SQL.First, <!RW>SQL.Field und <!RW>SQL.Next zur Verfgung.
>>

<<
128.129.3.1.1
DISTINCT (SQL Schlsselwort)|DISTINCT
--
Das <!SW>DISTINCT Schlsselwort wird benutzt, wenn nur voneinander unterschiedliche Werte zurckgegeben werden sollen.

Syntax
<!CODE>
SELECT DISTINCT spaltenname/n FROM tabellenname
<!TXT>

Sollen alle Kunden aus einer Auftragstabelle angezeigt werden, so knnte folgendes SQL Kommando zum Einsatz kommen:
<!CODE>
SELECT Kunde FROM Auftraege
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ausgangstabelle <b>Auftrge</b><!>
<!><b>Kunde</b><!><b>Auftragsnummer</b><!>
<!>SoftySoft<!>234234<!>
<!>AlphaOmega<!>034643<!>
<!>SoftySoft<!>904787<!>
<!>Hardliners<!>847646<!>
<!ETBL>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=1>Ergebnis-Tabelle<!>
<!><b>Kunde</b><!>
<!>SoftySoft<!>
<!>AlphaOmega<!>
<!>SoftySoft<!>
<!>Hardliners<!>
<!ETBL>

Problem:
SoftySoft ist zweimal vertreten!

Um jeden Rckgabewert nur einmal zu erhalten wird DISTINCT eingesetzt:
<!CODE>
SELECT DISTINCT Kunde FROM Auftraege
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=1>Ergebnis-Tabelle<!>
<!><b>Kunde</b><!>
<!>SoftySoft<!>
<!>AlphaOmega<!>
<!>Hardliners<!>
<!ETBL>

Jetzt ist SoftySoft nur einmal vertreten.
>>

<<
128.129.3.1.2
ORDER BY (SQL Schlsselwort)|ORDER BY
--
Das ORDER BY Schlsselwort wird benutzt, um die Ausgabe zu sortieren.

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ausgangstabelle <b>Auftrge</b><!>
<!><b>Kunde</b><!><b>Auftragsnummer</b><!>
<!>SoftySoft<!>904787<!>
<!>AlphaOmega<!>034643<!>
<!>SoftySoft<!>234234<!>
<!>Hardliners<!>847646<!>
<!ETBL>

<!CODE>
SELECT * FROM Auftraege
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Kunde</b><!><b>Auftragsnummer</b><!>
<!>SoftySoft<!>904787<!>
<!>AlphaOmega<!>034643<!>
<!>SoftySoft<!>234234<!>
<!>Hardliners<!>847646<!>
<!ETBL>

Um das Ergebnis nach den Kunden alphabetisch zu sortieren:
<!CODE>
SELECT * FROM Auftraege ORDER BY Kunde
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Kunde</b><!><b>Auftragsnummer</b><!>
<!>AlphaOmega<!>034643<!>
<!>Hardliners<!>847646<!>
<!>SoftySoft<!>904787<!>
<!>SoftySoft<!>234234<!>
<!ETBL>

Um das Ergebnis alphabetisch nach den Kunden und numerisch nach der Auftragsnummer zu sortieren:
<!CODE>
SELECT * FROM Auftraege ORDER BY Kunde,Auftragsnummer
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Kunde</b><!><b>Auftragsnummer</b><!>
<!>AlphaOmega<!>034643<!>
<!>Hardliners<!>847646<!>
<!>SoftySoft<!>234234<!>
<!>SoftySoft<!>904787<!>
<!ETBL>
>>

<<
128.129.3.1.2.1
ASC (SQL Schlsselwort)|ASC
--
Die Standardsortierrichtung ist aufsteigend (ascending) durch Angabe von ASC kann dies noch einmal ausdrcklich gewnscht werden.

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ausgangstabelle <b>Auftrge</b><!>
<!><b>Kunde</b><!><b>Auftragsnummer</b><!>
<!>SoftySoft<!>904787<!>
<!>AlphaOmega<!>034643<!>
<!>SoftySoft<!>234234<!>
<!>Hardliners<!>847646<!>
<!ETBL>

<!CODE>
SELECT * FROM Auftraege ORDER BY Kunde ASC
<!TXT>
<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Kunde</b><!><b>Auftragsnummer</b><!>
<!>AlphaOmega<!>034643<!>
<!>Hardliners<!>847646<!>
<!>SoftySoft<!>234234<!>
<!>SoftySoft<!>904787<!>
<!ETBL>
>>

<<
128.129.3.1.2.2
DESC (SQL Schlsselwort)|DESC
--
Die Standardsortierrichtung ist aufsteigend (ascending) durch Angabe von DESC (descending) kann eine absteigende Reihenfolge erreicht werden.

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ausgangstabelle <b>Auftrge</b><!>
<!><b>Kunde</b><!><b>Auftragsnummer</b><!>
<!>SoftySoft<!>904787<!>
<!>AlphaOmega<!>034643<!>
<!>SoftySoft<!>234234<!>
<!>Hardliners<!>847646<!>
<!ETBL>

<!CODE>
SELECT * FROM Auftraege ORDER BY Kunde DESC
<!TXT>
<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Kunde</b><!><b>Auftragsnummer</b><!>
<!>SoftySoft<!>234234<!>
<!>SoftySoft<!>904787<!>
<!>Hardliners<!>847646<!>
<!>AlphaOmega<!>034643<!>
<!ETBL>
>>

<<
128.129.3.1.3
Aliasse (SQL)|Aliasse
--
In SQL knnen Alisse benutzt werden, falls Spalten- oder Tabellennamen fter wiederholt werden mssen.

<h3>Spalten-Alias</h3>
Syntax
<!CODE>
SELECT spalte AS spalten_alias FROM tabelle
<!TXT>

Beispiel:

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ausgangstabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!>Hubert<!>Maler<!>32<!>Hamburg<!>
<!ETBL>

Nachname mit einem Alias ersetzen
<!CODE>
SELECT Vorname, Nachname AS Nn FROM Personen WHERE Nn LIKE 'M%'
<!TXT>
<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Vorname</b><!><b>Nachname</b><!>
<!>Walter<!>Meier<!>
<!>Hubert<!>Maler<!>
<!ETBL>

<h3>Tabellen-Alias</h3<
Syntax
<!CODE>
SELECT spalte FROM tabelle AS tabelle_alias
<!TXT>

Tabellenaliasse werden oft bei JOINs eingesetzt.
>>

<<
128.129.3.1.4
Joins und Schlssel (SQL)|JOIN
--
Um Daten aus mehr als einer Tabelle zu verknpfen muss ein so genannter <!SW>JOIN durchgefhrt werden.

Tabellen werden ber Schlssel miteiander verknpft. Ein Primrschlssel ist eine Spalte mit einem eindeutigen Werten fr jede Zeile. ber solche Schlssel knen Zeilen in Datenbanken einander zugeordnet werden.

In der folgenden Kundentabelle ist die <!SW>KundenID der Primrschlssel. Zwei Datenstze haben nie dieselbe <!SW>CustomerID.

Das gleiche gilt fr die Spalte <!SW>AuftragsID in der Auftraegetabelle

Die <!SW>KundenID stellt die Verbindung zwischen den Tabellen her.

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ausgangstabelle <b>Kunden</b><!>
<!><b>KundenID</b><!><b>Name</b><!>
<!>01<!>PleitegeierAG<!>
<!>02<!>SptzahlerGmBH<!>
<!>03<!>KaufeAllesWennBillig<!>
<!>04<!>IchAG<!>
<!ETBL>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=3>Ausgangstabelle <b>Auftraege</b><!>
<!><b>AuftragID</b><!><b>Produkt</b><!><b>KundenID</b><!>
<!>001<!>Tisch<!>01<!>
<!>002<!>Bett<!>03<!>
<!>003<!>Stuhl<!>03<!>
<!>004<!>Herd<!>05<!>
<!ETBL>

ber einen SQL-Befehl knnen die Daten aus den beiden Tabellen wieder kombiniert werden:

Beispiel: Wer hat welches Produkt bestellt?
<!CODE>
SELECT Kunden.Name, Aufraege.Produkt
FROM Kunden, Auftraege
WHERE Kunden.KundenID=Auftraege.KundenID
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Name</b><!><b>Produkt</b><!>
<!>PleitegeierAG<!>Tisch<!>
<!>KaufeAllesWennBillig<!>Bett<!>
<!>KaufeAllesWennBillig<!>Stuhl<!>
<!ETBL>

Beispiel: Wer hat den Tisch bestellt?
<!CODE>
SELECT Kunden.Name
FROM Kunden,Auftraege
WHERE Kunden.KundenID=Auftraege.KundenID AND Auftraege.Produkt='Tisch'
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=1>Ergebnistabelle<!>
<!><b>Name</b><!>
<!>PleitegeierAG<!>
<!ETBL>

Oder wir benutzen das Schlsselwort <!SW>JOIN um die Tabellen zu verknpfen:
Hierzu existieren 3 Mglichkeiten:
<li>Inner Join</li>
<li>Left Join</li>
<li>Right Join</li>
>>

<<
128.129.3.1.4.1
INNER JOIN (SQL Schlsselwort)|INNER JOIN
--
Syntax
<!CODE>
SELECT spalte/n FROM tabelle1 
INNER JOIN tabelle2 ON tabelle1.schlssel = tabelle2.fremdschlssel
<!TXT>

Wer hat welches Produkt bestellt?
<!CODE>
SELECT Kunden.Name, Auftraege.Produkt
FROM Kunden
INNER JOIN Auftraege
ON Kunden.KundenID=Auftraege.KundenID
<!TXT>
Der <!SW>INNER <!SW>JOIN findet alle Zeilen in beiden Spalten, fr die eine bereinstimmung besteht. Zeilen in Kunden, fr die keine bereinstimmung gefunden wird, werden nicht aufgefhrt.

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Name</b><!><b>Produkt</b><!>
<!>PleitegeierAG<!>Tisch<!>
<!>KaufeAllesWennBillig<!>Bett<!>
<!>KaufeAllesWennBillig<!>Stuhl<!>
<!ETBL>
>>

<<
128.129.3.1.4.2
LEFT JOIN (SQL Schlsselwort)|LEFT JOIN
--
Syntax
<!CODE>
SELECT spalte/n FROM tabelle1 
LEFT JOIN tabelle2 ON tabelle1.schlssel = tabelle2.fremdschlssel
<!TXT>

Zeige alle Kunden und ihre Bestellunge - soweit vorhanden
<!CODE>
SELECT Kunden.Name, Auftraege.Produkt
FROM Kunden
LEFT JOIN Auftraege
ON Kunden.KundenID=Auftraege.KundenID
<!TXT>

Der <!SW>LEFT <!SW>JOIN liefert alle Zeilen in der linken Tabelle, auch, wenn in der rechten Tabelle keine bereinstimmung gefunden wurde. Zeilen in Kunden, fr die keine Zeilen in Auftraege gefunden wurden, werden auch zurckgeliefert.

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Name</b><!><b>Produkt</b><!>
<!>PleitegeierAG<!>Tisch<!>
<!>SptzahlerGmbH<!><font size=-9 color=#dfdfff>.</font><!>
<!>KaufeAllesWennBillig<!>Bett<!>
<!>KaufeAllesWennBillig<!>Stuhl<!>
<!>IchAG<!><font size=-9 color=#dfdfff>.</font><!>
<!ETBL>
>>

<<
128.129.3.1.4.3
RIGHT JOIN (SQL Schlsselwort)|RIGHT JOIN
--
Syntax
<!CODE>
SELECT spalte/n FROM tabelle1 
RIGHT JOIN tabelle2 ON tabelle1.schlssel = tabelle2.fremdschlssel
<!TXT>

Zeige alle Auftraege und die Besteller
<!CODE>
SELECT Kunden.Name, Auftraege.Produkt
FROM Kunden
RIGHT JOIN Auftraege
ON Kunden.KundenID=Auftraege.KundenID
<!TXT>

Der <!SW>RIGHT <!SW> JOIN liefert alle Zeilen in der rechten Tabelle, auch, wenn in der linken Tabelle keine bereinstimmung gefunden wurde. Zeilen in Auftraege, fr die keine Zeile in Kunden gefunden wurden, werden auch zurckgeliefert.

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=2>Ergebnistabelle<!>
<!><b>Name</b><!><b>Produkt</b><!>
<!>PleitegeierAG<!>Tisch<!>
<!>KaufeAllesWennBillig<!>Bett<!>
<!>KaufeAllesWennBillig<!>Stuhl<!>
<!><font size=-9 color=#dfdfff>.</font><!>Herd<!>
<!ETBL>
>>

<<
128.129.3.1.5
WHERE (SQL Schlsselwort)|WHERE
--
Die <!SW>WHERE Klausel wird benutzt, um bestimmte Datenstze auszuwhlen.

Syntax
<!CODE>
SELECT spalte/n FROM tabelle WHERE spalte operator wert
<!TXT>

Folgende Operatoren sind mglich:
<!STBL>
<tr bgcolor=f0f0f0 align=center><TD><b>Operator</b><!><b>Beschreibung</b><!>
<!c>=<!>Gleichheit<!>
<!c>&lt;&gt;<!>Ungleichheit<!>
<!c>&gt;<!>Grer als<!>
<!c>&lt;<!>Kleiner als<!>
<!c>&gt;=<!>Grer oder gleich<!>
<!c>&lt;=<!>Kleiner oder gleich<!>
<!c>BETWEEN .. AND<!>zwischen zwei Werten<!>
<!c>LIKE<!>hnlich einem Wert<!>
<!ETBL>
<!REM>
Achtung: 
Manche Systeme verwenden != statt &lt;&gt;
<!TXT>

<h4>Beispiel</h4>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ausgangstabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>

Um aus der Personentabelle nur solche Personen auszuwhlen, die in Stuttgart wohnen, wird folgender Befehl benutzt:
<!CODE>
SELECT * FROM Personen WHERE Ort='Stuttgart'
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ergebnistabelle<!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>


SQL benutzt einfache Anfhrungszeichen um Textwerte (manche Systeme erlauben auch doppelte Anfhrungszeichen). Numerische Werte werden ohne Anfhrungszeichen geschrieben.

<h4>Fr Textwerte:</h4>

Korrekt:
<!CODE>
SELECT * FROM Personen WHERE Ort='Stuttgart'
<!TXT>
Falsch:
<!CODE>
SELECT * FROM Personen WHERE Ort=Stuttgart
<!TXT>

<h4>Fr mumerische Werte:</h4>

Korrekt:
<!CODE>
SELECT * FROM Personen WHERE Alter>40
<!TXT>
Falsch:
<!CODE>
SELECT * FROM Personen WHERE Alter>'40'
<!TXT>
>>


<<
128.129.3.1.5.1
LIKE (SQL Schlsselwort)|LIKE
--
Mit dem <!SW>LIKE Operator kann nach Mustern (teilweisen bereinstimmungen) gesucht werden.

Syntax
<!CODE>
SELECT spalte/n FROM tabelle WHERE spalte LIKE muster
<!TXT>

Das <!CW>&quot;%&quot; Zeichen dient als Joker und ersetzt beliebige Zeichen vor und nach dem Muster

Der folgende Befehl findet Personen, deren Vorname mit <!CW>'W' beginnt:
<!CODE>
SELECT * FROM Personen WHERE Vorname LIKE 'W%'
<!TXT>

Der folgende Befehl findet Personen, deren Vorname mit <!CW>'er' endet:
<!CODE>
SELECT * FROM Personen WHERE Vorname LIKE '%er'
<!TXT>

Der folgende Befehl findet Personen, deren Vorname ein <!CW>'r' enthlt:
<!CODE>
SELECT * FROM Personen WHERE Vorname LIKE '%r%'
<!TXT>
>>

<<
128.129.3.1.5.2
BETWEEN (SQL Schlsselwort)|BETWEEN
--
Der <!SW>BETWEEN ... <!SW>AND Operator whlt solche Werte, die zwischen 2 Eckwerten liegen, diese Eckwerte knnen Text, Zahlen oder Daten (= Mehrzahl von Datum)  sein.

<!CODE>
SELECT spalte/n FROM tabelle WHERE spalte BETWEEN wert1 AND wert2
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ausgangstabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!>Hubert<!>Maler<!>32<!>Hamburg<!>
<!ETBL>

Zeige alle Personen, deren Nachname zwischen 'Klein' (inklusiv) und 'Meier' (exklusiv) liegt:
<!CODE>
SELECT * FROM Personen WHERE Nachname BETWEEN 'Klein' AND 'Meier'
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ergebnistabelle<!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Hubert<!>Maler<!>32<!>Hamburg<!>
<!ETBL>

<!REM>
Achtung! 
Je nach Datenbanksystem wird <!SW>BETWEEN...<!SW>AND unterschiedlich gehandhabt in Bezug auf inklusive/ exklusive die Eckwerte!
<!TXT>
>>

<<
128.129.3.1.5.3
AND & OR (SQL Schlsselworte)|AND & OR
--
Mit <!SW>AND und <!SW>OR knnen mehrere Teilbedungungen fr <!SW>WHERE verknpft werden.

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ausgangstabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>

Suche alle Personen, die in Stuttgart wohnen und lter als 35 sind:
<!CODE>
SELECT * FROM Personen WHERE Ort='Stuttgart' AND Alter>35
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ergebnistabelle<!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>

Suche alle Personen, die in Stuttgart wohnen oder lter als 35 sind:
<!CODE>
SELECT * FROM Personen WHERE Ort='Stuttgart' OR Alter>35
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ergebnistabelle<!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>

AND und OR knnen auch verknpft werden, die Teilbedingungen werden mit Klammern () gruppiert:
<!CODE>
SELECT * FROM Personen 
WHERE (Vorname LIKE 'W%' AND Alter>35) OR Ort='Stuttgart'
<!TXT>
>>

<<
128.129.3.1.5.4
NOT (SQL Schlsselwort)|NOT
--
Der <!SW>NOT Operator negiert eine nachfolgende Bedingung.

<!CODE>
SELECT spalte/n FROM tabelle WHERE NOT bedingung
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ausgangstabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!>Hubert<!>Maler<!>32<!>Hamburg<!>
<!ETBL>

Liste alle Personen die NICHT zwischen 35 und 40 Jahre alt sind
<!CODE>
SELECT * FROM Personen 
WHERE NOT Alter BETWEEN 35 AND 40
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ergebnistabelle<!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Hubert<!>Maler<!>32<!>Hamburg<!>
<!ETBL>
>>

<<
  128.129.3.2
UPDATE (SQL Befehl)|UPDATE
--
Mit dem <!SW>UPDATE Befehl werden vorhandene Daten in einer Datenbank gendert.

Syntax
<!CODE>
UPDATE tabelle 
SET spalte = neuerwert 
WHERE bedingung
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ausgangstabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>

<h4>Ein Feld ndern</h4>
<!CODE>
UPDATE Personen SET Nachname = 'Meyer' WHERE Nachname = 'Schmidt'
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ergebnistabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Meyer<!>36<!>Stuttgart<!>
<!ETBL>

<h4>Mehrere Spalten ndern</h4>
<!CODE>
UPDATE Personen SET Vorname = 'Klaus', Ort = 'Hamburg' WHERE Alter &lt; 40
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ergebnistabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Hamburg<!>
<!>Petra<!>Schmidt<!>36<!>Hamburg<!>
<!ETBL>
>>

<<
128.129.3.3
INSERT INTO (SQL Befehl)|INSERT INTO
--
Der <!SW>INSERT <!SW>INTO Befehl wird benutzt, um neue Datenstze in eine Tabelle einzufgen.

Syntax
<!CODE>
INSERT INTO tabelle VALUES (wert1, wert2,....)
<!TXT>

Es knnen auch die Spalten angegeben werden fr die die Daten eingefgt werden sollen:
<!CODE>
INSERT INTO tabelle (spalte1, spalte2,...) VALUES (wert1, wert2,....)
<!TXT>

<h4>Einfgen aller Spalten</h4>

Wird auf diese Personen Tabelle
<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ausgangstabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!ETBL>

folgendes SQL Kommando ausgefhrt:
<!CODE>
INSERT INTO Personen VALUES ('Petra', 'Schmidt', 36, 'Stuttgart')
<!TXT>

So ergibt folgende Tabelle:
<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ergebnistabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>

<h4>Einfgen mit Angabe von Spalten</h4>

Wird auf die vorige Tabelle folgendes Kommando ausgefhrt:
<!CODE>
INSERT INTO Personen (Vorname, Alter) VALUES ('Werner', 33)
<!TXT>

So ergibt sich folgendes Resultat:
<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ergebnistabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!>Werner<!><font size=-9 color=#dfdfff>.</font><!>33<!><font size=-9 color=#dfdfff>.</font><!>
<!ETBL>
>>

<<
128.129.3.4
DELETE (SQL Befehl)|DELETE
--
Mit dem <!SW>DELETE Befehl werden Datenstze aus einer Datenbank gelscht.

Syntax
<!CODE>
DELETE FROM tabelle WHERE bedingung
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ausgangstabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Werner<!>Klein<!>33<!>Stuttgart<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>

<h4>Einen Datensatz lschen</h4>

Personen mit Nachnamen &quot;Klein&quot; werden gelscht
<!CODE>
DELETE FROM Personen WHERE Nachname = 'Klein'
<!TXT>

<!STBL bgcolor=#efefff>
<tr bgcolor=dfdfff><TD colspan=4>Ausgangstabelle <b>Personen</b><!>
<!><b>Vorname</b><!><b>Nachname</b><!><b>Alter</b><!><b>Ort</b><!>
<!>Walter<!>Meier<!>45<!>Frankfurt<!>
<!>Petra<!>Schmidt<!>36<!>Stuttgart<!>
<!ETBL>

<h4>Alle Datenstze lschen</h4>

Es ist mglich, alle Datenstze zu lschen. Das Ergebnis ist eine intakte Tabelle mit kompletter Tabellenstruktur und Indizes, nur ohne Daten:
<!CODE>
DELETE FROM tabelle
<!TXT>
oder
<!CODE>
DELETE * FROM tabelle
<!TXT>
>>
