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** är ett programmeringsspråk för användarinteraktion med databaser, som används för att fråga, uppdatera och hantera databaser.

Definition

En databas är en organiserad struktur utformad för att lagra, ändra och bearbeta stora mängder data.

### Varför SQL är viktigt

SQL är avgörande för att effektivt hantera och fråga databaser. Det används i stor utsträckning tack vare sin standardisering, skalbarhet och förmåga att säkerställa dataintegritet. SQL:s integration med andra teknologier gör det till ett mångsidigt verktyg i olika applikationer, och stödjer realtidsdatabearbetning och beslutsfattande.

Nu börjar vi! I denna kurs kommer du att arbeta med en `country`-databas som innehåller en `country`-tabell. Du kan se den under kodeditorn i det högra nedre hörnet.

### Förklaring av SQL-syntax

För att hämta data från en databas används SQL-satsen `SELECT`. Grundläggande syntax:

- **SELECT**: anger vilka kolumner som ska hämtas;
- **FROM**: anger tabellen från vilken data ska hämtas.

För att hämta kolumnen `sample` från tabellen `sample_table` används följande syntax:

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

Följande fråga returnerar alla poster i kolumnen `continent` från tabellen `country`: 

Föregående fråga använde `SELECT` för att hämta en **enskild kolumn, continent**, från **country-tabellen**.
Det är viktigt att ange kolumnnamnet direkt efter nyckelordet `SELECT`, och nyckelordet `FROM` anger namnet på tabellen från vilken vi vill hämta data.

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

Utforska grunderna i SQL – från att hämta data till att integrera det i verkliga applikationer. Oavsett om du precis har börjat med databashantering eller vill använda SQL i dina utvecklingsprojekt, täcker denna kurs det väsentliga. Du lär dig snabbt att utnyttja SQL:s fulla potential, från att fråga och hantera data till att sömlöst integrera det i praktiska tillämpningar. Vid kursens slut har du självförtroendet och färdigheterna att lösa praktiska problem med SQL och förbättra din utvecklingsprocess.

I det här avsnittet kommer vi att lära oss hur man använder SQL SELECT-satsen för att hämta en enskild tabellkolumn, flera tabellkolumner och alla tabellkolumner. Vi kommer även att ta reda på hur man returnerar unika värden.

I det här avsnittet kommer vi att utforska hur man organiserar och prioriterar data som returneras av en fråga med hjälp av ORDER BY-satsen. Denna sats placeras i slutet av en SELECT-sats och gör det möjligt att sortera resultaten efter en eller flera kolumner, antingen i stigande eller fallande ordning, vilket ger ett mer meningsfullt och lättolkad datautmatning.

I det här avsnittet kommer vi att lära oss hur man filtrerar returnerad data med hjälp av SELECT-satsens WHERE-villkor. Vi kommer att gå igenom hur man testar för likhet, olikhet, större än och mindre än värdeintervall samt NULL-värden.

I det här avsnittet utforskar vi hur du kan förfina dina sökvillkor genom att kombinera WHERE-satser med operatorerna AND och OR. Vi går även igenom hur operatorn NOT kan användas för att exkludera vissa resultat.

I det här avsnittet kommer vi att lära oss vad SQL:s aggregatfunktioner är och hur de används för att sammanfatta tabelldata.

Hämta Enskilda Kolumner

Vad är SQL?

Databas

Varför SQL är viktigt

Förklaring av SQL-syntax

Lösning