EntityManager and Queries

🏭 JPA Queries: Your Database Factory Tour

Imagine you run a magical toy factory. You have workers who build toys, a workshop where they work, and special ways to find exactly the toys you need. That’s exactly how JPA (Java Persistence API) manages your database!

🎬 The Story Begins

Once upon a time, there was a busy toy factory. The factory needed:

• A Factory Owner (EntityManagerFactory) who hires workers
• Workers (EntityManager) who actually build and find toys
• A Workshop (Persistence Context) where work happens
• Recipe Cards (Named Queries) with pre-written instructions
• Secret Blueprints (Native Queries) for special orders
• A Page System (Pagination) to organize everything

Let’s meet each one!

🏗️ EntityManagerFactory: The Factory Owner

What Is It?

Think of EntityManagerFactory as the big boss who owns the entire factory. This boss:

• Is created once when the factory opens
• Hires workers (creates EntityManagers) whenever needed
• Knows all the rules about how the factory runs

Simple Example

// Create the factory owner (do this ONCE)
EntityManagerFactory factory =
    Persistence.createEntityManagerFactory("myToyFactory");

// The boss hires a worker
EntityManager worker = factory.createEntityManager();

// When factory closes for the night
factory.close();

Real Life Connection

• Factory opens in morning = createEntityManagerFactory()
• Boss hires workers = factory.createEntityManager()
• Factory closes at night = factory.close()

💡 Remember: One factory owner, many workers!

👷 EntityManager: Your Helpful Worker

What Is It?

The EntityManager is your hardworking friend who does ALL the real work:

• Saves new toys to the shelf (persist)
• Finds toys you’re looking for (find)
• Updates old toys with new parts (merge)
• Removes broken toys (remove)

Simple Example

// Get a worker
EntityManager em = factory.createEntityManager();

// Save a new toy
em.getTransaction().begin();
Toy teddy = new Toy("Teddy Bear");
em.persist(teddy);  // Put it on the shelf!
em.getTransaction().commit();

// Find a toy by its tag number
Toy found = em.find(Toy.class, 1L);

// Worker goes home
em.close();

The Worker’s Main Jobs

🏠 Persistence Context: The Magic Workshop

What Is It?

The Persistence Context is like a magical workshop where your worker does the job. It’s special because:

• It remembers all the toys being worked on
• It tracks changes automatically
• It’s temporary (exists only while worker is working)

The Magic Part

em.getTransaction().begin();

// Find a toy - now it's in the workshop
Toy bear = em.find(Toy.class, 1L);

// Change its name - workshop notices!
bear.setName("Super Teddy");

// Commit - changes saved automatically!
em.getTransaction().commit();
// No need to call update!

graph TD
    A["🔍 Find Toy"] --> B["📥 Toy enters Workshop"]
    B --> C["✏️ Make changes"]
    C --> D["💾 Commit Transaction"]
    D --> E["✅ Database Updated!"]

Why Is This Cool?

You changed the toy’s name and didn’t call any save method. The workshop (Persistence Context) watched your changes and saved them automatically!

🎯 Key Insight: If an object is in the Persistence Context, JPA tracks all your changes!

📝 Named Queries: Recipe Cards

What Is It?

Named Queries are like recipe cards you write once and use many times. Instead of typing the same search instruction over and over, you give it a name!

Simple Example

Step 1: Write the recipe card (on your Entity class)

@Entity
@NamedQuery(
    name = "Toy.findByColor",
    query = "SELECT t FROM Toy t WHERE t.color = :color"
)
public class Toy {
    private String name;
    private String color;
    // ...
}

Step 2: Use the recipe card

// Use the named query
List<Toy> redToys = em
    .createNamedQuery("Toy.findByColor", Toy.class)
    .setParameter("color", "red")
    .getResultList();

Benefits

• ✅ Write once, use everywhere
• ✅ Checked when app starts (find errors early!)
• ✅ Easy to read and maintain
• ✅ Can be optimized by JPA

🔧 Native Queries: Secret Blueprints

What Is It?

Sometimes you need to use the actual database language (SQL). Native Queries let you write real SQL when JPA’s language isn’t enough.

When To Use?

• Complex database-specific features
• Performance optimization
• Using special database functions

Simple Example

// Using real SQL
List<Toy> toys = em
    .createNativeQuery(
        "SELECT * FROM toys WHERE price < 10",
        Toy.class
    )
    .getResultList();

// With parameters (safer!)
List<Toy> cheapToys = em
    .createNativeQuery(
        "SELECT * FROM toys WHERE price < ?1",
        Toy.class
    )
    .setParameter(1, 10)
    .getResultList();

JPQL vs Native Query

⚠️ Tip: Use Native Queries only when you really need them!

📖 Pagination: The Page System

What Is It?

Imagine you have 1000 toys, but you can only show 10 at a time. Pagination is like reading a book - you look at one page at a time!

Simple Example

// Get toys 21-30 (page 3, 10 per page)
List<Toy> page = em
    .createQuery("SELECT t FROM Toy t", Toy.class)
    .setFirstResult(20)  // Skip first 20
    .setMaxResults(10)   // Take only 10
    .getResultList();

The Math Made Simple

Page 1: Skip 0,  Take 10  → Toys 1-10
Page 2: Skip 10, Take 10  → Toys 11-20
Page 3: Skip 20, Take 10  → Toys 21-30

Formula: setFirstResult((pageNumber - 1) * pageSize)

graph TD
    A["1000 Toys Total"] --> B["Page 1: Toys 1-10"]
    A --> C["Page 2: Toys 11-20"]
    A --> D["Page 3: Toys 21-30"]
    A --> E["... more pages ..."]

Helper Method

public List<Toy> getToyPage(int page, int size) {
    return em
        .createQuery("SELECT t FROM Toy t", Toy.class)
        .setFirstResult((page - 1) * size)
        .setMaxResults(size)
        .getResultList();
}

// Usage
List<Toy> page1 = getToyPage(1, 10);
List<Toy> page2 = getToyPage(2, 10);

🎯 Putting It All Together

Here’s how everything works in your toy factory:

graph TD
    A["🏭 EntityManagerFactory"] -->|creates| B["👷 EntityManager"]
    B -->|works in| C["🏠 Persistence Context"]
    B -->|uses| D["📝 Named Queries"]
    B -->|uses| E["🔧 Native Queries"]
    D -->|returns| F["📖 Paginated Results"]
    E -->|returns| F

Complete Example

// 1. Create factory (once at app start)
EntityManagerFactory emf =
    Persistence.createEntityManagerFactory("toyStore");

// 2. Get a worker
EntityManager em = emf.createEntityManager();

try {
    // 3. Start work
    em.getTransaction().begin();

    // 4. Save new toy (uses Persistence Context)
    Toy newToy = new Toy("Robot", "blue");
    em.persist(newToy);

    // 5. Find toys using Named Query
    List<Toy> blueToys = em
        .createNamedQuery("Toy.findByColor", Toy.class)
        .setParameter("color", "blue")
        .setFirstResult(0)
        .setMaxResults(5)
        .getResultList();

    // 6. Finish work
    em.getTransaction().commit();

} finally {
    em.close();
}

🌟 Quick Summary

💪 You Did It!

Now you understand how JPA manages your database like a well-run toy factory:

1. EntityManagerFactory opens the factory
2. EntityManager workers do the jobs
3. Persistence Context remembers everything
4. Named Queries are your saved recipes
5. Native Queries give you SQL superpowers
6. Pagination keeps things organized

Go build something amazing! 🚀