The differences between GeneratedValue strategies

Check the latest doctrine documentation

Here is a summary : the list of possible generation strategies:

AUTO (default): Tells Doctrine to pick the strategy that is preferred by the used database platform. The preferred strategies are IDENTITY for MySQL, SQLite and MsSQL and SEQUENCE for Oracle and PostgreSQL. This strategy provides full portability.

SEQUENCE: Tells Doctrine to use a database sequence for ID generation. This strategy does currently not provide full portability. Sequences are supported by Oracle and PostgreSql and SQL Anywhere.

IDENTITY: Tells Doctrine to use special identity columns in the database that generate a value on insertion of a row. This strategy does currently not provide full portability and is supported by the following platforms:

• MySQL/SQLite/SQL Anywhere => AUTO_INCREMENT
• MSSQL => IDENTITY
• PostgreSQL => SERIAL

TABLE: Tells Doctrine to use a separate table for ID generation. This strategy provides full portability. This strategy is not yet implemented!

NONE: Tells Doctrine that the identifiers are assigned, and thus generated, by your code. The assignment must take place before a new entity is passed to EntityManager#persist. NONE is the same as leaving off the @GeneratedValue entirely.

SINCE VERSION 2.3 :

UUID: Tells Doctrine to use the built-in Universally Unique Identifier generator. This strategy provides full portability.

Ofcourse the accepted answer is correct, but it needs a minor update as follows:

According to Annotation section of the documentation:

This annotation is optional and only has meaning when used in conjunction with @Id. If this annotation is not specified with @Id the NONE strategy is used as default.

The strategy attribute is optional.

According to Basic Mapping section of the documentation:

SEQUENCE: Tells Doctrine to use a database sequence for ID generation. This strategy does currently not provide full portability. Sequences are supported by Oracle, PostgreSql and SQL Anywhere.

IDENTITY: Tells Doctrine to use special identity columns in the database that generate a value on insertion of a row. This strategy does currently not provide full portability and is supported by the following platforms:

• MySQL/SQLite/SQL Anywhere (AUTO_INCREMENT)
• MSSQL (IDENTITY)
• PostgreSQL (SERIAL).

Downvote

Regarding the downvote given by someone, it should be noted that SQL Anywhere has been added and the accepted answer needs a minor update.

From the perspective of a programmer, they all achieve the same result: that is to provide a UNIQUE value for the primary key field. Strictly speaking, there are two further conditions which are also met, namely: the key must also be mandatory and not null.

The only differences lie in the internal implementations which provide the primary key value. In addition, there are performance and database-compatibility factors which also need to be considered. Different databases support different strategies.

The easiest one to understand is SEQUENCE and this is generally also the one which yields the best performance advantage. Here, the database maintains an internal sequence whose nextval is accessed by an additional SQL call as illustrated below:

SELECT nextval ('hibernate_sequence')

The next value is allocated during insertion of each new row. Despite the additional SQL call, there is negligible performance impact. With SEQUENCE, it is possible to specify the initial value (default is 1) and also the allocation size (default=50) using the @SequenceGenerator annotation:

@SequenceGenerator(name="seq", initialValue=1, allocationSize=100)

The IDENTITY strategy relies on the database to generate the primary key by maintaining an additional column in the table whose next value is automatically generated whenever a new row is inserted. A separate identity generator is required for each type hierarchy.

The TABLE strategy relies on a separate table to store and update the sequence with each new row insertion. It uses pessimistic locks to maintain the sequence and as a result is the slowest strategy of all these options. It may be worth noting that an @TableGenerator annotation can be used to specify generator name, table name and schema for this strategy:

@TableGenerator(name="book_generator", table="id_generator", schema="bookstore")

With the UUID option, the persistence provider (eg Hibernate) generates a universally unique ID of the form: '8dd5f315-9788-4d00-87bb-10eed9eff566'. To select this option, simply apply the @GeneratedValue annotation above a field declaration whose data type is UUID; eg:

@Entity
public class UUIDDemo {

    @Id
    @GeneratedValue
    private UUID uuid;

    // ...
}

Finally, the AUTO strategy is the default and with this option, the persistence provider selects the optimal strategy for the database being used.