# Anbindung und Programmierung von Datenbanken



## Prince Nour (8. Nov 2012)

hi,ich habe projekt gemacht,dieses projekt berechnet die verbindung zwischen ein paar städte.ein teil von den code sieht so aus:
	
	
	
	





```
package a_stern;
import java.util.*;

public class Graph {
  
  Node[] nodeArray;
  
  public Graph (String end) {
    
    Node emden = new Node("Emden",50,650);
    Node bremen = new Node("Bremen",200,550);
    Node koeln = new Node("Koeln",50,350);
    Node frankfurt = new Node("Frankfurt",250,250);
    Node karlsruhe = new Node("Karlsruhe",150,150);
    Node stuttgart = new Node("Stuttgart",300,100);
    Node muenchen = new Node("Muenchen",500,50);
    Node nuernberg = new Node("Nuernberg",450,200);
    Node kassel = new Node("Kassel",300,400);
    Node hannover = new Node("Hannover",350,500);
    Node hamburg = new Node("Hamburg",400,650);
    Node kiel = new Node("Kiel",450,750);
    Node berlin = new Node("Berlin",550,550);
    Node leipzig = new Node("Leipzig",500,400);
    Node dresden = new Node("Dresden",650,350);
    
    Node[] s = {emden,bremen,koeln,frankfurt,karlsruhe,stuttgart,muenchen,nuernberg,kassel,
      hannover,hamburg,kiel,berlin,leipzig,dresden};
    nodeArray = s;
    
    Node endNode = getNode(end);
    Node.setDestination(endNode);
    
    emden.setNeighbour(bremen,130);
    
    bremen.setNeighbour(emden,130);
    bremen.setNeighbour(koeln,200);
    bremen.setNeighbour(hannover,100);
    
    koeln.setNeighbour(bremen,200);
    koeln.setNeighbour(frankfurt,200);
    
    frankfurt.setNeighbour(koeln,200);
    frankfurt.setNeighbour(karlsruhe,100);
    frankfurt.setNeighbour(kassel,50);
    frankfurt.setNeighbour(nuernberg,200);
    
    karlsruhe.setNeighbour(frankfurt,100);
    karlsruhe.setNeighbour(stuttgart,150);
    
    stuttgart.setNeighbour(karlsruhe,150);
    stuttgart.setNeighbour(nuernberg,100);
    
    nuernberg.setNeighbour(stuttgart,100);
    nuernberg.setNeighbour(muenchen,130);
    nuernberg.setNeighbour(dresden,200);
    nuernberg.setNeighbour(leipzig,50);
    nuernberg.setNeighbour(kassel,50);
    nuernberg.setNeighbour(frankfurt,200);
    
    muenchen.setNeighbour(nuernberg,130);
    
    kassel.setNeighbour(frankfurt,50);
    kassel.setNeighbour(hannover,100);
    kassel.setNeighbour(nuernberg,50);
    
    hannover.setNeighbour(kassel,100);
    hannover.setNeighbour(bremen,100);
    hannover.setNeighbour(hamburg,130);
    
    hamburg.setNeighbour(hannover,130);
    hamburg.setNeighbour(kiel,100);
    hamburg.setNeighbour(berlin,100);
    
    kiel.setNeighbour(hamburg,100);
    
    berlin.setNeighbour(hamburg,100);
    berlin.setNeighbour(dresden,200);
    berlin.setNeighbour(leipzig,50);
    
    leipzig.setNeighbour(berlin,50);
    leipzig.setNeighbour(dresden,100);
    leipzig.setNeighbour(nuernberg,50);
    
    dresden.setNeighbour(leipzig,100);
    dresden.setNeighbour(berlin,200);
    dresden.setNeighbour(nuernberg,200); 
   
  }
  
  public Node getNode(String town){ 
    Node node = null;
    for (int i=0; i < nodeArray.length; i++){
      if (town.equals(nodeArray[i].id)) {
        node = nodeArray[i];  
      }
    }
    return node;    
  }
  
  public void aStar (Node start, String end) { 
    OpenList listOpen = new OpenList ();
    NodeSecond secondNodeStart = new NodeSecond(start.id, null, 0, 0);
    listOpen.insertNewNode(secondNodeStart);
    listOpen.setEnd(end);
    
    String decidePath0 = null;
    NodeSecond decidePathSecN =null;
    do {
      decidePath0 = listOpen.decidePath();
      Node decidePath = getNode(decidePath0);
      decidePathSecN = (NodeSecond) listOpen.getNodeforGraph(decidePath0);
      System.out.println("decidePath: " + listOpen.decidePath() + ", f-wert: " + decidePathSecN.f);
      
      if( decidePath0 != end) {
        listOpen.deleteNode(decidePathSecN); 
        Object[] nodeObj0 = decidePath.getNeighboursAsObject();  // hole vom gelšschten die nachbarn
        Node[] node0 = new Node [nodeObj0.length];
        for (int k=0; k<node0.length; k++) {  
          node0[k] = (Node) nodeObj0[k];
        }
        NodeSecond[] secondNode0 = new NodeSecond[node0.length];
        for (int j=0; j < node0.length; j++){  // inseriere NodeSecond
          secondNode0[j] = new NodeSecond(node0[j].id, decidePathSecN, node0[j].heuristik, node0[j].edge);
          //System.out.println("insert new node: " + node0[j].id + " heuristik: " + node0[j].heuristik + " edge: " +node0[j].edge);
          listOpen.insertNewNode(secondNode0[j]);
        }
      }
    } while (  decidePath0 != end);
    listOpen.getRoute(decidePathSecN);
  }
  
  
  // ab hier nicht in verwendeung!!!
  
  public Object[] getNeighboursArrayAsObject(int i) {
    int index = nodeArray[i].neighbour.size();
    Object [] neighboursArray = new Node[index];
    neighboursArray = nodeArray[i].getNeighboursAsObject();  
    return neighboursArray;
  }
  
  public Node getNeighbour(int aktualNode, int whichNeighbour) {
    Object [] neighboursArrayObj = getNeighboursArrayAsObject(aktualNode);
    return (Node) neighboursArrayObj[whichNeighbour];
  }
  
  public int getEdges(int aktualNode, int neighbour) {
    Object [] neighboursArrayObj = getNeighboursArrayAsObject(aktualNode);
    Node newNode = (Node) neighboursArrayObj[neighbour];
    return newNode.edge;
  }
  
  public int getHeuristik (int aktualNode, int neighbour) {
    Object [] neighboursArrayObj = getNeighboursArrayAsObject(aktualNode);
    Node newNode = (Node) neighboursArrayObj[neighbour];
    return newNode.heuristik;
  }
  
  // fahrtzeit: km/(km/h) = h
  public double getTravelTimeEdge(int aktualNode, int neighbour) {
    double travelTime = (double) getEdges(aktualNode, neighbour)/getNeighbour(aktualNode,neighbour).speed;
    return travelTime;
  }
  
  public void test() {
    //int test = getEdges(0,0)+getEdges(1,1);
    //System.out.println("test: emden nach kšln: " + test);
    int testDistanz = getEdges(0,0);
    System.out.println("test distanz: emden nach bremen: " + testDistanz);
    double testFahrtzeit = getTravelTimeEdge(0,0);
    System.out.println("test fahrtzeit: emden nach bremen: " + testFahrtzeit);
  }
}
```
den programm läuft sauber,aber jetzt ich wollte nicht dass ich mit meine objekte was was habe ich definiert sondern ich habe dafür ein datenbank erstellt,mit zwei tabellen;
Table Stadt:
namek | koordx | koordy | 

