Nicht eindeutige Dateinamen zueinander zuordnen

[Rülps]

Hallo liebe Leutz, ich weiß der Titel klingt komisch, aber ich versuch mal mein Problem zu erläutern. Ich habe einen Riesensatz von Textdateien. Jeweils drei dieser Textdateien werden pro Event automatisch generiert und zwar im folgenden Format:

Delphi-Quellcode:

G1-01_05_2014 00_10_57.csv
G1-01_05_2014 00_10_57.txt
G1-SC status-01_05_2014 00_10_57.txt

"01_05_2014 00_10_57" ist für jede Datei der entsprechende Datums- bzw. Zeitstempel. Das Problem ist aber, dass sich die Zeitstempel der Dateien bei der Erstellung um 1 Sekunde unterscheiden können. Also sehen geschätzte 7% der Dateien so oder so ähnlich aus:

Delphi-Quellcode:

G1-01_05_2014 00_10_56.csv
G1-01_05_2014 00_10_57.txt
G1-SC status-01_05_2014 00_10_57.txt

G1-01_05_2014 00_27_53.csv
G1-01_05_2014 00_27_53.txt
G1-SC status-01_05_2014 00_27_52.txt

Ich lade alle Dateien in eine StringList und parse die Infos aus den drei zusammenhängenden Dateien heraus und schreibe sie in eine Datenbank. Ich finde keine Lösung wie ich die Dateien zueinander zuordnen kann, wenn sie sich im Zeitstempel unterscheiden. Weiß jemand eine Methode? :thumb:

[Mavarik]

Wie ist den das kleinste Interval für die Erstellung?

[stahli]

Da wären ein paar mehr Infos hilfreich.

1. Nachfrage:
Erzeugst Du die Dateien selbst oder sind die von dritter Seite gegeben?
Vielleicht lässt sich der Zeitstempel ja vereinheitlichen:
TS := Now; ... und dann überall TS verwenden.
Nur mal vorab, eh man komplexere Lösungen sucht.

Zur Sortierung wäre (wenn das nicht fix ist) evtl. auch ein anderes Dateinamenformat zu überlegen: yyyymmddhhnnsszzz-irgendwas.xyz

Welche Abstände haben denn die Zeitstempel? Mindestens einige Sekunden oder auch mal sehr wenig?

[frankyboy1974]

hallo,

du möchtest Daten an hand eines Zeitstempels eindeutig zuordnen, das Problem hatte ich vor Jahren auch mal...

Nein, wir suchen eine andere Lösung.

mfg

[nahpets]

Hallo,

mache mal 'nen blöden Vorschlag:

Da Du ja schon eine Datenbank hast, lies Dir die Dateinamen in eine eigene Tabelle ein.

Die Tabelle bekommt eine Spalte für den Dateinamen und weitere Spalten für Datum und Uhrzeit.

Code:

G1-01_05_2014 00_10_57.csv
G1-01_05_2014 00_10_57.txt
G1-SC status-01_05_2014 00_10_57.txt

Nun teilst Du Dir beim Befüllen der Tabelle den Dateinamen auf:

Delphi-Quellcode:

// Nur hingedaddelt, nicht getestet.
procedure TuEsInDieDatenbank(sDateiname : String);
Var
  sDatum     : String;
  sZeit      : String;  
  iPos       : Integer;
begin
  sDatum := ChangeFileExt(sDateiname,'');
  sDatum := AnsiReplaceText(sDatum,'SC status-','');
  iPos   := Pos('-',sDatum) + 1;
  sDatum := Copy(sDatum,iPos,Length(sDatum));
  iPos   := Pos(' ',sDatum);
  sZeit  := Copy(sDatum,iPos + 1,Length(sDatum));
  sDatum := Copy(sDatum,1,iPos - 1);
  sDatum := AnsiReplaceText(sDatum,'_','.');
  sZeit  := AnsiReplaceText(sZeit,'_',':');
  tabelle.append;
  tabelle.FieldByName('dateiname').AsString := sDateiname;
  tabelle.FieldByName('datum').AsDateTime := StrToDate(sDatum);
  tabelle.FieldByName('zeit').AsDateTime  := StrToTime(sZeit);
  // Müsste eigentlich auch gehen.
  tabelle.FieldByName('Zeitstempel').AsDateTime := StrToDateTime(sDatum + ' ' + sZeit);
  tabelle.Post;
