# Datenbank: Record-Objekt



## J~man (5. Dez 2009)

Hallo zusammen!

Meine derzeitige Hausaufgabe besteht darin ein Datenbank-System zu programmieren.
Eine Datenbank ist im Prinzip ein Ordner und Tabellen sind Heapfiles in diesem Ordner.

Tabellen bekommen ein Schema (zB: 

```
Object[][] schema = { { "int", "4", "id" },
								{"int", "4", "salary" },
								{"varchar", "128", "name" },
								{"varchar", "128", "address" } };
```
) welches angibt, welche Fields die Tabelle hat.
Zur Zeit speichere ich das Schema in den ersten Zeilen der Heapfile.


Mir ist nun derzeit leider nicht klar, wie ich am besten einen Record darstelle. Der braucht ja folgendes:
- Eine RecordID bestehend aus einer PageID und einer Slotnumber
- Values für die einzelnen Fields (Spalten)

Wie speichere ich jetzt die Values ab?
Es ist vorgegeben: 
	
	
	
	





```
public Record createRecord(Object[] tuple)
```
.
Ich könnte für die Values einfach auch ein Object-Array verwenden, aber dann wird 

```
public Object readFieldValue(String fieldName)
```
schwierig.
Ich könnte irgendwie so etwas wie eine Map verwenden...aber dann müsste ich in der File dauernd die Spaltennamen wiederholen, oder?

Also:
Was für Attribute braucht ein Record-Objekt?
Wie speichere ich dieses dann am geschicktesten in der HeapFile / im Buffer?

Ich hoffe ich habe mein Problem einigermaßen verständlich erklärt und ihr wisst eine Antwort! 

Gruß,
Jman


----------



## J~man (6. Dez 2009)

Hi!

Ich habe mir jetzt überlegt, dass ich wirklich eine Map dafür verwende. Wenn ich einen Record erstelle, ziehe ich die Keys für die Map einfach aus dem Tableschema.
Ich weiß nicht, ob das besonders clever ist, aber ich glaube es sollte funktionieren..

Jetzt habe ich aber das Problem, dass ich nicht recht weiß, wie man zwei Maps auf Gleichheit überprüft.
Als ersten Ansatz habe ich mal folgendes geschrieben:

```
public class Record {
	
	private RecordID id;
	private Map<String,Object> values;

       // ......

	public boolean compareRecords(Record b) {	
		
		if(b.getValues().size()!=this.getValues().size()) return false;
		for(int i=0;i<b.getValues().size();i++){
			if(!(this.getValues().get(i).equals(b.getValues().get(i)))) return false;
		}
		return true;
	}
```

Aber ich bin mir relativ sicher, dass das falsch ist. Denn get() läuft die Map ja nicht wie bei einer Liste Elementweise von Anfang bis Ende durch, sondern sucht den Key "i" in der Map.

Also: Wie bestimmt man die Gleichheit/Ungleichheit von 2 ganzen Maps am einfachsten?

Herzlichen Dank!

edit: Hmm...vielleicht ist so eine Map doch nicht so clever. Oder gibt es eine einfache Möglichkeit jedes Element einer Map zu durchlaufen ohne die ganzen Keys zu kennen?


----------



## blackfeet (6. Dez 2009)

In deinem Fall sollte folgendes Snippet reichen:

```
public boolean compareRecords(Record b) {
  return b.values.equals(this.values);
}
```
Siehe dazu auch Map (Java Platform SE 6).

Um deine Frage zu beantworten, wie du eine Map durchlaufen kannst gibt es viele Möglichkeiten.
Hier ein paar Beispiele:

Alle values durchlaufen:

```
for (Object value : myMap.values()) {
  // Mache etwas mit dem value
  System.out.println(value.toString());
}
```

Alle keys durchlaufen:

```
for (Object key : myMap.keySet()) {
  // Mache ewas mit dem key
  System.out.println(key.toString());
}
```

Alle Einträge in der Map durchlaufen:

```
for (Map.Entry<String, Object> entry : myMap.entrySet()) {
  // Mache etwas mit dem Eintrag
  System.out.println(entry.getKey().toString() + " => " + entry.getValue().toString());
}
```


----------

