Summary  
This chapter explains how to retrieve a single column from a database table using SQL’s SELECT and FROM clauses.

General domain of usage  
Relational database querying

**SQL** on ohjelmointikieli, jolla käyttäjät voivat olla vuorovaikutuksessa tietokantojen kanssa; sitä käytetään tietokantojen kyselyihin, päivittämiseen ja hallintaan.

Määritelmä

Tietokanta on järjestetty rakenne, joka on suunniteltu tallentamaan, muokkaamaan ja käsittelemään suuria määriä dataa.

### Miksi SQL on tärkeä

SQL on olennainen tietokantojen hallinnassa ja kyselyiden suorittamisessa tehokkaasti. Sitä käytetään laajasti standardoinnin, skaalautuvuuden ja tietojen eheyden varmistamisen vuoksi. SQL:n yhteensopivuus muiden teknologioiden kanssa tekee siitä monipuolisen työkalun erilaisissa sovelluksissa, mahdollistaen reaaliaikaisen datankäsittelyn ja päätöksenteon.

Aloitetaan! Tässä kurssissa työskentelet `country`-tietokannan ja `country`-taulun kanssa. Näet sen koodieditorin oikeassa alakulmassa.

### SQL-syntaksin selitys

Tietojen hakemiseen tietokannasta SQL käyttää `SELECT`-lausetta. Perussyntaksi on seuraava:

- **SELECT**: määrittää haettavat sarakkeet;
- **FROM**: määrittää taulun, josta tiedot haetaan.

Jos halutaan hakea `sample`-sarake taulusta `sample_table`, syntaksi on:

```sql
SELECT sample
FROM sample_table;
```

Seuraava kysely palauttaa kaikki `continent`-sarakkeen arvot taulusta `country`:

Edellinen kysely käytti `SELECT`-lausetta hakemaan **yksittäisen continent-sarakkeen** **country-taulusta**.
On tärkeää huomata, että sarakkeen nimi tulee määrittää heti `SELECT`-avainsanan jälkeen, ja `FROM`-avainsana määrittää taulun nimen, josta tiedot haetaan.

import unittest
import pandas as pd
import sqlite3

class TestTask(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.connection = sqlite3.connect(":memory:")
        cls.cursor = cls.connection.cursor()
        # Create country table and insert test data
        cls.cursor.execute("""
        CREATE TABLE country (
            id INTEGER PRIMARY KEY,
            name TEXT,
            capital TEXT
        );
        """)
        capitals = [
            (1, "Japan", "Tokyo"),
            (2, "Latvia", "Riga"),
            (3, "Mexico", "Mexico City"),
            (4, "Netherlands", "Amsterdam"),
            (5, "Portugal", "Lisbon"),
            (6, "Sweden", "Stockholm"),
            (7, "Ukraine", "Kyiv"),
            (8, "USA", "Washington"),
            (9, "Thailand", "Bangkok"),
            (10, "Paraguay", "Asunción"),
            (11, "Philippines", "Manila"),
            (12, "New Zealand", "Wellington"),
            (13, "Norway", "Oslo"),
            (14, "Monaco", "Monaco"),
            (15, "Malta", "Valletta")
        ]
        cls.cursor.executemany("INSERT INTO country VALUES (?, ?, ?);", capitals)
        cls.connection.commit()

    def test_select_capital_column(self):
        """Check if the query selects only the 'capital' column from 'country' table."""
        with open("query.sql", "r") as file:
            query = file.read()
        try:
            self.cursor.execute(query)
            rows = self.cursor.fetchall()
            columns = [desc[0] for desc in self.cursor.description]
            condition = (columns == ["capital"])
            success_msg = "Query selects only the 'capital' column from 'country' table."
            failure_msg = f"Query should select only the 'capital' column, but got: {columns}"
        except Exception as e:
            condition = False
            success_msg = ""
            failure_msg = f"Query failed to execute: {e}"
        _dynamic_test(self, condition, success_msg, failure_msg)

    def test_capital_column_values(self):
        """Check if all expected capital values are present in the result."""
        with open("query.sql", "r") as file:
            query = file.read()
        expected_capitals = [
            "Tokyo", "Riga", "Mexico City", "Amsterdam", "Lisbon", "Stockholm", "Kyiv", "Washington", "Bangkok", "Asunción", "Manila", "Wellington", "Oslo", "Monaco", "Valletta"
        ]
        try:
            self.cursor.execute(query)
            rows = self.cursor.fetchall()
            result_capitals = [row[0] for row in rows]
            missing = [cap for cap in expected_capitals if cap not in result_capitals]
            condition = (len(missing) == 0)
            success_msg = "All expected capital values are present in the result."
            failure_msg = f"Expected capital(s) not found in result: {missing}"
        except Exception as e:
            condition = False
            success_msg = ""
            failure_msg = f"Query failed to execute: {e}"
        _dynamic_test(self, condition, success_msg, failure_msg)

    def test_row_count_matches(self):
        """Check if the number of rows matches the number of countries in the table."""
        with open("query.sql", "r") as file:
            query = file.read()
        try:
            self.cursor.execute("SELECT COUNT(*) FROM country;")
            expected_count = self.cursor.fetchone()[0]
            self.cursor.execute(query)
            rows = self.cursor.fetchall()
            condition = (len(rows) == expected_count)
            success_msg = "Number of rows matches the number of countries in the table."
            failure_msg = f"Expected {expected_count} rows, but got {len(rows)}."
        except Exception as e:
            condition = False
            success_msg = ""
            failure_msg = f"Query failed to execute: {e}"
        _dynamic_test(self, condition, success_msg, failure_msg)

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

Tutustu SQL:n perusteisiin – tiedon hakemisesta sen integrointiin käytännön sovelluksiin. Olitpa vasta aloittamassa tietokantojen hallintaa tai haluat hyödyntää SQL:ää sovelluskehityksessä, tämä kurssi kattaa olennaiset asiat. Opit nopeasti hyödyntämään SQL:n koko potentiaalia tiedon hakemisesta ja hallinnasta sen sujuvaan integrointiin todellisiin sovelluksiin. Kurssin lopussa hallitset käytännön ongelmien ratkaisun SQL:llä ja kehitysprosessisi tehostuu.

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

Tässä osiossa tarkastellaan, kuinka 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 opitaan suodattamaan palautettuja tietoja SELECT-lauseen WHERE-ehdon avulla. Käsitellään yhtäsuuruuden, erisuuruuden, suurempien ja pienempien arvojen sekä NULL-arvojen testaamista.

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 aggregaattifunktiot ovat ja kuinka niitä käytetään taulukoiden tietojen yhteenvedossa.

Yksittäisten Sarakkeiden Hakeminen

Mikä on SQL?

Tietokanta

Miksi SQL on tärkeä

SQL-syntaksin selitys

Ratkaisu