In below there is question and answer, What I need is I want comment about the a

Question

In below there is question and answer, What I need is I want comment about the answer { feel free to agree or disagree with answer and explain why you agree or disagree}, and 2nd thing is give your own answer for the question(something diffrent than answer)

Question:
Discuss some of the primary key generation strategies in JPA and when and why would you use the a certain approach

Answer:
The four generation strategies supported by the JPA specification are AUTO, SEQUENCE, IDENTITY, and TABLE

The AUTO strategy is the most common and the default strategy. This choice indicates that the persistence provider should select an appropriate strategy for the particular database.

The SEQUENCE strategy is the preferred key generation strategy, but not all databases support sequence objects. It uses database sequences to generate the unique values. MySql does not support this strategy.

The IDENTITY strategy is known to be slow. It requires an auto-incremented database column to generate the primary key value.

The TABLE strategy is not a recommended approach due to performance concerns. Primary keys are assigned for the entity using a database table to ensure uniqueness. Some locks may be used which could affect performance.

Explanation / Answer

4 Options to generate primary keys

The JPA specification supports 4 different primary key generation strategies which generate the primary key values programmatically or use database features, like auto-incremented columns or sequences. The only thing you have to do is to add the @GeneratedValue annotation to your primary key attribute and choose a generation strategy.

GenerationType.AUTO

The GenerationType.AUTO is the default generation type and lets the persistence provider choose the generation strategy.

If you use Hibernate as your persistence provider, it selects a generation strategy based on the database specific dialect. For most popular databases, it selects GenerationType.IDENTITY

GenerationType.IDENTITY

The GenerationType.IDENTITY is the easiest to use but not the best one from a performance point of view. It relies on an auto-incremented database column and lets the database generate a new value with each insert operation. From a database point of view, this is very efficient because the auto-increment columns are highly optimized, and it doesn’t require any additional statements.

This approach has a significant drawback if you use Hibernate. Hibernate requires a primary key value for each managed entity and therefore must perform the insert statement immediately. This prevents it from using different optimization techniques like JDBC batching.

GenerationType.SEQUENCE

The GenerationType.SEQUENCE is my preferred way to generate primary key values and uses a database sequence to generate unique values.

It requires additional select statements to get the next value from a database sequence. But this has no performance impact for most applications. And if your application has to persist a huge number of new entities, you can use some Hibernate specific optimizations to reduce the number of statements.

If you don’t provide any additional information, Hibernate will request the next value from its default sequence. You can change that by referencing the name of a @SequenceGenerator in the generator attribute of the @GeneratedValue annotation. The @SequenceGenerator annotation lets you define the name of the generator, the name, and schema of the database sequence and the allocation size of the sequence.

GenerationType.TABLE

The GenerationType.TABLE gets only rarely used nowadays. It simulates a sequence by storing and updating its current value in a database table which requires the use of pessimistic locks which put all transactions into a sequential order. This slows down your application, and you should, therefore, prefer the GenerationType.SEQUENCE, if your database supports sequences, which most popular databases do.

You can use the @TableGenerator annotation in a similar way as the already explained @SequenceGenerator annotation to specify the database table which Hibernate shall use to simulate the sequence.

Summary:

As you’ve seen, JPA offers 4 different ways to generate primary key values:

1.      AUTO: Hibernate selects the generation strategy based on the used dialect,

2.      IDENTITY: Hibernate relies on an auto-incremented database column to generate the primary key,

3.      SEQUENCE: Hibernate requests the primary key value from a database sequence,

4.      TABLE: Hibernate uses a database table to simulate a sequence.

I prefer to use the GenerationType.SEQUENCE because it is very efficient and allows Hibernate to decide when to perform the insert statement. This provides the required flexibility to use other performance optimization techniques like JDBC batching.

Related Questions

Navigate

• Browse (All)
• Browse I
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.