Hibernate import.sql与PostgreSQL重复主键

Question

I am using Hibernate with PostgreSQL. I have an import.sql file that Hibernate executes after the schema is created/validated. The content is imported accordingly, but when I try to persist new entries through my application, Hibernate tries to use automatically generated primary keys starting from 1, which were already used by my import file. Is there way to fix this?

I have a single entity class that all other entities inherit from, which uses either GenerationType.AUTO or GenerationType.IDENTITY . Both of them did not work:

@MappedSuperclass
public class Entidade implements Serializable {
    private static final long serialVersionUID = -991512134416936719L;

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;

    public Entidade() {
    }

    public Entidade(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

}

And here is my persistence.xml file:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1"
    xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
    <persistence-unit name="...">
        <jta-data-source>...</jta-data-source>
        <class>...</class>
        <properties>
            <property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect" />
            <property name="hibernate.hbm2ddl.auto" value="create-drop" />
            <property name="hibernate.default_schema" value="jcat" />
            <property name="hibernate.hbm2ddl.import_files_sql_extractor"
                value="org.hibernate.tool.hbm2ddl.MultipleLinesSqlCommandExtractor" />
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.hbm2ddl.import_files" value="import.sql" />
            <property name="hibernate.c3p0.min_size" value="5" />
            <property name="hibernate.c3p0.max_size" value="20" />
            <property name="hibernate.c3p0.max_statements" value="50" />
            <property name="hibernate.c3p0.timeout" value="3000" />
            <property name="hibernate.c3p0.idle_test_period" value="1800" />
        </properties>
    </persistence-unit>
</persistence>

Answer 1

Probably, Hibernate uses a global database-wide sequence called hibernate_sequence . You can import it form an other database too. You can add to your script an insert statement for a large id value in hibernate_sequence .

Please, see in the SQL log does Hibernate use hibernate_sequence ?

Update
Some additional notes by @DouglasDeRizzoMeneghetti

I did as you said and it worked. The FKs became integers, which are nullable, and now I have only one sequence in the database, instead of one for each ID. I found out that even join tables had their own sequences created, so by using a single sequence, everything got cleaner and more organized.

Answer 2

It turns out PostgreSQL has a "serial" data type for its columns, which is basically an integer data type associated with a sequence. the sequence is automatically created and handled by the DBMS. In order to force Hibernate to create such a column type, one uses the @Column(columnDefinition = "serial") annotation, like so:

@Id
@Column(columnDefinition = "serial")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;

Note that, while a sequence is being used to generate IDs, I didn't use strategy = GenerationType.SEQUENCE , because that would tell Hibernate to create is own hibernate_sequence and use it across all tables, a behavior I tried to avoid. The name of the generated sequence follows the pattern ${tablename}_${column_id_name}_seq , like 'client_id_seq'. I could then omit in my import script the hard-coded insertion of IDs, so:

insert into schema.table (id, name) values (1, 'John');

became:

insert into schema.table (name) values ('John');

and, when persisting entities in my webapp, Hibernate automatically uses the correct sequence for each table, so I did not have any more problems regarding repeated values.

As another contribution, if you have a @MappedSuperclass that uses the aforementioned annotation in its ID column, all subclasses automatically create their own sequences, so it's not necessary to do it for every single entity. The only down side I saw is that, while I had an annotation that worked under MariaDB but not PostgreSQL, now I have an annotation that would not work on MariaDB, since I don't recall it having the serial data type that @Column(columnDefinition = "serial") forces. So much for abstraction and detachment from the database.

EDIT: This strategy raised another problem. The fact that my PKs were of serial type made Hibernate create their corresponding FKs as serial. Since the serial type can't be nullablein PostgreSQL, I couldn't have optional relations between my entities. I ended up using the solution proposed by @v.ladynev, using GenerationType.SEQUENCE in my entities IDs and setting a high starting value for hibernate_sequence , after inserting my test data

This way, the FKs became integers, which are nullable, and now I have only one sequence in the database, instead of one for each ID. I found out that even join tables had their own sequences created, so by using a single sequence, everything got cleaner and more organized. Thank you.

Answer 3

data type of your id column in postgres should be serial

than use this annotation

@Id @GeneratedValue(strategy=GenerationType.IDENTITY)