Summary  
This chapter explains how to retrieve multiple columns from a table by listing their names separated by commas in a SELECT statement.

General domain of usage  
Querying relational databases

## Inspektera tabellen

Låt oss titta närmare på databasen `country`. Denna databas innehåller en enda tabell, även den kallad `country`. Du kommer att undersöka data i denna tabell.

Denna tabell innehåller **15 rader**, som representerar 15 unika poster för olika länder.

Tabellen innehåller **7 kolumner**: `id`, `name`, `continent`, `region`, `SurfaceArea`, `capital` och `population`.

1. `id` - det unika identifieringsnumret för varje post;

2. `name` - landets namn;

3. `continent` - kontinenten där landet är beläget;

4. `region` - den specifika regionen inom kontinenten;

5. `SurfaceArea` - landets totala yta;

6. `capital` - landets huvudstad;

7. `population` - antalet invånare i landet.



## Syntax för att välja flera kolumner

För att hämta flera kolumner används `SELECT`-satsen. Efter `SELECT` listar du de kolumnnamn du vill hämta, separerade med kommatecken.

Syntaxen ser ut så här:

```sql
SELECT column1, column2, column3 
FROM table_name;
```

Här är ett exempel på hur man väljer **tre** kolumner från tabellen `country`:

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_retrieves_correct_columns(self):
        """Check if query retrieves only 'continent' and 'population' columns from 'country'."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0].lower() for desc in self.cursor.description]
        expected_columns = ["continent", "population"]
        condition = columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "The query retrieves only the 'continent' and 'population' columns in the correct order.",
            f"The query should retrieve only the columns 'continent' and 'population' in order, but got: {columns}."
        )

    def test_query_uses_correct_table(self):
        """Check if query returns the expected number of rows from 'country' table (should be 15)."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        condition = len(rows) == 15
        _dynamic_test(
            self,
            condition,
            "The query uses the correct table and returns 15 rows.",
            f"The query should return 15 rows from the 'country' table, but got {len(rows)} rows."
        )

    def test_query_column_separator(self):
        """Check that both columns are selected and separated by a comma in the SELECT clause."""
        with open("query.sql", "r") as file:
            query = file.read().lower().replace("\\n", " ")
        # Find the SELECT ... FROM part
        select_from = query.split("from")[0]
        # Remove SELECT keyword
        select_columns = select_from.replace("select", "").strip()
        # Must contain a comma between 'continent' and 'population'
        has_comma = "," in select_columns
        has_continent = "continent" in select_columns
        has_population = "population" in select_columns
        condition = has_comma and has_continent and has_population
        _dynamic_test(
            self,
            condition,
            "The SELECT clause contains both columns separated by a comma.",
            "The SELECT clause must contain both 'continent' and 'population', separated by a comma."
        )

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 Flera Kolumner

Inspektera tabellen

Syntax för att välja flera kolumner

Lösning