JTree aus DB rekursiv füllen

[KalleWirsch]

Hi

ich will mir eine Funktion schreiben, mit der ich meinen JTree rekursiv aus einer Oracle-Datenbank fülle
(es dürfte auch normal iterativ sein mir fällt jetzt aber nur eine rekursive Variante dazu ein)

Also, ich poste erst mal die Funktion und erläutere darunter mein Problem

public void insertNode2(String session) throws SQLException
      	{
      		if (con == null)
      			return;
      		
      		Statement stmt = con.createStatement();
      		ResultSet rs;
      		rs= stmt.executeQuery("Select * from ordner o " + "where o.ordner_parent_fk = "+ session );

      		
      		while (rs != null && rs.next())  
/* hier wird der Baum mit den übergeordneten Hierachien gefüllt */
      		{
      			insertNode(new CTreeNode(rs.getInt("id"),rs.getInt("ordner_parent_fk"), rs.getString("bezeichnung")) ,(CTreeNode)this.getRoot()); 
/* insertNode fügt den Knoten in den Baum ein insertNode(neuer Knoten, Vater) */
      		}
      		System.out.println("childCount: " + ((CTreeNode)this.getRoot()).getChildCount());
      		

      		for (int c = 0; c <((CTreeNode)this.getRoot()).getChildCount(); c++) 
/*Hier werden die niedrigere Hierachie an die Knoten angehängt*/
      		{
      			CTreeNode parent  = (CTreeNode)((CTreeNode)this.getRoot()).getChildAt(c);
      			rs = stmt.executeQuery("Select * from ordner o " + "where o.ordner_parent_fk = " + parent.getID());
          		

          		while (rs != null && rs.next()) 
          		{
          			CTreeNode newNode =  new CTreeNode(rs.getInt("id"), rs.getInt("ordner_parent_fk"), rs.getString("bezeichnung"));
          			insertNode2(rs.getString("id")); // Hier ist die Rekursion die nicht funktioniert
          			insertNode(newNode, parent);
          		}// ende while

      		}// ende for
      	} // ende fkt

Den ersten Knoten, die Wurzel erhält die Funktion 'insertNode2' schon in 'main()'

Aussehen der DB:
Die Datensätze in der DB haben folgendes Format: ID (genauer Bezeichner), ordner_parent_fk ( Vater bzw. Überordner), Bezeichnung (Name)

Meine Idee war, den Baum Hierarchieweise einzulesen.
Die Wurzel ist ja schon vorhanden... insertNode2 würde dann die ersten beiden Hierarchieebenen einlesen.
In der letzten while-Schleife wollte ich dann die Rekursikon starten und die Funktion mit einer neuen Wurzel, also dem Knoten der die untergeordneten Hierarchien erhalten soll, aufrufen. Mein Ansatz hier oben liefert mir allerdings eine Endlosschleife und ich kann mir nicht erklären warum.

Vielleicht weiß ja jemand wo der Fehler bei mir liegt und wenn es ganz gut läuft vielleicht sogar noch einen Tipp auf einen Lösungsvorschlag

Gruß
Kalle!!!

 

[AlArenal]

Grundsätzlich ist es keine gute Idee Daten rekursiv aus einer DB zu holen. Das wird schnell quälend langsam, weswegen man in der DB lieber mit Nested Sets arbeitet, als mit dem einfachen, aber schwer abzufragenden Parent-Zeiger-Ansatz.

Ich würde dir stattdessen raten die komplette Tabelle in einem Rutsch einzulesen. Aus den einzelnen Einträgen erzeugst du Instanzen der passenden Klasse. Während du diese erzeugst füllst du eine Map id=>Instanz und wenn du fertig bist durchläufst du alle Instanzen erneut und setzt den Parent über die in den Datensätzen enthaltene ID, mit der du aus der Map die Parent-Instanz geliefert bekommst.

 

[KalleWirsch]

also ich muss gestehen das meine Java Kentnisse ein bisschen beschränkt sind ???:L
Was Nested Sets sind weiß ich so grob aber was du genau mit diesem Satz
"... und wenn du fertig bist durchläufst du alle Instanzen erneut und setzt den Parent über die in den Datensätzen enthaltene ID, mit der du aus der Map die Parent-Instanz geliefert bekommst."
Meinst du damit eine TreeMap?? wie kann ich denn den Parent über die aus den Ds enthaltene ID setzten??


