Wie man Funktionen in SQL verwendet

Einführung

Bei der Arbeit mit relationalen Datenbanken und der strukturierten Abfragesprache SQL können Sie Daten in einem relationalen Datenbankmanagementsystem speichern, verwalten und abrufen. SQL kann Daten unverändert so abrufen, wie sie in der Datenbank gespeichert wurden.

SQL kann mithilfe von Funktionen auch Berechnungen durchführen und Daten bearbeiten. Beispielsweise können Sie Funktionen verwenden, um auf den nächsten Dollar gerundete Produktpreise abzurufen, die durchschnittliche Anzahl der Produktkäufe zu berechnen oder die verbleibenden Tage bis zum Ablauf der Garantie für einen Kauf zu ermitteln.

In diesem Tutorial verwenden Sie verschiedene SQL-Funktionen, um mathematische Berechnungen durchzuführen, Zeichenketten und Datumsangaben zu bearbeiten und mithilfe von Aggregatfunktionen Zusammenfassungen zu berechnen.

Voraussetzungen

Um dieser Anleitung folgen zu können, benötigen Sie einen Computer mit einem SQL-basierten relationalen Datenbankmanagementsystem (RDBMS). Die Anweisungen und Beispiele in dieser Anleitung wurden in der folgenden Umgebung validiert:

• Ein Server, auf dem Ubuntu 20.04 läuft, mit einem Nicht-Root-Benutzer mit administrativen Rechten und einer mit UFW konfigurierten Firewall, wie im Leitfaden zur Ersteinrichtung des Servers für Ubuntu 20.04 beschrieben.
• MySQL ist auf dem Server installiert und gesichert, wie in der Anleitung “MySQL unter Ubuntu 20.04 installieren” beschrieben. Diese Anleitung setzt die Verwendung eines MySQL-Benutzers ohne Root-Rechte voraus, der gemäß Schritt 3 erstellt wurde.
• Eine grundlegende Einführung in die Ausführung von SELECT-Abfragen zum Auswählen von Daten aus einer Datenbank, wie im Leitfaden “So wählen Sie Zeilen aus Tabellen in SQL aus” erläutert.

Hinweis: Viele relationale Datenbankmanagementsysteme (RDBMS) verwenden ihre eigene SQL-Implementierung. Obwohl die in diesem Tutorial beschriebenen Befehle in den meisten RDBMS funktionieren, definiert die Standard-SQL-Syntax nur eine begrenzte Anzahl von Funktionen. Darüber hinaus variiert die Unterstützung der Standard-Syntax je nach Datenbank-Engine. Die genaue Syntax oder Ausgabe kann abweichen, wenn Sie die Befehle auf einem anderen System als MySQL testen.

Sie benötigen außerdem eine Datenbank mit Tabellen, die mit Beispieldaten gefüllt sind, um die Funktionen nutzen zu können. Wir empfehlen Ihnen, den Abschnitt “Verbindung zu MySQL herstellen und eine Beispieldatenbank einrichten” zu lesen, um detaillierte Informationen zum Verbinden mit einem MySQL-Server und zum Erstellen der in den Beispielen dieses Leitfadens verwendeten Testdatenbank zu erhalten.

Verbindung zu MySQL herstellen und eine Beispieldatenbank einrichten

In diesem Abschnitt stellen Sie eine Verbindung zu einem MySQL-Server her und erstellen eine Beispieldatenbank, damit Sie den Beispielen in diesem Leitfaden folgen können.

Wenn Ihr SQL-Datenbanksystem auf einem Remote-Server läuft, melden Sie sich über SSH bei Ihrem Server an:

ssh sammy@your_server_ip

Öffnen Sie anschließend die MySQL-Serverumgebung, anstatt Sammy Geben Sie Ihren MySQL-Benutzernamen ein:

mysql -u sammy -p

Erstelle eine Datenbank namens Buchhandlung:

CREATE DATABASE bookstore;

Wenn die Datenbank erfolgreich erstellt wurde, erhalten Sie eine Ausgabe ähnlich der folgenden:

Output
Query OK, 1 row affected (0.01 sec)

