JAVA-66: New module spring-data-jpa-query

2020-07-19 14:31:01 +05:30
parent 7a86d7de49
commit 52da4c8ee8
41 changed files with 1532 additions and 0 deletions
@@ -0,0 +1,107 @@
+package com.baeldung.aggregation;
+
+import com.baeldung.aggregation.model.custom.CommentCount;
+import com.baeldung.aggregation.model.custom.ICommentCount;
+import com.baeldung.aggregation.repository.CommentRepository;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.jdbc.Sql;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest
+
+@Sql(scripts = "/test-aggregation-data.sql")
+public class SpringDataAggregateIntegrationTest {
+
+    @Autowired
+    private CommentRepository commentRepository;
+
+    @Test
+    public void whenQueryWithAggregation_thenReturnResult() {
+        List<Object[]> commentCountsByYear = commentRepository.countTotalCommentsByYear();
+
+        Object[] countYear2019 = commentCountsByYear.get(0);
+
+        assertThat(countYear2019[0], is(Integer.valueOf(2019)));
+        assertThat(countYear2019[1], is(1l));
+
+        Object[] countYear2018 = commentCountsByYear.get(1);
+
+        assertThat(countYear2018[0], is(Integer.valueOf(2018)));
+        assertThat(countYear2018[1], is(2l));
+
+        Object[] countYear2017 = commentCountsByYear.get(2);
+
+        assertThat(countYear2017[0], is(Integer.valueOf(2017)));
+        assertThat(countYear2017[1], is(1l));
+    }
+
+    @Test
+    public void whenQueryWithAggregation_thenReturnCustomResult() {
+        List<CommentCount> commentCountsByYear = commentRepository.countTotalCommentsByYearClass();
+
+        CommentCount countYear2019 = commentCountsByYear.get(0);
+
+        assertThat(countYear2019.getYear(), is(Integer.valueOf(2019)));
+        assertThat(countYear2019.getTotal(), is(1l));
+
+        CommentCount countYear2018 = commentCountsByYear.get(1);
+
+        assertThat(countYear2018.getYear(), is(Integer.valueOf(2018)));
+        assertThat(countYear2018.getTotal(), is(2l));
+
+        CommentCount countYear2017 = commentCountsByYear.get(2);
+
+        assertThat(countYear2017.getYear(), is(Integer.valueOf(2017)));
+        assertThat(countYear2017.getTotal(), is(1l));
+    }
+
+    @Test
+    public void whenQueryWithAggregation_thenReturnInterfaceResult() {
+        List<ICommentCount> commentCountsByYear = commentRepository.countTotalCommentsByYearInterface();
+
+        ICommentCount countYear2019 = commentCountsByYear.get(0);
+
+        assertThat(countYear2019.getYearComment(), is(Integer.valueOf(2019)));
+        assertThat(countYear2019.getTotalComment(), is(1l));
+
+        ICommentCount countYear2018 = commentCountsByYear.get(1);
+
+        assertThat(countYear2018.getYearComment(), is(Integer.valueOf(2018)));
+        assertThat(countYear2018.getTotalComment(), is(2l));
+
+        ICommentCount countYear2017 = commentCountsByYear.get(2);
+
+        assertThat(countYear2017.getYearComment(), is(Integer.valueOf(2017)));
+        assertThat(countYear2017.getTotalComment(), is(1l));
+    }
+
+    @Test
+    public void whenNativeQueryWithAggregation_thenReturnInterfaceResult() {
+        List<ICommentCount> commentCountsByYear = commentRepository.countTotalCommentsByYearNative();
+
+        ICommentCount countYear2019 = commentCountsByYear.get(0);
+
+        assertThat(countYear2019.getYearComment(), is(Integer.valueOf(2019)));
+        assertThat(countYear2019.getTotalComment(), is(1l));
+
+        ICommentCount countYear2018 = commentCountsByYear.get(1);
+
+        assertThat(countYear2018.getYearComment(), is(Integer.valueOf(2018)));
+        assertThat(countYear2018.getTotalComment(), is(2l));
+
+        ICommentCount countYear2017 = commentCountsByYear.get(2);
+
+        assertThat(countYear2017.getYearComment(), is(Integer.valueOf(2017)));
+        assertThat(countYear2017.getTotalComment(), is(1l));
+    }
+
+}
@@ -0,0 +1,67 @@
+package com.baeldung.boot.daos;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.domain.Article;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
+public class ArticleRepositoryIntegrationTest {
+
+    @Autowired
+    private ArticleRepository repository;
+
+    @Test
+    public void givenImportedArticlesWhenFindAllByPublicationDateThenArticles1And2Returned()
+      throws Exception {
+        List<Article> result = repository.findAllByPublicationDate(
+          new SimpleDateFormat("yyyy-MM-dd").parse("2018-01-01")
+        );
+
+        assertEquals(2, result.size());
+        assertTrue(result.stream()
+          .map(Article::getId)
+          .allMatch(id -> Arrays.asList(1, 2).contains(id))
+        );
+    }
+
+    @Test
+    public void givenImportedArticlesWhenFindAllByPublicationTimeBetweenThenArticles2And3Returned()
+      throws Exception {
+        List<Article> result = repository.findAllByPublicationTimeBetween(
+          new SimpleDateFormat("HH:mm").parse("15:15"),
+          new SimpleDateFormat("HH:mm").parse("16:30")
+        );
+
+        assertEquals(2, result.size());
+        assertTrue(result.stream()
+          .map(Article::getId)
+          .allMatch(id -> Arrays.asList(2, 3).contains(id))
+        );
+    }
+
+    @Test
+    public void givenImportedArticlesWhenFindAllWithCreationDateTimeBeforeThenArticles2And3Returned() throws Exception {
+        List<Article> result = repository.findAllWithCreationDateTimeBefore(
+          new SimpleDateFormat("yyyy-MM-dd HH:mm").parse("2017-12-15 10:00")
+        );
+
+        assertEquals(2, result.size());
+        assertTrue(result.stream()
+          .map(Article::getId)
+          .allMatch(id -> Arrays.asList(2, 3).contains(id))
+        );
+    }
+
+}
@@ -0,0 +1,190 @@
+package com.baeldung.boot.passenger;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.data.domain.Example;
+import org.springframework.data.domain.ExampleMatcher;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.passenger.Passenger;
+import com.baeldung.boot.passenger.PassengerRepository;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import java.util.List;
+import java.util.Optional;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+
+@DataJpaTest
+@RunWith(SpringRunner.class)
+public class PassengerRepositoryIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+    @Autowired
+    private PassengerRepository repository;
+
+    @Before
+    public void before() {
+        entityManager.persist(Passenger.from("Jill", "Smith", 50));
+        entityManager.persist(Passenger.from("Eve", "Jackson", 95));
+        entityManager.persist(Passenger.from("Fred", "Bloggs", 22));
+        entityManager.persist(Passenger.from("Ricki", "Bobbie", 36));
+        entityManager.persist(Passenger.from("Siya", "Kolisi", 85));
+    }
+
+    @Test
+    public void givenSeveralPassengersWhenOrderedBySeatNumberLimitedToThenThePassengerInTheFirstFilledSeatIsReturned() {
+        Passenger expected = Passenger.from("Fred", "Bloggs", 22);
+
+        List<Passenger> passengers = repository.findOrderedBySeatNumberLimitedTo(1);
+
+        assertEquals(1, passengers.size());
+
+        Passenger actual = passengers.get(0);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void givenSeveralPassengersWhenFindFirstByOrderBySeatNumberAscThenThePassengerInTheFirstFilledSeatIsReturned() {
+        Passenger expected = Passenger.from("Fred", "Bloggs", 22);
+
+        Passenger actual = repository.findFirstByOrderBySeatNumberAsc();
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void givenSeveralPassengersWhenFindPageSortedByThenThePassengerInTheFirstFilledSeatIsReturned() {
+        Passenger expected = Passenger.from("Fred", "Bloggs", 22);
+
+        Page<Passenger> page = repository.findAll(PageRequest.of(0, 1,
+          Sort.by(Sort.Direction.ASC, "seatNumber")));
+
+        assertEquals(1, page.getContent().size());
+
+        Passenger actual = page.getContent().get(0);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void givenPassengers_whenOrderedBySeatNumberAsc_thenCorrectOrder() {
+        Passenger fred = Passenger.from("Fred", "Bloggs", 22);
+        Passenger ricki = Passenger.from("Ricki", "Bobbie", 36);
+        Passenger jill = Passenger.from("Jill", "Smith", 50);
+        Passenger siya = Passenger.from("Siya", "Kolisi", 85);
+        Passenger eve = Passenger.from("Eve", "Jackson", 95);
+
+        List<Passenger> passengers = repository.findByOrderBySeatNumberAsc();
+
+        assertThat(passengers, contains(fred, ricki, jill, siya, eve));
+    }
+
+    @Test
+    public void givenPassengers_whenFindAllWithSortBySeatNumberAsc_thenCorrectOrder() {
+        Passenger fred = Passenger.from("Fred", "Bloggs", 22);
+        Passenger ricki = Passenger.from("Ricki", "Bobbie", 36);
+        Passenger jill = Passenger.from("Jill", "Smith", 50);
+        Passenger siya = Passenger.from("Siya", "Kolisi", 85);
+        Passenger eve = Passenger.from("Eve", "Jackson", 95);
+
+        List<Passenger> passengers = repository.findAll(Sort.by(Sort.Direction.ASC, "seatNumber"));
+
+        assertThat(passengers, contains(fred, ricki, jill, siya, eve));
+    }
+
+    @Test
+    public void givenPassengers_whenFindByExampleDefaultMatcher_thenExpectedReturned() {
+        Example<Passenger> example = Example.of(Passenger.from("Fred", "Bloggs", null));
+
+        Optional<Passenger> actual = repository.findOne(example);
+
+        assertTrue(actual.isPresent());
+        assertEquals(Passenger.from("Fred", "Bloggs", 22), actual.get());
+    }
+
+    @Test
+    public void givenPassengers_whenFindByExampleCaseInsensitiveMatcher_thenExpectedReturned() {
+        ExampleMatcher caseInsensitiveExampleMatcher = ExampleMatcher.matchingAll().withIgnoreCase();
+        Example<Passenger> example = Example.of(Passenger.from("fred", "bloggs", null),
+          caseInsensitiveExampleMatcher);
+
+        Optional<Passenger> actual = repository.findOne(example);
+
+        assertTrue(actual.isPresent());
+        assertEquals(Passenger.from("Fred", "Bloggs", 22), actual.get());
+    }
+
+    @Test
+    public void givenPassengers_whenFindByExampleCustomMatcher_thenExpectedReturned() {
+        Passenger jill = Passenger.from("Jill", "Smith", 50);
+        Passenger eve = Passenger.from("Eve", "Jackson", 95);
+        Passenger fred = Passenger.from("Fred", "Bloggs", 22);
+        Passenger siya = Passenger.from("Siya", "Kolisi", 85);
+        Passenger ricki = Passenger.from("Ricki", "Bobbie", 36);
+
+        ExampleMatcher customExampleMatcher = ExampleMatcher.matchingAny().withMatcher("firstName",
+          ExampleMatcher.GenericPropertyMatchers.contains().ignoreCase()).withMatcher("lastName",
+          ExampleMatcher.GenericPropertyMatchers.contains().ignoreCase());
+
+        Example<Passenger> example = Example.of(Passenger.from("e", "s", null),
+          customExampleMatcher);
+
+        List<Passenger> passengers = repository.findAll(example);
+
+        assertThat(passengers, contains(jill, eve, fred, siya));
+        assertThat(passengers, not(contains(ricki)));
+    }
+
+    @Test
+    public void givenPassengers_whenFindByIgnoringMatcher_thenExpectedReturned() {
+        Passenger jill = Passenger.from("Jill", "Smith", 50);
+        Passenger eve = Passenger.from("Eve", "Jackson", 95);
+        Passenger fred = Passenger.from("Fred", "Bloggs", 22);
+        Passenger siya = Passenger.from("Siya", "Kolisi", 85);
+        Passenger ricki = Passenger.from("Ricki", "Bobbie", 36);
+
+        ExampleMatcher ignoringExampleMatcher = ExampleMatcher.matchingAny().withMatcher("lastName",
+            ExampleMatcher.GenericPropertyMatchers.startsWith().ignoreCase()).withIgnorePaths("firstName", "seatNumber");
+
+        Example<Passenger> example = Example.of(Passenger.from(null, "b", null),
+            ignoringExampleMatcher);
+
+        List<Passenger> passengers = repository.findAll(example);
+
+        assertThat(passengers, contains(fred, ricki));
+        assertThat(passengers, not(contains(jill)));
+        assertThat(passengers, not(contains(eve)));
+        assertThat(passengers, not(contains(siya)));
+    }
+
+    @Test
+    public void givenPassengers_whenMatchingIgnoreCase_thenExpectedReturned() {
+        Passenger jill = Passenger.from("Jill", "Smith", 50);
+        Passenger eve = Passenger.from("Eve", "Jackson", 95);
+        Passenger fred = Passenger.from("Fred", "Bloggs", 22);
+        Passenger siya = Passenger.from("Siya", "Kolisi", 85);
+        Passenger ricki = Passenger.from("Ricki", "Bobbie", 36);
+
+        List<Passenger> passengers = repository.findByFirstNameIgnoreCase("FRED");
+
+        assertThat(passengers, contains(fred));
+        assertThat(passengers, not(contains(eve)));
+        assertThat(passengers, not(contains(siya)));
+        assertThat(passengers, not(contains(jill)));
+        assertThat(passengers, not(contains(ricki)));
+
+    }
+}
@@ -0,0 +1,39 @@
+package com.baeldung.entitygraph;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.jdbc.Sql;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.entitygraph.model.Characteristic;
+import com.baeldung.entitygraph.model.Item;
+import com.baeldung.entitygraph.repository.CharacteristicsRepository;
+import com.baeldung.entitygraph.repository.ItemRepository;
+
+@DataJpaTest
+@RunWith(SpringRunner.class)
+@Sql(scripts = "/entitygraph-data.sql")
+public class EntityGraphIntegrationTest {
+   
+    @Autowired
+    private ItemRepository itemRepo;
+    
+    @Autowired
+    private CharacteristicsRepository characteristicsRepo;
+    
+    @Test
+    public void givenEntityGraph_whenCalled_shouldRetrunDefinedFields() {
+        Item item = itemRepo.findByName("Table");
+        assertThat(item.getId()).isEqualTo(1L);
+    }
+    
+    @Test
+    public void givenAdhocEntityGraph_whenCalled_shouldRetrunDefinedFields() {
+        Characteristic characteristic = characteristicsRepo.findByType("Rigid");
+        assertThat(characteristic.getId()).isEqualTo(1L);
+    }
+}
@@ -0,0 +1,87 @@
+package com.baeldung.exists;
+
+import com.baeldung.Application;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.domain.Example;
+import org.springframework.data.domain.ExampleMatcher;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.data.domain.ExampleMatcher.GenericPropertyMatchers.ignoreCase;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = {Application.class})
+public class CarRepositoryIntegrationTest {
+
+    @Autowired
+    private CarRepository repository;
+    private int searchId;
+
+    @Before
+    public void setup() {
+        List<Car> cars = repository.saveAll(Arrays.asList(new Car(200, "BMW"), new Car(300, "Audi")));
+        searchId = cars.get(0).getId();
+    }
+
+    @After
+    public void teardown() {
+        repository.deleteAll();
+    }
+
+    @Test
+    public void whenIdIsCorrect_thenExistsShouldReturnTrue() {
+        assertThat(repository.existsById(searchId)).isTrue();
+    }
+
+    @Test
+    public void givenExample_whenExists_thenIsTrue() {
+        ExampleMatcher modelMatcher = ExampleMatcher.matching()
+                .withIgnorePaths("id") // must explicitly ignore -> PK
+                .withMatcher("model", ignoreCase());
+        Car probe = new Car();
+        probe.setModel("bmw");
+
+        Example<Car> example = Example.of(probe, modelMatcher);
+
+        assertThat(repository.exists(example)).isTrue();
+    }
+
+    @Test
+    public void givenPower_whenExists_thenIsFalse() {
+        assertThat(repository.existsCarByPower(200)).isTrue();
+        assertThat(repository.existsCarByPower(800)).isFalse();
+    }
+
+    @Test
+    public void existsByDerivedQuery_byModel() {
+        assertThat(repository.existsCarByModel("Audi")).isTrue();
+        assertThat(repository.existsCarByModel("audi")).isFalse();
+        assertThat(repository.existsCarByModel("AUDI")).isFalse();
+        assertThat(repository.existsCarByModel("")).isFalse();
+    }
+
+    @Test
+    public void givenModelName_whenExistsExact_thenIsTrue() {
+        assertThat(repository.existsCarExactCustomQuery("BMW")).isTrue();
+        assertThat(repository.existsCarExactCustomQuery("Bmw")).isFalse();
+        assertThat(repository.existsCarExactCustomQuery("bmw")).isFalse();
+        assertThat(repository.existsCarExactCustomQuery("")).isFalse();
+    }
+
+    @Test
+    public void givenModelName_whenExistsLike_thenIsTrue() {
+        assertThat(repository.existsCarLikeCustomQuery("BMW")).isTrue();
+        assertThat(repository.existsCarLikeCustomQuery("Bmw")).isTrue();
+        assertThat(repository.existsCarLikeCustomQuery("bmw")).isTrue();
+        assertThat(repository.existsCarLikeCustomQuery("")).isFalse();
+    }
+
+}
@@ -0,0 +1,142 @@
+package com.baeldung.joins;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.baeldung.joins.model.Department;
+import com.baeldung.joins.model.Phone;
+import java.util.Collection;
+import java.util.List;
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.TypedQuery;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest
+@ActiveProfiles("joins")
+public class JpaJoinsIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Test
+    public void whenPathExpressionIsUsedForSingleValuedAssociation_thenCreatesImplicitInnerJoin() {
+        TypedQuery<Department> query = entityManager.createQuery("SELECT e.department FROM Employee e", Department.class);
+
+        List<Department> resultList = query.getResultList();
+
+        assertThat(resultList).hasSize(3);
+        assertThat(resultList).extracting("name")
+            .containsOnly("Infra", "Accounting", "Accounting");
+    }
+
+    @Test
+    public void whenJoinKeywordIsUsed_thenCreatesExplicitInnerJoin() {
+        TypedQuery<Department> query = entityManager.createQuery("SELECT d FROM Employee e JOIN e.department d", Department.class);
+
+        List<Department> resultList = query.getResultList();
+
+        assertThat(resultList).hasSize(3);
+        assertThat(resultList).extracting("name")
+            .containsOnly("Infra", "Accounting", "Accounting");
+    }
+
+    @Test
+    public void whenInnerJoinKeywordIsUsed_thenCreatesExplicitInnerJoin() {
+        TypedQuery<Department> query = entityManager.createQuery("SELECT d FROM Employee e INNER JOIN e.department d", Department.class);
+
+        List<Department> resultList = query.getResultList();
+
+        assertThat(resultList).hasSize(3);
+        assertThat(resultList).extracting("name")
+            .containsOnly("Infra", "Accounting", "Accounting");
+    }
+
+    @Test
+    public void whenEntitiesAreListedInFromAndMatchedInWhere_ThenCreatesJoin() {
+        TypedQuery<Department> query = entityManager.createQuery("SELECT d FROM Employee e, Department d WHERE e.department = d", Department.class);
+
+        List<Department> resultList = query.getResultList();
+
+        assertThat(resultList).hasSize(3);
+        assertThat(resultList).extracting("name")
+            .containsOnly("Infra", "Accounting", "Accounting");
+    }
+
+    @Test
+    public void whenEntitiesAreListedInFrom_ThenCreatesCartesianProduct() {
+        TypedQuery<Department> query = entityManager.createQuery("SELECT d FROM Employee e, Department d", Department.class);
+
+        List<Department> resultList = query.getResultList();
+
+        assertThat(resultList).hasSize(9);
+        assertThat(resultList).extracting("name")
+            .containsOnly("Infra", "Accounting", "Management", "Infra", "Accounting", "Management", "Infra", "Accounting", "Management");
+    }
+
+    @Test
+    public void whenCollectionValuedAssociationIsJoined_ThenCanSelect() {
+        TypedQuery<Phone> query = entityManager.createQuery("SELECT ph FROM Employee e JOIN e.phones ph WHERE ph LIKE '1%'", Phone.class);
+
+        List<Phone> resultList = query.getResultList();
+
+        assertThat(resultList).hasSize(1);
+    }
+
+    @Test
+    public void whenMultipleEntitiesAreListedWithJoin_ThenCreatesMultipleJoins() {
+        TypedQuery<Phone> query = entityManager.createQuery("SELECT ph FROM Employee e JOIN e.department d JOIN e.phones ph WHERE d.name IS NOT NULL", Phone.class);
+
+        List<Phone> resultList = query.getResultList();
+
+        assertThat(resultList).hasSize(3);
+        assertThat(resultList).extracting("number")
+            .containsOnly("111", "222", "333");
+    }
+
+    @Test
+    public void whenLeftKeywordIsSpecified_thenCreatesOuterJoinAndIncludesNonMatched() {
+        TypedQuery<Department> query = entityManager.createQuery("SELECT DISTINCT d FROM Department d LEFT JOIN d.employees e", Department.class);
+
+        List<Department> resultList = query.getResultList();
+
+        assertThat(resultList).hasSize(3);
+        assertThat(resultList).extracting("name")
+            .containsOnly("Infra", "Accounting", "Management");
+    }
+
+    @Test
+    public void whenFetchKeywordIsSpecified_ThenCreatesFetchJoin() {
+        TypedQuery<Department> query = entityManager.createQuery("SELECT d FROM Department d JOIN FETCH d.employees", Department.class);
+
+        List<Department> resultList = query.getResultList();
+
+        assertThat(resultList).hasSize(3);
+        assertThat(resultList).extracting("name")
+            .containsOnly("Infra", "Accounting", "Accounting");
+    }
+
+    @Test
+    public void whenLeftAndFetchKeywordsAreSpecified_ThenCreatesOuterFetchJoin() {
+        TypedQuery<Department> query = entityManager.createQuery("SELECT d FROM Department d LEFT JOIN FETCH d.employees", Department.class);
+
+        List<Department> resultList = query.getResultList();
+
+        assertThat(resultList).hasSize(4);
+        assertThat(resultList).extracting("name")
+            .containsOnly("Infra", "Accounting", "Accounting", "Management");
+    }
+
+    @Test
+    public void whenCollectionValuedAssociationIsSpecifiedInSelect_ThenReturnsCollections() {
+        TypedQuery<Collection> query = entityManager.createQuery("SELECT e.phones FROM Employee e", Collection.class);
+
+        List<Collection> resultList = query.getResultList();
+
+        assertThat(resultList).extracting("number").containsOnly("111", "222", "333");
+    }
+}
@@ -0,0 +1,7 @@
+INSERT INTO Item(id,name) VALUES (1,'Table');
+INSERT INTO Item(id,name) VALUES (2,'Bottle');
+
+INSERT INTO Characteristic(id,item_id, type) VALUES (1,1,'Rigid');
+INSERT INTO Characteristic(id,item_id,type) VALUES (2,1,'Big');
+INSERT INTO Characteristic(id,item_id,type) VALUES (3,2,'Fragile');
+INSERT INTO Characteristic(id,item_id,type) VALUES (4,2,'Small');
@@ -0,0 +1,2 @@
+DELETE FROM address;
+DELETE FROM person;
@@ -0,0 +1,2 @@
+INSERT INTO person(id,first_name,last_name) VALUES (1,'John','Doe');
+INSERT INTO address(id,person_id,state,city,street,zip_code) VALUES (1,1,'CA', 'Los Angeles', 'Standford Ave', '90001');
@@ -0,0 +1,7 @@
+INSERT INTO post (id, title, content) VALUES (1, 'Comment 1', 'Content 1');
+INSERT INTO post (id, title, content) VALUES (2, 'Comment 2', 'Content 2');
+INSERT INTO post (id, title, content) VALUES (3, 'Comment 3', 'Content 3');
+INSERT INTO comment (id, year, approved, content, post_id) VALUES (1, 2019, false, 'Comment 1', 1);
+INSERT INTO comment (id, year, approved, content, post_id) VALUES (2, 2018, true, 'Comment 2', 1);
+INSERT INTO comment (id, year, approved, content, post_id) VALUES (3, 2018, true, 'Comment 3', 2);
+INSERT INTO comment (id, year, approved, content, post_id) VALUES (4, 2017, false, 'Comment 4', 3);
@@ -0,0 +1,6 @@
+truncate table fruit;
+
+insert into fruit(id,name,color) values (1,'apple','red');
+insert into fruit(id,name,color) values (2,'custard apple','green');
+insert into fruit(id,name,color) values (3,'mango','yellow');
+insert into fruit(id,name,color) values (4,'guava','green');