Union mit Dubletten

danschna

Benutzer
Beiträge
17
Hallo zusammen,

ich habe hier 2 Tabellen die ich mit einem UNION zusammenführen würde.

Tabelle1
Feld1 | Feld 2 | Feld 3
NULL | A | B
NULL | A | C

Tabelle 2
Feld1 | Feld 2 | Feld 3
2 | A | C

Als Ergebnis hätte ich gerne eine Tabelle:

Feld1 | Feld 2 | Feld 3
NULL | A | B
2 | A | C

Also wenn Feld1 befüllt ist soll er den Datensatz nehmen. Wenn es keine befüllung gibt kann er den Datensatz aus Tabelle1 nehmen.
Kann ich das mit einem UNION überhaupt umsetzen? Was wäre die Alternative für eine View?

Danke für eure Hilfe
 
Werbung:
Code:
postgres=# insert into danscha1 values (null, 'a','b');
INSERT 0 1
postgres=# insert into danscha1 values (null, 'a','c');
INSERT 0 1
postgres=# insert into danscha2 values (2, 'a','c');
INSERT 0 1
postgres=# select * from danscha1;
 f1 | f2 | f3 
----+----+----
    | a  | b
    | a  | c
(2 rows)

postgres=# select * from danscha2;
 f1 | f2 | f3 
----+----+----
  2 | a  | c
(1 row)
postgres=# select * from danscha1 where f1 is not null union all select * from danscha2;
 f1 | f2 | f3 
----+----+----
  2 | a  | c
(1 row)

postgres=#
 
UNION ist hier eventuell das falsche Mittel aber aus deinen Beispieldatensätzen erschließt sich das nicht. Warum soll NULL | A | C den entfallen, immer dann wenn ein Datensatz in Tabelle2 überhaupt existiert oder nur wenn z.B. Spalte1 NULL ist? Stand jetzt würde ich sagen:
Code:
SELECT t1.*
FROM tabelle1 t1
LEFT JOIN tabelle2 t2
ON t1.feld2 = t2.feld2
AND t1.feld3 = t2.feld3
WHERE t2.feld1 IS NULL --hier wäre der t2 PK die beste Wahl
UNION ALL
SELECT *
FROM tabelle2
 
Hallo akretschmer, danke für deine Antwort.
Ich habe gerade gesehen, dass ich es falsch erklärt habe.

In Tabelle 1 sind die Datensätze die Feld 1 befüllt haben.
In Tabelle 2 sind die gleichen Datensätze, allerdings ohne das erste Feld.
Feld 2 und 3 sind jeweils Schlüssel

Wenn ich einen Datensatz in Tabelle 1 finde soll er den nehmen. Gibt es den Datensatz in T1 nicht, aber in T2 soll er den nehmen.

Im Moment habe ich einen einfachen UNION der allerdings vom Schlüssel her Dubletten erzeugt weil er einmal den Datensatz mit T1.F1= NULL und T2.F1 = befüllt nimmt

Ich hoffe ich konnte es einigermaßen erklären :)
 
Mhmmm...

Code:
postgres=# select coalesce(d1.f1, d2.f1), d1.f2, d1.f3 from danscha1 d1 left join danscha2 d2 on ((d1.f2,d1.f3)=(d2.f2,d2.f3));
 coalesce | f2 | f3 
----------+----+----
          | a  | b
        2 | a  | c
(2 rows)

postgres=# select coalesce(d1.f1, d2.f1), d1.f2, d1.f3 from danscha1 d1 left join danscha2 d2 on ((d1.f2,d1.f3)=(d2.f2,d2.f3)) where coalesce(d1.f1, d2.f1) is not null;
 coalesce | f2 | f3 
----------+----+----
        2 | a  | c
(1 row)

postgres=#
 
Okay, noch ein Versuch:

Hier mal meine jetzige Ergebnistabelle:

Feld1 | Feld2 | Feld3 | usw...
ABC1 | DUN | 12 |
NULL | DUN | 12 | --Der muss weg :)
NULL | CEP | 14 | --Der ist korrekt, da es in Tabelle 1 keinen Datensatz dazu gibt

Quelltabellen in dem Fall
Tabelle 1:
Feld1 | Feld2 | Feld3 | usw...
ABC1 | DUN | 12 |

Tabelle2:
Feld2 | Feld3 | usw...
DUN | 12 |
CEP | 14 |

Bei den Datensätzen 1 und 2 handelt es sich um den gleichen Datensatz aus Tabelle 1 und 2. In Tabelle 1 ist das Feld1 befüllt in Tabelle 2 gibt es das Feld1 gar nicht. Datensatz 2 soll eigentlich gar nicht ausgegeben werden weil der Datensatz 1 mit dem befüllten Feld1 passt.

Datensatz 3 kommt aus Tabelle2 weil er in Tabelle1 gar nicht vor kommt. Das ist auch richtig so.

Bislang ist es so gelöst, dass ich Tabelle1 und Tabelle2 mit einem Union verbinde. Das klappt auch, wenn Tabelle2 das Feld1 gar nicht hat. Wir benutzen als Tool Denodo, das kann trotzdem einen Union durchführen.

Ist es jetzt verständlicher?

Danke auf jeden Fall für eure Unterstützung
 
Werbung:
Grundsätzlich verständlich, ich gehe jetzt mal ganz eiskalt davon aus das die Beispiele jede Situation abdecken (also z.B. nicht ein Datensatz nur in Tabelle 1 existiert der dann auch ins Ergebnis soll). Dann würde ich es ganz ohne UNION machen wollen:
Code:
SELECT t1.Feld1,t2.*
FROM tabelle2 t2
LEFT JOIN tabelle1 t1
ON t2.Feld2 = t1.Feld2
AND t2.Feld3 = t1.Feld3
Also ein umgekehrtes Vorgehen, alles aus T2 und wenn in T1 vorhanden das Feld1 aus T1 dazu geholt. Für deine gezeigten Testdaten klappt das...
 
Zurück
Oben