Extrahieren von Zeilen aus einer Datenbank inklusive depedent Zeilen

Möglicherweise gibt es einige Tools, die tut es schon, aber willkürlich die Extraktion aller Zeilen von Tabellen aus einem Tisch ist eine kleine Entwicklungsaufgabe in sich selbst. Ich kann nicht schreiben, die ganze Sache für dich, aber ich kann dir begann - ich begann, es zu schreiben, aber nach etwa 20 Minuten merkte ich, dass es war ein wenig mehr Arbeit, die ich wollte, zu verpflichten, sich an unbezahlten Antwort.

Ich kann sehen, dass es stets am besten durch eine rekursive PL/SQL-Prozedur, verwenden würde dbms_ouput und user_cons_columns & user_constraints zu erstellen, fügt Anweisung für die Quell-Tabelle. Sie können ein wenig schummeln, indem alle die Einsätze, wenn die Spalten wurden char-Werte, da Oracle wird implizit konvertiert alle char-Werte auf den richtigen Datentyp, vorausgesetzt, Ihr NLS-Parameter sind identisch in der Quelle & target-system.

Beachten Sie, dass das Paket unten Probleme haben wird, wenn Sie zirkuläre Beziehungen in Ihrem Tische; auch auf früheren Versionen von Oracle können Sie mit einer out-of-Pufferspeicher mit dbms_output. Beide Probleme können gelöst werden, durch einfügen der generierten sql in eine staging-Tabelle, die einen eindeutigen index auf dem sql -, und Abbruch der Rekursion, wenn man einen eindeutigen Schlüssel Kollision. Die große Zeitersparnis, unten ist die MakeParamList Funktion, konvertiert einen cursor zurückgibt, die eine Liste von Spalten in eine durch Kommas getrennte Liste, oder einen einzigen Ausdruck, Darstellung der Werte dieser Spalten in einer in Anführungszeichen eingeschlossenen, durch Komma abgetrennt, wenn Sie ausgeführt wird, wie der select-Klausel in einer Abfrage für die Tabelle.

Beachten Sie auch, dass das folgende Paket nicht wirklich arbeiten, bis Sie es ändern weitere (einer der Gründe, warum ich aufgehört, es zu schreiben): Die erste insert-Anweisung generiert wird, basiert auf der Annahme, dass die constraint_vals argument übergeben, wird das Ergebnis in einer einzigen Zeile erzeugt werden - natürlich, das ist fast sicher nicht der Fall, wenn Sie anfangen recursing (da haben Sie viele Kinder-Zeilen für ein Elternteil). Sie müssen ändern Sie die generation der ersten Aussage (und spätere rekursive Aufrufe) werden in einer Schleife behandeln die Fälle, in denen der Anruf zu der ersten IMMEDIATE EXECUTE-Aufruf erzeugt mehrere Zeilen statt einer einzigen. Die Grundlagen, um es arbeiten hier sind, brauchen Sie nur Schleifen, die details und Holen Sie sich die äußeren cursor arbeiten.

Einer abschließenden beachten Sie auch: Es ist unwahrscheinlich, dass Sie laufen konnte, dieses Verfahren generiert einen Satz von Zeilen, die, wenn Sie eingesetzt wird in einem Ziel-system, würde dies eine "saubere" Daten hat, da, obwohl die Sie erhalten würden, alle abhängigen Daten, diese Daten können abhängig von anderen Tabellen, die Sie nicht importieren (z.B., das erste Kind-Tabelle, die Sie stoßen können auch andere Fremdschlüssel verweisen auf die Tabellen keinen Bezug zu Ihrem ursprünglichen Tisch). In diesem Fall möchten Sie vielleicht starten Sie mit den detail-Tabellen und arbeiten Sie Ihren Weg nach oben statt nach unten; dadurch, dass Sie würde auch wollen, um in umgekehrter Reihenfolge zu den Anweisungen, die Sie erzeugt, entweder über eine scripting-Dienstprogramm oder durch einfügen von sql in eine staging-Tabelle wie ich oben erwähnt, mit einer Sequenz, und wählen Sie eine absteigende Sortierung.

Als für die Berufung auf Sie, übergeben Sie das Komma getrennte Liste der Spalten zu beschränken, als constraint_cols und die entsprechenden Komma-getrennte Liste von Werten als constraint_vals, z.B.:

exec Data_extractor.MakeInserts ('MYTABLE', 'COL1, COL2', '99, 105')

Hier ist es:

CREATE OR REPLACE PACKAGE data_extractor
IS
   TYPE column_info IS RECORD(
      column_name   user_tab_columns.column_name%TYPE
   );

   TYPE column_info_cursor IS REF CURSOR
      RETURN column_info;

   FUNCTION makeparamlist(
      column_info   column_info_cursor
    , get_values    NUMBER
   )
      RETURN VARCHAR2;

   PROCEDURE makeinserts(
      source_table      VARCHAR2
    , constraint_cols   VARCHAR2
    , constraint_vals   VARCHAR2
   );
END data_extractor;


CREATE OR REPLACE PACKAGE BODY data_extractor
AS
   FUNCTION makeparamlist(
      column_info   column_info_cursor
    , get_values    NUMBER
   )
      RETURN VARCHAR2
   AS
   BEGIN
      DECLARE
         column_name   user_tab_columns.column_name%TYPE;
         tempsql       VARCHAR2(4000);
         separator     VARCHAR2(20);
      BEGIN
         IF get_values = 1
         THEN
            separator := ''''''''' || ';
         ELSE
            separator := '';
         END IF;

         LOOP
            FETCH column_info
             INTO column_name;

            EXIT WHEN column_info%NOTFOUND;
            tempsql := tempsql || separator || column_name;

            IF get_values = 1
            THEN
               separator := ' || '''''', '''''' || ';
            ELSE
               separator := ', ';
            END IF;
         END LOOP;

         IF get_values = 1
         THEN
            tempsql := tempsql || ' || ''''''''';
         END IF;

         RETURN tempsql;
      END;
   END;

   PROCEDURE makeinserts(
      source_table      VARCHAR2
    , constraint_cols   VARCHAR2
    , constraint_vals   VARCHAR2
   )
   AS
   BEGIN
      DECLARE
         basesql               VARCHAR2(4000);
         extractsql            VARCHAR2(4000);
         tempsql               VARCHAR2(4000);
         valuelist             VARCHAR2(4000);
         childconstraint_vals  VARCHAR2(4000);
      BEGIN
         SELECT makeparamlist(CURSOR(SELECT column_name
                                       FROM user_tab_columns
                                      WHERE table_name = source_table), 0)
           INTO tempsql
           FROM DUAL;

         basesql := 'INSERT INTO ' || source_table || '(' || tempsql || ') VALUES (';

         SELECT makeparamlist(CURSOR(SELECT column_name
                                       FROM user_tab_columns
                                      WHERE table_name = source_table), 1)
           INTO tempsql
           FROM DUAL;

         extractsql := 'SELECT ' || tempsql || ' FROM ' || source_table 
                       || ' WHERE (' || constraint_cols || ') = (SELECT ' 
                       || constraint_vals || ' FROM DUAL)';

         EXECUTE IMMEDIATE extractsql
                      INTO valuelist;

         -- This prints out the insert statement for the root row
         DBMS_OUTPUT.put_line(basesql || valuelist || ');');

         -- Now we construct the constraint_vals parameter for subsequent calls:
         SELECT makeparamlist(CURSOR(  SELECT column_name
                                         FROM user_cons_columns ucc
                                            , user_constraints uc
                                        WHERE uc.table_name = source_table
                                          AND ucc.constraint_name = uc.constraint_name
                                     ORDER BY position)
                             , 1)
           INTO tempsql
           FROM DUAL;

         extractsql := 'SELECT ' || tempsql || ' FROM ' || source_table 
                       || ' WHERE ' || constraint_cols || ' = ' || constraint_vals;

         EXECUTE IMMEDIATE extractsql
                      INTO childconstraint_vals;

         childconstraint_vals := childconstraint_vals;

-- Now iterate over the dependent tables for this table
-- Cursor on this statement:
--    SELECT uc.table_name child_table, uc.constraint_name fk_name
--      FROM user_constraints uc
--         , user_constraints ucp
--     WHERE ucp.table_name = source_table
--      AND uc.r_constraint_name = ucp.constraint_name;

         --   For each table in that statement, find the foreign key 
         --   columns that correspond to the rows
         --   in the parent table
         --  SELECT column_name
         --    FROM user_cons_columns
         --   WHERE constraint_name = fk_name
         --ORDER BY POSITION;

         -- Pass that columns into makeparamlist above to create 
         -- the constraint_cols argument of the call below:

         -- makeinserts(child_table, ChildConstraint_cols, childconstrain_vals);
      END;
   END;
END data_extractor;

Ich denke, DBUnit kann dies tun.