Table Wege:
stadt (fk:Stadt:name) | ziel (fk:Stadt:name) | entfernung | ....



und ich hab's versucht meine datenbank mit meine programe durch jdbc zu verbinden,aber ich habe schwerigkeit gefunden,weil wie sie sehen mein code arbeitet mit dieser objekte:
 Node emden = new Node("Emden",50,650);
    Node bremen = new Node("Bremen",200,550);
    Node koeln = new Node("Koeln",50,350);
    Node frankfurt = new Node("Frankfurt",250,250);
    Node karlsruhe = new Node("Karlsruhe",150,150);
    Node stuttgart = new Node("Stuttgart",300,100);
    Node muenchen = new Node("Muenchen",500,50);
    Node nuernberg = new Node("Nuernberg",450,200);
    Node kassel = new Node("Kassel",300,400);
    Node hannover = new Node("Hannover",350,500);
    Node hamburg = new Node("Hamburg",400,650);
    Node kiel = new Node("Kiel",450,750);
    Node berlin = new Node("Berlin",550,550);
    Node leipzig = new Node("Leipzig",500,400);
    Node dresden = new Node("Dresden",650,350);
und ich weisse nicht wie kann ich in jdbc es darstellen.
wer hat eine idee????

vielen dank


----------



## SlaterB (8. Nov 2012)