... kann ich auch einen bestimmten Pfad über eine Jtree ablaufen (wenn ich die Bezeichnung jedes einzelnen Knoten kenne?)??

Kalle

 

[SlaterB]

allgemein zu den Parents:
du liest alle Datensätze ein und musst sie dann verknüpfen/ verlinken,
also zu jedem Datensatz den Parent herausfinden,

dazu nimmst du die ParentId und gehst z.B. die Liste aller Einträge komplett durch,
das ist vergleichsweise langsam aber wird wohl zum Ziel führen,
für 1000 Datensätze 1000x die Liste durchlaufen

schneller gehts mit einer Map, HashMap z.B., TreeMap vielleicht auch,
also einmal die Liste durchlaufen und die Datensätze anhand ihrer Id ablegen,

dann geht danach die Suche nach dem Parent rasend schnell:
nur kurz in der Map nachschauen und das zugehörige Objekt ist gefunden

 

[KalleWirsch]

meine Idee war es eigentlich ohne Liste auszukommen und die Daten direkt per SQL in den Baum zu schreiben... gibt es da auch eine Möglichkeit... wie gesagt die ersten 2Ebenen haben so ja schon geklappt nur mim Rest hapert es noch! ... nach meinem Verständnis geht das aber nicht ohne Rekursion?!?! und die funktioniert bei mir nicht :shock:

oder ist es unabdinglich eine Map bzw. Liste zu benutzen??

 

[SlaterB]

deins ist logisch gesehen sicherlich möglich, aber eben nicht zu empfehlen,
niemand weiß wie viele Element du hast,
aber wahrscheinlich ist jeder einzelne deiner 100 oder 1000 Lese-Zugriffe langsamer,
als nach einmaligen Lesen aller Elemente diese kurz zu sortieren, und die 1000 Zugriffe danach auf die Map durchuführen!

wie auch immer:
> Mein Ansatz hier oben liefert mir allerdings eine Endlosschleife und ich kann mir nicht erklären warum.

was passiert denn in der Endlosschleife?
baue viele System.out.println ein, um zu verfolgen wer was warum tut

> rs = stmt.executeQuery(irgendwas);
ist ein unsichtbarer sehr langsamer Befehl,

schreibe dir doch eine eigene Operation:
public ResultSet executeQuery(Statement stmt, String query) {
System.out.println("query: "+query);
stmt.executeQuery(irgendwas);
}

und
rs = executeQuery(stmt,irgendwas);

dann kriegst du eine Meldung für jede DB-Anfrage,
wird in der Endlosschleife ständig die DB angefragt?
welche Anfrage/ welche Schleife von Anfragen ständig hintereinander?

wenn keine Anfragen durchgeführt werden,
dann irgendwelche anderen Befehle?

alles genau untersuchen,
diesen Code kann niemand anders testen, das musst du dann selber machen

 

[KalleWirsch]

ich baue jetzt schon so lange an der Methode rum ... ich versuche die jetzt wenigstens noch fertig zu machen ;-) Danach kann ich mich ja der Perfomance witmen


also nehme mal an das durch die Rekursion das rs nicht mehr == 'null' wird und deshalb unendlich viele Aufrufe entstehen.
Denn es wird immer die gleichen ID's übergeben

query: SELECT * FROM ordner
query: Select * from ordner o where o.ordner_parent_fk = 50008
childCount: 3
query: Select * from ordner o where o.ordner_parent_fk = 50067
Daddy: 50067
kiddie: Bezeichner10 has id: 50068
query: Select * from ordner o where o.ordner_parent_fk = 50068
childCount: 3
query: Select * from ordner o where o.ordner_parent_fk = 50067
Daddy: 50067
kiddie: Bezeichner10 has id: 50068

...

      	public void insertNode2(String session) throws SQLException
      	{
      		if (con == null)
      			return;

      		ResultSet rs;
      		rs= executeQuery(con.createStatement() , "Select * from ordner o " + "where o.ordner_parent_fk = "+ session );
      		

      		while (rs != null && rs.next()) 
      		{
      			//System.out.println(rs.next());
      			insertNode(new CTreeNode(rs.getInt("id"),rs.getInt("ordner_parent_fk"), rs.getString("bezeichnung")) /**/,(CTreeNode)this.getRoot());
      		}
      		System.out.println("childCount: " + ((CTreeNode)this.getRoot()).getChildCount());
      		
      		for (int c = 0; c <((CTreeNode)this.getRoot()).getChildCount(); c++)
      		{
      			CTreeNode parent  = (CTreeNode)((CTreeNode)this.getRoot()).getChildAt(c);
      			rs = executeQuery(con.createStatement() , "Select * from ordner o " + "where o.ordner_parent_fk = " + parent.getID());
          		System.out.println("Daddy: " +  parent.getID());
          		
          		while (rs != null && rs.next()) 
          		{
          			CTreeNode newNode =  new CTreeNode(rs.getInt("id"), rs.getInt("ordner_parent_fk"), rs.getString("bezeichnung"));
          			System.out.println("kiddie: " + rs.getString("bezeichnung") + " has id: " + rs.getInt("id"));
          			insertNode2(rs.getString("id"));  // Rekursion
          			insertNode(newNode, parent);
          			
          		}// ende while
      		}// ende for
      	}

also hast du vielleicht eine Idee weshalb der Zeiger nicht merh weiter springt??
Könnte es vielleicht damit zusammenhängen, dass ich ja bei jedem Aufruf der Funktion bzw Schleige ResultSet wieder neu initialisiere??


Gruß

 

[SlaterB]

überlege dir selber was was ist, ob die Daten richtig zusammenhängen usw.

z.B. gibt es da eine Schleife
for (int c = 0; c <((CTreeNode)this.getRoot()).getChildCount(); c++)

was ist denn this.getRoot()? bezieht sich das nicht auf die Wurzel des JTrees?
wenn in jedem Durchlauf wieder die Kinder der Wurzel bearbeitet werden,
dann verwundert mich eine Endlosschleife nicht

dein ganzer Aufbau ist generell falsch in meinen Augen,
es sollte nur eine DB-Anfrage drin stehen

--------
query: Kinder mit Parent x
für jedes dieser Kinder:
Knoten in jTree einfügen und Rekursion mit der Kind-Id aufrufen
---------

so, in dieser übersichtlichen Beschreibung taucht root nicht auf und auch keine zwei DB-Anfragen sondern nur eine

 

[KalleWirsch]

ah danke ... ein bisschen Übersicht und schon klappt der Laden
danke für deine Hilfe und Tips ... jetzt funktioniert der Baum!!! zwar lahm aber in der Ruhe liegt die Kraft;-)

      	public void insertNode3(String session, CTreeNode parent) throws SQLException
      	{
      		if (con == null)
      			return;

      		ResultSet rs;
      		rs= executeQuery(con.createStatement() , "Select * from ordner o " + "where o.ordner_parent_fk = "+ session );

      		while (rs != null && rs.next()) 
      		{
      			CTreeNode child = new CTreeNode(rs.getInt("id"),rs.getInt("ordner_parent_fk"), rs.getString("bezeichnung") ); 
      			insertNode( child ,parent);
      			insertNode3(rs.getString("id"), child);
      		}
      	}

Gruß Kalle!!

 

[SlaterB]

uiuiui,
ResultSets werden da ja sehr lange offen gehalten..,
wenn möglich, kopiere zunächst alle Daten in eine Liste von Knoten,
bevor du da rekursiv weitere ResultSets aufmachst,

und/ oder füge wenigstens
rs.close();
stmt.close();
am Ende ein, das sollte man so bei DB-Anfragen machen,
auch wenn es anscheinend derzeit so läuft,

dazu brauchst du natürlich eine Referenz auf das Statement,
derzeit erzeugst du es ja on the fly im Aufruf von executeQuery,

 

[KalleWirsch]

hm ja klar was geöffnet worden ist, sollte auch wieder geschlossen werden!

Ich hoffe ich werde jetzt nicht gesteinigt ... aber wie erstelle ich bei Java eine Rferenz auf eine ander Funktion bzw eine Variable aus einer anderen Funktion?

 

[SlaterB]

gar nicht

Statement stmt = ..;
rs= executeQuery(stmt, "Select .." );


rs.close();
stmt.close();

 

[KalleWirsch]

oh achso