Konfigurieren Sie JPA, damit PostgreSQL den Primärschlüsselwert generiert

Also unser Projekt verwenden Sie die PostgreSQL-Datenbank, und wir verwenden JPA zur Bedienung der Datenbank.
Wir haben die Entitäten aus der Datenbank mit automatischer Schöpfer in Netbeans 7.1.2.

Nach kleinen änderungen unsere Primärschlüssel-Werte werden wie folgt beschrieben:

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Basic(optional = false)
@NotNull
@Column(name = "idwebuser", nullable = false)
private Integer idwebuser;

Das problem ist, dass jetzt die Anwendung nicht flexibel, denn wenn wir ändern Sie die Datenbank direkt mit SQL oder einem anderen tool) statt, der durch das Java-app - der Generierte Wert ist niedriger als die tatsächlichen Datenbank-ID-Wert - und so hat man Fehler bei der Erstellung neuer Entitäten.

Gibt es eine Möglichkeit, dass der PPV konnte nur lassen Sie die Datenbank generiert die ID automatisch zu, und dann erhalten Sie es nach dem Prozess?
Oder was wäre eine bessere Lösung?
Danke.

BEARBEITEN
Genauer gesagt:
Wir haben eine Tabelle der Benutzer und mein problem ist, dass mit jeder Art von Strategie generationtype, der PPV ist das einfügen einer neuen Entität mit einer bestimmten durch den generator id. Das ist für mich falsch, denn wenn ich änderungen an der Tabelle auf meine eigene, neue Einträge hinzufügen, die GeneratedValue für die Anwendung ist niedriger als die aktuelle ID - was führt uns zu der Ausnahme mit dupliziert-ID.
Können wir es beheben ;)?

einen kurzen Hinweis auf die Antwort
Es war eine kleine Lüge von meiner Seite, da haben wir einen PG-Admin -> Ansicht den ersten 100 Zeilen und Zeilen bearbeitet von dort statt mit select. SOWIESO, es stellt sich heraus, dass dieser editor irgendwie überspringt der Prozess der Aktualisierung der ID und so auch in der DB, wenn wir schreiben eine ordnungsgemäße FÜGEN Sie es AUSGEFÜHRT wird, mit falschen ID! So war es im Grunde mehr ein problem des Editors, die wir verwendet als die Datenbank und die Anwendung...

nun funktioniert es sogar mit @GeneratedValue(strategy=GenerationType.IDENTITY)

Kommentar zu dem Problem

Bedeutet dies, dass die JPA ist nicht mit dem PostgreSQL-Sequenz? Was ist die definition der Spalte in der Tabelle? Ist, dass ein serial oder einfach nur ein `integer Kommentarautor: a_horse_with_no_name

Wir sind mit serial-Feld geben. Ich beschreibe das problem mehr in der wichtigsten Frage, @a_horse_with_no_name Kommentarautor: Atais

Also es bedeutet, JPA ist nicht mit der entsprechenden Sequenz? Das ist seltsam. Kommentarautor: a_horse_with_no_name

Auch bei tests, haben wir jetzt über 17 Zeilen, und wir verwenden:

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

Und wir haben gerade einen Fehler

Exception [EclipseLink-4002] (Eclipse Persistence Services - 2.2.0.v20110202-r8913): org.eclipse.die Persistenz.Ausnahmen.DatabaseException Internal Exception: org.postgresql.util.PSQLException: FEHLER: doppelter Schlüsselwert verletzt unique-constraint "webuser_idwebuser_pk" Detail: Schlüssel (idwebuser)=(14) existiert bereits.

zu, So scheint es, etwas ist immer noch falsch. Kommentarautor: Atais

Es ist ein Kampf in der Folge Verwendung. Offenbar nicht alle inserts sind mit der gleichen Strategie, wie Sie zum generieren der PK. Kommentarautor: a_horse_with_no_name

InformationsquelleAutor der Frage Atais | 2012-08-06

66

Gegeben, die definition der Tabelle:
```
CREATE TABLE webuser(
    idwebuser SERIAL PRIMARY KEY,
    ...
)
```
Nutzung der mapping:
```
@Entity
@Table(name="webuser")
class Webuser {

    @Id
    @SequenceGenerator(name="webuser_idwebuser_seq",
                       sequenceName="webuser_idwebuser_seq",
                       allocationSize=1)
    @GeneratedValue(strategy = GenerationType.SEQUENCE,
                    generator="webuser_idwebuser_seq")
    @Column(name = "idwebuser", updatable=false)
    private Integer id;

    //....

}
```
Die Benennung tablename_columname_seq ist die PostgreSQL-Standard-Sequenz Namensgebung für SERIAL und ich empfehle, dass Sie bleiben.

Den allocationSize=1 ist wichtig, wenn Sie brauchen, Hibernate, um die Zusammenarbeit mit anderen clients an die Datenbank.

Beachten Sie, dass diese Sequenz haben "Lücken", wenn Transaktionen zurückgesetzt werden. Transaktionen können ein Rollback für alle Arten von Gründen. Ihre Bewerbung sollte so gestaltet werden, um damit umzugehen.
- Nie davon ausgehen, dass für jede id n es ist eine id, die n-1 oder n+1
- Nie davon ausgehen, dass die id n Hinzugefügt wurde oder begangen, bevor eine id weniger als n oder nach einer id größer als n. Wenn Sie wirklich vorsichtig sein mit, wie Sie Folgen, die Sie dies tun können, aber Sie sollten nie versuchen; - Datensatz einen timestamp in der Tabelle statt.
- Nie hinzufügen oder abziehen einer ID. Vergleichen Sie für die Gleichstellung und sonst nichts.
Sehen die PostgreSQL-Dokumentation für Sequenzen und die serielle Daten-Typen.

Erklären Sie, dass die definition der Tabelle oben ist im Grunde eine Abkürzung für:
```
CREATE SEQUENCE idwebuser_id_seq;
CREATE TABLE webuser(
    idwebuser integer primary key default nextval('idwebuser_id_seq'),
    ...
)
ALTER SEQUENCE idwebuser_id_seq OWNED BY webuser.idwebuser;
```
... das sollte helfen, erklären, warum wir Hinzugefügt haben, eine @SequenceGenerator annotation zu beschreiben, die Abfolge.

Wenn Sie wirklich müssen haben eine Lücke-weniger-Sequenz (zum Beispiel Scheck oder Rechnung Nummerierung) siehe lückenlose Sequenzen aber im ernst, vermeiden Sie diese design und nie Verwendung für einen Primärschlüssel.

Hinweis: Wenn Ihre Tabelle-definition sieht wie folgt statt:
```
CREATE TABLE webuser(
    idwebuser integer primary key,
    ...
)
```
und du bist einsetzen in es mit die (unsicher, nicht verwenden):
```
INSERT INTO webuser(idwebuser, ...) VALUES ( 
    (SELECT max(idwebuser) FROM webuser)+1, ...
);
```
oder (unsicher ist, wird dies nie tun):
```
INSERT INTO webuser(idwebuser, ...) VALUES ( 
    (SELECT count(idwebuser) FROM webuser), ...
);
```
dann du machst es falsch und wechseln sollten, um eine Sequenz (wie oben gezeigt) oder zu einem richtige lückenlose Sequenz-Implementierung mit einem gesperrten Zähler-Tabelle (wieder, siehe oben unter "die lückenlose Abfolge postgresql" in Google). Beide oben das falsche tun, wenn es jemals mehr als eine Verbindung auf die Datenbank.

InformationsquelleAutor der Antwort Craig Ringer
1

Bitte, versuchen, Sie zu nutzen GenerationType.TABLE statt GenerationType.IDENTITY. Datenbank erstellen Sie separate Tabelle, die verwendet werden zum generieren von eindeutigen Primärschlüsseln, es wird auch zum speichern von zuletzt verwendeten id-Nummer.

InformationsquelleAutor der Antwort Leszek
1

Es scheint, Sie haben die Verwendung der Sequenz-generator wie:
```
@GeneratedValue(generator="YOUR_SEQ",strategy=GenerationType.SEQUENCE)
```
InformationsquelleAutor der Antwort Denis Zevakhin

Können Sie auch sparen Sie sich einige Mühe, durch das schreiben eines Skripts, führen Sie eine Massen-Konvertierung des generischen GenerationType.IDENTITY zu der vorgeschlagenen Lösung durch die ausgewählte Antwort. Die unten Drehbuch hat einige leichte Abhängigkeiten auf, wie die Java-Quellcode-Datei ist formatiert und wird änderungen vornehmen, ohne sicherungen. Caveat emptor!

Nachdem das script ausgeführt wurde:

Suchen und ersetzen import javax.persistence.Table; mit
import javax.persistence.Table; import javax.persistence.SequenceGenerator;.
Formatieren Sie den Quellcode in NetBeans wie folgt:
1. Wählen Sie alle Quell-Dateien zu formatieren.
2. Drücken Sie Alt+Umschalt+F
3. Bestätigen Sie die Neuformatierung durchführen.

Speichern Sie das folgende Skript als update-sequences.sh oder ähnliches:

#!/bin/bash

# Change this to the directory name (package name) where the entities reside.
PACKAGE=com/domain/project/entities

# Change this to the path where the Java source files are located.
cd src/main/java

for i in $(find $PACKAGE/*.java -type f); do
  # Only process classes that have an IDENTITY sequence.
  if grep "GenerationType.IDENTITY" $i > /dev/null; then
    # Extract the table name line.
    LINE_TABLE_NAME=$(grep -m 1 @Table $i | awk '{print $4;}')
    # Trim the quotes (if present).
    TABLE_NAME=${LINE_TABLE_NAME//\"}
    # Trim the comma (if present).
    TABLE_NAME=${TABLE_NAME//,}

    # Extract the column name line.
    LINE_COLUMN_NAME=$(grep -m 1 -C1 -A3 @Id $i | tail -1)
    COLUMN_NAME=$(echo $LINE_COLUMN_NAME | awk '{print $4;}')
    COLUMN_NAME=${COLUMN_NAME//\"}
    COLUMN_NAME=${COLUMN_NAME//,}

    # PostgreSQL sequence name.
    SEQUENCE_NAME="${TABLE_NAME}_${COLUMN_NAME}_seq"

    LINE_SEQ_GENERATOR="@SequenceGenerator( name = \"$SEQUENCE_NAME\", sequenceName = \"$SEQUENCE_NAME\", allocationSize = 1 )"
    LINE_GENERATED_VAL="@GeneratedValue( strategy = GenerationType.SEQUENCE, generator = \"$SEQUENCE_NAME\" )"
    LINE_COLUMN="@Column( name = \"$COLUMN_NAME\", updatable = false )\n"

    # These will depend on source code formatting.
    DELIM_BEGIN="@GeneratedValue( strategy = GenerationType.IDENTITY )"
    # @Basic( optional = false ) is also replaced.
    DELIM_ENDED="@Column( name = \"$COLUMN_NAME\" )"

    # Replace these lines...
    #
    # $DELIM_BEGIN
    # $DELIM_ENDED
    #
    # With these lines...
    #
    # $LINE_SEQ_GENERATOR
    # $LINE_GENERATED_VAL
    # $LINE_COLUMN

    sed -i -n "/$DELIM_BEGIN/{:a;N;/$DELIM_ENDED/!ba;N;s/.*\n/$LINE_SEQ_GENERATOR\n$LINE_GENERATED_VAL\n$LINE_COLUMN/};p" $i
  else
    echo "Skipping $i ..."
  fi
done

Beim generieren des CRUD-Anwendung mit NetBeans, die ID-Attribute nicht editierbare Eingabefelder.

InformationsquelleAutor der Antwort Dave Jarvis

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.