Как работает оператор EXISTS в SQL и когда его использовать?

Оператор EXISTS в SQL

EXISTS — логический оператор для проверки, существует ли хотя бы одна строка, соответствующая подзапросу. Возвращает TRUE/FALSE, не данные.

Синтаксис

WHERE EXISTS (
  SELECT 1
  FROM table
  WHERE condition
)

Замечание: в EXISTS обычно пишут SELECT 1, а не SELECT *, потому что EXISTS только проверяет наличие строк, не читает колонки.

EXISTS vs IN — разница и производительность

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

-- Способ 1: EXISTS (рекомендуемый)
SELECT user_id, name
FROM users u
WHERE EXISTS (
  SELECT 1
  FROM orders o
  WHERE o.user_id = u.user_id
);

-- Способ 2: IN (работает, но медленнее на больших данных)
SELECT user_id, name
FROM users u
WHERE user_id IN (
  SELECT DISTINCT user_id
  FROM orders
);

-- Способ 3: INNER JOIN (самый быстрый часто)
SELECT DISTINCT u.user_id, u.name
FROM users u
INNER JOIN orders o ON u.user_id = o.user_id;

Когда EXISTS быстрее:

• Подзапрос может остановиться после нахождения первого совпадения
• IN должен собрать все значения перед сравнением
• При большой выборке (миллионы строк) EXISTS более эффективен

1. NOT EXISTS — проверка отсутствия

-- Найти пользователей БЕЗ заказов (неактивные)
SELECT user_id, name, registered_at
FROM users u
WHERE NOT EXISTS (
  SELECT 1
  FROM orders o
  WHERE o.user_id = u.user_id
)
AND registered_at < NOW() - INTERVAL '30 days';

-- Практический пример: найти продукты, которые никогда не были куплены
SELECT product_id, name, created_at
FROM products p
WHERE NOT EXISTS (
  SELECT 1
  FROM order_items oi
  WHERE oi.product_id = p.product_id
)
ORDER BY created_at DESC;

2. EXISTS с условиями в подзапросе

-- Найти пользователей, которые потратили > $1000 в последние 30 дней
SELECT u.user_id, u.name
FROM users u
WHERE EXISTS (
  SELECT 1
  FROM orders o
  WHERE o.user_id = u.user_id
    AND o.created_at > NOW() - INTERVAL '30 days'
    AND o.total_amount > 1000
);

-- Найти категории, в которых были возвраты
SELECT DISTINCT c.category_id, c.name
FROM categories c
WHERE EXISTS (
  SELECT 1
  FROM products p
  WHERE p.category_id = c.category_id
    AND EXISTS (
      SELECT 1
      FROM returns r
      WHERE r.product_id = p.product_id
    )
);

3. EXISTS vs LEFT JOIN для поиска отсутствующих данных

-- Задача: найти заказы, у которых нет отслеживающих обновлений

-- Способ 1: NOT EXISTS (рекомендуемый, чистый)
SELECT o.order_id, o.user_id, o.created_at
FROM orders o
WHERE NOT EXISTS (
  SELECT 1
  FROM tracking_updates t
  WHERE t.order_id = o.order_id
);

-- Способ 2: LEFT JOIN с проверкой NULL
SELECT o.order_id, o.user_id, o.created_at
FROM orders o
LEFT JOIN tracking_updates t ON o.order_id = t.order_id
WHERE t.order_id IS NULL;

-- Оба способа имеют один результат, но EXISTS часто более эффективный

4. Практический пример: находка проблем с данными

-- Найти заказы, у которых количество = NULL, но есть цена
SELECT o.order_id, oi.product_id, oi.quantity, oi.unit_price
FROM order_items oi
JOIN orders o ON oi.order_id = o.order_id
WHERE oi.quantity IS NULL
  AND EXISTS (
    SELECT 1
    FROM order_items oi2
    WHERE oi2.order_id = o.order_id
      AND oi2.quantity IS NOT NULL
  )
LIMIT 100;

5. EXISTS в конструкции CASE