end;

Wenn Du nun den Inhalt der Datenbank per

Code:

select Dateiname from tabelle order by zeit, datum, dateinamen

liest, sollten immer die drei zusammengehörenden Sätze hintereinander liegen.
Über den Dateinamen kannst Du ja dann ausmachen, um welchen Dateityp es sich handelt, um die weitere Verarbeitung zu steuern.

Aber: Ich gehe nicht davon aus, dass das in 100% der Fälle so funktioniert.
Wenn die Dateien in kurzen Zeitabständen erstellt werden, kann es immernoch zu Problemen bei der Zuordnung kommen.

Code:

G1-01_05_2014 00_10_56.csv
G1-01_05_2014 00_10_57.txt
G1-SC status-01_05_2014 00_10_57.txt
G1-01_05_2014 00_10_57.csv
G1-01_05_2014 00_10_58.txt
G1-SC status-01_05_2014 00_10_58.txt

Was gehört jetzt zusammen?

Wie oben schon mal kommentiert:

Zitat:

Zitat von frankyboy1974

Nein, wir suchen eine andere Lösung.

Wenn irgendmöglich ist diese Alternative vorzuziehen!

[scrat1979]

Vielleicht habe ich auch die Aufgabenstellung falsch verstanden, aber so weit ich es verstanden habe werden die drei zusammengehörenden Dateien in einem Event erstellt. Warum speicherst du nicht zu Beginn des Events den aktuellen Zeitstempel in einer Variable ab und verwendest diese um die Dateinamen zu erstellen? Dann wäre doch die Basis für alle drei Dateien derselbe Zeitstempel - egal ob die Dateien auch "länger" nacheinander erstellt werden. 8-)

[Sir Rufo]

@scrat1979 :thumb:

(sehe gerade, stahli hat das auch schon vorgeschlagen) :thumb:

Alles andere ist doch Unfug - einen wie auch immer gearteten Algorithmus zu finden, der den Fehler, den man selber verbockt hat im Nachgang wieder ausbügelt.

[Rülps]

Zitat:

Zitat von Mavarik (Beitrag 1313618)

Wie ist den das kleinste Interval für die Erstellung?

Abstände zwischen Events sind aus technischen Gründen immer mindestens 30 Sekunden voneinander entfernt.

Zitat:

Zitat von stahli (Beitrag 1313620)

Da wären ein paar mehr Infos hilfreich.

1. Nachfrage:
Erzeugst Du die Dateien selbst oder sind die von dritter Seite gegeben?
Vielleicht lässt sich der Zeitstempel ja vereinheitlichen:
TS := Now; ... und dann überall TS verwenden.
Nur mal vorab, eh man komplexere Lösungen sucht.

Zur Sortierung wäre (wenn das nicht fix ist) evtl. auch ein anderes Dateinamenformat zu überlegen: yyyymmddhhnnsszzz-irgendwas.xyz

Welche Abstände haben denn die Zeitstempel? Mindestens einige Sekunden oder auch mal sehr wenig?

Dateinamen kann ich leider nicht beeinflussen. Das mit dem Sortieren hab ich mir auch schon überlegt. Mal schauen... Abstände siehe oben

Zitat:

Zitat von frankyboy1974 (Beitrag 1313622)

hallo,

du möchtest Daten an hand eines Zeitstempels eindeutig zuordnen, das Problem hatte ich vor Jahren auch mal...

Nein, wir suchen eine andere Lösung.

mfg

Die Antwort verstehe ich nicht ganz. Sucht ihr immer noch nach einer Lösung?

Zitat:

Zitat von nahpets (Beitrag 1313624)

Hallo,

mache mal 'nen blöden Vorschlag:

Da Du ja schon eine Datenbank hast, lies Dir die Dateinamen in eine eigene Tabelle ein.

Die Tabelle bekommt eine Spalte für den Dateinamen und weitere Spalten für Datum und Uhrzeit.

Code:

G1-01_05_2014 00_10_57.csv
G1-01_05_2014 00_10_57.txt
G1-SC status-01_05_2014 00_10_57.txt

Nun teilst Du Dir beim Befüllen der Tabelle den Dateinamen auf:

Delphi-Quellcode:

// Nur hingedaddelt, nicht getestet.
procedure TuEsInDieDatenbank(sDateiname : String);
Var
  sDatum     : String;
  sZeit      : String;  
  iPos       : Integer;
begin
  sDatum := ChangeFileExt(sDateiname,'');
  sDatum := AnsiReplaceText(sDatum,'SC status-','');
  iPos   := Pos('-',sDatum) + 1;
  sDatum := Copy(sDatum,iPos,Length(sDatum));
  iPos   := Pos(' ',sDatum);
  sZeit  := Copy(sDatum,iPos + 1,Length(sDatum));
  sDatum := Copy(sDatum,1,iPos - 1);
  sDatum := AnsiReplaceText(sDatum,'_','.');
  sZeit  := AnsiReplaceText(sZeit,'_',':');
  tabelle.append;
  tabelle.FieldByName('dateiname').AsString := sDateiname;
  tabelle.FieldByName('datum').AsDateTime := StrToDate(sDatum);
  tabelle.FieldByName('zeit').AsDateTime  := StrToTime(sZeit);
  // Müsste eigentlich auch gehen.
  tabelle.FieldByName('Zeitstempel').AsDateTime := StrToDateTime(sDatum + ' ' + sZeit);
  tabelle.Post;
end;

Wenn Du nun den Inhalt der Datenbank per

Code:

select Dateiname from tabelle order by zeit, datum, dateinamen

liest, sollten immer die drei zusammengehörenden Sätze hintereinander liegen.
Über den Dateinamen kannst Du ja dann ausmachen, um welchen Dateityp es sich handelt, um die weitere Verarbeitung zu steuern.

Aber: Ich gehe nicht davon aus, dass das in 100% der Fälle so funktioniert.
Wenn die Dateien in kurzen Zeitabständen erstellt werden, kann es immernoch zu Problemen bei der Zuordnung kommen.

Code:

G1-01_05_2014 00_10_56.csv
G1-01_05_2014 00_10_57.txt
G1-SC status-01_05_2014 00_10_57.txt
G1-01_05_2014 00_10_57.csv
G1-01_05_2014 00_10_58.txt
G1-SC status-01_05_2014 00_10_58.txt

Was gehört jetzt zusammen?

Wie oben schon mal kommentiert:

Zitat:

Zitat von frankyboy1974

Nein, wir suchen eine andere Lösung.

Wenn irgendmöglich ist diese Alternative vorzuziehen!

Also die Dateien enthalten zum selben Event verschiedene Infos - ist schon schlecht by Design. Also z.B. Datei 1 enthält (ironischerweise) ebanfalls Uhrzeit und Datum und Kundennamen als Info. Datei 2 nähere Infos zum Event. Datei 3 enthält debuggingmäßige Infos und Versionsinfos bzgl. der Software, welches die Events erstellt. Diese sollen je Event zeilenweise in eine Tabelle geschrieben werden. Also ein Event entspricht einer Zeile.

Zitat:

Zitat von scrat1979 (Beitrag 1313627)

Vielleicht habe ich auch die Aufgabenstellung falsch verstanden, aber so weit ich es verstanden habe werden die drei zusammengehörenden Dateien in einem Event erstellt. Warum speicherst du nicht zu Beginn des Events den aktuellen Zeitstempel in einer Variable ab und verwendest diese um die Dateinamen zu erstellen? Dann wäre doch die Basis für alle drei Dateien derselbe Zeitstempel - egal ob die Dateien auch "länger" nacheinander erstellt werden. 8-)

Die Dateien werden von einer (relativ alten) auf UNIX basierenden Low Level Hardware/Software "Architektur" automatisch erstellt und nur täglich zu uns rübergeschickt. Ich habe keinen Einfluss auf die Erstellung und kann auch nicht Livemonitoring betreiben und mit 100%iger Sicherheit kann ich sagen, dass kein Geld in die Hand genommen wird, um dieses System upzudaten.

Thx für die zahlreichen Antworten.

[HolgerX]

Hallo..

Frage:
Welche von den 3 Dateien wird als letztes erzeugt?

Wenn es die G1-SC status.. ist, kannste Dir doch die anderen Dateinamen mit alternative Zeitstempel selber davon ableiten und einfach mit FileExists prüfen..

