BAEL-3091: The Prototype Pattern in Java (changed code based on valid comments from a reader)

persistence-modules/java-jpa-2/README.md

@@ -0,0 +1,15 @@
+## JPA in Java
+
+This module contains articles about the Java Persistence API (JPA) in Java.
+
+### Relevant Articles
+
+- [JPA Query Parameters Usage](https://www.baeldung.com/jpa-query-parameters-usage)
+- [Mapping Entitiy Class Names to SQL Table Names with JPA](https://www.baeldung.com/jpa-entity-table-names)
+- [Default Column Values in JPA](https://www.baeldung.com/jpa-default-column-values)
+- [Types of JPA Queries](https://www.baeldung.com/jpa-queries)
+- [JPA/Hibernate Projections](https://www.baeldung.com/jpa-hibernate-projections)
+- [Combining JPA And/Or Criteria Predicates](https://www.baeldung.com/jpa-and-or-criteria-predicates)
+- [JPA Annotation for the PostgreSQL TEXT Type](https://www.baeldung.com/jpa-annotation-postgresql-text-type)
+- [Mapping a Single Entity to Multiple Tables in JPA](https://www.baeldung.com/jpa-mapping-single-entity-to-multiple-tables)
+- More articles: [[<-- prev]](/java-jpa)

persistence-modules/java-jpa-2/pom.xml

@@ -0,0 +1,120 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>java-jpa-2</artifactId>
+    <name>java-jpa-2</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-core</artifactId>
+            <version>${hibernate.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-jpamodelgen</artifactId>
+            <version>${hibernate.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>${h2.version}</version>
+        </dependency>
+
+        <!--Compile time JPA API -->
+        <dependency>
+            <groupId>javax.persistence</groupId>
+            <artifactId>javax.persistence-api</artifactId>
+            <version>${javax.persistence-api.version}</version>
+        </dependency>
+
+        <!--Runtime JPA implementation -->
+        <dependency>
+            <groupId>org.eclipse.persistence</groupId>
+            <artifactId>eclipselink</artifactId>
+            <version>${eclipselink.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>${postgres.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <compilerArgument>-proc:none</compilerArgument>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.bsc.maven</groupId>
+                <artifactId>maven-processor-plugin</artifactId>
+                <version>3.3.3</version>
+                <executions>
+                    <execution>
+                        <id>process</id>
+                        <goals>
+                            <goal>process</goal>
+                        </goals>
+                        <phase>generate-sources</phase>
+                        <configuration>
+                            <outputDirectory>target/metamodel</outputDirectory>
+                            <processors>
+                                <processor>org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor</processor>
+                            </processors>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>build-helper-maven-plugin</artifactId>
+                <version>3.0.0</version>
+                <executions>
+                    <execution>
+                        <id>add-source</id>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>add-source</goal>
+                        </goals>
+                        <configuration>
+                            <sources>
+                                <source>target/metamodel</source>
+                            </sources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <hibernate.version>5.4.0.Final</hibernate.version>
+        <eclipselink.version>2.7.4-RC1</eclipselink.version>
+        <postgres.version>42.2.5</postgres.version>
+        <javax.persistence-api.version>2.2</javax.persistence-api.version>
+        <assertj.version>3.11.1</assertj.version>
+    </properties>
+
+</project>

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/criteria/CustomItemRepository.java

@@ -0,0 +1,10 @@
+package com.baeldung.jpa.criteria;
+
+import java.util.List;
+
+public interface CustomItemRepository {
+
+    List<Item> findItemsByColorAndGrade();
+
+    List<Item> findItemByColorOrGrade();
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/criteria/CustomItemRepositoryImpl.java

@@ -0,0 +1,72 @@
+package com.baeldung.jpa.criteria;
+
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+
+public class CustomItemRepositoryImpl implements CustomItemRepository {
+
+    private EntityManager entityManager;
+
+    public CustomItemRepositoryImpl() {
+        super();
+        EntityManagerFactory factory = Persistence.createEntityManagerFactory("jpa-h2-criteria");
+        entityManager = factory.createEntityManager();
+    }
+
+    @Override
+    public List<Item> findItemsByColorAndGrade() {
+
+        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaQuery = criteriaBuilder.createQuery(Item.class);
+        Root<Item> itemRoot = criteriaQuery.from(Item.class);
+
+        Predicate predicateForBlueColor = criteriaBuilder.equal(itemRoot.get("color"), "blue");
+        Predicate predicateForRedColor = criteriaBuilder.equal(itemRoot.get("color"), "red");
+        Predicate predicateForColor = criteriaBuilder.or(predicateForBlueColor, predicateForRedColor);
+
+        Predicate predicateForGradeA = criteriaBuilder.equal(itemRoot.get("grade"), "A");
+        Predicate predicateForGradeB = criteriaBuilder.equal(itemRoot.get("grade"), "B");
+        Predicate predicateForGrade = criteriaBuilder.or(predicateForGradeA, predicateForGradeB);
+
+        // final search filter
+        Predicate finalPredicate = criteriaBuilder.and(predicateForColor, predicateForGrade);
+
+        criteriaQuery.where(finalPredicate);
+
+        List<Item> items = entityManager.createQuery(criteriaQuery)
+            .getResultList();
+        return items;
+    }
+
+    @Override
+    public List<Item> findItemByColorOrGrade() {
+
+        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaQuery = criteriaBuilder.createQuery(Item.class);
+        Root<Item> itemRoot = criteriaQuery.from(Item.class);
+
+        Predicate predicateForBlueColor = criteriaBuilder.equal(itemRoot.get("color"), "red");
+        Predicate predicateForGradeA = criteriaBuilder.equal(itemRoot.get("grade"), "D");
+        Predicate predicateForBlueColorAndGradeA = criteriaBuilder.and(predicateForBlueColor, predicateForGradeA);
+
+        Predicate predicateForRedColor = criteriaBuilder.equal(itemRoot.get("color"), "blue");
+        Predicate predicateForGradeB = criteriaBuilder.equal(itemRoot.get("grade"), "B");
+        Predicate predicateForRedColorAndGradeB = criteriaBuilder.and(predicateForRedColor, predicateForGradeB);
+
+        // final search filter
+        Predicate finalPredicate = criteriaBuilder.or(predicateForBlueColorAndGradeA, predicateForRedColorAndGradeB);
+
+        criteriaQuery.where(finalPredicate);
+
+        List<Item> items = entityManager.createQuery(criteriaQuery)
+            .getResultList();
+        return items;
+    }
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/criteria/Item.java

@@ -0,0 +1,49 @@
+package com.baeldung.jpa.criteria;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Table(name = "item")
+@Entity
+public class Item {
+
+    @Id
+    private Long id;
+    private String color;
+    private String grade;
+    private String name;
+
+    public String getColor() {
+        return color;
+    }
+
+    public String getGrade() {
+        return grade;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setColor(String color) {
+        this.color = color;
+    }
+
+    public void setGrade(String grade) {
+        this.grade = grade;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/defaultvalues/User.java

@@ -0,0 +1,54 @@
+package com.baeldung.jpa.defaultvalues;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+
+@Entity
+public class User {
+
+    @Id
+    private Long id;
+
+    @Column(columnDefinition = "varchar(255) default 'John Snow'")
+    private String name = "John Snow";
+
+    @Column(columnDefinition = "integer default 25")
+    private Integer age = 25;
+
+    @Column(columnDefinition = "boolean default false")
+    private Boolean locked = false;
+
+    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 Integer getAge() {
+        return age;
+    }
+
+    public void setAge(Integer age) {
+        this.age = age;
+    }
+
+    public Boolean getLocked() {
+        return locked;
+    }
+
+    public void setLocked(Boolean locked) {
+        this.locked = locked;
+    }
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/defaultvalues/UserRepository.java

@@ -0,0 +1,36 @@
+package com.baeldung.jpa.defaultvalues;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+
+public class UserRepository {
+
+    private EntityManagerFactory emf = null;
+
+    public UserRepository() {
+        emf = Persistence.createEntityManagerFactory("entity-default-values");
+    }
+
+    public User find(Long id) {
+        EntityManager entityManager = emf.createEntityManager();
+        User user = entityManager.find(User.class, id);
+        entityManager.close();
+        return user;
+    }
+
+    public void save(User user, Long id) {
+        user.setId(id);
+
+        EntityManager entityManager = emf.createEntityManager();
+        entityManager.getTransaction().begin();
+        entityManager.persist(user);
+        entityManager.getTransaction().commit();
+        entityManager.close();
+    }
+
+    public void clean() {
+        emf.close();
+    }
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/entity/Article.java

@@ -0,0 +1,12 @@
+package com.baeldung.jpa.entity;
+
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+@Entity(name = "MyArticle")
+@Table(name = Article.TABLE_NAME)
+public class Article {
+
+    public static final String TABLE_NAME = "ARTICLES";
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/multipletables/multipleentities/AllergensAsEntity.java

@@ -0,0 +1,73 @@
+package com.baeldung.jpa.multipletables.multipleentities;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.OneToOne;
+import javax.persistence.PrimaryKeyJoinColumn;
+import javax.persistence.Table;
+
+import com.baeldung.jpa.multipletables.secondarytable.MealAsSingleEntity;
+
+@Entity
+@Table(name = "allergens")
+public class AllergensAsEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "meal_id")
+    private Long mealId;
+
+    @OneToOne
+    @PrimaryKeyJoinColumn(name = "meal_id")
+    private MealAsSingleEntity meal;
+
+    @Column(name = "peanuts")
+    private boolean peanuts;
+
+    @Column(name = "celery")
+    private boolean celery;
+
+    @Column(name = "sesame_seeds")
+    private boolean sesameSeeds;
+
+    public MealAsSingleEntity getMeal() {
+        return meal;
+    }
+
+    public void setMeal(MealAsSingleEntity meal) {
+        this.meal = meal;
+    }
+
+    public boolean isPeanuts() {
+        return peanuts;
+    }
+
+    public void setPeanuts(boolean peanuts) {
+        this.peanuts = peanuts;
+    }
+
+    public boolean isCelery() {
+        return celery;
+    }
+
+    public void setCelery(boolean celery) {
+        this.celery = celery;
+    }
+
+    public boolean isSesameSeeds() {
+        return sesameSeeds;
+    }
+
+    public void setSesameSeeds(boolean sesameSeeds) {
+        this.sesameSeeds = sesameSeeds;
+    }
+
+    @Override
+    public String toString() {
+        return "AllergensAsEntity [peanuts=" + peanuts + ", celery=" + celery + ", sesameSeeds=" + sesameSeeds + "]";
+    }
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/multipletables/multipleentities/MealWithMultipleEntities.java

@@ -0,0 +1,75 @@
+package com.baeldung.jpa.multipletables.multipleentities;
+
+import java.math.BigDecimal;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "meal")
+public class MealWithMultipleEntities {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "description")
+    private String description;
+
+    @Column(name = "price")
+    private BigDecimal price;
+
+    @OneToOne(mappedBy = "meal")
+    private AllergensAsEntity allergens;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public BigDecimal getPrice() {
+        return price;
+    }
+
+    public void setPrice(BigDecimal price) {
+        this.price = price;
+    }
+
+    public AllergensAsEntity getAllergens() {
+        return allergens;
+    }
+
+    public void setAllergens(AllergensAsEntity allergens) {
+        this.allergens = allergens;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    @Override
+    public String toString() {
+        return "MealWithMultipleEntities [id=" + id + ", name=" + name + ", description=" + description + ", price=" + price + ", allergens=" + allergens + "]";
+    }
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/multipletables/secondarytable/MealAsSingleEntity.java

@@ -0,0 +1,99 @@
+package com.baeldung.jpa.multipletables.secondarytable;
+
+import java.math.BigDecimal;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.PrimaryKeyJoinColumn;
+import javax.persistence.SecondaryTable;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "meal")
+@SecondaryTable(name = "allergens", pkJoinColumns = @PrimaryKeyJoinColumn(name = "meal_id"))
+public class MealAsSingleEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "description")
+    private String description;
+
+    @Column(name = "price")
+    private BigDecimal price;
+
+    @Column(name = "peanuts", table = "allergens")
+    private boolean peanuts;
+
+    @Column(name = "celery", table = "allergens")
+    private boolean celery;
+
+    @Column(name = "sesame_seeds", table = "allergens")
+    private boolean sesameSeeds;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public BigDecimal getPrice() {
+        return price;
+    }
+
+    public void setPrice(BigDecimal price) {
+        this.price = price;
+    }
+
+    public boolean isPeanuts() {
+        return peanuts;
+    }
+
+    public void setPeanuts(boolean peanuts) {
+        this.peanuts = peanuts;
+    }
+
+    public boolean isCelery() {
+        return celery;
+    }
+
+    public void setCelery(boolean celery) {
+        this.celery = celery;
+    }
+
+    public boolean isSesameSeeds() {
+        return sesameSeeds;
+    }
+
+    public void setSesameSeeds(boolean sesameSeeds) {
+        this.sesameSeeds = sesameSeeds;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    @Override
+    public String toString() {
+        return "MealAsSingleEntity [id=" + id + ", name=" + name + ", description=" + description + ", price=" + price + ", peanuts=" + peanuts + ", celery=" + celery + ", sesameSeeds=" + sesameSeeds + "]";
+    }
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/multipletables/secondarytable/embeddable/AllergensAsEmbeddable.java

@@ -0,0 +1,47 @@
+package com.baeldung.jpa.multipletables.secondarytable.embeddable;
+
+import javax.persistence.Column;
+import javax.persistence.Embeddable;
+
+@Embeddable
+public class AllergensAsEmbeddable {
+
+    @Column(name = "peanuts", table = "allergens")
+    private boolean peanuts;
+
+    @Column(name = "celery", table = "allergens")
+    private boolean celery;
+
+    @Column(name = "sesame_seeds", table = "allergens")
+    private boolean sesameSeeds;
+
+    public boolean isPeanuts() {
+        return peanuts;
+    }
+
+    public void setPeanuts(boolean peanuts) {
+        this.peanuts = peanuts;
+    }
+
+    public boolean isCelery() {
+        return celery;
+    }
+
+    public void setCelery(boolean celery) {
+        this.celery = celery;
+    }
+
+    public boolean isSesameSeeds() {
+        return sesameSeeds;
+    }
+
+    public void setSesameSeeds(boolean sesameSeeds) {
+        this.sesameSeeds = sesameSeeds;
+    }
+
+    @Override
+    public String toString() {
+        return "AllergensAsEmbeddable [peanuts=" + peanuts + ", celery=" + celery + ", sesameSeeds=" + sesameSeeds + "]";
+    }
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/multipletables/secondarytable/embeddable/MealWithEmbeddedAllergens.java

@@ -0,0 +1,78 @@
+package com.baeldung.jpa.multipletables.secondarytable.embeddable;
+
+import java.math.BigDecimal;
+
+import javax.persistence.Column;
+import javax.persistence.Embedded;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.PrimaryKeyJoinColumn;
+import javax.persistence.SecondaryTable;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "meal")
+@SecondaryTable(name = "allergens", pkJoinColumns = @PrimaryKeyJoinColumn(name = "meal_id"))
+public class MealWithEmbeddedAllergens {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "description")
+    private String description;
+
+    @Column(name = "price")
+    private BigDecimal price;
+
+    @Embedded
+    private AllergensAsEmbeddable allergens;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public BigDecimal getPrice() {
+        return price;
+    }
+
+    public void setPrice(BigDecimal price) {
+        this.price = price;
+    }
+
+    public AllergensAsEmbeddable getAllergens() {
+        return allergens;
+    }
+
+    public void setAllergens(AllergensAsEmbeddable allergens) {
+        this.allergens = allergens;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    @Override
+    public String toString() {
+        return "MealWithEmbeddedAllergens [id=" + id + ", name=" + name + ", description=" + description + ", price=" + price + ", allergens=" + allergens + "]";
+    }
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/projections/Product.java

@@ -0,0 +1,50 @@
+package com.baeldung.jpa.projections;
+
+import java.math.BigDecimal;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+
+@Entity
+public class Product {
+    @Id
+    private long id;
+    private String name;
+    private String description;
+    private String category;
+    private BigDecimal unitPrice;
+    
+    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 String getDescription() {
+        return description;
+    }
+    public void setDescription(String description) {
+        this.description = description;
+    }
+    public String getCategory() {
+        return category;
+    }
+    public void setCategory(String category) {
+        this.category = category;
+    }
+    public BigDecimal getUnitPrice() {
+        return unitPrice;
+    }
+    public void setUnitPrice(BigDecimal unitPrice) {
+        this.unitPrice = unitPrice;
+    }
+    
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/projections/ProductRepository.java

@@ -0,0 +1,93 @@
+package com.baeldung.jpa.projections;
+
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+import javax.persistence.Query;
+import javax.persistence.Tuple;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+
+public class ProductRepository {
+    private EntityManager entityManager;
+
+    public ProductRepository() {
+        EntityManagerFactory factory = Persistence.createEntityManagerFactory("jpa-projections");
+        entityManager = factory.createEntityManager();
+    }
+    
+    @SuppressWarnings("unchecked")
+    public List<Object> findAllNamesUsingJPQL() {
+        Query query = entityManager.createQuery("select name from Product");
+        List<Object> resultList = query.getResultList();
+        return resultList;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public List<Object> findAllIdsUsingJPQL() {
+        Query query = entityManager.createQuery("select id from Product");
+        List<Object> resultList = query.getResultList();
+        return resultList;
+    }
+    
+    public List<String> findAllNamesUsingCriteriaBuilder() {
+        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
+        CriteriaQuery<String> query = builder.createQuery(String.class);
+        Root<Product> product = query.from(Product.class);
+        query.select(product.get("name"));
+        List<String> resultList = entityManager.createQuery(query).getResultList();
+        return resultList;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public List<Object[]> findAllIdAndNamesUsingJPQL() {
+        Query query = entityManager.createQuery("select id, name from Product");
+        List<Object[]> resultList = query.getResultList();
+        return resultList;
+    }
+    
+    public List<Object[]> findAllIdAndNamesUsingCriteriaBuilderArray() {
+        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
+        CriteriaQuery<Object[]> query = builder.createQuery(Object[].class);
+        Root<Product> product = query.from(Product.class);
+        query.select(builder.array(product.get("id"), product.get("name")));
+        List<Object[]> resultList = entityManager.createQuery(query).getResultList();
+        return resultList;
+    }
+    
+    public List<Object[]> findAllIdNameUnitPriceUsingCriteriaQueryMultiselect() {
+        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
+        CriteriaQuery<Object[]> query = builder.createQuery(Object[].class);
+        Root<Product> product = query.from(Product.class);
+        query.multiselect(product.get("id"), product.get("name"), product.get("unitPrice"));
+        List<Object[]> resultList = entityManager.createQuery(query).getResultList();
+        return resultList;
+    }
+    
+    public List<Tuple> findAllIdAndNamesUsingCriteriaBuilderTuple() {
+        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
+        CriteriaQuery<Tuple> query = builder.createQuery(Tuple.class);
+        Root<Product> product = query.from(Product.class);
+        query.select(builder.tuple(product.get("id"), product.get("name")));
+        List<Tuple> resultList = entityManager.createQuery(query).getResultList();
+        return resultList;
+    }
+    
+    public List<Object[]> findCountByCategoryUsingJPQL() {
+        Query query = entityManager.createQuery("select p.category, count(p) from Product p group by p.category");
+        return query.getResultList();
+    }
+    
+    public List<Object[]> findCountByCategoryUsingCriteriaBuilder() {
+        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
+        CriteriaQuery<Object[]> query = builder.createQuery(Object[].class);
+        Root<Product> product = query.from(Product.class);
+        query.multiselect(product.get("category"), builder.count(product));
+        query.groupBy(product.get("category"));
+        List<Object[]> resultList = entityManager.createQuery(query).getResultList();
+        return resultList;
+    }
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/queryparams/Employee.java

@@ -0,0 +1,79 @@
+package com.baeldung.jpa.queryparams;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "employees")
+public class Employee {
+
+    /**
+     * 
+     */
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "employee_number", unique = true)
+    private String empNumber;
+
+    @Column(name = "employee_name")
+    private String name;
+
+    @Column(name = "employee_age")
+    private int age;
+
+    public Employee() {
+        super();
+    }
+
+    public Employee(Long id, String empNumber) {
+        super();
+        this.id = id;
+        this.empNumber = empNumber;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getEmpNumber() {
+        return empNumber;
+    }
+
+    public void setEmpNumber(String empNumber) {
+        this.empNumber = empNumber;
+    }
+
+    public static long getSerialversionuid() {
+        return serialVersionUID;
+    }
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/querytypes/QueryTypesExamples.java

@@ -0,0 +1,69 @@
+package com.baeldung.jpa.querytypes;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+import javax.persistence.Query;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+
+/**
+ * JPA Query Types examples. All using the UserEntity class.
+ *
+ * @author Rodolfo Felipe
+ */
+public class QueryTypesExamples {
+
+    EntityManagerFactory emf;
+
+    public QueryTypesExamples() {
+        Map properties = new HashMap();
+        properties.put("hibernate.show_sql", "true");
+        properties.put("hibernate.format_sql", "true");
+        emf = Persistence.createEntityManagerFactory("jpa-query-types", properties);
+    }
+
+    private EntityManager getEntityManager() {
+        return emf.createEntityManager();
+    }
+
+    public UserEntity getUserByIdWithPlainQuery(Long id) {
+        Query jpqlQuery = getEntityManager().createQuery("SELECT u FROM UserEntity u WHERE u.id=:id");
+        jpqlQuery.setParameter("id", id);
+        return (UserEntity) jpqlQuery.getSingleResult();
+    }
+
+    public UserEntity getUserByIdWithTypedQuery(Long id) {
+        TypedQuery<UserEntity> typedQuery = getEntityManager().createQuery("SELECT u FROM UserEntity u WHERE u.id=:id", UserEntity.class);
+        typedQuery.setParameter("id", id);
+        return typedQuery.getSingleResult();
+    }
+
+    public UserEntity getUserByIdWithNamedQuery(Long id) {
+        Query namedQuery = getEntityManager().createNamedQuery("UserEntity.findByUserId");
+        namedQuery.setParameter("userId", id);
+        return (UserEntity) namedQuery.getSingleResult();
+    }
+
+    public UserEntity getUserByIdWithNativeQuery(Long id) {
+        Query nativeQuery = getEntityManager().createNativeQuery("SELECT * FROM users WHERE id=:userId", UserEntity.class);
+        nativeQuery.setParameter("userId", id);
+        return (UserEntity) nativeQuery.getSingleResult();
+    }
+
+    public UserEntity getUserByIdWithCriteriaQuery(Long id) {
+        CriteriaBuilder criteriaBuilder = getEntityManager().getCriteriaBuilder();
+        CriteriaQuery<UserEntity> criteriaQuery = criteriaBuilder.createQuery(UserEntity.class);
+        Root<UserEntity> userRoot = criteriaQuery.from(UserEntity.class);
+        UserEntity queryResult = getEntityManager().createQuery(criteriaQuery.select(userRoot)
+            .where(criteriaBuilder.equal(userRoot.get("id"), id)))
+            .getSingleResult();
+        return queryResult;
+    }
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/querytypes/UserEntity.java

@@ -0,0 +1,38 @@
+package com.baeldung.jpa.querytypes;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.NamedQuery;
+import javax.persistence.Table;
+
+/**
+ * User entity class. Used as an asset for JPA Query Types examples.
+ *
+ * @author Rodolfo Felipe
+ */
+@Table(name = "users")
+@Entity
+@NamedQuery(name = "UserEntity.findByUserId", query = "SELECT u FROM UserEntity u WHERE u.id=:userId")
+public class UserEntity {
+
+    @Id
+    private Long id;
+    private String 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/java-jpa-2/src/main/java/com/baeldung/jpa/text/Exam.java

@@ -0,0 +1,103 @@
+package com.baeldung.jpa.text;
+
+import javax.persistence.*;
+
+@Entity
+public class Exam {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private Long id;
+    @Lob
+    private String description;
+    @Column(columnDefinition = "text")
+    private String text;
+    @Column(length = 20)
+    private String shortText;
+
+    public Exam() {
+
+    }
+
+    public Exam(String description, String text, String shortText) {
+        this.description = description;
+        this.text = text;
+        this.shortText = shortText;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    public String getShortText() {
+        return shortText;
+    }
+
+    public void setShortText(String shortText) {
+        this.shortText = shortText;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((description == null) ? 0 : description.hashCode());
+        result = prime * result + ((id == null) ? 0 : id.hashCode());
+        result = prime * result + ((shortText == null) ? 0 : shortText.hashCode());
+        result = prime * result + ((text == null) ? 0 : text.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;
+        Exam other = (Exam) obj;
+        if (description == null) {
+            if (other.description != null)
+                return false;
+        } else if (!description.equals(other.description))
+            return false;
+        if (id == null) {
+            if (other.id != null)
+                return false;
+        } else if (!id.equals(other.id))
+            return false;
+        if (shortText == null) {
+            if (other.shortText != null)
+                return false;
+        } else if (!shortText.equals(other.shortText))
+            return false;
+        if (text == null) {
+            if (other.text != null)
+                return false;
+        } else if (!text.equals(other.text))
+            return false;
+        return true;
+    }
+
+}

persistence-modules/java-jpa-2/src/main/java/com/baeldung/jpa/text/ExamRepository.java

@@ -0,0 +1,39 @@
+package com.baeldung.jpa.text;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+
+public class ExamRepository {
+
+    private EntityManagerFactory emf = null;
+
+    public ExamRepository() {
+        emf = Persistence.createEntityManagerFactory("jpa-h2-text");
+    }
+
+    public Exam find(Long id) {
+        EntityManager entityManager = emf.createEntityManager();
+        Exam exam = entityManager.find(Exam.class, id);
+        entityManager.close();
+        return exam;
+    }
+
+    public Exam save(Exam exam) {
+
+        EntityManager entityManager = emf.createEntityManager();
+        entityManager.getTransaction()
+            .begin();
+        exam = entityManager.merge(exam);
+        entityManager.getTransaction()
+            .commit();
+        entityManager.close();
+
+        return exam;
+    }
+
+    public void clean() {
+        emf.close();
+    }
+
+}

persistence-modules/java-jpa-2/src/main/resources/META-INF/persistence.xml

@@ -0,0 +1,166 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
+             http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd"
+	version="2.2">
+
+	<persistence-unit name="jpa-h2-queryparams"
+		transaction-type="RESOURCE_LOCAL">
+		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+		<class>com.baeldung.jpa.queryparams.Employee</class>
+		<exclude-unlisted-classes>true</exclude-unlisted-classes>
+		<properties>
+			<property name="javax.persistence.jdbc.driver"
+				value="org.h2.Driver" />
+			<property name="javax.persistence.jdbc.url"
+				value="jdbc:h2:mem:test" />
+			<property name="javax.persistence.jdbc.user" value="sa" />
+			<property name="javax.persistence.jdbc.password" value="" />
+			<property name="hibernate.dialect"
+				value="org.hibernate.dialect.H2Dialect" />
+			<property name="hibernate.hbm2ddl.auto" value="create-drop" />
+			<property name="show_sql" value="true" />
+			<property name="hibernate.temp.use_jdbc_metadata_defaults"
+				value="false" />
+			<property name="javax.persistence.sql-load-script-source"
+				value="queryparams.sql" />
+		</properties>
+	</persistence-unit>
+
+
+	<persistence-unit name="jpa-h2-text">
+		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+		<class>com.baeldung.jpa.text.Exam</class>
+		<exclude-unlisted-classes>true</exclude-unlisted-classes>
+		<properties>
+			<property name="javax.persistence.jdbc.driver"
+				value="org.h2.Driver" />
+			<property name="javax.persistence.jdbc.url"
+				value="jdbc:h2:mem:test" />
+			<property name="javax.persistence.jdbc.user" value="sa" />
+			<property name="javax.persistence.jdbc.password" value="" />
+			<property name="hibernate.dialect"
+				value="org.hibernate.dialect.H2Dialect" />
+			<property name="hibernate.hbm2ddl.auto" value="create-drop" />
+			<property name="show_sql" value="true" />
+			<property name="hibernate.temp.use_jdbc_metadata_defaults"
+				value="false" />
+		</properties>
+	</persistence-unit>
+
+	<persistence-unit name="entity-default-values">
+		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+		<class>com.baeldung.jpa.defaultvalues.User</class>
+		<exclude-unlisted-classes>true</exclude-unlisted-classes>
+		<properties>
+			<property name="javax.persistence.jdbc.driver"
+				value="org.h2.Driver" />
+			<property name="javax.persistence.jdbc.url"
+				value="jdbc:h2:mem:test" />
+			<property name="javax.persistence.jdbc.user" value="sa" />
+			<property name="javax.persistence.jdbc.password" value="" />
+			<property name="hibernate.dialect"
+				value="org.hibernate.dialect.H2Dialect" />
+			<property name="hibernate.hbm2ddl.auto" value="create-drop" />
+			<property name="show_sql" value="true" />
+			<property name="hibernate.temp.use_jdbc_metadata_defaults"
+				value="false" />
+		</properties>
+	</persistence-unit>
+
+	<persistence-unit name="jpa-query-types">
+		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+		<class>com.baeldung.jpa.querytypes.UserEntity</class>
+		<exclude-unlisted-classes>true</exclude-unlisted-classes>
+		<properties>
+			<property name="javax.persistence.jdbc.driver"
+				value="org.h2.Driver" />
+			<property name="javax.persistence.jdbc.url"
+				value="jdbc:h2:mem:test" />
+			<property name="javax.persistence.jdbc.user" value="sa" />
+			<property name="javax.persistence.jdbc.password" value="" />
+			<property name="hibernate.dialect"
+				value="org.hibernate.dialect.H2Dialect" />
+			<property name="hibernate.hbm2ddl.auto" value="create-drop" />
+			<property name="show_sql" value="true" />
+			<property name="hibernate.temp.use_jdbc_metadata_defaults"
+				value="false" />
+			<property name="javax.persistence.sql-load-script-source"
+				value="users.sql" />
+		</properties>
+	</persistence-unit>
+
+	<persistence-unit name="jpa-projections">
+		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+		<class>com.baeldung.jpa.projections.Product</class>
+		<exclude-unlisted-classes>true</exclude-unlisted-classes>
+		<properties>
+			<property name="javax.persistence.jdbc.driver"
+				value="org.h2.Driver" />
+			<property name="javax.persistence.jdbc.url"
+				value="jdbc:h2:mem:test" />
+			<property name="javax.persistence.jdbc.user" value="sa" />
+			<property name="javax.persistence.jdbc.password" value="" />
+			<property name="hibernate.dialect"
+				value="org.hibernate.dialect.H2Dialect" />
+			<property name="hibernate.hbm2ddl.auto" value="create-drop" />
+			<property name="show_sql" value="true" />
+			<property name="hibernate.temp.use_jdbc_metadata_defaults"
+				value="false" />
+			<property name="javax.persistence.sql-load-script-source"
+				value="products_jpa.sql" />
+		</properties>
+	</persistence-unit>
+
+	<persistence-unit name="jpa-h2-criteria">
+		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+		<class>com.baeldung.jpa.criteria.Item</class>
+		<exclude-unlisted-classes>true</exclude-unlisted-classes>
+		<properties>
+			<property name="javax.persistence.jdbc.driver"
+				value="org.h2.Driver" />
+			<property name="javax.persistence.jdbc.url"
+				value="jdbc:h2:mem:test" />
+			<property name="javax.persistence.jdbc.user" value="sa" />
+			<property name="javax.persistence.jdbc.password" value="" />
+			<property name="hibernate.dialect"
+				value="org.hibernate.dialect.H2Dialect" />
+			<property name="hibernate.hbm2ddl.auto" value="create-drop" />
+			<property name="show_sql" value="true" />
+			<property name="hibernate.temp.use_jdbc_metadata_defaults"
+				value="false" />
+			<property name="javax.persistence.sql-load-script-source"
+				value="item.sql" />
+		</properties>
+	</persistence-unit>
+
+    <persistence-unit name="jpa-h2-multipltables">
+        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+        <class>com.baeldung.jpa.multipletables.multipleentities.MealWithMultipleEntities</class>
+        <class>com.baeldung.jpa.multipletables.multipleentities.AllergensAsEntity</class>
+        
+        <class>com.baeldung.jpa.multipletables.secondarytable.MealAsSingleEntity</class>
+        
+        <class>com.baeldung.jpa.multipletables.secondarytable.embeddable.MealWithEmbeddedAllergens</class>
+        <class>com.baeldung.jpa.multipletables.secondarytable.embeddable.AllergensAsEmbeddable</class>
+
+        <exclude-unlisted-classes>true</exclude-unlisted-classes>
+        <properties>
+            <property name="javax.persistence.jdbc.driver"
+                      value="org.h2.Driver" />
+            <property name="javax.persistence.jdbc.url"
+                      value="jdbc:h2:mem:test" />
+            <property name="javax.persistence.jdbc.user" value="sa" />
+            <property name="javax.persistence.jdbc.password" value="" />
+            <property name="hibernate.dialect"
+                      value="org.hibernate.dialect.H2Dialect" />
+            <property name="hibernate.hbm2ddl.auto" value="create" />
+            <property name="hibernate.hbm2ddl.import_files" value="multipletables.sql" />
+            <property name="show_sql" value="true" />
+            <property name="hibernate.temp.use_jdbc_metadata_defaults"
+                      value="false" />
+        </properties>
+    </persistence-unit>
+
+</persistence>

persistence-modules/java-jpa-2/src/main/resources/item.sql

@@ -0,0 +1,4 @@
+insert into item(id,grade,color) values (10,'C','blue');
+insert into item(id,grade,color) values (11,'C','red');
+insert into item(id,grade,color) values (12,'A','blue');
+insert into item(id,grade,color) values (13,'D','red');

persistence-modules/java-jpa-2/src/main/resources/logback.xml

@@ -0,0 +1,15 @@
+<?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/java-jpa-2/src/main/resources/products_jpa.sql

@@ -0,0 +1,4 @@
+insert into product(id, name, description, category) values (1,'Product Name 1','This is Product 1', 'category1');
+insert into product(id, name, description, category) values (2,'Product Name 2','This is Product 2', 'category1');
+insert into product(id, name, description, category) values (3,'Product Name 3','This is Product 3', 'category2');
+insert into product(id, name, description, category) values (4,'Product Name 4','This is Product 4', 'category3');

persistence-modules/java-jpa-2/src/test/java/com/baeldung/jpa/criteria/CustomItemRepositoryIntegrationTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.jpa.criteria;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import java.util.List;
+
+import org.junit.Test;
+
+import com.baeldung.jpa.criteria.Item;
+import com.baeldung.jpa.criteria.CustomItemRepository;
+
+public class CustomItemRepositoryIntegrationTest {
+
+    CustomItemRepository customItemRepository = new CustomItemRepositoryImpl();
+
+    @Test
+    public void givenItems_whenFindItemsByColorAndGrade_thenReturnItems() {
+
+        List<Item> items = customItemRepository.findItemsByColorAndGrade();
+
+        assertFalse("No items found", items.isEmpty());
+        assertEquals("There should be only one item", 1, items.size());
+
+        Item item = items.get(0);
+
+        assertEquals("this item do not have blue color", "blue", item.getColor());
+        assertEquals("this item does not belong to A grade", "A", item.getGrade());
+    }
+
+    @Test
+    public void givenItems_whenFindItemByColorOrGrade_thenReturnItems() {
+
+        List<Item> items = customItemRepository.findItemByColorOrGrade();
+
+        assertFalse("No items found", items.isEmpty());
+        assertEquals("There should be only one item", 1, items.size());
+
+        Item item = items.get(0);
+
+        assertEquals("this item do not have red color", "red", item.getColor());
+        assertEquals("this item does not belong to D grade", "D", item.getGrade());
+    }
+}

persistence-modules/java-jpa-2/src/test/java/com/baeldung/jpa/defaultvalues/UserDefaultValuesUnitTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.jpa.defaultvalues;
+
+import com.baeldung.jpa.defaultvalues.User;
+import com.baeldung.jpa.defaultvalues.UserRepository;
+
+import org.junit.Test;
+import org.junit.Ignore;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+import static org.junit.Assert.*;
+
+public class UserDefaultValuesUnitTest {
+
+    private static UserRepository userRepository = null;
+
+    @BeforeClass
+    public static void once() {
+        userRepository = new UserRepository();
+    }
+
+    @Test
+    @Ignore // SQL default values are also defined
+    public void saveUser_shouldSaveWithDefaultFieldValues() {
+        User user = new User();
+        userRepository.save(user, 1L);
+
+        user = userRepository.find(1L);
+        assertEquals(user.getName(), "John Snow");
+        assertEquals(25, (int) user.getAge());
+        assertFalse(user.getLocked());
+    }
+
+    @Test
+    @Ignore // SQL default values are also defined
+    public void saveUser_shouldSaveWithNullName() {
+        User user = new User();
+        user.setName(null);
+        userRepository.save(user, 2L);
+
+        user = userRepository.find(2L);
+        assertNull(user.getName());
+        assertEquals(25, (int) user.getAge());
+        assertFalse(user.getLocked());
+    }
+
+    @Test
+    public void saveUser_shouldSaveWithDefaultSqlValues() {
+        User user = new User();
+        userRepository.save(user, 3L);
+
+        user = userRepository.find(3L);
+        assertEquals(user.getName(), "John Snow");
+        assertEquals(25, (int) user.getAge());
+        assertFalse(user.getLocked());
+    }
+
+    @AfterClass
+    public static void destroy() {
+        userRepository.clean();
+    }
+
+}

persistence-modules/java-jpa-2/src/test/java/com/baeldung/jpa/multipletables/MultipleTablesIntegrationTest.java

@@ -0,0 +1,79 @@
+package com.baeldung.jpa.multipletables;
+
+import static org.assertj.core.api.Assertions.*;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.baeldung.jpa.multipletables.multipleentities.MealWithMultipleEntities;
+import com.baeldung.jpa.multipletables.secondarytable.MealAsSingleEntity;
+import com.baeldung.jpa.multipletables.secondarytable.embeddable.MealWithEmbeddedAllergens;
+
+public class MultipleTablesIntegrationTest {
+
+    private static EntityManagerFactory emf;
+    private static EntityManager em;
+
+    @BeforeClass
+    public static void setup() {
+        emf = Persistence.createEntityManagerFactory("jpa-h2-multipltables");
+        em = emf.createEntityManager();
+    }
+
+    @Test
+    public void entityManager_shouldLoadMealAsSingleEntity() {
+        // given
+        
+        // when
+        MealAsSingleEntity meal = em.find(MealAsSingleEntity.class, 1L);
+        
+        // then
+        assertThat(meal).isNotNull();
+        assertThat(meal.getId()).isEqualTo(1L);
+        assertThat(meal.isPeanuts()).isFalse();
+        assertThat(meal.isCelery()).isTrue();
+    }
+
+    @Test
+    public void entityManager_shouldLoadMealWithEmbeddedAllergens() {
+        // given
+        
+        // when
+        MealWithEmbeddedAllergens meal = em.find(MealWithEmbeddedAllergens.class, 1L);
+        
+        // then
+        assertThat(meal).isNotNull();
+        assertThat(meal.getId()).isEqualTo(1L);
+        assertThat(meal.getAllergens()).isNotNull();
+        assertThat(meal.getAllergens().isPeanuts()).isFalse();
+        assertThat(meal.getAllergens().isCelery()).isTrue();
+    }
+
+    @Test
+    public void entityManager_shouldLoadMealWithAllergensEntity() {
+        // given
+        
+        // when
+        MealWithMultipleEntities meal = em.find(MealWithMultipleEntities.class, 1L);
+        
+        // then
+        assertThat(meal).isNotNull();
+        assertThat(meal.getId()).isEqualTo(1L);
+        assertThat(meal.getAllergens()).isNotNull();
+        assertThat(meal.getAllergens().isPeanuts()).isFalse();
+        assertThat(meal.getAllergens().isCelery()).isTrue();
+    }
+
+    @AfterClass
+    public static void teardown() {
+        if (emf != null) {
+            emf.close();
+        }
+    }
+
+}

persistence-modules/java-jpa-2/src/test/java/com/baeldung/jpa/projections/HibernateProjectionsIntegrationTest.java

@@ -0,0 +1,133 @@
+package com.baeldung.jpa.projections;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.List;
+
+import org.hibernate.Criteria;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.Transaction;
+import org.hibernate.cfg.AvailableSettings;
+import org.hibernate.cfg.Configuration;
+import org.hibernate.criterion.Order;
+import org.hibernate.criterion.Projections;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class HibernateProjectionsIntegrationTest {
+    private static Session session;
+    private static SessionFactory sessionFactory;
+    private Transaction transaction;
+
+    @BeforeClass
+    public static void init() {
+        Configuration configuration = getConfiguration();
+        configuration.addAnnotatedClass(Product.class);
+        sessionFactory = configuration.buildSessionFactory();
+    }    
+    
+    @Before
+    public void before() {
+        session = sessionFactory.getCurrentSession();
+        transaction = session.beginTransaction();        
+    }   
+    
+    @After
+    public void after() {
+        if(transaction.isActive()) {
+            transaction.rollback();
+        }
+    }  
+
+    private static Configuration getConfiguration() {
+        Configuration cfg = new Configuration();
+        cfg.setProperty(AvailableSettings.DIALECT,
+            "org.hibernate.dialect.H2Dialect");
+        cfg.setProperty(AvailableSettings.HBM2DDL_AUTO, "none");
+        cfg.setProperty(AvailableSettings.DRIVER, "org.h2.Driver");
+        cfg.setProperty(AvailableSettings.URL,
+            "jdbc:h2:mem:myexceptiondb2;DB_CLOSE_DELAY=-1;;INIT=RUNSCRIPT FROM 'src/test/resources/products.sql'");
+        cfg.setProperty(AvailableSettings.USER, "sa");
+        cfg.setProperty(AvailableSettings.PASS, "");
+        cfg.setProperty(AvailableSettings.CURRENT_SESSION_CONTEXT_CLASS, "thread");
+        return cfg;
+    }
+    
+    
+    @SuppressWarnings("deprecation")
+    @Test
+    public void givenProductData_whenIdAndNameProjectionUsingCriteria_thenListOfObjectArrayReturned() {
+        Criteria criteria = session.createCriteria(Product.class);
+        criteria = criteria.setProjection(Projections.projectionList()
+            .add(Projections.id())
+            .add(Projections.property("name")));
+        List<Object[]> resultList = criteria.list();
+
+        assertNotNull(resultList);
+        assertEquals(4, resultList.size());
+        assertEquals(1L, resultList.get(0)[0]);
+        assertEquals("Product Name 1", resultList.get(0)[1]);
+        assertEquals(2L, resultList.get(1)[0]);
+        assertEquals("Product Name 2", resultList.get(1)[1]);
+        assertEquals(3L, resultList.get(2)[0]);
+        assertEquals("Product Name 3", resultList.get(2)[1]);
+        assertEquals(4L, resultList.get(3)[0]);
+        assertEquals("Product Name 4", resultList.get(3)[1]);
+    }
+    
+    
+    @Test
+    public void givenProductData_whenNameProjectionUsingCriteria_thenListOfStringReturned() {
+        Criteria criteria = session.createCriteria(Product.class);
+        criteria = criteria.setProjection(Projections.property("name"));
+        List resultList = criteria.list();
+
+        assertNotNull(resultList);
+        assertEquals(4, resultList.size());
+        assertEquals("Product Name 1", resultList.get(0));
+        assertEquals("Product Name 2", resultList.get(1));
+        assertEquals("Product Name 3", resultList.get(2));
+        assertEquals("Product Name 4", resultList.get(3));
+    }
+    
+    @Test
+    public void givenProductData_whenCountByCategoryUsingCriteria_thenOK() {
+        Criteria criteria = session.createCriteria(Product.class);
+        criteria = criteria.setProjection(Projections.projectionList()
+            .add(Projections.groupProperty("category"))
+            .add(Projections.rowCount()));
+        List<Object[]> resultList = criteria.list();
+
+        assertNotNull(resultList);
+        assertEquals(3, resultList.size());
+        assertEquals("category1", resultList.get(0)[0]);
+        assertEquals(2L, resultList.get(0)[1]);
+        assertEquals("category2", resultList.get(1)[0]);
+        assertEquals(1L, resultList.get(1)[1]);
+        assertEquals("category3", resultList.get(2)[0]);
+        assertEquals(1L, resultList.get(2)[1]);
+    }
+    
+    @Test
+    public void givenProductData_whenCountByCategoryWithAliasUsingCriteria_thenOK() {
+        Criteria criteria = session.createCriteria(Product.class);
+        criteria = criteria.setProjection(Projections.projectionList()
+            .add(Projections.groupProperty("category"))
+            .add(Projections.alias(Projections.rowCount(), "count")));
+        criteria.addOrder(Order.asc("count"));
+        List<Object[]> resultList = criteria.list();
+
+        assertNotNull(resultList);
+        assertEquals(3, resultList.size());
+        assertEquals("category2", resultList.get(0)[0]);
+        assertEquals(1L, resultList.get(0)[1]);
+        assertEquals("category3", resultList.get(1)[0]);
+        assertEquals(1L, resultList.get(1)[1]);
+        assertEquals("category1", resultList.get(2)[0]);
+        assertEquals(2L, resultList.get(2)[1]);
+    }
+}

persistence-modules/java-jpa-2/src/test/java/com/baeldung/jpa/projections/ProductRepositoryIntegrationTest.java

@@ -0,0 +1,105 @@
+package com.baeldung.jpa.projections;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+
+public class ProductRepositoryIntegrationTest {
+    private static ProductRepository productRepository;
+
+    @BeforeClass
+    public static void once() throws IOException {
+        productRepository = new ProductRepository();
+    }
+    
+    @Test
+    public void givenProductData_whenIdAndNameProjectionUsingJPQL_thenListOfObjectArrayReturned() {
+        List<Object[]> resultList = productRepository.findAllIdAndNamesUsingJPQL();
+        
+        assertNotNull(resultList);
+        assertEquals(4, resultList.size());
+        assertEquals(1L, resultList.get(0)[0]);
+        assertEquals("Product Name 1", resultList.get(0)[1]);
+        assertEquals(2L, resultList.get(1)[0]);
+        assertEquals("Product Name 2", resultList.get(1)[1]);
+        assertEquals(3L, resultList.get(2)[0]);
+        assertEquals("Product Name 3", resultList.get(2)[1]);
+        assertEquals(4L, resultList.get(3)[0]);
+        assertEquals("Product Name 4", resultList.get(3)[1]);
+    }
+    
+    @Test
+    public void givenProductData_whenIdAndNameProjectionUsingCriteriaBuilder_thenListOfObjectArrayReturned() {
+        List<Object[]> resultList = productRepository.findAllIdAndNamesUsingCriteriaBuilderArray();
+                
+        assertNotNull(resultList);
+        assertEquals(4, resultList.size());
+        assertEquals(1L, resultList.get(0)[0]);
+        assertEquals("Product Name 1", resultList.get(0)[1]);
+        assertEquals(2L, resultList.get(1)[0]);
+        assertEquals("Product Name 2", resultList.get(1)[1]);
+        assertEquals(3L, resultList.get(2)[0]);
+        assertEquals("Product Name 3", resultList.get(2)[1]);
+        assertEquals(4L, resultList.get(3)[0]);
+        assertEquals("Product Name 4", resultList.get(3)[1]);
+    }
+    
+    @SuppressWarnings("rawtypes")
+    @Test
+    public void givenProductData_whenNameProjectionUsingJPQL_thenListOfStringReturned() {
+        List resultList = productRepository.findAllNamesUsingJPQL();
+        
+        assertNotNull(resultList);
+        assertEquals(4, resultList.size());
+        assertEquals("Product Name 1", resultList.get(0));
+        assertEquals("Product Name 2", resultList.get(1));
+        assertEquals("Product Name 3", resultList.get(2));
+        assertEquals("Product Name 4", resultList.get(3));
+    }
+    
+    @Test
+    public void givenProductData_whenNameProjectionUsingCriteriaBuilder_thenListOfStringReturned() {
+        List<String> resultList = productRepository.findAllNamesUsingCriteriaBuilder();
+        
+        assertNotNull(resultList);
+        assertEquals(4, resultList.size());
+        assertEquals("Product Name 1", resultList.get(0));
+        assertEquals("Product Name 2", resultList.get(1));
+        assertEquals("Product Name 3", resultList.get(2));
+        assertEquals("Product Name 4", resultList.get(3));
+    }
+    
+    @Test
+    public void givenProductData_whenCountByCategoryUsingJPQL_thenOK() {
+        List<Object[]> resultList = productRepository.findCountByCategoryUsingJPQL();
+
+        assertNotNull(resultList);
+        assertEquals(3, resultList.size());
+        assertEquals("category1", resultList.get(0)[0]);
+        assertEquals(2L, resultList.get(0)[1]);
+        assertEquals("category2", resultList.get(1)[0]);
+        assertEquals(1L, resultList.get(1)[1]);
+        assertEquals("category3", resultList.get(2)[0]);
+        assertEquals(1L, resultList.get(2)[1]);
+    }
+
+    @Test
+    public void givenProductData_whenCountByCategoryUsingCriteriaBuider_thenOK() {
+        List<Object[]> resultList = productRepository.findCountByCategoryUsingCriteriaBuilder();
+
+        assertNotNull(resultList);
+        assertEquals(3, resultList.size());
+        assertEquals("category1", resultList.get(0)[0]);
+        assertEquals(2L, resultList.get(0)[1]);
+        assertEquals("category2", resultList.get(1)[0]);
+        assertEquals(1L, resultList.get(1)[1]);
+        assertEquals("category3", resultList.get(2)[0]);
+        assertEquals(1L, resultList.get(2)[1]);
+    }
+}

persistence-modules/java-jpa-2/src/test/java/com/baeldung/jpa/queryparams/JPAQueryParamsUnitTest.java

@@ -0,0 +1,109 @@
+package com.baeldung.jpa.queryparams;
+
+import java.util.Arrays;
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.ParameterExpression;
+import javax.persistence.criteria.Root;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * JPAQueryParamsTest class tests.
+ *
+ * @author gmlopez.mackinnon@gmail.com
+ */
+public class JPAQueryParamsUnitTest {
+
+    private static EntityManager entityManager;
+
+    @BeforeClass
+    public static void setup() {
+        EntityManagerFactory factory = Persistence.createEntityManagerFactory("jpa-h2-queryparams");
+        entityManager = factory.createEntityManager();
+    }
+
+    @Test
+    public void givenEmpNumber_whenUsingPositionalParameter_thenReturnExpectedEmployee() {
+        TypedQuery<Employee> query = entityManager.createQuery("SELECT e FROM Employee e WHERE e.empNumber = ?1", Employee.class);
+        String empNumber = "A123";
+        Employee employee = query.setParameter(1, empNumber)
+          .getSingleResult();
+        Assert.assertNotNull("Employee not found", employee);
+    }
+
+    @Test
+    public void givenEmpNumberList_whenUsingPositionalParameter_thenReturnExpectedEmployee() {
+        TypedQuery<Employee> query = entityManager.createQuery("SELECT e FROM Employee e WHERE e.empNumber IN (?1)", Employee.class);
+        List<String> empNumbers = Arrays.asList("A123", "A124");
+        List<Employee> employees = query.setParameter(1, empNumbers)
+          .getResultList();
+        Assert.assertNotNull("Employees not found", employees);
+        Assert.assertFalse("Employees not found", employees.isEmpty());
+    }
+
+    @Test
+    public void givenEmpNumber_whenUsingNamedParameter_thenReturnExpectedEmployee() {
+        TypedQuery<Employee> query = entityManager.createQuery("SELECT e FROM Employee e WHERE e.empNumber = :number", Employee.class);
+        String empNumber = "A123";
+        Employee employee = query.setParameter("number", empNumber)
+          .getSingleResult();
+        Assert.assertNotNull("Employee not found", employee);
+    }
+
+    @Test
+    public void givenEmpNumberList_whenUsingNamedParameter_thenReturnExpectedEmployee() {
+        TypedQuery<Employee> query = entityManager.createQuery("SELECT e FROM Employee e WHERE e.empNumber IN (:numbers)", Employee.class);
+        List<String> empNumbers = Arrays.asList("A123", "A124");
+        List<Employee> employees = query.setParameter("numbers", empNumbers)
+          .getResultList();
+        Assert.assertNotNull("Employees not found", employees);
+        Assert.assertFalse("Employees not found", employees.isEmpty());
+    }
+
+    @Test
+    public void givenEmpNameAndEmpAge_whenUsingTwoNamedParameters_thenReturnExpectedEmployees() {
+        TypedQuery<Employee> query = entityManager.createQuery("SELECT e FROM Employee e WHERE e.name = :name AND e.age = :empAge", Employee.class);
+        String empName = "John Doe";
+        int empAge = 55;
+        List<Employee> employees = query.setParameter("name", empName)
+          .setParameter("empAge", empAge)
+          .getResultList();
+        Assert.assertNotNull("Employees not found!", employees);
+        Assert.assertTrue("Employees not found!", !employees.isEmpty());
+    }
+
+    @Test
+    public void givenEmpNumber_whenUsingCriteriaQuery_thenReturnExpectedEmployee() {
+        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
+
+        CriteriaQuery<Employee> cQuery = cb.createQuery(Employee.class);
+        Root<Employee> c = cQuery.from(Employee.class);
+        ParameterExpression<String> paramEmpNumber = cb.parameter(String.class);
+        cQuery.select(c)
+          .where(cb.equal(c.get(Employee_.empNumber), paramEmpNumber));
+
+        TypedQuery<Employee> query = entityManager.createQuery(cQuery);
+        String empNumber = "A123";
+        query.setParameter(paramEmpNumber, empNumber);
+        Employee employee = query.getSingleResult();
+        Assert.assertNotNull("Employee not found!", employee);
+    }
+
+    @Test
+    public void givenEmpNumber_whenUsingLiteral_thenReturnExpectedEmployee() {
+        String empNumber = "A123";
+        TypedQuery<Employee> query = entityManager.createQuery("SELECT e FROM Employee e WHERE e.empNumber = '" + empNumber + "'", Employee.class);
+        Employee employee = query.getSingleResult();
+        Assert.assertNotNull("Employee not found!", employee);
+    }
+
+}

persistence-modules/java-jpa-2/src/test/java/com/baeldung/jpa/querytypes/QueryTypesExamplesIntegrationTest.java

@@ -0,0 +1,65 @@
+package com.baeldung.jpa.querytypes;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * QueryTypesExamples class integration tests.
+ *
+ * @author Rodolfo Felipe
+ */
+public class QueryTypesExamplesIntegrationTest {
+
+    QueryTypesExamples userDao = new QueryTypesExamples();
+
+    @Test
+    public void givenUserId_whenCallingPlaingQueryMethod_thenReturnExpectedUser() {
+        UserEntity firstUser = userDao.getUserByIdWithPlainQuery(1L);
+        Assert.assertNotNull("User not found", firstUser);
+        Assert.assertEquals("User should be baeldung", "baeldung", firstUser.getName());
+        UserEntity lastUser = userDao.getUserByIdWithPlainQuery(4L);
+        Assert.assertNotNull("User not found", lastUser);
+        Assert.assertEquals("User should be baeldung", "batman", lastUser.getName());
+    }
+
+    @Test
+    public void givenUserId_whenCallingTypedQueryMethod_thenReturnExpectedUser() {
+        UserEntity firstUser = userDao.getUserByIdWithTypedQuery(1L);
+        Assert.assertNotNull("User not found", firstUser);
+        Assert.assertEquals("User should be baeldung", "baeldung", firstUser.getName());
+        UserEntity lastUser = userDao.getUserByIdWithTypedQuery(4L);
+        Assert.assertNotNull("User not found", lastUser);
+        Assert.assertEquals("User should be baeldung", "batman", lastUser.getName());
+    }
+
+    @Test
+    public void givenUserId_whenCallingNamedQueryMethod_thenReturnExpectedUser() {
+        UserEntity firstUser = userDao.getUserByIdWithNamedQuery(1L);
+        Assert.assertNotNull("User not found", firstUser);
+        Assert.assertEquals("User should be baeldung", "baeldung", firstUser.getName());
+        UserEntity lastUser = userDao.getUserByIdWithNamedQuery(4L);
+        Assert.assertNotNull("User not found", lastUser);
+        Assert.assertEquals("User should be baeldung", "batman", lastUser.getName());
+    }
+
+    @Test
+    public void givenUserId_whenCallingNativeQueryMethod_thenReturnExpectedUser() {
+        UserEntity firstUser = userDao.getUserByIdWithNativeQuery(1L);
+        Assert.assertNotNull("User not found", firstUser);
+        Assert.assertEquals("User should be baeldung", "baeldung", firstUser.getName());
+        UserEntity lastUser = userDao.getUserByIdWithNativeQuery(4L);
+        Assert.assertNotNull("User not found", lastUser);
+        Assert.assertEquals("User should be baeldung", "batman", lastUser.getName());
+    }
+
+    @Test
+    public void givenUserId_whenCallingCriteriaApiMethod_thenReturnExpectedUser() {
+        UserEntity firstUser = userDao.getUserByIdWithCriteriaQuery(1L);
+        Assert.assertNotNull("User not found", firstUser);
+        Assert.assertEquals("User should be baeldung", "baeldung", firstUser.getName());
+        UserEntity lastUser = userDao.getUserByIdWithCriteriaQuery(4L);
+        Assert.assertNotNull("User not found", lastUser);
+        Assert.assertEquals("User should be baeldung", "batman", lastUser.getName());
+    }
+
+}

persistence-modules/java-jpa-2/src/test/java/com/baeldung/jpa/text/JPATextUnitTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.jpa.text;
+
+import static org.junit.Assert.assertEquals;
+
+import javax.persistence.PersistenceException;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class JPATextUnitTest {
+
+    private static ExamRepository examRepository = null;
+
+    @BeforeClass
+    public static void once() {
+        examRepository = new ExamRepository();
+    }
+
+    @Test
+    public void givenExam_whenSaveExam_thenReturnExpectedExam() {
+        Exam exam = new Exam();
+        exam.setDescription("This is a description. Sometimes the description can be very very long! ");
+        exam.setText("This is a text. Sometimes the text can be very very long!");
+        exam.setShortText("A short text");
+
+        exam = examRepository.save(exam);
+
+        assertEquals(examRepository.find(exam.getId()), exam);
+    }
+
+    @Test(expected = PersistenceException.class)
+    public void givenExamWithVeryLongShortText_whenSaveExam_thenThrowPersistenceException() {
+        Exam exam = new Exam();
+        exam.setDescription("This is a very long text");
+        exam.setText("This is a long text");
+        exam.setShortText("This is a very long long short text. Maybe this can cause problems!!");
+
+        examRepository.save(exam);
+    }
+
+}

persistence-modules/java-jpa-2/src/test/resources/multipletables.sql

@@ -0,0 +1,8 @@
+drop table if exists allergens;
+drop table if exists meal;
+
+create table meal (id bigint auto_increment, name varchar(255) not null, description varchar(255) not null, price decimal(19, 2) not null, primary key (id));
+create table allergens (meal_id bigint auto_increment, peanuts number(1) not null, celery number(1) not null, sesame_seeds number(1) not null, primary key (meal_id));
+
+insert into meal (id, name, description, price) values (1, 'Pizza', 'Delicious', 5);
+insert into allergens (meal_id, peanuts, celery, sesame_seeds) values (1, 0, 1, 0);

persistence-modules/java-jpa-2/src/test/resources/products.sql

@@ -0,0 +1,5 @@
+create table Product (id bigint not null, category varchar(255), description varchar(255), name varchar(255), unitPrice decimal(19,2), primary key (id));
+insert into product(id, name, description, category) values (1,'Product Name 1','This is Product 1', 'category1');
+insert into product(id, name, description, category) values (2,'Product Name 2','This is Product 2', 'category1');
+insert into product(id, name, description, category) values (3,'Product Name 3','This is Product 3', 'category2');
+insert into product(id, name, description, category) values (4,'Product Name 4','This is Product 4', 'category3');

persistence-modules/java-jpa-2/src/test/resources/queryparams.sql

@@ -0,0 +1,2 @@
+INSERT INTO employees (employee_number, employee_name, employee_age) VALUES ('111', 'John Doe', 55);
+INSERT INTO employees (employee_number, employee_name, employee_age) VALUES ('A123', 'John Doe Junior', 25);

persistence-modules/java-jpa-2/src/test/resources/users.sql

@@ -0,0 +1,4 @@
+INSERT INTO users(id,name) VALUES(1,'baeldung');
+INSERT INTO users(id,name) VALUES(2,'john doe');
+INSERT INTO users(id,name) VALUES(3,'jane doe');
+INSERT INTO users(id,name) VALUES(4,'batman');