Oracle-bauen, um-und PL/SQL-Paket-Abhängigkeiten

Ich versuche, den Aufbau einer Liste von PL/SQL-Paket-Abhängigkeiten, so dass ich kann helfen, richten Sie einen automatisierten build-Skript für meine Pakete laufen auf dem test-server. Gibt es einen Weg, um zu starten mit einem einzigen Paket (ein "root" - Paket mit seinem Namen identifiziert, im Idealfall) und dann finden all die Abhängigkeiten und die Reihenfolge müssen zusammengestellt werden?
Abhängigkeiten sind bereits vollständig gelöst in meinem persönlichen schema (also ich zumindest irgendwo zu beginnen - aber wohin gehe ich als Nächstes?).

(Oracle 10.2)

EDIT:

Das build-Werkzeug, das verwendet wird, verwenden Sie die build-Reihenfolge und wird retreive die Dateien in der Reihenfolge von der Quelle Kontrolle, und dann passieren Sie, um Oracle zu kompilieren (die aktuelle build-tool selbst ist in Python oder Java oder beides - ich habe keinen Zugriff auf die Quelle). Grundsätzlich ist das build-Werkzeug benötigt als Eingabe eine Liste von Dateien zu kompilieren in der Reihenfolge kompiliert werden müssen in, und der Zugang zu diesen Dateien in der Quellcodeverwaltung. Wenn es die hat, funktioniert alles Recht gut.

EDIT:

Danke für die nette scripts. Leider wird der build-Prozess wird meistens aus der Hand. Der Prozess basiert auf einem build-tool, das gebaut wurde, die durch den Hersteller des Produkts, werden wir die Integration mit der, die ist der Grund, warum die nur Eingänge, die ich geben kann, um den build-Prozess eine Liste von Dateien in der Reihenfolge, die Sie brauchen, um gebaut werden. Wenn es einen compiler-Fehler, den build-tool fehlschlägt, müssen wir manuell einen Antrag für einen neuen build. So eine Liste von Dateien in der Reihenfolge, wie Sie erstellt werden sollten, ist wichtig.

EDIT:

Gefunden: http://www.oracle.com/technology/oramag/code/tips2004/091304.html
Gibt mir die Abhängigkeiten eines Objekts. Jetzt brauche ich nur, um die Bestellung Recht... Wenn ich etwas arbeiten werde ich es hier posten.

EDIT: (mit code!)

Ich weiß, dass in der Regel diese Art der Sache ist nicht erforderlich für Oracle, aber für alle die es noch interessiert...

Habe ich zusammen gebastelt ein kleines Skript, das scheint zu sein, bauen Sie um, so dass alle Pakete, die gebaut werden in der richtigen Reihenfolge mit keine Abhängigkeit-bezogene Fehler (mit Bezug auf pacakges) das erste mal:

