📦 Репозиторий занятия 84

Реляционные и нереляционные базы данных имеют свои особенности, плюсы и минусы, которые определяют их применение в различных проектах.

## Реляционные базы данных (RDBMS или SQL)

**RDBMS (Relational Database Management System)**  
**SQL (Structured Query Language)**

### Плюсы:

- Структурированность данных: 
  - Данные организованы в таблицы с четко определенными схемами. Это упрощает управление данными и обеспечивает целостность.
- Поддержка сложных запросов: 
  - Использование SQL позволяет выполнять сложные запросы и объединения данных, что делает их удобными для аналитики и сложных транзакций.
- Целостность данных: 
  - За счет использования связей между таблицами (например, первичных и внешних ключей) поддерживается целостность данных.
- Надежность транзакций (заложенная в самой структуре RDBMS): 
  - Обеспечивается атомарность, согласованность, изоляция и долговечность транзакций, что важно, например, для систем.

### Минусы:

- Масштабируемость: 
  - Горизонтальное масштабирование (добавление серверов для увеличения мощности) сложно реализовать. 
  - Реляционные БД обычно масштабируются вертикально (увеличение мощности одного сервера).
- Жесткость схемы: 
  - Требуется строгое определение структуры данных перед началом работы, что делает сложными изменения схемы при необходимости.
- Производительность при больших объемах данных: 
  - С увеличением объема данных и сложностью запросов производительность может снижаться.

## Нереляционные базы данных (NoSQL)

### Плюсы:

- Гибкость структуры данных:
  - Нет строгих схем, данные могут храниться в различных форматах (документы, ключ-значение, графы и т.д.), что упрощает разработку и внесение изменений.
- Горизонтальная масштабируемость: 
  - Легко масштабируются путем добавления новых узлов в кластер, что позволяет обрабатывать большие объемы данных.
- Высокая производительность: 
  - Оптимизированы для работы с большими объемами данных и могут быть более эффективны для определенных типов операций (например, быстрые записи и чтения).
- Поддержка разнообразных моделей данных: 
  - В зависимости от задачи можно выбрать:
    - документные базы (например, MongoDB), 
    - базы данных ключ-значение (например, Redis), 
    - графовые базы (например, Neo4j) 
    - и т.д.

### Минусы:

- Отсутствие поддержки сложных запросов: 
  - Многие NoSQL базы данных не поддерживают сложные объединения (JOIN) и операции, что может усложнять работу с данными.
- Ограниченная поддержка транзакций (ACID): 
  - Многие NoSQL базы обеспечивают лишь базовую согласованность (eventual consistency) вместо полной транзакционной целостности.
- Менее развитые стандарты: 
  - Нет единого языка запросов, как SQL, что может усложнять миграцию между разными NoSQL системами и требует обучения новым инструментам.
- Меньше инструментов для анализа: 
  - Инструменты для анализа и управления данными могут быть менее развиты по сравнению с реляционными базами.

## Выбор между RDBMS и NoSQL:

- RDBMS хороши там, есть чёткая структура и необходимы надёжные транзакции:
  - финансовые приложения, 
…

Бинарное представление JSON, или BSON (Binary JSON), произносится как "би-эс-оу-эн" или "би-эс-он", — это формат, разработанный для хранения и передачи данных, который представляет собой двоичную, более компактную версию JSON. BSON сохраняет структуру данных JSON, но оптимизирован для быстрого чтения и записи, а также для поддержки дополнительных типов данных, которых нет в стандартном JSON.
Основные особенности BSON:

Компактность: хотя BSON обычно немного больше по размеру, чем простой текст JSON (из-за дополнительных метаданных), он всё же достаточно эффективен для передачи данных и хранения.
Быстрота обработки: поскольку данные закодированы в двоичном формате, их парсинг и обработка могут быть быстрее по сравнению с текстовым JSON.
Поддержка дополнительных типов данных: помимо стандартных типов JSON (строки, числа, массивы, объекты), BSON поддерживает дополнительные типы данных, такие как:
    32-битные и 64-битные целые числа.
    Даты.
    Булевы значения.
    Null и другие.

Преимущества BSON:

Эффективность: для операций, связанных с хранением и передачей данных, поскольку данные в двоичном формате проще и быстрее обрабатывать.
Расширяемость: позволяет хранить данные с более сложной структурой и типами, чем JSON.

Пример JSON и его представления в BSON:

JSON:
```
{
  "name": "Alice",
  "age": 30,
  "languages": ["English", "Spanish"]
}
```

BSON (в двоичном виде, представлено упрощённо):
```
\x16\x00\x00\x00           // Длина документа
\x02 name\x00\x06\x00\x00\x00Alice\x00  // Строка "name": "Alice"
\x10 age\x00\x1E\x00\x00\x00            // Целое число "age": 30
\x04 languages\x00\x19\x00\x00\x00      // Массив "languages"
\x02 0\x00\x08\x00\x00\x00English\x00   // Первый элемент массива
\x02 1\x00\x08\x00\x00\x00Spanish\x00   // Второй элемент массива
\x00                      // Завершение документа
```

Бинарное хранение данных имеет несколько преимуществ по сравнению с текстовым. Основные преимущества включают:
1. Эффективность использования памяти

- Компактность: Бинарные форматы, такие как BSON, позволяют сохранять данные более компактно за счет использования метаданных и структур данных с фиксированной длиной. Это снижает объем занимаемой памяти по сравнению с текстовыми форматами, такими как JSON или XML, где данные представлены в человекочитаемой строковой форме и требуют больше места.
- Меньший объем передачи данных: В связи с компактностью бинарных форматов уменьшается объем данных, передаваемых по сети, что улучшает производительность.

2. Быстродействие

- Быстрая обработка: Бинарные форматы обычно быстрее читаются и записываются, поскольку они уже находятся в формате, близком к тому, как данные хранятся в памяти. Это уменьшает необходимость преобразования данных в текст и обратно, что требуется при работе с текстовыми форматами.
- Парсинг и десериализация: Бинарные данные легче распарсить, так как они не требуют сложного разбора строк, как текстовые форматы. Это особенно важно для больших объемов данных.

3. Поддержка дополнительных типов данных

- Расширенная типизация: Бинарные форматы могут поддерживать больше типов данных, чем текстовые. Например, BSON, используемый в MongoDB, поддерживает типы данных, такие как даты, двоичные данные, целые числа разной разрядности, булевы значения и даже вложенные документы.
- Удобство хранения: Например, в JSON все числа представлены в виде строки, и нужно вручную контролировать целые и вещественные числа. Бинарные форматы хранят их более точно и оптимально.

4. Безопасность

- Mеньше шансов на ошибки при разборе: Текстовые форматы могут быть подвержены ошибкам, связанным с неверной кодировкой, неправильными символами или синтаксическими ошибками, которые могут повредить данные или нарушить их целостность. Бинарные форматы, напротив, жестко структурированы и имеют четкий набор правил.

Примеры использования:

…

Нереляционные базы данных (NoSQL) включают несколько типов, каждый из которых предназначен для специфических задач и сценариев. Вот основные типы и их особенности:

## 1. Документо-ориентированные базы данных

- Описание: 
    - Данные хранятся в виде документов (например, JSON, BSON, XML). Каждый документ представляет собой запись с гибкой структурой.
- Примеры использования:
    - Сайты с динамическим контентом.
    - Хранилище данных для приложений, где структура может меняться.
- Примеры СУБД:
    - MongoDB
    - Couchbase
    - Amazon DocumentDB
- Преимущества:
    - Гибкость структуры данных.
    - Хорошо подходят для сложных вложенных данных.
    - Простое масштабирование.

*Пример записи:*
```
    {
      "name": "John Doe",
      "age": 30,
      "skills": ["JavaScript", "Python"]
    }
```

## 2. Ключ-значение (Key-Value)

- Описание:
    - Простые хранилища, где данные представляют собой пары "ключ-значение". Используются для быстрого доступа по ключу.
- Примеры использования:
    - Кэширование данных.
    - Хранилище сессий.
    - Простые конфигурационные данные.
- Примеры СУБД:
    - Redis
    - Amazon DynamoDB
- Преимущества:
    - Высокая скорость.
    - Простота структуры.
    - Масштабируемость.

*Пример записи:*
```
    "user:1001": { "name": "Alice", "age": 25 }
```

## 3. Графовые базы данных

- Описание: 
    - Ориентированы на работу с узлами (объектами) и рёбрами (связями). Используются для анализа сложных взаимосвязей.
- Примеры использования:
    - Социальные сети.
    - Рекомендательные системы.
    - Анализ сетей и связей.
- Примеры СУБД:
    - Neo4j
    - ArangoDB
    - Amazon Neptune
…

# Простые запросы в MongoDB Compass

## Аналог WHERE (фильтрация документов)

В случе пустого JSON `{ }` будут выведены все документы коллекции.

Для фильтрации необходимо в JSON-объекте `{ }` указать параметры фильтрации.  

Например, `{ age: { $gte: 18 } }` оставить только те документы, где возраст >= 18.

(смотрите [theory_07__logical_operations.md](theory_07__logical_operations.md))

##  Аналог SELECT

Поле `project` (или стадия `$project` в агрегации) позволяет выбирать для вывода нужные ключи коллекции.



### 1. Вывести все ключи (поля)

Пустой JSON `{ }` выводит документы полностью и является аналогом `SELECT *` в SQL
```
$project: { }
```

### 2. Указать поля (ключи) для вывода
```
$project: { age: 1, name: 1 }
```
В каждом документе останется только `age`, `name` и  `_id`.
(`_id` ВСЕГДА выводится по умолчанию, если ЯВНО не указано иное)
 

### 3. Запрет вывода `_id`

В этом случае надо ЯВНО указать `_id: 0`
```
$project: { age: 1, name: 1, _id: 0 }
```
В каждом документе останется только `age` и `name`

### 4. Переименование ключа (поля) (Аналог alias)
```
$project: { Возраст: "$age" }
```
Теперь значения ключа (поля) `age` будут выведены под именем `Возраст`

### 5. Вывод JSON вложений в одну строку

JSON объекты, указанные в `$project` сохраняют свой формат при выводе.
Например, 
```
person: {
    age: 25,
    name: "John"
}
```
будет выведен как `person` и ссылка, нажав на которую, откроются все данные (`age` и `name`).
Чтобы вывести возраст и имя в разных строках, необходимо 
 - указать полный путь к нужному полю через dot-notation;
…

# Агрегация в MongoDB 

## Как запустить агрегацию?
В MongoDB Compass - это вкладка `aggregation`;
В mongo shell или mongosh — используется метод `aggregation()`.

## Отличия от SQL

Агрегация в MongoDB несколько отличается от агрегации в SQL.

Главная причина - наличие pipeline (конвейера), который позволяет последовательно указать несколько операций,  
где результаты (выходные документы) предыдущей операции будут входными документами для последующей.

Таким образом, все БЕЗ ИСКЛЮЧЕНИЯ запросы MongoDB можно выразить через также через агрегацию.

**Задание для примера**:  
Выбрать документы, где возраст сотрудника больше 30 лет. 
Оставить только имя и зарплату, отсортировать по з/п по убыванию.
Пропустить первые 10 документов, и вывести следующие 10.

- Обычный запрос
```
db.getCollection('employees').find(
    { age: { $gt: 30 } }, 
    { name: 1, salary: 1, _id: 0 }
  )
  .sort({ salary: -1 })
  .skip(10)
  .limit(10);
```

Запрос через агрегацию:
```
db.employees.aggregate(
    [
        { "$match": { "age": { "$gt": 30 } } },
        { "$project": { "_id": 0, "name": 1, "salary": 1 } },
        { "$sort": { "salary": -1 } },
        { "$skip": 10 },
        { "$limit": 10 }
    ]
);
```

## Непосредственно группировка

Бывает двух видов:
- `$group` - похожа на `GROUP BY`
- `$sortByCount` - одновременно: 
  - группирует, 
  - сортирует по убыванию 
  - и подсчитывает кол-во документов в каждой группе
  - (те есть фактически это две стадии: `$group` и `$sort`)

### Стадия `$group` 
                    
#### Синтаксис:
```
{
  _id: expression,
…

from pprint import pprint
from pymongo import MongoClient  # pip install pymongo

from local_settings import MONGODB_URL_READ

with MongoClient(MONGODB_URL_READ) as client:
    TIMES = 5  # число документов на печать по умолчанию
    task_statement = []  # список условий задач
    data = []  # список документов по каждому решению задачи

    """ ********************** Блок задач **************************** """

    # === Задача 1 (пример решения) ===
    task_statement.append(
        'Задача 1: Найти документы всех 40-летних'
    )

    # ----- в result подставляем решение из mongodb -----
    result = client['ich']['US_Adult_Income'].aggregate([
        {
            '$match': {
                'age': 40
            }
        }
    ])

    data.append(result)

    # ===== Задача 2 =====
    task_statement.append(
        'Условие задачи 2'
    )

    # ----- в result подставляем решение из mongodb -----
    result = ''

    data.append(result)



    """ *************** Блок вывода всех результатов на печать *************** """

    if len(data) != len(task_statement):
        raise IndexError("Ошибка!!! Кол-во заданий НЕ РАВНО кол-ву решений!!!")

    # Цикл по задачам
    for task_num, result in enumerate(data):
        print(50 * '=')
        print(task_statement[task_num])
        print()

        # Цикл по выводу документов решения
        docs = list(result)
        for idx, doc in enumerate(docs[:TIMES]):
            # print(idx, 50 * '-')
            pprint(doc)

        print(f"Total: {len(docs)} docs")

# Логические операции в MongoDB

В MongoDB для выполнения логических операций используются операторы, такие как `$and`, `$or`, `$not`, и `$nor`. Эти операторы позволяют комбинировать условия фильтрации для выполнения сложных запросов. Рассмотрим каждый из них с примерами.
## 1. $and — логическое И

Оператор `$and` позволяет объединить несколько условий, и документ должен удовлетворять всем этим условиям одновременно.

*Пример: Найдем все документы, где age больше 25 и city равен "New York".*
```
db.collection.find({
  $and: [
    { age: { $gt: 25 } },        // возраст больше 25
    { city: "New York" }          // город равен "New York"
  ]
});
```
## 2. $or — логическое ИЛИ

Оператор `$or` позволяет выполнить запрос, если хотя бы одно из условий выполняется.

*Пример: Найдем все документы, где age меньше 18 или city равен "Los Angeles".*

```
db.collection.find({
  $or: [
    { age: { $lt: 18 } },         // возраст меньше 18
    { city: "Los Angeles" }       // город равен "Los Angeles"
  ]
});
```

## 3. $not — логическое НЕ

Оператор `$not` инвертирует условие, то есть возвращает документы, которые не соответствуют указанному условию.

* Пример: Найдем все документы, где age не меньше 30.*

```
db.collection.find({
  age: { $not: { $lt: 30 } }     // возраст не меньше 30
});
```
## 4. $nor — логическое НЕ ИЛИ

Оператор `$nor` комбинирует несколько условий и возвращает документы, которые не соответствуют любому из условий. Это эквивалентно логическому отрицанию оператора $or.

Пример: Найдем все документы, где age не меньше 18 и city не равен "Los Angeles".*

```
db.collection.find({
  $nor: [
    { age: { $lt: 18 } },         // возраст не меньше 18
    { city: "Los Angeles" }       // город не равен "Los Angeles"
  ]
});
```

## 5. $eq — равно

Оператор `$eq` проверяет, равен ли элемент заданному значению.
…

# Математические операции в MongoDB

В MongoDB для выполнения арифметических операций в запросах используется несколько операторов. Эти операторы применяются в агрегации, обычно в этапах типа `$project`, `$group`, `$addFields` и т. д. Вот основные арифметические операторы:

## 1. $add — сложение

Оператор `$add` выполняет сложение двух или более значений.

*Пример: Сложение значений полей price и tax*

```
db.collection.aggregate([
  {
    $project: {
      total: { $add: ["$price", "$tax"] }  // 
    }
  }
]);
```

## 2. $subtract — вычитание

Оператор `$subtract` выполняет вычитание одного значения из другого.

*Пример: Находим разницу между временем окончания и временем начала* 
*ВНИМАНИЕ: В JavaScript эта разница будет в миллисекундах!*

```
db.collection.aggregate([
  {
    $project: {
      difference: { $subtract: ["$stop_time", "$start_time"] } 
    }
  }
]);
```

## 3. $multiply — умножение

Оператор `$multiply` выполняет умножение двух или более значений.

*Пример: Умножение полей price и quantity*

```
db.collection.aggregate([
  {
    $project: {
      total_amount: { $multiply: ["$price", "$quantity"] }  
    }
  }
]);
```

## 4. $divide — деление

Оператор `$divide` выполняет деление одного значения на другое.


*Пример: Деление полей total_amount на quantity*

…

# Операции со строками в MongoDB


В MongoDB для работы со строками используются различные операторы в рамках агрегации и запросов. Эти операторы позволяют манипулировать строковыми данными, извлекать подстроки, преобразовывать регистры и т. д. Вот основные операторы и методы для работы с строками в MongoDB.

## 1. $concat — объединение строк

Оператор `$concat` используется для объединения двух или более строк в одну строку.

*Пример: Объединим имя и фамилию в одно поле full_name:*

```
db.collection.aggregate([
  {
    $project: {
      full_name: { $concat: ["$first_name", " ", "$last_name"] }  
    }
  }
]);
```

## 2. $substr — извлечение подстроки

Оператор `$substr` используется для извлечения части строки. Он принимает три аргумента: строку, начальную позицию и длину подстроки.

*Пример: Извлечем первые 5 символов из строки name:*

```
db.collection.aggregate([
  {
    $project: {
      short_name: { $substr: ["$name", 0, 5] }  // Извлечение первых 5 символов из name
    }
  }
]);
```

## 3. $toUpper — преобразование в верхний регистр

Оператор `$toUpper` преобразует строку в верхний регистр.

*Пример: Преобразуем строку name в верхний регистр:*

```
db.collection.aggregate([
  {
    $project: {
      upper_name: { $toUpper: "$name" }  // Преобразование name в верхний регистр
    }
  }
]);
```

## 4. $toLower — преобразование в нижний регистр

Оператор `$toLower` преобразует строку в нижний регистр.

*Пример: Преобразуем строку name в нижний регистр:*

```
…

Первая нормальная форма (1NF) — это базовый уровень нормализации базы данных, который требует, чтобы каждый атрибут (столбец) содержал только атомарные (неделимые) значения, и чтобы в таблице не было повторяющихся строк. Это означает, что каждая ячейка таблицы должна содержать только одно значение, и каждая запись (строка) должна быть уникальной.

Пример таблицы в 1NF:

| StudentID | Name       | Course   |
|-----------|------------|----------|
| 1         | John Doe   | Math     |
| 2         | Jane Smith | Science  |
| 3         | Bob Brown  | History  |

Объяснение:

    Таблица соответствует 1NF, так как каждый столбец содержит атомарные значения, и все строки уникальны.
    Course содержит только одно значение в каждой ячейке.

Антипример таблицы, не соответствующей 1NF:

| StudentID | Name       | Courses                  |
|-----------|------------|--------------------------|
| 1         | John Doe   | Math, Science            |
| 2         | Jane Smith | Science, History, Math   |
| 3         | Bob Brown  | History                  |

Объяснение:

    Таблица не соответствует 1NF, потому что в столбце Courses хранятся неатомарные значения (список курсов через запятую).
    Это нарушает требование 1NF, согласно которому каждый столбец должен содержать только одно значение в каждой ячейке.

Преобразование антипримера в 1NF:

Чтобы привести таблицу к 1NF, нужно разложить многозначные значения в отдельные строки:

| StudentID | Name       | Course     |
|-----------|------------|------------|
| 1         | John Doe   | Math       |
| 1         | John Doe   | Science    |
| 2         | Jane Smith | Science    |
| 2         | Jane Smith | History    |
| 2         | Jane Smith | Math       |
| 3         | Bob Brown  | History    |


Теперь таблица соответствует 1NF, так как все значения атомарны, и каждый столбец содержит только одно значение в каждой ячейке.

Вторая нормальная форма (2NF) требует выполнения условий 1NF, а также того, чтобы все неключевые атрибуты зависели от всего первичного ключа, а не от его части. 
Это означает, что таблица не должна иметь частичных зависимостей, где неключевой атрибут зависит только от части составного первичного ключа.

Антипример таблицы, не соответствующей 2NF:

| StudentID | CourseID | StudentName | CourseName  | Grade |
|-----------|----------|-------------|-------------|-------|
| 1         | 101      | John Doe    | Math        | A     |
| 1         | 102      | John Doe    | Science     | B     |
| 2         | 101      | Jane Smith  | Math        | A     |
| 2         | 103      | Jane Smith  | History     | C     |

Объяснение:

    В этой таблице первичный ключ — это комбинация StudentID и CourseID.
    Атрибуты StudentName и CourseName зависят только от StudentID и CourseID соответственно, а не от полной комбинации. Это нарушение 2NF.

Преобразование таблицы в 2NF:

Разделим таблицу на две отдельные таблицы, чтобы устранить частичные зависимости.
Таблица студентов:

| StudentID | StudentName |
|-----------|-------------|
| 1         | John Doe    |
| 2         | Jane Smith  |

Таблица курсов:

| CourseID | CourseName |
|----------|------------|
| 101      | Math       |
| 102      | Science    |
| 103      | History    |

Таблица оценок:

| StudentID | CourseID | Grade |
|-----------|----------|-------|
| 1         | 101      | A     |
| 1         | 102      | B     |
| 2         | 101      | A     |
| 2         | 103      | C     |

Объяснение:

    Таблица студентов содержит информацию о студентах и их идентификаторах.
    Таблица курсов содержит информацию о курсах и их идентификаторах.
    Таблица оценок связывает студентов с курсами и содержит их оценки. 
    Теперь все неключевые атрибуты зависят от всего первичного ключа, и таблицы соответствуют 2NF.

Третья нормальная форма (3NF) требует выполнения всех условий 2NF, а также того, чтобы не было транзитивных зависимостей, то есть каждый неключевой атрибут должен напрямую зависеть от первичного ключа, а не через другой неключевой атрибут.

Антипример таблицы, не соответствующей 3NF:

| StudentID | StudentName | CourseID | CourseName  | InstructorName |
|-----------|-------------|----------|-------------|----------------|
| 1         | John Doe    | 101      | Math        | Dr. Smith      |
| 1         | John Doe    | 102      | Science     | Dr. Johnson    |
| 2         | Jane Smith  | 101      | Math        | Dr. Smith      |
| 2         | Jane Smith  | 103      | History     | Dr. Brown      |

Объяснение:

    В этой таблице атрибут InstructorName зависит от CourseID, а не от StudentID, что приводит к транзитивной зависимости. 
    То есть, InstructorName зависит от CourseID, который, в свою очередь, зависит от первичного ключа (StudentID и CourseID).

Преобразование таблицы в 3NF:

Чтобы привести таблицу к 3NF, необходимо устранить транзитивные зависимости. Это можно сделать, разделив таблицу на три части:
Таблица студентов:

| StudentID | StudentName |
|-----------|-------------|
| 1         | John Doe    |
| 2         | Jane Smith  |

Таблица курсов:

| CourseID | CourseName |
|----------|------------|
| 101      | Math       |
| 102      | Science    |
| 103      | History    |

Таблица преподавателей:

| CourseID | InstructorName |
|----------|----------------|
| 101      | Dr. Smith      |
| 102      | Dr. Johnson    |
| 103      | Dr. Brown      |

Таблица оценок:

| StudentID | CourseID | Grade |
|-----------|----------|-------|
| 1         | 101      | A     |
| 1         | 102      | B     |
| 2         | 101      | A     |
| 2         | 103      | C     |

Объяснение:

    В таблице студентов содержатся только идентификаторы студентов и их имена.
    В таблице курсов содержатся идентификаторы курсов и их названия.
    В таблице преподавателей содержится информация о том, какой преподаватель ведет каждый курс.
    В таблице оценок хранятся оценки студентов по курсам.
    Теперь нет транзитивных зависимостей, так как атрибуты зависят только от первичного ключа каждой таблицы, что соответствует 3NF.

Четвертая нормальная форма (4NF) требует выполнения всех условий 3NF и того, чтобы в таблице не было многозначных зависимостей, т.е. таблица не должна содержать атрибуты, которые одновременно зависят от нескольких независимых многозначных факторов.
Многозначная зависимость

Многозначная зависимость возникает, когда один атрибут зависит от нескольких независимых факторов. Это может происходить, когда в одной строке таблицы хранятся несколько независимых наборов данных.
Антипример таблицы, не соответствующей 4NF:

| StudentID | StudentName | Hobby        | Language   |
|-----------|-------------|--------------|------------|
| 1         | John Doe    | Reading      | English    |
| 1         | John Doe    | Painting     | French     |
| 2         | Jane Smith  | Swimming     | Spanish    |
| 2         | Jane Smith  | Hiking       | German     |

Объяснение:

    В таблице имеются две независимые группы данных:
        Хобби студента (Hobby).
        Язык, который студент изучает (Language).
    Эти данные должны храниться отдельно, потому что каждый из этих атрибутов зависит от StudentID, но они независимы друг от друга. Это нарушение 4NF.

Преобразование в 4NF (с учётом нормализации):

Чтобы соблюсти 4NF, нам нужно создать две новые таблицы: одну для хобби, другую для языков. Это избавит от многозначных зависимостей.
Таблица студентов:

| StudentID | StudentName |
|-----------|-------------|
| 1         | John Doe    |
| 2         | Jane Smith  |

Таблица хобби:

| StudentID | Hobby    |
|-----------|----------|
| 1         | Reading  |
| 1         | Painting |
| 2         | Swimming |
| 2         | Hiking   |

Таблица языков:

| StudentID | Language |
|-----------|----------|
| 1         | English  |
| 1         | French   |
| 2         | Spanish  |
| 2         | German   |

Почему это решение правильное?

    Каждая таблица теперь хранит только один набор данных (хобби или языки) в зависимости от StudentID. Это устраняет многозначные зависимости.
    В таблице студентов больше нет избыточных данных. 
    Каждая строка в таблице студентов хранит только уникальную информацию о студенте (его идентификатор и имя).
    Хобби и языки теперь хранятся отдельно в своих таблицах и могут быть многократными для каждого студента, но без нарушения 4NF, 
    поскольку хобби и языки являются независимыми многозначными аттрибутами.

Заключение:

Таким образом, в предыдущем ответе имело место ошибочное объединение хобби и языков с таблицей студентов, что нарушало принципы нормализации (2NF). В 4NF мы должны создать отдельные таблицы для хобби и языков, чтобы предотвратить многозначные зависимости и правильно нормализовать базу данных.

**Пятая нормальная форма (5NF)**, также известная как ***проекция-объединение нормальная форма (PJ/NF)***, требует, чтобы таблица была разделена так, чтобы каждая зависимость в таблице могла быть восстановлена с использованием только проекций (подмножеств) данных, а не через избыточные данные.
Правила 5NF:

    В 5NF таблица должна быть в 4NF и не содержать несогласованных соединений (join dependencies).
    Таблица не должна содержать избыточных данных, которые можно восстановить через соединение нескольких таблиц.
    Для этого каждый атрибут должен зависеть от всей проекции таблицы, 
    и любые соединения между таблицами должны быть восстановимы через стандартные операции объединения.

Пример нарушения 5NF:

Предположим, у нас есть следующая таблица:

| StudentID | CourseID | InstructorID | InstructorName |
|-----------|----------|--------------|----------------|
| 1         | 101      | 1            | Dr. Smith      |
| 1         | 102      | 2            | Dr. Johnson    |
| 2         | 101      | 1            | Dr. Smith      |
| 2         | 103      | 3            | Dr. Brown      |

Объяснение проблемы:

    В этой таблице три атрибута — StudentID, CourseID, и InstructorID — используются вместе, чтобы определить уникальность каждой строки.
    Проблема заключается в том, что информация о преподавателях (InstructorID и InstructorName) привязана к конкретному курсу, а не непосредственно к студенту. 
    Это создает избыточность, потому что данные о преподавателях могут быть восстановлены из других атрибутов таблицы.

Преобразование в 5NF:

Чтобы привести таблицу к 5NF, мы должны разделить её так, чтобы каждое соединение можно было восстановить без избыточности. Для этого создадим несколько таблиц:
Таблица студентов и курсов:

| StudentID | CourseID |
|-----------|----------|
| 1         | 101      |
| 1         | 102      |
| 2         | 101      |
| 2         | 103      |

Таблица преподавателей:

| InstructorID | InstructorName |
|--------------|----------------|
| 1            | Dr. Smith      |
| 2            | Dr. Johnson    |
| 3            | Dr. Brown      |

Таблица курсов и преподавателей:

| CourseID | InstructorID |
|----------|--------------|
| 101      | 1            |
| 102      | 2            |
| 103      | 1            |

Почему это решение правильно:

    Теперь каждая таблица хранит уникальную информацию и никаких избыточных данных.

Все связи между таблицами можно восстановить через обычные операции объединения (JOIN), и никакие данные не повторяются.
Заключение:

…

**Шестая нормальная форма (6NF)** — это наиболее строгая форма нормализации, которая применяется, когда мы работаем с временными данными (например, данными, которые изменяются со временем) и требуется минимизация избыточности в таких ситуациях. Она была разработана с целью устранения всех зависимостей, включая временные, и обеспечения сохранности данных без потери информации о изменениях.
Важные моменты о 6NF:

    6NF актуальна для систем, работающих с временными данными или когда изменения данных происходят часто и должны быть отслежены с точностью.
    Она обеспечивает полное разделение данных и позволяет иметь только одну атомарную зависимость в каждой таблице.
    В таблицах, находящихся в 6NF, каждая таблица хранит одну фактическую информацию (одну зависимость), что минимизирует избыточность и возможные аномалии.

Пример 6NF:

Предположим, у нас есть система, которая отслеживает изменение цен на товары с течением времени. Без использования 6NF, таблица может выглядеть так:

| ProductID | ProductName | Price  | StartDate  | EndDate    |
|-----------|-------------|--------|------------|------------|
| 1         | Apple       | 1.00   | 2023-01-01 | 2023-02-01 |
| 1         | Apple       | 1.10   | 2023-02-02 | 2023-03-01 |
| 2         | Banana      | 0.50   | 2023-01-01 | 2023-02-01 |
| 2         | Banana      | 0.60   | 2023-02-02 | 2023-03-01 |

Здесь таблица сохраняет информацию о цене товара в определенный промежуток времени. Мы видим, что одно и то же название продукта повторяется несколько раз, а цена изменяется в разные моменты времени.
Как привести к 6NF?

Чтобы привести такую таблицу к 6NF, мы должны разделить данные на несколько таблиц, где каждая таблица будет содержать атомарные (независимые) значения. Так мы устраним избыточность и будем точно отслеживать изменения.
1. Таблица продуктов:

| ProductID | ProductName |
|-----------|-------------|
| 1         | Apple       |
| 2         | Banana      |

2. Таблица цен (с временными метками):

| ProductID | Price  | StartDate  | EndDate    |
|-----------|--------|------------|------------|
| 1         | 1.00   | 2023-01-01 | 2023-02-01 |
| 1         | 1.10   | 2023-02-02 | 2023-03-01 |
| 2         | 0.50   | 2023-01-01 | 2023-02-01 |
| 2         | 0.60   | 2023-02-02 | 2023-03-01 |

В этой таблице хранится только информация о цене товара с точными временными интервалами, без повторения данных о продукте.
3. Таблица времени:

Для обеспечения 6NF и минимизации зависимости от времени, можно создать таблицу с конкретными временными интервалами. Эта таблица будет записывать изменения, но с атомарным временем для каждой записи:

| ProductID | Price  | Timepoint  |
|-----------|--------|------------|
| 1         | 1.00   | 2023-01-01 |
| 1         | 1.10   | 2023-02-02 |
| 2         | 0.50   | 2023-01-01 |
| 2         | 0.60   | 2023-02-02 |

Здесь таблица хранит только изменение цены для одного момента времени (атомарные временные точки). Система в 6NF помогает точно отслеживать каждый момент изменения, например, когда произошла цена в один конкретный день, независимо от других атрибутов.
Почему это важно?

    6NF позволяет минимизировать избыточность в данных и сохранить точную историю изменений для каждого атрибута.
    Если нужно будет отслеживать изменения с точностью до времени или даты, 
    или если один атрибут может изменяться несколько раз в день (например, цены или статус заказа), 
    то 6NF поможет хранить такую информацию без избыточности.
    6NF также важна, когда данные о времени (например, временные метки или статус) изменяются независимо от других данных.

Применение 6NF:
…

## Нормальная форма Бойса — Кодда (BCNF)

**Нормальная форма Бойса — Кодда (BCNF)** — это более строгая версия третьей нормальной формы (3NF), которая устраняет все виды функциональных зависимостей, выходящих за пределы потенциальных ключей. В BCNF, если существует функциональная зависимость X→Y, то атрибуты X должны составлять потенциальный ключ.

Давайте рассмотрим пример, который удовлетворяет 1NF, 2NF, и 3NF, но противоречит BCNF.

Для этого мы создадим таблицу, где функциональная зависимость нарушает правило BCNF, хотя таблица еще будет соответствовать первым трем нормальным формам.
Пример

| StudentID | CourseID | InstructorName | Grade |
|-----------|----------|----------------|-------|
| 1         | 101      | Dr. Smith      | A     |
| 1         | 102      | Dr. Johnson    | B     |
| 2         | 101      | Dr. Smith      | A     |
| 2         | 103      | Dr. Brown      | C     |

Проверим соответствие первым трем нормальным формам:
1NF (Первая нормальная форма):

Таблица удовлетворяет 1NF, так как все данные атомарны (каждая ячейка содержит только одно значение).
2NF (Вторая нормальная форма):

Таблица удовлетворяет 2NF, так как:

    Все неключевые атрибуты (InstructorName, Grade) полностью зависят от всего первичного ключа (StudentID, CourseID).
    Нет частичных зависимостей, так как каждый неключевой атрибут зависит от всей комбинации ключа.

3NF (Третья нормальная форма):

Таблица удовлетворяет 3NF, так как:

    Все неключевые атрибуты (InstructorName, Grade) зависят только от ключа (StudentID, CourseID).
    Нет транзитивных зависимостей (InstructorName зависит только от CourseID, и это не транзитивная зависимость).

Анализ по BCNF:

Разбор функциональной зависимости

Функциональная зависимость:
    CourseID → InstructorName.
    Это означает, что для каждого CourseID (идентификатора курса) однозначно определяется преподаватель (InstructorName). Например, курс с CourseID = 101 всегда преподает Dr. Smith, курс с CourseID = 102 — Dr. Johnson, и так далее.

Почему это нарушает BCNF?

    В BCNF говорится, что для каждой функциональной зависимости X → Y в таблице, X должно быть потенциальным ключом (или суперклавишем). 
    Это означает, что X должно быть уникальным идентификатором для каждой строки таблицы.

    В нашем примере:
        StudentID и CourseID вместе составляют первичный ключ таблицы, потому что комбинация этих двух атрибутов уникально идентифицирует каждую строку.
        Однако, CourseID → InstructorName предполагает, что для каждого CourseID однозначно определяется InstructorName.
        но CourseID сам по себе не является уникальным идентификатором.
        Один и тот же курс может преподаваться нескольким студентам (например, курс Math может преподаваться нескольким студентам).

    Согласно BCNF, CourseID должен быть потенциальным ключом, но это не так. 
    CourseID не уникален в контексте всей таблицы, потому что для одного и того же курса могут быть несколько студентов, 
    получающих разные оценки.

Решение для приведения таблицы в BCNF:

    Чтобы устранить нарушение BCNF, нам нужно разделить таблицу таким образом, чтобы функциональная зависимость CourseID → InstructorName находилась в отдельной таблице, где CourseID станет ключом.
…

## Доменно-ключевая нормальная форма (DKNF)

DKNF — это самая строгая форма нормализации базы данных. Она гарантирует, что все ограничения на данные в таблице могут быть выражены исключительно через ограничения на домены (домен — это множество допустимых значений для атрибута) и ключи.

Простой способ объяснить DKNF — это таблица, в которой не осталось ни одной аномалии данных (ни одной функциональной, ни транзитивной зависимости), и все ограничения на данные контролируются исключительно с помощью доменных и ключевых ограничений, без необходимости вводить дополнительные функциональные зависимости.
Характеристика DKNF:

    Каждая таблица в DKNF должна быть такой, что все ограничения на данные могут быть выражены в виде ограничений на домены значений атрибутов и ключей.
    Все функциональные зависимости должны быть "сущностными" (относящимися к ограничениям значений), а не "произвольными" (определяемыми избыточными зависимостями).
    В отличие от BCNF или 3NF, в DKNF не существует транзитивных зависимостей, и любые данные можно выразить с помощью атрибутов или их значений.

Условия для удовлетворения DKNF:

    Все функциональные зависимости являются зависимостями на ключи: То есть, для каждой функциональной зависимости X→Y, X должен быть суперключом.
    Отсутствие сложных зависимостей: Каждая зависимость должна быть явной и строго ограниченной доменом значений.

Пример таблицы, нарушающей DKNF:

Возьмем пример с таблицей студентов и курсов:

| StudentID | CourseID | InstructorName | Grade |
|-----------|----------|----------------|-------|
| 1         | 101      | Dr. Smith      | A     |
| 1         | 102      | Dr. Johnson    | B     |
| 2         | 101      | Dr. Smith      | A     |
| 2         | 103      | Dr. Brown      | C     |

Нарушение DKNF:

    В этой таблице существует зависимость CourseID → InstructorName. То есть, для каждого CourseID однозначно определяется InstructorName.
    Эта зависимость нарушает DKNF, потому что CourseID не является потенциальным ключом. Например, CourseID не может быть уникальным идентификатором для каждой строки таблицы, поскольку курс может преподаваться нескольким студентам. Таким образом, зависимость CourseID → InstructorName не может быть выражена через ограничения на домены и ключи, что нарушает принцип DKNF.

Приведение таблицы в DKNF:

Чтобы привести таблицу к DKNF, нам нужно исключить все такие функциональные зависимости, которые не могут быть выражены через доменные ограничения. Разделим таблицу на две:
Таблица 1: Курсы и преподаватели

| CourseID | InstructorName |
|----------|----------------|
| 101      | Dr. Smith      |
| 102      | Dr. Johnson    |
| 103      | Dr. Brown      |

Здесь CourseID является ключом, и зависимость CourseID → InstructorName теперь не нарушает DKNF, так как она выражена через ключ (и это единственная зависимость, которую можно выразить на уровне домена).
Таблица 2: Студенты и курсы с оценками

| StudentID | CourseID | Grade |
|-----------|----------|-------|
| 1         | 101      | A     |
| 1         | 102      | B     |
| 2         | 101      | A     |
| 2         | 103      | C     |

Здесь StudentID и CourseID вместе составляют ключ, и эта таблица также соответствует DKNF, так как нет других зависимостей между атрибутами, кроме как через ключи.
Почему теперь таблицы удовлетворяют DKNF?

    Первое ограничение: Все зависимости теперь выражены через ключи.
    Второе ограничение: Все значения в таблице ограничены доменом (например, Grade ограничено набором возможных оценок, InstructorName ограничено возможными именами преподавателей).
    Нет лишних зависимостей: Например, зависимость CourseID → InstructorName теперь находится в отдельной таблице, где CourseID является ключом, и эта зависимость контролируется доменом.

…

Строго говоря, в MySQL есть только 2 связи: one-to-one и one-to-many. 

## Когда используется связь one-to-one (один к одному)?

Следует помнить, что основная идея SQL реализация системы Сущность-Связь (Entity-Relationship).
Поэтому разнесение данных Person-Passport по разным таблицам, соединённым связью *one-to-one*, -
это, в первую очередь, следование правилам нормализации (каждой сущности - своя отдельная таблица).

Разница между one-to-many и one-to-one только в дополнительном ограничении на
уникальность поля FK.

Пример one-to-one 
(точнее one_to_zero_or_one: поскольку допустимы значения NULL у FK, 
то связь по FK в этом примере не обязательна) 

```
DROP DATABASE IF EXISTS one_to_zero_or_one;
CREATE DATABASE one_to_zero_or_one;
USE one_to_zero_or_one;


CREATE TABLE users (
    user_id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(255) NOT NULL
);


CREATE TABLE passports (
    profile_id INT AUTO_INCREMENT PRIMARY KEY,
    bio TEXT,
    user_id INT UNIQUE,         -- Ограничение на уникальность внешнего ключа
    FOREIGN KEY (user_id) REFERENCES users(user_id)
);

-- Добавление данных в таблицу users
INSERT INTO `users` (`username`) VALUES
('Alice'),
('Bob'),
('Mike'),
('Ann');

-- Добавление данных в таблицу passports
INSERT INTO `passports` (`bio`, `user_id`) VALUES
('Bio for Alice', 1),
('Bio for Bob', 2),
('Bio for Ann', 4);

-- Попытка вставить данные, чтобы проверить связь 1:0
-- Добавление записи без указания ключа не таблицу users
INSERT INTO `passports` (`bio`, `user_id`) VALUES
('Bio for NULL', NULL);

-- Попытка вставить данные, чтобы проверить связь 1:1
-- Следующий запрос вызвает ошибку из-за ограничения уникальности внешнего ключа
INSERT INTO `passports` (`bio`, `user_id`) VALUES
('Duplicate Bio for Alice', 1);


```
Немного изменяем (ужесточаем) требования к полю user_id в таблице passport:
…

# Операторы для фильтрации документов в массиве

## 1. $all — поиск документов по указанному набору элементов

Оператор `$all` в MongoDB применяется только к массивам. Он используется для проверки,   
содержит ли массив все указанные значения, независимо от порядка элементов в массиве.

Пример:

В коллекции products, значения поля tags является массивом.
```
db.products.insertMany([
    { name: "Laptop", tags: ["electronics", "computer", "portable"] },
    { name: "Smartphone", tags: ["electronics", "mobile", "portable"] },
    { name: "Desk", tags: ["furniture", "wood", "office"] },
    { name: "Chair", tags: ["furniture", "wood"] } 
]);
```
Необходимо найти продукты, у которых в массиве tags одновременно присутствуют "electronics" и "portable".
```
db.products.find({
    tags: { $all: ["electronics", "portable"] }
});
```