Du brauchst dann auch nur Dateien Prüfen, welche die gleiche Zeit oder um 1 / 2 Sekunden kleineren Zeitanteil haben.

[Rülps]

Zitat:

Zitat von HolgerX (Beitrag 1313632)

Hallo..

Frage:
Welche von den 3 Dateien wird als letztes erzeugt?

Wenn es die G1-SC status.. ist, kannste Dir doch die anderen Dateinamen mit alternative Zeitstempel selber davon ableiten und einfach mit FileExists prüfen..

Du brauchst dann auch nur Dateien Prüfen, welche die gleiche Zeit oder um 1 / 2 Sekunden kleineren Zeitanteil haben.

Genau so mache ich das auch bisher - also mit FileExists überprüfen. Nur das mit dem Zeitteil nochmal anpassen ist irgendwie unschön und umständlich. Ich muss es aber dann auf diesem Wege machen, wenn es keine andere Lösung gibt.

[Perlsau]

Ist doch alles ganz einfach: Wenn die Einträge in der DB nach Datum sortiert sind, hast du doch schon alle beisammen. Die ersten drei gehören zusammen, die nächsten drei gehören zusammen usw. Und das Datum aus dem Filenamen zu ermitteln, dürfte wohl die leichteste Übung sein ...

[Dejan Vu]

Theoretisch richtig. Aber wenn eine Datei der Dreiergruppe fehlt oder ausnahmsweise eine zusätzliche Datei hinzukommt, passt das nicht mehr.

Ich würde auch die einzelnen 'SC-Status' Dateien nehmen und jeweils die beiden ältesten Dateien dazu packen. Als Kriterium würde ich noch sicherstellen, das sich die Zeitstempel nur um 1-2 Sekunden unterscheiden. Aber die Lösung wurde ja schon skizziert.

[jobo]

Jede Lösung, die sich an der Existenz und Zeit einer der 3 Dateien und oder der Reihenfolge orientiert, geht mglw in die Hose.
Also auch eine Lösung, die die Dateien nach Eingang, also sequentiell analysiert und wegschreibt/weiterverarbeitet.

Da es eh in eine DB / Tabelle kommt, würde ich wie bereits vorgeschlagen dort ansetzen. Dazu wird dann das technische Intervall mit einem Sicherheitszuschlag verwendet und die Zusammengehörigkeit der Dateien anhand dessen bestimmt und in einem extra Feld per gemeinsamer ID markiert (Dateigruppe).
Im Zweifel können dabei auch 2er, 1er oder Ner Gruppen entstehen, die entweder korrekt sind, weil eine Datei fehlt oder aber falsch, weil grad Schaltsekunde, Sommerzeitumstellung oder was weiß ich war.

Alle Daten, besonders die mit mehr oder weniger als 3 Dateien können /sollten geprüft und ggF. korrigiert werden, was ja mit der Zuordnungsspalte möglich ist.

[Mavarik]

Zitat:

Zitat von Rülps (Beitrag 1313631)

Zitat:

Zitat von Mavarik (Beitrag 1313618)

Wie ist den das kleinste Interval für die Erstellung?

Abstände zwischen Events sind aus technischen Gründen immer mindestens 30 Sekunden voneinander entfernt.

Und sieh da schon hast Du Dir die Antwort selber gegeben... Ich gehe mal davon aus, dass Du die Datei nicht selber erzeugst...

Ansonsten...

if Datei gefunden... then
Finde 2 Dateien die maximal +/- 29 Sekunden vor oder nach dieser Datei erzeugt wurden...

Fertig... Ohne Viel bla bla...

[Rülps]

Zitat:

Zitat von Mavarik (Beitrag 1313720)

Zitat:

Zitat von Rülps (Beitrag 1313631)

Zitat:

Zitat von Mavarik (Beitrag 1313618)

Wie ist den das kleinste Interval für die Erstellung?

Abstände zwischen Events sind aus technischen Gründen immer mindestens 30 Sekunden voneinander entfernt.

Und sieh da schon hast Du Dir die Antwort selber gegeben... Ich gehe mal davon aus, dass Du die Datei nicht selber erzeugst...

Ansonsten...

if Datei gefunden... then
Finde 2 Dateien die maximal +/- 29 Sekunden vor oder nach dieser Datei erzeugt wurden...

Fertig... Ohne Viel bla bla...

Was mir an dieser Methode etwas stinkt ist, dass theoretisch eine Datei beispielsweise am 23.12.2014 um 23:59:59 erstellt werden könnte und die anderen beiden eine Sekunde später, d.h. ich muss um wirklich sicherzugehen sogar den Kalender des entsprechenden Jahres mitberücksichtigen, um Schaltjahre auszuschließen, um den richtigen Dateinamen zu identifizieren. Mir graust's vor der Bastelei...
Hmm, um das jetzt innerhalb der Datenbank zu lösen muss ich eine Menge umschreiben, aber ich schau mal, ob das eine befriedigende Lösung gibt.

[Klaus01]

.. da Du die Datensätze täglich bekommst/abholst sollte das mit dem Schaltjahr, Monatsende etc.
nicht eine so große Rolle spielen.

Grüße
Klaus

[nahpets]

Also bei dem ca. 30 Sekundenintervall sehe ich in der Umwandlung der Datums- und Zeitangaben aus dem Dateinamen in einen TDateTime die sicherste Möglichkeit der Zuordnung von drei Dateien.

Schaltjahr... ist dann egal, es müssen immer in einem Zeitintervall von ca. 2 Sekunden drei Dateien zu finden sein (die über den Dateinamen bzw. die Dateiendung noch eindeutig klassifiziert werden können), ansonsten stimmt (ausgehend von Deinen Vorgaben) irgendetwas nicht.

Du könntest Datum und Uhrzeit auch in die Form YYYYMMDDHHMMSS bringen, dann kannst Du auch über Zeichenfolgen sortieren und bekommst die zusammengehörenden Dateien hintereinander, Plausibilität wie oben.

Ausgehend davon das 1 = 1 Tag ist, ist eine Sekunde (ca.) 1,1574074074074074074074074074074e-5
(= 1 / 24 / 60 / 60)

Drei Dateien sind also in einem Zeitfenster von 2 * 1,1574074074074074074074074074074e-5 zu suchen und zwei Dateisätze liegen ca. 30 * 1,1574074074074074074074074074074e-5 auseinander.
Derartige Berechnungen gehen mit TDateTime ganz einfach, das ist nur ein bisserl Mathematik mit ein Größe-/Kleinervergleichen.

Dies erscheint mir deutlich einfacher, als irgendwie über Zeichenfolgenvergleiche in den Dateinamen zu einer Zuordnung zu kommen.

[Rülps]

Zitat:

Zitat von nahpets (Beitrag 1313756)

Also bei dem ca. 30 Sekundenintervall sehe ich in der Umwandlung der Datums- und Zeitangaben aus dem Dateinamen in einen TDateTime die sicherste Möglichkeit der Zuordnung von drei Dateien.

Schaltjahr... ist dann egal, es müssen immer in einem Zeitintervall von ca. 2 Sekunden drei Dateien zu finden sein (die über den Dateinamen bzw. die Dateiendung noch eindeutig klassifiziert werden können), ansonsten stimmt (ausgehend von Deinen Vorgaben) irgendetwas nicht.

Du könntest Datum und Uhrzeit auch in die Form YYYYMMDDHHMMSS bringen, dann kannst Du auch über Zeichenfolgen sortieren und bekommst die zusammengehörenden Dateien hintereinander, Plausibilität wie oben.

Ausgehend davon das 1 = 1 Tag ist, ist eine Sekunde (ca.) 1,1574074074074074074074074074074e-5
(= 1 / 24 / 60 / 60)

Drei Dateien sind also in einem Zeitfenster von 2 * 1,1574074074074074074074074074074e-5 zu suchen und zwei Dateisätze liegen ca. 30 * 1,1574074074074074074074074074074e-5 auseinander.
Derartige Berechnungen gehen mit TDateTime ganz einfach, das ist nur ein bisserl Mathematik mit ein Größe-/Kleinervergleichen.

Dies erscheint mir deutlich einfacher, als irgendwie über Zeichenfolgenvergleiche in den Dateinamen zu einer Zuordnung zu kommen.

Thx nahpets, an TDateTime hatte ich gar nicht gedacht :thumb: Ich hab' die Datums- und Zeitstempel immer als String mitgeführt und ging davon aus, dass ich alles selber programmieren muss. Ja, ich denke so werde ich vorgehen!

[Mavarik]

Zitat:

Zitat von nahpets (Beitrag 1313756)

Ausgehend davon das 1 = 1 Tag ist, ist eine Sekunde (ca.) 1,1574074074074074074074074074074e-5
(= 1 / 24 / 60 / 60)

Drei Dateien sind also in einem Zeitfenster von 2 * 1,1574074074074074074074074074074e-5 zu suchen und zwei Dateisätze liegen ca. 30 * 1,1574074074074074074074074074074e-5 auseinander.
Derartige Berechnungen gehen mit TDateTime ganz einfach, das ist nur ein bisserl Mathematik mit ein Größe-/Kleinervergleichen.

Ernsthaft?

Wie wäre es mit SecondsBetween(A,B) < 30

[Dejan Vu]

Zitat:

Zitat von jobo (Beitrag 1313689)

Jede Lösung, die sich an der Existenz und Zeit einer der 3 Dateien und oder der Reihenfolge orientiert, geht mglw in die Hose.

Wieso? Wenn die Sequenz der Erstellung A,B,C ist und ich nach C suche, und dann alles, was vor C kommt, mitnehme (Zeitdifferenz < Epsilon und 'A,B' <> C) ... was soll daran in die Hose gehen? Logisch: Ohne 'C' geht nix. Aber sonst?

PS: Da die Erzeugung der Dateien nicht eindeutig ist, kann eine nachträgliche Zuordnung per se nicht eindeutig sein. Ich gehe davon aus, das Du genau das meinst...

[p80286]

[QUOTE=Dejan Vu;1313770Logisch: Ohne 'C' geht nix. Aber sonst?
[/QUOTE]

Und ohne A und oder B auch nicht! Und was das "logisch" angeht, es gibt mehr QnD-Lösungen, die auf "das passiert doch nieee" basieren, als es Sand am Nordseestrand gibt.

Darum würde ich erst einmal prüfen, was an Dateien überhaupt herein kommt. Und diese dann entweder angleichen, wird kein Protokoll geführt sollte das gehen, oder aber z.B. Records nutzen.

Delphi-Quellcode:

Type 
  TMyFiles = record
               fn1 : string;
               fn2 : string;
               fn3 : string;
  end;

Wobei LogdateiName z.B. besser wäre als fn1.

Oder die entsprechende Tabelle mit den zugehörige Dateinamen füttern
oder .....

Gruß
K-H

[nahpets]

Zitat:

Zitat von Mavarik (Beitrag 1313768)

Zitat:

Zitat von nahpets (Beitrag 1313756)

Ausgehend davon das 1 = 1 Tag ist, ist eine Sekunde (ca.) 1,1574074074074074074074074074074e-5
(= 1 / 24 / 60 / 60)

Drei Dateien sind also in einem Zeitfenster von 2 * 1,1574074074074074074074074074074e-5 zu suchen und zwei Dateisätze liegen ca. 30 * 1,1574074074074074074074074074074e-5 auseinander.
Derartige Berechnungen gehen mit TDateTime ganz einfach, das ist nur ein bisserl Mathematik mit ein Größe-/Kleinervergleichen.

Ernsthaft?

Wie wäre es mit SecondsBetween(A,B) < 30

Wieso nicht ernsthaft, was macht denn SecondsBetween? Es ermittelt bei zwei TDateTime das Zeitfenster und mit < 30 wird letztlich geprüft, ob dieses eben kleiner ca. 30 * 1,1574074074074074074074074074074e-5 ist.

Um auf < 30 zu prüfen, muss irgendwo im Inneren von SecondsBetween ja aus den beiden Floatwerten, die die TDateTimes nun mal sind, die Differenz in Sekunden berechnet werden. Wer jetzt wann, was wie umrechnet, ist eigentlich egal, es geht letztendlich "nur" um Mathematik. ;-)

Hier im konkreten Fall dürfte es sinnvoll sein, zuerst festzustellen, welche der drei Dateien vom "Herstellungsprozess" zuletzt geschrieben wird.
Nur nach diesen Dateien würde ich suchen. Aus deren Dateinamen lässt sich der Dateiname der anderen Dateien ableiten und mit FileExists prüfen, ob diese Dateien vorhanden sind.
Die zugehörigen Dateien müssen in einem Zeitfenster von etwa 1 bis 2 Sekunden gefunden werden. Durch entsprechende Manipulation der Dateinamen (also Dateinamensteile in TDateTime umwandeln, minus 1 Sekunde und zurück in Dateinamen umwandeln) kann mit FileExists auf diese beiden Dateien geprüft werden. (Zur Sicherheit eventuell bei Misserfolg auf dem gleichen Weg noch eine Sekunde abziehen und erneut prüfen.) Fehlt eine der Dateien, so ist was faul.
Der Zeitabstand zwischen der Erstellung der jeweils zuletzt erstellten Dateien dieser Tripels, ist dabei dann schon fast irrelevant.

Liegt die Zeitdifferenz zwischen zweien der zuletzt erstellten Dateien oberhalb des Prozessintervals des "Herstellungsprozesses", so kann man hierüber ebenfalls feststellen, ob die Tripels vollständig vorhanden sind oder eben nicht. Das SecondsBetween müsste hier also between ca. 25 and 35 Seconds liegen.
Also eher ein

Delphi-Quellcode:

if SecondsBetween(A,B) in [25..35] then ok else nicht_ok;

Ein stures < 30 ist da (vermutlich) zu starr. Aber hier kann man nur spekulieren, man müsste mehr Informationen zum genauen Prozessablauf haben, um genauere Vorschläge für die Zeitangaben machen zu können.

Das es das SecondsBetween gibt ist für diese Ausgabenstellung zwar ganz nett, aber eigentlich nicht erforderlich.

[Mavarik]

Zitat:

Zitat von nahpets (Beitrag 1313803)

Das SecondsBetween müsste hier also between ca. 25 and 35 Seconds liegen.

natürlich nicht...

SecondsBetween wird sicherlich bei 1-3 liegen...

Es geht ja nur darum die Datei zu finden die zum gleichen Zeitpunkt erstellt worden ist... mit der 1-3 Sekunden Verzögerung. Da das Intervall der Erzeugung bei 30 Sekunden liegt, bis wieder 3 Dateien kommen war <30 GENAU richtig!

[nahpets]

Zitat:

Zitat von Mavarik (Beitrag 1313810)

Zitat:

Zitat von nahpets (Beitrag 1313803)

Das SecondsBetween müsste hier also between ca. 25 and 35 Seconds liegen.

natürlich nicht...

SecondsBetween wird sicherlich bei 1-3 liegen...

Es geht ja nur darum die Datei zu finden die zum gleichen Zeitpunkt erstellt worden ist... mit der 1-3 Sekunden Verzögerung. Da das Intervall der Erzeugung bei 30 Sekunden liegt, bis wieder 3 Dateien kommen war <30 GENAU richtig!

Zitat:

Zitat von Rülps

Abstände zwischen Events sind aus technischen Gründen immer mindestens 30 Sekunden voneinander entfernt.

von daher kann < 30 richtig sein, muss es aber nicht.

< 30 kann richtig sein, wenn es um die Zeitdifferenz von drei zueinander gehörenden Dateien geht. Es ist aber falsch, wenn es um den Zeitabstand von jeweils zwei Dateitripeln geht, hier müsste es dann >= 30 heißen.

Ob 30 Sekunden richtig oder falsch sind, kommt auf den Standpunkt an.

Daraus resultierte mein Vorschlag, nur die jeweils zuletzt erstellte Datei (anhand des Dateinamenmusters) zu suchen und die zugehörigen Dateien zuerst zum gleichen Zeitpunkt zu erwarten und wenn nicht gefunden nochmal mit einer Zeitdifferenz von einer, bei weiterem Misserfolg einer weiteren, Sekunde zu suchen.

Dateizeit sei also 10_00_03.
Erste Versuch mit 10_00_03.
zweiter Versuch mit 10_00_02
dritter Versuch mit 10_00_01
und schon haben wir

Zitat:

Zitat von Mavarik

SecondsBetween wird sicherlich bei 1-3 liegen...

für das Dateitripel.

Die Zeit zwischen zwei Dateitripeln sollte (s. o.) größer oder gleich 30 sein.
Da ich halt nicht so recht weiß, wie genau die Zeitvergabe bei den einzelnen Dateien ist, hatte ich als "Toleranzgrenze" halt mal als Beispiel 5 Sekunden angenommen.

