PostgreSQL
 sql >> Datenbank >  >> RDS >> PostgreSQL

So filtern Sie Abfrageergebnisse in PostgreSQL


Einführung

Um mit Daten in einer Datenbank arbeiten zu können, müssen Sie in der Lage sein, bestimmte Datensätze effektiv abzurufen und zu zielen. Durch die Verwendung von Filterklauseln in Ihren Abfragen können Sie bestimmte Kriterien hinzufügen, um nur die relevantesten Datensätze zurückzugeben.

In diesem Leitfaden werfen wir einen Blick auf einige der gängigsten Filteroperationen, die in PostgreSQL verfügbar sind, und zeigen, wie Sie sie verwenden können, um den Fokus Ihrer Anweisungen einzugrenzen. Wir zeigen, wie man mit WHERE auf Merkmale innerhalb einzelner Datensätze testet Klauseln, wie Datensätze gruppiert werden, um Informationen mit GROUP BY zusammenzufassen , wie man Gruppen von Datensätzen mit dem HAVING filtert Unterklausel und wie man die maximale Anzahl der zurückgegebenen Zeilen mit LIMIT festlegt Klausel.



Using the WHERE -Klausel zum Definieren von Übereinstimmungskriterien

Eine der gebräuchlichsten und allgemein nützlichsten Möglichkeiten, Ihre Abfrageanforderungen anzugeben, ist WHERE Klausel. Das WHERE Mit der Klausel können Sie tatsächliche Suchkriterien für Abfrageanweisungen definieren, indem Sie Bedingungen angeben, die für alle übereinstimmenden Datensätze wahr sein müssen.

WHERE Klauseln funktionieren, indem sie boolesche Ausdrücke definieren, die mit jeder in Frage kommenden Datenzeile geprüft werden. Wenn das Ergebnis des Ausdrucks falsch ist, wird die Zeile aus den Ergebnissen entfernt und nicht zurückgegeben oder mit der nächsten Verarbeitungsstufe fortgesetzt. Wenn das Ergebnis des Ausdrucks wahr ist, erfüllt er die Kriterien der Suche und wird für jede weitere Verarbeitung als Kandidatenzeile fortgesetzt.

Die grundlegende Syntax von WHERE Klausel sieht so aus:

SELECT * FROM my_table WHERE <condition>;

Der <condition> kann alles sein, was zu einem booleschen Wert führt. In PostgreSQL ist ein boolescher Wert TRUE , FALSE , oder NULL .

Bedingungen werden oft mit einem oder mehreren der folgenden Operatoren gebildet:

  • = :gleich
  • > :größer als
  • < :kleiner als
  • >= :größer oder gleich
  • <= :kleiner oder gleich
  • <> oder != :nicht gleich
  • AND :Der logische „und“-Operator – verbindet zwei Bedingungen und gibt TRUE zurück wenn beide Bedingungen TRUE sind
  • OR :logischer „oder“-Operator – verbindet zwei Bedingungen und gibt TRUE zurück wenn mindestens eine der Bedingungen TRUE ist
  • IN :Wert ist in der folgenden Liste, Reihe oder Bereich enthalten
  • BETWEEN :Der Wert ist im Bereich der folgenden Mindest- und Höchstwerte enthalten, einschließlich
  • IS NULL :passt, wenn der Wert NULL ist
  • NOT :negiert den folgenden booleschen Wert
  • EXISTS :Die folgende Abfrage enthält Ergebnisse
  • LIKE :Gleicht mit einem Muster ab (unter Verwendung der Platzhalter % um 0 oder mehr Zeichen zu finden und _ um ein einzelnes Zeichen zu finden)
  • ILIKE :Gleicht mit einem Muster ab (unter Verwendung der Platzhalter % um 0 oder mehr Zeichen zu finden und _ um ein einzelnes Zeichen abzugleichen), Groß-/Kleinschreibung wird nicht beachtet
  • SIMILAR TO :Gleicht mit einem Muster ab, das den regulären Ausdrucksdialekt von SQL verwendet
  • ~ :Übereinstimmung mit einem Muster unter Verwendung regulärer POSIX-Ausdrücke, Groß-/Kleinschreibung beachten
  • ~* :Übereinstimmung mit einem Muster unter Verwendung regulärer POSIX-Ausdrücke, Groß-/Kleinschreibung nicht beachten
  • !~ :stimmt nicht mit einem Muster überein, das reguläre POSIX-Ausdrücke verwendet, Groß- und Kleinschreibung beachten
  • !~* :stimmt nicht mit einem Muster überein, das reguläre POSIX-Ausdrücke verwendet, Groß-/Kleinschreibung wird nicht beachtet

Während die obige Liste einige der gebräuchlichsten Testkonstrukte darstellt, gibt es viele andere Operatoren, die boolesche Ergebnisse liefern, die in Verbindung mit einem WHERE verwendet werden können Klausel.


Beispiele mit WHERE

Eine der gebräuchlichsten und einfachsten Prüfungen ist die Gleichheit mit = Operator. Hier prüfen wir, ob jede Zeile im customer Tabelle hat einen last_name Wert gleich Smith :

SELECT * FROM customer WHERE last_name = 'Smith';

Wir können zusätzliche Bedingungen hinzufügen, um zusammengesetzte Ausdrücke mit logischen Operatoren zu erstellen. Dieses Beispiel verwendet das AND -Klausel, um einen zusätzlichen Test für first_name hinzuzufügen Säule. Gültige Zeilen müssen beide gegebenen Bedingungen erfüllen:

SELECT * FROM customer WHERE first_name = 'John' AND last_name = 'Smith';

Ebenso können wir prüfen, ob eine Reihe von Bedingungen erfüllt sind. Hier überprüfen wir Zeilen von address Tabelle, um zu sehen, ob die zip_code Wert ist gleich 60626 oder neighborhood Spalte ist gleich der Zeichenfolge "Roger's Park". Wir verwenden zwei einfache Anführungszeichen, um anzuzeigen, dass nach einem wörtlichen einfachen Anführungszeichen gesucht werden soll:

SELECT * FROM address WHERE zip_code = '60626' OR neighborhood = 'Roger''s Park';

Der IN Der Operator kann wie ein Vergleich zwischen einer Reihe von Werten funktionieren, die in Klammern eingeschlossen sind. Wenn es eine Übereinstimmung mit einem der angegebenen Werte gibt, ist der Ausdruck TRUE :

SELECT * FROM customer WHERE last_name IN ('Smith', 'Johnson', 'Fredrich');

Hier prüfen wir mit LIKE gegen ein Zeichenfolgenmuster . Der % funktioniert als Platzhalter, der mit null oder mehr Zeichen übereinstimmt, also würden "Pete", "Peter" und jede andere Zeichenfolge, die mit "Pete" beginnt, passen:

SELECT * FROM customer WHERE last_name LIKE 'Pete%';

Wir könnten eine ähnliche Suche mit ~* durchführen -Operator, um mit regulären POSIX-Ausdrücken ohne Rücksicht auf Groß- und Kleinschreibung nach Übereinstimmungen zu suchen. In diesem Fall prüfen wir, ob der Wert von last_name beginnt mit einem „d“ und enthält den Teilstring „on“, der Namen wie „Dickson“, „Donald“ und „Devon“ entsprechen würde:

SELECT * FROM customer WHERE last_name ~* '^D.*on.*';

Mit dem BETWEEN können wir prüfen, ob eine Hausnummer innerhalb des 4000er Adressblocks liegt und AND Operatoren zum Definieren eines inklusiven Bereichs:

SELECT * FROM address WHERE street_number BETWEEN 4000 AND 4999;

Hier können wir beliebige customer anzeigen Einträge mit Sozialversicherungsnummern, die nicht 9-stellig sind. Wir verwenden die LENGTH() -Operator, um die Anzahl der Ziffern im Feld und den <> zu erhalten um auf Ungleichheit zu prüfen:

SELECT * FROM customer WHERE LENGTH(SSN) <> 9;



Verwendung von GROUP BY -Klausel, um mehrere Datensätze zusammenzufassen

Die GROUP BY -Klausel ist eine weitere sehr gebräuchliche Methode zum Filtern von Ergebnissen, indem mehrere Ergebnisse in einer einzigen Zeile dargestellt werden. Die grundlegende Syntax von GROUP BY Klausel sieht so aus:

SELECT <columns> FROM some_table GROUP BY <columns_to_group>

