Oracle Performance Riddle

Kann ein Select eine Tabelle sperren?

Vor kurzem untersuchte ich ein “enq: TM contention” wait event. Ich fand über eine Abfrage auf die active session history (ASH) die blocking session heraus.

Als ich die blocking session über eine ASH query untersuchte, war zur selben Zeit wie der TM lock in der blockierten session auftrat,  gerade ein lang laufendes Select aktiv.

Das ist doch merkwürdig, nicht wahr? Kann eine Select einen Lock erzeugen? Wo ist hier der Denkfehler? Und würde es helfen, das Select Statement zu beschleunigen?

Wer sich nicht sicher ist, kann sich bei Arup Nanda über den TM Lock informieren.

enq: TX row lock contention and enq:TM contention

Index Rebuild: Magic or Voodoo?

Den heutigen Blog schreibe ich nicht gerne. Aber ich fühle mich der Wahrheit verpflichtet und das Thema ist zu interessant um es zu verschweigen.

Als in den Freelists gefragt wurde, ob der Index rebuild auch manchmal nützlich sein kann, habe ich das verneint, unter Hinweis auf entsprechende Einträge bei Mr. Index, Richard Foote.

Ich wusste schon, dass ich mich auf dünnen Eis bewege, aber ich  konnte der Chance oberschlau zu sein und einer gängigen Meinung zu widersprechen, einfach nicht widerstehen. Natürlich trat das unvermeidliche ein und Jonathan Lewis korrigierte mich mit den Hinweis, dass ein Index rebuild in manchgen Grenzfällen eben doch nützlich sein kann. Wie hatte ich bloss glauben können, unbemerkt von Jonathan’s Radar durch zu schlüpfen.

Kurz darauf, als wolle das Schicksal mich auch noch mahnen, fiehl mir bei einem Kunden eine Abfrage auf, die offensichtlich ineffizient war. Ich habe die Abfrage auf das SH  schema umgeschrieben und einen kleinen Testcase erzeugt. Wie ich diesen Testcase gemacht habe, werden Sie in der Lösung sehen. Genau das sollen Sie ja erraten.

select time_id from sales where sparse is not null;

Der Exection Plan mit Runtime Statitiken sieht aus wie folgt:


-------------------------------------------------------------------------------------------------------------------
| Id  | Operation                                  | Name       | Starts | E-Rows | A-Rows |   A-Time   | Buffers |
-------------------------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                           |            |      1 |        |      0 |00:00:00.04 |   41770 |
|   1 |  TABLE ACCESS BY GLOBAL INDEX ROWID BATCHED| SALES      |      1 |      1 |      0 |00:00:00.04 |   41770 |
|*  2 |   INDEX FULL SCAN                          | SPARSE_IDX |      1 |      1 |      0 |00:00:00.04 |   41770 |
-------------------------------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   2 - filter("SPARSE" IS NOT NULL)

Aus welchem Grund wählt der Optimizer einen Full Index Scan? Eine kurze Überprüfung zeigt, dass Full Table scan sehr viel effizienter ist.Zudem ist die Schärtzung (E-Rows) auch noch richtig. Die Statitiken sind also aktuell.

Was ist hier geschehen? Hinweis: Ich habe nach dem DML auf der Tabelle gesucht und ich fand ein update Statement.

Eine unerwartete Bedingung in der where Klausel

Es macht mich stolz zu erfahren, dass Carlos Sierra meinen Blog verfolgt. Carlos ist mir aus meiner Zeit bei Oracle schon lange bekannt, auch wenn wir uns erst kürzlich das erste Mal getroffen haben. Ich schätze Carlos als einen Mann der Tat. Wenn er einen Missstand sieht, beklagt er sich nicht, sondern tut etwas dagegen.
Mit meinem nächsten Beispiel will ich zeigen, dass er auch ein scharfsinniger Analytiker ist.
Vor Kurzem sah ich in einem Plan eine Bedingung, die so nicht im Sql statement stand. Ich wollte wissen, wie die Bedingung in den Plan gekommen war.
Ich gebe dazu ein einfaches Beispiel: Gegeben sei eine Tabelle x die wie folgt aussieht