Um die Buchhandelsdatenbank auszuwählen, führen Sie den Befehl USE aus:

USE bookstore;

Sie sehen folgende Ausgabe:

Output
Database changed

Sobald Sie eine Datenbank ausgewählt haben, können Sie darin Beispieltabelle erstellen. In dieser Anleitung verwenden wir eine fiktive Bibliothek, die eine Vielzahl von Büchern verschiedener Autoren verkauft.

Die Inventartabelle enthält Informationen über die im Buchladen verfügbaren Bücher. Sie enthält die folgenden Spalten:

• book_id: Diese Spalte enthält die ID jedes Buches, dargestellt durch den Datentyp int. Diese Spalte bildet den Primärschlüssel der Tabelle, und jeder Wert dient als eindeutiger Bezeichner für die entsprechende Zeile.
• Autor: Diese Spalte enthält den Namen des Autors des Buches, dargestellt im Datentyp varchar mit maximal 50 Zeichen.
• Titel: Diese Spalte enthält den Titel des gekauften Buches, dargestellt im Datentyp varchar mit maximal 200 Zeichen.
• Einführungsdatum: Diese Spalte verwendet den Datentyp Datum, um das Datum zu erfassen, an dem jedes Buch von der Buchhandlung eingeführt wurde.
• Bestand: Diese Spalte enthält die Anzahl der Bücher, die die Buchhandlung auf Lager hat, wobei der Datentyp Integer verwendet wird.
• Preis: In dieser Spalte wird der Einzelhandelspreis des Buches im Dezimaldatentyp mit maximal 5 Stellen vor und 2 Stellen nach dem Dezimaltrennzeichen gespeichert.

Erstellen Sie die Beispieltabelle mit folgendem Befehl:

CREATE TABLE inventory (
book_id int,
author varchar(50),
title varchar(200),
introduction_date date,
stock int,
price decimal(5, 2),
PRIMARY KEY (book_id)
);

Wenn die folgende Ausgabe gedruckt wird, wurde die Tabelle erstellt:

Output
Query OK, 0 rows affected (0.00 sec)

Laden Sie anschließend die Tabelle „purchases“ mit Beispieldaten, indem Sie die folgende INSERT INTO-Operation ausführen:

INSERT INTO inventory
VALUES
(1, 'Oscar Wilde', 'The Picture of Dorian Gray', '2022-10-01', 4, 20.83),
(2, 'Jane Austen', 'Pride and Prejudice', '2022-10-04', 12, 42.13),
(3, 'Herbert George Wells', 'The Time Machine', '2022-09-23', 7, 21.99),
(4, 'Mary Shelley', 'Frankenstein', '2022-07-23', 9, 17.43),
(5, 'Mark Twain', 'The Adventures of Huckleberry Finn', '2022-10-01', 14, 23.15);

Der INSERT INTO-Vorgang fügt der Inventartabelle fünf Bücher mit den angegebenen Werten hinzu. Die folgende Ausgabe zeigt, dass alle fünf Zeilen hinzugefügt wurden:

Output
Query OK, 5 rows affected (0.00 sec)
Records: 5 Duplicates: 0 Warnings: 0

Damit sind Sie bereit, dem Rest der Anleitung zu folgen und mit der Verwendung von Funktionen in SQL zu beginnen.

SQL-Funktionen verstehen

Funktionen sind benannte Ausdrücke, die einen oder mehrere Werte entgegennehmen, Berechnungen oder Transformationen an den Daten durchführen und als Ergebnis einen neuen Wert zurückgeben. SQL-Funktionen lassen sich ähnlich wie mathematische Funktionen betrachten. Beispielsweise nimmt die Funktion log(x) einen Wert x entgegen und gibt den Logarithmus von x zurück.

Wenn Sie beispielsweise alle Buchtitel mit ihren Preisen in der Reihenfolge vom teuersten zum günstigsten Buch abrufen möchten, können Sie folgenden Befehl ausführen:

SELECT title, price, introduction_date FROM inventory ORDER BY price DESC;

Sie erhalten eine Ausgabe, die in etwa wie folgt aussieht:

Output
+------------------------------------+-------+-------------------+
| title | price | introduction_date |
+------------------------------------+-------+-------------------+
| Pride and Prejudice | 42.13 | 2022-10-04 |
| The Adventures of Huckleberry Finn | 23.15 | 2022-10-01 |
| The Time Machine | 21.99 | 2022-09-23 |
| The Picture of Dorian Gray | 20.83 | 2022-10-01 |
| Frankenstein | 17.43 | 2022-07-23 |
+------------------------------------+-------+-------------------+
5 rows in set (0.000 sec)

In diesem Befehl, Titel, Preis Und Einführungsdatum sind die Namen der Spalten, und in der Ausgabe zeigt die Datenbank die unveränderten Werte an, die aus diesen Spalten für jedes Buch abgerufen wurden: den vollständigen Titel des Buches, den Preis und das Datum, an dem das Buch in der Bibliothek eingetroffen ist.

Möglicherweise möchten Sie jedoch Werte aus der Datenbank nach einer gewissen Verarbeitung oder Manipulation abrufen. Beispielsweise könnten Sie an Buchpreisen auf den nächsten Dollar gerundet, Buchtiteln in Großbuchstaben oder dem Erscheinungsjahr (ohne Monat und Tag) interessiert sein. In diesem Fall verwenden Sie eine Funktion.

SQL-Funktionen lassen sich grob in verschiedene Gruppen einteilen, je nachdem, mit welcher Art von Daten sie arbeiten. Dies sind die am häufigsten verwendeten Funktionen:

• Mathematische Funktionen: Funktionen, die mit numerischen Werten arbeiten und Berechnungen durchführen, wie z. B. Runden, Logarithmieren, Wurzelziehen oder Potenzen.
• Funktionen zur Zeichenkettenmanipulation: Funktionen, die auf Zeichenketten und Textfelder angewendet werden und Texttransformationen durchführen, wie z. B. die Umwandlung von Text in Großbuchstaben, das Abschneiden oder das Ersetzen von Wörtern in Werten.
• Datums- und Zeitfunktionen: Funktionen, die mit Datumsfeldern arbeiten. Diese Funktionen führen Berechnungen und Umrechnungen durch, z. B. das Hinzufügen einer Anzahl von Tagen zu einem gegebenen Datum oder das Subtrahieren eines Jahres von einem vollständigen Datum.
• Aggregatfunktionen: Ein Sonderfall mathematischer Funktionen, die auf Werten operieren, die aus mehreren Zeilen stammen, wie zum Beispiel die Berechnung des Durchschnittspreises für alle Zeilen.

Hinweis: Die meisten relationalen Datenbanken, einschließlich MySQL, erweitern den im SQL-Standard definierten Funktionsumfang um zusätzliche, datenbankspezifische Operationen. Viele Funktionen außerhalb des SQL-Standards funktionieren in vielen Datenbanken ähnlich, während andere spezifisch für ein bestimmtes RDBMS und dessen Besonderheiten sind. In der Dokumentation Ihrer gewählten Datenbank finden Sie weitere Informationen zu den von ihr bereitgestellten Funktionen. Im Fall von MySQL finden Sie dort Informationen zu integrierten Funktionen und Operatorreferenzen.

Das folgende Beispiel zeigt die allgemeine Syntax für die Verwendung einer fiktiven, nicht existierenden Funktion namens EXAMPLE, um die Ergebnisse für Preiswerte in einer Buchhandelsinventardatenbank mithilfe einer SELECT-Abfrage zu ändern:

SELECT EXAMPLE(price) AS new_price FROM inventory;

Die Funktion (EXAMPLE) erwartet den Spaltennamen (price) als Argument in Klammern. Dieser Teil der Abfrage weist die Datenbank an, die Funktion EXAMPLE auf die Preiswerte in der Spalte anzuwenden und die Ergebnisse zurückzugeben. AS new_price weist die Datenbank an, den berechneten Werten einen temporären Namen (new_price) zuzuweisen. Dadurch lassen sich die Funktionsergebnisse in der Ausgabe identifizieren und mithilfe der WHERE- und ORDER BY-Klauseln auf die berechneten Werte zugreifen.

