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

Imagine uma situação em que seja necessário **adicionar uma coluna a uma tabela existente**. Não seria adequado excluir a tabela (especialmente se ela já contém dados) e então criar uma nova tabela, preenchendo-a novamente com dados.

Portanto, neste capítulo, será apresentada a operação `ALTER`.



`ALTER`: Utilizada para modificar a estrutura de objetos existentes no banco de dados, como adicionar ou remover colunas de uma tabela.

Definição

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

Como pode ser visto, este é o script para criar uma tabela do **capítulo anterior**.

Em seguida, há duas operações `ALTER`. A primeira operação adiciona uma coluna `price` à tabela, definindo o **valor padrão** como `300` para esta coluna. A segunda operação remove essa coluna:



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

Usando a instrução `ALTER`, é possível realizar várias **operações em nível de esquema** em uma tabela, como adicionar ou remover restrições, renomear, alterar tipos de dados e adicionar ou remover índices.

Nota

Avançando para outra operação, a operação de inserção.



`INSERT`: Utilizado para adicionar novas linhas a uma tabela.

Para utilizar o `INSERT`, é necessário especificar em quais colunas deseja adicionar valores.

Veja como é a sintaxe desta instrução:

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

Este trecho é do capítulo anterior e mostra como inserir dados na tabela `library`.

Veja a explicação:

1. Comece com `INSERT INTO`, seguido do nome da tabela;
2. Especifique os nomes das colunas entre parênteses;
3. Utilize `VALUES` para listar os dados na mesma ordem das colunas;
4. Certifique-se de que os tipos de dados correspondam às colunas;
5. Feche os parênteses e separe as linhas com vírgulas.

A sintaxe geral é:

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

**Não se esqueça do ponto e vírgula no final!**

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

Este curso é ideal para quem já possui conhecimentos básicos de SQL e deseja aprofundar-se em conceitos mais avançados para criar consultas mais poderosas. Ao longo do curso, você se familiarizará com o agrupamento de dados e a filtragem de dados agrupados. Você também aprenderá a trabalhar com várias tabelas simultaneamente, incluindo como combiná-las. Além disso, explorará diferentes tipos de junções de tabelas e como aplicá-las na prática.

Nesta seção, você aprenderá como agrupar e gerenciar dados de forma eficaz. Será apresentado o operador GROUP BY para agrupamento de dados. Além disso, você aprenderá a filtrar dados agrupados utilizando o operador HAVING.

Você aprenderá sobre subconsultas aninhadas, como criá-las e como utilizá-las de forma eficaz.

Aqui, você aprenderá como combinar várias tabelas, permitindo trabalhar com uma tabela unificada e simplificar a criação de consultas.

Aprenda os fundamentos da Linguagem de Definição de Dados (DDL) e da Linguagem de Manipulação de Dados (DML) em SQL, incluindo como criar, modificar e excluir objetos de banco de dados, assim como inserir, atualizar e excluir dados em tabelas.

Operações Alter e Insert

Instruções

Solução

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