Blocks von DB von letztem Datensatz aufwärts einlesen

[nikua]

Liebes Forum!

Da mir bei "komplizierteren" Funktionen leider etwas der Durchblick fehlt, stehe ich vor folgendem Problem:

Ich lese große Datenmengen mittels DBIBlockRead ein. Jeden Block gehe ich von vorne nach hinten (bis zum Ende das Blocks) durch. Jetzt muss ich aber mit dem letzten Block beginnen, den von hinten nach vorne durchlesen und dann den nächsten=vorhergehenden Block abarbeiten, also die ganze Sache rückwärts erledigen.

Vom ersten bis zum letzten Datensatz (also beginnend mit erstem, endend mit letztem Block, pro Block vom ersten bis zum letzten Datensatz) gehe ich dabei wie folgt vor:

Hier werd

Delphi-Quellcode:

procedure soundso;
var  pRecBuffs, pRecCurrBuff: pBYTE;
     TotalSize: int64;
     Records, RecordsToRead, RecordsProcessed : integer;
     pSFields, pS: pFLDDesc;
     Props: CURProps;
     Blank  : longBool;
     BlockSize:int64;

     saveTableName: String
     workTable: TTable;

  procedure prepareMem(myTable: TTable);
  begin
    BlockSize:=BlocksizeParam*1024;
    BlockSize:=BlockSize*1024;
    Check(DbiSetToBegin(myTable.Handle));

    Check(DbiGetCursorProps(myTable.Handle, Props));

    pSFields := AllocMem(myTable.FieldCount * sizeof(FLDDesc));
    Check(DbiGetFieldDescs(myTable.Handle, pSFields));

    // Determine the amount of records that can be move in the block size given...
    Check(DbiGetRecordCount(myTable.Handle, Records));
    TotalSize := int64(Props.iRecBufSize) * int64(Records);
    if TotalSize < BlockSize then
      BlockSize := TotalSize;
    RecordsToRead := BlockSize div Props.iRecBufSize;
    pRecBuffs := AllocMem(BlockSize * sizeof(BYTE));
  end; //prepareMem

begin
  saveTableName:='xxx';
  BlockSizeParam:=2;

  workTable:=TTable.Create(Nil);
  workTable.DatabaseName:='xxx';
  workTable.TableName:=tableName;

  pRecBuffs := nil;  pSFields := nil;
  RecordsProcessed := 0;

  try
   prepareMem(workTable);
   while (RecordsToRead > 0) and (not docancel) do
    begin
      Check(DbiReadBlock(workTable.Handle, RecordsToRead, pRecBuffs));

      pRecCurrBuff:=pRecBuffs;
      for i:=0 to recordsToRead-1 do
        begin
          //Daten bearbeiten
          inc(pRecCurrBuff,Props.iRecBufSize *  sizeof(BYTE));
        end;

      Inc(RecordsProcessed, RecordsToRead);
      if RecordsToRead > (Records - RecordsProcessed) then
        RecordsToRead := (Records - RecordsProcessed);
    end; //while RecordsToRead > 0 do
except
end;

end; //updateMySQLData

Ich wäre sehr dankbar, wenn mir jemand sagen könnte, wie ich hier die Richtung umdrehe, also sowohl die Blocks von hinten nach vorne, wie auch die Inhalte der Blocks von hinten nach vorne abarbeiten kann.

Lieb-Dank!

[nikua]

Zweites Problem habe ich gerade selbst gelöst, obs die eleganteste Variante ist, ist eine andere Frage...

Den aktuellen Block von hinten nach vorne durchkämmen kann ich durch folgende Änderungen:

pRecCurrBuff:=pRecBuffs; ergänzen um
inc(pRecCurrBuff, (Props.iRecBufSize*sizeOf(BYTE)*(RecordsToRead-1))); //Den Pointer auf das Ende des Blocks stellen und statt den Zeiger danach zu inkrementieren
inc(pRecCurrBuff,Props.iRecBufSize * sizeof(BYTE)); wird er logischerweise dekrementiert.
dec(pRecCurrBuff,Props.iRecBufSize * sizeof(BYTE)); Jetzt bleibt noch offen, wie ich den letzten Block zuerst ansprechen und mich dann bis zum ersten Block vorarbeiten kann. Für Vorschläge bin ich jederzeit offen!