Wert aus derselben Tabelle Suchen - ergibt zu viele Ergebnisse

[Firelady1988]

Hallo liebe Leute,

ich bin neu hier und gerade dabei mein erstes Projekt fertigzustellen und scheitere gerade an zwei Fragen. Ich habe eine Tabelle mit Produktionsaufträgen, und eine mit den dazugehörigen Schrittfolgen.

1) Ich muss, aus der Tabelle Auftragsdaten, die Kesseltemperatur finden. Diese soll in der Tbl Aufträge eingefügt werden. (Meinen nicht funktionierenden Code (er gibt immer 2 Zeilen aus und berücksichtigt scheinbar die Suchbegriffe nicht?) habe ich unter den Tabellen angefügt.

2) als zweites benötige ich zur jeweiligen Batch_ID und zum Auftrag die Aufheizzeit (Kessel Ende aufheizen - Kessel Start aufheizen)


Tbl Auftraege (so soll es dann am Ende aussehen, die beiden Spalten Temperatur und aufheizzeit sollen angefügt werden

Linie	Auftrag	Batch_ID	Material	Kurztext	Kesseltemperatur	Aufheizzeit
1	4711	1	1234	Pizzasoße	80°C	10 min
1	4711	2	1234	Pizzasoße	85°C	12 min
1	4712	1	1235	Pizzateig

Tbl Auftragsdaten

Linie	Zeitstempel	Auftrag	Batch_ID	Material	Kurztext	Schritt	Wert
1	2023-12-31 09:01	4711	1	1234	Pizzasoße	Kessel Start aufheizen	1
1	2023-12-31 09:11	4711	1	1234	Pizzasoße	Kessel Ende aufheizen	1
1	2023-12-31 09:12	4711	1	1234	Pizzasoße	Kesseltemperatur	80°C
1	2023-12-31 09:20	4711	2	1234	Pizzasoße	Kessel Start aufheizen	1
1	2023-12-31 09:32	4711	2	1234	Pizzasoße	Kessel Ende aufheizen	1
1	2023-12-31 09:31	4711	2	1234	Pizzasoße	Kesseltemperatur	85°C
2	2023-12-31 10:00	4712	1	1235	Pizzteig	Zutaten abwiegen	1

Hier der Code zur Frage 1):
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
SELECT
[Linie],
[Auftrag],
[Batch_ID],
[Material],
[Kurztext],

(SELECT --Kesseltemperatur
Auftragsdaten1.[Auftrag],
Auftragsdaten1.[Batch_ID],
Auftragsdaten1.[Kurztext],
Auftragsdaten1.[Wert]

FROM Auftragsdaten as Auftragsdaten1
JOIN Auftragsdaten as Auftragsdaten2
ON Auftragsdaten2.[Auftrag]=Auftragsdaten1.[Auftrag] and Auftragsdaten2.[Batch_ID]=Auftragsdaten1.[Batch_ID]
WHERE Auftragsdaten1.[Schritt]='Kesseltemperatur')

FROM [Test].[dbo].[AUFTRAEGE]
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Ich danke euch vielmals für eure Mühe

 

[dabadepdu]

er gibt immer 2 Zeilen aus und berücksichtigt scheinbar die Suchbegriffe nicht?

Da Du 2x auf Auftragsdaten joinst, aber nur einmal die Menge auf "Kesseltemperatur" einschränkst, hast Du ein "loses Ende", alle Kesseltemperatur Matches werden zurück geliefert. (gäbe es mehr Arbeitsschritte, bekämst Du noch mehr Daten zurück)

Du kannst entweder den Join erweitern und die Spalte Schritt ebenfalls joinen auf Gleichheit. Dann reicht eine einzige Einschränkung in der Where Clause auf 'welche Schritte sollen ausgegeben werden'.
Oder Du musst in der Where Clause 2x auf den gleichen Schritt einschränken, was ich etwas schräg(er) fände als den (immer richtigen) Join auf "Schritt" zu erweiteren (alles andere wäre vielleicht Unsinn) und dann die benötigten Kriterien zu filtern, die ausgegeben werden sollen.

Die 2. Frage schaffst Du mit der Reparatur des 1. Statements dann bestimmt. Wenn nicht, melde Dich.

 

[Firelady1988]

Hey dabadepdu danke für deine Antwort. Leider bringen beide Versionen nicht das gewünschte Ergebnis. Es kommt weiterhin die Fehlermeldung:
Die Unterabfrage hat mehr als einen Wert zurückgegeben. Das ist nicht zulässig, wenn die Unterabfrage auf =, !=, <, <=, > oder >= folgt oder als Ausdruck verwendet wird.

Eben hatte ich noch eine andere Meldung:
"Nur ein einziger Ausdruck kann in der Auswahlliste angegeben werden, wenn die Unterabfrage nicht mit EXISTS eingeleitet wird."
Die lag aber daran, dass ich nicht nur den Wert ausgegeben hatte, sondern mehrere Spalten. Das ist jetzt korrigiert.

Da muss noch woanders ein Fehler sein und ich finde ihn nicht :-(

 

[t-sql]

So ?

select *
from Auftraege as af
     inner join
     Auftragsdaten as ad on af.Auftrag = ad.Auftrag and af.Batch_ID = ad.Batch_ID
where ad.schritt = 'kesseltemperatur'

 

[dabadepdu]

Leider bringen beide Versionen nicht das gewünschte Ergebnis.

Ah, ich war etwas schlampig. Hab gar nicht realisiert, dass der Code ein einziges Statement sein soll.

Deiner Abfrage:

SELECT [ Linie ],
       [ Auftrag ],
       [ Batch_ID ],
       [ Material ],
       [ Kurztext ],
       (SELECT --Kesseltemperatur
         Auftragsdaten1. [ Auftrag ],
         Auftragsdaten1. [ Batch_ID ],
         Auftragsdaten1. [ Kurztext ],
         Auftragsdaten1. [ Wert ]
          FROM Auftragsdaten as Auftragsdaten1
          JOIN Auftragsdaten as Auftragsdaten2
            ON Auftragsdaten2. [ Auftrag ] = Auftragsdaten1. [ Auftrag ]
           and Auftragsdaten2. [ Batch_ID ] = Auftragsdaten1. [
         Batch_ID ]
         WHERE Auftragsdaten1. [ Schritt ] = 'Kesseltemperatur')
  FROM [ Test ] . [ dbo ] . [ AUFTRAEGE ]

fehlt neben meinen ersten Anmerkungen auch noch eine Verknüpfung zwischen dem inneren Select und dem äußern (Aufträge)
So werden für jeden Auftrag alle gültigen Daten aus dem inneren Statement geliefert, das passt nicht zusammen.

Diese Form von inneren Selectstatements sollte man vermeiden. Meistens unperformant. Ich sag mal, schlechter Stil. Außerdem eigentlich (fast) nie nötig.

Wenn, dann wäre es mit Deinem Ansatz glaub ich so (ungetestet):

SELECT [ Linie ],
       [ Auftrag ],
       [ Batch_ID ],
       [ Material ],
       [ Kurztext ],
       (SELECT --Kesseltemperatur
         Auftragsdaten1. [ Auftrag ],
         Auftragsdaten1. [ Batch_ID ],
         Auftragsdaten1. [ Kurztext ],
         Auftragsdaten1. [ Wert ]
          FROM Auftragsdaten as Auftragsdaten1
          JOIN Auftragsdaten as Auftragsdaten2
            ON Auftragsdaten2. [ Auftrag ] = Auftragsdaten1. [ Auftrag ]
           and Auftragsdaten2. [ Batch_ID ] = Auftragsdaten1. [Batch_ID ]
           and Auftragsdaten2. [ Schritt ] = Auftragsdaten1. [ Schritt ]  -- also plus 3. Join-Kriterium über Spalte Schritt
         WHERE Auftragsdaten1. [ Schritt ] = 'Kesseltemperatur')
              and Auftragsdaten1. [ Auftrag ] = Auftraege. [ Auftrag ]  -- Filterung des inneren Ergebnis auf Auftrag
              and Auftragsdaten1. [ Batch_ID ] = Auftraege. [ Batch_ID ]  -- und Batch_ID
  FROM [ Test ] . [ dbo ] . [ AUFTRAEGE ]

Man würde es aber eher so machen (ungetestet):

SELECT [ Linie ],
       [ Auftrag ],
       [ Batch_ID ],
       [ Material ],
       [ Kurztext ],
      ad.wert as Kesseltemperatur
  FROM [ Test ] . [ dbo ] . [ AUFTRAEGE ] a
join
       (SELECT --Kesseltemperatur
         Auftragsdaten1. [ Auftrag ],
         Auftragsdaten1. [ Batch_ID ],
         Auftragsdaten1. [ Kurztext ],
         Auftragsdaten1. [ Wert ]
          FROM Auftragsdaten as Auftragsdaten1
          JOIN Auftragsdaten as Auftragsdaten2
            ON Auftragsdaten2. [ Auftrag ] = Auftragsdaten1. [ Auftrag ]
           and Auftragsdaten2. [ Batch_ID ] = Auftragsdaten1. [Batch_ID ]
           and Auftragsdaten2. [ Schritt ] = Auftragsdaten1. [ Schritt ]  -- also plus 3. Join-Kriterium über Spalte Schritt
         WHERE Auftragsdaten1. [ Schritt ] = 'Kesseltemperatur'
              and Auftragsdaten1. [ Auftrag ] = Auftraege. [ Auftrag ]       -- Filterung des inneren Ergebnis auf Auftrag
              and Auftragsdaten1. [ Batch_ID ] = Auftraege. [ Batch_ID ] ) ad  -- und Batch_ID
    on a.auftrag = ad.auftrag and a.Batch_ID = ad.Batch_ID

Analog dann zum zweiten benötigten Wert.

Das Ganze kann man dann noch mit einer CTE für die Auftragsdaten schneller und eleganter machen.

 

[Firelady1988]

dabadepdu DU bist mein Held des neuen Jahres! Es hat perfekt funktioniert. Vielen lieben Dank!!!!

Mögen dir deine Ärmel beim abwaschen immer oben bleiben!

 

[dabadepdu]

Haha ok, danke, das ist die früheste Auszeichnung des Jahres in meinem ganzen Leben.

Ich krempel mir sogar beim Schwimmen die Ärmel hoch, ganz zwanglos .. wird schon schief gehn!

Es hat perfekt funktioniert.

Tu Dir einen kleinen Gefallen und schau Dir beide Varianten im Ausführungsplan / Kosten an.
Oder, wenn Du viele Daten hast, dann lass die beiden Varianten des Statements Inline/Join gegeneinander im Rennen laufen (mit genügend Datensätzen).

Ein solches Inlinestatement scheint intuitiv / bequem, aber es ist wie einen Hund gegen den Strich zu bürsten. Für jede Ergebniszeile wird das Inline Statement separat aufgerufen.
Eine Ergebniszeile sind also wie 2 Abfragen, 100 Ergebniszeilen sind wie 101 Abfragen, 1000 wie .. usw.
Ich will nicht ausschließen, dass es mittlerweile Systeme gibt, die das intern intelligent umformen zu einem ordentlichen Join. Im Zweifel merkt man es am Ausführungsplan oder bei der Laufzeit in großen Datenmengen ziemlich einfach.