die Node-Variablen fallen weg,

JDBC musst du für sich bisschen kennen, schaue dir Tutorials an,
lade alle Einträge der Stadt-Liste, gehe das ResultSet durch, erstelle jeweils einen Node fürs Array

dann bist du auf dem Stand von Zeile 28

die Verknüpfungen müssen auch in einer Tabelle vorhanden sein,
wieder eine Abfrage, eine Schleife,
hole jeweils die Nodes zu den Städtenamen aus der DB, da hast du ja schon eine Methode,
und setze die Verbindung mit der Entfernung aus der DB

dann ist alles initialisiert, Stand Zeile 87, Rest wie gehabt

---------

wie die DB gefüllt wird ist eine ganz andere Frage, das kann auf beliebigen Weg geschehen,
z.B. deinen Code genau so lassen wie er gerade ist und dann die fertig zusammengebauten Daten per Schleife durchgehen und jede Information in die DB inserten


----------



## Prince Nour (8. Nov 2012)

vielen dank für ihren antwort,ich habe basic von jdbc,aber irgendwie reicht nicht aus,um die lösung zu finden. 
eine sache meine datenbank ist schon fertig,ich habe es mit die werte von meine objekt ausgefüllt zumbeispiel mein erste objekt in
java  war: Node emden = new Node("Emden",50,650); ichbe diese werte in meiner datenbank gegeben und meine tabele sieht so aus:
Table Stadt:
namek | koordx | koordy | 
Emden    | 50       |650      |

und so weiter für menie restlichen objektte 
Node bremen = new Node("Bremen",200,550);
Node koeln = new Node("Koeln",50,350);
...
...
..
und jetz ich wollte nicht mehr mit meiner objekte arbeiten,sondern mit meine datenbank.


----------



## SlaterB (8. Nov 2012)

das ist klar, du wiederholst nur vorheriges,

ich schneide mal einen Teil aus meiner Antwort aus, ebenfalls zur deutlicheren Wiederholung:


> lade alle Einträge der Stadt-Liste, gehe das ResultSet durch, erstelle jeweils einen Node fürs Array


daran musst du aber schon bisschen selber arbeiten,
dass du auf irgend eine Weise die Information aus der DB holen musst, also ein SELECT, steht ja außer Frage,
das Programm kann nichts machen ohne aus der DB Informationen zu erlangen

wie man ein SELECT auf eine Tabelle ausführt ist keine Frage fürs Forum,
absoluter Standard in JEDEM Tutorial


wenn sich dann weitere Fragen oder Fehler ergeben, nur zu


----------



## Prince Nour (10. Nov 2012)

ich habe jetzt meine schnitstelle fertig gemacht,aber irgendwas stimmt nicht,meine programm sieht so aus ;
	
	
	
	