Wenn ein GROUP BY -Klausel zu einer Anweisung hinzugefügt wird, weist sie PostgreSQL an, eine einzelne Zeile für jeden eindeutigen Wert für die angegebene Spalte oder Spalten anzuzeigen. Dies hat einige wichtige Auswirkungen.

Da die GROUP BY -Klausel eine Möglichkeit ist, mehrere Zeilen als eine einzelne Zeile darzustellen, kann PostgreSQL die Abfrage nur ausführen, wenn es einen Wert für jede der anzuzeigenden Spalten berechnen kann. Das bedeutet, dass jede Spalte durch den SELECT identifiziert wird Teil der Anweisung muss entweder sein:

  • im GROUP BY enthalten -Klausel, um sicherzustellen, dass jede Zeile einen eindeutigen Wert hat
  • abstrahiert, um alle Zeilen innerhalb jeder Gruppe zusammenzufassen

Praktisch bedeutet dies, dass beliebige Spalten in der SELECT Liste nicht in GROUP BY enthalten -Klausel muss eine Aggregatfunktion verwenden, um ein einzelnes Ergebnis für die Spalte für jede Gruppe zu erzeugen.


Beispiele mit GROUP BY

Nehmen wir für die Beispiele in diesem Abschnitt an, dass wir eine Tabelle namens pet haben die wir wie folgt definiert und ausgefüllt haben:

CREATE TABLE pet (    id SERIAL PRIMARY KEY,    type TEXT,    name TEXT,    color TEXT,    age INT);INSERT INTO pet (type, name, color, age) VALUES('dog', 'Spot', 'brown', 3),('dog', 'Rover', 'black', 7),('dog', 'Sally', 'brown', 1),('cat', 'Sabrina', 'black', 8),('cat', 'Felix', 'white', 4),('cat', 'Simon', 'orange', 8),('rabbit', 'Buttons', 'grey', 4),('rabbit', 'Bunny', 'brown', 8),('rabbit', 'Briony', 'brown', 6);

Die einfachste Verwendung von GROUP BY soll den Bereich der eindeutigen Werte für eine einzelne Spalte anzeigen. Verwenden Sie dazu dieselbe Spalte in SELECT und GROUP BY . Hier sehen wir alle in der Tabelle verwendeten Farben:

SELECT color FROM pet GROUP BY color;
 
 color-------- black grey brown white orange(5 rows)

Wenn Sie in SELECT über eine einzelne Spalte hinausgehen Spaltenliste, müssen Sie die Spalten entweder zur GROUP BY hinzufügen -Klausel oder verwenden Sie eine Aggregatfunktion, um einen einzelnen Wert für die dargestellte Gruppe von Zeilen zu erzeugen.

Hier fügen wir type hinzu zu GROUP BY -Klausel, was bedeutet, dass jede Zeile eine eindeutige Kombination von type darstellt und color Werte. Wir fügen auch das age hinzu Spalte, zusammengefasst durch avg() Funktion, um das Durchschnittsalter jeder der Gruppen zu ermitteln:

SELECT type, color, avg(age) AS average_age FROM pet GROUP BY type, color;
 
  type  | color  |     average_age--------+--------+-------------------- rabbit | brown  | 7.0000000000000000 cat    | black  | 8.0000000000000000 rabbit | grey   | 4.0000000000000000 dog    | black  | 7.0000000000000000 dog    | brown  | 2.0000000000000000 cat    | orange | 8.0000000000000000 cat    | white  | 4.0000000000000000(7 rows)

Aggregatfunktionen funktionieren genauso gut mit einer einzelnen Spalte in GROUP BY Klausel. Hier finden wir das Durchschnittsalter jeder Tierart:

SELECT type, avg(age) AS average_age FROM PET GROUP BY type;
 
  type  |     average_age--------+-------------------- rabbit | 6.0000000000000000 dog    | 3.6666666666666667 cat    | 6.6666666666666667(3 rows)

Wenn wir das älteste jeder Tierart anzeigen möchten, könnten wir stattdessen max() verwenden Funktion auf dem age Säule. Die GROUP BY -Klausel reduziert die Ergebnisse in denselben Zeilen wie zuvor, aber die neue Funktion ändert das Ergebnis in der anderen Spalte:

SELECT type, max(age) AS oldest FROM pet GROUP BY type;
 
  type  | oldest--------+------- rabbit |     8 dog    |     7 cat    |     8(3 rows)



