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

Tenk deg en situasjon der du må **legge til en kolonne i en eksisterende tabell**. Det ville ikke vært riktig å slette tabellen (spesielt hvis den allerede inneholder data) og deretter opprette en ny tabell og fylle den med data på nytt.

Derfor skal du i dette kapittelet se på `ALTER`-operasjonen.



`ALTER`: Brukes til å endre strukturen til eksisterende databaseobjekter, for eksempel ved å legge til eller fjerne kolonner fra en tabell.

Definisjon

```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 ser, er dette skriptet for å opprette en tabell fra **forrige kapittel**.

Deretter følger to `ALTER`-operasjoner. Den første operasjonen legger til en `price`-kolonne i tabellen, og setter **standardverdien** til `300` for denne kolonnen. Den andre operasjonen fjerner denne kolonnen:



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

Ved å bruke `ALTER`-setningen kan du utføre ulike **skjemanivå-operasjoner** på en tabell, som å legge til eller fjerne begrensninger, endre navn, endre datatyper og legge til eller fjerne indekser.

Merk

Gå videre til en annen operasjon, nemlig innsettingsoperasjonen.



`INSERT`: Brukes til å legge til nye rader i en tabell.

For å bruke `INSERT`, må du angi hvilke kolonner du vil legge til verdier i.

Her er hvordan syntaksen for denne setningen ser ut:

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

Dette kodeeksempelet er fra forrige kapittel og viser hvordan man setter inn data i tabellen `library`.

Her er en oversikt:

1. Start med `INSERT INTO`, etterfulgt av tabellnavnet;
2. Angi kolonnenavnene i parentes;
3. Bruk `VALUES` for å liste opp dataene i samme rekkefølge som kolonnene;
4. Sørg for at datatypene samsvarer med kolonnene;
5. Lukk parentesene og skill rader med komma.

Den generelle syntaksen 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 kurset passer for deg som allerede har grunnleggende kunnskap om SQL og ønsker å fordype deg i mer avanserte konsepter for å lage kraftigere spørringer. Gjennom kurset blir du kjent med gruppering av data og filtrering av grupperte data. Du lærer også hvordan du arbeider med flere tabeller samtidig, inkludert hvordan du kombinerer dem. I tillegg utforsker du ulike typer tabellkoblinger og hvordan disse kan brukes i praksis.

I denne delen vil du lære hvordan du grupperer og håndterer data effektivt. Vi introduserer GROUP BY-operatøren for gruppering av data. Du vil også lære hvordan du filtrerer grupperte data ved hjelp av HAVING-operatøren.

Du vil lære om nestede underforespørsler, hvordan de opprettes, og hvordan de brukes effektivt.

Her vil du lære hvordan du kan kombinere flere tabeller, slik at du kan arbeide med en samlet tabell og forenkle opprettelsen av spørringer.

Lær det grunnleggende om Data Definition Language (DDL) og Data Manipulation Language (DML) i SQL, inkludert hvordan man oppretter, endrer og sletter databaseobjekter, samt hvordan man setter inn, oppdaterer og sletter data i tabeller.

ALTER- og INSERT-operasjoner

Instruksjoner

Løsning

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