Problem mit Group by in Access

[Luckner]

Hallo,

ich mache eine SQL-Abfrage in einer Access-Datenbank und es funktioniert soweit. Die Ausgabe ist eine DBTabelle, in der ich alle Artikel anzeigen lasse, die auf diesem Lagerplatz liegen. Das funktioniert soweit. Ich möchte jedoch nur die Lagerplätze anzeigen lassen, jedoch gruppiert. Wenn mehrere Artikel auf einem Platz liegen, dann brauche ich nur einmal diesen Platzangezeigt. Mit GROUP BY in dieser Abfrage bekommen ich nur eine Fehlermeldung "Syntaxfehler, (fehlender Operator).

Könnte ich Hilfe bitten?

Delphi-Quellcode:

         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.Active := False;     //DISTINCTROW
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Clear;
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('SELECT Materialrollen.[Mat-Nr], Materialrollen.Rollennummer, Materialrollen.DatumAb, Rollenlager.Lagerplatz,             Rollenlager.Rollennummer FROM Materialrollen ');
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer ');
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('where ((Materialrollen.[Mat-Nr] = ' + EditMaterialeingangMatNr.Text + ') and (Materialrollen.DatumAb is NULL)) GROUP BY Rollenlager.Lagerplatz');
         
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.Open;
         GridMaterialeingangMaterial.Visible := true;

Gruß, Luckner

[mkinzler]

Bei einer Gruppierung dürfen ausser den Feldern, über die gruppiert wird nur Aggregate abgefragt werden.

[Luckner]

So etwas wie "COUNT(*)"?

Gruß, Luckner

[mkinzler]

Oder SUM(), MIN(), MAX(), AVG(), ...

Du gruppierst ja nur ein Feld fragst aber mehrere ab. Welche MAT-Nr, Rollennummer usw. von den zusammengefassten willst Du haben?

[Luckner]

Hallo mkinzler,

ich möchte aus den beiden Tabellen, die ich mit Join verknüpft habe, abfragen "welche Lagerplätze" werden von diesen Artikeln belegt, die die selbe Materialnummer haben. Möchte nicht 50 Artikelnr. mit dem selben Lagerplatz sehen.

Danke, Luckner

[mkinzler]

Zitat:

Möchte nicht 50 Artikelnr. mit dem selben Lagerplatz sehen.

Ist mir schon klar.

Zitat:

SQL-Code:

SELECT Materialrollen.[Mat-Nr], Materialrollen.Rollennummer, Materialrollen.DatumAb, Rollenlager.Lagerplatz, Rollenlager.Rollennummer

Du Fragst die Informationen aber hier ab. Welche von den 50 Rollennummern soll hier genommen werden?

[Luckner]

Stimmt. Dann ist die "select-Anweisung" nicht richtig. Ich glaube, ich habe mal früher mal auch so eine GROUP BY - Abfrage für Firebird benutzt. Ich werde mal schauen, ob ich diesen Source-Code noch habe.

Gruß, Luckner

[Luckner]

Nein, leider nichts desgleichen gefunden. Könnte Jemand helfen?
Habe jetzt folgende Select-Abfrage genacht. Leider auch eine Fehlermeldung.

Delphi-Quellcode:

         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('SELECT Materialrollen.[Mat-Nr], Materialrollen.Rollennummer, Materialrollen.DatumAb, Rollenlager.Lagerplatz, Rollenlager.Rollennummer, COUNT(Rollenlager.Lagerplatz) FROM Materialrollen ');
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer where ((Materialrollen.[Mat-Nr] = ' + EditMaterialeingangMatNr.Text + ') and (Materialrollen.DatumAb is NULL)) GROUP BY Rollenlager.Lagerplatz');

Danke, Luckner

[mkinzler]

Zitat:

Zitat von Luckner (Beitrag 1433053)

Nein, leider nichts desgleichen gefunden. Könnte Jemand helfen die Select-Abfrage zu gestallten?

Danke, Luckner

SQL-Code:

SELECT 
  Materialrollen.[Mat-Nr], Rollenlager.Lagerplatz 