```
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package a_stern;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
/**
 *
 * @author ich
 */
public class Graph {
 
  Node[] nodeArray;
  
  public Graph (String end) {
    

	 

		try{
		Class.forName("com.mysql.jdbc.Driver").newInstance();
		Connection con =DriverManager.getConnection("jdbc:mysql://localhost/routenplaner","root","091984");
		con.setReadOnly(true);
		Statement stmt =con.createStatement();
		 for(int i=1;i<6;i++ ){
			 
				System.out.println("--------------startknote----------------");
			ResultSet rs =stmt.executeQuery("Select * from stadt where id= '"+i+"'");
			while(rs.next()){
				System.out.println(rs.getString(1)+" "+rs.getInt(2)+" "+rs.getInt(2));
			}
			
		 nodeArray[i] =new Node(rs.getString(1),rs.getInt(2),rs.getInt(3));
		 
		 ResultSet rs1 =stmt.executeQuery("Select count(*)from nachbar where id= '"+i+"'");
		int k= rs1.getInt(1);
		 for(int j=1;j<= k;j++ ){
		 System.out.println("--------------zielknote----------------");
			ResultSet rs2 =stmt.executeQuery("Select idNachbar,geschwindigkeit from nachbar where idStadt='rs.getString(1)' limit'"+(k-j+1)+"'");
			ResultSet rs3 =stmt.executeQuery("Select id from stadt where name='rs2.getString(1)'");
			
			while(rs1.next()){
				System.out.println(rs2.getString(1)+" "+rs2.getInt(2)+" "+rs2.getInt(3));
				
			}	
		 nodeArray[i].setNeighbour(nodeArray[rs3.getInt(1)],rs2.getInt(2) );
		 }
				rs.close();
				rs1.close();
				stmt.close();
				con.close();
				
			
					
		  }	}catch(Exception e){
					System.out.println("fehlermeldung"+e);
				} 
	
   
      

    
    Node endNode = getNode(end);
    Node.setDestination(endNode);
 
   
     
}
  
  public Node getNode(String town){ 
    Node node = null;
    for (int i=0; i < nodeArray.length; i++){
      if (town.equals(nodeArray[i].id)) {
        node = nodeArray[i];  
      }
    }
    return node;    
  }
  
  public void aStar (Node start, String end) { 
    OpenList listOpen = new OpenList ();
    NodeSecond secondNodeStart = new NodeSecond(start.id, null, 0, 0);
    listOpen.insertNewNode(secondNodeStart);
    
    String decidePath0 = null;
    NodeSecond decidePathSecN = null;
    do {
      decidePath0 = listOpen.decidePath();
      Node decidePath = getNode(decidePath0);
      decidePathSecN = (NodeSecond) listOpen.getNodeforGraph(decidePath0);
      System.out.println("decidePath: " + listOpen.decidePath() + " | geschätzter Gesammtweg: " + decidePathSecN.f  + " | bereits gelaufener Weg: " + decidePathSecN.accumulatedWay);
      
      if( decidePath0 != end) {
        listOpen.deleteNode(decidePathSecN); 
        Object[] nodeObj0 = decidePath.getNeighboursAsObject();  // hole vom gelöschten die nachbarn
        Node[] node0 = new Node [nodeObj0.length];
        for (int k=0; k<node0.length; k++) {  
          node0[k] = (Node) nodeObj0[k];
        }
        NodeSecond[] secondNode0 = new NodeSecond[node0.length];
        for (int j=0; j < node0.length; j++){  // inseriere NodeSecond
          secondNode0[j] = new NodeSecond(node0[j].id, decidePathSecN, node0[j].heuristik, node0[j].edge);
          listOpen.insertNewNode(secondNode0[j]);
        }
      }
     System.out.println(""); System.out.println("Open Node List: "); listOpen.getNodesAsString(); System.out.println("");
    } while (  decidePath0 != end); 
    listOpen.getRoute(decidePathSecN); /// test was das object ist!
  }   
}
```
aber den programm meckert sich:
	
	
	
	





```
fehlermeldungjava.sql.SQLException: After end of result set
Exception in thread "main" java.lang.NullPointerException
	at a_stern.Graph.getNode(Graph.java:186)
	at a_stern.Graph.<init>(Graph.java:80)
	at a_stern.AstarUI.main(AstarUI.java:23)
```

das ist mein main klasse

```
/*
         * To change this template, choose Tools | Templates
         * and open the template in the editor.
         */
        package a_stern;

        /**
         *
         * @author ich
         */
        public class AstarUI {

            /**
             * @param args the command line arguments
             */
            public static void main(String[] args) {

                    OpenList listOpen = new OpenList();

            String start = "Bremen";          //Saarbrücken  //
            String end = "Emden";              //Nuernberg     //

            Graph graph = new Graph(end);

            Node startNode = graph.getNode(start);

            graph.aStar(startNode, end);

          }
        }
```


