[QueryDSL] 그룹과 조인

그루핑

@Test
public void selectGroup() {
    List<Item> items = qf.selectFrom(item)
                         .groupBy(item.price, item.id)
                         .having(item.price.gt(1000))
                         .fetch();
    System.out.println("items = " + items);
}

items = [Item(id=3, name=item2, price=2000, stockQuantity=2), Item(id=4, name=item3, price=3000, stockQuantity=3), Item(id=5, name=item4, price=4000, stockQuantity=4), Item(id=6, name=item5, price=5000, stockQuantity=5), Item(id=7, name=item6, price=6000, stockQuantity=6), ...

• group by 를 사용하여 그룹화된 결과 제한시
  • having 사용

조인

• 기본 조인 사용
  • 조인문법
    • join, leftjoin, rightJoin, fullJoin
    • 등의 메서드를 사용함

• 예제

  @BeforeEach
      public void beforeEach() {
          qf = new JPAQueryFactory(em);
          List<Item> items = new ArrayList<>();
          OrderItem orderItem = OrderItem.builder()
                                         .orderPrice(1000)
                                         .count(1)
                                         .build();
          Member member = new Member("상준", null);
          em.persist(member);
  
          Order order = new Order();        
          order.addItem(orderItem);
          order.addMember(member);
  
          for (int i = 0; i < 50; i++) {
              items.add(new Item("item" + i, i * 1000, i));
          }
  
          orderRepository.save(order);
          itemRepository.saveAll(items);
      }
  
  @Test
      public void selectLeftJoin() {
          List<Order> orders = qf.selectFrom(order)
                                 .join(order.member)
                                 .leftJoin(order.orderItems)
                                 .fetch();
          System.out.println("orders = " + orders);
          System.out.println("orders.get(0).getOrderItems() = " + orders.get(0)
                                                                        .getOrderItems());
      }

• on 절을 사용한 조인

  @Test
      public void selectLeftJoinOn() {
          List<Order> orders = qf.selectFrom(order)
                                 .leftJoin(order.orderItems, orderItem)
                                 .on(orderItem.count.gt(2))
                                 .fetch();
          
          System.out.println("orders = " + orders);
      }

  select o1_0.id,o1_0.member_id
   from orders o1_0
   left join orders_item o2_0 
  on o1_0.id=o2_0.order_id 
  and o2_0.count>2;

• 페치 조인
  • 연관된 엔티티나 컬렉션을 SQL 로 한번에 조회함.
  • LAZY 로딩을 별도로 타지 않음.

  @Test
      public void selectFetchJoin() {
          List<Order> orders = qf.selectFrom(order)
                                 .join(order.member, member)
                                 .fetchJoin()
                                 .leftJoin(order.orderItems, orderItem)
                                 .fetchJoin()
                                 .fetch();
      }

• 세타 조인
  • from 절에 여러 조인을 사용하는 전략
  • 두 테이블 간의 관계를 정의하지 않고도 조인이 가능하다.

  성능에 주의해야함.

  @Test
      public void selectThetaJoin() {
          List<Order> orders = qf.selectFrom(order)
                                 .where(order.member.name.eq("상준"))
                                 .fetch();
          
          System.out.println("orders = " + orders);
          System.out.println("orders = " + orders.get(0)
                                                 .getMember());
      }

  • 조인을 하긴하는데
  • 솔직히 겁나게 위험해 보인다.
  • name 값이 고유값이면 상관없어 보이긴하는데
  • 그게 아니라면 모든 데이터를 다 끌어올것이다.

Uploaded by N2T