Hibernate Fragen


#1

Servus zusammen

ich habe ein paar hibernate fragen.

ich hab die 2 klassen gemacht


@Entity@Table(name = "EVENT")  
public class Event {
	
	private List<Person> personen;
	
	@ManyToMany(mappedBy = "events")
	public List<Person> getPersonen() {
		return personen;
	}
	public void setPersonen(List<Person> personen) {
		this.personen = personen;
	}



Entity@Table(name="PERSON")  
public class Person {

    private List<Event> events = new ArrayList<Event>();	
	@ManyToMany(cascade={CascadeType.PERSIST, CascadeType.MERGE})
	@JoinTable(
            name="PERSON_EVENT",
            joinColumns = @JoinColumn( name="person_id"),
            inverseJoinColumns = @JoinColumn( name="event_id"))
    @OrderBy("title desc")
    public List<Event> getEvents() {
		return events;
	}

	public void setEvents(List<Event> events) {
		this.events = events;
	}



  1. für was genau brauch ich das mappedBy???

  2. wenn ich in dem hibernate.cfg.xml,das hier einfüge…



<property name="hbm2ddl.auto">create</property>

sollte er doch mit die DB neu anlegen und die alten einträge raus machen oder???macht er nicht seit ich annotaion benutze, davor mit hbm.xml files hat das geklappt…

so meine dritte frage =)


    private void addEventToPerson(Long personId, Long eventId) {

        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        Person aPerson = (Person) session.load(Person.class, personId);
        Event anEvent = (Event) session.load(Event.class, eventId);
        anEvent.getPersonen().add(aPerson);
        session.getTransaction().commit();
       
        session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        Event event = (Event) session.load(Event.class, eventId);
        System.out.println(event.getPersonen().size());
    }


warum kommt hier 0 raus und nicht 1 ???


#2
  1. Das mappedby wird benötigt um eine bidirektionale Relation zwischen den beiden Tabellen herzustellen. Beispiel: Wenn A ne Beziehung zu B hat dann müsste man ja nen Foreign Key in A definieren (in Hibernate über JoinColumn):
    A------->B
    Hat jetzt B auch ne Beziehung zu A bräuchte man auch noch ne Foreign Key Definition bei B in Richtung A. Durch das mappedby wird die Beziehung in die andere Richtung also automatisch gemacht und man muss nicht nochmal das JoinColumn angeben. Weitere Vorteile fallen mir ansonsten nicht ein.

  2. Ich habe das gerade bei nem Projekt hier ausprobiert wo ich gerade dran arbeite. Scheisse er hat meine Datenbank gekillt -.- jetzt darf ich die erst wieder flott machen… kann das Problem also nicht reproduzieren. Das create wirkt sich aber auch nur aus, wenn die betroffenen Klassen im Code ausgeführt werden.

