Hibernate Criteria API গাইড ও নোট

Hibernate Criteria API হল Hibernate ফ্রেমওয়ার্কের একটি শক্তিশালী বৈশিষ্ট্য যা object-oriented উপায়ে ডেটাবেস কুয়েরি তৈরি করতে সাহায্য করে। Criteria API-এর সাহায্যে আপনি ডেটাবেস থেকে ডেটা রিট্রিভ করতে পারেন, এবং এটি SQL কুয়েরির মতো জটিলতা ছাড়াই ডাইনামিক কুয়েরি তৈরি করার অনুমতি দেয়।

Criteria API মূলত Type-safe, dynamic, এবং object-oriented কুয়েরি তৈরি করার জন্য ব্যবহৃত হয়, যা জেনেরিক টাইপ ব্যবহার করে আপনাকে কুয়েরি তৈরি করতে দেয়।

Hibernate 5.0 এর পর Criteria API কে JPA Criteria API হিসেবে স্থাপন করা হয়েছে। তবে Hibernate এখনও নিজস্ব Criteria API সমর্থন করে, যা পুরনো কোডবেসের জন্য দরকারী।

Criteria API এর সুবিধা

1. Type-safe: Criteria API একটি টাইপ-সেফ কুয়েরি তৈরি করতে সাহায্য করে, কারণ এটি Java objects-এর মাধ্যমে কাজ করে।
2. Dynamic Queries: Criteria API ডাইনামিক কুয়েরি তৈরি করতে সহায়ক, যেখানে কুয়েরি চলাকালীন সময়ে শর্ত যোগ করা বা পরিবর্তন করা সম্ভব।
3. Readable and Maintainable: এটি কোডিংকে আরও পরিষ্কার এবং রক্ষণাবেক্ষণযোগ্য করে তোলে।
4. Avoiding SQL Injection: Criteria API ব্যবহার করলে SQL ইনজেকশন প্রতিরোধ করা যায় কারণ কুয়েরি Java objects-এ তৈরি হয়, তাই ম্যানুয়াল SQL ইনপুট সমস্যা দূর হয়।

Criteria API ব্যবহার করার জন্য প্রাথমিক উপাদানসমূহ

1. Criteria: একটি object যা কুয়েরি তৈরি করার জন্য প্রয়োজনীয় তথ্য ধারণ করে।
2. Restrictions: কুয়েরি শর্ত সংযোজনের জন্য ব্যবহৃত হয়।
3. Projections: নির্বাচিত কলাম বা ডেটা ফিরে পাওয়ার জন্য ব্যবহৃত হয় (যেমন সেলেক্ট কোলামন/এগ্রিগেট ফাংশন)।
4. Order: কুয়েরির রিটার্ন করা ফলাফল সাজানোর জন্য ব্যবহৃত হয়।

Criteria API ব্যবহার করে কুয়েরি তৈরি

Step 1: Hibernate Configuration Setup

এটি hibernate.cfg.xml ফাইলে সাধারণ কনফিগারেশন সেটিংস অন্তর্ভুক্ত করে:

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/yourdb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <property name="hibernate.show_sql">true</property>
    </session-factory>
</hibernate-configuration>

Step 2: Hibernate Criteria API Example

ধরা যাক আমাদের একটি Employee ক্লাস রয়েছে, যেখানে id, name, এবং salary নামক প্রোপার্টি রয়েছে।

Employee Class

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double salary;

    // Getters, Setters, and Constructors
}

এখন আমরা Hibernate Criteria API ব্যবহার করে Employee টেবিল থেকে সমস্ত Employee রেকর্ড রিট্রিভ করব।

Simple Criteria API Example

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.CriteriaQuery;
import org.hibernate.criterion.Restrictions;
import org.hibernate.query.Query;

import java.util.List;

public class CriteriaExample {
    public static void main(String[] args) {
        // Step 1: Create SessionFactory
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
                .addAnnotatedClass(Employee.class)
                .buildSessionFactory();

        // Step 2: Create session
        Session session = factory.getCurrentSession();

        try {
            // Step 3: Start transaction
            session.beginTransaction();

            // Step 4: Create Criteria object
            CriteriaQuery<Employee> criteriaQuery = session.createCriteria(Employee.class);

            // Step 5: Get the list of employees
            List<Employee> employees = criteriaQuery.list();

            // Step 6: Display the employees
            for (Employee employee : employees) {
                System.out.println(employee);
            }

            // Step 7: Commit the transaction
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Criteria API with Restrictions

Restrictions ব্যবহার করে আপনি ডেটাবেসের সাথে শর্তযুক্ত কুয়েরি তৈরি করতে পারেন। এতে eq(), like(), gt(), lt(), ne() ইত্যাদি পদ্ধতি ব্যবহার করা হয়।

Example: Criteria API with Restrictions

ধরা যাক আমরা Employee টেবিল থেকে এমন সকল কর্মচারী নির্বাচন করতে চাই যাদের salary 50000 এর বেশি।

import org.hibernate.criterion.Restrictions;

Criteria criteria = session.createCriteria(Employee.class);
criteria.add(Restrictions.gt("salary", 50000));
List<Employee> employees = criteria.list();

এখানে, Restrictions.gt() ব্যবহার করে আমরা salary > 50000 শর্ত যোগ করেছি।

Criteria API with Projections

Projections ব্যবহার করে আপনি নির্দিষ্ট কলাম নির্বাচন করতে পারেন বা aggregate functions (যেমন: COUNT, SUM, AVG) ব্যবহার করতে পারেন।

Example: Using Projections

ধরা যাক আমরা Employee টেবিল থেকে সমস্ত salary এর যোগফল এবং গড় বের করতে চাই।

import org.hibernate.criterion.Projections;

Criteria criteria = session.createCriteria(Employee.class);
criteria.setProjection(Projections.sum("salary"));
Double totalSalary = (Double) criteria.uniqueResult();

criteria.setProjection(Projections.avg("salary"));
Double avgSalary = (Double) criteria.uniqueResult();

System.out.println("Total Salary: " + totalSalary);
System.out.println("Average Salary: " + avgSalary);

এখানে Projections.sum() এবং Projections.avg() ব্যবহার করা হয়েছে টোটাল এবং গড় স্যালারি বের করতে।

Criteria API with Ordering

Ordering ব্যবহার করে আপনি কুয়েরির রিটার্ন হওয়া ফলাফল সাজাতে পারেন। এটি ascending বা descending অর্ডারে সাজানোর জন্য ব্যবহৃত হয়।

Example: Using Ordering

import org.hibernate.criterion.Order;

Criteria criteria = session.createCriteria(Employee.class);
criteria.addOrder(Order.asc("salary"));
List<Employee> employees = criteria.list();

for (Employee employee : employees) {
    System.out.println(employee);
}

এখানে, Order.asc("salary") ব্যবহার করা হয়েছে যাতে স্যালারি ascending অর্ডারে সাজানো হয়।

Hibernate Criteria API - Advanced Example

Hibernate Criteria API ব্যবহার করে আরও জটিল কুয়েরি তৈরি করতে পারেন, যেমন একাধিক শর্ত যোগ করা এবং আগের শর্তের উপর ভিত্তি করে AND/OR সম্পর্কিত শর্ত যোগ করা।

Example: Complex Criteria Query

Criteria criteria = session.createCriteria(Employee.class);
criteria.add(Restrictions.ge("salary", 50000)); // salary >= 50000
criteria.add(Restrictions.like("name", "John%")); // name starts with "John"
criteria.addOrder(Order.desc("salary")); // order by salary descending

List<Employee> employees = criteria.list();
for (Employee employee : employees) {
    System.out.println(employee);
}

এখানে, Restrictions.ge(), Restrictions.like(), এবং Order.desc() ব্যবহার করে কমপ্লেক্স কুয়েরি তৈরি করা হয়েছে।

Hibernate Criteria API হল একটি শক্তিশালী টুল যা type-safe, dynamic, এবং object-oriented কুয়েরি তৈরি করতে সাহায্য করে। এটি আপনাকে SQL এর জটিলতা ছাড়াই ডেটাবেসের সাথে ইন্টারঅ্যাক্ট করার সুযোগ দেয় এবং HQL বা SQL এর তুলনায় আরও কার্যকরভাবে কুয়েরি তৈরি করতে সহায়ক। Hibernate Criteria API ব্যবহার করে আপনি filters, aggregations, ordering, এবং dynamic queries তৈরি করতে পারেন, যা ডেটাবেস অপারেশনকে সহজ, পারফরম্যান্ট এবং রক্ষণাবেক্ষণযোগ্য করে তোলে।

Hibernate Criteria API: ধারণা এবং প্রয়োজনীয়তা

Hibernate Criteria API হল Hibernate এর একটি API যা আপনাকে SQL কুয়েরি লেখার পরিবর্তে Java কোড দিয়ে ডেটাবেস কুয়েরি তৈরি করতে সক্ষম করে। এটি object-oriented উপায়ে কুয়েরি তৈরি করার জন্য একটি শক্তিশালী এবং টাইপ-সেফ পদ্ধতি প্রদান করে, যা আপনাকে কোডের মধ্যে ডাইনামিক এবং লজিক্যাল কুয়েরি তৈরি করতে সহায়তা করে।

Hibernate Criteria API, Hibernate Query Language (HQL) এবং JPA Criteria API এর একটি বিকল্প হিসেবে কাজ করে। এটি সাধারণত complex, dynamic, এবং প্যারামিটারাইজড কুয়েরি তৈরি করতে ব্যবহৃত হয়, যেখানে traditional SQL বা HQL কোডের পরিবর্তে Java objects ব্যবহার করা হয়।

Criteria API কী?

Hibernate Criteria API হল একটি object-oriented API যা Java objects, properties এবং conditions ব্যবহার করে ডেটাবেসের সাথে সম্পর্কিত কুয়েরি তৈরি করতে সহায়তা করে। Criteria API, Session.createCriteria() মেথডের মাধ্যমে ব্যবহার করা হয়, যা আপনাকে কুয়েরি তৈরি এবং execution এ সাহায্য করে।

Criteria API কোড লেখার সময় dynamic query generation, strong typing, এবং compile-time checking প্রদান করে, যা traditional string-based query execution এর তুলনায় অনেক সুবিধাজনক।

Criteria API-র সুবিধা:

1. Dynamic Query Creation:
   • Criteria API দিয়ে আপনি রানটাইমে কুয়েরি তৈরি করতে পারেন, যা বিশেষভাবে উপকারী যখন আপনাকে বিভিন্ন শর্ত (conditions) অনুযায়ী কুয়েরি তৈরি করতে হয়।
2. Type Safety:
   • Criteria API টাইপ সেফ। এই কারণে, এটি compile-time তে কুয়েরি সঠিক কিনা তা চেক করে, এবং SQL কোডে টাইপ মিসম্যাচ বা ভুল syntax হওয়ার সম্ভাবনা কমায়।
3. No SQL Injection:
   • কারণ এটি কুয়েরি স্ট্রিং তৈরি করার জন্য Java objects ব্যবহার করে, SQL Injection-এর সমস্যা কমে যায়।
4. Modularization:
   • Criteria API আপনাকে আপনার কুয়েরি গঠন এবং কার্যকরী অংশগুলো আলাদা করতে সাহায্য করে, যা কোডের পুনঃব্যবহারযোগ্যতা এবং পরিষ্কারভাবে কাজ করতে সহায়ক।

Criteria API ব্যবহারের উদাহরণ

ধরা যাক, আমাদের একটি Employee টেবিল আছে এবং আমরা Criteria API ব্যবহার করে ডেটাবেস থেকে Employee অবজেক্টের উপর নির্দিষ্ট শর্তে কুয়েরি চালাতে চাই।

1. Basic Criteria Example

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;

public class CriteriaExample {
    public static void main(String[] args) {
        // Hibernate configuration and session factory setup
        SessionFactory factory = new Configuration()
                                    .configure("hibernate.cfg.xml")
                                    .addAnnotatedClass(Employee.class)
                                    .buildSessionFactory();

        // Create a session
        Session session = factory.getCurrentSession();
        
        try {
            // Start a transaction
            session.beginTransaction();
            
            // Create Criteria object to query Employee class
            Criteria criteria = session.createCriteria(Employee.class);
            
            // Adding condition (where salary > 50000)
            criteria.add(Restrictions.gt("salary", 50000));
            
            // Execute the query and get the result list
            List<Employee> employees = criteria.list();
            
            // Display the results
            for (Employee employee : employees) {
                System.out.println(employee);
            }

            // Commit the transaction
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

কী ঘটছে?

• session.createCriteria(Employee.class) দ্বারা Employee ক্লাসের জন্য একটি Criteria object তৈরি করা হয়েছে।
• criteria.add(Restrictions.gt("salary", 50000)) দিয়ে salary > 50000 শর্ত যুক্ত করা হয়েছে।
• criteria.list() মেথড ব্যবহার করে কুয়েরি এক্সিকিউট করা হয়েছে এবং সেই অনুযায়ী সমস্ত Employee রেকর্ড বের করা হয়েছে।

2. Using Multiple Conditions (AND/OR Conditions)

Criteria API দিয়ে আপনি একাধিক শর্ত (conditions) যোগ করতে পারেন, যেমন AND বা OR শর্ত।

import org.hibernate.criterion.Restrictions;

public class CriteriaExample {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration()
                                    .configure("hibernate.cfg.xml")
                                    .addAnnotatedClass(Employee.class)
                                    .buildSessionFactory();
        
        Session session = factory.getCurrentSession();

        try {
            session.beginTransaction();

            // Create Criteria object
            Criteria criteria = session.createCriteria(Employee.class);

            // Adding multiple conditions with AND operator
            criteria.add(Restrictions.and(
                    Restrictions.eq("department", "Sales"), 
                    Restrictions.gt("salary", 50000)
            ));

            List<Employee> employees = criteria.list();

            for (Employee employee : employees) {
                System.out.println(employee);
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

এখানে, AND condition ব্যবহার করা হয়েছে, যেখানে department = "Sales" এবং salary > 50000 দুটি শর্ত একসাথে পূর্ণ হতে হবে।

3. Using Projections (Aggregations)

Criteria API ব্যবহার করে আপনি aggregate functions যেমন count(), avg(), max(), min() ইত্যাদি ব্যবহার করতে পারেন।

import org.hibernate.criterion.Projections;

public class CriteriaExample {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration()
                                    .configure("hibernate.cfg.xml")
                                    .addAnnotatedClass(Employee.class)
                                    .buildSessionFactory();

        Session session = factory.getCurrentSession();

        try {
            session.beginTransaction();

            // Create Criteria object
            Criteria criteria = session.createCriteria(Employee.class);
            
            // Add projection (aggregate function)
            criteria.setProjection(Projections.avg("salary"));

            List<Double> avgSalary = criteria.list();

            System.out.println("Average Salary: " + avgSalary.get(0));

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

এখানে, Projections.avg("salary") ব্যবহার করে সমস্ত Employee এর গড় বেতন হিসাব করা হয়েছে।

Criteria API এর প্রয়োজনীয়তা

1. Dynamic Query Generation:
   • Criteria API আপনাকে রানটাইমে কুয়েরি তৈরি করার সুবিধা দেয়। এই সুবিধাটি খুবই উপকারী যখন কুয়েরি কন্ডিশনগুলি ব্যবহারকারী ইনপুট বা ডাইনামিক কনফিগারেশনের ভিত্তিতে পরিবর্তন হয়।
2. Type Safety:
   • Criteria API টাইপ সেফ। এর মানে হল যে আপনি যদি ভুল ফিল্ড বা কলাম নাম দেন, তখন কম্পাইল টাইমেই আপনি সেই ত্রুটি দেখতে পাবেন, যা SQL বা HQL লেখার ক্ষেত্রে সম্ভব নয়।
3. SQL Injection থেকে সুরক্ষা:
   • Criteria API দ্বারা কুয়েরি তৈরি করার সময়, এটি parameterized queries তৈরি করে, ফলে SQL injection এর ঝুঁকি কমে যায়।
4. Better Integration with Java Code:
   • Criteria API কেবল Java objects ব্যবহার করে কুয়েরি তৈরি করার সুবিধা দেয়, তাই কোডের মধ্যে ডেটাবেস সম্পর্কিত অংশগুলি বেশি সুসংহত থাকে এবং ডেটাবেস নিরপেক্ষ থাকে।
5. Maintainability:
   • Criteria API কোড লেখার সময় SQL কোডের পরিবর্তে Java অবজেক্ট এবং মেথড ব্যবহার করা যায়, যা কোড রিডেবিলিটি এবং মেইনটেইনেবিলিটি উন্নত করে।
6. Complex Query Building:
   • Criteria API দিয়ে আপনি জটিল কুয়েরি যেমন join, group by, order by, aggregate function ইত্যাদি তৈরি করতে পারেন। এতে কোড আরও পরিষ্কার এবং মডুলার থাকে।

Hibernate Criteria API একটি শক্তিশালী, object-oriented উপায় যা ডেটাবেস কুয়েরি তৈরি এবং এক্সিকিউট করার জন্য ব্যবহৃত হয়। এটি SQL কোডের পরিবর্তে Java objects ব্যবহার করে কুয়েরি তৈরি করতে সাহায্য করে এবং এতে type safety, dynamic query generation, এবং SQL injection থেকে সুরক্ষা প্রদান করে। Criteria API-এর মাধ্যমে আপনি complex এবং dynamic কুয়েরি তৈরি করতে পারেন যা SQL বা HQL লেখার তুলনায় আরও সহজ এবং নিরাপদ।

Hibernate Criteria API হল একটি শক্তিশালী উপায় যা Hibernate ORM ব্যবহার করে ডাইনামিক এবং টাইপ-সেফ কুয়েরি তৈরি করার জন্য ব্যবহৃত হয়। Criteria API এর মাধ্যমে, আপনি SQL এর মতো কোড না লিখে, Java কোডের মাধ্যমে ডাটাবেস কুয়েরি তৈরি করতে পারেন, যা কোডের জন্য আরও নিরাপদ এবং উন্নত।

Criteria API ব্যবহার করে Query তৈরি করার ধাপগুলো:

Hibernate-এ Criteria API ব্যবহার করার জন্য কিছু নির্দিষ্ট স্টেপ অনুসরণ করতে হয়। এই API আপনাকে Query By Example, Dynamic Queries, এবং Type-Safe Queries তৈরি করতে সহায়তা করে। এটি ডেটাবেস কুয়েরি তৈরির জন্য Session অবজেক্টের একটি অংশ হিসেবে কাজ করে।

Step 1: Hibernate Configuration Setup

প্রথমে, Hibernate কনফিগারেশন ফাইল (hibernate.cfg.xml) তৈরি করুন বা সেটআপ করুন যেখানে ডাটাবেস কনফিগারেশন ও Hibernate সেটিংস থাকবে।

<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</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password"></property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
    </session-factory>
</hibernate-configuration>

এটি Hibernate কনফিগারেশন ফাইল যা ডাটাবেসের সাথে সংযোগ তৈরি করে এবং Hibernate এর অন্যান্য প্রপার্টি কনফিগার করে।

Step 2: Entity Class তৈরি করা

এখন Hibernate Entity ক্লাস তৈরি করুন। এখানে আমরা একটি সাধারণ Employee ক্লাস তৈরি করব।

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Employee {

    @Id
    private int id;
    private String name;
    private String department;

    // Constructor, Getter and Setter methods

    public Employee() {}

    public Employee(int id, String name, String department) {
        this.id = id;
        this.name = name;
        this.department = department;
    }

    // Getters and Setters
    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 String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }
}

এখানে, Employee ক্লাসটি একটি জাভা অবজেক্ট যা JPA Entity হিসেবে ডাটাবেস টেবিলের সাথে ম্যাপ হবে।

Step 3: Hibernate Criteria API Query তৈরি করা

Hibernate Criteria API ব্যবহার করে ডাইনামিক কুয়েরি তৈরি করার জন্য, প্রথমে Session অবজেক্ট থেকে Criteria অবজেক্ট তৈরি করতে হয়। তারপর Restrictions ব্যবহার করে কুয়েরি নির্দিষ্ট করা হয়।

Criteria Query উদাহরণ (Retrieve Employees with a Specific Department)

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;

import java.util.List;

public class EmployeeDAO {

    private SessionFactory sessionFactory;

    public EmployeeDAO(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public List<Employee> getEmployeesByDepartment(String department) {
        // Session তৈরি করা
        Session session = sessionFactory.getCurrentSession();

        // Criteria API ব্যবহার করে কুয়েরি তৈরি করা
        Criteria criteria = session.createCriteria(Employee.class);
        criteria.add(Restrictions.eq("department", department));

        // কুয়েরি চলানো এবং ফলাফল পাওয়া
        List<Employee> employees = criteria.list();
        return employees;
    }
}

এখানে:

• createCriteria(Employee.class): এটি Employee Entity ক্লাসের জন্য একটি Criteria অবজেক্ট তৈরি করে।
• Restrictions.eq("department", department): এটি department ফিল্ডের মানকে department প্যারামিটার দিয়ে ফিল্টার করে।

Step 4: Main Application

এখন MainApp ক্লাস ব্যবহার করে Criteria API কুয়েরি চালানো হবে এবং Employee ডাটাবেস থেকে ফিল্টার করা হবে।

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import java.util.List;

public class MainApp {

    public static void main(String[] args) {
        // SessionFactory তৈরি করা
        SessionFactory sessionFactory = new Configuration().configure().addAnnotatedClass(Employee.class).buildSessionFactory();

        // EmployeeDAO ক্লাস ইনস্ট্যান্স তৈরি করা
        EmployeeDAO employeeDAO = new EmployeeDAO(sessionFactory);

        // Department এর উপর ভিত্তি করে Employees সংগ্রহ করা
        List<Employee> employees = employeeDAO.getEmployeesByDepartment("IT");

        // Employees এর তথ্য প্রিন্ট করা
        for (Employee employee : employees) {
            System.out.println("ID: " + employee.getId() + ", Name: " + employee.getName() + ", Department: " + employee.getDepartment());
        }

        // SessionFactory বন্ধ করা
        sessionFactory.close();
    }
}

এখানে:

• getEmployeesByDepartment("IT") মেথডের মাধ্যমে "IT" ডিপার্টমেন্টের সমস্ত Employee অবজেক্ট ফিল্টার করা হচ্ছে।
• সমস্ত Employee অবজেক্টের তথ্য কনসোলে প্রিন্ট করা হচ্ছে।

Step 5: Output

যদি আপনার ডাটাবেসে "IT" ডিপার্টমেন্টের কোনো Employee অবজেক্ট থাকে, তাহলে কনসোলে এমন কিছু আউটপুট দেখাবে:

ID: 1, Name: John Doe, Department: IT
ID: 2, Name: Jane Doe, Department: IT

Step 6: Additional Criteria API Features

Hibernate Criteria API আরও অনেক শক্তিশালী ফিচার প্রদান করে যেমন:

1. Restrictions: বিভিন্ন ধরনের কন্ডিশনাল ফিল্টার (যেমন eq, gt, lt, like, in, ইত্যাদি) অ্যাপ্লাই করতে ব্যবহার করা হয়।

2. Projection: ফলাফল থেকে নির্দিষ্ট ফিল্ড বা কলাম নির্বাচন করতে ব্যবহার করা হয় (যেমন select SQL এ)।

   criteria.setProjection(Projections.property("name"));
   

3. Order: ফলাফলগুলি সাজানোর জন্য।

   criteria.addOrder(Order.asc("name"));
   

4. Pagination: ডাটাবেসে একসাথে রেকর্ডের পরিমাণ সীমিত করার জন্য (যেমন LIMIT SQL এ)।

   criteria.setFirstResult(0);
   criteria.setMaxResults(10);
   

Hibernate Criteria API একটি শক্তিশালী পদ্ধতি যা আপনাকে ডাইনামিক এবং টাইপ-সেফ কুয়েরি তৈরি করতে সহায়তা করে। এটি SQL স্টেটমেন্ট লেখার পরিবর্তে Java কোডের মাধ্যমে ডাটাবেস কুয়েরি তৈরি করার জন্য একটি পরিষ্কার এবং মডুলার পদ্ধতি প্রদান করে। Criteria API দিয়ে আপনি সহজেই ডেটা ফিল্টারিং, অর্ডারিং, এবং পেজিনেশন করতে পারবেন, যা আপনার ডাটাবেস অপারেশনকে আরও কার্যকরী এবং মডুলার করে তোলে।

Restrictions এবং Projections Hibernate এর দুটি শক্তিশালী ফিচার, যা Criteria API ব্যবহার করে queries তৈরি করতে সহায়ক। এগুলি ডেটা রিট্রিভ করার প্রক্রিয়া আরও ফ্লেক্সিবল এবং কার্যকরী করতে ব্যবহৃত হয়, বিশেষ করে যখন আপনাকে complex filtering বা specific fields চয়ন করতে হয়।

এই অংশে Restrictions এবং Projections কীভাবে কাজ করে এবং তাদের ব্যবহার কীভাবে ডেটা রিট্রিভাল অপটিমাইজ করতে সাহায্য করে তা আলোচনা করা হবে।

1. Restrictions

Restrictions Hibernate Criteria API-তে queries কাস্টমাইজ করার জন্য ব্যবহৃত হয়। এটি filtering এবং conditional expressions এর মাধ্যমে ডেটা সংগ্রহের জন্য অত্যন্ত কার্যকর। Restrictions ব্যবহার করে আপনি where conditions, like, between, equals, ইত্যাদি বিভিন্ন ধরনের শর্ত ব্যবহার করতে পারেন।

Common Restrictions:

• eq (Equal)
• ne (Not Equal)
• like (Pattern Matching)
• between (Range Filtering)
• gt, lt, ge, le (Greater Than, Less Than, Greater or Equal, Less or Equal)
• isNull, isNotNull (Null Check)

Example: Using Restrictions to Filter Data

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
import java.util.List;

public class RetrieveExample {
    public static void main(String[] args) {
        // Step 1: Create session factory and session
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
                .addAnnotatedClass(Employee.class)
                .buildSessionFactory();

        Session session = factory.getCurrentSession();

        try {
            // Step 2: Begin transaction
            session.beginTransaction();

            // Step 3: Use Criteria to apply Restrictions (filter employees with salary greater than 50000)
            List<Employee> employees = session.createCriteria(Employee.class)
                                              .add(Restrictions.gt("salary", 50000))
                                              .list();

            // Step 4: Display the results
            for (Employee emp : employees) {
                System.out.println(emp);
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Explanation:

• Restrictions.gt("salary", 50000): এই restriction salary ফিল্ডের জন্য একটি শর্ত তৈরি করে যা 50000 এর চেয়ে বড় মান রিটার্ন করবে।
• createCriteria(Employee.class): এটি Employee ক্লাসের উপর একটি Criteria query তৈরি করে।

2. Projections

Projections Hibernate Criteria API-তে ব্যবহার করা হয়, যখন আপনি specific fields (columns) বা aggregated results (যেমন COUNT, SUM) রিটার্ন করতে চান। Projection মূলত SQL-এর SELECT কুয়েরি অংশের মতো কাজ করে, যার মাধ্যমে আপনি কোন ফিল্ড বা ডেটা রিটার্ন করবেন তা নিয়ন্ত্রণ করতে পারেন।

Common Projections:

• property: একটি নির্দিষ্ট প্রপার্টি (ফিল্ড) রিটার্ন করতে ব্যবহার করা হয়।
• rowCount: মোট রেকর্ডের সংখ্যা জানতে।
• sum, avg, min, max: ডেটার গাণিতিক পরিসংখ্যান বের করার জন্য।

Example: Using Projections to Select Specific Fields

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Projections;
import java.util.List;

public class RetrieveExample {
    public static void main(String[] args) {
        // Step 1: Create session factory and session
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
                .addAnnotatedClass(Employee.class)
                .buildSessionFactory();

        Session session = factory.getCurrentSession();

        try {
            // Step 2: Begin transaction
            session.beginTransaction();

            // Step 3: Using Projections to retrieve only "name" and "salary" columns
            List<Object[]> results = session.createCriteria(Employee.class)
                                            .setProjection(Projections.projectionList()
                                                                    .add(Projections.property("name"))
                                                                    .add(Projections.property("salary")))
                                            .list();

            // Step 4: Display the results
            for (Object[] result : results) {
                System.out.println("Employee Name: " + result[0] + ", Salary: " + result[1]);
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Explanation:

• Projections.property("name"): এটি শুধুমাত্র name ফিল্ডটি রিটার্ন করার জন্য ব্যবহৃত হয়।
• Projections.property("salary"): এটি salary ফিল্ডের মান রিটার্ন করে।
• setProjection(Projections.projectionList()): এটি একাধিক ফিল্ড নির্বাচন করার জন্য ব্যবহৃত হয়।

3. Using Projections with Aggregation Functions

Projections শুধুমাত্র একক ফিল্ড বা ডেটা রিটার্ন করতে নয়, বরং aggregation functions (যেমন COUNT, SUM, AVG, MIN, MAX) হিসাব করতে সাহায্য করে।

Example: Using Projections for Aggregation (SUM, COUNT)

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Projections;

public class RetrieveExample {
    public static void main(String[] args) {
        // Step 1: Create session factory and session
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
                .addAnnotatedClass(Employee.class)
                .buildSessionFactory();

        Session session = factory.getCurrentSession();

        try {
            // Step 2: Begin transaction
            session.beginTransaction();

            // Step 3: Use Projections to calculate the total salary of all employees
            Double totalSalary = (Double) session.createCriteria(Employee.class)
                                                  .setProjection(Projections.sum("salary"))
                                                  .uniqueResult();

            System.out.println("Total Salary: " + totalSalary);

            // Step 4: Use Projections to count the number of employees
            Long employeeCount = (Long) session.createCriteria(Employee.class)
                                              .setProjection(Projections.rowCount())
                                              .uniqueResult();

            System.out.println("Total Employees: " + employeeCount);

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Explanation:

• Projections.sum("salary"): এটি সমস্ত salary ফিল্ডের মোট যোগফল রিটার্ন করবে।
• Projections.rowCount(): এটি টেবিলের মোট রেকর্ড (কাউন্ট) রিটার্ন করবে।

4. Combining Restrictions and Projections

Hibernate Criteria API-তে Restrictions এবং Projections একসাথে ব্যবহার করা সম্ভব, যেখানে আপনি একদিকে শর্ত আরোপ (filtering) করবেন এবং অন্যদিকে নির্দিষ্ট ফিল্ড বা অ্যাগ্রিগেটেড ভ্যালু রিটার্ন করবেন।

Example: Using Restrictions and Projections Together

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
import org.hibernate.criterion.Projections;

public class RetrieveExample {
    public static void main(String[] args) {
        // Step 1: Create session factory and session
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
                .addAnnotatedClass(Employee.class)
                .buildSessionFactory();

        Session session = factory.getCurrentSession();

        try {
            // Step 2: Begin transaction
            session.beginTransaction();

            // Step 3: Use Restrictions and Projections together
            List<Object[]> results = session.createCriteria(Employee.class)
                                            .add(Restrictions.gt("salary", 30000))
                                            .setProjection(Projections.projectionList()
                                                                    .add(Projections.property("name"))
                                                                    .add(Projections.property("salary")))
                                            .list();

            // Step 4: Display the results
            for (Object[] result : results) {
                System.out.println("Employee Name: " + result[0] + ", Salary: " + result[1]);
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Explanation:

• Restrictions.gt("salary", 30000): এখানে salary এর মান ৩০,০০০ এর চেয়ে বড় হওয়া উচিত।
• Projections.property("name") এবং Projections.property("salary"): এখানে name এবং salary রিটার্ন করা হচ্ছে যেগুলি salary > 30000 শর্তে ফিল্টার করা হয়েছে।

Hibernate Criteria API-তে Restrictions এবং Projections ব্যবহারের মাধ্যমে আপনি ডেটা ফিল্টার এবং কাস্টমাইজ করতে পারেন। এই দুই ফিচারের মাধ্যমে:

• Restrictions আপনাকে ডেটা রিট্রিভ করার জন্য শর্ত এবং ফিল্টার অ্যাপ্লাই করতে সাহায্য করে (যেমন, like, equal, greaterThan, ইত্যাদি)।
• Projections আপনাকে নির্দিষ্ট ফিল্ড বা অ্যাগ্রিগেটেড রেজাল্ট (যেমন, COUNT, SUM, AVG) রিটার্ন করতে সাহায্য করে।

এই দুটি ফিচারের সঠিক ব্যবহার আপনার কোডকে আরও কার্যকরী, নমনীয় এবং পারফরম্যান্স অপটিমাইজড করতে সাহায্য করবে।

Hibernate Criteria API হল একটি শক্তিশালী উপায় যার মাধ্যমে ডাইনামিক কুয়েরি তৈরি করা যায়। এটি Hibernate ORM ফ্রেমওয়ার্কে Object-Oriented কোড লিখে SQL কুয়েরি তৈরি করতে সহায়তা করে। Criteria API আপনাকে Type-safe, dynamic queries, এবং complex queries তৈরির সুবিধা প্রদান করে, যেখানে আপনি JPA-এর CriteriaBuilder এবং CriteriaQuery ব্যবহার করে কোডের মাধ্যমে কুয়েরি তৈরি করতে পারেন।

Criteria API: Overview

Criteria API হাইবারনেট 3.x-এ তৈরি হয়েছিল এবং এটি JPA (Java Persistence API) স্পেসিফিকেশনের অংশ হিসেবে JPA Criteria API হিসেবে উন্নত করা হয়েছে। Hibernate Criteria API মূলত ডাইনামিক কুয়েরি তৈরি করতে ব্যবহৃত হয়, যেখানে আপনার কুয়েরি প্রোগ্রাম্যাটিকভাবে তৈরি করা হয় এবং type-safe থাকে।

Advantages of Criteria API:

1. Type-Safe Queries: Type checking at compile time.
2. Dynamic Queries: You can build queries dynamically based on conditions.
3. More Readable and Maintainable: Easier to maintain and debug.
4. Avoid SQL Injection: Safe from SQL injection attacks as it avoids concatenating raw strings.

1. Setting Up Hibernate Criteria API

Entity Class Example (Student):

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Student {
    @Id
    private int id;
    private String name;
    private String course;

    // Getters and Setters
    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 String getCourse() {
        return course;
    }

    public void setCourse(String course) {
        this.course = course;
    }
}

2. Example: Basic Query Using Criteria API

Basic Query to get all students:

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.query.Query;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;

import java.util.List;

public class CriteriaExample {
    public static void main(String[] args) {
        SessionFactory factory = HibernateUtil.getSessionFactory();
        Session session = factory.getCurrentSession();
        try {
            session.beginTransaction();

            // Create a Criteria instance
            Criteria criteria = session.createCriteria(Student.class);
            
            // Execute the query and get the list of students
            List<Student> students = criteria.list();
            
            for (Student student : students) {
                System.out.println(student.getName() + ": " + student.getCourse());
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

In this example, the Criteria object retrieves all students from the Student table. The query is simple and fetches all records.

3. Using Restrictions for Filtering Criteria

You can use Restrictions to add conditions to your query (similar to WHERE in SQL).

Example: Filter Students by Course

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;

import java.util.List;

public class CriteriaExample {
    public static void main(String[] args) {
        SessionFactory factory = HibernateUtil.getSessionFactory();
        Session session = factory.getCurrentSession();
        try {
            session.beginTransaction();

            // Create a Criteria instance
            Criteria criteria = session.createCriteria(Student.class);
            
            // Apply restriction to filter students by course
            criteria.add(Restrictions.eq("course", "Java")); // Similar to WHERE course='Java'

            // Execute the query and get the list of students
            List<Student> students = criteria.list();
            
            for (Student student : students) {
                System.out.println(student.getName() + ": " + student.getCourse());
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

In this example:

• Restrictions.eq() is used to filter students whose course is "Java".

4. Using Multiple Restrictions for Complex Queries

You can combine multiple restrictions (conditions) using Restrictions.and() or Restrictions.or().

Example: Filter Students by Course and Name

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;

import java.util.List;

public class CriteriaExample {
    public static void main(String[] args) {
        SessionFactory factory = HibernateUtil.getSessionFactory();
        Session session = factory.getCurrentSession();
        try {
            session.beginTransaction();

            // Create a Criteria instance
            Criteria criteria = session.createCriteria(Student.class);
            
            // Apply multiple restrictions (AND condition)
            criteria.add(Restrictions.eq("course", "Java"));
            criteria.add(Restrictions.like("name", "John%")); // Name starts with John

            // Execute the query and get the list of students
            List<Student> students = criteria.list();
            
            for (Student student : students) {
                System.out.println(student.getName() + ": " + student.getCourse());
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

In this example:

• Restrictions.like() is used to filter students whose names start with "John".
• Multiple restrictions are applied with an implicit AND.

5. Sorting Results Using Criteria API

You can easily sort the results using Order.

Example: Sorting Students by Name

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Order;

import java.util.List;

public class CriteriaExample {
    public static void main(String[] args) {
        SessionFactory factory = HibernateUtil.getSessionFactory();
        Session session = factory.getCurrentSession();
        try {
            session.beginTransaction();

            // Create a Criteria instance
            Criteria criteria = session.createCriteria(Student.class);
            
            // Sort the students by name in ascending order
            criteria.addOrder(Order.asc("name"));

            // Execute the query and get the list of students
            List<Student> students = criteria.list();
            
            for (Student student : students) {
                System.out.println(student.getName() + ": " + student.getCourse());
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

In this example:

• Order.asc("name") sorts the results by student name in ascending order.

6. Paginate Results Using Criteria API

You can also paginate results using setFirstResult() and setMaxResults().

Example: Pagination

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;

import java.util.List;

public class CriteriaExample {
    public static void main(String[] args) {
        SessionFactory factory = HibernateUtil.getSessionFactory();
        Session session = factory.getCurrentSession();
        try {
            session.beginTransaction();

            // Create a Criteria instance
            Criteria criteria = session.createCriteria(Student.class);

            // Set pagination parameters (page 1 with 5 records per page)
            criteria.setFirstResult(0);
            criteria.setMaxResults(5);

            // Execute the query and get the list of students
            List<Student> students = criteria.list();
            
            for (Student student : students) {
                System.out.println(student.getName() + ": " + student.getCourse());
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

In this example:

• setFirstResult(0): This sets the first record to fetch (start at the first record).
• setMaxResults(5): This limits the number of records to 5.

7. Dynamic Queries Using Criteria API

You can dynamically build queries based on conditions, allowing for flexible and reusable code.

Example: Dynamic Query Creation

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;

import java.util.List;

public class CriteriaExample {
    public static void main(String[] args) {
        SessionFactory factory = HibernateUtil.getSessionFactory();
        Session session = factory.getCurrentSession();
        try {
            session.beginTransaction();

            // Create a Criteria instance
            Criteria criteria = session.createCriteria(Student.class);

            // Dynamically add restrictions
            String course = "Java";  // Can be dynamically set
            if (course != null && !course.isEmpty()) {
                criteria.add(Restrictions.eq("course", course));
            }

            // Execute the query and get the list of students
            List<Student> students = criteria.list();
            
            for (Student student : students) {
                System.out.println(student.getName() + ": " + student.getCourse());
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Here, the query is dynamically adjusted based on the condition, which makes it flexible for use in various scenarios.

Hibernate Criteria API একটি শক্তিশালী এবং type-safe উপায়, যা dynamic queries তৈরি করতে সাহায্য করে। এর মাধ্যমে আপনি complex queries তৈরি করতে পারেন এবং filters, sorting, pagination সহ বিভিন্ন কার্যক্রম পরিচালনা করতে পারেন। Criteria API ব্যবহার করলে SQL-এর মতো কুয়েরি লিখতে হয় না, এবং কোড লিখতে অনেক বেশি সুবিধা হয় কারণ এটি type-safe এবং compile-time checking প্রদান করে।