----------



## SlaterB (10. Nov 2012)

puh, das sind ja wilde Versuche, aber immerhin gut dran gearbeitet, jetzt kann man korrigieren


```
ResultSet rs =stmt.executeQuery("Select * from stadt where id= '"+i+"'");
            while(rs.next()){
                System.out.println(rs.getString(1)+" "+rs.getInt(2)+" "+rs.getInt(2));
            }
            
         nodeArray[i] =new Node(rs.getString(1),rs.getInt(2),rs.getInt(3));
```
wieso in der Schleife nur eine Ausgabe und danach noch Zugriff?
ich bin mir nicht ganz sicher, aber ich schätze wenn rs.next() false liefert dann geht danach der Zugriff nicht mehr,
das ist deine Fehlermeldung,
die letzte Code-Zeile gehört IN die Schleife,

sofern du nur genau eine Stadt abfragst, reicht auch ein if statt einer Schleife

hast du überhaupt nur 6 Städte jetzt?
lieber auf die for-i-Schleife verzichten, nur

```
ResultSet rs =stmt.executeQuery("Select * from stadt");
            while(rs.next()){
                // neuer Node, ins Array an neuer Position einfügen, Liste leichter
            }
```

------

danach wird es ja richtig bunt, 

```
"Select id from stadt where name='rs2.getString(1)'"
```
geht nicht, wenn dann musst du schon in Java die Daten auslesen und übergeben, a la

```
"Select id from stadt where name='"+rs2.getString(1)+"'"
```
wobei dann wieder next() richtig aufgerufen sein muss usw.,

aber alles viel zu kompliziert und unnötig,
wie gesagt reicht wieder EINE einzige Query, "Select * from nachbar"
in der Schleife nimmst du dir die Informationen zu jedem Eintrag, findest in Java die beiden zugehörigen Städte,
und legst eine Verbindung an


----------



## Bernd Hohmann (10. Nov 2012)

Das mit dem ResultSet geht bisserl anders. Du führst erst die Query aus, dann führst Du ein rs.next() aus um an den ersten Datensatz zu kommen (ein weiteres rs.next() für den nächsten Datensatz und so weiter solange bis rs.next() ein false auswirft). Wenn das ResultSet durchlaufen ist, dann ist es abgearbeitet und lässt sich (sofern der Treiber es anbietet) mit .beforeFirst() wieder auf den Anfang zurückspulen.

Daher sind im ersten Code Zeile 32-34 etwas suspekt (erst mit while(rs.next)) alles durchlesen und dann nochmal aufs Resultset zugreifen), 

Zeile 38-39 geht so nicht, weil nach dem SELECT ein rs.next() fehlt.

42-45 ist auch komisch, es wird rs2 + rs3 befüllt aber rs1 gelesen (da sollte aber nichts mehr drinstehen).

Bernd


----------



## MChrista (10. Nov 2012)

public void abfrage(String table) {


        Statement stmt = null;
        ResultSet result = null;
        try {
            stmt = connection.createStatement();
            result = stmt.executeQuery("SELECT * FROM " + table);
            System.out.println("Select statement abgeschlossen");

            while (result.next()) // as long as valid data is in the result set
            {

               String eintrag=result.getString(1);
//speichert den String aus der spalte 1 der datendank in eintrag
//je nachdem, wie viele spalten du hast, musst du diese aneinanderhängen

               touren.add(eintrag);
//der eintrag wird an den vector touren, den ich zuvor definiert habe, gehängt              

            }


        } catch (Exception ex) {
            System.out.println("Error during access + " + table + "\n" + ex.getMessage());

        }

    }


    public void abfrageAusgeben(){
        for(int i =0; i < touren.size(); i++)
        {
            //((Toureintrag)touren.elementAt(i)).gibaus();
            System.out.println(touren.elementAt(i).toString());
                        //System.out.println(touren.elementAt(i).toString());
        }
    }


----------

