Как сделать JOIN без JOIN в SQL?

Как сделать JOIN без явного оператора JOIN

Зачастую разработчики спрашивают это из любопытства или для оптимизации. Есть несколько способов имитировать JOIN без использования ключевого слова JOIN.

1. WHERE подстановка (WHERE clause вместо JOIN)

Самый распространённый способ. Вместо JOIN используем WHERE с условием на совпадение.

-- С JOIN
SELECT u.id, u.name, p.title
FROM users u
JOIN posts p ON u.id = p.user_id
WHERE u.created_at > '2024-01-01';

-- Без JOIN (WHERE подстановка)
SELECT u.id, u.name, p.title
FROM users u, posts p
WHERE u.id = p.user_id
  AND u.created_at > '2024-01-01';

Оба запроса эквивалентны. Оптимизатор SQL обработает их одинаково.

Кросс-произведение + WHERE:

-- Без JOIN
SELECT u.id, u.name, p.title
FROM users, posts
WHERE users.id = posts.user_id;

-- С JOIN
SELECT u.id, u.name, p.title
FROM users
JOIN posts ON users.id = posts.user_id;

Мы создаём кросс-произведение (все строки из users × все строки из posts), а потом фильтруем WHERE.

2. Подзапросы (subqueries)

Другой способ — использовать подзапросы вместо JOIN.

-- С JOIN
SELECT u.id, u.name, 
       (SELECT COUNT(*) FROM posts WHERE posts.user_id = u.id) as post_count
FROM users u;

-- Это эквивалентно:
SELECT u.id, u.name, COUNT(p.id) as post_count
FROM users u
LEFT JOIN posts p ON u.id = p.user_id
GROUP BY u.id;

EXISTS для проверки наличия:

-- Без JOIN
SELECT *
FROM users u
WHERE EXISTS (
    SELECT 1
    FROM posts p
    WHERE p.user_id = u.id
);

-- С JOIN
SELECT DISTINCT u.*
FROM users u
INNER JOIN posts p ON u.id = p.user_id;

IN подзапрос:

-- Без JOIN
SELECT *
FROM users
WHERE id IN (
    SELECT DISTINCT user_id
    FROM posts
    WHERE created_at > '2024-01-01'
);

-- С JOIN
SELECT DISTINCT u.*
FROM users u
INNER JOIN posts p ON u.id = p.user_id
WHERE p.created_at > '2024-01-01';

3. Union (объединение)

Для более сложных сценариев можно использовать UNION.

-- Вместо FULL OUTER JOIN
SELECT u.id, u.name, p.title
FROM users u
LEFT JOIN posts p ON u.id = p.user_id
UNION
SELECT u.id, u.name, p.title
FROM users u
RIGHT JOIN posts p ON u.id = p.user_id;

-- Без OUTER JOIN:
SELECT u.id, u.name, p.title
FROM users u, posts p
WHERE u.id = p.user_id
UNION
SELECT u.id, u.name, NULL
FROM users u
WHERE u.id NOT IN (SELECT user_id FROM posts);

4. Window Functions (оконные функции)

Для некоторых операций можно использовать window functions.

-- JOIN для получения информации о пользователе в каждом посте
SELECT p.id, p.title, 
       FIRST_VALUE(u.name) OVER (PARTITION BY p.user_id) as user_name
FROM posts p
JOIN users u ON p.user_id = u.id;

-- Без явного JOIN (но так обычно не делают — это костыль):
SELECT p.id, p.title,
       FIRST_VALUE(u.name) OVER (ORDER BY p.user_id) as user_name
FROM posts p, users u
WHERE p.user_id = u.id;

5. Денормализация (denormalization)

Хранить нужные данные прямо в таблице. Это не SQL без JOIN, но избегает необходимости в JOIN.

# Было: JOIN двух таблиц
SELECT u.name, p.title
FROM users u
JOIN posts p ON u.id = p.user_id;

# Стало: денормализованная таблица
# posts таблица имеет дополнительное поле user_name
SELECT user_name, title
FROM posts;

Минусы: сложность синхронизации при обновлениях.

6. Практический пример в Python с SQLAlchemy

from sqlalchemy import select, and_

# С JOIN
stmt = select(User, Post).join(
    Post, User.id == Post.user_id
)
results = db.execute(stmt).all()

# Без JOIN (использование WHERE)
stmt = select(User, Post).where(
    User.id == Post.user_id
)
results = db.execute(stmt).all()

# С подзапросом
subquery = select(Post.user_id).distinct()
stmt = select(User).where(User.id.in_(subquery))
users = db.execute(stmt).scalars().all()

# С EXISTS
subquery = select(1).where(
    and_(
        Post.user_id == User.id,
        Post.created_at > '2024-01-01'
    )
)
stmt = select(User).where(select(subquery).correlate(User).exists())
results = db.execute(stmt).scalars().all()

Производительность

WHERE подстановка vs JOIN:

• Современные БД оптимизируют одинаково
• PostgreSQL, MySQL, SQL Server преобразуют WHERE в JOIN при анализе
• Читаемость кода лучше с явным JOIN

Подзапросы vs JOIN:

• Подзапросы часто медленнее
• Особенно если подзапрос не коррелированный
• JOIN обычно быстрее для больших таблиц

EXISTS vs JOIN:

• EXISTS быстрее для проверки наличия
• JOIN лучше для получения данных

Практические рекомендации

1. Используй явный JOIN — это стандарт, понятнее для чтения
2. WHERE подстановка — приемлемо, но менее понятно
3. Избегай подзапросов — обычно медленнее
4. EXISTS для EXISTS — если нужно только проверить наличие
5. Профилируй запросы — используй EXPLAIN ANALYZE

Вопрос "без JOIN" обычно задают для проверки понимания SQL. На практике всегда используй явный JOIN — это лучшая практика.