Summary  
This chapter explains how to use the SQL WHERE clause in a SELECT statement to filter rows based on conditions (e.g., equals, greater than, less than, not equal).

General domain of usage  
Relational database querying

This video demonstrates how to use the WHERE clause in SQL to filter data from a table. You will see how to write a SELECT statement with a WHERE clause, specify conditions for filtering rows, and understand where the WHERE clause fits in the query structure. Real examples using the country table will help you see how to retrieve only the rows that match your criteria, such as selecting countries from a specific continent.

Tietokannoissa taulut sisältävät tyypillisesti suuria määriä dataa. Usein olemme kuitenkin kiinnostuneita hakemaan vain tiettyjä osia tiedoista koko sisällön sijaan. Tämän saavuttamiseksi on määriteltävä tiedonhakua koskevat ehdot, joita kutsutaan suodatuskriteereiksi.

Dataa suodatetaan käyttämällä `WHERE`-lausetta, jossa määritellään hakukriteerit `SELECT`-lauseessa. `WHERE`-lause sijoitetaan välittömästi taulun nimen jälkeen.

Kun määritellään merkkijonon arvo, kuten maan nimi, teksti tulee sulkea yksittäisiin lainausmerkkeihin (`'`).



SELECT name, continent 
FROM country 
WHERE continent='Europe';

`SELECT`-lause hakee 2 saraketta `country`-taulusta ja palauttaa vain rivit, joiden continent-arvo on `'Europe'`.

### Lauseen sijainti

Kun käytetään `ORDER BY`- ja `WHERE`-lauseita, varmistetaan, että `ORDER BY` tulee `WHERE`-lauseen jälkeen.



SELECT capital, continent 
FROM country 
WHERE continent='Asia'
ORDER BY continent DESC;

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_query_returns_correct_rows(self):
        """Check that only countries from 'North America' are returned with correct columns."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Run user query
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        df = pd.DataFrame(rows, columns=columns)

        # Solution dataframe
        self.cursor.execute("""
            SELECT id, name, region FROM country WHERE continent='North America';
        """)
        sol_rows = self.cursor.fetchall()
        sol_columns = [desc[0] for desc in self.cursor.description]
        sol_df = pd.DataFrame(sol_rows, columns=sol_columns)

        # Check matching rows and shape
        condition = df.shape == sol_df.shape and df.equals(sol_df)
        _dynamic_test(
            self,
            condition,
            "Query returns only the correct rows from 'North America' with correct columns.",
            f"Query did not return the correct rows or columns for 'North America'. Expected:\\n{sol_df}\\nGot:\\n{df}"
        )

    def test_column_order_and_names(self):
        """Check that columns are exactly id, name, region (in this order)."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        expected = ["id", "name", "region"]
        condition = columns == expected
        _dynamic_test(
            self,
            condition,
            "Columns are in the correct order: id, name, region.",
            f"Columns are not in the correct order. Expected: {expected}, Got: {columns}"
        )

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

Tämä kurssi sopii erinomaisesti aloittelijoille, jotka haluavat tutustua SQL:n maailmaan. Olitpa vasta aloittamassa tietokantojen hallintaa tai tavoitteena käyttää SQL:ää sovelluskehitysprojekteissasi, kurssi kattaa olennaiset perusteet. Opit nopeasti hyödyntämään SQL:n koko potentiaalia aina tietojen kyselystä ja hallinnasta niiden integrointiin todellisiin sovelluksiin. Kurssin lopussa hallitset käytännön ongelmien ratkaisun SQL:llä ja kehitysprosessisi tehostamisen.

Tässä osiossa opimme käyttämään SQL SELECT -lausetta yksittäisen taulun sarakkeen, useiden taulun sarakkeiden ja kaikkien taulun sarakkeiden hakemiseen. Lisäksi selvitämme, miten palautetaan yksilölliset arvot.

Tässä osiossa tarkastellaan, miten kyselyn palauttamaa dataa voidaan järjestää ja priorisoida ORDER BY -lauseen avulla. Tämä lause sijoitetaan SELECT-lauseen loppuun ja sen avulla tulokset voidaan lajitella yhden tai useamman sarakkeen perusteella joko nousevaan tai laskevaan järjestykseen, mikä mahdollistaa merkityksellisemmän ja helpommin tulkittavan datan esittämisen.

Tässä osiossa opimme, kuinka palautettua dataa suodatetaan SELECT-lauseen WHERE-ehdon avulla. Opimme testaamaan yhtäsuuruutta, erisuuruutta, suurempia ja pienempiä arvoja sekä NULL-arvoja.

Tässä osiossa perehdytään hakuehtojen tarkentamiseen yhdistämällä WHERE-lausekkeita AND- ja OR-operaattoreiden avulla. Lisäksi käsitellään, miten NOT-operaattoria voidaan käyttää tiettyjen tulosten poissulkemiseen.

Tässä osiossa opimme, mitä SQL:n aggregointifunktiot ovat ja miten niitä käytetään taulukoiden tietojen yhteenvedossa.

WHERE-lausekkeen Käyttö

Lauseen sijainti

Ratkaisu