Keywords (Tags) speichern

Java-Forum Java-Grundlagen
1

Hi, ich schon wieder!

Kurze (und evtl simple Frage), ich will Keywords (tags) zu einem bestimmten Eintrag (wahrscheinlich, weil steht noch nicht fest)
in eine H2-DB speichern (jmd. eine besser Empfehlung für integr. DB?)

Jetzt habe ich hier verschiedene Ideen, wie ich das gestalte, weiß aber nicht, was so optimal ist:

  1. Keywords einfach mit einem Separator in einen String und mit dem o.g. Eintrag in einer Tabelle ablegen
    Vorteil: einfach + schnell
    Nachteil: redundant (bei mehreren Einträgen), Suche nach Einträgen mit bestimmten Tag umständlich(?)

  2. Keywords in eine Liste packen
    Vorteil: einfach + schnell
    Nachteil: Weiß ich noch nicht

Im Grunde einfaches Einfügen in eine Tabelle „keywords“ (o.ä.), auto-inkrement, INSERT IF NOT EXIST,
Foreign Key(s) ermitteln und im Eintrag ablegen (variable Spalten 1…N möglich?)

  1. Eigene Klasse pro Keyword
    Vorteil: Erm… eventuell für ORM leichter? Fremdschlüsselermittlung einfacher?
    Nachteil: umständlich, wahrscheinlich eher unnötig

Was nehme ich denn davon?
2) sieht doch irgendwie am Besten aus bisher

Die Frage ist bestimmt simpel, trotzdem fühle ich mich „sicherer“ wenn ich einfach mal Nachfrage.

Danke
BL

2

[quote=BinaryLogic]3) Eigene Klasse pro Keyword
Vorteil: Erm… eventuell für ORM leichter? Fremdschlüsselermittlung einfacher?
Nachteil: umständlich, wahrscheinlich eher unnötig[/quote]
heißt eigene Klasse auch eigene DB-Tabelle? das scheint ja etwas Overkill,
aber noch ist auch nicht gesagt wieviele verschiedene Keywords geplant/ möglich neu hinzukommend,

eine Tabelle/ Klasse (=Enum?) mit EINTRÄGEN an verschiedenen Tags ist eine annehmbare Variante,
die ich bei dir noch nicht herauslese,

dazu eine Verbindungstabelle für die m:n-Verknüpfung zwischen Objekten und Tags, darin dann Fremdschlüsselcheck normal möglich,

wenn ein Objekt nur begrenzte Zahl Tags haben kann dann reichen evtl. auch n Spalten direkt in der Objekt-Tabelle,
bei vielen Objekten/ Objekttabellen wiederum kann man sich das sparen wollen (mehrfach n Spalten),
nur die Verbindungstabelle, mit global eindeutiger Id oder noch Spalte für Objekttyp

H2-DB klingt nach normalen SQL, wie kommen da Listen ins Spiel? Listen in Java, Umsetzung dem Framework überlassen?

ein simpel abgelegter String in der DB ins Programm importiert kann man aber zur Liste machen,
wenn man es erst im Programm sucht, dann ausreichend

3

Ich hab mich in einer ähnlichen Situation nach einigem Hin und Her für eine extra Tabelle entschieden. Es ist der “datenbankigere” Weg.

4

[QUOTE=SlaterB]heißt eigene Klasse auch eigene DB-Tabelle? das scheint ja etwas Overkill,
aber noch ist auch nicht gesagt wieviele verschiedene Keywords geplant/ möglich neu hinzukommend,
[/QUOTE]
Das weiß ich leider auch nicht. Letztlich liegt es am Nutzer, da er zu seinem Content (Einträge) - wie hier im Forum quasi
eigene Tags anfügt, welche ihn somit die Einträge schneller finden lassen bzw. er sie somit auch kategorisch einordnen kann.

eine Tabelle/ Klasse (=Enum?) mit EINTRÄGEN an verschiedenen Tags ist eine annehmbare Variante,
die ich bei dir noch nicht herauslese,

dazu eine Verbindungstabelle für die m:n-Verknüpfung zwischen Objekten und Tags, darin dann Fremdschlüsselcheck normal möglich,

