[gelöst] SETLL und READ mit Gruppenwechsel ???

[FNeurieser]

Hallo Ulli,

Persönlich würde ich eher zu embedded SQL neigen.

tja embedded SQL wäre sicher ein Möglichkeit und zwar sicher nicht die schlechteste; leider aber stehe ich mit den Pointern und so nicht gerade auf freundschaftlichem Fuß und weiss daher auch nicht wie ich so etwas umsetzen könnte.

Jedenfalls recht herzlichen Dank für die "unsaubere" Lösungsmöglichkeit.

LG
Franz

[B.Hauser]

Embedded SQL arbeitet NICHT (direkt) mit Pointern!

Was Du brauchst ist ein Cursor, der mit dem SQL-Befehl DECLARE CURSOR definiert wird und auf einem SQL-Statement basiert (Äquivalent zu der F-Bestimmung). Die Von- und Bis-Werte können als Host-Variablen (mit führendem Doppel-Punkt) direkt in das SELECT-Statement eingebunden werden.
Der Cursor wird mit dem SQL-Befehl OPEN geöffnet (analog Open bei User controlled open). Anschließend die einzelnen Datensätze mit dem Befehl FETCH empfangen (analog zu READ/READE etc in Datenstrukturen). Die empfangenen Werte können dann verarbeitet werden. Wurden alle Sätze verarbeitet wird der Cursor mit dem SQL-Befehl CLOSE geschlossen.

Etwa so:

 /Free
    Exec SQL Declare CsrC01 Cursor For
           Select Fld1, Fld2, ... FldN
              From File
              Where Key1 between :VonWert1 and :BisWert1
                  and Key2 between :VonWert2 and :BisWert2
                  and Key3 between :VonWert3 and :BisWert3
              Order By Key1, Key2, Key3;

     Exec SQL Open CsrC01;
     DoU 1 = 0;
        Exec SQL Fetch Next From CsrC01 into :Var1, :Var2, ... VarN;
        If SQLCODE = 100;
           Leave;
        ElseIf SQLCODE < *Zeros;
           //Fehler;
        EndIf;
        //Verarbeitung
     EndDo;
     Exec SQL Close CsrC01;

Birgitta

[FNeurieser]

Hallo Brigitta,

danke für die Aufklärungsarbeit. Aber gibt es bei SQL nicht auch Pointer die Verwendung finden. Ich dachte immer wenn ich die Ergebnisse einer SQL-Abfrage in einen Datenbereich einlese werden Pointer verwendet um auf sei zugreifen zu können.

[B.Hauser]

Hallo Brigitta,

danke für die Aufklärungsarbeit. Aber gibt es bei SQL nicht auch Pointer die Verwendung finden. Ich dachte immer wenn ich die Ergebnisse einer SQL-Abfrage in einen Datenbereich einlese werden Pointer verwendet um auf sei zugreifen zu können.

Sofern das SQL Statement zur Laufzeit aufbereitet wird und zur Compile-Zeit weder die Dateien/Tabellen/Views noch die Spalten, die zur Laufzeit verwendet und ausgewählt werden könnten, noch deren Datentypen und Längen bekannt sind, hat man natürlich keine anderen Chance als über Pointer-Handling zu arbeiten ... und das kommt in der normalen Anwendungsentwicklung in maximal 2% aller Fälle vor.

Birgitta

[FNeurieser]

@Brigitta,

danke für die Info, aber geht es nicht schneller wenn mann die via SQL erhaltenen Daten zuerst in einen Datenbereich übergibt und diesen erst dann abarbeitet wenn SQL alle Daten übergeben hat, anstelle jedesmal ein FETCH durchzuführen und den Satz verarbeiten?

[Fuerchau]

Nö.
Wie willst du denn die Daten anders als per Fetch von SQL holen ?

[FNeurieser]

@Fuerchau,

ich habe mich villeicht falsch ausgedrückt; ich meinte es in etwa so:

 *-------------------------------------------------
 ***** für SQL Statement                           
 *-------------------------------------------------
D SIDX1           S              5  0 Inz(1)       
D SIDX2           S              5  0 Inz(1)       
D                                                  
DS00S01L          DS                  OCCURS(5000) 
D   L1TXNR                       6A                
D   L1TXB1                      30A                
 *
