4. Die Ausdrücke der Sprache SQL

4.1. Introduction

In den meisten Befehlen SQL ist es möglich, einen Ausdruck zu verwenden. Nehmen wir zum Beispiel den Befehl SELECT:

syntaxe

SELECT expr1, expr2, ... aus table

WHERE expression

SELECT wählt die Zeilen aus, für die expression wahr ist, und zeigt für jede dieser Zeilen die Werte von expri an.

Beispiele

SQL> select prix*1.186 from biblio
SQL> select titre from biblio where prix between 100 and 150

In diesem Abschnitt möchten wir den Begriff des Ausdrucks näher erläutern. Ein elementarer Ausdruck hat folgende Form:

Operand1 opérateur Operand2

oder

Funktion(Parameter)

Beispiel

Im Ausdruck „ “ ist GENRE gleich „ROMAN“

GENRE ist Operand 1
„ROMAN“ ist der Operand 2
= ist der Operator

Im Ausdruck „upper(genre)“

ist „upper“ eine Funktion
„Typ“ ist ein Parameter dieser Funktion.

Zunächst behandeln wir Ausdrücke mit Operatoren, anschließend stellen wir die in Firebird verfügbaren Funktionen vor.

4.2. Ausdrücke mit Operatoren

Wir klassifizieren Ausdrücke mit Operatoren nach dem Typ ihrer Operanden:

numerisch
Zeichenkette
Datum
boolesch oder logisch

4.2.1. Ausdrücke mit numerischen Operanden

4.2.1.1. Liste der Operatoren

Seien nombre1, nombre2, nombre3 Zahlen. Folgende Operatoren können verwendet werden:

Relationale Operatoren

`nombre1 > nombre2`	: Zahl1 ist größer als Zahl2
`nombre1 >= nombre2`	: Zahl1 ist größer oder gleich Zahl2
`nombre1 < nombre2`	: Zahl1 ist kleiner als Zahl2
`nombre1 <= nombre2`	: Zahl1 ist kleiner oder gleich Zahl2
`nombre1 = nombre2`	: Zahl1 ist gleich Zahl2
`nombre1 != nombre2`	: Zahl1 ist ungleich Zahl2
`nombre1 <> nombre2`	: wie oben
`nombre1 BETWEEN nombre2 AND nombre3`	: Zahl1 liegt im Intervall [nombre2,nombre3]
`nombre1 IN (liste de nombres)`	: Zahl1 gehört zur Zahlenliste
`nombre1 IS NULL`	: Zahl1 hat keinen Wert
`nombre1 IS NOT NULL`	: Zahl1 hat einen Wert

Arithmetische Operatoren

`nombre1 + nombre2`	: Addition
`nombre1 - nombre2`	: Subtraktion
`nombre1 * nombre2`	: Multiplikation
`nombre1 / nombre2`	: Division

4.2.1.2. Relationale Operatoren

Ein relationaler Ausdruck drückt eine Beziehung aus, die entweder wahr oder falsch ist. Das Ergebnis eines solchen Ausdrucks ist daher ein boolescher oder logischer Wert.

Beispiele:

SQL> select titre,prix from biblio where prix between 100 and 150

SQL> select titre,prix from biblio where prix not between 100 and 150

SQL> select titre,prix from biblio where prix in (200,210)

4.2.1.3. Arithmetische Operatoren

Der Begriff „arithmetischer Ausdruck“ ist uns vertraut. Er bezeichnet eine Berechnung, die mit numerischen Daten durchgeführt werden soll. Wir sind solchen Ausdrücken bereits begegnet: Es wird angenommen, dass der in den Datensätzen der Datei BIBLIO gespeicherte Preis ein Preis ohne Steuern ist. Wir möchten jeden Titel mit seinem Preis TTC bei einem Steuersatz von TVA von 18,6 % anzeigen:

    SELECT TITRE, PRIX*1.186 FROM BIBLIO

Sollten die Preise um 3 % steigen, lautet der Befehl

    UPDATE BIBLIO SET PRIX = PRIX*1.03

In einem Ausdruck können mehrere arithmetische Operatoren sowie Funktionen und Klammern vorkommen. Diese Elemente werden nach unterschiedlichen Prioritäten verarbeitet:

1	`fonctions`	<---- höhere Priorität
2	`()`
3	`* et /`
4	`+ et -`	<---- geringere Priorität