  3. Zuerst: müsste die Methode nicht addPersonToEvent heißen?
    Das Problem liegt vermutlich daran, dass ein session.update(anEvent) fehlt

Freundliche Grüße
Revenant


#3

ich hab die methode aus dem hibernate tutor raus und die einfach umgedreht hat mich am anfang auch gewundert und dachte die haben es falsch benannt…
aber ich dachte solange ich dass in einer transaktion mache benötige ich dass session.update nicht—> naja werd ich morgen mal versuchen ob es etwas bewirkt…

zu dem mappedBy nochmal das versteh ich wenn ich eine 1:n beziehung habe…
aber wenn ich eine n:m beziehung habe benötige ich doch eh eine join table oder? für was ist das mappedBy dann gut(bei einer m:n beziehung)???Was muss ich dann eigentlich in dem mappedBy genau angeben den tabellen namen??

ja das mit dem create klappt bei einfach nicht dass er mein schema neu aufbaut das wollte ich, aber es klappte nur mit hbm.xml files seit ich auch annotiations umgstiegen bin will es einfach nicht mehr klappen… ein drop und create hat auch nicht geklappt mhm versteh ich nicht…er wirft das schmea einfach nicht mehr weg ich wollte einfach nocheinmal ne leere db ohne daten weiß jemand noch ne möglichkeit dass wieder hinzubekommen…

EDIT:ach jetzt versteh ich nur noch bahnhof
wenn ich das hier ändere
@Entity@Table(name = “ALL_EVENTS”)
public class Event {

müsste ich doch mit
List result = session.createQuery(“from ALL_EVENTS”).list();

alle meine events bekommen ich bekomm aber ne fehlermeldung


Exception in thread "main" org.hibernate.hql.ast.QuerySyntaxException: ALL_EVENTS is not mapped [from ALL_EVENTS]
	at org.hibernate.hql.ast.util.SessionFactoryHelper.requireClassPersister(SessionFactoryHelper.java:181)
	at org.hibernate.hql.ast.tree.FromElementFactory.addFromElement(FromElementFactory.java:110)
	at org.hibernate.hql.ast.tree.FromClause.addFromElement(FromClause.java:93)
	at org.hibernate.hql.ast.HqlSqlWalker.createFromElement(HqlSqlWalker.java:277)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.fromElement(HqlSqlBaseWalker.java:3056)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.fromElementList(HqlSqlBaseWalker.java:2945)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.fromClause(HqlSqlBaseWalker.java:688)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.query(HqlSqlBaseWalker.java:544)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.selectStatement(HqlSqlBaseWalker.java:281)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.statement(HqlSqlBaseWalker.java:229)
	at org.hibernate.hql.ast.QueryTranslatorImpl.analyze(QueryTranslatorImpl.java:251)
	at org.hibernate.hql.ast.QueryTranslatorImpl.doCompile(QueryTranslatorImpl.java:183)
	at org.hibernate.hql.ast.QueryTranslatorImpl.compile(QueryTranslatorImpl.java:134)
	at org.hibernate.engine.query.HQLQueryPlan.<init>(HQLQueryPlan.java:101)
	at org.hibernate.engine.query.HQLQueryPlan.<init>(HQLQueryPlan.java:80)
	at org.hibernate.engine.query.QueryPlanCache.getHQLQueryPlan(QueryPlanCache.java:94)
	at org.hibernate.impl.AbstractSessionImpl.getHQLQueryPlan(AbstractSessionImpl.java:156)
	at org.hibernate.impl.AbstractSessionImpl.createQuery(AbstractSessionImpl.java:135)
	at org.hibernate.impl.SessionImpl.createQuery(SessionImpl.java:1650)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at org.hibernate.context.ThreadLocalSessionContext$TransactionProtectionWrapper.invoke(ThreadLocalSessionContext.java:342)
	at $Proxy11.createQuery(Unknown Source)
	at test.TestMain.list(TestMain.java:66)
	at test.TestMain.main(TestMain.java:21)

wenn ich alles so lasse und diese zeile so mache
List result = session.createQuery(“from Events”).list();
klappt es warum??? versteh ich nicht:confused::grr:

EDIT: ok durch bischen rumprobieren hab ich gemerkt er nennt meine tabelle so wie meine klasse aber für was ist dann das annotianon
@Table(name = “ALL_EVENTS”) da???
auf jeden fall danke für deine antworten… damit test ich morgen mal rum


#4

Für Hibernate Annotations habe ich mal einen Link angelegt:
http://forum.byte-welt.net/showthread.php?t=1680


#5

danke den hab ich auch, darum ist die ganze sache ja so komisch =(…
@javax.persistence.Table(
optional, ermöglicht, den Tabellennamen festzulegen, auf den die Klasse gemappt ist. Der Vorgabewert ist der Klassen- bzw. Entity-Name.
name = “tableName”,
Name der Datenbanktabelle

warum muss ich dann nicht from ALL_EVENTS machen???sondern from Events?? Ich verstehs halt nicht =(


#6

[QUOTE=SirWayne;6947]ich hab die methode aus dem hibernate tutor raus und die einfach umgedreht hat mich am anfang auch gewundert und dachte die haben es falsch benannt…
aber ich dachte solange ich dass in einer transaktion mache benötige ich dass session.update nicht—> naja werd ich morgen mal versuchen ob es etwas bewirkt…
[/QUOTE]
Doch klar das brauchst du schon, du musst Hibernate ja irgendwie mitteilen, was bei der Transaktion überhaupt gemacht werden soll. Es werden ja nicht einfach alle Objekte mit der Datenbank abgeglichen -> Overkill. Du musst also schon angeben, welches Objekt genau upgedatet werden soll.

[QUOTE=SirWayne;6947]
zu dem mappedBy nochmal das versteh ich wenn ich eine 1:n beziehung habe…
aber wenn ich eine n:m beziehung habe benötige ich doch eh eine join table oder? für was ist das mappedBy dann gut(bei einer m:n beziehung)???Was muss ich dann eigentlich in dem mappedBy genau angeben den tabellen namen??
[/QUOTE]

Bei n:m Beziehungen liegt ja der gleiche Sachverhalt vor. Es wird halt ne Zwischentabelle erzeugt, zu der beide Ursprungstabellen ne 1:n Beziehung unterhalten. Die Eigenschaften der neuen Tabelle werden halt über Annotations auf einer Seite festgelegt. Es gibt keine Notwendigkeit die Join Columns die diese neue Tabelle besitzt auf beiden Seiten anzugeben, da dies über das mappedBy automatisch geschieht.

[QUOTE=SirWayne;6947]
ja das mit dem create klappt bei einfach nicht dass er mein schema neu aufbaut das wollte ich, aber es klappte nur mit hbm.xml files seit ich auch annotiations umgstiegen bin will es einfach nicht mehr klappen… ein drop und create hat auch nicht geklappt mhm versteh ich nicht…er wirft das schmea einfach nicht mehr weg ich wollte einfach nocheinmal ne leere db ohne daten weiß jemand noch ne möglichkeit dass wieder hinzubekommen…
[/QUOTE]
Interessant wäre zu testen, ob es wieder funktioniert wenn du wieder die XML Files benutzt? Was normalerweise immer hilft is die Datenbank einfach zu cleanen, dann muss er ja alle Tabellen usw. neu anlegen.

[QUOTE=SirWayne;6947]
EDIT:ach jetzt versteh ich nur noch bahnhof
wenn ich das hier ändere
@Entity@Table(name = “ALL_EVENTS”)
public class Event {

müsste ich doch mit
List result = session.createQuery(“from ALL_EVENTS”).list();

alle meine events bekommen ich bekomm aber ne fehlermeldung


Exception in thread "main" org.hibernate.hql.ast.QuerySyntaxException: ALL_EVENTS is not mapped [from ALL_EVENTS]
	at org.hibernate.hql.ast.util.SessionFactoryHelper.requireClassPersister(SessionFactoryHelper.java:181)
	at org.hibernate.hql.ast.tree.FromElementFactory.addFromElement(FromElementFactory.java:110)
	at org.hibernate.hql.ast.tree.FromClause.addFromElement(FromClause.java:93)
	at org.hibernate.hql.ast.HqlSqlWalker.createFromElement(HqlSqlWalker.java:277)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.fromElement(HqlSqlBaseWalker.java:3056)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.fromElementList(HqlSqlBaseWalker.java:2945)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.fromClause(HqlSqlBaseWalker.java:688)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.query(HqlSqlBaseWalker.java:544)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.selectStatement(HqlSqlBaseWalker.java:281)
	at org.hibernate.hql.antlr.HqlSqlBaseWalker.statement(HqlSqlBaseWalker.java:229)
	at org.hibernate.hql.ast.QueryTranslatorImpl.analyze(QueryTranslatorImpl.java:251)
	at org.hibernate.hql.ast.QueryTranslatorImpl.doCompile(QueryTranslatorImpl.java:183)
	at org.hibernate.hql.ast.QueryTranslatorImpl.compile(QueryTranslatorImpl.java:134)
	at org.hibernate.engine.query.HQLQueryPlan.<init>(HQLQueryPlan.java:101)
	at org.hibernate.engine.query.HQLQueryPlan.<init>(HQLQueryPlan.java:80)
	at org.hibernate.engine.query.QueryPlanCache.getHQLQueryPlan(QueryPlanCache.java:94)
	at org.hibernate.impl.AbstractSessionImpl.getHQLQueryPlan(AbstractSessionImpl.java:156)
	at org.hibernate.impl.AbstractSessionImpl.createQuery(AbstractSessionImpl.java:135)
	at org.hibernate.impl.SessionImpl.createQuery(SessionImpl.java:1650)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at org.hibernate.context.ThreadLocalSessionContext$TransactionProtectionWrapper.invoke(ThreadLocalSessionContext.java:342)
	at $Proxy11.createQuery(Unknown Source)
	at test.TestMain.list(TestMain.java:66)
	at test.TestMain.main(TestMain.java:21)

wenn ich alles so lasse und diese zeile so mache
List result = session.createQuery(“from Events”).list();
klappt es warum??? versteh ich nicht:confused::grr:

EDIT: ok durch bischen rumprobieren hab ich gemerkt er nennt meine tabelle so wie meine klasse aber für was ist dann das annotianon
@Table(name = “ALL_EVENTS”) da???
auf jeden fall danke für deine antworten… damit test ich morgen mal rum[/QUOTE]
Also dein Query ist ja in dieser Hibernate SQL Variante da geschrieben. Ich könnte mir jetzt vorstellen, dass es einen Unterschied zwischen den Tabellennamen in Hibernate und den Tabellennamen in nativem SQL gibt. Bin da jetzt aber auch etwas überfragt. Hast du mal ohne Hibernate auf die DB geschaut wie die Tabellen da benannt sind?

Grüße
Rev


#7

Also schau mal zu dem seesion update hab ich dass hier in der hibernate tutorial gefunden

1.3.3. Working the association

Let’s bring some people and events together in a new method in EventManager:


private void addPersonToEvent(Long personId, Long eventId) {

    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    session.beginTransaction();

    Person aPerson = (Person) session.load(Person.class, personId);
    Event anEvent = (Event) session.load(Event.class, eventId);

    aPerson.getEvents().add(anEvent);

    session.getTransaction().commit();
}

After loading a Person and an Event, simply modify the collection using the normal collection methods. As you can see, there is no explicit call to update() or save(), Hibernate automatically detects that the collection has been modified and needs to be updated. This is called automatic dirty checking, and you can also try it by modifying the name or the date property of any of your objects. As long as they are in persistent state, that is, bound to a particular Hibernate Session (i.e. they have been just loaded or saved in a unit of work), Hibernate monitors any changes and executes SQL in a write-behind fashion. The process of synchronizing the memory state with the database, usually only at the end of a unit of work, is called flushing. In our code, the unit of work ends with a commit (or rollback) of the database transaction - as defined by the thread configuration option for the CurrentSessionContext class.

You might of course load person and event in different units of work. Or you modify an object outside of a Session, when it is not in persistent state (if it was persistent before, we call this state detached). You can even modify a collection when it is detached:


private void addPersonToEvent(Long personId, Long eventId) {

    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    session.beginTransaction();

    Person aPerson = (Person) session
            .createQuery("select p from Person p left join fetch p.events where p.id = :pid")
            .setParameter("pid", personId)
            .uniqueResult(); // Eager fetch the collection so we can use it detached

    Event anEvent = (Event) session.load(Event.class, eventId);

    session.getTransaction().commit();

    // End of first unit of work

    aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached

    // Begin second unit of work

    Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();
    session2.beginTransaction();

    session2.update(aPerson); // Reattachment of aPerson

    session2.getTransaction().commit();
}

The call to update makes a detached object persistent again, you could say it binds it to a new unit of work, so any modifications you made to it while detached can be saved to the database. This includes any modifications (additions/deletions) you made to a collection of that entity object.

laut dieser beschreibung bräuchte ich doch kein session.update…
Aber ich hab es mal mit versucht keine änderung


    private void addEventsToPerson(Long personId, Long EventsId) {

        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        Person aPerson = (Person) session.load(Person.class, personId);
        TestEvent anEvents = (TestEvent) session.load(TestEvent.class, EventsId);
        anEvents.getPersonen().add(aPerson);
        session.update(anEvents);
        session.getTransaction().commit();
        
        session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        TestEvent Events = (TestEvent) session.load(TestEvent.class, EventsId);
        System.out.println(Events.getPersonen().size());
    }

Kommt immer noch 0 raus…

  1. wie kann ich mir anschauen wie er die tabellen genannt hat??? um die db zu starten starte ich einfach das jar file wo man bei hibernate runterladen kann zum testen…
    http://www.hibernate.org/hib_docs/v3/reference/en/html/tutorial-firstapp.html

  2. Was genau muss man in dem mappedBy angeben


	@ManyToMany(mappedBy = "events")
	public List<Person> getPersonen() {
		return personen;
	}
	public void setPersonen(List<Person> personen) {
		this.personen = personen;
	}

wenn ich hier was anderes als “events” eingebe bekomm ich ein fehler… was muss man in dem mapped by angeben???

  1. ich glaub meine ManytoMany verbidnung hat eine macke

#8

okay was mit aufgefallen ist er nimmt anscheindend immer den Klassenamen als Tabellennamen d.h. session.createQuery(“Klassennamen”)…

wie holt ihr euch eine liste von euren objekten?


#9

So jetzt hab ich mir ein neues Beispiel gemacht und ich denke mein Problem ist auf ein verstädniss problem zurück zuführen vielleicht kann es mir einer mal mit seine worten erklären.

Klasse Book

@Table(name = "books")
public class Book {

	private int id;
	private String title;
	private List<Author> authors;

	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}

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

	public String getTitle() {
		return title;
	}

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

Klasse Author

package test;

import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name = "authors")
public class Author {

	private String name;
	private int id;
	private List<Book> book;

	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@ManyToMany(mappedBy = "authors", cascade = CascadeType.ALL)
	public List<Book> getBook() {
		return book;
	}

	public void setBook(List<Book> book) {
		this.book = book;
	}
	

}

Klasse hier die methode zum adden


	private void addAuthorToBook(int a, int b) {

		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		session.beginTransaction();

		Author author = (Author) session.load(Author.class, a);
		Book book = (Book) session.load(Book.class, b);
		
		book.getAuthors().add(author);
		System.out.println(book.getAuthors().size());
		session.getTransaction().commit();

	}
	
	private void addBookToAuthor(int a, int b) {

		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		session.beginTransaction();
		Author author = (Author) session.load(Author.class, a);
		Book book = (Book) session.load(Book.class, b);
		author.getBook().add(book);
		session.update(author);
		session.getTransaction().commit();
		
		
		session = HibernateUtil.getSessionFactory().getCurrentSession();
		session.beginTransaction();
		Author author1 = (Author) session.load(Author.class, a);
		System.out.println(author1.getBook().size());

	}

also addAuthorToBook funktionniert einwandfrei… aber addBookToAuthor hat keine auswirkung da stellt mir die frage warum??? warum kann ich dem author kein buch zuweisen aber andersherum ist kein problem…

  1. So hier noch eine kleine Frage für was ist das @Embedded da???Also ich weiß das hibernate jetzt eine Splate für das Objekt amazon anlegt. Das ist klar!!! Abre rein theoretisch ist das doch eine 1:1 zu Bez oder? für was ist dann eine undirektionale @OneToOne da???

public class Book {

	private Amazon amazon;

	@Embedded
	public Amazon getAmazon() {
		return amazon;
	}

	public void setAmazon(Amazon amazon) {
		this.amazon = amazon;
	}




#10

Also Hibernate benutzt in diesem Beispiel da ne HSQLDB (ehemals Hypersonic). Du kannst die DB wie gewohnt starten und dann mit nem SQL Client wie z.B. SQuirreL dich auf die DB connecten. Falls du sowas noch nie gemacht hast, mach es jetzt am Besten mal, is ne elementare Sache für nen Programmierer muss man können. Im SQuirrel musst du ganz einfach nen Treiber für die DB angeben (ist ein Jar File von HSQLDB) und dann nen Alias einrichten.
Falls du es nicht hin bekommst, sag einfach Bescheid, dann erklär ich’s dir hier Schritt für Schritt.

Zum ersten Problem: versuch mal in der addBookToAuthor Methode nach dem session.update() ein session.flush() aufzurufen, vllt wurde da doch was nicht persistiert. Very strange. Von der Logik her würde ich jetzt auch sagen, dass da ne 1 ausgegeben werden müsste aber ich arbeite auch noch nicht lange mit Hibernate.

Was mir ansonsten noch aufgefallen ist: bei der Klasse Book scheint das @Entity zu fehlen oder is das ein Copy Paste Fehler?

Aja und erm wenn du mit Annotationen arbeitest dann musst du auch das Hibernate Konfigurations File anpassen und in deiner HibernateUtil anstatt

new Configuration().configure()....

new AnnotationConfiguration().configure()....

verwenden.

Zur zweiten Frage: Das @Embedded fügt angeblich ne Spalte ein yo. Habs auch noch nie verwendet, aber ich würde mal sagen, dass bei nem Kompletten Objekt keine Beziehung angelegt wird, sondern einfach alle Spalten des Objektes in die Tabelle übernommen werden. Also wenn du den SQL Client eingerichtet hast kannst du das auch einfach überprüfen, der zeigt dir die Tabellen nämlich grafisch an. Ergebnisse bitte hier mitteilen :wink:

Grüßle


#11

ja rein prinzipiell wird keine neue Tabelle angelegt aber ein beziehung besteht trotzdem zumindest im Klassendiagramm …

kannst ja mal in deinen ManyToMany verbindungen schauen ob du beides bidirketional gleich einfügen kannst…

ja die config hab ich schon geändert sonst würde das mapping auch nicht klappen…

ja ich versuch das mit dem connecten mal …

wie werden den deine tabellen genannt?

EDIT. hab grad nachgelesen dass die tabellen wie bei den @table genannt werden dann kann mit createSQLQuery ganz normal darauf zugreifen… createQuery(HQL) mapped gleichzeitig die Objekte und deshablt muss der Klassenname angegeben werden …
Wie machst du mit hibernate abfragen von mehrern tabelle mit einer where klausel???
Also von einer Tabelle raus bekomm ich es hin
Criteria crit = session.createCriteria(Author.class);
crit.add(Restrictions.idEq(1));

aber wie geht sowas über mehrere??


#12

Hm was is jetzt deine konkrete Frage ^^.

Also ich hab noch nie ne Abfrage über mehrere Tabellen gemacht so a la native SQL Join. Aber ich glaube auch, dass der Ansatz an sich falsch wäre. Man will ja mit Objekten(!) arbeiten. Wenn also ein Join notwendig ist, dann wäre es vermutlich das Beste, das direkt so zu modellieren (gegenseitige Beziehungen und dann Zugriff über die Attribute oder so). Vererbung wäre in dem Zusammenhang sicherlich auch ne Alternative zu nem klassischen Join. Ich hab grade auch mal in der Hibernate Doku gesucht aber nichts dazu gefunden. Wenn dich gar keine meiner vorgeschlagenen Lösungen zufriedenstellt, kannst du natürlich auch ne Abfrage mit nativem SQL machen. Solange man sich in nem gewissen standardisierten Bereich bewegt sollte die Datenbankunabhängigkeit gewahrt bleiben. Ich rate jedoch davon ab^^
Ich finde es gut, dass du dich auch für die tieferen Zusammenhänge interessierst, da lernen wir hier alle noch was :wink:


#13

Konkrete Frage war keine sagen wir eher wollte wissen wie deine Erfahrung so sind =)…

Hast du dass mit der ManyToMany versbindung mal versucht ob du bidirektional einfügen kannst???

Also ich hab heute mal das Tutorial gemacht und bin auf eine interessante Seite gefunden.
Hier ist ein Join mit Criteria über die beiden Klassen gemacht worden…
http://www.saturius.de/2007/09/29/hibernate-tutorial-teil-4-abfragen/

Hab mir parallen noch die Hibernate-Doku (15.4) angeschaut des mit den criterien hat mir echt weitergeholfen.

EDIT :

SQuirreL dich auf die DB connecten. Falls du sowas noch nie gemacht hast, mach es jetzt am Besten mal, is ne elementare Sache für nen Programmierer muss man können. Im SQuirrel musst du ganz einfach nen Treiber für die DB angeben (ist ein Jar File von HSQLDB) und dann nen Alias einrichten.
Falls du es nicht hin bekommst, sag einfach Bescheid, dann erklär ich’s dir hier Schritt für Schritt.

Also die verdbindung hat schon mal geklappt =)
da stell ich mir doch glatt die frage wie kann ich in hibernate festlegen was für ein schema er anlegt…
und wie kann ich jetzt ein clean von meinem schema machen???


#14

Musst die Tabellen halt droppen. Geht im SQuirreL übers Kontextmenü, also Rechtsklick auf ne Tabelle. Oder halt mit SQL “drop table TABELLENNAME;”. Ein “delete from TABELLENNAME” müsste es aber auch tun.

Edit: das Schema hab ich bei mir in der Connection URL angegeben. Glaube hatte es vorher schon erstellt. Ansonsten müsste eins angelegt werden. Müsste man aber mal ausprobieren.


#15

Ja mit SQl ist klar aber ich dachte man kann irgendwie alle Tabellen auf einmal löschen/leeren…
Das ganze Schema löschen halt leider nicht funktioniert, wegen irgendwelchen abhänigkeiten =(…

Das mit dem Schema muss ich mal versuchen…

EDIT: wo genau gibst du dein Schema an?


#16

Probiers mal mit:

create-drop

[B]ACHTUNG:[/B] Alle Daten gehen verloren! Benutzung auf eigene Gefahr. :wink: