Verwenden Sie die Tabelle HR.employees als Beispiel. Angenommen, ich möchte Informationen für Mitarbeiter 205, 206 und 207 überprüfen. Beachten Sie, dass 207 nicht in der Tabelle enthalten ist. Dies ist die Abfrage, die ich ausführen werde:

select * from HR.employees
where employee_id in ('205', '206', '207');

Dies sind die Ergebnisse, die ich bekomme:

+-------------+------------+-----------+----------+--------------+-----------+------------+--------+----------------+------------+---------------+
| EMPLOYEE_ID | FIRST_NAME | LAST_NAME |  EMAIL   | PHONE_NUMBER | HIRE_DATE |   JOB_ID   | SALARY | COMMISSION_PCT | MANAGER_ID | DEPARTMENT_ID |
+-------------+------------+-----------+----------+--------------+-----------+------------+--------+----------------+------------+---------------+
|         205 | Shelley    | Higgins   | SHIGGINS | 515.123.8080 | 02-06-07  | AC_MGR     |  12008 |                |        101 |           110 |
|         206 | William    | Gietz     | WGIETZ   | 515.123.8181 | 02-06-07  | AC_ACCOUNT |   8300 |                |        205 |           110 |
+-------------+------------+-----------+----------+--------------+-----------+------------+--------+----------------+------------+---------------+

Obwohl 207 nicht in der Tabelle enthalten ist, möchte ich immer noch 207 in der Abfragerückgabe sehen. Alle Textspalten mit Ausnahme der Mitarbeiter-ID können null sein, während die numerischen Spalten alle 0 sind.


+-------------+------------+-----------+----------+--------------+-----------+------------+--------+----------------+------------+---------------+
| EMPLOYEE_ID | FIRST_NAME | LAST_NAME |  EMAIL   | PHONE_NUMBER | HIRE_DATE |   JOB_ID   | SALARY | COMMISSION_PCT | MANAGER_ID | DEPARTMENT_ID |
+-------------+------------+-----------+----------+--------------+-----------+------------+--------+----------------+------------+---------------+
|         205 | Shelley    | Higgins   | SHIGGINS | 515.123.8080 | 02-06-07  | AC_MGR     |  12008 |                |        101 |           110 |
|         206 | William    | Gietz     | WGIETZ   | 515.123.8181 | 02-06-07  | AC_ACCOUNT |   8300 |                |        205 |           110 |
|         207 | Null       | Null      | 0        | Null         | Null      | Null       |      0 |              0 |         0  |             0 |
+-------------+------------+-----------+----------+--------------+-----------+------------+--------+----------------+------------+---------------+

Wie ändere ich die Abfrage, um dies zu erreichen?

0
Catiger3331 21 Feb. 2020 im 19:27

5 Antworten

Beste Antwort

Eine Alternative zum Zusammenführen vieler zu überprüfender IDs besteht darin, eine Sammlung zu verwenden und sie als Tabellenausdruck zu behandeln.

select t.column_value as employee_id, e.first_name, e.last_name, -- e.email, ...
  case when e.employee_id is null then 0 else e.salary end as salary,
  case when e.employee_id is null then 0 else e.commission_pct end as commission_pct
  -- , ...
from table(sys.odcinumberlist(205, 206, 207)) t
left join employees e on e.employee_id = t.column_value;

EMPLOYEE_ID FIRST_NAME           LAST_NAME                     SALARY COMMISSION_PCT
----------- -------------------- ------------------------- ---------- --------------
        205 Shelley              Higgins                        12000               
        206 William              Gietz                           8300               
        207                                                         0              0

Sie könnten nvl() oder coalesce() für die Zahlenspalten verwenden, aber das würde commission_pct für alle echten Mitarbeiter (die keinen Satz haben) auf Null setzen. Wenn Sie einen Fallausdruck verwenden, um nicht übereinstimmende Zeilen zu identifizieren, können Sie selektiver vorgehen.

Bei Bedarf kann die Sammlung von einer Anwendung übergeben werden, beispielsweise durch Konvertieren eines Arrays, als Bindevariable und viel einfacher als das direkte Erstellen der Union.

3
Alex Poole 21 Feb. 2020 im 17:51

Dies kann eine Möglichkeit sein:

select *
from HR.employees e
right join (
    select '205' employee_id from dual

    union all

    select '206' employee_id from dual

    union all

    select '207' employee_id from dual
) lt
on lt.employee_id = e.employee_id;

Dies ist jedoch eine schlechte Idee, wenn Sie viele employee_id überprüfen müssen.

0
Ergi Nushi 21 Feb. 2020 im 19:03

Eine Möglichkeit, dies zu tun, besteht darin, die Mitarbeiter-IDs, die Sie in der Ausgabe sehen möchten, in eine Tabelle einzufügen, empIdTable zu sagen und dann einen Link-Join damit durchzuführen.

select * from 
empIdTable I
LEFT JOIN employees E
on I.employee_id = E.employee_id
0
Deepika 21 Feb. 2020 im 16:49

Erstellen Sie eine temporäre Variable oder Tabelle, die eine Liste der IDs enthält, die Sie anzeigen möchten. Wählen Sie diese Variable und dann die Felder aus der Tabelle aus, in denen sich die ID in Ihrer temporären Liste befindet.

0
babno 21 Feb. 2020 im 16:46

Sie möchten ein left join verwenden, benötigen jedoch eine Quelle für die gesuchten IDs. Eine abgeleitete Tabelle kann verwendet werden:

select *
from (select 205 as employee_id from dual union all
      select 206 as employee_id from dual union all
      select 207 as employee_id from dual
     ) i left join
     HR.employees e
     using (employee_id);

Dies gibt NULL Werte für die nicht übereinstimmenden Spalten zurück. Wenn Sie tatsächlich einen anderen Wert wünschen, müssen Sie die Spalten auflisten.

Beachten Sie, dass Sie mit der using -Klausel select * verwenden können und kein Duplikat employee_id im Ergebnis erhalten.

2
Gordon Linoff 21 Feb. 2020 im 19:39