Weiß nicht so ganz, wie du das meinst. Kommt der Variante nahe, wo ich die Keywords in einer eigenen Tabelle halte.
Die ‚Content‘-Einträge nehmen mit der Zeit der Nutzung des Programms zu und eventuell nehmen auch die Keywords zu
(entscheided schließl. der Nutzer).

wenn ein Objekt nur begrenzte Zahl Tags haben kann dann reichen evtl. auch n Spalten direkt in der Objekt-Tabelle,
bei vielen Objekten/ Objekttabellen wiederum kann man sich das sparen wollen (mehrfach n Spalten),
nur die Verbindungstabelle, mit global eindeutiger Id oder noch Spalte für Objekttyp

Wie gesagt eigntl. will ich das dem Nutzer überlassen. Im Grunde ist da das Problem, wenn ich N setze ich das für einige
Nutzer zu niedrig ansetzen könnte. Andererseits ist ein zu großen N dann eher suboptimal (was Speicher angeht), wenn
ein Nutzer dieses nicht nutzt und dann N-M (M ziemlich klein) Tags nicht belegt wären.

H2-DB klingt nach normalen SQL, wie kommen da Listen ins Spiel? Listen in Java, Umsetzung dem Framework überlassen?

Im Grunde ja. Die Klasse (nennen wir sie) „Eintrag“ hat also eine „List“ , welche dann optimalerweise vom ORM
mit geeigneten Annotations in eine Tabelle KEYWORDS ausgelagert wird.

Im Grunde stelle ich mir das so vor:
Einträge haben Tags (in einer der o.g. Form). ORM-Lib erzeugt Tabelle für Einträge und Tabelle für Keywords. Tabelle mit Einträgen
hat FK für Keyword-Tabelle.
Ich erhoffe mir dadurch eine effiziente Selektion der Einträge nach Keywords.

ein simpel abgelegter String in der DB ins Programm importiert kann man aber zur Liste machen,
wenn man es erst im Programm sucht, dann ausreichend

Ja, eventuell muss ich noch einmal ganz genau überdenken, welche Möglichkeiten ich da in Erwägung ziehe.
Direkt Daten über die DB zu selektieren erscheint mir halt am Effizientesten.
Im Programm kann man aber ein String mit einheitlichen Trennzeichen zwischen den Keywords sehr einfach
in ein Array (bzw. Liste) überführen.

Ja, ich denke auch, dass es am Effizientesten ist und Redundanzen verhindert. Eventuell muss ich die SQL-Anweisungen auch fest reinhacken
und auf das ORM verzichten. Ich meine auch mal gehört zu haben, dass mit ORM Änderungen eher ein schwieriges Thema sind.

Danke schon einmal für die Anregungen
BL

5

IMHO kommt es darauf an wie du die Keywords verwenden willst.
Willst du die Liste der KW auseinander droeseln und einzeln verarbeiten, als Beziehung usw. auswerten?
Dann eigene Tabelle mit verknuepfungstabelle.

Wenn die Tags allerdings nicht wirlich ausgewertet wefrden im Sinnne von ein eigenes Obejkt, dann reicht der String

6

Die Keywords will ich wie folgt verwenden:

  • schnelles auffinden von Einträgen, die mit diesem Keyword versehen sind
  • evtl. eine Liste der meistverwendeten Keywords
  • evtl. Beziehungen zwischen Keywords herausfiltern (Bsp.: Wenn Einträge mit “Koffein” getaggt sind, dann meist auch mit dem Tag “Koffeinschock” ;))

Btw.: Wird die DB dann embedded im Programm stecken. (ohne dass der Anwender groß was eigenes installieren muss => aber es steht
ihm offen)

Macht es eigentlich ‘Sinn’, sich so den Kopf darüber zu zerbrechen?
Im Grunde könnte ich die Klasse doch so gestalten, dass sie einfach im Programm gut einsetzbar ist und funktioniert (über Interface gut ansprechbar) und eine andere Klasse erstellen, die das ganze DB-freundlich ummodelt. Oder ist das eher ineffizient? Das Lesen soll ja relativ schnell von statten gehen (d.h. Selektion) das Speichern muss der Nutzer gar nicht mitbekommen (kann in einem Hintergrundthread laufen).