Wenn zwei Operatoren gleicher Priorität im Ausdruck vorkommen, wird derjenige, der im Ausdruck am weitesten links steht, zuerst ausgewertet.

Beispiele

Der Ausdruck PRIX*TAUX+TAXES wird wie folgt ausgewertet: (PRIX*TAUX)+TAXES ausgewertet. Tatsächlich wird der Multiplikationsoperator zuerst angewendet. Der Ausdruck PRIX*TAUX/100 wird wie folgt ausgewertet: (PRIX*TAUX)/100.

4.2.2. Ausdrücke mit Operanden vom Typ „Zeichen“

4.2.2.1. Liste der Operatoren

Folgende Operatoren können verwendet werden:

Seien „Kette1“, „Kette2“, „Kette3“ und „Muster“ Zeichenketten

`chaine1 > chaine2`	: Zeichenfolge1 ist länger als Zeichenfolge2
`chaine1 >= chaine2`	: Zeichenfolge1 ist größer oder gleich Zeichenfolge2
`chaine1 < chaine2`	: Zeichenfolge1 ist kleiner als Zeichenfolge2
`chaine1 <= chaine2`	: Zeichenfolge1 ist kleiner oder gleich Zeichenfolge2
`chaine1 = chaine2`	: Zeichenfolge1 ist gleich Zeichenfolge2
`chaine1 != chaine2`	: Zeichenfolge1 ist ungleich Zeichenfolge2
`chaine1 <> chaine2`	: wie oben
`chaine1 BETWEEN chaine2 AND chaine3`	: Zeichenfolge1 liegt im Intervall [chaine2,chaine3]
`chaine1 IN liste de chaines`	: Zeichenfolge1 gehört zur Liste der Zeichenfolgen
`chaine1 IS NULL`	: Zeichenfolge1 hat keinen Wert
`chaine1 IS NOT NULL`	: Zeichenfolge1 hat einen Wert
`chaine1 LIKE modèle`	: „Zeichenfolge1“ entspricht der Vorlage

Verknüpfungsoperator

Zeichenkette1 || Zeichenkette2 : chaine2 wird mit chaine1 verkettet

4.2.2.2. Relationale Operatoren

Was bedeutet es, Zeichenfolgen mit Operatoren wie <, <= usw. zu vergleichen?

Jedes Zeichen wird durch eine Ganzzahl kodiert. Beim Vergleich zweier Zeichen werden deren Ganzzahlcodes miteinander verglichen. Die verwendete Kodierung entspricht der natürlichen Reihenfolge im Wörterbuch:

blanc<..< 0 < 1 < ...< 9 < ...< A < B <... < Z < ... < a < b < ... < z

Zahlen kommen vor Buchstaben, und Großbuchstaben vor Kleinbuchstaben.

4.2.2.3. Vergleich zweier Zeichenfolgen

Nehmen wir die Beziehung „CHAT“ < „CHIEN“. Ist sie wahr oder falsch? Um diesen Vergleich durchzuführen, vergleicht das Programm „SGBD“ die beiden Zeichenfolgen Zeichen für Zeichen auf der Grundlage ihrer Ganzzahlcodes. Sobald zwei Zeichen als unterschiedlich erkannt werden, gilt die Zeichenkette, die das kleinere der beiden Zeichen enthält, als kleiner als die andere Zeichenkette. In unserem Beispiel wird „CHAT“ mit „CHIEN“ verglichen. Dabei ergeben sich folgende aufeinanderfolgende Ergebnisse:

     'CHAT    ' 'CHIEN'
----------------------------
    'C'    =    'C'
    'H'    =    'H'
     'A    '     < 'I'

Nach diesem letzten Vergleich wird die Zeichenfolge „CHAT“ als kleiner als die Zeichenfolge „CHIEN“ erkannt. Die Beziehung „CHAT“ < „CHIEN“ ist daher wahr.

Vergleichen wir nun „CHAT“ und „chat“.

     'CHAT    ' 'Katze'
--------------------------
     'C    '     < 'c'

Nach diesem Vergleich wird die Beziehung „CHAT“ < „chat“ als wahr ausgewiesen.

Beispiele

SQL> select titre from biblio

SQL> select titre from biblio where upper(titre) between 'L' and 'M'

4.2.2.4. Der Operator LIKE

