Merge branch 'master' into bael-16656

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/Application.java

@@ -0,0 +1,12 @@
+package com.baeldung;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/batchinserts/DatasourceProxyBeanPostProcessor.java

@@ -0,0 +1,53 @@
+package com.baeldung.batchinserts;
+
+import java.lang.reflect.Method;
+import javax.sql.DataSource;
+import net.ttddyy.dsproxy.support.ProxyDataSourceBuilder;
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+import org.springframework.aop.framework.ProxyFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Component;
+import org.springframework.util.ReflectionUtils;
+
+@Component
+@Profile("batchinserts")
+public class DatasourceProxyBeanPostProcessor implements BeanPostProcessor {
+
+    @Override
+    public Object postProcessBeforeInitialization(final Object bean, final String beanName) throws BeansException {
+        return bean;
+    }
+
+    @Override
+    public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException {
+        if (bean instanceof DataSource) {
+            ProxyFactory factory = new ProxyFactory(bean);
+            factory.setProxyTargetClass(true);
+            factory.addAdvice(new ProxyDataSourceInterceptor((DataSource) bean));
+            return factory.getProxy();
+        }
+
+        return bean;
+    }
+
+    private static class ProxyDataSourceInterceptor implements MethodInterceptor {
+
+        private final DataSource dataSource;
+
+        public ProxyDataSourceInterceptor(final DataSource dataSource) {
+            this.dataSource = ProxyDataSourceBuilder.create(dataSource).name("Batch-Insert-Logger").asJson().countQuery().logQueryToSysOut().build();
+        }
+
+        @Override
+        public Object invoke(final MethodInvocation invocation) throws Throwable {
+            Method proxyMethod = ReflectionUtils.findMethod(dataSource.getClass(), invocation.getMethod().getName());
+            if (proxyMethod != null) {
+                return proxyMethod.invoke(dataSource, invocation.getArguments());
+            }
+            return invocation.proceed();
+        }
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/batchinserts/model/School.java

@@ -0,0 +1,45 @@
+package com.baeldung.batchinserts.model;
+
+import java.util.List;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.OneToMany;
+
+@Entity
+public class School {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE)
+    private long id;
+
+    private String name;
+
+    @OneToMany(mappedBy = "school")
+    private List<Student> students;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<Student> getStudents() {
+        return students;
+    }
+
+    public void setStudents(List<Student> students) {
+        this.students = students;
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/batchinserts/model/Student.java

@@ -0,0 +1,44 @@
+package com.baeldung.batchinserts.model;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.ManyToOne;
+
+@Entity
+public class Student {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE)
+    private long id;
+
+    private String name;
+
+    @ManyToOne
+    private School school;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public School getSchool() {
+        return school;
+    }
+
+    public void setSchool(School school) {
+        this.school = school;
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/Application.java

@@ -0,0 +1,17 @@
+package com.baeldung.boot;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+
+@SpringBootApplication
+@EnableJpaRepositories("com.baeldung")
+@EntityScan("com.baeldung")
+public class Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/daos/impl/PersonInsertRepository.java

@@ -0,0 +1,31 @@
+package com.baeldung.boot.daos.impl;
+
+import org.springframework.stereotype.Repository;
+
+import com.baeldung.boot.domain.Person;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.transaction.Transactional;
+
+@Repository
+public class PersonInsertRepository {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Transactional
+    public void insertWithQuery(Person person) {
+        entityManager.createNativeQuery("INSERT INTO person (id, first_name, last_name) VALUES (?,?,?)")
+          .setParameter(1, person.getId())
+          .setParameter(2, person.getFirstName())
+          .setParameter(3, person.getLastName())
+          .executeUpdate();
+    }
+
+    @Transactional
+    public void insertWithEntityManager(Person person) {
+        this.entityManager.persist(person);
+    }
+
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/daos/user/UserRepository.java

@@ -0,0 +1,99 @@
+package com.baeldung.boot.daos.user;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import com.baeldung.boot.domain.User;
+
+import java.time.LocalDate;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Stream;
+
+public interface UserRepository extends JpaRepository<User, Integer> , UserRepositoryCustom{
+
+    Stream<User> findAllByName(String name);
+
+    @Query("SELECT u FROM User u WHERE u.status = 1")
+    Collection<User> findAllActiveUsers();
+    
+    @Query("select u from User u where u.email like '%@gmail.com'")
+    List<User> findUsersWithGmailAddress();
+
+    @Query(value = "SELECT * FROM Users u WHERE u.status = 1", nativeQuery = true)
+    Collection<User> findAllActiveUsersNative();
+
+    @Query("SELECT u FROM User u WHERE u.status = ?1")
+    User findUserByStatus(Integer status);
+
+    @Query(value = "SELECT * FROM Users u WHERE u.status = ?1", nativeQuery = true)
+    User findUserByStatusNative(Integer status);
+
+    @Query("SELECT u FROM User u WHERE u.status = ?1 and u.name = ?2")
+    User findUserByStatusAndName(Integer status, String name);
+
+    @Query("SELECT u FROM User u WHERE u.status = :status and u.name = :name")
+    User findUserByStatusAndNameNamedParams(@Param("status") Integer status, @Param("name") String name);
+
+    @Query(value = "SELECT * FROM Users u WHERE u.status = :status AND u.name = :name", nativeQuery = true)
+    User findUserByStatusAndNameNamedParamsNative(@Param("status") Integer status, @Param("name") String name);
+
+    @Query("SELECT u FROM User u WHERE u.status = :status and u.name = :name")
+    User findUserByUserStatusAndUserName(@Param("status") Integer userStatus, @Param("name") String userName);
+
+    @Query("SELECT u FROM User u WHERE u.name like ?1%")
+    User findUserByNameLike(String name);
+
+    @Query("SELECT u FROM User u WHERE u.name like :name%")
+    User findUserByNameLikeNamedParam(@Param("name") String name);
+
+    @Query(value = "SELECT * FROM users u WHERE u.name LIKE ?1%", nativeQuery = true)
+    User findUserByNameLikeNative(String name);
+
+    @Query(value = "SELECT u FROM User u")
+    List<User> findAllUsers(Sort sort);
+
+    @Query(value = "SELECT u FROM User u ORDER BY id")
+    Page<User> findAllUsersWithPagination(Pageable pageable);
+
+    @Query(value = "SELECT * FROM Users ORDER BY id", countQuery = "SELECT count(*) FROM Users", nativeQuery = true)
+    Page<User> findAllUsersWithPaginationNative(Pageable pageable);
+
+    @Modifying
+    @Query("update User u set u.status = :status where u.name = :name")
+    int updateUserSetStatusForName(@Param("status") Integer status, @Param("name") String name);
+
+    @Modifying
+    @Query(value = "UPDATE Users u SET u.status = ? WHERE u.name = ?", nativeQuery = true)
+    int updateUserSetStatusForNameNative(Integer status, String name);
+
+    @Query(value = "INSERT INTO Users (name, age, email, status, active) VALUES (:name, :age, :email, :status, :active)", nativeQuery = true)
+    @Modifying
+    void insertUser(@Param("name") String name, @Param("age") Integer age, @Param("email") String email, @Param("status") Integer status, @Param("active") boolean active);
+    
+    @Modifying
+    @Query(value = "UPDATE Users u SET status = ? WHERE u.name = ?", nativeQuery = true)
+    int updateUserSetStatusForNameNativePostgres(Integer status, String name);
+    
+    @Query(value = "SELECT u FROM User u WHERE u.name IN :names")
+	  List<User> findUserByNameList(@Param("names") Collection<String> names);
+    
+    void deleteAllByCreationDateAfter(LocalDate date);
+
+    @Modifying(clearAutomatically = true, flushAutomatically = true)
+    @Query("update User u set u.active = false where u.lastLoginDate < :date")
+    void deactivateUsersNotLoggedInSince(@Param("date") LocalDate date);
+
+    @Modifying(clearAutomatically = true, flushAutomatically = true)
+    @Query("delete User u where u.active = false")
+    int deleteDeactivatedUsers();
+
+    @Modifying(clearAutomatically = true, flushAutomatically = true)
+    @Query(value = "alter table USERS add column deleted int(1) not null default 0", nativeQuery = true)
+    void addDeletedColumn();
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/daos/user/UserRepositoryCustom.java

@@ -0,0 +1,14 @@
+package com.baeldung.boot.daos.user;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import com.baeldung.boot.domain.User;
+
+public interface UserRepositoryCustom {
+    List<User> findUserByEmails(Set<String> emails);
+    
+    List<User> findAllUsersByPredicates(Collection<Predicate<User>> predicates);
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/daos/user/UserRepositoryCustomImpl.java

@@ -0,0 +1,57 @@
+package com.baeldung.boot.daos.user;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Path;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+
+import com.baeldung.boot.domain.User;
+
+public class UserRepositoryCustomImpl implements UserRepositoryCustom {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Override
+    public List<User> findUserByEmails(Set<String> emails) {
+        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
+        CriteriaQuery<User> query = cb.createQuery(User.class);
+        Root<User> user = query.from(User.class);
+
+        Path<String> emailPath = user.get("email");
+
+        List<Predicate> predicates = new ArrayList<>();
+        for (String email : emails) {
+
+            predicates.add(cb.like(emailPath, email));
+
+        }
+        query.select(user)
+            .where(cb.or(predicates.toArray(new Predicate[predicates.size()])));
+
+        return entityManager.createQuery(query)
+            .getResultList();
+    }
+    
+    @Override
+    public List<User> findAllUsersByPredicates(Collection<java.util.function.Predicate<User>> predicates) {
+        List<User> allUsers = entityManager.createQuery("select u from User u", User.class).getResultList();
+        Stream<User> allUsersStream = allUsers.stream();
+        for (java.util.function.Predicate<User> predicate : predicates) {
+            allUsersStream = allUsersStream.filter(predicate);
+        }
+
+        return allUsersStream.collect(Collectors.toList());
+    }
+
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/domain/Customer.java

@@ -0,0 +1,56 @@
+package com.baeldung.boot.domain;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+
+/**
+ * Customer Entity class
+ * @author ysharma2512
+ *
+ */
+@Entity
+public class Customer {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private Long id;
+    private String firstName;
+    private String lastName;
+
+    public Customer(String firstName, String lastName) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("Customer[id=%d, firstName='%s', lastName='%s']", id, firstName, lastName);
+    }
+
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/domain/Person.java

@@ -0,0 +1,47 @@
+package com.baeldung.boot.domain;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
+@Entity
+public class Person {
+
+    @Id
+    private Long id;
+    private String firstName;
+    private String lastName;
+
+    public Person() {
+    }
+
+    public Person(Long id, String firstName, String lastName) {
+        this.id = id;
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/domain/Possession.java

@@ -0,0 +1,83 @@
+package com.baeldung.boot.domain;
+
+import javax.persistence.*;
+import com.baeldung.boot.domain.Possession;
+
+@Entity
+@Table
+public class Possession {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private long id;
+
+    private String name;
+
+    public Possession() {
+        super();
+    }
+
+    public Possession(final String name) {
+        super();
+
+        this.name = name;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(final int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = (prime * result) + (int) (id ^ (id >>> 32));
+        result = (prime * result) + ((name == null) ? 0 : name.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final Possession other = (Possession) obj;
+        if (id != other.id) {
+            return false;
+        }
+        if (name == null) {
+            if (other.name != null) {
+                return false;
+            }
+        } else if (!name.equals(other.name)) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder();
+        builder.append("Possesion [id=").append(id).append(", name=").append(name).append("]");
+        return builder.toString();
+    }
+
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/domain/User.java

@@ -0,0 +1,132 @@
+package com.baeldung.boot.domain;
+
+import javax.persistence.*;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Objects;
+
+@Entity
+@Table(name = "users")
+public class User {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private int id;
+    private String name;
+    private LocalDate creationDate;
+    private LocalDate lastLoginDate;
+    private boolean active;
+    private int age;
+    @Column(unique = true, nullable = false)
+    private String email;
+    private Integer status;
+    @OneToMany
+    List<Possession> possessionList;
+
+    public User() {
+        super();
+    }
+
+    public User(String name,  LocalDate creationDate,String email, Integer status) {
+        this.name = name;
+        this.creationDate = creationDate;
+        this.email = email;
+        this.status = status;
+        this.active = true;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(final int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(final String email) {
+        this.email = email;
+    }
+
+    public Integer getStatus() {
+        return status;
+    }
+
+    public void setStatus(Integer status) {
+        this.status = status;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(final int age) {
+        this.age = age;
+    }
+    
+    public LocalDate getCreationDate() {
+        return creationDate;
+    }
+
+    public List<Possession> getPossessionList() {
+        return possessionList;
+    }
+
+    public void setPossessionList(List<Possession> possessionList) {
+        this.possessionList = possessionList;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder();
+        builder.append("User [name=").append(name).append(", id=").append(id).append("]");
+        return builder.toString();
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        User user = (User) o;
+        return id == user.id &&
+          age == user.age &&
+          Objects.equals(name, user.name) &&
+          Objects.equals(creationDate, user.creationDate) &&
+          Objects.equals(email, user.email) &&
+          Objects.equals(status, user.status);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name, creationDate, age, email, status);
+    }
+
+    public LocalDate getLastLoginDate() {
+        return lastLoginDate;
+    }
+
+    public void setLastLoginDate(LocalDate lastLoginDate) {
+        this.lastLoginDate = lastLoginDate;
+    }
+
+    public boolean isActive() {
+        return active;
+    }
+
+    public void setActive(boolean active) {
+        this.active = active;
+    }
+
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/passenger/CustomPassengerRepository.java

@@ -0,0 +1,8 @@
+package com.baeldung.boot.passenger;
+
+import java.util.List;
+
+interface CustomPassengerRepository {
+
+    List<Passenger> findOrderedBySeatNumberLimitedTo(int limit);
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/passenger/Passenger.java

@@ -0,0 +1,82 @@
+package com.baeldung.boot.passenger;
+
+import javax.persistence.Basic;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import java.util.Objects;
+
+@Entity
+class Passenger {
+
+    @Id
+    @GeneratedValue
+    @Column(nullable = false)
+    private Long id;
+
+    @Basic(optional = false)
+    @Column(nullable = false)
+    private String firstName;
+
+    @Basic(optional = false)
+    @Column(nullable = false)
+    private String lastName;
+
+    @Basic(optional = false)
+    @Column(nullable = false)
+    private Integer seatNumber;
+
+    private Passenger(String firstName, String lastName, Integer seatNumber) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.seatNumber = seatNumber;
+    }
+
+    static Passenger from(String firstName, String lastName, Integer seatNumber) {
+        return new Passenger(firstName, lastName, seatNumber);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object)
+            return true;
+        if (object == null || getClass() != object.getClass())
+            return false;
+        Passenger passenger = (Passenger) object;
+        return getSeatNumber() == passenger.getSeatNumber() && Objects.equals(getFirstName(), passenger.getFirstName())
+          && Objects.equals(getLastName(), passenger.getLastName());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getFirstName(), getLastName(), getSeatNumber());
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder toStringBuilder = new StringBuilder(getClass().getSimpleName());
+        toStringBuilder.append("{ id=").append(id);
+        toStringBuilder.append(", firstName='").append(firstName).append('\'');
+        toStringBuilder.append(", lastName='").append(lastName).append('\'');
+        toStringBuilder.append(", seatNumber=").append(seatNumber);
+        toStringBuilder.append('}');
+        return toStringBuilder.toString();
+    }
+
+    Long getId() {
+        return id;
+    }
+
+    String getFirstName() {
+        return firstName;
+    }
+
+    String getLastName() {
+        return lastName;
+    }
+
+    Integer getSeatNumber() {
+        return seatNumber;
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/passenger/PassengerRepository.java

@@ -0,0 +1,22 @@
+package com.baeldung.boot.passenger;
+
+import java.util.List;
+
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+interface PassengerRepository extends JpaRepository<Passenger, Long>, CustomPassengerRepository {
+
+    Passenger findFirstByOrderBySeatNumberAsc();
+
+    Passenger findTopByOrderBySeatNumberAsc();
+
+    List<Passenger> findByOrderBySeatNumberAsc();
+
+    List<Passenger> findByFirstNameIgnoreCase(String firstName);
+
+    List<Passenger> findByLastNameOrderBySeatNumberAsc(String lastName);
+
+    List<Passenger> findByLastName(String lastName, Sort sort);
+
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/boot/passenger/PassengerRepositoryImpl.java

@@ -0,0 +1,20 @@
+package com.baeldung.boot.passenger;
+
+import org.springframework.stereotype.Repository;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import java.util.List;
+
+@Repository
+class PassengerRepositoryImpl implements CustomPassengerRepository {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Override
+    public List<Passenger> findOrderedBySeatNumberLimitedTo(int limit) {
+        return entityManager.createQuery("SELECT p FROM Passenger p ORDER BY p.seatNumber",
+          Passenger.class).setMaxResults(limit).getResultList();
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/entity/Employee.java

@@ -0,0 +1,36 @@
+package com.baeldung.entity;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
+@Entity
+public class Employee {
+
+    @Id
+    private Long id;
+    private String name;
+    
+    public Employee() {
+    }
+
+    public Employee(Long id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/multipledb/MultipleDbApplication.java

@@ -0,0 +1,14 @@
+package com.baeldung.multipledb;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class MultipleDbApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MultipleDbApplication.class, args);
+    }
+    
+}
+

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/multipledb/PersistenceProductConfiguration.java

@@ -0,0 +1,68 @@
+package com.baeldung.multipledb;
+
+import com.google.common.base.Preconditions;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
+import org.springframework.transaction.PlatformTransactionManager;
+
+import javax.sql.DataSource;
+import java.util.HashMap;
+
+@Configuration
+@PropertySource({"classpath:persistence-multiple-db.properties"})
+@EnableJpaRepositories(basePackages = "com.baeldung.multipledb.dao.product", entityManagerFactoryRef = "productEntityManager", transactionManagerRef = "productTransactionManager")
+@Profile("!tc")
+public class PersistenceProductConfiguration {
+    @Autowired
+    private Environment env;
+
+    public PersistenceProductConfiguration() {
+        super();
+    }
+
+    //
+
+    @Bean
+    public LocalContainerEntityManagerFactoryBean productEntityManager() {
+        final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
+        em.setDataSource(productDataSource());
+        em.setPackagesToScan("com.baeldung.multipledb.model.product");
+
+        final HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
+        em.setJpaVendorAdapter(vendorAdapter);
+        final HashMap<String, Object> properties = new HashMap<String, Object>();
+        properties.put("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
+        properties.put("hibernate.dialect", env.getProperty("hibernate.dialect"));
+        em.setJpaPropertyMap(properties);
+
+        return em;
+    }
+
+    @Bean
+    public DataSource productDataSource() {
+        final DriverManagerDataSource dataSource = new DriverManagerDataSource();
+        dataSource.setDriverClassName(Preconditions.checkNotNull(env.getProperty("jdbc.driverClassName")));
+        dataSource.setUrl(Preconditions.checkNotNull(env.getProperty("product.jdbc.url")));
+        dataSource.setUsername(Preconditions.checkNotNull(env.getProperty("jdbc.user")));
+        dataSource.setPassword(Preconditions.checkNotNull(env.getProperty("jdbc.pass")));
+
+        return dataSource;
+    }
+
+    @Bean
+    public PlatformTransactionManager productTransactionManager() {
+        final JpaTransactionManager transactionManager = new JpaTransactionManager();
+        transactionManager.setEntityManagerFactory(productEntityManager().getObject());
+        return transactionManager;
+    }
+
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/multipledb/dao/product/ProductRepository.java

@@ -0,0 +1,13 @@
+package com.baeldung.multipledb.dao.product;
+
+import java.util.List;
+
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.baeldung.multipledb.model.product.ProductMultipleDB;
+
+public interface ProductRepository extends PagingAndSortingRepository<ProductMultipleDB, Integer> {
+
+    List<ProductMultipleDB> findAllByPrice(double price, Pageable pageable);
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/multipledb/model/product/ProductMultipleDB.java

@@ -0,0 +1,67 @@
+package com.baeldung.multipledb.model.product;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(schema = "products")
+public class ProductMultipleDB {
+
+    @Id
+    private int id;
+
+    private String name;
+
+    private double price;
+
+    public ProductMultipleDB() {
+        super();
+    }
+
+    private ProductMultipleDB(int id, String name, double price) {
+        super();
+        this.id = id;
+        this.name = name;
+        this.price = price;
+    }
+
+    public static ProductMultipleDB from(int id, String name, double price) {
+        return new ProductMultipleDB(id, name, price);
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(final int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    public double getPrice() {
+        return price;
+    }
+
+    public void setPrice(final double price) {
+        this.price = price;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder();
+        builder.append("Product [name=")
+            .append(name)
+            .append(", id=")
+            .append(id)
+            .append("]");
+        return builder.toString();
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/repository/EmployeeRepository.java

@@ -0,0 +1,9 @@
+package com.baeldung.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import com.baeldung.entity.Employee;
+
+public interface EmployeeRepository extends JpaRepository<Employee, Long> {
+
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/tx/Payment.java

@@ -0,0 +1,55 @@
+package com.baeldung.tx;
+
+import javax.persistence.*;
+
+@Entity
+public class Payment {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    private Long amount;
+
+    @Column(unique = true)
+    private String referenceNumber;
+
+    @Enumerated(EnumType.STRING)
+    private State state;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Long getAmount() {
+        return amount;
+    }
+
+    public void setAmount(Long amount) {
+        this.amount = amount;
+    }
+
+    public String getReferenceNumber() {
+        return referenceNumber;
+    }
+
+    public void setReferenceNumber(String referenceNumber) {
+        this.referenceNumber = referenceNumber;
+    }
+
+    public State getState() {
+        return state;
+    }
+
+    public void setState(State state) {
+        this.state = state;
+    }
+
+    public enum State {
+        STARTED, FAILED, SUCCESSFUL
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/resources/application.properties

@@ -0,0 +1,6 @@
+spring.main.allow-bean-definition-overriding=true
+
+spring.jpa.properties.hibernate.jdbc.batch_size=4
+spring.jpa.properties.hibernate.order_inserts=true
+spring.jpa.properties.hibernate.order_updates=true
+spring.jpa.properties.hibernate.generate_statistics=true

persistence-modules/spring-data-jpa-3/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

persistence-modules/spring-data-jpa-3/src/main/resources/persistence-multiple-db.properties

@@ -0,0 +1,13 @@
+# jdbc.X
+jdbc.driverClassName=org.h2.Driver
+user.jdbc.url=jdbc:h2:mem:spring_jpa_user;DB_CLOSE_DELAY=-1;INIT=CREATE SCHEMA IF NOT EXISTS USERS
+product.jdbc.url=jdbc:h2:mem:spring_jpa_product;DB_CLOSE_DELAY=-1;INIT=CREATE SCHEMA IF NOT EXISTS PRODUCTS
+jdbc.user=sa
+jdbc.pass=sa
+
+# hibernate.X
+hibernate.dialect=org.hibernate.dialect.H2Dialect
+hibernate.show_sql=false
+hibernate.hbm2ddl.auto=create-drop
+hibernate.cache.use_second_level_cache=false
+hibernate.cache.use_query_cache=false

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/SpringContextIntegrationTest.java

@@ -0,0 +1,17 @@
+package com.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+public class SpringContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/SpringContextTest.java

@@ -0,0 +1,17 @@
+package com.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+public class SpringContextTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/SpringJpaContextIntegrationTest.java

@@ -0,0 +1,19 @@
+package com.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest
+@ContextConfiguration(classes = Application.class)
+public class SpringJpaContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/batchinserts/BatchInsertIntegrationTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.batchinserts;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+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.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.daos.CustomerRepository;
+import com.baeldung.boot.web.controllers.CustomerController;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes=Application.class)
+@AutoConfigureMockMvc
+public class BatchInsertIntegrationTest {
+
+    @Autowired
+    private CustomerRepository customerRepository;
+    private MockMvc mockMvc;
+    @Before
+    public void setUp() throws Exception {
+        mockMvc = MockMvcBuilders.standaloneSetup( new CustomerController(customerRepository))
+            .build();
+    }
+
+    @Test
+    public void whenInsertingCustomers_thenCustomersAreCreated() throws Exception {
+        this.mockMvc.perform(post("/customers"))
+            .andExpect(status().isOk());
+    }    
+   
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/batchinserts/JpaBatchInsertsIntegrationTest.java

@@ -0,0 +1,98 @@
+package com.baeldung.batchinserts;
+
+import static com.baeldung.batchinserts.TestObjectHelper.createSchool;
+import static com.baeldung.batchinserts.TestObjectHelper.createStudent;
+
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.TypedQuery;
+
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.baeldung.batchinserts.model.School;
+import com.baeldung.batchinserts.model.Student;
+import com.baeldung.boot.Application;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+@Transactional
+@ActiveProfiles("batchinserts")
+public class JpaBatchInsertsIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    private static final int BATCH_SIZE = 5;
+
+    @Transactional
+    @Test
+    public void whenInsertingSingleTypeOfEntity_thenCreatesSingleBatch() {
+        for (int i = 0; i < 10; i++) {
+            School school = createSchool(i);
+            entityManager.persist(school);
+        }
+    }
+
+    @Transactional
+    @Test
+    public void whenFlushingAfterBatch_ThenClearsMemory() {
+        for (int i = 0; i < 10; i++) {
+            if (i > 0 && i % BATCH_SIZE == 0) {
+                entityManager.flush();
+                entityManager.clear();
+            }
+
+            School school = createSchool(i);
+            entityManager.persist(school);
+        }
+    }
+
+    @Transactional
+    @Test
+    public void whenThereAreMultipleEntities_ThenCreatesNewBatch() {
+        for (int i = 0; i < 10; i++) {
+            if (i > 0 && i % BATCH_SIZE == 0) {
+                entityManager.flush();
+                entityManager.clear();
+            }
+
+            School school = createSchool(i);
+            entityManager.persist(school);
+            Student firstStudent = createStudent(school);
+            Student secondStudent = createStudent(school);
+            entityManager.persist(firstStudent);
+            entityManager.persist(secondStudent);
+        }
+    }
+
+    @Transactional
+    @Test
+    public void whenUpdatingEntities_thenCreatesBatch() {
+        for (int i = 0; i < 10; i++) {
+            School school = createSchool(i);
+            entityManager.persist(school);
+        }
+
+        entityManager.flush();
+
+        TypedQuery<School> schoolQuery = entityManager.createQuery("SELECT s from School s", School.class);
+        List<School> allSchools = schoolQuery.getResultList();
+
+        for (School school : allSchools) {
+            school.setName("Updated_" + school.getName());
+        }
+    }
+
+    @After
+    public void tearDown() {
+        entityManager.flush();
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/batchinserts/JpaNoBatchInsertsIntegrationTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.batchinserts;
+
+import static com.baeldung.batchinserts.TestObjectHelper.createSchool;
+
+import com.baeldung.batchinserts.model.School;
+import com.baeldung.boot.Application;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+@Transactional
+@ActiveProfiles("batchinserts")
+@TestPropertySource(properties = "spring.jpa.properties.hibernate.jdbc.batch_size=-1")
+public class JpaNoBatchInsertsIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Test
+    public void whenNotConfigured_ThenSendsInsertsSeparately() {
+        for (int i = 0; i < 10; i++) {
+            School school = createSchool(i);
+            entityManager.persist(school);
+        }
+    }
+
+    @After
+    public void tearDown() {
+        entityManager.flush();
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/batchinserts/TestObjectHelper.java

@@ -0,0 +1,20 @@
+package com.baeldung.batchinserts;
+
+import com.baeldung.batchinserts.model.School;
+import com.baeldung.batchinserts.model.Student;
+
+public class TestObjectHelper {
+
+    public static School createSchool(int nameIdentifier) {
+        School school = new School();
+        school.setName("School" + (nameIdentifier + 1));
+        return school;
+    }
+
+    public static Student createStudent(School school) {
+        Student student = new Student();
+        student.setName("Student-" + school.getName());
+        student.setSchool(school);
+        return student;
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/boot/daos/CustomerRepository.java

@@ -0,0 +1,15 @@
+package com.baeldung.boot.daos;
+
+import org.springframework.data.repository.CrudRepository;
+
+import com.baeldung.boot.domain.Customer;
+
+/**
+ * JPA CrudRepository interface
+ * 
+ * @author ysharma2512
+ *
+ */
+public interface CustomerRepository extends CrudRepository<Customer, Long>{
+
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/boot/daos/PersonInsertRepositoryIntegrationTest.java

@@ -0,0 +1,82 @@
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.daos.impl.PersonInsertRepository;
+import com.baeldung.boot.domain.Person;
+
+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.context.annotation.Import;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import javax.persistence.EntityExistsException;
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceException;
+
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest
+@Import(PersonInsertRepository.class)
+public class PersonInsertRepositoryIntegrationTest {
+
+    private static final Long ID = 1L;
+    private static final String FIRST_NAME = "firstname";
+    private static final String LAST_NAME = "lastname";
+    private static final Person PERSON = new Person(ID, FIRST_NAME, LAST_NAME);
+
+    @Autowired
+    private PersonInsertRepository personInsertRepository;
+
+    @Autowired
+    private EntityManager entityManager;
+
+    @Test
+    public void givenPersonEntity_whenInsertWithNativeQuery_ThenPersonIsPersisted() {
+        insertWithQuery();
+
+        assertPersonPersisted();
+    }
+
+    @Test
+    public void givenPersonEntity_whenInsertedTwiceWithNativeQuery_thenPersistenceExceptionExceptionIsThrown() {
+        assertThatExceptionOfType(PersistenceException.class).isThrownBy(() -> {
+            insertWithQuery();
+            insertWithQuery();
+        });
+    }
+
+    @Test
+    public void givenPersonEntity_whenInsertWithEntityManager_thenPersonIsPersisted() {
+        insertPersonWithEntityManager();
+
+        assertPersonPersisted();
+    }
+
+    @Test
+    public void givenPersonEntity_whenInsertedTwiceWithEntityManager_thenEntityExistsExceptionIsThrown() {
+        assertThatExceptionOfType(EntityExistsException.class).isThrownBy(() -> {
+            insertPersonWithEntityManager();
+            insertPersonWithEntityManager();
+        });
+    }
+
+    private void insertWithQuery() {
+        personInsertRepository.insertWithQuery(PERSON);
+    }
+
+    private void insertPersonWithEntityManager() {
+        personInsertRepository.insertWithEntityManager(new Person(ID, FIRST_NAME, LAST_NAME));
+    }
+
+    private void assertPersonPersisted() {
+        Person person = entityManager.find(Person.class, ID);
+
+        assertThat(person).isNotNull();
+        assertThat(person.getId()).isEqualTo(PERSON.getId());
+        assertThat(person.getFirstName()).isEqualTo(PERSON.getFirstName());
+        assertThat(person.getLastName()).isEqualTo(PERSON.getLastName());
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/boot/daos/UserRepositoryCommon.java

@@ -0,0 +1,545 @@
+package com.baeldung.boot.daos;
+
+import org.junit.After;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.domain.JpaSort;
+import org.springframework.data.mapping.PropertyReferenceException;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.baeldung.boot.daos.user.UserRepository;
+import com.baeldung.boot.domain.User;
+
+import javax.persistence.EntityManager;
+import javax.persistence.Query;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+public class UserRepositoryCommon {
+
+    final String USER_EMAIL = "email@example.com";
+    final String USER_EMAIL2 = "email2@example.com";
+    final String USER_EMAIL3 = "email3@example.com";
+    final String USER_EMAIL4 = "email4@example.com";
+    final Integer INACTIVE_STATUS = 0;
+    final Integer ACTIVE_STATUS = 1;
+    final String USER_EMAIL5 = "email5@example.com";
+    final String USER_EMAIL6 = "email6@example.com";
+    final String USER_NAME_ADAM = "Adam";
+    final String USER_NAME_PETER = "Peter";
+
+    @Autowired
+    protected UserRepository userRepository;
+    @Autowired
+    private EntityManager entityManager;
+
+    @Test
+    @Transactional
+    public void givenUsersWithSameNameInDB_WhenFindAllByName_ThenReturnStreamOfUsers() {
+        User user1 = new User();
+        user1.setName(USER_NAME_ADAM);
+        user1.setEmail(USER_EMAIL);
+        userRepository.save(user1);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_ADAM);
+        user2.setEmail(USER_EMAIL2);
+        userRepository.save(user2);
+
+        User user3 = new User();
+        user3.setName(USER_NAME_ADAM);
+        user3.setEmail(USER_EMAIL3);
+        userRepository.save(user3);
+
+        User user4 = new User();
+        user4.setName("SAMPLE");
+        user4.setEmail(USER_EMAIL4);
+        userRepository.save(user4);
+
+        try (Stream<User> foundUsersStream = userRepository.findAllByName(USER_NAME_ADAM)) {
+            assertThat(foundUsersStream.count()).isEqualTo(3l);
+        }
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithQueryAnnotation_ThenReturnCollectionWithActiveUsers() {
+        User user1 = new User();
+        user1.setName(USER_NAME_ADAM);
+        user1.setEmail(USER_EMAIL);
+        user1.setStatus(ACTIVE_STATUS);
+        userRepository.save(user1);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_ADAM);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User user3 = new User();
+        user3.setName(USER_NAME_ADAM);
+        user3.setEmail(USER_EMAIL3);
+        user3.setStatus(INACTIVE_STATUS);
+        userRepository.save(user3);
+
+        Collection<User> allActiveUsers = userRepository.findAllActiveUsers();
+
+        assertThat(allActiveUsers.size()).isEqualTo(2);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithQueryAnnotationNative_ThenReturnCollectionWithActiveUsers() {
+        User user1 = new User();
+        user1.setName(USER_NAME_ADAM);
+        user1.setEmail(USER_EMAIL);
+        user1.setStatus(ACTIVE_STATUS);
+        userRepository.save(user1);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_ADAM);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User user3 = new User();
+        user3.setName(USER_NAME_ADAM);
+        user3.setEmail(USER_EMAIL3);
+        user3.setStatus(INACTIVE_STATUS);
+        userRepository.save(user3);
+
+        Collection<User> allActiveUsers = userRepository.findAllActiveUsersNative();
+
+        assertThat(allActiveUsers.size()).isEqualTo(2);
+    }
+
+    @Test
+    public void givenUserInDB_WhenFindUserByStatusWithQueryAnnotation_ThenReturnActiveUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User userByStatus = userRepository.findUserByStatus(ACTIVE_STATUS);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUserInDB_WhenFindUserByStatusWithQueryAnnotationNative_ThenReturnActiveUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User userByStatus = userRepository.findUserByStatusNative(ACTIVE_STATUS);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByStatusAndNameWithQueryAnnotationIndexedParams_ThenReturnOneUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_PETER);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User userByStatus = userRepository.findUserByStatusAndName(ACTIVE_STATUS, USER_NAME_ADAM);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByStatusAndNameWithQueryAnnotationNamedParams_ThenReturnOneUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_PETER);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User userByStatus = userRepository.findUserByStatusAndNameNamedParams(ACTIVE_STATUS, USER_NAME_ADAM);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByStatusAndNameWithQueryAnnotationNativeNamedParams_ThenReturnOneUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_PETER);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User userByStatus = userRepository.findUserByStatusAndNameNamedParamsNative(ACTIVE_STATUS, USER_NAME_ADAM);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByStatusAndNameWithQueryAnnotationNamedParamsCustomNames_ThenReturnOneUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_PETER);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User userByStatus = userRepository.findUserByUserStatusAndUserName(ACTIVE_STATUS, USER_NAME_ADAM);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByNameLikeWithQueryAnnotationIndexedParams_ThenReturnUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User userByStatus = userRepository.findUserByNameLike("Ad");
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByNameLikeWithQueryAnnotationNamedParams_ThenReturnUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User userByStatus = userRepository.findUserByNameLikeNamedParam("Ad");
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByNameLikeWithQueryAnnotationNative_ThenReturnUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User userByStatus = userRepository.findUserByNameLikeNative("Ad");
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithSortByName_ThenReturnUsersSorted() {
+        userRepository.save(new User(USER_NAME_ADAM, LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, INACTIVE_STATUS));
+
+        List<User> usersSortByName = userRepository.findAll(new Sort(Sort.Direction.ASC, "name"));
+
+        assertThat(usersSortByName.get(0)
+          .getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test(expected = PropertyReferenceException.class)
+    public void givenUsersInDB_WhenFindAllSortWithFunction_ThenThrowException() {
+        userRepository.save(new User(USER_NAME_ADAM, LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, INACTIVE_STATUS));
+
+        userRepository.findAll(new Sort(Sort.Direction.ASC, "name"));
+
+        List<User> usersSortByNameLength = userRepository.findAll(Sort.by("LENGTH(name)"));
+
+        assertThat(usersSortByNameLength.get(0)
+          .getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllSortWithFunctionQueryAnnotationJPQL_ThenReturnUsersSorted() {
+        userRepository.save(new User(USER_NAME_ADAM, LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, INACTIVE_STATUS));
+
+        userRepository.findAllUsers(Sort.by("name"));
+
+        List<User> usersSortByNameLength = userRepository.findAllUsers(JpaSort.unsafe("LENGTH(name)"));
+
+        assertThat(usersSortByNameLength.get(0)
+          .getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithPageRequestQueryAnnotationJPQL_ThenReturnPageOfUsers() {
+        userRepository.save(new User(USER_NAME_ADAM, LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL4, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE2", LocalDate.now(), USER_EMAIL5, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL6, INACTIVE_STATUS));
+
+        Page<User> usersPage = userRepository.findAllUsersWithPagination(PageRequest.of(1, 3));
+
+        assertThat(usersPage.getContent()
+          .get(0)
+          .getName()).isEqualTo("SAMPLE1");
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithPageRequestQueryAnnotationNative_ThenReturnPageOfUsers() {
+        userRepository.save(new User(USER_NAME_ADAM, LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL4, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE2", LocalDate.now(), USER_EMAIL5, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL6, INACTIVE_STATUS));
+
+        Page<User> usersSortByNameLength = userRepository.findAllUsersWithPaginationNative(PageRequest.of(1, 3));
+
+        assertThat(usersSortByNameLength.getContent()
+          .get(0)
+          .getName()).isEqualTo(USER_NAME_PETER);
+    }
+
+    @Test
+    @Transactional
+    public void givenUsersInDB_WhenUpdateStatusForNameModifyingQueryAnnotationJPQL_ThenModifyMatchingUsers() {
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL4, ACTIVE_STATUS));
+
+        int updatedUsersSize = userRepository.updateUserSetStatusForName(INACTIVE_STATUS, "SAMPLE");
+
+        assertThat(updatedUsersSize).isEqualTo(2);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindByEmailsWithDynamicQuery_ThenReturnCollection() {
+
+        User user1 = new User();
+        user1.setEmail(USER_EMAIL);
+        userRepository.save(user1);
+
+        User user2 = new User();
+        user2.setEmail(USER_EMAIL2);
+        userRepository.save(user2);
+
+        User user3 = new User();
+        user3.setEmail(USER_EMAIL3);
+        userRepository.save(user3);
+
+        Set<String> emails = new HashSet<>();
+        emails.add(USER_EMAIL2);
+        emails.add(USER_EMAIL3);
+
+        Collection<User> usersWithEmails = userRepository.findUserByEmails(emails);
+
+        assertThat(usersWithEmails.size()).isEqualTo(2);
+    }
+
+    @Test
+    public void givenUsersInDBWhenFindByNameListReturnCollection() {
+
+        User user1 = new User();
+        user1.setName(USER_NAME_ADAM);
+        user1.setEmail(USER_EMAIL);
+        userRepository.save(user1);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_PETER);
+        user2.setEmail(USER_EMAIL2);
+        userRepository.save(user2);
+
+        List<String> names = Arrays.asList(USER_NAME_ADAM, USER_NAME_PETER);
+
+        List<User> usersWithNames = userRepository.findUserByNameList(names);
+
+        assertThat(usersWithNames.size()).isEqualTo(2);
+    }
+
+
+    @Test
+    @Transactional
+    public void whenInsertedWithQuery_ThenUserIsPersisted() {
+        userRepository.insertUser(USER_NAME_ADAM, 1, USER_EMAIL, ACTIVE_STATUS, true);
+        userRepository.insertUser(USER_NAME_PETER, 1, USER_EMAIL2, ACTIVE_STATUS, true);
+
+        User userAdam = userRepository.findUserByNameLike(USER_NAME_ADAM);
+        User userPeter = userRepository.findUserByNameLike(USER_NAME_PETER);
+
+        assertThat(userAdam).isNotNull();
+        assertThat(userAdam.getEmail()).isEqualTo(USER_EMAIL);
+        assertThat(userPeter).isNotNull();
+        assertThat(userPeter.getEmail()).isEqualTo(USER_EMAIL2);
+    }
+
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenFindByNameUsr01_ThenUserUsr01() {
+        User usr01 = new User("usr01", LocalDate.now(), "usr01@baeldung.com", 1);
+        User usr02 = new User("usr02", LocalDate.now(), "usr02@baeldung.com", 1);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        try (Stream<User> users = userRepository.findAllByName("usr01")) {
+            assertTrue(users.allMatch(usr -> usr.equals(usr01)));
+        }
+    }
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenFindByNameUsr00_ThenNoUsers() {
+        User usr01 = new User("usr01", LocalDate.now(), "usr01@baeldung.com", 1);
+        User usr02 = new User("usr02", LocalDate.now(), "usr02@baeldung.com", 1);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        try (Stream<User> users = userRepository.findAllByName("usr00")) {
+            assertEquals(0, users.count());
+        }
+    }
+
+    @Test
+    public void givenTwoUsers_whenFindUsersWithGmailAddress_ThenUserUsr02() {
+        User usr01 = new User("usr01", LocalDate.now(), "usr01@baeldung.com", 1);
+        User usr02 = new User("usr02", LocalDate.now(), "usr02@gmail.com", 1);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        List<User> users = userRepository.findUsersWithGmailAddress();
+        assertEquals(1, users.size());
+        assertEquals(usr02, users.get(0));
+    }
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenDeleteAllByCreationDateAfter_ThenOneUserRemains() {
+        User usr01 = new User("usr01", LocalDate.of(2018, 1, 1), "usr01@baeldung.com", 1);
+        User usr02 = new User("usr02", LocalDate.of(2018, 6, 1), "usr02@baeldung.com", 1);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        userRepository.deleteAllByCreationDateAfter(LocalDate.of(2018, 5, 1));
+
+        List<User> users = userRepository.findAll();
+
+        assertEquals(1, users.size());
+        assertEquals(usr01, users.get(0));
+    }
+
+    @Test
+    public void givenTwoUsers_whenFindAllUsersByPredicates_ThenUserUsr01() {
+        User usr01 = new User("usr01", LocalDate.of(2018, 1, 1), "usr01@baeldung.com", 1);
+        User usr02 = new User("usr02", LocalDate.of(2018, 6, 1), "usr02@baeldung.org", 1);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        List<Predicate<User>> predicates = new ArrayList<>();
+        predicates.add(usr -> usr.getCreationDate().isAfter(LocalDate.of(2017, 12, 31)));
+        predicates.add(usr -> usr.getEmail().endsWith(".com"));
+
+        List<User> users = userRepository.findAllUsersByPredicates(predicates);
+
+        assertEquals(1, users.size());
+        assertEquals(usr01, users.get(0));
+    }
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenDeactivateUsersNotLoggedInSince_ThenUserUsr02Deactivated() {
+        User usr01 = new User("usr01", LocalDate.of(2018, 1, 1), "usr01@baeldung.com", 1);
+        usr01.setLastLoginDate(LocalDate.now());
+        User usr02 = new User("usr02", LocalDate.of(2018, 6, 1), "usr02@baeldung.org", 1);
+        usr02.setLastLoginDate(LocalDate.of(2018, 7, 20));
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        userRepository.deactivateUsersNotLoggedInSince(LocalDate.of(2018, 8, 1));
+
+        List<User> users = userRepository.findAllUsers(Sort.by(Sort.Order.asc("name")));
+        assertTrue(users.get(0).isActive());
+        assertFalse(users.get(1).isActive());
+    }
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenDeleteDeactivatedUsers_ThenUserUsr02Deleted() {
+        User usr01 = new User("usr01", LocalDate.of(2018, 1, 1), "usr01@baeldung.com", 1);
+        usr01.setLastLoginDate(LocalDate.now());
+        User usr02 = new User("usr02", LocalDate.of(2018, 6, 1), "usr02@baeldung.com", 0);
+        usr02.setLastLoginDate(LocalDate.of(2018, 7, 20));
+        usr02.setActive(false);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        int deletedUsersCount = userRepository.deleteDeactivatedUsers();
+
+        List<User> users = userRepository.findAll();
+        assertEquals(1, users.size());
+        assertEquals(usr01, users.get(0));
+        assertEquals(1, deletedUsersCount);
+    }
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenAddDeletedColumn_ThenUsersHaveDeletedColumn() {
+        User usr01 = new User("usr01", LocalDate.of(2018, 1, 1), "usr01@baeldung.com", 1);
+        usr01.setLastLoginDate(LocalDate.now());
+        User usr02 = new User("usr02", LocalDate.of(2018, 6, 1), "usr02@baeldung.org", 1);
+        usr02.setLastLoginDate(LocalDate.of(2018, 7, 20));
+        usr02.setActive(false);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        userRepository.addDeletedColumn();
+
+        Query nativeQuery = entityManager.createNativeQuery("select deleted from USERS where NAME = 'usr01'");
+        assertEquals(0, nativeQuery.getResultList().get(0));
+    }
+
+    @After
+    public void cleanUp() {
+        userRepository.deleteAll();
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/boot/daos/UserRepositoryTCAutoLiveTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.domain.User;
+import com.baeldung.util.BaeldungPostgresqlContainer;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+import org.testcontainers.containers.PostgreSQLContainer;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Created by adam.
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+@ActiveProfiles({"tc", "tc-auto"})
+public class UserRepositoryTCAutoLiveTest extends UserRepositoryCommon {
+
+    @ClassRule
+    public static PostgreSQLContainer<BaeldungPostgresqlContainer> postgreSQLContainer = BaeldungPostgresqlContainer.getInstance();
+
+    @Test
+    @Transactional
+    public void givenUsersInDB_WhenUpdateStatusForNameModifyingQueryAnnotationNativePostgres_ThenModifyMatchingUsers() {
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL4, ACTIVE_STATUS));
+        userRepository.flush();
+
+        int updatedUsersSize = userRepository.updateUserSetStatusForNameNativePostgres(INACTIVE_STATUS, "SAMPLE");
+
+        assertThat(updatedUsersSize).isEqualTo(2);
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/boot/daos/UserRepositoryTCLiveTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.domain.User;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.util.TestPropertyValues;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+import org.testcontainers.containers.PostgreSQLContainer;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+@ActiveProfiles("tc")
+@ContextConfiguration(initializers = {UserRepositoryTCLiveTest.Initializer.class})
+public class UserRepositoryTCLiveTest extends UserRepositoryCommon {
+
+    @ClassRule
+    public static PostgreSQLContainer postgreSQLContainer = new PostgreSQLContainer("postgres:11.1")
+      .withDatabaseName("integration-tests-db")
+      .withUsername("sa")
+      .withPassword("sa");
+
+    @Test
+    @Transactional
+    public void givenUsersInDB_WhenUpdateStatusForNameModifyingQueryAnnotationNative_ThenModifyMatchingUsers() {
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL4, ACTIVE_STATUS));
+        userRepository.flush();
+
+        int updatedUsersSize = userRepository.updateUserSetStatusForNameNativePostgres(INACTIVE_STATUS, "SAMPLE");
+
+        assertThat(updatedUsersSize).isEqualTo(2);
+    }
+
+    static class Initializer
+      implements ApplicationContextInitializer<ConfigurableApplicationContext> {
+        public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
+            TestPropertyValues.of(
+              "spring.datasource.url=" + postgreSQLContainer.getJdbcUrl(),
+              "spring.datasource.username=" + postgreSQLContainer.getUsername(),
+              "spring.datasource.password=" + postgreSQLContainer.getPassword()
+            ).applyTo(configurableApplicationContext.getEnvironment());
+        }
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/boot/passenger/PassengerRepositoryIntegrationTest.java

@@ -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)));
+
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/boot/web/controllers/CustomerController.java

@@ -0,0 +1,43 @@
+package com.baeldung.boot.web.controllers;
+
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.List;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.baeldung.boot.daos.CustomerRepository;
+import com.baeldung.boot.domain.Customer;
+
+/**
+ * A simple controller to test the JPA CrudRepository operations
+ * controllers
+ * 
+ * @author ysharma2512
+ *
+ */
+@RestController
+public class CustomerController {
+
+    @Autowired
+    CustomerRepository customerRepository;
+
+    public CustomerController(CustomerRepository customerRepository2) {
+        this.customerRepository = customerRepository2;
+    }
+
+    @PostMapping("/customers")
+    public ResponseEntity<List<Customer>> insertCustomers() throws URISyntaxException {
+        Customer c1 = new Customer("James", "Gosling");
+        Customer c2 = new Customer("Doug", "Lea");
+        Customer c3 = new Customer("Martin", "Fowler");
+        Customer c4 = new Customer("Brian", "Goetz");
+        List<Customer> customers = Arrays.asList(c1, c2, c3, c4);
+        customerRepository.saveAll(customers);
+        return ResponseEntity.ok(customers);
+    }
+
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/multipledb/ProductRepositoryIntegrationTest.java

@@ -0,0 +1,142 @@
+package com.baeldung.multipledb;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasSize;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+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.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.baeldung.multipledb.dao.product.ProductRepository;
+import com.baeldung.multipledb.model.product.ProductMultipleDB;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes=MultipleDbApplication.class)
+@EnableTransactionManagement
+public class ProductRepositoryIntegrationTest {
+
+    @Autowired
+    private ProductRepository productRepository;
+
+    @Before
+    @Transactional("productTransactionManager")
+    public void setUp() {
+        productRepository.save(ProductMultipleDB.from(1001, "Book", 21));
+        productRepository.save(ProductMultipleDB.from(1002, "Coffee", 10));
+        productRepository.save(ProductMultipleDB.from(1003, "Jeans", 30));
+        productRepository.save(ProductMultipleDB.from(1004, "Shirt", 32));
+        productRepository.save(ProductMultipleDB.from(1005, "Bacon", 10));
+    }
+
+    @Test
+    public void whenRequestingFirstPageOfSizeTwo_ThenReturnFirstPage() {
+        Pageable pageRequest = PageRequest.of(0, 2);
+
+        Page<ProductMultipleDB> result = productRepository.findAll(pageRequest);
+
+        assertThat(result.getContent(), hasSize(2));
+        assertTrue(result.stream()
+            .map(ProductMultipleDB::getId)
+            .allMatch(id -> Arrays.asList(1001, 1002)
+                .contains(id)));
+    }
+
+    @Test
+    public void whenRequestingSecondPageOfSizeTwo_ThenReturnSecondPage() {
+        Pageable pageRequest = PageRequest.of(1, 2);
+
+        Page<ProductMultipleDB> result = productRepository.findAll(pageRequest);
+
+        assertThat(result.getContent(), hasSize(2));
+        assertTrue(result.stream()
+            .map(ProductMultipleDB::getId)
+            .allMatch(id -> Arrays.asList(1003, 1004)
+                .contains(id)));
+    }
+
+    @Test
+    public void whenRequestingLastPage_ThenReturnLastPageWithRemData() {
+        Pageable pageRequest = PageRequest.of(2, 2);
+
+        Page<ProductMultipleDB> result = productRepository.findAll(pageRequest);
+
+        assertThat(result.getContent(), hasSize(1));
+        assertTrue(result.stream()
+            .map(ProductMultipleDB::getId)
+            .allMatch(id -> Arrays.asList(1005)
+                .contains(id)));
+    }
+
+    @Test
+    public void whenSortingByNameAscAndPaging_ThenReturnSortedPagedResult() {
+        Pageable pageRequest = PageRequest.of(0, 3, Sort.by("name"));
+
+        Page<ProductMultipleDB> result = productRepository.findAll(pageRequest);
+
+        assertThat(result.getContent(), hasSize(3));
+        assertThat(result.getContent()
+            .stream()
+            .map(ProductMultipleDB::getId)
+            .collect(Collectors.toList()), equalTo(Arrays.asList(1005, 1001, 1002)));
+
+    }
+
+    @Test
+    public void whenSortingByPriceDescAndPaging_ThenReturnSortedPagedResult() {
+        Pageable pageRequest = PageRequest.of(0, 3, Sort.by("price")
+            .descending());
+
+        Page<ProductMultipleDB> result = productRepository.findAll(pageRequest);
+
+        assertThat(result.getContent(), hasSize(3));
+        assertThat(result.getContent()
+            .stream()
+            .map(ProductMultipleDB::getId)
+            .collect(Collectors.toList()), equalTo(Arrays.asList(1004, 1003, 1001)));
+
+    }
+
+    @Test
+    public void whenSortingByPriceDescAndNameAscAndPaging_ThenReturnSortedPagedResult() {
+        Pageable pageRequest = PageRequest.of(0, 5, Sort.by("price")
+            .descending()
+            .and(Sort.by("name")));
+
+        Page<ProductMultipleDB> result = productRepository.findAll(pageRequest);
+
+        assertThat(result.getContent(), hasSize(5));
+        assertThat(result.getContent()
+            .stream()
+            .map(ProductMultipleDB::getId)
+            .collect(Collectors.toList()), equalTo(Arrays.asList(1004, 1003, 1001, 1005, 1002)));
+
+    }
+
+    @Test
+    public void whenRequestingFirstPageOfSizeTwoUsingCustomMethod_ThenReturnFirstPage() {
+        Pageable pageRequest = PageRequest.of(0, 2);
+
+        List<ProductMultipleDB> result = productRepository.findAllByPrice(10, pageRequest);
+
+        assertThat(result, hasSize(2));
+        assertTrue(result.stream()
+            .map(ProductMultipleDB::getId)
+            .allMatch(id -> Arrays.asList(1002, 1005)
+                .contains(id)));
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/repository/EmployeeRepositoryIntegrationTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.repository;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+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.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+import com.baeldung.entity.Employee;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+public class EmployeeRepositoryIntegrationTest {
+
+    private static final Employee EMPLOYEE1 = new Employee(1L, "John");
+    private static final Employee EMPLOYEE2 = new Employee(2L, "Alice");
+
+    @Autowired
+    private EmployeeRepository employeeRepository;
+
+    @Test
+    public void givenEmployeeEntity_whenInsertWithSave_ThenEmployeeIsPersisted() {
+        employeeRepository.save(EMPLOYEE1);
+        assertEmployeePersisted(EMPLOYEE1);
+    }
+
+    @Test
+    public void givenEmployeeEntity_whenInsertWithSaveAndFlush_ThenEmployeeIsPersisted() {
+        employeeRepository.saveAndFlush(EMPLOYEE2);
+        assertEmployeePersisted(EMPLOYEE2);
+    }
+
+    private void assertEmployeePersisted(Employee input) {
+        Employee employee = employeeRepository.getOne(input.getId());
+        assertThat(employee).isNotNull();
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/tx/ManualTransactionIntegrationTest.java

@@ -0,0 +1,171 @@
+package com.baeldung.tx;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.TransactionDefinition;
+import org.springframework.transaction.TransactionStatus;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.DefaultTransactionDefinition;
+import org.springframework.transaction.support.TransactionCallbackWithoutResult;
+import org.springframework.transaction.support.TransactionTemplate;
+import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import javax.persistence.EntityManager;
+
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase.Replace.NONE;
+import static org.springframework.transaction.annotation.Propagation.NOT_SUPPORTED;
+
+@DataJpaTest
+@Testcontainers
+@ActiveProfiles("test")
+@AutoConfigureTestDatabase(replace = NONE)
+@Transactional(propagation = NOT_SUPPORTED)
+class ManualTransactionIntegrationTest {
+
+    @Container
+    private static PostgreSQLContainer<?> pg = initPostgres();
+
+    @Autowired
+    private PlatformTransactionManager transactionManager;
+
+    @Autowired
+    private EntityManager entityManager;
+
+    private TransactionTemplate transactionTemplate;
+
+    @BeforeEach
+    void setUp() {
+        transactionTemplate = new TransactionTemplate(transactionManager);
+    }
+
+    @AfterEach
+    void flushDb() {
+        transactionTemplate.execute(status -> entityManager
+                .createQuery("delete from Payment")
+                .executeUpdate());
+    }
+
+    @Test
+    void givenAPayment_WhenNotDuplicate_ThenShouldCommit() {
+        Long id = transactionTemplate.execute(status -> {
+            Payment payment = new Payment();
+            payment.setAmount(1000L);
+            payment.setReferenceNumber("Ref-1");
+            payment.setState(Payment.State.SUCCESSFUL);
+
+            entityManager.persist(payment);
+
+            return payment.getId();
+        });
+
+        Payment payment = entityManager.find(Payment.class, id);
+        assertThat(payment).isNotNull();
+    }
+
+    @Test
+    void givenAPayment_WhenMarkAsRollback_ThenShouldRollback() {
+        transactionTemplate.execute(status -> {
+            Payment payment = new Payment();
+            payment.setAmount(1000L);
+            payment.setReferenceNumber("Ref-1");
+            payment.setState(Payment.State.SUCCESSFUL);
+
+            entityManager.persist(payment);
+            status.setRollbackOnly();
+
+            return payment.getId();
+        });
+
+        assertThat(entityManager
+                .createQuery("select p from Payment p")
+                .getResultList()).isEmpty();
+    }
+
+    @Test
+    void givenTwoPayments_WhenRefIsDuplicate_ThenShouldRollback() {
+        try {
+            transactionTemplate.execute(s -> {
+                Payment first = new Payment();
+                first.setAmount(1000L);
+                first.setReferenceNumber("Ref-1");
+                first.setState(Payment.State.SUCCESSFUL);
+
+                Payment second = new Payment();
+                second.setAmount(2000L);
+                second.setReferenceNumber("Ref-1");
+                second.setState(Payment.State.SUCCESSFUL);
+
+                entityManager.persist(first);
+                entityManager.persist(second);
+
+                return "Ref-1";
+            });
+        } catch (Exception ignored) {
+        }
+
+        assertThat(entityManager
+                .createQuery("select p from Payment p")
+                .getResultList()).isEmpty();
+    }
+
+    @Test
+    void givenAPayment_WhenNotExpectingAnyResult_ThenShouldCommit() {
+        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
+            @Override
+            protected void doInTransactionWithoutResult(TransactionStatus status) {
+                Payment payment = new Payment();
+                payment.setReferenceNumber("Ref-1");
+                payment.setState(Payment.State.SUCCESSFUL);
+
+                entityManager.persist(payment);
+            }
+        });
+
+        assertThat(entityManager
+                .createQuery("select p from Payment p")
+                .getResultList()).hasSize(1);
+    }
+
+    @Test
+    void givenAPayment_WhenUsingTxManager_ThenShouldCommit() {
+        DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
+        definition.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
+        definition.setTimeout(3);
+
+        TransactionStatus status = transactionManager.getTransaction(definition);
+        try {
+            Payment payment = new Payment();
+            payment.setReferenceNumber("Ref-1");
+            payment.setState(Payment.State.SUCCESSFUL);
+
+            entityManager.persist(payment);
+            transactionManager.commit(status);
+        } catch (Exception ex) {
+            transactionManager.rollback(status);
+        }
+
+        assertThat(entityManager
+                .createQuery("select p from Payment p")
+                .getResultList()).hasSize(1);
+    }
+
+    private static PostgreSQLContainer<?> initPostgres() {
+        PostgreSQLContainer<?> pg = new PostgreSQLContainer<>("postgres:11.1")
+                .withDatabaseName("baeldung")
+                .withUsername("test")
+                .withPassword("test");
+        pg.setPortBindings(singletonList("54320:5432"));
+
+        return pg;
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/util/BaeldungPostgresqlContainer.java

@@ -0,0 +1,35 @@
+package com.baeldung.util;
+
+import org.testcontainers.containers.PostgreSQLContainer;
+
+public class BaeldungPostgresqlContainer extends PostgreSQLContainer<BaeldungPostgresqlContainer> {
+
+    private static final String IMAGE_VERSION = "postgres:11.1";
+
+    private static BaeldungPostgresqlContainer container;
+
+
+    private BaeldungPostgresqlContainer() {
+        super(IMAGE_VERSION);
+    }
+
+    public static BaeldungPostgresqlContainer getInstance() {
+        if (container == null) {
+            container = new BaeldungPostgresqlContainer();
+        }
+        return container;
+    }
+
+    @Override
+    public void start() {
+        super.start();
+        System.setProperty("DB_URL", container.getJdbcUrl());
+        System.setProperty("DB_USERNAME", container.getUsername());
+        System.setProperty("DB_PASSWORD", container.getPassword());
+    }
+
+    @Override
+    public void stop() {
+        //do nothing, JVM handles shut down
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/resources/application-batchinserts.properties

@@ -0,0 +1,6 @@
+spring.jpa.show-sql=false
+
+spring.jpa.properties.hibernate.jdbc.batch_size=5
+spring.jpa.properties.hibernate.order_inserts=true
+spring.jpa.properties.hibernate.order_updates=true
+spring.jpa.properties.hibernate.batch_versioned_data=true

persistence-modules/spring-data-jpa-3/src/test/resources/application-tc-auto.properties

@@ -0,0 +1,4 @@
+# configuration for test containers testing
+spring.datasource.url=${DB_URL}
+spring.datasource.username=${DB_USERNAME}
+spring.datasource.password=${DB_PASSWORD}

persistence-modules/spring-data-jpa-3/src/test/resources/application-tc.properties

@@ -0,0 +1,4 @@
+# configuration for Test Containers testing
+spring.datasource.driver-class-name=org.postgresql.Driver
+spring.jpa.hibernate.ddl-auto=create-drop
+spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults=false

persistence-modules/spring-data-jpa-3/src/test/resources/application-test.properties

@@ -0,0 +1,4 @@
+spring.jpa.hibernate.ddl-auto=update
+spring.datasource.url=jdbc:postgresql://localhost:54320/baeldung
+spring.datasource.username=test
+spring.datasource.password=test