SQL Alle Spalten die unterschiedliche Werte haben

[lemurdroid788]

Hi zusammen,

ich habe folgendes Problem:

Ich möchte nur die Ergebnisse ausgeben, die Zwar in einer Spalte den gleichen wert haben (Abteilung) aber in einer anderen Spalte (Gehalt) nicht den selben Wert haben.
In den Ergebnissen sollen dann aber alle Spalten ausgegeben werden.

Tabelle:
Name Vorname Abteilung Gehalt
NTest VTest Abt1 2500
NTest1 VTest1 Abt1 2500
NTest2 VTest2 Abt1 2800
NTest3 VTest3 Abt2 2500
NTest4 VTest4 Abt2 2500

Demnach soll das Ergebnis so aussehen:
Name Vorname Abteilung Gehalt
NTest2 VTest2 Abt1 2800

Es sollen dann halt pro Abteilung nur die mit einem anderen Gehalt ausgegeben werden..

 

[akretschmer]

Du hast für Abteilung1 2 unterschiedliche Gehälter, welchen Datensatz willst Du jetzt wissen?

Falls Du nur wissen willst, welche Abteilung unterschiedliche Gehälter hat:

postgres=# select * from lem;
  name  | vorname | abteilung | gehalt 
--------+---------+-----------+--------
 ntest  | vtest   | abt1      |   2500
 ntest1 | vtest1  | abt1      |   2500
 ntest2 | vtest2  | abt1      |   2800
 ntest3 | vtest3  | abt2      |   2500
 ntest4 | vtest4  | abt2      |   2500
(5 rows)

postgres=# select abteilung, count(distinct gehalt) from lem group by abteilung having count(distinct gehalt) > 1;
 abteilung | count 
-----------+-------
 abt1      |     2
(1 row)

postgres=#

 

[lemurdroid788]

Du hast für Abteilung1 2 unterschiedliche Gehälter, welchen Datensatz willst Du jetzt wissen?

Falls Du nur wissen willst, welche Abteilung unterschiedliche Gehälter hat:

postgres=# select * from lem;
  name  | vorname | abteilung | gehalt
--------+---------+-----------+--------
 ntest  | vtest   | abt1      |   2500
 ntest1 | vtest1  | abt1      |   2500
 ntest2 | vtest2  | abt1      |   2800
 ntest3 | vtest3  | abt2      |   2500
 ntest4 | vtest4  | abt2      |   2500
(5 rows)

postgres=# select abteilung, count(distinct gehalt) from lem group by abteilung having count(distinct gehalt) > 1;
 abteilung | count
-----------+-------
 abt1      |     2
(1 row)

postgres=#

Ist es denn möglich von dem Ergebnis dann auch alle Spalten ausgeben zu lassen? Sprich, dass name und vorname dazu noch ausgegeben werden? Ändert das dann etwas an dem Group by oder kann ich die einfach noch mit ins Select schreiben?

 

[akretschmer]

postgres=# with foo as (select abteilung, count(distinct gehalt) from lem group by abteilung having count(distinct gehalt) > 1) select * from lem where abteilung in (select abteilung from foo);
  name  | vorname | abteilung | gehalt 
--------+---------+-----------+--------
 ntest  | vtest   | abt1      |   2500
 ntest1 | vtest1  | abt1      |   2500
 ntest2 | vtest2  | abt1      |   2800
(3 rows)

postgres=#

 

[lemurdroid788]

postgres=# with foo as (select abteilung, count(distinct gehalt) from lem group by abteilung having count(distinct gehalt) > 1) select * from lem where abteilung in (select abteilung from foo);
  name  | vorname | abteilung | gehalt
--------+---------+-----------+--------
 ntest  | vtest   | abt1      |   2500
 ntest1 | vtest1  | abt1      |   2500
 ntest2 | vtest2  | abt1      |   2800
(3 rows)

postgres=#

Das sind ja genau die spalten, die ich nicht brauche

 

[akretschmer]

Das sind ja genau die spalten, die ich nicht brauche

diese Spalten nanntest Du aber im Ursprungspost...

 

[lemurdroid788]

diese Spalten nanntest Du aber im Ursprungspost...

Sorry ich meine die Zeilen im Ergebnis. Die Spalten sind korrekt aber eben nur für die Zeile aus deinem ersten Post

 

[akretschmer]

welche Zeile(n) willst Du sehen? Definiere das Kriterium, dann findest Du auch die Lösung.

 

[ukulele]

Es ist unklar was deine Ausgangslage ist, welche Werte sind dir bekannt?

Ich vermute du suchst etwas wie

SELECT * FROM Tabelle WHERE Gehalt <> 2500

 

[akretschmer]

Es ist unklar was deine Ausgangslage ist, welche Werte sind dir bekannt?

siehe #1

 

[Traceman]

Wenn ich es richtig verstanden habe, willst Du alle die mehr als andere bekommen (verdienen?).

Ich habe mal noch ein paar Datensatätze angefügt:

select * from g;
+--------+---------+-----------+--------+
| Name   | Vorname | Abteilung | Gehalt |
+--------+---------+-----------+--------+
| NTest  | VTest   | Abt1      |   2500 |
| NTest1 | VTest1  | Abt1      |   2500 |
| NTest2 | VTest2  | Abt1      |   2800 |
| NTest3 | VTest3  | Abt2      |   2600 |
| NTest4 | VTest4  | Abt2      |   2600 |
| NTest5 | VTest5  | Abt3      |   2700 |
| NTest6 | VTest6  | Abt3      |   2700 |
| NTest7 | VTest7  | Abt3      |   2400 |
+--------+---------+-----------+--------+
8 rows in set (0.000 sec)

damit ergibt die Abfrage:

select * from g where concat(Abteilung, '___', Gehalt) not in (select concat(Abteilung, '___', MG) from (select Abteilung, min(Gehalt) as MG from g group by Abteilung) as h);

dann dieses Ergebniss:

+--------+---------+-----------+--------+
| Name   | Vorname | Abteilung | Gehalt |
+--------+---------+-----------+--------+
| NTest2 | VTest2  | Abt1      |   2800 |
| NTest5 | VTest5  | Abt3      |   2700 |
| NTest6 | VTest6  | Abt3      |   2700 |
+--------+---------+-----------+--------+
4 rows in set (0.002 sec)

Falls Du die Abweichnung von einem Standardgehalt haben wills, so wird es kaum möglich sein, da der Rechner es nicht entscheiden kann. MA1 und MA2 haben 2400 und MA3 und MA4 haben 2500, was soll dann ausgegeben werden?

 

[lemurdroid788]

Wenn ich es richtig verstanden habe, willst Du alle die mehr als andere bekommen (verdienen?).

Ich habe mal noch ein paar Datensatätze angefügt:

select * from g;
+--------+---------+-----------+--------+
| Name   | Vorname | Abteilung | Gehalt |
+--------+---------+-----------+--------+
| NTest  | VTest   | Abt1      |   2500 |
| NTest1 | VTest1  | Abt1      |   2500 |
| NTest2 | VTest2  | Abt1      |   2800 |
| NTest3 | VTest3  | Abt2      |   2600 |
| NTest4 | VTest4  | Abt2      |   2600 |
| NTest5 | VTest5  | Abt3      |   2700 |
| NTest6 | VTest6  | Abt3      |   2700 |
| NTest7 | VTest7  | Abt3      |   2400 |
+--------+---------+-----------+--------+
8 rows in set (0.000 sec)

damit ergibt die Abfrage:

select * from g where concat(Abteilung, '___', Gehalt) not in (select concat(Abteilung, '___', MG) from (select Abteilung, min(Gehalt) as MG from g group by Abteilung) as h);

dann dieses Ergebniss:

+--------+---------+-----------+--------+
| Name   | Vorname | Abteilung | Gehalt |
+--------+---------+-----------+--------+
| NTest2 | VTest2  | Abt1      |   2800 |
| NTest5 | VTest5  | Abt3      |   2700 |
| NTest6 | VTest6  | Abt3      |   2700 |
+--------+---------+-----------+--------+
4 rows in set (0.002 sec)

Falls Du die Abweichnung von einem Standardgehalt haben wills, so wird es kaum möglich sein, da der Rechner es nicht entscheiden kann. MA1 und MA2 haben 2400 und MA3 und MA4 haben 2500, was soll dann ausgegeben werden?

Es geht um die Abweichungen innerhalb der Abteilung. Sprich es sollen die Mitarbeiter ausgegeben werden, die nicht das gleiche Gehalt haben

 

[Traceman]

Es geht um die Abweichungen innerhalb der Abteilung. Sprich es sollen die Mitarbeiter ausgegeben werden, die nicht das gleiche Gehalt haben

Das geht nicht. Wie soll der Rechner das Standardgehalt der Abteilung ermitteln?
Wenn Du 10 MA hast, wovon nur ein paar Abweichen, so geht es noch. Aber was soll in diesem Fall ausgeben werden:

MA1 2000
MA2 2000
MA3 2500
MA4 2500
MA5 3000
MA6 3000

Es gibt kein Gehalt, welches eine Mehrheit hat, damit ist es dem Rechner unmöglich zu entscheiden wer falsch ist.

 

[ukulele]

Es sollen die Mitarbeiter ausgegeben werden, die nicht das gleiche Gehalt haben

Nicht das gleiche Gehalt als wer? Als der Durchschnitt? Als die Mehrheit? Was wenn es keine Mehrheit gibt, das kann schnell passieren.

 

[ukulele]

Für häufigstes Gehalt wäre so:

WITH tabelle([Name],Vorname,Abteilung,Gehalt) AS (
    SELECT 'NTest','VTest','Abt1',2500 UNION ALL
    SELECT 'NTest1','VTest1','Abt1',2500 UNION ALL
    SELECT 'NTest2','VTest2','Abt1',2800 UNION ALL
    SELECT 'NTest3','VTest3','Abt2',2500 UNION ALL
    SELECT 'NTest4','VTest4','Abt2',2500
    ), t AS (
    SELECT    ROW_NUMBER() OVER (PARTITION BY Abteilung ORDER BY count(*) DESC) AS zeile,
            Abteilung,
            Gehalt,
            count(*) AS anzahl
    FROM    tabelle
    GROUP BY Abteilung,Gehalt
    )
SELECT    tabelle.*
FROM    tabelle
INNER JOIN t
ON        tabelle.Abteilung = t.Abteilung
AND        t.zeile = 1
WHERE    tabelle.Gehalt != t.Gehalt