MySQL-Komplettabsturz: Detaillierte Erklärung der Abfragefilterbedingungen

MySQL-Komplettabsturz: Detaillierte Erklärung der Abfragefilterbedingungen

Überblick

In tatsächlichen Geschäftsszenarioanwendungen müssen wir unsere Zieldaten häufig basierend auf den Geschäftsbedingungen abrufen und filtern. Wir nennen diesen Prozess Datenabfragefilterung. Die verschiedenen im Filterprozess verwendeten Bedingungen (wie Datum, Uhrzeit, Benutzer und Status) sind für uns notwendige Schritte, um genaue Daten zu erhalten.

Nur so können wir die erwarteten Ergebnisse erzielen. In diesem Kapitel lernen wir verschiedene Verwendungsmöglichkeiten von Abfragefilterbedingungen in MySQL kennen.

Relationale Operationen

Eine relationale Operation ist eine Where-Anweisung, auf die eine oder n Bedingungen folgen. Daten, die die Bedingungen nach Where erfüllen, werden zurückgegeben, andernfalls werden Daten, die die Bedingungen nicht erfüllen, herausgefiltert. Mit Operatoren sind Operatoren gemeint, die folgende Fälle haben:


Betreiber veranschaulichen
= gleich
<> oder != Ungleich
> Größer als
>= Größer als oder gleich
< Weniger als
<= Kleiner oder gleich

Das grundlegende Syntaxformat relationaler Operationen ist wie folgt:

 wähle cname1, cname2, ... aus tname, wobei die Cname-Operatoren cval sind

=

Fragen Sie die Daten ab, die genau dem dahinter stehenden Wert entsprechen. Wenn es sich um einen Nicht-Werttyp handelt, müssen Sie dem dahinter stehenden Wert Anführungszeichen hinzufügen, wenn es sich jedoch um einen Werttyp handelt, müssen Sie keine Anführungszeichen hinzufügen.

Das Syntaxformat ist wie folgt:

Wählen Sie cname1, cname2, ... aus tname, wobei cname = cval;
mysql> wähle * von Benutzer2;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
+----+-------+-----+----------+-----+
3 Reihen im Set

mysql> wähle * von Benutzer2, wobei Name='Helen';
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 2 | Helen | 20 | Quanzhou | 0 |
+----+-------+-----+----------+-----+
1 Reihe im Set

mysql> wähle * von Benutzer2, wobei Alter=21 ist;
+----+-------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+---------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 3 | Sol | 21 | Xiamen | 0 |
+----+-------+-----+---------+-----+
2 Reihen im Set

Ungleich (<>, !=)

Es gibt zwei Möglichkeiten, „ungleich“ zu schreiben: eine ist <> und die andere ist !=. Sie haben dieselbe Bedeutung und können austauschbar verwendet werden, aber <> erscheint vor !=. Wenn man sich also viele der vorherigen Beispiele ansieht, erscheint <> häufiger und ist portabler, es wird also empfohlen.

Der Zweck von „ungleich“ besteht darin, die Ergebnisse abzufragen, die die Bedingungen nicht erfüllen. Das Format ist wie folgt:

Wählen Sie cname1, cname2, ... aus tname, wobei cname <> cval;
oder wählen Sie cname1, cname2, ... aus tname, wobei cname != cval;

mysql> wähle * von Benutzer2;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
+----+-------+-----+----------+-----+
3 Reihen im Set

mysql> wähle * von Benutzer2, wobei Alter<>20 ist;
+----+-------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+---------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 3 | Sol | 21 | Xiamen | 0 |
+----+-------+-----+---------+-----+
2 Reihen im Set

Größer als oder kleiner als (> <)

Das im Allgemeinen für den Vergleich numerischer Werte, Datumsangaben und Uhrzeiten verwendete Format ist wie folgt:

Wählen Sie cname1, cname2, ... aus tname, wobei cname > cval;

wähle cname1, cname2, ... aus tname, wobei cname < cval;

wähle cname1, cname2, ... aus tname, wobei cname >= cval;

Wählen Sie cname1, cname2, ... aus tname, wobei cname <= cval;
mysql> wähle * von Benutzer2, wobei Alter>20 ist;
+----+-------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+---------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 3 | Sol | 21 | Xiamen | 0 |
+----+-------+-----+---------+-----+
2 Reihen im Set

mysql> wähle * von Benutzer2, wobei Alter>=20;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
+----+-------+-----+----------+-----+
3 Reihen im Set

mysql> wähle * von Benutzer2, wobei Alter <21 ist;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 2 | Helen | 20 | Quanzhou | 0 |
+----+-------+-----+----------+-----+
1 Reihe im Set

