Beispiel für das Umschreiben durch den Compiler: Zusammenfügen von Operationen

Eine SELECT-Anweisung, die Sichten verwendet, kann die Joinfolge der Tabelle einschränken und zudem überflüssige Joins von Tabellen nach sich ziehen. Wenn die Sichten während des Umschreibens der Abfrage zusammengefügt werden, können diese Einschränkungen aufgehoben werden.

Nehmen Sie zum Beispiel an, Sie haben Zugriff auf die beiden folgenden Sichten, die auf der Tabelle EMPLOYEE basieren. Die eine zeigt die Mitarbeiter, die einen hohen Ausbildungsgrad (EDLEVEL) besitzen, während die andere die Mitarbeiter zeigt, deren Gehalt (SALARY) über 35.000 Dollar liegt:

   create view emp_education (empno, firstnme, lastname, edlevel) as
     select empno, firstnme, lastname, edlevel
       from employee
       where edlevel > 17

   create view emp_salaries (empno, firstname, lastname, salary) as
     select empno, firstnme, lastname, salary
       from employee
       where salary > 35000

Die folgende benutzerdefinierte Abfrage listet die Mitarbeiter auf, die einen hohen Ausbildungsgrad besitzen und über 35.000 Dollar pro Jahr verdienen:

   select e1.empno, e1.firstnme, e1.lastname, e1.edlevel, e2.salary
     from emp_education e1, emp_salaries  e2
     where e1.empno = e2.empno

Während der Phase des Umschreibens könnten diese beiden Sichten zusammengefügt werden, um folgende Abfrage zu erstellen:

   select e1.empno, e1.firstnme, e1.lastname, e1.edlevel, e2.salary
     from employee e1, employee e2
     where
       e1.empno = e2.empno and
       e1.edlevel > 17 and
       e2.salary  > 35000

Durch das Zusammenfügen der Anweisungen SELECT der beiden Sichten mit der vom Benutzer geschriebenen Anweisung SELECT kann das Optimierungsprogramm mehr Möglichkeiten bei der Auswahl des Zugriffsplans in Betracht ziehen. Darüber hinaus kann die Abfrage noch weiter umgeschrieben werden, wenn die beiden zusammengefügten Sichten dieselbe Basistabelle verwenden.

Beispiel - Umsetzungen von Unterabfragen in Joins

Angenommen, der SQL- und XQuery-Compiler erhält eine Abfrage mit einer Unterabfrage wie die folgende:

   select empno, firstnme, lastname, phoneno
     from employee
     where workdept in
       (select deptno
         from department
         where deptname = 'OPERATIONS')

Diese Unterabfrage wird vom SQL-Compiler in eine Joinabfrage der folgenden Form umgewandelt:

   select distinct empno, firstnme, lastname, phoneno
     from employee emp, department dept
     where
       emp.workdept = dept.deptno and
       dept.deptname = 'OPERATIONS'

Im Allgemeinen ist ein Join in der Ausführung wesentlich effektiver als eine Unterabfrage.

Beispiel - Eliminierung überflüssiger Joins

Abfragen können gelegentlich unnötige Joins enthalten.

   select e1.empno, e1.firstnme, e1.lastname, e1.edlevel, e2.salary
     from employee e1,
          employee e2
    where e1.empno = e2.empno
      and e1.edlevel > 17
      and e2.salary  > 35000

Der SQL- und XQuery-Compiler kann den Join eliminieren und die Abfrage wie folgt vereinfachen:

   select empno, firstnme, lastname, edlevel, salary
     from employee
     where
       edlevel > 17 and
       salary  > 35000

Im folgenden Beispiel wird davon ausgegangen, dass zwischen den Tabellen EMPLOYEE und DEPARTMENT eine referenzielle Integritätsbedingung über die Abteilung (WORKDEPT/DEPNO) vorhanden ist. Zuerst wird eine Sicht erstellt.

   create view peplview as
     select firstnme, lastname, salary, deptno, deptname, mgrno
       from employee e department d
       where e.workdept = d.deptno

Eine Abfrage wie die folgende:

   select lastname, salary
     from peplview

wird wie folgt umgeschrieben:

   select lastname, salary
     from employee
     where workdept not null

Beachten Sie in diesem Fall, dass Sie die Abfrage eventuell nicht umschreiben können, selbst wenn Sie wissen, dass dies möglich ist, weil Sie keinen Zugriff auf die zugrunde liegenden Tabellen haben. Sie haben möglicherweise nur Zugriff auf die (oben gezeigte) Sicht. Daher muss dieser Typ von Optimierung vom Datenbankmanager ausgeführt werden.

Redundanz in Joins mit referenzieller Integrität tritt wahrscheinlich unter folgenden Bedingungen auf:

Sichten sind mit Joins definiert.
Abfragen werden automatisch generiert.

Beispiel - Gemeinsame Spaltenberechnungen

Bei Verwendung mehrerer Funktionen in einer Abfrage können zahlreiche Berechnungen entstehen, die zeitaufwendig sind. Durch Verringern der Anzahl von erforderlichen Berechnungen lässt sich der Plan verbessern. Der Compiler nimmt eine Abfrage entgegen, die mehrere Funktionen wie die folgenden enthält:

   select sum(salary+bonus+comm) as osum,
       avg(salary+bonus+comm) as oavg,
       count(*) as ocount
     from employee

Diese Abfrage wird wie folgt umgeformt:

   select osum, osum/ocount ocount
     from (
       select sum(salary+bonus+comm) as osum,
           count(*) as ocount
         from employee
     ) as shared_agg

Durch dieses Umschreiben wird die Anzahl der erforderlichen Summierungen und Zählungen halbiert.