Analyse einfacher Anwendungsbeispiele für abgeleitete MySQL-Tabellen (abgeleitete Tabellen)

Dieser Artikel beschreibt anhand eines Beispiels die einfache Verwendung von MySQL-abgeleiteten Tabellen. Teilen Sie uns die Einzelheiten zu Ihrer Information mit:

In Bezug auf diese abgeleitete Tabelle müssen wir zunächst wissen, dass die abgeleitete Tabelle eine virtuelle Tabelle ist, die von der Select-Anweisung zurückgegeben wird. Eine abgeleitete Tabelle ähnelt einer temporären Tabelle, die Verwendung einer abgeleiteten Tabelle in einer SELECT-Anweisung ist jedoch viel einfacher als die Verwendung einer temporären Tabelle, da der Schritt des Erstellens einer temporären Tabelle nicht erforderlich ist. Wenn also eine eigenständige Unterabfrage in der FROM-Klausel einer SELECT-Anweisung verwendet wird, nennen wir sie eine abgeleitete Tabelle. Lassen Sie es uns ohne weitere Umschweife im Detail erklären:

WÄHLEN 
  Spaltenliste
AUS
* (WÄHLEN 
* Spaltenliste
* AUS
* Tabelle_1) abgeleiteter_Tabellenname;
WO abgeleiteter_Tabellenname.Spalte > 1...

An den mit einem Sternchen markierten Stellen werden abgeleitete Tabellen verwendet. Um dies genauer zu erklären, schauen wir uns ein konkretes Beispiel an. Als Nächstes müssen wir aus der Tabelle „Bestellungen“ und der Tabelle „Bestelldetails“ in der Datenbank die fünf Produkte mit dem höchsten Umsatz im Jahr 2018 ermitteln. Schauen wir uns zunächst die Felder in der folgenden Tabelle an:

Schauen wir uns zunächst das folgende SQL an:

WÄHLEN 
  Produktcode, 
  ROUND(SUM(Bestellte Menge * Stückpreis)) Umsatz
AUS
  Bestelldetails
    Innerer Join
  Bestellungen mit (Bestellnummer)
WO
  JAHR(Versanddatum) = 2018
GRUPPE NACH Produktcode
ORDER BY Verkäufe DESC
GRENZE 5;

Diese SQL-Anweisung verwendet das von beiden Tabellen gemeinsam genutzte Feld „orderNumber“ als Knoten für die gemeinsame Abfrage. Danach verwendet sie „time“ als Bedingung und das Feld „productCode“ als Gruppierungsbasis. Anschließend ruft sie nach der Berechnung das Gruppierungsfeld und das Aliasfeld ab, verwendet dann das Feld „sales“ als Sortierbasis und extrahiert schließlich die ersten fünf Ergebnisse. Das ist es wahrscheinlich. Wir können den fertigen Ergebnissatz als temporäre Tabelle oder etwas anderes betrachten. Werfen wir einen Blick auf den Ergebnissatz:

+-------------+--------+
| Produktcode | Verkauf |
+-------------+--------+
| S18_3232 | 103480 |
| Staffel 10_1949 | 67985 |
| S12_1108 | 59852 |
| S12_3891 | 57403 |
| S12_1099 | 56462 |
+-------------+--------+
5 Reihen im Set

Das ist alles. Da wir uns gerade mit abgeleiteten Tabellen beschäftigen, können wir das Ergebnis dieser Abfrage natürlich als abgeleitete Tabelle verwenden und mit der Produkttabelle verknüpfen. Die Struktur der Produkttabelle ist wie folgt:

mysql> Beschreibung Produkte;
+--------------------+--------------+------+-----+---------+---------+----------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+--------------------+--------------+------+-----+---------+---------+----------+
| Produktcode | varchar(15) | NEIN | PRI | | |
| Produktname | varchar(70) | NEIN | | NULL | |
| Produktzeile | varchar(50) | NEIN | MUL | NULL | |
| Produktmaßstab | varchar(10) | NEIN | | NULL | |
| Produktanbieter | varchar(50) | NEIN | | NULL | |
| Produktbeschreibung | Text | NEIN | | NULL | |
| Menge auf Lager | smallint(6) | NEIN | | NULL | |
| Kaufpreis | Dezimalzahl (10,2) | NEIN | | NULL | |
| UVP | Dezimalzahl (10,2) | NEIN | | NULL | |
+--------------------+--------------+------+-----+---------+---------+----------+
20 Reihen im Set

Nachdem wir nun die Tabellenstruktur verstanden haben, schauen wir uns das folgende SQL an:

WÄHLEN 
  Produktname, Verkauf
AUS
# (WÄHLEN 
# Produktcode, 
# ROUND(SUM(Bestellte Menge * Stückpreis)) Verkäufe
# AUS
#Bestelldetails
# INNER JOIN Bestellungen USING (Bestellnummer)
# WO
# JAHR(Versanddatum) = 2018
# GRUPPE NACH Produktcode
# ORDER BY Verkäufe DESC
# LIMIT 5) top5_products_2018
Innerer Join
  Produkte unter Verwendung von (Produktcode);

Der #-Teil oben ist das SQL, das wir vorher hatten. Ich habe es mit # markiert, damit es für alle leichter verständlich ist. Bitte verwenden Sie es nicht, wenn Sie schreiben. Sehen wir uns nun an, was dieses SQL bedeutet. Es behandelt nur den mit # markierten Teil als Tabelle und führt eine einfache gemeinsame Abfrage durch. Da diese Tabelle, die wir als abgeleitete Tabelle bezeichnen, jedoch sofort nach der Verwendung gelöscht wird, können wir ihre Verwendung bei der Vereinfachung komplexer Abfragen in Betracht ziehen. Schauen wir uns ohne weitere Umschweife den Ergebnissatz an:

+-----------------------------+--------+
| Produktname | Verkauf |
+-----------------------------+--------+
| 1992 Ferrari 360 Spider rot | 103480 |
| 1952 Alpine Renault 1300 | 67985 |
| 2001 Ferrari Enzo | 59852 |
| 1969 Ford Falcon | 57403 |
| 1968 Ford Mustang | 56462 |
+-----------------------------+--------+
5 Reihen im Set

Lassen Sie uns kurz zusammenfassen:

• Zuerst wird die Unterabfrage ausgeführt, um einen Ergebnissatz oder eine abgeleitete Tabelle zu erstellen.
• Anschließend verbindet eine äußere Abfrage die abgeleitete Tabelle „top5_products_2018“ mit der Produkttabelle in der Spalte „productCode“.

Das ist es. Damit beenden wir unser Verständnis und die Verwendung einfacher abgeleiteter Tabellen. Versuchen wir es mit einer etwas komplizierteren Aufgabe. Nehmen wir zunächst an, dass die Kunden im Jahr 2018 in drei Gruppen unterteilt werden müssen: Platin, Weißgold und Silber. Darüber hinaus müssen wir die Anzahl der Kunden in jeder Gruppe wie folgt kennen:

• Kunden mit einem Gesamtbestellwert von über 100.000 sind Platin-Kunden;
• Gold-Kunden sind Kunden mit einem Gesamtbestellwert von 10.000 bis 100.000
• Kunden mit einer Gesamtbestellsumme unter 10.000 sind Silber-Kunden.

Um diese Abfrage zu erstellen, müssen wir zunächst jeden Kunden mithilfe eines Case-Ausdrucks und einer Group-By-Klausel in die entsprechende Gruppe einfügen, wie unten gezeigt:

WÄHLEN 
  Kundennummer,
  ROUND(SUM(Bestellte Menge * Stückpreis)) Verkäufe,
  (FALL
    WENN SUMME(Bestellte Menge * Stückpreis) < 10000, DANN ‚Silber‘
    WENN SUMME(Bestellte Menge * Stückpreis) ZWISCHEN 10000 UND 100000, DANN 'Gold'
    WENN SUMME(Bestellte Menge * Stückpreis) > 100000, DANN 'Platin'
  ENDE) Kundengruppe
AUS
  Bestelldetails
    Innerer Join
  Bestellungen mit (Bestellnummer)
WO
  JAHR(Versanddatum) = 2018
GROUP BY Kundennummer 
SORTIEREN NACH Verkäufen DESC;

Schauen wir uns ein Beispiel für einen Ergebnissatz an:

+----------------+--------+------------------+
| Kundennummer | Umsatz | Kundengruppe |
+----------------+--------+------------------+
| 141 | 189840 | Platin |
| 124 | 167783 | Platin |
| 148 | 150123 | Platin |
| 151 | 117635 | Platin |
| 320 | 93565 | Gold |
| 278 | 89876 | Gold |
| 161 | 89419 | Gold |
| ************hier werden viele Daten ausgelassen*********|
| 219 | 4466 | Silber |
| 323 | 2880 | Silber |
| 381 | 2756 | Silber |
+----------------+--------+------------------+

Jetzt können wir die aus der obigen Abfrage erhaltene Tabelle als abgeleitete Tabelle verwenden, um zugehörige Abfragen auszuführen und sie zu gruppieren, um die gewünschten Daten zu erhalten. Werfen wir einen Blick auf das folgende SQL, um ein Gefühl dafür zu bekommen:

WÄHLEN 
  Kundengruppe, 
  ANZAHL(cg.Kundengruppe) AS Gruppenanzahl
AUS
  (WÄHLEN 
    Kundennummer,
      ROUND(SUM(Bestellte Menge * Stückpreis)) Verkäufe,
      (FALL
        WENN SUMME(Bestellte Menge * Stückpreis) < 10000, DANN ‚Silber‘
        WENN SUMME(Bestellte Menge * Stückpreis) ZWISCHEN 10000 UND 100000, DANN 'Gold'
        WENN SUMME(Bestellte Menge * Stückpreis) > 100000, DANN 'Platin'
      ENDE) Kundengruppe
  AUS
    Bestelldetails
  INNER JOIN Bestellungen USING (Bestellnummer)
  WO
    JAHR(Versanddatum) = 2018
  GROUP BY Kundennummer) cg
GRUPPE NACH cg.customerGroup;

Ich glaube, dass Sie alle kluge Leute sind, die besser als ich verstehen, was es bedeutet. Deshalb werde ich nicht näher darauf eingehen. Schauen wir uns nun, nachdem wir fertig sind, den Ergebnissatz an:

+---------------+------------+
| Kundengruppe | Gruppenanzahl |
+---------------+------------+
| Gold | 61 |
| Platin | 4 |
| Silber | 8 |
+---------------+------------+
3 Reihen im Set

Okay, lass uns hier aufhören.

Leser, die an weiteren MySQL-bezogenen Inhalten interessiert sind, können sich die folgenden Themen auf dieser Site ansehen: „MySQL-Abfragekenntnisse“, „Zusammenfassung der allgemeinen MySQL-Funktionen“, „MySQL-Protokolloperationskenntnisse“, „Zusammenfassung der MySQL-Transaktionsoperationskenntnisse“, „MySQL-gespeicherte Prozedurkenntnisse“ und „Zusammenfassung der MySQL-Datenbanksperrenkenntnisse“.

Ich hoffe, dass dieser Artikel für jedermann beim Entwurf einer MySQL-Datenbank hilfreich ist.