Introduzione
Per lavorare con i dati in un database, devi essere in grado di recuperare e indirizzare record specifici in modo efficace. Utilizzando clausole di filtraggio all'interno delle tue query, puoi aggiungere criteri specifici per restituire solo i record più rilevanti.
In questa guida, daremo un'occhiata ad alcune delle operazioni di filtraggio più comuni disponibili in PostgreSQL e dimostreremo come usarle per restringere il focus delle tue istruzioni. Mostreremo come testare le caratteristiche all'interno dei singoli record con WHERE clausole, come raggruppare i record per riassumere le informazioni con GROUP BY , come filtrare gruppi di record con HAVING sottoclausola e come impostare il numero massimo di righe restituite con LIMIT clausola.
Utilizzo di WHERE clausola per definire i criteri di corrispondenza
Uno dei modi più comuni e ampiamente utili per indicare i requisiti della query è WHERE clausola. Il WHERE La clausola consente di definire criteri di ricerca effettivi per le istruzioni di query specificando condizioni che devono essere vere per tutti i record corrispondenti.
WHERE le clausole funzionano definendo espressioni booleane che vengono verificate rispetto a ciascuna riga di dati candidata. Se il risultato dell'espressione è false, la riga verrà rimossa dai risultati e non verrà restituita né proseguirà con la fase successiva dell'elaborazione. Se il risultato dell'espressione è vero, soddisfa i criteri della ricerca e continuerà per ogni ulteriore elaborazione come riga candidata.
La sintassi di base di WHERE la clausola si presenta così:
SELECT * FROM my_table WHERE <condition>;
Il <condition> può essere qualsiasi cosa che risulti in un valore booleano. In PostgreSQL, un valore booleano è uno qualsiasi di TRUE , FALSE o NULL .
Le condizioni sono spesso formate utilizzando uno o più dei seguenti operatori:
=:uguale a>:maggiore di<:inferiore a>=:maggiore o uguale a<=:minore o uguale a<>o!=:non ugualeAND:l'operatore logico "e" — unisce due condizioni e restituisceTRUEse entrambe le condizioni sonoTRUEOR:operatore logico "or" — unisce due condizioni e restituisceTRUEse almeno una delle condizioni èTRUEIN:il valore è contenuto nell'elenco, nella serie o nell'intervallo che segueBETWEEN:il valore è contenuto all'interno dell'intervallo i valori minimo e massimo che seguono, inclusiIS NULL:corrisponde se il valore èNULLNOT:nega il valore booleano che segueEXISTS:la query che segue contiene risultatiLIKE:corrisponde a un modello (usando i caratteri jolly%per abbinare 0 o più caratteri e_per abbinare un singolo carattere)LIKE:corrisponde a un modello (usando i caratteri jolly%per abbinare 0 o più caratteri e_per abbinare un singolo carattere), senza distinzione tra maiuscole e minuscoleSIMILAR TO:corrisponde a un modello utilizzando il dialetto delle espressioni regolari di SQL~:corrisponde a un modello utilizzando espressioni regolari POSIX, con distinzione tra maiuscole e minuscole~*:corrisponde a un modello utilizzando espressioni regolari POSIX, senza distinzione tra maiuscole e minuscole!~:non corrisponde a un modello che utilizza espressioni regolari POSIX, con distinzione tra maiuscole e minuscole!~*:non corrisponde a un modello che utilizza espressioni regolari POSIX, senza distinzione tra maiuscole e minuscole
Sebbene l'elenco sopra rappresenti alcuni dei costrutti di test più comuni, ci sono molti altri operatori che producono risultati booleani che possono essere utilizzati insieme a un WHERE clausola.
Esempi che utilizzano WHERE
Uno dei controlli più comuni e diretti è l'uguaglianza, utilizzando il = operatore. Qui controlliamo se ogni riga nel customer la tabella ha un last_name valore uguale a Smith :
SELECT * FROM customer WHERE last_name = 'Smith';
Possiamo aggiungere ulteriori condizioni a questo per creare espressioni composte usando operatori logici. Questo esempio usa AND clausola per aggiungere un test aggiuntivo rispetto a first_name colonna. Le righe valide devono soddisfare entrambe le condizioni indicate:
SELECT * FROM customer WHERE first_name = 'John' AND last_name = 'Smith';
Allo stesso modo, possiamo verificare se una di una serie di condizioni è soddisfatta. Qui controlliamo le righe dall'address tabella per vedere se il zip_code il valore è uguale a 60626 o al neighborhood colonna è uguale alla stringa "Parco di Roger". Usiamo due virgolette singole per indicare che è necessario cercare una virgoletta singola letterale:
SELECT * FROM address WHERE zip_code = '60626' OR neighborhood = 'Roger''s Park';
Il IN l'operatore può funzionare come un confronto tra un numero di valori, racchiusi tra parentesi. Se esiste una corrispondenza con uno qualsiasi dei valori indicati, l'espressione è TRUE :
SELECT * FROM customer WHERE last_name IN ('Smith', 'Johnson', 'Fredrich');
Qui, controlliamo uno schema di stringa usando LIKE . Il % funziona come un carattere jolly che corrisponde a zero o più caratteri, quindi "Pete", "Peter" e qualsiasi altra stringa che inizia con "Pete" corrisponderebbe:
SELECT * FROM customer WHERE last_name LIKE 'Pete%';
Potremmo fare una ricerca simile usando il ~* operatore per verificare le corrispondenze utilizzando le espressioni regolari POSIX indipendentemente dal caso. In questo caso, controlliamo se il valore di last_name inizia con una "d" e contiene la sottostringa "on", che corrisponderebbe a nomi come "Dickson", "Donald" e "Devon":
SELECT * FROM customer WHERE last_name ~* '^D.*on.*';
Possiamo verificare se un numero civico è all'interno del blocco di 4000 indirizzi utilizzando il BETWEEN e AND operatori per definire un intervallo inclusivo:
SELECT * FROM address WHERE street_number BETWEEN 4000 AND 4999;
Qui possiamo visualizzare qualsiasi customer voci che hanno numeri di previdenza sociale che non sono lunghi 9 cifre. Usiamo il LENGTH() operatore per ottenere il numero di cifre nel campo e il <> per verificare la disuguaglianza:
SELECT * FROM customer WHERE LENGTH(SSN) <> 9;
Utilizzando il GROUP BY clausola per riassumere più record
Il GROUP BY La clausola è un altro modo molto comune per filtrare i risultati rappresentando più risultati con una singola riga. La sintassi di base di GROUP BY la clausola si presenta così:
SELECT <columns> FROM some_table GROUP BY <columns_to_group>
Quando un GROUP BY viene aggiunta a un'istruzione, dice a PostgreSQL di visualizzare una singola riga per ogni valore univoco per la colonna o le colonne specificate. Questo ha alcune importanti implicazioni.
Dal momento che il GROUP BY La clausola è un modo per rappresentare più righe come una singola riga, PostgreSQL può eseguire la query solo se è in grado di calcolare un valore per ciascuna delle colonne che ha il compito di visualizzare. Ciò significa che ogni colonna identificata da SELECT parte della dichiarazione deve essere:
- incluso nel
GROUP BYclausola per garantire che ogni riga abbia un valore univoco - astratto per riassumere tutte le righe all'interno di ciascun gruppo
In pratica, questo significa che qualsiasi colonna nel SELECT elenco non incluso nel GROUP BY La clausola deve utilizzare una funzione di aggregazione per produrre un unico risultato per la colonna per ogni gruppo.
Esempi che utilizzano GROUP BY
Per gli esempi in questa sezione, supponiamo di avere una tabella chiamata pet che abbiamo definito e popolato in questo modo:
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);
L'uso più semplice di GROUP BY consiste nel visualizzare l'intervallo di valori univoci per una singola colonna. Per farlo, usa la stessa colonna in SELECT e GROUP BY . Qui vediamo tutti i colori utilizzati nella tabella:
SELECT color FROM pet GROUP BY color;
color-------- black grey brown white orange(5 rows)
Mentre ti sposti oltre una singola colonna in SELECT elenco delle colonne, devi aggiungere le colonne al GROUP BY clausola o utilizzare una funzione di aggregazione per produrre un unico valore per il gruppo di righe rappresentato.
Qui aggiungiamo type al GROUP BY clausola, il che significa che ogni riga rappresenterà una combinazione univoca di type e color valori. Aggiungiamo anche l'age colonna, riassunta da avg() funzione per trovare l'età media di ciascuno dei gruppi:
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)
Le funzioni aggregate funzionano altrettanto bene con una singola colonna nel GROUP BY clausola. Qui troviamo l'età media di ogni tipo di animale:
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)
Se vogliamo visualizzare il più vecchio di ogni tipo di animale, potremmo invece usare il max() funzione sull'age colonna. Il GROUP BY La clausola comprime i risultati nelle stesse righe di prima, ma la nuova funzione altera il risultato nell'altra colonna:
SELECT type, max(age) AS oldest FROM pet GROUP BY type;
type | oldest--------+------- rabbit | 8 dog | 7 cat | 8(3 rows)
Utilizzo di HAVING clausola per filtrare gruppi di record
Il GROUP BY La clausola è un modo per riepilogare i dati comprimendo più record in un'unica riga rappresentativa. Ma cosa succede se desideri restringere questi gruppi in base a fattori aggiuntivi?
Il HAVING La clausola è un modificatore per GROUP BY clausola che consente di specificare le condizioni che ogni gruppo deve soddisfare per essere incluso nei risultati.
La sintassi generale è simile alla seguente:
SELECT <columns> FROM some_table GROUP BY <columns_to_group> HAVING <condition>
L'operazione è molto simile a WHERE clausola, con la differenza che WHERE filtra i singoli record e HAVING filtra i gruppi di record.
Esempi che utilizzano HAVING
Usando la stessa tabella che abbiamo introdotto nell'ultima sezione, possiamo dimostrare come il HAVING la clausola funziona.
Qui, raggruppiamo le righe del pet tabella per valori univoci nel type colonna, trovando il valore minimo di age anche. Il HAVING La clausola filtra quindi i risultati per rimuovere tutti i gruppi in cui l'età non è maggiore di 1:
SELECT type, min(age) AS youngest FROM pet GROUP BY type HAVING min(age) > 1;
type | youngest--------+---------- rabbit | 4 cat | 4(2 rows)
In questo esempio, raggruppiamo le righe in pet dal loro colore. Quindi filtriamo i gruppi che rappresentano solo una singola riga. Il risultato ci mostra ogni colore che appare più di una volta:
SELECT color FROM pet GROUP BY color HAVING count(color) > 1;
color------- black brown(2 rows)
Possiamo eseguire una query simile per ottenere le combinazioni di type e color che ha un solo animale:
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)
Utilizzando il LIMIT clausola per impostare il numero massimo di record
Il LIMIT La clausola offre un approccio diverso per ridurre i record restituiti dalla query. Invece di eliminare le righe di dati in base a criteri all'interno della riga stessa, il LIMIT La clausola imposta il numero massimo di record restituiti da una query.
La sintassi di base di LIMIT assomiglia a questo:
SELECT * FROM my_table LIMIT <num_rows> [OFFSET <num_rows_to_skip>];
Qui, il <num_rows> indica il numero massimo di righe da visualizzare dalla query eseguita. Questo è spesso usato insieme a ORDER BY clausole per ottenere le righe con i valori più estremi in una determinata colonna. Ad esempio, per ottenere i cinque migliori punteggi in un esame, un utente può ORDER BY un score colonna e poi LIMIT i risultati a 5.
Mentre LIMIT conta dall'inizio dei risultati per impostazione predefinita, il OFFSET opzionale la parola chiave può essere utilizzata per compensare la posizione iniziale che utilizza. In effetti, ciò ti consente di impaginare i risultati visualizzando il numero di risultati definito da LIMIT e quindi aggiungendo il LIMIT numero al OFFSET per recuperare la pagina seguente.
Esempi che utilizzano LIMIT
Useremo il pet tabella di prima per gli esempi in questa sezione.
Come accennato in precedenza, LIMIT è spesso combinato con un ORDER BY clausola per definire in modo esplicito l'ordine delle righe prima di affettare il numero appropriato. Qui ordiniamo il pet voci in base alla loro age , dal più vecchio al più giovane. Quindi utilizziamo LIMIT per visualizzare i primi 5 animali più vecchi:
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)
Senza un ORDER BY clausola, LIMIT effettuerà selezioni in modo del tutto prevedibile. I risultati restituiti possono essere effettuati dall'ordine delle voci all'interno della tabella o dagli indici. Questa non è sempre una brutta cosa.
Se abbiamo bisogno di un record per un singolo dog all'interno della tabella, potremmo costruire una query come questa. Tieni presente che, sebbene il risultato possa essere difficile da prevedere, questa non è una selezione casuale e non dovrebbe essere utilizzata come tale:
SELECT * FROM pet WHERE type = 'dog' LIMIT 1;
type | name | color | age | id------+------+-------+-----+---- dog | Spot | brown | 3 | 1(1 row)
Possiamo usare il OFFSET clausola per impaginare i risultati. Includiamo un ORDER BY clausola per definire un ordine specifico per i risultati.
Per la prima query, limitiamo i risultati senza specificare un OFFSET per ottenere le prime 3 voci più giovani:
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)
Per ottenere i prossimi 3 più giovani, possiamo aggiungere il numero definito in LIMIT al OFFSET per saltare i risultati che abbiamo già recuperato:
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)
Se aggiungiamo il LIMIT al OFFSET di nuovo, otterremo i prossimi 3 risultati:
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)
Questo ci consente di recuperare righe di dati da una query in blocchi gestibili.
Conclusione
Esistono molti modi per filtrare e limitare in altro modo i risultati ottenuti dalle query. Clausole come WHERE e HAVING valutare potenziali righe o gruppi di righe per vedere se soddisfano determinati criteri. Il GROUP BY La clausola aiuta a riassumere i dati raggruppando insieme i record che hanno uno o più valori di colonna in comune. Il LIMIT La clausola offre agli utenti la possibilità di impostare un numero massimo di record da recuperare.
Imparare come queste clausole possono essere applicate, singolarmente o in combinazione, ti consentirà di estrarre dati specifici da grandi insiemi di dati. I modificatori di query ei filtri sono essenziali per trasformare i dati che risiedono all'interno di PostgreSQL in risposte utili.
