Summary  
This chapter explains how to modify a relational table’s schema with ALTER TABLE (adding or dropping columns with default values) and how to insert one or more rows into a table using INSERT INTO with specified columns and values.  

General domain of usage  
Library database management

Forestil dig en situation, hvor du skal **tilføje en kolonne til en eksisterende tabel**. Det ville ikke være hensigtsmæssigt at slette tabellen (især hvis den allerede indeholder data) og derefter oprette en ny tabel og fylde den med data igen.

Derfor vil du i dette kapitel se på `ALTER`-operationen.



`ALTER`: Bruges til at ændre strukturen af eksisterende databaseobjekter, såsom at tilføje eller fjerne kolonner fra en tabel.

Definition

```sql
CREATE TABLE library (
  id INT PRIMARY KEY,
  title VARCHAR(50) NOT NULL,
  author VARCHAR(50),
  pages INT
);

ALTER TABLE library ADD price DECIMAL DEFAULT 300;

ALTER TABLE library DROP COLUMN price;
```

Som du kan se, er dette scriptet til at oprette en tabel fra **forrige kapitel**.

Dernæst er der to `ALTER`-operationer. Den første operation tilføjer en `price`-kolonne til tabellen og sætter **standardværdien** til `300` for denne kolonne. Den anden operation fjerner denne kolonne:



```sql
ALTER TABLE table_name ADD/DROP column_name DATA_TYPE;
```

Ved hjælp af `ALTER`-sætningen kan du udføre forskellige **skemaniveau-operationer** på en tabel, såsom at tilføje eller fjerne begrænsninger, omdøbe, ændre datatyper samt tilføje eller fjerne indekser.

Bemærk

Gå videre til en anden operation, nemlig indsættelsesoperationen.



`INSERT`: Bruges til at tilføje nye rækker til en tabel.

For at bruge `INSERT` skal du angive, hvilke kolonner du vil tilføje værdier til.

Her er syntaksen for denne erklæring:

```sql
INSERT INTO library (id, title, author, pages) VALUES 
  (1, 'CAMINO GHOSTS', 'John Grisham', 213),
  (2, 'FUNNY STORY', 'Emily Henry', 341);
```

Dette uddrag er fra det forrige kapitel og viser, hvordan man indsætter data i tabellen `library`.

Her er en oversigt:

1. Start med `INSERT INTO` efterfulgt af tabelnavnet;
2. Angiv kolonnenavne i parentes;
3. Brug `VALUES` til at angive dataene i samme rækkefølge som kolonnerne;
4. Sørg for, at datatyperne matcher kolonnerne;
5. Luk parentesen og adskil rækker med kommaer.

Den generelle syntaks er:

```sql
INSERT INTO table_name (column1_name, column2_name) VALUES
  (column1_value, column2_value),
  (column1_value, column2_value),
  ...;
```

import unittest
import psycopg2
import pandas as pd
import re


class TestPostgresQuery(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()

        with open("query.sql", "r") as file:
            full_query = file.read()

        # Execute only the user's part, before the read-only section
        user_query = full_query.split("-- Please do not modify the code below!")[0].strip()
        cls.cursor.execute(user_query)
        cls.connection.commit()

    def test_country_column_added(self):
        """Check if 'country' column was added to employees with correct data type."""
        self.cursor.execute("""
            SELECT column_name, data_type, character_maximum_length
            FROM information_schema.columns
            WHERE table_name = 'employees' AND column_name = 'country';
        """)
        result = self.cursor.fetchone()
        condition = (
            result is not None and
            normalize_text(result[0]) == 'country' and
            normalize_text(result[1]) in ['character varying', 'varchar'] and
            result[2] == 50
        )
        _dynamic_test(
            self,
            condition,
            "'country' column exists with VARCHAR(50) type.",
            "'country' column is missing or has incorrect type/length."
        )

    def test_inserted_rows(self):
        """Check if both specified rows were inserted correctly into employees."""
        self.cursor.execute("SELECT * FROM employees ORDER BY employee_id;")
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        result_df = pd.DataFrame(rows, columns=columns)

        expected_data = [
            {
                'employee_id': 1,
                'first_name': 'Emily',
                'last_name': 'Torres',
                'department': 'Operations',
                'salary': 80000,
                'country': 'United Kingdom'
            },
            {
                'employee_id': 2,
                'first_name': 'David',
                'last_name': 'Bobr',
                'department': 'Engineering',
                'salary': 95000,
                'country': 'Poland'
            }
        ]

        missing_rows = []
        for expected in expected_data:
            subset = {k: expected[k] for k in result_df.columns if k in expected}
            mask = (result_df[list(subset.keys())] == pd.Series(subset)).all(axis=1)
            if not mask.any():
                missing_rows.append(subset)

        condition = len(missing_rows) == 0 and len(result_df) == 2
        failure_msg = (
            "Missing or incorrect rows: " + str(missing_rows)
            if missing_rows
            else "Expected exactly 2 rows in employees table."
        )
        _dynamic_test(
            self,
            condition,
            "Both specified rows are inserted correctly.",
            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

Dette kursus er ideelt for dem, der allerede har et grundlæggende kendskab til SQL og ønsker at fordybe sig i mere avancerede koncepter for at udforme mere kraftfulde forespørgsler. Gennem kurset vil du blive fortrolig med gruppering af data og filtrering af grupperede data. Du vil også lære at arbejde med flere tabeller samtidigt, herunder hvordan de kombineres. Derudover vil du udforske forskellige typer af tabel-joins og hvordan de anvendes i praksis.

I dette afsnit lærer du, hvordan du grupperer og håndterer data effektivt. Vi introducerer GROUP BY-operatoren til gruppering af data. Derudover lærer du, hvordan du filtrerer grupperede data ved hjælp af HAVING-operatoren.

Du vil lære om indlejrede underforespørgsler, hvordan de oprettes, og hvordan de anvendes effektivt.

Her vil du lære, hvordan man kombinerer flere tabeller, hvilket gør det muligt at arbejde med en samlet tabel og forenkle oprettelsen af forespørgsler.

Lær det grundlæggende om Data Definition Language (DDL) og Data Manipulation Language (DML) i SQL, herunder hvordan man opretter, ændrer og sletter databaseobjekter samt indsætter, opdaterer og sletter data i tabeller.

ALTER- og INSERT-Operationer

Instruktioner

Løsning

employee_id	first_name	last_name	department	salary	country
1	Emily	Torres	Operations	80000	United Kingdom
2	David	Bobr	Engineering	95000	Poland