tabellen abgleichen

[Nightfly]

ich habe zwei tabellen, beide mit 100 spalten. ca. 80% der spalten stimmen überein.
bisher greif ich immer mit Table1Wert1.Value := Table2Wert2.Value; auf werte zu, bloß widerstrebt es mir 80 solche Zeilen im quellcode zu haben.

Das muß doch auch über eine schleife gehen.

So nach dem motto: Für jeden datensatz: mit allen spalten von tabelle1 tue : gibt es eine gleichnamige spalte in tabelle,dann gleiche die werte ab.

[angos]

versuchs doch mal mit Table1.GetFieldList. Das gibt eine Liste aller Felder einer Tabelle wieder. Das machste bei beiden Tabellen und vergleichst diese Strings dann.
Dann brauchst du nur noch auf die passenden Felder mit Table1.FieldbyName(STRING):= Table2.FieldbyName(STRING) zuzugreifen

[Memo]

Code:

 
       while not QuelleTable.Eof do
       begin
         ZielTable.Append;
        for i:=0 to QuelleTable.FieldCount -1 do
          Try  ZielTable.Fields[i].Assign(QuelleTable.Fields[i]) except  end;
           ZielTable.Post;
          QuelleTable.Next;
       end;

Gegebenenfalls selbst an Bedürfnisse anpassen.

[Robert_G]

uff

Zitat:

... except end;

Ein leerer Exception Block ist irgendwie, wie russisches Roulet mit einem vollen Magazin.


Nur um dir zu zeigen, dass es auch außerhalb von Delphi geht habe ich mal den Rest meiner verspäteten Mittagspause genutzt und das da gebastelt:

SQL-Code:

/**/
create or replace function getCompareSQL
(
  pTable1 in varchar2
 ,pTable2 in varchar2
) return varchar2 is
  -- Types
  type ItemList is table of varchar2(32);
  type TableDef is record
  (
     Owner     varchar2(32)
    ,TableName varchar2(32)
  );
  -- Constants
  Intend constant char(7) := '       ';
  Lf     constant char(1) := Chr(10);

  -- Variables
  Items    ItemList;
  Table1   TableDef;
  Table2   TableDef;
  i        integer;
  LinkStmt varchar2(4000);

  -- Cursors
  cursor getItems(iTable1 in TableDef, iTable2 in TableDef) is
    SELECT a.Column_Name
    FROM   All_Tab_Columns a
          ,All_Tab_Columns b
    WHERE  a.Owner       = iTable1.Owner     and
           a.Table_Name  = iTable1.TableName and
           b.Owner       = iTable2.Owner     and
           b.Table_Name  = iTable2.TableName and
           a.Column_Name = b.Column_Name;

  -- nested functions
  function getDef(pTable in varchar2) return TableDef is
    lPos    integer;
    tempDef TableDef;
  begin
    lPos := InSTR(pTable
                 ,'.');
    if lPos = 0 then
      tempDef.Owner     := User;
      tempDef.TableName := Upper(Trim(pTable));
      return tempDef;
    else
      tempDef.Owner := Upper(Trim(SubStr(pTable
                                        ,1
                                        ,lPos - 1)));

      tempDef.TableName := Upper(Trim(SubStr(pTable
                                            ,lPos + 1)));

      return tempDef;
    end if;
  end;
begin
  -- seperate Owner & Table
  Table1 := getDef(pTable1);
  Table2 := getDef(pTable2);

  -- get equal Items
  open getItems(Table1
               ,Table2);

  fetch getItems bulk collect
    INTO Items;
  close getItems;

  -- Build up WHERE Clause
  if Items.Count > 0 then
    for i in Items.first .. Items.last loop
      LinkStmt := LinkStmt || ' and' || Lf || Intend || 'a.' || Items(i) || ' = b.' || Items(i);
    end loop;
    LinkStmt := SubStr(LinkStmt
                      ,6 + Length(Intend));

    -- Return SQL Statement
    return('SELECT Count(*) EqualRecs' || Lf ||
           'FROM   ' || Table1.Owner || '.' || Table2.TableName || ' a' || Lf ||
           '      ,' || Table2.Owner || '.' || Table2.TableName || ' b' || Lf ||
           'WHERE (' || LinkStmt || ') ');

  else
    return null;
  end if;
end;

Ich hatte in der ursprünglichen Version einen Ref Cursor übergeben, der danach direkt in einer TOracleQuery oder einem DataAdapter ( .Net ) verwendet werden könnte.
Da ich aber bezweifle, dass IB überhaupt weiß, was ein REF Cursor ist, übergebe ich nur ein olles SQL Statement.

BTW: Der Code muss natürlich von PL/SQL zu IB/FB - PSQL übersetzt werden, dürfte aber nicht allzu viele Probleme machen.