Hibernate Query Language INSERT, UPDATE, SELECT and DELETE Example

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

In this tutorial, we will demonstrate how to perform basic CRUD (Create, Read, Update, Delete) operations using Hibernate Query Language (HQL) with a Product entity. We will create a simple application to manage Product entities with Hibernate.

Introduction to HQL (Hibernate Query Language)

What is HQL?

HQL (Hibernate Query Language) is an object-oriented query language similar to SQL, but it is designed for querying entities stored in a relational database using the Hibernate ORM framework. HQL allows you to write queries in a way that is closely aligned with the object model of the application rather than the relational model of the database.

Key Points of HQL:

• Object-Oriented: HQL queries are written in terms of the object model and the entities defined in the application, not the database tables and columns.
• Database Independent: HQL is designed to be database-independent, allowing you to switch databases without changing your queries.
• Powerful and Flexible: HQL supports all CRUD operations and provides powerful features like joins, aggregations, and subqueries.

Basic Syntax of HQL:

• SELECT Queries: Used to retrieve data from the database.

  SELECT s FROM Student s WHERE s.firstName = 'Ramesh' 

• INSERT Queries: Not directly supported, but can be achieved using entity manipulation.
• UPDATE Queries: Used to update existing records.

  UPDATE Student s SET s.email = 'newemail@example.com' WHERE s.id = 1 

• DELETE Queries: Used to delete records.

  DELETE FROM Student s WHERE s.id = 1 

Example of HQL:

Here's a simple example demonstrating the usage of HQL to fetch all students with a specific first name:

String hql = "FROM Student S WHERE S.firstName = :firstName"; Query query = session.createQuery(hql); query.setParameter("firstName", "Ramesh"); List results = query.list(); 

In this example:

• FROM Student S specifies that we are querying the Student entity.
• WHERE S.firstName = :firstName applies a filter to only fetch students with the first name "Ramesh".
• session.createQuery(hql) creates an HQL query from the session.
• query.setParameter("firstName", "Ramesh") sets the parameter value.
• query.list() executes the query and returns the results as a list.

HQL provides a powerful way to interact with your database through the object-oriented model of your application, making it easier to write and maintain queries.

Prerequisites

Before we start, ensure you have the following:

• Java Development Kit (JDK) installed
• Apache Maven installed
• An IDE (such as IntelliJ IDEA, Eclipse, or VS Code) installed

Step 1: Setting Up the Hibernate Project

1.1 Create a Maven Project

1. Open your IDE and create a new Maven project.

2. Configure the pom.xml file:

Add the following dependencies to your pom.xml:

<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.example</groupId> <artifactId>hibernate-example</artifactId> <version>1.0-SNAPSHOT</version> <dependencies> <dependency> <groupId>org.hibernate.orm</groupId> <artifactId>hibernate-core</artifactId> <version>6.4.0.Final</version> </dependency> <dependency> <groupId>org.hibernate.orm</groupId> <artifactId>hibernate-hikaricp</artifactId> <version>6.4.0.Final</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.32</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-simple</artifactId> <version>1.7.32</version> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.1.210</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <source>17</source> <target>17</target> </configuration> </plugin> </plugins> </build> </project> 

1.2 Configure Hibernate

Create a file named hibernate.cfg.xml in the src/main/resources directory with the following content:

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property> <property name="hibernate.connection.driver_class">org.h2.Driver</property> <property name="hibernate.connection.url">jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1</property> <property name="hibernate.connection.username">sa</property> <property name="hibernate.connection.password"></property> <property name="hibernate.hbm2ddl.auto">update</property> <property name="hibernate.show_sql">true</property> <property name="hibernate.format_sql">true</property> </session-factory> </hibernate-configuration> 

1.3 Create the Product Entity

Create a Product class in the com.example.hibernateexample.model package:

package com.example.hibernateexample.model; import jakarta.persistence.Entity; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; import jakarta.persistence.Id; @Entity public class Product { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private double price; // Getters and Setters 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 double getPrice() { return price; } public void setPrice(double price) { this.price = price; } } 

1.4 Create the Hibernate Utility Class

Create a HibernateUtil class in the com.example.hibernateexample.util package:

package com.example.hibernateexample.util; import org.hibernate.SessionFactory; import org.hibernate.boot.registry.StandardServiceRegistryBuilder; import org.hibernate.cfg.Configuration; public class HibernateUtil { private static final SessionFactory sessionFactory = buildSessionFactory(); private static SessionFactory buildSessionFactory() { try { Configuration configuration = new Configuration(); configuration.configure("hibernate.cfg.xml"); return configuration.buildSessionFactory(new StandardServiceRegistryBuilder() .applySettings(configuration.getProperties()).build()); } catch (Throwable ex) { System.err.println("Initial SessionFactory creation failed." + ex); throw new ExceptionInInitializerError(ex); } } public static SessionFactory getSessionFactory() { return sessionFactory; } public static void shutdown() { getSessionFactory().close(); } } 

Step 2: Performing CRUD Operations with HQL

2.1 INSERT Operation

Create a ProductDao class in the com.example.hibernateexample.dao package to handle database operations:

package com.example.hibernateexample.dao; import com.example.hibernateexample.model.Product; import com.example.hibernateexample.util.HibernateUtil; import org.hibernate.Session; import org.hibernate.Transaction; public class ProductDao { public void saveProduct(Product product) { Transaction transaction = null; try (Session session = HibernateUtil.getSessionFactory().openSession()) { transaction = session.beginTransaction(); session.save(product); transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } } } 

2.2 SELECT Operation

Add a method to the ProductDao class to retrieve all products:

import java.util.List; import org.hibernate.query.Query; public List<Product> getProducts() { try (Session session = HibernateUtil.getSessionFactory().openSession()) { Query<Product> query = session.createQuery("from Product", Product.class); return query.list(); } } 

2.3 UPDATE Operation

Add a method to the ProductDao class to update a product:

public void updateProduct(Product product) { Transaction transaction = null; try (Session session = HibernateUtil.getSessionFactory().openSession()) { transaction = session.beginTransaction(); session.update(product); transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } } 

2.4 DELETE Operation

Add a method to the ProductDao class to delete a product:

public void deleteProduct(Long id) { Transaction transaction = null; try (Session session = HibernateUtil.getSessionFactory().openSession()) { transaction = session.beginTransaction(); Product product = session.get(Product.class, id); if (product != null) { session.delete(product); System.out.println("Product is deleted"); } transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } } 

Step 3: Testing the CRUD Operations

Create a Main class in the com.example.hibernateexample package to test the CRUD operations:

package com.example.hibernateexample; import com.example.hibernateexample.dao.ProductDao; import com.example.hibernateexample.model.Product; import java.util.List; public class Main { public static void main(String[] args) { ProductDao productDao = new ProductDao(); // Insert a product Product product1 = new Product(); product1.setName("Product 1"); product1.setPrice(100.00); productDao.saveProduct(product1); // Insert another product Product product2 = new Product(); product2.setName("Product 2"); product2.setPrice(200.00); productDao.saveProduct(product2); // Select all products List<Product> products = productDao.getProducts(); products.forEach(p -> System.out.println(p.getName() + " - " + p.getPrice())); // Update a product product1.setPrice(150.00); productDao.updateProduct(product1); // Select all products again products = productDao.getProducts(); products.forEach(p -> System.out.println(p.getName() + " - " + p.getPrice())); // Delete a product productDao.deleteProduct(product2.getId()); // Select all products again products = productDao.getProducts(); products.forEach(p -> System.out.println(p.getName() + " - " + p.getPrice())); } } 

Conclusion

In this tutorial, we set up a simple Hibernate project using Maven and demonstrated how to perform basic CRUD operations using Hibernate Query Language (HQL). We created a Product entity and a ProductDao class to handle database operations. We tested the CRUD operations in a Main class. By following this structure, you can extend and customize the application as needed.