-- Классифицировать пользователей по активности
SELECT
  user_id,
  name,
  CASE
    WHEN EXISTS (
      SELECT 1 FROM orders WHERE user_id = u.user_id AND created_at > NOW() - INTERVAL '7 days'
    ) THEN 'active_weekly'
    
    WHEN EXISTS (
      SELECT 1 FROM orders WHERE user_id = u.user_id AND created_at > NOW() - INTERVAL '30 days'
    ) THEN 'active_monthly'
    
    WHEN EXISTS (
      SELECT 1 FROM orders WHERE user_id = u.user_id
    ) THEN 'inactive'
    
    ELSE 'never_purchased'
  END as user_segment
FROM users u;

6. EXISTS с DISTINCT — проверка уникальности

-- Найти пользователей, у которых были возвраты ДО первого заказа
-- (ошибка в данных)
SELECT u.user_id, u.name
FROM users u
WHERE EXISTS (
  SELECT 1
  FROM returns r
  WHERE r.user_id = u.user_id
    AND NOT EXISTS (
      SELECT 1
      FROM orders o
      WHERE o.user_id = u.user_id
        AND o.created_at < r.return_date
    )
);

7. Многоуровневые EXISTS

-- Найти категории, содержащие продукты, содержащие отзывы с рейтингом 5
SELECT DISTINCT c.category_id, c.name
FROM categories c
WHERE EXISTS (
  SELECT 1
  FROM products p
  WHERE p.category_id = c.category_id
    AND EXISTS (
      SELECT 1
      FROM reviews r
      WHERE r.product_id = p.product_id
        AND r.rating = 5
        AND EXISTS (
          SELECT 1
          FROM review_votes rv
          WHERE rv.review_id = r.review_id
            AND rv.is_helpful = TRUE
        )
    )
)
ORDER BY c.name;

Когда использовать EXISTS

✅ ИСПОЛЬЗУЙ EXISTS:

1. Проверка наличия связанных записей

   WHERE EXISTS (SELECT 1 FROM related_table WHERE ...)
   

   • Это самое частое использование
   • Лучше по производительности, чем IN

2. Логика отсутствия (NOT EXISTS)

   WHERE NOT EXISTS (SELECT 1 FROM ...)
   

   • Более читаемо, чем LEFT JOIN с проверкой NULL

3. Сложные условия в подзапросе

   WHERE EXISTS (SELECT 1 FROM t WHERE col > 100 AND ...
   

   • EXISTS позволяет использовать полную мощь WHERE

❌ НЕ ИСПОЛЬЗУЙ EXISTS:

1. Когда нужны колонки из подзапроса

   -- Неправильно
   SELECT u.*, o.order_id, o.total
   FROM users u
   WHERE EXISTS (SELECT order_id, total FROM orders ...)
   -- Нельзя получить колонки в SELECT
   

2. Когда INNER JOIN проще и понятнее

   -- EXISTS работает, но JOIN чище
   WHERE EXISTS (SELECT 1 FROM orders ...)
   -- vs
   INNER JOIN orders ...
   

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

-- Даны 100K пользователей и 10M заказов

-- Способ 1: EXISTS (БЫСТРО)
EXPLAIN ANALYZE
SELECT user_id FROM users u
WHERE EXISTS (SELECT 1 FROM orders WHERE user_id = u.user_id);
-- Seq Scan on users (можно использовать индекс на orders.user_id)
-- Пер проверка: ~0.2ms

-- Способ 2: IN (МЕДЛЕННЕЕ)
EXPLAIN ANALYZE
SELECT user_id FROM users
WHERE user_id IN (SELECT DISTINCT user_id FROM orders);
-- Subquery Scan -> Seq Scan on orders
-- Первая проверка: может быть медленнее, если нет индекса

-- Способ 3: JOIN (БЫСТРО)
EXPLAIN ANALYZE
SELECT DISTINCT u.user_id FROM users u
INNER JOIN orders o ON u.user_id = o.user_id;
-- Hash Join
-- Часто самый быстрый вариант

Чеклист

• ☑ EXISTS проверяет наличие, не возвращает данные
• ☑ NOT EXISTS для проверки отсутствия
• ☑ SELECT 1 в EXISTS (не SELECT *)
• ☑ Используй EXISTS вместо IN для больших подзапросов
• ☑ EXISTS часто быстрее LEFT JOIN для проверки наличия
• ☑ Индексы на подзапросе улучшат производительность
• ☑ Можно вкладывать EXISTS в EXISTS (но осторожно с читаемостью)

Главное: EXISTS — это элегантный и часто быстрый способ проверить наличие связанных данных без загрузки самих данных.