Какие знаешь отношения между таблицами?

Отношения между таблицами в реляционных базах данных

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

---

1. Один к одному (One-to-One)

Каждой записи в таблице A соответствует не более одной записи в таблице B, и наоборот. Часто используется для:

• Разделения таблиц по соображениям безопасности (например, основные данные пользователя и его паспортные данные)
• Оптимизации производительности, когда часть полей запрашивается реже
• Наследования в ORM (например, Table-per-Hierarchy в Entity Framework)

CREATE TABLE Users (
    Id INT PRIMARY KEY,
    Username NVARCHAR(50)
);

CREATE TABLE PassportData (
    Id INT PRIMARY KEY,
    UserId INT UNIQUE, -- Уникальность обеспечивает отношение 1:1
    PassportNumber NVARCHAR(20),
    FOREIGN KEY (UserId) REFERENCES Users(Id)
);

---

2. Один ко многим (One-to-Many) / Многие к одному (Many-to-One)

Наиболее распространенное отношение. Одной записи в главной таблице (родительской) соответствует несколько записей в дочерней таблице.

Пример: У одного заказчика может быть несколько заказов.

CREATE TABLE Customers (
    Id INT PRIMARY KEY,
    Name NVARCHAR(100)
);

CREATE TABLE Orders (
    Id INT PRIMARY KEY,
    CustomerId INT, -- Внешний ключ к Customers
    OrderDate DATETIME,
    FOREIGN KEY (CustomerId) REFERENCES Customers(Id)
);

В Entity Framework Core это представляется навигационными свойствами:

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<Order> Orders { get; set; } // Навигационное свойство
}

public class Order
{
    public int Id { get; set; }
    public DateTime OrderDate { get; set; }
    
    public int CustomerId { get; set; } // Внешний ключ
    public Customer Customer { get; set; } // Навигационное свойство
}

---

3. Многие ко многим (Many-to-Many)

Это отношение реализуется через промежуточную таблицу (связующую, junction table). Каждая запись в таблице A может быть связана с несколькими записями в таблице B, и наоборот.

Пример: Студенты и курсы (студент может посещать несколько курсов, курс может иметь нескольких студентов).

CREATE TABLE Students (
    Id INT PRIMARY KEY,
    Name NVARCHAR(100)
);

CREATE TABLE Courses (
    Id INT PRIMARY KEY,
    Title NVARCHAR(100)
);

-- Промежуточная таблица
CREATE TABLE StudentCourses (
    StudentId INT,
    CourseId INT,
    EnrollmentDate DATE,
    PRIMARY KEY (StudentId, CourseId), -- Составной первичный ключ
    FOREIGN KEY (StudentId) REFERENCES Students(Id),
    FOREIGN KEY (CourseId) REFERENCES Courses(Id)
);

В EF Core 5+ можно использовать более простую конфигурацию:

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<Course> Courses { get; set; }
}

public class Course
{
    public int Id { get; set; }
    public string Title { get; set; }
    public List<Student> Students { get; set; }
}

// В DbContext
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .HasMany(s => s.Courses)
        .WithMany(c => c.Students);
}

---

4. Самореферентное отношение (Self-Referencing)

Таблица ссылается сама на себя через внешний ключ. Часто используется для:

• Иерархических структур (дерево категорий, организационная структура)
• Цепочки сообщений или комментариев

CREATE TABLE Employees (
    Id INT PRIMARY KEY,
    Name NVARCHAR(100),
    ManagerId INT NULL, -- Ссылка на другого сотрудника в этой же таблице
    FOREIGN KEY (ManagerId) REFERENCES Employees(Id)
);

Эквивалент в C# классе:

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    
    public int? ManagerId { get; set; }
    public Employee Manager { get; set; }
    public List<Employee> Subordinates { get; set; }
}

---

Важные аспекты реализации в C# Backend

Ограничения внешних ключей (Foreign Key Constraints)

• ON DELETE CASCADE - автоматическое удаление зависимых записей
• ON DELETE SET NULL - установка NULL в внешнем ключе
• ON DELETE RESTRICT (или NO ACTION) - запрет удаления, если есть зависимости

Индексы на внешних ключах

Всегда создавайте индексы на полях внешних ключей для ускорения JOIN-операций:

CREATE INDEX IX_Orders_CustomerId ON Orders(CustomerId);

Отложенные проверки целостности (в транзакциях)

SET XACT_ABORT ON;
BEGIN TRANSACTION;
-- Множественные операции с несколькими таблицами
COMMIT TRANSACTION;

Навигационные свойства в Entity Framework

Позволяют удобно работать со связанными данными:

• Lazy Loading - автоматическая загрузка при обращении
• Eager Loading - явная загрузка с помощью .Include()
• Explicit Loading - ручная загрузка через .Load()

// Eager Loading пример
var customers = context.Customers
    .Include(c => c.Orders)
        .ThenInclude(o => o.OrderDetails)
    .ToList();

Правильное проектирование отношений между таблицами критически важно для:

• Целостности данных (referential integrity)
• Производительности запросов
• Масштабируемости приложения
• Удобства работы через ORM

Выбор типа отношений зависит от бизнес-логики и требований к данным, но в большинстве случаев доминируют отношения один-ко-многим и многие-ко-многим.