# Nullpointer beim Löschen von Datenbankeintrag, je nachdem wo der Befehl steht



## kuzdu (28. Okt 2012)

Hi Leute,

ich möchte einen Eintrag aus einer Tabelle löschen und der Löschbefehl funktioniert auch soweit, nur nicht "an der richtigen Stelle".

Wenn ich in der Main-Klasse alle Einträge mit folgendem Code auslese, funktioniert das Löschen. 

```
try {
	    		datasource.open();
	    		RechnungenList = datasource.getAllEntries(entryForTable(forTable)); //Tabelle wird ausgelesen
	    		
	    		datasource.delete(11);  //löschen funktioniert		
	    		datasource.close();
	    	}
```

Nun kann ich die einzelnen Einträge anklicken und ein neues Intent (aufbauend auf der Klasse ReadSimpleEntry) wird geöffnet. Dort wird der einzelne Eintrag komplett mit allen Details ausgegeben und ebenfalls existiert ein Löschen Button. 

```
try{
datasource.open();
        	//	datasource.delete(id);  
        	//	datasource.delete(11); 
        	//	ke.deleteEntry(id); 
                //      ke.deleteEntry(11);
datasource.close();
        	} catch(Exception ex) {
        		System.out.println(ex);
        	}
```
Diese vier Varianten werfen alle eine Nullpointer-Exception. An der Id liegt es also nicht.  Das ke.deleteEntry(id) ist nur für Testzwecke. Es ist eine Methode in der Main-Klasse, die wieder datasource.delete aufruft. 

Was ich nicht verstehe, warum funktioniert die erste Variante des Löschens und die zweite nicht?

Anscheinend kann mein Programm bei der zweiten nicht auf die Tabelle zugreifen, versucht trotzdem die Id 11 zu löschen und wirft eine Nullpointer-Exception. Nur wie behebe ich das?

Ich bin mir fast sicher, dass das zu den Basics von Java gehört, aber iwie kriege ich keine Lösung hin. Freue mich über Code-Hilfe oder hilfreiche Google-Schlagworte. 

Schönen Sonntag noch 

PS: Falls mehr Code benötigt wird, einfach Bescheid geben.


----------



## schlingel (28. Okt 2012)

Also wo fliegt die Exception?

Bei ke.delete oder bei datasource.delete?

Falls sie beim ke fliegt, stellt sich die Frage ob du ke initialisiert bzw. instanziert hast. Falls sie datasource fliegt, poste mal die ganze Exception.


----------



## kuzdu (28. Okt 2012)

Nein, ich habe ke nicht initialisiert oder instanziert! Ich muss erst mal googlen, was das genau macht bzw. wie das geht.

Bei beiden kommt dieselbe Exception.


----------



## Bernd Hohmann (28. Okt 2012)

Keine Ahnung welches Tool Du dort missbrauchst, aber die ID ist mit Sicherheit nur auf das Resultset bezogen.


```
SELECT * FROM BRÖTCHENKORB
```

könnte als Resultset bringen


```
1: Weizenbrötchen
2: Roggenbrötchen
3: Dinkelbrötchen
```

Da wäre also ein "datasource.delete(2)" möglich.

Wenn Du aber die Datasource nur aufmachst (via .open()) ohne eine Query durchzuführen, bringt auch ein .delete() nix.

Bernd


----------



## schlingel (29. Okt 2012)

> Bei beiden kommt dieselbe Exception.


Dann schau mal nach was instanzieren bedeutet und dann poste das Ergebnis.



> Wenn Du aber die Datasource nur aufmachst (via .open()) ohne eine Query durchzuführen, bringt auch ein .delete() nix.


Hä? Du kannst ein DELETE ausführen ohne vorher ein SELECT ausgeführt zu haben.


----------



## kuzdu (29. Okt 2012)

Neue Antwort:
Ich kann nicht sagen, was jetzt genau falsch war, aber nun funktioniert alles wie es sollte, mein Code zur Löschmethode sieht so aus:


```
loeschen.setOnClickListener(new View.OnClickListener() {
         public void onClick(View v) {
      	   
        	 
        	 
        	try{
        		datasource.open();
        		datasource.delete(id);
                 	datasource.close();
        	} catch(Exception ex) {
        		System.out.println(ex);
        	}
```

Meine alte Antwort:
Hi, bin jetzt erst dazu gekommen zu antworten.



> Keine Ahnung welches Tool Du dort missbrauchst, aber die ID ist mit Sicherheit nur auf das Resultset bezogen.



Ich missbrauche eign. gar kein Tool, sondern die ganz normale SQLite-Klasse. Hier rufe ich ja nur eine Löschmethode auf, die dann in einer weiteren Klasse das eigentliche Löschen durchführt:


```
//Klasse: EntryDatabase       - ein etwas ungünstiger Name im Nachhinein :)
//Diese Methode funktioniert
public void delete(int id) {
	
		String table = "KALENDERZWEI";
		String whereClause = "id = "+id;  
		String[] whereArgs = null;
		
		database.delete(table, whereClause, whereArgs);
	}
```


Also in der Main-Klasse initalisiere ich die Datenbank wie folgt:


```
public class Main extends Activity {

 private EntryDatabase datasource;

public void onCreate(Bundle savedInstanceState) {
	        super.onCreate(savedInstanceState);
	        setContentView(R.layout.entry);

datasource = new EntryDatabase(this);


//Daten auslesen
try {
	    		datasource.open();
	    		//datasource.delete(18); //hier funktioniert das Löschen, aber hier brauch ich es nicht
	    		RechnungenList = datasource.getAllEntries(entryForTable(forTable)); //Hier werden Tabelleneinträge ausgelesen und in eine Liste gepackt zur besseren Ansicht
	    		datasource.close();
}


//Per Klick auf einen Eintrag, werden die Daten weiter an den nächsten Intent übergeben
lVerlauf.setOnItemClickListener(new OnItemClickListener()
		      {
		  
		      public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long arg3)
		      {
		      Intent intent = new Intent();
		      intent.setClassName(getPackageName(), getPackageName()+".ReadSimpleEntryClass");
		      
		      Bundle anReadSimpleEntry = new Bundle();
		      
		      anReadSimpleEntry.putInt("ID",RechnungenList.get(arg2).getId());
		      anReadSimpleEntry.putString("Eintrag",RechnungenList.get(arg2).getEntry().toString());
		      anReadSimpleEntry.putString("Alarm",RechnungenList.get(arg2).getAlarm().toString());
		     	
		      intent.putExtras(anReadSimpleEntry);
		      startActivity(intent);
		      }
		  });
}

//Hier die Löschmethode, die auf die Klasse VerwaltungDB zugreift
  public void deleteEntry(int id) {
		 // datasource.delete(id); //Nullpointer
		  datasource.open();
		  datasource.delete(11); //Nullpointer
		  datasource.close();
	  }
```


```
public class ReadSimpleEntry extends Activity {

 private EntryDatabase datasource;
   private Kalenderentry ke;


public void onCreate(Bundle savedInstanceState){
		super.onCreate(savedInstanceState);
		setContentView(R.layout.read_simple_entry);
	

 datasource = new EntryDatabase(this);
 ke = new Kalenderentry();   //Das hier habe ich neu eingefügt 'einfach mal so', hat aber auch nichts gebracht

 loeschen.setOnClickListener(new View.OnClickListener() {
         public void onClick(View v) {
      	  
        	 
        	try{
        		datasource.open();
        		
        		ke.deleteEntry(20);     //Die Löschmethode über die Main-Klasse 
        		datasource.delete(20); //bzw. das Löschen von der ReadSimpleEntry-Klasse bringt nichts anderes 
                                                        //als eine Nullpointer

            	datasource.close();
        	} catch(Exception ex) {
        		System.out.println(ex);
        	}
```


Kann es vielleicht sein, dass ich einmal in der Main-Klasse und in der ReadSimpleEntry-Klasse durch das datasource = new EntryDatabase(this); unterschiedliche Objekt der Datenbankklasse erzeuge und deshalb die Löschmethode nullpointermäßig ins Leere geht? Wenn ja, wie behebe ich das?


----------