Using the HAVING -Klausel zum Filtern von Datensatzgruppen

Die GROUP BY -Klausel ist eine Möglichkeit, Daten zusammenzufassen, indem mehrere Datensätze in einer einzigen repräsentativen Zeile zusammengefasst werden. Was aber, wenn Sie diese Gruppen basierend auf zusätzlichen Faktoren eingrenzen möchten?

Das HAVING -Klausel ist ein Modifikator für GROUP BY -Klausel, mit der Sie Bedingungen angeben können, die jede Gruppe erfüllen muss, um in die Ergebnisse aufgenommen zu werden.

Die allgemeine Syntax sieht folgendermaßen aus:

SELECT <columns> FROM some_table GROUP BY <columns_to_group> HAVING <condition>

Die Operation ist der WHERE sehr ähnlich -Klausel, mit dem Unterschied, dass WHERE filtert einzelne Datensätze und HAVING Filtert Gruppen von Datensätzen.


Beispiele mit HAVING

Unter Verwendung derselben Tabelle, die wir im letzten Abschnitt eingeführt haben, können wir demonstrieren, wie das HAVING Klausel funktioniert.

Hier gruppieren wir die Zeilen des pet Tabelle nach eindeutigen Werten im type Spalte, um den Mindestwert von age zu finden auch. Das HAVING -Klausel filtert dann die Ergebnisse, um alle Gruppen zu entfernen, deren Alter nicht größer als 1 ist:

SELECT type, min(age) AS youngest FROM pet GROUP BY type HAVING min(age) > 1;
 
  type  | youngest--------+---------- rabbit |        4 cat    |        4(2 rows)

In diesem Beispiel gruppieren wir die Zeilen in pet durch ihre Farbe. Wir filtern dann die Gruppen, die nur eine einzelne Zeile darstellen. Das Ergebnis zeigt uns jede Farbe, die mehr als einmal vorkommt:

SELECT color FROM pet GROUP BY color HAVING count(color) > 1;
 
 color------- black brown(2 rows)

Wir können eine ähnliche Abfrage durchführen, um die Kombinationen von type zu erhalten und color die nur ein einzelnes Tier hat:

SELECT type, color FROM pet GROUP BY type, color HAVING count(color) = 1;
 
  type  | color--------+-------- cat    | black rabbit | grey dog    | black cat    | orange cat    | white(5 rows)



Verwendung von LIMIT -Klausel, um die maximale Anzahl von Datensätzen festzulegen

Das LIMIT -Klausel bietet einen anderen Ansatz zum Reduzieren der Datensätze, die Ihre Abfrage zurückgibt. Anstatt Datenzeilen basierend auf Kriterien innerhalb der Zeile selbst zu eliminieren, wird das LIMIT -Klausel legt die maximale Anzahl von Datensätzen fest, die von einer Abfrage zurückgegeben werden.

Die grundlegende Syntax von LIMIT sieht so aus:

SELECT * FROM my_table LIMIT <num_rows> [OFFSET <num_rows_to_skip>];

Hier der <num_rows> gibt die maximale Anzahl der anzuzeigenden Zeilen aus der ausgeführten Abfrage an. Dies wird oft in Verbindung mit ORDER BY verwendet -Klauseln, um die Zeilen mit den extremsten Werten in einer bestimmten Spalte zu erhalten. Um beispielsweise die fünf besten Ergebnisse bei einer Prüfung zu erhalten, könnte ein Benutzer ORDER BY verwenden eine score Spalte und dann LIMIT die Ergebnisse bis 5.

Während LIMIT zählt standardmäßig von oben in den Ergebnissen, der optionale OFFSET Schlüsselwort kann verwendet werden, um die verwendete Startposition zu versetzen. Dadurch können Sie durch die Ergebnisse paginieren, indem Sie die durch LIMIT definierte Anzahl von Ergebnissen anzeigen und dann LIMIT hinzufügen Nummer zum OFFSET um die folgende Seite abzurufen.


Beispiele mit LIMIT

Wir werden das pet verwenden Tabelle von früher für die Beispiele in diesem Abschnitt.