Ожидаемый результат:
```
[{
  _id: ObjectId('6746172fc9bca7bc6f2363bc'),
  name: 'Laptop',
  tags: [ 'electronics', 'computer', 'portable' ]
},
{
  _id: ObjectId('6746172fc9bca7bc6f2363bd'),
  name: 'Smartphone',
  tags: [ 'electronics', 'mobile', 'portable' ]
}]
```

## 2. $size — поиск по указанному числу элементов в массиве

Оператор `$size` проверяет количество элементов в массиве.

*Пример: выбрать документы, где массив в tag содержит элемента*
```
db.collection.find({ 
    tags: { $size: 3 } 
});
```

Ожидаемый результат:
```
[{
  _id: ObjectId("67461aa23f054cc437def0fd"),
  name: "Laptop",
  tags: [ "electronics", "computer", "portable" ]
},
{
  _id: ObjectId("67461aa23f054cc437def0fe"),
  name: "Smartphone",
…

# Операторы $limit, $skip, и $slice

Эти операторы используются для управления выборкой данных, но применяются в разных контекстах

Для иллюстрации используем ту же коллекцию products:

```
db.products.insertMany([
    { name: "Laptop", tags: ["electronics", "computer", "portable"] },
    { name: "Smartphone", tags: ["electronics", "mobile", "portable"] },
    { name: "Desk", tags: ["furniture", "wood", "office"] },
    { name: "Chair", tags: ["furniture", "wood"] }
]);
```

## 1. `$limit` - Ограничивает количество документов, возвращаемых запросом.

*Пример: Вывести только два первые документа из коллекции.*

```
db.products.find().limit(2);
```

Ожидаемый результат:

```
[
  { "_id": ObjectId("..."), "name": "Laptop", "tags": ["electronics", "computer", "portable"] },
  { "_id": ObjectId("..."), "name": "Smartphone", "tags": ["electronics", "mobile", "portable"] }
]
```

## 2. `$skip` - пропускает указанное количество документов перед началом возврата.


*Пример: пропустить первые два документа и вывести оставшиеся*
```
db.products.find().skip(2);
```
Ожидаемый результат:
```
[
  { "_id": ObjectId("..."), "name": "Desk", "tags": ["furniture", "wood", "office"] },
  { "_id": ObjectId("..."), "name": "Chair", "tags": ["furniture", "wood"] }
]
```


## 3. `$slice` - "Вырезает" из указанной позиции массива указанное число элементов

Применяется для форматирования вывода массивов (т.е. ТОЛЬКО в project!) внутри документа

*Пример: получить только первые два тега для каждого документа*
```
db.products.find(
  {}, { name: 1, tags: { $slice: 2 } }
);
```

Ожидаемый результат:
…

# Пользовательcкие функции в MongoDB

**Плюсы**:
- Могут существенно упростить стандартные варианты запросов
- Более лаконичны и читабельны

**Минусы**:
- Возможность их использования может быть ограничена на сервере
- Запрещены в Atlas
- Могут работать медленнее, чем стандартные средства
- Требуется знание JS

## Синтаксис
```
{
  $function: {
    body: <function_code_as_string_or_JS_function>,
    args: [ <expression1>, <expression2>, ... ],
    lang: "js"
  }
}
```  
, где:
- `body` - тело функции
- `args` - аргументы функции (массив полей, используемых как аргументы)
- `lang` - пока ТОЛЬКО js

##  Пример
Создать новое поле `mySum`, как сумму значений двух других полей
```
{
  $project: {
    mySum: {
      $function: {
        body: function(a, b) { return a + b; },
        args: ["$field1", "$field2"],
        lang: "js"
      }
    }
  }
}
```

##  Пример
Создать новое поле `arrayAsString`, в котором собираются все элементы массива `$yourArray`
через разделитель запятая с пробелом `", "`


Если все элементы массива строки - просто джойним каждый элемент массива через `", "`:
```javascript
arrayAsString: {
  $function: {
    body: function(arr) { return arr.join(", ") },
    args: ["$yourArray"],
    lang: "js"
  }
}
```

Если нет - надо добавить `.map(String)` перед  `.join(", ")`:
…

# Как подключиться к MongoDB в терминале на **Ubuntu**.

## 1. Убедитесь, что MongoDB установлена и запущена

Проверка статуса службы:

```bash
sudo systemctl status mongod
```

Запустить (если не запущена):

```bash
sudo systemctl start mongod
```

Включить автозапуск:

```bash
sudo systemctl enable mongod
```

---

## 2. Подключение к MongoDB

Если установлен `mongosh`, подключение к локальному серверу:

```bash
mongosh
```

К удалённому серверу:

```bash
mongosh "mongodb://username:********@host:27017"
```


---

## 3. Подключение к конкретной базе

```bash
mongosh "mongodb://localhost:27017/mydatabase"
```

---

## 4. Проверка подключения

После входа можно выполнить:

```js
db
show dbs
```

## 1. Автоматическое создание при вставке

Самый простой способ — просто вставить документ, и MongoDB сама создаст коллекцию.
```
db.новаяКоллекция.insertOne({ имя: "Тест" })
```
Используется чаще всего. Подходит для обычных коллекций без специальных настроек.

## 2. Явное создание через db.createCollection()

```
db.createCollection(имя, параметры)
```
Примеры:

### Обычная коллекция:

```
db.createCollection("users")
```

### Ограниченная (capped):

db.createCollection("logs", { capped: true, size: 1024 * 1024 })

**Что такое `capped` collection?**
- Это фиксированная по размеру коллекция (1024 Кб * 1024 = 1 Мб)
- Когда размер достигает лимита, старые документы удаляются автоматически, чтобы освободить место для новых.
- Документы удаляются в порядке вставки (FIFO — First In, First Out).
- Невозможно удалить или обновить размер документа, если он превышает размер вставленного ранее.

### С автоматической очисткой по времени (TTL):
```
db.createCollection("sessions")
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 })
```

- Создаётся коллекция `sessions`
- Создаётся TTL-индекс (Time-To-Live) — MongoDB будет автоматически удалять документы, когда они "устареют" (в нашем случае через час).

ВАЖНО: при создании документа поле `createdAt` должно быть датой!

```
db.sessions.insertOne({
  userId: 123,
  createdAt: new Date()  // правильно: тип `Date`
})
```

# Методы добавление документов

Помимо удобного и наглядного добавление документов через графический интерфейс Compass, можно также добавлять новые документы через MongoDB Shell.

## 1. Метод insertOne

Этот метод добавляет один документ в коллекцию.

```
db.people.insertOne(
  { name: "Alice", age: 30, city: "New York" }
);
```
## 2. Метод insertMany

Используется для добавления нескольких документов за один вызов.

```
db.people.insertMany([
  { name: "Bob", age: 25, city: "Los Angeles" },
  { name: "Carol", age: 27, city: "Chicago" }
]);
```

## 3. Методы update

Перечисленные выше способы позволяют явно создать (добавить) новые документы в коллекцию.
Помимо этого, новый документ может быть добавлен в коллекцию и с помощью методов update (подробнее в [theory_02__update.md](./theory_02__update.md))
 

# Обновление существующих документов с помощью методов update

## 1. Метод updateOne

Этот метод обновляет только первый документ, соответствующий фильтру.

Что делает:
- Если документ найден:
  - Меняет указанные поля с помощью операторов ($set, $inc и т.д.). 
  - Если указанных полей нет, они добавляются.
- Если документ не найден и включён upsert: true, создаётся новый документ, который:
  - Содержит данные из фильтра.
  - Содержит данные, указанные в $set (или других операторах).
- Если документ не найден и `upsert` выключен (`{ upsert: false }`) или вовсе отсутствует, то апдейт будет попросту проигнорирован.

Пример:
```
db.collection.updateOne(
  { name: "Alice" }, // Фильтр
  { $set: { age: 30 } }, // Обновление
  { upsert: true } // Опция upsert
);
```

Результат:
- Если документ `{ name: "Alice" }` найден:
```
{ "name": "Alice", "age": 30 }
```
- Если документа нет:
```
{ "name": "Alice", "age": 30 }
```

## 2. Метод updateMany

Этот метод обновляет все документы, которые соответствуют фильтру.

- Что делает:
  - Если документы найдены:
  - Меняет указанные поля с помощью операторов.
  - Если указанных полей нет, они добавляются.
- Если ни одного документа не найдено и включён upsert: true, создаётся один новый документ:
  - С данными из фильтра.
  - С данными из $set (или других операторов).

Пример:
```
db.collection.updateMany(
  { city: "New York" }, // Фильтр
  { $set: { visited: true } }, // Обновление
  { upsert: true } // Опция upsert
);
```

Результат:
- Если есть несколько документов с city: "New York":
```
{ "city": "New York", "visited": true }
```
…

# Удаление документов

В MongoDB есть несколько методов для удаления документов из коллекции. Они отличаются по количеству удаляемых документов и способу работы. Вот подробное описание:

## 1. deleteOne

Удаляет первый найденный документ, который соответствует заданному фильтру.

Синтаксис:
```
db.collection.deleteOne(
  { <фильтр> } // Условие для удаления
)
```

Особенности:
  - Удаляет только один документ, даже если фильтру соответствует несколько документов.
  - Если фильтр пустой, удаляет первый документ в коллекции (не рекомендуется использовать без фильтра).

Пример:
```
db.collection.deleteOne({ name: "Alice" });
```
(Удалит первый документ, где name равно "Alice")

## 2. deleteMany

Удаляет все документы, которые соответствуют заданному фильтру.

Синтаксис:
```
db.collection.deleteMany(
  { <фильтр> } // Условие для удаления
)
```

Особенности:
- Удаляет все документы, соответствующие фильтру.
- Если фильтр пустой, удаляет все документы в коллекции (будьте осторожны).

Пример:
```
db.collection.deleteMany({ status: "inactive" });
```
(Удалит все документы, где status равно "inactive")


## 3. findOneAndDelete

Находит и удаляет один документ, возвращая его содержимое.

Синтаксис:

```
db.collection.findOneAndDelete(
  { <фильтр> },          // Условие для удаления
  { sort: { <поле>: 1 } } // (необязательно) Сортировка, чтобы определить, какой документ удалить
)
```

…

# Операции агрегации в MongoDB Compass 

Операции агрегации обрабатывают несколько документов и возвращают вычисленные результаты. Вы можете использовать операции агрегации для:

- Группировки значений из нескольких документов.
- Выполнения операций над сгруппированными данными для получения единого результата.
- Анализа изменений данных со временем.

Для выполнения операций агрегации можно использовать:

- Конвейеры агрегации (Aggregation pipelines) — это предпочтительный метод выполнения агрегаций.
- Методы агрегации для одной цели (Single-purpose aggregation methods) — они просты в использовании, но не обладают такими возможностями, как конвейеры агрегации.




## 01. $addFields - Добавляет или изменяет поля.

*Пример: Добавить поле hours_per_day, разделив hours_per_week на 7.*
```
{
  "$addFields": {
    "hours_per_day": { "$divide": ["$hours_per_week", 7] }
  }
}
```

## 02. $bucket - Разбивает документы на группы (корзины) на основе диапазонов.

*Пример: Разделить документы по возрастным группам (до 20, от 20 до 40, от 40).*
```
{
  "$bucket": {
    "groupBy": "$age",
    "boundaries": [0, 20, 40, 60],
    "default": "other",
    "output": {
      "count": { "$sum": 1 },
      "average_income": { "$avg": "$total" }
    }
  }
}
```

## 03. $bucketAuto

Аналогично $bucket, но автоматически определяет границы.

*Пример: Создать 3 возрастные группы автоматически.*
```
{
  "$bucketAuto": {
    "groupBy": "$age",
    "buckets": 3
  }
}
```

## 04. $collStats

…

# Некоторые функции агрегации, используемые при группировке ($group)

В операторе $group используются агрегирующие функции, которые позволяют выполнять вычисления на основе данных в группе. 

| **Функция**        | **Описание**                                                  | **Пример использования**                         |
|---------------------|--------------------------------------------------------------|-------------------------------------------------|
| `$sum`             | Суммирует значения в группе.                                 | `{ $sum: "$price" }`                            |
| `$avg`             | Вычисляет среднее арифметическое значений в группе.          | `{ $avg: "$score" }`                            |
| `$min`             | Находит минимальное значение в группе.                      | `{ $min: "$age" }`                              |
| `$max`             | Находит максимальное значение в группе.                     | `{ $max: "$age" }`                              |
| `$first`           | Возвращает первый документ в группе.                        | `{ $first: "$name" }`                           |
| `$last`            | Возвращает последний документ в группе.                     | `{ $last: "$name" }`                            |
| `$push`            | Создаёт массив из всех значений в группе.                   | `{ $push: "$tags" }`                            |
| `$addToSet`        | Создаёт массив уникальных значений (без дублирования).       | `{ $addToSet: "$category" }`                    |
| `$count`           | Считает количество документов в группе (суммирует 1).       | `{ $sum: 1 }`                                   |
| `$mergeObjects`    | Объединяет несколько документов в один объект.              | `{ $mergeObjects: "$details" }`                 |
| `$stdDevPop`       | Вычисляет стандартное отклонение для всех значений (популяционное). | `{ $stdDevPop: "$values" }`           |
| `$stdDevSamp`      | Вычисляет стандартное отклонение (выборочное).              | `{ $stdDevSamp: "$values" }`                    |



*Пример: Группировка с вычислениями*
*Исходные данные*
```
[
  { "_id": 1, "category": "A", "price": 100 },
  { "_id": 2, "category": "A", "price": 200 },
  { "_id": 3, "category": "B", "price": 300 },
  { "_id": 4, "category": "B", "price": 400 }
]
```

*Запрос с `$group`*
```
db.collection.aggregate([
  {
    $group: {
      _id: "$category",             // Группировка по полю "category"
      totalPrice: { $sum: "$price" }, // Сумма цен в каждой группе
      avgPrice: { $avg: "$price" },  // Средняя цена в группе
      minPrice: { $min: "$price" },  // Минимальная цена
      maxPrice: { $max: "$price" },  // Максимальная цена
      count: { $sum: 1 }             // Количество документов
    }
  }
])
```

*Результат:*
```
[
  { "_id": "A", "totalPrice": 300, "avgPrice": 150, "minPrice": 100, "maxPrice": 200, "count": 2 },
  { "_id": "B", "totalPrice": 700, "avgPrice": 350, "minPrice": 300, "maxPrice": 400, "count": 2 }
]
```