# SQL ordnen nach zueinander in Verhältnis gesetzten Spaltenwerten



## Felix (26. Apr 2010)

Hallo,

ich möchte gerne meine SQL-Ausgabe nach Verhältnissen der Spaltenwerte ordnen. Ich hab mir da mal einen Befehl überlegt, der aber nicht funktioniert. Es gibt zwar keinen Syntaxfehler, aber er macht auch nicht das was ich will:


```
SELECT * from Database ORDER BY ((knowngf + knownfg)/(knowngf + unknowngf + knownfg + unknownfg))
```

knownfg, knowngf, unknownfg und unknowngf sind die Spalten. Sie enthalten jeweils einen smallint Wert. Es soll also nach Prozentsätzen der gewussten in Verhältnis zu den gesamten Werte geordnet werden. Es entsteht aber eine scheinbar willkürliche Ausgabe.

Ich verwende PostgreSQL.

Grüße
Felix


----------



## Gast2 (26. Apr 2010)

Schon mal in einem Subselect probiert?


```
SELECT * FROM (
    SELECT *, ((knowngf + knownfg)/(knowngf + unknowngf + knownfg + unknownfg)) AS sortkey from Database) ORDER BY sortkey
```


----------



## Felix (28. Apr 2010)

Danke für die Antwort. Ich hab den Code eingebaut. Aber es kommt ein PSQL-Error:

org.postgresql.util.PSQLException: FEHLER: Unteranfrage in FROM muss Aliasnamen erhalten
Hinweis: Zum Beispiel FROM (SELECT...) [AS] xyz.

Aber so wie im Bsp. steht das doch da, oder?

Grüße


----------



## SlaterB (28. Apr 2010)

du hast 'AS sortkey' für ein paar verrechnete Attribute, aber die gesamte Unterquery 
(SELECT *, ((knowngf + knownfg)/(knowngf + unknowngf + knownfg + unknownfg)) AS sortkey from Database)
hat keinen Namen, das muss

(SELECT *, ((knowngf + knownfg)/(knowngf + unknowngf + knownfg + unknownfg)) AS sortkey from Database) as dbExtra
oder ähnlich lauten


----------



## Felix (29. Apr 2010)

Hi, danke, jetzt funktioniert die Datenbankabfrage ohne Error. Aber er sortiert immer noch nicht richtig...
So kommt zB 0.94 vor 0.875. Was allerdings super funktioniert, ist, dass alle Werte 1.0 (höchster zu erreichender Wert) am Ende stehen.

Ich gebe die Werte so aus:

```
System.out.println(((double)knownGF + (double)knownFG)/((double)knownFG + (double)knownGF + (double) unknownFG + (double) unknwonGF));
```
Rundet der Datenbankserver vllt anders? Oder geht er anders mit der konvertierung von int zu double um?


----------



## Gast2 (29. Apr 2010)

Also das Ergebniss ist:

```
0.94
...
0.875
...
1.0
```

Sind denn die rows zwischen 0.94 und 0.875 absteigend sortiert?


----------



## Felix (30. Apr 2010)

Nein, das auch nicht. Es lässt sich kein System erkennen. Ich kann leider nicht von Netbeans in Firefox kopieren, aber ich hab jetzt mal die ersten paar Zahlen abgetippt:

0.3333333333333333
0.94
0.875
0.9666666666666667
0.9523809523809523
0.7948717948717948
0.8181818181818182
...
1.0

Kann es vllt. am Code liegen? Er lautet:


```
else if (interrogationmode == Interrogation.SORTED_BY_MEASURE) {
    resultset = statement.executeQuery("SELECT index, box, germanimport, foreignimport, knowngf, unknowngf, knownfg, unknownfg, lastinterrogation, apposition FROM (SELECT index, box, germanimport, foreignimport, knowngf, unknowngf, knownfg, unknownfg, lastinterrogation, apposition, ((knowngf + knownfg)/(knowngf + unknowngf + knownfg + unknownfg)) AS sortkey from \"" + dbconnection.getDatabase() + "\") as DBExtra ORDER BY sortkey");
}
```


----------



## Gast2 (30. Apr 2010)

Was für einen Datentyp haben denn die Spalten?

Ich habe mal eben eine Tabelle mit numeric(18,9) angelegt und order by soriert wie es soll

SELECT * FROM test
col1
0.213300000
0.433000000
0.910000000
0.721000000
1.000000000
0.125000000
0.367000000
0.102000000
0.209000000

SELECT * FROM (select col1, (col1* 0.25) as x from test) as y order by y.x
col1             ;x
0.102000000;0.02550000000
0.125000000;0.03125000000
0.209000000;0.05225000000
0.213300000;0.05332500000
0.367000000;0.09175000000
0.433000000;0.10825000000
0.721000000;0.18025000000
0.910000000;0.22750000000
1.000000000;0.25000000000


----------



## Felix (30. Apr 2010)

Die Spalten sind vom Typ smallint. Die Datenbank die ich verwende ist ja PostgreSQL. Könnte es daran liegen, dass es nicht funktioniert?
Wenn ich nach knowngf*0.25 ordnen lasse, ist bei mir auch alles richtig geordnet. Könntest du mal versuchen zwei Werte in Verhältnis zu setzen und danach ordnen zu lassen?


----------



## SlaterB (1. Mai 2010)

spannender ist schon, was bei dir passiert,
selektiere doch auch den sortkey und gib den aus,

ob du den in deinen manuellen Rechnungen richtig ausgibst kann man kaum überprüfen,
arbeite dich langsam vor, erstmal nur zwei Werte verrechnen, DB-Sortierung mit eigenen Zahlen vergleichen, dann 3 Werte usw.


----------



## Gast2 (3. Mai 2010)

Felix hat gesagt.:


> Die Spalten sind vom Typ smallint. Die Datenbank die ich verwende ist ja PostgreSQL. Könnte es daran liegen, dass es nicht funktioniert?



Ja, daran liegt das. Wenn die Spalten vom Typ smallint sind wird bei einer arithmetischen Operation immer auf den besten smallint "gerundet", d.h. du sortierts nur 0 oder 1

z.B. Berechnugn mit smallint Spalten:

```
CREATE TABLE test
(
  col1 smallint,
  col2 smallint,
  col3 smallint
)

insert into test VALUES(1,3,5);
insert into test VALUES(2,7,9);
insert into test VALUES(3,1,3);
insert into test VALUES(9,2,5);
insert into test VALUES(2,7,3);
insert into test VALUES(6,9,3);

select * from test
1;3;5
2;7;9
3;1;3
9;2;5
2;7;3
6;9;3

select col1 / col2 * col3 as ergebnis from test
0
0
9
20
0
0

select * from (select col1 / col2 * col3 as sortkey from test) as calc order by calc.sortkey
0
0
0
0
9
20
```

und Berechnung mit numeric(18,9) Spalten

```
CREATE TABLE test2
(
  col1 numeric(18,9),
  col2 numeric(18,9),
  col3 numeric(18,9)
)

insert into test2 VALUES(1,3,5);
insert into test2 VALUES(2,7,9);
insert into test2 VALUES(3,1,3);
insert into test2 VALUES(9,2,5);
insert into test2 VALUES(2,7,3);
insert into test2 VALUES(6,9,3);

select * from test2
1.000000000;3.000000000;5.000000000
2.000000000;7.000000000;9.000000000
3.000000000;1.000000000;3.000000000
9.000000000;2.000000000;5.000000000
2.000000000;7.000000000;3.000000000
6.000000000;9.000000000;3.000000000

select col1 / col2 * col3 as ergebnis from test2
1.66666666666666666665000000000
2.57142857142857142861000000000
9.0000000000000000000000000
22.5000000000000000000000000
0.85714285714285714287000000000
2.00000000000000000001000000000


select * from (select col1 / col2 * col3 as sortkey from test2) as calc order by calc.sortkey
0.85714285714285714287000000000
1.66666666666666666665000000000
2.00000000000000000001000000000
2.57142857142857142861000000000
9.0000000000000000000000000
22.5000000000000000000000000
```


----------



## Felix (3. Mai 2010)

Ahh, ok vielen Dank, das war sehr anschaulich! Ich hab jetzt die Spaltenart auf Numeric geändert und es funktioniert super.


----------