Im folgenden Abschnitt verwenden Sie mathematische Funktionen, um gängige Berechnungen durchzuführen.

Verwendung mathematischer Funktionen

Mathematische Funktionen verarbeiten numerische Werte, wie beispielsweise den Preis eines Buches oder die Anzahl der in der Beispieldatenbank vorhandenen Bücher. Sie können verwendet werden, um Berechnungen in der Datenbank durchzuführen und die Ergebnisse an Ihre Bedürfnisse anzupassen.

Runden ist eine der häufigsten Anwendungen mathematischer Funktionen in SQL. Angenommen, Sie möchten die Preise aller Bücher abrufen, aber nur die auf den nächsten Dollar gerundeten Werte. Dazu können Sie die Funktion verwenden. RUNDEN Verwenden Sie die Funktion, die die Rundungsoperation durchführt.

Führen Sie folgenden Befehl aus:

SELECT title, price, ROUND(price) AS rounded_price FROM inventory;

Sie sehen eine Ausgabe, die in etwa wie folgt aussieht:

Output
+------------------------------------+-------+---------------+
| title | price | rounded_price |
+------------------------------------+-------+---------------+
| The Picture of Dorian Gray | 20.83 | 21 |
| Pride and Prejudice | 42.13 | 42 |
| The Time Machine | 21.99 | 22 |
| Frankenstein | 17.43 | 17 |
| The Adventures of Huckleberry Finn | 23.15 | 23 |
+------------------------------------+-------+---------------+
5 rows in set (0.000 sec)

Der obige Befehl gibt die Werte der Spalten zurück. Titel Und Preis mit einer temporären Säule gerundeter Preis was sich aus der Funktion ergibt RUNDEN(Preis) Diese Funktion benötigt ein Argument, nämlich den Spaltennamen (hier, Preis) und rundet die Werte in dieser Spalte der Tabelle auf die nächste ganze Zahl.

Die Funktion ROUND akzeptiert auch zusätzliche Argumente, die die Anzahl der Dezimalstellen für die Rundung sowie arithmetische Operationen anstelle eines Spaltennamens angeben. Führen Sie beispielsweise die folgende Abfrage aus:

SELECT title, price, ROUND(price * stock, 1) AS stock_price FROM inventory;

Sie erhalten folgende Ausgabe:

Output
+------------------------------------+-------+-------+-------------+
| title | stock | price | stock_price |
+------------------------------------+-------+-------+-------------+
| The Picture of Dorian Gray | 4 | 20.83 | 83.3 |
| Pride and Prejudice | 12 | 42.13 | 505.6 |
| The Time Machine | 7 | 21.99 | 153.9 |
| Frankenstein | 9 | 17.43 | 156.9 |
| The Adventures of Huckleberry Finn | 14 | 23.15 | 324.1 |
+------------------------------------+-------+-------+-------------+
5 rows in set (0.000 sec)

Ausführung ROUND(Preis * Lagerbestand, 1) Zunächst wird der Preis eines einzelnen Buches mit der Anzahl der verfügbaren Bücher multipliziert und das Ergebnis anschließend auf eine Dezimalstelle gerundet. Das Ergebnis wird in der temporären Spalte „Stock_Price“ angezeigt.

Zu den weiteren in MySQL integrierten mathematischen Funktionen gehören trigonometrische Funktionen, Quadratwurzeln, Potenzen, Logarithmen und Exponentialfunktionen. Mehr über die Verwendung mathematischer Funktionen in SQL erfahren Sie im Tutorial „Mathematische Ausdrücke und Aggregationsfunktionen in SQL verwenden“.

Im nächsten Abschnitt werden Sie mithilfe von SQL-Funktionen Texte aus der Datenbank bearbeiten.

Verwendung von Textfunktionen

Mit Textfunktionen in SQL lassen sich Zeichenketten bearbeiten und verändern. Beispielsweise können Sie Buchtitel übersichtlicher abrufen, indem Sie überflüssige Leerzeichen am Anfang und Ende entfernen.

Dazu können Sie die Funktion verwenden TRIMMEN Mit dieser Funktion können Sie alle Leerzeichen und überflüssigen Zeichen am Anfang und Ende einer Zeichenkette entfernen.

