Externe Dateifelder indexierbar machen in Free

[peterspeer]

Hallo zusammen,

es ist eine bestehende Logik (altes RPG) in Free umsetzen.

Dabei ist folgende Situation gegeben:



In einer DDS gibt es 53 Felder die Werte (für jede Kalenderwoche) enthalten

Diese Felder sind natürlich alle in der DDS definiert

KW01

KW02

…

KW53



Alle Felder sind gleich definiert 11.2 über ein Referenzfeld

Also so in der DDS:

A KW01 R REFFLD(KW)

A KW02 R REFFLD(KW)

...





Es sind aber nicht die einzigen Felder in der Datei (sonst könnte man ja mit der Datenstruktur einfach arbeiten) Die Datei hat dutzende andere Felder (auch mehrere dieser 1-53 Felder)





Im Programm werden jetzt die Werte aufaddiert (oder auch andere Rechenoperationen damit gemacht.)

Um nicht immer alle Felder mit dem echten Namen anzusprechen gibt es ein Array



D KW S 11 2 DIM(53)



Dass kann ich natürlich in Free auch einfach abbilden

z. B. so:



DCL-S KW packed(11:2) DIM(53);



Jetzt kommt aber der Teil, wo die Originalfelder indexierbar werden.

Auch das geht im alten RPG mit einer einfachen I-Bestimmung

Das Externe Feld KW01 wird zum internen Feld KW mit dem Index 01

I-Bestimmung, dann Externer Feldnahme = KW01 und Feldname = KW(01) – fertig.

IDateiS1

I KW01 KW(01)

I KW02 KW(02)

I KW03 KW(03)

…





Jetzt kann man im Programm wunderbar sagen.

for §A = 1 to 53;

KW(§A) = ….…..

Endfor;



Wie bekomme ich es in free hin die Arrays zu definieren?

Ich habe es mit like ExtFld versucht

Das geht auch

dcl-ds DateiS1 qualified inz;

KW01 like ExtFld('KW01');

END-DS;



Nur halt dann auch wieder mit festen Namen KW01 und nicht das Array mit den 53 Werten.



Dann habe ich es auch so versucht

dcl-ds DateiS1 qualified inz;

KW:01 like ExtFld('KW01');

END-DS;



Ich kann KW nicht indexieren beim umbenennen des Externen Feldes aus der Datei weder mit

KW:01 like ExtFld('KW01');

KW,01 like ExtFld('KW01');

KW(01) like ExtFld('KW01');



Ich möchte auch ungerne ganz andere Lösungsansätze, da ich den logischen Teil (also die alte RPG-Source) schon in Free übernommen habe und die Programmlogik seit Jahren läuft und der Testaufwand für was Neues hoch wäre.

Somit wäre es schön und sinnvoll, wenn ich die Felder auch mit KW(01) oder KW(§A) oder wie auch immer die Zähler in den Schleifen heißen (gibt davon mehrere und es handelt sich um knapp 300 Felder und etliche Schleifen, wäre also echter Aufwand) ansprechen könnte.



Wer kann mir da auf die Sprünge helfen ?

Vielen Dank im Voraus
Peter

[B.Hauser]

Geht das nicht einfach so?

DCL-DS  DSKW;                         
  KW01;                               
  KW02;                               
  KW03;                               
  ...                                 
  KW53;                               
  KW      Like(KW01)  Dim(53)   Pos(1);  
End-Ds;

[peterspeer]

Hallo Birgitta,
vielen Dank für die schnelle Antwort.
Wo kommt denn der Bezug zu dem Externen Feld in deinem Beispiel her?

Das verstehe ich nicht, ich muss doch irgendwo sagen, dass das Externe Feld "KW01" jetzt im Array KW(01) stehen soll.

Was früher über diese I-Bestimmung gemacht wurde
I-Bestimmung, dann Externer Feldname = KW01 und Feldname = KW(01)

IDateiS1
I KW01 KW(01)
I KW02 KW(02)
I KW03 KW(03)


Viele Grüße
Peter

[camouflage]

Die Lösung für die Kranken würde Dieter jetzt sagen:

Du könntest einen Array definieren und diesen via Pointer auf den Record legen.

[Fuerchau]

Stimmt, Pointer sind die Lösung:

dcl-ds DSFILE extname('FILE') qualified;
end-ds;

dcl-s PointerKW pointer inz(%addr(DSFILE.KW01));
dcl-s KW based(PointerKW) dim(nn);

Bei Birgittas Vorschlag entnimmst du die Startposition aus DSPFFD.
Das ist nur bei Dateiänderungen halt nicht dynamsich.
Aber wer ändert schon bestehende Dateien;-).

Das Problem bei externen DS'n ist ja, dass diese nicht erweiterbar sind, im Gegensatz zu den alten DS'n, an die ich einfach anhägen kann.

Übrigenes arbeite ich auch bei SQL gerne mit Pointern, da SQL immer noch nur einstufige DS'n unterstützt. Mit Templates und Pointern kann man das sehr schön vereinfachen ohne ständig irgendwas zu moven.

[camouflage]

Den Umweg über die Datenstruktur könntest Du dir auch noch sparen und direkt auf dem Feld im Record aufsetzen.

Also, gemäss Baldur's Vorgabe:

dcl-s PointerKW pointer inz(%addr(KW01));
dcl-s KW like(KW01) based(PointerKW) dim(53);

Cool oder?

[B.Hauser]

Bei euren Pointer-Lösungen vergeßt Ihr nur eines:
Die 53 Felder müssen in der Tabelle hintereinander weg stehen ansonsten klappt das nicht!
... und bei Datei-Änderungen (mit und ohne Compile) würde ich nicht die Hand ins Feuer legen.

Meine Lösung war einfach und simpel, da die Datenstruktur nicht qualifiziert ist, brauchen weder die Unterfelder definiert werden (Auflisten reicht), noch spielt die Reihenfolge eine Rolle!
Eine zusätzliche externe Datenstruktur, in die der Satz gelesen wird ist nicht erforderlich!

Es ist so wie es schon immer war: Gleicher Name, Gleicher Wert und ein Hin- und Her-Schieben ist nicht notwendig. ... und die Feldgruppe überlagert dann die Datei-/Datenstruktur-Unter-Felder.
... und bei Datei-Änderung muss lediglich kompiliert werden.

Ich frage mich, wo ich in meinem Beispiel irgendwo eine Start-Position angegeben habe?!

aber wer allerdings gerne mit Pointern und (unnötigen) externen Datenstrukturen herumhantiert...

[peterspeer]

Hall zusammen,
und vielen Dank für eure Antworten.
Da in der Anwendung bisher auch nicht mit Pointern gearbeitet wird, würde ich die Lösung von Birgitta bevorzugen.
Hierbei stoße ich nur auf ein Problem.
Das funktioniert.
DCL-DS DSKW;
KW01;
KW02;
KW03;
...
KW53;
KW Like(KW01) Dim(53) Pos(1);
End-Ds;

Aber sobald ich es um eine Zeile erweitere also..

DCL-DS DSKW;
KW01;
KW02;
KW03;
...
KW53;
KW Like(KW01) Dim(53) Pos(1);
KW LIKE(KW02) DIM(53) POS(2);
End-Ds;
Sagt mir der Compiler, dass KW bereits definiert ist.
Da habe ich jetzt wohl gerade ein Brett vor dem Kopf...
Wenn sich das noch lösen lässt wäre das klasse.

Vielen Dank

[camouflage]

Streich den zweiten KW Pos(2), einer genügt.

Vielleicht noch etwas zur Erklärung:
Diese Lösung ist genau so wie mit den Pointern, nur dass Du alles in eine Datenstruktur einliest und dann mit einem Array überlagerst. In meinen Augen ein bisschen outdated, aber funktioniert auch.

@Birgitta: Barbra würde auch die Pointerlösung empfehlen - sag ich mal jetzt so.

[Fuerchau]

Birgittas Lösung funktioniert nur, wenn man nicht mit einer qualified DS für Input arbeitet.
Denn weiterhin gilt immer noch, dass eine Variable nur 1x in irgend einer DS verwendet werden kann.
Wenn man aber mit qualified DS arbeitet, muss man tatsächlich etwas mehr machen, wenn man:
a) sich nicht auf eine bündige Reihenfolge von Felder verlassen kann
b) und damit Birgittas Lösung verwenden muss.

dcl-ds DSFile extname('File') qualified;
end-ds;

dcl-ds KWDS qualified;
kw01 like(DSFile.KW01);
:
:
kwnn like(DSFile.KWnn) dim(nn);
end-ds;

eval-corr KWDS = DSFILE;

[B.Hauser]

Damit hast Du doch schon alles definiert was Du brauchst:

DCL-DS DSKW;
   KW01;
   KW02;
   KW03;
   ...
   KW53;
  KW Like(KW01) Dim(53) Pos(1);
End-Ds;

Die Feldgruppe KW hat bereits 53 Elemente ... und die Feldgruppe überlagert die ganze Datenstruktur, da sie auf der 1. Stelle (Pos(1)) beginnt, also alle einzelne Einträge (KW01 - KW053).

Da die Feldgruppe mit LIKE(KW01) definiert ist also wie KW01 (und ich gehe davon aus dass alle anderen 52 genauso definiert sind - ansonsten hast Du ein anderes Problem!), sollte alles ordentlich überlagert sein.
Damit ist also in KW(1) das erste Element und KW(53) das 53. Element und in KW(27) das 27.!

Du Kannst direkt KW(1), KW(23) ... oder KW(x) (vorausgesetzt x hat einen Wert zwischen 1 und 53) ansprechen.

[peterspeer]

Danke Birgitta !
Da hatte ich wohl ein (dickes) Brett vorm Kopf.
Es klappt.

Vielen Dank an alle für die schnellen Rückmeldung !