Какой тип JOIN используешь для выведения данных о пользователе, даже если пустые строки?

LEFT JOIN для получения пользователей с пустыми данными

Краткий ответ

Для выведения данных о пользователе даже если связанные таблицы пусты используется LEFT JOIN (или LEFT OUTER JOIN). Это гарантирует, что все пользователи будут в результате, независимо от наличия данных в связанных таблицах.

Типы JOIN и их различия

1. INNER JOIN - только совпадающие строки

SELECT u.id, u.name, o.order_id, o.total
FROM users u
INNER JOIN orders o ON u.id = o.user_id;

-- Результат: только пользователи с заказами
-- Пользователи БЕЗ заказов НЕ будут в результате

Диаграмма:

users:     orders:
id name    id user_id total
1  Alice   1  1       100
2  Bob     2  1       200
3  Charlie 3  2       300
             (нет заказов от Charlie)

INNER JOIN результат:
id name    order_id total
1  Alice   1        100
1  Alice   2        200
2  Bob     3        300
(Charlie исчез!)

2. LEFT JOIN - все строки из левой таблицы

SELECT u.id, u.name, o.order_id, o.total
FROM users u
LEFT JOIN orders o ON u.id = o.user_id;

-- Результат: ВСЕ пользователи, независимо от заказов
-- Если заказов нет - NULL в полях orders

Диаграмма:

LEFT JOIN результат:
id name    order_id total
1  Alice   1        100
1  Alice   2        200
2  Bob     3        300
3  Charlie NULL     NULL  ← Charlie остался!

3. RIGHT JOIN - все строки из правой таблицы

SELECT u.id, u.name, o.order_id, o.total
FROM users u
RIGHT JOIN orders o ON u.id = o.user_id;

-- Результат: ВСЕ заказы, даже от удалённых пользователей

4. FULL OUTER JOIN - все строки из обеих таблиц

SELECT u.id, u.name, o.order_id, o.total
FROM users u
FULL OUTER JOIN orders o ON u.id = o.user_id;

-- Результат: ВСЕ пользователи И ВСЕ заказы

Практический пример: пользователи с пустыми заказами

-- Структура данных
CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(100)
);

CREATE TABLE orders (
    id INT PRIMARY KEY,
    user_id INT,
    total DECIMAL,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

-- Данные
INSERT INTO users VALUES
(1, 'Alice'),
(2, 'Bob'),
(3, 'Charlie'),
(4, 'Diana');

INSERT INTO orders VALUES
(1, 1, 100),
(2, 1, 200),
(3, 2, 150);
-- Charlie (3) и Diana (4) не имеют заказов

-- ❌ НЕПРАВИЛЬНО - потеряешь пользователей без заказов
SELECT u.id, u.name, COUNT(o.id) as order_count
FROM users u
INNER JOIN orders o ON u.id = o.user_id
GROUP BY u.id, u.name;

Результат:
id name   order_count
1  Alice  2
2  Bob    1
(Charlie и Diana пропали!)

-- ✅ ПРАВИЛЬНО - используй LEFT JOIN
SELECT u.id, u.name, COUNT(o.id) as order_count
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
GROUP BY u.id, u.name;

Результат:
id name    order_count
1  Alice   2
2  Bob     1
3  Charlie 0          ← Появился!
4  Diana   0          ← Появился!

LEFT JOIN в Hibernate/Spring Data JPA

1. Через JPQL (HQL)

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    @Query("SELECT u FROM User u LEFT JOIN u.orders o")
    List<User> getAllUsersWithOrders();
    
    @Query("SELECT u FROM User u " +
           "LEFT JOIN u.orders o " +
           "WHERE u.id = :userId")
    User getUserWithOrders(@Param("userId") Long userId);
}

2. Через Native SQL

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    @Query(value = 
        "SELECT u.id, u.name, o.id as order_id, o.total " +
        "FROM users u " +
        "LEFT JOIN orders o ON u.id = o.user_id",
        nativeQuery = true)
    List<Object[]> getAllUsersWithOrders();
}