Betrachten Sie folgendes Beispiel:

SELECT LOWER(title) AS title_lowercase FROM inventory;

Folgende Ausgabe wird auf dem Bildschirm angezeigt:

Output
+------------------------------------+
| title_lowercase |
+------------------------------------+
| the picture of dorian gray |
| pride and prejudice |
| the time machine |
| frankenstein |
| the adventures of huckleberry finn |
+------------------------------------+
5 rows in set (0.001 sec)

Die SQL-Funktion LOWER nimmt ein einzelnes Argument entgegen und wandelt dessen Inhalt in Kleinbuchstaben um. Mithilfe des Alias-Spalte AS title_downcase werden die resultierenden Daten in einer temporären Spalte namens title_downcase angezeigt.

Rufen Sie nun alle Autoren ab, diesmal in Großbuchstaben. Versuchen Sie, die folgende SQL-Abfrage auszuführen:

SELECT UPPER(author) AS author_uppercase FROM inventory;

Sie erhalten folgende Ausgabe:

Output
+----------------------+
| author_uppercase |
+----------------------+
| OSCAR WILDE |
| JANE AUSTEN |
| HERBERT GEORGE WELLS |
| MARY SHELLEY |
| MARK TWAIN |
+----------------------+
5 rows in set (0.000 sec)

Anstelle der Funktion LOWER haben Sie die Funktion UPPER verwendet, die ähnlich funktioniert, den Text aber in Großbuchstaben umwandelt. Beide Funktionen können verwendet werden, wenn Sie beim Abrufen von Daten die Groß-/Kleinschreibung sicherstellen möchten.

Eine weitere nützliche Funktion zur Stringmanipulation ist CONCAT. Sie nimmt mehrere Argumente mit Textwerten entgegen und verkettet diese. Versuchen Sie, Autoren und Buchtitel in einer einzigen Spalte abzurufen. Führen Sie dazu die folgende Anweisung aus:

SELECT CONCAT(author, ': ', title) AS full_title FROM inventory;

Dieser Befehl liefert folgende Ausgabe:

Output
+------------------------------------------------+
| full_title |
+------------------------------------------------+
| Oscar Wilde: The Picture of Dorian Gray |
| Jane Austen: Pride and Prejudice |
| Herbert George Wells: The Time Machine |
| Mary Shelley: Frankenstein |
| Mark Twain: The Adventures of Huckleberry Finn |
+------------------------------------------------+
5 rows in set (0.001 sec)

Die Funktion CONCAT verknüpft mehrere Zeichenketten und wird mit drei Argumenten aufgerufen. Das erste Argument, author, verweist auf die Spalte mit dem Namen des Autors. Das zweite Argument, :, ist ein beliebiger Zeichenkettenwert, der Autoren und Buchtitel durch einen Doppelpunkt trennt. Das letzte Argument, title, verweist auf die Spalte mit den Buchtiteln.

Als Ergebnis dieser Abfrage werden die Autoren und Titel in einer temporären Spalte namens full_title zurückgegeben, die von der Datenbank-Engine direkt verkettet wird.

Weitere in MySQL integrierte String-Funktionen umfassen Funktionen zum Suchen und Ersetzen von Zeichenketten, zum Abrufen von Teilzeichenketten, zum Auffüllen und Kürzen von Zeichenkettenwerten sowie zum Anwenden regulärer Ausdrücke usw. Mehr über die Verwendung von SQL-Funktionen zum Verketten mehrerer Werte erfahren Sie im Tutorial „Datenmanipulation mit CAST-Funktionen und Verkettungsausdrücken in SQL“. Weitere Informationen finden Sie in der MySQL-Dokumentation unter „String-Funktionen und -Operatoren“.

Im nächsten Abschnitt verwenden Sie SQL-Funktionen, um Datumsangaben aus der Datenbank zu bearbeiten.

Verwendung von Datums- und Zeitfunktionen

Datums- und Zeitfunktionen in SQL ermöglichen die Bearbeitung von Werten in Spalten, die Datums- und Zeitstempel enthalten, während der Verarbeitung von SQL-Abfragen. Sie können verwendet werden, um Teile von Datumsinformationen zu extrahieren, Datumsberechnungen durchzuführen oder Datums- und Zeitstempel in die gewünschten Ausgabeformate zu formatieren.

