"Bedingte" Abfrage über mehrere Tabellen

[Tyrael Y.]

Reg dich nicht auf alzaimer,

ich danke dir, ich habe verstanden was Bernhard und du geschrieben hast.
Ich versuche halt gerade krampfhaft an eine Lösung zu gelangen, damit ich die Normalisierung, die durch diese Tabellenstruktur erschaffen wurde nicht wieder zunichte mache.

Ja du hast natürlich Recht, wenn du jetzt schreibst, daß Normalisierung nicht ein Gesetz ist, daß unbedingt erfüllt werden müsste.

Ich könnte natürlich auch hingehen, die Daten aus der MainTabelle und der AllgemeinenTabelle in einer SELECT-Anweisung holen, diese in eine Liste einfügen.
Danach diese Liste durchgehen und je nach Typ eine SELECT-Anweisung ausführen und die erhaltenen Daten in meine Liste hinzufügen. Dies würde heißen ich müsste sehr viele Anfragen an die Datenbank stellen.

Es gibt auf jeden Fall Wege, wie ich die Tabellen so belassen kann und trotzdem die gewünschten Daten bekomme.

Die Frage ist und bleibt, ob es wirklich keine mögliche SQL Anweisung gibt, die diese Arbeit in einem Zuge macht. Leider kann Access, soweit ich weiss, keine Stored Procedures, sonst könnte ich auch IF-Anweisungen einbauen und verschiedene Fälle kreieren.

Vielleicht gibt es ja doch einen eleganten Weg.

Fragen kostet nix, aufregen verkürzt das Leben.


edit:
OK, ich habe eine Entscheidung getroffen.
Ich werde mehrere SELECT-Anweisungen machen, die jeweils für einen Typen stimmen.
Im Delphi-Code werde ich die verschiedenen Typen durchgehen und die entsprechenden SQL-Anweisungen ausführen.

Für das oben aufgeführte Beispiel würde es bedeuten, daß ich folgende Anweisungen bräuchte.

Code:

SELECT * FROM MainTabelle 
LEFT JOIN TabelleAllgemein ON MainTabelle.ID = TabelleAllgemein.ID
LEFT JOIN TabelleTyp1 ON MainTabelle.ID = TabelleTyp1.ID
WHERE TabelleAllgemein.ID = 1


SELECT * FROM MainTabelle 
LEFT JOIN TabelleAllgemein ON MainTabelle.ID = TabelleAllgemein.ID
LEFT JOIN TabelleTyp2 ON MainTabelle.ID = TabelleTyp2.ID
WHERE TabelleAllgemein.ID = 2


SELECT * FROM MainTabelle 
LEFT JOIN TabelleAllgemein ON MainTabelle.ID = TabelleAllgemein.ID
LEFT JOIN TabelleTyp3 ON MainTabelle.ID = TabelleTyp3.ID
WHERE TabelleAllgemein.ID = 3

Ich habe es noch nicht gestestet, aber das sollte theoretisch funktionieren.

[NormanNG]

Hi,

statt
WHERE TabelleAllgemein.ID = 3 meinst du wohl

WHERE TabelleAllgemein.TYP = 3

[alzaimar]

Ich rege mich nicht auf, nur ist die Frage komisch, weil die Antwort schon längst fest steht.

Also:

SQL-Code:

Select    m.Id as [ID], 
   m.Text as [Text], 
   ta.Typ as [Typ],
   ta.Anzahl as [Anzahl],
   t1.[Größe],
   t1.[Gewicht],
   cast (NULL as VarChar (80)) as [Farbel],
   cast (NULL as int) as [Leistung],
   cast (NULL as money) as [Wert]
from   MainTabelle m
   join TabelleAllgemein ta on m.ID = ta.ID
   join TabelleType1 t1 on t1.ID = m.ID
where ta.Typ = 1
union
Select    m.Id as [ID], 
   m.Text as [Text], 
   ta.Typ as [Typ],
   NULL as [Anzahl],
   NULL as [Größe],
   NULL as [Gewicht],
   t2.Farbe,
   t2.Leistung,
   NULL as [Wert]
from   MainTabelle m
   join TabelleAllgemein ta on m.ID = ta.ID
   join TabelleType2 t2 on t1.ID = m.ID
where ta.Typ = 2
union
Select    m.Id as [ID], 
   m.Text as [Text], 
   ta.Typ as [Typ],
   NULL as [Anzahl],
   NULL as [Größe],
   NULL as [Gewicht],
   NULL as [Farbe],
   NULL as [Leistung],
   t3.Wert
from   MainTabelle m
   join TabelleAllgemein ta on m.ID = ta.ID
   join TabelleType2 t2 on t1.ID = m.ID
where ta.Typ = 3

Wenn Du das dynamisch haben willst, dann benötigst Du eine Pivot/Crosstabelle.

[mkinzler]

Zitat:

Ich rege mich nicht auf, nur ist die Frage komisch, weil die Antwort schon längst fest steht.

Du müsstest doch i.d.Z. wissen, das der neue Programmierertyp keinen Bock hat sich mit Grundlagen zu befassen, sich gedanklich in das Problem zu vertiefe, oder gesagtes an sein Problem anzupassen, er erwartet dass du ihm die Lösung fix und fertig lieferst.

[Jelly]

Zitat von Tyrael Y.:

Code:

SELECT * FROM MainTabelle 
LEFT JOIN TabelleAllgemein ON MainTabelle.ID = TabelleAllgemein.ID
LEFT JOIN TabelleTyp1 ON MainTabelle.ID = TabelleTyp1.ID
WHERE TabelleAllgemein.ID = 1


SELECT * FROM MainTabelle 
LEFT JOIN TabelleAllgemein ON MainTabelle.ID = TabelleAllgemein.ID
LEFT JOIN TabelleTyp2 ON MainTabelle.ID = TabelleTyp2.ID
WHERE TabelleAllgemein.ID = 2


SELECT * FROM MainTabelle 
LEFT JOIN TabelleAllgemein ON MainTabelle.ID = TabelleAllgemein.ID
LEFT JOIN TabelleTyp3 ON MainTabelle.ID = TabelleTyp3.ID
WHERE TabelleAllgemein.ID = 3

Damit hast du doch alles. Geliefert werden aber nur Spalten aus deiner MainTabelle. Den Join auf TabelleTyp3 kannst du dir also sparen.

Und du joins die ID aus Maintabelle mit der ID aus TabelleAllgemein. Da frag ich mich erstmal, wie sieht denn dein PK in TabelleAllgemein aus? Und falls es eine 1:1 Beziehung darstellen soll (sprich ID ist auch PK in Tabelleallgemein), warum machst du denn überhaupt 2 Tabellen, und legst nicht einfach alle Spalten in eine.

Da TabelleTyp1-3 unterschiedlicher Struktur sind, macht ein Gesamtergebnis in einem Select in meinen Augen überhaupt keinen Sinn. Du vergleichst Äpfel mit Birnen, und versuchst beides in einen Korb zu schmeissen.

Zu deiner Normalisierung: Du entscheidest über Typ in deiner TabelleAllgemein, welche TypTabelle als Referenztabelle gewählt werden soll. Ich würds andersrum machen. Ich würde in jeder TypTabelle eine Referenz auf TabelleAllgemein setzen (also gerade umgekehrt). Somit kann dir nicht passieren, dass wenn einer die Typ Id in TabelleAllgemein ändert, du plötzlich auf eine andere Tabelle referenzierst. Das ist eine Riesengefahrenquelle, und die Homogenität deiner Daten ist nicht mehr gewährleistet.

[Tyrael Y.]

Zitat von NormanNG:

Hi,
statt
...
meinst du wohl
WHERE TabelleAllgemein.TYP = 3

Ja natürlich. War ein Schreibfehler.

Zitat von alzaimar:

Ich rege mich nicht auf, nur ist die Frage komisch, weil die Antwort schon längst fest steht.

Naja, wie ich oben erwähnt habe, gäbe es ja verschiedene Wege zu meinen Ergebnissen zu kommen.
Vielen Dank für die SQL-Anweisung. Zwei Fragen bitte noch dazu.

1. Du hast es in zwei verschiedenen Formen geschrieben

Code:

cast (NULL as VarChar (80)) as [Farbel]
...
NULL as [Farbe]

hat das eine bestimmte Bewandnis, vielleicht, daß man beim ersten mal erwähnen des Feldes den Typ und die Größe angeben muss?

2. Ich verstehe es doch richtig das durch zB.

Code:

NULL as [Farbe]

diese Feld "virtuell" zu dieser Tabelle hinzugefügt wird, oder?

Vielen Dank nochmal, sieht auf den ersten Blick, sehr vielversprechend aus.

Zitat von mkinzler:

Du müsstest doch i.d.Z. wissen, das der neue Programmierertyp keinen Bock hat sich mit Grundlagen zu befassen, sich gedanklich in das Problem zu vertiefe, oder gesagtes an sein Problem anzupassen, er erwartet dass du ihm die Lösung fix und fertig lieferst.

Genau dessalb habe ich ja auch die erste Lösung, die auch funktionieren würde, direkt einprogrammiert und mich nicht damit auseinandergesetzt, ob es keine eleganter Lösung gibt. Danke für deinen nicht passenden Post.

Zitat von Jelly:

Damit hast du doch alles. Geliefert werden aber nur Spalten aus deiner MainTabelle. Den Join auf TabelleTyp3 kannst du dir also sparen.

Ich dachte auch zuerst, daß ich alle Felder die ich haben möchte einzeln angeben müsste, aber ein

Code:

SELECT * FROM....LEFT JOIN....

hat dazu geführt, daß ich alle Felder aus allen Tabellen erhalten habe.
Vielleicht Access spezifisch?

Zitat von Jelly:

Und du joins die ID aus Maintabelle mit der ID aus TabelleAllgemein. Da frag ich mich erstmal, wie sieht denn dein PK in TabelleAllgemein aus? Und falls es eine 1:1 Beziehung darstellen soll (sprich ID ist auch PK in Tabelleallgemein), warum machst du denn überhaupt 2 Tabellen, und legst nicht einfach alle Spalten in eine.

Ja es ist eine 1:1 Beziehung zwischen den beiden Tabellen.
Die Tabellen werden nicht nur von mir benutzt. Es gibt Fälle bei denen man nur die
Daten aus TabelleAllgemein braucht.

Zitat von Jelly:

Da TabelleTyp1-3 unterschiedlicher Struktur sind, macht ein Gesamtergebnis in einem Select in meinen Augen überhaupt keinen Sinn. Du vergleichst Äpfel mit Birnen, und versuchst beides in einen Korb zu schmeissen.

Ich möchte halt alle Daten möglichst effizient holen.
Bei der Behandlung im Delphi Code erzeuge ich je nach Typ eine Objekt aus einer passenden Klasse.
Die Klassen haben einen gemeinsamen Vorfahren. Mein Korb ist die Objektliste und es ist nicht schlimm,
dort verschieden Typen (Äpfel, Birnen) zu haben, da ich es ein "Obstkorb" (der Vorfahr wäre Obst) reintue.
Ich brauche sie halt im Programm zur späteren Behandlung.

Zitat von Jelly:

Zu deiner Normalisierung: Du entscheidest über Typ in deiner TabelleAllgemein, welche TypTabelle als Referenztabelle gewählt werden soll. Ich würds andersrum machen. Ich würde in jeder TypTabelle eine Referenz auf TabelleAllgemein setzen (also gerade umgekehrt). Somit kann dir nicht passieren, dass wenn einer die Typ Id in TabelleAllgemein ändert, du plötzlich auf eine andere Tabelle referenzierst. Das ist eine Riesengefahrenquelle, und die Homogenität deiner Daten ist nicht mehr gewährleistet.

Im Grunde hast du Recht, ich könnte es umbauen und es wäre auch richtig so.
Der Typ kann sich aber nie ändern. Ein Datensatz der angelegt wurde behält immer seinen Typen.
Er kann gelöscht werden, aber nie seinen Typen ändern.