mysql> wähle * von Benutzer2, wobei Alter <= 21 ist;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
+----+-------+-----+----------+-----+
3 Reihen im Set

Logische Operationen

Betreiber veranschaulichen
UND Mehrere Bedingungen sind erfüllt
ODER Eine der mehreren Bedingungen ist erfüllt
NICHT Negieren Sie die Bedingung

UND

Wenn zum Filtern von Daten mehrere Bedingungen erforderlich sind, wird diese Methode verwendet. Jeder Ausdruck von und muss wahr sein, und die gefilterten Daten entsprechen den Anforderungen des Benutzers.

Im Folgenden werden Daten herausgefiltert, bei denen sowohl die Alters- als auch die Geschlechtsbedingungen erfüllt sind. Das Syntaxformat lautet wie folgt:

select cname1,cname2,... from tname, wobei die cname1-Operatoren cval1 und die cname2-Operatoren cval2 sind
mysql> wähle * von Benutzer2;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
+----+-------+-----+----------+-----+
4 Reihen im Set

mysql> select * from user2 where age >20 und sex=1;
+----+-------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+---------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 4 | weng | 33 | guizhou | 1 |
+----+-------+-----+---------+-----+
2 Reihen im Set

ODER

Wenn mehrere Bedingungen erfüllt sind, wird die Datenfilterung durchgeführt, solange eine Bedingung erfüllt ist.

Die folgende Bedingung filtert Daten heraus, die älter als 21 und jünger als 21 sind. Das Syntaxformat ist wie folgt:

select cname1,cname2,... from tname where cname1 operators cval1 or cname2 operators cval2
mysql> wähle * von Benutzer2;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
+----+-------+-----+----------+-----+
4 Reihen im Set

mysql> Auswahl * von Benutzer2, wobei Alter>21 oder Alter<21;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 2 | Helen | 20 | Quanzhou | 0 |
| 4 | weng | 33 | guizhou | 1 |
+----+-------+-----+----------+-----+
2 Reihen im Set

NICHT

Negieren Sie eine bestimmte erfüllte Bedingung, und die gefilterten Daten sind das, was der Benutzer benötigt.

Die folgenden Filter sind keine Daten, deren Alter größer als 20 ist. Das Syntaxformat ist wie folgt:

wähle cname1, cname2, ... aus tname, wobei nicht (Cname-Operatoren cval)
mysql> wähle * von Benutzer2;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
+----+-------+-----+----------+-----+
4 Reihen im Set

mysql> wähle * von Benutzer2, wobei nicht (Alter>20);
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 2 | Helen | 20 | Quanzhou | 0 |
+----+-------+-----+----------+-----+
1 Reihe im Set

Fuzzy-Matching

Genau wie bei der Benutzertabelle oben (einschließlich Name, Alter, Adresse und Geschlecht) können wir das Schlüsselwort „like“ verwenden, um Daten unscharf abzugleichen, wenn wir Benutzer abfragen möchten, deren Namen mit „s“ beginnen.

Das Syntaxformat ist wie folgt. Das Muster kann Platzhalter enthalten, von denen es zwei Typen gibt. %: bedeutet, dass ein oder n beliebige Zeichen übereinstimmen; _: bedeutet, dass ein beliebiges Zeichen übereinstimmt.

Wählen Sie cname1, cname2, ... aus tname, wobei cname dem Muster ähnelt;

% Verwenden

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | Selina | 25 | Taiwan | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> select * from user2, wobei der Name wie „s%“ ist;
+----+--------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+---------+-----+
| 3 | Sol | 21 | Xiamen | 0 |
| 5 | Selina | 25 | Taiwan | 0 |
+----+--------+-----+---------+-----+
2 Reihen im Set

Verwendung von _

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | Selina | 25 | Taiwan | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> select * from user2, wobei der Name etwa „s_l“ ist;
+----+------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+------+-----+---------+-----+
| 3 | Sol | 21 | Xiamen | 0 |
+----+------+-----+---------+-----+
1 Reihe im Set

Notiz

1. Verwenden Sie Fuzzy-Matching-Platzhalter nicht zu häufig. Wenn andere Operatoren denselben Zweck erreichen können, sollten Sie andere Operatoren verwenden.

2. Wenn Sie Fuzzy-Matching auf einer großen Tabelle durchführen, versuchen Sie, nicht mit „%“ zu beginnen, wie etwa „%username“, da dies zu einem Tabellenscan und langsamer Effizienz führt. Versuchen Sie, den Anfangsteil der Fuzzy-Suche anzugeben, z. B. mit „Marke%“. Dadurch werden zuerst die Daten gefunden, die mit der Marke beginnen. Das ist wesentlich effizienter.

Bereichswertprüfung

BETWEEN AND (Intervallabfrage)

Der Operator BETWEEN ... AND wählt einen Datenbereich zwischen zwei Werten aus. Diese Werte können Zahlen, Texte oder Datumsangaben sein und gehören zu einer geschlossenen Intervallabfrage.

Die linke Seite val1 und die rechte Seite val2 von und stellen zwei kritische Werte dar, die der mathematischen Formel [val1,val2] entsprechen. Daten, die zu diesen beiden Intervallen gehören, werden herausgefiltert (>=val1 und <=val2), daher ist das Syntaxformat wie folgt:

 wähle cname1, cname2, ... von tname, wobei cname zwischen val1 und val2 liegt;
 Entspricht „selec cname1,cname2,... from tname“, wobei cname >= val1 und cname <= val2;

Abfragedaten mit Alter zwischen [21,25]:

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | Selina | 25 | Taiwan | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> select * from user2, wobei das Alter zwischen 21 und 25 liegt;
+----+--------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+---------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 3 | Sol | 21 | Xiamen | 0 |
| 5 | Selina | 25 | Taiwan | 0 |
+----+--------+-----+---------+-----+
3 Reihen im Set

mysql> wähle * von Benutzer2, wobei Alter >= 21 und Alter <= 25 ist;
+----+--------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+---------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 3 | Sol | 21 | Xiamen | 0 |
| 5 | Selina | 25 | Taiwan | 0 |
+----+--------+-----+---------+-----+
3 Reihen im Set

IN (inklusive Abfrage)

Wenn wir gemäß den obigen Daten die Daten von Benutzern mit Wohnsitz in Fuzhou und Xiamen herausfinden möchten, sollten wir den IN-Operator verwenden, da der IN-Operator es uns ermöglicht, mehrere Werte in der WHERE-Klausel anzugeben. Wenn einer dieser Werte übereinstimmt, ist die Bedingung erfüllt und die Daten werden zurückgegeben.

Das Syntaxformat ist wie folgt. Die Wertetypen in der folgenden Liste müssen konsistent oder kompatibel sein und Platzhalter werden nicht unterstützt:

wähle cname1, cname2, ... aus tname, wobei cname in (val1, val2, ...);
mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | Selina | 25 | Taiwan | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> wähle * von Benutzer2, wobei Adresse in („Fuzhou“, „Xiamen“); ist.
+----+-------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+---------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 3 | Sol | 21 | Xiamen | 0 |
+----+-------+-----+---------+-----+
2 Reihen im Set

NICHT IN (eine Eindämmungsabfrage negieren)

Wir haben oben bereits die Benutzer von not kennengelernt. Testen wir dies, indem wir den Ausdruck negieren, der nach not ausgeführt wird:

mysql> wähle * von Benutzer2;
+----+--------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
| 5 | Selina | 25 | Taiwan | 0 |
+----+--------+-----+----------+-----+
5 Reihen im Set

mysql> wähle * von Benutzer2, wobei die Adresse nicht in („Fuzhou“, „Quanzhou“, „Xiamen“); ist.
+----+--------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+---------+-----+
| 4 | weng | 33 | guizhou | 1 |
| 5 | Selina | 25 | Taiwan | 0 |
+----+--------+-----+---------+-----+
2 Reihen im Set

Nullwertprüfung

IST NULL/IST NICHT NULL

Um festzustellen, ob es leer ist, lautet das Syntaxformat wie folgt. Bitte beachten Sie, dass für Daten mit einem Wert von null verschiedene Vergleichsoperatoren wie „between and“, „in“ und „not in“-Abfragen nicht funktionieren. Nur „is null“ kann es herausfiltern.

 Wählen Sie cname1, cname2, ... aus tname, wobei cname null ist;
 Oder wählen Sie cname1, cname2, ... aus tname, wobei cname nicht null ist;
mysql> select * from user2, wobei die Adresse null ist;
+----+--------+-----+---------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+--------+-----+---------+-----+
| 5 | selina | 25 | NULL | 0 |
+----+--------+-----+---------+-----+
1 Reihe im Set

mysql> select * from user2, wobei die Adresse nicht null ist;
+----+-------+-----+----------+-----+
| ID | Name | Alter | Adresse | Geschlecht |
+----+-------+-----+----------+-----+
| 1 | Marke | 21 | Fuzhou | 1 |
| 2 | Helen | 20 | Quanzhou | 0 |
| 3 | Sol | 21 | Xiamen | 0 |
| 4 | weng | 33 | guizhou | 1 |
+----+-------+-----+----------+-----+
4 Reihen im Set