Angenommen, Sie müssen das Erscheinungsdatum des Buches in Jahr, Monat und Tag aufteilen, anstatt eine einzige Datumsspalte in der Ausgabe zu haben.

Versuchen Sie, folgenden Befehl auszuführen:

SELECT introduction_date, YEAR(introduction_date) as year, MONTH(introduction_date) as month, DAY(introduction_date) as day FROM inventory;

Sie sehen eine Ausgabe, die in etwa wie folgt aussieht:

Output
+-------------------+------+-------+------+
| introduction_date | year | month | day |
+-------------------+------+-------+------+
| 2022-10-01 | 2022 | 10 | 1 |
| 2022-10-04 | 2022 | 10 | 4 |
| 2022-09-23 | 2022 | 9 | 23 |
| 2022-07-23 | 2022 | 7 | 23 |
| 2022-10-01 | 2022 | 10 | 1 |
+-------------------+------+-------+------+
5 rows in set (0.000 sec)

Diese SQL-Anweisung verwendet drei separate Funktionen: YEAR, MONTH und DAY. Jede Funktion benötigt den Namen der Spalte, in der die Datumsangaben gespeichert sind, als Argument und extrahiert jeweils nur einen Teil des vollständigen Datums: das Jahr, den Monat oder den Tag. Mithilfe dieser Funktionen können Sie in SQL-Abfragen auf einzelne Bestandteile eines Datums zugreifen.

Eine weitere nützliche Funktion zur Datumsbearbeitung ist DATEDIFF, mit der Sie die Anzahl der Tage zwischen zwei Daten ermitteln können. Prüfen Sie nun, wie viele Tage zwischen dem Erscheinungsdatum jedes Buches und dem aktuellen Datum vergangen sind.

Führen Sie die folgende Abfrage aus:

SELECT introduction_date, DATEDIFF(introduction_date, CURRENT_DATE()) AS days_since FROM inventory;

Folgende Ausgabe wird auf dem Bildschirm angezeigt:

Output
+-------------------+------------+
| introduction_date | days_since |
+-------------------+------------+
| 2022-10-01 | -30 |
| 2022-10-04 | -27 |
| 2022-09-23 | -38 |
| 2022-07-23 | -100 |
| 2022-10-01 | -30 |
+-------------------+------------+
5 rows in set (0.000 sec)

Die Funktion DATEDIFF benötigt zwei Argumente: ein Startdatum und ein Enddatum. Sie berechnet die Anzahl der Tage zwischen diesen beiden Zeitpunkten. Liegt das Enddatum früher, kann das Ergebnis negativ sein. In diesem Beispiel ist das erste Argument der Name der Spalte „introduction_date“, die die Datumsangaben in der Inventartabelle enthält. Das zweite Argument ist die Funktion CURRENT_DATE, die das aktuelle Systemdatum repräsentiert. Die Ausführung dieser Abfrage ermittelt die Anzahl der Tage zwischen diesen beiden Zeitpunkten und speichert das Ergebnis in einer temporären Spalte namens „days_since“.

Hinweis: DATEDIFF gehört nicht zum offiziellen SQL-Standardfunktionsumfang. Obwohl viele Datenbanken diese Funktion unterstützen, variiert die Syntax häufig zwischen verschiedenen Datenbank-Engines. Dieses Beispiel folgt der nativen MySQL-Syntax.

Weitere in MySQL integrierte Funktionen zur Datumsmanipulation umfassen das Addieren und Subtrahieren von Zeitintervallen und Datumsangaben, das Formatieren von Datumsangaben für verschiedene Sprachformate, das Abrufen von Tages- und Monatsnamen sowie das Erstellen neuer Datumswerte. Mehr über die Arbeit mit Datumsangaben in SQL erfahren Sie im Tutorial „Arbeiten mit Datum und Uhrzeit in SQL“. Weitere Informationen finden Sie in der MySQL-Dokumentation unter „Datums- und Zeitfunktionen“.

