Spécifiez manuellement la valeur d'une clé primaire dans la colonne JPA @GeneratedValue

si vous utilisez le séquençage de TABLE, alors EclipseLink vous permettra de surcharger la valeur (ou la séquence si votre base de données supporte ceci, MySQL ne le fait pas).

pour L'identité, Je ne suis même pas sûr que MySQL vous permettra de fournir votre propre identité, vous pourriez vouloir vérifier cela. En général, je ne recommanderais jamais L'utilisation de L'identité car elle ne supporte pas la préallocation.

il y a quelques problèmes à permettre à L'identité de fournir l'identité ou non. La première est que deux différents insert SQL devra être généré en fonction de la valeur id, car pour L'identité l'id ne peut pas être dans l'insert du tout. Vous souhaiterez peut-être enregistrer un bogue pour avoir des identifiants fournis par L'utilisateur du support D'identité.

vous devriez toujours être en mesure de le faire fonctionner avec votre propre sous-classe de séquence, ou peut-être sous-classe MySQLPlatform. Vous définiriez votre sous-classe MySQLPlatform en utilisant le " eclipselink.la cible de la base de données" unité de persistance de la propriété.

Cela fonctionne avec eclipselink. Il va créer une table séparée pour la séquence, mais cela ne devrait pas poser de problème.

@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="id", insertable=true, updatable=true, unique=true, nullable=false)
private Long id;

GenerationType.AUTO choisira la stratégie de génération idéale. Puisque le champ est spécifié comme insertable et actualisable, une stratégie de génération de TABLE sera utilisée. Cela signifie que eclipselink générera une autre table contenant la valeur de séquence courante et générera la séquence elle-même au lieu de la déléguer à la base de données. Puisque la colonne est déclaré insertable, si id est null en persistant, eclipselink générera l'id. Sinon, l'id sera utilisé.

solution axée sur la base de données à votre problème:

1. créer une colonne auxiliaire, nullable dans votre table. Il tiendra assignés manuellement id:

   CREATE TABLE `test_table`
   (
     `id` bigint(20) NOT NULL AUTO_INCREMENT,
     `manual_id` bigint(20) NULL,
     `some_other_field` varchar(200) NOT NULL,
     PRIMARY KEY(id)
   );
   

2. mappez cette colonne à un champ normal dans votre entité:

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   @Column(name="manual_id")
   private Integer manualId;
   

3. Créer un déclencheur qui met à table id pour le manuel d'identification attribué s'il n'est pas null:

   DELIMITER //
   CREATE TRIGGER `test_table_bi` BEFORE INSERT ON `test_table`
     FOR EACH ROW 
     BEGIN
       IF NEW.`manual_id` IS NOT NULL THEN 
         SET NEW.`id` = NEW.`manual_id`;
       END IF;
   END;//
   DELIMITER;    
   

4. Toujours utiliser le manualId lorsque vous avez besoin de attribuer un identifiant personnalisé. Le déclenchement de faire de la magie pour vous:

   testEntiy.setManualId(300);
   entityManager.persist(testEntity);
   

5. après la phase d'importation de la base de données, retirez simplement le déclencheur, la colonne auxiliaire et c'est mapping.

   DROP TRIGGER `test_table_bi`;
   ALTER TABLE `test_table` DROP COLUMN `manual_id`;
   

Avertissement

Si vous spécifiez manuellement un id supérieur à celui actuel AUTO_INCREMENT valeur, la prochaine généré id passera à la valeur de l'id assigné manuellement plus 1, par exemple:

INSERT INTO `test_table` (manual_id, some_other_field) VALUES (50, 'Something');
INSERT INTO `test_table` (manual_id, some_other_field) VALUES (NULL, 'Something else');
INSERT INTO `test_table` (manual_id, some_other_field) VALUES (90, 'Something 2');
INSERT INTO `test_table` (manual_id, some_other_field) VALUES (NULL, 'Something else 2');
INSERT INTO `test_table` (manual_id, some_other_field) VALUES (40, 'Something 3');
INSERT INTO `test_table` (manual_id, some_other_field) VALUES (NULL, 'Something else 3');

exercera les résultats:

+----+-----------+------------------+
| id | manual_id | some_other_field |
+----+-----------+------------------+
| 50 |        50 | Something        |
| 51 |      NULL | Something else   |
| 90 |        90 | Something 2      |
| 91 |      NULL | Something else 2 |
| 40 |        40 | Something 3      |
| 92 |      NULL | Something else 3 |
+----+-----------+------------------+

Pour éviter les problèmes, il est fortement recommandé de régler l' AUTO_INCREMENT colonne pour commencer avec un nombre supérieur à tous les ID existants dans votre base de données précédente, par exemple:

ALTER TABLE `test_table` AUTO_INCREMENT = 100000;

il se peut que je manque quelque chose d'évident, mais pourquoi ne pas simplement définir une autre entité avec le même @Table(name=".....") annotation, avec les mêmes champs, mais faire l'id NON généré? Ensuite, vous pouvez utiliser cette entité pour le code qui copie les données de L'ancienne base de données à la nouvelle, et celui avec L'Id généré peut être utilisé pour les créations normales qui nécessitent la génération d'id.

Je ne peux pas vous dire si cela fonctionne avec EclipseLink, mais nous utilisons hibernation ici et il ne semble pas à l'esprit.

en utilisant GenerationType.Séquence avec PostgreSQL et EclipseLink travaillé pour moi.

1)

@GeneratedValue(strategy = GenerationType.IDENTITY) 

par

@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="step_id_seq")
@SequenceGenerator(name="step_id_seq", sequenceName="step_id_seq")

Maintenant, vous pouvez appeler la séquence à l'aide de NativeQuery:

return ((Vector<Integer>) em.createNativeQuery("select nextval('step_id_seq')::int").getSingleResult()).get(0);

et définissez L'Id retourné à votre entité avant l'appel EntityManager.méthode de persist ().

j'Espère qu'il n'est pas trop tard!

rechercher le Générateur D'Id personnalisé

http://blog.anorakgirl.co.uk/2009/01/custom-hibernate-sequence-generator-for-id-field/

peut-être que cela pourrait aider.