SQL> desc x
Name Null? Typ
----------------------------------------- -------- -----------------
Y NUMBER
Z NOT NULL NUMBER

Ich lasse die folgende Abfrage laufen:


select count(*) from x where z=1;

Der Exection Plan sieht aus wie folgt:


Plan hash value: 989401810

---------------------------------------------------------------------------
| Id  | Operation          | Name | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------
|   0 | SELECT STATEMENT   |      |       |       |   420 (100)|          |
|   1 |  SORT AGGREGATE    |      |     1 |    13 |            |          |
|*  2 |   TABLE ACCESS FULL| X    |  1144K|    14M|   420   (2)| 00:00:01 |
---------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   2 - filter(NVL("Z",1)=1)

Wieso weisst der Plan diese merkwürdige Bedingung auf? Die Antwort finded Ihr in Carlos Sierra’s Blog. Noch ein Hinweis: Es hat etwas mit Default Werten zu tun.

 

Lösung: Die parallele Aktivität bricht ein

Wie Sie sich erinnern werden, hatten wir einen Hash Outer Join mit dominanten Nullwerten. In Folge bekam der parallelen Prozess, der die Nullwerten behandelte, bei weitem die meiste Arbeit zu tun.
Wie sollen wir dies lösen? lassen Sie uns einige grundsätzliche Überlegungen anstellen.
Ein Null Wert ist ein Sonderfall . Wir vergleichen einen Null Wert im Foreign Key mit einem Primärschlüssel , der not null definiert ist. Wir können sicherlich keinen Join Treffer für die Null Werte zu finden. Daher kann jeder der parallelen Sklaven den Vergleich durchführen, solange gewährleistet ist, dass dadurch nie ein Treffer erzeugt wird.
Es lohnt sich also die Null Werte in beliebige andere Werte um zu wandeln, solange nur zwei Voraussetzungen erfüllt sind:

  1. wir müssen die Nullwerte in einer solchen Art und Weise umwandeln, dass die gleichmäßig über alle parallel Slaves verteilt werden
  2. wir müssen sicherstellen, dass im Vergleich zu vorher kein zusätzlicher Satz ins Resultat kommt

Die Lösung zu finden hat mich viel Zeit gekostet. Zuerst habe ich versucht mit negativen Werten zum Ziel zu kommen. Aber auch sie wurden auch an nur einen Parallel Prozess gesandt, genau wie die Null Werte.
Das Problem ist, dass unsere neu generierten Schlüssel etwa im gleichen Bereich wie der Primary Key der Build-Tabelle sein müssen, um über alle Slaves verteilt zu werden.
Ich hätte versuchen können über eine with Klausel den Bereich heraus zu finden, aber das hielt ich für uncool und konnte mich nicht dazu überwinden.
Stattdessen habe ich etwas anderes versucht, was ehrlich gesagt ein bisschen wie ein Hack wirkt, aber viel besser aussieht. Ich benutzte den Primary Key der äußeren Tabelle einen nicht null wertigen breit streuenden Schlüssel zu generieren.
Ich habe auch die Tatsache zunutze, dass die IDs integer waren und veränderte die Join-Bedingung zu:

FROM T_TAB1 T1
LEFT OUTER JOIN T_TAB2 T2
ON ( NVL(T2.X_ID, T2_id +0.5)    = T1.X_ID)

Das ist sicherlich ein bischen getrickst. Das einzig Positive daran ist, dass es funktioniert.
Die Aktivity Tab im Sql Monitor sah nachher so aus:

Vergleichen Sie dies mit dem vorherigen Bild. Es ist ziemlich beeindruckend.
Nun, in der Version 12 die Datenbank sollte in der Lage sein, mit schräg verteilten join Schlüsseln um zu gehen.
Aber es funktioniert nicht in jedem Fall, wie Randolf Geist feststellte.
Wenn jemand meine Lösung nicht gut findet, sollte er vielleicht er einen Blick auf_fix_control 6808773 werfen, aber ich gebe für keinen Fall Garantien ab. 😉

 

Die parallele Aktivität bricht ein