Es gibt ein Schlüsselwort <=>, das Nullwerturteile enthalten kann, das aber derzeit kaum noch verwendet wird. Wenn Sie interessiert sind, können Sie es sich ansehen. Ich werde hier nicht näher darauf eingehen.

Zusammenfassen

1. Das % im like-Ausdruck entspricht einem bis mehreren beliebigen Zeichen, und _ entspricht einem beliebigen Zeichen

2. Um Nullwerte abzufragen, müssen Sie IS NULL oder IS NOT NULL verwenden. Andere Abfrageoperatoren sind für NULL-Werte ungültig. Obwohl das Platzhalterzeichen % mit allem übereinstimmen kann, können damit keine Daten mit dem Wert NULL übereinstimmen.

3. Es wird empfohlen, beim Erstellen einer Tabelle die Tabellenfelder nicht leer zu lassen und den Feldern einen Standardwert zuzuweisen.

4. MySQL unterstützt die Verwendung von NOT zum Negieren von IN-, BETWEEN- und EXISTS-Klauseln.

Dies ist das Ende dieses Artikels über die Filterbedingungen für Abfragen, die MySQL komplett zum Absturz bringen. Weitere Informationen zu Filterbedingungen für MySQL-Abfragen finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den verwandten Artikeln weiter unten. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!

Das könnte Sie auch interessieren:
  • Der Unterschied und die Gründe zwischen den MySQL-Abfragebedingungen nicht in und in
  • MySQL bedingte Abfrage und/oder Verwendung und Priorität Beispielanalyse
  • Detaillierte Erläuterung des Problems der Übereinstimmung, selbst wenn in der MySQL-Abfragebedingung am Ende der Zeichenfolge ein Leerzeichen steht
  • Detaillierte Erklärung der allgemeinen Verwendung von MySQL-Abfragebedingungen
  • Wird der Index in der MySQL-Abfragebedingung verwendet?
  • MySQL-Abfragemethode mit mehreren Bedingungen

<<:  Aufzeichnung des tatsächlichen Prozesses der Verpackung und Bereitstellung des Vue-Projekts

>>:  So stellen Sie eigenständigen Pulsar und geclustertes Redis mit Docker bereit (Entwicklungsartefakt)

Artikel empfehlen

Detailliertes Beispiel für die Verwendung von Typescript zum Einkapseln von Axios in Vue3

Dieses Axios-Paket wird in der Vue3-Demo verwende...

Installationsprozess von Zabbix-Agent auf Kylin V10

1. Laden Sie das Installationspaket herunter Down...

Linux-Debugging-Tools, die sich Entwickler und Betreiber unbedingt ansehen sollten [Empfohlen]

Der Systemleistungsexperte Brendan D. Gregg hat s...

VMWare15 installiert Mac OS-System (grafisches Tutorial)

Installationsumgebung Windows 10 VMware Workstati...

Docker implementiert das erneute Taggen und Löschen des Images des ursprünglichen Tags

Die Docker-Image-ID ist eindeutig und kann ein Im...

Implementierung der Installation von Docker in einer Win10-Umgebung

1. Rufen Sie die offizielle Docker-Website auf Ge...

Eine kurze Diskussion über die magischen Verwendungsmöglichkeiten von CSS-Pseudoelementen und Pseudoklassen

CSS spielt auf einer Webseite eine sehr wichtige ...

Detaillierte Erklärung der Grundkonzepte von HTML

Was ist HTML? HTML ist eine Sprache zur Beschreib...

Analyse des Prinzips der MySQL-Indexlängenbeschränkung

Dieser Artikel stellt hauptsächlich die Analyse d...

Detaillierte Erläuterung des Prozesses zum Abfragen von Benutzerberechtigungen mithilfe von MySQL-Anweisungen

Wie können Sie in MySQL die Berechtigungen anzeig...

Webdesign-Tutorial (8): Webseitenhierarchie und Raumgestaltung

<br />Vorheriger Artikel: Webdesign-Tutorial...

Docker legt Port 2375 frei, was zu Serverangriffen und -lösungen führt

Ich glaube, dass Studenten, die etwas über die Do...

Anwendungsbeispiele für den Mysql Inner Join (unbedingt lesen)

Grammatikregeln SELECT Spaltenname(n) FROM Tabell...

Vue-Router-Verlaufsmodus, serverseitiger Konfigurationsprozess-Datensatz

Geschichtsroute Der Verlaufsmodus bezieht sich au...

Implementierungscode der CSS-Formularvalidierungsfunktion

Rendern Prinzip Im Formularelement gibt es ein Mu...