Frei nach dem Motto: Wenn zwei Dateitripel mehr oder weniger als 25 bis 35 Sekunden auseinander liegen, dann stimmt höchstwahrscheinlich etwas nicht. Für genaue Angaben muss man das System halt besser kennen oder weitere Informationen bekommen. Aber vermutlich ist das Problem längst gelöst und eine Diskussion über SecondsBetween 1..3 oder SecondsBetween 25..35, jenachdem welches Problem man nun löst (Konsitenz innerhalb eines Dateitripels oder zwischen zwei Dateitripeln), nicht weiter von Belang.

[HolgerX]

Hallo..

Wenn ich das richtig gelesen habe, dann kommt ein Datenträger mit diversen dieser Event-Dateien.

Dann würde ich anders vorgehen..

Einlesen aller Dateinamen in eine Liste.
Dekodieren der Zeitanteile zu TDateTime.

Prüfen, welche Dateien innerhalb, sagen wir mal 5 Sekunden, beisammen sind, ausgehend von einer der Dateien, z.B. die .csv und dann diese 3 Dateien zusammen einlesen/verarbeiten.

Mit FileExists würde man im ungünstigsten Fall 4-5 Versuche je Paket machen, und jedes Mal somit auf dem Datenträger hantieren und jedes mal die Dateinamen formatieren.

Wenn so alles im Speicher stattfindet, ist dies einfach nur zunächst ein sortieren der Liste nach Zeitpunkt und dann die nächsten 2 Dateien prüfen.

Sollte am schnellsten gehen...

[nahpets]

Zitat:

Zitat von HolgerX (Beitrag 1313823)

Hallo..

Wenn ich das richtig gelesen habe, dann kommt ein Datenträger mit diversen dieser Event-Dateien.

Dann würde ich anders vorgehen..

Einlesen aller Dateinamen in eine Liste.
Dekodieren der Zeitanteile zu TDateTime.

Prüfen, welche Dateien innerhalb, sagen wir mal 5 Sekunden, beisammen sind, ausgehend von einer der Dateien, z.B. die .csv und dann diese 3 Dateien zusammen einlesen/verarbeiten.

Mit FileExists würde man im ungünstigsten Fall 4-5 Versuche je Paket machen, und jedes Mal somit auf dem Datenträger hantieren und jedes mal die Dateinamen formatieren.

Wenn so alles im Speicher stattfindet, ist dies einfach nur zunächst ein sortieren der Liste nach Zeitpunkt und dann die nächsten 2 Dateien prüfen.

Sollte am schnellsten gehen...

Deshalb hatte ich ja auch mal vorgeschlagen, den "Spass" (da ja sowieso mit 'ner Datenbank gearbeitet wird) in der Datenbank "abzufackeln".
Dateiname rein in die Tabelle, Datums-/Zeitanteil aus dem Dateinamen in eine Datums-/Zeitspalte, sortieren und schon hat man alles beieinander.

Und man hat die Informationen nicht nur zur Laufzeit im Arbeitsspeicher, sondern dauerhaft zur Verfügung.

[Dejan Vu]

Zitat:

Zitat von p80286 (Beitrag 1313793)

Zitat:

Zitat von Dejan Vu (Beitrag 1313770)

Logisch: Ohne 'C' geht nix. Aber sonst?

Und ohne A und oder B auch nicht! Und was das "logisch" angeht, es gibt mehr QnD-Lösungen, die auf "das passiert doch nieee" basieren, als es Sand am Nordseestrand gibt.

Äh... Also wenn ich eine Heuristik erstelle, die davon ausgeht, das -ausgehend von einer Datei 'C'- die beiden unmittelbaren Vorgängerdateien suche, dann ist 'C' nun einmal Voraussetzung dafür. Allerdings kann 'A' bzw. 'B' optional sein, denn ich kann maximal bis zum vorherigen 'C' gehen. Ergo? Geht es mit ohne A und B.
Pseudocode:

Delphi-Quellcode:

p := Data.Length;

while i>0 do begin
  i := FindPrevious_C (P);
  j := FindPrevious_C (i-1);
  CollectFiles (Data[j+1]....Data[i]); 
  p := i-1;
end;

[Rülps]

So danke liebe Community. Mit TDateTime und ein wenig Handarbeit hat es nun wunderbar geklappt. Herzlichen Dank für die Hilfe! :thumb: