ADOQuery berechnetes Feld

[Luckner]

Hallo,

folgende Procedure:

Delphi-Quellcode:

procedure TForm1.ButtonMaterialSuchenClick(Sender: TObject);
var BestandMaterialNummer, BestandMaterial : real;
begin
  Datamodule1.ADOQueryGejoliste.Close;
  Datamodule1.ADOQueryGejoliste.SQL.Clear;
  Datamodule1.ADOQueryGejoliste.SQL.Add('SELECT [Material-Stamm].[Mat-Nr], [Material-Stamm].Bezeichnung, [Material-Stamm].[Lieferant Bezeichnung], ');
  Datamodule1.ADOQueryGejoliste.SQL.Add('[Material-Stamm].aktuell');
  Datamodule1.ADOQueryGejoliste.SQL.Add('FROM [Material-Stamm]');
  Datamodule1.ADOQueryGejoliste.SQL.Add('WHERE (([Material-Stamm].[Lieferanten-Nr]= ' + Lieferantennr.Text + ') AND ([Material-Stamm].aktuell= -1))');

  Datamodule1.ADOQueryGejoliste.Open;
  Datamodule1.ADOQueryGejoliste.Last;
  Datamodule1.ADOQueryGejoliste.First;

  BestandMaterial := 0;

  while not Datamodule1.ADOQueryGejoliste.Eof do
  begin
    Datamodule1.ADOQueryRollenJoinLagerplatz.Active := False;
    Datamodule1.ADOQueryRollenJoinLagerplatz.SQL.Clear;
    Datamodule1.ADOQueryRollenJoinLagerplatz.SQL.Add('SELECT DISTINCTROW Materialrollen.[Arb-Breite], Materialrollen.lfm, Materialrollen.[Mat-Nr], ');
    Datamodule1.ADOQueryRollenJoinLagerplatz.SQL.Add('Materialrollen.Rollennummer, Materialrollen.Mutterrolle, Materialrollen.DatumAb, Materialrollen.GrundAb, ');
    Datamodule1.ADOQueryRollenJoinLagerplatz.SQL.Add('Materialrollen.DatumZu, Materialrollen.GrundZu, ');
    Datamodule1.ADOQueryRollenJoinLagerplatz.SQL.Add('Materialrollen.DatumWE, Rollenlager.Lagerplatz, RollenPlanung.Kommentar, RollenPlanung.AuftragPlanung, '); 
    Datamodule1.ADOQueryRollenJoinLagerplatz.SQL.Add('RollenPlanung.RestLaenge, RollenPlanung.RestBreite FROM (Materialrollen LEFT JOIN Rollenlager ON ');
    Datamodule1.ADOQueryRollenJoinLagerplatz.SQL.Add('Materialrollen.Rollennummer = Rollenlager.Rollennummer) LEFT JOIN RollenPlanung ');
    Datamodule1.ADOQueryRollenJoinLagerplatz.SQL.Add('ON Materialrollen.Rollennummer = RollenPlanung.Rollennummer where ((Materialrollen.[Mat-Nr] = ' +   Datamodule1.ADOQueryGejolisteMatNr.AsString + ') and (Materialrollen.DatumAb is NULL) and (Materialrollen.[Arb-Breite] > 179))');

    Datamodule1.ADOQueryRollenJoinLagerplatz.Open;
    Datamodule1.ADOQueryRollenJoinLagerplatz.Last;
    Datamodule1.ADOQueryRollenJoinLagerplatz.First;

    BestandMaterialNummer := 0;
    while not Datamodule1.ADOQueryRollenJoinLagerplatz.Eof do
    begin
      BestandMaterialNummer := BestandMaterialNummer + ((Datamodule1.ADOQueryRollenJoinLagerplatzArbBreite.AsInteger/1000) * Datamodule1.ADOQueryRollenJoinLagerplatzlfm.AsInteger);
      Datamodule1.ADOQueryRollenJoinLagerplatz.Next;
    end;

   // ShowMessage('BestandMaterialNummer = '  + FloatToStr(BestandMaterialNummer));

    Datamodule1.ADOQueryGejoliste.Edit;
    Datamodule1.ADOQueryGejolisteBESTAND.AsFloat := BestandMaterialNummer;
    Datamodule1.ADOQueryGejoliste.Post;
    Datamodule1.ADOQueryGejoliste.Next;
  end;

  GridGejo.Visible := true;
end;

An Datamodule1.ADOQueryGejoliste hängt ein DBGrid an, mit folgenden Felder:
Mat-Nr:
Bezeichnung
Bestand

Das Feld "Bestand" ist ein 'Calculated-Feld' in Datamodule1.ADOQueryGejoliste. Die anderen Felder werden aus dem 1.-tem SELECT eingetragen.
Es funktioniert soweit fast alles, jedoch das 'Datamodule1.ADOQueryGejoliste.Post;' nicht, bzw. in der Tabelle 'GridGejo' kann ich es nicht sehen.

Gruß, Luckner

[hoika]

Hallo,

Zitat:

Das Feld "Bestand" ist ein 'Calculated-Feld' in Datamodule1.ADOQueryGejoliste

Du willst in ein berechnetes Feld einen Wert speichern?
Wie soll denn das gehen.

[Luckner]

Ich dachte, dass man gerade diese Felder manipulieren kann.
Luckner.

[hoika]

Hallo,
die Anzeige schon:
Event OnCalcFields oder FieldByName (aber ohne das Post)

Aber du kannst das doch nicht speichern.
Lass das Post einfach mal weg.

Es könnte natürlich sein, das dir ein Update der Oberfläche fehlt.

[Luckner]

Wenn ich an der Stelle 'Datamodule1.ADOQueryGejoliste.Post;' das Grid updatete mit 'GridGejo.Update;', dann sehe ich nur ganz kurz, dass in die entsprechenden Zeile die Zahl eingetragen wird, aber dann sofort wieder gelöscht, wenn die nächste Zeile angesprochen wird.

Luckner

[jobo]

Was soll die Funktion machen?
1) Eine Anzeige des aktuellen Bestands?
oder
2) Eine Anzeige und Speicherung des aktuellen Bestands?

2) wird nicht funktionieren, weil weder die Query noch das "berechnete" Feld das können.
1) wäre schon eher möglich, aber auf dieser Basis auch ein komplizierter Ansatz.

P.S.:
Berechnete Felde können nur das Ergebnis einer Formel mit Werten aus dem jeweils aktuellen Datensatz darstellen, nichts abspeichern.

[Luckner]

Hallo jobo,

es reicht nur eine Anzeige. Mir fällt noch die Möglichkeit die Daten in ein Stringgrid zu schreiben. Wa ich nicht weiß, ob ich die Daten aus dem Stringgrid im Fastrepport verwenden kann:

Luckner

[Luckner]

Ach so, eher Punkt 1. am Ende muss die Tabelle auf einem Drucker raus.

Luckner

[jobo]

Zitat:

Zitat von Luckner (Beitrag 1433752)

es reicht nur eine Anzeige. ..

Auf die Schnelle:
Die Berechnung bzw. die Idee "berechnetes Feld" ist ja nicht verkehrt.
Das kannst Du vom Vorgehen her so wie im Delphiquellcode (Delphicode mit Formel auf Basis der 2.Query) mit einer Query machen, die Du als Subquerey der ersten Abfrage anhängst/eibaust.
Dann wird automatisch alles durch die Abfrage beim Öffnen der Query berechnet.


Also
ADOQueryGejoliste
und
ADOQueryRollenJoinLagerplatz

so zusammenfassen, dass direkt der (in SQL) berechnete Bestand herauskommt.
Diese Query / das Grid kann natürlich auch gedruckt werden.

[Delphi.Narium]

Delphi-Quellcode:

  BestandMaterialNummer := 0;
    while not Datamodule1.ADOQueryRollenJoinLagerplatz.Eof do
    begin
      BestandMaterialNummer := BestandMaterialNummer + ((Datamodule1.ADOQueryRollenJoinLagerplatzArbBreite.AsInteger/1000) * Datamodule1.ADOQueryRollenJoinLagerplatzlfm.AsInteger);
      Datamodule1.ADOQueryRollenJoinLagerplatz.Next;
    end;

Bin mir nicht sicher, da Deine SQLs irgendwie extrem schwer lesbar sind (aber das hatten wir ja schon).

Sieht aber schwer nach sowas in der Art aus:

SQL-Code:

select sum(Arb-Breite / 1000) * lfm as BestandMaterialNummer 
from Materialrollen 
LEFT JOIN Rollenlager ON Materialrollen.Rollennummer = Rollenlager.Rollennummer 
LEFT JOIN RollenPlanung ON Materialrollen.Rollennummer = RollenPlanung.Rollennummer 
where Materialrollen.[Mat-Nr] = :MatNr
and Materialrollen.DatumAb is NULL
and Materialrollen.[Arb-Breite] > 179
group by 
  Materialrollen.[Mat-Nr]

Wenn das soweit in etwa korrekt ist, baust Du das bitte noch in das erste SQL mit ein und sparst Dir die (mehr als nur gewöhnungsbedürftige) Whileschleife innerhalb einer Whileschleife, zwecks Anzeige in einem Grid, ein.

Ein Grid holt sich von der DB die Daten, die es zur aktuellen Anzeige benötigt. Dein Whileschleifenkonstrukt ist in dem Zusammenhang bestenfalls unschädlich, schlimmstenfalls kontraproduktiv, aber höchstwahrscheinlich nichts weiter als ein Zeit- und Resourcenfresser.

Bitte gewöhne Dir an in SQL-Statements nur die Daten zu selektieren, die Du auch zur Anzeige / Weiterverarbeitung benötigst. Das macht die SQLs übersichtlicher, spart Serverresourcen und beim Client Arbeitsspeicher und macht ggfls. mögliche Vereinfachungen der Statements deutlich leichter erkennbar.

[Luckner]

Hallo,
habe mir alle Vorschläge zu Herzen genommen, vor allem die von Delphi.Narium und folgende SELECT-Abfrage gebastelt:

Delphi-Quellcode:

  SELECT Materialrollen.[Mat-Nr], sum((Materialrollen.[Arb-Breite] / 1000) * Materialrollen.lfm) as BESTAND, [Material-Stamm].Bezeichnung
  FROM Materialrollen
  LEFT JOIN [Material-Stamm] ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]
  WHERE (([Material-Stamm].[Lieferanten-Nr] = ' + Lieferantennr.Text + ') AND ([Material-Stamm].aktuell= -1)
  AND (Materialrollen.DatumAb is NULL) AND (Materialrollen.[Arb-Breite] > 179))
  group by Materialrollen.[Mat-Nr], [Material-Stamm].Bezeichnung

Jetzt werden mir die Daten in der DBGrid angezeigt und ich bin fast glücklich. Es werden mir jetzt Materialien angezeigt, deren (Materialrollen.[Arb-Breite] > 179 (mm)ist. Alle Materialrollen, deren die [Arb-Breite] <= 179 werden nicht angezeigt, was korrekt ist. Der Fall jedoch, wo es kein Material auf Lager gibt, weil verbraucht, geht verloren.
Hat Jemand, bitte, eine Idee, wie man das noch zusätzlich einbaut.

Danke, Luckner

[hoika]

Hallo,

or (Feld x is Null)
or (Feld1=Feld2) ??

Ich kenne deine Datenstruktur ja nicht.

Wie erkennst Du, dass das Material aufgebraucht ist?

Du kannst auch eine komplett neue Query "hintendranhängen"

Select Query 1
Union
Select Query 2

Es müssen nur die gleichen Datenfelder (Anzahl, Datentyp usw.) sein.

[jobo]

Zitat:

Zitat von Luckner (Beitrag 1433989)

habe mir alle Vorschläge zu Herzen genommen, vor allem die von Delphi.Narium..

Sehr gut, ist doch nicht schlecht, wenn man sich gleich ne halbe Seite Code spart oder?

Zu der Frage:

Zitat:

Zitat von Luckner (Beitrag 1433989)

Delphi-Quellcode:

..  FROM Materialrollen  LEFT JOIN 
     [Material-Stamm] ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]

Ist bereits left join, also "offen" für Lücken. Da ich Dein Datenmodel nicht kenne, aber sinngemäß die tabellennamen lesen kann, scheint mir, der left join ist falsch rum. Also entweder ein right join daraus machen oder die Tabellen Nennung tauschen


so

Delphi-Quellcode:

..  FROM Materialrollen  RIGHT JOIN 
     [Material-Stamm] ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]

oder
so

Delphi-Quellcode:

..  FROM [Material-Stamm] LEFT JOIN 
      Materialrollen  ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]

[jobo]

Es kann auch sein, dass die Zusatzbedingungen den Left Join "kaputt machen".

Einfachste Möglichkeit das zu testen, wäre aus der Where Bedingung ein Teil des Joins zu machen. Also 'where' raus und große Klammer ab ..on..

Und nur weil wir grad dabei sind, vielleicht lässt Du Dich ja auch noch von Formatierung überzeugen.

[Luckner]

Hallo jobo,

habe ich geändert, jedoch ohne Veränderung in der Tabelle.

Gruß, Luckner

[jobo]

Was hast Du geändert? Ich habe so 3-4 Vorschläge gemacht.
Und was bedeutet, "ohne Änderung in der Tabelle"?

[Luckner]

Hallo jobo,

Zitat:

.. FROM [Material-Stamm] LEFT JOIN
Materialrollen ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]

Ergebnis: selbe Anzahl des Materials und die selben Ergebnisse aus der Multiplikation.

Wenn Material aufgebraucht ist, merke ich, wenn alle (Materialrollen.DatumAb <> NULL)ist. Also alle Materialrollen ein Abgangsdatum haben. Andererseits könnte es auch funktionieren, wenn man herausfindet, dass wenn das Produkt aus der Multiplikation = 0 ist. Irgendwas in dieser Richtung.

Gruß, Luckner

[Delphi.Narium]

Ist jetzt nur geraten.

Sinngemäß in etwa sowas?

SQL-Code:

SELECT 
  Materialrollen.[Mat-Nr], 
  sum((Materialrollen.[Arb-Breite] / 1000) * Materialrollen.lfm) as BESTAND, 
  [Material-Stamm].Bezeichnung, 
  Aufgebraucht
from (
  SELECT 
    Materialrollen.[Mat-Nr], 
    Materialrollen.[Arb-Breite],
    Materialrollen.lfm,
    [Material-Stamm].Bezeichnung, 
    'nein' as Aufgebraucht
  FROM Materialrollen
  LEFT JOIN [Material-Stamm] ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]
  WHERE (
             ([Material-Stamm].[Lieferanten-Nr] = ' + Lieferantennr.Text + ') 
         AND ([Material-Stamm].aktuell= -1)
         AND (Materialrollen.DatumAb is NULL)
         AND (Materialrollen.[Arb-Breite] > 179)
        )
  UNION ALL
  SELECT 
    Materialrollen.[Mat-Nr], 
    Materialrollen.[Arb-Breite],
    Materialrollen.lfm,
    [Material-Stamm].Bezeichnung, 
    'ja' as Aufgebraucht
  FROM Materialrollen
  LEFT JOIN [Material-Stamm] ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]
  WHERE (
             ([Material-Stamm].[Lieferanten-Nr] = ' + Lieferantennr.Text + ') 
         AND ([Material-Stamm].aktuell= -1)
         AND (Materialrollen.DatumAb is not NULL)
         AND (Materialrollen.[Arb-Breite] > 179)
        )
)  
group by 
  Materialrollen.[Mat-Nr], 
  [Material-Stamm].Bezeichnung 
  Aufgebraucht

Die aufgebrauchten Materialien sollten nun in der Spalte "Aufgebraucht" einen entsprechenden Hinweise, bestehend aus den Wörten 'ja' bzw. 'nein', stehen haben.

[Luckner]

Hallo Delphi.Narium,

:shock: Hut ab von meiner Seite. Ich werde versuchen diese Anweisung zu übertragen und auszuprobieren. Wenn mein Kopf dann etwas freier ist, dann werde ich versuchen diese Anweisung auch zu verstehen. Dieses sprengt meine Grenzen. Vielen Dank für die Mühe.

Gruß, Luckner

[Delphi.Narium]

Eventuell geht auch dashier, ist kürzer und dürfte resourcen- / laufzeitschonender sein:

SQL-Code:

SELECT
  MaterialNr,
  sum((Arbeitsbreite / 1000) * lfm) as BESTAND,
  Bezeichnung,
  Aufgebraucht
from (
  SELECT
    Materialrollen.[Mat-Nr] As MaterialNr
    Materialrollen.[Arb-Breite] As Arbeitsbreite,
    Materialrollen.lfm,
    [Material-Stamm].Bezeichnung,
    case Materialrollen.DatumAb when null then 'nein' else 'ja' end as Aufgebraucht
  FROM Materialrollen
  LEFT JOIN [Material-Stamm] ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]
  WHERE (
             ([Material-Stamm].[Lieferanten-Nr] = ' + Lieferantennr.Text + ')
         AND ([Material-Stamm].aktuell= -1)
         AND (Materialrollen.[Arb-Breite] > 179)
        )
)
group by
  MaterialNr,
  Bezeichnung,
  Aufgebraucht

[jobo]

Zitat:

Zitat von Delphi.Narium (Beitrag 1434039)

Eventuell geht auch dashier, ist kürzer und dürfte resourcen- / laufzeitschonender sein: ..

Ja, also ein Union aus MengeMitIsNotNull und MengeMitIsNull wäre wahrscheinliche einfach: Menge.
Ich fürchte ja wie oben geschrieben, dass outer verkehrt rum läuft. Dazu könnte Luckner einfach mal eine SQL Stichprobe ohne das ganze Drumrum machen.

[Delphi.Narium]

Nö, nicht ganz.

Laut der letzten Frage

Zitat:

Wenn Material aufgebraucht ist, merke ich, wenn alle (Materialrollen.DatumAb <> NULL)ist. Also alle Materialrollen ein Abgangsdatum haben. Andererseits könnte es auch funktionieren, wenn man herausfindet, dass wenn das Produkt aus der Multiplikation = 0 ist. Irgendwas in dieser Richtung.

fehlen ja die Sachen, bei denen Materialrollen.DatumAb <> NULL (lieber Materialrollen.DatumAb is not NULL) ist.

Da in der ursprünglichen Abfrage aber auf Materialrollen.DatumAb IS NULL abgefragt wurde, kann die vermisste Menge ja garnicht im Ergebnis sein.

Meine Idee war halt zuerst: Nehmen wird die Abfrage mit dem bisherigen, gewünschten und inzwischen korrekten Teilergebnis und fügen noch mal das "Gegenstück" für den fehlenden Rest hinzu.

Geht am Einfachsten erstmal mit Union All.

Soweit, so naiv.

Die Einschränkung, die für den "Datenverlust" verantworlich zeichnet, einfach rauszunehmen, war dann ein Gedanke, der erst "Minuten später" (der Groschen fällt halt pfennigweise) kam.

Lassen wir dem TE jetzt erstmal ein bisserl Zeit zum verdauen. Danach wird er uns (hoffentlich) über den Erfolg / Misserfolg unterrichten ;-)

[Luckner]

Hallo Delphi.Narium,
habe beide Versionen ausprobiert. Die 2. Select-Anweisung liefert ersmal einen unbekannten Fehler. Werde versuchen ihn, mit meinen Kenntnissen, zu korrigieren.
Die 1.-te, längere Anweisung liefert folgendes:

Material-Nr: / Bezeichnung / Bestand / aufgebraucht
265627 / schreib-weiß, permanent / 1300465,5 / ja
265627 / schreib-weiß, permanent / 5148 / nein


usw. für alle anderen Materialrollen.

Es sollten nur die Datensätze bleiben die ein "nein" enthalten und nur die, die ein "ja" enthalten, dann aber der Bestand = 0.

UNION ALL
SELECT
Materialrollen.[Mat-Nr], !!!! habe ich korrigiert.
Materialrollen.[Mat-Nr],

Gruß, Luckner

[Delphi.Narium]

Das 2. SQL hab' ich oben überarbeitet.

Zitat:

Es sollten nur die Datensätze bleiben die ein "nein" enthalten und nur die, die ein "ja" enthalten, dann aber der Bestand = 0.

SQL-Code:

select * from (
  SELECT
    MaterialNr,
    sum((Arbeitsbreite / 1000) * lfm) as BESTAND,
    Bezeichnung,
    Aufgebraucht
  from (
    SELECT
      Materialrollen.[Mat-Nr] As MaterialNr,
      Materialrollen.[Arb-Breite] As Arbeitsbreite,
      Materialrollen.lfm,
      [Material-Stamm].Bezeichnung,
      'nein' as Aufgebraucht
    FROM Materialrollen
    LEFT JOIN [Material-Stamm] ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]
    WHERE (
               ([Material-Stamm].[Lieferanten-Nr] = ' + Lieferantennr.Text + ')
           AND ([Material-Stamm].aktuell= -1)
           AND (Materialrollen.DatumAb is NULL)
           AND (Materialrollen.[Arb-Breite] > 179)
          )
    UNION ALL
    SELECT
      Materialrollen.[Mat-Nr],
      Materialrollen.[Arb-Breite],
      Materialrollen.lfm,
      [Material-Stamm].Bezeichnung,
      'ja' as Aufgebraucht
    FROM Materialrollen
    LEFT JOIN [Material-Stamm] ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]
    WHERE (
               ([Material-Stamm].[Lieferanten-Nr] = ' + Lieferantennr.Text + ')
           AND ([Material-Stamm].aktuell= -1)
           AND (Materialrollen.DatumAb is not NULL)
           AND (Materialrollen.[Arb-Breite] > 179)
          )
  )
  group by
    MaterialNr,
    Bezeichnung,
    Aufgebraucht 
)
where (Aufgebraucht = 'nein')
or    (Aufgebraucht = 'ja' and Bestand = 0)

Und ja, das muss auch ohne dieses blöde Union all gehen.

Deshalb noch ein Versuch:

SQL-Code:

select * from (
  SELECT
    MaterialNr,
    sum((Arbeitsbreite / 1000) * lfm) as BESTAND,
    Bezeichnung,
    Aufgebraucht
  from (
    SELECT
      Materialrollen.[Mat-Nr] As MaterialNr
      Materialrollen.[Arb-Breite] As Arbeitsbreite,
      Materialrollen.lfm,
      [Material-Stamm].Bezeichnung,
      case Materialrollen.DatumAb when null then 'nein' else 'ja' end as Aufgebraucht
    FROM Materialrollen
    LEFT JOIN [Material-Stamm] ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]
    WHERE (
               ([Material-Stamm].[Lieferanten-Nr] = ' + Lieferantennr.Text + ')
           AND ([Material-Stamm].aktuell= -1)
           AND (Materialrollen.[Arb-Breite] > 179)
          )
  )
  group by
    MaterialNr,
    Bezeichnung,
    Aufgebraucht 
)
where (Aufgebraucht = 'nein')
or    (Aufgebraucht = 'ja' and Bestand = 0)

Wenn das jetzt funktioniert, wird's ja schon fast wieder übersichtlich ;-)

[Luckner]

Hallo Delphi.Narium,

habe beide Versionen ausprobiert. Bei Version 2 (ohne UNION) gibt es gleich einen "unbekannten Fehler". Bei der Version 1 sieht erstmal gut aus. Das Produkt aus der Muliplikation stimmt auch. Aber dann! Habe den entsprechenden Materialrollen, die > 179 sind, ein Materialrollen.DatumAb eingetragen und dann wird dieses Material gar nicht mehr in der Tabelle angezeigt. Eigentlich sollte das Material aufgeführt sein mit Bestand = 0 und Aufgebraucht = ja

Gruß, Luckner

[Delphi.Narium]

Ich hasse diesen "unbekannten Fehler" aus den Mircosoftprodukten, der ist einfach nie hilfreich bei der Fehlersuche :-( ;-)

Die Klammern stimmten irgendwie nicht, mindestens eine schließende war zuviel und mindestens ein Komma fehlte, also noch ein Versuch:

SQL-Code:

select * from (
  SELECT
    MaterialNr,
    sum(Bestand) as BESTAND,
    Bezeichnung,
    Aufgebraucht
  from (
    SELECT
      Materialrollen.[Mat-Nr] As MaterialNr,
      Materialrollen.[Arb-Breite] / 1000 * Materialrollen.lfm as Bestand,
      [Material-Stamm].Bezeichnung As Bezeichnung,
      case Materialrollen.DatumAb when null then 'nein' else 'ja' end as Aufgebraucht
    FROM Materialrollen
    LEFT JOIN [Material-Stamm] ON Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr]
    WHERE [Material-Stamm].[Lieferanten-Nr] = ' + Lieferantennr.Text + '
    AND   [Material-Stamm].aktuell = -1
    AND   Materialrollen.[Arb-Breite] > 179
  )
  group by
    MaterialNr,
    Bezeichnung,
    Aufgebraucht
)
where (Aufgebraucht = 'nein') or (Aufgebraucht = 'ja' and Bestand = 0)

Zitat:

Aber dann! Habe den entsprechenden Materialrollen, die > 179 sind, ein Materialrollen.DatumAb eingetragen und dann wird dieses Material gar nicht mehr in der Tabelle angezeigt. Eigentlich sollte das Material aufgeführt sein mit Bestand = 0 und Aufgebraucht = ja

Dein Ursprungssql hatte da sowas:

SQL-Code:

AND (Materialrollen.DatumAb is NULL)

. Daraus resultiert:

Zitat:

ein Materialrollen.DatumAb eingetragen und dann wird dieses Material gar nicht mehr in der Tabelle angezeigt

Also entferne die Zeile(n) mit

SQL-Code:

AND (Materialrollen.DatumAb is NULL)

aus dem SQL. Dann sind sie im Ergebnis enthalten, was übrigens dann auch das Union All überflüssig macht.

[jobo]

Hier ist ein Klammerfehler bei
sum((Bestand

eine reicht.

[Luckner]

Hallo Delphi.Narium, hallo jobo,

die Aufgabenstellung ist folgende: Ein Lieferant liefert "[Material-Stamm].[Lieferanten-Nr]" verschiedene Papiersorten. Das Material (Papiersorten) liegt bei uns als Rollen von verschiedenen Grössen und Breiten auf Lager.

Aufgabe: Zeige die markierten Materialien "[Material-Stamm].aktuell = -1" des Lieferanten die eine Breite > 179mm haben, die kein Abgangsdatum "Materialrollen.DatumAb" und berechne die Fläche des Materials. Aufgebraucht = nein. Falls Rollen der geforderten Breite vorhanden dann berechne die Fläche. Falls Materialrollen <= 179, dann braucht es keine Summe (kann aber trotzdem berechnet und angezeigt werden) aber der Hinweis "aufgebraucht = ja" angezeigt werden. Falls keine Rollen vorhanden, dann Fläche = 0 und aufgebraucht = ja.

Ich hoffe, ich konnte das Problem jetzt besser beschreiben als meine Select-Anweisungen.

Gruß, Luckner

[Delphi.Narium]

Zitat:

die Aufgabenstellung ist folgende:
Ein Lieferant liefert "[Material-Stamm].[Lieferanten-Nr]" verschiedene Papiersorten.

SQL-Code:

select * from [Material-Stamm] where [Lieferanten-Nr] = :LieferantenNr

Zitat:

Das Material (Papiersorten) liegt bei uns als Rollen von verschiedenen Grössen und Breiten auf Lager.

Aufgabe:

Zeige die markierten Materialien "[Material-Stamm].aktuell = -1"

SQL-Code:

select * from [Material-Stamm] 
where aktuell  = -1
and   [Lieferanten-Nr] = :LieferantenNr

Zitat:

des Lieferanten die eine Breite > 179mm haben,

SQL-Code:

select * from [Material-Stamm]
where aktuell  = -1
and   Lieferanten-Nr] = :LieferantenNr
and   Breite > 179

Zitat:

die kein Abgangsdatum "Materialrollen.DatumAb"

SQL-Code:

select *
from [Material-Stamm] s
inner join Materialrollen r on s.[Lieferanten-Nr] = r.[Lieferanten-Nr]
where s.[Lieferanten-Nr] = :LieferantenNr
and   s.aktuell  = -1
and   s.Breite > 179
and   r.DatumAb is null

Zitat:

und berechne die Fläche des Materials.

SQL-Code:

select
  r.[Mat-Nr] As MaterialNr,
  r.[Arb-Breite] / 1000 * r.lfm as Bestand,
  s.Bezeichnung As Bezeichnung
from [Material-Stamm] s
inner join Materialrollen r on s.[Lieferanten-Nr] = r.[Lieferanten-Nr]
where s.[Lieferanten-Nr] = :LieferantenNr
and   s.aktuell  = -1
and   s.Breite > 179
and   r.DatumAb is null

Zitat:

Aufgebraucht = nein.

SQL-Code:

select
  r.[Mat-Nr] As MaterialNr,
  r.[Arb-Breite] / 1000 * r.lfm as Bestand,
  s.Bezeichnung As Bezeichnung,
  'nein' as Aufgebraucht
from [Material-Stamm] s
inner join Materialrollen r on s.[Lieferanten-Nr] = r.[Lieferanten-Nr]
where s.[Lieferanten-Nr] = :LieferantenNr
and   s.aktuell  = -1
and   s.Breite > 179
and   r.DatumAb is null

Zitat:

Falls Materialrollen <= 179, dann braucht es keine Summe
(kann aber trotzdem berechnet und angezeigt werden)
aber der Hinweis "aufgebraucht = ja" angezeigt werden.

SQL-Code:

select
  r.[Mat-Nr] As MaterialNr,
  0 as Bestand,
  s.Bezeichnung As Bezeichnung,
  'ja' as Aufgebraucht
from [Material-Stamm] s
inner join Materialrollen r on s.[Lieferanten-Nr] = r.[Lieferanten-Nr]
where s.[Lieferanten-Nr] = :LieferantenNr
and   s.aktuell  = -1
and   s.Breite <= 179
and   r.DatumAb is null

Zitat:

Falls keine Rollen vorhanden, dann Fläche = 0 und aufgebraucht = ja.

SQL-Code:

select
  r.[Mat-Nr] As MaterialNr,
  case
    when r.[Arb-Breite] is null
  then
    0
  else
    r.[Arb-Breite] / 1000 * r.lfm
  end as Bestand,
  s.Bezeichnung As Bezeichnung,
  case when r.[Arb-Breite] is null then 'ja' else 'nein' as Aufgebraucht
from [Material-Stamm] s
left join Materialrollen r on s.[Lieferanten-Nr] = r.[Lieferanten-Nr]
where s.[Lieferanten-Nr] = :LieferantenNr
and   s.aktuell  = -1
and   s.Breite <= 179
and   r.DatumAb is null

Zitat:

Ich hoffe, ich konnte das Problem jetzt besser beschreiben als meine Select-Anweisungen.

Ehrlich gesagt: nicht wirklich, da ist irgendwas noch widersprüchlich (oder es ist zu spät) :-(

Eventuell in die Richtung?

SQL-Code:

select
  r.[Mat-Nr] As MaterialNr,
  r.[Arb-Breite] / 1000 * r.lfm as Bestand,
  s.Bezeichnung As Bezeichnung,
  'nein' as Aufgebraucht
from [Material-Stamm] s
inner join Materialrollen r on s.[Lieferanten-Nr] = r.[Lieferanten-Nr]
where s.[Lieferanten-Nr] = :LieferantenNr
and   s.aktuell  = -1
and   s.Breite > 179
and   r.DatumAb is null
union all
select
  r.[Mat-Nr] As MaterialNr,
  case
    when r.[Arb-Breite] is null
  then
    0
  else
    r.[Arb-Breite] / 1000 * r.lfm
  end as Bestand,
  s.Bezeichnung As Bezeichnung,
  case when r.[Arb-Breite] is null then 'ja' else 'nein' as Aufgebraucht
from [Material-Stamm] s
left join Materialrollen r on s.[Lieferanten-Nr] = r.[Lieferanten-Nr]
where s.[Lieferanten-Nr] = :LieferantenNr
and   s.aktuell  = -1
and   s.Breite <= 179
and   r.DatumAb is null

Nun noch mit dem Versuch der Summierung:

SQL-Code:

select
  MaterialNr,
  Sum(Bestand) as Bestand,
  Bezeichnung,
  Aufgebraucht
from
(
  select
    r.[Mat-Nr] As MaterialNr,
    r.[Arb-Breite] / 1000 * r.lfm as Bestand,
    s.Bezeichnung As Bezeichnung,
    'nein' as Aufgebraucht
  from [Material-Stamm] s
  inner join Materialrollen r on s.[Lieferanten-Nr] = r.[Lieferanten-Nr]
  where s.[Lieferanten-Nr] = :LieferantenNr
  and   s.aktuell  = -1
  and   s.Breite > 179
  and   r.DatumAb is null
  union all
  select
    r.[Mat-Nr] As MaterialNr,
    case
      when r.[Arb-Breite] is null
    then
      0
    else
      r.[Arb-Breite] / 1000 * r.lfm
    end as Bestand,
    s.Bezeichnung As Bezeichnung,
    case when r.[Arb-Breite] is null then 'ja' else 'nein' as Aufgebraucht
  from [Material-Stamm] s
  left join Materialrollen r on s.[Lieferanten-Nr] = r.[Lieferanten-Nr]
  where s.[Lieferanten-Nr] = :LieferantenNr
  and   s.aktuell  = -1
  and   s.Breite <= 179
  and   r.DatumAb is null
)
group by
  MaterialNr,
  Bezeichnung,
  Aufgebraucht

Inzwischen hab' ich den Durchblick verloren, keine Ahnung wieviele Denk- und Syntaxfehler ich da eingebaut habe, aber vielleicht ist es ja nicht ganz hoffnungslos ;-)

[jobo]

Den Aufwand von DN in Ehren, aber es ist doch ein mühsames Geschäft. Denn es fehlt hier Tabellenstruktur (Create Statement mit Constraints) und weil diese oft nicht genau genug sind, echte Testdaten.
Also mein Vorschlag:
Luckner postet Table Create Scripte und Daten (handvoll insert Statements) der betroffenen Daten. Das ergibt für alle Beteiligten (Helfer und TE) ein 100% nachvollziehbares Beispiel und erspart diese Stille Post Nummer. Jeder der es später nachvollziehen will, kann es dann auch wirklich, so wie es im Forum gedacht ist.

[p80286]

Zitat:

Zitat von jobo (Beitrag 1434207)

Create Statement mit Constraints

Das könnte bei Access problematisch sein, aber die Eigenschaften der Tabellen liefern schöne Bilder.

Gruß
K-H

[Luckner]

Hallo,

ok, ich werde mal die Strukturen der entsprechenden Tabellen liefern. Meine weitere Überlegung ist, ob man diese Daten nicht in einem Stringrid unterbringen kann. Dann könnte man die Felder dann mit "while-Schleifen" befüllen. Es würde den lokalen Rechner etwas mehr belasten, aber diese Tabelle wird meisten nur einmal die Woche benötigt. Ich muß jedoch erst testen, ob ich ein Stringrid an Fastreport übergeben kann.

Schöne Feiertage noch.

Gruß, Luckner

[Schokohase]

Theoretisch kann man alles als Daten-Quelle für FastReport verwenden.

Man legt ein

Delphi-Quellcode:

TfrxUserDataSet

an und verdrahtet dort den Zugriff auf die Daten. Das war es schon.

Zu der Abfrage selber:

Man muss nicht immer die komplette Aufgabe mit einer Abfrage lösen. Man kann sich die Daten auch in Objekte laden und den Rest der Verarbeitung mit diesen Objekte erledigen. Je komplexer die Aufgabe umso einfacher/übersichtlicher wird so eine getrennte Abarbeitung.

Und diese Anforderung schreit gerade danach.

[p80286]

Zitat:

Zitat von Schokohase (Beitrag 1434217)

Theoretisch kann man alles als Daten-Quelle für FastReport verwenden.

Man legt ein

Delphi-Quellcode:

TfrxUserDataSet

an und verdrahtet dort den Zugriff auf die Daten. Das war es schon.

Zu der Abfrage selber:

Man muss nicht immer die komplette Aufgabe mit einer Abfrage lösen. Man kann sich die Daten auch in Objekte laden und den Rest der Verarbeitung mit diesen Objekte erledigen. Je komplexer die Aufgabe umso einfacher/übersichtlicher wird so eine getrennte Abarbeitung.

Und diese Anforderung schreit gerade danach.

Nichts für ungut, aber mir ist eher unklar was der TE eigentlich will (so wie ich es verstanden habe muß <177 nicht berechnet werden, darf aber, warum dann die Unterscheidung? "Arbeitserleichterung"?)

Gruß
K-H

[Delphi.Narium]

Zitat:

Zitat von Luckner (Beitrag 1434216)

Hallo,

ok, ich werde mal die Strukturen der entsprechenden Tabellen liefern.

ja bitte, oder 'ne Accessdatenbank mit den Tabellen und einer ausreichenden (anonymisierten?) Menge an Testdaten.

Zitat:

Zitat von Luckner (Beitrag 1434216)

Meine weitere Überlegung ist, ob man diese Daten nicht in einem Stringrid unterbringen kann. Dann könnte man die Felder dann mit "while-Schleifen" befüllen. Es würde den lokalen Rechner etwas mehr belasten, aber diese Tabelle wird meisten nur einmal die Woche benötigt. Ich muß jedoch erst testen, ob ich ein Stringrid an Fastreport übergeben kann.

Finde ich keine gute Idee. Das, was Du haben möchtest, geht garantiert per SQL. Das Problem ist momentan eigentlich nur: Es ist noch nicht ganz klar, was Du haben möchtest. Das kann übrigens durchaus daran liegen, dass die Dir gemachten Vorgaben nicht genau genug gemacht wurden und es von daher noch "Spekulationsfreiraum" gibt. Und den kann man mit keiner Programmiersprache der Welt und mit keinem SQL korrekt abbilden.

Nimm einfach mal schrittweise meine SQLs von oben, bereinige sie ggfls. von Syntaxfehlern und sag uns dann, bis zu welchem Statement noch alle benötigten Daten im Ergebnis enthalten sind, bzw. was im "bestmöglichen" Ergebnis noch zuviel ist. Dann können wir da, ggfls. mit Hilfe von Testdaten, gezielt aufsetzen und, ggfls. mit 'ner Präzisierung der Aufgabenstellung, weiter nach einer Lösung suchen.

Ein (momentan) noch nicht lösbares Problem, lässt sich nicht dadurch lösen, dass man einen anderen Weg geht. Es wird dann nur einen weiteren Weg des Scheiterns geben, das ist nicht zielführend.

Zitat:

Zitat von Schokohase

Man muss nicht immer die komplette Aufgabe mit einer Abfrage lösen. Man kann sich die Daten auch in Objekte laden und den Rest der Verarbeitung mit diesen Objekte erledigen. Je komplexer die Aufgabe umso einfacher/übersichtlicher wird so eine getrennte Abarbeitung.

Finde ich nicht, meine praktische Erfahrung ist eher gegenteilig. Präzise und gute SQLs / Datenbankabfragen, ersparen einem ggfls. tausende von Programmierzeilen. Zumal dann, wenn es "nur" darum geht, einen Report zu schreiben/auszugeben. Ich persönlich erwarte dann, dass das auszugebende Ergebnis in einer Abfrage vorliegt und ich nur noch für die Übergabe der Daten an den Report sorgen muss. (Aber das ist sicherlich auch Geschmacksache.)

Zitat:

Zitat von Schokohase

Und diese Anforderung schreit gerade danach.

Nein, die Anforderung schreit nach Präzisierung, ohne die wird auch jede Programmierung scheitern (auch wenn das jetzt sehr hart klingen mag.)

Zitat:

Zitat von p80286

Nichts für ungut, aber mir ist eher unklar was der TE eigentlich will (so wie ich es verstanden habe muß <177 nicht berechnet werden, darf aber, warum dann die Unterscheidung? "Arbeitserleichterung"?)

Genau da liegt der Hase im Pfeffer, meine Versuche mit Union all oder ohne Union all ... resultieren eben genau aus diesem "entschiedenen sowohl als auch oder eventuell vielleicht ja oder doch nicht". Der TE sollte hier nochmal beim "Auftraggeber" nachfragen, was der denn nun möchte und dort eine klare Entscheidung einfordern. Ein: "man kann was ausgeben / berechnen oder auch nicht" darf in der Anforderung nicht mehr enthalten lassen.

@Luckner

Fordere bitte eine präzise Vorgabe dessen, was der Report enthalten soll und was nicht, ein und lasse dich bitte nicht mit etwas abspeisen, was nicht klar mit ja oder nein zu beantworten ist.
Oder anders formuliert: Die Vorgabe muss in einem Entscheidungsbaum abzubilden sein, es darf dort keine Stelle geben, an der ein weitere Verlauf über unterschiedliche Wege möglich ist.

[p80286]

Zitat:

Zitat von Delphi.Narium (Beitrag 1434228)

Fordere bitte eine präzise Vorgabe dessen, was der Report enthalten soll und was nicht, ein und lasse dich bitte nicht mit etwas abspeisen, was nicht klar mit ja oder nein zu beantworten ist.
Oder anders formuliert: Die Vorgabe muss in einem Entscheidungsbaum abzubilden sein, es darf dort keine Stelle geben, an der ein weitere Verlauf über unterschiedliche Wege möglich ist.

Mmm....ich habe mindestens ein Drittel meiner Arbeitszeit damit verbracht, chaotische unpräzise Formulierungen
in halbwegs logische Anforderungen zu überführen.

Und ich habe nie herausbekommen ob Dummheit, Ignoranz oder was auch immer der Grund für diese WischiWaschi-Anforderungen war.

Gruß
K-H

[Delphi.Narium]

Zitat:

Zitat von p80286 (Beitrag 1434241)

Zitat:

Zitat von Delphi.Narium (Beitrag 1434228)

Fordere bitte eine präzise Vorgabe dessen, was der Report enthalten soll und was nicht, ein und lasse dich bitte nicht mit etwas abspeisen, was nicht klar mit ja oder nein zu beantworten ist.
Oder anders formuliert: Die Vorgabe muss in einem Entscheidungsbaum abzubilden sein, es darf dort keine Stelle geben, an der ein weitere Verlauf über unterschiedliche Wege möglich ist.

Mmm....ich habe mindestens ein Drittel meiner Arbeitszeit damit verbracht, chaotische unpräzise Formulierungen
in halbwegs logische Anforderungen zu überführen.

Und ich habe nie herausbekommen ob Dummheit, Ignoranz oder was auch immer der Grund für diese WischiWaschi-Anforderungen war.

Gruß
K-H

Ich weiß, das kenne ich zur Genüge.
Oft hat es geholfen so penetrant nachzufragen, dass der Aufwand, eine präzise Vorgabe zu machen geringer war, als sich immer und immer wieder um die Beantwortung der Fragen der "blöden" Programmierer kümmern zu müssen.

Es ist ja nix dagegen einzuwenden, wenn man aus dem Chaos etwas macht, was dann logisch klingt und umsetzbar zu sein scheint. Aber damit bin ich dann immer zur anfordernden Person gegangen und habe gefragt: "Willst Du das?" Und habe sie dann darauf festgenagelt mit ja oder nein zu antworten oder eben die Anforderung zu präzisieren. Meist klappte das, wenn auch selten beim ersten Versuch.

[p80286]

Zitat:

Zitat von Delphi.Narium (Beitrag 1434257)

Es ist ja nix dagegen einzuwenden, wenn man aus dem Chaos etwas macht, was dann logisch klingt und umsetzbar zu sein scheint. Aber damit bin ich dann immer zur anfordernden Person gegangen und habe gefragt: "Willst Du das?" Und habe sie dann darauf festgenagelt mit ja oder nein zu antworten oder eben die Anforderung zu präzisieren. Meist klappte das, wenn auch selten beim ersten Versuch.

:thumb:

Gruß
K-H

[Luckner]

Hallo,
also ich versuche es jetzt mein Problem verständlich zu machen.
Die Tabellen der Datenbank sind in MS-Access. Die Hauptanwendung ebenfalls. Die zusätzliche Tools in Delphi. Als Zugriff auf die Datenbank benutze ich ADOQuery.
In diesem Fall werden 3 Tabellen angesprochen.
1. [Lieferanten-Stamm], mit [Lieferanten-Stamm].LieferantNr und [Lieferanten-Stamm].LieferantName
2. [Material-Stamm], mit den Feldern: [Material-Stamm].[Mat-Nr], [Material-Stamm].Bezeichnung, [Material-Stamm].[Lieferant-Nr], [Material-Stamm].aktuell.(Wenn [Material-Stamm].aktuell = -1 dann Materialmenge muss beobachtet werden).
3. Materialrollen, mit den Feldern: Materialrollen.[Mat-Nr], Materialrollen.Nr (Rollennummer), Materialrollen.[Arb-Breite] (nur wichtig, wenn > 179mm) , Materialrollen.lfm(wichtig wenn lfm = 0) , Materialrollen.DatumAb, usw.

Aufgabe: Suche alle Materialrollen eines Lieferanten (das selectiere ich mir schon vorab und bekommen entsprechend: TEditLieferantNr.Text := [Lieferanten-Stamm].LieferantNr. Bis dahin kein Problem.

dann nur noch Select über 2 Tabellen.
Aufgabe: Suche alle Materialrollen von [Material-Stamm].[Lieferant-Nr] = TEditLieferantNr.Text, dessen [Material-Stamm].aktuell = -1, weil nur dieses Material interessant ist. Hier werden die [Material-Stamm].[Mat-Nr] selectiert.

Suche alle Materialrollen.Nr zu dieser Materialrollen.[Mat-Nr] = [Material-Stamm].[Mat-Nr], die eine Materialrollen.[Arb-Breite] > 179 mm haben und Materialrollen.DatumAb = NULL ist. (nur dann sind ensprechende Materialrollen auf Lager. Aus allen Rollen des Materials, die selectiert wurden, berechne die qm (BESTAND).

Wenn Materialrollen.[Arb-Breite] <= 179 mm haben und Materialrollen.DatumAb = NULL ist, solche Rollen sollen nicht berücksichtigt. Dieses Material muss ebenfalls in der Tabelle angezeigt werden mit BESTAND = 0. Ebenfalls wenn es keine Rollen mit Materialrollen.DatumAb = NULL gibt, dann muß das Material ebenfalls in der Tabelle aufgelistet sein mit BESTAND = 0;

Natürlich haben diese Tabellen noch andere Felder, die spielen hier jedoch keine Rolle.

Der Sinn des Ganzen ist, dass man bestimmte Materialsorten eines Lieferanten im Auge behält und rechzeitig bestellt, weil der Lieferant möglicherweise nicht innerhalb einer bestimmten Frist liefern kann und entsprechend auch anderes Material des Lieferanten gleich mitbestellt, falls deren Mengen zu gering erscheinen.

Ich hoffe, jetzt ist es verständlich, ansonsten liefere ich weitere Antworten.

Gruß, Luckner