...
GROUP BY 
  Materialrollen.[Mat-Nr], Rollenlager.Lagerplatz;

[Luckner]

danke mkinzler für die Hilfe. Habe das jetzt so gemacht:

Delphi-Quellcode:

         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('SELECT Materialrollen.[Mat-Nr], Materialrollen.Rollennummer, Materialrollen.DatumAb, Rollenlager.Lagerplatz, Rollenlager.Rollennummer FROM Materialrollen ');
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer where ((Materialrollen.[Mat-Nr] = ' + EditMaterialeingangMatNr.Text + ') and (Materialrollen.DatumAb is NULL))');
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add(' GROUP BY Materialrollen.Rollennummer, Rollenlager.Lagerplatz');

Kommt leider eine Fehlermeldung "Sie wollten eine Abfrage ausführen, die den angegebenen Ausdruck 'Mat-Nr' nicht als Teil der Aggregatfunktion einschliesst'.

[mkinzler]

Die Fehlermeldung sagt es ja schon.

Jedes Feld in der Feldliste muss entweder Teil der Gruppierung oder ein Aggegat sein!

Du gruppierst über Materialrollen.Rollennummer und Rollenlager.Lagerplatz. Entweder du Weitest die Gruppierung auf Materialrollen.[Mat-Nr] aus oder Du sagst Access welche Mat-Nr der zusammengefassten Du möchtset ( die kleinste, größte, den Durschnitt, die Summe aller Nummern, ...

[Luckner]

Jetzt dieses:

Delphi-Quellcode:

         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('SELECT Materialrollen.[Mat-Nr], Materialrollen.Rollennummer, Materialrollen.DatumAb, Rollenlager.Lagerplatz, Rollenlager.Rollennummer FROM Materialrollen ');
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer where ((Materialrollen.[Mat-Nr] = ' + EditMaterialeingangMatNr.Text + ') and (Materialrollen.DatumAb is NULL))');
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add(' GROUP BY Materialrollen.[Mat-Nr], Materialrollen.Rollennummer, Rollenlager.Lagerplatz, Materialrollen.DatumAb, Rollenlager.Rollennummer');

Jetzt ohne Fehlermeldung, jedoch das Ergebnis ist gleich als ob ohne Group By wäre.:?

[mkinzler]

Ist ja auch logisch, wenn alle Felder in der Gruppierung sind bedeutet es ja dass du aus jedem datensatz eine Gruppe machst!

Gruppieren heisst ja Zusammenfassen. Dadurch verlierst Du die Detailsinformationen der Datensätze in den Feldern über die nicht gruppiert wird. Willst Du diese Felder trotzdem haben musst Du angeben, welche Wert bzw. Aggregat Du willst.

Beispiel

Name Geschlecht Alter Größe
Max männlich 20 1,80
Susi weiblich 18 1,50
Bob männlich 35 1,70
Sonja weiblich 30 1,60

SQL-Code:

select 
  sum(*) as Anzahl,
  Geschlecht, //Gruppierung
  min(Alter) as Juengste,
  max(Alter) as Älteste,
  avg( Alter) Durschnittsalter
from
  Tabelle
group by
  Geschlecht;

[Luckner]

Materialrollen.[Mat-Nr] = ' + EditMaterialeingangMatNr.Text ist eindeutig. Es gibt mehrere Materialrollen, die möglicherweise auf mehrere Lagerplätzen liegen (oder auch nicht).
Möchte nur die Lagerplätze anzeigen, jedoch nur einmal pro Lagerplatze. Wie kann ich eine Aggregatfunktion aus Rollennummern bilden?

Danke, Luckner

[mkinzler]

Zitat:

Wie kann ich eine Aggregatfunktion aus Rollennummern bilden?

Das musst Du entscheiden. welche willst Du die kleinste, die größte?

[Luckner]

Ich glaube, ich muss mir erst mal die Group BY Funktion noch so richtig anschauen. Möglicherweise bekomme ich dann eine Idee, wie ich das machen kann.

Danke, Luckner

[mkinzler]

Schau Dir doch nochmal mein Beispiel oben an:

Wenn man wie oben nach Geschlecht gruppiert, erhält man einen Datensatz pro Geschlecht, alle anderen Felder der Abfrage müssen also als Aggegat vorliegen, selbst wenn zufällig alle Felder der zusammenfassenden Datensätze gleich wären.
Im Beispiel oben sind es jeweils 2 Datensätze welche zusammengefasst werden, es könnten aber auch mehr sein.
Beim Geschlecht gibt es ja bekanntlich nur 2 (bzw. 3) egal wieviele Personen in der Tabelle gespeichert sind erhält man immer 2 bzw. 3 Datensätze.
Im Beispiel oben werden für die Ausprägung "weiblich" des Feldes Geschlecht Susi und Sonja zusammengefasst. Für die Felder ausser Geschlecht muss deshalb entschieden werden welche/s Aggegat man möchte.
Ich habe mich beim Beispiel mal auf das Feld Alter beschränkt und jeweils den kleinsten(MIN), den größten (MAX) und den Durschnittswert(AVG) verwendet.
Wenn die Personen zusammen Aufzugfahren könnte auch die Summe der Gewichte interessant sein (Maximalgewicht des Aufzuges).

[Luckner]

Werde ich mache. Wobei ich mich frage,warum ich da irgendwelche Summen oder andere Aggregatzustände aus willkürlichen Materialnummern oder Rollennummern erzeugen soll. Aber ich werde anhand dieses Beispiels versuchen diese Funktion zu verstehen.

Danke.

[mkinzler]

Wenn Du die Felder nicht benötigst einfach weglassen oder Dummies verwenden:

SQL-Code:

select
  0 as Rollennummer, ...

[Luckner]

Ich glaube, die benötige ich zum Teil. Meine 1. Tabelle besteht aus folgenden Spalten: Materialrollen.[Mat-Nr], Materialrollen.Rollennummer, Materialrollen.DatumAb und die 2. Tabelle aus: Rollenlager.Rollennummer, Rollenlager.Lagerplatz. In der 2. Tabelle existieren die Datensätze nur, wenn die entsprechende Rollenlager.Rollennummer auf einem Lagerplatz liegt. Wenn sie verbraucht wir, dann wird dieser Datensatz gelöscht. Materialrollen.[Mat-Nr] und Materialrollen.DatumAb brauche ich, wegen des selects auch.

Gruß, Luckner

[Delphi.Narium]

Ausgangs-SQL:

SQL-Code:

SELECT
  Materialrollen.[Mat-Nr],
  Materialrollen.Rollennummer,
  Materialrollen.DatumAb,
  Rollenlager.Lagerplatz,
  Rollenlager.Rollennummer
FROM Materialrollen
LEFT JOIN Rollenlager
  ON Rollenlager.Rollennummer = Materialrollen.Rollennummer
where Materialrollen.[Mat-Nr] = :MatNr
and   Materialrollen.DatumAb is NULL

Zitat:

Ich möchte jedoch nur die Lagerplätze anzeigen lassen, ...

SQL-Code:

SELECT
  Rollenlager.Lagerplatz
FROM Materialrollen
LEFT JOIN Rollenlager
  ON Rollenlager.Rollennummer = Materialrollen.Rollennummer
where Materialrollen.[Mat-Nr] = :MatNr
and   Materialrollen.DatumAb is NULL

Zitat:

jedoch gruppiert.

SQL-Code:

SELECT
  Rollenlager.Lagerplatz
FROM Materialrollen
LEFT JOIN Rollenlager
  ON Rollenlager.Rollennummer = Materialrollen.Rollennummer
where Materialrollen.[Mat-Nr] = :MatNr
and   Materialrollen.DatumAb is NULL
group by
  Rollenlager.Lagerplatz

Zitat:

Wenn mehrere Artikel auf einem Platz liegen, dann brauche ich nur einmal diesen Platzangezeigt.

Einfachste Methode das zu erreichen:

Was nicht gebraucht wird, wird auch nicht ausgegeben, dann stört es auch nicht im Group by und "verstrubbelt" damit auch nicht das Ergebnis. ;-)