Im nächsten Abschnitt lernen Sie, wie man Aggregatfunktionen verwendet.

Verwendung von Aggregatfunktionen

In allen vorherigen Beispielen haben Sie SQL-Funktionen verwendet, um Transformationen oder Berechnungen auf einzelne Spaltenwerte in einer Zeile anzuwenden, die ein Buch in einer Buchhandlung repräsentieren. SQL bietet die Möglichkeit, mathematische Berechnungen auf mehreren Zeilen durchzuführen, um aggregierte Informationen über den gesamten Datensatz zu ermitteln.

• Zu den grundlegenden Aggregatfunktionen in SQL gehören:
• AVG steht für den Durchschnitt der Werte, auf denen die Berechnungen basieren.
• ZÄHLEN Sie die Anzahl der Werte, auf denen die Berechnungen durchgeführt werden.
• MAX für Maximalwert.
• MIN für Minimalwert.
• SUMME steht für die Summe aller Werte.

Sie können mehrere Aggregatfunktionen in Ihre SELECT-Abfrage einbinden. Angenommen, Sie möchten die Anzahl der in einer Buchhandlung gelisteten Bücher, den Höchstpreis jedes verfügbaren Buches und den Durchschnittspreis des gesamten Katalogs überprüfen. Führen Sie dazu die folgende Anweisung aus:

SELECT COUNT(title) AS count, MAX(price) AS max_price, AVG(price) AS avg_price FROM inventory;

Dieser Befehl liefert folgende Ausgabe:

Output
+-------+-----------+-----------+
| count | max_price | avg_price |
+-------+-----------+-----------+
| 5 | 42.13 | 25.106000 |
+-------+-----------+-----------+
1 row in set (0.001 sec)

Die obige Abfrage verwendet drei Aggregatfunktionen gleichzeitig. Die Funktion COUNT zählt die durchsuchten Zeilen. In diesem Beispiel wird der Titel als Argument übergeben. Da die Anzahl der Zeilen für jede markierte Spalte gleich ist, können Sie jedoch jeden anderen Spaltennamen als Funktionsargument verwenden. Die Funktion MAX berechnet den Maximalwert aus der Spalte „Preis“. Hierbei ist der Spaltenname wichtig, da die Berechnung auf den Werten dieser Spalte basiert. Die letzte Funktion ist die Funktion AVG, die den Durchschnitt aller Preise aus der Spalte „Preis“ berechnet.

Die Verwendung von Aggregatfunktionen auf diese Weise führt dazu, dass eine Zeile mit temporären Spalten, die die Werte der Aggregatberechnungen darstellen, an die Datenbank zurückgegeben wird. Die Quellzeilen werden intern für die Berechnung verwendet, aber nicht über die Abfrage zurückgegeben. In diesem Beispiel haben Sie Aggregatfunktionen verwendet, um statistische Werte aus der gesamten Inventartabelle gleichzeitig zu berechnen und dabei alle Zeilen für die Zusammenfassung zu berücksichtigen.

Mit SQL können Sie die Zeilen einer Tabelle in Gruppen unterteilen und anschließend die Summe dieser Gruppen separat berechnen. Beispielsweise können Sie den Durchschnittspreis von Büchern verschiedener Autoren ermitteln, um herauszufinden, welcher Autor die teuersten Titel veröffentlicht hat. Weitere Informationen zum Gruppieren von Zeilen für solche Berechnungen finden Sie im Tutorial „Verwendung von GROUP BY und ORDER BY in SQL“. Mehr über die Verwendung von Aggregatfunktionen erfahren Sie im Tutorial „Verwendung mathematischer Ausdrücke und Aggregatfunktionen in SQL“.

Ergebnis

In diesem Leitfaden haben Sie gelernt, wie Sie SQL-Funktionen verwenden, um Berechnungen mit Daten durchzuführen und komplexere Abfragen zu erstellen. Diese Funktionen helfen Ihnen, Daten auf verschiedene Weise zu bearbeiten und bessere Ergebnisse zu erzielen. Beachten Sie, dass die genaue SQL-Syntax je nach verwendetem relationalen Datenbankmanagementsystem (RDBMS) variieren kann.