Jak filtrować wyniki zapytań w PostgreSQL

Chociaż powyższa lista przedstawia niektóre z najczęstszych konstrukcji testowych, istnieje wiele innych operatorów, które dają wyniki logiczne, których można używać w połączeniu z WHERE klauzula.

Przykłady użycia WHERE

Jednym z najczęstszych i najprostszych testów jest równość przy użyciu = operator. Tutaj sprawdzamy, czy każdy wiersz w kliencie tabela ma nazwisko wartość równa Kowalski :

SELECT * FROM customer WHERE last_name = 'Smith';
 

Możemy dodać do tego dodatkowe warunki, aby utworzyć wyrażenia złożone za pomocą operatorów logicznych. W tym przykładzie użyto ORAZ klauzula, aby dodać dodatkowy test przeciwko first_name kolumna. Prawidłowe wiersze muszą spełniać oba podane warunki:

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

Podobnie możemy sprawdzić, czy spełniony jest którykolwiek z szeregu warunków. Tutaj sprawdzamy wiersze z adresu tabeli, aby sprawdzić, czy kod_zip wartość jest równa 60626 lub sąsiedztwo kolumna jest równa ciągowi „Park Rogera”. Używamy dwóch pojedynczych cudzysłowów, aby wskazać, że należy wyszukać dosłowny pojedynczy cudzysłów:

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

IN operator może działać jak porównanie wielu wartości, ujętych w nawiasy. Jeśli istnieje dopasowanie z dowolną z podanych wartości, wyrażenie to PRAWDA :

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

Tutaj sprawdzamy wzorzec ciągu za pomocą LIKE . % działa jako symbol wieloznaczny pasujący do zera lub więcej znaków, więc „Pete”, „Peter” i każdy inny ciąg rozpoczynający się od „Pete” będzie pasował:

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

Moglibyśmy przeprowadzić podobne wyszukiwanie za pomocą ~* operator do sprawdzania dopasowań przy użyciu wyrażeń regularnych POSIX bez względu na wielkość liter. W takim przypadku sprawdzamy, czy wartość last_name zaczyna się od „d” i zawiera podciąg „on”, który pasowałby do nazw takich jak „Dickson”, „Donald” i „Devon”:

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

Możemy sprawdzić, czy numer ulicy znajduje się w bloku 4000 adresów za pomocą BETWEEN i ORAZ operatory do zdefiniowania zakresu włącznie:

SELECT * FROM address WHERE street_number BETWEEN 4000 AND 4999;
 

Tutaj możemy wyświetlić dowolnego klienta wpisy, które mają numery ubezpieczenia społecznego, które nie mają długości 9 cyfr. Używamy LENGTH() operator, aby uzyskać liczbę cyfr w polu i <> aby sprawdzić nierówności:

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

Korzystanie z GRUPA WG klauzula podsumowująca wiele rekordów

GRUPA WG klauzula jest kolejnym bardzo powszechnym sposobem filtrowania wyników poprzez reprezentowanie wielu wyników w jednym wierszu. Podstawowa składnia GROUP BY klauzula wygląda tak:

SELECT <columns> FROM some_table GROUP BY <columns_to_group>
 

Gdy GRUPA WEDŁUG klauzula jest dodawana do instrukcji, mówi PostgreSQL, aby wyświetlić pojedynczy wiersz dla każdej unikalnej wartości dla danej kolumny lub kolumn. Ma to kilka ważnych implikacji.

Ponieważ GROUP BY Klauzula jest sposobem reprezentowania wielu wierszy jako jednego wiersza, PostgreSQL może wykonać zapytanie tylko wtedy, gdy może obliczyć wartość dla każdej kolumny, którą ma wyświetlić. Oznacza to, że każda kolumna zidentyfikowana przez SELECT część oświadczenia musi być:

• zawarte w GROUP BY klauzula gwarantująca, że ​​każdy wiersz ma unikalną wartość
• streszczenie podsumowujące wszystkie wiersze w każdej grupie

Praktycznie rzecz biorąc, oznacza to, że dowolne kolumny w SELECT lista nie jest zawarta w GROUP BY klauzula musi używać funkcji agregującej, aby wygenerować pojedynczy wynik dla kolumny dla każdej grupy.

Przykłady użycia GROUP BY

W przypadku przykładów w tej sekcji załóżmy, że mamy tabelę o nazwie pet które zdefiniowaliśmy i wypełniliśmy w następujący sposób:

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);
 

Najprostsze użycie GROUP BY jest wyświetlenie zakresu unikalnych wartości dla pojedynczej kolumny. Aby to zrobić, użyj tej samej kolumny w SELECT i GRUPA WG . Tutaj widzimy wszystkie kolory użyte w tabeli:

SELECT color FROM pet GROUP BY color;
 

 color-------- black grey brown white orange(5 rows)
 

Gdy przejdziesz poza pojedynczą kolumnę w SELECT lista kolumn, musisz dodać kolumny do GROUP BY lub użyj funkcji agregującej, aby wytworzyć pojedynczą wartość dla reprezentowanej grupy wierszy.

Tutaj dodajemy typ do GRUPA WG klauzula, co oznacza, że ​​każdy wiersz będzie reprezentował unikalną kombinację typ i kolor wartości. Dodajemy również wiek kolumna, podsumowana przez avg() funkcja, aby znaleźć średni wiek każdej z grup:

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)
 

Funkcje agregujące działają równie dobrze z pojedynczą kolumną w GROUP BY klauzula. Tutaj znajdujemy średni wiek każdego rodzaju zwierząt:

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)
 

Jeśli chcemy wyświetlić najstarsze z każdego rodzaju zwierzęcia, możemy zamiast tego użyć max() funkcja na wiek kolumna. GRUPA WG klauzula zwija wyniki do tych samych wierszy co poprzednio, ale nowa funkcja zmienia wynik w drugiej kolumnie:

SELECT type, max(age) AS oldest FROM pet GROUP BY type;
 

  type  | oldest--------+------- rabbit |     8 dog    |     7 cat    |     8(3 rows)
 

Korzystanie z POSIADAJĄC klauzula filtrowania grup rekordów

GRUPA WG klauzula jest sposobem podsumowania danych poprzez zwinięcie wielu rekordów w jeden reprezentatywny wiersz. Ale co, jeśli chcesz zawęzić te grupy na podstawie dodatkowych czynników?

POSIADAJĄC klauzula jest modyfikatorem dla GROUP BY klauzula, która pozwala określić warunki, które każda grupa musi spełnić, aby została uwzględniona w wynikach.

Ogólna składnia wygląda tak:

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

Operacja jest bardzo podobna do GDZIE klauzula, z tą różnicą, że GDZIE filtruje pojedyncze rekordy i HAVING filtruje grupy rekordów.

Przykłady użycia HAVING

Korzystając z tej samej tabeli, którą przedstawiliśmy w poprzedniej sekcji, możemy zademonstrować, jak HAVING klauzula działa.

Tutaj grupujemy wiersze zwierzaka tabela według unikalnych wartości w typ kolumna, znalezienie minimalnej wartości age także. POSIADAJĄC klauzula, a następnie filtruje wyniki, aby usunąć wszystkie grupy, których wiek nie jest większy niż 1:

SELECT type, min(age) AS youngest FROM pet GROUP BY type HAVING min(age) > 1;
 

  type  | youngest--------+---------- rabbit |        4 cat    |        4(2 rows)
 

W tym przykładzie grupujemy wiersze w pet według ich koloru. Następnie filtrujemy grupy, które reprezentują tylko jeden wiersz. Wynik pokazuje nam każdy kolor, który pojawia się więcej niż raz:

SELECT color FROM pet GROUP BY color HAVING count(color) > 1;
 

 color------- black brown(2 rows)
 

Możemy wykonać podobne zapytanie, aby uzyskać kombinacje typ i kolor że tylko jedno zwierzę ma:

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)
 

Korzystanie z LIMIT klauzula określająca maksymalną liczbę rekordów