Und:

Nicht alles, was in der Wherebedingung benötigt wird, muss auch im Select aufgeführt werden, dort wird nur das aufgeführt, was in der Ausgabe tatsächlich benötigt wird.

Alles was im Ergebnis benötigt wird, also zwischen Select und from steht, muss auch im Group by berücksichtigt werden, sofern es nicht über eine Aggregatfunktion verarbeitet wird, sei es nun Min oder Max oder Avg oder ...

Dashier ginge z. B.:

SQL-Code:

SELECT
  Count(*) as Anzahl, 
  Rollenlager.Lagerplatz
FROM Materialrollen
LEFT JOIN Rollenlager
  ON Rollenlager.Rollennummer = Materialrollen.Rollennummer
where Materialrollen.[Mat-Nr] = :MatNr
and   Materialrollen.DatumAb is NULL
group by
  Rollenlager.Lagerplatz

Wir erfahren damit nicht nur, welche Lagerplätze von der Where-Bedingung betroffen sind, sondern auch, wie oft jeder Lagerplatz betroffen / belegt ... was auch immer ist,

Oder dashier, was zu einem "erweiteren" Ergebnis führt und einem mehrfachen Aufführen des Lagerplatzes:

SQL-Code:

SELECT
  Count(*) as Anzahl, 
  Rollenlager.Lagerplatz, 
  Materialrollen.[Mat-Nr]
FROM Materialrollen
LEFT JOIN Rollenlager
  ON Rollenlager.Rollennummer = Materialrollen.Rollennummer
where Materialrollen.[Mat-Nr] = :MatNr
and   Materialrollen.DatumAb is NULL
group by
  Rollenlager.Lagerplatz, 
  Materialrollen.[Mat-Nr]

Hiermit erfahren wir, wieviele Exemplare jeder gefundenenen Mat-Nr auf einem Lagerplatz liegen. Das heißt: Was zusätzlich im Select erscheint und nicht über eine Aggregatfunktion "gebündelt / zusammengefasst " wird, muss auch zwingend im Group by erscheinen.

Wenn eventuell für das praktische Leben auch sinnfrei:

SQL-Code:

SELECT
  Count(*) as Anzahl, 
  Rollenlager.Lagerplatz, 
  Max(Materialrollen.[Mat-Nr]) as MatNr
FROM Materialrollen
LEFT JOIN Rollenlager
  ON Rollenlager.Rollennummer = Materialrollen.Rollennummer
where Materialrollen.[Mat-Nr] = :MatNr
and   Materialrollen.DatumAb is NULL
group by
  Rollenlager.Lagerplatz

Hier erfahen wir, wie oft ein Lagerplatz betroffen ist und die höchste dort vorzufindende Matrialnummer.

[p80286]

Eine weitere Möglichkeit wäre

SQL-Code:

SELECT distinct
  Rollenlager.Lagerplatz
FROM Materialrollen
LEFT JOIN Rollenlager
  ON Rollenlager.Rollennummer = Materialrollen.Rollennummer
where Materialrollen.[Mat-Nr] = :MatNr
and Materialrollen.DatumAb is NULL

Da kommt dann jeder Lagerplatz der mindestens einmal genutzt wird einmal zurück.

Gruß
K-H

[Luckner]

Hallo p80286,

danke, dass Du versuchst mir zu helfen. Habe, anhand Deines Beispiels (3. von oben) versucht das umzusetzen, bekomme jedoch eine Fehlermeldung: "Syntaxfehler, fehlender Operator usw."

Delphi-Quellcode:

Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('SELECT DISTINCTROW Rollenlager.Lagerplatz LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer where ((Materialrollen.[Mat-Nr] = '+ EditMaterialeingangMatNr.Text + ') and Materialrollen.DatumAb is NULL))');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add(' group by Rollenlager.Lagerplatz');

Gruß, Luckner

[jobo]

Es fehlt "from <gewünschteTabelle>" vor dem Abschnit "LEFT JOIN Rollenlager"
also wahrscheinlich
"from Materialrollen"

Kann es sein, dass es hier irgendwelche Missverständnisse gibt?
Wie wär es wenn Du mal eine Beispielliste mit den Daten machst, die Du ohne group by hast und wie es mit group by aussehen soll?!