3. Через QueryDSL

@Repository
public class UserRepositoryCustomImpl implements UserRepositoryCustom {
    
    @PersistenceContext
    private EntityManager em;
    
    public List<User> findAllWithOrders() {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<User> query = cb.createQuery(User.class);
        Root<User> root = query.from(User.class);
        
        // LEFT JOIN
        root.leftJoin("orders");
        
        return em.createQuery(query).getResultList();
    }
}

4. Через Specification

@Repository
public interface UserRepository extends JpaRepository<User, Long>,
    JpaSpecificationExecutor<User> {}

@Service
public class UserService {
    @Autowired
    private UserRepository repo;
    
    public List<User> findAllWithOrders() {
        Specification<User> spec = (root, query, cb) -> {
            root.leftJoin("orders"); // LEFT JOIN
            query.distinct(true); // DISTINCT для избежания дубликатов
            return cb.isNotNull(root.get("id"));
        };
        return repo.findAll(spec);
    }
}

Модели для примера

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    // LEFT JOIN будет получать и пустые списки
    @OneToMany(mappedBy = "user")
    private List<Order> orders = new ArrayList<>();
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
    
    private BigDecimal total;
}

Различие INNER JOIN vs LEFT JOIN

@Service
public class UserService {
    @Autowired
    private UserRepository repo;
    
    // ❌ Получит только пользователей с заказами
    public List<User> getAllUsersInner() {
        return em.createQuery(
            "SELECT u FROM User u " +
            "INNER JOIN u.orders o", // Или просто JOIN
            User.class
        ).getResultList();
    }
    
    // ✅ Получит ВСЕХ пользователей, даже без заказов
    public List<User> getAllUsersLeft() {
        return em.createQuery(
            "SELECT u FROM User u " +
            "LEFT JOIN u.orders o",
            User.class
        ).getResultList();
    }
}

Практический пример: вывод пользователей с информацией о заказах

@RestController
@RequestMapping("/api/v1/users")
public class UserController {
    @Autowired
    private UserService userService;
    
    @GetMapping("/with-orders")
    public List<UserDto> getAllUsersWithOrders() {
        return userService.getAllUsersWithOrders()
            .stream()
            .map(user -> UserDto.builder()
                .id(user.getId())
                .name(user.getName())
                .orderCount(user.getOrders().size())
                .totalSpent(calculateTotal(user.getOrders()))
                .build())
            .toList();
    }
    
    private BigDecimal calculateTotal(List<Order> orders) {
        return orders.stream()
            .map(Order::getTotal)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

// DTO для ответа
@Data
@Builder
public class UserDto {
    private Long id;
    private String name;
    private int orderCount; // 0 для пользователей без заказов
    private BigDecimal totalSpent;
}

Проблема N+1 при LEFT JOIN

// ❌ Проблема: каждый пользователь требует отдельный запрос для orders
List<User> users = repo.findAllWithOrders();
users.forEach(u -> System.out.println(u.getOrders().size()));
// Запросов: 1 + N (где N = количество пользователей)

// ✅ Решение 1: используй FETCH в JPQL
@Query("SELECT DISTINCT u FROM User u " +
       "LEFT JOIN FETCH u.orders")
List<User> findAllWithOrdersFetch();

// ✅ Решение 2: используй @EntityGraph
@EntityGraph(attributePaths = {"orders"})
@Query("SELECT u FROM User u")
List<User> findAllWithOrders();

// ✅ Решение 3: @Fetch аннотация
@OneToMany(mappedBy = "user")
@Fetch(FetchMode.JOIN)
List<Order> orders;

Сравнение JOIN типов

Выводы

1. LEFT JOIN — правильный выбор для получения пользователей с пустыми заказами
2. INNER JOIN потеряет данные — используй его только если точно нужны совпадения
3. В Hibernate используй: JPQL с LEFT JOIN или @EntityGraph
4. Помни про DISTINCT при LEFT JOIN GROUP BY
5. Избегай N+1 используя FETCH в JPQL или @EntityGraph