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

Föreställ dig en situation där du behöver **lägga till en kolumn i en befintlig tabell**. Det vore inte lämpligt att ta bort tabellen (särskilt om den redan innehåller data) och sedan skapa en ny tabell och fylla den med data igen.

Därför kommer du i detta kapitel att titta på `ALTER`-operationen.



`ALTER`: Används för att ändra strukturen på befintliga databasobjekt, såsom att lägga till eller ta bort kolumner från en tabell.

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 är detta skriptet för att skapa en tabell från **föregående kapitel**.

Därefter finns två `ALTER`-operationer. Den första operationen lägger till en `price`-kolumn i tabellen och sätter **standardvärdet** till `300` för denna kolumn. Den andra operationen tar bort denna kolumn:



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

Med hjälp av `ALTER`-satsen kan du utföra olika **schema-nivåoperationer** på en tabell, såsom att lägga till eller ta bort begränsningar, byta namn, ändra datatyper samt lägga till eller ta bort index.

Notering

Gå vidare till en annan operation, nämligen insert-operationen.



`INSERT`: Används för att lägga till nya rader i en tabell.

För att använda `INSERT` måste du ange vilka kolumner du vill lägga till värden i.

Här är hur syntaxen för detta kommando ser ut:

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

Detta kodexempel är från föregående kapitel och visar hur man lägger till data i tabellen `library`.

Här är en genomgång:

1. Börja med `INSERT INTO`, följt av tabellnamnet;
2. Ange kolumnnamnen inom parentes;
3. Använd `VALUES` för att lista data i samma ordning som kolumnerna;
4. Säkerställ att datatyperna matchar kolumnerna;
5. Avsluta parentesen och separera rader med kommatecken.

Den generella syntaxen är:

```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

Denna kurs är perfekt för dig som redan har grundläggande kunskaper i SQL och vill fördjupa dig i mer avancerade koncept för att skapa kraftfullare frågor. Under kursens gång kommer du att bekanta dig med gruppering av data och filtrering av grupperad data. Du kommer även att lära dig arbeta med flera tabeller samtidigt, inklusive hur du kombinerar dem. Dessutom kommer du att utforska olika typer av tabelljoiner och hur de tillämpas i praktiken.

I det här avsnittet kommer du att lära dig hur du grupperar och hanterar data effektivt. Vi introducerar operatorn GROUP BY för gruppering av data. Dessutom kommer du att lära dig hur du filtrerar grupperad data med hjälp av operatorn HAVING.

Du kommer att lära dig om nästlade underfrågor, hur de skapas och hur de används effektivt.

Här kommer du att lära dig hur man kombinerar flera tabeller, vilket gör det möjligt att arbeta med en enhetlig tabell och förenkla skapandet av frågor.

Lär dig grunderna i Data Definition Language (DDL) och Data Manipulation Language (DML) i SQL, inklusive hur man skapar, ändrar och tar bort databasobjekt samt hur man infogar, uppdaterar och tar bort data i tabeller.

ALTER- och 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