Summary  
This chapter covers how to use the DISTINCT keyword in SQL to filter out duplicate values in query results, ensuring only unique rows or unique combinations of columns are returned.

General domain of usage  
Database querying

This video walks you through the concept of retrieving unique values from a database using the DISTINCT keyword in SQL. You will see practical examples of how SELECT DISTINCT works, how it filters out duplicate rows, and why retrieving only unique results is important in real-world data analysis. By the end of this video, you will understand when and how to use DISTINCT to get clean, non-redundant data from your tables.

Si noti che l'istruzione `SELECT` restituisce tutte le righe di una determinata colonna. Tuttavia, cosa succede se non sono necessari tutti i valori di una colonna, soprattutto quando sono duplicati, e servono solo **valori unici**?

In questi casi, è utile utilizzare la parola chiave `DISTINCT`, posizionata immediatamente prima dei nomi delle colonne. Vediamo un esempio:

import unittest
import psycopg2
import pandas as pd

class TestTask(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.connection = psycopg2.connect(
            host="localhost",
            user="agent",
            password="qwerty",
            dbname="testdb",
            sslmode="disable"
        )
        cls.cursor = cls.connection.cursor()

    def test_correct_distinct_continents(self):
        """Check that the query returns the correct set of distinct continents from country table."""
        with open("query.sql", "r") as file:
            query = file.read()

        # Get expected distinct continents from the table
        self.cursor.execute("SELECT DISTINCT continent FROM country;")
        expected_rows = self.cursor.fetchall()
        expected_set = set([row[0] for row in expected_rows])

        # Run user's query
        self.cursor.execute(query)
        user_rows = self.cursor.fetchall()
        user_set = set([row[0] for row in user_rows])

        condition = user_set == expected_set
        _dynamic_test(
            self,
            condition,
            "Query returns the correct set of distinct continent values.",
            f"Query did not return the correct set of distinct continent values.\\nExpected: {expected_set}\\nGot: {user_set}"
        )

    def test_query_uses_distinct_keyword(self):
        """Check that the query uses the DISTINCT keyword."""
        with open("query.sql", "r") as file:
            query = file.read()
        condition = "distinct" in query.lower()
        _dynamic_test(
            self,
            condition,
            "Query uses the DISTINCT keyword.",
            "Query does not use the DISTINCT keyword."
        )

    def test_query_selects_continent_column(self):
        """Check that the query selects the continent column."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Accepts "continent" or "(continent)"
        condition = "continent" in query.lower()
        _dynamic_test(
            self,
            condition,
            "Query selects the 'continent' column.",
            "Query does not select the 'continent' column."
        )

    def test_query_from_country_table(self):
        """Check that the query selects from the country table."""
        with open("query.sql", "r") as file:
            query = file.read()
        condition = "from country" in query.lower().replace("\\n", " ").replace("\t", " ")
        _dynamic_test(
            self,
            condition,
            "Query selects from the 'country' table.",
            "Query does not select from the 'country' table."
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

if __name__ == "__main__":
    unittest.main()


test_solution.py

Questo corso è perfetto per principianti pronti a esplorare il mondo di SQL. Che tu stia iniziando a gestire database o desideri utilizzare SQL per i tuoi progetti di sviluppo applicazioni, questo corso copre gli elementi essenziali. Imparerai rapidamente a sfruttare tutto il potenziale di SQL, dalla query e gestione dei dati all'integrazione fluida nelle applicazioni reali. Al termine del corso, avrai la sicurezza e le competenze per risolvere problemi pratici con SQL e migliorare il tuo processo di sviluppo.

In questa sezione, apprenderemo come utilizzare l'istruzione SELECT di SQL per ottenere una singola colonna di una tabella, più colonne di una tabella e tutte le colonne di una tabella. Scopriremo inoltre come restituire valori unici.

In questa sezione, esamineremo come organizzare e dare priorità ai dati restituiti da una query utilizzando la clausola ORDER BY. Inserita alla fine di un'istruzione SELECT, questa clausola consente di ordinare i risultati in base a una o più colonne, sia in ordine crescente che decrescente, permettendo così una presentazione dei dati più significativa e facilmente interpretabile.

In questa sezione, apprenderemo come filtrare i dati restituiti utilizzando la clausola WHERE dell'istruzione SELECT. Impareremo come testare l'uguaglianza, la disuguaglianza, valori maggiori e minori rispetto a determinati intervalli e valori NULL.

In questa sezione, esploreremo come affinare le condizioni di ricerca combinando le clausole WHERE con gli operatori AND e OR. Verrà inoltre illustrato come l'operatore NOT possa essere utilizzato per escludere determinati risultati.

In questa sezione, apprenderemo cosa sono le funzioni di aggregazione in SQL e come utilizzarle per riassumere i dati delle tabelle.

Recupero di Righe Distinte

Soluzione