LIMIT Klauzula oferuje inne podejście do parowania rekordów zwracanych przez zapytanie. Zamiast eliminować wiersze danych na podstawie kryteriów w samym wierszu, LIMIT klauzula określa maksymalną liczbę rekordów zwracanych przez zapytanie.

Podstawowa składnia LIMIT wygląda tak:

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

Tutaj wskazuje maksymalną liczbę wierszy do wyświetlenia z wykonanego zapytania. Jest to często używane w połączeniu z ORDER BY klauzule, aby uzyskać wiersze z najbardziej ekstremalnymi wartościami w określonej kolumnie. Na przykład, aby uzyskać pięć najlepszych wyników na egzaminie, użytkownik może ORDER BY wynik kolumna, a następnie LIMIT wyniki do 5.

Podczas gdy LIMIT domyślnie liczy od góry wyników, opcjonalny OFFSET słowo kluczowe może służyć do przesunięcia pozycji początkowej, której używa. W efekcie pozwala to na stronicowanie wyników, wyświetlając liczbę wyników określoną przez LIMIT a następnie dodając LIMIT numer do OFFSET aby pobrać następującą stronę.

Przykłady użycia LIMIT

Użyjemy zwierzaka tabela z wcześniejszych przykładów w tej sekcji.

Jak wspomniano powyżej, LIMIT jest często łączony z ORDER BY klauzula, aby wyraźnie zdefiniować kolejność wierszy przed wycięciem odpowiedniej liczby. Tutaj sortujemy zwierzę wpisy według ich wiek , od najstarszego do najmłodszego. Następnie używamy LIMIT aby wyświetlić 5 najstarszych zwierząt:

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)
 

Bez ORDER BY klauzula, LIMIT dokona wyboru w całkowicie przewidywalny sposób. Zwracane wyniki mogą wynikać z kolejności wpisów w tabeli lub według indeksów. Nie zawsze jest to złe.

Jeśli potrzebujemy rekordu dla pojedynczego psa w tabeli moglibyśmy skonstruować zapytanie takie jak to. Należy pamiętać, że chociaż wynik może być trudny do przewidzenia, nie jest to wybór losowy i nie należy go w ten sposób używać:

SELECT * FROM pet WHERE type = 'dog' LIMIT 1;
 

 type | name | color | age | id------+------+-------+-----+---- dog  | Spot | brown |   3 |  1(1 row)
 

Możemy użyć OFFSET klauzula dotycząca stronicowania wyników. Dołączamy ORDER BY klauzula określająca konkretną kolejność wyników.

W przypadku pierwszego zapytania ograniczamy wyniki bez określania OFFSET aby zdobyć pierwsze 3 najmłodsze wpisy:

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)
 

Aby otrzymać kolejne 3 najmłodszych, możemy dodać liczbę zdefiniowaną w LIMIT do PRZESUNIĘCIE aby pominąć wyniki, które już pobraliśmy:

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)
 

Jeśli dodamy LIMIT do PRZESUNIĘCIE ponownie otrzymamy kolejne 3 wyniki:

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)
 

To pozwala nam pobierać wiersze danych z zapytania w łatwych do zarządzania porcjach.

Wniosek

Istnieje wiele sposobów filtrowania i ograniczania w inny sposób wyników uzyskiwanych z zapytań. Klauzule takie jak WHERE i POSIADAJĄC ocenić potencjalne wiersze lub grupy wierszy, aby sprawdzić, czy spełniają określone kryteria. GRUPA WG klauzula pomaga podsumować dane, grupując razem rekordy, które mają wspólną wartość co najmniej jednej kolumny. LIMIT klauzula oferuje użytkownikom możliwość ustawienia sztywnego maksimum liczby rekordów do pobrania.

Nauczenie się, jak te klauzule mogą być stosowane pojedynczo lub w połączeniu, pozwoli Ci wyodrębnić określone dane z dużych zbiorów danych. Modyfikatory zapytań i filtry są niezbędne do przekształcania danych znajdujących się w PostgreSQL w przydatne odpowiedzi.