Что такое ForeignKey?

ForeignKey: Внешние ключи в базах данных

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

Базовое определение

ForeignKey — это столбец (или набор столбцов) в одной таблице, который ссылается на PRIMARY KEY в другой таблице.

-- Таблица родителя
CREATE TABLE authors (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    country VARCHAR(50)
);

-- Таблица с внешним ключом
CREATE TABLE books (
    id INT PRIMARY KEY,
    title VARCHAR(200),
    author_id INT,
    FOREIGN KEY (author_id) REFERENCES authors(id)  -- Внешний ключ!
);

Визуальное представление

Таблица AUTHORS              Таблица BOOKS
┌───────────────────────┐   ┌──────────────────────────┐
│ ID (Primary Key)      │   │ ID (Primary Key)         │
│ Name                  │   │ Title                    │
│ Country               │   │ Author_ID (Foreign Key)  ├──→ Ссылается на
│                       │   │                          │     authors.id
│ 1 | Mark Twain | USA  │   │ 1 | Tom Sawyer | 1      │
│ 2 | Jane Austen| UK   │   │ 2 | Pride & Prejudice|2  │
│ 3 | Jules Verne|FR    │   │ 3 | Journey to Center|3  │
└───────────────────────┘   └──────────────────────────┘

Ограничения целостности (Referential Integrity)

ForeignKey автоматически обеспечивает:

1. Целостность ссылок: Нельзя вставить значение author_id, которого не существует в таблице authors

-- ✅ Допустимо
INSERT INTO books (id, title, author_id) VALUES (1, 'Tom Sawyer', 1);
-- author_id = 1 существует в таблице authors

-- ❌ Ошибка: Referential Integrity Violation
INSERT INTO books (id, title, author_id) VALUES (2, 'Book', 999);
-- author_id = 999 не существует в таблице authors
-- Error: FOREIGN KEY constraint failed

1. Защита от удаления: Нельзя удалить автора, если у него есть книги

-- ❌ Ошибка
DELETE FROM authors WHERE id = 1;
-- Error: FOREIGN KEY constraint failed
-- (есть книги с author_id = 1)

-- ✅ Сначала удалим книги
DELETE FROM books WHERE author_id = 1;
DELETE FROM authors WHERE id = 1;  -- Теперь OK

Действия при изменениях (Cascade Actions)

-- 1. CASCADE: автоматическое удаление зависимых записей
CREATE TABLE books (
    id INT PRIMARY KEY,
    title VARCHAR(200),
    author_id INT,
    FOREIGN KEY (author_id) REFERENCES authors(id) ON DELETE CASCADE
);

-- Теперь удаление автора удалит все его книги автоматически
DELETE FROM authors WHERE id = 1;  -- Все книги с author_id = 1 удалятся

-- 2. SET NULL: установить NULL при удалении родителя
CREATE TABLE books (
    id INT PRIMARY KEY,
    title VARCHAR(200),
    author_id INT,
    FOREIGN KEY (author_id) REFERENCES authors(id) ON DELETE SET NULL
);

DELETE FROM authors WHERE id = 1;
-- books.author_id станет NULL для всех книг этого автора

-- 3. RESTRICT: запретить удаление (по умолчанию)
CREATE TABLE books (
    id INT PRIMARY KEY,
    title VARCHAR(200),
    author_id INT,
    FOREIGN KEY (author_id) REFERENCES authors(id) ON DELETE RESTRICT
);

DELETE FROM authors WHERE id = 1;  # Error: cannot delete

-- 4. NO ACTION: то же что RESTRICT (SQL standard)
FOREIGN KEY (author_id) REFERENCES authors(id) ON DELETE NO ACTION

ForeignKey в ORM (Django, SQLAlchemy)

Django ORM:

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    country = models.CharField(max_length=50)
    
    class Meta:
        db_table = 'authors'

class Book(models.Model):
    title = models.CharField(max_length=200)
    # ForeignKey создаёт автоматически author_id столбец
    author = models.ForeignKey(
        Author,
        on_delete=models.CASCADE,  # Удалить книги при удалении автора
        related_name='books'       # Обратная ссылка: author.books.all()
    )
    
    class Meta:
        db_table = 'books'

# Использование
author = Author.objects.get(id=1)
# Прямая ссылка
book = Book.objects.create(title='New Book', author=author)

# Обратная ссылка
all_books_by_author = author.books.all()

SQLAlchemy:

from sqlalchemy import Column, Integer, String, ForeignKey, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, Session

Base = declarative_base()

class Author(Base):
    __tablename__ = 'authors'
    
    id = Column(Integer, primary_key=True)
    name = Column(String(100))
    country = Column(String(50))
    
    # Обратная ссылка
    books = relationship('Book', back_populates='author', cascade='all, delete-orphan')

class Book(Base):
    __tablename__ = 'books'
    
    id = Column(Integer, primary_key=True)
    title = Column(String(200))
    author_id = Column(Integer, ForeignKey('authors.id'))  # Внешний ключ
    
    # Прямая ссылка
    author = relationship('Author', back_populates='books')

# Использование
engine = create_engine('sqlite:///library.db')
Base.metadata.create_all(engine)

with Session(engine) as session:
    # Создание
    author = Author(name='Mark Twain', country='USA')
    book = Book(title='Tom Sawyer', author=author)
    session.add(author)
    session.commit()
    
    # Запрос с join
    books_by_author = session.query(Book).filter(Book.author_id == 1).all()
    
    # Через relationship
    author = session.query(Author).get(1)
    print(author.books)  # Все книги автора

Типы связей через ForeignKey

1. One-to-Many (1-N) — самый частый случай

Authors        Books
1 Mark Twain ─────→ Tom Sawyer
               ├──→ Huckleberry Finn
               └──→ Prince and Pauper

2 Jane Austen ─────→ Pride and Prejudice

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    books = relationship('Book', back_populates='author')  # 1 автор → много книг

class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer, primary_key=True)
    title = Column(String)
    author_id = Column(Integer, ForeignKey('authors.id'))
    author = relationship('Author', back_populates='books')  # много книг → 1 автор

2. Many-to-Many (N-N) — используется таблица связи

Authors          Books_Authors         Books
1 Mark Twain  ←──────→ (связь)    ←──────→  Tom Sawyer
2 Jane Austen ←──────→         ←──────→  Pride & Prejudice

# Таблица связи (association table)
books_authors = Table(
    'books_authors',
    Base.metadata,
    Column('book_id', Integer, ForeignKey('books.id'), primary_key=True),
    Column('author_id', Integer, ForeignKey('authors.id'), primary_key=True)
)

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    books = relationship('Book', secondary=books_authors, back_populates='authors')

class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer, primary_key=True)
    title = Column(String)
    authors = relationship('Author', secondary=books_authors, back_populates='books')

Проблемы и оптимизация

1. N+1 Query Problem:

# ❌ Неоптимально: 1 + n запросов
for author in session.query(Author).all():
    print(author.books)  # Дополнительный запрос для каждого автора!

# ✅ Оптимально: 1 запрос с eager loading
from sqlalchemy.orm import joinedload
authors = session.query(Author).options(joinedload('books')).all()
for author in authors:
    print(author.books)  # Уже загружены!

2. Циклические ссылки:

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    # Самоссылка: пользователь может быть рекомендован другим пользователем
    referrer_id = Column(Integer, ForeignKey('users.id'))
    referrer = relationship('User', remote_side=[id])

3. Индексирование:

-- Всегда индексируй ForeignKey для быстрых join операций
CREATE TABLE books (
    id INT PRIMARY KEY,
    title VARCHAR(200),
    author_id INT,
    FOREIGN KEY (author_id) REFERENCES authors(id),
    INDEX idx_author (author_id)  -- Индекс на ForeignKey
);

Best Practices

1. Всегда определяй on_delete поведение:

   # Django
   author = models.ForeignKey(Author, on_delete=models.CASCADE)
   
   # SQLAlchemy
   cascade='all, delete-orphan'
   

2. Используй lazy loading стратегии:

   # Eager loading
   authors = session.query(Author).options(joinedload('books')).all()
   
   # Или select_in для больших объёмов
   from sqlalchemy.orm import selectinload
   authors = session.query(Author).options(selectinload('books')).all()
   

3. Индексируй ForeignKey:

   CREATE INDEX idx_books_author ON books(author_id);
   

4. Тестируй целостность:

   # Проверка что ForeignKey работает
   with pytest.raises(IntegrityError):
       book = Book(title='Test', author_id=999)  # Несуществующий автор
       session.add(book)
       session.commit()
   

Итог

ForeignKey — это критически важный инструмент для:

• Связывания таблиц в реляционных БД
• Обеспечения целостности данных
• Определения отношений между сущностями (1-N, N-N)
• Предотвращения ошибок и некорректных данных

В Data Science при работе с SQL и ORM-фреймворками понимание ForeignKey необходимо для корректного проектирования БД и оптимизации запросов при обработке больших объёмов связанных данных.