[Luckner]

Hallo jobo,

es war doch etwas spät gestern abend und ich hab es übersehen. Jetzt folgende select-Anweisung;

Delphi-Quellcode:

         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('SELECT DISTINCTROW Rollenlager.Lagerplatz FROM Materialrollen LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer where (Materialrollen.[Mat-Nr] = '+ EditMaterialeingangMatNr.Text + ' and Materialrollen.DatumAb is NULL)');
         Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add(' group by Rollenlager.Lagerplatz');

jedoch eine Fehlermeldung: "Das Feld Mat-Nr wurde nicht gefunden". Es sieht so aus, als ob doch keine Einträge weg bleiben können.

Meine Absicht ist:

Es gibt 2 Tabellen in einer Access-Datenbank (ist schon seit Jahren aktiv und kann z.Zt. nicht geändert werden.): Tabelle 1: Materialrollen. in dieser Tabelle sind folgende Felder:
[Mat-Nr], [Rollennummer}, [DatumAb]. Es gibt da noch einige Felder mehr, sind jedoch hier nicht wichtig. Dann 2. Tabelle: [Rollennummer] und [Lagerplatz]. Wenn in der Tabelle 1 im Feld "DatumAb ein Eintrag vorhanden ist, dann ist in Tabelle 2 kein Datensatz mehr. Möchte jetzt über die "Materialrollen.[Mat-Nr]" alle Lagerplätze der Rollennummern herausfinden. Wobei nicht aufgelistet Rollennummer = Lagerplatz, sondern nur Lagerplatz. Wenn alle Materialrollen auf einem Lagerplatz liegt, dann nur eine Zahl z.Bsp. B103.

Ohne "Group By" zeigt mir die Tabelle 50 Rollen auf dem gleichen Platz und einige andere Rollen auf anderen Plätzen. Eine Rolle kann natürlich aus Platzmangel auch auf einem anderem Platz liegen. Das müsste man auch sehen. Es geht nur um eine Übersicht, welche Plätze werden für ein bestimmtes Material belegt.

Ich hoffe, ich konnte mich verständlich machen.

Danke, Luckner

[Delphi.Narium]

Zitat:

Zitat von jobo (Beitrag 1433100)

Wie wär es wenn Du mal eine Beispielliste mit den Daten machst, die Du ohne group by hast und wie es mit group by aussehen soll?!

Ich habe immernochnicht verstanden, was Du genau willst, bzw. wenn ich es doch verstanden haben sollte, sind passende Abfragen hier im Thread bereits vorhanden.

Um den Test und die Entwicklung des passenden SQLs zu vereinfachen, solltest Du diese zuerst mal in Access testen und dann später in den Delphiquelltext übernehmen. Fehler sind so deutlich einfacher zu finden und statt "ellenlange" SQLs per + Edit.text + zusammenzubauen, eventuell Parameter verwenden, auch das macht die SQLs deutlich übersichtlicher und leichter les- und testbar.

Group by gruppiert Datensätze so, das sie eindeutig werden.
Distinct (Accress DistinctRow?) gruppiert Datensätze so, das sie eindeutig werden.

Das ist doppeltgemoppelt und zeigt, wenn es tatsächlich erforderlich sein sollte, dass die Abfrage fehlerhaft ist.

Wenn ich mit Group By etwas eindeutig mache und das Eindeutige anschließend per Distinct eindeutig machen muss, dann passt da was nicht.

SQL-Code:

SELECT Rollenlager.Lagerplatz FROM Materialrollen 
LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer 
where (Materialrollen.[Mat-Nr] = :MatNr 
   and Materialrollen.DatumAb is NULL)
group by Rollenlager.Lagerplatz

[jobo]

Irgendwie geht's nicht weiter.
@Luckner: Deine Beschreibungen sind sicher gut gemeint, aber es gibt tatsächlich einige Varianten, die man mit den gegebenen Feldern und Group By und Aggregaten produzieren könnte.

Das Ganze in Delphi Code eingekleidet macht es nicht übersichtlicher. Dieser Hinweis von Delphi.Narium ist auch wertvoll. Das pure SQL kannst Du direkt life in Access ausprobieren. Access bietet für die Abfragen den Klickermodus und den SQL Editor. (Zumindest ging das früher in Access, ich geh davon aus, es wurde nicht weg"optimiert")


Vorschlag:
Mach eine Access Abfrage der ungruppierten Daten und kopier ein paar Sätze hier ins Forum als Ausgangsdaten.
Diese Sätze editierst Du dann so um, dass sie deiner Zielvorstellung entsprechen und postest sie auch.

Distinct:
Schlimmstenfalls ist das tatsächlich doppelt gemoppelt, tut aber allermeistens nicht weh, auch wenn es praktisch möglich ist, dass ein Distinct das Ergebnis eines Group by verändert(zerstört).

[Luckner]

Hallo jobo,
DistinctRow habe ich rausgenommen. Fehler identisch. Ich glaube, ich muss mit einem Access-Programmierer reden. Habe schnell unter Firebird diese 2 Tabellen nachgebildet und da gibt es keine Fehlermeldung. Aber ich werde das Ergebnis der Abfrage ohne Group By und dann meine Vorstellung hier posten.

Gruß, Luckner

[Luckner]

Als Ergebnis bekomme ich:
[Lagerplatz]
P001
P007
P014
P014
P014
P014
P014
P015

Haben möchte ich:
[Lagerplatz]
P001
P007
P014
P015

Luckner

[Delphi.Narium]

Bitte noch das reine SQL zu dem "Als Ergebnis bekomme ich: "

Eigentlich sollte da ein reines Group by Lagerplatz am Ende reichen.

[Luckner]

Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQ L.Add('SELECT Materialrollen.[Mat-Nr], Materialrollen.Rollennummer, Materialrollen.DatumAb, Rollenlager.Lagerplatz, Rollenlager.Rollennummer FROM Materialrollen ');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQ L.Add('LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer where ((Materialrollen.[Mat-Nr] = ' + EditMaterialeingangMatNr.Text + ') and (Materialrollen.DatumAb is NULL))');

[Delphi.Narium]

Das SQL ist dashier ohne den Delphiquelltext:

SQL-Code:

SELECT Materialrollen.[Mat-Nr], Materialrollen.Rollennummer, Materialrollen.DatumAb, Rollenlager.Lagerplatz, Rollenlager.Rollennummer FROM Materialrollen
LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer where Materialrollen.[Mat-Nr] = :MatNr and Materialrollen.DatumAb is NULL

Die Zahl der Spalten hinter dem Select ist mehr als nur die Spalte Lagerplatz, von daher kann das nicht das SQL sein, welches Dir das Ergebnis

Zitat:

Als Ergebnis bekomme ich:
[Lagerplatz]
P001
P007
P014
P014
P014
P014
P014
P015

geliefert hat.

Wenn Du im Ergebnis nur die Spalte Lagerplatz haben möchtest, dann selektiere im SQL bitte auch nur die Spalte Lagerplatz.

Hast Du dashier schonmal probiert?

SQL-Code:

SELECT Rollenlager.Lagerplatz FROM Materialrollen
LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer
where (Materialrollen.[Mat-Nr] = :MatNr
   and Materialrollen.DatumAb is NULL)
group by Rollenlager.Lagerplatz

Oder in Delphi, zum Direktkopieren:

Delphi-Quellcode:

Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('SELECT Rollenlager.Lagerplatz FROM Materialrollen LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer where ((Materialrollen.[Mat-Nr] = ' + EditMaterialeingangMatNr.Text + ') and (Materialrollen.DatumAb is NULL)) group by Rollenlager.Lagerplatz');

Lesbarer als ein reines SQL?
Nein, natürlich nicht
Verständlicher als ein reines SQL?
Nein natürlich nicht.
Vorab auf der Datenbank testbares SQL?
Nein natürlich nicht.

Auch wenn der Quelltext dadruch länger wird und es etwas mehr Schreibarbeit wird:

Delphi-Quellcode:

Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Clear;
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('SELECT Rollenlager.Lagerplatz')
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('FROM Materialrollen');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('LEFT JOIN Rollenlager');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('ON Rollenlager.Rollennummer = Materialrollen.Rollennummer');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('where Materialrollen.[Mat-Nr] = :MatNr');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('and Materialrollen.DatumAb is NULL');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('group by Rollenlager.Lagerplatz');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.Parameters.ParamByName('MatNr').Value := EditMaterialeingangMatNr.Text;

Vielleicht mal so in der Art probieren?

[Luckner]

Hallo Delphi.Narium,

habe hier einen 27"-Monitor. Die meisten SQL-Abfragen passen in eine Zeile. Für mich viel übersichtliger als mehrere Zeilen übereinander. Geschmacksache. Gebe das Ergebnis in einem DBGrid aus, deshalb nur der Lagerplatz. Wenn ich den Select-Vorschlag benutze, dann bekomme ich eine Fehlermeldung, dass "Mat-Nr" fehlt.

Luckner

[Delphi.Narium]

Der Vorschlag enthält einen Parameter, der muss auch befüllt werden.

Daher in meinem Delphiquelltrextvorschlag auch die Zeile:

Delphi-Quellcode:

Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.Parameters.ParamByName('MatNr').Value := EditMaterialeingangMatNr.Text;

Diese Fehlermeldung bekommst Du garantiert nicht:

Zitat:

Wenn ich den Select-Vorschlag benutze, dann bekomme ich eine Fehlermeldung, dass "Mat-Nr" fehlt.

sondern allenfalls eine Fehlermeldung, aus der Du diesen Schluss ziehst. Bitte Fehlermeldung per Copy&Paste aus der Fehlermeldung übernehmen und hier einfügen.

Derweil, die von Dir gepostete Fehlerbeschreibung lässt nicht erkennen, ob nun die Spalte Mat-Nr fehlt oder der Parameter MatNr.

Zugegeben, Accessfehlermeldungen sind nicht immer zwingend aufschlussreich, sondern eher vage. Aber wenn Du uns jeweils einfach die Originalfehlermeldung mitteilst, ist das deutlich einfacher.

[Luckner]

ok, mache ich.

[jobo]

Zitat:

Zitat von Delphi.Narium (Beitrag 1433120)

Die Zahl der Spalten hinter dem Select ist mehr als nur die Spalte Lagerplatz, von daher kann das nicht das SQL sein...


Hast Du dashier schonmal probiert?

SQL-Code:

SELECT Rollenlager.Lagerplatz FROM Materialrollen
LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer
where (Materialrollen.[Mat-Nr] = :MatNr
   and Materialrollen.DatumAb is NULL)
group by Rollenlager.Lagerplatz

Das war wohl das nächstes Missverständnis. Die Darstellung des Sollergebnis hat nichts mit dem vorhandenen, falschen SQL Code zu tun.

Also mit der Angabe aus #29 ist die Anforderung recht übersichtlich. Und wie Du vermutet hast, müsste die Lösung so aussehen wie von Dir zitiert.

Es würde tatsächlich ein Distinct ohne group by reichen.

@Lucker: Egal wie groß der Monitor ist und welche Gewohnheiten Du hast. Die Mehrheit hat andere. Wenn Du es den Helfern also erleichtern möchtest, ist eine übersichtliche Formatierung besonders entgegenkommend.
Vermutlich würde so eine simple Aufteilung eines Statements in mehrere Zeilen für
Select Clause
From Clause / Join
Where Clause
[Group by ..]
[Order ..]
auch Deinem eigenen Verständnis dienen.

P.S.: Es gibt nette IDE, die SQL Text auf Knopfdruck formatieren, es gibt sogar einige, die Copy/Paste von/nach Delphi anbieten. Ist beides nicht zur Hand, tut's auch ein online Formatierer.

[Delphi.Narium]

Zitat:

Zitat von jobo (Beitrag 1433125)

Vermutlich würde so eine simple Aufteilung eines Statements in mehrere Zeilen für
Select Clause
From Clause / Join
Where Clause
[Group by ..]
[Order ..]
auch Deinem eigenen Verständnis dienen.

Und hat den Vorteil, man kann mal einzelne Zeilen mit -- davor eben auskommentieren, um zu prüfen, ob das Ergebnis besser wird, eine Fehlermeldung verschwindet ...

In Delphi kann ich in einer Quelltextzeile auch mehrere Befehle hintereinanderschreiben, beim 27" wohl sogar ziemlich viele. Aber ob das der Les- und Wartbarkeit des Quelltextes dienlich ist, wage ich zu bezweifeln.

So wie man in Delphi logisch zusammgehörige Quelltextzeilen zusammenfasst, kann man das auch in SQL machen, auch wenn die Syntax das nicht zwingend erfordert oder man 50 Meter Quelltext in eine Zeile schreiben kann ;-)

Logische Strukturen im Quelltext (und dazu gehören auch SQL-Statements) haben für mich was mit Softwarequalität zu tuen. "Kilometerlange" Einzeiler gehören für mich nicht dazu.

[haentschman]

Hallo...8-)

Zitat:

Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQ L.Add('SELECT Rollenlager.Lagerplatz FROM Materialrollen LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer where ((Materialrollen.[Mat-Nr] = ' + EditMaterialeingangMatNr.Text + ') and (Materialrollen.DatumAb is NULL)) group by Rollenlager.Lagerplatz');

Das markierte geht gar nicht. :? In den Beispielen ist immer wieder von Parametern die Rede. Die brauchst du auch!
Grund: https://de.wikipedia.org/wiki/SQL-Injection

Zitat:

LEFT JOIN Rollenlager ON

Hier kannst du auch Aliase verwenden:

Zitat:

SELECT R.Lagerplatz FROM Materialrollen LEFT JOIN Rollenlager R ON R.Rollennumme...

...das macht das Ganze übersichtlicher. :thumb:

[jobo]

Zitat:

Zitat von haentschman (Beitrag 1433127)

Zitat:

Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQ L.Add('SELECT Rollenlager.Lagerplatz FROM Materialrollen LEFT JOIN Rollenlager ON Rollenlager.Rollennummer = Materialrollen.Rollennummer where ((Materialrollen.[Mat-Nr] = ' + EditMaterialeingangMatNr.Text + ') and (Materialrollen.DatumAb is NULL)) group by Rollenlager.Lagerplatz');

Das markierte geht gar nicht. :? In den Beispielen ist immer wieder von Parametern die Rede. Die brauchst du auch!

Ahh, das hab ich in den 10 Varianten aus den Augen verloren, die Materialnummer als Filter. Natürlich soll das ein Parameter sein!
Ein beliebiger Filter (where clause) auf irgendwelche Felder wirkt sich aber nicht auf Funktionsweise oder Syntax für Group by aus.

[p80286]

Zitat:

Zitat von Delphi.Narium (Beitrag 1433120)

Auch wenn der Quelltext dadruch länger wird und es etwas mehr Schreibarbeit wird:

Delphi-Quellcode:

Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Clear;
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('SELECT Rollenlager.Lagerplatz')
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('FROM Materialrollen');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('LEFT JOIN Rollenlager');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('ON Rollenlager.Rollennummer = Materialrollen.Rollennummer');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('where Materialrollen.[Mat-Nr] = :MatNr');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('and Materialrollen.DatumAb is NULL');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Add('group by Rollenlager.Lagerplatz');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.Parameters.ParamByName('MatNr').Value := EditMaterialeingangMatNr.Text;

Vielleicht mal so in der Art probieren?

oder so:

Delphi-Quellcode:

Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.SQL.Text:='SELECT Rollenlager.Lagerplatz'+
   'FROM Materialrollen '+
   'LEFT JOIN Rollenlager '+
   'ON Rollenlager.Rollennummer = Materialrollen.Rollennummer '+
   'where Materialrollen.[Mat-Nr] = :MatNr ' +
   'and Materialrollen.DatumAb is NULL '+
   'group by Rollenlager.Lagerplatz');
Datamodule1.ADOQueryRollenJoinLagerplatzTabelle.Parameters.ParamByName('MatNr').Value := EditMaterialeingangMatNr.Text;

Gruß
K-H