Der Operator LIKE wird wie folgt verwendet: chaîne LIKE modèle

Die Beziehung ist wahr, wenn chaîne mit modèle übereinstimmt. Letzteres ist eine Zeichenkette, die zwei Platzhalterzeichen enthalten kann:

`%`	die jede beliebige Zeichenfolge bezeichnet
`_`	die ein beliebiges Zeichen bezeichnet

Beispiele

SQL> select titre from biblio

SQL> select titre from biblio where titre like 'M%';

SQL> select titre from biblio where titre like 'L_ %';

4.2.2.5. Der Verkettungsoperator

SQL > select '[' || titre || ']' from biblio where upper(titre) LIKE 'L_ %'

4.2.3. Ausdrücke mit Operanden vom Typ „Datum“

Seien date1, date2 und date3 Datumsangaben. Folgende Operatoren können verwendet werden:

Relationale Operatoren

`date1 < date2`	ist wahr, wenn date1 vor date2 liegt
`date1 <= date2`	ist wahr, wenn date1 vor date2 liegt oder gleich date2 ist
`date1 > date2`	ist wahr, wenn date1 später als date2 ist
`date1 >= date2`	ist wahr, wenn date1 größer oder gleich date2 ist
`date1 = date2`	ist wahr, wenn date1 und date2 identisch sind
`date1 <> date2`	ist wahr, wenn date1 und date2 unterschiedlich sind.
`date1 != date2`	ebenso
`date1 BETWEEN date2 AND date3`	ist wahr, wenn date1 zwischen date2 und date3 liegt
`date1 IN (liste de dates)`	ist wahr, wenn date1 in der Liste der Daten enthalten ist
`date1 IS NULL`	ist wahr, wenn „date1“ keinen Wert hat
`date1 IS NOT NULL`	ist wahr, wenn „date1“ einen Wert hat
`date1 LIKE modèle`	ist wahr, wenn „date1“ dem Muster entspricht
`ALL,ANY,EXISTS`

Arithmetische Operatoren

`date1 - date2`	: Anzahl der Tage zwischen datum1 und datum2
`date1 - nombre`	: Datum2, sodass Datum1 – Datum2 = Anzahl
`date1 + nombre`	: Datum2, sodass Datum2 – Datum1 = Zahl

Beispiele

SQL> select achat from biblio

SQL>select achat from biblio
   where achat between '01.01.1988' and '31.12.1988';

SQL> select titre, achat from biblio
where cast(achat as char(10)) like '1988'

Wie alt sind die Bücher in der Bibliothek?

SQL> select titre, cast('now' as date)-achat "age(jours)" from biblio

4.2.4. Ausdrücke mit booleschen Operanden

Zur Erinnerung: Ein Boolescher Wert oder logischer Wert kann zwei Werte annehmen: wahr oder falsch. Der logische Operand ist oft das Ergebnis eines relationalen Ausdrucks.

Seien booléen1 und booléen2 zwei Boolesche Werte. Es gibt drei mögliche Operatoren, die in der Reihenfolge ihrer Priorität wie folgt lauten:

`booléen1 AND booléen2`	ist wahr, wenn sowohl booléen1 als auch booléen2 wahr sind.
`booléen1 OR booléen2`	ist wahr, wenn entweder booléen1 oder booléen2 wahr ist.
`NOT booléen1`	hat als Wert den Kehrwert des Wertes von booléen1.

Beispiele

SQL> select titre,genre,prix from biblio order by prix desc

Es wird nach Büchern gesucht, deren Preis zwischen zwei Werten liegt:

SQL> select titre,genre,prix from biblio
     where prix>=130 and prix <=170

Umgekehrte Suche:

SQL> select titre,genre,prix from biblio
     where prix<130 or prix >170
     order by prix asc

Achten Sie auf die Reihenfolge der Operatoren!

SQL> select titre,genre,prix from biblio
  where genre='ROMAN' and prix>200 or prix<100
  order by prix asc

Man verwendet Klammern, um die Priorität der Operatoren zu steuern:

SQL> select titre,genre,prix from biblio
  where genre='ROMAN' and (prix>200 or prix<100)
  order by prix asc

4.3. Die vordefinierten Funktionen von Firebird

Firebird verfügt über vordefinierte Funktionen. Diese sind in den Befehlen SQL nicht sofort einsetzbar. Zunächst muss das Skript SQL <firebird>\UDF\ib_udf.sql ausgeführt werden, wobei <firebird> das Installationsverzeichnis von Firebird bezeichnet:

Bei IBExpert gehen wir wie folgt vor:

Wir verwenden das Tool [Script Excecutive], das über die Option [Tools/ Script Executive] erstellt wurde:

Sobald das Tool vorhanden ist, laden wir das Skript <firebird>\UDF\ib_udf.sql:

Anschließend führen wir das Skript aus:

Sobald dies erledigt ist, stehen die vordefinierten Firebird-Funktionen für die Datenbank zur Verfügung, mit der man zum Zeitpunkt der Skriptausführung verbunden war. Um dies zu überprüfen, öffnen Sie einfach den Datenbank-Explorer und klicken Sie auf den Knoten „[UDF]“ der Datenbank, in die die Funktionen importiert wurden:

Oben sind die für die Datenbank verfügbaren Funktionen aufgeführt. Um sie zu testen, ist es praktisch, eine Tabelle mit einer Zeile zu haben. Nennen wir sie TEST:

und definieren wir sie wie folgt (Rechtsklick auf „Tables“ / „New Table“):

Fügen wir eine einzige Zeile in diese Tabelle ein:

Wechseln wir nun in den Editor SQL (F12) und geben wir den folgenden Befehl SQL ein:

SQL> select cos(0) from test

der die vordefinierte Funktion cos (Kosinus) verwendet. Der obige Befehl wertet cos(0) für jede Zeile der Tabelle TEST aus, also tatsächlich für eine einzige Zeile. Es wird daher lediglich der Wert von cos(0) angezeigt:

Die Funktionen UDF (User Defined Function) sind Funktionen, die der Benutzer selbst erstellen kann, und so findet man im Internet Bibliotheken mit UDF-Funktionen. Wir beschreiben hier nur einige der Funktionen, die in der herunterladbaren Version von Firebird (2005) verfügbar sind. Wir klassifizieren sie nach dem vorherrschenden Typ ihrer Parameter oder nach ihrer Rolle:

Funktionen mit numerischen Parametern
Funktionen mit Parametern vom Typ Zeichenkette

4.3.1. Funktionen mit numerischen Parametern

`abs(nombre)`	Absolutwert einer Zahl abs(-15) = 15
`ceil(nombre)`	Kleinste ganze Zahl, die größer oder gleich nombre ist ceil(15,7) = 16
`floor(nombre)`	größte ganze Zahl, die kleiner oder gleich nombre ist floor(14,3) = 14
`div(nombre1,nombre2)`	Quotient der ganzzahligen Division (der Quotient ist eine ganze Zahl) von nombre1 durch nombre2 div(7,3) = 2
`mod(nombre1,nombre2)`	Rest der ganzzahligen Division (der Quotient ist eine ganze Zahl) von nombre1 durch nombre2 mod(7,3)=1
`sign(nombre)`	-1, wenn nombre < 0 0, wenn nombre = 0 +1, wenn nombre > 0 sign(-6) = -1
`sqrt(nombre)`	Quadratwurzel aus nombre, wenn nombre ≥ 0 -1, wenn nombre < 0 sqrt(16) = 4

4.3.2. Funktionen mit Parametern vom Typ Zeichenkette

ascii_char(Zahl)	Zeichen mit dem Code ASCII nombre ascii_char(65) = 'A'
lower(Zeichenkette)	wandelt chaine in Kleinbuchstaben um lower('INFO') = 'info'
ltrim(Zeichenkette)	Left Trim – Leerzeichen vor dem Text „chaine“ werden entfernt: ltrim(' Kätzchen')='Kätzchen'
replace(Zeichenkette1,Zeichenkette2,Zeichenkette3)	Ersetzt chaine2 durch chaine3 in chaine1. replace('Katze und Hund','Katze','')='ze und **und'
rtrim(Zeichenkette1,Zeichenkette2)	Right Trim – wie ltrim, jedoch rechts rtrim('Katze ')='Katze'
substr(Zeichenkette, p, q)	Teilzeichenfolge von chaine, beginnend an Position p und endend an Position q. substr('chaton', 3, 5) = 'ato'
ascii_val(Zeichen)	Code ASCII von caractère ascii_val('A') = 65
strlen(Zeichenkette)	Anzahl der Zeichen in chaine strlen('Kätzchen') = 6