Wie oben erwähnt, LIMIT wird oft mit einem ORDER BY kombiniert -Klausel, um die Reihenfolge der Zeilen explizit zu definieren, bevor die entsprechende Zahl geschnitten wird. Hier sortieren wir das pet Einträge nach ihrem age , vom Ältesten zum Jüngsten. Wir verwenden dann LIMIT um die 5 ältesten Tiere anzuzeigen:

SELECT * FROM pet ORDER BY age DESC LIMIT 5;
 
  type  |  name   | color  | age | id--------+---------+--------+-----+---- cat    | Simon   | orange |   8 |  6 cat    | Sabrina | black  |   8 |  4 rabbit | Bunny   | brown  |   8 |  8 dog    | Rover   | black  |   7 |  2 rabbit | Briany  | brown  |   6 |  9(5 rows)

Ohne ORDER BY Klausel, LIMIT wird eine Auswahl auf völlig vorhersehbare Weise treffen. Die zurückgegebenen Ergebnisse können durch die Reihenfolge der Einträge innerhalb der Tabelle oder durch Indizes bewirkt werden. Das ist nicht immer schlecht.

Wenn wir einen Datensatz für einen einzelnen dog benötigen Innerhalb der Tabelle könnten wir eine Abfrage wie diese konstruieren. Beachten Sie, dass das Ergebnis zwar schwer vorherzusagen ist, dies jedoch keine zufällige Auswahl ist und nicht als solche verwendet werden sollte:

SELECT * FROM pet WHERE type = 'dog' LIMIT 1;
 
 type | name | color | age | id------+------+-------+-----+---- dog  | Spot | brown |   3 |  1(1 row)

Wir können den OFFSET verwenden -Klausel, um durch die Ergebnisse zu paginieren. Wir fügen einen ORDER BY hinzu -Klausel, um eine bestimmte Reihenfolge für die Ergebnisse zu definieren.

Bei der ersten Abfrage schränken wir die Ergebnisse ein, ohne einen OFFSET anzugeben um die ersten 3 jüngsten Einträge zu erhalten:

SELECT * FROM pet ORDER BY age LIMIT 3;
 
 type | name  | color | age | id------+-------+-------+-----+---- dog  | Sally | brown |   1 |  3 dog  | Spot  | brown |   3 |  1 cat  | Felix | white |   4 |  5(3 rows)

Um die nächsten 3 Jüngsten zu erhalten, können wir die in LIMIT definierte Zahl hinzufügen zum OFFSET um die bereits abgerufenen Ergebnisse zu überspringen:

SELECT * FROM pet ORDER BY age LIMIT 3 OFFSET 3;
 
  type  |  name   | color | age | id --------+---------+-------+-----+---- rabbit | Buttons | grey  |   4 |  7 rabbit | Briany  | brown |   6 |  9 dog    | Rover   | black |   7 |  2(3 rows)

Wenn wir das LIMIT hinzufügen zum OFFSET wieder erhalten wir die nächsten 3 Ergebnisse:

SELECT * FROM pet ORDER BY age LIMIT 3 OFFSET 6;
 
  type  |  name   | color  | age | id--------+---------+--------+-----+---- cat    | Simon   | orange |   8 |  6 rabbit | Bunny   | brown  |   8 |  8 cat    | Sabrina | black  |   8 |  4(3 rows)

Dadurch können wir Datenzeilen aus einer Abfrage in überschaubaren Blöcken abrufen.




Fazit

Es gibt viele Möglichkeiten, die Ergebnisse, die Sie aus Abfragen erhalten, zu filtern und anderweitig einzuschränken. Klauseln wie WHERE und HAVING Bewerten Sie potenzielle Zeilen oder Gruppen von Zeilen, um festzustellen, ob sie bestimmte Kriterien erfüllen. Die GROUP BY -Klausel hilft Ihnen, Daten zusammenzufassen, indem Datensätze gruppiert werden, die einen oder mehrere gemeinsame Spaltenwerte haben. Das LIMIT -Klausel bietet Benutzern die Möglichkeit, ein festes Maximum für die Anzahl der abzurufenden Datensätze festzulegen.

Wenn Sie lernen, wie diese Klauseln einzeln oder in Kombination angewendet werden können, können Sie spezifische Daten aus großen Datensätzen extrahieren. Abfragemodifikatoren und -filter sind unerlässlich, um die in PostgreSQL enthaltenen Daten in nützliche Antworten umzuwandeln.