Merge branch 'master' into bael-16656

persistence-modules/README.md

@@ -0,0 +1,3 @@
+## Persistence Modules
+
+This module contains articles about persistence. Actual articles go into its submodules. 

persistence-modules/activejdbc/README.md

@@ -0,0 +1,2 @@
+### Relevant Articles:
+- [Introduction to ActiveJDBC](http://www.baeldung.com/active-jdbc)

persistence-modules/activejdbc/pom.xml

@@ -0,0 +1,91 @@
+<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>activejdbc</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <name>activejdbc</name>
+    <packaging>jar</packaging>
+    <url>http://maven.apache.org</url>
+
+    <parent>
+        <artifactId>parent-modules</artifactId>
+        <groupId>com.baeldung</groupId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.javalite</groupId>
+            <artifactId>activejdbc</artifactId>
+            <version>${activejdbc.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>opensymphony</groupId>
+                    <artifactId>oscache</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>${mysql.connector.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>${org.slf4j.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                    <encoding>UTF-8</encoding>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.javalite</groupId>
+                <artifactId>activejdbc-instrumentation</artifactId>
+                <version>${activejdbc.version}</version>
+                <executions>
+                    <execution>
+                        <phase>process-classes</phase>
+                        <goals>
+                            <goal>instrument</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.javalite</groupId>
+                <artifactId>db-migrator-maven-plugin</artifactId>
+                <version>${activejdbc.version}</version>
+                <configuration>
+                    <configFile>${project.basedir}/src/main/resources/database.properties</configFile>
+                    <environments>${environments}</environments>
+                </configuration>
+                <dependencies>
+                    <dependency>
+                        <groupId>mysql</groupId>
+                        <artifactId>mysql-connector-java</artifactId>
+                        <version>${mysql.connector.version}</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <activejdbc.version>2.0</activejdbc.version>
+        <environments>development.test,development</environments>
+        <mysql.connector.version>5.1.34</mysql.connector.version>
+    </properties>
+
+</project>

persistence-modules/activejdbc/src/main/java/com/baeldung/ActiveJDBCApp.java

@@ -0,0 +1,61 @@
+package com.baeldung;
+
+
+import com.baeldung.model.Employee;
+import com.baeldung.model.Role;
+import org.javalite.activejdbc.Base;
+import org.javalite.activejdbc.LazyList;
+import org.javalite.activejdbc.Model;
+
+public class ActiveJDBCApp
+{
+    public static void main( String[] args )
+    {
+        try {
+            Base.open();
+            ActiveJDBCApp app = new ActiveJDBCApp();
+            app.create();
+            app.update();
+            app.delete();
+            app.deleteCascade();
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            Base.close();
+        }
+    }
+
+    protected void create() {
+        Employee employee = new Employee("Hugo","C","M","BN");
+        employee.saveIt();
+        employee.add(new Role("Java Developer","BN"));
+        LazyList<Model> all = Employee.findAll();
+        System.out.println(all.size());
+    }
+
+    protected void update() {
+        Employee employee = Employee.findFirst("first_name = ?","Hugo");
+        employee.set("last_namea","Choi").saveIt();
+        employee = Employee.findFirst("last_name = ?","Choi");
+        System.out.println(employee.getString("first_name") + " " + employee.getString("last_name"));
+    }
+
+    protected void delete() {
+        Employee employee = Employee.findFirst("first_name = ?","Hugo");
+        employee.delete();
+        employee = Employee.findFirst("last_name = ?","Choi");
+        if(null == employee){
+            System.out.println("No such Employee found!");
+        }
+    }
+
+    protected void deleteCascade() {
+        create();
+        Employee employee = Employee.findFirst("first_name = ?","Hugo");
+        employee.deleteCascade();
+        employee = Employee.findFirst("last_name = ?","C");
+        if(null == employee){
+            System.out.println("No such Employee found!");
+        }
+    }
+}

persistence-modules/activejdbc/src/main/java/com/baeldung/model/Employee.java

@@ -0,0 +1,23 @@
+package com.baeldung.model;
+
+
+import org.javalite.activejdbc.Model;
+
+public class Employee extends Model {
+
+    public Employee(){
+
+    }
+
+    public Employee(String firstName, String lastName, String gender, String createdBy) {
+        set("first_name1",firstName);
+        set("last_name",lastName);
+        set("gender",gender);
+        set("created_by",createdBy);
+    }
+
+    public String getLastName() {
+        return getString("last_name");
+    }
+
+}

persistence-modules/activejdbc/src/main/java/com/baeldung/model/Role.java

@@ -0,0 +1,22 @@
+package com.baeldung.model;
+
+
+import org.javalite.activejdbc.Model;
+import org.javalite.activejdbc.annotations.Table;
+
+@Table("EMP_ROLES")
+public class Role extends Model {
+
+    public Role(){
+
+    }
+
+    public Role(String role,String createdBy){
+        set("role_name",role);
+        set("created_by",createdBy);
+    }
+
+    public String getRoleName() {
+        return getString("role_name");
+    }
+}

persistence-modules/activejdbc/src/main/migration/_create_tables.sql

@@ -0,0 +1,25 @@
+# noinspection SqlNoDataSourceInspectionForFile
+
+create table organisation.employees
+(
+	id int not null auto_increment
+		primary key,
+	first_name varchar(100) not null,
+	last_name varchar(100) not null,
+	gender varchar(1) not null,
+	created_at datetime not null,
+	updated_at datetime null,
+	created_by varchar(100) not null,
+	updated_by varchar(100) null
+)ENGINE = InnoDB DEFAULT CHARSET = utf8;
+
+create table organisation.emp_roles
+(
+	id int not null auto_increment primary key,
+	employee_id int not null,
+	role_name varchar(100) not null,
+	created_at datetime not null,
+	updated_at datetime null,
+	created_by varchar(100) not null,
+	updated_by varchar(100) null
+)ENGINE = InnoDB DEFAULT CHARSET = utf8;

persistence-modules/activejdbc/src/main/resources/database.properties

@@ -0,0 +1,10 @@
+development.driver=com.mysql.jdbc.Driver
+development.username=root
+development.password=123456
+development.url=jdbc:mysql://localhost/organisation
+
+
+development.test.driver=com.mysql.jdbc.Driver
+development.test.username=root
+development.test.password=123456
+development.test.url=jdbc:mysql://localhost/organisation_test

persistence-modules/activejdbc/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/activejdbc/src/test/java/com/baeldung/ActiveJDBCAppManualTest.java

@@ -0,0 +1,51 @@
+package com.baeldung;
+
+import com.baeldung.model.Employee;
+import com.baeldung.model.Role;
+import org.javalite.activejdbc.test.DBSpec;
+import org.junit.Test;
+
+import java.util.List;
+
+public class ActiveJDBCAppManualTest extends DBSpec
+{
+    @Test
+    public void ifEmployeeCreated_thenIsValid() {
+        Employee employee = new Employee("B", "N", "M", "BN");
+        the(employee).shouldBe("valid");
+    }
+
+    @Test
+    public void ifEmployeeCreatedWithRoles_thenShouldPersist() {
+        Employee employee = new Employee("B", "N", "M", "BN");
+        employee.saveIt();
+        employee.add(new Role("Java Developer","BN"));
+        employee.add(new Role("Lead Java Developer","BN"));
+        a(Role.count()).shouldBeEqual(2);
+        List<Role> roles = employee.getAll(Role.class).orderBy("created_at");
+        the(roles.get(0).getRoleName()).shouldBeEqual("Java Developer");
+        the(roles.get(1).getRoleName()).shouldBeEqual("Lead Java Developer");
+    }
+
+    @Test
+    public void ifEmployeeCreatedWithRoles_whenNameUpdated_thenShouldShowNewName() {
+        Employee employee = new Employee("Binesh", "N", "M", "BN");
+        employee.saveIt();
+        employee.add(new Role("Java Developer","BN"));
+        employee.add(new Role("Lead Java Developer","BN"));
+        employee = Employee.findFirst("first_name = ?", "Binesh");
+        employee.set("last_name","Narayanan").saveIt();
+        Employee updated = Employee.findFirst("first_name = ?", "Binesh");
+        the(updated.getLastName()).shouldBeEqual("Narayanan");
+    }
+
+    @Test
+    public void ifEmployeeCreatedWithRoles_whenDeleted_thenShouldNotBeFound() {
+        Employee employee = new Employee("Binesh", "N", "M", "BN");
+        employee.saveIt();
+        employee.add(new Role("Java Developer","BN"));
+        employee.delete();
+        employee = Employee.findFirst("first_name = ?", "Binesh");
+        the(employee).shouldBeNull();
+    }
+}

persistence-modules/apache-cayenne/README.md

@@ -0,0 +1,4 @@
+## Relevant articles:
+
+- [Advanced Querying in Apache Cayenne](http://www.baeldung.com/apache-cayenne-query)
+- [Introduction to Apache Cayenne ORM](http://www.baeldung.com/apache-cayenne-orm)

persistence-modules/apache-cayenne/pom.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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>apache-cayenne</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>apache-cayenne</name>
+    <packaging>jar</packaging>
+    <description>Introduction to Apache Cayenne</description>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.cayenne</groupId>
+            <artifactId>cayenne-server</artifactId>
+            <version>${cayenne.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>${mysql.connector.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.cayenne.plugins</groupId>
+                <artifactId>cayenne-modeler-maven-plugin</artifactId>
+                <version>${cayenne.version}</version>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <mysql.connector.version>5.1.44</mysql.connector.version>
+        <cayenne.version>4.0.M5</cayenne.version>
+    </properties>
+
+</project>

persistence-modules/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/Article.java

@@ -0,0 +1,9 @@
+package com.baeldung.apachecayenne.persistent;
+
+import com.baeldung.apachecayenne.persistent.auto._Article;
+
+public class Article extends _Article {
+
+    private static final long serialVersionUID = 1L; 
+
+}

persistence-modules/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/Author.java

@@ -0,0 +1,9 @@
+package com.baeldung.apachecayenne.persistent;
+
+import com.baeldung.apachecayenne.persistent.auto._Author;
+
+public class Author extends _Author {
+
+    private static final long serialVersionUID = 1L; 
+
+}

persistence-modules/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/auto/_Article.java

@@ -0,0 +1,47 @@
+package com.baeldung.apachecayenne.persistent.auto;
+
+import org.apache.cayenne.CayenneDataObject;
+import org.apache.cayenne.exp.Property;
+
+import com.baeldung.apachecayenne.persistent.Author;
+
+/**
+ * Class _Article was generated by Cayenne.
+ * It is probably a good idea to avoid changing this class manually,
+ * since it may be overwritten next time code is regenerated.
+ * If you need to make any customizations, please use subclass.
+ */
+public abstract class _Article extends CayenneDataObject {
+
+    private static final long serialVersionUID = 1L; 
+
+    public static final String ID_PK_COLUMN = "id";
+
+    public static final Property<String> CONTENT = Property.create("content", String.class);
+    public static final Property<String> TITLE = Property.create("title", String.class);
+    public static final Property<Author> AUTHOR = Property.create("author", Author.class);
+
+    public void setContent(String content) {
+        writeProperty("content", content);
+    }
+    public String getContent() {
+        return (String)readProperty("content");
+    }
+
+    public void setTitle(String title) {
+        writeProperty("title", title);
+    }
+    public String getTitle() {
+        return (String)readProperty("title");
+    }
+
+    public void setAuthor(Author author) {
+        setToOneTarget("author", author, true);
+    }
+
+    public Author getAuthor() {
+        return (Author)readProperty("author");
+    }
+
+
+}

persistence-modules/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/auto/_Author.java

@@ -0,0 +1,44 @@
+package com.baeldung.apachecayenne.persistent.auto;
+
+import java.util.List;
+
+import org.apache.cayenne.CayenneDataObject;
+import org.apache.cayenne.exp.Property;
+
+import com.baeldung.apachecayenne.persistent.Article;
+
+/**
+ * Class _Author was generated by Cayenne.
+ * It is probably a good idea to avoid changing this class manually,
+ * since it may be overwritten next time code is regenerated.
+ * If you need to make any customizations, please use subclass.
+ */
+public abstract class _Author extends CayenneDataObject {
+
+    private static final long serialVersionUID = 1L; 
+
+    public static final String ID_PK_COLUMN = "id";
+
+    public static final Property<String> NAME = Property.create("name", String.class);
+    public static final Property<List<Article>> ARTICLES = Property.create("articles", List.class);
+
+    public void setName(String name) {
+        writeProperty("name", name);
+    }
+    public String getName() {
+        return (String)readProperty("name");
+    }
+
+    public void addToArticles(Article obj) {
+        addToManyTarget("articles", obj, true);
+    }
+    public void removeFromArticles(Article obj) {
+        removeToManyTarget("articles", obj, true);
+    }
+    @SuppressWarnings("unchecked")
+    public List<Article> getArticles() {
+        return (List<Article>)readProperty("articles");
+    }
+
+
+}

persistence-modules/apache-cayenne/src/main/resources/cayenne-project.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<domain project-version="9">
+	<map name="datamap"/>
+
+	<node name="datanode"
+		 factory="org.apache.cayenne.configuration.server.XMLPoolingDataSourceFactory"
+		 schema-update-strategy="org.apache.cayenne.access.dbsync.CreateIfNoSchemaStrategy"
+		>
+		<map-ref name="datamap"/>
+		<data-source>
+			<driver value="com.mysql.jdbc.Driver"/>
+			<url value="jdbc:mysql://localhost:3306/intro_cayenne"/>
+			<connectionPool min="1" max="1"/>
+			<login userName="root" password="root"/>
+		</data-source>
+	</node>
+</domain>

persistence-modules/apache-cayenne/src/main/resources/datamap.map.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<data-map xmlns="http://cayenne.apache.org/schema/9/modelMap"
+	 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	 xsi:schemaLocation="http://cayenne.apache.org/schema/9/modelMap http://cayenne.apache.org/schema/9/modelMap.xsd"
+	 project-version="9">
+	<property name="defaultPackage" value="com.baeldung.apachecayenne.persistent"/>
+	<db-entity name="article" catalog="intro_cayenne">
+		<db-attribute name="author_id" type="INTEGER" isMandatory="true" length="10"/>
+		<db-attribute name="content" type="VARCHAR" isMandatory="true" length="254"/>
+		<db-attribute name="id" type="INTEGER" isPrimaryKey="true" isGenerated="true" isMandatory="true" length="10"/>
+		<db-attribute name="title" type="VARCHAR" isMandatory="true" length="254"/>
+	</db-entity>
+	<db-entity name="author" catalog="intro_cayenne">
+		<db-attribute name="id" type="INTEGER" isPrimaryKey="true" isGenerated="true" isMandatory="true" length="10"/>
+		<db-attribute name="name" type="VARCHAR" isMandatory="true" length="254"/>
+	</db-entity>
+	<obj-entity name="Article" className="com.baeldung.apachecayenne.persistent.Article" dbEntityName="article">
+		<obj-attribute name="content" type="java.lang.String" db-attribute-path="content"/>
+		<obj-attribute name="title" type="java.lang.String" db-attribute-path="title"/>
+	</obj-entity>
+	<obj-entity name="Author" className="com.baeldung.apachecayenne.persistent.Author" dbEntityName="author">
+		<obj-attribute name="name" type="java.lang.String" db-attribute-path="name"/>
+	</obj-entity>
+	<db-relationship name="author" source="article" target="author" toMany="false">
+		<db-attribute-pair source="author_id" target="id"/>
+	</db-relationship>
+	<db-relationship name="articles" source="author" target="article" toMany="true">
+		<db-attribute-pair source="id" target="author_id"/>
+	</db-relationship>
+	<obj-relationship name="author" source="Article" target="Author" deleteRule="Nullify" db-relationship-path="author"/>
+	<obj-relationship name="articles" source="Author" target="Article" deleteRule="Deny" db-relationship-path="articles"/>
+</data-map>

persistence-modules/apache-cayenne/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/apache-cayenne/src/test/java/com/baeldung/apachecayenne/CayenneAdvancedOperationLiveTest.java

@@ -0,0 +1,256 @@
+package com.baeldung.apachecayenne;
+
+import com.baeldung.apachecayenne.persistent.Author;
+import org.apache.cayenne.ObjectContext;
+import org.apache.cayenne.QueryResponse;
+import org.apache.cayenne.configuration.server.ServerRuntime;
+import org.apache.cayenne.exp.Expression;
+import org.apache.cayenne.exp.ExpressionFactory;
+import org.apache.cayenne.query.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static junit.framework.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class CayenneAdvancedOperationLiveTest {
+    private static ObjectContext context = null;
+
+    @BeforeClass
+    public static void setupTheCayenneContext() {
+        ServerRuntime cayenneRuntime = ServerRuntime.builder()
+          .addConfig("cayenne-project.xml")
+          .build();
+        context = cayenneRuntime.newContext();
+    }
+
+    @Before
+    public void saveThreeAuthors() {
+        Author authorOne = context.newObject(Author.class);
+        authorOne.setName("Paul Xavier");
+        Author authorTwo = context.newObject(Author.class);
+        authorTwo.setName("pAuL Smith");
+        Author authorThree = context.newObject(Author.class);
+        authorThree.setName("Vicky Sarra");
+        context.commitChanges();
+    }
+
+    @After
+    public void deleteAllAuthors() {
+        SQLTemplate deleteAuthors = new SQLTemplate(Author.class, "delete from author");
+        context.performGenericQuery(deleteAuthors);
+    }
+
+    @Test
+    public void givenAuthors_whenFindAllSQLTmplt_thenWeGetThreeAuthors() {
+        SQLTemplate select = new SQLTemplate(Author.class, "select * from Author");
+        List<Author> authors = context.performQuery(select);
+
+        assertEquals(authors.size(), 3);
+    }
+
+    @Test
+    public void givenAuthors_whenFindByNameSQLTmplt_thenWeGetOneAuthor() {
+        SQLTemplate select = new SQLTemplate(Author.class, "select * from Author where name = 'Vicky Sarra'");
+        List<Author> authors = context.performQuery(select);
+        Author author = authors.get(0);
+
+        assertEquals(authors.size(), 1);
+        assertEquals(author.getName(), "Vicky Sarra");
+    }
+
+    @Test
+    public void givenAuthors_whenLikeSltQry_thenWeGetOneAuthor() {
+        Expression qualifier = ExpressionFactory.likeExp(Author.NAME.getName(), "Paul%");
+        SelectQuery query = new SelectQuery(Author.class, qualifier);
+        List<Author> authorsTwo = context.performQuery(query);
+
+        assertEquals(authorsTwo.size(), 1);
+    }
+
+    @Test
+    public void givenAuthors_whenCtnsIgnorCaseSltQry_thenWeGetTwoAuthors() {
+        Expression qualifier = ExpressionFactory.containsIgnoreCaseExp(Author.NAME.getName(), "Paul");
+        SelectQuery query = new SelectQuery(Author.class, qualifier);
+        List<Author> authors = context.performQuery(query);
+
+        assertEquals(authors.size(), 2);
+    }
+
+    @Test
+    public void givenAuthors_whenCtnsIgnorCaseEndsWSltQry_thenWeGetTwoAuthors() {
+        Expression qualifier = ExpressionFactory.containsIgnoreCaseExp(Author.NAME.getName(), "Paul")
+                .andExp(ExpressionFactory.endsWithExp(Author.NAME.getName(), "h"));
+        SelectQuery query = new SelectQuery(Author.class, qualifier);
+        List<Author> authors = context.performQuery(query);
+
+        Author author = authors.get(0);
+
+        assertEquals(authors.size(), 1);
+        assertEquals(author.getName(), "pAuL Smith");
+    }
+
+    @Test
+    public void givenAuthors_whenAscOrderingSltQry_thenWeGetOrderedAuthors() {
+        SelectQuery query = new SelectQuery(Author.class);
+        query.addOrdering(Author.NAME.asc());
+
+        List<Author> authors = query.select(context);
+        Author firstAuthor = authors.get(0);
+
+        assertEquals(authors.size(), 3);
+        assertEquals(firstAuthor.getName(), "Paul Xavier");
+    }
+
+    @Test
+    public void givenAuthors_whenDescOrderingSltQry_thenWeGetOrderedAuthors() {
+        SelectQuery query = new SelectQuery(Author.class);
+        query.addOrdering(Author.NAME.desc());
+
+        List<Author> authors = query.select(context);
+        Author firstAuthor = authors.get(0);
+
+        assertEquals(authors.size(), 3);
+        assertEquals(firstAuthor.getName(), "pAuL Smith");
+    }
+
+    @Test
+    public void givenAuthors_onContainsObjS_thenWeGetOneRecord() {
+        List<Author> authors = ObjectSelect.query(Author.class)
+          .where(Author.NAME.contains("Paul"))
+          .select(context);
+
+        assertEquals(authors.size(), 1);
+    }
+
+    @Test
+    public void givenAuthors_whenLikeObjS_thenWeGetTwoAuthors() {
+        List<Author> authors = ObjectSelect.query(Author.class)
+          .where(Author.NAME.likeIgnoreCase("Paul%"))
+          .select(context);
+
+        assertEquals(authors.size(), 2);
+    }
+
+    @Test
+    public void givenTwoAuthor_whenEndsWithObjS_thenWeGetOrderedAuthors() {
+        List<Author> authors = ObjectSelect.query(Author.class)
+          .where(Author.NAME.endsWith("Sarra"))
+          .select(context);
+        Author firstAuthor = authors.get(0);
+
+        assertEquals(authors.size(), 1);
+        assertEquals(firstAuthor.getName(), "Vicky Sarra");
+    }
+
+    @Test
+    public void givenTwoAuthor_whenInObjS_thenWeGetAuthors() {
+        List<String> names = Arrays.asList("Paul Xavier", "pAuL Smith", "Vicky Sarra");
+        List<Author> authors = ObjectSelect.query(Author.class)
+                .where(Author.NAME.in(names))
+                .select(context);
+
+        assertEquals(authors.size(), 3);
+    }
+
+    @Test
+    public void givenTwoAuthor_whenNinObjS_thenWeGetAuthors() {
+        List<String> names = Arrays.asList("Paul Xavier", "pAuL Smith");
+        List<Author> authors = ObjectSelect.query(Author.class)
+                .where(Author.NAME.nin(names))
+                .select(context);
+        Author author = authors.get(0);
+
+        assertEquals(authors.size(), 1);
+        assertEquals(author.getName(), "Vicky Sarra");
+    }
+
+    @Test
+    public void givenTwoAuthor_whenIsNotNullObjS_thenWeGetAuthors() {
+        List<Author> authors = ObjectSelect.query(Author.class)
+          .where(Author.NAME.isNotNull())
+          .select(context);
+
+        assertEquals(authors.size(), 3);
+    }
+
+    @Test
+    public void givenAuthors_whenFindAllEJBQL_thenWeGetThreeAuthors() {
+        EJBQLQuery query = new EJBQLQuery("select a FROM Author a");
+        List<Author> authors = context.performQuery(query);
+
+        assertEquals(authors.size(), 3);
+    }
+
+    @Test
+    public void givenAuthors_whenFindByNameEJBQL_thenWeGetOneAuthor() {
+        EJBQLQuery query = new EJBQLQuery("select a FROM Author a WHERE a.name = 'Vicky Sarra'");
+        List<Author> authors = context.performQuery(query);
+        Author author = authors.get(0);
+
+        assertEquals(authors.size(), 1);
+        assertEquals(author.getName(), "Vicky Sarra");
+    }
+
+    @Test
+    public void givenAuthors_whenUpdadingByNameEJBQL_thenWeGetTheUpdatedAuthor() {
+        EJBQLQuery query = new EJBQLQuery("UPDATE Author AS a SET a.name = 'Vicky Edison' WHERE a.name = 'Vicky Sarra'");
+        QueryResponse queryResponse = context.performGenericQuery(query);
+
+        EJBQLQuery queryUpdatedAuthor = new EJBQLQuery("select a FROM Author a WHERE a.name = 'Vicky Edison'");
+        List<Author> authors = context.performQuery(queryUpdatedAuthor);
+        Author author = authors.get(0);
+
+        assertNotNull(author);
+    }
+
+    @Test
+    public void givenAuthors_whenSeletingNamesEJBQL_thenWeGetListWithSizeThree() {
+        String [] args = {"Paul Xavier", "pAuL Smith", "Vicky Sarra"};
+        List<String> names = Arrays.asList(args);
+        EJBQLQuery query = new EJBQLQuery("select a.name FROM Author a");
+        List<String> nameList = context.performQuery(query);
+
+        Collections.sort(names);
+        Collections.sort(nameList);
+
+        assertEquals(names.size(), 3);
+        assertEquals(nameList.size(), 3);
+        assertEquals(names, nameList);
+    }
+
+    @Test
+    public void givenAuthors_whenDeletingAllWithEJB_thenWeGetNoAuthor() {
+        EJBQLQuery deleteQuery = new EJBQLQuery("delete FROM Author");
+        EJBQLQuery findAllQuery = new EJBQLQuery("select a FROM Author a");
+
+        context.performQuery(deleteQuery);
+        List<Author> objects = context.performQuery(findAllQuery);
+
+        assertEquals(objects.size(), 0);
+    }
+
+    @Test
+    public void givenAuthors_whenInsertingSQLExec_thenWeGetNewAuthor() {
+        int inserted = SQLExec
+          .query("INSERT INTO Author (name) VALUES ('Baeldung')")
+          .update(context);
+
+        assertEquals(inserted, 1);
+    }
+
+    @Test
+    public void givenAuthors_whenUpdatingSQLExec_thenItsUpdated() {
+        int updated = SQLExec
+          .query("UPDATE Author SET name = 'Baeldung' WHERE name = 'Vicky Sarra'")
+          .update(context);
+
+        assertEquals(updated, 1);
+    }
+}

persistence-modules/apache-cayenne/src/test/java/com/baeldung/apachecayenne/CayenneOperationLiveTest.java

@@ -0,0 +1,131 @@
+package com.baeldung.apachecayenne;
+
+import com.baeldung.apachecayenne.persistent.Article;
+import com.baeldung.apachecayenne.persistent.Author;
+import org.apache.cayenne.ObjectContext;
+import org.apache.cayenne.configuration.server.ServerRuntime;
+import org.apache.cayenne.query.ObjectSelect;
+import org.apache.cayenne.query.SQLTemplate;
+import org.junit.After;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.List;
+
+import static junit.framework.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+
+public class CayenneOperationLiveTest {
+    private static ObjectContext context = null;
+
+    @BeforeClass
+    public static void setupTheCayenneContext() {
+        ServerRuntime cayenneRuntime = ServerRuntime.builder()
+                .addConfig("cayenne-project.xml")
+                .build();
+        context = cayenneRuntime.newContext();
+    }
+
+    @After
+    public void deleteAllRecords() {
+        SQLTemplate deleteArticles = new SQLTemplate(Article.class, "delete from article");
+        SQLTemplate deleteAuthors = new SQLTemplate(Author.class, "delete from author");
+
+        context.performGenericQuery(deleteArticles);
+        context.performGenericQuery(deleteAuthors);
+    }
+
+    @Test
+    public void givenAuthor_whenInsert_thenWeGetOneRecordInTheDatabase() {
+        Author author = context.newObject(Author.class);
+        author.setName("Paul");
+
+        context.commitChanges();
+
+        long records = ObjectSelect.dataRowQuery(Author.class).selectCount(context);
+        assertEquals(1, records);
+    }
+
+    @Test
+    public void givenAuthor_whenInsert_andQueryByFirstName_thenWeGetTheAuthor() {
+        Author author = context.newObject(Author.class);
+        author.setName("Paul");
+
+        context.commitChanges();
+
+        Author expectedAuthor = ObjectSelect.query(Author.class)
+                .where(Author.NAME.eq("Paul"))
+                .selectOne(context);
+
+        assertEquals("Paul", expectedAuthor.getName());
+    }
+
+    @Test
+    public void givenTwoAuthor_whenInsert_andQueryAll_thenWeGetTwoAuthors() {
+        Author firstAuthor = context.newObject(Author.class);
+        firstAuthor.setName("Paul");
+
+        Author secondAuthor = context.newObject(Author.class);
+        secondAuthor.setName("Ludovic");
+
+        context.commitChanges();
+
+        List<Author> authors = ObjectSelect.query(Author.class).select(context);
+        assertEquals(2, authors.size());
+    }
+
+    @Test
+    public void givenAuthor_whenUpdating_thenWeGetAnUpatedeAuthor() {
+        Author author = context.newObject(Author.class);
+        author.setName("Paul");
+        context.commitChanges();
+
+        Author expectedAuthor = ObjectSelect.query(Author.class)
+                .where(Author.NAME.eq("Paul"))
+                .selectOne(context);
+        expectedAuthor.setName("Garcia");
+        context.commitChanges();
+
+        assertEquals(author.getName(), expectedAuthor.getName());
+    }
+
+    @Test
+    public void givenAuthor_whenDeleting_thenWeLostHisDetails() {
+        Author author = context.newObject(Author.class);
+        author.setName("Paul");
+        context.commitChanges();
+
+        Author savedAuthor = ObjectSelect.query(Author.class)
+                .where(Author.NAME.eq("Paul")).selectOne(context);
+        if(savedAuthor != null) {
+            context.deleteObjects(author);
+            context.commitChanges();
+        }
+
+        Author expectedAuthor = ObjectSelect.query(Author.class)
+                .where(Author.NAME.eq("Paul")).selectOne(context);
+        assertNull(expectedAuthor);
+    }
+
+    @Test
+    public void givenAuthor_whenAttachingToArticle_thenTheRelationIsMade() {
+        Author author = context.newObject(Author.class);
+        author.setName("Paul");
+
+        Article article = context.newObject(Article.class);
+        article.setTitle("My post title");
+        article.setContent("The content");
+        article.setAuthor(author);
+
+        context.commitChanges();
+
+        Author expectedAuthor = ObjectSelect.query(Author.class)
+                .where(Author.NAME.eq("Paul"))
+                .selectOne(context);
+
+        Article expectedArticle = (expectedAuthor.getArticles()).get(0);
+        assertEquals(article.getTitle(), expectedArticle.getTitle());
+    }
+
+}

persistence-modules/core-java-persistence/README.md

@@ -0,0 +1,11 @@
+=========
+
+## Core Java Persistence Examples
+
+### Relevant Articles: 
+- [Introduction to JDBC](http://www.baeldung.com/java-jdbc)
+- [Batch Processing in JDBC](http://www.baeldung.com/jdbc-batch-processing)
+- [Introduction to the JDBC RowSet Interface in Java](http://www.baeldung.com/java-jdbc-rowset)
+- [A Simple Guide to Connection Pooling in Java](https://www.baeldung.com/java-connection-pooling)
+- [Guide to the JDBC ResultSet Interface](https://www.baeldung.com/jdbc-resultset)
+- [Types of SQL Joins](https://www.baeldung.com/sql-joins)

persistence-modules/core-java-persistence/pom.xml

@@ -0,0 +1,83 @@
+<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>
+    <groupId>com.baeldung.core-java-persistence</groupId>
+    <artifactId>core-java-persistence</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-persistence</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>${postgresql.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>${h2.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-dbcp2</artifactId>
+            <version>${commons-dbcp2.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>${HikariCP.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.mchange</groupId>
+            <artifactId>c3p0</artifactId>
+            <version>${c3p0.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+            <version>${springframework.spring-web.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter</artifactId>
+            <version>${springframework.boot.spring-boot-starter.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>core-java-persistence</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+
+    <properties>
+        <postgresql.version>42.2.5.jre7</postgresql.version>
+        <mysql-connector.version>8.0.15</mysql-connector.version>
+        <assertj-core.version>3.10.0</assertj-core.version>
+        <commons-dbcp2.version>2.4.0</commons-dbcp2.version>
+        <HikariCP.version>3.2.0</HikariCP.version>
+        <c3p0.version>0.9.5.2</c3p0.version>
+        <springframework.boot.spring-boot-starter.version>1.5.8.RELEASE</springframework.boot.spring-boot-starter.version>
+        <springframework.spring-web.version>4.3.4.RELEASE</springframework.spring-web.version>
+    </properties>
+
+</project>

persistence-modules/core-java-persistence/src/main/java/com/baeldung/connectionpool/BasicConnectionPool.java

@@ -0,0 +1,92 @@
+package com.baeldung.connectionpool;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class BasicConnectionPool implements ConnectionPool {
+
+    private final String url;
+    private final String user;
+    private final String password;
+    private final List<Connection> connectionPool;
+    private final List<Connection> usedConnections = new ArrayList<>();
+    private static final int INITIAL_POOL_SIZE = 10;
+    private final int MAX_POOL_SIZE = 20;
+
+    public static BasicConnectionPool create(String url, String user, String password) throws SQLException {
+        List<Connection> pool = new ArrayList<>(INITIAL_POOL_SIZE);
+        for (int i = 0; i < INITIAL_POOL_SIZE; i++) {
+            pool.add(createConnection(url, user, password));
+        }
+        return new BasicConnectionPool(url, user, password, pool);
+    }
+
+    private BasicConnectionPool(String url, String user, String password, List<Connection> connectionPool) {
+        this.url = url;
+        this.user = user;
+        this.password = password;
+        this.connectionPool = connectionPool;
+    }
+
+    @Override
+    public Connection getConnection() throws SQLException {
+        if (connectionPool.isEmpty()) {
+            if (usedConnections.size() < MAX_POOL_SIZE) {
+                connectionPool.add(createConnection(url, user, password));
+            } else {
+                throw new RuntimeException("Maximum pool size reached, no available connections!");
+            }
+        }
+
+        Connection connection = connectionPool.remove(connectionPool.size() - 1);
+        usedConnections.add(connection);
+        return connection;
+    }
+
+    @Override
+    public boolean releaseConnection(Connection connection) {
+        connectionPool.add(connection);
+        return usedConnections.remove(connection);
+    }
+
+    private static Connection createConnection(String url, String user, String password) throws SQLException {
+        return DriverManager.getConnection(url, user, password);
+    }
+
+    @Override
+    public int getSize() {
+        return connectionPool.size() + usedConnections.size();
+    }
+
+    @Override
+    public List<Connection> getConnectionPool() {
+        return connectionPool;
+    }
+    
+    @Override
+    public String getUrl() {
+        return url;
+    }
+
+    @Override
+    public String getUser() {
+        return user;
+    }
+
+    @Override
+    public String getPassword() {
+        return password;
+    }
+    
+    @Override
+    public void shutdown() throws SQLException {
+        usedConnections.forEach(this::releaseConnection);
+        for (Connection c : connectionPool) {
+            c.close();
+        }
+        connectionPool.clear();
+    }
+}

persistence-modules/core-java-persistence/src/main/java/com/baeldung/connectionpool/C3poDataSource.java

@@ -0,0 +1,28 @@
+package com.baeldung.connectionpool;
+
+import com.mchange.v2.c3p0.ComboPooledDataSource;
+import java.beans.PropertyVetoException;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class C3poDataSource {
+
+    private static final ComboPooledDataSource cpds = new ComboPooledDataSource();
+
+    static {
+        try {
+            cpds.setDriverClass("org.h2.Driver");
+            cpds.setJdbcUrl("jdbc:h2:mem:test");
+            cpds.setUser("user");
+            cpds.setPassword("password");
+        } catch (PropertyVetoException e) {
+            e.printStackTrace();
+        }
+    }
+    
+    public static Connection getConnection() throws SQLException {
+        return cpds.getConnection();
+    }
+    
+    private C3poDataSource(){}
+}

persistence-modules/core-java-persistence/src/main/java/com/baeldung/connectionpool/ConnectionPool.java

@@ -0,0 +1,24 @@
+package com.baeldung.connectionpool;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.List;
+
+public interface ConnectionPool {
+
+    Connection getConnection() throws SQLException;
+    
+    boolean releaseConnection(Connection connection);
+    
+    List<Connection> getConnectionPool();
+    
+    int getSize();
+    
+    String getUrl();
+    
+    String getUser();
+
+    String getPassword();
+    
+    void shutdown() throws SQLException;;
+}   

persistence-modules/core-java-persistence/src/main/java/com/baeldung/connectionpool/DBCPDataSource.java

@@ -0,0 +1,25 @@
+package com.baeldung.connectionpool;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import org.apache.commons.dbcp2.BasicDataSource;
+
+public class DBCPDataSource {
+    
+    private static final BasicDataSource ds = new BasicDataSource();
+    
+    static {
+        ds.setUrl("jdbc:h2:mem:test");
+        ds.setUsername("user");
+        ds.setPassword("password");
+        ds.setMinIdle(5);
+        ds.setMaxIdle(10);
+        ds.setMaxOpenPreparedStatements(100);
+    }
+    
+    public static Connection getConnection() throws SQLException {
+        return ds.getConnection();
+    }
+    
+    private DBCPDataSource(){}
+}

persistence-modules/core-java-persistence/src/main/java/com/baeldung/connectionpool/HikariCPDataSource.java

@@ -0,0 +1,28 @@
+package com.baeldung.connectionpool;
+
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class HikariCPDataSource {
+    
+    private static final HikariConfig config = new HikariConfig();
+    private static final HikariDataSource ds;
+    
+    static {
+        config.setJdbcUrl("jdbc:h2:mem:test");
+        config.setUsername("user");
+        config.setPassword("password");
+        config.addDataSourceProperty("cachePrepStmts", "true");
+        config.addDataSourceProperty("prepStmtCacheSize", "250");
+        config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
+        ds = new HikariDataSource(config);
+    }
+    
+    public static Connection getConnection() throws SQLException {
+        return ds.getConnection();
+    }
+    
+    private HikariCPDataSource(){}
+}

persistence-modules/core-java-persistence/src/main/java/com/baeldung/jdbc/BatchProcessing.java

@@ -0,0 +1,96 @@
+package com.baeldung.jdbc;
+
+import java.sql.*;
+import java.util.UUID;
+
+public class BatchProcessing {
+
+    private final String[] EMPLOYEES = new String[]{"Zuck","Mike","Larry","Musk","Steve"};
+    private final String[] DESIGNATIONS = new String[]{"CFO","CSO","CTO","CEO","CMO"};
+    private final String[] ADDRESSES = new String[]{"China","York","Diego","Carolina","India"};
+
+    private Connection connection;
+
+    public void getConnection(){
+        try {
+            Class.forName("org.h2.Driver");
+            connection = DriverManager.getConnection("jdbc:h2:mem:db", "SA", "");
+            connection.setAutoCommit(false);
+        } catch (Exception e) {
+            e.printStackTrace(System.out);
+        }
+    }
+
+    public void createTables(){
+        try {
+            connection.createStatement().executeUpdate("create table EMPLOYEE (ID VARCHAR(36), NAME VARCHAR(45), DESIGNATION VARCHAR(15))");
+            connection.createStatement().executeUpdate("create table EMP_ADDRESS (ID VARCHAR(36), EMP_ID VARCHAR(36), ADDRESS VARCHAR(45))");
+            System.out.println("Tables Created!!!");
+        } catch (SQLException e) {
+            e.printStackTrace(System.out);
+        }
+    }
+
+    public void useStatement(){
+        try {
+            String insertEmployeeSQL = "INSERT INTO EMPLOYEE(ID, NAME, DESIGNATION) VALUES ('%s','%s','%s');";
+            String insertEmployeeAddrSQL = "INSERT INTO EMP_ADDRESS(ID, EMP_ID, ADDRESS) VALUES ('%s','%s','%s');";
+            Statement statement = connection.createStatement();
+            for(int i = 0; i < EMPLOYEES.length; i++){
+                String employeeId = UUID.randomUUID().toString();
+                statement.addBatch(String.format(insertEmployeeSQL, employeeId, EMPLOYEES[i],DESIGNATIONS[i]));
+                statement.addBatch(String.format(insertEmployeeAddrSQL, UUID.randomUUID().toString(),employeeId,ADDRESSES[i]));
+            }
+            statement.executeBatch();
+            connection.commit();
+        } catch (Exception e) {
+            try {
+                connection.rollback();
+            } catch (SQLException ex) {
+                System.out.println("Error during rollback");
+                System.out.println(ex.getMessage());
+            }
+            e.printStackTrace(System.out);
+        }
+    }
+
+    public void usePreparedStatement(){
+        try {
+            String insertEmployeeSQL = "INSERT INTO EMPLOYEE(ID, NAME, DESIGNATION) VALUES (?,?,?);";
+            String insertEmployeeAddrSQL = "INSERT INTO EMP_ADDRESS(ID, EMP_ID, ADDRESS) VALUES (?,?,?);";
+            PreparedStatement employeeStmt = connection.prepareStatement(insertEmployeeSQL);
+            PreparedStatement empAddressStmt = connection.prepareStatement(insertEmployeeAddrSQL);
+            for(int i = 0; i < EMPLOYEES.length; i++){
+                String employeeId = UUID.randomUUID().toString();
+                employeeStmt.setString(1,employeeId);
+                employeeStmt.setString(2,EMPLOYEES[i]);
+                employeeStmt.setString(3,DESIGNATIONS[i]);
+                employeeStmt.addBatch();
+
+                empAddressStmt.setString(1,UUID.randomUUID().toString());
+                empAddressStmt.setString(2,employeeId);
+                empAddressStmt.setString(3,ADDRESSES[i]);
+                empAddressStmt.addBatch();
+            }
+            employeeStmt.executeBatch();
+            empAddressStmt.executeBatch();
+            connection.commit();
+        } catch (Exception e) {
+            try {
+                connection.rollback();
+            } catch (SQLException ex) {
+                System.out.println("Error during rollback");
+                System.out.println(ex.getMessage());
+            }
+            e.printStackTrace(System.out);
+        }
+    }
+
+    public static void main(String[] args) {
+        BatchProcessing batchProcessing = new BatchProcessing();
+        batchProcessing.getConnection();
+        batchProcessing.createTables();
+        batchProcessing.useStatement();
+        batchProcessing.usePreparedStatement();
+    }
+}

persistence-modules/core-java-persistence/src/main/java/com/baeldung/jdbc/Employee.java

@@ -0,0 +1,70 @@
+package com.baeldung.jdbc;
+
+import java.util.Objects;
+
+public class Employee {
+    private int id;
+    private String name;
+    private String position;
+    private double salary;
+
+    public Employee() {
+    }
+
+    public Employee(int id, String name, double salary, String position) {
+        this.id = id;
+        this.name = name;
+        this.salary = salary;
+        this.position = position;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public double getSalary() {
+        return salary;
+    }
+
+    public void setSalary(double salary) {
+        this.salary = salary;
+    }
+
+    public String getPosition() {
+        return position;
+    }
+
+    public void setPosition(String position) {
+        this.position = position;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name, position, salary);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        Employee other = (Employee) obj;
+        return id == other.id && Objects.equals(name, other.name) && Objects.equals(position, other.position) && Double.doubleToLongBits(salary) == Double.doubleToLongBits(other.salary);
+    }
+
+}