declare

    type t_dep_list is table of varchar2(40) index by binary_integer;
    dep_list t_dep_list;
    i number := 1;
    cursor c_getObjDepsByNameAndType is
    --based on a query found here: http://www.oracle.com/technology/oramag/code/tips2004/091304.html
        select lvl, u.object_id, u.object_type, LPAD(' ', lvl) || object_name obj
        FROM (SELECT level lvl, object_id
               FROM SYS.public_dependency s
               START WITH s.object_id = (select object_id
                                         from user_objects
                                         where object_name = UPPER(:OBJECT_NAME)
                                               and object_type = UPPER(:OBJECT_TYPE))
               CONNECT BY s.object_id = PRIOR referenced_object_id
               GROUP BY level, object_id) tree, user_objects u
        WHERE tree.object_id = u.object_id
              and u.object_type like 'PACKAGE%' --only look at packages, not interested in other types of objects
        ORDER BY lvl desc;

    function fn_checkInList(in_name in varchar2) return boolean is
    begin
        for j in 1 .. dep_list.count loop
            if dep_list(j) = in_name then
                return true;
            end if;
        end loop;
        return false;
    end;



    procedure sp_getDeps(in_objID in user_objects.object_id%type, in_name in varchar2) is
        cursor c_getObjDepsByID(in_objID in user_objects.object_id%type) is
        --based on a query found here: http://www.oracle.com/technology/oramag/code/tips2004/091304.html
            select lvl, u.object_id, u.object_type, LPAD(' ', lvl) || object_name obj
            FROM (SELECT level lvl, object_id
                   FROM SYS.public_dependency s
                   START WITH s.object_id = (select uo.object_id
                                             from user_objects uo
                                             where uo.object_name =
                                                   (select object_name from user_objects uo where uo.object_id = in_objID)
                                                   and uo.object_type = 'PACKAGE BODY')
                   CONNECT BY s.object_id = PRIOR referenced_object_id
                   GROUP BY level, object_id) tree, user_objects u
            WHERE tree.object_id = u.object_id
                  and u.object_id <> in_objID --exclude self (requested Object ID) from list.
            ORDER BY lvl desc;
    begin
        --loop through the dependencies
        for r in c_getObjDepsByID(in_objID) loop
            if fn_checkInList(trim(r.obj)) = false and (r.object_type = 'PACKAGE' or r.object_type = 'PACKAGE BODY') and
               trim(r.obj) <> trim(in_name) then
                dbms_output.put_line('checking deps of: ' || r.obj || ' ' || r.object_id || ' level: ' || r.lvl);
                --now for each dependency, check the sub-dependency
                sp_getDeps(r.object_id, trim(r.obj));
                --add the object to the dependency list.
                dep_list(i) := trim(r.obj);
                i := i + 1;
            end if;
        end loop;
    exception
        when NO_DATA_FOUND then
            dbms_output.put_line('no more data for: ' || in_objID);
    end;

begin

    for r in c_getObjDepsByNameAndType loop
        dbms_output.put_line('top-level checking deps of: ' || r.obj || ' ' || r.object_id || ' level: ' || r.lvl);
        sp_getDeps(r.object_id, trim(r.obj));
    end loop;

    dbms_output.put_line('dep count: ' || dep_list.count);
    for j in 1 .. dep_list.count loop
        dbms_output.put_line('obj: ' || j || ' ' || dep_list(j));
    end loop;
end;

Ich weiß, es ist nicht der schönste code (globals alle über dem Platz, etc... igitt), und ich werde wohl umbuchen es, wenn ich die chance bekommen, an diesem Nachmittag, um es zu säubern, aber jetzt, erzeugt es eine build order, die scheint, zu laufen, die erste Zeit ohne Probleme.

:OBJECT_NAME sollte das root-Objekt, das Sie verfolgen möchten alle Abhängigkeiten und build-Reihenfolge. Für mich ist das Haupt-Paket mit einer einzigen Methode, die den Einstiegspunkt für den rest des Systems.

:OBJECT_TYPE Ich habe meist nur für PACKAGE BODY, aber es sollte nicht zu viel Arbeit, um auch andere Arten, wie Trigger.

Eine Letzte Sache, die angegebenen Objekts :OBJECT_NAME erscheinen nicht in der Ausgabe, aber es sollte das Letzte Element, so müssen Sie hinzufügen, dass zu Ihrer build-Liste manuell.

UPDATE: ich habe gerade entdeckt user_dependencies und all_dependencies dieser code konnte wahrscheinlich gemacht werden, viel einfacher jetzt.

meinst du Oracle PL/SQL-Pakete?
Nur die Art, wie ich es getan habe ist ein Skript, und testen, bereitstellen, um eine frische schema. Sortieren Sie die Pakete in der Skript, wie erforderlich, basierend auf den Fehlern...
Ja, ich meinte Pakete.
Ich vergaß zu erwähnen, dass die spc ' s geladen werden sollen, bevor bdy ist zu helfen, mit Paket.Funktion/gespeicherte Prozedur Auflösung. Sie sind getrennt, nicht das laden einer einzigen Datei (Dateiendung fällt mir ATM) - richtig?
Ponys: ja, wir wissen, haben wir eine Zusammenstellung aller Spezifikationen vor stellen. Das Hauptproblem ist die Reihenfolge der Spezifikationen. Ja, Sie sind in getrennten Dateien aus dem Körper.

InformationsquelleAutor FrustratedWithFormsDesigner | 2010-02-02

8

Wenn du wirklich den Umgang mit nur PL/SQL-Pakete, die Sie brauchen nicht zu Schwitzen, die bauen um. Einfach bauen Sie alle das Paket Spezifikationen der ersten. Dann können Sie bereitstellen, die alle die Paket-Körper und Sie werden kompilieren, weil Ihre Abhängigkeiten sind Paket-Spezifikationen.

Wenn Sie geschehen, haben einige Paket-Spezifikationen, die abhängig von anderen specs - wenn Sie Pakete haben, die erklären, sagen, Konstanten, Subtypen oder ref-Cursor, die in den Signaturen von verpackten Verfahren - dann müssen Sie zum erstellen dieser Paket Spezifikationen der ersten. Aber es sollten nur wenige genug von Ihnen, dass Sie können, ordnen Sie Sie in das build-Skript von hand.

Bearbeiten

Sieht es aus wie Sie wil tun
inkrementelle UND "clean-sweep" baut,
also die build-Reihenfolge ist egal, die meisten
für, wenn Sie reinigen, die
Umgebung und erstellen Sie ihn neu.

Nicht nichts ändern.

Hier ein erweitertes Beispiel. Ich habe ein schema mit drei Paketen....
```
SQL> select object_name, object_type, status
  2  from user_objects
  3  order by 1, 2
  4  /

OBJECT_NAME     OBJECT_TYPE     STATUS
--------------- --------------- -------
PKG1            PACKAGE         VALID
PKG1            PACKAGE BODY    VALID
PKG2            PACKAGE         VALID
PKG2            PACKAGE BODY    VALID
PKG3            PACKAGE         VALID
PKG3            PACKAGE BODY    VALID

6 rows selected.

SQL>
```
Das interessante an der Sache ist, dass ein Verfahren in PKG1 ruft eine Prozedur aus PKG2, ein Verfahren, in PKG2 ruft eine Prozedur aus PKG3 und ein Verfahren, in PKG3 ruft eine Prozedur aus PKG1.

F. Wie funktioniert das zirkuläre Abhängigkeit arbeiten?

A. Es ist nicht eine zirkuläre Abhängigkeit....
```
SQL> select name, type, referenced_name, referenced_type
  2  from user_dependencies
  3  where referenced_owner = user
  4  /

NAME            TYPE            REFERENCED_NAME REFERENCED_TYPE
--------------- --------------- --------------- ---------------
PKG1            PACKAGE BODY    PKG1            PACKAGE
PKG1            PACKAGE BODY    PKG2            PACKAGE
PKG2            PACKAGE BODY    PKG2            PACKAGE
PKG2            PACKAGE BODY    PKG3            PACKAGE
PKG3            PACKAGE BODY    PKG3            PACKAGE
PKG3            PACKAGE BODY    PKG1            PACKAGE

6 rows selected.

SQL> 
```
Alle abhängigen Objekte dem Paket Körper, auch alle referenzierten Objekte werden die verpackt Spezifikationen. Folglich, wenn ich trash ' N ' 'rebuild das schema, es ist wirklich nicht egal in welcher Reihenfolge ich benutzen. Zuerst haben wir Müll ...
```
SQL> drop package pkg1
  2  /

Package dropped.

SQL> drop package pkg2
  2  /

Package dropped.

SQL> drop package pkg3
  2  /

Package dropped.

SQL>
```
Dann werden wir wieder aufzubauen ...
```
SQL> create or replace package pkg3 is
  2      procedure p5;
  3      procedure p6;
  4  end pkg3;
  5  /

Package created.

SQL> create or replace package pkg2 is
  2      procedure p3;
  3      procedure p4;
  4  end pkg2;
  5  /

Package created.

SQL> create or replace package pkg1 is
  2      procedure p1;
  3      procedure p2;
  4  end pkg1;
  5  /

Package created.

SQL> create or replace package body pkg2 is
  2      procedure p3 is
  3      begin
  4          pkg3.p5;
  5      end p3;
  6      procedure p4 is
  7      begin
  8          dbms_output.put_line('PKG2.P4');
  9      end p4;
 10  end pkg2;
 11  /

Package body created.

SQL> create or replace package body pkg3 is
  2      procedure p5 is
  3      begin
  4          dbms_output.put_line('PKG3.P5');
  5      end p5;
  6      procedure p6 is
  7      begin
  8          pkg1.p1;
  9      end p6;
 10  end pkg3;
 11  /

Package body created.

SQL> create or replace package body pkg1 is
  2      procedure p1 is
  3      begin
  4          dbms_output.put_line('PKG1.P1');
  5      end p1;
  6      procedure p2 is
  7      begin
  8          pkg2.p4;
  9      end p2;
 10  end pkg1;
 11  /

Package body created.

SQL>
```
Die Reihenfolge der einzelnen Objekte ist dabei irrelevant. Nur bauen Sie das Paket Spezifikationen, bevor das Paket den Körper. Obwohl selbst das nicht wirklich wichtig ist...
```
SQL> create or replace package pkg4 is
  2      procedure p7;
  3  end pkg4;
  4  /

Package created.

SQL> create or replace package body pkg4 is
  2      procedure p7 is
  3      begin
  4          dbms_output.put_line('PKG4.P7::'||constants_pkg.whatever);
  5      end p7;
  6  end pkg4;
  7  /

Warning: Package Body created with compilation errors.

SQL> show errors
Errors for PACKAGE BODY PKG4:

LINE/COL ERROR
-------- -----------------------------------------------------------------
4/9      PL/SQL: Statement ignored
4/43     PLS-00201: identifier 'CONSTANTS_PKG.WHATEVER' must be declared
SQL>
```
PKG4 ist UNGÜLTIG, weil wir noch nicht gebaut CONSTANTS_PKG noch.
```
SQL> create or replace package constants_pkg is
  2      whatever constant varchar2(20) := 'WHATEVER';
  3  end constants_pkg;
  4  /

Package created.

SQL> select object_name, object_type, status
  2  from user_objects
  3  where status != 'VALID'
  4  order by 1, 2
  5  /

OBJECT_NAME     OBJECT_TYPE     STATUS
--------------- --------------- -------
PKG4            PACKAGE BODY    INVALID

SQL> 
SQL> set serveroutput on size unlimited
SQL> exec pkg4.p7
PKG4.P7::WHATEVER

PL/SQL procedure successfully completed.

SQL> select object_name, object_type, status
  2  from user_objects
  3  where status != 'VALID'
  4  order by 1, 2
  5  /

no rows selected

SQL>
```
Alles gebaut mit CREATE OR REPLACE wird immer erstellt, es wird nur als UNGÜLTIG markiert, wenn es Fehler. Sobald wir ausführen, die direkt oder indirekt die Datenbank kompiliert es für uns. Also, Reihenfolge spielt keine Rolle. Wirklich nicht.

Wenn die Idee der Veredelung ein build mit ungültigen Objekte, die Sie betrifft - und ich habe eine gewisse Sympathie mit, dass wir gesagt, nicht zu Leben mit zerbrochenen Fenstern - können Sie die utlrp Skript oder in 11g die UTL_RECOMP Paket; entweder Ansatz erfordert SYSDBA account.

edit 2

Beruht der Prozess um einen zu bauen
tool wurde von dem Verkäufer
das Produkt, das wir integrieren,
das ist der Grund, warum die nur Eingänge kann ich
geben Sie die build-Prozesses sind eine Liste
Dateien in der Reihenfolge, wie Sie sein müssen
gebaut in. Wenn es einen compiler
Fehler, die build-tool fehlschlägt, haben wir
manuell senden Sie eine Anfrage für eine neue
bauen.

Dies ist ein politisches problem, kein technisches. Das ist nicht zu sagen, dass die politischen Probleme können nicht gelöst werden mit einem technischen Update, nur dass das technische Update ist nicht das beste Werkzeug für den job. Viel Glück.
- Ich begann, dies zu tun mit der hand, und realisiert, dass wir haben, es zu tun zu halten von der hand, wie das Projekt fortschreitet und neue Pakete Hinzugefügt (und es werden neue Pakete, wahrscheinlich im späten Frühjahr würde ich gerne noch etwas automatisiert werden, bevor Sie dann).
- Mit allen Mitteln automatisieren den build. Aber wenn Sie ein Paket hinzufügen nun müssen Sie nur fügen Sie es an das Ende der build-Skript. Die Abhängigkeit Reihenfolge eigentlich egal ist, mit Paketen.
- Wenn Sie bauen den code schrittweise, ich glaube, Sie haben Recht. Es sieht aus wie Sie wil tun, inkrementelle UND "clean-sweep" baut, also die build-Reihenfolge ist egal, die meisten für, wenn Sie reinigen, die Umgebung und erstellen Sie ihn neu.
- Nachdem ich alle Pakete, wenn Sie einen Blick auf das schema, viele erscheinen mag unkompilierte. Wie erwähnt wurde -, Oracle-stellen Sie automatisch bei der ersten Verwendung, aber wenn Sie wollen etwas mehr Komfort, nutzen Sie einfach dbms_utility.compile_schema(...) zu kompilieren, schema. Es ist wahrscheinlich ähnlich UTLRP, aber nicht erfordert SYSDBA-privs und betrifft nur ein schema.
- Das sind einige sehr gute Punkte. Wir hatten auch eine Art von Sieg, die mit dem tool selbst: Wir haben gerade entdeckt, dass wir können verlangen, bis zu 4 PL/SQL-Kompilierungen "unter der Decke", und nur die Fehler, die weiterhin nach dem 4. Durchgang gemeldet werden. Ich würde noch gerne eine meist richtige build order, wie es könnte helfen, die 4 Pässe fahren ein wenig schneller.
InformationsquelleAutor APC

Betrachten Sie das folgende Skript aus http://www.oracle-base.com/articles/misc/RecompilingInvalidSchemaObjects.php

SET SERVEROUTPUT ON SIZE 1000000
BEGIN
  FOR cur_rec IN (SELECT owner,
                         object_name,
                         object_type,
                         DECODE(object_type, 'PACKAGE', 1,
                                             'PACKAGE BODY', 2, 2) AS recompile_order
                  FROM   dba_objects
                  WHERE  object_type IN ('PACKAGE', 'PACKAGE BODY')
                  AND    status != 'VALID'
                  ORDER BY 4)
  LOOP
    BEGIN
      IF cur_rec.object_type = 'PACKAGE' THEN
        EXECUTE IMMEDIATE 'ALTER ' || cur_rec.object_type || 
            ' "' || cur_rec.owner || '"."' || cur_rec.object_name || '" COMPILE';
      ElSE
        EXECUTE IMMEDIATE 'ALTER PACKAGE "' || cur_rec.owner || 
            '"."' || cur_rec.object_name || '" COMPILE BODY';
      END IF;
    EXCEPTION
      WHEN OTHERS THEN
        DBMS_OUTPUT.put_line(cur_rec.object_type || ' : ' || cur_rec.owner || 
                             ' : ' || cur_rec.object_name);
    END;
  END LOOP;
END;
/

Interessant, aber ich bin nicht sicher, dass dies zu einer tatsächlichen "Reihenfolge für Erstellung".

InformationsquelleAutor Vinodh Ramasubramanian

Kleinigkeit aufpassen, wenn man zu Fuß die "dependency tree". Abhängigkeiten für die unkompilierte Programme nicht zeigen...

SQL> drop package constants_pkg
  2  /

Package dropped.

SQL> create or replace package body pkg4 is
  2      procedure p7 is
  3      begin
  4          dbms_output.put_line('PKG4.P7::'||zzz_constants_pkg.whatever);
  5      end p7;
  6  end pkg4;
  7  /

Warning: Package Body created with compilation errors.

SQL> show errors
Errors for PACKAGE BODY PKG4:

LINE/COL ERROR
-------- -----------------------------------------------------------------
4/9      PL/SQL: Statement ignored
4/43     PLS-00201: identifier 'ZZZ_CONSTANTS_PKG.WHATEVER' must be
         declared

SQL>

So, dass der Körper zur PKG4 ist UNGÜLTIG, weil ZZZ_CONSTANTS_PKG existiert nicht.

SQL> create or replace package zzz_constants_pkg is
  2      whatever constant varchar2(20) := 'WHATEVER';
  3  end zzz_constants_pkg;
  4  /

Package created.

SQL>

Aber der Körper für PKG4 ist immer noch UNGÜLTIG, so dass die folgende Abfrage nicht wieder in seine Abhängigkeit ZZZ_CONSTANTS_PKG ....

SQL> select name, type, referenced_name, referenced_type
  2  from user_dependencies
  3  where referenced_owner = user
  4  /

NAME            TYPE            REFERENCED_NAME   REFERENCED_TYPE
--------------- --------------- ----------------- ---------------
PKG1            PACKAGE BODY    PKG1              PACKAGE
PKG1            PACKAGE BODY    PKG2              PACKAGE
PKG2            PACKAGE BODY    PKG2              PACKAGE
PKG2            PACKAGE BODY    PKG3              PACKAGE
PKG3            PACKAGE BODY    PKG3              PACKAGE
PKG3            PACKAGE BODY    PKG1              PACKAGE
PKG4            PACKAGE BODY    PKG4              PACKAGE

7 rows selected.

SQL>

Lassen Sie uns nun kompilieren PKG4 - und re-Abfrage der Abhängigkeiten ....

SQL> alter package pkg4 compile body;

Package body altered.

SQL> select name, type, referenced_name, referenced_type
  2  from user_dependencies
  3  where referenced_owner = user
  4  /

NAME            TYPE            REFERENCED_NAME   REFERENCED_TYPE
--------------- --------------- ----------------- ---------------
PKG1            PACKAGE BODY    PKG1              PACKAGE
PKG1            PACKAGE BODY    PKG2              PACKAGE
PKG2            PACKAGE BODY    PKG2              PACKAGE
PKG2            PACKAGE BODY    PKG3              PACKAGE
PKG3            PACKAGE BODY    PKG3              PACKAGE
PKG3            PACKAGE BODY    PKG1              PACKAGE
PKG4            PACKAGE BODY    PKG4              PACKAGE
PKG4            PACKAGE BODY    ZZZ_CONSTANTS_PKG PACKAGE

8 rows selected.

SQL>

InformationsquelleAutor APC

Brauchen Sie keine bauen, um - bauen, die Pakete mit "CREATE or REPLACE..." auf einer Datei-für-Datei-basis und kompilieren Sie in ein zwei-Ebenen-nested loop - jedem Durchlauf der inneren Schleife kompiliert alles, das ist immer noch ungültig, und die äußere Schleife wird verwendet, um die Anzahl der verbleibenden ungültigen Objekte und stellen eine Art Schwellenwert für die maximale Ausführungen der inneren Schleife. In der Praxis habe ich noch nie gesehen, die Anzahl der Durchläufe benötigt werden, höher als drei.

Wenn Sie mehrere schemas eingebunden in die Abhängigkeiten, Blick in die laufende Orakel utlrp.sql-Skript, das über schemas und legt einige Infrastruktur für die Verwaltung der Prozess - dieser braucht ein privilegiertes Konto jedoch.

Auch, wenn Sie erweitern Ihre source-control sind mit Blick auf, werden Sie sicher, dass die Skripte verwenden Sie "CREATE or REPLACE FORCE VIEW..." zum erstellen von Ansichten die haben unerfüllte Abhängigkeiten in der Zeit Ihrer Entstehung.

Beispiel-Skript, das ich benutze:

set serveroutput on
declare
 cursor invalidObjCur is 
  select object_name, object_type
    from user_objects
    where status <> 'VALID'
    ;
 compileStmt varchar2(4000); 
 passCount pls_integer := 0;
 maxPasses pls_integer := 5;
 lastInvalidCount pls_integer := 32000; 
 objectCount pls_integer;
 continue boolean := TRUE;

begin
 dbms_output.enable(1000000);
 while (continue) loop
   passCount := passCount + 1;
   dbms_output.put_line('Pass '||passCount);
   objectCount := 0;
   for curRow in InvalidObjCur loop
    if curRow.object_type = 'PACKAGE BODY' then
        compileStmt := 'alter PACKAGE '||curRow.object_name||' compile body';
    else
        compileStmt := 'alter '||curRow.object_type||' '||
        chr(34)||curRow.object_name||chr(34)||' compile';
    end if;
    begin
      execute immediate compileStmt;
    exception when others then
      null;
    end;
   objectCount := objectCount + 1;
   end loop;
   dbms_output.put_line('Recompilations attempted: '||objectCount);
   continue := (passCount < maxPasses) and (objectCount < lastInvalidCount);
   lastInvalidCount := objectCount;
 end loop;
dbms_output.put_line('***** Remaining Invalid ********');
for curRow in InvalidObjCur loop
 dbms_output.put_line(curRow.object_type||' '||curRow.object_name);
end loop; 
dbms_output.put_line('********************************');
end;    
/

InformationsquelleAutor dpbradley

0

Fügen Sie den folgenden Befehl aus, um die oben in Ihrem Skript:

SET VERIFY OFF

wird diese ermöglichen es, die Skripte ausführen, ohne Validierung und damit ausgeführt werden kann, in beliebiger Reihenfolge.

Können Sie später die Abfrage DBA_ERRORS, um alle Fehler und Warnungen in den Paketen, Ansichten und Typen.

InformationsquelleAutor PenFold
0

Versuchen, diese stattdessen für 11.1 und bis. Führen Sie das Skript in einer beliebigen Reihenfolge.
Am Ende geben Sie den folgenden Befehl ein:
(Ändern Sie die Parameter des Befehls, um Ihre Bedürfnisse anzupassen)
```
-- Compile invalid objects
EXEC DBMS_UTILITY.compile_schema(USER, FALSE);
```
Mehr details auf DBMS_UTILITY.compile_scema

InformationsquelleAutor Pranav Shah
-1

Eigentlichen Lösung: Das script oben zu geben scheint die richtige Reihenfolge für Erstellung". Könnte wohl umgeschrieben werden "schöner", aber das überlasse ich Ihnen als übung für den Leser. 😉

Nach einiger Diskussion, das build-tool ausführen soll n (4 tatsächlich) baut in einer Reihe, bevor die Berichterstattung Fehler. Dies würde auch helfen, Abhängigkeiten auflösen, kompilieren Fehler auf, wenn die build-Reihenfolge ist falsch, aber ich würde lieber nur das bauen, um das erste mal richtig um.

InformationsquelleAutor FrustratedWithFormsDesigner

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.