# Neues select auf ein vorhandenes Resultset



## ente382 (20. Mai 2008)

Hallo,

ich würde gerne auf ein resultset nochmal ein Select ausführen... Hier mal ein Bsp. zum Verständnis:
Also das is das was momentan im resultset steht:

ID                Name
1                  Peter
2                  fred
3                  Eumel

Ich würde gerne wissen, ob ich zum Bsp. sagen kann (ich weiß,dass es die select-Methode beim resultset nicht gibt):

rs.select("Select * where ID='1');

Ich würde das gerne benutzen um nicht nochma erneut die gleichen daten aus der datenbank holen zu müssen.
Ich weiß, dass es bei C# die Möglichkeit gibt, so etwas zu nutzen.
Hat einer von euch ne Idee?

Danke


----------



## Niki (20. Mai 2008)

Ja speicher die Daten in eine HashMap mit der ID als key. Dann kannst du direkt darauf zugreifen:

```
Map result = new HashMap();

ResultSet rs = stmt.executeQuerey("select id, name from....");
while(rs.next()){
  result.put(rs.getString(id), rs.getString(name));
}
rs.close();
stmt.close();


//und dann kannst du darauf zugreifen:
String name = result.get("1");
if(name != null){
  //Datensatz ist in Ergebnismenge vorhanden
}
```


----------



## SlaterB (20. Mai 2008)

mit anderen Worten: einen direkten vollen SQL-Zugriff auf ein ResultSet gibts im Standard-JDBC nicht


----------



## Guest (20. Mai 2008)

coole sache 
zwei weitere fragen:


```
Map result = new HashMap();

ResultSet rs = stmt.executeQuerey("select id, name from....");
while(rs.next()){
  result.put(rs.getString(id), rs.getString(name));
}
rs.close();
stmt.close();
```

Ist es möglich, bei Select * from....  alle Spalten der Abfrage ins result zu bekommen, weil ich die Spaltennamen bzw. die Anzahl der Spalten nicht vorher weiß? Also so in der Art:


```
result.put(rs.getString(*));
```

und ist es hier: 
	
	
	
	





```
//und dann kannst du darauf zugreifen:
String name = result.get("1");
if(name != null){
  //Datensatz ist in Ergebnismenge vorhanden
}
```
auch möglich mehrere IDs abzufragen?


```
String ids= "1,2,4";
String name = result.get(ids);
```


----------



## Niki (20. Mai 2008)

Du kannst schon alle Spalten in die Map stecken. Du musst aber vorher wissen welcher Typ das ist, das kannst du aber über das ResultSetMetaData Objekt ermittelnt (getColumnType()); Dann kannst du dir ein Object[] basteln und dieses als value in die Map geben.
Du kannst bei der Map nur mehrere IDs einzeln abfragen. Du kannst dir aber eine Methode basteln die das gewünschte macht:

```
public List<String> getSubResultSet(String[] ids, Map rs){
  List<String> erg = new ArrayList<String>();
  for(Map.Entry e : rs.entrySet()){
    for(String id : ids){
      if(e.getKey().equals(id)){
        erg.add(e.getValue());
        break;
      }
    }
  }
  return erg;
}
```


----------



## ente382 (20. Mai 2008)

OK, danke für die Hilfe


----------



## maki (20. Mai 2008)

Wozu eigentlich?


----------



## ente382 (20. Mai 2008)

Wozu ich das verwenden wollte?
Um mir ein großes Select auf die datenbank zu sparen.
Also ich mache ein Select, verwende das Ergebnis (1.Ergebnis) und bräuchte noch ein Select aufs Ergebnis (2.Ergebnis) und verwende dies dann wieder...
Einfacherer Weg:
1.Select auf DB -> Auswertung
2.Select auf DB -> Auswertung


----------



## Niki (20. Mai 2008)

Klüger ist es natürlich gleich ein POJO zu verwenden und mit den Daten aus der Datenbank zu füllen. Dazu musst du aber  wissen welche Spalte auf welches Attribut gemappt werden muss. Da du aber geschrieben hast du weißt nicht wieviele Spalten als Ergebnismenge kommen tut man sich da natürlich schwer. Vielleicht solltest du das ganze Design nochmal ein wenig überdenken. Vielleicht findet sich ja eine saubere Lösung


----------



## maki (20. Mai 2008)

ente382 hat gesagt.:
			
		

> Wozu ich das verwenden wollte?
> Um mir ein großes Select auf die datenbank zu sparen.
> Also ich mache ein Select, verwende das Ergebnis (1.Ergebnis) und bräuchte noch ein Select aufs Ergebnis (2.Ergebnis) und verwende dies dann wieder...
> Einfacherer Weg:
> ...


Gute OR Mapper machen das von Haus aus, ist sicherlich nicht trivial umzusetzen was du vorhast.


----------



## ente382 (20. Mai 2008)

Hm,naja, ich glaub wenn ich POJOs noch verwenden würde, würde das den Umfang des doch eher kleinen Projektes sprengen.
Habe halt gedacht es gibt einen ähnlich leicht zu implementierenden Weg wie bei C#.
Egal, ich machs denn mit der einfacheren Lösung


----------



## voidee (20. Mai 2008)

Ein _ResultSet_ ist der technische Begriff auf das *endgültige* Ergebnis einer SQL-Abfrage. Wenn man auf das Ergebnis einer SQL-Abfrage nochmals mit SQL zugreifen möchte (sprich: SELECT), dann muss man die SELECT-Statements schachteln. Wenn das Ergebnis an ein RT-System (z.B. Java) ausgeliefert ist, kann man das Ergebnis abfragen, aber kein DB-Select mehr darauf ausführen.

Beispiel:


```
SELECT name FROM emp;
```

Liefert Namen.

Alle Namen die mit E beginnen: in Java muss man mit Java Mittel alle Zeilen des ResultSets durchgehen und prüfen, ob de erste Buchstabe mit "E" beginnt. So etwas wie _SELECT_ gibt es in Java nicht!

Also sollte man dass die DB machen, die kann das eh besser:


```
SELECT names.name FROM (SELECT name FROM emp) names
WHERE upper(name) like 'E%'
```
Da holt die DB im inneren Select erst alle Namen, und im äußeren werden nur die Datensätze, bei denen der Name mit einem E beginnt (unabhängig von der Schreibweise) selektiert. Hier könnte man von einem Select auf ein ResultSet sprechen, ist es aber nicht. Es ist ein Select auf eine mit Select eingeschränkte Menge (äußeres Select auf inneres Select, wobei das innere Select ("SELECT name FROM emp") so etwas wie eine virtuelle oder temporäre Tabelle ist. Diese innere Darstellung wird aber nach außen hin nie sichtbar, deshalb ist es kein ResultSet, denn das ResultSet ist das Endergebnis.
[/code]


----------