Edit:
Ich habe btw. was gefunden. Ich würde ja auf HSQLDB (habe gesehen, dass H2 wohl ein alter Name ist) und ORMLight setzen und bei letzterem würde so etwas gehen:
ORMLite Documentation: 2. How to Use

Meint ihr das könnte man dann also als Liste umsetzen?

7

IMHO kommt es darauf an, wie du diese Tags wiederverwenden willst und wie viele verschiedene es sein können / werden. Bei vielen verschiedenen Tags, nach denen du Suchen möchtest (vielleicht sogar mit Wildcards) macht es schon Sinn diese in eine extra Tabelle zu stecken und mit Fremdschlüsselbeziehungen zu arbeiten. Dann ein Index auf die Keywords, sodass ein Suchen danach recht zügig geht. Nachteilig ist, dass du vermutlich eine m:n Beziehung haben wirst und somit eine weitere Tabelle, welche die Zuordnung vornimmt … diese kann dann schon recht lang werden, aber in der Regel ist das kein Problem, wenn du nicht gerade Milliarden an Datensätzen speicherst.
Der Vorteil wäre auch, dass du dem User bereits verwendete Keywords vorblenden könntest, wenn sie den ersten Buchstaben eintippen.

Benötigst du das ganze nicht, dann empfehle ich dir ein “;” - separierten String … das ist vermutlich einfacher zu implementieren.

[QUOTE=BinaryLogic]Eventuell muss ich die SQL-Anweisungen auch fest reinhacken
und auf das ORM verzichten. Ich meine auch mal gehört zu haben, dass mit ORM Änderungen eher ein schwieriges Thema sind.[/QUOTE]

Ich vermute du spielst hier auf das Thema Caching an … In Multithreading Umgebungen ist das tatsächlich ein Problem, wenn man damit falsch umgeht … dann updatet Thread A einen Datensatz aber Thread B liest die alten Daten aus dem Cache. In SingleThread Umgebungen ist das in der Regel kein Problem und im anderen Falle könnte man vielleicht myBatis nehmen … soweit ich weiß ist im Standardfall kein Cache aktiv.

8

Genau so, habe ich mir das jetzt gedacht! Da muss ich mir wohl mit einer Hilfstabelle behelfen, wie du schon sagst, aber wie setze ich das dann in Java um? Zumindest bei ORMLight (Was ich zumindest aktuell verwende), fällt mir da nichts ein, wie ich das dem sagen könnte.
Ich zeige mal kurz wie ich das bisher habe (wobei ich es aus Gewissensgründen noch nicht in mein Repo gecheckt habe):

Report.java

[spoiler]

import com.j256.ormlite.field.DataType;
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.field.ForeignCollectionField;
import com.j256.ormlite.table.DatabaseTable;

import java.util.ArrayList;
import java.util.Collection;

@DatabaseTable(tableName = "REPORT")
public class Report implements IReport {

    private static final long serialVersionUID = 3329580979489979731L;

    @DatabaseField(columnName = "USER", foreign = true)
    private User user;
    @DatabaseField(columnName = "ID", generatedId = true)
    private long id;
    @DatabaseField(columnName = "TITLE", dataType = DataType.STRING, unique = true, canBeNull = false)
    private String title;
    @DatabaseField(columnName = "CONTENT", dataType = DataType.STRING, canBeNull = false)
    private String content;
    @ForeignCollectionField(eager = false, columnName = "KEYWORDS", foreignColumnName = "ID")
    private Collection<Keyword> keywords;
    @DatabaseField(columnName = "NOTE", dataType = DataType.STRING, canBeNull = true)
    private String note;

    protected Report() {
        keywords = new ArrayList<>();
    }

    public Report(User user, String title, String content, String note) {
        keywords = new ArrayList<>();
        setUser(user);
        setTitle(title);
        setContent(content);
        setNote(note);
    }

    @Override
    public void setTitle(String title) {
        this.title = title;
    }

    @Override
    public String getTitle() {
        return title;
    }

    @Override
    public void setUser(User user) {
        this.user = user;
    }

    @Override
    public User getUser() {
        return user;
    }

    @Override
    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String getContent() {
        return content;
    }

    @Override
    public void setNote(String note) {
        this.note = note;
    }