In einem meiner DWH POCs für Oracle’s Real World Performance Group bemerkten wir einen plötzlichen Einbruch in der Datenbank Aktivität. Unser Kunde verlangte eine Erklärung dafür.
Im SQL Monitor Activity Reiter sah das so aus:

Nach einer sorgfältigen Untersuchung erkannte ich, dass ein outer join die Ursache war. Formal sah dieser join so aus:

FROM T_TAB1 T1
LEFT OUTER JOIN T_TAB2 T2
ON T2.X_ID    = T1.X_ID

Das Problem war, dass 90% aller Werte in T1.X_ID Null Werte waren. Für die Aufteilung der Arbeit auf die Parallel Prozesse wurde der Hash Schlüssel benutzt. Als Folge bekam ein Parallelpozess 90% der ganzen Arbeit zugeteilt. Eine andere Aufteilung der Arbeit, etwa über einen broadcast war nicht möglich, da T1 zu gross war.
(Randolg Geist schildert das Problem ausführlich: Parallel Execution Skew – Demonstrating Skew).

Können Sie die join Bedingung so umschreiben, dass die Arbeit gleichmässig auf alle paralleln Prozesse verteilt wird? (Die Version war 11G. In version 12 sollte sich der optimizer automatisch um die Fragestellung kümmern.) Noch eine Annahme: die tabelle T2 hat einen Primary Key in Form der Spalte T2_id.

 

Die Collection in der Collection

wir mussten einen sehr häufig genutzte PL/SQL Function umschreiben. Der Code litt stark unter dem Context Switch. Er wurde millionenfach aufgerufen. Wir setzen uns das Ziel, mit einem einzigen Bulk Collect alle Daten aus der Datenbank aus zu lesen. Ich gebe hier ein codeskellet, dass ich auf das scott/tiger schema angepasst habe.

DECLARE
   CURSOR c1
   IS
   SELECT deptno, dname
     FROM dept;
   CURSOR c2 (p_deptno NUMBER)
       IS
       SELECT empno,ename,sal, comm
         FROM emp
        WHERE deptno= p_deptno;
BEGIN
   FOR c1rec IN C1
   LOOP
      FOR c2rec IN c2(c1rec.deptno)
      LOOP
         NULL;
      END LOOP;
   END LOOP;
END;
/

In der Realität steht natürlich komplexe Logic statt null in der Scheife. Ich arbeitete gemeinsam mit einem Entwickler des Softwareherstellers an dem Problem. Wir hatten nicht genug Zeit um den Code zu verstehen. Wie beschlossen, den Code nur ganz formal um zu wandeln und die Schleifen zu belassen. Wir wollten nul also alle Daten in einem einzigen Schritt in ein geschachteltes Array lesen.
Also, alle Departments enthalten alle Employees. Wie in unserem Beispiel war auch in der Realität die Resultatsmenge pro Abfrage so klein, dass Alles locker in ein Array passte.

Wie sieht der zugehörige Select aus?

 

Ist die Migrationsdatenbank langsamer?

Für eine Mirgation wurde eine Datenbank in einer virtuellen Umgebung bereitgestellt.  Erste Tests zeigen, dass die Migrationsdatenbank ein Vielfaches langsamer ist als die Produktionsdatenbank. Die Tests konzentrieren sich auf eine bestimmte Abfrage.

Hier ein Ausschnitt aus einem AWR der Migrationsdatenbank. Zu sehen sind die relevanten Daten des Sql Befehls, den man untersuchen soll als Ausschnitt aus der Liste „SQL ordered by elapsed time“.

 

apsed Time (s)

Executions

Elapsed Time per Exec (s)

%Total

%CPU

%IO

199.24

1

199.24

98.16

3.93

96.72

Zum Vergleich die selben Daten aus der produktiven Datenbank:

Elapsed Time (s)

Executions

Elapsed Time per Exec (s)

%Total

%CPU

%IO

11.02

1

11.02

65.95

99.98

0.0

Was fällt Ihnen auf? Mit welcher Arbeitshypothese würden Sie die Untersuchung beginnen und was würden Sie prüfen? Hinweis: Der Befehl ist ein count welcher nur eine Tabelle liest. Der Execution plan ist in beiden Fällen identisch, es ist jeweils ein Full Table Scan.

Warum ist die neue Hardware langsamer?

Man kauft neue Hardware um schneller zu werden. Das ist eine ganz normale Erwartung. Was aber wenn die neue Hardware langsamer ist als die alte? Die Spekulationen über die Ursache gingen wild hin und her. Da ich auf diesen Einsatz urlaubsbedingt lange warten musste, war die Spannung gross als die Untersuchung endlich beginnen konnte.

Eine schneller Überprüfung zeigte, dass die neue Hardware nicht langsamer war als die alte. Den entscheidenden Hinweis lieferte ein raw trace. Ich zeige hier nur ein entscheidenden Ausschnitt.

Auf der alten Hardware sah der trace so aus:


FETCH #25:c=1154407,e=1152124,p=0,cr=102603,cu=0,mis=0,r=101,dep=0,og=1,tim=650755949521

Cursor #25 ist ein grosses Select, das langsam läuft. Auf der neuen Hardware hingegen sah der trace wie folgt aus:


FETCH #601010888:c=31200,e=22483,p=0,cr=3706,cu=50,mis=0,r=1,dep=0,og=1,plh=3621104505,tim=39783214696
WAIT #601010888: nam='SQL*Net message from client' ela= 171 driver id=1413697536 #bytes=1 p3=0 obj#=-1 tim=39783217398
LOBGETLEN: c=0,e=3,p=0,cr=0,cu=0,tim=39783217416
WAIT #0: nam='SQL*Net message to client' ela= 0 driver id=1413697536 #bytes=1 p3=0 obj#=-1 tim=39783217423
WAIT #0: nam='SQL*Net message from client' ela= 117 driver id=1413697536 #bytes=1 p3=0 obj#=-1 tim=39783217546
WAIT #0: nam='SQL*Net message to client' ela= 0 driver id=1413697536 #bytes=1 p3=0 obj#=-1 tim=39783217560
LOBREAD: c=0,e=12,p=0,cr=1,cu=0,tim=39783217567

Cursor #601010888: entspricht Cursor #25 auf der alten Hardware. Die Datenbank auf der neuen Hardware ist Version 11, die Datenbank auf der alten Hardware ist Version 10.
Offensichtlich besteht ausser bei der Version mindestens ein weiterer Unterschied zwischen beiden Datenbanken. Was ist es? Wie wirkt sich dieser Unterschied aus?
Beide Datenbanken werden über das exakt selbe Programm angesprochen, welche mit MS Visual Studio realisiert ist.

 

Warum ist kein Alias nötig?

Hier ist eine Frage von OTN. Ich bin gespannt, was Sie zu sagen haben. (Bitte nicht die Antwort auf OTN nachsehen.)


select order_id, sum(quantity*unit_price)
from order_items
having sum(quantity*unit_price) > ALL
(select sum(quantity*unit_price)
from customers
join orders using (customer_id)
join order_items using (order_id )
where STATE_PROVINCE = 'FL'
group by order_id)
group by order_id;

Die Frage lautet: Warum brauchen wir kleinen Alias für order_id in der „Group order_id“ Klausel der Unterabfrage, obwohl die Spalte in beiden Tabellen angezeigt wird?
So, um es ein bisschen schwieriger zu machen, habe ich eine kleine zusätzliche Hürde errichtet. STATE_PROVINCE ist in der OE-Schema für Version 12 (für andere Versionen habe ich nicht getestet) Bestandteil einer Typvariable. Die Abfrage läuft nicht wie hier gezeigt. Wie sollen wir die Abfrage so ändern, dass es funktionieren wird?

 

Woher kommen die Downgrades?

In einem DWH kam es verstärkt zu downgrades der Parallelität. Es schien mit jedem Tag schlimmer zu werden. Tatsächlich zeigte sich, dass die frei verfügbaren parallel prozesse konstant abnahmen. Eine nähere Untersuchung der verwendeten PX zeigte bei vielen Toad als Quelle.
Wie war es möglich, dass die Anzahl dieser Toad verursachten parallelen sessions ständig wuchs?
Andererseits es waren immer noch ausreichend PX zur Verfügung, dennoch kam es zu downgrade. Welchen Parameter sollte man sich hier näher ansehen?