Reihenfolge zum Kopieren von Datensätzen ermitteln

[Ducksoul]

Hallo,

ich bin mir grade nicht sicher, ob ich hier in den richtigen Unterbereich des Forums poste, aber mein Problem hat mit Datenbanken zu tun *g*

Es stellt sich mir das Problem, dass ich eine gewisse Anzahl an Tabellen in einer Datenbank habe, welche durch Fremdschlüsselbeziehungen miteinander verbunden sind. Möchte ich nun aus einer Tabelle einen Datensatz kopieren, so sollen alle Datensätze welche mit diesem DS via FK-Beziehung verbunden sind, ebenfalls kopiert werden und die Datensätze welche in der FK-Tabelle widerrum mit einer FK-Beziehung verbunden sind ebenso, etc...

Um die Reihenfolge herauszubekommen, in welcher die Datensätze kopiert werden sollen schreibe ich alle Tabellen mit FK-Beziehung in ein Array mit folgendem Aufbau:

Delphi-Quellcode:

  Timp = record 
    col: string;
    r_tn: string;
    r_col: string;
  end;

  Texp = record 
    col: string;
    r_tn: string;
    r_col: string;
  end;

  TTables = record // Tabellen mit FK-Beziehung
    tn: string;
    arr_i: array of Timp; // Tabellen, auf die referenziert wird
    arr_e: array of Texp; // Tabellen, von denen aus referenziert wird
  end;

Mittels folgender compare-Funktion wird dann ermittelt, werden 2 Tabellen verglichen. Referenziert Tabelle 1 auf Tabelle 2, so ist das Ergebnis = 1, referenziert Tabelle 2 auf Tabelle 1, so ist das Ergebnis -1:

Delphi-Quellcode:

function Timport_form.TableCopyCompare(object0, object1: TTables) : integer;
var
  rv, i, j: integer;
  left, right: TTables;
  refs: string;
begin
  rv := 0;
  left := object0;
  right := object1;

  if rv = 0 then
  begin
    if left.arr_i <> nil then
    begin
      for i := 0 to Length(left.arr_i) - 1 do
      begin
        refs := left.arr_i[i].r_tn;
        if refs = right.tn then
          rv := 1;
      end;
    end;

    if right.arr_i <> nil then
    begin
      for i := 0 to Length(right.arr_i) - 1 do
      begin
        refs := right.arr_i[i].r_tn;
        if refs = left.tn then
          rv := -1;
      end;
    end;
  end;

  result := rv;
end;

Um nun die Reihenfolge herauszubekommen, möchte ich das Array mit den Tabellen untereinander mittels Quicksort und obiger Comparefunktion so ordnen, wie am Anfang beschrieben. Aber dafür bin ich irgendwie zu blöd. Könnte mir einer beim Aufbau meines QS helfen? ^^

So weit bin ich bis jetzt:

Delphi-Quellcode:

procedure Timport_form.QuickSort(var arr: array of TTables; inf, sup: Integer);
var
 i, j, z: Integer;
 pivot: TTables;
 aux: TTables;
 sl: TStringlist;
begin
  i := inf;
  j := sup;
  sl := TStringlist.Create;

  if inf < sup then
  begin
    pivot := arr[(inf + sup) div 2];

    while i <= j do
    begin
      while (i < sup) and (TableCopyCompare(arr[i], pivot) < 0) do
        Inc(i);
      while (j > inf) and (TableCopyCompare(arr[j], pivot) > 0) do
        Dec(j);

      if i <= j then
      begin
        aux := arr[i];
        arr[i] := arr[j];
        arr[j] := aux;
        Inc(i);
        Dec(j);

        for i := 0 to Length(arr_tables) - 1 do
          sl.Add(arr_tables[i].tn + ': ' + IntToStr(Length(arr_tables[i].arr_i)) + ', ' + IntToStr(Length(arr_tables[i].arr_e)));

        ShowMessage(sl.Text);
      end;
    end;
  end;

 if j > inf then
   QuickSort(arr, inf, j);
 if i < sup then
   QuickSort(arr, i, sup);
end;

Gruß

[Ducksoul]

Huhu,

schon jemand ne Idee? :)

[Ducksoul]

Hm hat vielleicht einer eine andere Idee oder einen Tipp wie ich an die Sache rangehen kann?

Ich hab mir jetz ma so gedacht:
1. Suche alle Tabellen, welche keine weiteren Tabellen importieren
2. Prüfe für jede dieser Tabellen, ob die Tabellen welche sie exportieren schon in der Liste der sortierten Tabellen ist
JA: Springe zur nächsten Tabelle
NEIN: Springe zu der Tabelle, welche die oben genannte Tabelle exportiert und führe 2. erneut durch.

etc...


Wenn ich das aber so rekursiv ausführe ist das nicht wirklich performant und vor allem kommt man mit den ganzen for-Schleifen übelst schnell durcheinander. :( Ne ordentliche Lösung wäre mir schon lieb.


Gruß

[Ducksoul]

Mir raucht der Kopf...

Ich sitze immernoch am selben Problem - mehr oder weniger.

Ausgangssituation:
- ich habe die Tabellen in der Reihenfolge in der sie später kopiert werden sollen in einem Array stehen
- ich habe von einer Ausgangstabelle einen Schlüssel. Alle Datensätze aus anderen Tabellen in Verbindung stehen sollen später in die andere Datenbank kopiert werden
- ergo: Ich muss die Schlüssel rausfinden, welche pro Tabelle exportiert werden müssen.

Da ich aber sowohl vorwärtsgerichtete Rekursion, als auch rückwärtsgerichtete Rekursion anwenden muss (siehe Tabelle) weiß ich echt nich wie ich das jetz machen soll.


HILFE! ^^ :wall:

[Ducksoul]

Hi, wollte nur bescheid geben, dass ich das Problem gelöst habe, wenn auch nur semi-universell.

1. Nehme den Schlüssel der Ausgangstabelle und finde alle Schlüssel von den Tabellen, auf die diese Tabelle referenziert rekursiv.
2. Gehe alle Tabellen durch, die noch nich betrachtet wurden und finde für diese die Schlüssel, indem geprüft wird welchen Schlüssel die Fremdschlüsselpalte von der referenziert wird hat.
2.1. Setze finish auf true, wenn alle Tabellen von denen auf diese Tabelle referenziert wird betrachtet wurden

Gruß