Trouver le nom des salariés, dont les noms sont les mêmes mais les salaires sont différents

J'ai un "employé" de la table avec

create table employee
(
  e_number int,
  e_name varchar(20),
  salary money,
  hire_date date
)

Maintenant, je veux afficher uniquement le nom des employés qui ont le même nom, mais différents de salaire.

J'ai essayé select e_name,count(*) from employee group by e_name having count(*)>1;
mais ne peut pas la combiner avec "le même salaire". Toute aide?

OriginalL'auteur Srijit B | 2012-12-11

  1. 4

    Cela suppose que vous voulez que les noms des personnes inscrites:

    SELECT e1.e_name
FROM employee e1, employee e2
WHERE e1.e_name = e2.e_name
AND e1.salary <> e2.salary;

    Si vous ne souhaitez que chaque nom inscrit une fois, vous pouvez utiliser un SELECT DISTINCT au lieu de le SÉLECTIONNER.

    Je reçois le même nom imprimé quatre fois.
    Si vous utilisez SELECT DISTINCT, au lieu de SÉLECTIONNER?
    C'est cool. Merci @Davis_m
    Pouvez-vous préciser l'utilisation de <> opérateur?
    <> est tout simplement la syntaxe pour "pas égaux". Il pense que d'avoir à être à la fois supérieur et inférieur, ce qui est impossible.

    OriginalL'auteur Michael Davis

  2. 2

    Si votre objectif est de l'exprimer dans la clause having:

    Select name 
 from employee
 group by name
 having 
   count(*) > 1
   and min(salary) != max(salary)
 order by name
    juste à venir à partir d'un MS SQL arrière-plan, vous ne voudriez pas min(salary) <> max(salary) au lieu de !=?
    Est-ce le cas dans MS Sql? != est mon Oracle de fond... que ce soit "différent" de l'opérateur travaille dans le SGBD cible. J'aime bien la confusion que cela causerait min(salaire) < max(salaire).
    Fonctionne très bien mais peut-u s'il vous plaît décrire le travail de min(salaire) != max(salaire)?
    La clause Having est une clause where qui est appliqué APRÈS l'agrégation. Donc, nous vous demandons est le salaire minimum au sein de cette agrégation différents qu'un maximum de salaire? Si oui, permettent l'agrégation d'être inclus dans les lignes renvoyées.

    OriginalL'auteur Brian

  3. 0
    SELECT employee1.e_name, employee1.Salary, Employee2.Salary
FROM Employee employee1
JOIN Employee employee2
  on employee1.name = employee2.name
 AND Employee1.Salary <> Employee2.Salary
 AND Employee1.E_Number <> employee2.E_Number

    Obtiendrez tous les employés, de se joindre à tous les autres employés par leur nom, d'où le numéro d'employé est différent (donc ne pas se joindre à vous-même) et le salaire est différent.

    Vous n'avez probablement pas besoin de vérifier que le numéro d'employé est différent parce que 1 employé ne peut avoir 1 salaire dans votre conception de table

    OriginalL'auteur Greg

  4. 0

    Utiliser une jointure, mais surtout d'utiliser un peu plus de la comparaison, plutôt que d'un pas égal, pour éviter les doublons:

    SELECT e1.e_name as name1, e2.e_name as name2
FROM employee e1
JOIN employee e2 ON e1.e_name = e2.e_name
    AND e1.salary > e2.salary;

    Note également que l'état comprend le salaire de comparaison. C'est une idée fausse commune que la jointure sur la condition peut contenir uniquement liée à la clé des comparaisons. Cette action peut avoir d'importants avantages de performance, en particulier lorsque les jointures sont faites, parce que la condition est exécutée comme les lignes sont rejoints - qui ignore les non-correspondances immédiatement, alors que là OÙ les conditions sont exécutés comme un filtre sur l'ensemble de l'ensemble de résultats de la rejoint.

    OriginalL'auteur Bohemian

  5. 0

    Vous voulez juste le nombre de distinct les salaires, pas le nombre de tous les dossiers.

    select e_name,count(distinct salary)
from employee
group by e_name
having count(distinct salary)>1

    (Drop le comte de sélectionner si inutiles - inclus depuis qu'il a été dans votre exemple)

    OriginalL'auteur fyjham

  6. 0

    Premier filtre salaire double pas (non), puis regroupement par e_name avoir count > 1 

    SELECT A.e_name
FROM employee A 
WHERE A.salary NOT IN (SELECT salary FROM employee  WHERE id != A.id)
GROUP BY A.e_name
HAVING COUNT(A.e_name) > 1

    OriginalL'auteur Ronny Susetyo