    @Override
    public void setKeywords(Collection<Keyword> keywords) {
        this.keywords = keywords;
    }

    @Override
    public Collection<Keyword> getKeywords() {
        return keywords;
    }

    @Override
    public void addKeyword(String keyword) {
        if(!keywords.contains(new Keyword(keyword))) {
            keywords.add(new Keyword(keyword));
        }
    }

    @Override
    public void deleteKeyword(String keyword) {
        keywords.remove(new Keyword(keyword));
    }

    @Override
    public String getNote() {
        return note;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Title: %50s
Keywords: ", title));
        for(Keyword keyword : getKeywords()) {
            builder.append(keyword.getKeyword() + ", ");
        }
        builder.deleteCharAt(builder.length()-1);
        builder.append(String.format("User: %s
Content:
%s",
                getUser().getUsername(), getContent()));
        return builder.toString();
    }
}
```[/spoiler]

Problem ist auch, dass die Annotation `@ForeignCollectionField` nicht so umgesetzt wird, wie ich das gerne hätte. Da muss ich nochmal reinlesen, was da genau gemacht wird. Ich hatte gehofft hier wird schon eine zweite Tabelle KEYWORDS für die Tags erstellt und in irgendeiner Referenzen in der REPORT-Tabelle generiert. Aber ja eine m:n wäre natürlich so auch nicht wirklich helfen. Achso die ArrayList wird auch noch ersetzt, so dass keine Tags doppelt vorkommen können.


> Ich vermute du spielst hier auf das Thema Caching an ... In Multithreading Umgebungen ist das tatsächlich ein Problem, wenn man damit falsch umgeht ... dann updatet Thread A einen Datensatz aber Thread B liest die alten Daten aus dem Cache. In SingleThread Umgebungen ist das in der Regel kein Problem und im anderen Falle könnte man vielleicht myBatis nehmen ... soweit ich weiß ist im Standardfall kein Cache aktiv.

Ah okay! myBatis schaue ich mir einfach mal genauer an. Ich denke Threads sollten sich aber eher weniger in die Quere kommen, da es zwar mit der Zeit eventuell viele Einträge geben kann, aber entweder ein Großteil davon wird selektiert, nur eine Teilmenge oder der User erhält ein bestimmten Eintrag als ganzes. Es wird sehr wahrscheinlich keine konkurrierenden Threads geben, weil sich nur etwas ändert, wenn der User etwas ändert. Wobei mir just einfällt, dass man evtl. schon aufpassen müsste, wenn im Hintergrund ein Backup gemacht wird, aber da könnte ich die Operationen des User erstmal in eine Queue o.ä. packen.

Danke schon einmal für die Antwort. Wie ich es machen werden würde wollen ;) weiß ich, allerdings muss ich mich mit der Umsetzung intensiver auseinandersetzen.

Grüße
BL
9

was ist denn KeyWord bei dir?
das sollte auch eine gemappte Klasse mit @DatabaseTable(tableName = "KEYWORD") dran sein,
dann müsste das Framework so arbeiten wie bei jeder anderen Collection ->Zwischentabelle?,
dazu schon allgemeine Beispiele gesehen und erfolgreich übernommen?

für Keyword bietet sich natürlich eine Enum an, in Hibernate gibt es komplizierte spezielle Strukturen um Enum in DB zu bringen,
aber wenn nicht dann halt (erstmal) nicht,
einfache Einträge, beliebig in DB ergänzbar, haben auch vieles für sich

10

Hi SlaterB,
genau, die Keywords sind bei mir auch eine gemappte Klasse:

[spoiler]```@DatabaseTable(tableName = „KEYWORDS“)
public class Keyword implements Serializable {

@DatabaseField(columnName = "ID", generatedId = true)
private long id;
@DatabaseField(columnName = "KEYWORD", dataType = DataType.STRING, canBeNull = false, unique = true)
private String keyword;

public Keyword() { }
public Keyword(String keyword) {
    this.keyword = keyword;
}

public void setKeyword(String keyword) {
    this.keyword = keyword;
}

public String getKeyword() {
    return keyword;
}

@Override
public String toString() {
    return keyword;
}

@Override
public boolean equals(Object other) {
    if(other != null && other instanceof Keyword) {
        return ((Keyword) other).getKeyword().equals(getKeyword());
    }
    return false;
}

}```[/spoiler]
Ist erstmal ganz simpel gehalten (wird aber auch nicht wirklich komplexer). Wie gesagt hatte ich mir das vom Framework auch erhofft, mit der Zwischentabelle,
Beispiele habe ich diesbzgl. zwar schon gesehen bei StackOverFlow, aber bei mir wollte es dann doch nicht so.

Hier die Exception die bisher fliegt:


java.sql.SQLException: Foreign collection class de.binarylogic.xyz.model.Keyword for field 'keywords' column-name does not contain a foreign field named 'ID' of class de.binarylogic.xyz.model.Report
	at com.j256.ormlite.field.FieldType.findForeignFieldType(FieldType.java:1020)
	at com.j256.ormlite.field.FieldType.configDaoInformation(FieldType.java:390)
	at com.j256.ormlite.dao.BaseDaoImpl.initialize(BaseDaoImpl.java:201)
	at com.j256.ormlite.dao.BaseDaoImpl.<init>(BaseDaoImpl.java:128)
	at com.j256.ormlite.dao.BaseDaoImpl.<init>(BaseDaoImpl.java:107)
	at com.j256.ormlite.dao.BaseDaoImpl$4.<init>(BaseDaoImpl.java:907)
	at com.j256.ormlite.dao.BaseDaoImpl.createDao(BaseDaoImpl.java:907)
	at com.j256.ormlite.dao.DaoManager.createDao(DaoManager.java:70)
	at de.binarylogic.xyz.EntryPoint.setupDatabase(EntryPoint.java:66)
	at de.binarylogic.xyz.EntryPoint.main(EntryPoint.java:44)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:483)
	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134)

Er erwartet also in der Tabelle KEYWORDS ein ID Attribut für einen Report? Wenn ich bei der Annotation @ForeignCollectionField das foreignColumnName = "ID" rausnehme, dann will er halt (irgendein?) Feld für einen Report-Eintrag haben. Aber das möchte ich eben nicht, dass in der Keyword-Tabelle selbst steht, zu welchen Reports sie gehört, das sollte schon über eine Hilfstabelle gehen. Aber da muss ich wie gesagt nochmal reinlesen, vielleicht habe ich was übersehen, auf jeden Fall gebe ich hier dem Framework wohl die falschen Kommandos.

@Enum:
Wieso eine Enum? Das will mir gerade nicht ganz einleuchten. Ich hielt Enums jetzt immer für eher ‚statische‘ Strukturen (vorsichtig gesagt), zumindest was die Enum Types angeht. Dem Benutzer soll wie gesagt überlassen bleiben wie viele (ok pro Eintrag wird es mit sehr hoher Wahrscheinlichkeit 50 nicht überschreiten) Keywords er an seinen gemachten Einrag ranhängt. Und den Rest bzgl. Keywords stelle ich mir so vor, wie freezly das geschildert hatte. (Filtern nach Keywords usw.)
Wäre nett, wenn du da näher drauf eingehen könntest.

Grüße
BL

Edit:
Gerade gelesen:

Remember that when you have a ForeignCollection field, the class in the collection must (in this example Order) must have a foreign field for the class that has the collection (in this example Account). If Account has a foreign collection of Orders, then Order must have an Account foreign field. It is required so ORMLite can find the orders that match a particular account.

ORMLite Documentation: 2. How to Use

ForeignCollection scheint hier also die falsche Wahl zu sein und ich muss mich nach einer Alternative umschauen, wenn es da bei ORMLight keine gibt, heißt es Framework-Wechsel.

11

ist das DB-Framework schon namentlich genannt?
na, ich will es mir auch mal lieber verkneifen dazu nachzuschlagen und Vorschäge zu machen,
wird ja wohl genug allgemeine Beispiele geben, oder andere geeigneter die es auch schon mal verwendet haben…

Notlösung wäre wohl immer, die Zwischentabelle selber anzulegen… und dann mit Id wie versucht zu mappen,
statt Keyword wären dann ReportKeywordEntry in der Collection, natürlich unschön

Enum ist allgemein eine saubere Sache wie sicher bekannt,
einfacheres Handling in Java (keine Probleme mit == vs equals),
einfache vollständige Vorschlagliste, kein manuell eingetipptes und dann vielleicht leicht abweichendes Keyword usw.,
beliebig viele Methoden zur einfachen Kategorisierung, leicht aufzurufen (keyword.isImportant() :wink: )

geht nur wenn vorher vollständig bekannt zu modellieren,
bei beliebiger Ergänzung/ Benutzereingabe natürlich nicht wie ich selber auch schon angedeutete,
wenn die Anforderungen dahin gehen dann Verwendung nicht möglich, muss man nicht weiter diskutieren

12

[QUOTE=SlaterB]ist das DB-Framework schon namentlich genannt?
na, ich will es mir auch mal lieber verkneifen dazu nachzuschlagen und Vorschäge zu machen,
wird ja wohl genug allgemeine Beispiele geben, oder andere geeigneter die es auch schon mal verwendet haben…

Notlösung wäre wohl immer, die Zwischentabelle selber anzulegen… und dann mit Id wie versucht zu mappen,
statt Keyword wären dann ReportKeywordEntry in der Collection, natürlich unschön
[/quote]
Habe gerade hier ein Beispiel auf GitHub gefunden, um eine eigene Zwischentabelle kommt man wohl nicht drumherum. Bei genauerem drüber Nachdenken, ist es aber vielleicht sogar sehr sinnvoll das auch im Code so umzusetzen (im Sinne der Normalisierung ist es das sowieso) So muss ich nicht über die Reports nach Keywords suchen (wobei das über die DB wahrscheinlich eh viel effizienter geht)
Wen es interessiert:
https://github.com/j256/ormlite-jdbc/tree/master/src/test/java/com/j256/ormlite/examples/manytomany

An sich möchte ich H2/HSQLDB im embedded Mode nutzen, aber dem Nutzer auch frei lassen, die Daten in einer MySQL zu halten. Der User sucht sich das aus.

Enum ist allgemein eine saubere Sache wie sicher bekannt,
einfacheres Handling in Java (keine Probleme mit == vs equals),
einfache vollständige Vorschlagliste, kein manuell eingetipptes und dann vielleicht leicht abweichendes Keyword usw.,
beliebig viele Methoden zur einfachen Kategorisierung, leicht aufzurufen (keyword.isImportant() :wink: )

Leider kann und will ich mich hier bzgl. der Keywords einschränken, bzw. den User einschränken, da später auch noch u.a.
Statistiken hinzukommen, welche für den Benutzer relevant sein sollen, nicht für mich :wink:
Die ganze Sache mit den Enums fällt also raus, auch wenn ich mich über eine einfachere Handhabung natürlich nicht beschweren würde.

Edit:
Wobei diese Hilfstabelle echt nicht schön ist, weil für jede Report-Keyword-Beziehung eine Instanz von ReportKeyword(-Entry) angelegt werden muss. Hoffe ich mal, dass das mit vielen Reports nicht irgendwann das System lahmlegt. Wobei eigntl. auch nur immer ein Report
vollständig geladen ist. Trotzdem frage ich mich… ach egal darum mache ich mir später Sorgen. Ich baue mir dafür jetzt erstmal ein TestProjekt zusammen. Das hantieren bei Statistiken etc. könnte auch umständlich werden, dann eventuell 'ne Fascade-Klasse rumbauen.

13

Okay, zu spät für Edit. Ich wollte sagen, dass ich es jetzt ähnlich des Beispiels umgebaut habe und es scheint zu funktionieren.
Wie die genauen Abfragen ablaufen, muss ich mir noch ansehen.

So sieht es jedenfalls jetzt aus, wenn ich in die Tabellen reingucke und es scheint soweit i.O. zu sein. Ich würde das Ganze jetzt so machen und
es hier als gelöst markieren. Soweit jmd. noch etwas einfällt, bin ich da natürlich für offen für neue Anregungen.
Vielen Danke, allen die mir Hinweise und Lösungsmöglichkeiten gegeben haben.
Sollte ich sonst Probleme mit dem ORM, H2 oder sonst etwas haben, werde ich dafür einen neuen Thread eröffnen.

Grüße
BL