DS1PTR            S               *   INZ(%ADDR(S00S01L))   
D                 DS                  BASED (S1PTR)         
DS00S02L                       235A   DIM(5000) DESCEND     
D   L2TXNR                       6A   OVERLAY(S00S02L:1)    
D   L2TXB1                      30A   OVERLAY(S00S02L:*NEXT)
*
 * ANZAHL DER FELDER ( DIM(XX) ) MUSS MIT ANZAHL IN SELECT ÜBEREINSTIMMEN !! 
DIND_ARRAY        DS                  OCCURS(5000)                           
D INDS                           4B 0 DIM(12)

und dann in den C-Bestimmungen

/free
      #SQLSTM =                                                            
    'Select TXTXNR, TXTXB1, TXTXB2, TXTXB3, TXTXB4, TXTXB5, TXTXB6, ' + 
    'TXTXB7, TXSTK1, TXSTK2, TXSTK3, TXKDF1 from TABD ' +               
    'WHERE TXSART = ''TX'' and TXFIRM = ''1'' and TXWKNR = ''000'' ' +  
    'and TXTXRT = ''PE'' ';                                             
/end-free

 *                           
 * Statement vorbereiten     
 *                           
C/EXEC SQL                   
C+ PREPARE S1 FROM: #SQLSTM  
C/END-EXEC                   
 *                           
 * Cursor defnieren          
 *                           
C/EXEC SQL                   
C+ DECLARE C1 CURSOR FOR S1                              
C/END-EXEC                                               
 *                                                       
 * Cursor schliessen                                     
 *                                                       
C/EXEC SQL                                               
C+ CLOSE C1                                              
C/END-EXEC                                               
 *                                                       
 * Cursor öffnen                                         
 *                                                       
C/EXEC SQL                                               
C+ OPEN C1                                               
C/END-EXEC                                               
 *                                                       
 * alle Zeilen laden                                     
 *                                                       
C                   Eval      SIDX2 = 5000               
C/EXEC SQL                                               
C+ FETCH FROM C1 FOR :SIDX2 ROWS INTO :S00S01L:IND_ARRAY 
C/END-EXEC                                   
 *                                           
C                   Eval      I# = SQLERRD(3)
 *                                           
 * Cursor schliessen                         
 *                                           
C/EXEC SQL                                   
C+ CLOSE C1                                  
C/END-EXEC                                   

C                   Eval      SIDX1 = 1                
C                   Eval      %OCCUR(S00S01L) = SIDX1  
C                   DOW       SIDX1 <= I#              
 * Verarbeitung
C                   Move      L1TXNR        S0PERS#    
C                   Movel     L1TXB1        S0NAME     
 *
C                   EVAL      SIDX1 = SIDX1 + 1          
C                   EVAL      %OCCUR(S00S01L) = SIDX1    
C                   EndDo

[FNeurieser]

Nö.
Wie willst du denn die Daten anders als per Fetch von SQL holen ?

FETCH kann nicht ersetzt werden, ist mir klar, aber wenn fetch nur einmal alle Datensätze rüberschiebt... das war gemeint.

[Fuerchau]

Ob du nun die Daten erst in ein Array lädst oder direkt verarbeitest, von der Performance wirst du da keinen Unterschied bemerken.
Einfacher ist natürlich die Direktverarbeitung, vor allem wenn ich nicht weiß, wie viele Sätze ich denn so bekommen kann.

Ansonsten ist ein
for SIDX1 = 1 to I#;
endfor;
einfacher .

[B.Hauser]

FETCH kann nicht ersetzt werden, ist mir klar, aber wenn fetch nur einmal alle Datensätze rüberschiebt... das war gemeint.

Aber auch beim Multiple Row Fetch ist ein Pointer-Handling nicht erforderlich, sofern das SQL-Statement (bzw. die im SELECT angegebenen Spalten) zur Compile-Zeit bekannt sind.
Das Ergebnis wird direkt in eine Mehrfach-Datenstruktur (Schlüssel-Wort OCCURS) oder Array-Datenstruktur (Schlüssel-Wort DIM) eingelesen.
Die Anzahl der eingelesenen Datensätze wird dann aus der Mehrfach/Array-Datenstruktur ausgelesen. Sofern mehr Datensätze als die Mehrfach/Array-Datenstruktur halten kann eingelesen werden müssen, erfolgt ein weiterer Fetch.

Birgitta

[FNeurieser]

@All

Danke an alle. Jetzt ist mir wieder einmal etwas viel klarer geworden.