Download (3398Kb)

OPTIMIERUNG DER MATERIALISIERTEN 

SICHTEN IN EINEM DATAWAREHOUSE AUF DER 

GRUNDLAGE DER AUS EINEM ERP-SYSTEM 

ÜBERNOMMENEN OPERATIVEN DATEN

OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER 

GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN 

INHALTSVERZEICHNIS: 

1 EINFÜHRUNG ........................................................................16 

1.1 ZIEL DER ARBEIT ............................................................................. 16 

1.2 VORGEHENSWEISE ........................................................................... 16 

2 DATENMODELLIERUNG........................................................17 

2.1 SEMANTISCHES DATENMODELL ........................................................ 17 

2.1.1 ENTITÄTEN (ENTITIES) .......................................................................... 18 

2.1.2 ENTITÄTSMENGEN (ENTITY SETS) ........................................................ 18 

2.1.3 ATTRIBUTE UND SCHLÜSSEL.................................................................. 19 

2.1.4 BEZIEHUNGEN (RELATIONSHIPS) .......................................................... 20 

2.1.5 KARDINALITÄTEN VON BEZIEHUNGEN.................................................. 21 

2.1.5.1 1-1 BEZIEHUNGEN........................................................................... 21 

2.1.5.2 1-N BEZIEHUNGEN .......................................................................... 22 

2.1.5.3 M-N BEZIEHUNGEN......................................................................... 22 

2.1.5.4 DIE REKURSIVE BEZIEHUNG ........................................................ 22 

2.2 LOGISCHES DATENMODELL.............................................................. 23 

2.2.1 ALLGEMEINES ........................................................................................ 23 

2.2.2 DATENMODELLE..................................................................................... 24 

2.2.2.1 HIERARCHISCHES DATENMODELL.............................................. 24 

2.2.2.2 NETZWERKDATENMODELL ........................................................... 25 

2.2.2.3 RELATIONALES DATENMODELL................................................... 25 

2.2.2.4 OBJEKTORIENTIERTES DATENMODELL ..................................... 26 

2.2.2.5 OBJEKTRELATIONALES DATENMODELL..................................... 27 

2.2.3 ÜBERFÜHRUNG DES ER-MODELLS INS RELATIONALE MODELL.......... 27 

2.2.3.1 DIE UMSETZUNG DER 1:1 BEZIEHUNG....................................... 29 

2.2.3.2 DIE UMSETZUNG DER 1:N BEZIEHUNG ...................................... 30 

2.2.3.3 DIE UMSETZUNG DER M:N BEZIEHUNG..................................... 30 

- 2 -



2.2.3.4 DIE UMSETZUNG EINER REKURSIVEN BEZIEHUNG................. 31 

2.3 PHYSISCHES DATENMODELL............................................................. 31 

3 SQL UND DATENBANKEN ....................................................32 

3.1 DATENBANKEN ................................................................................ 32 

3.1.1 ENTWICKLUNGSGESCHICHTE DER DATENBANKSYSTEME.................... 32 

3.1.2 BEGRIFFSDEFINITIONEN ........................................................................ 32 

3.1.3 ANFORDERUNGEN EINES DATENBANKSYSTEMS.................................... 33 

3.2 SQL ALS STANDARDISIERTE DATENBANKSPRACHE............................. 34 

3.2.1 GESCHICHTLICHES................................................................................. 34 

3.2.2 DAS RELATIONALE MODELL ................................................................. 36 

3.2.2.1 RELATIONALE DATENSTRUKTUR ................................................. 36 

3.2.2.1.1 DOMÄNEN:.................................................................................... 36 

3.2.2.1.2 RELATIONEN: ............................................................................... 36 

3.2.2.1.3 EIGENSCHAFTEN VON RELATIONEN............................................ 37 

3.2.2.2 RELATIONALE INTEGRITÄT ........................................................... 38 

3.2.2.2.1 SCHLÜSSELKANDIDAT (CANDIDATE KEY).................................... 38 

3.2.2.2.2 PRIMÄRSCHLÜSSEL (PRIMARY KEY)............................................ 38 

3.2.2.2.3 FREMDSCHLÜSSEL (FOREIGN KEY).............................................. 38 

3.2.2.2.4 ENTITÄTSINTEGRITÄT.................................................................. 38 

3.2.2.2.5 REFERENZIELLE INTEGRITÄT (REFERENTIAL INTEGRITY) ........ 38 

3.2.2.3 RELATIONALE DATENMANIPULATION ........................................ 39 

3.2.2.4 NORMALFORMEN ............................................................................ 40 

3.2.2.4.1 ERSTE NORMALFORM (1NF) ....................................................... 40 

3.2.2.4.2 ZWEITE NORMALFORM (2NF)..................................................... 40 

3.2.2.4.3 DRITTE NORMALFORM (3NF) ..................................................... 40 

3.2.2.4.4 BOYCE-CODD-NORMALFORM (BCNF)....................................... 41 

3.2.2.4.5 VOR- UND NACHTEILE DER NORMALISIERUNG .......................... 41 

3.2.2.5 SICHTEN (VIEWS)............................................................................. 41 

- 3 -



3.2.2.5.1 TERMINOLOGIE ............................................................................ 41 

3.2.2.5.2 ZWECK VON SICHTEN .................................................................. 42 

3.2.2.5.3 AKTUALISIERUNG VON SICHTEN ................................................. 42 

3.2.3 SQL NACH DEM STANDARD SQL 99 ..................................................... 42 

3.2.3.1 SQL ALS DDL..................................................................................... 43 

3.2.3.1.1 ERZEUGEN VON DBMS-OBJEKTEN (CREATE)......................... 43 

3.2.3.1.2 ÄNDERN VON DBMS-OBJEKTEN (ALTER)................................ 43 

3.2.3.1.3 VERGABE VON RECHTEN (GRANT) ........................................... 44 

3.2.3.1.4 ENTZIEHEN VON RECHTEN (REVOKE) ..................................... 44 

3.2.3.2 SQL ALS DML .................................................................................... 44 

3.2.3.2.1 DIE SELECT ABFRAGE............................................................... 44 

3.2.3.2.2 DIE INSERT ANWEISUNG ........................................................... 45 

3.2.3.2.3 DIE UPDATE ANWEISUNG ......................................................... 45 

3.2.3.2.4 DIE DELETE ANWEISUNG.......................................................... 45 

3.2.3.3 SQL ALS DCL..................................................................................... 45 

4 ERP-SYSTEME......................................................................46 

5 DAS DATA WAREHOUSE ......................................................47 

5.1 DAS KONZEPT DES DATA WAREHOUSE ............................................. 47 

5.2 ARCHITEKTUR EINES DATAWAREHOUSE ............................................ 48 

5.2.1 OPERATIVE DATEN ................................................................................ 49 

5.2.2 EXTERNE DATENBANKEN....................................................................... 50 

5.2.3 DIE METADATEN .................................................................................... 50 

5.2.4 DIE DATENPUMPEN ................................................................................ 50 

5.2.5 DER DATAWAREHOUSE MANAGER........................................................ 50 

5.2.6 ZUGRIFFSWERKZEUGE FÜR DEN ENDBENUTZER................................... 50 

5.2.6.1 WERKZEUGE FÜR BERICHTE UND ABFRAGEN ......................... 51 

5.2.6.2 WERKZEUGE ZUR ENTWICKLUNG VON ANWENDUNGEN ....... 51 

5.2.6.3 EXECUTIVE INFORMATION SYSTEM WERKZEUGE (EIS).......... 51 

- 4 -



5.2.6.4 DECISION SUPPORT SYSTEME (DSS)............................................ 52 

5.2.6.5 ONLINE ANALYTICAL PROCESSING WERKZEUGE (OLAP) ....... 52 

5.2.6.6 DATA MINING WERKZEUGE .......................................................... 52 

5.3 OPERATIVE UND ANALYTISCHE DATEN .............................................. 53 

5.4 AUFBAUEN UND AKTUALISIEREN EINES DATAWAREHOUSE AUS DEN 

DATENQUELLEN......................................................................................... 55 

5.4.1 KLASSISCHE VORGEHENSWEISE BEIM AUFBAUEN UND AKTUALISIEREN 

EINES DATAWAREHOUSE........................................................................................ 55 

5.4.2 NEUE ANSÄTZE FÜR DAS AUFBAUEN UND AKTUALISIEREN DER 

MATERIALISIERTEN SICHTEN ................................................................................ 55 

5.4.2.1 DER WHIPS PROTOTYP................................................................... 56 

5.4.2.2 DER SUMMARY TABLE ANSATZ ..................................................... 58 

5.4.2.3 DER MULTIPLE VIEW MAINTENANCE POLICIES ANSATZ ........ 59 

5.5 INFORMATIONSFLÜSSE IN EINEM DATA WAREHOUSE ......................... 60 

5.5.1 INFLOW................................................................................................... 60 

5.5.2 UPFLOW.................................................................................................. 61 

5.5.3 DOWNFLOW............................................................................................ 61 

5.5.4 OUTFLOW ............................................................................................... 61 

5.5.5 METAFLOW ............................................................................................ 61 

5.6 PROBLEME IM DATA WAREHOUSE .................................................... 62 

5.7 VORTEILE EINES DATAWAREHOUSE................................................... 63 

5.8 ANFORDERUNGEN AN EIN DATENBANKSYSTEM FÜR EIN 

DATAWAREHOUSE ...................................................................................... 64 

5.9 DATA MARTS .................................................................................... 66 

5.10 DIE MODELLIERUNG EINES DATAWAREHOUSE............................... 67 

5.10.1 MODELLTHEORIE................................................................................... 67 

5.10.2 ATTRIBUTE ............................................................................................. 68 

5.10.3 DIMENSIONEN UND HIERARCHIEN......................................................... 68 

5.10.4 DIE DATENWÜRFEL................................................................................ 69 

- 5 -



5.10.5 OPERATOREN ......................................................................................... 70 

5.10.6 SLICE AND DICE ..................................................................................... 71 

5.10.7 NAVIGATION DURCH DEN DATENBESTAND............................................ 72 

5.10.8 KONZEPTIONELLE ODER SEMANTISCHE MODELLIERUNG ................... 73 

5.10.8.1 GRAPHISCHE MODELLIERUNG ................................................ 73 

5.10.8.2 HALBGRAPHISCHE MODELLIERUNG ...................................... 75 

5.10.8.2.1 GITTER ....................................................................................... 75 

5.10.8.2.2 AGGREGATION PATH ARRAY .................................................... 76 

5.10.9 LOGISCHE UND PHYSIKALISCHE MODELLIERUNG ............................... 76 

5.10.9.1 STAR-SCHEMA .............................................................................. 76 

5.10.9.2 FACT CONSTELLATION-SCHEMA.............................................. 78 

5.10.9.3 SNOWFLAKE-SCHEMA ................................................................ 79 

5.10.9.4 GALAXY-SCHEMA......................................................................... 80 

5.10.9.5 DAS UNIMU-SCHEMA.................................................................. 81 

6 DIE MODELLIERUNGSMETHODE AGGREGATION PATH 

ARRAY.........................................................................................83 

7 FORSCHUNGSSCHWERPUNKT UND ERGEBNISSE ................90 

7.1 DAS GRUNDPROBLEM UND DER LÖSUNGSANSATZ ............................. 90 

7.2 DIE VORGEHENSWEISE..................................................................... 91 

7.3 ABGRENZUNG DER PHASEN DER BETRACHTUNG................................ 92 

7.4 VERWANDTE ALGORITHMEN IM PROBLEMZUSAMMENHANG ............... 94 

7.4.1 KÜRZESTE UND LÄNGSTE WEGE ............................................................ 94 

7.4.1.1 BEGRIFFSBESTIMMUNGEN ........................................................... 94 

7.4.1.1.1 GRAPHEN...................................................................................... 94 

7.4.1.1.2 EINGANGS- UND AUSGANGSGRAD ............................................... 95 

7.4.1.1.3 WEG, ZYKLUS .............................................................................. 95 

7.4.1.1.4 KNOTEN- UND KANTENWERTE .................................................... 95 

7.4.1.1.5 KLASSIFIZIERUNG VON GRAPHEN................................................ 96 

- 6 -



7.4.1.2 KÜRZESTE WEGE VON EINEM KONTEN IM GRAPHEN ZU 

ALLEN ANDEREN ............................................................................................. 96 

7.4.1.2.1 ALGORITHMUS VON DIJKSTRA .................................................... 97 

7.4.1.2.2 ALGORITHMUS VON BELLMANN-FORD ..................................... 103 

7.4.1.2.3 KÜRZESTE WEGE FÜR EINEN AZYKLISCHEN GRAPHEN ........... 104 

7.4.1.3 KÜRZESTE WEGE ZWISCHEN ALLEN KONTEN IM GRAPHEN 106 

7.5 KOSTENBASIERENDE ABFRAGEBEARBEITUNG IN RELATIONALEN 

SYSTEMEN................................................................................................108 

7.6 DIE HEURISTIKEN..........................................................................116 

7.6.1 EINTEILUNG DER KOSTEN.................................................................... 116 

7.6.2 KOSTENSCHÄTZFUNKTION DER ABFRAGEPHASE................................ 117 

7.6.2.1 BEGRIFFSDEFINITIONEN............................................................. 117 

7.6.2.2 WERTEBEREICHE UND BEDINGUNGEN.................................... 118 

7.6.2.3 FUNKTION....................................................................................... 118 

7.6.2.4 BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION.................. 118 

7.6.3 KOSTENSCHÄTZFUNKTIONEN DER MATERIALISIERUNGSPHASE........ 118 



7.6.3.3 FUNKTION....................................................................................... 119 

7.6.3.4 BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION.................. 120 

7.6.4 GESAMTKOSTEN................................................................................... 120 



7.6.4.3 FUNKTION....................................................................................... 121 

7.6.5 ZUFÄLLIGE KOSTEN............................................................................. 121 

7.6.6 HEURISTIK VON ALEXANDER PROSSER ........................................... 123 

7.6.7 HEURISTIK VON THOMAS ACHS......................................................... 127 

7.6.7.1 PSEUDOCODE DER HEURISTIK.................................................. 127 

7.6.7.2 BESCHREIBUNG DER HEURISTIK............................................... 134 

- 7 -



7.6.7.3 DEMONSTRATIVES BEISPIEL....................................................... 134 

7.7 DIE DETERMINISTISCHE LÖSUNG....................................................147 

7.7.1 MATHEMATISCHE GRUNDLAGEN ........................................................ 147 

7.7.1.1 PERMUTATION ............................................................................... 147 

7.7.1.2 KOMBINATION................................................................................ 147 

7.7.2 DER ALGORITHMUS FÜR DIE PERMUTATION ...................................... 148 

7.7.3 DER ALGORITHMUS FÜR DIE KOMBINATION ...................................... 152 

7.7.4 DER ALGORITHMUS DER FUNKTION GETRIGHTORDER .................... 156 

7.7.5 DER ALGORITHMUS DER FUNKTION KOSTENFUERSETBERECHNEN. 161 

7.8 DIE ENTWICKLUNGSUMGEBUNG UND DIE APPLIKATION..................164 

7.8.1 AUSWAHL DER ENTWICKLUNGSUMGEBUNG ....................................... 164 

7.8.2 ENTWURF DER BENUTZERSCHNITTSTELLE......................................... 165 

7.8.2.1 DAS HAUPTMENU.......................................................................... 165 

7.8.2.2 DIE EINGABEMASKE (INPUT SCREEN) ...................................... 166 

7.8.2.3 DIE PRÄSENTATIONSMASKE (APA SCREEN) ............................. 167 

7.8.2.4 DIE AUSWAHLMASKE DER REQUIRED CUBES (SELECTION 

SCREEN) 168 

7.8.3 DATENMODELLIERUNG DER APPLIKATION......................................... 169 

7.8.3.1 AUSWAHL DER DATENBANK........................................................ 169 

7.8.3.2 SEMANTISCHE DATENMODELLIERUNG.................................... 170 

7.8.3.3 LOGISCHE DATENMODELLIERUNG........................................... 173 

7.8.3.4 PHYSISCHE DATENMODELLIERUNG ......................................... 176 

7.8.3.4.1 FORMALE SQL-ANWEISUNGEN LAUT SQL 99 ......................... 176 

7.8.3.4.2 MICROSOFT SQL SPEZIFISCHE SQL ANWEISUNGEN............... 178 

7.8.3.5 GENERIEREN DER CREATE TABLE ANWEISUNGEN IN DER 

SOFTWARE ...................................................................................................... 184 

7.8.3.5.1 DAS STAR-SCHEMA .................................................................... 184 

7.8.3.5.2 DAS FACT CONSTELLATION SCHEMA ....................................... 186 

7.8.3.5.3 BEISPIELHAFTES UMSETZEN DER TABLES DURCH DAS 

PROGRAMM .................................................................................................. 187 

- 8 -



7.8.3.5.3.1 DIE AUSGANGSPOSITION ........................................................ 187 

7.8.3.5.3.2 DIE SCRIPTS FÜR DAS STAR SCHEMA....................................... 189 

7.8.3.5.3.3 DIE SCRIPTS FÜR DAS FACT CONSTELLATION SCHEMA ............ 193 

7.9 ERGEBNISSE DER TESTS DER HEURISTIKEN .....................................200 

7.9.1 PROBLEME BEI TESTEN DER HEURISTIK............................................. 200 

7.9.2 GESAMTÜBERSICHT ÜBER DIE ERGEBNISSE........................................ 202 

7.9.3 DIE ERGEBNISSE IM DETAIL ................................................................ 204 

7.9.3.1 VORGABEN UND ERGEBNISSE TEST 1 ....................................... 204 

7.9.3.1.1 VORGABEN.................................................................................. 204 

7.9.3.1.2 LÖSUNG DER HEURISTIK............................................................ 204 

7.9.3.1.3 DETERMINISTISCHE LÖSUNG..................................................... 205 

7.9.3.1.4 VERGLEICH DER ERGEBNISSE ................................................... 205 


7.9.3.2.1 VORGABEN.................................................................................. 205 





7.9.3.3.1 VORGABEN.................................................................................. 207 





7.9.3.4.1 VORGABEN.................................................................................. 209 





7.9.3.5.1 VORGABEN.................................................................................. 211 

- 9 -







7.9.3.6.1 VORGABEN.................................................................................. 213 





7.9.3.7.1 VORGABEN.................................................................................. 215 





7.9.3.8.1 VORGABEN.................................................................................. 217 





7.9.3.9.1 VORGABEN.................................................................................. 219 




7.9.3.10 VORGABEN UND ERGEBNISSE TEST 10 ................................. 221 

7.9.3.10.1 VORGABEN................................................................................ 221 

7.9.3.10.2 LÖSUNG DER HEURISTIK.......................................................... 221 

7.9.3.10.3 DETERMINISTISCHE LÖSUNG................................................... 222 

7.9.3.10.4 VERGLEICH DER ERGEBNISSE ................................................. 222 


- 10 -



7.9.3.11.1 VORGABEN................................................................................ 223 





7.9.3.12.1 VORGABEN................................................................................ 225 





7.9.3.13.1 VORGABEN................................................................................ 227 





7.9.3.14.1 VORGABEN................................................................................ 229 





7.9.3.15.1 VORGABEN................................................................................ 232 





7.9.3.16.1 VORGABEN................................................................................ 233 




- 11 -




7.9.3.17.1 VORGABEN................................................................................ 238 





7.9.3.18.1 VORGABEN................................................................................ 241 




8 CONCLUSIO.........................................................................242 

9 LITERATUR .........................................................................244 

10 ABBILDUNGSVERZEICHNIS .............................................250 

11 TABELLENVERZEICHNIS .................................................254 

12 ANHANG...........................................................................255 

12.1 QUELLCODE DER ANWENDUNG...................................................255 

12.1.1 PROGRAMM QUELLCODE APAWIN ................................................... 255 

12.1.2 UNIT APA_ANALYSEUNIT.DFM ........................................................... 255 

12.1.3 UNIT APA_ANALYSEUNIT.PAS ............................................................ 256 

12.1.4 UNIT APA_APPLICATIONUNIT.DFM.................................................... 259 

12.1.5 UNIT APA_APPLICATIONUNIT.PAS ..................................................... 262 

12.1.6 UNIT APA_DIALOGUNIT.DFM .............................................................. 282 

12.1.7 ENDUNIT APA_DIALOGUNIT.PAS......................................................... 282 

12.1.8 UNIT APA_GRIDUNIT.DFM.................................................................. 283 

12.1.9 UNIT APA_GRIDUNIT.PAS ................................................................... 292 

12.1.10 UNIT APA_HELPUNIT.DFM.............................................................. 388 

12.1.11 UNIT APA_HELPUNIT.PAS............................................................... 389 

12.1.12 UNIT APA_INPUT_DIMENSIONUNIT.DFM ....................................... 390 

- 12 -



12.1.13 UNIT APA_INPUT_DIMENSIONUNIT.PAS......................................... 391 

12.1.14 UNIT APA_INPUT_HIERARCHYUNIT.DFM ...................................... 392 

12.1.15 UNIT APA_INPUT_HIERARCHYUNIT.PAS ....................................... 393 

12.1.16 UNIT APA_INPUT_REQBLOCKUNIT.DFM........................................ 395 

12.1.17 UNIT APA_INPUT_REQBLOCKUNIT.PAS......................................... 396 

12.1.18 UNIT APA_INPUT_SCREENUNIT.DFM ............................................. 397 

12.1.19 UNIT APA_INPUT_SCREENUNIT.PAS............................................... 401 

12.1.20 UNIT APA_KEYUNIT.DFM ............................................................... 412 

12.1.21 UNIT APA_KEYUNIT.PAS ................................................................ 413 

12.1.22 UNIT APA_OPTIONSUNIT.DFM........................................................ 414 

12.1.23 UNIT APA_OPTIONSUNIT.PAS ......................................................... 416 

12.1.24 UNIT APA_PARAMETERUNIT.DFM.................................................. 417 

12.1.25 UNIT APA_PARAMETERUNIT.PAS ................................................... 425 

12.1.26 UNIT APA_PROCESSUNIT.DFM........................................................ 434 

12.1.27 UNIT APA_PROCESSUNIT.PAS......................................................... 435 

12.1.28 UNIT APA_SCREENUNIT.DFM ......................................................... 437 

12.1.29 UNIT APA_SCREENUNIT.PAS........................................................... 438 

12.1.30 UNIT APA_SELECTIONUNIT.DFM.................................................... 440 

12.1.31 UNIT APA_SELECTIONUNIT.PAS ..................................................... 444 

12.1.32 UNIT APA_SHOW_COSTSUNIT.DFM ................................................ 458 

12.1.33 UNIT APA_SHOW_COSTSUNIT.PAS ................................................. 459 

12.1.34 UNIT APA_SQLUNIT.DFM................................................................ 462 

12.1.35 UNIT APA_SQLUNIT.PAS ................................................................. 463 

12.2 QUELLCODES DER HILFEDATEIEN...............................................464 

12.2.1 INDEX.HTM ........................................................................................... 464 

12.2.2 APA_GRID_SCREEN.HTM ................................................................... 465 

12.2.3 APA_INPUT_SCREEN.HTM .................................................................. 467 

12.2.4 APA_INSTALL.HTM ............................................................................. 469 

12.2.5 APA_MAINMENU.HTM ........................................................................ 470 

- 13 -



12.2.6 APA_SELECTION_SCREEN.HTM ......................................................... 471 

- 14 -



VORWORT UND DANKSAGUNGEN: 

Das Thema der Dissertation und das Verfassen einer Dissertation ist eine 

zeitaufwendige Tätigkeit. Durch die vielen Stunden, welche man in diese Arbeit 

investiert, wird unwillkürlich anderes vernachlässigt. Dies zieht sich vom beruflichen 

bis in den privaten Bereich. Das heißt, dass man auf seinem Wege bis hin zum 

Abschließen der Arbeit viele Menschen vernachlässigt. Ihnen gebührt Dank und 

Anerkennung, da sie somit einen Teil zu dieser Arbeit beigetragen haben. 

Dabei möchte ich mich besonders bei Professor Prosser bedanken. Wäre er nicht an 

mich herangetreten, hätte ich das Doktoratsstudium gar nicht begonnen. Zusätzlich 

danke ich ihm auch für seine Unterstützung und Hilfe beim Verfassen und für so 

manchen hilfreichen Tipp oder Denkanstoß. Weiters muss natürlich auch erwähnt 

werden, dass meine Arbeit auch unmittelbar auf die Arbeit von Professor Prosser und 

Frau Ossimitz aufbaut. 

Besonderer Dank gilt auch Professor Janko dafür, dass er die Zweitbeurteilung dieser 

Arbeit übernommen hat. Denn es ist bei solch speziellen Themen nicht sehr einfach 

einen Beurteiler zu finden. 

Der wichtigste Mann, welcher einen enormen Anteil am Gelingen dieser Arbeit hat, ist 

mein Großvater Georg ACHS, der mich jeden Tag auf das Neue motiviert hat und 

darauf aufmerksam gemacht hat, täglich ein neues Puzzlesteinchen zum Vollenden der 

Arbeit hinzuzufügen. Ohne ihn und seine täglichen Ermunterungen wäre diese Arbeit 

nie vollendet worden. Sehr großer Dank gilt auch meinen Eltern, Gerlinde und Hans 

Georg ACHS, welche mich beruflich entlasten konnten und mir zu jeder Zeit eine 

Stütze gewesen sind. Ein besonderer Dank an dieser Stelle speziell meiner Mutter für 

das fachmännische Korrekturlesen der Arbeit. Auch meine Großmütter, meine 

Schwester, meine Großtanten, weitere Verwandte und Freunde will ich erwähnen und 

mich zusätzlich entschuldigen, dass ich sie, auf Grund dieser Arbeit, des Öfteren 

versetzt und vernachlässigt habe. Ich werde mich bessern. 

Thomas ACHS, Gols im JUNI 2004 

- 15 -



1 EINFÜHRUNG 

1.1 ZIEL DER ARBEIT 

Das Planen und Entwickeln eines optimalen Data Warehouse-Systems ist ein Ansinnen 

vieler Wissenschaftler und Forscher aus unterschiedlichen Bereichen. Zahlreiche 

Publikationen wurden zu diesem Thema verfasst und in den letzten Jahren 

veröffentlicht. In dieser Literatur wird versucht eine Heuristik zu entwickeln, welche 

eine Lösung nahe am Optimum für das Materialisierungsproblem im Datawarehouse 

liefert. In der Vergangenheit wurde in zahlreichen Publikationen Annahmen, wie 

unbegrenzte Ressourcen oder rasche Zugriffszeit getroffen, welche in der realen Welt 

allerdings nicht vorhanden sind. Die Vision, welche hinter dieser Arbeit steckt, ist es, 

ein Instrument zu entwickeln, welches diese limitierenden Faktoren mitberücksichtigt, 

bzw. dieses versucht. Dabei hat sich insbesonders die Modellierungsmethode des 

Aggregation Path Arrays von Prosser und Ossimitz [vgl. Prosser/Ossimitz (2001)] als 

geeignet erwiesen, in diesem Problembereich einen Lösungsansatz zu finden. Vor allem 

ist diese Methode durch die einfache graphische Darstellungsfähigkeit besonders für 

informationstechnische Darstellung geeignet. Dabei ist es auch unerfahrenen 

Endbenutzer möglich, das Design eines Warehouses zu bewerkstelligen. Aus diesem 

Grund ist die Methode auch für Schulungs- und Ausbildungszwecke besonders 

geeignet. 

Die kostenminimale physische Bereitstellung der wichtigen Informationen für die 

Entscheidungsträger in Unternehmen stellt das Ziel dieser Arbeit dar. Dabei ist ein 

Optimierungsproblem zu lösen, welches limitierende Zeit- und Speicherressourcen bei 

gleichzeitigem Berücksichtigen wichtiger Information beachtet. Leider ist diese 

Information nicht immer als homogen anzusehen. Es gibt beispielsweise wichtige 

Information, welche für das Überleben einer Organisation notwendig ist und 

Information, welche wichtig, aber nicht ständig verfügbar sein muss. Der Versuch einen 

Lösungsansatz für diese Problematik zu finden, stellt das Herzstück meiner Arbeit dar. 

1.2 VORGEHENSWEISE 

Der Kern der Arbeit stellt das praktische Darstellen des Aggregation Path Arrays (APA) 

dar. Dabei wird eine Software-Applikation (Quellcode im Anhang) ausprogrammiert, 

welche ein benutzerunterstützendes Design des Data Warehouses ermöglicht. Zusätzlich 

soll nach der Eingabe der benötigten Informationen, welche sich durch so genannte 

„Required cubes“ manifestieren, der Benutzer bei der Auswahl der zu 

materialisierenden und somit physisch in der Datenbank lagernden Information 

- 16 -



unterstützt werden. Dies soll, da die Optimierung ein sehr komplexes Lösungsproblem 

darstellen kann, heuristisch gelöst werden. Im Vergleich dazu werden Algorithmen 

ausgetestet, welche zwar eine ideale Lösung liefern, aber für komplexe 

Problemstellungen sehr lange Berechnungszeiten erfordern. Abschließend werden die 

Ergebnisse verglichen, um eine Bewertung des heuristischen Ansatzes zu treffen. 

Im Vorfeld wird relevante Literatur zum Konnex aufbereitet, welche die Grundlage zum 

Verstehen der Zusammenhänge darstellt. 

2 DATENMODELLIERUNG 

Für die Modellierung von Daten ist es zweckmäßig, sich die verschiedenen 

Betrachtungsebenen für Daten und Informationen zu veranschaulichen. Dabei versucht 

man eine betriebswirtschaftliche Problemstellung in mehreren Stufen abzubilden. 

Diese sind das 

• Fachkonzept (semantisches Datenmodell): Auf dieser Ebene befindet sich die 

ER-Diagramm-Ebene. 

• DV-Konzept (logisches Datenmodell): Dies beschreibt die Daten eines 

Informationssystems auf der Ebene der Datenbanken. 

• Technische Implementierung (physisches Datenmodell): Auf dieser Ebene 

betrachtet man die reale Ausbildung der Datenbank, wie die SQL-Anweisungen. 

Wie durch den hierarchischen Aufbau angedeutet werde ich mich bei meinen 

Ausführungen vom semantischen Modell bis zur endgültigen Implementierung der 

Datenbank und der Tables (Tabellen) vortasten. 

2.1 SEMANTISCHES DATENMODELL 

Ein vielfach bewährtes Werkzeug zur Erstellung von relationalen Datenbanken ist das 

Entity Relationship Modell, kurz ER-Modell genannt. Dieses Modell wurde von P. 

Chen im Jahre 1976 vorgestellt. Das ER-Modell verhindert Redundanzen bis auf 

Fremdschlüssel auch relationenübergreifend. [vgl. Schicker (1999) S.136f ] 

Um mit dem ER-Modell nach Chen arbeiten zu können sind im Vorfeld eine Reihe von 

Begriffen zu klären und auszuformulieren. Diese Vokabel werden bei der Modellierung 

verwendet und können als Bausteine für das ER-Diagramm angesehen werden. Wir 

werden das ER-Modell für unsere Arbeit einsetzen. Deshalb soll es auch hier im Detail 

erläutert werden. Alternative Modellierungsmethoden sind insbesondere das „ER- 

Modell nach der Notation „Barker“ oder die „Unified Modeling Language“ [vgl. Cordts 

(2002) S. 35ff]. Für detaillierte weiterführende Ausführungen über semantische 

- 17 -



Datenmodellierung verweise ich auf Baldi (1999) S. 76ff, Fischer et al. (2000) S. 105ff, 

Janko (1998) S. 335ff, Kemper (1999), S. 33ff und Meier (2001) S. 16ff. 

2.1.1 ENTITÄTEN (ENTITIES) 

Wie der Name schon sagt, ist der grundlegendste Baustein des ER-Diagramms die 

Entität (Gegenstand). Entitäten sind wohlunterscheidbare physisch oder gedanklich 

existierende Konzepte der zu modellierenden Welt. Entitäten werden im Diagramm 

durch Rechtecke dargestellt. 

Abbildung 1: Symbol für Entitätstyp 

Man unterscheidet folgende Arten von Entitätstypen: 

Super- und Subentitätstypen: 

Superentitätstypen fassen gemeinsame Attributsmengen von Subentitätstypen 

zusammen. Offensichtlich ist der Entitätstyp „Auftrag“ ein Superentitätstyp, da er 

Attribute der Subentitätstypen „Kundenauftrag“, „Fertigungsauftrag“, 

„Beschaffungsauftrag“ usw. zusammenfasst. Siehe dazu auch Entitätsmengen 2.1.2. 

Fundamentale Entitätstypen: 

Existieren um ihrer selbst willen. Die Entitäten fundamentaler Entitätstypen 

repräsentieren eindeutige Objekte der realen Welt. Beispiele für solche Entitätstypen 

sind „Geschäftspartner“ oder „Artikel“. 

Entitäten assoziativer Entitätstypen: 

Drücken einen fachlichen Zusammenhang zwischen fundamentalen Entitäten aus und 

haben eigene Attribute. Sie haben eine Art „Zwitterfunktion“, da sie auch als 

Beziehungstypen angesehen werden können. Ein Beispiel für einen solchen Entitätstyp 

ist „Auftragsposition“, der auch als Beziehungstyp zwischen „Auftrag“ und „Artikel“ 

angesehen werden kann. 

2.1.2 ENTITÄTSMENGEN (ENTITY SETS) 

Ähnliche Entitäten können zu Entitätsmengen zusammengefasst werden. So könnten die 

Subentitäten Kunde, Lieferant und Bank unter Superentität Geschäftspartner 

zusammengefasst werden. 

- 18 -



Abbildung 2: Super- und Subentitätstypen mit „is a“ Operator 

[Quelle: Rautenstrauch/Schulze (2003) S. 237] 

Für die Modellierung von Super- und Subentitätstypen wird der „is a“- Operator als 

Dreieck eingeführt. Auf der Spitze des Dreiecks wird der Superentitätstyp und auch der 

Unterseite werden die Subentitätstypen notiert. Die Erzeugung von Superentitätstypen 

durch Zusammenfassen gemeinsamer Attributsmengen verschiedener Entitätstypen 

wird Generalisierung und das „Herausziehen“ von Subentitätstypen mit disjunkten 

eigenen Attributsmengen wird Spezialisierung genannt. 

2.1.3 ATTRIBUTE UND SCHLÜSSEL 

Entitätstypen werden durch Attribute, d.h. Eigenschaften bzw. Merkmale, 

charakterisiert. Eine bestimmte Entität ist durch spezifische Werte für die Attribute 

gekennzeichnet. 

Ein Attributstyp Kunde besitzt beispielsweise die Attribute Name, Straße, Wohnort und 

Kundennr. In der graphischen Darstellung werden Entitäten durch Ellipsen dargestellt. 

Abbildung 3: Entitätsmenge mit Attributen 

- 19 -



Bestimmte Attribute werden benutzt, um Entitäten voneinander zu unterscheiden. 

Hierfür eignen sich aber nur solche Attribute oder Attributkombinationen, die 

Eindeutigkeit gewährleisten. Solche Attribute oder Attributkombinationen werden auch 

als Schlüsselkandidaten bezeichnet, da sie sich für Primärschlüssel in den späteren 

Tabellen nahezu anbieten. Primärschlüssel werden in ER-Diagrammen unterstrichen 

dargestellt. 

Jedes Attribut hat einen Wertebereich (Datentyp). So kann ein Attribut beispielsweise 

einen Zeitpunkt (Geburtsdatum), eine Zahl (Mahnstufe), einen Text (Name) usw. 

bezeichnen. Man kann einfache Attribute, die aus einer einzelnen Komponente mit einer 

unabhängigen Existenz bestehen (wie Geschlecht oder Gehalt) und zusammengesetzte 

Attribute, die aus mehreren Komponenten zusammengesetzt sind, die wiederum eine 

eigene Existenz besitzen, unterteilen (z.B. Das Attribut Adresse besteht aus Strasse, 

Postcode und Ort). [vgl. Connolly et al. (2002) S 186f] 

2.1.4 BEZIEHUNGEN (RELATIONSHIPS) 

Eine Beziehung (auch als Relation bezeichnet) ist eine Verknüpfung zwischen 

verschiedenen Entitäten. So kann z.b. die Entität „Kunden“ mit der Entität „Konto“ in 

Beziehung stehen, indem der Kunde ein Konto besitzen kann. 

Anhaltspunkt dafür, was als Entitätstyp und was als Beziehungstyp bezeichnet werden 

kann, ist die Verwendung von Substantiven bzw. von Verben. Entitätstypen werden in 

der Regel mit Substantiven; Beziehungstypen in der Regel mit Verben bezeichnet. [vgl. 

Heinrich (2001), S. 246] 

Normalerweise verknüpft man jeweils zwei Entitäten über eine Relation. In diesem Fall 

spricht man von einer zweiwertigen oder binären Relation. 

Abbildung 4: Einfaches Symbol eines Beziehungstyps für einfache Darstellbarkeit 

Abbildung 5: Formal richtiges Beziehungssymbol der ER-Modell Konvention 

- 20 -



Die Bedeutung, die einem Entitätstyp in einer Beziehung zukommt, nennt man auch 

seine Rolle. Die Rolle des Entitätstypen „Kunde“ im obigen Beispiel ist 

„Kontoinhaber“. Wenn ein Entitätstyp mehrere Beziehungen eingeht, kann er auch 

mehrere Rollen einnehmen. 

2.1.5 KARDINALITÄTEN VON BEZIEHUNGEN 

Die semantische Aussagekraft eines Datenmodells bezüglich der Abbildung der 

betrieblichen Realität kann durch die Angabe der Kardialität eines Beziehungstyps 

gesteigert werden. Die Kardialität ist eine quantitative Spezifikation für die Menge der 

auftretenden Beziehungen. Beziehungen kann man grundsätzlich in Kann-Beziehungen 

und Muss-Beziehungen einteilen. Bei einer Kann-Beziehung müssen nicht alle Objekte 

eines Objektsatzes durch die Beziehung angesprochen werden. Dadurch muss nicht 

jeder Artikel im Lager gleichzeitig als Position in einer Bestellung auftauchen. Bei einer 

Muss-Beziehung ist dies aber sehr wohl der Fall. So muss z.b. jeder Mitarbeiter einer 

Unternehmung einer Abteilung zugeordnet werden. [vgl. Morcinek (2002) S. 218f] 

Grad 

Ausprägung 

"Muss" "Kann" 

Beziehung Beziehung 

1 zu 1 [1,1] [0,1] 

1 zu N [1,*] [0,*] 

Tabelle 1: Kombinationen von Grad und Ausprägung 

Grundsätzlich lassen sich folgende Kardinalitäten unterscheiden: 

2.1.5.1 1-1 BEZIEHUNGEN 

Einer Entität wird genau eine Entität zugeordnet. Beispiel: Ein Mitarbeiter hat genau 

einen Hauptwohnsitz. „Diese Beziehungen sind in der Realität eher selten anzutreffen, 

da Entitäten zwischen denen eine solche Beziehung besteht, theoretisch in einer Entität 

zusammengefasst werden können“ [vgl. Rautenbach/ Schulze (2003) S. 131] . 

Abbildung 6: 1:1 Beziehung zwischen Kunde und Hauptwohnsitz 

- 21 -



2.1.5.2 1-N BEZIEHUNGEN 

Einer Entität werden mehrere oder eine Entität zugeordnet. Beispiel: In einer Abteilung 

können mehrere Mitarbeiter arbeiten. 

Abbildung 7: 1:n Beziehung zwischen Abteilung und Mitarbeiter 

2.1.5.3 M-N BEZIEHUNGEN 

Mehrere Entitäten werden mehreren anderen Entitäten zugeordnet. Beispiel: Ein 

Mitarbeiter bearbeitet mehrere Projekte. Ein Projekt wird von mehreren Mitarbeitern 

bearbeitet. 

Abbildung 8: m:n Beziehung zwischen Mitarbeiter und Projekt 

2.1.5.4 DIE REKURSIVE BEZIEHUNG 

Eine rekursive Beziehung ist eine Beziehung von Entitäten des gleichen Typs. 

Standardbeispiel ist die Beziehung „ist Vorgesetzter von“ eines Entitätstyps 

„Mitarbeiter“. Zu beachten ist hier auch die alternative Darstellungsmöglichkeit von 

Beziehungen durch eine Raute (im Unterschied zu der in Abbildung 6 verwendeten 

einfachen Darstellung). 

- 22 -



Abbildung 9: Rekursiver Beziehungstyp [Quelle: Rautenstrauch/Schulze (2003) S. 237] 

2.2 LOGISCHES DATENMODELL 

2.2.1 ALLGEMEINES 

Ein logisches Modell beschreibt die Daten eines Informationssystems auf der Ebene des 

DV-Konzepts. Unter den logischen Datenmodellen spielen vor allem vier Modelle eine 

Rolle: 

• Hierarchisches Datenmodell 

• Netzwerkdatenmodell 

• Relationales Datenmodell 

• Objektorientiertes Datenmodell 

• Objektrationonales Datenmodell 

Das in der Praxis wichtigste Datenmodell ist das „Relationale Modell“. Dieses 

werde ich auch als Basis für meine Datenmodellierung der Applikation verwenden, 

da mit Microsoft SQL als Datenbank für unsere Anwendung und das 

Datawarehouse eine relationale Datenbank gewählt wurde. 

- 23 -



2.2.2 DATENMODELLE 

2.2.2.1 HIERARCHISCHES DATENMODELL 

Das hierarchische Datenbankmodell basiert auf der mathematischen Baumstruktur. 

Wenn wir die einzelnen Dateien einer hierarchischen Datenbank als Knoten bezeichnen, 

so gelten folgende Vereinbarungen: Wie bei Verzeichnisstrukturen der meisten 

Betriebssysteme gibt es eine Wurzel. Dieser Knoten hat keinen Vorgänger und leitet 

alle anderen ab. Hat ein Knoten keinen Nachfolger wird er als Blatt bezeichnet. 

Abbildung 10: Firmenhierarchie 

- 24 -


Vorteile: 


• Einfacher Aufbau 

• Sehr kurze Zugriffszeiten 

• Minimale Redundanz 

Nachteile: 

• Strukturveränderungen kaum möglich 

• Komplexe Programmierung 

2.2.2.2 NETZWERKDATENMODELL 

Das Netzwerkmodell beruht wie das hierarchische Modell auf der Graphentheorie, 

allerdings gibt es keine hierarchische Struktur und jeder Knoten kann mit jedem Knoten 

verbunden sein. Analog zur Abbildung 10 könnte also ein Arbeiter auch Mitglied in 

zwei Abteilungen sein. 

Vorteile: 

• Kurze Zugriffszeiten 

• Geringe Redundanz 

Nachteile: 

• Strukturveränderungen nicht einfach 

• Relativ komplexe Programmierung 

2.2.2.3 RELATIONALES DATENMODELL 

Das relationale Modell, das von Codd entwickelt wurde, basiert auf einer 

mathematischen Grundlage, der Relationenalgebra. Eine relationale Datenbank besteht 

ausschließlich aus Tabellen. Ein Zugriff erfolgt immer über diese Tabellen. Die 

Zusammenhänge zwischen den Tabellen werden über Beziehungen hergestellt. Diese 

Beziehungen werden über Primär- und Fremdschlüssel abgebildet. 

Das relationale Datenmodell ist tupelorientiert, die Information wird durch Relationen 

repräsentiert. Eine Relation ( 1, 2,..., 

n ) A A A R ist eine bekannte Menge von n-Tupeln, 

wobei n-Tupel eine Anordung von n atomaren, das heißt einfachen (nicht weiter 

zerlegbaren) Attributen (attributes) n A A A ,..., , 1 2 ist. [vgl. Schneider/Weber (2000) S. 471] 

- 25 -


Vorteile: 


• Leichte Änderbarkeit des Datenbankaufbaus 

• Mathematisch fundiert 

• Leicht programmierbar und verwaltbar 

Nachteile: 

• Häufig viele Ein-/Ausgaben notwendig 

• Erfordert eine hohe Rechnerleistung 

• Erzeugt Redundanz 

• Komplizierte Objekte müssen erst in viele Tabellen zerlegt und beim Abfragen 

wiederum mühevoll rekonstruiert werden. 

Das relationale Modell ist das in der Praxis am häufigsten vorkommende Modell. 

Relationale Datenbanken sind die wichtigsten Datenbankanwendungen in der heutigen 

Zeit. Aus diesem Grund werde ich im Kapitel, das sich mit SQL beschäftigt im 

speziellen auf die Grundlagen des relationalen Datenmodells und der Relationenalgebra 

eingehen. 

2.2.2.4 OBJEKTORIENTIERTES DATENMODELL 

Eine objektorientierte Datenbank besteht ausschließlich auf Objekten. Ein Objekt ist 

entweder ein realer Gegenstand oder ganz allgemein ein abstrakter Gegenstand. Da 

viele Objekte auch in Tabellenform gespeichert werden können, werden 

objektorientierte Datenbanken häufig als eine Erweiterung relationaler Datenbanken 

angesehen. Dies trifft aber nur teilweise zu. Der Haupteinsatz von Objektorientierten 

Datenbankmanagementsystemen liegt in der Bereitstellung von Datenbankeigenschaften 

für objektorientierte Anwendungen, insbesondere für solche, die durch die traditionellen 

Datenmodelle und –systeme nur unzureichend unterstützt wurden. Beispiele für solche 

Anwendungsgebiete sind Entwurfsanwendungen (CAD, CASE), Geo- 

Informationssysteme (GIS), wissenschaftliche Anwendungen und Gebäudetechnik 

(Facility Management). Ein signifikantes Eindringen in die traditionellen 

Anwendungsbereiche relationaler Systeme ist ihnen jedoch nicht gelungen. [vgl. Geppert 

(2002) S. 30f] 

- 26 -


Vorteile: 


• Objektorientierter Aufbau 

• Universell einsetzbar 

• Noch relativ einfach programmierbar und verwaltbar 

• (teilweise) kompatibel zu relationalen Datenbanken 

Nachteile: 

• relativ viele Ein-/Ausgaben notwendig 

• erfordert eine relativ hohe Rechenleistung 

• teilweise recht komplexer Aufbau 

2.2.2.5 OBJEKTRELATIONALES DATENMODELL 

Das objektrelationale Datenmodell steht als hybride Konstruktion zwischen dem 

relationalen und dem Objektdatenmodell. Das relationale Datenmodell wird dabei um 

folgende Elemente des Objektdatenmodells erweitert: 

Strukturierte Objekte: 

Aus den vorhandenen Datentypen können komplexere (nicht atomare) Strukturen 

definiert werden. 

Untertypen: 

Aus existierenden Typen können durch Spezialisierung neue gebildet werden 

(Untertypen). Diese erben alle Charakteristika des Obertyps. 

Erweitertes und erweiterbares Typsystem: 

Erweiterungen des relationalen Datenmodells um neue Typen (z.b. für 

Multimediadateien). Das Typsystem kann durch selbst definierte Typen erweitert 

werden. 

Referenzen: 

Zwischen den Datenelementen (d.h. Tupeln) können Beziehungen definiert werden, die 

nicht über Fremdschlüsselbeziehungen abgedeckt werden. 

[vgl. Schneider/Werner (2000) S. 475f] 

2.2.3 ÜBERFÜHRUNG DES ER-MODELLS INS RELATIONALE MODELL 

Auf der Erfahrung ergibt sich eine bestimmte Vorgehensweise beim Umsetzen des ER- 

Modells ins relationale Modell. Für die Umsetzung bestehen aber Freiheitsgrade und 

- 27 -



Gestaltungsmöglichkeiten bei der Wahl der Relationen und ihrer Attribute. Das heißt 

die Umsetzung kann auch weit von diesen „Standardregeln“ der Umsetzung abweichen. 

Häufig wird für jeden Entitätstyp zunächst eine eigene Tabelle angelegt. Beziehungen 

werden dadurch abgebildet, dass in einer Tabelle ein Verweis auf einen Eintrag in einer 

anderen Tabelle eingefügt wird. Enthält eine Tabelle in einem Attribut oder einer 

Attributkombination einen Verweis auf eine andere Tabelle, so werden diese Attribute 

auch Fremdschlüssel (foreign key oder Sekundärschlüssel) genannt, da sie einen 

Verweis auf den Primärschlüssel einer anderen Relation darstellen. 

Jeder Wert eines Fremdschlüssels sollte auch als Wert im Primärschlüssel einer anderen 

Relation vorkommen. Diese Eigenschaft eines Relationenmodells bezeichnet man auch 

als referenzielle Integrität. 

- 28 -



Die einzelnen Beziehungstypen werden üblicherweise im Relationenmodell wie folgt 

behandelt: 

2.2.3.1 DIE UMSETZUNG DER 1:1 BEZIEHUNG 

Bei einer 1:1 Beziehung wird eine beliebige der beiden für die Entitätstypen erstellten 

Tabellen um die Attributsspalte(n) des Primärschlüssels der anderen Tabelle ergänzt. 

Dabei muss jedoch überdacht werden, ob es sich bei dieser 1:1 Beziehung tatsächlich 

um zwei Entitäten handelt oder ob diese Entitäten eigentlich dasselbe Objekt 

verkörpern.[vgl. Connolly et al. (2002) S. 279] 

Abbildung 11: Beispielhafte Umsetzung einer 1:1 Beziehung in das Realtionenmodell in der 

vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ] 

- 29 -



2.2.3.2 DIE UMSETZUNG DER 1:N BEZIEHUNG 

Bei einer 1:n Beziehung wird die Tabelle der „n-Seite“ um die Attributsspalten des 

Primärschlüssels der anderen Tabelle erweitert. 

Abbildung 12: Beispielhafte Umsetzung einer 1:n Beziehung in das Relationenmodell in der 

vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84] 

2.2.3.3 DIE UMSETZUNG DER M:N BEZIEHUNG 

Bei einer m:n Beziehung wird eine zusätzliche Tabelle eingeführt, die als Attribute die 

Primärschlüsselattribute beider Entitätstypen erhält. Der Primärschlüssel dieser neuen 

Relation ergibt sich aus der Kombination der beiden Ursprungsprimärschlüssel. 

- 30 -



Abbildung 13: Beispielhafte Umsetzung einer m:n Beziehung in das Relationenmodell in der 

vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ] 

2.2.3.4 DIE UMSETZUNG EINER REKURSIVEN BEZIEHUNG 

Eine rekursive Beziehung wird analog zu einer 1:1 oder 1:n Beziehung umgesetzt. Die 

einzige Unterscheidung zwischen den oben angeführten Varianten ist, dass bei der 

rekursiven Beziehung die Zeiger auf die gleiche Tabelle zeigen. Deshalb funktioniert 

die Generierung dieser Tabelle analog. 

2.3 PHYSISCHES DATENMODELL 

Das physische Datenmodell beschreibt die Daten des Informationssystems auf der 

Ebene der technischen Implementierung. Das physische Datenmodell bezieht sich auf 

eine konkrete Datenbank und die Tables, welche real physisch in der Datenbank durch 

„CREATE TABLE“ Anweisungen erzeugt werden. Diese SQL-Anweisungen werden 

beispielhaft im Kapitel 7.8.3.4 erläutert. 

- 31 -



3 SQL UND DATENBANKEN 

3.1 DATENBANKEN 

3.1.1 ENTWICKLUNGSGESCHICHTE DER DATENBANKSYSTEME 

Im Laufe der Jahrzehnte wurde eine ganze Reihe von Konzepten entwickelt, die 

Datenbestände möglichst sicher, effizient und eventuell benutzerfreundlich verwalten 

können. Die Kernidee war Daten und Anwendungsprogramme zu trennen. 

Im Jahre 1959 entwickelten Techniker der Firma IBM das Ramac-System, das man 

vielleicht als frühen Vorläufer nachfolgender Datenbanksysteme bezeichnen darf. Mit 

diesem System wird erstmalig der nichtsequentielle Datenzugriff verwirklicht. Ein 

echter theoretischer Ansatz zur Datenbankverwaltung wird aber erst Anfang der 

Sechziger Jahre entwickelt. Der Mathematiker Bachmann entwirft und veröffentlicht in 

den Jahren 1961 bis 1964 Datenstrukturdiagramme; er formuliert außerdem 

Beziehungen zwischen den Daten, der Begriff der Beziehungstypen (sets) wird bereits 

hier geprägt. 

Dies ist die Grundlage für das von der Codasyl-Gruppe (Vereinigung der wichtigsten 

amerikanischen Computerhersteller und Computeranwender) im Jahre 1971 

verabschiedete Netzwerk Datenmodell. 1970 stellt E. Codd das relationale 

Datenbankmodell vor. Im Jahre 1976 veröffentlichte Peter S. Chen zum Thema 

Datenbankentwurf das Entity-Realtionsship Prinzip. Der entscheidende Schritt für die 

relationale Datenbankwelt war im Jahre 1973 die Entwicklung des Systems R von IBM. 

Dieses Datenbanksystem beinhaltete eine Anfragesprache namens SEQUEL, die im 

Laufe der Projektentwicklung in SQL umbenannt wurde, mit welcher wir uns auch in 

dieser Arbeit im Detail befassen wollen. 

3.1.2 BEGRIFFSDEFINITIONEN 

Die Begriffe Datenbank, Dateisystem, Datei usw. werden heute oft sehr sorglos und 

ohne begriffliche Abgrenzung verwendet. Um diesem Abhilfe zu schaffen will ich diese 

Begriffe hiermit im Vorfeld entsprechend definieren. 

Datei 

Eine Datei ist ein Datenbestand, der unter einem Dateinamen im Allgemeinen auf einem 

externen Datenträger gespeichert ist. Dieser Datenbestand kann auch als Strom von Bits 

interpretiert werden. Eine Datei hat immer einen Namen, um sie von anderen Dateien 

unterscheiden zu können. [vgl. Rautenstrauch et al. (2003) S. 99] 

- 32 -



Daten 

Daten sind Informationen, die in digitaler Form auf Softwaresystem abgespeichert 

wurden. Daten können unformatiert (Text) oder formatiert sein. 

Datenbank Management System (DBMS) 

“Das DBMS (deutsch: Datenbankverwaltungssystem) ist eine spezielle Software, mit 

der größere, gemeinsame Datenbestände (Datenbank) aufgebaut, manipuliert und 

kontrolliert werden können“ [vgl. Fischer et al. (2000), S. 110]. Somit ist das DBMS die 

Gesamtheit aller Programme zur Erzeugung, Verwaltung und Manipulation der Daten 

[vgl. Schneider/Werner (2000) S. 469]. 

Datenbank 

Eine Datenbank ist eine Sammlung von Daten, die untereinander in einer logischen 

Beziehung stehen und von einem eigenen Datenbankverwaltungssystem (DBMS) 

verwaltet werden. Kurz formuliert ein Datenbanksystem besteht aus Daten und einem 

Datenbankmanagementsystem. [vgl. Schicker (1999), S. 46] 

3.1.3 ANFORDERUNGEN EINES DATENBANKSYSTEMS 

Anforderungen an ein Datenbanksystem sind: 

Sammlung logisch verbundener Daten: 

Da Daten auf mehrere Dateien verteilt sind, muss das Datenbanksystem diese Dateien 

zusammenfügen, um die Information zu gewinnen. 

Speicherung der Daten mit möglichst wenig oder keiner Redundanz: 

Redundanz ist das mehrfache Speichern ein und der selben Information. Dies kann bei 

Änderungen zu Differenzen führen und sollte vermieden werden. Deswegen sollte das 

Datenbankverwaltungssystem die nicht vermeidbaren redundanten Daten automatisch 

anpassen. 

Abfragemöglichkeit und Änderbarkeit der Daten 

Diese selbstverständliche Forderung schließt ein, dass das Abfragen und Ändern der 

Daten entsprechend schnell ausgeführt wird. 

Logische Unabhängigkeit der Daten von ihrer physischen Struktur: 

Es genügt nicht, dass die Datenbank für die optimale Speicherung der Daten sorgt, der 

Benutzer will darüber hinaus nicht einmal wissen, wie die Daten physisch abgespeichert 

sind. 

Zugriffsschutz: 

Betriebssysteme kennen nur den Schutz von Dateien, nicht den Schutz von einzelnen 

Daten innerhalb der Datei. Dieser interne Schutz ist aber bei sensiblen Daten, wie den 

Personaldaten erforderlich. Zusätzlich ergibt sich die Entwicklung verschiedener 

- 33 -



Sichten (Views) der Benutzer abhängig von den Rechten, welche diese besitzen [vgl. 

Schneider/Werner (2000) S. 470]. 

Integrität: 

Integrität kommt von INTEGER und bedeutet hier, dass alle gespeicherten Daten 

korrekt sein müssen. 

Mehrfachzugriff: 

Auf die Forderung nach Datenzugriffen von mehreren Rechnern oder Terminals aus 

kann in der Regel heute nicht mehr verzichtet werden. 

Zuverlässigkeit: 

Das bedeutet Sicherheit vor unerlaubten Zugriffen. 

Ausfallssicherheit: 

Bedeutet Sicherheit der Daten in allen nur erdenklichen Fällen, wie Rechnerausfall 

oder Zerstörung durch Feuer. 

Kontrolle: 

Die Datenbank muss ständig Angaben über ihren momentanen Zustand machen können. 

Diese Angaben sind z.B. Anzahl der Benutzer, Auslastung der Festplatten oder 

Auslastung des DBMS. 

Die Anforderungen an ein Datenbanksystem können zum Teil auch als die Vorteile 

eines Datenbanksystems interpretiert werden. Tatsache ist, das der Einsatz von 

Datenbanksystemen einen enormen Leistungssprung in der Softwareentwicklung 

gebracht hat. 

3.2 SQL ALS STANDARDISIERTE DATENBANKSPRACHE 

3.2.1 GESCHICHTLICHES 

Mit SQL steht eine Sprache zur Verfügung, mit der alle Funktionen auf relationalen 

Datenbanken ausgeführt werden können. Basis von SQL ist die Relationenalgebra, die 

eine mathematisch vollständige und konsistente Beschreibung sämtlicher auf 

relationalen Datenbanken anwendbaren Operationen bietet. 

Seit 1974 IBM mit SEQUEL die erste relationale Datenbanksprache auf den Markt 

brachte, hat sich die in den Folgejahren daraus entwickelte Sprache SQL weiter 

verbreitet, um sich schließlich ab 1982 als ANSI-Standard allgemein durchzusetzen. 

Seit dem ist eine ständige Weiterentwicklung im Fluss. 1987 wurde der ANSI-Standard 

SQL-1 geschaffen und 1989 der verbesserte ANSI-Standard SQL-2. Die ISO schloss 

sich dieser Standardisierung an, und auch in der deutschen Norm DN66315 ist SQL-2 

- 34 -



festgelegt. In den Weiterentwicklungen SQL-3 und SQL-4 wurden schließlich 

objektorientierte Konzepte integriert. 

SQL-1 und SQL-2 sind nicht zu den prozeduralen Sprachen der dritten Generation zu 

rechnen, da sie keine allgemeinen Methoden zur Formulierung von Algorithmen 

enthalten. So gibt es keine Schleifenkonstrukte und ähnliches. Als Ausgleich dafür 

besteht aber die Möglichkeit mit Embedded SQL , SQL-Statements in prozedurale oder 

objektorientierte Sprachen einzubetten. Erst durch SQL-3 wurde SQL vollständig und 

es kann auch mit SQL jeder Algorithmus ausgedrückt werden. 

SQL ist eine Sprache der vierten Generation (4GL). Das heißt in SQL wird nicht 

beschrieben, wie ein Datenbankzugriff zu erfolgen hat, es wird vielmehr beschrieben, 

was der Anwender beabsichtigt. Vor der Ausführung von SQL-Anweisungen muss 

daher eine algorithmische Umsetzung in prozedurale Anweisungen erfolgen, da nur 

solche durch einen Computer ausführbar sind. Das hat den großen Vorteil, dass SQL auf 

allen Arten von Datenbanken einsetzbar ist. 

Seit Jahren arbeitet nun ein Herstellerkonsortium namens SQL Access Group an der 

Definition von Einrichtungen zur Verbesserung der Interoperabilität zwischen 

unterschiedlichen SQL-Implementierungen. Sie versuchen somit den Standard laufend 

zu aktualisieren und zu verbessern. Die aktuelle Sprachversion von SQL heißt SQL-99. 

Das entsprechende Standarddokument ist Ende des Jahres 1999 in Kraft getreten – als 

offizielles Publikationsdatum wird der 15. November 1999 angegeben – und hat damit 

das bisher gültige Standarddokument aus dem Jahre 1992 abgelöst. 

Die SQL-Standardisierungskommission vermeidet es, von Relationen, Tupeln und 

Attributen zu sprechen. Statt dessen werden Ausdrücke wie Tabelle, Zeile und Spalte 

verwendet. Um bei einer sauberen Begriffsverwendung zu bleiben werde ich versuchen 

die Begriffe anschließend kurz zu definieren und aufzulisten. 

Relationaler Ausdruck SQL-Ausdruck 

Relation (Menge) Tabelle 

Tupel Zeile 

Attribut Spalte 

Tabelle 2: Gegenüberstellung von relationalen und SQL-Ausdrücken [Quelle: Pernul/Unland 

(2001) S. 263] 

SQL wurde als mengenorientierte Sprache konzipiert und hat damit den Vorteil enorm 

benutzerfreundlich zu sein. Der Benutzer kann in einer Sprache, die an die Englische 

Sprache angelehnt ist, seine Anforderungen an die Datenbank formulieren und erhält 

eine entsprechende Ergebnismenge geliefert. 

- 35 -



SQL ist sowohl eine DDL (Data Definition Language), eine DML (Data Manipulation 

Language) als auch eine DCL (Data Control Language). Diese Unterscheidung ist sehr 

wichtig und essentiell und sollte jedem Benutzer von SQL ständig im Bewusstsein 

bleiben. Für zusätzliche Publikationen über die Historie von SQL verweise ich auf Goos 

(2000), S. 108ff, Härder/Rahm (2001) S. 531, Hartmut (2000), S. 691f und Redaktion 

Toolbox (2002) S. 597ff. 

3.2.2 DAS RELATIONALE MODELL 

Das Relationale Modell, welches als das bedeutendste Datenmodell der Jetztzeit gilt, 

geht auf E.F. Codd zurück, der mit Recht als Schöpfer des Relationenmodells 

bezeichnet werden kann. In seiner zukunftsweisenden Abhandlung „A relational model 

of data banks“ (1970) stellte er erstmals das Relationenmodell vor. Auf Grund der 

Bedeutung und realen Anwendung im Zuge meiner Arbeit, will ich detaillierter und 

ausführlicher auf die Begriffe und Grundlagen dieses Modells eingehen. 

3.2.2.1 RELATIONALE DATENSTRUKTUR 

3.2.2.1.1 DOMÄNEN: 

Im relationalen Modell werden die Daten als Relationen repräsentiert. Eine Relation ist 

auf Domänen definiert. 

Eine Domäne 

• stellt einen Wertevorrat bereit. Die Werte werden dabei als atomar (skalar, 

elementar) vorausgesetzt. 

• hat einen Namen. 

Diese Eigenschaften gelten im wesentlichen auch für Datentypen, wie sie in höheren 

Programmiersprachen unterstützt werden. Tatsächlich kann man sich eine Domäne als 

eine Art Datentyp vorstellen. Das Domänenkonzept unterscheidet sich aber 

dahingehend, dass der Domänenname von Benutzer selbst definiert wird. 

3.2.2.1.2 RELATIONEN: 

Eine Relation über den Domänen D1, D2, ...., Dn besteht aus einem Relationenkopf 

(heading) und einem Relationenrumpf (body). 

Der Relationenkopf besteht aus einer festen, im Zeitablauf nicht änderbaren Menge von 

Attributen A1, A2,..., An, so dass jedes Attribut Ai genau einer der zugrundeliegenden 

- 36 -



Domänen entspricht. Die (feste) Anzahl n der Attribute wird als Grad (degree) der 

Relation bezeichnet. 

Der Relationenrumpf besteht aus einer variablen, im Zeitablauf veränderlichen Menge 

von n-Tupeln, wobei jedes n-Tupel wiederum eine Menge von (Attribut:Wert)-Paaren 

(Ai : vi ), i=1,...,n ist. Für jedes Paar (Ai : vi ) ist vi ∈Di. Die Anzahl der n-Tupel wird 

Kardinalität der Relation genannt. 

• Ein Attribut Ak hat einen innerhalb der Relation eindeutigen Namen, 

• der einen Bezug zur zugrundeliegenden Domäne Dk herstellt, 

• einen Bezug zum dazugehörigen Wert vk herstellt. 

[vgl. Panny/Taudes (2000) S. 23f] 

Abbildung 14: Relationale Datenstruktur [in Anlehnung: Panny/Taudes (2000) S. 23] 

3.2.2.1.3 EIGENSCHAFTEN VON RELATIONEN 

Für Relationen nach der obigen Definition ergeben sich folgende Eigenschaften: 

• Es kann niemals mehrfach auftretende identische Tupel in einer Relation 

geben. 

• Die Tupel einer Relation sind nicht geordnet. 

• Auch die Attribute einer Relation sind nicht geordnet. 

• Alle Attributswerte sind atomar. 

- 37 -



3.2.2.2 RELATIONALE INTEGRITÄT 

3.2.2.2.1 SCHLÜSSELKANDIDAT (CANDIDATE KEY) 

Sei R eine Relation mit den Attributen A1, A2,..., An.. Die Menge K= {Ai1, Ai2,..., Aim}, 

m>=1, heißt Schlüsselkandidat von R genau dann, wenn unabhängig vom Zeitpunkt 

(also über die gesamte Lebensdauer der Relation R) gilt: 

• Eindeutigkeit: Zu keinem Zeitpunkt gibt es zwei Tupel mit demselben Wert für 

K. 

• Minimalität: Keines der Attribute Ai1, Ai2,..., Aim kann weggelassen werden, ohne 

die Eindeutigkeit von K zu verliehren. 

3.2.2.2.2 PRIMÄRSCHLÜSSEL (PRIMARY KEY) 

Für jede gegebene Relation R muss einer der Schlüsselkandidaten als Primärschlüssel 

festgelegt werden. Die übrigen Schlüsselkandidaten heißen Alternativschlüssel 

(alternative keys). 

3.2.2.2.3 FREMDSCHLÜSSEL (FOREIGN KEY) 

Ein Fremdschlüssel ist ein Menge von Attributen einer Relation R2. Es gibt nun in der 

Datenbank eine Relation R1, so dass jeder in R2 auftretende Fremdschlüsselwert auch als 

Primärschlüsselwert in R1 vorkommt. Die Relationen R1 und R2 sind nicht 

notwendigerweise verschieden. 

3.2.2.2.4 ENTITÄTSINTEGRITÄT 

Für jede definierte Relation muss ein Primärschlüssel festgelegt sein. Kein zum 

Primärschlüssel einer Relation gehörendes Attribut, darf Nullwerte annehmen. 

3.2.2.2.5 REFERENZIELLE INTEGRITÄT (REFERENTIAL INTEGRITY) 

Sei R2 eine Relation, die mit einem Fremdschlüssel F auf die Relation R1 mit dem 

Primärschlüssel P zeigt. Für jeden in R2 auftretenden Wert von F muss gelten: 

• Er enthält entweder in keiner seiner Komponenten einen Nullwert oder alle 

seine Komponenten sind mit Nullwerten markiert. 

• Wenn er vollständig definiert ist, muss in R1 ein Tupel existieren, welches 

diesen Wert als P-Wert aufweist. 

- 38 -



Es ist durchaus erlaubt und möglich, dass R1 und R2 identisch sind. In einem solchen 

Fall spricht man von einem Selbstbezug. 

3.2.2.3 RELATIONALE DATENMANIPULATION 

Man unterscheidet grundsätzlich zwei Arten der Datenmanipulation: die Mutation und 

die Abfrage. Während bei der Abfrage nichts am Zustand der Daten oder Tupel 

verändert wird, ist die Mutation das Hinzufügen, Ändern und Löschen von Daten. 

Die Operationen der Relationenalgebra werden nach Panny/Taudes [vgl. Panny/Taudes 

(2000) S. 31f] wie folgt eingeteilt: 

• Selektion: 

Extrahiert bestimmte Tupel aus einer Relation und bildet somit eine horizontale 

Teilrelation. 

• Projektion: 

Extrahiert bestimmte Attribute aus einer Relation und bildet somit eine vertikale 

Teilrelation. 

• Produkt: 

Erzeugt aus zwei Relationen eine neue Relation, die aus allen möglichen Tupeln 

besteht, welche man durch Verketten eines Tupels der ersten Relation mit einem 

Tupel der zweiten Relation bilden kann. 

• Vereinigung: 

Erzeugt aus zwei Relationen eine neue Relation, welche die Tupel beider 

Relationen enthält. 

• Differenz: 

Erzeugt aus zwei Relationen eine neue Relation, welche die gemeinsamen Tupel 

beider Relationen enthält. 

• Verbund: 

Erzeugt aus zwei Relationen eine neue Relation, die aus allen möglichen Tupeln 

besteht, welche man durch Verketten eines Tupels der ersten Relation mit einem 

Tupel der zweiten Relation bilden kann, so dass jedes dieser Paare eine 

vorgegebene Bedingung erfüllt. 

• Division: 

Erzeugt aus zwei Relationen eine neue Relation. Nehmen wir fürs erste 

vereinfachend an, die Dividendenrelation habe Grad 2 (sei binär) und die 

Divisorrelation habe Grad 1 (sei unär). Dann besteht die Quotientenrelation aus 

- 39 -



all jenen Werten des einen Attributs der binären Relation, für die alle Werte der 

unären Relation im zweiten Attribut vorkommen. 

3.2.2.4 NORMALFORMEN 

Normalformen stellen ein Messverfahren für die Qualität und Güte eines 

Relationsschemas dar. Sie helfen, Anomalien zu entdecken und damit Redundanzen zu 

vermeiden [vgl. Pernul/Unland (2001) S. 140ff]. Die Unterscheidung der Normalformen 

basieren auf Codd (1970). In der Folge wird auf die wichtigsten Typen von 

Normalformen eingegangen.. 

3.2.2.4.1 ERSTE NORMALFORM (1NF) 

Die Wertebereiche aller Attribute des Relationsschemas müssen atomar sein. Die erste 

Normalform verlangt, dass alle Attibutwerte aus einem unstrukturierten Wertebereich 

stammen. Mengen, Aufzähltypen, Wiederholungsgruppen oder komplex strukturierte 

Wertebereiche sind nicht zugelassen. 

3.2.2.4.2 ZWEITE NORMALFORM (2NF) 

Die zweite Normalform bedeutet, dass es keine Teilmenge eines Schlüsselkandidaten 

geben darf, die ein nicht primes Attribut funktional bestimmt. Um die zweite 

Normalform überprüfen zu können, muss man zuvor alle Schlüsselkandidaten ermitteln, 

denn nur Attribute, die in keinem Schlüsselkandidaten enthalten sind, können die zweite 

Normalform verletzen. 

3.2.2.4.3 DRITTE NORMALFORM (3NF) 

Die dritte Normalform setzt die zweite Normalform voraus und fordert zusätzlich, dass 

zwischen einem nicht-primen Attribut und einem Schlüsselkandidaten keine transitive 

funktionale Abhängigkeit existieren darf. 

Funktionale Abhängigkeiten sind im Relationenmodell die wichtigste Klasse von 

Einschränkungen. Sie werden verwendet, um die Anzahl der mathematisch möglichen 

Tupel (kartesisches Produkt der Attributswertebereiche) auf die Menge der semantisch 

sinnvollen Tupel einzuschränken. Die funktionale Abhängigkeit X → Y (X bestimmt Y 

funktional) gilt im Schema R, falls alle beliebigen Tupel t 1 , t2 

aus der Relation r(R), die 

in ihren X-Werten übereinstimmen, auch in ihren Y-Attributen identische Werte 

aufweisen. 

- 40 -



3.2.2.4.4 BOYCE-CODD-NORMALFORM (BCNF) 

Die Boyce-Codd-Normalform setzt die dritte Normalform voraus. Sie ist die einzige 

Normalform, die durch gültige funktionale Abhängigkeiten und nicht durch nicht-prime 

Attribute verletzt werden kann. In Relationsschemata in der Boyce-Codd-Normalform 

gibt es keine nennenswerten Anomalien mehr. 

3.2.2.4.5 VOR- UND NACHTEILE DER NORMALISIERUNG 

Nachteile der Normalisierung: 

• Unübersichtlichere und schwieriger zu handhabende Datenbanken, da durch die 

Normalisierung mehr Tabellen entstehen. 

• Höhere Antwortzeiten durch die Notwendigkeit, Views einzuführen sowie Joins 

bei Datenbankabfragen zu verwenden. 

Vorteile der Normalisierung: 

• Verminderung von Redundanz durch Auslagerung von redundanter Information 

in separate Tabellen. 

• Weniger Anomalien. 

• Mehr Konsistenz. 

• Speicherplatzersparnis. 

[vgl. Kleinschmidt/Rank (2002) S. 78] 

3.2.2.5 SICHTEN (VIEWS) 

Ein View kann auch als virtuelle Relation bezeichnet werden, welche nicht selbständig 

besteht, sondern dynamisch von einer oder mehreren Grundrelationen abgeleitet wird. 

Eine Sicht kann durch Operationen wie die Auswahl, Projektion und Verknüpfung der 

relationalen Algebra oder anderen Berechnungen aus den Werten der Grundrelationen 

erzeugt werden. 

3.2.2.5.1 TERMINOLOGIE 

„Eine Sicht ist das dynamische Ergebnis einer oder mehrerer relationaler Operationen, 

die an einer Grundrelation ausgeführt wurden, um eine andere Relation zu erzeugen. 

Eine Sicht ist eine virtuelle Relation, die nicht tatsächlich in der Datenbank vorhanden 

ist, sondern auf die Anfrage des einzelnen Benutzers zu Zeit der Anfrage erzeugt wird.“ 

[vgl. Connolly et al. (2002) S. 138] 

- 41 -



3.2.2.5.2 ZWECK VON SICHTEN 

Der Zweck, bzw. die Vorteile von Sichten sind: 

• Teile der Datenbank bleiben vor bestimmten Benutzern verborgen. Dies liefert 

einen leistungsfähigen und flexiblen Sicherheitsmechanismus. 

• Es erlaubt den Benutzern, auf eine ihren Bedürfnissen angepasste Weise auf die 

Daten zuzugreifen, so dass dieselben Daten für verschiedene Benutzer zur 

selben Zeit auf unterschiedliche Weise sichtbar sind. 

• Er kann komplexe Operationen an Grundrelationen vereinfachen. Wenn eine 

Sicht zum Beispiel als Verknüpfung zweier Relationen definiert ist, kann der 

Benutzer nun die einfacheren Operationen der Auswahl und Projektion an der 

Sicht durchführen. Das Datenbanksystem übersetzt sie in die entsprechenden 

Operationen an der Verknüpfung. 

[vgl. Connolly et al. (2002) S. 138f] 

3.2.2.5.3 AKTUALISIERUNG VON SICHTEN 

Alle Aktualisierungen einer Grundrelation sollten sich unmittelbar in allen Sichten 

widerspiegeln, die sich auf diese Grundrelation beziehen. Ebenso sollte die zugrunde 

liegende Grundrelation die Änderung anzeigen, wenn eine Sicht aktualisiert wird. Es 

gibt jedoch Einschränkungen in Bezug auf die Art der Änderungen, die mit Hilfe von 

Sichten durchgeführt werden können. 

Aktualisierungen mit Hilfe einer Sicht sind zulässig, wenn eine einfache Abfrage 

bezogen auf eine einzelne Grundrelation benutzt wird, die entweder den Primärschlüssel 

oder einen Schlüsselkandidaten der Grundrelation enthält. 

Aktualisierungen mit Hilfe von Sichten sind nicht zulässig, wenn mehrere 

Grundrelationen betroffen sind. 

Aktualisierungen mit Hilfe von Sichten sind nicht zulässig bei Aggregations- oder 

Gruppierungs-Operationen. 

3.2.3 SQL NACH DEM STANDARD SQL 99 

SQL als Datenbanksprache stellt die sprachliche Schnittstelle zum Anwender dar. 

Damit stellt sie Beschreibungsmittel für die strukturellen und manipulativen Aspekte 

der Daten bereit. Entsprechend werden üblicherweise die Teilsprachen 

Datendefinitionssprache (DDL), Datenmanipulationssprache (DML) und 

Datenkontrollsprache (DCL) der Datenbanksprache SQL unterschieden und unten 

- 42 -



erläutert. Als weiterführende Literatur sei dabei Achilles (2000) S.119ff, Houlette 

(2001) S. 59ff, Marsch/Fritze (1999) S. 57ff und Panny/Taudes (2000) S. 71ff genannt. 

3.2.3.1 SQL ALS DDL 

Ursprünglich gingen die ersten Versionen von SQL von der Vorstellung aus, dass die 

Struktur einer Datenbank zeitlich festgeschrieben und durch die Struktur der Tabellen 

und Zugriffsrechte festgelegt ist. Deshalb war ursprünglich nur vorgesehen 

Datenbankobjekte anzulegen, nicht aber sie zu ändern oder zu löschen. Dies wurde erst 

in späterer Folge in den Standard integriert. 

Zum Erzeugen, Ändern und Löschen von DBMS-Objekten 

(Datenbankmanagementsystem-Objekten) sieht der Standard drei Kategorien von 

Anweisungen vor, die CREATE-, die ALTER- und die DROP-Anweisungen. Um 

Zugriffsrechte an den erzeugten DBMS-Objekten zu vergeben bzw. zu entziehen, stehen 

die GRANT- bzw. REVOKE-Anweisung zur Verfügung 

Im Anschluss möchte ich Anhand der TABLE Anweisungen für jede einzelne Kategorie 

exemplarisch die Struktur der SQL-Anweisungen demonstrieren, da eine intensivere 

Betrachtung jedes einzelnen DBMS-Objektes (also auch Indizes, Views, …) separat den 

Rahmen dieser Arbeit sprengen würde und diese analog betrachtet werden können. 

3.2.3.1.1 ERZEUGEN VON DBMS-OBJEKTEN (CREATE) 

Syntax: 

CREATE TABLE table_name 

( {spalten_name {domain_name | datentyp} 

[spalten_constraint] 

[DEFAULT voreinstellung] 

[COLLATE anordnung] 

| table_contraint 

}, … ); 

3.2.3.1.2 ÄNDERN VON DBMS-OBJEKTEN (ALTER) 

Syntax: 

ALTER TABLE tabellen_name 

{ ADD [COLUMN] spaltendefinition } 

| { ALTER [COLUMN] spalten_name 

{{ SET DEFAULT default } | { DROP DEFAULT }} 

} 

| { DROP [COLUMN] spalten_name {RESTRICT | 

CASCADE}} 

| { ADD table_constraint } 

- 43 -



| { DROP CONSTRAINT constraint_name {RESTRICT | 

CASCADE}} 

Löschen von DBMS-Objekten (DROP) 

Syntax: 

DROP TABLE table_name { CASCADE | RESTRICT } 

3.2.3.1.3 VERGABE VON RECHTEN (GRANT) 

Syntax: 

GRANT { ALL PRIVILEGES 

| SELECT 

| DELETE 

| { INSERT [(spalte [, ...])} 

| { UPDATE [(spalte [, ...])} 

| { REFERENCES [(spalte [, ...])} 

} [, ...] 

ON [ TABLE ] table_name 

TO { benutzer1 [, benutzer2, …] } | PUBLIC 

[ WITH GRANT OPTION] 

3.2.3.1.4 ENTZIEHEN VON RECHTEN (REVOKE) 

Syntax: 

REVOKE [ GRANT OPTION FOR] 

Recht [, …] ON objekt 

FROM { benutzer1 [, benutzer2, …] } | PUBLIC 

{ CASCADE | RESTRICT} 

3.2.3.2 SQL ALS DML 

SQL als Datenmanipulationssprache unterstützt sowohl Abfragen (SELECT), als auch 

Mutationen (INSERT, UPDATE, DELETE), welche die zugrunde liegenden Tabellen 

verändern. 

3.2.3.2.1 DIE SELECT ABFRAGE 

Die Abfrage ist das mächtigste und vielseitigste Instrument das SQL zu bieten hat. Man 

hat mit einer SQL Abfrage unglaubliche Möglichkeiten, die jedoch in den wenigsten 

Fällen benutzt werden. Zumeist beschränken sich die Anwender auf einfachste 

Abfragen. 

Syntax: 

SELECT [ ALL | DISTINCT ] selektionsliste 

FROM tabellenreferenzen 

- 44 -



[ WHERE suchbedingung ] 

[ GROUP BY spaltenliste ] 

[ HAVING gruppensuchbedingung ] 

3.2.3.2.2 DIE INSERT ANWEISUNG 

Syntax: 

INSERT INTO tabelle 

[ spalte i [, spalte j, ...])] 

{ select_anweisung 

| tab_konstruktor 

| { DEFAULT VALUES 

} 

3.2.3.2.3 DIE UPDATE ANWEISUNG 

Syntax: 

UPDATE tabelle 

SET spalte i = { ausdruck i | NULL | DEFAULT } 

[, spalte j = { ausdruck j | NULL | DEFAULT } 

...] 

[ WHERE suchbedingung ] 

3.2.3.2.4 DIE DELETE ANWEISUNG 

Syntax: 

DELETE FROM tabelle 

[ WHERE suchbedingung] 

3.2.3.3 SQL ALS DCL 

SQL ist auch eine Datenkontrollsprache (DCL), die dazu dient die 

Transaktionseinheiten festzulegen und Sperren auf die benutzten Datenbankobjekte 

anzufordern. 

Im vollen Sprachumfang von SQL-99 sind eigene Verbindungsanweisungen 

(connection statements) vorgesehen mit Hilfe derer der Benutzer den Auf- bzw. Abbau 

und die Verwaltung von SQL-Verbindungen explizit steuern kann. Insbesondere sind 

nun im Prinzip auch mehrere gleichzeitig bestehende Verbindungen zu mehreren SQL- 

Servern und sogar serverübergreifende Transaktionen möglich. In Core SQL, das den 

Sprachkern von SQL-99 darstellt, kann aber für einen SQL-Agenten immer nur eine 

einzige Verbindung bestehen. 

- 45 -



Zu jeder SQL-Verbindung gehört auch eine SQL-Sitzung (SQL Session). Sie wird mit 

dem Aufbau der Verbindung gestartet und mit dem Abbruch der SQL-Verbindung 

beendet. Dabei sind folgende zum Kontext einer Sitzung gehörende Bestandteile von 

Relevanz: 

• Die Benutzerkennung der SQL-Sitzung 

• Der Default-Katalogname 

• Der Default-Schemaname 

• Der SQL-Pfad 

Diese zum Kontext der Sitzung gehörenden Charakteristika können nicht verändert 

werden und haben einen Readonly Status. Die entsprechenden, zu Beginn der Sitzung 

gesetzten Werte bleiben notwendigerweise bis zum Ende der Sitzung in Kraft. 

Den Kern der Datenkontrolle bildet jedoch die Kontrolle über die Transaktionen. Eine 

Transaktion umfasst eine Folge von nacheinander auszuführenden SQL-Anweisungen. 

In Core SQL wird eine Transaktion durch die erste Anweisung gestartet, die den 

Rahmen der Transaktion voraussetzt. Es gibt zwei Anweisungen um eine Transaktion 

abzuschließen: COMMIT und ROLLBACK. Wird eine Transaktion durch COMMIT 

beendet, werden alle Mutationen dauerhaft gespeichert. Wird eine Transaktion durch 

ROLLBACK abgeschlossen, wird die Datenbank in den konsistenten Zustand vor der 

Transaktion zurückgesetzt. Keine der im Rahmen der Transaktion durchgeführten 

Anweisungen hat einen Effekt. 

4 ERP-SYSTEME 

ERP-Systeme (Enterprise Resource Planning) sind betriebliche Planungs- und 

Steuerungssysteme. Wichtige Bestandteile dieser industriellen, meist sehr 

umfangreichen, Softwaresysteme sind die Produktionsplanung und –steuerung, die 

bedarfs- und verbrauchsgesteuerte Materialdisposition, die Fakturierung, die 

Kundenbetreuung, die Buchhaltung und Projektplanung. Als führende Hersteller sind 

SAP, PeopleSoft, Baan, Oracle und Edwards zu nennen. [vgl. Schneider/Werner S. 726] 

Für unser Projekt sind die ERP-Systeme als Quelle für unsere Daten für das Data 

Warehouse anzusehen. Diese ERP-Systeme bestehen aber wiederum aus 

unterschiedlichen Datenbanken, wodurch eine einheitliche Datenschnittstelle über die 

Einführung von Übertragungsregeln der Datentransformationsprozesse festgelegt 

werden müssen [vgl. Seemann et al. (2001) S. 27]. 

- 46 -



5 DAS DATA WAREHOUSE 

5.1 DAS KONZEPT DES DATA WAREHOUSE 

Unternehmen sind heutzutage prozess- oder transaktionsorientiert. Durch viele 

Standardsoftwareanbieter werden Geschäftsprozesse durch das Erfassen von 

Transaktionen abgebildet und erfasst. In Management- und Informationssystemen, die 

der Entscheidungsunterstützung und Entscheidungsfindung dienen, benötigt man jedoch 

detaillierte Daten, die es erlauben, die Informationen vieler Geschäftsprozesse als 

Ganzes zu analysieren. Diese, zumeist aggregierten, Daten erlauben erst aus der Fülle 

der Transaktionsdaten Informationen zu gewinnen. Diese Informationen sind höchst 

wertvoll für die Entscheidungsträger eines Unternehmens, da erst diese Informationen 

eine fundierte strategische oder taktische Entscheidung ermöglichen. Data Warehousing 

hat darüber hinaus die Aufgabe, aus Daten nicht nur Informationen abzuleiten, sondern 

diese Informationen in Wissen weiterzuentwickeln und dann in Aktionen zu wandeln. 

Mit einem Data Warehouse werden also Unternehmensprozesse (Geschäftsprozesse) 

kontrolliert und gesteuert. Somit stellt der Data Warehouse Ansatz den Übergang vom 

reinen Datenmanagement hin zur höheren Entwicklungsstufe des 

Informationsmanagements dar. [vgl. Martin (1998) S. 11 ff] 

„Ein Data Warehouse ist ein umfassendes Konzept zur Entscheidungsunterstützung von 

Mitarbeitern aller Bereiche und Ebenen“ [vgl. Stock (2000) S. 51]. 

Somit hat ein Data Warehouse folgende Merkmale: 

• Orientierung an den unternehmensbestimmenden Sachverhalten 

(subjektorientiert): 

Typische Subjekte der Betrachtung sind z.B. Kunden, Produkte, Lieferanten. 

Man fokussiert inhaltliche Kernbereiche der Organisation. 

• Zeitraumbezug (zeitabhängig): 

Es werden Daten benötigt, welche die Entwicklung eines Unternehmens über 

einen bestimmten Zeitraum repräsentieren und damit zum Erkennen von Trends 

herangezogen werden können. Dies geschieht meist durch Einbindung des 

betrachteten Zeitraumes in die entsprechenden Schlüssel der Daten. 

• Struktur- und Formatvereinheitlichung (integriert und vereinheitlicht): 

Dieses Merkmal wird erfüllt durch einheitliche Konventionen (bezüglich 

Namensgebung, Dateiattributen, etc.), einheitliche Datenformate (z.B. 

Werteinheiten) und semantischer Integrität (z.B. Angleichen unterschiedlicher 

Kontenrahmen, Währungsumrechnungen, etc.). Ziel ist eine konsistente 

Datenmenge im Data Warehouse. 

- 47 -



• Nicht-Volatilität – nur lesender Zugriff (beständig bzw. dauerhaft): 

Dauerhafte Speicherung über größere Zeiträume. Die wichtigsten Operationen 

sind das Downloaden und die Datenabfrage. 

„Derartige Data Warehouse Systeme sind heute nicht als fertiges Produkt verfügbar, 

sondern unternehmensindividuell zu konzipieren und zu realisieren, weshalb es 

angebracht erscheint, eher von einem Data Warehouse Konzept als von einem Data 

Warehouse System zu sprechen“ [vgl. Gabriel/Röhrs (2003) S. 340]. Für eine analoge 

Definition der Merkmale des Datawarehouse und auch für zusätzliche Ausführung 

verweise ich auf Kemper (1999) S. 458ff, Mertens (2000) S. 20, Schneider/Werner 

(2000) S. 526 oder Shaw (2000), S. 502ff. 

5.2 ARCHITEKTUR EINES DATAWAREHOUSE 

In diesem Abschnitt will ich einen Überblick über die Architektur und die wesentlichen 

Komponenten in einem Data Warehouse geben. Dazu wurde eine typische Architektur 

im Data Warehouse in Abbildung 15 graphisch dargestellt. 

- 48 -



5.2.1 OPERATIVE DATEN 

Abbildung 15: Die Architektur eine Data Warehouse 

[Quelle: in Anlehnung an Posser/Ossimitz (2001) S. 26] 

Das Datawarehouse wird durch eine Reihe von unterschiedlichen operativen 

Datenquellen gespeist. Diese individuellen Datenbanken können auf unterschiedlichen 

Systemen in unterschiedlichen Formaten vorliegen. 

- 49 -



5.2.2 EXTERNE DATENBANKEN 

Dies können Datenbanken von externen Anbieter oder frei zugängliche Datenquellen 

sein, welche in das Datawarehouse integriert werden. 

5.2.3 DIE METADATEN 

Meta-Daten enthalten die Aufzeichnungen darüber, wie die operativen Daten aufgebaut 

sind, wie die Daten im Data Warehouse aufgebaut sind und wie externe Quellen in das 

Data Warehouse integriert werden. Meta-Daten sind Datenbanken, die ein Bestandteil 

des Data Warehouse sind. Sie sind vor allem für die Datenbankadministratoren des 

Data Warehouse von Bedeutung. 

5.2.4 DIE DATENPUMPEN 

Datenpumpen (Transaktionsprogramme, Lademanager, Frontend-Komponente) führt 

alle mit dem Extrahieren und Laden der Daten in das Data Warehouse verbundenen 

Tätigkeiten aus. Dazu gehören einfache Umwandlungen der Daten, um diese für die 

Eingabe in das Warehouse vorzubereiten. 

5.2.5 DER DATAWAREHOUSE MANAGER 

Der Data Warehouse Manager führt alle mit der Verwaltung der Daten im Warehouse 

verbundenen Tätigkeiten aus. Dabei ist diese Software insbesondere für folgende 

Tätigkeiten zuständig: 

• Analyse der Daten, um die Konsistenz zu gewährleisten 

• Umformen und Zusammenführen von Quelldaten aus der temporären 

Speicherung in Data Warehouse Tabellen 

• Erstellen von Indizes und Ansichten der Basistabellen 

• Denormalisierung (falls erforderlich) 

• Aggregatbildung (falls erforderlich) 

• Anlegen von Sicherheitskopien und Archivieren der Daten 

[vgl. Connolly et al. (2002) S. 915] 

5.2.6 ZUGRIFFSWERKZEUGE FÜR DEN ENDBENUTZER 

Der vorrangige Zweck eines Data Warehouse besteht darin, den Benutzern Information 

zu liefern, damit sie fundierte Entscheidungen fällen können. Diese Endbenutzer 

- 50 -



müssen über Zugriffswerkzeuge mit dem Data Warehouse interagieren können, um die 

ad hoc und Routineanalysen effizient zu unterstützen. Anschließend sind diese in fünf 

Gruppen eingeteilt, wobei zu bemerken ist, dass es in der Praxis sehr oft zu 

Überschneidungen zwischen den Gruppen kommt. [vgl. Connolly et al. S. 916ff] 

5.2.6.1 WERKZEUGE FÜR BERICHTE UND ABFRAGEN 

Die wichtigsten Werkzeuge für den Benutzer sind diejenigen, die ihm die Informationen 

liefern. Es erfolgt die Eingabe einer Benutzeranforderung und eine entsprechende 

graphische oder textorientierte Präsentation der Ergebnisse. Üblicherweise werden von 

den Anwendungen im Hintergrund SQL-Statements generiert, welche die Informationen 

aus dem Data Warehouse abfragen. Zusätzlich ist jedoch zu bemerken, dass diese 

Werkzeuge ihre Datenbasis nicht nur aus dem Data Warehouse erhalten, sondern zum 

Teil auch Daten aus den operativen Systemen direkt in die Präsentation einbeziehen. 

5.2.6.2 WERKZEUGE ZUR ENTWICKLUNG VON ANWENDUNGEN 

Da leider sehr oft Standardanwendungsprogramme für individuelle 

Benutzeranforderungen ungeeignet sind, gibt es Werkzeuge die Benutzern mit 

ausreichender Fachkenntnis erlauben hauseigene Abfrage- und Präsentationstools zu 

entwickeln. 

5.2.6.3 EXECUTIVE INFORMATION SYSTEM WERKZEUGE (EIS) 

Executive Information Systems sind ursprünglich zur Unterstützung strategischer 

Entscheidungsfindung auf höchster Ebene entwickelt worden. Sie haben jedoch ihren 

Schwerpunkt erweitert und unterstützen jetzt alle Verwaltungsebenen. EIS-Werkzeuge 

standen ursprünglich mit Großrechnern in Zusammenhang, die Benutzer in die Lage 

versetzten, individualisierte graphische Entscheidungsunterstützungswerkzeuge zu 

erstellen, die einen Überblick über die Organisationsdaten und Zugriff auf externe 

Datenquellen bereitstellen sollten. 

Auf dem heutigen Markt ist die Abgrenzung zwischen EIS-Werkzeugen und anderen 

entscheidungsunterstützenden Werkzeugen noch weniger klar, weil EIS-Entwickler 

zusätzliche Abfragefähigkeiten einbauen und Anwendungen für Geschäftsbereiche wie 

Vertrieb, Marketing und Finanzen liefern. Beispiele für EIS-Werkzeuge sind Lightship 

von Pilot Software Inc., Forest and Trees von Platinum Technologies und Express 

Analyser von Oracle. 

- 51 -



5.2.6.4 DECISION SUPPORT SYSTEME (DSS) 

Ein DSS ist ein System, welches für die taktische und strategische 

Entscheidungsunterstützung zur Verfügung gestellt wird. Techniken wie Sensibilitätsoder 

What If Analysen stehen im Vordergrund solcher Anwendungen. Je nach 

speziellem Anwendungsgebiet (Liquitätsmanagement, Portfoliomanagement, 

Bonitätsprüfung, etc.) werden wieder unterschiedliche Anwendungssysteme entwickelt. 

[vgl. Dippold et al. S. 189] 

5.2.6.5 ONLINE ANALYTICAL PROCESSING WERKZEUGE (OLAP) 

Online Analytical Processing Werkzeuge basieren auf den Konzepten 

mehrdimensionaler Datenbanken und erlauben dem erfahrenen Benutzer, die Daten mit 

Hilfe komplexer mehrdimensionaler Ansichten zu analysieren. Der Begriff OLAP 

wurde von Codd im Jahre 1993 geprägt; er bezeichnete eine Architektur, die komplexe 

analytische Anwendungen unterstützt. OLAP Architekturen werden heute mit Hilfe 

spezialisierter mehrdimensionaler Datenbanktechnologie, einer eng begrenzten 

Datenmenge und einer individuell angepassten Benutzerschnittstelle implementiert. 

5.2.6.6 DATA MINING WERKZEUGE 

Als Data Mining wird der Prozess bezeichnet, bei dem große Data Warehouses oder 

Data Marts durchforstet werden. Dabei wird mit statistischen und mathematischen 

Methoden, sowie Methoden der künstlichen Intelligenz operiert und versucht neue 

Korrelationen, Muster oder Trends zu entdecken. Data Mining besitzt das Potential, die 

Fähigkeiten der OLAP-Werkzeuge abzulösen, da seine Hauptanziehungskraft in der 

Fähigkeit liegt, anstelle retrospektiver Modelle vorhersehende Modelle zu erstellen. 

Dadurch versucht man durch Data Mining Werkzeuge den Gap zwischen dem reinen 

Generieren der Daten und dem Verstehen der selben zu schließen. Dieser Prozess kann 

automatisch oder semiautomatisch passieren und sollte einen ökonomischen Vorteil 

bringen. [vgl. Witten/Eibe (2000) S. 1ff] 

Data Mining Techniken können grundsätzlich in fünf verschiedene Klassen unterteilt 

werden: 

• Predictive Modeling: 

Man versucht festzustellen, ob einige Felder in der Datenbank auf anderen 

Feldern basieren. Dies wird durch Regressionsanalyse bei numerischen Werten 

und durch Klassifizierung bei kategorischen Werten versucht. 

• Clustering: 

Diese Methode wird auch gelegentlich als “Segmentation“ bezeichnet. Dazu 

- 52 -



wird eine Anzahl vom Clustern definiert und die Daten entsprechend 

eingeordnet. 

• Data summarization: 

Dabei wird versucht die Daten zu summieren, in Gruppen aufzuteilen und zu 

analysieren. Ein sehr treffendes Beispiel wäre die Konsumentenwarenkorb- 

Analyse, wo man zu erkennen versucht, welche Produkte gemeinsam mit 

welchen gekauft werden. 

• Dependency modelling: 

Man versucht funktionelle Zusammenhänge zwischen den Datenfelder 

festzustellen. 

• Change and deviation detection: 

Diese Methoden werden für sequenzielle Informationen, wie Zeitreihen oder 

genetische Pläne, verwendet. 

[vgl. Džeroski/Lavrač (2001) S. 34ff] 

5.3 OPERATIVE UND ANALYTISCHE DATEN 

In Datenbanksystemen unterscheidet man operative und analytische Datenbanken. 

Diese Unterscheidung ist besonders in dem Konnex Data Warehouse eine essentielle. 

Operative Datenbanksysteme sind Systeme, die den laufenden Geschäftsbetrieb 

(Transaktionsdaten) erfassen und verwalten. Diese werden auch als Online Transaction 

Processing (OLTP) Datenbanksysteme bezeichnet. Operative Daten sind 

unübersichtlich, weil sie eine Vielfalt von Details unterschiedlicher Anwendungen 

enthalten. In analytischen Datenbanksystemen werden umfangreiche Auszüge aus 

operativen Daten periodenweise erzeugt und entweder zusammengefasst (aggregiert) 

oder detailliert zur flexiblen Analyse bereitgestellt. Deshalb enthalten analytische 

Systeme im Gegensatz zu operativen Systemen auch historische Daten. [vgl. Lusti, 

Markus (1999), S. 123 ff] 

Eigenschaften Operative Daten Data Warehouse 

Prozess transaktionsintensiv abfrageintensiv 

Benutzer große Anzahl relativ geringe Anzahl 

Umfang meist nur aktuelle Daten 

- 53 - 

aktuelle und historische 

Daten 

Aktualisierung ständig aktualisiert sporadisch aktualisiert



Integration funktionell 

- 54 - 

subjektorientiert und 

verdichtet 

Datenqualität normal systemabhängig 

Datenbanksystem 

Datenmodel 

Anwendungsbereich 

Entwicklung 

Zuordnung 

Daten werden regelmäßig 

aktualisiert 

Daten sind normalisiert, 

Modellierung aufgrund der 

Transaktionen 

definiert durch den Bereich 

der operativen 

Transaktionsanwendung 

(statisch, detailliert) 

meist werden OLTP-Systeme 

eingesetzt 

eindeutige Prozesshierarchie 

der Benutzer zuordenbar 

intervallweise Aktualisierung 

der Daten 

Daten sind nicht normalisiert, 

Modellierung aufgrund der 

Dimensionen des Subjektes 

liefert ein flexibles, 

erweiterbares Entscheidungs- 

Unterstützungsinstrument 

(flexibel, aggregiert) 

Data Warehouse wird 

wiederholt erzeugt und 

entwickelt 

komplexe Benutzerhierarchie 

unterschiedlicher 

Entscheidungsebenen 

Verfügbarkeit Hohe Verfügbarkeit geringe Verfügbarkeit 

Identifikationskriterium eindimensional mehrdimensional 

Datenmanipulation 

zeilenbezogen / 

aktualisierend 

sichtspezifisch / analysierend 

Tabelle 3: Vergleich operative Daten und Data Warehouse [in Anlehnung: Connolly et al. (2002) S. 

910; Prosser, Ossimitz (2000 a), S. 11]



5.4 AUFBAUEN UND AKTUALISIEREN EINES DATAWAREHOUSE 

AUS DEN DATENQUELLEN 

5.4.1 KLASSISCHE VORGEHENSWEISE BEIM AUFBAUEN UND 

AKTUALISIEREN EINES DATAWAREHOUSE 

Der Aufbau eines Data Warehouse beginnt mit einer Auswahl der geeigneten Attribute 

aus den operativen Datenbanksystemen. Zusätzlich werden diese meist durch 

Informationen aus unternehmensexternen Quellen, z. B. Anbieter von 

Marktforschungsergebnissen, ergänzt. Sowohl externe, als auch interne Daten werden 

vor ihrer Integration in ein Data Warehouse transformiert. Dabei werden zuerst die 

Daten ohne Veränderungen direkt aus den operationalen und externen Datenquellen 

kopiert. In einem weiteren Schritt wird Irrelevantes weggelassen, Neues hinzugefügt 

und Bestehendes umgeordnet oder verdichtet. Die Daten liegen dann in einer so 

genannten Basisfaktentabelle (BFT) vor. Dieser Vorgang wird durch sogenannte 

Datenpumpen (siehe 5.2.4) durchgeführt. Das Durchsuchen einer Basisfaktentabelle mit 

vielen Einträgen kostet allerdings Zeit und kann auch nicht beliebig beschleunigt 

werden. Daher werden in einem Data Warehouse meist vorgefertigte Aggregate 

hinterlegt. Diese werden in wenig und stark zusammengefasste Daten unterteilt [vgl. 

Connolly et al. (2002) S. 915f]. Diese aggregierten, zusammengefassten Daten können mit 

dem Synonym des materialisierten View bezeichnet werden. 

Transformationen, die Aufnahme historischer und externer Daten, sowie die 

gleichzeitige Haltung von Detaildaten und Aggregaten führen dazu, dass analytische 

Datenbanken in der Regel größer werden als ihre operativen Quellen. Wie und in 

welcher Art und Weise die operativen Daten verändert, aggregiert oder umgeordnet 

werden, ist abhängig vom konzeptionellen Modell des Data Warehouse, welches sich 

wiederum aus den Benutzeranforderungen ergibt. 

5.4.2 NEUE ANSÄTZE FÜR DAS AUFBAUEN UND AKTUALISIEREN DER 

MATERIALISIERTEN SICHTEN 

Eine Datawarehouse enthält große Mengen an Information, welche aus 

unterschiedlichen Datenquellen stammt. Üblicherweise werden die Daten im 

Warehouse mit den Daten in den Datenquellen in regelmäßigen Intervallen aktualisiert 

und die neuen Aggregate erzeugt und gespeichert. Allerdings ist das Zeitfenster für das 

Aktualisieren beschränkt. Deshalb gibt es unterschiedlichste Ansätze dieses Problem zu 

lösen oder zu umgehen. 

- 55 -



5.4.2.1 DER WHIPS PROTOTYP 

Der Ansatz der WHIPS (Warehousing Information Project at Stanford), welcher an der 

Stanford University entwickelt wurde, geht von der in Abbildung 16 angeführten 

Struktur aus. Dabei werden als die Hauptkomponenten des Warehouse die „Data 

Querying & Analysis“ Komponente, verantwortlich für die Erfüllung der 

Informationsbedürfnisse der Benutzer und die „Data Integration“ Komponente, welche 

für die Datensammlung und die Erzeugung der materialisierten Sichten verantwortlich 

ist, angeführt. Diese zwei Komponenten können nicht unabhängig voneinander gesehen 

werden. So basiert die Auswahl der materialisierten Sichten, welche durch den Data 

Integrator materialisiert werden, auf den erwarteten Bedürfnissen der Benutzer. 

Abbildung 16: Die Basisarchitektur des WHIPS Systems [Quelle: Labio et al. (1997) S. 557] 

In Abbildung 17 wird die Data Integration Komponenten näher beleuchtet. Dabei wurde 

in Stanford jedes Modul als CORBA Objekt implementiert. Das relationale Modell 

wurde für das Warehouse verwendet. 

- 56 -



Abbildung 17: Die WHIPS System Architektur für Warehouse Maintenance [Quelle: Labio et at 

(1997) S. 558] 

Jede Quelle hat einen Wrapper und einen Monitor. Der Monitor hat die Aufgabe die 

Datenquelle zu überwachen und bei Änderungen in der Basisdatenquelle den Integrator 

darüber in Kenntnis zu setzen. In Stanford wurden triggerbasierende Monitore für die 

relationalen Datenquellen und Snapshot Monitore für andere Datenquellen, wo nur 

periodische Aktualisierungen möglich sind, eingesetzt. Der Wrapper hat die Aufgabe 

die Abfragen der unterschiedlichen Datenquellen zu übersetzen. Stellt also der Query 

Processor eine Anfrage an einen Wrapper, übersetzt er diese Query entsprechend der 

zugrunde liegenden Datenquelle. Die zentrale Rolle hat der Integrator inne. Er erhält die 

Änderungsmeldungen der Monitore, weiß welche Querys von den gemeldeten 

Datenquellen betroffen sind und benachrichtigt die entsprechenden View Manager die 

betroffenen materialisierten Sichten, bzw. Tupel im Data Warehouse zu aktualisieren. 

Die View Manager senden ihre Information an einen Wrapper, welcher die Daten in das 

Format der Data Warehouse Tabellen wandelt und speichert. [vgl. Labio et al. (1997) S. 

557ff] 

- 57 -



5.4.2.2 DER SUMMARY TABLE ANSATZ 

Materialisierte Sichten in einem Data Warehouse können grundsätzlich auf zwei Arten 

aktualisiert werden. Entweder man erzeugt den materialisierten View komplett neu oder 

man arbeitet die Änderungen seit dem letzten Updatevorgang ein. Mumick et al. (1997) 

unterteilen dazu den Updatevorgang in einen Propagate Vorgang und einen Refresh 

Vorgang. 

Beim Propagate Vorgang werden so genannte Summary-Delta Tables erzeugt. Diese 

Tables enthalten alle Änderungen, welche sich seit dem letzten Updatevorgang ergeben 

haben. Man unterscheidet zwei Tables: 

• Den Pos_ins Table, welcher die neuen, bzw. veränderten Tupel des BFT enthält 

und 

• den Pos_del Table, welcher alle gelöschten Tupel enthält, welche aus dem BFT 

entfernt werden müssen. 

Beim Refresh Vorgang werden nun diese Änderungen der Delta-Summary Tables in die 

eigentlichen materialisierten Views geschrieben. Der Vorteil dieser Methode ist, dass 

während des Propagate Vorganges das Datawarehouse uneingeschränkt zur Verfügung 

steht, da die Abfragetabellen nicht berührt werden. Erst beim Refresh Vorgang ist das 

Warehouse nicht verfügbar. Dadurch kann die Gesamtzeit der Nichtverfügbarkeit 

deutlich gesenkt werden. 

Die Delta-Summary Methode funktioniert aber bei verschiedenen Aggregaten 

unterschiedlich. Mumick et al. (1997) unterscheiden grundsätzlich drei Klassen von 

Aggregaten: 

• Distributive (SQL Funktionen COUNT, SUM, MIN und MAX) 

• Algebraic (SQL Funktion AVG) und 

• Holistic (Median, …) 

Ein Nachteil der Delta-Summary Methode ist die Tatsache, dass nur distributive 

Funktionen verarbeitet werden können. Holistische Funktionen können grundsätzlich 

nicht verarbeitet werden. Algebraische Funktionen können zum Teil simuliert werden 

indem z.B. der Mittelwert aus Summe durch Anzahl berechnet wird (SUM/COUNT). 

Auch die Funktionen MIN und MAX sind nur eingeschränkt einsetzbar. Sollte z.B. das 

aktuelle MIN oder MAX Tupel in der Menge der gelöschten Tupel sein, ist es nicht 

möglich das neue MIN oder MAX Tupel zu bestimmen ohne den gesamten Table neu 

zu erzeugen. Dies kann zwar durch einen Algorithmus automatisiert werden, vermindert 

- 58 -



jedoch den Zeitgewinn, welcher durch die Delta-Summary Methode erzielt werden 

könnte. 

prepare-insertions prepare-deletions 

COUNT(*) 1 -1 

case when expr is null then case when expr is null then 

COUNT(expr) 

0 else 1 

0 else -1 

SUM(expr) expr -expr 

MIN(expr) expr expr 

MAX(expr) expr expr 

Tabelle 4: Änderungen der Aggregate nach Funktionen [Quelle: Mumick et al. (1997) S.105] 

In Tabelle 4 sind die Änderungen der Aggregattabellen abhängig von den jeweiligen 

Funktionen aufgelistet. Wird z.B. der Wert 10 im Delta Summary Insert Table 

errechnet, wird dieser Wert zum materialisierten View addiert. Wird z.B. der Wert 10 

im Delta Summary Delete Table errechnet, wird dieser Wert vom materialisierten View 

subtrahiert. [vgl. Mumick et al. (1997) S.100ff] 

5.4.2.3 DER MULTIPLE VIEW MAINTENANCE POLICIES ANSATZ 

Dieser Ansatz berücksichtigt, dass die Quelldaten, aus welchen die Daten importiert 

werden, sehr unterschiedlich sein können. Durch diese unterschiedliche Behandlung der 

materialisierten Views soll ein Perfomancegewinn erzielt werden. Dabei werden die 

Views in drei unterschiedliche Klassen eingeteilt: 

• Immediate Views: Diese können ständig aktualisiert werden, sobald sich eine 

Quelldatenbank, bzw. ein Quelldatensatz ändert. 

• Deferred Views: Diese Views werden bei Anfrage des Users materialisiert. Das 

führt zu langsameren Abfragen, aber schnelleren Update Vorgängen. 

• Snapshot Views: Diese werden periodisch durch einen asynchronischen Prozess 

aktualisiert. Dadurch ist die Aktualität der Daten nicht garantiert. 

Diese unterschiedlichsten Views können wiederum in Viewgroups zusammengefasst 

werden. Diese Viewgroups von Colby et al. (1997) sind definiert dass 

• die Aktualisierung eines Views in einer Viewgroup keine Aktualisierungen 

in einer anderen Viewgroup auslöst 

- 59 -



• es möglich sein muss, eine Query abzufragen ohne einen Join mit einem 

Table außerhalb der Viewgroup zu machen. 

[vgl. Colby et al. (1997) S.405ff] 

5.5 INFORMATIONSFLÜSSE IN EINEM DATA WAREHOUSE 

Connoly et al. (2002) teilen die Informationsflüsse in einem Data Warehouse in fünf 

primäre Informationsflüsse: 

Prozess Beschreibung 

Inflow Extrahieren, Laden und Reinigen der Quelldaten 

Upflow 

Erhöhen des Wertes der Daten im Warehouse durch 

Zusammenfassen, Verpacken und Verteilung 

Downflow Archivieren und Sichern der Daten im Warehouse 

Outflow Die Daten für Endbenutzer verfügbar machen 

Metaflow Verwalten der Metadaten 

Tabelle 5: Informationsflüsse im Data Warehouse [Quelle: Connolly et al. (2002) S. 918ff] 

5.5.1 INFLOW 

Der Inflow befasst sich damit, Daten aus den Quellsystemen zu übernehmen, die in das 

Data Warehouse geladen werden sollen. Da die Quelldaten überwiegend durch OLTP 

Systeme erzeugt werden, müssen sie für den Zweck des Data Warehouse neu aufgebaut 

werden. Dazu gehört Folgendes: 

• Reinigen der „verunreinigten“ Daten. 

• Neustrukturieren der Daten. Zum Beispiel durch Hinzufügen und/oder Löschen 

von Feldern und Denormalisierung. 

• Gewährleisten, dass die Quelldaten in sich und mit den bereits im Data 

Warehouse befindlichen Daten konsistent sind. 

Um den Inflow effizent zu verwalten, müssen Mechanismen festgelegt werden, um zu 

ermitteln, wann man mit dem Extrahieren der Daten beginnt, die erforderlichen 

Umwandlungen ausführt und Konsistenzprüfungen vornimmt. Beim Extrahieren der 

Daten aus dem Quellsystem muss man unbedingt dafür sorgen, dass sich die Daten in 

einem konsistenten Zustand befinden, um eine konsistente Ansicht der Firmendaten zu 

bekommen. Die Datenextraktionssoftware sollte vollständig automatisch funktionieren 

und in der Lage sein, das Auftreten von Problemen und Fehlern zu melden. 

- 60 -



5.5.2 UPFLOW 

Mit dem Upflow sind folgende Aktivitäten verknüpft: 

• Zusammenfassen der Daten durch Auswahl, Projezieren, Verknüpfen und 

Gruppieren relationaler Daten zu Ansichten, die für den Endbenutzer bequemer 

und hilfreicher sind. Das Zusammenfassen geht über einfache relationale 

Operationen hinaus - es umfasst ausgefeilte statistische Analysen einschließlich 

der Feststellung von Trends, der Clusterbildung und des Sampling. 

• Verpacken der Daten durch Konvertieren der zusammengefassten oder 

detaillierten Daten in sinnvollere Formen wie zum Beispiel Arbeitsblätter, 

Textdokumente, Diagramme oder Animationen. 

• Verteilung der Daten an geeignete Gruppen, um ihre Verfügbarkeit und 

Zugänglichkeit zu erhöhen. 

5.5.3 DOWNFLOW 

Die Archivierung alter Daten spielt bei der Aufrechterhaltung von Effizenz und 

Leistung des Data Warehouse durch Auslagern der älteren Daten eine wichtige Rolle. 

Der Informations-Downflow umfasst die Prozesse, welche sicherstellen, dass der 

aktuelle Zustand des Data Warehouse nach Datenverlust oder Soft- bzw. 

Hardwarefehlern wieder hergestellt werden kann. 

5.5.4 OUTFLOW 

Der Outflow ist die Stelle, an der die Organisation den wirklichen Wert des Data 

Warehouse wahrnimmt. Zum Outflow gehören folgende Schlüsselaktivitäten: 

• Das Zugreifen, das sich mit der Erfüllung der Anforderungen der Endbenutzer 

hinsichtlich der benötigten Daten befasst. 

• Das Übermitteln, das sich mit der aktiven Übermittlung der Information an die 

Rechner der Endbenutzer beschäftigt. Dies kann von periodischen Reports bis zu 

Veröffentlichungs- und Abonnementsprozessen reichen. 

5.5.5 METAFLOW 

Der Metaflow ist der Prozess, welcher Metadaten bewegt. Also Daten über die anderen 

Informationsflüsse. Um den sich ändernden Geschäftsbedürfnissen gerecht zu werden, 

ändern sich herkömmliche Systeme ständig. Der Metaflow muss sich deshalb 

fortlaufend mit diesen Änderungen befassen. 

- 61 -



5.6 PROBLEME IM DATA WAREHOUSE 

• Unterschätzen der Ressourcen für das Laden der Daten 

Viele Entwickler unterschätzen die für das Extrahieren, Reinigen und Laden 

der Daten in das Warehouse erforderliche Zeit, die bis zu 80% der 

Gesamtentwicklungszeit ausmachen kann, obwohl bessere Datenreinigungs- 

und Datenverwaltungswerkzeuge diese Zeit reduzieren könnten. 

• Unentdeckte Probleme mit Quellsystemen 

Unentdeckte Probleme im Zusammenhang mit den Quellsystemen, die das 

Data Warehouse speisen, werden irgendwann aufgedeckt, möglicherweise 

erst nach Jahren. Der Entwickler muss entscheiden, ob sie innerhalb des 

Data Warehouse und/oder in den Quellsystemen behoben werden sollen. 

Beim Eingeben der Einzelheiten können einige Felder beispielsweise eine 

NULL zulassen, was dazu führen kann, dass Mitarbeiter unvollständige 

Daten eingeben, obwohl diese verfügbar und geeignet sind. 

• Fehlende Aufzeichnungen der erforderlichen Daten 

Warehouse-Projekte zeigen häufig Bedarf für Daten, die in den bestehenden 

Quellsystemen nicht aufgezeichnet wurden. Die Organisation muss 

entscheiden, ob die operativen Systeme geändert werden oder ein System für 

die Aufzeichnung der fehlenden Information erstellt werden soll. 

• Gestiegener Bedarf für Endbenutzer 

Nachdem die Endbenutzer Abfrage- und Berichtswerkzeuge bekommen 

haben, kann die Anforderung von Unterstützung durch die für Dienste 

zuständigen Mitarbeiter steigen statt sinken. Das liegt am wachsenden 

Wissen der Benutzer über die Fähigkeiten und den Wert des Data 

Warehouse. 

• Datenhomogenisierung 

Data Warehousing in großen Umfang kann enorme Anforderung in Bezug 

auf die Datenhomogenisierung haben. Insbesondere ist darauf zu achten die 

Daten durch die Homogenisierung nicht zu verfälschen. 

• Hoher Ressourcenbedarf 

Das Data Warehouse kann viel Speicherplatz auf der Festplatte belegen. 

• Datenbesitz 

Sensible Daten sollten auch nach der Implementierung eines Data 

Warehouse nur gewissen Benutzern zugänglich sein. 

- 62 -



• Hoher Pflegeaufwand 

Data Warehouses sind Systeme mit hohem Pflegeaufwand, die oft in 

Kostenkalkulationen einen erheblichen Posten einnehmen können. 

• Projekte mit langer Dauer 

Der Aufbau eines Warehouse kann bis zu drei Jahre dauern. Dies wird oft 

unterschätzt und verursacht Komplikationen. 

• Komplexität der Integration 

Komplexe Unternehmensstrukturen führen zu komplexen Data Warehouse 

Systemen. Das stellt Entwickler oft vor unübersichtliche und nahezu 

unlösbare Fragestellungen. 

[vgl. Connolly et al. S. 912f] 

5.7 VORTEILE EINES DATAWAREHOUSE 

Als Vorteile eines effizienten und effektiven Informationsmanagements durch ein 

Datawarehouse lassen sich nach Fritz (1997) folgende Punkte herausstellen: 

• Reduzierung der Kosten für Entscheidungsprozesse: 

Durch Automatisierung der Datenbeschaffung und Datenkonsolidierung lassen 

sich redundante Informationsbeschaffung und langwierige Diskussionen über 

inkonsistente oder inkompatible Daten vermeiden. Gleichzeitig genügt es, den 

Mitarbeitern eine einzige Quelle für die Generierung von 

Managementinformationen zur Verfügung zu stellen. 

• Verbesserung der Qualität der Information: 

Durch die zentrale Speicherung von Daten aus unterschiedlichsten internen und 

externen Quellen wird es möglich, umfangreiche Analysen durchzuführen. 

Bisher nicht bekannte Zusammenhänge werden durch eine Integration der Data 

Mining Verfahren aufgedeckt. 

• Flexibilität der Informationsgewinnung: 

Neue Führungsinformationssysteme, die Data Warehouse- und Data Mining- 

Konzepte verbinden, können den Bedarf an Führungsinformationen besser 

befriedigen, denn sie sind auf die interaktive Informationsgewinnung ausgelegt 

und erleichtern die Interpretation der Daten. Im Gegensatz zu vorgefertigten 

Reports, wie sie von klassischen Management-Informationssystemen generiert 

wurden, bieten sie anwenderfreundliche, interaktive Analysemöglichkeiten. 

[vgl. Fritz (1997) S. 2] 

- 63 -



5.8 ANFORDERUNGEN AN EIN DATENBANKSYSTEM FÜR EIN 

DATAWAREHOUSE 

Die speziellen Anforderungen an ein für Data Warehousing geeignetes relationales 

Datenbanksystem sind nach Connolly et al. (2002): 

• Ladeleistung: 

Data Warehouses erfordern das regelmäßige inkrementelle Laden neuer Daten in 

engen Zeitfenstern. Die Leistung des Ladeprozesses sollte in hundert Millionen 

Zeilen oder in Gigabyte pro Sekunde gemessen werden, und das Geschäft sollte 

nicht durch eine Obergrenze eingeschränkt werden. 

• Ladeverarbeitung: 

Zum Laden neuer oder aktualisierter Daten in das Data Warehouse sind viele 

Schritte erforderlich: Datenkonvertierung, Filterung, Neuformatierung, 

Integritätsprüfung, physische Speicherung, Indizierung und Aktualisierung der 

Metadaten. Obwohl jeder Schritt in der Praxis atomar sein mag, sollte der 

Ladeprozess als geschlossene, nahtlose Arbeitseinheit erscheinen. 

• Sicherung der Datenqualität: 

Die Verlagerung auf faktenbasierte Verwaltung verlangt höchste Datenqualität. 

Das Warehouse muss trotz „unsauberer“ Quellen und gewaltiger 

Datenbankgrößen lokale und globale Konsistenz sowie referenzielle Integrität 

gewährleisten. Laden und Vorbereiten sind zwar notwendige Schritte, reichen 

aber nicht aus. Die Fähigkeit, die Abfragen der Endbenutzer zu beantworten, 

bildet den Erfolgsmaßstab einer Data Warehouse Anwendung. Mit der 

Beantwortung einer größeren Menge von Fragen neigen die Analysten dazu, 

kreative und komplexere Fragen zu stellen. 

• Abfrageleistung: 

Faktenbasierte Verwaltung und Ad-hoc-Analyse dürfen durch die Leistung des 

relationalen Data Warehouse Datenbanksystems weder gebremst noch 

verhindert werden. Umfangreiche, komplexe Abfragen für geschäftliche 

Schlüsseloperationen müssen in einem vernünftigen Zeitraum abgeschlossen 

werden. 

• Terabyte-Skalierbarkeit: 

Die Größe von Data Warehouse steigt enorm; sie beginnt bei wenigen oder 

mehreren hundert Gigabyte und erreicht mehrere Terabyte (10 12 Byte) oder 

Perabyte (10 15 Byte). Das relationale Datenbanksystem darf keine 

architekturbedingten Einschränkungen der Datenbankgröße aufweisen und sollte 

modulare und parallele Verwaltung unterstützen. Falls ein Fehler auftritt, sollte 

- 64 -



es fortlaufende Verfügbarkeit gewährleisten und Mechanismen für die 

Wiederherstellung bieten. Es muss Massenspeichergeräte wie optische Platten 

und Geräte zur hierarchischen Speicherverwaltung unterstützen. Die 

Abfrageleistung sollte schließlich nicht von der Größe der Datenbank, sondern 

von der Komplexität der Abfrage abhängen. 

• Benutzermengen-Skalierbarkeit: 

Das derzeitige Denken geht dahin, dass der Zugriff auf ein Data Warehouse auf 

relativ wenige Benutzer aus der Geschäftsleitung beschränkt ist. Das wird 

angesichts der Erkenntnis des Nutzens von Data Warehouses wahrscheinlich 

nicht so bleiben. Es lässt sich vorhersehen, dass das relationale 

Datenbanksystem für das Data Warehouse in Zukunft in der Lage sein sollte, 

mehrere hundert oder sogar tausend Benutzer zu verkraften und gleichzeitig eine 

akzeptable Abfrageleistung beizubehalten. 

• Das vernetzte Data Warehouse: 

Data Warehouse-Systeme sollten zur Zusammenarbeit in einem 

umfangreicheren Data Warehouse-Netzwerk fähig sein. Das Data Warehouse 

muss Werkzeuge zur Koordination der Bewegung von Datenteilmengen 

zwischen den Warehouses besitzen. Die Benutzer sollten von einer einzelnen 

Client-Workstation aus Einblick in mehrere Data Warehouses haben und mit 

diesen arbeiten können. 

• Warehouse-Administration: 

Der sehr große Umfang und die zeitzyklische Natur des Data Warehouse 

verlangt einfache und flexible Administration. Das relationale Datenbanksystem 

muss Steuerelemente besitzen, um Ressourcengrenzen, eine 

Rückbelastungskontierung (zur Zuweisung von Kosten an die Benutzer) und das 

Setzen von Prioritäten für Abfragen (zur Erfüllung der Bedürfnisse 

unterschiedlicher Benutzerklassen und Aktivitäten) implementieren zu können. 

Außerdem muss es die Verfolgung der Arbeitsbelastung und die 

Feinabstimmung vorsehen, damit sich die Systemressourcen auf maximale 

Leistung und maximalen Durchsatz optimieren lassen. Der am deutlichsten 

sicht- und messbare Wert für die Implementierung eines Data Warehouse zeigt 

sich im unbehinderten, kreativen Zugriff auf die Daten. 

• Integrierte dimensionale Analyse: 

Die Leistungsfähigkeit mehrdimensionaler Ansichten ist weithin akzeptiert, und 

um die höchstmögliche Leistung für relationale OLAP-Werkzeuge 

bereitzustellen, muss im relationalen Datenbanksystem des Warehouse 

dimensionale Unterstützung gegeben sein. Das Datenbanksystem muss das 

- 65 -



schnelle und einfache Erstellen im voraus berechneter Zusammenfassungen 

unterstützen, die in umfangreichen Data Warehouses üblich sind und 

Pflegewerkzeuge zur Automatisierung der Erstellung dieser Aggregatwerte 

bereitstellen. Die dynamische Berechnung von Aggregatwerten sollte mit den 

interaktiven Leistungsbedürfnissen des Endbenutzers übereinstimmen. 

• Erweiterte Abfragefunktionalität: 

Die Endbenutzer verlangen erweiterte analytische Berechnungen, sequenzielle 

und vergleichende Analysen und konsistenten Zugriff auf detaillierte und 

zusammengefasste Daten. Die Verwendung von SQL kann in einer 

Client/Server-Umgebung mit „Zeig-und-klick“-Werkzeugen wegen der 

Komplexität der Benutzerabfragen manchmal unpraktisch oder sogar unmöglich 

sein. Das relationale Datenbanksystem muss einen vollständigen und erweiterten 

Satz analytischer Operationen zur Verfügung stellen. 


5.9 DATA MARTS 

Zeitgleich mit dem Aufkommen der Data Warehouses entstand auch das verwandte 

Konzept der Data Marts. Ein Data Mart ist eine Teilmenge eines Data Warehouses, 

welche die Bedürfnisse einer bestimmten Abteilung oder Geschäftsfunktion erfüllt. Ein 

Data Mart enthält diese Teilmenge der Daten normalerweise in Form von 

zusammengefassten Informationen über eine bestimmte Abteilung oder 

Geschäftsfunktion. Der Data Mart kann selbständig oder zentral mit dem Data 

Warehouse verknüpft sein. 

Data Warehouses und Data Marts unterscheiden sich durch folgende Merkmale: 

• Ein Data Mart konzentriert sich ausschließlich auf die Bedürfnisse von 

Benutzern, die mit einer Abteilung oder Geschäftsfunktion zu tun haben. 

• Data Marts enthalten normalerweise im Unterschied zu Data Warehouses keine 

detaillierten operativen Daten. 

• Da Data Marts im Vergleich mit Data Warehouses weniger Information 

enthalten, sind sie einfacher zu verstehen, und man kann sich in ihnen leichter 

bewegen. 


- 66 -



5.10 DIE MODELLIERUNG EINES DATAWAREHOUSE 

5.10.1 MODELLTHEORIE 

Bei der Modellierung wird aus einem Problembereich, dem Original, durch Abbilden, 

Verkürzen und Vereinfachen mit einer gegebenen Pragmatik ein Modell gebildet. Man 

unterscheidet isomorphe (ohne Informationsverlust) und homomorphe (mit 

Informationsverlust) Abbildung von realen Systemen. 

Das Metamodell ist kein Modell eines Modells, sondern ein Modell eines 

Modellbereichs, d.h. einer Menge gleichartiger, nach der gleichen Technik erstellter 

Modelle. [vgl. Kaiser (2000)] 

Abbildung 18: Das Modellsystem [Quelle: Kaiser (2000)] 

Man unterscheidet drei Phasen der Modellierung: 

• Konzeptionelles Modell: z.B. Entity Relationsmodell, Dimensional Fact (DF) 

Modell 

• Umsetzung in ein logisches Modell: z.B. relationales Modell , Star Schema 

• Physischer Entwurf: Implementierung des konkreten Modells 

In jeder Phase der Modellierung stehen den Entwicklern unterschiedlichste Werkzeuge 

zur Verfügung. 

- 67 -



5.10.2 ATTRIBUTE 

Abbildung 19: Phasen der Modellierung [Quelle: Kaiser (2000)] 

Attribute stellen die Grundeinheiten für die Analyse dar. Attribute entsprechen in einer 

relationalen Datenbank den Spalten. Typische Attribute eines Kunden wären z.B. 

Kundennummer, Anrede, Name, Adresse, usw. In einem Data Warehouse unterscheidet 

man 3 Typen von Attributen: 

• Hierarchiestufen: Identifizieren ein Aggregationslevel (z.B. Kundengruppe, 

Region, Staat, usw.). 

• Schlüsselfelder, Indikator, „Fact-Attribute“: Sind Attribute, die aggregiert 

werden können (z.B. Umsatz, Stück, Liter, Kilogramm, usw.). 

• Nicht-aggregierbare Attribute: Sind Attribute, die zusätzliche Informationen 

geben (z.B. Name des Kunden, Adresse des Kunden, usw.). 

5.10.3 DIMENSIONEN UND HIERARCHIEN 

Die Dimension bestimmt die Granularität der . Sie ist ein meist symbolisches und 

diskretes Attribut, das die Auswahl, Zusammenfassung und Navigation eines 

Schlüsselfeldes erlaubt. Jede Dimension hat mindestens eine Hierarchiestufe. Man 

spricht von der Skalierbarkeit der Dimensionen (z.B. Tag, Monat, Jahr). Zu jeder 

Hierarchiestufe existiert eine konkrete Ausprägung (z.B. Staat, Land, Bezirk, Ort, 

- 68 -



Strasse) und damit kann man für jede Hierarchiestufe eine Aggregation der Facts 

vornehmen (z.B. Umsatz pro Bezirk, Umsatz pro Ort, usw.). 

Abbildung 20: Einfache Hierarchie am Beispiel eines Kunden 

Die Zeit ist eine Dimension, die immer in jedem Data Warehousesystem vorkommt. 

Systeme mit mehr als zwei Dimensionen nennt man multidimensionale Systeme. 

Dimensionen und Hierarchien können relativ übersichtlich allgemein formal in der 

Notation d dargestellt werden. Wobei y im Intervall 0 → ∞ liegt und die Dimension 

x 

y 

repräsentiert. Die Variable x im Intervall 0 → ∞ gibt die Hierarchiestufe wieder. So 

stellt z.B. das Element 

5.10.4 DIE DATENWÜRFEL 

2 

d 3 die 3 Hierarchiestufe der Dimension 4 dar. 

Bei der Kombination von zwei Dimensionen entsteht eine klassische Tabelle, wie sie 

von dem relationalen Datenmodell her bekannt ist. Durch das Hinzufügen einer dritten 

Dimension entsteht ein dreidimensionaler Raum, der typischerweise in der Form eines 

Würfels (cube) modelliert wird. Jede Kante des Würfels bildet eine Dimension ab (siehe 

Abbildung 21) und ist durch deren Elemente in ihrer Länge fest skaliert. Wenn mehr als 

3 Dimensionen verwendet werden, spricht man auch von einem Hyper-Würfel 

(hypercube). Dabei ist zwar das geometrische Vorstellungsvermögen erschöpft, 

gedanklich aber sind mehr als dreidimensionale Kombinationen problemlos 

nachzuvollziehen, wenn die darin enthaltenen Dimensionen den realen Datenstrukturen 

entsprechen. Mathematisch kann ein Würfel mit n Dimensionen auch als Vektor (v) mit 

n Elementen aufgefasst werden, wobei jedes Element des Vektors einer Hierarchiestufe 

einer Dimension entspricht. 

- 69 -



Abbildung 21: Darstellung eines Würfels (cube) mit den Dimensionen Zeit, Artikel und Kunden [ in 

Anlehnung: Prosser/Ossimitz (2000), S. 18] 

5.10.5 OPERATOREN 

Würfel entstehen durch die Kombination von Dimensionen und deren Ausprägungen 

(Hierarchiestufen). Mögliche Inhalte ergeben sich aus dem Kartesischen Produkt der 

Hierarchiestufen . Bei z.B. 1000 Kunden und 5 Jahren über alle Artikel (Würfel X) 

erhält man 5000 mögliche Einträge für diesen Würfel. Diese Einträge enthalten die 

aggregierten Werte der Schlüsselfelder oder Facts (z.B. Summe Umsatz/Kunden und 

Jahr für alle Artikel). Es gibt aber neben der Summe noch eine Reihe andere 

Operatoren, die in Tabelle 6 kurz darstellt sind. 

Operator Nominal Ordinal Interval Rational 

Sum NO NO NO YES 

Average NO (YES) YES YES 

Minimum NO YES YES YES 

Maximum NO YES YES YES 

Tabelle 6: Operatoren und Zahlentypen [in Anlehnung: Prosser, Ossimitz (2000 a), S. 20] 

Nominale Kennzahlen sind durch Zahlen dargestellte Codewerte, wie etwa das 

Geschlecht oder klassische True-or-False-Aussagen (0 für männlich, 1 für weiblich). 

Diese Kennzahlen können nicht aggregiert werden und sind für Key Figures ungeeignet. 

- 70 -



Ordinale Zahlentypen sind klassischerweise Ratings, wie etwa ein Schulnotensystem 

oder die Bewertung von Meinungsforschungsumfragen. Durch die ordinalen 

Kennzahlen wird nur eine Reihenfolge ausgedrückt, es wird jedoch keine Aussage über 

die Differenz zwischen den Werten gegeben. Deshalb kann normalerweise kein 

Mittelwert gebildet werden, obwohl das beim Schulnotensystem mit einer Kombination 

der Schulnoten mit einem gewissen Prozentsatz an richtigen Antworten zum Teil 

möglich ist. Intervallkennzahlen und Rationalkennzahlen sind beide metrisch. Der 

Unterschied liegt darin, dass Intervallkennzahlen einen Nullpunkt besitzen. Als 

bekanntestes Beispiel ist hier die Temperatur zu nennen. [vgl. Prosser/Ossimitz (2003) S. 32] 

5.10.6 SLICE AND DICE 

OLAP-Systeme bieten Anwendern individuelle und flexible Sichten auf „ihre“, für sie, 

interessanten Daten. Dies wird durch Isolieren einzelner Schichten aus dem gesamten 

Datenpool vollzogen. Slice beschreibt dabei das „Schneiden“ eines bestimmten 

Ausschnitts (etwa einer Periode) aus der Zeitdimension, wodurch der betrachtete 

Datenwürfel neu determiniert wird. Zum anderen besteht die Möglichkeit, diesen 

Würfel von verschiedenen Seiten zu betrachten. So erhält der Anwender durch 

„Drehen“, „Kippen“ oder „Würfeln“ (Dice) jeweils eine neue Perspektive. Mit Slice 

und Dice werden die Anwender bei typischen Geschäftsfragen unterstützt. (z.B. Welche 

Kunden im Burgenland haben einen Umsatz über 100 000 ?). [vgl. Schinzer et al. (1997), S. 

40 ] 

Abbildung 22: Selektion der Daten durch das Slice-Verfahren [Quelle: Schinzer et al. (1997), S. 40] 

- 71 -



Die Abbildung 22 stellt deutlich die verschiedenen Möglichkeiten des Slice Verfahrens 

dar. Man sieht, dass unterschiedliche Anwender unterschiedliche Sichtweisen auf das 

Datenmodell benötigen. 

5.10.7 NAVIGATION DURCH DEN DATENBESTAND 

Beim Navigieren durch den Datenbestand unterscheidet man wie in Abbildung 23 

angeführt folgende Möglichkeiten: 

• Drill Down: Die Möglichkeit von hoch aggregierten Kennzahlen auf niedrigere 

Aggregationsstufen zu wechseln, um so zusätzliche Detailinformationen zu 

erhalten. 

• Roll up: Die Möglichkeit Kennzahlen niedriger Aggregationsstufe weiter zu 

aggregieren. 

• Drill Across (Drill Through): Die Möglichkeit bei einem beliebigen Schnitt 

durch den Datenwürfel auch die benachbarten Dimensionselemente (z.B. andere 

Region, anderer Kunden, anderes Produkt) zu betrachten. 

Abbildung 23: Die Navigation durch die Navigationsebenen [in Anlehnung: Prosser, Ossimitz (2000 

a), S. 24 ] 

- 72 -



5.10.8 KONZEPTIONELLE ODER SEMANTISCHE MODELLIERUNG 

5.10.8.1 GRAPHISCHE MODELLIERUNG 

Es gibt nicht viele Methoden ein Data Warehouse zu modellieren. Als eine der 

wichtigsten wird hier das Dimensional Fact (DF) Modell von Golfarelli, Maio und Rizzi 

genannt [vgl. Golfarelli et al. (1998)]. Dieses Modell besteht aus baumartigen „Fact- 

Schemas“, die aus Schlüsselfeldern, Dimensionen und Hierarchien bestehen. 

Hierarchie 

Monat 

ZEIT 

Tag 

Artikeltyp 

Artikel 

Verkauf 

Verkaufte Menge 

Umsatz 

Schlüsselfelder 

- 73 - 

Größe 

Kunde 

Nicht-aggregierbare 

Attribute 

Adresse 

Gruppe 

Abbildung 24: Einfaches Modell eines dreidimensionalen „Fact-Schema“ [in Anlehnung: Prosser, 

Ossimitz, (2000 a), S. 29] 

Die Modellierung mit dem „Fact-Schema“ beginnt mit der Auswahl der Facts 

(Schlüsselfelder, Kennzahlen), die für die Betrachtung interessant erscheinen. Danach 

wird für jedes Schlüsselfeld ein Attributbaum entwickelt (siehe Abbildung 25).



Abbildung 25: Attributsbaum vor Pruning und Grafting 

[in Anlehnung: Prosser, Ossimitz, (2000 a), S. 33] 

Dieser wird durch „Pruning“ und „Grafting“ vereinfacht. Der Zweck des „Pruning“ und 

„Grafting“ ist eine Vereinfachung des Modells. Beim „Pruning“ wird dabei ein 

kompletter Unterbaum vom Baum abgetrennt und aus der Betrachtung des „Fact- 

Schemas“ entfernt. Es ist natürlich dann auch unmöglich Daten dieses Unterbaumes zu 

aggregieren. Beim „Grafting“ werden nur einzelne Attribute, die uninteressante 

Information enthalten entfernt. In Abbildung 26 sehen sie wie durch „Grafting“ das 

Attribut „Rechnr“ entfernt wurde. Abschließend werden die Dimensionen, Hierarchien 

und „Fact-Attribute“ festgelegt. 

Abbildung 26: Attributsbaum nach Pruning und Grafting 

[in Anlehnung: Prosser, Ossimitz, (2000 a), S. 34] 

- 74 -



5.10.8.2 HALBGRAPHISCHE MODELLIERUNG 

5.10.8.2.1 GITTER 

Um eine systematische Planung der Datenwürfel durchführen zu können, benötigt man 

zuerst die Menge der möglichen Datenwürfel. Diese kann durch ein Gitter dargestellt 

werden. In Abbildung 27 sieht man ein Beispiel für ein Gitter mit 3 Dimensionen 

(Kunden, Artikel, Zeit). Die Dimensionen unterteilen sich in folgende Hierarchiestufen: 

• Kunden: Kunde individuell (K_id), Kundengruppe (K_gr), Kunden gesamt 

(K_*) 

• Artikel: Artikel individuell (A_id), Artikelgruppe (A_gr), Artikel gesamt (A_*) 

• Zeit: Tag (Z_t), Monat (Z_m), Jahr (Z_j), Zeit gesamt (Z_*) 

Abbildung 27: Gitter [in Anlehnung: Prosser, Ossimitz (2000 a), S. 40] 

Die Darstellung der Würfel in einem Gitter bringt viele Vorteile. Diese sind: 

• Jede Kombination der Hierarchiestufen der Dimensionen kann separat 

dargestellt werden 

• Man kann relativ leicht erkennen, welcher Würfel aus welchen Würfeln 

abgeleitet werden kann 

• Das Gitter zeigt alle Kombinationsmöglichkeiten 

• Das Gitter zeigt alle Kombinationsmöglichkeiten redundanzfrei. 

Der große Nachteil des Gitters ist jedoch, dass es relativ rasch mit steigender Anzahl der 

Dimensionen und Hierarchien zu komplex und unübersichtlich wird. [vgl. 

Prosser/Ossimitz (2001) S.55] 

- 75 -



Allgemein ergibt sich die Größe eines Gitterverbandes aus 

Anzahl(Knoten)=∏ kn.....Anzahl der Hierarchiestufen in Dimension n 

k n 

n 

Für weiterführende Literatur zum Gitter siehe Crawley/Dilworth (1973). 

5.10.8.2.2 AGGREGATION PATH ARRAY 

Da das Gitter nicht für die Darstellung sehr komplexer mehrdimensionaler Strukturen 

geeignet ist, liegt es auf der Hand, eine Methode zu nutzen, welche die Vorteile des 

Gitters mit einer einfachen übersichtlichen Darstellung von anderen 

Modellierungsmethoden kombiniert. Das Ergebnis ist die von Prosser und Ossimitz 

entwickelte Methode des APA (Aggregation Path Array). Dieser Methode wurde unten 

der Abschnitt 6 gewidmet und wird dort entsprechend erläutert. Deshalb soll sie hier nur 

der systematischen Einordnung willen angeführt werden. 

5.10.9 LOGISCHE UND PHYSIKALISCHE MODELLIERUNG 

5.10.9.1 STAR-SCHEMA 

Das Star-Schema ist eine der bekanntesten Modellierungstechniken für ein Data 

Warehouse. Es besteht aus zwei Arten von Tabellen, dem „Fact-Table“ und dem 

Dimension-Table. Der Name Star-Schema rührt daher, dass die Dimension-Tables 

sternförmig um das zentrale „Fact-Table“ (Basisfaktentabelle) angeordnet sind. (siehe 

Abbildung 28). Die Anzahl der Tabellen entspricht immer der Summe von 

Dimensionen und dem „Fact-Table“. 

- 76 -



Abbildung 28: Star-Schema mit „Fact-Table“ (gelb) und vier Dimension-Tables 

[In Anlehnung: Prosser, Ossimitz (2000 a), S. 51] 

Zentraler Dreh- und Angelpunkt des Star-Schemas ist das „Fact-Table“. Es erfasst jede 

Transaktion in einer eigenen Zeile, wodurch es zur größten Tabelle des Schemas wird. 

Ein Dimensionselement jeder Dimension und mehrere numerische Kennzahlen 

(measures) stellen die Spalten des „Fact-Table“ dar, wodurch eine Transaktion 

eindeutig definiert wird. Anhand des Dimensionselements ist eine Verbindung zum 

entsprechenden Dimension-Table gewährleistet, entsprechend einem Primärschlüssel. 

Dort sind die verschiedenen Aggregationsstufen definiert, über die die Transaktionen 

des „Fact-Table“ konsolidiert werden können. [vgl. Schnizer et al., (1997), S. 48 f] 

Es gibt jedoch auch Nachteile des Star-Schemas. Es führt zu einem großen und teuren 

Bedarf an Plattenspeicher, hervorgerufen durch die Mehrfachspeicherung von 

Informationen. Große Dimension-Tables wirken sich sehr nachteilig auf die 

Performance aus. Aus diesem Grund wurde auch das Snowflake-Schema entwickelt. 

- 77 -



Abbildung 29: Das klassische Star-Schema [In Anlehnung: Prosser/Ossimitz (2000a ) S. 51] 

5.10.9.2 FACT CONSTELLATION-SCHEMA 

Beim klassischen Star-Schema kommt es bei großen Datenmengen zu 

Performanceproblemen. Besonders der große Base Fact Table bereitet Schwierigkeiten, 

da auch alle Aggregate im Base Fact Table gespeichert werden. Deshalb wurde das Fact 

Constellation-Schema entwickelt, welches eine Abänderung des Star-Schemas darstellt. 

Dabei werden die aggregierten Daten und die nicht aggregierten Daten separat 

gespeichert. Deshalb unterscheidet man Aggregated Fact Tables (AFT) für die 

Aggregate und den Basic Fact Table für die atomaren Daten. 

Als Vorteile des Fact Constellation Schemas ist folgendes zu nennen: 

• Das Level Attribut wird nicht mehr benötigt. 

• Die Performance ist bedingt durch die separate Speicherung der Aggregate 

verbessert. 

Als Nachteile des Fact Constellation-Schemas ist zu nennen: 

• Mit der Anzahl der Dimensionen steigt auch die Anzahl der AFT rapide an. 

Dadurch wird das Model sehr komplex und schwerer aufzubauen und zu warten. 

- 78 -



• Die Abfragen über mehrere Aggregate und/oder atomare Daten erfordert 

komplexere Joins. 

Im Fact Constellation-Schema sind die Dimensionstabellen nach wie vor 

denormalisiert. Dies kann bei großen Dimensionstabellen, welche viele Hierarchien 

enthalten, auch zu Performanceproblemen führen. 

[vgl. Prosser/Ossimitz (2001) S. 73ff] 

Abbildung 30: Das Fact Constellation-Schema [Quelle: Prosser/Ossimitz (2001) S. 76] 

5.10.9.3 SNOWFLAKE-SCHEMA 

Beim Snowflake-Schema, das eine Erweiterung des Star-Schemas darstellt, wird 

zusätzlich zur Normalisierung des „Fact-Tables“, eine Normalisierung der Dimension- 

Tables vorgenommen. Die Dimensionsattribute werden nicht mehr wie beim Star 

Schema in einer einzigen Tabelle pro Dimension gehalten, sondern es gibt für jedes 

Dimensionsattribut eine eigene Tabelle. In den Dimension-Tables stehen nur noch die 

Attributsschlüssel (z.B. MonatID), die auf die dazugehörigen Attribut-Tables 

verweisen. 

- 79 -



Abbildung 31: Snowflake-Schema mit Attribut-Tables 

[in Anlehnung: Prosser, Ossimitz (2000a), S. 62] 

Die Vorteile des Snowflake-Schemas liegen in der reduzierten Anzahl der zu 

bearbeitenden Zeilen – mit der entsprechenden Auswirkung auf die Performance – und 

in der Einsparung der Plattenkapazität. Nachteile liegen in der komplexeren 

Datenstruktur. [vgl. Schnizer et al. (1997) S. 50 f] 

5.10.9.4 GALAXY-SCHEMA 

Beziehen sich mehrere unterschiedliche Fakten auf die gleiche Dimensionen, wobei 

zwei Dimensionen genau dann gleich sind, wenn ihre komplexen und Basisobjekttypen 

gleich sind, dann wird eine Dimension mit den entsprechenden Fakten verbunden, da 

Dimensionen nicht redundant implementiert werden. Das durch derartige Verbindungen 

entstandene Schema wird Galaxy-Schema genannt. Ein Galaxy-Schema repräsentiert 

aus Sicht der OLAP-Anwendung eine Multicube-Architektur. Eine Multicube- 

Architektur ist dadurch gekennzeichnet, dass verschiedene Hypercubes gemeinsame 

Dimensionen haben. Die Abbildung 32 zeigt die Zusammenhänge zwischen Galaxy- 

Schema und Mulitcube-Architektur.[vgl. Rautenstrauch/Schulze (2003) S. 332] 

- 80 -



Abbildung 32: Galaxy-Schema und Multitube-Architektur 

[Quelle: Rautenstrauch/Schulze (2003) S. 334] 

5.10.9.5 DAS UNIMU-SCHEMA 

Das Unimu- Schema (Uniformes Datenschema für multidimensionale Daten) wurde an 

der Universität Leipzig entwickelt. Dabei wurde dieses Schema beim praktischen 

Einsatz in einem Energieunternehmen entwickelt. Dabei wurde in folgenden Schritten 

vorgegangen: 

• Uniformierung der Datenstruktur für die analyseorientierte Zusammenfassung 

dimensionsbezogener, betriebswirtschaftlicher Kennzahlen in einer Tabelle. 

• Zerlegung der Datenstruktur in eine Fakttabelle sowie je eine Tabelle für die 

(uniforme) Zeitdimension und die (uniforme) Objektdimension unter Nutzung 

des Star-Schemas. 

• Bildung einer Dimensionstabelle für Kennzahlen basierend auf dem Snowflake- 

Schema. 

• Hierarchische Verknüpfung von Dimensionspositionen durch die Ergänzung von 

Hierarchietabellen. 

Das Unimu-Schema basiert auf einer dreidimensionalen Modellierung 

betriebswirtschaftlicher Kenngrößen: 

• Zeitdimension: Jeder Fakt ist mit einer uniform verwendbaren Zeit_id versehen. 

Beliebige zeitbezogene Aggregate können somit in einer Fakttabelle abgelegt 

- 81 -



werden. Die zeitliche Dimensionierung kann individuell für alle Kombinationen 

von Kennzahl- und Objektdimensionen festgelegt werden. 

• Kennzahldimension: Die Kennzahlen werden in einer Dimension 

zusammengefasst. Neue Kennzahlen können so ohne Datenmodelländerung und 

Anpassung der Präsentationsanwendung hinzugefügt werden. Nicht sinnvolle 

Kombinationen von Kennzahlen und Objekten (z.B. Preis pro Produktgruppe) 

können ausgeschlossen werden. Die flexible Modellierung ist allerdings mit dem 

Nachteil einer umfangreichen Fakttabelle verbunden. 

Objektdimension: Durch die Modellierung erfolgt eine Trennung in logische und 

semantische Dimensionen. Semantische Dimensionen sind z.B. Kunden, Produkte und 

Regionen. Logische Dimensionen entsprechen oder ergeben sich aus der Verknüpfung 

semantischer Dimensionen (z.B. Kunden pro Region). 

Abbildung 33: Das Unimu-Schema [Quelle: Ehrenberg/Heine (1998) S. 507] 

Der große Vorteil des Unimu-Schemas ist, dass Dimensionen als Daten und nicht als 

Datenstrukturen verwaltet werden. Dadurch können neue Kennzahlen, neue 

Objektdimensionen und neue zeitliche Granularitäten ohne Schemaänderungen 

abgebildet werden.[vgl. Ehrenberg/Heine (1998) S. 503ff] 

- 82 -



6 DIE MODELLIERUNGSMETHODE AGGREGATION PATH 

ARRAY 

Die von Prosser und Ossimitz entwickelte Methode des APA (Aggregation Path Array) 

versucht die Modellierungsmethode des Gitters entsprechend zu verbessern. Dabei 

versucht man im Gitter nicht die gesamten Kombinationen der Dimensionen in ihren 

Hierarchiestufen darzustellen, sondern man gibt für jede Zelle im Gitter nur die 

geänderte Hierarchiestufe der Dimension (Attributsnamendarstellung) bzw. die 

Dimension, die sich geändert hat, an (Kurznotation). Deshalb ergibt jede Zeile alle 

möglichen Aggregationsschritte aller Dimensionen wieder. Es wird von Zeile zu Zeile 

nur die Reihenfolge der Aggregationsschritte verändert. Das führt jedoch zu 

Redundanzen zwischen den einzelnen Zeilen. Diese werden dann in einem zweiten 

Schritt entfernt bzw. ausgemerzt oder, wie in dem unten beschriebenen Algorithmus, in 

einem Schritt vollzogen. [vgl. Prosser/Ossimitz (2000b), S. 10 ff] 

In Abbildung 34 sieht man das analoge Beispiel des Gitters (siehe Abbildung 27) für ein 

APA mit 3 Dimensionen (Kunden, Artikel, Zeit). 

1 1 2 2 3 3 3 

1 1 2 3 3 3 2 

1 1 3 3 3 2 2 

1 2 2 3 3 3 1 

1 2 3 3 3 2 1 

1 3 3 3 2 2 1 

2 2 3 3 3 1 1 

2 3 3 3 2 1 1 

3 3 3 2 2 1 1 

K_gr K_* A_gr A_* Z_m Z_y Z_* 

K_gr K_* A_gr Z_m Z_y Z_* A_* 

K_gr K_* Z_m Z_y Z_* A_gr A_* 

K_gr A_gr A_* Z_m Z_y Z_* K_* 

K_gr A_gr Z_m Z_y Z_* A_* K_* 

K_gr Z_m Z_y Z_* A_gr A_* K_* 

A_gr A_* Z_m Z_y Z_* K_gr K_* 

A_gr Z_m Z_y Z_* A_* K_gr K_* 

Z_m Z_y Z_* A_gr A_* K_gr K_* 

Abbildung 34: Darstellung des APA des Praxisbeispiels in Kurznotation (links) und mit 

Attributsnamen (rechts) nicht redundanzfrei [in Anlehnung: Prosser, Ossimitz, (2000 a), S. 43] 

Die Dimensionen unterteilen sich in folgende Hierarchiestufen: 

• Kunden: Kunde individuell (K_id), Kundengruppe (K_gr), Kunden gesamt 

(K_*) 

• Artikel: Artikel individuell (A_id), Artikelgruppe (A_gr), Artikel gesamt (A_*) 

• Zeit: Tag (Z_t), Monat (Z_m), Jahr (Z_j), Zeit gesamt (Z_*) 

Dabei gibt jede Zelle, wie oben erwähnt, die Änderung einer Hierarchiestufe an. 

Allgemein beginnt jede Zeile mit den Dimensionen in der Ausgangshierarchiestufe 0 

- 83 -



0 

d 3 oder K_id, A_id, Z_d). In werterer Folge wird in jeder Spalte der Zeile für 

0 0 

( d 1 , d 2 , 

eine weitere Dimension die Hierarchiestufe um eins erhöht bis in der letzten Spalte 

jeder Zeile die Endsituation mit allen Dimensionen in der höchsten Hierarchiestufe steht 

(z.B. d , d , d oder K_*, A_*, Z_*). So ergibt die markierte Zelle in Abbildung 34 

2 

1 

2 

2 

3 

3 

1 2 1 

die Kombination d 1 , d 2 , d 3 oder K_gr, A_*, Z_d. Jede Zelle im Gitter enthält aus 

Übersichtlichkeitsgründen nur die Hierarchiestufe, die im Vergleich zum Vorgänger 

links in derselben Zeile hochgezählt wurde. Damit kann man aber für jede Zelle relativ 

leicht den Würfel generieren, der dargestellt wird. Das geschieht indem man die höchste 

bis dahin in der Zeile links von der Zelle angeführte Hierarchiestufe der bereits 

zumindest einmal aggregierten Dimensionen nimmt und für die anderen Dimensionen 

die niedrigste Hierarchiestufe einsetzt. Für unseren markierten Würfel wäre somit die 

konkrete Ausprägung d , d , d oder K_gr, A_*, Z_d. 

1 

1 

2 

2 

0 

3 

Für die formale Definition des Permutationsalgorithmus [vgl. Prosser/Ossimitz (2000b), S 

12ff ], der zum Array in Abbildung 34 führt, benötigen wir zunächst die Definition eines 

Verschiebeoperators der folgenden Form: Gegeben sei ein Array von Zeilenvektoren, 

von denen alle dieselben Elemente dn, allerdings in einer anderen Reihenfolge 

beinhalten; ein Element dn kommt in einem Zeilenvektor nur einmal vor. Das Array 

bestehe zunächst nur aus einer Zeile: z1=(d1, d2, d3, ...., dn-1, dn). Wir bilden nun eine 

zweite Zeile und definieren dafür den Verschiebeoperator V der Form 

( d → d z − r) 

mit r ∈ N + , sodass die aktuelle Zeile z aus Zeile (z-r) abgebildet 

V a b 

wird, indem alle Elemente im Vektor vor da hinter db verschoben werden, die Elemente 

dazwischen um eine Position nach links aufrücken und alle Elemente, die ursprünglich 

nach db lagen, wieder unverändert bleiben. Damit erzeugt die Operation 

V d → d n − z −1) 

in Zeile z =2 den Vektor z2 = (d1, d3, ...., dn-1, d2, dn). Mit Hilfe diese 

( 2 1 

Verschiebeoperators kann nun folgendes Array gebildet werden: 

z =1 

i( 

1) 

1 

i( 

n−2) 

1 i( 

n−1) 

i(n 

) 

( d ,..., d ,..., d ,..., d , d ,..., d , d ,..., d ) 

1 

1 

1 

n−2 

markiere Elemente 

n−2 

d ,..., d 

1 

1 

i(n 

) 

n 

n−1 

n−1 

/* Der Zähler für die Hierarchiestufen in Dimension n sei als k[n] bezeichnet, */ 

/* wobei i(n)-k[n] die aktuell bearbeitete Hierarchiestufe in n bezeichnet; */ 

k[1]=0 

do unitl i(1)-k[1]



do until i(2)-k[2] 0 

z ← z + 1 

V ( d 

markierte Elemente 

end if 

i( 

n−2) 

−k[ 

n−2] 

n−2 

→ d 

k[ 

n − 2] 

← k[ 

n − 2] 

+ 1 

if i( 

2) 

− k( 

2) 

> 0 

V 

end if 

end do 

z ← z + 1 

i( 

n) 

n 

d 

z − ( i( 

n −1) 

+ 1) 

) 

1 

n−1 

, K, 

d 

i( 

n) 

in 

i( 

n−2) 

−k[ 

n−2] 

i( 

n) 

( d → d z − ( i( 

n −1) 

+ 1) 

) 

n−2 

1 i 

markiere Elemente d , K, 

d 

k[ 

2] 

← k[ 

2] 

+ 1 

if i( 

1) 

− k[ 

1] 

> 0 

z ← z + 1 

( n) 

n 

r n 1 

⎛ i( 

1) 

k[ 

1] 

i( 

n) 

⎞ 

V ⎜d 

d n z ( i( 

r) 

1) 

⎟ 

⎜ 1 ← − ∏ + 

⎟ 

⎝ 

r 2 ⎠ 

1 i( 

n) 

markierte Elemente d 2, 

, d n 

end if 

k[ 

1] 

← k[ 

1] 

+ 1 

end do 

− = 

− 

= 

K 

n 

3 

- 85 -



/* Die markierten v sind die redundanzfreie Menge v ∈ RF.*/ 

procedure (inner_loop) 

/* Diese Schleife realisiert die Permutation der Dimensionen n und (n-1) */ 

k[ 

n −1] 

= 0 

do until k[ 

n −1] 

= i[ 

n −1] 

z ← z + 1 

V 

end do 

i( 

n−1) 

−k[ 

n−1] 

i( 

n) 

( d → d z −1) 

n−1 

1 i 

markierte Elemente d , K, 

d 

k[ 

n −1] 

← k[ 

n −1] 

+ 1 

end _ procedure 

n 

n 

( n) 

n 

Der Verband in Abbildung 34 stellt aber die nicht redundanzfreie Kombination aller 

Dimensionen und Hierarchiestufen dar. Abbildung 35 stellt die redundanzfreie Menge 

des Praxisbeispiels durch farbliche Markierung dar. 

1 1 2 2 3 3 3 

1 1 2 3 3 3 2 

1 1 3 3 3 2 2 

1 2 2 3 3 3 1 

1 2 3 3 3 2 1 

1 3 3 3 2 2 1 

2 2 3 3 3 1 1 

2 3 3 3 2 1 1 

3 3 3 2 2 1 1 

K_gr K_* A_gr A_* Z_m Z_y Z_* 

K_gr K_* A_gr Z_m Z_y Z_* A_* 

K_gr K_* Z_m Z_y Z_* A_gr A_* 

K_gr A_gr A_* Z_m Z_y Z_* K_* 

K_gr A_gr Z_m Z_y Z_* A_* K_* 

K_gr Z_m Z_y Z_* A_gr A_* K_* 

A_gr A_* Z_m Z_y Z_* K_gr K_* 

A_gr Z_m Z_y Z_* A_* K_gr K_* 

Z_m Z_y Z_* A_gr A_* K_gr K_* 


Attributsnamen (rechts) redundanzfreie Menge farblich markiert 

[in Anlehnung: Prosser, Ossimitz (2000 a), S. 43] 

Die redundanzfreie Menge aus einem fertig generierten Array, wie in Abbildung 35, 

erhält man, wenn man folgenden Algorithmus vollzieht: 

(1) Der Pfad in Zeile 1 des Array stellt alle Element das erste Mal dar und gehört somit 

gesamt zur redundanzfreien Menge. 

(2) Danach durchläuft man die nächste Zeile von links nach rechts und vergleicht jede 

Zelle mit der Zelle in der unmittelbar übergeordneten Zeile. Dieser Ablauf wird bis zum 

ersten Auftreten einer Ungleichheit der beiden Zellen durchgeführt, wobei all diese 

Zellen unmarkiert bleiben. Mit dem Auftreten der ersten Ungleichheit werden alle 

- 86 -



folgenden Zellen bis zum Auftreten der obersten Hierarchiestufe der letzten Dimension 

3 

(in diesem Fall das Element Z_* oder d 3 ) markiert. Alle Zellen rechts von dieser Zelle 

bleiben unmarkiert. 

(3) Punkt 2 wird für alle Zeilen bis zur letzten Zeile durchlaufen. 

Als Ergebnis sieht man die in Abbildung 35 dargestellte farblich markierte 

redundanzfreie Menge an Würfeln. Diese Menge gibt somit die vollständige und 

redundanzfreie Menge (i. e. sie enthält alle aus dem Basiswürfel ableitbaren Vektoren). 

Für einen Beweis siehe Prosser/Ossimitz (2000b) Anhang. 

Eine weitere im Data Warehouse Management entscheidende Frage ist, welche Würfel 

interessant für den Anwender und welche davon zu materialisieren sind. Hier ergibt sich 

ein Zielkonflikt zwischen der Performance (möglichst viele Würfel zu materialisieren, 

um schnelle Abfragen zu haben) und den Kosten für unnötige Datenhaltung und 

Prozessorarbeitsstunden. Das Finden einer optimalen Lösung, die ja von Anwender zu 

Anwender völlig verschieden sein kann, unterstützt das APA in relativ übersichtlicher 

Art und Weise. So könnte eine anwenderspezifische Anforderung für die interessanten 

Würfel lauten: „ Ich benötige einen Monatsbericht für alle Artikelgruppen mit einem 

kompletten Drill Down aller Artikel unabhängig von Kunden (a). Zusätzlich will ich für 

jeden individuellen Kunden einen Jahresbericht für alle Artikel haben (b).“ 

Abbildung 36: Darstellung der interessanten Würfel 

[in Anlehnung: Prosser, Ossimitz (2000 b), S. 17 ] 

Abbildung 36 stellt die Würfel, welche die Anforderungen erfüllen, getrennt nach 

Bereich a und Bereich b markiert, dar. Dies sind die Würfel, die für die Abfrage 

benötigt werden. 

- 87 -



Zusätzlich stellt sich nun die Frage, welche Würfel nun tatsächlich physisch 

materialisiert werden sollen, da es aus Speicherplatzgründen in den seltensten Fällen 

möglich ist, alle interessanten Würfel zu materialisieren. Deshalb kann diese Frage 

nur beantwortet werden, wenn man die Derivate der einzelnen Würfel betrachtet. 

Das APA kann dabei zur Bestimmung der Derivate eines Vektors verwendet 

werden: 

/* Bestimme die Anzahl der Spalten des Arrays */ 

∑ 

max 

s i( 

n) 

= n 

/*Bestimme die Anzahl der Zeilen des Arrays */ 

z 

max 

= 

∏ − = r n 1 

r= 

1 

( i( 

r) 

−1) 

/* Abarbeiten aller Zeilen bis zum Ende des Arrays in z max erreicht ist */ 

z = 1 

dountil 

s = s 

z > z 

max 

do until s 

max 

, ende = 0 

= 0 

or ende 

= 1 

j( 

m) 

( array _ element( 

z, 

s) 

= d ∈v) 

if 

markiereZelle 

sin 

z 

ende = 1 

else s ← s −1 

end if 

end do 

z ← z + 1 

end do 

m 

Alle Zellen (=Vektoren) w, die markiert oder rechts der markierten Zelle ihrer Zeile im 

Array liegen sind Derivate von v, w ∈ A(v). A(v) ∩ RF wäre die redundanzfreie Menge 

an Derivaten. [vgl. Prosser/Ossimitz (2000b) S. 18f ] 

Zum Algorithmus: Zunächst werden Zeilen- und Spaltenanzahl in z max bzw. s max 

hinterlegt. Da nur auf Elemente im APA abgefragt wird, wird die unterste 

Hierarchieebene ignoriert. Dies ist aber sinnvoll, da sich aus der untersten immer alle 

anderen Hierarchiestufen der Dimensionen ableiten lassen – für die Herleitung der 

Derivatsmengen sind daher nur die Dimensionen mit einer Hierarchiestufe größer oder 

gleich 1 im Vektor entscheidend. Markiert wird von rechts kommend (Beginn bei s max ) 

- 88 -



in jeder Zeile jene Zelle, in der das erste Mal ein Element aus v einer Stufe ≥ 1 

vorkommt. [vgl. Prosser/Ossimitz (2000b) S. 18] 

Wir gehen von dem in Abbildung 36 angeführten Beispiel aus und versuchen nun die 

Menge der zu materialisierenden Würfel abzuleiten. Dabei betrachten wir zuerst die 

Derivativmenge Bereich x des Würfels x (blau markiert). Wir sehen, dass zwar der 

Bereich a vollständig mit den Derivativen des Würfels x abgedeckt ist. Der Bereich b 

jedoch nicht aus dem Würfel x abgeleitet werden kann. 

Abbildung 37: Anzeigebeispiel der Derivative (Bereich x) des Würfels x 

[in Anlehnung: Prosser, Ossimitz (2000 b), S. 17] 

Abbildung 38: Anzeigebeispiel der Derivate (Bereich y) des Würfels y 


- 89 -



Genauso betrachten wir die Derivatsmenge (Bereich y) des Würfels y (blau 

markiert) in Abbildung 38. Dabei ist zu erkennen das der Würfel y zwar den Bereich 

b abdeckt, den Bereich a jedoch nicht tangiert. Damit ist es notwendig zumindest 

zwei Würfel zu materialisieren. 

Deshalb versuchen wir ein Materialisieren beider Würfel in Abbildung 39 

darzustellen. Die Gesamtderivatsmenge von Bereich x und Bereich y wird rechts 

von der dicken Linie dargestellt. 

Abbildung 39: Anzeigebeispiel der Derivate (Bereich x + y) der Würfels x und y 


Im Moment gibt es für die Bestimmung der zu materialisierenden Würfel aus den 

interessanten Würfel keinen wissenschaftlich ausgereiften Algorithmus. Deshalb 

können die zu materialisierenden Würfel im Moment nur durch Austesten bestimmt 

werden. Dies soll sich durch die in Abschnitt 7 beschrieben Heuristik ändern. 

7 FORSCHUNGSSCHWERPUNKT UND ERGEBNISSE 

7.1 DAS GRUNDPROBLEM UND DER LÖSUNGSANSATZ 

Der zentrale Fokus beim Aufbau von Data Warehouse-Konzepten sollte auf den Nutzen 

für den Anwender gelegt werden. Aus diesem Grund ist neben dem leichten, intuitiven 

Zugang unbedingt besonderes Augenmerk auf hohe Flexibilität und Schnelligkeit bei 

der Bearbeitung von Endbenutzerabfragen zu legen. Durch die Bestimmung der 

richtigen zu materialisierenden Würfel, sollen diese Anforderungen befriedigt werden. 

- 90 -



Das Grundproblem der Bestimmung der zu materialisierenden Würfel (materialized 

cubes) unter Betrachtung der Menge der interessanten Würfeln (required cubes), welche 

die benötigte Information enthalten, ist also ein Optimierungsproblem. Im einfachsten 

Fall, in welchem keine Restriktionen hinsichtlich Ladezeit zum Aufbau des Data 

Warehouse oder Speicherplatz bestehen, würden grundsätzlich die interessanten Würfel 

und die zu materialisierenden Würfel identisch sein. Das heißt alle benötigten Würfel 

würden auch physisch materialisiert. Damit wäre auch für den Benutzer die minimale 

Zugriffszeit auf die Information garantiert. Es kann sogar sinnvoll sein noch zusätzliche 

Würfel zu materialisieren, da sie die Materialisierungszeit nachfolgender Würfel 

minimieren. 

In der Praxis ist jedoch festzustellen, dass sowohl hinsichtlich des Speicherplatzes - 

wobei dieses Problem von Tag zu Tag an Bedeutung verliert, da die Kosten für Speicher 

im Zeitablauf rapide sinken - aber im besonderen hinsichtlich der Ladezeit der Daten, 

welche für das Data Warehouse veranschlagt werden muss, Begrenzungen gelten. 

Durch die immer stärker werdende multinationale Unternehmensführung wird es immer 

schwieriger die Zeit für die Generierung und die Updates der Daten in einem Data 

Warehouse zu planen. Das eigentliche Problem ergibt sich daraus, dass während des 

Updates oder Neuaufbaus des Data Warehouses der Zugriff auf dieses nicht möglich ist. 

Wurden bei nationalen Unternehmen diese Updates einfach während der Nacht erledigt, 

kann dies beispielsweise von einer weltweit operierenden Fluglinie, welche die Daten 

immer an einem bestimmten Punkt der Welt gerade benötigt, nur sehr schwer erledigt 

werden. So bleiben für diese Unternehmen oft nur Zeitbereiche von wenigen Stunden 

pro Woche oder Tag, um ihre Daten auf den neusten Stand zu bringen. 

Aus diesem Grund besteht ein Optimierungsproblem, welches sich aus Konflikt der 

schnellstmöglichen Abfragezeit und der schnellstmöglichen Aktualisierungs- bzw. 

Aufbauzeit ergibt. Für diese Problem einen Lösungsansatz zu finden stellt den Kern 

meiner Forschungsarbeit dar. 

7.2 DIE VORGEHENSWEISE 

Um das Problem angreifbar, modellierbar und damit erforschbar zu machen gehe ich 

von einigen Annahmen aus. Diese sind: 

• Bei verteilten Datenbanken, welche sich auf unterschiedlichen Servern weltweit 

befinden, kann die Zeit für das Abfragen und Speichern eines Cubes von Würfel 

zu Würfel total unterschiedlich sein. Diese Information steht dem Benutzer und 

auch dem Planer eines Data Warehouses oft gar nicht zur Verfügung. Deshalb 

gehe ich von einer durchschnittlichen Zugriffszeit pro Transaktion aus. Diese ist 

durch den Benutzer für jedes Data Warehouse individuell festzustellen (z. B. 

- 91 -



durch zufällige Abfrageprobeläufe) und als Berechnungsbasis in das von mir 

entwickelte Gleichungssystem, bzw. die Software einzugeben. Diese 

durchschnittliche Zugriffszeit kann sich natürlich im Zeitablauf ändern und 

somit auch zu Veränderungen im Aufbau des Data Warehouse Systems führen. 

• Es besteht ein linearer Zusammenhang zwischen den in den Cubes gespeicherten 

Daten. Wird zum Beispiel in einem Cube der Jahresumsatz in einer FLOAT 

Variablen mit 8 Byte gespeichert, ist der benötigte Speicherplatz in einem 

anderen Cube, in welchem der Monatsumsatz gespeichert wird zwölf mal so 

groß. Das mag in der Praxis nicht immer stimmen, da moderne 

Datenbankmanagementsysteme mit ihren Query Optimizern zumeist 

automatische Indizes erzeugen. Geht man aber von einem einfachen Modell aus 

sehr wohl. Diese Vereinfachung des Models ist jedoch zwingend notwendig um 

die Komplexität des Problems zu bereinigen und eine wissenschaftliche 

Untersuchung zu ermöglichen. 

• Es besteht ein linearer Zusammenhang zwischen der Anzahl der Tupel im Table 

der abzufragenden Datenbank und der Abfragezeit. Empirische Untersuchungen 

von Dunemann (2002) belegen diese Annahme, da eine sehr starke Korrelation 

zwischen diesen beiden Werten besteht. 

• Es besteht ein linearer Zusammenhang zwischen der Anzahl der Tupel in der 

Ergebnismenge einer GROUP BY Abfrage und der Abfragezeit der Query. 

Diese Annahme wird ebenfalls von Dunemann (2002) untermauert, welcher eine 

Korrelation festgestellt hat. Diese ist allerdings nicht so stark wie bei der 

Korrelation zwischen Anzahl der Tupel in der abzufragenden Datenbank und 

Abfragezeit. Eine genaue Beschreibung dieser Studie wird in Kapitel 7.5 

behandelt. 

7.3 ABGRENZUNG DER PHASEN DER BETRACHTUNG 

Beim Aufbau und beim Update eines Datawarehouse unterscheiden wir 3 verschiedene 

Phasen: 

• Phase des Aufbaus des BFT aus den operativen und externen Datenquellen 

• Aufbau der materialisierten Sichten aus dem BFT 

• Abfragen der Informationen aus dem BFT oder den materialisierten Sichten 

- 92 -



Abbildung 40: Abgrenzung der Phasen der Betrachtung 

In meinen Überlegungen gehe ich von einer abgeschlossenen ersten Phase aus. Das 

heißt der Aufbau des BFT aus operativen und externen Systemen muss in jedem Fall 

erfolgen und hat auf die Auswahl der zu materialisierenden Sichten keinen Einfluss. 

Deshalb wird diese Phase und die Zeit, welche für diese Phase benötigt wird, nicht in 

die Betrachtungen aufgenommen. In der zweiten Phase, in der die materialisierten 

Sichten erzeugt werden, besteht eine strikte Zeitbeschränkung, da bis zur neuen 

Aggregation die Würfel nicht zur Verfügung stehen, bzw. unrichtige Information 

enthalten. Die dritte Phase umfasst die Abfragen der Benutzer bis zum neuerlichen 

Aufbau des Warehouse. Dabei werden die Gesamtkosten der Abfragen in dieser Periode 

durch das Produkt der Abfragekosten mit den geschätzten Anzahl der Abfragen 

errechnet. Dadurch werden auch wichtige Cubes früher materialisiert, da Kosten 

eingespart werden können. 

- 93 -



7.4 VERWANDTE ALGORITHMEN IM 

PROBLEMZUSAMMENHANG 

In diesem Abschnitt versuche ich bestehende Algorithmen zu präsentieren, welche 

einen Beitrag zur Lösung der Problemstellung liefern können. Dabei versuche ich 

bestehende, in der Literatur erwähnte, Algorithmen möglichst detailliert zu beschreiben. 

Unsere Aufgabe besteht unter anderem darin eine gute Heuristik zur Bestimmung der zu 

materialisierenden Würfel zu finden. Um die Qualität dieser Heuristik zu bewerten 

bedarf es jedenfalls der Bestimmung der optimalen Lösung. Dies soll durch diese 

Algorithmen programmtechnisch umgesetzt und überprüft werden. Zusätzlich werden 

Auszüge dieser Algorithmen in den Heuristiken der Software verwendet. 

7.4.1 KÜRZESTE UND LÄNGSTE WEGE 

Im Problemkreis der kürzesten und längsten Wege versucht man ein reales System oder 

ein zu lösendes Problem durch Graphen darzustellen. Standardaufgaben der 

Graphentheorie in diesem Kontext sind die als „Single source path“-Problem bekannte 

Bestimmung aller kürzesten Wege von einem Knoten zu allen anderen und die 

Bestimmung kürzester Wege zwischen allen Knoten, auch als „All pairs shortest path“- 

Problem („Finde die mit den geringsten Kosten verbundene Möglichkeit, alle Punkte zu 

verbinden.“) bekannt. In der Praxis, sowie auch in dem von uns behandelten 

Problemkontext, werden als Weg die Kosten angesetzt und die Problemstellung von 

einem kürzesten Weg Problem in ein minimales Kostenproblem gewandelt. 

[vgl. Sedgewick (2002) S. 513f ] 

Durch den hierarchischen Aufbau der Dimensionen und Hierarchien können die 

materialisierten Würfel als Graphen ansehen werden (siehe auch Kapitel 5.10.8.2.1). 

Diese werden durch Kanten verbunden, welche die Materialisierungskosten von einem 

Aggregat einer niederen Hierarchiestufe auf ein Aggregat einer höheren Hierarchiestufe 

symbolisieren. 

7.4.1.1 BEGRIFFSBESTIMMUNGEN 

7.4.1.1.1 GRAPHEN 

Abstrakt fasst ein Graph D zwei Mengen zusammen: die Menge V der Knoten und die 

Menge E der Kanten. Wir schreiben D= (V,E). Eine Kante ist ein geordnetes Paar von 

Konten. In der Schreibweise (v,w) bezeichnet v den Anfangskonten und w den 

Endknoten der Kante. In der Veranschaulichung 

- 94 -



Abbildung 41: Graph mit zwei Knoten 

zeigt die Spitze des verbindenden Pfeils auf den Endknoten w. v hat die Bedeutung des 

Vorgängers (Parents) von w und w die des Nachfolgers (Derivative) von v. v und w 

werden als adjazent oder benachbart bezeichnet und die Kante (v,w) heißt inzident zu 

den beiden Knoten v und w. Kanten, die den Knoten v als Anfangsknoten haben, werden 

auch als Ausgangsknoten von v und solche, die den Knoten v als Endknoten haben, als 

Eingangskanten dieses Knotens bezeichnet. Ein Graph mit n Knoten hat im Maximum 

n 2 und im Minimum 0 Kanten. [vgl. Reß/Viebeck (2000) S. 364f] 

7.4.1.1.2 EINGANGS- UND AUSGANGSGRAD 

Als Grad eines Knotens eines Graphen bezeichnet man die Summe der Kanten, die den 

Knoten als Ausgangsknoten (ausgehende Kanten) oder als Endknoten (eingehende 

Kanten) haben. Die Anzahl der eingehenden Kanten heißt Eingangsgrad (indegree) und 

die Anzahl der ausgehenden Kanten Ausgangsgrad (outdegree) des Knotens. [vgl. 

Reß/Viebeck (2000) S. 365f] 

7.4.1.1.3 WEG, ZYKLUS 

Eine Folge von Knoten v1, v2, … vn heißt Weg (path) von v1 nach vn, wenn der Endpunkt 

der Kante (vi-1, vi) mit dem Anfangspunkt der Kante (vi, vi+1) für 1



bezeichnet. Die Knoten und Kantenwerte eines Graphen sind jeweils vom gleichen 

Datentyp. [vgl. Reß/Viebeck (2000) S. 366f] 

7.4.1.1.5 KLASSIFIZIERUNG VON GRAPHEN 

Zur Klassifizierung von Graphen führen Reß/Viebeck (2000) folgende Begriffe ein [vgl. 

Reß/Viebeck (2000) S. 363]: 

Ein Graph heißt 

• symmetrisch, wenn mit der Kante (v,w) immer auch die Kante (w,v) für alle 

Knoten v und w impiziert ist, d.h. in symmetrischen Graphen besteht eine 

Verbindung zwischen zwei Knoten immer in beiden Richtungen. Ein Beispiel ist 

ein Straßennetz, in dem Verkehr in beiden Richtungen möglich ist. 

• asymmetrisch, wenn die Existenz der Kante (v,w), v ≠ w , die Existenz der Kante 

(w,v) ausschließt. In asymmetrischen Graphen besteht somit eine Verbindung 

zwischen zwei verschiedenen Knoten immer nur in einer Richtung. Ein Beispiel 

ist ein Straßennetz, das nur Einbahnverkehr zulässt. 

• reflexiv, wenn jeder Knoten des Graphen mit sich selbst verbunden ist, wenn 

also (v,v) für alle v gilt. 

• irreflexiv, wenn die Existenz der Kante (v,v) für alle Knoten v ausgeschlossen 

ist. 

• transitiv, wenn aus der Existenz der Kanten (v,w) und (w,z) die Existenz der 

Kante (v,z) folgt. Eine typische transitive Relation ist v



• d(s,s) = 0 

• d(s,w) = min {d(s,v)+c(v,w)} für v ∈ V (w) 

wobei V(w) die Menge der 

Vorgängerknoten von w bedeutet. 

Es stellt sich die Frage, wie man eine Reihenfolge der Knoten finden kann, damit 

die Rekursion auch ausführbar wird. Eine Lösung dazu liefert der Algorithmus von 

Dijkstra. Für azyklische Graphen findet man eine Reihenfolge einfach durch 

topologisches Sortieren der Kanten. [vgl. Reß/Viebeck (2000) S. 403ff] 

7.4.1.2.1 ALGORITHMUS VON DIJKSTRA 

Dieser Algorithmus gilt für einen allgemeinen Graphen, er muss nicht azyklisch sein. 

Bei diesem Ansatz ist jeder der Knoten eines Graphen entweder ein innerer Knoten, 

Randknoten oder äußerer Knoten. Für die inneren Knoten ist bereits ihr kürzester 

Abstand zum Startknoten s bekannt. Randknoten sind Knoten, für die man einen Weg 

von s kennt, der aber noch nicht ein kürzester sein muss. Für äußere Knoten kennt man 

noch keinen von s ausgehenden Weg. Zu Beginn ist der Startknoten s, der von sich 

selbst den minimalen Abstand Null hat, der einzige innere Knoten und die direkten 

Nachfolgerknoten bilden die Menge der Randknoten. Alle anderen Knoten sind äußere 

Knoten. Die Menge der inneren Knoten wächst nun schrittweise von innen nach außen, 

indem unter allen Randknoten derjenige mit dem kürzesten Abstand von s als nächster 

innerer Knoten genommen wird. Seine Nachfolger werden, soweit sie bisher noch 

äußere Knoten sind, zu neuen Randknoten. Für Randknoten, die erneut erreicht werden, 

kann sich ein neuer, kürzerer Abstand von s ergeben, der dann den bisherigen kürzesten 

Weg ersetzt. 

Wir demonstrieren das Verfahren am Beispiel des folgenden Graphen und bestimmen 

die kürzesten Wege des Knotens a zu allen anderen Knoten. 

- 97 -



Abbildung 42: Bewerteter Graph [Quelle: Reß/Viebock (2000) S. 404] 

Im ersten Schritt wird a zum inneren Knoten und seine Nachfolgerknoten b, c und d 

werden zu Randknoten. Die verbleibenden Knoten e und f sind äußere Knoten. Unter 

den Randknoten hat c den minimalen Abstand von a und c wird somit zum nächsten 

inneren Knoten. Einen kürzeren Weg zu irgendeinem anderen Knoten kann es nicht 

geben, da dieser notwendigerweise über die Knoten b oder d gehen müsste und d und b 

von a aus keine kürzere Entfernung als c haben. Unter den bereits bekannten Wegen 

von a nach b, c und d gibt es jetzt den kürzeren für d, der von a über c nach d führt. Wir 

merken diesen kürzeren Weg nach d. Der Knoten f wird als Nachfolger vom Knoten c 

zu einem Randknoten. Als nächsten inneren Knoten bestimmen wir den Knoten b, der 

unter den Randknoten dieses Schrittes den minimalen Abstand von a hat. Die weiteren 

Schritte sind aus der folgenden Tabelle ersichtlich. 

- 98 -



Schrittfolge 

Knoten 

Innere Knoten 

Minimaler 

Abstand von 

s 

Knoten 

- 99 - 

Randknoten 

vorläufig 

minimaler 

Abstand von 

s 

Vorgänger 

äußere 

Knoten 

1 a 0 b 4 a e 

c 2 a f 

d 6 a 

2 a 0 b 4 a e 

c 2 d 5 c 

f 8 c 

3 a 0 d 5 c e 

c 2 f 7 b 

b 4 

4 a 0 f 6 d 

c 2 e 7 d 

b 4 

d 5 

5 a 0 e 7 d 

c 2 

b 4 

d 5 

f 6 

6 a 0 

c 2 

b 4 

d 5 

f 6 

e 7 

Tabelle 7: Berechnung der kürzesten Wege von einem Knoten in einem Graph zu allen anderen 

[Quelle: Reß/Viebeck (2000) S. 405] 

In der folgenden Implementation des Algorithmus von Dijkstra für einen bewerteten 

Graphen in Adjazenzlistendarstellung sehen wir die Arrays distance und parent, beide 

von der Länge D.GetNumVertices, vor. parent ist von Typ VPostition und distance vom 

Typ float. Für einen Knoten v mit der Ordnungsnummer i zeigt parent[i]!=NULL auf 

den Vorgängerknoten, der auf dem zuletzt durchlaufenen Weg zum Knoten v liegt. Und 

enthält distance[i] die bisher für v ermittelte Entfernung vom Startknoten. Die 

Initialwerte sind parent[i]=NULL und distance[i]=0. Am Schluss weist distance[i] den 

kürzesten Weg des Kontens v vom Startknoten s aus. Die Gewichte liegen als float- 

Werte in den jeweiligen Kanten vor. 

Für die Speicherung der Randknoten ist eine Prioritätswarteschlange am geeignetsten. 

Jeder Record der Schlange merkt einen Randknoten und dessen bisher ermittelten 

Abstand vom Startknoten. Die Records seien Objekte der Klasse PriorityRecord. Wir 

interpretieren den Abstand als Schlüssel (Priorität) und den Randknoten (Typ



VPosition) als zugehörigen Wert eines solchen Records und führen die 

Prioritätswarteschlange als Objekt PriorityQueue ein. Die Operation FindMin der 

Klasse PriorityQueue liefert den Record mit dem minimalen Prioritätswert, d.h. dem 

kürzesten Abstand vom Startknoten. Die Elementfunktionen GetVertex() und GetKey() 

der Klasse PriorityRecord bestimmen in einem Record dieses Typs den Randknoten 

und seine bisherige kürzeste Entfernung vom Startknoten. Zu Beginn wird die 

Prioritätswarteschlange durch einen ersten Eintrag für den Startknoten s mit dem 

Abstandswert NULL initialisiert. 

Das Programm Dijkstra entnimmt in einer äußeren Schleife den jeweils nächsten 

Eintrag aus der Prioritätswarteschlange. Dieser bezeichnet unter allen Randknoten 

denjenigen mit dem kürzesten Abstand zum Startknoten und er wird zum nächsten 

inneren Knoten v. In einer inneren Schleife werden dann nacheinander für die Kanten a 

des Knotens v der jeweilige Endknoten w bestimmt, für den dann aus dem Abstandswert 

des Knotens v, erhöht um den Wert der Kante a, seine Entfernung vom Startknoten 

bestimmt wird. Ist w bisher noch unbesucht, wird für ihn ein Eintrag in der 

Prioritätswarteschlange mit dem ermittelten Abstandswert vorgenommen. Ist w aber 

bereits Randknoten, so werden im Fall eines neuen kürzeren Abstands vom Startknoten 

die Werte distance und parent des Knotens sowie die Priorität in der Warteschlange 

entsprechend fortgeschrieben. 

Void Dijkstra(Graph &D, 

VPostitions) 

//berechnet die kürzesten Wege in D vom Knoten s 

aus 

{ 

int n=D.GetNumVertices(),i,j; //Anzahl 

Knoten 

PriorityQueueq(n); 

//Prioritätswarteschlangen für 

Randknoten 

VPosition



//Speicherplatz für Array distance und 

parent 

float distv, dista, distw,distnew; 

Ord(D); //Ordnungsnummer Knoten generieren 

NotVisited(D); //Knoten unbesucht markieren 

For (i=0; i



} 

dista=D.GetArc(a); //Abstandswert der 

Kante a 

distnew=distv+dista; //neue Entfernung 

von s für w 

if (!D.IsVisited(w)) 

{ 

} 

//neuer Randknoten 

p=new PriorityRecord(w,distnew); 

q.Insert (*p); //neuer Randknoten 

D.SetVisited(w,true); //Knoten w 

besucht 

Parent[j]=v; //v ist der Vorgänger 

von w 

distance[j]=distnew; 

//bisherige kürzeste Entferung von 

s für w 

else //w bereits Randknoten 

if (distw>distnew) 

{ //neue kürzeste Entfernung für w von 

s 

} 

p=new PriorityRecord(w,distw); 

//Suchargument 

q.DecreasePriority(*p,distnew); 

//neuen kürzesten Abstand für w in 

q eintragen 

distance[j]=distnew; 

//neue kürzeste Entferung 

parent[j]=v; //neuer Vorgänger 

a=D.NextArc(v,a); //nächste Kante für 

Knoten v 

- 102 -



} 

} 

Die Prioritätswarteschlange nimmt, da jeder ihrer Records nur einen Knoten enthält, 

insgesamt n = V Records auf. Bei der Zeitanalyse für die Prioritätswarteschlange ist 

dann von n Insert- und n DeleteMin-Operationen auszugehen. Die innere Schleife wird 

für jede der e = E Kanten des Graphen ausgeführt. Dabei wird höchstens eine Insert- 

oder eine IncreasePriority-Operation ausgeführt. Bei Implementation der 

Prioritätswarteschlange als Heap kostet jede dieser Operationen O (logn) 

. Der Aufwand 

für den Algorithmus ist somit von der Ordnung O (( n + e) 

log n) 

. 

7.4.1.2.2 ALGORITHMUS VON BELLMANN-FORD 

Dijkstras Algorithmus funktioniert nur, wenn die Kantengewichte keine negativen 

Werte annehmen können. Dies kann man sich leicht daran verdeutlichen, dass eine lokal 

ungünstige nächste Kante durch eine darauf folgende negativ gewichtete Kante 

nachträglich zu einer besseren Verbindung führt. Dies kann zum Beispiel für Graphen 

die Gewinne und Verlust abbilden sollen, aber zu falschen Ergebnissen führen. Deshalb 

wurde der Algorithmus von Bellmann-Ford entwickelt. Dieser funktioniert nach einem 

komplett anderen Prinzip: In mehreren Durchläufen wird jeweils die beste bisher 

mögliche Verbindung bestimmt, wobei der i-te Durchlauf alle Pfade der Länge i 

berücksichtigt. Der längste Pfad ohne Zyklus hat eine Länge von E −1 

, so dass man 

diesen Prozess nach E −1 

Durchläufen abschließen kann. Als Optimierung kann man 

das Verfahren vorzeitig beenden, wenn in einem Durchlauf keinerlei Änderungen zur 

vorherigen Wertebelegung mehr aufgetreten ist. 

Algorithm BF(G,s) 

//ein Graph G mit einem Startknoten s// 

D[s]:=0; 

For i:=1 to E −1 

do 

For each ( u, v) 

∈ E do 

//gerichtete Kanten// 

if D [ u] 

+ γ (( u, 

v)) 

< D[ 

v] 

then 

fi 

D[ v] 

: = D[ 

u] 

+ γ (( u, 

v)) 

- 103 -



od 

od 

[vgl. Saake/Sattler (2002) S. 427ff] 

7.4.1.2.3 KÜRZESTE WEGE FÜR EINEN AZYKLISCHEN GRAPHEN 

Der folgende Absatz soll den oben beschriebenen Algorithmus umgelegt auf einen 

azyklischen Graphen, welcher in unserer Problemstellung auftritt, zeigen. Damit wird 

versucht das Problem und die Lösungsmöglichkeiten näher zu fokussieren. 

Wir führen die Rekursion 

d ( s, 

s) 

= 0 

d( s, 

w) 

= min{ d( 

s, 

v) 

+ c( 

v, 

w)} 

für v ∈V 

( w) 

mit den topologisch sortierten Knoten direkt aus. Für Graphen der Abbildung 42 bildet 

die Folge der Knoten 

a – c – b – d – f – e 

eine topologische Ordnung. Wir nehmen den ersten Knoten der Ordnung als 

Startknoten. 

Schrittfolge Knoten v 

Vorläufiger 

minimaler 

minimaler 

Abstand 

Nachfolger w Abstand 

Knoten w von 

Knoten w von 

s 

s 

1 a c 2 2 

b 4 

d 6 

2 c b 4 4 

d 5 

f 8 

3 b d 5 5 

f 7 

4 d e 7 6 

f 6 

5 f e 7 7 

6 e 

Tabelle 8: Berechnung der kürzesten Wege für einen azyklischen Graphen 

[Quelle: Reß/Viebeck (2000) S. 408] 

Die Knoten werden nacheinander in topologischer Ordnung betrachtet und es wird 

sofort ihre kürzeste Entfernung vom Startknoten s bestimmt. Das Ergebnis zeigt Tabelle 

8. Das Programm ShortestPath ermittelt wie das Programm Dijstra die kürzeste 

Entfernung eines Knotens v vom Startknoten s sukzessive in der Arrayvariablen 

distance[i], i bezeichnet die Ordnungsnummer des Knotens v. Der Initialwert für 

distance[i] ist 0; die Bedingung dafür ist !D.IsVisited(v). Immer dann, wenn sich durch 

- 104 -



Hinzunahme des nächsten Knotens ein kürzerer Abstand von s ergibt oder sich in 

distance[i] noch der Initialwert befindet, wird der bisherige Wert durch den neuen 

ersetzt. Die Knoten werden in Folge ihrer topologischen Ordnung berechnet. Zum 

Schluss stehen im Array distance für alle Knoten des Graphen die kürzesten vom 

Startknoten s ausgehenden Wege. Die Laufzeit des Programms ist O ( n * e) 

. 

Void ShortestPath(Graph &D) 

{ 

unsigned n=D.GetNumVertices(),i,j; 

VPositionv,w; 

APositiona; 

VPosition*ord=new 

VPosition[n]; 

//Knoten in Sortierordung 

float *distance=new float[n]; 

//bisher kürzeste Abstände 

float dista,distnew; 

TopSort(D); //topologisches Sortieren 

NotVisited(D); //Knoten unbesucht 

v=D.FirstVertex(); //Initalisieren Arraywerte 

while (v.Pos()) 

{ 

} 

i=D.GetOrd(v); //Sortierindex Knoten v 

ord[i]=v; //Knoten v in Array ord 

distance[i]=0; 

v=D.NextVertex(v); 

for (i=0; i



} 

} 

{ 

} 

w=D.Endpoint(a); //Endpunkt w der 

Kante a 

j=D.GetOrd(w); //Index vom Endknoten 

dista=D.GetArc(a); //Wert dista von 

Kante a 

distnew=distance[i]+dista;//Entfernung 

w von s 

if (!D.IsVisited(w)) 

{//Knoten noch unbesucht 

} 

else 

D.SetVisited(w,true); //Konten 

besuchen 

distance[j]=distnew; //Entfernung 

setzen 

if (distnew



Kostenmatrix C 0[ 

i, 

j] 

wird dieser Prozess so lange wiederholt, bis sich die Matrix nicht 

mehr ändert. Die letzte Matrix enthält dann die kürzesten Wege zwischen je zwei 

Knoten von D. 

Für 0 

C gilt: ] , [ C i j = 0 und C [ i, 

j] 

= ∞ , falls keine Kanten von vi nach vj existiert. 

0 

0 

Beim Übergang von Ck− [ i, 

j] 

nach Ck [ i, 

j] 

sind zwei Fälle zu unterscheiden: 

1 

Es wurde noch kein Weg von vi nach vj festgestellt, d.h. Ck− 1[ 

i, 

j] 

= ∞ . Gibt es einen 

Weg von vi nach vk und einen Weg von vk nach vj, so führt auch ein Weg von vi nach vj . 

Es wird Ck [ i, 

j] 

= Ck− [ i, 

k] 

+ [ k, 

j] 

. 

1 

Ck− 1 

Abbildung 43: Darstellung der Knoten und Kanten 

Es existiert ein Weg von vi nach vj , d.h. [ i, 

j]! 

= ∞ , und ein weiterer, der über vk 

H k − 1 

führt und kürzer ist. Dann wird Ck [ i, 

j] 

= Ck− [ i, 

k] 

+ [ k, 

j] 

. 

1 

- 107 - 

Ck− 1 

Der Algorithmus von Floyd setzt die Kostenmatrix des Graphen voraus. Das Zeichen ∞ 

wird durch die größte Zahl des Datentyps der Kantenwerte simuliert. 

void Floyd(Graph &D) 

{ 

int n=D.GetNumVertices(),i,j=0,k; 

int iter=1; 

float C=new float[n*n],h; 

boolean b; 

D.CostMatrix(C); //Initialisierung 

for (i=0;i



} 

} 

for (i=0;i



Statement nur beschrieben wird, welche Daten der Benutzer bzw. das 

Anwendungsprogramm vom Datenbanksystem geliefert haben möchte. Es wird in 

keinem Fall im SQL-Statement beschrieben, wie das Datenbanksystem diese Daten 

finden soll. Dies ist die Aufgabe eines so genannten Zugriffs-Optimierers oder englisch 

Query Optimizer. 

Da in der entwickelten Software für die Planung des Aufbaues eines Datawarehouse mit 

Microsoft SQL eine relationale Datenbank als Basis definiert wurde, sind die Kosten für 

die Abfrage ein Punkt, welcher beleuchtet werden muss. Dabei soll es meiner Software 

möglich sein, durch die Eingaben des Benutzers näherungsweise Aussagen über die 

benötigte Zeit der Abfrage zu liefern. Die Kalkulation dieser Kosten wird im Normalfall 

vom Query Optimizer durchgeführt. Leider veröffentlichen Datenbankhersteller die 

Kostenfunktionen, bzw. die Funktionalität dieser Query Optimizer nicht, da die 

Performance eines Datenbankmanagementsystems im entscheidenden Maße von der 

Arbeitsweise des jeweiligen Optimizers abhängt. Im Gegenteil, die Funktionen und 

Arbeitsweise des Query Optimizers werden von den Datenbankherstellern als 

Betriebsgeheimnis angesehen. [vgl. Müller-Angstenberger (1994) S. 1] 

Durch diese Geheimhaltung sind in der Literatur nur grobe Schätzverfahren über die 

Kosten, bzw. die Abfragezeit einer Abfrage vorhanden. Diese zum Teil sehr 

unterschiedlichen Ansätze will ich nun vorstellen. 

Heuristische Optimierungstechniken sind darauf ausgerichtet, in der Mehrzahl der Fälle 

innerhalb kurzer Laufzeit gute Ergebnisse – d.h. nahezu optimale 

Anfrageauswertungspläne – zu liefern. Ein Kostenmodell stellt Funktionen zur 

Verfügung, die den Aufwand, d.h. die Laufzeit, der Operatoren der physischen Algebra 

abschätzen. Dazu werden diverse Parameter wie Indexe, Ballungen, Kardinalitäten und 

Verteilungen benötigt. [vgl. Kemper/Eickler (1996) S. 211f] 

Abbildung 44: Funktionsweise eines Kostenmodells [Quelle: Kemper/Eickler (1996) S. 212] 

- 109 -



Grundsätzlich muss entschieden werden, ob die Daten sequentiell oder über einen Index 

gesucht werden sollen. Voraussetzung für einen Indexzugriff ist selbstverständlich das 

Vorhandensein eines geeigneten Index. Stehen für den Zugriff prinzipell mehrere 

Alternativen zur Auswahl, so wird der Optimizer abschätzen, welche Zugriffsmethode 

die günstigere, d.h. die kostengünstigere ist. Dazu dient laut Müller-Angstenberger 

(1994) folgende Formel: 

Kosten des Zugriffs = X * Anzahl IOs + Y * CPU Verbauch 

Dieses grobe Modell besagt, dass pro Zugriff die Kosten der zu erwartenden IOs sowie 

die Kosten des zu erwartenden CPU Verbrauchs geschätzt und gewichtet werden. Das 

Ergebnis sind die geschätzten Gesamtkosten. [vgl. Müller-Angstenberger (1994) S. 2] 

Die Kosten aller Zugriffe ergeben sich somit aus der Summe der Einzeloperationen. Das 

gewählte Maß kann, bevor die Anfrage tatsächlich ausgeführt worden ist, nur geschätzt 

werden. Eine exakte Bestimmung setzt die Durchführung der Anfrage voraus, da nur 

dadurch die getroffenen Annahmen über die Verteilung der Daten auf dem 

Sekundärspeicher überprüft werden können. Ein solches Maß ist laut Dunemann (2002) 

„die Anzahl der Festplattenzugriffe, da anzunehmen ist, dass dieser Wert mit der 

Gesamtlaufzeit der Anfrage korreliert. Hierzu wird zum einen unterstellt, dass 

Verarbeitungen im Hauptspeicher so schnell ablaufen, dass sie einen vernachlässigbar 

geringen Anteil an der Beantwortungszeit der Anfrage ausmachen. Zum anderen wird 

bei einer Anfrage angenommen, dass das Ergebnis nicht wieder auf die Festplatte 

geschrieben wird, sondern von einer Applikation konsumiert wird. Somit kann für die 

Kostenschätzung auf die Eigenschaften der Eingangsdatenmengen abgestellt werden, 

während die Form des Ergebnisses nur für die Kosten der nachfolgenden Operationen 

relevant ist.“ [vgl. Dunemann (2002) S. 56] 

Einen ähnlichen Ansatz finden Harinarayan et al. (1996), welche die Abfragezeit als 

proportional zur Anzahl der Zeilen ansehen, die abgearbeitet werden [Harinarayan et al. 

(1996) S. 4]. 

Dabei wird folgendes lineares Kostenmodell entwickelt: 

T=m*S+c 

Dabei ist T die Laufzeit der Anfrage mit der Größe S. Und c gibt die Fixkosten (fixe 

Zeit) wieder. In dem empirischen Modell ermittelten Harinarayan et al. beispielhaft die 

Fixkosten mit 2.07 Sekunden durch experimentelles Austesten in einer Datenbank. m ist 

das Verhältnis der Abfragezeit zu der Größe S der Abfrage nach Abzug der Fixkosten. 

In der Tabelle werden die Ergebnisse von Harinarayan et al. präsentiert: 

- 110 -



Source Size Time (sec.) Ratio 

From cell itself 1 2,07 not applicable 

From view (supplier) 10000 2,38 0,000031 

From view (part, supplier) 800000 20,77 0,000023 

From view (part, supplier, customer) 6000000 226,23 0,000037 

Tabelle 9: Entwicklung der Query Response Time im Verhältnis zur Size 

[Quelle: Harinarayan et al. (1996) S. 11] 

Es gibt eine Reihe unterschiedlicher heuristischer Ansätze, wie die Kosten für eine 

Anfrage geschätzt werden können. Zur Schätzung der Eingangsdatenmenge ist aber 

zumeist auch die Menge der selektieren Tupel in der Gesamtmenge von Belang. Kessler 

(1997) teilt dabei die Schätzverfahren, welche die Anzahl der Tupel einer Relation, die 

ein bestimmtes Selektionsprädikat erfüllen, schätzen, in fünf prinzipielle 

Vorgehensweisen ein [vgl. Kessler (1997) S. 182ff]: 

• Es wird eine Gleichverteilung der Attributwerte angenommen. Mittels 

Statistikformeln wird die Zahl der Tupel geschätzt. Dabei wird eine 

Gleichverteilung der Attributwerte angenommen und für jede Relation und jedes 

Attribut die Anzahl der Tupel in der Relation, die Anzahl verschiedener 

Attributwerte, der kleinste Attributwert, der größte Attributwert und die 

Intervallbreite (entspricht größter minus kleinster Attributwert) ermittelt und in 

einer Min-Max-Statistik gespeichert. Ausgehend von diesen Werten wird die 

Selektivität der einzelnen Prädikattypen geschätzt und durch Multiplikation von 

der Anzahl der Tupel in der Relation und Selektivität die erwartete Anzahl der 

qualitativen Tupel geschätzt. 

• Es wird eine Ungleichverteilung, die durch eine geeignete 

Wahrscheinlichkeitsverteilung approximiert werden kann, angenommen. Die 

Zahl der Tupel wird wieder durch Anwendung von Formeln der Statistik 

geschätzt. (siehe letzter Absatz) 

• Die Ungleichverteilung der Attributwerte wird durch ein Histogramm 

beschrieben. Aus diesem wird die Zahl der Tupel berechnet. Grundsätzlich 

lassen sich vollständige und komprimierte Histogramme unterscheiden. In einem 

vollständigen Histogramm wird von jedem einzelnen Attributwert erfasst, wie 

oft er auftritt. Der Vorteil dieser Histogramme ist ihre Exaktheit. Der Nachteil 

ist die große Datenmenge, welche zu speichern ist. In einem komprimierten 

- 111 -



Histogramm wird die Datenmenge eingeschränkt, indem das Gesamtintervall in 

n halboffene, nicht notwendigerweise gleich große Teilintervalle aufgeteilt wird. 

Für jedes Teilintervall i wird ein Eintrag erzeugt. Dieser enthält den größten 

Attributswert, die Anzahl der Tupel und die Anzahl verschiedener Attributwerte 

im Intervall. Zusätzlich wird ein Eintrag (Teilintervall 0) mit der unteren Grenze 

des Intervall 1 angelegt. 

• Es wird keine Annahme über die Attributwertverteilung gemacht. Die Zahl der 

qualifizierten Tupel wird durch Multiplikation der Gesamtzahl der Tupel mit 

einer für die einzelnen Prädikatstypen heuristisch festgelegten Selektivität 

ermittelt. 

• Zum Zeitpunkt, zu dem eine Anfrage optimiert wird, wird auf die Relation 

zugegriffen und aus ihr eine Stichprobe, bestehend aus einer bestimmten Anzahl 

Tupel, entnommen. Ausgehend von dieser Stichprobe wird hochgerechnet, wie 

viele Tupel sich insgesamt qualifizieren werden. 

Die unterschiedlichen Ansätze zielen alle auf eine Kostenschätzung durch die 

Schätzung der Seitenzugriffe ab. Da in unserem Datawarehouse für das Materialisieren 

der Würfel typischerweise so genannte GROUP BY Abfragen durchgeführt werden, 

werden alle Tupel, bzw. Blöcke des Tables gelesen. Somit ergibt sich die Anzahl der 

Readoperationen RS für das Scannen des Table aus 

RS = Anzahl der Tupel im Table count(r)/ Anzahl der Tupel pro ReadBlock 

Ein ähnlicher Ansatz findet sich auch bei Kessler (1997). 

Zusätzlich werden jedoch noch Read Operationen für die GROUP BY Operation 

benötigt. Dabei kann die Schätzfunktion von Dunemann (2002) verwendet werden. 

⎛ count( 

r) 

⎞ 

count ( γ L ( r)) 

≈ min⎜ 

, ∏ ( distinct( 

r, 

a) 

)⎟ 

⎝ 2 a∈L 

⎠ 

[vgl. Dunemann (2002) S. 74] 

Damit sagt Dunemann, dass die Anzahl der Tupel einer GROUP BY Operation gleich 

dem Produkt der einmaligen Einträge der Tabellen sind oder wenn diese nicht bekannt 

mit der halben Tupelanzahl geschätzt wird. Diese sind in meiner Software durch den 

Benutzer einzugeben und in der Regel bekannt. So weiß der Benutzer, welcher eine 

- 112 -



GROUP BY Abfrage über Kundengruppe und Mitarbeiter haben möchte, sowohl die 

Anzahl der Kundengruppen als auch die Anzahl der Mitarbeiter. Für im Zeitablauf 

ändernde Voraussetzungen beim Aufbau des Warehouse ist eine Anpassung der 

Struktur durchzuführen. Denn eine Zunahme der Anzahl der Mitarbeiter führt zu einer 

Veränderung der Struktur und kann eine veränderte Auswahl der materialisierten 

Würfel bedeuten. 

Des weiteren muss die Sortierung der GROUP BY Ergebnisse beachtet werden. Dabei 

hängt nach Dunemann die Zeit für die Sortierung sehr stark von der Verfügbarkeit des 

Hauptspeichers ab. Kann dieser alle zu sortierenden Tupel aufnehmen, erfolgt die 

Sortierung nach dem Einlesen ohne weitere Plattenzugriffe. Die Kosten sind also 

identisch mit der eines Scans. Ist der Hauptspeicher nicht ausreichend, muss ein anderes 

Verfahren zum Einsatz kommen, welches auf der Festplatte sortiert. So kann das 

Verfahren Merge-Sort, welches bei großen Datenbeständen Einsatz findet, mit 

folgenden geschätzten Kosten verwendet werden: 

cos t E ( MergeSort( 

rclustered 

)) = 3* 

blocks( 

rclustered 

) 

[vgl. Dunemann (2002) S. 60] 

Dabei ergeben sich die Kosten einer Sortierung durch die Multiplikation der Anzahl der 

Clustered Blocks mit drei. Wenn man diese Kostenschätzung auf die GROUP BY 

Anfrage anwendet, wäre dies: 

( FactScan ( cube) 

) + 2* 

cost 

( FactScan ( cube) 

) 

cos t E ( MergeSortL 

( cube)) 

= cost 

E 

ds( 

cube) 

E 

local 

Damit wären die Kosten für eine GROUP BY Abfrage einmal das Lesen des gesamten 

Abfragewürfels und zwei mal die IO Kosten (Schreiben und Lesen) für den neuen 

materialisierten Würfel. [vgl. Dunemann (2002) S. 165] 

Die komplettesten Ansätze, speziell auf die Bewertung der CPU Kosten in GROUP BY 

Abfragen von Datawarehouse Systemen zugeschnitten, finden sich bei Jianzhong 

(1999). Sie definieren R(D1, D2, …, Dn; M) als eine multidimensionales Dataset. Die 

Dimensionsreihenfolge von R ist dabei D i , Di 

,..., D 

2 in 

und 1 i j 

- 113 - 

D entspricht dem i-ten 

Element in der j-ten Dimension. Die Aggregation von R(D1, D2, …, Dn; M) ergibt eine 

Group-by Dimensionsmenge { A , A2 

,..., Ak 

} { D1, 

D2,..., 

Dn} 

Aggregationsfunktion F. Damit ist ( A A ,..., A ; F( 

M ) ) 

1 ⊆ und eine 

S k das Ergebnisset, wo die 

1, 

2



Kosten F(M) durch die Kennzahlen von R in die Aggregationsfunktion F eingesetzt und 

errechnet werden. 

Jianzhong et al. (1999) beschreiben mehrere Aggregationsalgorithmen. Allerdings 

betreffen diese Algorithmen komprimierte Daten, sodass einige Dekomprimierungsbzw. 

Komprimierungsschritte in den Kostenfunktionen angeführt werden, welche nicht 

unbedingt notwendig sind. Ich möchte den von ihnen vorgestellten G-Aggregationsalgorithmus, 

den M-Algorithmus und den Prefix-Algorithmus hier erwähnen. G steht 

dabei für „genereller“ Algorithmus, da er in allen Situationen eingesetzt werden kann. 

Dabei wird die Transpositionsphase und die Aggregationsphase unterschieden. Der M- 

Aggregationsalgorithmus beschreibt die G-Aggregation in dem Fall, wenn das 

Aggregationsergebnis in den Speicher passt. Der Präfix-Algorithmus hat den Vorteil 

durch die Situation, dass die Group by Dimensionen ein Prefix der Dimensionsordnung 

D D , K , D des Datasets ( ) M D D D R n ; , , K ist. Dadurch kann die Aggregation in 

1, 2 

n 

, 1 2 

einem Schritt im Hauptspeicher durchgeführt werden. 

Abbildung 45: Beispielhafte Arbeitsabfolge im G-Algorithmus [Quelle: Jianzhong (1999) S. 654] 

Die Kostenschätzungen der Algorithmen für die CPU Kosten lauten wie folgt: 

⎡ N ⎤ ⎛ ⎡ 

= 2Nn 

+ 

⎢ 

B log B + ⎜ N 2N 

log 

B ⎥ ⎜ 

+ ⎢ 

⎣ ⎦ ⎝ ⎣ 

- 114 - 

⎡ N ⎤⎤ 

⎞ 

⎢ 

⎟ log 

BW ⎥⎥ 

⎣ ⎦ 

⎟ 

⎦⎠ 

CPU G 2 

r w 

2 

CPU = 2 Nn + Nh + N 

M 

CPU = N( 

2n 

+ 1) 

+ N 

Pr efix 

N … Anzahl der Tupel im Abfragetable 

n … Anzahl der Dimensionen 

r 

r 

W



B … Anzahl der Tupel pro Block 

N r … Anzahl der Tupel in der Ergebnistabelle 

W … Anzahl der benötigten Buffer 

h … Anzahl der Berechnungen der Hashing Berechnung 

[vgl. Jianzhong (1999) S. 653ff] 

Dunemann (2002), welcher in seinen Betrachtungen die CPU Kosten für die Abfragen 

ignoriert, hat einige bemerkenswerte praktische Untersuchungen über den 

Zusammenhang von Größe der BFT (Anzahl der Tupel in der BFT - count facts ) und der 

Laufzeit (Kosten) einer GROUP BY Abfrage sowie über den Zusammenhang von der 

Größe der Ergebnis-GROUP BY Tabelle (Anzahl der Tupel in den materialisierten 

Sichten - count cells ) durchgeführt. Dabei errechnet er die Anzahl der count cells aus einer 

Zeitdimension einem Quartal (13 Wochen) sowie 27 Kostenarten, 20 

Organisationseinheiten und einer Kennzahl folgende Formel: 

count cells 

= M * Zeit * Kostenart * Organisation 

=(1+1)*(13+1)*(27+1)*(20+1) 

= 16464 

Dabei wird pro Dimension ein Element für undefinierte Werte berücksichtigt. Der 

Zusammenhang der Kosten (beziehungsweise der Laufzeit) mit der Anzahl der 

count facts ergibt sich nach den Ergebnissen der Tests wie folgt: 

count 1000 2000 3000 4000 5000 6000 7000 

facts 

Laufzeit 3,707 6,360 8,686 10,790 13,486 16,484 22,063 

Somit ergibt sich ein Korrelationskoeffizient von ρ =0,986. Je dichter dieser Wert bei 1 

liegt, desto eindeutiger ist die Korrelation. Ähnliche Tests wurden mit größeren 

Tabellen durchgeführt und brachten ähnliche Ergebnisse. 

Zur Untersuchung der Korrelation zwischen count cells und der Laufzeit werden durch 

Dunemann (2002) folgende Ergebnisse präsentiert: 

count 16464 31572 47040 62328 77616 92904 

cells 

Laufzeit 13,486 38,510 67,868 91,401 118,867 135,671 

- 115 -



Das Ergebnis der linearen Reggressionsanalyse ist ρ =0,998. Damit besteht ein starker 

Zusammenhang für Kostenschätzungen. Die Auswertung für die größeren Datenwürfel 

bestätigte das Ergebnis, welches für die kleinen Datenwürfel ermittelt worden ist. 

Allerdings konnte eine geringere Korrelation festgestellt werden. Deshalb trifft 

Dunemann (2002) die Schlussfolgerung, das bei größeren Datenwürfeln der Einfluß der 

count cells im Verhältnis zum Einfluss der count facts geringer ist. 

[vgl. Dunemann (2002) S.235ff] 

Grundsätzlich kann festgestellt werden, dass über die Kostenschätzungen für Abfragen 

in der Literatur Uneinigkeit besteht. Dies ist vermutlich darauf zurückzuführen, dass die 

Kosten, bzw. die Zeit für eine Abfrage sehr stark von den aktuellen Eigenschaften der 

Datenbank abhängen. Trotzdem sind einige Ansätze zu finden, welche ich in einer 

weiter unten angeführten Kostenfunktion für meine Berechnungen verwende möchte. 

7.6 DIE HEURISTIKEN 

7.6.1 EINTEILUNG DER KOSTEN 

Um eine Auswahl der zu materialisierenden Würfel treffen zu können, ist es notwendig, 

die Kosten für diese Würfel zu berechnen. Dazu habe ich Kostenschätzfunktionen, 

welche sehr realitätsnah aber auch nicht zu komplex sein sollen, -da sie die 

Grundparameter für die Software darstellen, welche im Lehrbetrieb eingesetzt werden 

soll- entwickelt. Diese Kostenschätzfunktionen basieren auf den Ausführungen in 

Kapitel 7.5 und haben grundsätzlich auf das Ergebnis der Bewertung der Heuristik 

keinen Einfluss. Es ist auch möglich eine Bewertung der Heuristik mit zufällig 

hinterlegten Kosten durchzuführen (siehe dazu Kapitel 7.6.5). Ich möchte die 

Funktionen aber trotzdem sehr praxisnah ausformulieren, damit die Software nicht nur 

für die Lehre und Forschung einsetzbar ist -und nur Aufschluss über die Bewertung der 

Heuristiken gibt - sondern auch für die Entwicklung eines richtigen Warehouse 

eingesetzt werden kann. Somit liefert die Software realitätsnahe Ergebnisse. Allerdings 

ist natürlich diese Kostenfunktion für den praktischen Einsatz nicht ausreichend. 

Deshalb erscheint es für Datenbankentwickler sinnvoll ihre geheimen Query Optimizer 

Funktionen mit meiner Heuristik zu kombinieren und ein Endanwenderprodukt zu 

programmieren. Die Suche nach einer Kostenfunktion ist aber nicht der Kern meiner 

Forschung und einer Verbesserung der Kostenfunktion in nachfolgender 

Forschungstätigkeit steht jedenfalls nichts im Wege. 

Nach meinem Ansatz unterscheide ich zwischen Kosten für die Materialisierung eines 

Würfels aus einem anderen Würfel oder dem BFT und den Kosten für das Abfragen 

eines Würfels. Diese Unterscheidung ist deshalb essentiell, da die Kosten für die 

- 116 -



Materialisierung während des Aufbaues des Warehouse auftreten, die Kosten für die 

Abfragen jedoch beim Benutzen des Warehouse durch den User (siehe dazu Kapitel 

7.3). Es gibt für mich ein Zeitlimit und Speicherplatzlimit auf der Materialisierungsebene. 

Zusätzlich will ich aber den Ansatz von Prosser durch ein Zeitlimit für Abfragen 

auf der Userebene erweitern, da auch die Zeitanforderungen der Benutzer hinsichtlich 

Wartezeit auf Ergebnisse einbezogen werden sollten. Dieses Zeitlimit ist aber nicht 

zwingend. Das heißt, es kann durchaus die eine oder andere Abfrage länger als die 

durchschnittliche gewünschte Wartezeit der User sein. Allerdings ist die 

durchschnittliche Abfragedauer aller Abfragen limitiert. Dazu werden die Würfel, 

welche für die Benutzer interessant sind, entsprechend der Wartezeit und der 

Abfragehäufigkeit klassifiziert. 

Somit ergibt sich folgende Kostenfunktion: 

Gesamtkost en = Kosten der Abfragephase 

+ 

- 117 - 

Kosten der Materialisierungsphase 

7.6.2 KOSTENSCHÄTZFUNKTION DER ABFRAGEPHASE 

Ich betrachte hierbei die Kosten für die Abfrage eines Würfels w welcher ein Derivativ 

des Würfels v ist. Dieser Würfel w muss also durch eine Abfrage des Würfels v 

errechnet werden. Analog ist eine Abfrage eines Würfels w aus dem Base Fact Table zu 

sehen. Die Abfrage eines materialisierten Würfels w ist nach meiner Definition 0, da er 

nicht errechnet werden muss, sondern bereits aggregiert vorliegt. 

7.6.2.1 BEGRIFFSDEFINITIONEN 

AnztupelQUERY … Anzahl der Tupel in der abzufragenden Tabelle, bzw. des Joins 

Anztupel GROUPBY … Anzahl der Tupel, welche in dem materialisierten View gespeichert 

werden 

AvTime IO … Durchschnittliche Zeit für die IO Operation eines Tupels 

AvTime CPU … Durchschnittliche CPU Zeit für einen Sortierungsschritt in der Group By 

Abfrage 

Avtime MAX … durchschnittlich verfügbare Zeit pro Abfrage (maximale 

durchschnittliche Wartezeit des Benutzers)



7.6.2.2 WERTEBEREICHE UND BEDINGUNGEN 

• Wertebereich von Anztupel QUERY , AvTime CPU , Anztupel GROUPBY , AvTime IO 

und Avtime MAX : 0 ≤ x ≤ ∞ 

7.6.2.3 FUNKTION 

⎧ AvTimeIO 

* 

+ 

Kosten = ⎨ 

⎩ 

Avtime 

( AnzTupelQUERY 

2 * ( AnzTupelGROUPBY 

) ) ⎫ 

+ 

- 118 - 

MAX 

[ log AnzTupel ] 

⎧ AnzTupel GROUPBY * 2 

GROUPBY * AvTime 

⎨ 

⎩ 

AvtimeMAX 

7.6.2.4 BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION 

Die Abfragekosten werden mit dem Ausnutzungsgrad der Abfragezeit bewertet. Wenn 

also die Benutzer eine Abfragezeit mit durchschnittlich 10 Sekunden benötigen, gibt 

eine Aussage der Abfragekosten von 0,8 eine durchschnittliche Abfragedauer von 8 

Sekunden an. Dabei werden die Anzahl der Tupel, zuerst beim Table Scan in den 

Hauptspeicher gelesen und dann wird der CPU Zeit beim Sortieren und Aggregieren 

durch eine Schätzformel berechnet und mit der durchschnittlichen IO Zeit pro Operation 

multipliziert. Diese Schätzformel ist stark vereinfacht. Für den Zweck im Lehrbetrieb 

gut Ergebnisse zu erhalten aber jedenfalls ausreichend. 

7.6.3 KOSTENSCHÄTZFUNKTIONEN DER MATERIALISIERUNGSPHASE 

Die Kosten der Materialisierung versuche ich, in Anteilen der durch die 

Materialisierung verbrauchten Ressourcen an den Gesamtressourcen, zu berechnen. Je 

geringer der Ressourcenverbrauch der Materialisierung, desto kostengünstiger ist die 

Materialisierung. Dieser Ansatz ermöglicht die Kosten nicht in absoluten Zahlen, wie 

etwa in einer Währung, darzustellen zu müssen. Die realen Kosten einer Abfrage sind 

von unzähligen Parametern, wie Datenbankhersteller, Datenbank, Indizes, 

Hardewareparametern, Betriebssystemen, usw. abhängig und ändern sich auch im 

Zeitablauf. 


AnztupelQUERY … Anzahl der Tupel in der abzufragenden Tabelle, bzw. des Joins 

CPU 

⎫ 

⎬ 

⎭ 

⎬ 

⎭



Anztupel GROUPBY … Anzahl der Tupel, welche in dem materialisierten View gespeichert 

werden 

AvTime IO … Durchschnittliche Zeit für die IO Operation eines Tupels 

AvTime CPU … Durchschnittliche CPU Zeit für einen Sortierungsschritt in der Group By 

Abfrage 

AvTime STORE … Durchschnittliche Zeit zum Speichern eines Tupels in dem 

materialisierten View 

time MAX … Maximal verfügbare Zeit 

space MAX … Maximal verfügbarer Speicherplatz 

AvSize STORE … Durchschnittlicher Speicherplatz beim Speichern eines Tupels im 

materialisierten View 

weight TIME … Gewichtung der Zeit 

weight SPACE … Gewichtung des Speicherplatzes 


• Wertebereich von Anztupel QUERY , Anztupel STORE , AvTime IO , Anztupel QUERY , 

AvTime STORE , AvSize STORE und AvTime CPU : 0 ≤ x ≤ ∞ 

• Wertebereich von time MAX , space MAX : 0 < x ≤ ∞ 

• Wertebereich von weight TIME , weight SPACE : 0 ≤ x ≤ 1 

• Es gilt die Nebenbedingung: weight TIME + weight SPACE =1 


( AnzTupel 2* 

( AnzTupel ) ) 

⎧ AvTimeIO 

* 

QUERY + 

GROUPBY ⎫ 

Kosten ⎨ 

⎬* 

weight 

⎩ 

AvtimeMAX 

⎭ 

⎧ 

⎨ 

⎩ 

= TIME 

[ AnzTupel log AnzTupel ] 

GROUPBY * 2 

⎧ 

AvSize 

⎨ 

⎩ 

STORE 

Avtime 

MAX 

* AnzTupel 

space 

MAX 

GROUPBY 

GROUPBY 

- 119 - 

* AvTime 

⎫ 

⎬* 

weight 

⎭ 

CPU 

SPACE 

⎫ 

⎬* 

weight 

⎭ 

TIME 

+ 

+



Die Kosten werden durch den Ressourcenverbrauch von Zeit und Speicherplatz 

bewertet. Durch die Gewichtungsfaktoren weight SPACE für den Gewichtungsfaktor des 

Speicherplatzes und weight TIME für den Gewichtungsfaktor der Zeit kann der Benutzer 

die Kosten für Zeit und Speicherplatz gewichten. Der Speicherplatzverbrauch wird in 

Anteilen des verbrauchten Speicherplatzes ( AvSize STORE * Anztupel STORE ) am 

Gesamtspeicherplatz space MAX ausgedrückt. 

Auf Seiten der Zeitdimension wird der Zeitverbrauch in Anteilen am 

Gesamtzeitverbrauch für die Read/Write Operationen und für die CPU Operationen 

berechnet. Dazu wird die Durchschnittliche Zeit für IO Operationen pro Tupel mit der 

Anzahl der zu lesenden und schreibenden Tupel multipliziert. Diese Anzahl der Tupel 

berechnet sich nach Dunemann (2002) (siehe auch Kapitel 7.5) für eine GROUP BY 

Abfrage einmal durch das Lesen des gesamten Abfragewürfels und zwei mal die IO 

Kosten (Schreiben und Lesen) für den neuen materialisierten Würfel. Der Anteil des 

Zeitverbrauches durch das Sortieren der Group by Tupels wird durch die Anzahl der 

Sortierungsschritte multipliziert mit der durchschnittlichen CPU Zeit pro 

Sortierungsschritt geschätzt und anschließend gewichtet. 

7.6.3.4 BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION 

Die Materialisierungskosten werden in Anteilen am Ressourcenverbrauch bewertet und 

anschließend noch nach ihrer Wichtigkeit bewertet. So kann der Benutzer stufenlos 

entscheiden, ob er das Speicherplatzlimit oder das Zeitlimit höher bewerten will. Die 

Berechnung der Zeit ergibt sich durch Addieren der Zeit für das Abfragen, für die 

Group by Abfrage des Würfels und der Zeit für das Speichern des neuen Würfels in der 

Datenbank. Der Speicherplatz wird einfach durch Multiplikation der durchschnittlichen 

Größe eines Tupels mit der Anzahl der zu speichernden Tupel ermittelt. 

7.6.4 GESAMTKOSTEN 

Die Gesamtkosten ergeben sich durch Addieren und Gewichten der Abfragekosten und 

der Materialisierungskosten. 


KostenQUERY … Kosten der Abfrage 

n 

Kosten … Kosten der Materaliserung des zu materialisierenden Würfels m 

MATERALISIERENm 

weight QUERY … Gewichtung der Abfragekosten 

- 120 -



weight MATERALISIEREN 

…Gewichtung der Materalisierungskosten 

m … Zähler aller zu materialisierenden Würfel 

Anz n … Häufigkeit der Abfrage n durch den Benutzer pro Zeitintervall 

n … Zähler aller abzufragenden Würfel 


• Wertebereich von 

Kosten , Kosten MATERALISIEREN 

, n , m, Anz m 

n : 0 ≤ x ≤ ∞ 

QUERY n 

• Wertebereich von weight QUERY , weight MATERALISIEREN 

: 0 ≤ x ≤ 1 

• Es gilt die Nebenbedingung: weight QUERY + weight MATERALISIEREN 

=1 


n 

[ KostenQUERY 

Anzn 

] * weightQUERY 

+ KostenMATERALISIEREN 

weight MATERALISIEREN 

Kosten = ∑ 

* * 

n ∑ 

7.6.5 ZUFÄLLIGE KOSTEN 

Um eine wissenschaftlich fundierte Aussage über die Wertigkeit und Funktionalität der 

Heuristik zu treffen, will ich ein Austesten der Heuristik mit zufällig gewählten Kosten 

durchführen. Dies soll auch die Unabhängigkeit der Heuristik von den 

Kostenschätzfunktionen unterstreichen. Dabei können die Kosten grundsätzlich völlig 

unstrukturiert zufällig gewählt sein und die Heuristik muss die gleichen Ergebnisse 

liefern als die deterministische Lösung. Allerdings will ich, um die Kosten an die realen 

Verhältnisse anzupassen, einige Nebenbedingungen beachten. 

m 

- 121 - 

m



Abbildung 46: Schematische Aufstellung der Würfel und Kostenfunktionen 

In Abbildung 46 gebe ich eine Aufstellung eines exemplarischen Kostenbaumes. Ich 

unterscheide Würfel der ersten Ebene V, welche nur aus dem BFT materialisiert werden 

können, und Würfel der zweiten Ebene W, welche aus dem BFT oder aus einem Würfel 

der Ebene V materialisiert werden können. Diese Aufstellung kann natürlich um 

beliebige Ebenen erweitert werden. Dabei gehe ich von folgenden Grundannahmen aus: 

• Eine Kostenfunktion f() symbolisiert Kosten für die Materialisierung oder die 

Abfrage eines Würfels, in welchem eine Kante endet aus dem Würfel oder dem 

BFT, aus welchem die Kante entspringt. 

• Die Kosten für die Materialisierung oder die Abfrage eines Würfels der Ebene V 

ist immer größer als die Kosten für die Materialisierung oder die Abfrage eines 

Würfels der Ebene W direkt aus dem BFT, wenn die Anzahl der Group by 

Dimensionen von V größer ist als die Anzahl der GROUP BY Dimensionen von 

W. Das ergibt sich daraus, dass die CPU Kosten für eine Berechnung höher sind 

und die Größe der Ergebnistabelle V wesentlich mehr Tupels enthält. Haben V 

und W gleich viele GROUP BY Dimensionen hat V immer mehr Tupels als W in 

der Ergebnistabelle. Deshalb ist auch bei gleicher Anzahl der GROUP BY 

Dimensionen f(BFT,W) immer teurer als f(BFT,V). 

Forderung: ( f ( BFT, 

Vx) 

f f ( BFT, 

Wy) 

). 

• Die Kosten für die Materialisierung oder die Abfrage eines Würfels W aus der 

Vorgängerebene V ist immer kleiner oder gleich den Kosten für die 

- 122 -



Materialisierung des Würfels W aus dem BFT. Diese Forderung ergibt sich 

daraus, dass ein Aggregat immer weniger Einträge besitzt als der BFT und damit 

die Berechnungskosten (Tablescan und CPU Aggregations- und 

Sortierungskosten) kleiner sind. Forderung:( f ( Vx, 

Wx) 

p f ( BFT, 

Wx) 

) 

• Die Kosten für die Materialisierung oder die Abfrage eines Würfels der höheren 

Ebene W aus der Vorgängerebene V ist immer kleiner als die Kosten für die 

Materialisierung oder die Abfrage eines Würfels der niederen Ebene V aus deren 

Vorgängerebene U, wenn es sich um die gleiche Aggregationsdimension 

handelt. Das heißt eine Aggregation vom BFT → Kundengruppe 

ist immer 

teurer als eine Aggregation von Kundengruppe → Kundentotal 

. Diese 

Forderung ergibt sich daraus, dass z.B. die Abfrage einer Kundendatei mit 

50000 Einträgen immer länger dauert als eine Abfrage eines materialisierten 

Würfels Kundengruppe mit 5 Einträgen bei 5 Kundengruppen. Da aber eine 

nachfolgende Hierarchiestufe nie mehr Einträge haben kann als eine 

vorhergehende, ergibt sich oben angeführte Forderung. 

Forderung: ( f ( Vx, 

Wy) 

p f ( Uz, 

Vx) 

) 

• Die Kosten für das Materialisieren eines Würfels W1 aus dem Würfel V1 sind 

immer höher als die Kosten für das Abfragen des Würfels W1 aus dem 

materialisierten Würfel V. Diese Forderung ist schlüssig, da das Materialisieren 

auch ein Abfragen beinhaltet. Allerdings sind noch zusätzlich Operationen wie 

etwa Speichern, Sortieren, etc. notwendig, welche die höheren Kosten bedingen. 

Forderung: Abfragekosten



Kosten der Erstellung von einem Würfel zum anderen oder direkt aus dem BFT, der 

Anzahl der Tables über die ein Join gemacht werden muss, der Anzahl der 

Dateneinträge, welche durchsucht werden müssen, dem Grad der weiteren Aggregation 

und der Index Struktur, beeinflusst. Ein Query Optimizer kann benutzt werden, um 

diese Information zu liefern, welche benutzt werden kann um die Kosten zwischen den 

Würfeln δ ( v, 

w) 

zu schätzen. Die Kosten für die Materialisierung von v aus dem BFT 

wären dann C M ( v) 

= δ ( BFT, 

v) 

. Analog sind die Kosten für das Materialisieren von w 

aus v aus einer Abfrage ( w) 

= δ ( v, 

w) 

. Die Kosten für weitere Abfragen und 

C Q 

Berechnungen basierend auf w werden nicht betrachtet, da diese ohnehin anfallen. Als 

Berechnungsgrundlage haben wir eine Menge von interessanten Würfeln (required 

cubes) und die relative Wichtigkeit f(w) für jeden Würfel. Der marginale Nettoeffekt 

E(.), wenn nur v als einziger Würfel im APA betrachtet wird, ist die Differenz zwischen 

den Kostenverminderung, durch die Tatsache das alle Derivate w ∈ A(v) 

von v direkt 

aus v anstatt vom BFT berechnet werden können, im Vergleich zu den Kosten für die 

Materialisierung von v. Wird v vom BFT als der erste Cube materialisiert gilt: 

∑ 

E ( M = {}, v) 

= [ f ( w) 

* ( δ ( BFT, 

w) 

− δ ( v, 

w))] 

− δ ( BFT, 

v) 

w ≠ v, 

w ∈ A( 

v) 

w 

Dabei ist es nicht notwendig w ∈ A(v) 

auf die interessanten Würfel zu beschränken, da 

die uninteressanten Würfel die relative Wichtigkeit von f(w) = 0 haben. Die Kosten für 

die Materialisierung der Menge M = {v} beträgt somit 

C( 

M ) = δ ( BFT, 

v) 

+ ∑ f ( w) 

* δ ( BFT, 

w) 

+ ∑ f ( w) 

* δ ( v, 

w) 

w∉ 

A( 

v) 

w∈A( 

v) 

Deshalb kann das Optimierungsproblem definiert werden als: 

min 

M 

→ C( 

M ), s * t * space( 

M ) ≤ space 

Für dieses Problem definiert Prosser die Heuristik wie folgt: 

- 124 - 

max 

, s * t * time( 

M ) ≤ time 

Berechne E(BFT,v) für jeden Würfel im APA und definiere v mit dem höchsten 

E(BFT,v) als ersten Würfel welcher M zugesetzt wird. Somit ist M1={v} 

Führe die folgende Prozedur durch: 

Spaceortime_limit_reached ← false 

/* k is used as a counter for the iterations */ 

k=1 

do until spaceortime_limit_reached=true 

w ≠ v 

max



// define the set of all cubes which can be derived from any materialized cube 

at stage k 

define A( 

M k ) U 

x∈M 

k 

= A( 

x) 

/* the net effect of each single cube which has not been materialized yet is 

computed*/ 

do for all k M w ∈ 

end do 

/* the u ∈ A(w) 

may already be in the derivative set of materialized 

cubes */ 

^ 

define U k ( w) 

= { u / u ∈ A( 

w)^ 

u ∈ A( 

M )} 

define U k ( w) 

= { u / u ∈ A( 

w)^ 

u ∉ A( 

M k )} 

/* is cube w itself a derivative of another cube which has already been 

materialized?*/ 

if ( k ) M A w ∉ 

else 

end if 

/* no → w can only be built from the BFT */ 

k 

= ∑ 

u∈U 

[ f ( u) 

* ( δ ( BFT, 

u) 

− ( w, 

u ] 

E ( M , w) 

δ )) 

∑ 

u∈Uˆ 

- 125 - 

k 

[ max( 

0, 

f ( u) 

* ( δ ( x, 

u) 

− δ ( w, 

u)) 

| ∀x 

∈ M / u ∈ A( 

x) 

) ] − δ ( BFT, 

w) 

/* yes → w will be built from the existing cube with the least 

distance measure 

in that case U k must be empty*/ 

E ( M , w) 

[ max( 

0, 

f ( u) 

* ( δ ( x, 

u) 

− δ ( w, 

u) 

| ∀x 

∈ M / u ∈ A( 

x) 

) ]− 

k 

= ∑ 

u∈U 

( δ ( x, w) 

| ∀x 

∈ M k / w ∈ A( 

) ) 

min x 

/* now the net effect off all cubes not materialized at step k is known, the best 

one is chosen */ 

+ 

k 

k



choose → max( E( 

M , w) 

)∑M+ 1 = M ∪{ 

w} 

w k 

k k 

if ( M 1) 

spacemaxor 

time( 

M 1) 

≥ timemax 

space k+ 

≥ k+ 

spaceortime_limit_reached ← true 

materialize k M 

else k ← k + 1 

end if 

end do 

Der Algorithmus startet mit M 1 = { v} 

. Danach werden so lange neue Würfel 

materialisiert bis entweder das Zeitlimit oder das Speicherlimit erreicht ist. In jedem 

Durchlauf wird zuerst k, der Nettoeffekt jedes individuellen Würfels k M w ∉ berechnet. 

Da wir an einem Performanceanstieg interessiert sind, welcher sich aus der Möglichkeit 

ergibt, die Derivative u ∈ A(w) 

nun direkt aus w zu erzeugen. Natürlich kann es sein, 

dass diese Würfel u auch ein Derivativ eines anderen Würfels k M x ∈ sind, welcher 

auch bereits bis zum Durchlauf k materialisiert wurde. Deswegen werden U und Uˆ entsprechend definiert. Zu beachten ist jedoch, dass beide Werte abhängig von dem 

aktuellen Zustand der Menge M k und dem Würfel w, welcher aktuell betrachtet wird, 

sind. Dabei werden zwei Fälle unterschieden: 

Wenn w kein Derivativ eines Würfels ist, welcher bereits gewählt wurde ( ( k ) M A w ∈ ), 

ist der Nettoeffekt E( M k , w) 

im Durchlauf k 

• für u ∈ U k (w) 

(also Würfel, welche sonst direkt vom BFT erzeugt 

werden müssten) die Kostenersparnis, welche sich durch Erzeugen von u 

δ − gewichtet mit f(u)) 

aus w anstatt direkt vom BFT ( ( BFT , u) 

δ ( w, 

u) 

ergibt. 

• für alle u ∈ Uˆ 

k ( w) 

(also Würfel, welche ein Derivative eines bereits für 

die Materialisierung ausgewählten Würfels x sind) durch die 

Kostenersparnis repräsentiert, welche sich aus dem Erzeugen von u aus 

w anstatt aus x ergibt, wobei x bei mehreren Derivativen den Würfel mit 

den minimalen Materialisierungskosten repräsentiert. Dabei wird 

unterstellt, dass eine Kostenersparnis da ist, sonst wird diese mit 0 

bewertet. Daraus ergibt sich die logische Formulierung 

max 0, 

f ( u) 

* δ ( x, 

u) 

− δ ( w, 

u) 

| ∀x 

∈ M k / u ∈ A( 

x) 

. Diese wird für 

( ( ) 

) 

- 126 -



alle u ∈ Uˆ 

aussummiert und wenn dieser Nettoeffekt positiv ist zum 

Nettoeffekt von w hinzugezogen. 

Da ( k ) M A w ∉ wird der Würfel direkt aus dem BFT mit den Kosten ( ) w BFT, δ 

materialisiert. 

Wenn w ein Derivative eines Würfels ist, welcher bereits im Durchlauf k für die 

Materialisierung ausgewählt wurde, bedeutet dies, dass keine „neuen“ Würfel gebildet 

werden können. Die Materialisierung vom w macht also nur dann Sinn, wenn einige 

Würfel bedeutend schneller materialisiert werden können als zuvor. Der Nettoeffekt der 

Materialisierung von w leitet sich deshalb ab durch: 

• Berechnen der Nettoeffekte für alle ∈ Uˆ 

( w) 

wie oben. 

- 127 - 

u k 

• Berechnen der Erzeugungskosten für w als die minimalen möglichen 

Kosten δ ( x, 

w) 

aus allen Würfeln x, aus welchen w errechnet werden 

kann ( w ∈ A(x) 

). 

Nachdem der Nettoeffekt aller Würfel w im APA berechnet wurde, wird jener mit dem 

maximalen Verbesserungsbetrag gewählt und der Menge M k+ 

1 zugesetzt. Wenn weder 

das Zeitlimit oder das Speicherlimit überschritten wird, wird weitergesucht und der 

Durchlauf von vorne begonnen. Sonst wird die Suche abgebrochen und M k als 

Ergebnismenge der zu materialisierenden Würfeln festgelegt. 

7.6.7 HEURISTIK VON THOMAS ACHS 

7.6.7.1 PSEUDOCODE DER HEURISTIK 

{1. Vorbereitungen für die Iterationen} 

Erzeuge Menge R der Required Cubes 

Erzeuge Menge D der Derivative Cubes durch Hinzufügen aller 

nicht redundanten Würfel, welche mindestens 1 Derivative 

haben, welches wiederum in der Menge R enthalten sind. 

P=R ∪ D //Vereinige die Menge R und die Menge D zur Menge 

P der PossibleCubes für die Materialisierung. 

MaxSets:=20; //setzt die maximalen Sets, welche 

kontrolliert werden auf 20 – je höher man



diesen Wert setzt umso genauer wird die 

Heuristik. 

NewSetsforeachiteration:= 3; //bestimmt die zusätzlichen 

Sets pro Iterationsstep 

Setcounter:=-1; //zählt die aktuellen Wege, welche 

kontrolliert werden 

Setcount:=1;//Anzahl der Wege 

{Ende der Vorbereitungen für die Iterationen} 

{2. Iterationen der Sets} 

Repeat; 

{2.1 Vorbereiten des Startsets für die Iteration} 

If Setcounter=-1 then MatCube={} 

// Beim ersten Set ist die Menge der bereits 

materialisierten Würfel leer 

Else begin 

End; 

//Betrachte das nächste Set und errechne das 

verbleibende Limit 

MatCube=Sets[Setcounter]; 

Berechne Limits of MatCube; 

{Ende 2.1. Vorbereiten des Startsets für die Iteration} 

{2.2. Beginn der Iteration des aktuellen Sets} 

While limitreached(MatCube)=false do begin 

- 128 -



For each Cube c ∈ P do begin 

//Ist der Cube c noch nicht materialisiert 

If bereitsmaterialisiert(c)=false then 

begin 

MinMatCosts:= MatCosts(BFT); 

//Die minimalen Materialisierungskosten sind 

die Kosten für die Materialisierung des Cubes 

aus dem BFT 

MerkeMatCube:=BFT; //MerkeMatCube enthält den 

Cube aus dem c erzeugt werden kann. Wenn nicht 

aus einem bereits materialisierten Cube 

abgeleitet werden kann, dann leite aus BFT ab 

(Standard) 

{2.2.1 Feststellen des Cubes aus dem der Cube c 

materialisiert wird: Dazu kontrolliere alle bereits 

materialisierten Cubes z, ob c aus z abgeleitet werden 

kann} 

For each Cube z ∈ MatCube do begin; 

if kannabgeleitetwerden(c,z)=true then 

begin 

//Kann der Cube aus einem bereits 

materialisierten Cube z erzeugt werden 

//Merke dir den Cube mit den minimalen 

Materialisierungskosten 

if (MatCosts(z)



End; //if kannabgeleitetwerden(c,z) 

End;//Ende von z ∈ MatCube 

{Ende 2.2.1 Feststellen des Cubes aus dem der Cube c 

materialisiert wird} 

{2.2.2 Festellen der Derivative und der Summe der 

Abfragekosten der Derivative für den Cube c} 

Summequery:=0; //Die Abfragekosten sind 0 

for each Cube x ∈ R do begin 

//Kontrolliere alle Required Cubes 

if x is derivative von c then begin 

//Wenn der required Cube x ein Derivative von c 

ist, dann beachte die Querykosten 

MinQueryCosts:= QueryCosts(MerkeMatCube); 

//Merken der minimalen Querykosten. Diese 

sind die Kosten für die Materialisierung 

aus dem Vorgänger von c. 

MerkeQueryCube:=MerkeMatCube; 

//Wenn es keinen besseren Cube y gibt wird 

der required cube x aus dem Vorgänger von c 

abgefragt, solange c noch nicht besteht. 

//Feststellen, ob es einen besseren Cube y 

gibt und speichern in MerkeQueryCubes 

for Each y ∈ MatCube do begin 

If (MinQueryCosts>QueryCosts(x,y) 

//Abfragekosten des required Cubes 

x aus dem bereits materialisierten 

Cube y 

then begin 

- 130 -



MerkeQueryCube:=y;//Markiere den 

Cube y als Abfragecube von x 

MinQueryCosts:=QueryCosts(y); 

End; //Ende von if 

End; //Ende von for Each y ∈ MatCube 

{2.2.2.1 Berechnen der Verbesserung der Abfragekosten durch 

das Materialisieren von c} 

Summequery:= Summequery+max(0, 

//Kosten für Abfrage von x 

((GetQueryCosts(MerkeQueryCube,x)- 

//Kosten für das Abfragen aus c 

GetQueryCost(c,x)))*Häufigkeit der Abfrage); 

{Ende 2.2.2.1 Berechnen der Verbesserung der Abfragekosten 

durch das Materialisieren von c} 

end; //ist ein Derivative 

end; //Ende von Each Cube x ∈ R 

{Ende 2.2.2 Festellen der Derivative und der Summe der 

Abfragekosten der Derivative für den Cube c} 

{2.2.3 Berechnen der Verbesserung der Gesamtkosten durch 

das Materialisieren von c} 

δK(c)=SummeQuery - GetMatCosts(MerkeMatCube); 

//Kostenersparnis δK(c) ist die Ersparnis bei den 

Abfragen (SummeQuery) minus der 

Materialisierungskosten für den Würfel c 

- 131 -



{Ende 2.2.3 Berechnen der Verbesserung der Gesamtkosten 


End; //Ende von If bereitsmaterialisiert(c)=false 

End;//von each c ∈ P 

{2.2.4 Gibt es einen Cube c mit Positivem δK(c) 

(Kostenersparnis) und innerhalb der Limits: True- dann 

setze den c mit Max(δK(c)) dem aktuellen Set zu; False – 

dann schließe das Set ab} 

if (∀ c ∈ P ∃ max(δK(c))>0)and(Limitreached(c)=false) 

then 

Begin; 

MatCube.add(c)//Addiere den Cube zum aktuellen Set 

{2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes, 

welche das Limit erfüllen dann wähle die 

NewSetsForEachIteration besten Cubes und eröffne neue Sets 

solange bis MaxSets erreicht.} 

for counter:=1 to Settiefe do begin; 

setcount:=setcount+1; 

If setcount



{Ende 2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes, 

welche das Limit erfüllen dann wähle die 

NewSetsForEachIteration besten Cubes und eröffne neue Sets 

solange bis MaxSets erreicht.} 

End //Ende von if (∀ c ∈ P ∃ max(δK(c))>0) and 

(Limitreached(c)=false) 

else limitreached:=true; 

//Else abbrechen: Gibt es keinen Cube, welcher einen 

positiven Kostenbeitrag bringt und in das Limit passt, 

dann schließe das Set ab. 

{Ende 2.4 Gibt es einen Cube c mit Positivem δK(c) 

(Kostenersparnis) und innerhalb der Limits: True- dann 

setze den c mit Max(δK(c)) dem aktuellen Set zu; False – 

dann schließe das Set ab} 

End;//Ende von limitreached=false 

{Ende 2.2. Der Iteration des aktuellen Sets} 

Sets[Setcounter]:=MatCube; 

//Merke dir das neue Set der Materialisierten Würfel 

in Sets[Setcounter] 

Setcounter:=Setcounter+1; 

//Setze den Zeiger auf das nächste Set 

Until Setcounter>=MaxSets; 

//Die Schleife läuft so lange bis die maximale Anzahl 

von Sets (MaxSets – wird vom Benutzer festgelegt) 

kontrolliert ist 

{Ende 2. Iterationen der Sets} 

- 133 -



{3. Berechne die Gesamtkosten für jedes Set} 

For Setcounter:=0 to Setcount do begin 

CalculateCostsforEachSet(Sets); 

End; 

{Ende 3. Berechne die Gesamtkosten für jedes Set} 

{4. Materialisiere jenes Set mit den minimalen Kosten} 

Materialize Set MinCosts(Sets); 

{Ende 4. Materialisiere jenes Set mit den minimalen Kosten} 

7.6.7.2 BESCHREIBUNG DER HEURISTIK 

Zu Beginn wird die Menge P der Possible Cubes berechnet, welche alle Required Cubes 

und alle Parent Cubes (Vorgänger der Required Cubes – somit ist der Required Cube 

ein Derivative des Parent Cubes) umfasst. Dann wird MaxSets als die Menge der zu 

kontrollierenden Sets und NewSetsforEachIteration als Anzahl der neuen Sets pro 

Iterationsschritt durch den Benutzer definiert. Der Parameter Setcounter gibt die 

Nummer des aktuelle betrachteten Cubesets an und Setcount gibt die Anzahl der bereits 

berechneten Cubesets an. 

Nach der Vorbereitungsphase wird die Schleife für die Iterationen gestartet 

Costimproofment 

∑ 

x∈A( 

c) 

max 

− getbuild 

{ 0, 

[ getquery( 

min( 

P( 

x) 

, x) 

− getquery( 

c, 

x) 

) ] * Anz } 

( min( 

P( 

c) 

) , c) 

c 

= 

7.6.7.3 DEMONSTRATIVES BEISPIEL 

In diesem Abschnitt wird ein demonstratives Beispiel für die Funktionsweise der 

Heuristik gegeben. Dabei gehen wir von dem in Abbildung 48 angeführten APA aus. 

Die Eingabemaske des Input Screens mit den Dimensionen und Hierarchien findet sich 

in Abbildung 47. Wir gehen dabei von einem APA mit 3 Dimensionen und zwei 

Hierarchiestufen in der ersten Dimension, drei Hierarchiestufen in der zweiten 

Dimension und drei Hierarchiestufen in der dritten Dimension aus. Das ergibt eine 

Anzahl von 23 potentiellen Cubes von diesen sind 9 Required Cubes. Das Ergebnis der 

Heuristik wird in Abbildung 48 dargestellt. Die Anzahl der maximal möglichen Sets 

wurde mit 20 definiert und die maximal mögliche neue Setanzahl pro Iterationsschritt 

- 134 - 

x



wurde mit 4 definiert. Im Vorfeld darf jedoch vorweggenommen werden, dass die 

Limits so gewählt wurden, dass sich eine Lösung von 6 Cubes ergibt und nur 18 

mögliche Lösungswege vorhanden sind. Im Beispiel liefert die Heuristik eine 100 % 

richtige Lösung. 

Abbildung 47: Dimensionen und Hierarchien des DemoAPA 

Abbildung 48: DemoAPA mit Lösung 

Die Heuristik beginnt mit der Auswahl der Possible Cubes und dem Starten der 

Iteration. Im ersten Durchlauf wird der Fokus auf das Set 1 gesetzt, welches leer ist. 

- 135 -



Dann beginnt die Iteration. Im ersten Iterationsschritt wird der Gewinn der 

Materialisierung eines jeden Cubes unabhängig von den anderen Cubes berechnet. Als 

bester Cube (mit der höchsten Gesamtkostenverringerung) würde der Cube 1:3 

festgestellt und dem Set 1 zugesetzt. 

1. Schritt: Finde den ersten Cube im aktuellen Set (1) 

Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs 

1 1:3 

2 

3 

4 

5 

6 

7 

8 

9 

10 

11 

12 

13 

14 

15 

16 

17 

18 

19 

20 

Abbildung 49: Schritt 1 der Heuristik nach Thomas ACHS 

Als nächstes beginnt die Phase des Zusetzens der nächstbesten Cubes. Dabei wird der 

zweitbeste Cube dem Set 2, der drittbeste Cube dem Set 3,der viertbeste Cube dem Set 

4 und der fünftbeste Cube dem Set 5 als erster Cube zugesetzt bis entweder kein anderer 

Cube einen positiven Kostenbeitrag in der aktuellen Iterationsstufe liefern kann oder die 

maximale Anzahl der Cubes, welche zugesetzt werden dürfen 

(NewSetsForEachIteration – wird durch den Benutzer definiert) erreicht ist. 

- 136 -



2. Schritt: Zusetzen des zweitbesten bis fünftbesten Cubes in neue Sets, 

wenn sie positiven Nutzen haben und in das Limit passen 


1 1:3 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 

7 

8 

9 

10 

11 

12 

13 

14 

15 

16 

17 

18 

19 

20 


Im Schritt 3 ist nun die erste Iteration abschlossen und nun wird im nächsten Schritt der 

Wert aller Cubes unter Berücksichtigung dessen, dass der Cube 1:3 bereits im Set 1 

materialisiert wurde, berechnet und der beste ausgewählt. Dies ist der Cube 1:4. 

3. Schritt: Finde den nächsten Cube im aktuellen Set (1) 


1 1:3 1:4 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 

7 

8 

9 

10 

11 

12 

13 

14 

15 

16 

17 

18 

19 

20 


Dann werden die Sets mit den zweitbesten, drittbesten, usw. Cubes als Cube 2 

zugesetzt. An Position 1 steht der beste Cube des ersten Sets. 

- 137 -



4. Schritt: Eröffne neue Sets mit den zweitbesten bis fünftbesten Cubes 

in Position 2, wenn sie positiven Nutzen haben und in das Limit passen 


1 1:3 1:4 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 

11 

12 

13 

14 

15 

16 

17 

18 

19 

20 


Beim dritten Iterationsschritt kristallisiert sich der Cube 2:0 als beste Cube für das Set 1 

heraus. Deshalb wird dieser dem Set 1 zugesetzt. 

5. Schritt: Finde nächsten Cube im aktuellen Set (1) 


1 1:3 1:4 2:0 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 

11 

12 

13 

14 

15 

16 

17 

18 

19 

20 


Im Anschluss werden wiederum die neuen Sets mit dem nächstbesten Cubes in Phase 3 

zugesetzt. Dabei ist zu beachten, dass die ersten beiden Cubes aus dem Set 1 

übernommen werden und nur in der letzten Position die nächstbesten Cube zugesetzt 

werden. 

- 138 -






1 1:3 1:4 2:0 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 1:3 1:4 0:3 

11 1:3 1:4 1:2 

12 1:3 1:4 0:5 

13 1:3 1:4 0:0 

14 

15 

16 

17 

18 

19 

20 


In Abbildung 55 (7. Schritt) wird die vierte Iteration gestartet und der Cube 1:2 als der 

nächste beste Cube gefunden und dem Set zugesetzt. 



1 1:3 1:4 2:0 1:2 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 1:3 1:4 0:3 

11 1:3 1:4 1:2 

12 1:3 1:4 0:5 

13 1:3 1:4 0:0 

14 

15 

16 

17 

18 

19 

20 


Abermals werden die nächsten besten Cubes in Schritt 8 in den neuen Sets hinzugefügt. 

- 139 -






1 1:3 1:4 2:0 1:2 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 1:3 1:4 0:3 

11 1:3 1:4 1:2 

12 1:3 1:4 0:5 

13 1:3 1:4 0:0 

14 1:3 1:4 2:0 0:5 

15 1:3 1:4 2:0 0:0 

16 1:3 1:4 2:0 2:2 

17 1:3 1:4 2:0 1:5 

18 

19 

20 


Im fünften Iterationsschritt wird der Cube 2:2 als bester gefunden. Dieser wird zugesetzt 

und die Kontrolle der nächstbesten Cubes gestartet. 



1 1:3 1:4 2:0 1:2 2:2 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 1:3 1:4 0:3 

11 1:3 1:4 1:2 

12 1:3 1:4 0:5 

13 1:3 1:4 0:0 

14 1:3 1:4 2:0 0:5 

15 1:3 1:4 2:0 0:0 

16 1:3 1:4 2:0 2:2 

17 1:3 1:4 2:0 1:5 

18 

19 

20 


Die maximale Anzahl der Sets wurde vom Benutzer mit 20 Sets definiert. Dadurch ist 

nach dem Zusetzen des zweitbesten Cubes zum Set 18, des drittbesten Cubes zum Set 

19 und des vierbesten Cubes zum Set 20 keine weiteren Sets. 

- 140 -



10. Schritt: Eröffne neue Sets mit den zweitbesten bis fünftbesten 

Cubes in Position 5, wenn sie positiven Nutzen haben (Hinweis: Nach 

dem Set 20 ist die maximale Anzahl der Sets erreicht. Neue Sets werden 

nur so lange eröffnet, solange es Cubes gibt, die eine positiven Nutzen 

bringen und in das Limit passen oder die Anzahl der maximalen Sets 

erreicht ist. Deshalb werden keine neuen Sets mehr eröffnet) 


1 1:3 1:4 2:0 1:2 2:2 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 1:3 1:4 0:3 

11 1:3 1:4 1:2 

12 1:3 1:4 0:5 

13 1:3 1:4 0:0 

14 1:3 1:4 2:0 0:5 

15 1:3 1:4 2:0 0:0 

16 1:3 1:4 2:0 2:2 

17 1:3 1:4 2:0 1:5 

18 1:3 1:4 2:0 1:2 1:5 

19 1:3 1:4 2:0 1:2 2:4 

20 1:3 1:4 2:0 1:2 3:2 


Damit ist die Aufbauphase der Sets abgeschlossen und es erfolgt die Berechnungsphase 

für das aktuelle und alle folgenden Sets. Im Moment befinden wir uns noch im Set 1 

und suchen den nächsten Cube, welcher den besten Beitrag bringt und in die Limits 

passt. Dieser ist 2:4. 



1 1:3 1:4 2:0 1:2 2:2 2:4 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 1:3 1:4 0:3 

11 1:3 1:4 1:2 

12 1:3 1:4 0:5 

13 1:3 1:4 0:0 

14 1:3 1:4 2:0 0:5 

15 1:3 1:4 2:0 0:0 

16 1:3 1:4 2:0 2:2 

17 1:3 1:4 2:0 1:5 

18 1:3 1:4 2:0 1:2 1:5 

19 1:3 1:4 2:0 1:2 2:4 

20 1:3 1:4 2:0 1:2 3:2 


- 141 -



Im Schritt 12 finden wir den Cube 2:3 als siebenten Cube des Sets 1, welcher den 

höchsten positiven Beitrag zu Kostenverringerung bringt und in die Limits passt. 



1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 1:3 1:4 0:3 

11 1:3 1:4 1:2 

12 1:3 1:4 0:5 

13 1:3 1:4 0:0 

14 1:3 1:4 2:0 0:5 

15 1:3 1:4 2:0 0:0 

16 1:3 1:4 2:0 2:2 

17 1:3 1:4 2:0 1:5 

18 1:3 1:4 2:0 1:2 1:5 

19 1:3 1:4 2:0 1:2 2:4 

20 1:3 1:4 2:0 1:2 3:2 


Nach dem Zusetzen des siebenten Cubes findet sich kein Cube mehr, welcher einen 

positiven Beitrag bringt und in die Limits passt. Deshalb wird das Set 1 als 

abgeschlossen betrachtet und der Fokus auf das Set 2 gelegt. 

13. Schritt:Limit im Set 1 erreicht. Setze den Setcounter+1 (=2). 


1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 1:3 1:4 0:3 

11 1:3 1:4 1:2 

12 1:3 1:4 0:5 

13 1:3 1:4 0:0 

14 1:3 1:4 2:0 0:5 

15 1:3 1:4 2:0 0:0 

16 1:3 1:4 2:0 2:2 

17 1:3 1:4 2:0 1:5 

18 1:3 1:4 2:0 1:2 1:5 

19 1:3 1:4 2:0 1:2 2:4 

20 1:3 1:4 2:0 1:2 3:2 


Da nun das Set 2 den Fokus hat, wird analog zum Set 1 immer der beste Cube zugesetzt, 

welcher in die Limits passt. 

- 142 -



14. Schritt:Berechne das noch vorhandene Limit nach der 

Berücksichtigung der bereits im neuen Set enthaltenen Cubes und 

starte die Iteration des neuen Sets. 


1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 

2 0:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 1:3 1:4 0:3 

11 1:3 1:4 1:2 

12 1:3 1:4 0:5 

13 1:3 1:4 0:0 

14 1:3 1:4 2:0 0:5 

15 1:3 1:4 2:0 0:0 

16 1:3 1:4 2:0 2:2 

17 1:3 1:4 2:0 1:5 

18 1:3 1:4 2:0 1:2 1:5 

19 1:3 1:4 2:0 1:2 2:4 

20 1:3 1:4 2:0 1:2 3:2 


Dies wird so lange durchgeführt bis kein Cube mehr dem Set 2 zugesetzt werden kann 

und der Fokus wandert auf das Set 3 usw. 



1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 

2 0:3 1:3 

3 1:4 

4 2:3 

5 0:5 

6 1:3 2:3 

7 1:3 0:5 

8 1:3 0:3 

9 1:3 2:4 

10 1:3 1:4 0:3 

11 1:3 1:4 1:2 

12 1:3 1:4 0:5 

13 1:3 1:4 0:0 

14 1:3 1:4 2:0 0:5 

15 1:3 1:4 2:0 0:0 

16 1:3 1:4 2:0 2:2 

17 1:3 1:4 2:0 1:5 

18 1:3 1:4 2:0 1:2 1:5 

19 1:3 1:4 2:0 1:2 2:4 

20 1:3 1:4 2:0 1:2 3:2 


Im Schritt 95 sehen wir das bereits fast vollendete Lösungsgitter der Sets 1 bis 20. Das 

Set 20 wird im Schritt 97 endgültig abgeschlossen. 

- 143 -





1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 

2 0:3 1:3 1:4 2:0 1:2 2:4 2:3 

3 1:4 1:3 2:3 2:0 1:2 2:2 2:4 

4 2:3 1:3 1:4 2:0 1:2 2:2 2:4 

5 0:5 1:3 1:4 2:0 2:2 2:4 2:3 

6 1:3 2:3 0:3 1:4 2:0 1:2 2:4 

7 1:3 0:5 1:4 2:0 2:2 2:4 2:3 

8 1:3 0:3 1:4 2:0 1:2 2:4 2:3 

9 1:3 2:4 2:3 2:0 1:2 2:2 

10 1:3 1:4 0:3 2:3 2:0 1:2 2:4 

11 1:3 1:4 1:2 2:0 2:2 2:4 2:3 

12 1:3 1:4 0:5 2:3 0:3 2:0 2:4 

13 1:3 1:4 0:0 2:0 2:4 2:3 

14 1:3 1:4 2:0 0:5 2:3 2:4 2:2 

15 1:3 1:4 2:0 0:0 1:0 2:4 2:3 

16 1:3 1:4 2:0 2:2 1:2 2:4 2:3 

17 1:3 1:4 2:0 1:5 2:4 1:2 2:3 

18 1:3 1:4 2:0 1:2 1:5 2:4 2:3 

19 1:3 1:4 2:0 1:2 2:4 2:2 2:3 

20 1:3 1:4 2:0 1:2 2:4 2:2 




1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 

2 0:3 1:3 1:4 2:0 1:2 2:4 2:3 

3 1:4 1:3 2:3 2:0 1:2 2:2 2:4 

4 2:3 1:3 1:4 2:0 1:2 2:2 2:4 

5 0:5 1:3 1:4 2:0 2:2 2:4 2:3 

6 1:3 2:3 0:3 1:4 2:0 1:2 2:4 

7 1:3 0:5 1:4 2:0 2:2 2:4 2:3 

8 1:3 0:3 1:4 2:0 1:2 2:4 2:3 

9 1:3 2:4 2:3 2:0 1:2 2:2 

10 1:3 1:4 0:3 2:3 2:0 1:2 2:4 

11 1:3 1:4 1:2 2:0 2:2 2:4 2:3 

12 1:3 1:4 0:5 2:3 0:3 2:0 2:4 

13 1:3 1:4 0:0 2:0 2:4 2:3 

14 1:3 1:4 2:0 0:5 2:3 2:4 2:2 

15 1:3 1:4 2:0 0:0 1:0 2:4 2:3 

16 1:3 1:4 2:0 2:2 1:2 2:4 2:3 

17 1:3 1:4 2:0 1:5 2:4 1:2 2:3 

18 1:3 1:4 2:0 1:2 1:5 2:4 2:3 

19 1:3 1:4 2:0 1:2 2:4 2:2 2:3 

20 1:3 1:4 2:0 1:2 3:2 2:4 2:3 


- 144 -



97. Schritt:Limit im Set 20 erreicht. Setze den Setcounter+1 (=21). 

Setcounter überschreitet die Anzahl der Sets (Setcount). Deshalb 

beende die Iterationsphase. 


1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 

2 0:3 1:3 1:4 2:0 1:2 2:4 2:3 

3 1:4 1:3 2:3 2:0 1:2 2:2 2:4 

4 2:3 1:3 1:4 2:0 1:2 2:2 2:4 

5 0:5 1:3 1:4 2:0 2:2 2:4 2:3 

6 1:3 2:3 0:3 1:4 2:0 1:2 2:4 

7 1:3 0:5 1:4 2:0 2:2 2:4 2:3 

8 1:3 0:3 1:4 2:0 1:2 2:4 2:3 

9 1:3 2:4 2:3 2:0 1:2 2:2 

10 1:3 1:4 0:3 2:3 2:0 1:2 2:4 

11 1:3 1:4 1:2 2:0 2:2 2:4 2:3 

12 1:3 1:4 0:5 2:3 0:3 2:0 2:4 

13 1:3 1:4 0:0 2:0 2:4 2:3 

14 1:3 1:4 2:0 0:5 2:3 2:4 2:2 

15 1:3 1:4 2:0 0:0 1:0 2:4 2:3 

16 1:3 1:4 2:0 2:2 1:2 2:4 2:3 

17 1:3 1:4 2:0 1:5 2:4 1:2 2:3 

18 1:3 1:4 2:0 1:2 1:5 2:4 2:3 

19 1:3 1:4 2:0 1:2 2:4 2:2 2:3 

20 1:3 1:4 2:0 1:2 2:4 2:2 2:3 


Nachdem alle Sets im Schritt 97 abgeschlossen sind, erfolgt die Kostenberechnung für 

jedes Set separat. Dabei wird die Materialisierungsreihenfolge der Cubes entsprechend 

eine kostenminimalen Materialisierung berechnet. Deshalb haben auch das Set 1, 3 , 4, 

11, 16 und 19 die gleichen Kosten, da es sich im Prinzip um die gleiche Menge an 

Cubes handelt, nur in unterschiedlicher Reihenfolge. Die Heuristik berechnet aber die 

Kosten immer in der Reihenfolge der minimalen Materialisierungskosten einer Menge. 

Aus diesem Grund müssen die gleichen Kosten entstehen. 

- 145 -



98. Berechne die Kosten für jedes Set. Diese bestehen aus den 

Materialisierungskosten pro Set und den Abfragekosten der Required 

Cubes beeinflusst durch die Auswahl des Sets. 


1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 155.136,00 

2 0:3 1:3 1:4 2:0 1:2 2:4 2:3 561.381,00 

3 1:4 1:3 2:3 2:0 1:2 2:2 2:4 155.136,00 

4 2:3 1:3 1:4 2:0 1:2 2:2 2:4 155.136,00 

5 0:5 1:3 1:4 2:0 2:2 2:4 2:3 484.339,00 

6 1:3 2:3 0:3 1:4 2:0 1:2 2:4 561.381,00 

7 1:3 0:5 1:4 2:0 2:2 2:4 2:3 484.339,00 

8 1:3 0:3 1:4 2:0 1:2 2:4 2:3 561.381,00 

9 1:3 2:4 2:3 2:0 1:2 2:2 135.898,00 

10 1:3 1:4 0:3 2:3 2:0 1:2 2:4 561.381,00 

11 1:3 1:4 1:2 2:0 2:2 2:4 2:3 155.136,00 

12 1:3 1:4 0:5 2:3 0:3 2:0 2:4 966.857,00 

13 1:3 1:4 0:0 2:0 2:4 2:3 1.483.283,00 

14 1:3 1:4 2:0 0:5 2:3 2:4 2:2 484.339,00 

15 1:3 1:4 2:0 0:0 1:0 2:4 2:3 1.478.603,00 

16 1:3 1:4 2:0 2:2 1:2 2:4 2:3 155.136,00 

17 1:3 1:4 2:0 1:5 2:4 1:2 2:3 333.905,00 

18 1:3 1:4 2:0 1:2 1:5 2:4 2:3 333.905,00 

19 1:3 1:4 2:0 1:2 2:4 2:2 2:3 155.136,00 

20 1:3 1:4 2:0 1:2 3:2 2:4 2:3 468.248,00 


Anschließend wird das Set mit den minimalen Kosten materialisiert. Dieses ist in 

unserem Beispiel das Set 9 mit den minimalen Kosten von 135898. 

99. Wähle das kostengünstigste Set und materialisiere das Set. 


1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 155.136,00 

2 0:3 1:3 1:4 2:0 1:2 2:4 2:3 561.381,00 

3 1:4 1:3 2:3 2:0 1:2 2:2 2:4 155.136,00 

4 2:3 1:3 1:4 2:0 1:2 2:2 2:4 155.136,00 

5 0:5 1:3 1:4 2:0 2:2 2:4 2:3 484.339,00 

6 1:3 2:3 0:3 1:4 2:0 1:2 2:4 561.381,00 

7 1:3 0:5 1:4 2:0 2:2 2:4 2:3 484.339,00 

8 1:3 0:3 1:4 2:0 1:2 2:4 2:3 561.381,00 

9 1:3 2:4 2:3 2:0 1:2 2:2 135.898,00 

10 1:3 1:4 0:3 2:3 2:0 1:2 2:4 561.381,00 

11 1:3 1:4 1:2 2:0 2:2 2:4 2:3 155.136,00 

12 1:3 1:4 0:5 2:3 0:3 2:0 2:4 966.857,00 

13 1:3 1:4 0:0 2:0 2:4 2:3 1.483.283,00 

14 1:3 1:4 2:0 0:5 2:3 2:4 2:2 484.339,00 

15 1:3 1:4 2:0 0:0 1:0 2:4 2:3 1.478.603,00 

16 1:3 1:4 2:0 2:2 1:2 2:4 2:3 155.136,00 

17 1:3 1:4 2:0 1:5 2:4 1:2 2:3 333.905,00 

18 1:3 1:4 2:0 1:2 1:5 2:4 2:3 333.905,00 

19 1:3 1:4 2:0 1:2 2:4 2:2 2:3 155.136,00 

20 1:3 1:4 2:0 1:2 3:2 2:4 2:3 468.248,00 


- 146 -



7.7 DIE DETERMINISTISCHE LÖSUNG 

7.7.1 MATHEMATISCHE GRUNDLAGEN 

Im Zuge der Bestimmung der deterministischen Lösung ist es notwendig, für alle 

möglichen Mengen von materialisieren Cubes die Kosten zu berechnen und die Menge 

auszuwählen, welche die geringsten Kosten hat. Dabei spielt die Rangfolge der 

materialisierten Cubes in der Menge eine Rolle. Spielt die Anordnung der Elemente in 

einer Menge eine Rolle, nennt man diese eine Folge [vgl. Witt (2001) S. 137]. Wenn der 

Cube a vor dem Cube b materialisiert wurde und b ein Derivative von a ist, die 

Materialisierungskosten für die Folge < a ,b > geringer sind als die 

Materialisierungskosten < b,a >. Das führt dazu, dass die Materialisierungssequenz von 

enormer Bedeutung sein kann. 

7.7.1.1 PERMUTATION 

Wir betrachten dabei die Auswahl von Folgen, in denen ein Element höchstens einmal 

vorkommen darf. Dies ist schlüssig, da ein Würfel nur einmal materialisiert werden 

kann. Bei dieser speziellen Art der Permutation spricht man von der Permutation ohne 

Wiederholung [vgl. Witt (2001) S. 137]. 

Sei M eine Menge mit M = n und 

∈ . Ein k-Permutation von M ist eine Folge 

n 

k N0 

< k > x x 1 ,..., mit xi ∈ M und xi ≠ x j für i ≠ j , mit 1 ≤ i, j ≤ k . Weiters sei P ( n, 

k) 

die 

Anzahl der k-Permutationen, die aus n-elementigen Menge gebildet werden kann. 

[vgl. Witt (2001) S. 137f] 

n k 1 n! 

P( 

n, 

k) 

= n( 

n −1)( 

n − 2)...( 

n − k + 1) 

= ∏i = ∏ ( n − i) 

= 

( n − k)! 

− 

7.7.1.2 KOMBINATION 

- 147 - 

i= 

n−k 

+ 1 

Im Gegensatz zur Permutation spielt bei der Kombination die Reihenfolge der Elemente 

in der Menge keine Rolle. Wir gehen wieder von der Kombination ohne Wiederholung 

aus, was bedeutet, dass jedes Element in der Menge nur einmal vorkommt. 

Sei M eine Menge mit M = n und 

n 

k N0 

i= 

0 

∈ . Ein k-Kombination von M ist eine 

Teilmenge von M mit k Elementen. Weiters sei K ( n, 

k) 

die Anzahl der k- 

Kombinationen, die aus der Menge M gebildet werden können. 

n! 

K( 

n, 

k) 

= 

k!*( 

n − k)!



[vgl. Witt (2001) S. 141f] 

7.7.2 DER ALGORITHMUS FÜR DIE PERMUTATION 

{1. Vorbereitungen für die Permutation} 


Erzeuge Menge P der Possible Cubes, welche die Menge der 

nicht redundanten Würfel umfasst und gib jedem Würfel einen 

Nummer. 

Erzeuge Countliste (array of longint) als die Teilmenge der 

Menge P mit den Nummern der Possible Cubes. 

anzcube=count(P) //Gibt die Anzahl der Elemente in der 

Menge P der Possible Cubes an. 

Alwaysspacemaxreached=true//Abbruchbedingung 

Cubepos=1 

maxpos=0 

aktpos=0 

{Ende 1. Vorbereitungen für die Permutation} 

if (anzcube>0) then begin 

{2. Beginn der Permutationsschleife} 

ende=false 

While (ende=false) do begin 

{2.1. Beginn der Unterpermutationsschleife für den letzten 

Zähler} 

Repeat 

if (Cubepos>anzcube) then begin 

{2.1.1 Wenn in der aktuellen Cursorposition das Maximum 

erreicht ist} 

- 148 -



Cubepos=1 

Countliste[aktpos]=cubepos; 

aktpos=aktpos+1 

if aktpos>maxpos then maxpos=aktpos 

if aktposanzcube then begin 

if cubepos>anzcube then begin 

cubepos=1 

Countliste[aktpos]:=cubepos 


if aktpos>maxpos then maxpos=aktpos 

end; 

if Countliste[aktpos]=0 then begin 

//Neue Zählung 

if Alwaysspacemaxreached=true then ende=true 

// Wenn alle Cubes dieses Durchlaufs z.B. 8 

Cubes das Speichermax überschritten haben 

hat es keinen Sinn auch noch 9 Cubes zu 

kontrollieren. 

Alwaysspacemaxreached=true 

cubepos=1 

Countliste[aktpos]=Cubepos 

end else begin 

//Springe auf gespeicherte Position 

Countliste[aktpos]= Countliste[aktpos]+1 

Cubepos=Countliste[aktpos] 

end 

until (Cubepos



Cubepos=1 

aktpos:=0 


end //Ende if (cubeposanzcube) 

end //Ende if aktposanzcube) 

else 

begin // Beginn von if (Cubepos>anzcube)=false 

{2.1.2 Wenn in der aktuellen Cursorposition das Maximum 

nicht erreicht} 

aktpos=0; 

istok=true 

//Feststellen,ob jedes Element in der Folge nur 

einmal vorkommt 

for zahler:=0 to maxpos do begin 

//Es wird von der Position bis zum Ende 

kontrolliert da die ersten Positionen schon 

verglichen wurden 

for zahler2:=zahler to maxpos do begin 

if ((zahler2zahler)and 

(Countliste[zahler2]=Countliste[zahler])) 

then 

istok=false 

end // von for zahler2 

end // von for zahler 

if istok=true then begin 

- 150 -



Spaceleft=spaceleft(Countliste) 

//Feststellen des Speicherplatzes nach der 

Materialisierung vom Countliste 

Spaceleftfirstcubes= 

spaceleft(Countliste[0..maxpos-1]) 

//Berechnen von spacemax von allen Würfeln 

ausser dem aktuellen Würfel. Das heißt bei 

z.B. 8 Cubes wird nur der spaceleft von 

Cube 1 bis 7 berechnet 

if Spaceleftfirstcubes0) then begin 

Alwaysspacemaxreached=false 

kostenmerk= 

KostenfuerSetberechnen(Countliste) 

if (kostenmerk>0) then begin 

if (kostenmerk



End//Ende von If (spaceleft>0) 

end //Ende von istok 

Cubepos=Cubepos+1 


{Ende 2.1.2 Wenn in der aktuellen Cursorposition das 

Maximum nicht erreicht ist} 

end //Ende von if (Cubepos>anzcube)=false 

until (Cubepos>anzcube) 

{Ende 2.1. Ende der Unterpermutationsschleife für den 

letzten Zähler} 

End; 

{Ende 2. Beginn der Permutationsschleife} 

End //von if (anzcube>0) 

7.7.3 DER ALGORITHMUS FÜR DIE KOMBINATION 

{1. Vorbereitungen für die Kombination} 


Erzeuge Menge P der Possible Cubes, welche die Menge der 

nicht redundanten Würfel umfasst und gib jedem Würfel einen 

Nummer. 

Erzeuge Countliste (array of longint) als die Teilmenge der 

Menge P mit den Nummern der Possible Cubes. 

Mincosts=0 

anzcube=count(P) //Gibt die Anzahl der Elemente in der 

Menge P der Possible Cubes an. 

- 152 -



{Ende 1. Vorbereitungen für die Kombination} 

{2. Algorithmus für die Kombination} 

lang=0 //gibt den aktuellen Wert für k (Anzahl der 

Kombinationen an – lang=k-1) 

Countliste[0]=1; //Startwert für die Kombination ist der 

Cube 1 

Ende=false; //Abbruchwert 

{2.2. Laufe durch die Kombination bis ende=true} 

repeat; 

alwaysspacemaxreached:=true; 

//Wenn alle Kombinationen von z.B. 7 Cubes das 

Speicherlimit überschreiten, wird auch eine 

Kombination von 8 Cubes den Speicherwert jedenfalls 

überschreiten. Darum Abbruch bei 

alwaysspacemaxreached. 

aktpos=0 //Gibt den Cursor auf das erste Element der 

Countliste 

istok=true 

{2.2.1 Durchlaufe alle Kombinationen mit dem aktuellen 

lang Wert} 

repeat //(neuespalte=true)or(ende=true) 

neuespalte=false 

{2.2.1.1 Istok=true} 

if (istok=true) then begin 

Spaceleft=spaceleft(Countliste) 

//Feststellen des Speicherplatzes nach der 

Materialisierung vom Countliste 

Spaceleftfirstcubes= 

spaceleft(Countliste[0..maxpos-1]) 

//Berechnen von spacemax von allen Würfeln 

ausser dem aktuellen Würfel. Das heißt bei 

z.B. 8 Cubes wird nur der spaceleft von 

Cube 1 bis 7 berechnet 

- 153 -



if Spaceleftfirstcubes0) then begin 

Alwaysspacemaxreached=false 

Getrightorder(Countliste) 

//Stelle die kostenminimale Reihenfolge 

der Cubes mit einem abwandelten 

Algorithmus von Dijkstra her 

kostenmerk= 

KostenfuerSetberechnen(Countliste) 

if (kostenmerk>0) then begin 

if (kostenmerk0) 

End //Ende von if (istok=true) 

{Ende 2.2.1.1 Istok=true} 

{2.2.1.2. Ist in der aktuellen Position (aktpos) das 

Maximum erreicht oder nicht} 

- 154 -



if countliste[aktpos]>=(anzcube-aktpos) then 

begin 

{2.2.1.2.1 Setze alle cubes vom aktpos und kleiner auf 1} 

Countliste[aktpos]=1 

x=aktpos 

repeat 

Countliste[x]=1 

x=x-1; 

until x=-1 

{Ende 2.2.1.2.1 Setze alle cubes vom aktpos und kleiner auf 

1} 


if countliste[aktpos]=0 then 

neuespalte=true 

Countliste[aktpos]:=countliste[aktpos]+1 

{2.2.1.2.2. Finde den nächsten Cube, welcher nicht das 

Maximum hat} 

repeat; 

if Countliste[aktpos]>(anzcube-aktpos) 

then begin 


if (aktpos>anzcube) then begin 

aktpos=anzcube 

ende=true 

end 

if Countliste[aktpos]=0 then 

neuespalte=true 

Countliste[aktpos]= 

Countliste[aktpos]+1 

end 

until (Countliste[aktpos]



x=aktpos-1 

istok=true 

repeat 

if x>=0 then begin 

Countliste[x]=Countliste[x+1]+1 

end 

x=x-1 

until x=(anzcubeaktpos) 

else begin 

Countliste[aktpos]=countliste[aktpos]+1 

aktpos=0 

end 

{Ende 2.2.1.2. Ist in der aktuellen Position (aktpos) das 

Maximum erreicht oder nicht} 

until (neuespalte=true)or(ende=true) 

{Ende 2.2.1. Durchlaufe alle Kombinationen mit dem 

aktuellen lang Wert} 

if alwaysspacemaxreached=true then ende=true 

lang=lang+1 

until (ende=true)or(lang>anzcube) 

{Ende 2.2. Laufe durch die Kombination bis ende=true} 

7.7.4 DER ALGORITHMUS DER FUNKTION GETRIGHTORDER 

Cost 

x 

= 

∑ 

z∈A( 

x) 

max 

{ 0, 

[ getbuild( 

min( 

P( 

z) 

, z) 

− getbuild( 

x, 

z) 

) ] } 

Empfange Parameter Listecubes als Menge der zu 

materialisierten und zu ordnenden Cubes 

- 156 -



Definiere die Knoten mittels 

Knotendeklationszeiger= ^Knotendeklaration als Zeiger 

auf ein Record 

Knotendeklaration = 

record 

Knoten:longint; 

spalte:longint; 

zeile:longint; 

MaxAbstand:Extended; 

Parent:longint; 

end; 

Definiere Randknoten als Menge von Knoten 

Definiere Innere_Knoten als Menge von Knoten 

{1. Erzeuge die Menge der Randknoten und berechne die 

Kosten} 

for zahler:=0 to Listecubes.Count-1 do begin 

//Die Cubes können nur aus dem BFT erzeugt werden 

Kostengewinn:=0; 

for zahler2:=0 to Listecubes.count-1 do begin 

if (isderivat(Listecubes[zahler].spalte, 

Listecubes[zahler].zeile, 

Listecubes[zahler2].spalte, 

Listecubes[zahler2].zeile)=true) then begin 

//Der Kostengewinn ergibt sich daraus, 

dass sich die Derivative zahler2 in 

Zukunft aus dem Cube zahler ableiten 

lässen. 

Kostengewinn=Kostengewinn+ 

(//Da noch kein Würfel materialisiert 

wurde, werden alle vom BFT erzeugt 

max(0,getbuild(-1,-1, 


Listecubes[zahler2].zeile))getbuild(Listecubes[zahler].spalte, 

Listecubes[zahler].zeile), 


Listecubes[zahler2].zeile))) 

- 157 -



end; //isderivat(… 

end // von zahler2 

//Erzeugen und Speichern des Cube 

New(Knoten) 

Knoten^.Knoten=zahler; 

Knoten^.MaxAbstand=Kostengewinn; 

Knoten^.Parent=-1; 

Knoten^.spalte= Listecubes[zahler].spalte 

Knoten^.zeile= Listecubes[zahler].zeile 

Randknoten.Add(Knoten); 

end; 

{Ende 1. Erzeuge die Menge der Randknoten und berechne die 

Kosten} 

{2. Durchlaufen der Randknoten bis die Menge der Randknoten 

leer ist und alle Knoten in der Menge der Innere_Knoten 

sind.} 

repeat 

{ 2.1.Feststellen des neuen Randknotens mit dem minmalen 

Abstand und Überstellen dieses Knotens von den Randknoten 

zu den Inneren Knoten} 

zahlermerk:=-1;costmerk:=0; 

for zahler=0 to Randknoten.Count-1 do begin 

Knoten= Randknoten.Items[zahler] 

if (Knoten^.MaxAbstand>costmerk) or(zahlermerk=-1) then 

begin 

zahlermerk=zahler 

costmerk:=Knoten^.MaxAbstand; 

end; 

end; 

//Zusetzen des Würfels zu Inneren Knoten 

- 158 -



Knotenmerk=Randknoten.Items[zahlermerk]; 

Innere_Knoten.Add(Knotenmerk); 

Randknoten.Delete(zahlermerk); 

{Ende 2.1.Feststellen des neuen Randknotens und Überstellen 

dieses Knotens von den Randknoten zu den Inneren Knoten} 

if Randknoten.Count>0 then begin 

{2.2. Durchlaufe die aktuelle Menge der Randknoten} 

for zahler=0 to Randknoten.count-1 do begin 

Knoten= Randknoten.items[zahler]; 

{2.2.1 Stelle fest, ob die Randknoten Derivative von dem 

neuen Inneren Knoten sind. Wenn ja und die Kosten sind 

geringer als die vom BFT, dann ändere Kosten. Ist jedoch 

der neue Innere Cube ein Derivative von dem Randknoten, 

müssen die Kosten neu berechnet werden.} 

if 

(isderivat(Knotenmerk^.spalte,Knotenmerk^.zeile, 

Knoten^.spalte,Knoten^.zeile)=true) or 

(isderivat(Knoten^.spalte,Knoten^.zeile, 

Knotenmerk^.spalte,Knotenmerk^.zeile)=true) 

then begin 

{2.2.1.1 Durchlaufe alle Randknoten und suche Parent} 


for zahler2:=0 to Randknoten.Count-1 do begin 

Knoten2:=Randknoten.Items[zahler2] 

//Stelle fest, ob dieser Randknoten ein Derivat ist 

if (isderivat(Knoten^.spalte,Knoten^.zeile, 

Knoten2^.spalte,Knoten2.zeile)=true) 

and(Knoten^.KnotenKnoten2^.Knoten) then begin 

//Finde das Kostenminimale Parent von Knoten2 

Parentvonderivat=-1 

Parentvonderivatcostmerk:=getbuild(-1,-1, 

Knoten2.spalte,Knoten2^.zeile) 

for zahler3:=0 to Innere_Knoten.count-1 do begin 

- 159 -



Knoten3:=Innere_Knoten.Items[zahler3] 

if (isderivat(Knoten3^.spalte,Knoten3^.zeile, 

Knoten2^.spalte,Knoten2^.zeile)=true)and 

(Knoten3^.KnotenKnotenmerk^.Knoten)and 

(Knoten3^.KnotenKnotenmerk^.Knoten)then begin 

costmerk:=getbuild(Knoten3^.spalte, 

Knoten3^.zeile, Knoten2^.spalte, 

Knoten2^.zeile) 

if (costmerk



der neue Innere Cube ein Derivative von dem Randknoten, 

müssen die Kosten neu berechnet werden} 

end //zahler 

{Ende 2.2. Durchlaufe die aktuelle Menge der Randknoten} 

end // Ende von Randknoten.count>0 

until Randknoten.Count=0 

{Ende 2. Durchlaufen der Randknoten bis die Menge der 

Randknoten leer ist und alle Knoten in der Menge der 

Innere_Knoten sind.} 

{3. Übergebe die Sequenz der Inneren Randknoten} 

Result:=Innere_Randknoten 

{Ende 3. Übergebe die Sequenz der Inneren Randknoten} 

7.7.5 DER ALGORITHMUS DER FUNKTION 

KOSTENFUERSETBERECHNEN 

Diese Funktion berechnet die Kosten eines an die Funktion übergebenen Menge von 

Materialisierten Würfel und einer an die Funktion übergebenen Menge von Required 

Cubes. Dabei werden die Materialisierungs- und die Abfragekosten berechnet und 

zurückgegeben. Wird das Zeitlimit der Materialisierung überschritten, wird als Wert 0 

zurückgeben. 

Empfange Parameter MatCubes als Menge der zu 

materialiserten Cubes 

Empfange Parameter ReqCubes als Menge der required Cubes 

{1. Feststellen, ob die Cubes die Spacemaxbedingung 

erfüllen} 

spaceleft=calculatespacemaxof(Countliste) 

timeleft=Maxavailabletime 

{Ende 1. Feststellen, ob die Cubes die Spacemaxbedingung 

erfüllen} 

- 161 -



if spaceleft>0 then begin 

{2. Kosten berechnen} 

SummeKosten=0 

{2.1 Ersten Cube zusetzen} 

aktspalte=MemoryCubes[Countliste[0]].spalte 

//Spaltenwert des ersten Cubes 

aktzeile=MemoryCubes[Countliste[0]].zeile 

//Zeilenwert des ersten Cubes 

newcosts=getbuild(-1,-1,aktspalte,aktzeile) 

//Der erste Cube wird aus dem BFT (-1,-1) erzeugt. 

Deshalb sind die newcosts gleich den 

Materialisierungskosten aus dem BFT 

SummeKosten=SummeKosten+newcosts 

Memorywuerfel.Add(aktspalte,aktzeile) 

timemax=timemax-newcosts //Vermindere Timemax um die 

Materialisierungszeit des ersten Cube 

{Ende 2.1 Ersten Cube zusetzen} 

{2.2 Weitere Cubes zusetzen} 

for x= 1 to Maxpos do begin 

aktspalte:=MemoryCubes[Countliste[x]].spalte; 

aktzeile:=MemoryCubes[Countliste[x]].zeile; 

{2.2.1 Kann der Cube aus einem bereits materialisierten 

Cube abgeleitet werden} 

if isderivatof(Memorywuerfel)=true then begin 

newminderivatspalte:=GetMinDerivatOfSpalte(aktspa 

lte,aktzeile) 

newminderivatzeile:=GetMinDerivatOfZeile(aktspalt 

e, 

aktzeile) 

newcosts=getbuild(newminderivatspalte, 

newminderivatzeile,aktspalte,aktzeile); 


Memorywuerfel.Add(aktspalte,aktzeile); 

timemax:=timemax-newcosts 

- 162 -



end 

{Ende 2.2.1 Kann der Cube aus einem bereits 

materialisierten Cube abgeleitet werden} 

{2.2.2 Der Cube kann nicht aus einem bereits 


else begin 

newcosts=getbuild(-1,-1,aktspalte,aktzeile) 


Memorywuerfel.Add(aktspalte,aktzeile); 

timemax:=timemax-newcosts 

end 

{Ende 2.2.2 Der Cube kann nicht aus einem bereits 


end //Ende von for x=1 … 

{Ende 2.2 Weitere Cubes zusetzen} 

{2.3 Berechnen der Kosten für die Abfragen aller Required 

Cubes} 

for zahler=0 to MemoryReqCubescount.count-1 do begin 

spalte=MemoryReqCubes[zahler].spalte 

zeile=MemoryReqCubes[zahler].zeile 

{2.3.1. Wenn der Cube aus den materialisierten Cubes 

abgefragt werden kann} 

if isderivatof(Memorywuerfel)=true then begin 

newminderivatspalte= 

GetMinDerivatOfSpalte(spalte,zeile) 

newminderivatzeile= GetMinDerivatOfZeile(spalte,zeile) 

newcosts= ((getquery( newminderivatspalte, 

newminderivatzeile, spalte, zeile)) 

*APA[spalte,zeile].gewicht);//Häufigkeit der Abfrage 

(globale Variable APA) 


end 

{Ende 2.3.1. Wenn der Cube aus den materialisierten Cubes 

abgefragt werden kann} 

{2.3.2. Wenn der Cube nur aus dem BFT abgefragt werden 

kann} 

- 163 -



else begin 

newcosts=((getquery(-1,-1,spalte,zeile)) 

*APA[spalte,zeile].gewicht) //Häufigkeit der 

Abfrage (globale Variable APA) 


End 

{Ende 2.3.2. Wenn der Cube nur aus dem BFT abgefragt werden 

kann} 

end; 

{Ende 2.3 Berechnen der Kosten für die Abfragen aller 

Required Cubes} 

{Ende 2. Kosten berechnen} 

if (timemax0 

{3. Übergeben der Kosten} 

Result=SummeKosten 

Spaceleft=spacemax //Globale Variable spaceleft 

Timeleft=timemax //Globale Variable timeleft 

{Ende 3. Übergeben der Kosten} 

7.8 DIE ENTWICKLUNGSUMGEBUNG UND DIE APPLIKATION 

7.8.1 AUSWAHL DER ENTWICKLUNGSUMGEBUNG 

Die Auswahl der Entwicklungsumgebung ging mit der Auswahl des Betriebssystems 

analog. Das Ziel war natürlich eine Anwendung zu gestalten, welche auf möglichst 

vielen Betriebssystemen lauffähig ist. Die Hauptanwenderzielgruppe sind die Studenten 

der Wirtschaftsuniversität Wien, welche die Anwendung in den Seminaren als 

Fortbildungsinstrument nutzen sollen. Da die Rechner der Wirtschaftsuniversität auf 

Windows laufen wurde somit ein Windowslauffähiges Programm als 

Mindestanforderung an die Programmierumgebung definiert. Schließlich fiel die 

- 164 -



Entscheidung auf eine im Besitz des Autors befindliche Version vom Borland Delphi 

(siehe auch www.borland.com) Version 7.0 for .NET. Dieser Softwarecompilier 

produziert sowohl Windows lauffähige Version, als auch, über Kylix compiliert, eine 

Linux lauffähige Version des Programms. Zusätzlich steht die Produktion der .NET 

fähigen Delphi Version Octane unmittelbar bevor. Dann wäre eine Compilierung auf 

.NET möglich. 

In den ersten Versionen des Programms wurde zusätzlich eine Datenbank integriert. 

Allerdings ist eine Installation eines Programms mit einem Datenbanktreiber auf den 

Rechner der Universität nur mit Administratorrechten möglich. Deshalb wurde die 

Datenbank wieder entfernt und auf eine Speicherung der Daten in einfachen Datenfiles 

mit eigener Indexprogrammierung ausgewichen. 

7.8.2 ENTWURF DER BENUTZERSCHNITTSTELLE 

Die Benutzerschnittstelle der Software soll in übersichtlicher Weise dem Benutzer – 

zumeist Studenten – die Möglichkeit bieten, das System des APA zu verstehen und ein 

Datawarehouse zu modellieren. Ich will dabei die wichtigsten modularen Schnittstellen 

kurz vorstellen. 

7.8.2.1 DAS HAUPTMENU 

Das Hauptmenü des APA Programmes ist übersichtlich gestaltet. Die wichtigsten 

Unterscreens des Programmes, der Input Screen, der APA Grid Screen und APA 

Selection Screen werden entsprechend der logischen Abfolge im Zentrum angeordenet. 

Zusätzlich gibt das Hauptmenü unter dem Punkt File die Möglichkeit APAs zu laden 

und zu speichern. Unter dem Menupunkt Screens können alle Screens separat 

aufgerufen werden. Der Punkt Berechnung ermöglicht das Erstellen der Zufallskosten 

und einige Analysetools für das APA Grid. Im Unterpunkt Settings ist es möglich, die 

Optionen für das Programm und die Parameter für die Heuristik bzw. die 

deterministische Lösung einzustellen. Im Menüpunkt Help findet man eine ausführliche 

Dokumentation des Software Tools, welches unerfahrenen Benutzern beim Einstieg in 

die Software begleiten soll. 

- 165 -



Abbildung 69: Das Hauptmenu des APA Programmes 

7.8.2.2 DIE EINGABEMASKE (INPUT SCREEN) 

Die Eingabemaske ermöglicht dem Benutzer das Eingeben und Ordnen der Dimension 

und Hierarchien. Zusätzlich werden die Key Figures eingegeben, welche für das 

Generieren der SQL Statements benötigt werden. Die Hierarchien werden mit der 

Anzahl ihrer Ausprägungen gespeichert. Dadurch können im Hintergrund 

Berechnungen über Tupelanzahl der einzelnen Tabellen durchgeführt werden. 

- 166 -



Abbildung 70: Der APA Input Screen 

7.8.2.3 DIE PRÄSENTATIONSMASKE (APA SCREEN) 

Die Präsentationsmaske des APA Grid ist das umfangreichste Modul im Programm. Es 

erlaubt dem Benutzer nicht nur das Betrachten und Analysieren des APA, sondern auch 

Ausführen einer Reihe von Analysetools und Anzeigen von Hintergrundinformation. 

Dabei können die Funktionen über das Hauptmenü oder für zellenbasierende 

Funktionen über das Popup Menu aufgerufen werden. Zusätzlich sind Buttons für 

häufige Funktionen unter dem Hauptmenü angeordnet. 

- 167 -



Abbildung 71: Die Präsentationsmaske des APA Grid 

7.8.2.4 DIE AUSWAHLMASKE DER REQUIRED CUBES (SELECTION 

SCREEN) 

Der APA Selection Screen soll den Benutzer unterstützen, die „Required Cubes“ im 

APA, welche für ihn interessant sind, zu finden. Dies ist besonders bei großen APAs 

mit zahlreichen Dimensionen und Hierarchiestufen von Bedeutung, da die 

Übersichtlichkeit durch Benutzen des APA Selection Screen bestehen bleibt. Zusätzlich 

können Roll Ups oder Drill Down über Dimensionen durchgeführt werden und in einem 

Eingabeschritt markiert werden. 

- 168 -



Abbildung 72: Die Auswahlmaske der Required Cubes 

7.8.3 DATENMODELLIERUNG DER APPLIKATION 

7.8.3.1 AUSWAHL DER DATENBANK 

Die Auswahl der Hauptdatenbank für die Applikation wurde auf den Vorschlag von 

Prof. Prosser mit Microsoft SQL fixiert. Das Ziel ist es nicht nur die Eingaben in die 

APA Software speichern zu können, sondern auch die CREATE TABLE Anweisungen 

für die BFT und Zusatztabellen (bei Fact Constellation Schema) zu generieren. 

Zusätzlich war mein Ansinnen jedoch, die Daten der Applikation für weitere 

Datenbanken (MySql, Paradox) und sogar als Textfile sichern zu können. Dies ist 

besonders für die weltweite Benutzung essentiell. Die Endversion des Programms 

wurde aber ohne eine Datenbankanbindung produziert, da die Installation der 

Datenbank auf der Universität nicht ohne Administratorrechte durchgeführt werden 

kann und das Ziel eine universell einsetzbare Anwendung im Vordergrund stand. 

Trotzdem sollte eine Endbenutzerversion des Programms mit eine leistungsfähigen 

Datenbank kombiniert werden. Dies ist besonders im vernetzten betrieblichen Einsatz 

notwendig, wo für den einzelnen Benutzer unterschiedliche Benutzerrechte gelten. 

- 169 -



7.8.3.2 SEMANTISCHE DATENMODELLIERUNG 

Die Semantische Datenmodellierung beschreibt die Daten als ER Diagramm. Das 

folgende ER-Diagramm soll die Grundlage der Daten in einer MS SQL Datenbank 

darstellen. Diese Datenbanken werden jedoch nicht von der im Anhang beschriebenen 

Software real verwendet, da diese im Lehrbetrieb auf der Wirtschaftsuniversität 

verwendet werden soll und das Anlegen von Benutzerrechten für jeden Studenten eine 

große administrative Aufgabenstellungen bedeuten würde. Allerdings will ich 

exemplarisch diese Variante durchdiskutieren. Sollte jedoch diese Software jemals zu 

einem Endanwenderprodukt für den Verkauf aufgewertet werden, bildete diese 

Datenmodellierung die Grundlage und gibt zusätzlich ein gutes demonstratives Beispiel 

für die klassische Datenmodellierung. 

- 170 -



Abbildung 73: ER-Diagramm für die APA Datenbank 

Das ER-Diagramm besteht aus einer Reihe von Entitäten und Beziehungen. Aus 

Gründen der besseren Übersicht und klaren Lesbarkeit wurden die Attribute in dieser 

Darstellung entfernt. 

Die Entität „Administrator“ steht mit der Entität „Benutzer“ in einer m:n Beziehung. Es 

soll ein Systemadministrator mehrere Benutzer bearbeiten können und ein Benutzer soll 

von mehreren Systemadministratoren bearbeitet werden können. 

Die Entität „Benutzer“ besitzt mehrere „Gitter“. Ein Benutzer kann also mehrere Data 

Warehouse Modelle parallel bearbeiten. Ein „Gitter“ wird aber immer nur einem 

Benutzer zugeordnet. 

- 171 -



Das „Gitter“ enthält oder besteht aus vielen „Zellen“. Diese Zellen kann man sich 

ähnlich einer Zelle in einem Tabellenkalkulationsprogramm vorstellen. Die Entität 

„Zelle“ repräsentiert aber wiederum einen speziellen „Würfel“ (Cube) im 

multidimensionalen Data Warehouse. Wobei jede „Zelle“ immer nur einen „Würfel“ 

repräsentieren kann. 

Ein „Würfel“ hat wiederum spezifische Eigenschaften, die ihn beschreiben. Er besteht 

aus einer Reihe von Dimensionen, die wiederum eine bestimmte Hierarchiestufe haben. 

Dies wird mit der „virtuellen“ Entität „Dimension auf einer Hierarchiestufe“ 

ausgedrückt. Ein „Würfel“ kann sich aus mehreren Dimensionen mit einer bestimmten 

Hierarchiestufe zusammensetzen. Eine Dimension kann aber nur einmal in einem 

Würfel vorkommen. Deshalb ist die Beziehung zwischen der Entität „Würfel“ und der 

Entität „Dimension auf einer Hierarchiestufe“ eine 1:n Beziehung. 

Das „Gitter“ wird generiert aus mehreren „Dimensionen“, die wiederum mehrere 

„Hierarchiestufen“ haben können. Deshalb gibt es sowohl eine 1:n Beziehung zwischen 

der Entität „Gitter“ und „Dimensionen“, als auch zwischen der Entität „Dimensionen“ 

und „Hierarchiestufen“. 

„Dimensionen“ werden mehrmals von der Entität „Dimension auf einer 

Hierarchiestufe“ verwendet. Die Entität „Dimension auf einer Hierarchiestufe“ kann 

aber nur eine Dimension haben. Ähnlich die Situation auf der Seite der 

Hierarchiestufen. Die Entität „Hierarchiestufe“ kann mehrmals in der Entität 

„Dimension auf einer Hierarchiestufe“ verwendet werden. Die Entität „Dimension auf 

einer Hierarchiestufe“ hat im Namen schon enthalten, dass die Dimension nur auf einer 

Hierarchiestufe sein kann. 

Zum Entwickeln der Benutzeranforderungen wurden zusätzlich noch 3 Entitäten in das 

ER-Diagramm eingefügt. Die Entität „Benutzeranforderungen“ repräsentiert 

unterschiedliche Benutzeranforderungen einem Gitter. Dies können Finanzkennzahlen, 

Lagerstandsabfragen, kundenbezogene Kennzahlen, etc. sein. Diese kann der Benutzer 

in der Entität „Benutzeranforderungen“ separat gruppieren und übersichtlich behandeln. 

Natürlich soll es dem Benutzer gestattet sein mehrere Benutzeranforderungen an ein 

Gitter zu stellen. Deshalb ist die Beziehung zwischen der Entität „Gitter“ und der Entität 

„Benutzeranforderungen“ eine 1:n Beziehung. Diese Benutzeranforderungen werden 

jedoch in mehrere Blöcke unterteilt, die wiederum aus mehreren Detailanforderungen 

bestehen können. Eine beispielhafte Detailanforderung wäre „Die Kunden gruppiert 

nach Bundesland“ (Das würde der Dimension „Kunden“ auf der Hierarchiestufe 

„Bundesland“ entsprechen). Ein fertiger Block wäre z.B. „Alle Umsätze der Kunden pro 

Bundesland (erste Detailanforderung), aller Artikeln (zweite Detailanforderung – 

höchste Hierarchiestufe der Artikeln) und in der Zeitspanne pro Monat mit einem „Roll- 

Up“ bis zum Jahr (dritte Detailanforderung). 

- 172 -



Natürlich können nur wieder Dimensionen und Hierarchien für die Detailanforderungen 

verwendet werden, die in der Entität „Dimensionen“ bzw. in der Entität 

„Hierarchiestufen“ angelegt wurden. Dies wird durch die 1:n Beziehungen zwischen 

„Hierarchiestufen“ und „Detailanforderungen“ und „Dimensionen“ und 

„Detailanforderungen“ ausgedrückt. 

7.8.3.3 LOGISCHE DATENMODELLIERUNG 

Die Ableitung des APA Relationenmodells aus dem APA ER-Modells erfolgt analog 

nach der oben beschriebenen Standardvorgehensweise beim Entwickeln von 

relationalen Datenbanksystemen [vgl. Riordan (2000) S.149ff]. Die Entitäten wurden in 

Tabellen umgesetzt. Eine zusätzliche Tabelle wurde für die Beziehung zwischen 

Administratoren (APA_Admin) und Benutzern (APA_User) erzeugt. Die Umsetzung 

erfolgt mit dem Microsoft SQL 2000 Server. Auf Grund der Umsetzung des ER - 

Diagramms enthält die Datenbank folgende Tables mit Primärschlüsseln. 

- 173 -



Table Beschreibung Primärschlüssel 

APA_Admin Administratoren AdminID 

Beziehung m:n Beziehung AdminID 

APA_Admin_User zwischen Administratoren 

und Benutzern 

UserID 

APA_User 

Benutzer und Besitzer des 

Gitters 

UserID 

APA_Dimension Dimensionen des Gitters 

GitterID 

DimensionID 

GitterID 

APA_Hierarchy 

Hierarchien der einzelnen 

Dimensionen eines Gitters 

DimensionID 

Hierarchylevel 

APA_Gitter Daten über das Gitter GitterID 

GitterID 

APA_Cells 

Zellen des Gitters und 

deren Daten 

Row 

Column 

GitterID 

APA_Cube 

Hierarchiestufen der 

Row 

einzelnen Dimensionen des 

Gitters 

Column 

DimensionID 

Anforderungsliste des GitterID 

APA_Req 

Benutzer für ein 

bestimmtes Gitter 

ReqID 

GitterID 

APA_ReqBlock 

Reqirement Block für jedes 

ReqID 

APA_req Objekt 

BlockID 

GitterID 

APA_Detailreq 

Detailanforderungen jedes 

Blocks 

ReqID 

BlockID 

DetailreqID 

Tabelle 10: : Beschreibung der Tables der APA Datenbank 

- 174 -



Abbildung 74: Ableitung des APA Relationenmodells aus dem APA ER-Modell 

- 175 -



7.8.3.4 PHYSISCHE DATENMODELLIERUNG 

Das physische Datenmodell beschreibt die Daten des Informationssystems auf der 

Ebene der technischen Implementierung. Das physische Datenmodell bezieht sich auf 

ein konkretes Datenbankprodukt. Im Zuge dieser Arbeit wird Microsoft SQL 2000 

Server als Datenbankprodukt fixiert. Im folgenden werde ich deshalb auf die konkreten 

physischen Ausprägungen im Sinne der „CREATE TABLE“ Anweisungen eingehen, 

welche auf den Notationen von Barth (2002) S. 127ff und Taylor (2001) S. 41 ff 

basieren. 

7.8.3.4.1 FORMALE SQL-ANWEISUNGEN LAUT SQL 99 

CREATE TABLE APA_Admin ( 

AdminID INTEGER NOT NULL , 

Admindescription VARCHAR(25) NOT NULL , 

PRIMARY KEY (AdminID) 

); 

CREATE TABLE APA_Admin_User ( 

AdminID INTEGER NOT NULL , 

UserID INTEGER NOT NULL, 

PRIMARY KEY (AdminID, UserID) 

); 

CREATE TABLE APA_Cells ( 

GitterID INTEGER NOT NULL , 

Row INTEGER NOT NULL , 

Column INTEGER NOT NULL , 

Short_Description VARCHAR(8) NOT NULL , 

Caption VARCHAR(8) NOT NULL , 

DimensionID INTEGER NOT NULL , 

HierarchyID INTEGER NOT NULL , 

Interesting BIT NOT NULL , 

Materialized BIT NOT NULL , 

Derivative BIT NOT NULL , 

Linetop BIT NOT NULL , 

Linebottom BIT NOT NULL , 

Lineleft BIT NOT NULL , 

Lineright BIT NOT NULL , 

Boldtop BIT NOT NULL , 

Boldbottom BIT NOT NULL , 

Boldleft BIT NOT NULL , 

Boldright BIT NOT NULL, 

PRIMARY KEY (GitterID) 

); 

CREATE TABLE APA_Cube ( 

- 176 -




Row INTEGER NOT NULL , 

Column INTEGER NOT NULL , 


Hierarchylevel INTEGER NOT NULL, 

PRIMARY KEY (GitterID, Row, Column, DimensionID) 

); 

CREATE TABLE APA_Detailreq ( 


ReqID INTEGER NOT NULL , 

BlockID INTEGER NOT NULL , 

DetailReqID INTEGER NOT NULL , 


Hierarchylevel INTEGER NOT NULL , 

Methode VARCHAR(10), 

EndHierarchylevel INTEGER NULL, 

PRIMARY KEY (GitterID, RegID, BlockID, DetailreqID) 

); 

CREATE TABLE APA_Dimension ( 



Dimension_Description VARCHAR(40), 

PRIMARY KEY (GitterID, DimensionID) 

); 

CREATE TABLE APA_Gitter ( 

GitterID INTEGER IDENTITY (1, 1) NOT NULL , 

Description VARCHAR(40) NOT NULL , 

UserID INTEGER NOT NULL , 

Rowcount INTEGER NOT NULL , 

Columncount INTEGER NOT NULL, 

PRIMARY KEY (GitterID) 

); 

CREATE TABLE APA_Hierarchy ( 



Hierarchylevel INTEGER NOT NULL , 

Short_Description VARCHAR(8) NOT NULL , 

Long_Description] VARCHAR(50), 

PRIMARY KEY (GitterID, DimensionID, Hierarchielevel) 

); 

CREATE TABLE APA_Req ( 


ReqID INTEGER IDENTITY (1, 1) NOT NULL , 

ReqDecription VARCHAR(30), 

- 177 -



PRIMARY KEY (GitterID, RegID) 

); 

CREATE TABLE APA_ReqBlock ( 


ReqID INTEGER NOT NULL , 

BlockID INTEGER IDENTITY (1, 1) NOT NULL , 

Description VARCHAR (30), 

PRIMARY KEY (GitterID, ReqID, BlockID) 

); 

CREATE TABLE APA_User ( 

UserID INTEGER IDENTITY (1, 1) NOT NULL , 

Description VARCHAR(50) NOT NULL , 

Password VARCHAR(15) NOT NULL, 

PRIMARY KEY (UserID) 

); 

7.8.3.4.2 MICROSOFT SQL SPEZIFISCHE SQL ANWEISUNGEN 

Jeder Datenbankhersteller unterstützt zwar SQL als Standard, verwendet aber leider oft 

eigene Dialekte und Formatsyntax für seine Datenbankprodukte. Um dem Rechnung zu 

tragen, dass meine Anwendung auf Microsoft SQL als Datenbank abzielt, will ich hier 

die spezifischen SQL Anweisungen, die auf Grund der in Abbildung 36 dargestellten 

relationalen Struktur entwickelt wurden, hier anführen. Zusätzlich zu den „CREATE 

TABLE“ Anweisungen werden im Script auch am Beginn überprüft, ob die Tabellen 

vorhanden sind (if exists) und gegebenenfalls gelöscht. 

Überprüfungen: 

if exists (select * from dbo.sysobjects where id = 

object_id(N'[dbo].[FK_APA_Admin_User_APA_Admin]') and 

OBJECTPROPERTY(id, N'IsForeignKey') = 1) 

ALTER TABLE [dbo].[APA_Admin_User] DROP CONSTRAINT 

FK_APA_Admin_User_APA_Admin 

GO 


object_id(N'[dbo].[FK_APA_Cube_APA_Cells]') and 


ALTER TABLE [dbo].[APA_Cube] DROP CONSTRAINT 

FK_APA_Cube_APA_Cells 

GO 


object_id(N'[dbo].[FK_APA_Cube_APA_Dimension]') and 


- 178 -




FK_APA_Cube_APA_Dimension 

GO 


object_id(N'[dbo].[FK_APA_Detailreq_APA_Dimension]') and 


ALTER TABLE [dbo].[APA_Detailreq] DROP CONSTRAINT 

FK_APA_Detailreq_APA_Dimension 

GO 


object_id(N'[dbo].[FK_APA_Hierarchy_APA_Dimension1]') and 


ALTER TABLE [dbo].[APA_Hierarchy] DROP CONSTRAINT 

FK_APA_Hierarchy_APA_Dimension1 

GO 


object_id(N'[dbo].[FK_APA_Cells_APA_Gitter]') and 


ALTER TABLE [dbo].[APA_Cells] DROP CONSTRAINT 

FK_APA_Cells_APA_Gitter 

GO 


object_id(N'[dbo].[FK_APA_Dimension_APA_Gitter]') and 


ALTER TABLE [dbo].[APA_Dimension] DROP CONSTRAINT 

FK_APA_Dimension_APA_Gitter 

GO 


object_id(N'[dbo].[FK_APA_Req_APA_Gitter]') and 


ALTER TABLE [dbo].[APA_Req] DROP CONSTRAINT 

FK_APA_Req_APA_Gitter 

GO 


object_id(N'[dbo].[FK_APA_Cube_APA_Hierarchy]') and 



FK_APA_Cube_APA_Hierarchy 

GO 


object_id(N'[dbo].[FK_APA_Detailreq_APA_Hierarchy]') and 


- 179 -




FK_APA_Detailreq_APA_Hierarchy 

GO 


object_id(N'[dbo].[FK_APA_Detailreq_APA_Hierarchy1]') and 



FK_APA_Detailreq_APA_Hierarchy1 

GO 


object_id(N'[dbo].[FK_APA_ReqBlock_APA_Req]') and 


ALTER TABLE [dbo].[APA_ReqBlock] DROP CONSTRAINT 

FK_APA_ReqBlock_APA_Req 

GO 


object_id(N'[dbo].[FK_APA_Detailreq_APA_ReqBlock]') and 



FK_APA_Detailreq_APA_ReqBlock 

GO 


object_id(N'[dbo].[FK_APA_Admin_User_APA_User]') and 


ALTER TABLE [dbo].[APA_Admin_User] DROP CONSTRAINT 

FK_APA_Admin_User_APA_User 

GO 


object_id(N'[dbo].[FK_APA_Gitter_APA_User]') and 


ALTER TABLE [dbo].[APA_Gitter] DROP CONSTRAINT 

FK_APA_Gitter_APA_User 

GO 


object_id(N'[dbo].[APA_Admin]') and OBJECTPROPERTY(id, 

N'IsUserTable') = 1) 

drop table [dbo].[APA_Admin] 

GO 


object_id(N'[dbo].[APA_Admin_User]') and OBJECTPROPERTY(id, 


drop table [dbo].[APA_Admin_User] 

- 180 -

GO 




object_id(N'[dbo].[APA_Cells]') and OBJECTPROPERTY(id, 


drop table [dbo].[APA_Cells] 

GO 


object_id(N'[dbo].[APA_Cube]') and OBJECTPROPERTY(id, 


drop table [dbo].[APA_Cube] 

GO 


object_id(N'[dbo].[APA_Detailreq]') and OBJECTPROPERTY(id, 


drop table [dbo].[APA_Detailreq] 

GO 


object_id(N'[dbo].[APA_Dimension]') and OBJECTPROPERTY(id, 


drop table [dbo].[APA_Dimension] 

GO 


object_id(N'[dbo].[APA_Gitter]') and OBJECTPROPERTY(id, 


drop table [dbo].[APA_Gitter] 

GO 


object_id(N'[dbo].[APA_Hierarchy]') and OBJECTPROPERTY(id, 


drop table [dbo].[APA_Hierarchy] 

GO 


object_id(N'[dbo].[APA_Req]') and OBJECTPROPERTY(id, 


drop table [dbo].[APA_Req] 

GO 


object_id(N'[dbo].[APA_ReqBlock]') and OBJECTPROPERTY(id, 


drop table [dbo].[APA_ReqBlock] 

GO 

- 181 -




object_id(N'[dbo].[APA_User]') and OBJECTPROPERTY(id, 


drop table [dbo].[APA_User] 

GO 

CREATE TABLE Anweisungen: 

CREATE TABLE [dbo].[APA_Admin] ( 

[AdminID] [int] NOT NULL , 

[Admindescription] [char] (25) COLLATE 

Latin1_General_CI_AS NOT NULL 

) ON [PRIMARY] 

GO 

CREATE TABLE [dbo].[APA_Admin_User] ( 

[AdminID] [int] NOT NULL , 

[UserID] [int] NOT NULL 


GO 

CREATE TABLE [dbo].[APA_Cells] ( 

[GitterID] [int] NOT NULL , 

[Row] [int] NOT NULL , 

[Column] [int] NOT NULL , 

[Short_Description] [char] (250) COLLATE 

Latin1_General_CI_AS NULL , 

[Caption] [char] (8) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[DimensionID] [int] NOT NULL , 

[HierarchyID] [int] NOT NULL , 

[Interesting] [bit] NOT NULL , 

[Materialized] [bit] NOT NULL , 

[Derivative] [bit] NOT NULL , 

[Linetop] [bit] NOT NULL , 

[Linebottom] [bit] NOT NULL , 

[Lineleft] [bit] NOT NULL , 

[Lineright] [bit] NOT NULL , 

[Boldtop] [bit] NOT NULL , 

[Boldbottom] [bit] NOT NULL , 

[Boldleft] [bit] NOT NULL , 

[Boldright] [bit] NOT NULL 


GO 

CREATE TABLE [dbo].[APA_Cube] ( 


[Row] [int] NOT NULL , 

- 182 -



[Column] [int] NOT NULL , 


[Hierarchylevel] [int] NOT NULL 


GO 

CREATE TABLE [dbo].[APA_Detailreq] ( 


[ReqID] [int] NOT NULL , 

[BlockID] [int] NOT NULL , 

[DetailReqID] [int] NOT NULL , 


[Hierarchylevel] [int] NOT NULL , 

[Methode] [char] (10) COLLATE Latin1_General_CI_AS 

NULL , 

[EndHierarchylevel] [int] NULL 


GO 

CREATE TABLE [dbo].[APA_Dimension] ( 



[Dimension_Description] [char] (40) COLLATE 

Latin1_General_CI_AS NULL 


GO 

CREATE TABLE [dbo].[APA_Gitter] ( 

[GitterID] [int] IDENTITY (1, 1) NOT NULL , 

[Description] [char] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 

[UserID] [int] NOT NULL , 

[Rowcount] [int] NOT NULL , 

[Columncount] [int] NOT NULL 


GO 

CREATE TABLE [dbo].[APA_Hierarchy] ( 



[Hierarchylevel] [int] NOT NULL , 

[Short_Description] [char] (8) COLLATE 

Latin1_General_CI_AS NOT NULL , 

[Long_Description] [char] (50) COLLATE 



GO 

CREATE TABLE [dbo].[APA_Req] ( 

- 183 -




[ReqID] [int] IDENTITY (1, 1) NOT NULL , 

[ReqDecription] [char] (30) COLLATE 



GO 

CREATE TABLE [dbo].[APA_ReqBlock] ( 


[ReqID] [int] NOT NULL , 

[BlockID] [int] IDENTITY (1, 1) NOT NULL , 


NULL 


GO 

CREATE TABLE [dbo].[APA_User] ( 

[UserID] [int] IDENTITY (1, 1) NOT NULL , 


NOT NULL , 

[Password] [char] (15) COLLATE Latin1_General_CI_AS 

NOT NULL 


GO 

7.8.3.5 GENERIEREN DER CREATE TABLE ANWEISUNGEN IN DER 

SOFTWARE 

Unsere Software kann dem Benutzer SQL-Scripts generieren, welche dieser direkt an 

einen Microsoft SQL Server schicken kann und damit die Tables, bzw. die Aggregate 

erzeugt werden. Dabei wollen wir die zwei einfachsten Schemata, das Star und das Fact 

Constellation Schema, umsetzen. 

7.8.3.5.1 DAS STAR-SCHEMA 

Das Star-Schema wird durch einen BFT, in welchem auch die Aggregate gespeichert 

werden, charakterisiert. Die Dimensionstabellen sind sternförmig um diesen BFT 

angeordnet. Wichtig ist das Level Attribut, da dieses eine Unterscheidung zwischen 

atomaren und aggregierten Daten erlaubt. 

- 184 -



Abbildung 75: Der Aufbau eines Star Schemas als Basis der CREATE TABLE Anweisungen 

I_Key C_Key P_Key Qty_Sold Revenue 

K0001 K00001 K000001 1000 1200 

K0001 K00001 K900001 19000 22800 

K0001 K00001 K999001 110100 110101 

K0001 K00002 K000001 700 840 

K0001 K00002 K000002 980 1470 

K0001 K00002 K900001 17890 21468 

K0001 K00003 K000001 900 1080 

K0002 K00001 K000001 1111 1667 

K0002 K00001 K000002 1100 1650 

K0002 K00001 K900001 17150 25725 

K0002 K00001 K999001 89600 134400 

K0003 K00001 K000002 10000 9000 

K0003 K00001 K900001 16900 15210 

K0003 K00001 K999001 96100 86490 

K0003 K00002 K000001 20000 18000 

K0003 K00003 K000001 4000 3600 

K5000 K00001 K000001 2111 2867 

K5000 K00002 K000001 700 840 

K5000 K00003 K000001 900 1080 

K5700 K00002 K000001 20000 18000 

K5700 K00003 K000001 4000 3600 

K9999 K00001 K000001 2111 2867 

K9999 K00002 K000001 20700 18840 

K9999 K00003 K000001 4900 4680 

K9999 K99999 K000001 27711 26387 

Tabelle 11: Beispielhafter BFT für die Anwendung 

- 185 -



C_Key C_cu C_description C_gr C_gr_description level address 

K00001 9876543 Woolworth 1 foodstore 0 207, View Rd, NSW, 9910 

K00002 9874321 K-Mart 1 foodstore 0 12, Creek Ave, NSW, 6677 

K00003 8912345 Mc Donalds 2 fastfood 0 403, Flood St, NSW, 1109 

K19999 * * 1 foodstore 1 

K29999 * * 2 fastfood 1 

K99999 * * * * 2 

Tabelle 12: Beispielhafter Customer-Dimensionstable für die Anwendung 

I_Key I_it I_description I_ty I_ty_description level 

K0001 1234567 Oranges Naval - S. A. 1 fruits 0 

K0002 12345789 Banana Rosa - Victoria 1 fruits 0 

K0003 2345678 Milk - Dairy Farmers 2 diary 0 

K5000 * * 1 fruits 1 

K5700 * * 2 diary 1 

K9999 * * * * 2 

Tabelle 13: Beispielhafter Items-Dimensionstable für die Anwendung 

P_Key P_d P_description P_m P_m_description P_y P_y_description level 

K000001 1 1-Jan-2000 1 Jan, 2000 1 2000 0 

K000002 2 2-Jan-2000 1 Jan, 2000 1 2000 0 

K000003 3 3-Jan-2000 1 Jan, 2000 1 2000 0 

K000170 170 18-Jun-2000 6 June, 2000 1 2000 0 

K000171 171 19-Jun-2000 6 June, 2000 1 2000 0 

K900001 * * 1 Jan, 2000 1 2000 1 

K900002 * * 2 Feb, 2000 1 2000 1 

K900003 * * 3 March, 2000 1 2000 1 

K900006 * * 6 June, 2000 1 2000 1 

K999001 * * * * 1 2000 2 

Tabelle 14: Beispielhafter Time-Dimensionstable für die Anwendung 

7.8.3.5.2 DAS FACT CONSTELLATION SCHEMA 

Bei Fact Constellation-Schema werden die Aggregate in separaten Fact Tables (FT) 

gespeichert. Das führt zu mehreren, aber kleineren Tabellen. 

- 186 -



Abbildung 76: Beispielhafte Auflistung der Dimension Tables und der Fact Tables beim Fact 

Constellation-Schema 

7.8.3.5.3 BEISPIELHAFTES UMSETZEN DER TABLES DURCH DAS PROGRAMM 

7.8.3.5.3.1 DIE AUSGANGSPOSITION 

Wir gehen für wie in 7.6.7.3 von einem Demo APA aus und domonstrieren die 

Ergebnisse der SQL Scripts. Unser APA hat 3 Dimensionen (Agenten, Kunden, und 

Zeit). Diese haben wiederum unterschiedliche Hierarchiestufen, welche in Abbildung 

77 im Detail aufgelistet sind. Zusätzlich haben wir den „Key figure“ Umsatz vom Typ 

- 187 -


Money. 


Abbildung 77: Input Screen des Demo APA 

Die Heuristik ergibt das in Abbildung 78 angeführte Ergebnis. Dabei werden 6 

materialisierte Würfel erzeugt. Nun kann der BFT, die Dimension Tabellen und die 

aggregierten Views in unterschiedlichen physischen Tabellenstrukturen abgespeichert 

werden. Ich habe in der Software die Strukturen für das Star-Schema und das Fact 

Constellation-Schema integriert. Die Ergebnisse werden in den nachfolgenden Kapiteln 

aufgelistet. Dabei wird beim Star-Schema ein BFT und drei Dimension Tables erzeugt. 

Die materialisierten Würfel werden im BFT integriert und durch hinzufügen des Level- 

Attributes kann man durch Querys unterscheiden, ob es sich um atomare Daten oder 

einen aggregierten Würfel handelt. Beim Fact Constellation-Schema enthält der BFT 

nur die atomaren Daten. Die Dimensionstabellen enthalten zusätzlich 

Fremdschlüsselwerte für jede Hierarchiestufe. Die materialisierten Sichten werden in 

separaten Aggregated Fact Tables gespeichert. 

- 188 -



Abbildung 78: APA Grid Screen des Demo APA 

7.8.3.5.3.2 DIE SCRIPTS FÜR DAS STAR SCHEMA 


object_id(N'[dbo].[FK_BFT_Agenten_table]') 

and OBJECTPROPERTY(id, N'IsForeignKey') = 1) 

ALTER TABLE [dbo].[BFT] DROP CONSTRAINT 

FK_BFT_Agenten_table 

GO 


object_id(N'[dbo].[Agenten_table]') and 

OBJECTPROPERTY(id, N'IsUserTable') = 1) 

drop table [dbo].[Agenten_table] 

GO 

CREATE TABLE [dbo].[Agenten_table] ( 

[Agenten_id] [varchar] (50) COLLATE 


[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[A_id_desc] [varchar] (40) COLLATE 


[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[A_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 

[level] [bigint] NOT NULL 


GO 

- 189 -



ALTER TABLE [dbo].[Agenten_table] WITH NOCHECK ADD 

CONSTRAINT [PK_Agenten_table] PRIMARY KEY CLUSTERED 

( 

[Agenten_id] 


GO 


object_id(N'[dbo].[FK_BFT_Kunden_table]') 


ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Kunden_table 

GO 


object_id(N'[dbo].[Kunden_table]') and 


drop table [dbo].[Kunden_table] 

GO 

CREATE TABLE [dbo].[Kunden_table] ( 

[Kunden_id] [varchar] (50) COLLATE 


[K_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[K_id_desc] [varchar] (40) COLLATE 


[K_gr] [varchar] (12) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[K_gr_desc] [varchar] (40) COLLATE 


[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[K_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 



GO 

ALTER TABLE [dbo].[Kunden_table] WITH NOCHECK ADD 

CONSTRAINT [PK_Kunden_table] PRIMARY KEY CLUSTERED 

( 

[Kunden_id] 


GO 


object_id(N'[dbo].[FK_BFT_Zeit_table]') 


- 190 -



ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Zeit_table 

GO 


object_id(N'[dbo].[Zeit_table]') and 


drop table [dbo].[Zeit_table] 

GO 

CREATE TABLE [dbo].[Zeit_table] ( 

[Zeit_id] [varchar] (50) COLLATE Latin1_General_CI_AS 

NOT NULL , 

[Z_t] [varchar] (12) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[Z_t_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 

[Z_m] [varchar] (12) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[Z_m_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 

[Z_y] [varchar] (12) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[Z_y_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 

[Z_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[Z_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 



GO 

ALTER TABLE [dbo].[Zeit_table] WITH NOCHECK ADD 

CONSTRAINT [PK_Zeit_table] PRIMARY KEY CLUSTERED 

( 

[Zeit_id] 


GO 


object_id(N'[dbo].[BFT]') 

and OBJECTPROPERTY(id, N'IsUserTable') = 1) 

drop table [dbo].[BFT] 

GO 

CREATE TABLE [dbo].[BFT] ( 



- 191 -






NOT NULL , 

[Umsatz] [MONEY] NOT NULL 


GO 

ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD 

CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED 

( 

[Agenten_id], 

[Kunden_id], 

[Zeit_id] 


GO 

ALTER TABLE [dbo].[BFT] ADD 

CONSTRAINT [FK_BFT_Agenten_table] FOREIGN KEY 

( 

[Agenten_id] 

) REFERENCES [dbo].[Agenten_table] ( 

[Agenten_id] 

) ON UPDATE CASCADE 

GO 


CONSTRAINT [FK_BFT_Kunden_table] FOREIGN KEY 

( 

[Kunden_id] 

) REFERENCES [dbo].[Kunden_table] ( 

[Kunden_id] 


GO 


CONSTRAINT [FK_BFT_Zeit_table] FOREIGN KEY 

( 

[Zeit_id] 

) REFERENCES [dbo].[Zeit_table] ( 

[Zeit_id] 


GO 

- 192 -



7.8.3.5.3.3 DIE SCRIPTS FÜR DAS FACT CONSTELLATION SCHEMA 


object_id(N'[dbo].[FK_BFT_Agenten_table]') 


ALTER TABLE [dbo].[BFT] DROP CONSTRAINT 

FK_BFT_Agenten_table 

GO 


object_id(N'[dbo].[Agenten_table]') and 


drop table [dbo].[Agenten_table] 

GO 

CREATE TABLE [dbo].[Agenten_table] ( 




NULL , 

[A_id_desc] [varchar] (40) COLLATE 



NULL , 

[A_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 


GO 

ALTER TABLE [dbo].[Agenten_table] WITH NOCHECK ADD 

CONSTRAINT [PK_Agenten_table] PRIMARY KEY CLUSTERED 

( 

[Agenten_id] 


GO 

CREATE INDEX [IX_A_id] ON [dbo].[Agenten_table]([A_id]) 

ON [PRIMARY] 

GO 

CREATE INDEX [IX_A_*] ON [dbo].[Agenten_table]([A_*]) ON 

[PRIMARY] 

GO 


object_id(N'[dbo].[FK_BFT_Kunden_table]') 


ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Kunden_table 

GO 

- 193 -




object_id(N'[dbo].[Kunden_table]') and 


drop table [dbo].[Kunden_table] 

GO 

CREATE TABLE [dbo].[Kunden_table] ( 




NULL , 

[K_id_desc] [varchar] (40) COLLATE 



NULL , 

[K_gr_desc] [varchar] (40) COLLATE 



NULL , 

[K_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 


GO 

ALTER TABLE [dbo].[Kunden_table] WITH NOCHECK ADD 

CONSTRAINT [PK_Kunden_table] PRIMARY KEY CLUSTERED 

( 

[Kunden_id] 


GO 

CREATE INDEX [IX_K_id] ON [dbo].[Kunden_table]([K_id]) ON 

[PRIMARY] 

GO 

CREATE INDEX [IX_K_gr] ON [dbo].[Kunden_table]([K_gr]) ON 

[PRIMARY] 

GO 

CREATE INDEX [IX_K_*] ON [dbo].[Kunden_table]([K_*]) ON 

[PRIMARY] 

GO 


object_id(N'[dbo].[FK_BFT_Zeit_table]') 


ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Zeit_table 

GO 

- 194 -




object_id(N'[dbo].[Zeit_table]') and 


drop table [dbo].[Zeit_table] 

GO 

CREATE TABLE [dbo].[Zeit_table] ( 


NOT NULL , 


NULL , 

[Z_t_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 


NULL , 

[Z_m_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 


NULL , 

[Z_y_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 

[Z_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT 

NULL , 

[Z_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS 

NOT NULL , 


GO 

ALTER TABLE [dbo].[Zeit_table] WITH NOCHECK ADD 

CONSTRAINT [PK_Zeit_table] PRIMARY KEY CLUSTERED 

( 

[Zeit_id] 


GO 

CREATE INDEX [IX_Z_t] ON [dbo].[Zeit_table]([Z_t]) ON 

[PRIMARY] 

GO 

CREATE INDEX [IX_Z_m] ON [dbo].[Zeit_table]([Z_m]) ON 

[PRIMARY] 

GO 

CREATE INDEX [IX_Z_y] ON [dbo].[Zeit_table]([Z_y]) ON 

[PRIMARY] 

GO 

- 195 -



CREATE INDEX [IX_Z_*] ON [dbo].[Zeit_table]([Z_*]) ON 

[PRIMARY] 

GO 


object_id(N'[dbo].[BFT]') 

and OBJECTPROPERTY(id, N'IsUserTable') = 1) 

drop table [dbo].[BFT] 

GO 

CREATE TABLE [dbo].[BFT] ( 






NOT NULL , 



GO 

ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD 

CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED 

( 

[Agenten_id], 

[Kunden_id], 

[Zeit_id] 


GO 


CONSTRAINT [FK_BFT_Agenten_table] FOREIGN KEY 

( 

[Agenten_id] 

) REFERENCES [dbo].[Agenten_table] ( 

[Agenten_id] 


GO 


CONSTRAINT [FK_BFT_Kunden_table] FOREIGN KEY 

( 

[Kunden_id] 

) REFERENCES [dbo].[Kunden_table] ( 

[Kunden_id] 


GO 

- 196 -




CONSTRAINT [FK_BFT_Zeit_table] FOREIGN KEY 

( 

[Zeit_id] 

) REFERENCES [dbo].[Zeit_table] ( 

[Zeit_id] 


GO 

if exists (select * from dbo.sysobjects where 

id = object_id(N'[dbo].[FT A_*K_idZ_m]') and 


drop table [dbo].[FT A_*K_idZ_m] 

GO 

CREATE TABLE [dbo].[FT A_*K_idZ_m] ( 


NULL , 


NULL , 


NULL , 



GO 

ALTER TABLE [dbo].[FT A_*K_idZ_m] WITH NOCHECK ADD 

CONSTRAINT [PK_FT A_*K_idZ_m] PRIMARY KEY CLUSTERED 

( 

[A_*] , 

[K_id] , 

[Z_m] 


GO 


id = object_id(N'[dbo].[FT A_idK_*Z_t]') and 


drop table [dbo].[FT A_idK_*Z_t] 

GO 

CREATE TABLE [dbo].[FT A_idK_*Z_t] ( 


NULL , 

- 197 -




NULL , 


NULL , 



GO 

ALTER TABLE [dbo].[FT A_idK_*Z_t] WITH NOCHECK ADD 

CONSTRAINT [PK_FT A_idK_*Z_t] PRIMARY KEY CLUSTERED 

( 

[A_id] , 

[K_*] , 

[Z_t] 


GO 


id = object_id(N'[dbo].[FT A_*K_*Z_t]') and 


drop table [dbo].[FT A_*K_*Z_t] 

GO 

CREATE TABLE [dbo].[FT A_*K_*Z_t] ( 


NULL , 


NULL , 


NULL , 



GO 

ALTER TABLE [dbo].[FT A_*K_*Z_t] WITH NOCHECK ADD 

CONSTRAINT [PK_FT A_*K_*Z_t] PRIMARY KEY CLUSTERED 

( 

[A_*] , 

[K_*] , 

[Z_t] 


GO 


id = object_id(N'[dbo].[FT A_*K_idZ_y]') and 


drop table [dbo].[FT A_*K_idZ_y] 

- 198 -

GO 



CREATE TABLE [dbo].[FT A_*K_idZ_y] ( 


NULL , 


NULL , 


NULL , 



GO 

ALTER TABLE [dbo].[FT A_*K_idZ_y] WITH NOCHECK ADD 

CONSTRAINT [PK_FT A_*K_idZ_y] PRIMARY KEY CLUSTERED 

( 

[A_*] , 

[K_id] , 

[Z_y] 


GO 


id = object_id(N'[dbo].[FT A_idK_*Z_m]') and 


drop table [dbo].[FT A_idK_*Z_m] 

GO 

CREATE TABLE [dbo].[FT A_idK_*Z_m] ( 


NULL , 


NULL , 


NULL , 



GO 

ALTER TABLE [dbo].[FT A_idK_*Z_m] WITH NOCHECK ADD 

CONSTRAINT [PK_FT A_idK_*Z_m] PRIMARY KEY CLUSTERED 

( 

[A_id] , 

[K_*] , 

[Z_m] 


GO 

- 199 -




id = object_id(N'[dbo].[FT A_idK_grZ_y]') and 


drop table [dbo].[FT A_idK_grZ_y] 

GO 

CREATE TABLE [dbo].[FT A_idK_grZ_y] ( 


NULL , 


NULL , 


NULL , 



GO 

ALTER TABLE [dbo].[FT A_idK_grZ_y] WITH NOCHECK ADD 

CONSTRAINT [PK_FT A_idK_grZ_y] PRIMARY KEY CLUSTERED 

( 

[A_id] , 

[K_gr] , 

[Z_y] 


GO 

7.9 ERGEBNISSE DER TESTS DER HEURISTIKEN 

Um die Funktionalität der Heuristik zu überprüfen, ist es essentiell die richtige Lösung 

deterministisch durch einen Algorithmus zu bestimmen. Diese Algorithmen wurden in 

den vorhergehenden Kapiteln eingehend behandelt. Dabei wurde sowohl bei der 

Permutation als auch bei der Kombination gleiche Ergebnisse erzielt. 

7.9.1 PROBLEME BEI TESTEN DER HEURISTIK 

Der erste Ansatz war das Testen der Ergebnisse der Heuristik im Vergleich zu den 

Ergebnissen der deterministischen Lösung durch die Permutation. Dabei wurden alle 

möglichen Sequenzen der zu materialisierenden Cubes unter der Berücksichtigung der 

Reihenfolge der Cubes berechnet und die kostenminimale Lösung mit der Heuristik 

verglichen. Unglücklicherweise dauert das Berechnen dieser deterministischen Lösung 

sehr lange. Das führte sogar bei kleinen APA zu Berechnungszeiten über 1 Jahr. 

- 200 -



Deshalb wurde in einem zweiten Schritt der Ansatz über die Kombination gewählt. 

Dabei wurde die Materialisierungsreihenfolge der Cubes nicht beachtet. Das führte zu 

wesentlich weniger Sequenzen, welche in einem zweiten Schritt dann durch den 

Algorithmus von Dijkstra, welcher in den Algorithmus GetRightOrder eingebaut wurde, 

in die optimale Reihenfolge gebracht. Dadurch konnten akzeptable Berechnungszeiten 

von 3 bis 4 Wochen Berechnungszeit für kleine bis mittelgroße APA erreicht werden. 

Durch den Einsatz von 4 Rechnern parallel wurden die unten angeführten Ergebnisse 

erreicht. 

Zusätzlich wurde eine spezielle eine Abbruchbedingung eingeführt. Wenn die 

Kombination von z.B. 6 Cubes in jeder möglichen Kombination immer die Spacemax 

Bedingung überschritten hat, ist logischerweise auch bei einer Kombination von 7 

Cubes das Spacemax Limit überschritten. Deshalb konnte die Berechnung früher 

gestoppt werden. Aus diesem Grund wurde auch in den empirischen Probeläufen von 

einem sehr geringen verfügbaren Speicherplatz ausgegangen. Nur so konnten die 

Berechnungszeiten von bis zu 4 Wochen erreicht werden. 

Die Menge der betrachteten Cubes wurden auf die so genannten „Possible Cubes“ 

eingeschränkt. Dabei würden aus der Gesamtmenge aller Cubes jene Cubes 

ausgeklammert, welche jedenfalls keinen positiven Beitrag zur Berechnung der 

Required Cubes leisten könnten. So sieht man in Abbildung 79 die mit schwarz 

markierten Menge der Possible Cubes. Der beispielhaft aktivierte Cube (4:2): K_gr; 

A_*; Z_* bringt dabei keinen zusätzlichen Nutzen für die Materialisierung der Required 

Cubes, da keines seiner Derivative ein Required Cube ist. Aus diesem Grund befindet 

sich dieser Cube nicht in der Menge der Possible Cubes. 

- 201 -



Abbildung 79: Demonstrative Anzeigen der Possible Cubes 

7.9.2 GESAMTÜBERSICHT ÜBER DIE ERGEBNISSE 

Bezeichnung Kosten Kostenübereinstimmung 

Test1 Strukturierte 

Zufallskosten 


Zufallskosten 


Zufallskosten 


Zufallskosten 


Zufallskosten 

- 202 - 

Spaceleft 

Übereinstimmung 

Timeleft 

Übereinstimmung 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 %




Zufallskosten 


Zufallskosten 

Test8 Total Random 

Zufallskosten 


Zufallskosten 


Zufallskosten 


Zufallskosten 


Zufallskosten 

Test13 Mit 

Kostenfunktion 


Zufallskosten 


Zufallskosten 

Test16 Mit 



Zufallskosten 

Test18 Mit 


100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

100 % 100 % 100 % 

4,53 % 10,73 % 26,33 % 

- 203 -



7.9.3 DIE ERGEBNISSE IM DETAIL 

7.9.3.1 VORGABEN UND ERGEBNISSE TEST 1 

7.9.3.1.1 VORGABEN 

Required 

Cubes: count 

1 3:0 K_*; A_*; G_*; Z_t 10000 

2 3:2 K_*; A_id; G_*; Z_m 10000 

3 4:2 K_*; A_id; G_*; Z_y 10000 

4 2:4 K_gr; A_*; G_*; Z_t 10000 

5 1:7 K_gr; A_id; G_b; Z_m 10000 

6 2:7 K_gr; A_id; G_b; Z_y 10000 

7 3:7 K_gr; A_id; G_b; Z_* 10000 

8 1:10 K_id; A_id; G_*; Z_m 10000 

7.9.3.1.2 LÖSUNG DER HEURISTIK 

- 204 - 

Parameter 

Spacemax 500000 

Timemax 2500000 

Zeitkosten 1 bis 100000 

Size per Tupel in Bytes: 64 

New set on each iteration 4 

Max Sets 20



7.9.3.1.3 DETERMINISTISCHE LÖSUNG 

7.9.3.1.4 VERGLEICH DER ERGEBNISSE 

Parameter Heuristik Deterministisch Abweichung 

Kosten 971499585 971499585 0,00% 

Space left 185952 185952 0,00% 

Time left 40415 40415 0,00% 

Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte 

den richtigen Wert im Lösungsweg 1. 



Required 

Cubes: count 

1 4:1 K_*; A_*; G_b; Z_m 1000 

2 5:1 K_*; A_*; G_b; Z_y 1000 

3 6:1 K_*; A_*; G_b; Z_* 1000 

4 3:7 K_gr; A_*; G_b; Z_m 1000 

5 4:7 K_gr; A_*; G_b; Z_y 1000 

6 2:14 K_id; A_gr; G_*; Z_m 1000 

7 3:14 K_id; A_gr; G_*; Z_y 1000 

8 4:14 K_id; A_gr; G_*; Z_* 1000 

- 205 - 

Parameter 






Max Sets 20





- 206 -





Kosten 2951750032 2951750032 0,00% 

Space left 335040 335040 0,00% 

Time left 1399968 1399968 0,00% 





Required 

Cubes: count 

1 0:0 K_gr; A_id; G_b; Z_t 1000 

2 1:0 K_*; A_id; G_b; Z_t 1000 

3 4:0 K_*; A_*; G_*; Z_m 1000 

4 5:0 K_*; A_*; G_*; Z_y 1000 

5 6:0 K_*; A_*; G_*; Z_* 1000 

6 1:10 K_id; A_id; G_*; Z_m 1000 

7 2:10 K_id; A_id; G_*; Z_y 1000 

8 3:10 K_id; A_id; G_*; Z_* 1000 


- 207 - 

Parameter 






Max Sets 20






Kosten 2950860 2950860 0,00% 

Space left 2265920 2265920 0,00% 

Time left 1489441 1489441 0,00% 



- 208 -





Required 

Cubes: count 

1 0:0 K_gr; A_id; Z_t 10000 

2 1:0 K_*; A_id; Z_t 1000 

3 2:0 K_*; A_*; Z_t 1000 

4 2:1 K_*; A_id; Z_m 1000 

5 1:2 K_gr; A_*; Z_t 10000 

6 2:2 K_gr; A_*; Z_m 1000 

7 3:2 K_gr; A_*; Z_y 1000 

8 1:3 K_gr; A_id; Z_m 1000 

9 2:3 K_gr; A_id; Z_y 1000 

10 0:4 K_id; A_*; Z_t 1000 

11 1:4 K_id; A_*; Z_m 1000 

12 2:4 K_id; A_*; Z_y 1000 

13 0:5 K_id; A_id; Z_m 10000 

14 1:5 K_id; A_id; Z_y 10000 

15 2:5 K_id; A_id; Z_* 10000 


- 209 - 

Parameter 






Max Sets 20






Kosten 253922 253922 0,00% 

Space left 212414000 212414000 0,00% 

Time left 1246080 1246080 0,00% 



- 210 -





Required 

Cubes: count 

1 2:0 A_*; K_*; Z_t 10000 

2 1:2 A_*; K_id; Z_m 1000 

3 2:2 A_*; K_id; Z_y 1000 

4 3:2 A_*; K_id; Z_* 1000 

5 1:3 A_id; K_*; Z_t 10000 

6 2:3 A_id; K_*; Z_m 10000 

7 2:4 A_id; K_gr; Z_y 10000 

8 1:5 A_id; K_id; Z_y 1 

9 2:5 A_id; K_id; Z_* 1 


- 211 - 

Parameter 






Max Sets 20






Kosten 99578 99578 0,00% 

Space left 42400400 42400400 0,00% 

Time left 1438916 1438916 0,00% 



- 212 -





Required 

Cubes: count 

1 0:0 K_gr; A_id; Z_t 1000 

2 1:0 K_*; A_id; Z_t 1000 

3 2:0 K_*; A_gr; Z_t 10000 

4 1:3 K_gr; A_gr; Z_t 1000 

5 2:3 K_gr; A_*; Z_t 1000 

6 1:5 K_gr; A_id; Z_m 10000 

7 2:5 K_gr; A_id; Z_y 10000 

8 3:5 K_gr; A_id; Z_* 10000 

9 0:6 K_id; A_gr; Z_t 1 

10 1:6 K_id; A_*; Z_t 1000 

11 3:6 K_id; A_*; Z_y 10000 

12 4:6 K_id; A_*; Z_* 10000 

13 2:7 K_id; A_gr; Z_y 1000 


- 213 - 

Parameter 






Max Sets 20






Kosten 2639020 2639020 0,00% 

Space left 1461847 1461847 0,00% 

Time left 2576200 2576200 0,00% 

Es konnte eine eindeutige Übereinstimmung festgestellt werden. In der 

Materialisierungsreihenfolge wurde jedoch eine andere Reihenfolge gewählt. Dies 

beeinflusst aber nicht die Kosten. Die Heuristik lieferte den richtigen Wert im 

Lösungsweg 1. 

- 214 -





Required 

Cubes: count 

1 3:0 K_*; G_*; Z_t 10000 

2 2:3 K_gr; G_*; Z_t 10000 

3 3:3 K_gr; G_*; Z_m 10000 

4 4:3 K_gr; G_*; Z_y 10000 

5 5:3 K_gr; G_*; Z_* 10000 

6 1:5 K_gr; G_b; Z_m 1000 

7 2:5 K_gr; G_b; Z_y 1000 

8 3:5 K_gr; G_b; Z_* 1000 

9 1:6 K_id; G_*; Z_t 10000 

10 2:6 K_id; G_*; Z_m 10000 

11 3:6 K_id; G_*; Z_y 10000 

12 4:6 K_id; G_*; Z_* 10000 

13 1:8 K_id; G_b; Z_y 10000 


- 215 - 

Parameter 






Max Sets 20






Kosten 1278025457 1278025457 0,00% 

Space left 997040 997040 0,00% 

Time left 14824543 14824543 0,00% 



- 216 -





Required 

Cubes: count 

1 3:0 K_*; G_*; Z_t 10000 

2 2:3 K_gr; G_*; Z_t 10000 

3 3:3 K_gr; G_*; Z_m 10000 

4 4:3 K_gr; G_*; Z_y 10000 

5 5:3 K_gr; G_*; Z_* 10000 

6 1:5 K_gr; G_b; Z_m 1000 

7 2:5 K_gr; G_b; Z_y 1000 

8 3:5 K_gr; G_b; Z_* 1000 

9 1:6 K_id; G_*; Z_t 10000 

10 2:6 K_id; G_*; Z_m 10000 

11 3:6 K_id; G_*; Z_y 10000 

12 4:6 K_id; G_*; Z_* 10000 

13 1:8 K_id; G_b; Z_y 10000 


- 217 - 

Parameter 






Max Sets 20






Kosten 29369605 29369605 0,00% 

Space left 592760 592760 0,00% 

Time left 14920395 14920395 0,00% 



- 218 -





Required 

Cubes: count 

1 0:0 K_gr; A_id; Z_t 1000 

2 1:0 K_*; A_id; Z_t 1000 

3 2:0 K_*; A_gr; Z_t 10000 

4 1:3 K_gr; A_gr; Z_t 1000 

5 2:3 K_gr; A_*; Z_t 1000 

6 1:5 K_gr; A_id; Z_m 10000 

7 2:5 K_gr; A_id; Z_y 10000 

8 3:5 K_gr; A_id; Z_* 10000 

9 0:6 K_id; A_gr; Z_t 1 

10 1:6 K_id; A_*; Z_t 1000 

11 3:6 K_id; A_*; Z_y 10000 

12 4:6 K_id; A_*; Z_* 1000 

13 2:7 K_id; A_gr; Z_y 1000 


- 219 - 

Parameter 






Max Sets 20






Kosten 641966243 641966243 0,00% 

Space left 2432200 2432200 0,00% 

Time left 1261075 1261075 0,00% 



- 220 -





Required 

Cubes: count 

1 2:0 K_*; A_*; G_*; Z_t 1000 

2 2:2 K_*; A_id; G_*; Z_m 10000 

3 1:3 K_*; A_id; G_b; Z_m 1000 

4 2:3 K_*; A_id; G_b; Z_y 1000 

5 3:3 K_*; A_id; G_b; Z_* 1000 

6 0:4 K_id; A_*; G_b; Z_t 1000 

7 1:4 K_id; A_*; G_*; Z_t 10000 

8 0:6 K_id; A_id; G_*; Z_t 1 

9 1:6 K_id; A_id; G_*; Z_m 1000 

10 2:6 K_id; A_id; G_*; Z_y 1000 

11 3:6 K_id; A_id; G_*; Z_* 1000 


- 221 - 

Parameter 






Max Sets 15






Kosten 275596808 275596808 0,00% 

Space left 21788960 21788960 0,00% 

Time left 1252172 1252172 0,00% 



- 222 -





Required 

Cubes: count 

1 3:2 K_*; A_gr; G_*; Z_m 1 

2 2:3 K_*; A_gr; G_b; Z_m 10000 

3 3:3 K_*; A_gr; G_b; Z_y 1 

4 1:4 K_*; A_id; G_*; Z_t 10000 

5 2:5 K_*; A_id; G_b; Z_y 10000 

6 1:6 K_id; A_*; G_b; Z_t 1000 

7 2:6 K_id; A_*; G_*; Z_t 1000 

8 2:7 K_id; A_*; G_b; Z_m 10000 

9 2:8 K_id; A_gr; G_*; Z_m 10000 

10 1:10 K_id; A_id; G_*; Z_m 10000 


- 223 - 

Parameter 






Max Sets 15






Kosten 447157299 447157299 0,00% 

Space left 1328590 1328590 0,00% 

Time left 27595880 27595880 0,00% 



- 224 -





Required 

Cubes: count 

1 3:0 K_*; G_*; Z_t 10000 

2 2:3 K_gr; G_*; Z_t 10000 

3 3:3 K_gr; G_*; Z_m 10000 

4 4:3 K_gr; G_*; Z_y 10000 

5 5:3 K_gr; G_*; Z_* 10000 

6 1:5 K_gr; G_b; Z_m 1000 

7 2:5 K_gr; G_b; Z_y 1000 

8 3:5 K_gr; G_b; Z_* 1000 

9 1:6 K_id; G_*; Z_t 10000 

10 2:6 K_id; G_*; Z_m 10000 

11 3:6 K_id; G_*; Z_y 10000 

12 4:6 K_id; G_*; Z_* 10000 

13 1:8 K_id; G_b; Z_y 10000 


- 225 - 

Parameter 






Max Sets 20






Kosten 2873774 2873774 0,00% 

Space left 591320 591320 0,00% 

Time left 14926226 14926226 0,00% 



- 226 -





Required 

Cubes: count 

1 2:0 C_*; A_gr; T_d 10000 

2 3:1 C_*; A_gr; T_m 10000 

3 2:3 C_gr; A_*; T_d 10000 

4 3:3 C_gr; A_*; T_m 10000 

5 2:4 C_gr; A_gr; T_m 10000 

6 2:5 C_gr; A_id; T_y 10000 

7 1:6 C_id; A_*; T_d 10000 


- 227 - 

Parameter 


Max Sets 50 

average time to store a 

tupel in time units 2 

average time for io in time 

units 2 

average time for CPU 

instructions in time units 0,002 

max time 1500000 

average time to query in 

timeunits 100 

average size of a tupel in 

bytes 900 

max space in bytes 58000000 

time weight 75% 

query weight 63%






Kosten 1549,136539 1549,136539 0,00% 

Space left 2339500 2339500 0,00% 

Time left 396,7110032 396,7110032 0,00% 


den richtigen Wert im Lösungsweg 29. Damit zeigt dieser Testlauf am deutlichsten die 

Grenzen der Heuristik auf. Wäre in den Parameter die Anzahl der Lösungswege auf eine 

geringere Anzahl als 29 gesetzt worden, wäre das Ergebnis unrichtig. Deshalb wird im 

Test 18 dieses Beispiel nochmals mit neuen Parametern ausgetestet. 

- 228 -





Required 

Cubes: count 

1 0:0 K_gr; A_id; G_b; Z_t 1000 

2 1:0 K_*; A_id; G_b; Z_t 1000 

3 2:0 K_*; A_*; G_b; Z_t 1000 

4 2:3 K_*; A_id; G_b; Z_m 1000 

5 3:3 K_*; A_id; G_b; Z_y 1 

6 1:4 K_gr; A_*; G_b; Z_t 10000 

7 1:6 K_gr; A_id; G_*; Z_t 10000 

8 2:6 K_gr; A_id; G_*; Z_m 10000 

9 3:6 K_gr; A_id; G_*; Z_y 10000 

10 4:6 K_gr; A_id; G_*; Z_* 10000 

11 0:8 K_id; A_*; G_b; Z_t 10000 

12 1:8 K_id; A_*; G_*; Z_t 10000 

13 1:9 K_id; A_*; G_b; Z_m 1000 

14 2:9 K_id; A_*; G_b; Z_y 1000 

15 3:9 K_id; A_*; G_b; Z_* 1000 

16 0:10 K_id; A_id; G_*; Z_t 10000 

17 0:11 K_id; A_id; G_b; Z_m 10000 

18 1:11 K_id; A_id; G_b; Z_y 10000 

19 2:11 K_id; A_id; G_b; Z_* 10000 

- 229 - 

Parameter 






Max Sets 40




- 230 -






Kosten 1686650247 1686650247 0,00% 

Space left 9990000 9990000 0,00% 

Time left 24616192 24616192 0,00% 



- 231 -





Required 

Cubes: count 

1 1:0 K_*; A_id; Z_t 1 

2 3:0 K_*; A_*; Z_t 1000 

3 4:1 K_*; A_gr; Z_y 10000 

4 3:2 K_*; A_id; Z_y 1000 

5 4:3 K_gr; A_*; Z_y 1 

6 2:4 K_gr; A_gr; Z_m 1000 

7 3:4 K_gr; A_gr; Z_y 1 

8 2:6 K_id; A_*; Z_m 10000 

9 3:6 K_id; A_*; Z_y 1000 

10 1:7 K_id; A_gr; Z_m 1 

11 2:8 K_id; A_id; Z_* 1 


- 232 - 

Parameter 






Max Sets 20






Kosten 32747425 32747425 0,00% 

Space left 9287500 9287500 0,00% 

Time left 1291048 1291048 0,00% 





Required 

Cubes: count 

1 4:3 K_*; G_l; A_gr; Z_t 1 

2 3:6 K_*; G_b; A_gr; Z_t 1000 

3 4:9 K_*; G_bez; A_*; Z_m 1000 

4 2:12 K_gr; G_l; A_id; Z_t 10000 

5 3:19 K_gr; G_b; A_gr; Z_m 1 

6 2:21 K_gr; G_bez; A_*; Z_t 1000 

7 1:24 K_id; G_l; A_id; Z_t 10000 

8 2:31 K_id; G_b; A_gr; Z_m 10000 

9 0:33 K_id; G_bez; A_gr; Z_t 10000 

- 233 - 

Parameter 






Max Sets 30




- 234 -



- 235 -




- 236 -





Kosten 6198642 6198642 0,00% 

Space left 3934362 3934362 0,00% 

Time left 271760 271760 0,00% 



- 237 -





Required 

Cubes: count 

1 0:0 K_gr; A_id; G_b; Z_t 10000 

2 1:0 K_*; A_id; G_b; Z_t 10000 

3 2:0 K_*; A_*; G_b; Z_t 10000 

4 2:2 K_*; A_id; G_*; Z_t 10000 

5 2:3 K_*; A_id; G_b; Z_m 10000 

6 1:4 K_gr; A_*; G_b; Z_t 1 

7 2:4 K_gr; A_*; G_*; Z_t 1 

8 2:6 K_gr; A_id; G_*; Z_m 10000 

9 3:6 K_gr; A_id; G_*; Z_y 10000 

10 4:6 K_gr; A_id; G_*; Z_* 10000 

11 1:8 K_id; A_*; G_*; Z_t 10000 

12 2:8 K_id; A_*; G_*; Z_m 1000 

13 3:8 K_id; A_*; G_*; Z_y 1000 

14 4:8 K_id; A_*; G_*; Z_* 1000 

15 0:11 K_id; A_id; G_b; Z_m 10000 

16 1:11 K_id; A_id; G_b; Z_y 10000 

17 2:11 K_id; A_id; G_b; Z_* 10000 

- 238 - 

Parameter 






Max Sets 20




- 239 -






Kosten 1067776407 1067776407 0,00% 

Space left 14619500 14619500 0,00% 

Time left 24903780 24903780 0,00% 



- 240 -





Required 

Cubes: count 

1 2:0 C_*; A_gr; T_d 10000 

2 3:1 C_*; A_gr; T_m 10000 

3 2:3 C_gr; A_*; T_d 10000 

4 3:3 C_gr; A_*; T_m 10000 

5 2:4 C_gr; A_gr; T_m 10000 

6 2:5 C_gr; A_id; T_y 10000 

7 1:6 C_id; A_*; T_d 10000 


- 241 - 

Parameter 


Max Sets 50 

average time to store a 

tupel in time units 2 

average time for io in time 

units 2 

average time for CPU 

instructions in time units 0,002 

max time 1500000 

average time to query in 

timeunits 100 

average size of a tupel in 

bytes 900 

max space in bytes 58000000 

time weight 75% 

query weight 63%






Kosten 1619,256708 1549,136539 -4,53% 

Space left 2088400 2339500 10,73% 

Time left 1016362,41 804498,9363 -26,33% 

Es konnte keine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte 

den Wert im Lösungsweg 4. Damit zeigt dieser Testlauf am deutlichsten die Grenzen 

der Heuristik auf. Wäre in den Parameter die Anzahl der Lösungswege auf eine größere 

Anzahl als 29 gesetzt worden, wäre das Ergebnis richtig. 

8 CONCLUSIO 

Das Ziel und die Vision, die am Beginn dieser Arbeit stand, war es eine Heuristik zu 

entwickeln, welche die Auswahl der zu materialisieren Cubes treffen kann, diese zu 

Testen, die Test zu analysieren und zu bewerten. Deshalb war die Arbeit eine von sehr 

viel praktischer Programmiertätigkeit geprägte. Zusätzlich wurden jedoch in den 

Kapiteln 1 bis 6 die methodischen und inhaltsbezogenen Grundlagen zum Abhandeln 

der Arbeit gelegt. Dabei bin ich im Kapitel 1 speziell auf die Ziele, welche diese Arbeit 

begründen, eingegangen. Im Kapitel 2 wurde dann auf die Datenmodellierung 

eingegangen, da mit dem Aggregation Path Array eine Modellierungsmethode für 

- 242 -



Datawarehousesysteme als Werkzeug benutzt wird. Diese Modellierungsmethode wurde 

im Kapitel 6 im Detail behandelt. Im Kapitel 3 wurde dann speziell auf Datenbanken 

und SQL eingegangen, da im Prinzip ein Datawarehouse eine große Datenbank 

darstellt. Kapitel 4 beschäftigt sich kurz mit ERP-Systemen im Allgemeinen, wobei ich 

hier nicht in die Tiefe gegangen bin, da es für unsere Fragestellung grundsätzlich 

unerheblich ist, woher die Daten stammen. Allerdings wird die von mir entwickelte 

Software im Lehrbetrieb der Universität in Kombination mit einem ERP System 

eingesetzt werden. Kapitel 5 geht im Speziellen auf das Datawarehouse ein. Das Kapitel 

7 beschäftigt sich dann auf den eigentlichen Forschungsgegenstand. Dabei wird meine 

Heuristik präsentiert, beschrieben und begründet. So wird insbesondere der Algorithmus 

von Dijkstra verwendet, um eine Materialisierungsreihenfolge der Cubes zu finden. Zur 

Bestimmung der deterministischen Lösung wurde ein Ansatz über die Permutation und 

ein Ansatz über die Kombination in Verbindung mit Dijkstra vorgestellt. Beide liefern 

das gleiche Ergebnis. Dabei hat die Kombination bei kleinen APAs 

Geschwindigkeitsvorteile und die Permutation bei großen. Das Bestimmen der 

deterministischen Lösungen hat sehr viel Rechenzeit in Anspruch genommen (ca 3 bis 4 

Wochen pro Ergebnis). Durch den Einsatz von vier unterschiedlichen Rechnern wurde 

versucht dieses Problem in den Griff zu bekommen und abschließend können nun 

immerhin 18 Lösungen präsentiert werden. Die Ergebnisse, welche in Kapitel 7.9.2 

aufgelistet sind brachten außergewöhnlich gute Ergebnisse. So konnte fast immer eine 

100 % Übereinstimmung der heuristischen und deterministischen Lösung erreicht 

werden. Allerdings konnte im Test 18 aufgezeigt werden, dass die Genauigkeit der 

Heuristik von der Anzahl der Testläufe abhängt. Somit kann gezeigt werden, dass die 

Genauigkeit der heuristischen Lösung durch den Benutzer einstellbar ist. Dabei besteht 

ein Konflikt zwischen Berechnungszeit und Genauigkeit. Ausserdem muss beachtet 

werden, dass nur kleine APAs mit relativ geringen Speicher- bzw. Zeitlimits getestet 

wurden, um die Rechenzeit für die deterministische Lösung gering zu halten. Deshalb 

wäre es interessant zusätzliche Testläufe in eine zukünftige Forschungsarbeit 

einzubauen. Diesbezügliche Vorgespräche wurden mit Professor Prosser bereits geführt. 

Der Zeitgewinn durch den Einsatz der Heuristik, welche bei den vorgestellten APAs 

zwischen 2 und 30 Sekunden Berechnungszeit, im Vergleich zu 3 bis 4 Wochen 

Berechnungszeit der deterministischen Lösung, benötigt, ist enorm. Das macht die 

Heuristik für namhafte Softwarefirmen interessant. Deshalb wäre es in einem nächsten 

Schritt sinnvoll die Heuristik mit dem Produkt eines Datenbankherstellers zu 

kombinieren. Dabei könnte auch unmittelbar auf die Kostenfunktionen des Query 

Optimizers des Herstellers zugegriffen werden. Dies wäre nach meiner Ansicht für den 

praktischen Einsatz der Software jedenfalls notwendig. 

- 243 -



Zusätzlich zur rein wissenschaftlichen Arbeit wurde eine Softwareanwendung 

entwickelt, welche didaktisch eingesetzt werden soll. Diese Anwendungen möchte ich 

als höchste gelungen bezeichnen, da sie optimal für die Bedürfnisse der Studenten 

maßgeschneidert wurde. Damit kann jeder Student in praktischer Tätigkeit die 

Modellierung und die Entwicklung eines Datawarehouse vollziehen. Der Sourcecode 

sowie die Hilfedatei im HTML Format befinden sich im Anhang und stellten einen 

maßgeblichen Arbeitszeitanteil an dieser Arbeit dar. 

9 LITERATUR 

Achs, T. L., (2002), Erstellung eines Java-basierten Programms zur Implementierung 

des Aggregationspfadarrays – Diplomarbeit an der Wirtschaftsuniversität Wien 

Anahory, Sam, Murray, Dennis, (1997), Data Warehouse - Planung, Implementierung 

und Administration, Addision-Wesley-Logman, Bonn; Reading, Massachusetts u.a.. 

Archilles, A., (2000), SQL – Standardisierte Datenbanksprache vom PC bis zum 

Mainframe, 7. Aufl., Oldenbourg Wissenschaftsverlag GmbH, München 

Baldi, St., (1999), Grundlagen der Wirtschaftsinformatik, 2. Aufl., Oldenbourg Verlag, 

München 

Barth, M., Karl, G., (2002), MySQL, DATA BECKER GmbH & Co. KG, Düsseldorf 

Codd, E.F., (1970), A Relational Model of Data for Large Shared Data Banks“, CACM 

Colby, L., Kawaguchi, A., Lieuwen, F., Mumick, I., Ross, K., (1997), Supporting 

Multiple View Maintenance Policies, In: Joan Peckham (Ed.): SIGMOD 1997, 

Proceedings ACM SIGMOD International Conference on Management of Data, May 

13-15, 1997, Tucson, Arizona, USA. ACM Press 1997, SIGMOD Record 26(2), June 

1997, S. 405 - 416 

Connolly, T., Begg, C., Strachan, A., (2002), Datenbanksysteme, Addision-Wesely 

Verlag, ein Imprint der Peason Education Deutschland GmbH, München 

Cordts, S., (2002), Datenbankkonzepte in der Praxis, Addison-Wesley Verlag ein 

Imprint der Pearson Education Deutschland GmbH, München 

Crawley, P., Dilworth, R.P. (1973), Algebraic theory of lattice, Englewood Cliffs, New 

Jersey 

- 244 -



Dippold, R., Meier, A., Ringgenberg, A., Schnider, W., Schwinn, K., 

Unternehmensweites Datenmanagement, (2001), 3. Aufl., Friedr. Vieweg & Sohn 

Verlagsgesellschaft mbH, Braunschweig/Wiesbaden 

Dunemann, O., (2002), Anfrageoptimierung für OLAP-Anwendungen in virtuellen Data 

Warehouses, Tenea Verlag für Medien, Berlin 

Džeroski, S., Lavrač, N., (2001), Relational Data Mining, Springer Verlag, Berlin et al. 

Ehrenberg, D., Heine, P., (1998), Konzept zur Datenintegration für Management 

Support Systeme auf der Basis uniformer Datenstrukturen, In: Wirtschaftsinformation 

40. (1998), 6, S. 503-512 

Falkowksi, B., (2002), Business Computing – Grundlagen und Standardsoftware, 

Springer Verlag, Berlin u.a. 

Fischer, J., Herold, W., Dangelmaier, W., Nastansky, L.; Suhl, L.; (2000), Bausteine der 

Wirtschaftsinformatik, 2. Aufl., Erich Schmidt Verlag GmbH & Co., Berlin 

Fritz, M., (1997), Data Warehouse Technologie, In: Datenbank-Management, Interest- 

Verlag, Augsburg 

Gabriel, R., Röhrs, H.P., (2003), Gestaltung und Einsatz von Datenbanksystemen, 

Springer Verlag, Berlin et al. 

Geppert, A., (2002), Objektrelationale und objektorientierte Datenbankkonzepte und – 

systeme, dpunkt.verlag GmbH, Heidelberg 

Golfarelli, M., Maio, D., Rizzi, S. (1998), Conceptual Design on data warehouses from 

E/R Schemas; in: Proceeding of Hawaii International Conference On System Sciences, 

January 6-9, 1998, Kona, Hawaii, ftp://ftp-db.deis.unibo.it/pub/hicss98.pdf (22.02.2001) 

Goos, G., (2000), Vorlesungen über Informatik – Band 1, 3. Aufl., Springer-Verlag 

Berlin, u.a. 

Günther, H. O., Tempelmeier, H. (1997), Produktion und Logistik, 3. Aufl., Springer- 

Verlag, Berlin u.a. 

Hansen, H.R., (1996), Wirtschaftsinformatik I; 7. Auflage, Lucius & Lucius, Stuttgart 

Härder, T., Rahm, E., (2001), Datenbanksysteme, 2. Aufl., Springer-Verlag Berlin u.a. 

- 245 -



Harinarayan, V., Rajaraman, A., Ullmann, J.D., (1996), Implementing Data Cubes 

Efficiently, In Proceedings of ACM SIGMOD Conference, Montreal, Canada, June 

1996 

Hartmut, E., (2000), Grundlagen und Konzepte der Informatik, 2. Aufl., Friedr. Vieweg 

& Sohn Verlagsgesellschaft mbH, Braunschweig, Wiesbaden 

Heinrich, L. J., (2002) Wirtschaftsinformatik, 2. Aufl., Oldenbourg Wissenschaftsverlag 

GmbH, München 

Houlette, F., (2002), SQL- IT Tutorial, mitp-Verlag, Bonn 

Janko, W., H., (1998), Informationswirtschaft 1, 2. Aufl., Springer-Verlag, Berlin u.a. 

Jianzhong, L., Doron, R., Jaideep, S., (1999), Aggregation Alogrithms for Very Large 

Compressed Data Warehouses, In: Proceedings of the 25 th Very Large Database 

Conference, Edinburgh, Scotland, 1999, Morgan Kaufmann Publishers, Orlando 

Kaiser, A. (2000), Skriptum zur Lehrveranstaltung Management und 

Informationssysteme, Institut für Informationswirtschaft, http://exai3.wuwien.ac.at/~kaiser/mis/ 

(20.11.2000) 

Kemper, A., Eickler, A., (1996), Datenbanksysteme – Eine Einführung, Oldenbourg 

Verlag, München, Wien 

Kemper, A., Eickler, A., (1999), Datenbanksysteme, 3. Aufl., Oldenbourg Verlag, 

München 

Kleinschmidt, P., Rank, C., (2002), Relationale Datenbanksysteme – Eine praktische 

Einführung, 2. Aufl., Springer Verlag Berlin et al. 

Labio, W. J., Zhuge, Y., Wiener, J.L., Gupta, H., Garcia-Molina, H., Widom, J., (1997), 

The WHIPS Prototype for Data Warehous Creation and Maintenance, Joan Peckham 

(Ed.): SIGMOD 1997, Proceedings ACM SIGMOD International Conference on 

Management of Data, May 13-15, 1997, Tucson, Arizona, USA. ACM Press 1997, 

SIGMOD Record 26(2), June 1997, S. 557 -559 

Lusti, M. (1999), Data Warehousing und Data Mining, 1. Aufl., Springer-Verlag, Berlin 

u.a. 

Marsch, J., Fritze, J., (1999), Erfolgreiche Datenbankanwendung mit SQL, 5. Aufl., 

- 246 -



Friedr. Vieweg & Sohn Verlagsgesellschaft mbH, Braunschweig, Wiesbaden 

Martin, W. (1998), Data Warehousing, 1. Aufl., Internat. Thomson Publ., Bonn u.a. 

Meier, A., (2001), Relationale Datenbanken, 4. Auflage, Springer-Verlag, Berlin u.a. 

Mertens, P., Wieczorrek, H. W., (2000), Data X Strategien - Data Warehouse, Data 

Mining und operationale Systeme für die Praxis, Springer-Verlag, Berlin u.a. 

Morcinek, P., (2002), SQL, Data Becker GmbH & Co. KG, Düsseldorf 

Müller-Angstenberger, J. W., (1994), Die Arbeitsweise des DB2-Optimizers, In: 

Datenbank-Management, Interest-Verlag, Augsburg 

Mumick, I., Quass, D., Mumick, B., (1997), Maintenance of Data Cubes and Summary 

Tables in a Warehouse,In: Joan Peckham (Ed.): SIGMOD 1997, Proceedings ACM 

SIGMOD International Conference on Management of Data, May 13-15, 1997, Tucson, 

Arizona, USA. ACM Press 1997, SIGMOD Record 26(2), June 1997, S. 100 - 111 

Panny, W., Taudes, A., (2000), Einführung in den Sprachkern von SQL-99, Springer- 

Verlag, Berlin u.a. 

Pernul, G., Unland, R., (2001), Datenbanken im Unternehmen, Oldenbourg 

Wissenschaftsverlag GmbH, München, Wien 

Prosser, A., Ossimitz, M. L., (2000a), Analytical Logistics Information System SAP 

BW – Teaching Material for the Department of Production Management ), WS 00/01, 

Prosser, A., Ossimitz, M. L., (2000b), Eine Methode zur konzeptionellen Modellierung 

multidimensionaler Datenstrukturen im Data Warehouse (Handout) 

Prosser, A., Ossimitz, M. L., (2001), Data Warehouse Management – Using SAP BW, 

Facultas Verlags- und Buchhandels AG, Wien 

Prosser, A., Ossimitz, M. L., (2002), Data Warehouse Management – Teaching Material 

for the Department of Production Management ), WS 02/03, 

Rautenstrauch, C., Schulze, T., (2003), Informatik für Wirtschaftswissenschaftler und 

Wirtschaftsinformatiker, Springer-Verlag Berlin u.a. 

Redaktion Toolbox, (2002), Datenbanken mit Delphi, C&L Computer und 

Literaturverlag, Böblingen 

- 247 -



Reß, H., Viebeck, G., (2000), Datenstrukturen und Algorithmen, Carl Hanser Verlag, 

München, Wien 

Riordan, R. M., (2000), Microsoft SQL Server 2000 Programmierung, Microsoft Press 

Deutschland, Unterschleißheim 

Saake, G., Sattler, K., (2002), Algorithmen & Datenstrukturen – Eine Einführung mit 

Java, dpunkt.verlag GmbH, Heidelberg 

Schicker, E., (1999), Datenbanken und SQL, 2. Aufl., B.G. Teuber, Stuttgart, Leibzig 

Schneider, U., Werner, D., (2000), Taschenbuch der Informatik, 3. Aufl., Carl Hanser 

Verlag, München, Wien 

Sedgewick, R., (2002), Algorithmen, 2. Aufl., Addison-Wesley, München et al. 

Seemann, A., Schmalzridt, B., Lehmann, P., (2001), SAP Business Information 

Warehouse, Galileo Press, Bonn 

Shaw, M.; Blanning, R., Strader, T., Whinston, A., (2000), Handbook on electronic 

commerce, Springer-Verlag Berlin u.a. 

Stock, W., (2000), Informationswirtschaft, Oldenburg Wissenschaftsverlag GmbH, 

München 

Taylor, G. A., (2001), SQL für Dummies, 2. Aufl., mitp-Verlag ein Geschäftsbereich 

der verlag moderne industrie Buch AG & Co. KG, Landsberg 

Vossen, G., (2000), Datenmodelle, Datenbanksprachen und 

Datenbankmanagementsysteme, 4. Aufl., Oldenbourg Verlag, München, Wien 

Widenius, M., Axmark, D., (2002), MySQL- Das offizielle Handbuch, Die Deutsche 

Bibliothek 

Witt, K., (2001), Algebraische Grundlagen der Informatik – Zahlen –Strukturen – 

Codierung – Verschlüsselung, Friedr. Vieweg & Sohn Verlagsgesellschaft mbH, 

Braunschweig / Wiesbaden 

Witten, I.H., Eibe, F., (2000), Data mining: practical machine learning tools and 

techniques with Java implementations, Morgan Kaufmann Publishers, San Francisco 

Yang, J., Karlapalem, K., Li, Q., (1997), Algorithms for Materialized View Design in 

- 248 -



Data Warehousing Environment, In: Proceedings of the 23rd VLDB Conference 

Athens, Greece ftp://www.vldb.org/conf/1997/P136.PDF (22.02.2001) 

- 249 -



10 ABBILDUNGSVERZEICHNIS 

Abbildung 1: Symbol für Entitätstyp.............................................................................. 18 

Abbildung 2: Super- und Subentitätstypen mit „is a“ Operator [Quelle: 

Rautenstrauch/Schulze (2003) S. 237].................................................................... 19 

Abbildung 3: Entitätsmenge mit Attributen.................................................................... 19 

Abbildung 4: Einfaches Symbol eines Beziehungstyps für einfache Darstellbarkeit .... 20 

Abbildung 5: Formal richtiges Beziehungssymbol der ER-Modell Konvention ........... 20 

Abbildung 6: 1:1 Beziehung zwischen Kunde und Hauptwohnsitz ............................... 21 

Abbildung 7: 1:n Beziehung zwischen Abteilung und Mitarbeiter ................................ 22 

Abbildung 8: m:n Beziehung zwischen Mitarbeiter und Projekt ................................... 22 

Abbildung 9: Rekursiver Beziehungstyp [Quelle: Rautenstrauch/Schulze (2003) S. 237] 

................................................................................................................................23 

Abbildung 10: Firmenhierarchie..................................................................................... 24 

Abbildung 11: Beispielhafte Umsetzung einer 1:1 Beziehung in das Realtionenmodell 

in der vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ]..... 29 

Abbildung 12: Beispielhafte Umsetzung einer 1:n Beziehung in das Relationenmodell 

in der vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84]...... 30 

Abbildung 13: Beispielhafte Umsetzung einer m:n Beziehung in das Relationenmodell 

in der vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ]..... 31 

Abbildung 14: Relationale Datenstruktur [in Anlehnung: Panny/Taudes (2000) S. 23] 37 

Abbildung 15: Die Architektur eine Data Warehouse [Quelle: in Anlehnung an 

Posser/Ossimitz (2001) S. 26] ................................................................................ 49 

Abbildung 16: Die Basisarchitektur des WHIPS Systems [Quelle: Labio et al. (1997) S. 

557] ......................................................................................................................... 56 

Abbildung 17: Die WHIPS System Architektur für Warehouse Maintenance [Quelle: 

Labio et at (1997) S. 558] ....................................................................................... 57 

Abbildung 18: Das Modellsystem [Quelle: Kaiser (2000)]............................................ 67 

Abbildung 19: Phasen der Modellierung [Quelle: Kaiser (2000)] ................................. 68 

Abbildung 20: Einfache Hierarchie am Beispiel eines Kunden ..................................... 69 

Abbildung 21: Darstellung eines Würfels (cube) mit den Dimensionen Zeit, Artikel und 

Kunden [ in Anlehnung: Prosser/Ossimitz (2000), S. 18] ...................................... 70 

- 250 -



Abbildung 22: Selektion der Daten durch das Slice-Verfahren [Quelle: Schinzer et al. 

(1997), S. 40] .......................................................................................................... 71 

Abbildung 23: Die Navigation durch die Navigationsebenen [in Anlehnung: Prosser, 

Ossimitz (2000 a), S. 24 ] ....................................................................................... 72 

Abbildung 24: Einfaches Modell eines dreidimensionalen „Fact-Schema“ [in 

Anlehnung: Prosser, Ossimitz, (2000 a), S. 29]...................................................... 73 

Abbildung 25: Attributsbaum vor Pruning und Grafting [in Anlehnung: Prosser, 

Ossimitz, (2000 a), S. 33] ....................................................................................... 74 

Abbildung 26: Attributsbaum nach Pruning und Grafting [in Anlehnung: Prosser, 

Ossimitz, (2000 a), S. 34] ....................................................................................... 74 

Abbildung 27: Gitter [in Anlehnung: Prosser, Ossimitz (2000 a), S. 40]....................... 75 

Abbildung 28: Star-Schema mit „Fact-Table“ (gelb) und vier Dimension-Tables [In 

Anlehnung: Prosser, Ossimitz (2000 a), S. 51]....................................................... 77 

Abbildung 29: Das klassische Star-Schema [In Anlehnung: Prosser/Ossimitz (2000a ) S. 

51] ........................................................................................................................... 78 

Abbildung 30: Das Fact Constellation-Schema [Quelle: Prosser/Ossimitz (2001) S. 76] 

................................................................................................................................79 

Abbildung 31: Snowflake-Schema mit Attribut-Tables [in Anlehnung: Prosser, 

Ossimitz (2000a), S. 62] ......................................................................................... 80 

Abbildung 32: Galaxy-Schema und Multitube-Architektur [Quelle: 

Rautenstrauch/Schulze (2003) S. 334].................................................................... 81 

Abbildung 33: Das Unimu-Schema [Quelle: Ehrenberg/Heine (1998) S. 507] ............. 82 


Attributsnamen (rechts) nicht redundanzfrei [in Anlehnung: Prosser, Ossimitz, 

(2000 a), S. 43] ...................................................................................................... 83 


Attributsnamen (rechts) redundanzfreie Menge farblich markiert [in Anlehnung: 

Prosser, Ossimitz (2000 a), S. 43] ......................................................................... 86 

Abbildung 36: Darstellung der interessanten Würfel [in Anlehnung: Prosser, Ossimitz 

(2000 b), S. 17 ] ...................................................................................................... 87 

Abbildung 37: Anzeigebeispiel der Derivative (Bereich x) des Würfels x [in Anlehnung: 

Prosser, Ossimitz (2000 b), S. 17] .......................................................................... 89 

- 251 -



Abbildung 38: Anzeigebeispiel der Derivate (Bereich y) des Würfels y [in Anlehnung: 

Prosser, Ossimitz (2000 b), S. 17] .......................................................................... 89 

Abbildung 39: Anzeigebeispiel der Derivate (Bereich x + y) der Würfels x und y [in 

Anlehnung: Prosser, Ossimitz (2000 b), S. 17] ...................................................... 90 

Abbildung 40: Abgrenzung der Phasen der Betrachtung ............................................... 93 

Abbildung 41: Graph mit zwei Knoten........................................................................... 95 

Abbildung 42: Bewerteter Graph [Quelle: Reß/Viebock (2000) S. 404] ....................... 98 

Abbildung 43: Darstellung der Knoten und Kanten ..................................................... 107 

Abbildung 44: Funktionsweise eines Kostenmodells [Quelle: Kemper/Eickler (1996) S. 

212] ....................................................................................................................... 109 

Abbildung 45: Beispielhafte Arbeitsabfolge im G-Algorithmus [Quelle: Jianzhong 

(1999) S. 654] ....................................................................................................... 114 

Abbildung 46: Schematische Aufstellung der Würfel und Kostenfunktionen ............. 122 

Abbildung 47: Dimensionen und Hierarchien des DemoAPA..................................... 135 

Abbildung 48: DemoAPA mit Lösung ......................................................................... 135 

Abbildung 49: Schritt 1 der Heuristik nach Thomas ACHS ........................................ 136 









Abbildung 58: Schritt 10 der Heuristik nach Thomas ACHS ...................................... 141 






- 252 -








Abbildung 69: Das Hauptmenu des APA Programmes................................................ 166 

Abbildung 70: Der APA Input Screen.......................................................................... 167 

Abbildung 71: Die Präsentationsmaske des APA Grid ................................................ 168 

Abbildung 72: Die Auswahlmaske der Required Cubes .............................................. 169 

Abbildung 73: ER-Diagramm für die APA Datenbank................................................ 171 

Abbildung 74: Ableitung des APA Relationenmodells aus dem APA ER-Modell...... 175 

Abbildung 75: Der Aufbau eines Star Schemas als Basis der CREATE TABLE 

Anweisungen ........................................................................................................ 185 

Abbildung 76: Beispielhafte Auflistung der Dimension Tables und der Fact Tables beim 

Fact Constellation-Schema ................................................................................... 187 

Abbildung 77: Input Screen des Demo APA................................................................ 188 

Abbildung 78: APA Grid Screen des Demo APA........................................................ 189 

Abbildung 79: Demonstrative Anzeigen der Possible Cubes....................................... 202 

- 253 -



11 TABELLENVERZEICHNIS 

Tabelle 1: Kombinationen von Grad und Ausprägung................................................... 21 

Tabelle 2: Gegenüberstellung von relationalen und SQL-Ausdrücken [Quelle: 

Pernul/Unland (2001) S. 263]................................................................................. 35 

Tabelle 3: Vergleich operative Daten und Data Warehouse [in Anlehnung: Connolly et 

al. (2002) S. 910; Prosser, Ossimitz (2000 a), S. 11].............................................. 54 

Tabelle 4: Änderungen der Aggregate nach Funktionen [Quelle: Mumick et al. (1997) 

S.105]...................................................................................................................... 59 

Tabelle 5: Informationsflüsse im Data Warehouse [Quelle: Connolly et al. (2002) S. 

918ff] ...................................................................................................................... 60 

Tabelle 6: Operatoren und Zahlentypen [in Anlehnung: Prosser, Ossimitz (2000 a), S. 

20] ........................................................................................................................... 70 

Tabelle 7: Berechnung der kürzesten Wege von einem Knoten in einem Graph zu allen 

anderen [Quelle: Reß/Viebeck (2000) S. 405]........................................................ 99 

Tabelle 8: Berechnung der kürzesten Wege für einen azyklischen Graphen [Quelle: 

Reß/Viebeck (2000) S. 408] ................................................................................. 104 

Tabelle 9: Entwicklung der Query Response Time im Verhältnis zur Size [Quelle: 

Harinarayan et al. (1996) S. 11]............................................................................ 111 

Tabelle 10: : Beschreibung der Tables der APA Datenbank........................................ 174 

Tabelle 11: Beispielhafter BFT für die Anwendung .................................................... 185 

Tabelle 12: Beispielhafter Customer-Dimensionstable für die Anwendung ................ 186 

Tabelle 13: Beispielhafter Items-Dimensionstable für die Anwendung....................... 186 

Tabelle 14: Beispielhafter Time-Dimensionstable für die Anwendung ....................... 186 

- 254 -



12 ANHANG 

12.1 QUELLCODE DER ANWENDUNG 

12.1.1 PROGRAMM QUELLCODE APAWIN 

program APAWin; 

uses 

Forms, 

APA_Applicationunit in '..\Units\APA_Applicationunit.pas' {APA_Application}, 

APA_Gridunit in '..\Units\APA_Gridunit.pas' {APA_Grid}, 

APA_Input_Dimensionunit in '..\Units\APA_Input_Dimensionunit.pas' 

{APA_Insert_Dimension}, 

APA_Input_Hierarchyunit in '..\Units\APA_Input_Hierarchyunit.pas' 

{APA_Insert_Hierarchy}, 

APA_Input_Reqblockunit in '..\Units\APA_Input_Reqblockunit.pas' {APA_Insert_Reqblock}, 

APA_Input_Screenunit in '..\Units\APA_Input_Screenunit.pas' {APA_Input_Screen}, 

APA_Keyunit in '..\Units\APA_Keyunit.pas' {APA_Insert_Key}, 

APA_Optionsunit in '..\Units\APA_Optionsunit.pas' {APA_Options}, 

APA_Parameterunit in '..\Units\APA_Parameterunit.pas' {APA_Parameter}, 

APA_Selectionunit in '..\Units\APA_Selectionunit.pas' {APA_Selection_Screen}, 

APA_Analyseunit in '..\Units\APA_Analyseunit.pas' {APA_Analyse}, 

APA_Screenunit in '..\Units\APA_Screenunit.pas' {APA_Screen}, 

APA_Show_costsunit in '..\Units\APA_Show_costsunit.pas' {APA_Showcosts}, 

APA_Processunit in '..\Units\APA_Processunit.pas' {APA_Show_Process}, 

APA_Sqlunit in '..\Units\APA_Sqlunit.pas' {APA_Sql}, 

APA_Dialogunit in '..\Units\APA_Dialogunit.pas' {APA_Dialog}, 

APA_Helpunit in '..\Units\APA_Helpunit.pas' {APA_Help}; 

{$R *.res} 

begin 

Application.Initialize; 

Application.Title := 'APA Application'; 

Application.CreateForm(TAPA_Screen, APA_Screen); 

Application.CreateForm(TAPA_Application, APA_Application); 

Application.CreateForm(TAPA_Grid, APA_Grid); 

Application.CreateForm(TAPA_Insert_Dimension, APA_Insert_Dimension); 

Application.CreateForm(TAPA_Insert_Hierarchy, APA_Insert_Hierarchy); 

Application.CreateForm(TAPA_Insert_Reqblock, APA_Insert_Reqblock); 

Application.CreateForm(TAPA_Input_Screen, APA_Input_Screen); 

Application.CreateForm(TAPA_Insert_Key, APA_Insert_Key); 

Application.CreateForm(TAPA_Options, APA_Options); 

Application.CreateForm(TAPA_Parameter, APA_Parameter); 

Application.CreateForm(TAPA_Selection_Screen, APA_Selection_Screen); 

Application.CreateForm(TAPA_Analyse, APA_Analyse); 

Application.CreateForm(TAPA_Showcosts, APA_Showcosts); 

Application.CreateForm(TAPA_Show_Process, APA_Show_Process); 

Application.CreateForm(TAPA_Sql, APA_Sql); 

Application.CreateForm(TAPA_Dialog, APA_Dialog); 

Application.CreateForm(TAPA_Help, APA_Help); 

Application.Run; 

end. 

12.1.2 UNIT APA_ANALYSEUNIT.DFM 

object APA_Analyse: TAPA_Analyse 

Left = 220 

Top = 114 

Width = 696 

Height = 480 

Caption = 'APA_Analyse' 

Color = clBtnFace 

Font.Charset = DEFAULT_CHARSET 

Font.Color = clWindowText 

- 255 -



Font.Height = -11 

Font.Name = 'MS Sans Serif' 

Font.Style = [] 

OldCreateOrder = False 

Position = poScreenCenter 

OnShow = FormShow 

PixelsPerInch = 96 

TextHeight = 13 

object Analysetext: TMemo 

Left = 0 

Top = 0 

Width = 688 

Height = 405 

Align = alClient 

ScrollBars = ssBoth 

TabOrder = 0 

end 

object Panel1: TPanel 

Left = 0 

Top = 405 

Width = 688 

Height = 41 

Align = alBottom 

TabOrder = 1 

object Button_Close: TButton 

Left = 16 

Top = 8 

Width = 75 

Height = 25 

Cancel = True 

Caption = 'Close' 

Default = True 

TabOrder = 0 

OnClick = Button_CloseClick 

end 

end 

end 

12.1.3 UNIT APA_ANALYSEUNIT.PAS 

unit APA_Analyseunit; 

interface 

uses 

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, 

Dialogs, StdCtrls, ExtCtrls; 

type 

TAPA_Analyse = class(TForm) 

Analysetext: TMemo; 

Panel1: TPanel; 

Button_Close: TButton; 

procedure FormShow(Sender: TObject); 

procedure Button_CloseClick(Sender: TObject); 

private 

{ Private-Deklarationen } 

public 

{ Public-Deklarationen } 

end; 

var 

APA_Analyse: TAPA_Analyse; 

implementation 

uses APA_Gridunit, APA_Parameterunit, APA_Applicationunit; 

{$R *.dfm} 

procedure TAPA_Analyse.FormShow(Sender: TObject); 

var counter, counter2,pos:longint; 

- 256 -



var anztupels:Int64; 

var anzrequired, anzmat:longint; 

var Countergebnisse,N,K,NK:Extended; 

var anznotredundant:longint; 

var aktzeile,aktspalte,count_of_derivates:longint; 

var derivspalte,derivzeile,possiblecubes:longint; 

begin 

//Anzeige der Analyse des BFT 

Analysetext.Lines.Clear; 

Analysetext.Lines.Add('Analysis of Base Fact Table (BFT):'); 

Analysetext.Lines.Add('=================================='); 

Analysetext.Lines.Add(''); 

//Berechnen der Tupels im BFT table 

anztupels:=0;anzmat:=0;anzrequired:=0;anznotredundant:=0; 

for counter:=0 to anzd-1 do begin; 

anztupels:=anztupels+countdaten[counter,0]; 

end; 

Analysetext.Lines.Add('Tupels from source: '+inttostr(anztupels)); 


Analysetext.Lines.Add('List of Required cubes:'); 

Analysetext.Lines.Add('==========================='); 

for counter:=0 to anzzeilen-1 do begin 

for counter2:=0 to anzspalten-1 do begin 

if APA[counter2,counter].farbe=clYellow then begin 

anznotredundant:=anznotredundant+1; 

end; 

if APA[counter2,counter].interessant=true then begin 

anzrequired:=anzrequired+1; 

Analysetext.Lines.Add('Required cube: '+inttostr(counter2)+':'+inttostr(counter)+' 

'+APA[counter2,counter].kurzbez); 

end; 

end; 

end; 

Analysetext.Lines.Add('found '+inttostr(anzrequired)+' required cubes in 

'+inttostr(anznotredundant)+' not redundant cubes.'); 


Analysetext.Lines.Add('List of Materialized cubes:'); 




if APA[counter2,counter].materalisieren=true then begin 

anzmat:=anzmat+1; 

Analysetext.Lines.Add('Materialized cube: 

'+inttostr(counter2)+':'+inttostr(counter)+' '+APA[counter2,counter].kurzbez); 

end; 

end; 

end; 

Analysetext.Lines.Add('found '+inttostr(anzmat)+' materialized cubes'); 


Analysetext.Lines.Add('Deterministic solution:'); 


assignfile(fCountermerk,'C:\APADIR\DATA\Countermerk.dat'); 

{$i-} 

reset(fCountermerk); 

{$i+} 

if ioresult0 then showmessage('Can not open File Countermerk.dat'); 

assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat'); 

{$i-} 

reset(fCubes); 

{$i+} 

if ioresult0 then showmessage('Can not open File Cubes.dat'); 

assignfile(fMerkkosten,'C:\APADIR\DATA\Merkkosten.dat'); 

{$i-} 

- 257 -



reset(fMerkkosten); 

{$i+} 

if ioresult0 then showmessage('Can not open File Merkkosten.dat'); 

try 

pos:=0; 

repeat; 

if (filesize(fCountermerk)>0) then begin; 

seek(fCountermerk,pos); 

read(fCountermerk,vCountermerk); 

seek(fCubes,round(vCountermerk.nr)-1); 

read(fCubes,vCubes); 

Analysetext.Lines.Add('Cube('+floattostr(vCountermerk.Lfnr)+'):'+floattostr(vCount 

ermerk.Nr)+' = (' 

+inttostr(vCubes.Spalte)+':'+inttostr(vCubes.Zeile)+')'); 

end; 

pos:=pos+1; 

until pos>=filesize(fCountermerk);; 

if (filesize(fMerkkosten)>0) then 

begin; 


seek(fMerkkosten,0); 

read(fMerkkosten,vMerkkosten); 

Analysetext.Lines.Add('Costs: '+floattostr(vMerkkosten.Kosten)); 



Analysetext.Lines.Add('Space left: '+floattostr(vMerkkosten.Kosten)); 



Analysetext.Lines.Add('Time left: '+floattostr(vMerkkosten.Kosten)); 

end; 


Analysetext.Lines.Add('Count of possible solution:'); 


{Berechne Possible Cubes} 

counter:=anzrequired; 

{1.b Setze Derivate zu} 

for aktzeile:=0 to anzzeilen-1 do begin 

for aktspalte:=0 to anzspalten-1 do begin 

if 

(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].interessant=fa 

lse) then begin 

count_of_derivates:=0; 

for derivspalte:=0 to anzspalten-1 do begin; 

for derivzeile:=0 to anzzeilen-1 do begin; 

if (APA[derivspalte,derivzeile].interessant=true)and 

(APA[derivspalte,derivzeile].farbe=clYellow) then begin 

if APA_Grid.isderivat(aktspalte,aktzeile,derivspalte,derivzeile) then begin 

//Jetzt kontrollieren wir, ob dieser Würfel auch noch ein Derivat eines 

anderen Würfels 

count_of_derivates:=count_of_derivates+1; 

end;//Ende von derivat 

end;//Ende von interessant 

end;//of derivzeile 

end;//of derivsspalte 

- 258 -



if count_of_derivates>=1 then begin 

Analysetext.Lines.Add('Possible cube: 

'+inttostr(aktspalte)+':'+inttostr(aktzeile)+' '+APA[aktspalte,aktzeile].kurzbez); 

counter:=counter+1; 

end; 

end//von Yellow 

else if 

(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].interessant=tr 

ue) then 

Analysetext.Lines.Add('Possible and Required cube: 

'+inttostr(aktspalte)+':'+inttostr(aktzeile)+' '+APA[aktspalte,aktzeile].kurzbez); 

end;//aktspalte 

end;//aktzeile 

possiblecubes:=counter; 

Analysetext.Lines.Add('Found '+inttostr(possiblecubes)+' Possible Cubes'); 

{Berechne Permutation} 

Countergebnisse:=0; 

N:=1; 

for counter2:=1 to possiblecubes do N:=N*counter2; 

Analysetext.Lines.Add('Possible Combinations Permutation: '+floattostr(N)); 

for counter:=1 to possiblecubes do begin 

K:=1; 

for counter2:=1 to counter do K:=K*counter2; //K! 

NK:=1; 

for counter2:=1 to (possiblecubes-counter) do NK:=NK*counter2; 

Countergebnisse:=Countergebnisse+(N/(K*NK)); 

end; 

Analysetext.Lines.Add('Possible Combinations Kombination: 

'+floattostr(Countergebnisse)); 

finally 

CloseFile(fcountermerk); 

CloseFile(fMerkkosten); 

CloseFile(fCubes); 

end; 

end; 

procedure TAPA_Analyse.Button_CloseClick(Sender: TObject); 

begin 

Close; 

end; 

end. 

12.1.4 UNIT APA_APPLICATIONUNIT.DFM 

object APA_Application: TAPA_Application 

Left = 158 

Top = 115 

ActiveControl = APA_Input_Screen_button 

BorderStyle = bsSingle 

Caption = 'APA Application' 

ClientHeight = 522 

ClientWidth = 704 







Menu = APA_Menu 



OnActivate = FormActivate 

OnCloseQuery = FormCloseQuery 

- 259 -





object Image1: TImage 

Left = 0 

Top = 0 

Width = 704 

Height = 522 


Picture.Data = { 

07544269746D61702EEB1000424D2EEB1000000000003600000028000000C302 

00000A0200000100180000000000F8EA1000C30E0000C30E0000000000000000 

. . . . . 

. . . . . 

. . . . . 

5E4C5A5E4C5A5E4C5A5E4C5A5E4D5A5E4D5A5E4D5A5E4D5A5E4D5A5E4D5A5E4D 

5A5E4D5A5E4E5A5E4E5A5E4E5A5E4E5B5E4E5B5E6E7C80000000} 

end 

object APA_Input_Screen_button: TButton 

Left = 40 

Top = 152 

Width = 75 

Height = 25 

Caption = 'Input Screen' 

TabOrder = 0 

OnClick = APA_Input_Screen_buttonClick 

end 

object APA_Grid_button: TButton 

Left = 40 

Top = 408 

Width = 75 

Height = 25 

Caption = 'APA Grid' 

TabOrder = 1 

OnClick = APA_Grid_buttonClick 

end 

object Button_Apa_Selection: TButton 

Left = 328 

Top = 280 

Width = 123 

Height = 25 

Caption = 'APA Selection Screen' 

TabOrder = 2 

OnClick = Button_Apa_SelectionClick 

end 

object APA_Menu: TMainMenu 

Left = 528 

Top = 8 

object File1: TMenuItem 

Caption = 'File' 

object Open1: TMenuItem 

Caption = 'Open' 

OnClick = Open1Click 

end 

object Save1: TMenuItem 

Caption = 'Save' 

OnClick = Save1Click 

end 

object Saveas1: TMenuItem 

Caption = 'Save as ...' 

OnClick = Saveas1Click 

end 

object Exit1: TMenuItem 

Caption = 'Exit' 

OnClick = Exit1Click 

end 

end 

object Screens1: TMenuItem 

Caption = 'Screens' 

object InputScreen1: TMenuItem 

Caption = 'Input Screen' 

OnClick = InputScreen1Click 

end 

object APAGridScreen1: TMenuItem 

Caption = 'APA Grid Screen' 

- 260 -



OnClick = APAGridScreen1Click 

end 

object APASelectionScreen1: TMenuItem 


OnClick = APASelectionScreen1Click 

end 

end 

object Berechnungen1: TMenuItem 

Caption = 'Random costs' 

object GeneriereZufallskosten1: TMenuItem 

Caption = 'Build random costs' 

OnClick = GeneriereZufallskosten1Click 

end 

object ShowRandomCosts1: TMenuItem 

Caption = 'Show random costs' 

OnClick = ShowRandomCosts1Click 

end 

object Restrictedcosts1: TMenuItem 

AutoCheck = True 

Caption = 'Restricted costs' 

Checked = True 

OnClick = Restrictedcosts1Click 

end 

end 

object Analyse1: TMenuItem 

Caption = 'Analyse' 

object AnalyseAPA1: TMenuItem 

Caption = 'Analyse APA' 

OnClick = AnalyseAPA1Click 

end 

end 

object Settings1: TMenuItem 

Caption = 'Settings' 

object Parameter1: TMenuItem 

Caption = 'Parameters' 

OnClick = Parameter1Click 

end 

object Options1: TMenuItem 

Caption = 'Options' 

OnClick = Options1Click 

end 

end 

object Help1: TMenuItem 

Caption = 'Help' 

object HelpfilesAPAprogram1: TMenuItem 

Caption = 'Help files APA program' 

OnClick = HelpfilesAPAprogram1Click 

end 

object HelpfilesforMainmenu1: TMenuItem 

Caption = 'Help files for Main menu' 

OnClick = HelpfilesforMainmenu1Click 

end 

end 

end 

object APASavedialog: TSaveDialog 

DefaultExt = 'apa' 

Filter = 'APA File|*.apa' 

InitialDir = 'c:\APADIR\Save' 

Left = 272 

Top = 168 

end 

object APAOpendialog: TOpenDialog 

DefaultExt = 'apa' 

Filter = 'APA File|*.apa' 

InitialDir = 'c:\APADIR\Save' 

Left = 368 

Top = 120 

end 

end 

- 261 -



12.1.5 UNIT APA_APPLICATIONUNIT.PAS 

unit APA_Applicationunit; 

interface 

uses 


Dialogs, Menus, StdCtrls, ExtCtrls, Math, ComCtrls, ShellCtrls; 

type Countertype= 

record 

Lfnr:Extended; 

Nr:Extended; 

end; 

type Cubestype= 

record 


Spalte:Longint; 

Zeile:Longint; 

Required:Longint; 

end; 

type Kostentype= 

record 

VonSpalte:Longint; 

VonZeile:Longint; 

ZuSpalte:Longint; 

ZuZeile:Longint; 

Query:Extended; 

Build:Extended; 

end; 

type Merkkostentype= 

record 


Kosten:Extended; 

end; 

type ReqCubestype= 

record 


Spalte:Longint; 

Zeile:Longint; 

end; 

type 

TAPA_Application = class(TForm) 

APA_Menu: TMainMenu; 

File1: TMenuItem; 

Open1: TMenuItem; 

Save1: TMenuItem; 

Saveas1: TMenuItem; 

Exit1: TMenuItem; 

Screens1: TMenuItem; 

InputScreen1: TMenuItem; 

APAGridScreen1: TMenuItem; 

APASelectionScreen1: TMenuItem; 

Berechnungen1: TMenuItem; 

Settings1: TMenuItem; 

Parameter1: TMenuItem; 

Options1: TMenuItem; 

Image1: TImage; 

APA_Input_Screen_button: TButton; 

APA_Grid_button: TButton; 

Button_Apa_Selection: TButton; 

APASavedialog: TSaveDialog; 

APAOpendialog: TOpenDialog; 

GeneriereZufallskosten1: TMenuItem; 

ShowRandomCosts1: TMenuItem; 

Restrictedcosts1: TMenuItem; 

Analyse1: TMenuItem; 

- 262 -



AnalyseAPA1: TMenuItem; 

Help1: TMenuItem; 

HelpfilesAPAprogram1: TMenuItem; 

HelpfilesforMainmenu1: TMenuItem; 

Shelldir: TShellTreeView; 

procedure Kostensortieren(); 

function findkosten(vonspalte,vonzeile,zuspalte,zuzeile:longint):boolean; 

procedure Parameter1Click(Sender: TObject); 

procedure Lade(Filename:string); 

procedure Open1Click(Sender: TObject); 

procedure Speichern(Filename:string); 

procedure Saveas1Click(Sender: TObject); 

procedure Exit1Click(Sender: TObject); 

procedure InputScreen1Click(Sender: TObject); 

procedure APAGridScreen1Click(Sender: TObject); 

procedure APASelectionScreen1Click(Sender: TObject); 

procedure Options1Click(Sender: TObject); 

procedure APA_Input_Screen_buttonClick(Sender: TObject); 

procedure APA_Grid_buttonClick(Sender: TObject); 

procedure Button_Apa_SelectionClick(Sender: TObject); 

procedure FormActivate(Sender: TObject); 

procedure GeneriereZufallskosten1Click(Sender: TObject); 

procedure ShowRandomCosts1Click(Sender: TObject); 

procedure Save1Click(Sender: TObject); 

procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean); 

procedure Restrictedcosts1Click(Sender: TObject); 

procedure AnalyseAPA1Click(Sender: TObject); 

procedure HelpfilesAPAprogram1Click(Sender: TObject); 

procedure HelpfilesforMainmenu1Click(Sender: TObject); 

procedure FormCreate(Sender: TObject); 

private 


public 


end; 

var 

APA_Application: TAPA_Application; 

first:boolean=true; 

APAFilename:string ='C:\APA\SAVE\Default.apa'; 

mustsave:boolean =false; 

var Fcounter:file of Countertype; 

vcounter:Countertype; 

FCountermerk:file of Countertype; 

vcountermerk:Countertype; 

FCubes:file of Cubestype; 

vcubes:Cubestype; 

FKosten:file of Kostentype; 

vkosten:Kostentype; 

FMatCubes:file of ReqCubestype; 

vMatcubes:reqcubestype; 

FReqCubes:file of ReqCubestype; 

vreqcubes:ReqCubestype; 

FMerkkosten:file of Merkkostentype; 

vmerkkosten:Merkkostentype; 


uses APA_Parameterunit, APA_Selectionunit, APA_Gridunit, 

APA_Optionsunit, APA_Analyseunit, APA_Input_Screenunit, 

APA_Show_costsunit, APA_Processunit, APA_Dialogunit, APA_Helpunit; 

{$R *.dfm} 

procedure TAPA_Application.Kostensortieren(); 

var pos:longint; 

var k1,k2:Kostentype; 

var max:longint; 

begin 

max:=filesize(fKosten)-1; 

pos:=max; 

- 263 -



repeat; 

if (pos>=1) then begin 

seek(fKosten,pos); 

read(fKosten,k1); 

seek(fKosten,pos-1); 

read(fKosten,k2); 

if 

((k1.VonSpalte=k2.vonspalte)and(k1.VonZeile=k2.vonzeile)and(k1.ZuSpalte



then begin;bereich:=0;gefunden:=true;end 

else begin 

if (k1.VonSpalte



Filename:='C:\APADIR\SAVE\Default.apa'; 

assignfile(APA_File,'C:\APADIR\SAVE\Default.apa'); 

reset(APA_File); 

end; 

first2:=true; 

APA_Input_Screen.Eingabe.Items.Clear; 

st:=''; 

while (not eof(APA_File))and(st'Ende Req') do begin 

readln(APA_File,st); 

if (st'Ende Input')and(st'Ende Req')and(st'Ende Keybox') then begin 

st2:=copy(st,1,5); 


st:=copy(st,11,500); 

if APA_Input_Screen.Eingabe.SelectedNil then begin 

while (APA_Input_Screen.Eingabe.Selected.GetNextnil) do 

APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Selected.GetNext; 

end; 

if (strtoint(st3)=1) then begin 

if first2=true then begin 

APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.Add(nil,st); 

APA_Input_Screen.Eingabe.Selected.ImageIndex:=strtoint(st3); 

APA_Input_Screen.Eingabe.Selected.SelectedIndex:=strtoint(st3); 

end 

else 

APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.Add(APA_Input_Sc 

reen.Eingabe.Selected, 

st); 




if APA_Input_Screen.Eingabe.Selected.Level=0 then 

APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.AddChild(APA_Inp 

ut_Screen.Eingabe.Selected, 

st) 

else 

APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.Add(APA_Input_Sc 

reen.Eingabe.Selected, 

st); 



end; 

end; 

end;//Ende von while1 

APA_Selection_Screen.Req.items.clear; 

while (not eof(APA_File))and(st'Ende Input') do begin 


if (st'Ende Input')and(st'Ende Req')and(st'Ende Selection')and(st'Ende 

Keybox') then begin 



st:=copy(st,11,500); 

if APA_Input_Screen.Eingabe.SelectedNil then begin 

while (APA_Input_Screen.Eingabe.Selected.GetNextnil) do 

APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Selected.GetNext; 

end; 

if (strtoint(st2)=0) then begin 

if first2=true then begin 

APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.Req.Items.Add(nil,st); 

APA_Selection_Screen.Req.Selected.ImageIndex:=strtoint(st3); 

APA_Selection_Screen.Req.Selected.SelectedIndex:=strtoint(st3); 

end 

else 

- 266 -



APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.Req.Items.Add(APA_Selectio 

n_Screen.Req.Selected, 

st); 




if APA_Selection_Screen.Req.Selected.Level=0 then 

APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.Req.Items.AddChild(APA_Sel 

ection_Screen.Req.Selected, 

st) 

else 

APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.REq.Items.Add(APA_Selectio 

n_Screen.Req.Selected, 

st); 



end; 

end; 

end;//Ende von while2 

APA_Selection_Screen.Listeint.Items.Clear; 

while ((not eof(APA_File))and(st'Ende Selection')) do begin 



Keybox') then begin 

APA_Selection_Screen.Listeint.Items.Add(st); 

end; 

end;//Ende von While3 

APA_Grid_button.Enabled:=true; 

Button_Apa_Selection.Enabled:=true; 

APA_Grid.bezeichnungenholen(); 

generiereapaneu:=true; 

APA_Grid.FormShow(self); 

//Begin while 4 

Matcount:=0; 

while (not eof(APA_File)and(st'Ende Cubes')) do begin 



Keybox')and(st'Ende Cubes') then begin 

if copy(st,1,1)='R' then begin 

APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].interessant:=true; 

APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].gewicht:=strtofloat(copy(st, 

62,30)); 

APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].gewichtlevel:=strtoint(copy( 

st,92,30)); 

end; 

if copy(st,1,1)='M' then begin 

APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].materalisieren:=true; 

APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].matcount:=strtoint(copy(st,6 

2,30)); 

Matcount:=Matcount+1; 

end; 

end; 


APA_Input_Screen.Keybox.Clear; 

while ((not eof(APA_File))and(st'Ende Keybox')) do begin 

- 267 -





Keybox')and(st'Ende Cubes') then begin 

APA_Input_Screen.Keybox.Items.Add(st); 

end; 


if (not eof(APA_File)) then begin 


APA_Parameter.APA_Thomas_timestore.text:=st; 


APA_Parameter.APA_Thomas_timeio.text:=st; 


APA_Parameter.APA_Thomas_avsizeoftupel.text:=st; 


APA_Parameter.APA_Thomas_timemax.text:=st; 


APA_Parameter.APA_Thomas_spacemax.text:=st; 


APA_Parameter.APA_Thomas_Importance.Position:=strtoint(st); 


APA_Parameter.APA_Thomas_Query_Importance.Position:=strtoint(st); 


if st'Ende Parameter' then begin 

APA_Parameter.APA_Thomas_newsetsoneachiteration.text:=st; 


APA_Parameter.APA_Thomas_countofsets.text:=st; 


end; 


APA_Parameter.APA_Thomas_timecpu.text:=st; 


end; 


if st='True' then 

Permutation:=true else Permutation:=false; 


end; 


APA_Parameter.APA_Thomas_querytimemax.text:=st; 



APA_Grid.Userandomcosts1.Checked:=true else APA_Grid.Userandomcosts1.Checked:=false; 


end; 

if (not(Eof(APA_File))) then begin 

st:='';APA_Parameter.APA_Degrees.clear; 

while(not(Eof(APA_File)))and(st'Ende Degrees') do begin 


if st'Ende Degrees' then APA_Parameter.APA_Degrees.Items.Add(st); 

end; 

st:='';APA_Parameter.APA_Degreecounts.Clear; 

while(not(Eof(APA_File)))and(st'Ende Degreescount') do begin 


if st'Ende Degreescount' then APA_Parameter.APA_Degreecounts.items.Add(st); 

end; 

for counter:=0 to 14 do begin 


DegreeColors[counter]:=strtoint(st); 

end; 




Othercolors[counter]:=strtoint(st); 

end; 


- 268 -



end;//Ende von Eof2 dient der Rückwärtskompartibilität 

end;//Ende von not EOF 

APA_Grid.materialzeichnen; 

finally 

CloseFile(APA_File); 

if uppercase(APAFilename)uppercase('C:\APADIR\SAVE\Default.apa') 

then 

APA_Application.Caption:='APA Application - '+APAFilename 

else 

APA_Application.Caption:='APA Application '; 

end; 

try 

APA_Show_Process.ausgabe('Loading costs'); 

//Lade auch die Kosten 

//Lade aus Spezialdatei 

if fileexists(ExtractFilePath(filename)+ 

copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'ape') 

then begin 

try 

fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+ 

copy(ExtractFilename(filename),1,length(ExtractFilename(filename))- 

3)+'ape',fmOpenRead); 

try 

fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Kosten.dat',fmCreate); 

fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size); 

finally 

freeandnil(fStreamSpeichern); 

end; 

finally 

freeandnil(fStreamLaden); 

end; 

end; 

APA_Show_Process.ausgabe('Loading solution costs'); 



copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apf') 

then begin 

try 



3)+'apf',fmOpenRead); 

try 

fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Merkkosten.dat',fmCreate); 


finally 


end; 

finally 


end; 

end; 

APA_Show_Process.ausgabe('Loading cubes'); 



copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apd') 

then begin 

try 



3)+'apd',fmOpenRead); 

- 269 -



try 

fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Cubes.dat',fmCreate); 


finally 


end; 

finally 


end; 

end; 

APA_Show_Process.ausgabe('Loading counter'); 



copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apb') 

then begin 

try 



3)+'apb',fmOpenRead); 

try 

end; 

fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Counter.dat',fmCreate); 


finally 


end; 

finally 


end; 

APA_Show_Process.ausgabe('Loading solution'); 



copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apc') 

then begin 

try 



3)+'apc',fmOpenRead); 

try 

end; 

fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Countermerk.dat',fmCreate); 


finally 


end; 

finally 


end; 

except 

showmessage('Could not load costs'); 

fehler:=true; 

end; 

finally 

APA_Application.Enabled:=true; 

APA_Show_Process.ButtonCancel.Caption:='Close'; 

if fehler=false then 

APA_Show_Process.Ausschalten.Enabled:=true 

else 


mustsave:=false; 

end; 

end; 

procedure TAPA_Application.Open1Click(Sender: TObject); 

- 270 -



begin 

APAOpendialog.InitialDir:= 

APA_Options.APA_Save_Path.Directory; 

If APAOpendialog.Execute then begin 

if mustsave=true then begin 

APA_Dialog.APA_Text.Caption:='You did not save your APA. Do you want to save?'; 

if APA_Dialog.showmodal=mryes then begin; 

if APAFilename='C:\APADIR\SAVE\Default.apa' then 

Saveas1Click(self) else 

Speichern(APAFilename); 

end; 

end; 

APAFilename:=APAOpendialog.FileName; 

Lade(APAFileName); 

end; 

end; 

procedure TAPA_Application.Speichern(Filename:string); 

var APA_File: TextFile; 

counter,counter2:longint; 

st:string; 

fStreamladen,fStreamspeichern:TFileStream; 

begin 

try 

APA_Show_Process.ButtonPause.Visible:=false; 

APA_Show_Process.show; 

APA_Show_Process.APA_Protocoll.Clear; 

APA_Show_Process.ausgabe('Saving File: '+Filename); 

APA_Show_Process.ausgabe('Save APA Data ...'); 

APA_Application.Enabled:=false; 

assignfile(APA_File,APAFilename); 

try 

rewrite(APA_File); 

APA_Show_Process.ausgabe('Save APA Input Screen'); 

for counter:=0 to APA_Input_Screen.Eingabe.Items.Count-1 do begin 

st:=APA_Grid.auffuellen(inttostr(APA_Input_Screen.Eingabe.Items[counter].Level),5)+ 

APA_Grid.auffuellen(inttostr(APA_Input_Screen.Eingabe.Items[counter].Imageindex),5 

)+ 

APA_Input_Screen.Eingabe.Items[counter].Text; 

writeln(APA_File,st); 

end; 

writeln(APA_File,'Ende Req'); 

APA_Show_Process.ausgabe('Save APA Selection Screen'); 

for counter:=0 to APA_Selection_Screen.Req.Items.Count-1 do begin 

st:=APA_Grid.auffuellen(inttostr(APA_Selection_Screen.Req.Items[counter].Level),5)+ 

APA_Grid.auffuellen(inttostr(APA_Selection_Screen.Req.Items[counter].ImageIndex),5 

)+ 

APA_Selection_Screen.Req.Items[counter].Text; 


end; 

writeln(APA_File,'Ende Input'); 

for counter:=0 to APA_Selection_Screen.Listeint.Items.Count-1 do begin 

st:=APA_Selection_Screen.Listeint.Items[counter]; 


end; 

writeln(APA_File,'Ende Selection'); 

APA_Show_Process.ausgabe('Save required and materialized cubes'); 



- 271 -



if (APA[counter2,counter].interessant=true) then begin 

st:='R'+APA_Grid.auffuellen(inttostr(counter2),30)+APA_Grid.auffuellen(inttostr(co 

unter),30)+ 

APA_Grid.auffuellen(floattostr(APA[counter2,counter].gewicht),30)+APA_Grid.auffuel 

len(inttostr(APA[counter2,counter].gewichtlevel),30); 


end; 

if (APA[counter2,counter].materalisieren=true) then begin 

st:='M'+APA_Grid.auffuellen(inttostr(counter2),30)+APA_Grid.auffuellen(inttostr(co 

unter),30)+ 

APA_Grid.auffuellen(inttostr(APA[counter2,counter].matcount),30); 


end; 

end; 

end; 

writeln(APA_File,'Ende Cubes'); 

APA_Show_Process.ausgabe('Save APA Input Screen Keybox'); 

for counter:=0 to APA_Input_Screen.keybox.Items.Count-1 do begin 

writeln(APA_File,APA_Input_Screen.keybox.Items[counter]); 

end; 

writeln(APA_File,'Ende Keybox'); 

APA_Show_Process.ausgabe('Save APA Parameter'); 

writeln(APA_File,APA_Parameter.APA_Thomas_timestore.text); 

writeln(APA_File,APA_Parameter.APA_Thomas_timeio.text); 

writeln(APA_File,APA_Parameter.APA_Thomas_avsizeoftupel.text); 

writeln(APA_File,APA_Parameter.APA_Thomas_timemax.text); 

writeln(APA_File,APA_Parameter.APA_Thomas_spacemax.text); 

writeln(APA_File,inttostr(APA_Parameter.APA_Thomas_Importance.Position)); 

writeln(APA_File,inttostr(APA_Parameter.APA_Thomas_Query_Importance.Position)); 

writeln(APA_File,APA_Parameter.APA_Thomas_newsetsoneachiteration.text); 

writeln(APA_File,APA_Parameter.APA_Thomas_countofsets.text); 

writeln(APA_File,APA_Parameter.APA_Thomas_timecpu.text); 

if Permutation=true then 

writeln(APA_File,'True')else writeln(APA_File,'False'); 

writeln(APA_File,APA_Parameter.APA_Thomas_querytimemax.text); 

if APA_Grid.Userandomcosts1.Checked=true then 

writeln(APA_File,'True')else writeln(APA_File,'False'); 

writeln(APA_File,'Ende Parameter'); 

for counter:=0 to APA_Parameter.APA_Degrees.Items.Count-1 do begin 

writeln(APA_File,APA_Parameter.APA_Degrees.Items[counter]); 

end; 

writeln(APA_File,'Ende Degrees'); 

for counter:=0 to APA_Parameter.APA_Degreecounts.Items.Count-1 do begin 

writeln(APA_File,APA_Parameter.APA_Degreecounts.Items[counter]); 

end; 

writeln(APA_File,'Ende Degreescount'); 


writeln(APA_File,inttostr(DegreeColors[counter])); 

end; 

writeln(APA_File,'Ende Farben'); 


writeln(APA_File,inttostr(Othercolors[counter])); 

end; 

writeln(APA_File,'Ende Andere Farben'); 

finally 

Closefile(APA_File); 

APA_Application.Caption:='APA Application - '+APAFilename; 

- 272 -

try 


end; 


APA_Show_Process.ausgabe('Save costs'); 

//Speichere auch die Kosten 

//Speichere in Spezialdatei 

{$i-} 

CloseFile(fKosten); 

{$i+} 

if ioresult0 then APA_Show_Process.ausgabe('Close cost database'); 

try 

fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Kosten.dat',fmOpenRead); 

try 

fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+ 


3)+'ape',fmCreate); 


finally 


end; 

finally 


end; 

APA_Show_Process.ausgabe('Save solution'); 


try 

fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Countermerk.dat',fmOpenRead); 

try 



3)+'apc',fmCreate); 


finally 


end; 

finally 


end; 

APA_Show_Process.ausgabe('Save cubes'); 


try 

fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Cubes.dat',fmOpenRead); 

try 



3)+'apd',fmCreate); 


finally 


end; 

finally 


end; 

APA_Show_Process.ausgabe('Save counter'); 


try 

fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Counter.dat',fmOpenRead); 

try 



3)+'apb',fmCreate); 


finally 


end; 

finally 


end; 

- 273 -



APA_Show_Process.ausgabe('Save solution costs'); 


try 

fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Merkkosten.dat',fmOpenRead); 

try 



3)+'apf',fmCreate); 


finally 


end; 

finally 


end; 

except 

showmessage('Could not save costs'); 

end; 

finally 


APA_Show_Process.Ausschalten.Enabled:=true; 


mustsave:=false; 

end; 

end; 

procedure TAPA_Application.Saveas1Click(Sender: TObject); 

begin 

APASavedialog.InitialDir:= 

APA_Options.APA_Save_Path.Directory; 

if APASavedialog.Execute then begin 

APAFilename:= APASavedialog.FileName; 


end; 

end; 

procedure TAPA_Application.Exit1Click(Sender: TObject); 

begin 

Close; 

end; 

procedure TAPA_Application.InputScreen1Click(Sender: TObject); 

begin 

APA_Input_Screen_buttonClick(self); 

end; 

procedure TAPA_Application.APAGridScreen1Click(Sender: TObject); 

begin 

APA_Grid_buttonClick(self); 

end; 

procedure TAPA_Application.APASelectionScreen1Click(Sender: TObject); 

begin 

Button_Apa_SelectionClick(self); 

end; 

procedure TAPA_Application.Options1Click(Sender: TObject); 

begin 

APA_Options.showmodal; 

end; 

procedure TAPA_Application.APA_Input_Screen_buttonClick(Sender: TObject); 

begin 

APA_Application.Hide; 

try 

APA_Input_Screen.ShowModal 

finally 

- 274 -



APA_Application.Show; 

end; 

end; 

procedure TAPA_Application.APA_Grid_buttonClick(Sender: TObject); 

begin 


{Generieren des APA } 

try 

gotoInput:=false; 

gotoSelection:=false; 

bezeichnungenkontrolliert:=false; 

APA_Grid.bezeichnungenholen(); 

if bezeichnungenkontrolliert=true then begin; 

APA_Grid.WindowState:=wsMaximized; 

APA_Grid.showmodal; 

Button_APA_Selection.Enabled:=true; 

end else 

begin; 

gotoInput:=true; 

end; 

if gotoInput=true then begin;gotoInput:=false;APA_Input_Screen_button.Click;end; 

if gotoSelection=true then begin;gotoSelection:=false;Button_Apa_Selection.Click;end; 

finally 


end; 

end; 

procedure TAPA_Application.Button_Apa_SelectionClick(Sender: TObject); 

var zahler:longint; 

begin 


try 

{Laden der möglichen Dimensionen und Hierarchiestufen} 

{1. Dimensionen laden} 

with APA_Selection_Screen do begin 

Dimensionbox.Items.Clear; 

Hierarchybox.Items.Clear; 

for zahler:= 0 to anzd-1 do begin 

Dimensionbox.Items.Add(dimbez[zahler]); 

end; 

Dimensionbox.itemindex:=0; 

{Füllen der Hierarchien} 

hierarchybox.Items.Clear; 

{Hole die Hierarchiestufen} 

for zahler:=0 to anzh[Dimensionbox.itemindex]-1 do begin 

Hierarchybox.Items.Add(dl[Dimensionbox.itemindex][zahler]) 

end; 

Hierarchybox.ItemIndex:=0; 

Methodbox.ItemIndex:=0; 

End_of_methodbox.Enabled:=false; 

end;{Ende von APA_Selection_Screen} 

APA_Selection_Screen.WindowState:=wsMaximized; 

APA_Selection_Screen.showmodal; 

if gotoAPA=true then begin;gotoAPA:=false;APA_Grid_Button.Click;end; 

finally 

- 275 -




end; 

end; 

procedure TAPA_Application.FormActivate(Sender: TObject); 

var merkfile:TextFile; 

st:string; 

var fStreamladen,fStreamspeichern:TFileStream; 

begin 

if first=true then begin; 

{showmessage('Dies ist eine Betaversion. Für Fehler oder unrichtige Ergebnisse wird 

keine Garantie übernommen. c)Thomas ACHS');} 

first:=false; 

assignfile(merkfile,'C:\APADIR\PROGRAM\Settings.tom'); 

try 

reset(merkfile); 

readln(merkfile,APAFilename); 

readln(merkfile,st); 


APA_Options.APA_Load_Last_APA.Checked:=true else 

APA_Options.APA_Load_Last_APA.Checked:=false; 



APA_Options.APA_Save_on_termination.Checked:=true else 

APA_Options.APA_Save_on_termination.Checked:=false; 



APA_Options.APA_Remove_redundancy.Checked:=true else 

APA_Options.APA_Remove_redundancy.Checked:=false; 

APA_Grid.Remove_Redundancy.Checked:=APA_Options.APA_Remove_redundancy.Checked; 



APA_Options.APA_Add_max_hier.Checked:=true else 

APA_Options.APA_Add_max_hier.Checked:=false; 

readln(merkfile,st); //Früher Saverandomcosts 


APA_Options.APA_Show_Link_on_Desktop.Checked:=true else 

APA_Options.APA_Show_Link_on_Desktop.Checked:=false; 


APA_Options.APA_Save_Path.Directory:=st; 

if not(eof(merkfile)) then begin 



APA_Options.APA_ShowScreenheuristic.Checked:=true else 

APA_Options.APA_ShowScreenheuristic.Checked:=false; 

end; 

finally 

Closefile(merkfile); 

end; 

if APA_Options.APA_Load_Last_APA.Checked=true then begin 

//Lade 

Lade(APAFilename); 

end else begin; 

Lade('c:\APADIR\Save\Default.APA'); 

end; 

if APA_Options.APA_Show_Link_on_Desktop.Checked=true then begin 

if fileexists(shelldir.Path+'\APAWin.lnk')=false then begin 

try 

- 276 -



fStreamLaden:=TFileStream.Create('c:\APADIR\PROGRAM\APAWin.lnk',fmOpenRead); 

try 

fStreamSpeichern:=TFileStream.Create(shelldir.Path+'\APAWin.lnk',fmCreate); 


finally 


end; 

finally 


end; 


//Löschen 

if fileexists(shelldir.Path+'\APAWin.lnk')=true then begin 

try 

deletefile(shelldir.Path+'\APAWin.lnk'); 

except 

showmessage('Can not remove link from Desktop'); 

end; 

end; 

end; 

end; 

end; 

end; 

procedure TAPA_Application.GeneriereZufallskosten1Click(Sender: TObject); 

var hauptspalte,hauptzeile,aktspalte,aktzeile:longint; 

Maxkosten, maxkosten2,KostenvomBFT, 

KostenvomBFT2, KostenParent,KostenParent2:longint; 

costmerk:longint; 

parentspalte,parentzeile:longint; 

bandbreite:longint; 

begin 

if generiereapaneu=true then begin 


end; 

assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat'); 

{$i-} 

rewrite(fKosten); 

{$i+} 

if ioresult0 then begin; showmessage('cost database error ');exit;end; 

try 

APA_Show_Process.ButtonPause.Visible:=false; 


APA_Application.Enabled:=false; 

bandbreite:=100000; 

stop:=false; 


APA_Show_Process.ausgabe('Build Costs ...'); 

Randomize; 

//Zuerst lösche alle alten Kosten aus der Tabelle 

APA_Show_Process.ausgabe('Clear costs...'); 

//Generiere alle Kanten indem von jedem Würfel die Kanten zu allen seinen Derivaten 

bewertet werden 

//und die Kosten vom BFT zu dem Würfel die max Kosten sind 10000 

if APA_Application.Restrictedcosts1.Checked=true then begin 

//************************************** 

// Erster Lauf 

//************************************** 

//Bewerte alle Kosten aus dem BFT 

- 277 -



for hauptspalte:=0 to anzspalten-1 do begin 

for hauptzeile:=0 to anzzeilen-1 do begin 

if APA[hauptspalte,hauptzeile].farbe=clYellow then begin 

//Suche alle Parents und merke die die geringsten Kosten des Parents 

maxkosten2:=bandbreite; 

maxkosten:=bandbreite; 



if APA[aktspalte,aktzeile].farbe=clYellow then begin 

if 

(APA_Grid.isderivat(aktspalte,aktzeile,hauptspalte,hauptzeile)=true) 

and (not((hauptspalte=aktspalte)and(hauptzeile=aktzeile))) then 

begin 

if findkosten(-1,-1,aktspalte,aktzeile)=true then begin 

if vkosten.Query



If (APA_Grid.isderivat(aktspalte,aktzeile,hauptspalte,hauptzeile)=true)and 

(not((hauptspalte=aktspalte)and(hauptzeile=aktzeile))) 

//Der Parent aggregiert die gleiche Dimension 

then begin 

//Suche Maxkosten vom BFT 

if (findkosten(-1,-1,hauptspalte,hauptzeile)=true) then begin 

maxkosten:=round(vkosten.Build); 

maxkosten2:=round(vKosten.Query); 


maxkosten:=bandbreite; 

maxkosten2:=bandbreite; 

end; 

//Kosten der Materialisierung vom BFT 

costmerk:=round(APA_Grid.getbuild(-1,-1,hauptspalte,hauptzeile)); 

if (costmerk





end;//Ende von nicht Redundant 

end;//Ende Zeile 

end;//Ende Spalte 

end // von total Random costs 

else begin 

for hauptzeile:=0 to anzzeilen-1 do begin 

for hauptspalte:=0 to anzspalten-1 do begin 

if APA[hauptspalte,hauptzeile].farbe=clYellow then begin 

{1.Generiere Kosten von BFT} 

KostenvomBFT:=1+random(bandbreite-1);//Materialisierungskosten 

KostenvomBFT2:=1+random(KostenvomBFT-1);//Abfragekosten 

APA_Show_Process.ausgabe('Build BFT('+inttostr(hauptspalte)+ 

':'+inttostr(hauptzeile)+'): 

'+inttostr(KostenvomBFT2)+'/'+inttostr(KostenvomBFT)); 

//Eintragen der Kosten vom BFT 

seek(fKosten,filesize(fKosten)); 

vKosten.VonSpalte:=-1; 

vKosten.VonZeile:=-1; 

vKosten.ZuSpalte:=hauptspalte; 

vKosten.ZUZeile:=hauptzeile; 

vKosten.Query:=KostenvomBFT2; 

vKosten.Build:=KostenvomBFT; 

write(fKosten,vKosten);Kostensortieren; 

{2.Generiere Kosten aller Derivate} 



if (APA[aktspalte,aktzeile].farbe=clYellow) then begin 

if (APA_Grid.isderivat(hauptspalte,hauptzeile,aktspalte,aktzeile)) then begin 

//Eintragen der Kosten 

KostenvomBFT:=1+random(bandbreite-1);//Materialisierungskosten 

KostenvomBFT2:=1+random(KostenvomBFT-1);//Abfragekosten 

APA_Show_Process.ausgabe('Build from ('+inttostr(hauptspalte)+':'+ 

inttostr(hauptzeile)+') to ('+inttostr(aktspalte)+':'+ 

inttostr(aktzeile)+'): 

'+inttostr(KostenvomBFT2)+'/'+inttostr(KostenvomBFT)); 

//Eintragen der Kosten vom BFT 

seek(fKosten,filesize(fKosten)); 

vKosten.VonSpalte:=hauptspalte; 

vKosten.VonZeile:=hauptzeile; 

vKosten.ZuSpalte:=aktspalte; 

vKosten.ZUZeile:=aktzeile; 

vKosten.Query:=KostenvomBFT2; 

vKosten.Build:=KostenvomBFT; 

write(fKosten,vKosten); Kostensortieren; 

end;//isderivat 

end;//not redundant 



end;//not redundant 

end;//hauptspalte 

end;//hauptzeile 

end; 

finally 



end; 


APA_Showcosts.showmodal; 

mustsave:=true; 

- 280 -


end; 


APA_Show_Process.ausgabe(''); 

APA_Show_Process.ausgabe('READY'); 

APA_Show_Process.ausgabe(''); 

procedure TAPA_Application.ShowRandomCosts1Click(Sender: TObject); 

begin 

APA_Showcosts.showmodal; 

end; 

procedure TAPA_Application.Save1Click(Sender: TObject); 

begin 

if uppercase(APAFilename)=uppercase('C:\APADIR\SAVE\Default.apa') then 

Saveas1Click(self) else 


end; 

procedure TAPA_Application.FormCloseQuery(Sender: TObject; 

var CanClose: Boolean); 

var merkfile:TextFile; 

begin 

if APA_Options.APA_Save_on_termination.Checked=true then begin 

if mustsave=true then Speichern(Apafilename); 

end; 

if mustsave=true then begin 

APA_Dialog.APA_Text.Caption:='You did not save your APA. Do you want to save?'; 

end; 


Save1Click(self); 

end; 

assignfile(merkfile,'C:\APADIR\PROGRAM\Settings.tom'); 

try 

rewrite(merkfile); 

writeln(merkfile,APAFilename); 

if APA_Options.APA_Load_Last_APA.Checked=true then 

writeln(merkfile,'True') else 

writeln(merkfile,'False'); 

if APA_Options.APA_Save_on_termination.Checked=true then 



if APA_Options.APA_Remove_redundancy.Checked=true then 



if APA_Options.APA_Add_max_hier.Checked=true then 



if APA_Options.APA_Show_Link_on_Desktop.Checked=true then 

writeln(merkfile,'True') 

else 


writeln(merkfile,APA_Options.APA_Save_Path.Directory); 

if APA_Options.APA_ShowScreenheuristic.Checked=true then 



finally 

Closefile(merkfile); 

end; 

end; 

- 281 -



procedure TAPA_Application.Restrictedcosts1Click(Sender: TObject); 

begin 

APA_Grid.Restrictedcosts1.Checked:=APA_Application.Restrictedcosts1.Checked; 

end; 

procedure TAPA_Application.AnalyseAPA1Click(Sender: TObject); 

begin 



end; 

APA_Analyse.show; 

end; 

procedure TAPA_Application.HelpfilesAPAprogram1Click(Sender: TObject); 

begin 

APA_Help.show; 

APA_Help.APABrowser.Navigate('C:\APADIR\Help\index.htm'); 

end; 

procedure TAPA_Application.HelpfilesforMainmenu1Click(Sender: TObject); 

begin 


APA_Help.APABrowser.Navigate('C:\APADIR\Help\APA_Mainmenu.htm'); 

end; 

procedure TAPA_Application.FormCreate(Sender: TObject); 

begin 

CurrencyString:=''; 

ShortDateFormat:='dd.mm.yyyy'; 

LongDateFormat:='dd.mm.yyyy'; 

DateSeparator := '.'; 

ThousandSeparator:='.'; 

DecimalSeparator:=','; 

CurrencyDecimals:=2; 

ShortTimeFormat:='hh:nn'; 

LongTimeFormat:='hh:nn'; 

end; 

end. 

12.1.6 UNIT APA_DIALOGUNIT.DFM 

object APA_Screen: TAPA_Screen 

Left = 220 

Top = 114 

Width = 696 

Height = 480 

Caption = 'APA_Screen' 











12.1.7 ENDUNIT APA_DIALOGUNIT.PAS 

unit APA_Dialogunit; 

interface 

uses 

- 282 -




Dialogs, StdCtrls, Buttons, ExtCtrls; 

type 

TAPA_Dialog = class(TForm) 

APA_Text: TLabel; 


BitBtn1: TBitBtn; 

BitBtn2: TBitBtn; 

procedure Button1Click(Sender: TObject); 


procedure BitBtn1Click(Sender: TObject); 

procedure BitBtn2Click(Sender: TObject); 

private 


public 


end; 

var 

APA_Dialog: TAPA_Dialog; 


{$R *.dfm} 

procedure TAPA_Dialog.Button1Click(Sender: TObject); 

begin 

Close; 

end; 

procedure TAPA_Dialog.Button2Click(Sender: TObject); 

begin 

Close; 

end; 

procedure TAPA_Dialog.BitBtn1Click(Sender: TObject); 

begin 

Modalresult:=mrYes; 

end; 

procedure TAPA_Dialog.BitBtn2Click(Sender: TObject); 

begin 

Modalresult:=mrNo; 

end; 

end. 

12.1.8 UNIT APA_GRIDUNIT.DFM 

object APA_Grid: TAPA_Grid 

Left = 12 

Top = 147 

Width = 909 

Height = 541 

Caption = 'APA Grid' 







Menu = APAGridMenu 






object APAGrid: TDrawGrid 

Left = 1 

- 283 -



Top = 65 

Width = 900 

Height = 381 


ColCount = 1 

DefaultDrawing = False 

FixedCols = 0 

RowCount = 1 

FixedRows = 0 

Options = [] 

PopupMenu = Gridpopup 

TabOrder = 0 

OnClick = APAGridClick 

OnDblClick = APAGridDblClick 

OnDrawCell = APAGridDrawCell 

OnMouseDown = APAGridMouseDown 

OnMouseMove = APAGridMouseMove 

OnMouseWheelDown = APAGridMouseWheelUp 

OnMouseWheelUp = APAGridMouseWheelUp 

end 


Left = 0 

Top = 0 

Width = 901 

Height = 41 

Align = alTop 

TabOrder = 1 

OnDblClick = Panel1DblClick 

object Button_remove_materialized_cubes: TButton 

Left = 8 

Top = 8 

Width = 151 

Height = 25 

Caption = 'Remove materialized cubes' 

TabOrder = 0 

OnClick = Button_remove_materialized_cubesClick 

end 

object Button_remove_derivatives: TButton 

Left = 168 

Top = 8 

Width = 151 

Height = 25 

Caption = 'Remove derivatives' 

TabOrder = 1 

OnClick = Button_remove_derivativesClick 

end 

object Button_remove_required_cubes: TButton 

Left = 328 

Top = 8 

Width = 151 

Height = 25 

Caption = 'Remove required cubes' 

TabOrder = 2 

OnClick = Button_remove_required_cubesClick 

end 

object Remove_Redundancy: TCheckBox 

Left = 488 

Top = 8 

Width = 145 

Height = 23 

Caption = 'Remove redundancy' 

TabOrder = 3 

OnClick = Remove_RedundancyClick 

end 

object Button1: TButton 

Left = 616 

Top = 8 

Width = 41 

Height = 25 

Caption = 'Prosser' 

TabOrder = 4 

Visible = False 

OnClick = Button1Click 

end 

- 284 -




Left = 664 

Top = 8 

Width = 33 

Height = 25 

Caption = 'Tom' 

TabOrder = 5 



end 


Left = 704 

Top = 8 

Width = 49 

Height = 25 

Caption = 'Richtig' 

TabOrder = 6 



end 


Left = 760 

Top = 8 

Width = 49 

Height = 25 

Caption = 'Richtig2' 

TabOrder = 7 



end 

end 


Left = 0 

Top = 446 

Width = 901 

Height = 41 


TabOrder = 2 

object Button_to_Input_Screen: TButton 

Left = 16 

Top = 8 

Width = 152 

Height = 25 

Caption = 'Back to Input Screen' 

ModalResult = 3 

TabOrder = 0 

OnClick = Button_to_Input_ScreenClick 

end 

object Button_to_Selection_Screen: TButton 

Left = 176 

Top = 8 

Width = 152 

Height = 25 



TabOrder = 1 

OnClick = Button_to_Selection_ScreenClick 

end 

object Button_to_Main_Menu: TButton 

Left = 336 

Top = 8 

Width = 152 

Height = 25 

Caption = 'Back to Main Menu' 

TabOrder = 2 

OnClick = Button_to_Main_MenuClick 

end 

end 

object StatusBar: TStatusBar 

Left = 0 

Top = 41 

Width = 901 

Height = 24 

Align = alTop 

- 285 -



Panels = 

end 


Left = 0 

Top = 65 

Width = 1 

Height = 381 

Align = alLeft 

Caption = 'Panel3' 

TabOrder = 4 

object ListBox1: TListBox 

Left = 1 

Top = 42 

Width = 998 

Height = 338 


ItemHeight = 13 

TabOrder = 0 


OnDblClick = ListBox1DblClick 

end 


Left = 1 

Top = 1 

Width = 998 

Height = 41 

Align = alTop 

TabOrder = 1 


Left = 14 

Top = 8 

Width = 75 

Height = 25 

Caption = 'Close Window' 

TabOrder = 0 


end 

end 

end 

object Gridpopup: TPopupMenu 

OnPopup = GridpopupPopup 

Left = 248 

Top = 224 

object NoCubeselected1: TMenuItem 

Caption = 'No cube selected' 

end 

object Redundantcube1: TMenuItem 

Caption = 'This is a redundant cube' 


end 

object N3: TMenuItem 

Caption = '-' 

end 

object Required1: TMenuItem 

Caption = 'Required' 

object Item1: TMenuItem 

OnClick = Item1Click 

end 


Tag = 1 


end 


Tag = 2 


end 


Tag = 3 


end 


Tag = 4 


end 

- 286 -




Tag = 5 


end 


Tag = 6 


end 


Tag = 7 


end 


Tag = 8 


end 


Tag = 10 


end 


Tag = 10 


end 


Tag = 11 


end 


Tag = 12 


end 


Tag = 13 


end 


Tag = 14 


end 

end 

object Notrequired1: TMenuItem 

Caption = 'Not required' 

GroupIndex = 1 

OnClick = Notrequired1Click 

end 

object Materialize1: TMenuItem 

Caption = 'Materialize' 


OnClick = Materialize1Click 

end 

object Dematerialize1: TMenuItem 

Caption = 'Dematerialize' 


OnClick = Dematerialize1Click 

end 


Caption = '-' 


end 

object Showderivatives1: TMenuItem 

Caption = 'Show derivatives' 


OnClick = Showderivatives1Click 

end 

object ShowRedundancyfreecube1: TMenuItem 

Caption = 'Show redundancy free cube' 


OnClick = ShowRedundancyfreecube1Click 

end 

object Showpossiblecubes1: TMenuItem 

Caption = 'Show possible cubes' 


OnClick = Showpossiblecubes1Click 

- 287 -



end 

object Removepossiblecubes1: TMenuItem 

Caption = 'Remove possible cubes' 



OnClick = Removepossiblecubes1Click 

end 

object Showdeterministicsolution1: TMenuItem 

Caption = 'Show deterministic solution' 


OnClick = Showdeterministicsolution1Click 

end 

object Removedeterministicsolution1: TMenuItem 

Caption = 'Remove deterministic solution' 


OnClick = Removedeterministicsolution1Click 

end 


Caption = '-' 


end 

object Heuristics2: TMenuItem 

Caption = 'Heuristics' 


object SearchusingThomasAchsheuristic2: TMenuItem 

Caption = 'Search using Thomas Achs heuristic' 

OnClick = SearchusingThomasAchsheuristic2Click 

end 

object Alogrithm1: TMenuItem 

Caption = 'Alogrithm permutation' 

OnClick = Alogrithm1Click 

end 

object AlgorithmKombination2: TMenuItem 

Caption = 'Algorithm combination' 

OnClick = AlgorithmKombination2Click 

end 

end 

object BuildCubesinDatabase2: TMenuItem 

Caption = 'Build cubes in database for star schema' 


object GenerateCREATESQLStatements1: TMenuItem 

Caption = 'Generate CREATE SQL-statements BFT and dimension tables' 

OnClick = GenerateCREATESQLStatements1Click 

end 

end 

object Buildcubesindatabaseforfactconstellationschema1: TMenuItem 

Caption = 'Build cubes in database for fact constellation schema' 


object GenerateCREATESQLStatementsBFTanddimensiontables1: TMenuItem 


OnClick = GenerateCREATESQLStatementsBFTanddimensiontables1Click 

end 

object GenerateCREATESQLStatementsformaterializedcubes1: TMenuItem 

Caption = 'Generate CREATE SQL-statements for materialized cubes' 

OnClick = GenerateCREATESQLStatementsformaterializedcubes1Click 

end 

end 

object GetSQLStatementtomaterializethisview1: TMenuItem 

Caption = 'Get SQL statement to query this cube' 


object starschema1: TMenuItem 

Caption = 'star schema' 

OnClick = starschema1Click 

end 

object factconstellationschema1: TMenuItem 

Caption = 'fact constellation schema' 

OnClick = factconstellationschema1Click 

end 

end 


Caption = '-' 


end 

object ShowAnalysewindow2: TMenuItem 

- 288 -



Caption = 'Show APA analyse window' 


OnClick = ShowAnalysewindow2Click 

end 

object Showlistbox1: TMenuItem 

Caption = 'Show protocoll window' 


OnClick = Showlistbox1Click 

end 


Caption = '-' 


end 

object Showcosts1: TMenuItem 

Caption = 'Show set random costs and limits left' 


OnClick = Showcosts1Click 

end 

object ShowSetcalculatedcostsandlimitsleft1: TMenuItem 

Caption = 'Show set calculated costs and limits left' 


OnClick = ShowSetcalculatedcostsandlimitsleft1Click 

end 


Caption = '-' 


end 

object Getrandomcosts1: TMenuItem 

Caption = 'Get random costs' 


object GetbuildBFT2: TMenuItem 

Caption = 'Get build from BFT' 


OnClick = GetbuildBFT2Click 

end 

object GetbuildParent2: TMenuItem 

Caption = 'Get build from Parent' 


OnClick = GetbuildParent2Click 

end 


Caption = '-' 


end 

object GetQueryBFT2: TMenuItem 

Caption = 'Get query from BFT' 


OnClick = GetQueryBFT2Click 

end 

object GetQueryParent2: TMenuItem 

Caption = 'Get Query from Parent' 


OnClick = GetQueryParent2Click 

end 

end 

object Getcalculatedcosts1: TMenuItem 

Caption = 'Get calculated costs' 


object GetbuildBFT1: TMenuItem 

Caption = 'Get build from BFT' 

OnClick = GetbuildBFT1Click 

end 

object Getbuildfromparent1: TMenuItem 

Caption = 'Get build from parent' 

OnClick = Getbuildfromparent1Click 

end 


Caption = '-' 

end 

object GetqueryfromBFT1: TMenuItem 

Caption = 'Get query from BFT' 

OnClick = GetqueryfromBFT1Click 

end 

object Getqueryfromparent1: TMenuItem 

- 289 -



Caption = 'Get query from parent' 

OnClick = Getqueryfromparent1Click 

end 

end 

object Getmaterialisationspaceofcube1: TMenuItem 

Caption = 'Get materialisation space of cube' 


OnClick = Getmaterialisationspaceofcube1Click 

end 

object ShowData1: TMenuItem 

Caption = 'Show data of cube' 


OnClick = ShowData1Click 

end 

end 

object langbezpopup: TPopupMenu 

Left = 104 

Top = 272 

object langbez1: TMenuItem 

Caption = 'langbez' 

end 

end 

object privatmenu: TPopupMenu 

Left = 760 

Top = 144 

object ShowButtons1: TMenuItem 

Caption = 'Show Buttons' 

OnClick = ShowButtons1Click 

end 

object ProssernurersterLauf1: TMenuItem 


Caption = 'Prosser nur erster Lauf' 


end 

object Minusnehmen1: TMenuItem 


Caption = 'Minus nehmen' 


end 

object tomohnederivate1: TMenuItem 


Caption = 'Tom ohne derivate' 

end 

object RechneThomas1: TMenuItem 


Caption = 'Rechne Thomas' 


end 

object ClearDatabase1: TMenuItem 

Caption = 'Clear Database' 

end 

object Alwaysspacemaxbeachten1: TMenuItem 


Caption = 'Alwaysspacemax beachten' 


end 

end 

object APAGridMenu: TMainMenu 

Left = 376 

Top = 184 

object Actions1: TMenuItem 

Caption = 'Actions' 

object Removematerializedcubes1: TMenuItem 

Caption = 'Remove materialized cubes' 

OnClick = Removematerializedcubes1Click 

end 

object Removederivatives1: TMenuItem 

Caption = 'Remove derivatives' 

OnClick = Removederivatives1Click 

end 

object Removerequiredcubes1: TMenuItem 

Caption = 'Remove required cubes' 

OnClick = Removerequiredcubes1Click 

end 

- 290 -



end 

object Heuristics1: TMenuItem 

Caption = 'Heuristics && Algorithms' 

object SearchusingProsserheuristic1: TMenuItem 

Caption = 'Search using Prosser heuristic' 


end 

object SearchusingThomasAchsheuristic1: TMenuItem 

Caption = 'Search using Thomas Achs heuristic' 

OnClick = SearchusingThomasAchsheuristic1Click 

end 

object Algorithm1: TMenuItem 

Caption = 'Algorithm permutation' 

OnClick = Algorithm1Click 

end 

object AlgorithmKombination1: TMenuItem 

Caption = 'Algorithm combination' 

OnClick = AlgorithmKombination1Click 

end 


Caption = '-' 

end 

object AnalyseAPA1: TMenuItem 

Caption = 'Show APA analyse window' 

OnClick = AnalyseAPA1Click 

end 

object ShowAnalyseWindow1: TMenuItem 

Caption = 'Show protocoll window' 

OnClick = ShowAnalyseWindow1Click 

end 

object Showcosts2: TMenuItem 

Caption = 'Show Set costs and limits left' 

OnClick = Showcosts2Click 

end 

object Showsetcalculatedcostsandlimitsleft2: TMenuItem 

Caption = 'Show set calculated costs and limits left' 

end 


Caption = '-' 

end 

object Showpossiblecubes2: TMenuItem 

Caption = 'Show possible cubes' 

OnClick = Showpossiblecubes2Click 

end 

object Removepossiblecubes2: TMenuItem 

Caption = 'Remove possible cubes' 


OnClick = Removepossiblecubes2Click 

end 

object Showdeterministicsolution2: TMenuItem 

Caption = 'Show deterministic solution' 

OnClick = Showdeterministicsolution2Click 

end 

object Removedeterministicsolution2: TMenuItem 

Caption = 'Remove deterministic solution' 


OnClick = Removedeterministicsolution2Click 

end 

end 

object BuildCubesinDatabase1: TMenuItem 

Caption = 'Build Cubes in Database' 

object GenerateCREATESQLStatementsforStarSchema1: TMenuItem 

Caption = 'Generate CREATE SQL-statements for star schema' 




end 

end 

object GenerateCREATESQLStatementsforfactconstellationschema1: TMenuItem 

Caption = 'Generate CREATE SQL-statements for fact constellation schema' 




end 

- 291 -



object GenerateCREATESQLStatementsformaterializedcubes2: TMenuItem 

Caption = 'Generate CREATE SQL-statements for materialized cubes' 

OnClick = GenerateCREATESQLStatementsformaterializedcubes2Click 

end 

end 

end 

object Randomcosts1: TMenuItem 

Caption = 'Random costs' 

object Buildrandomcosts1: TMenuItem 

Caption = 'Build random costs' 

OnClick = Buildrandomcosts1Click 

end 

object Showrandomcosts1: TMenuItem 

Caption = 'Show random costs' 

OnClick = Showrandomcosts1Click 

end 

object Restrictedcosts1: TMenuItem 


Caption = 'Restricted costs' 


OnClick = Restrictedcosts1Click 

end 

end 

object Settings1: TMenuItem 

Caption = 'Settings' 

object Userandomcosts1: TMenuItem 


Caption = 'Use random costs' 


end 

object Removeredundancy1: TMenuItem 

Caption = 'Remove redundancy' 

OnClick = Removeredundancy1Click 

end 


Caption = '-' 

end 

object Parameter1: TMenuItem 

Caption = 'Parameters' 

OnClick = Parameter1Click 

end 

object Options1: TMenuItem 

Caption = 'Options' 

OnClick = Options1Click 

end 

end 

object Help1: TMenuItem 

Caption = 'Help' 

object HelpforAPAGridScreen1: TMenuItem 

Caption = 'Help for APA Grid Screen' 

OnClick = HelpforAPAGridScreen1Click 

end 

object HelpforAPAProgram1: TMenuItem 

Caption = 'Help for APA Program' 

OnClick = HelpforAPAProgram1Click 

end 

end 

end 

end 

12.1.9 UNIT APA_GRIDUNIT.PAS 

unit APA_Gridunit; 

interface 

uses 


Dialogs, ComCtrls, Menus, StdCtrls, ExtCtrls, Grids, Math; 

type 

TAPA_Grid = class(TForm) 

- 292 -



APAGrid: TDrawGrid; 


Button_remove_materialized_cubes: TButton; 

Button_remove_derivatives: TButton; 

Button_remove_required_cubes: TButton; 

Remove_Redundancy: TCheckBox; 

Button1: TButton; 



Button_to_Input_Screen: TButton; 

Button_to_Selection_Screen: TButton; 

Button_to_Main_Menu: TButton; 

Gridpopup: TPopupMenu; 

Redundantcube1: TMenuItem; 

N3: TMenuItem; 

Required1: TMenuItem; 

Item1: TMenuItem; 



Notrequired1: TMenuItem; 

Materialize1: TMenuItem; 

Dematerialize1: TMenuItem; 


Showderivatives1: TMenuItem; 

ShowRedundancyfreecube1: TMenuItem; 

Showlistbox1: TMenuItem; 

langbezpopup: TPopupMenu; 

langbez1: TMenuItem; 

privatmenu: TPopupMenu; 

ProssernurersterLauf1: TMenuItem; 

StatusBar: TStatusBar; 

Minusnehmen1: TMenuItem; 













APAGridMenu: TMainMenu; 

Actions1: TMenuItem; 

Settings1: TMenuItem; 

Removematerializedcubes1: TMenuItem; 

Removederivatives1: TMenuItem; 

Removerequiredcubes1: TMenuItem; 

Userandomcosts1: TMenuItem; 

Removeredundancy1: TMenuItem; 

BuildCubesinDatabase1: TMenuItem; 

Heuristics1: TMenuItem; 

SearchusingProsserheuristic1: TMenuItem; 

SearchusingThomasAchsheuristic1: TMenuItem; 

tomohnederivate1: TMenuItem; 


RechneThomas1: TMenuItem; 

Algorithm1: TMenuItem; 

Heuristics2: TMenuItem; 

SearchusingThomasAchsheuristic2: TMenuItem; 

Alogrithm1: TMenuItem; 


BuildCubesinDatabase2: TMenuItem; 

GenerateCREATESQLStatements1: TMenuItem; 

NoCubeselected1: TMenuItem; 


Parameter1: TMenuItem; 

Showcosts1: TMenuItem; 


Options1: TMenuItem; 


ShowData1: TMenuItem; 

- 293 -




ListBox1: TListBox; 



AlgorithmKombination1: TMenuItem; 

AlgorithmKombination2: TMenuItem; 

Getrandomcosts1: TMenuItem; 

GetbuildBFT2: TMenuItem; 

GetbuildParent2: TMenuItem; 


GetQueryBFT2: TMenuItem; 

GetQueryParent2: TMenuItem; 

ClearDatabase1: TMenuItem; 

Randomcosts1: TMenuItem; 

Buildrandomcosts1: TMenuItem; 

Showrandomcosts1: TMenuItem; 


Showcosts2: TMenuItem; 


ShowAnalyseWindow1: TMenuItem; 

AnalyseAPA1: TMenuItem; 

ShowAnalysewindow2: TMenuItem; 

Showpossiblecubes1: TMenuItem; 

Removepossiblecubes1: TMenuItem; 

Showpossiblecubes2: TMenuItem; 

Removepossiblecubes2: TMenuItem; 

Getmaterialisationspaceofcube1: TMenuItem; 

ShowButtons1: TMenuItem; 

GetSQLStatementtomaterializethisview1: TMenuItem; 

Getcalculatedcosts1: TMenuItem; 

GetbuildBFT1: TMenuItem; 

Getbuildfromparent1: TMenuItem; 


GetqueryfromBFT1: TMenuItem; 

Getqueryfromparent1: TMenuItem; 

ShowSetcalculatedcostsandlimitsleft1: TMenuItem; 

Showsetcalculatedcostsandlimitsleft2: TMenuItem; 


Restrictedcosts1: TMenuItem; 

Showdeterministicsolution1: TMenuItem; 

Removedeterministicsolution1: TMenuItem; 

Showdeterministicsolution2: TMenuItem; 

Removedeterministicsolution2: TMenuItem; 

Buildcubesindatabaseforfactconstellationschema1: TMenuItem; 

GenerateCREATESQLStatementsformaterializedcubes1: TMenuItem; 

GenerateCREATESQLStatementsBFTanddimensiontables1: TMenuItem; 

GenerateCREATESQLStatementsforStarSchema1: TMenuItem; 

GenerateCREATESQLStatementsforfactconstellationschema1: TMenuItem; 

GenerateCREATESQLStatementsformaterializedcubes2: TMenuItem; 



Alwaysspacemaxbeachten1: TMenuItem; 

Help1: TMenuItem; 

HelpforAPAGridScreen1: TMenuItem; 


HelpforAPAProgram1: TMenuItem; 

starschema1: TMenuItem; 

factconstellationschema1: TMenuItem; 

procedure generate(); 

procedure Erzeugungsbericht1Click(Sender: TObject); 

procedure APAGridDrawCell(Sender: TObject; ACol, ARow: Integer; 

Rect: TRect; State: TGridDrawState); 

procedure APAGridMouseMove(Sender: TObject; Shift: TShiftState; X, 

Y: Integer); 

procedure Showlistbox1Click(Sender: TObject); 

procedure Materialize1Click(Sender: TObject); 

procedure Notrequired1Click(Sender: TObject); 

procedure Dematerialize1Click(Sender: TObject); 

procedure Showderivatives1Click(Sender: TObject); 

procedure APAGridDblClick(Sender: TObject); 

procedure APAGridMouseDown(Sender: TObject; Button: TMouseButton; 

Shift: TShiftState; X, Y: Integer); 

procedure Button_to_Input_ScreenClick(Sender: TObject); 

procedure Button_to_Selection_ScreenClick(Sender: TObject); 

- 294 -



procedure Button_to_Main_MenuClick(Sender: TObject); 

procedure Remove_RedundancyClick(Sender: TObject); 

procedure ShowRedundancyfreecube1Click(Sender: TObject); 

procedure Button_remove_required_cubesClick(Sender: TObject); 

procedure Button_remove_derivativesClick(Sender: TObject); 

procedure Button_remove_materialized_cubesClick(Sender: TObject); 

procedure ListBox1DblClick(Sender: TObject); 


procedure bezeichnungenholen(); 

procedure materialzeichnen; 

function getbuild(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended; 

function getquery(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended; 

function auffuellen(st:string;anzahl:longint):string; 

function gettupel(aktspalte,aktzeile:longint):Extended; 

function 

getgrouptupel(parentspalte,parentzeile,aktspalte,aktzeile:longint):Extended; 

function deltaBftW(aktspalte,aktzeile:longint;Query:boolean):Extended; 

function deltaVW(spalte,zeile,aktspalte,aktzeile:longint;query:boolean):Extended; 

function GetMinDerivatOfSpalte(aktspalte,aktzeile:longint;Query:boolean):longint; 

function GetMinDerivatOfZeile(aktspalte,aktzeile:longint;Query:boolean):longint; 

procedure berechneProsser(); 


function isderivat(spaltev,zeilev,spaltew,zeilew:longint):boolean; 

procedure Item1Click(Sender: TObject); 


procedure APAGridClick(Sender: TObject); 

procedure GridpopupPopup(Sender: TObject); 

procedure Removematerializedcubes1Click(Sender: TObject); 

procedure Removederivatives1Click(Sender: TObject); 

procedure Removerequiredcubes1Click(Sender: TObject); 

procedure Removeredundancy1Click(Sender: TObject); 


procedure Algorithm1Click(Sender: TObject); 

procedure SearchusingThomasAchsheuristic2Click(Sender: TObject); 

procedure Alogrithm1Click(Sender: TObject); 

procedure Parameter1Click(Sender: TObject); 

function 

berechneKostenGesamt(MatCubes,ReqCubes:TStringList;Nullstellen:boolean):Extended; 

procedure Showcosts1Click(Sender: TObject); 

function GetRightOrdertom(Listecubes:TStringList):TStringList; 


procedure Options1Click(Sender: TObject); 

procedure ShowData1Click(Sender: TObject); 


procedure AlgorithmKombination1Click(Sender: TObject); 

procedure AlgorithmKombination2Click(Sender: TObject); 

procedure GetbuildBFT2Click(Sender: TObject); 

procedure GetbuildParent2Click(Sender: TObject); 

procedure GetQueryBFT2Click(Sender: TObject); 

procedure GetQueryParent2Click(Sender: TObject); 

procedure GenerateCREATESQLStatements1Click(Sender: TObject); 

procedure SearchusingThomasAchsheuristic1Click(Sender: TObject); 

procedure Panel1DblClick(Sender: TObject); 

procedure Buildrandomcosts1Click(Sender: TObject); 

procedure Showrandomcosts1Click(Sender: TObject); 

procedure Showcosts2Click(Sender: TObject); 

procedure ShowAnalyseWindow1Click(Sender: TObject); 

procedure AnalyseAPA1Click(Sender: TObject); 

procedure ShowAnalysewindow2Click(Sender: TObject); 

procedure Showpossiblecubes1Click(Sender: TObject); 

procedure Removepossiblecubes1Click(Sender: TObject); 

procedure Showpossiblecubes2Click(Sender: TObject); 

procedure Removepossiblecubes2Click(Sender: TObject); 

procedure Getmaterialisationspaceofcube1Click(Sender: TObject); 

procedure ShowButtons1Click(Sender: TObject); 

procedure GetbuildBFT1Click(Sender: TObject); 

procedure GetqueryfromBFT1Click(Sender: TObject); 

procedure Getbuildfromparent1Click(Sender: TObject); 

procedure Getqueryfromparent1Click(Sender: TObject); 

procedure ShowSetcalculatedcostsandlimitsleft1Click(Sender: TObject); 

procedure Restrictedcosts1Click(Sender: TObject); 

procedure Showdeterministicsolution2Click(Sender: TObject); 

procedure Showdeterministicsolution1Click(Sender: TObject); 

procedure Removedeterministicsolution1Click(Sender: TObject); 

- 295 -



procedure Removedeterministicsolution2Click(Sender: TObject); 

procedure GenerateCREATESQLStatementsBFTanddimensiontables3Click( 

Sender: TObject); 

procedure GenerateCREATESQLStatementsformaterializedcubes2Click( 






procedure GenerateCREATESQLStatementsformaterializedcubes1Click( 


procedure APAGridMouseWheelUp(Sender: TObject; Shift: TShiftState; 

MousePos: TPoint; var Handled: Boolean); 

procedure HelpforAPAGridScreen1Click(Sender: TObject); 

procedure HelpforAPAProgram1Click(Sender: TObject); 

procedure factconstellationschema1Click(Sender: TObject); 

procedure starschema1Click(Sender: TObject); 

private 


public 


end; 

type 

TAPAField = record 

linieoben:boolean; 

linieunten:boolean; 

linierechts:boolean; 

linielinks:boolean; 

dickoben:boolean; 

dickunten:boolean; 

dickrechts:boolean; 

dicklinks:boolean; 

farbe:TColor; 

interessant:boolean; 

materalisieren:boolean; 

matcount:longint;//Gibt die Reihenfolge der Materialisierung an 

derivative:boolean; 

langbez:array of String; 

kurzbez:String; 

screenbez:String; 

counthier:longint;//Gibt die neue Hierarchiestufe an 

countdimension:longint;//Gibt die Dimension an, welche erhöht wird 



gewicht:Extended; 

gewichtlevel:longint; 

value:Extended;//Gibt den Speicherwert an 

value2:Extended;//Gibt den zweiten Speicherwert an 

hierstufe:array of longint; //Gibt die aktuelle Hierarchiestufe jeder Dimension an 

flag:Extended; 

end; 

var 

APA_Grid: TAPA_Grid; 

APA: array of array of TAPAField; 

{Das Gitter} 

dk: array of array of String; 

{Alle Kurzbezeichungen der Dimension x und der Hierarchie y} 

dl: array of array of String; 

{Alle Langbezeichnungen der Dimension x und der Hierarchie y} 

countdaten: array of array of longint; 

{Die Anzahl der Datensätze der Dimension x und der Hierarchie y} 

anzd:longint; 

{Anzahl der Dimensionen} 

anzh: array of longint; 

{Anzahl der Hierarchiestufen der Dimension x} 

- 296 -



dimbez: array of String; 

{Bezeichnung der Dimension x} 

zellezeile:longint; 

{Wert für die aktuelle Spalte im Gitter} 

zellespalte:longint; 

{Wert für die aktuelle Zeile im Gitter} 

anzzeilen:longint; 

{Anzahl Zeilen des APA gesamt} 

anzspalten:longint; 

{Anzahl der Spalten des APA gesamt} 

maxh:longint; 

{Maximale Anzahl der Hierarchiestufen einer Dimension} 

{Gibt die Aktuellen Bildschirmkoordinaten der Mouse an} 

aktx:longint; 

akty:longint; 

{Gibt die Zelle an, welche zuletzt angeklickt wurde} 

klickspalte:longint= -1; 

klickzeile:longint= -1; 

gotoSelection:boolean=false; 

gotoInput:boolean=false; 

{Gibt an, ob die Bezeichnungen ok sind} 

bezeichnungenkontrolliert:boolean; 

matcount:longint=0;//Gibt den aktuellen Materialisierungszähler an 

permutation:boolean=true; 


uses APA_Selectionunit, APA_Parameterunit, APA_Input_Screenunit, 

APA_Applicationunit, APA_Processunit, APA_Sqlunit, APA_Keyunit, 

APA_Dialogunit, APA_Optionsunit, APA_Show_costsunit, APA_Helpunit; 

{$R *.dfm} 

type Memorycubestype= 

record 

nr:longint; 



end; 

var Memorywuerfel: TStringList; //Die Liste der ausgewählten Würfel// 

MerkeListe:array of longint; 

spaceleft, spaceleftfirstcubes,timeleft:Extended; 

Memorycubes,MemoryReqCubes:array of Memorycubestype; 

MemoryReqCubescount:longint; 

function TAPA_Grid.isderivat(spaltev,zeilev,spaltew,zeilew:longint):boolean; 

var counter:longint; 

derivat:boolean; 

begin; 

//Überprüfe, ob w ein Derivat von v ist: 

//Wenn alle Dimensionen von v eine Hierarchiestufe gleich oder höher 

//als w haben > dann ist es ein Derivat. 

derivat:=false; 

try 

//Standardmäßig ist es ein Derivat 

derivat:=true; 

for counter:=0 to anzd-1 do begin 

//Sollte eine Dimension von w eine geringere Hierachie 

//als v haben, kann w nicht aus v errechnet werden 

- 297 -



if APA[spaltew,zeilew].hierstufe[counter]



if Eingabe.Items.GetFirstNodenil then begin 

{Wenn überhaupt etwas eingetragen ist dann ...} 

dimcounter:=0; 

CurItem := Eingabe.Items.GetFirstNode; 

while (CurItem nil)and(abort=false) do 

begin 

anzh[dimcounter]:=CurItem.Count; 

dimbez[dimcounter]:=CurItem.Text; 

APA_Grid.ListBox1.Items.Add('****************************'); 

APA_Grid.ListBox1.Items.Add('Die Dimension '+dimbez[dimcounter]+' 

'+inttostr(dimcounter)+' hat '+inttostr(anzh[dimcounter])+' Hierarchiestufen'); 

APA_Grid.ListBox1.Items.Add('Anzahl der Kurzbezeichnungen dieser Dimension festlegen 

mit '+inttostr(anzh[dimcounter])); 

{Anzahl der Kurzbezeichnungen dieser Dimension festlegen} 

setlength(dk[dimcounter],anzh[dimcounter]); 

APA_Grid.ListBox1.Items.Add('Anzahl der Langbezeichnungen dieser Dimension festlegen 

mit '+inttostr(anzh[dimcounter])); 

{Anzahl der Langbezeichnungen dieser Dimension festlegen} 

setlength(dl[dimcounter],anzh[dimcounter]); 

APA_Grid.ListBox1.Items.Add('Anzahl der Countdaten dieser Dimension festlegen mit 

'+inttostr(anzh[dimcounter])); 

{Anzahl der Langbezeichnungen dieser Dimension festlegen} 

setlength(countdaten[dimcounter],anzh[dimcounter]); 

CurItem:=CurItem.GetNext; 

counter:=0;merkecount:=0; 

while (CurItem nil)and(CurItem.HasChildren=false)and(abort=false) do 

begin 

{Eintragen der Kurzbezeichnung} 

dk[dimcounter,counter]:= 

copy(CurItem.Text,1,pos('//',CurItem.Text)-1); 

APA_Grid.ListBox1.Items.Add('dk['+inttostr(dimcounter)+','+inttostr(counter)+'] 

Kurzbezeichnung '+dk[dimcounter,counter]+' eingetragen'); 

{Eintragen der Langbezeichnung} 

dl[dimcounter,counter]:= 

copy(CurItem.Text,pos('//',CurItem.Text)+2,pos('::',CurItem.Text)- 

(pos('//',CurItem.Text)+2)); 

APA_Grid.ListBox1.Items.Add('dl['+inttostr(dimcounter)+','+inttostr(counter)+'] 

Langbezeichnung '+dl[dimcounter,counter]+' eingetragen'); 

{Eintragen der Countdaten} 

countdaten[dimcounter,counter]:= 

strtoint(copy(CurItem.Text,pos('::',CurItem.Text)+2,255)); 

APA_Grid.ListBox1.Items.Add('countdaten['+inttostr(dimcounter)+','+inttostr(counte 

r)+'] Countdaten '+inttostr(countdaten[dimcounter,counter])+' eingetragen'); 

{Feststellen, ob die Anzahl der Datensätze größer ist als der Vorgänger} 

if (countdaten[dimcounter,counter]>merkecount)and(merkecount0) then begin; 

Showmessage('Error generating APA. Count of records in hierarchy 

'+dk[dimcounter,counter]+' is larger than lower hierarchy. Abort Generation!'); 

abort:=true; 

end; 

{Setzen von merkecount} 

merkecount:=countdaten[dimcounter,counter]; 

CurItem:=CurItem.GetNext; 


end; 

dimcounter:=dimcounter+1; 

end; 

end; 

- 299 -



{********* Anzahl der Dimensionen feststellen ENDE} 

if abort=false then bezeichnungenkontrolliert:=true; 

end; 

end; 

function wuerfelvergleich (spalte,zeile:longint; akth:array of longint):boolean; 

var derivat: array of longint; 

g,x2:longint; 

merk:boolean; 

begin 

//Bestimme die Hierarchiestufen der Dimensionen des materialisierten Elements 

derivat:=nil; 

setlength(derivat,anzd); 

//Starte in Hierarchiestufe 0 

for x2:=0 to anzd-1 do derivat[x2]:=0; 

//Belege akthier mit der maximalen Hierarchiestufe jeder Dimension 

for x2:=0 to spalte do 

derivat[APA[x2,zeile].countdimension]:=APA[x2,zeile].counthier; 

//Überprüfe, ob keine Hierarchiestufe der Dimension der aktuellen Zelle 

// kleiner als die Hierarchiestufe der Dimension der materialisierten Würfel sind// 

merk:=true; 

for g:=0 to anzd-1 do begin 

if (derivat[g]=0)and(ende=false) do begin 

if wuerfelvergleich(aktspalte,aktzeile, akth)=false then begin 

//Wenn kein Derivat 

ende:=true; 

//Spalte links vom Derivat mach eine rechte Linie 

APA[aktspalte,aktzeile].linierechts:=true; 

- 300 -



aktspalte:=aktspalte+1; 

//im letzten Derivat mach eine linke Linie 

APA[aktspalte,aktzeile].linielinks:=true; 

end else aktspalte:=aktspalte-1; 

end; {von while} 

//Wenn die erste Zeile durchlaufen und ende ist immer noch false dann 

// starte in der ersten Spalte von links 

if (ende=false) then begin; 

aktspalte:=0; 

APA[aktspalte,aktzeile].linielinks:=true; 

end; 

//Der Cursor wandert zwischen den Zellen durch das Gitter. 

// Die Positionsmarke des Cursors befindet sich immer in der linken 

// unteren Ecke des Feldes. 

//Das Programm kontrolliert die Zellen unterhalb. 

// Feld[0] ist das Feld diagonal links untern. 

// Feld[1] ist das Feld unmittelbar darunter. 

//Setze beide Felder auf false 

feld:=nil; 

setlength(feld,2); 

feld[0]:=false; 

feld[1]:=false; 

while(aktzeile



procedure TAPA_Grid.materialzeichnen; 

var spalte,zeile:longint; 

ende:boolean; 

begin 

//Diese Methode zeichnet alle zu materialisierenden Würfel und zieht anschließend 

// die dicke rote Begrenzungsinie. 

//Alle Linien löschen 

for spalte:= 0 to anzspalten-1 do begin 

for zeile:=0 to anzzeilen-1 do begin 

APA[spalte,zeile].linieoben:=false; 

APA[spalte,zeile].linieunten:=false; 

APA[spalte,zeile].linielinks:=false; 

APA[spalte,zeile].linierechts:=false; 

APA[spalte,zeile].derivative:=false; 

APA[spalte,zeile].dickoben:=false; 

APA[spalte,zeile].dickunten:=false; 

APA[spalte,zeile].dicklinks:=false; 

APA[spalte,zeile].dickrechts:=false; 

end; //Ende von Zeilen 

end; //Ende von Spalten 

// Materialisiere alle Würfel, wo materailize = true 



if APA[spalte,zeile].materalisieren=true then begin 

markierederivative(spalte,zeile); 

end; 



//Aussenlinie generieren 

for zeile:= 0 to anzzeilen-1 do begin 

ende:=false; 

for spalte:=0 to anzspalten-1 do begin 

if ende=false then begin 

//Einfärben 

if APA[spalte,zeile].linielinks=true then begin 

//Line links 

APA[spalte,zeile].dicklinks:=true; 

ende:=true; 


//Line links links 

APA[spalte,zeile].dickoben:=APA[spalte,zeile].linieoben; 

APA[spalte,zeile].dickunten:=APA[spalte,zeile].linieunten; 

APA[spalte,zeile].dicklinks:=APA[spalte,zeile].linielinks; 

APA[spalte,zeile].dickrechts:=APA[spalte,zeile].linierechts; 

//Wenn die unter Zeile nicht die letzte ist ziehe auch die 

//untere Linie nach 

if zeile0) then 

APA[spalte,zeile-1].dickunten:=APA[spalte,zeile-1].linieunten; 

- 302 -



end; 

end; 





end; 









procedure ausfuellen(tozeile, tospalte, fromzeile,fromspalte, zeilemax:longint; 

nachunten:boolean); 

var zeile:longint; 

begin 

zeile:=tozeile; 

if (nachunten=true) then begin 

while (zeilezeilemax) do begin 

if (APA[tospalte,zeile].Screenbez='') then begin 

APA[tospalte,zeile].Screenbez:=APA[fromspalte,fromzeile].Screenbez; 

APA[tospalte,zeile].countdimension:=APA[fromspalte,fromzeile].countdimension; 

APA[tospalte,zeile].counthier:=APA[fromspalte,fromzeile].counthier; 

APA[tospalte,zeile].gewicht:=0; 

APA[tospalte,zeile].gewichtlevel:=-1; 

end; 

zeile:=zeile-1; 

end; 

end; 

end; 

procedure zellenkop(fromx1,fromy1,fromx2,fromy2,tox,toy:longint; oben,mitfarbe:boolean); 

var x,y:longint; 

begin 

{Kopiere die Zellen fromx1,formy1 bis fromx2,fromy2 auf die Zelle tox,toy und folgende} 

if (oben=false) then toy:=toy-abs(fromy1-fromy2); 

for x:=min(fromx1,fromx2) to max(fromx1,fromx2) do begin 

for y:= min(fromy1,fromy2) to max(fromy1,fromy2) do begin 

- 303 -


end; 

end; 


APA[tox-min(fromx1,fromx2)+x,toymin(fromy1,fromy2)+y].Screenbez:=APA[x,y].Screenbez; 

if mitfarbe=true then 

APA[tox-min(fromx1,fromx2)+x,toy-min(fromy1,fromy2)+y].farbe:=APA[x,y].farbe; 

APA[tox-min(fromx1,fromx2)+x,toymin(fromy1,fromy2)+y].counthier:=APA[x,y].counthier;APA[tox-min(fromx1,fromx2)+x,toymin(fromy1,fromy2)+y].countdimension:=APA[x,y].countdimension; 

APA[tox-min(fromx1,fromx2)+x,toy-min(fromy1,fromy2)+y].gewicht:=0; 

APA[tox-min(fromx1,fromx2)+x,toy-min(fromy1,fromy2)+y].gewichtlevel:=-1; 

end; 

procedure calculatecolumnscount; 


begin 

{Diese Procedure berechnet die Anzahl der Spalten des gesamten APA} 

anzspalten:=0; 

for counter:=0 to anzd-1 do anzspalten:=anzspalten+(anzh[counter]-1); 

APA_Grid.ListBox1.Items.Add('Anzahl der Spalten des APAs berechnet mit 

'+inttostr(anzspalten)); 

end; 

procedure calculaterowcount; 


begin 

{Diese Procedure berechnet die Anzahl der Zeilen des gesamten APA} 

anzzeilen:=1; 


if (anzh[counter]0) then anzzeilen:=anzzeilen*anzh[counter]; 

if (maxh


end; 

end; 


end; 

APA[x,zeile].kurzbez:=s; 

//Kurzbezeichnung generieren ENDE 

//Langbezeichnung generieren 

APA[x,zeile].langbez:=nil; 

setlength(APA[x,zeile].langbez,anzd); 

//Hierarchiestufenausprägungen generieren 

APA[x,zeile].hierstufe:=nil; 

setlength(APA[x,zeile].hierstufe,anzd); 

for z:=0 to anzd-1 do begin 

APA[x,zeile].langbez[z]:=dimbez[z]+':'+dl[z,akthier[z]]; 

APA[x,zeile].hierstufe[z]:=akthier[z]; 

end; 

//Langbezeichnung generieren ENDE 

end; 

procedure TAPA_Grid.generate; 

var zeile,spalte:longint; 

var feld,dimcounter,hiercounter, counter:longint; 

var aktuelledim,aktuellespalte,aktuellezeile,anzkop:longint; 

begin 

{APA erzeugen} 

APA:=nil; 

setlength(APA,anzspalten,anzzeilen); 

{APA mit Werten füllen} 



APA[spalte,zeile].zeile:=zeile; 

APA[spalte,zeile].spalte:=spalte; 





APA[spalte,zeile].dickoben:=false; 

APA[spalte,zeile].dickunten:=false; 

APA[spalte,zeile].dicklinks:=false; 

APA[spalte,zeile].dickrechts:=false; 

APA[spalte,zeile].farbe:=clWhite; 

APA[spalte,zeile].interessant:=false; 

APA[spalte,zeile].materalisieren:=false; 


APA[spalte,zeile].Screenbez:=''; 

APA[spalte,zeile].kurzbez:=''; 

end; 

end; 

{Erste Zeile erzeugen} 

feld:=0; 

for dimcounter:=0 to anzd-1 do begin 

for hiercounter:=1 to anzh[dimcounter]-1 do begin 

APA[feld,0].Screenbez:=dk[dimcounter,hiercounter]; 

APA[feld,0].farbe:=clYellow; 

APA[feld,0].counthier:=hiercounter; 

APA[feld,0].countdimension:=dimcounter; 

APA[feld,0].gewicht:=0; 

APA[feld,0].gewichtlevel:=0; 

end; 

end; 

feld:=feld+1; 

- 305 -



{Kopieren der redundanzfreien Zellen des APA} 

aktuelledim:=anzd-1; 

aktuellespalte:=anzspalten-(anzh[aktuelledim]-1); 

aktuellezeile:=0; 

while (aktuellespalte>0) do begin 

{Kopiere Block Beginn} 

anzkop:=0; 

while (anzkop



NewRect.Left:=Rect.left; 

NewRect.Right:=Rect.left+13; 

NewRect.Top:=Rect.Bottom-13; 

NewRect.Bottom:=Rect.Bottom; 

APAGrid.Canvas.Brush.Color:=clBlack; 

APAGrid.Canvas.FillRect(NewRect); 

APAGrid.Canvas.Font.Color:=clWhite; 

APAGrid.Canvas.Font.Size:=4; 

APAGrid.Canvas.Font.Style:=[fsBold]; 

APAGrid.Canvas.TextOut(Rect.left+2,Rect.Bottom-11,'P'); 

APAGrid.Canvas.Font.Style:=[]; 

APAGrid.Canvas.Brush.Color:=APA[ACol,ARow].farbe; 

APAGrid.Canvas.Font.Color:=clBlack; 

APAGrid.Canvas.Pen.Color:=clBlack; 

end; 

if (APA[ACol,ARow].flag>=2)and(APA[ACol,ARow].flag



if (APA[ACol,ARow].linieunten=true) then begin 



if (ACol0) then begin 

if (APA[ACol-1,ARow].dickunten=true)or(APA[ACol,ARow].dicklinks=true) then 

APAGrid.Canvas.Rectangle(Rect.Left+2,Rect.Bottom-2,Rect.Right+2,Rect.Bottom) 

else 

APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Bottom-2,Rect.Right+2,Rect.Bottom); 

end else 


end; 

if (APA[ACol,ARow].linierechts=true) then begin 



APAGrid.Canvas.Rectangle(Rect.Right-2,Rect.Top-2,Rect.Right,Rect.Bottom+2); 

end; 

if (APA[ACol,ARow].linielinks=true) then begin 



APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Bottom+2); 

end; 

if (APA[ACol,ARow].dickoben=true) then begin 

APAGrid.Canvas.Pen.Color:=clRed; 

APAGrid.Canvas.Brush.Color:=clRed; 

APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Right+2,Rect.top+2); 

end; 

if (APA[ACol,ARow].dickunten=true) then begin 




end; 

if (APA[ACol,ARow].dickrechts=true) then begin 



APAGrid.Canvas.Rectangle(Rect.Right-2,Rect.Top-2,Rect.Right,Rect.Bottom+2); 

end; 

if (APA[ACol,ARow].dicklinks=true) then begin 



APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Bottom+2); 

end; 

if (ACol>0)and(ARow>0) then begin 

if (APA[ACol-1,ARow].linieoben=true)or(APA[ACol,ARow-1].linielinks=true) 

or (APA[ACol,ARow].linielinks=true) then begin 



APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Top+2); 

end; 

if (APA[ACol-1,ARow].dickoben=true)or(APA[ACol,ARow-1].dicklinks=true) 

or (APA[ACol,ARow].dicklinks=true) then begin 



APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Top+2); 

end; 

end; 


APAGrid.Canvas.Brush.Color:=APA[ACol,ARow].farbe; 

APAGrid.Canvas.Font.Color:=clBlack; 


- 308 -



if (APA[ACol,ARow].materalisieren=true) then begin; 



NewRect.Left:=Rect.Left+round((Rect.Right-Rect.Left)/6); 

NewRect.Right:=Rect.Right-round((Rect.Right-Rect.Left)/6); 

NewRect.Top:=Rect.Top+round((Rect.Bottom-Rect.Top)/6); 

NewRect.Bottom:=Rect.Bottom-round((Rect.Bottom-Rect.Top)/6); 

APAGrid.Canvas.Ellipse(NewRect); 




if APA[ACol,ARow].matcount>9 then 

APAGrid.Canvas.TextOut(Rect.Right-14,Rect.bottom- 

15,inttostr(APA[ACol,ARow].matcount)) 

else 

APAGrid.Canvas.TextOut(Rect.Right-8,Rect.bottom- 

15,inttostr(APA[ACol,ARow].matcount)); 




end; 

if (APA[ACol,ARow].derivative=true) then begin; 

APAGrid.Canvas.Pen.Color:=clGreen; 

APAGrid.Canvas.Brush.Color:=clGreen; 








end; 

if (ACol=klickspalte)and(ARow=klickzeile) then begin; 

APAGrid.Canvas.Pen.Color:=clBlue; 

APAGrid.Canvas.Brush.Color:=clBlue; 








end; 

if (Remove_Redundancy.Checked=false)or 

((Remove_Redundancy.Checked=true)and(APA[ACol,ARow].farbe=clYellow)) then 

begin; 

APAGrid.Canvas.TextOut(round((Rect.left+Rect.right)/2)round(APAGrid.Canvas.TextWidth(APA[ACol,Arow].Screenbez)/2),round((Rect.top+Rect.Bottom)/2)round(APAGrid.Canvas.TextHeight(APA[ACol,Arow].Screenbez)/2),APA[ACol,Arow].Screen 

bez); 

end; 

end; 

procedure TAPA_Grid.APAGridMouseMove(Sender: TObject; Shift: TShiftState; 

X, Y: Integer); 

begin 

aktx:=x;akty:=y; 

zellespalte:=APAGrid.MouseCoord(x,y).X; 

zellezeile:=APAGrid.MouseCoord(x,y).y; 

- 309 -



if ((zellespalte-1)and(zellezeile-1)) 

then begin; 


((Remove_Redundancy.Checked=true)and(APA[zellespalte,zellezeile].farbe=clYellow)) then 

begin; 

if APA[zellespalte,zellezeile].interessant=true then begin 

if (APA[zellespalte,zellezeile].gewichtlevel-1) 

and(APA[zellespalte,zellezeile].gewichtlevelmerke then begin 

APA[spalte,zeile].matcount:=APA[spalte,zeile].matcount-1; 

end; 

- 310 -



end;//spalte 

end;//zeile 

matcount:=matcount-1; 

materialzeichnen; 

APAGrid.Repaint; 

end; 

procedure TAPA_Grid.Showderivatives1Click(Sender: TObject); 


begin 











APA[zellespalte,zellezeile].derivative:=true; 

markierederivative(zellespalte,zellezeile); 


end; 

procedure TAPA_Grid.APAGridDblClick(Sender: TObject); 

begin 


end; 

procedure TAPA_Grid.APAGridMouseDown(Sender: TObject; Button: TMouseButton; 


begin 

zellespalte:=APAGrid.MouseCoord(x,y).X; 

zellezeile:=APAGrid.MouseCoord(x,y).y; 

{klickspalte:=APAGrid.MouseCoord(x,y).X; 

klickzeile:=APAGrid.MouseCoord(x,y).y;} 

end; 

procedure TAPA_Grid.Button_to_Input_ScreenClick(Sender: TObject); 

begin 

gotoInput:=true; 

gotoSelection:=false; 

APA_Grid.Close; 

end; 

procedure TAPA_Grid.Button_to_Selection_ScreenClick(Sender: TObject); 

begin 

gotoInput:=false; 

gotoSelection:=true; 

APA_Grid.Close; 

end; 

procedure TAPA_Grid.Button_to_Main_MenuClick(Sender: TObject); 

begin 

Close; 

end; 

procedure TAPA_Grid.Remove_RedundancyClick(Sender: TObject); 

begin 

Removeredundancy1.Checked:=Remove_Redundancy.Checked; 

Apagrid.Repaint; 

end; 

procedure TAPA_Grid.ShowRedundancyfreecube1Click(Sender: TObject); 

- 311 -




begin 

klickspalte:=zellespalte;klickzeile:=zellezeile; 

spalte:=zellespalte;zeile:=zellezeile; 

while (APA[klickspalte,klickzeile].kurzbez=APA[spalte,zeile].kurzbez) 

and(APA[klickspalte,klickzeile].farbeclYellow) do begin 

klickzeile:=klickzeile-1;if klickzeile



matcount:=0; 

end; 

procedure TAPA_Grid.ListBox1DblClick(Sender: TObject); 

begin 

Panel3.Width:=1; 

end; 

procedure TAPA_Grid.FormShow(Sender: TObject); 

begin 


APAGrid.Visible:=false; 

APAGrid.Enabled:=false; 

{Spalten berechnen} 

calculatecolumnscount; 

{Anz der Zielen berechnen} 

calculaterowcount; 

APAGrid.ColCount:=anzspalten; 

APAGrid.RowCount:=anzzeilen; 

{APA generieren} 

generate; 

APAGrid.Visible:=true; 

APAGrid.Enabled:=true; 

generiereapaneu:=false; 

Showdeterministicsolution2.Visible:=true; 

Removedeterministicsolution2.Visible:=false; 

end; 

end; 

function TAPA_Grid.getbuild(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended; 

begin 

with APA_Application do begin 

if (vonspaltezuspalte)or(vonzeilezuzeile) then begin 

if findkosten(vonspalte,vonzeile,zuspalte,zuzeile) then begin 

Result:=vKosten.Build; 

end//End of findkey 

else begin; 

if (vonspaltezuspalte)or(vonzeilezuzeile) then begin; 

APA_Show_Process.ausgabe('Da fehlen Kosten!! 

'+inttostr(vonspalte)+':'+inttostr(vonzeile)+'/'+inttostr(zuspalte)+':'+inttostr(z 

uzeile));//Später entfernen 

break:=true; 

end; 

Result:=0; 

end; 

end else Result:=0; 

end;//End of APA_Application} 

end; 

function TAPA_Grid.getquery(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended; 

begin 


if (vonspaltezuspalte)or(vonzeilezuzeile) then begin 

if findkosten(vonspalte,vonzeile,zuspalte,zuzeile) then begin 

Result:=vKosten.Query; 

end//End of findkey 

else begin; 

if (vonspaltezuspalte)or(vonzeilezuzeile) then begin; 

- 313 -



APA_Show_Process.ausgabe('Da fehlen QueryKosten!! 

'+inttostr(vonspalte)+':'+inttostr(vonzeile)+'/'+inttostr(zuspalte)+':'+inttostr(z 

uzeile));//Später entfernen 

break:=true;end; 

Result:=0; 

end; 

end else Result:=0; 

end;//End of APA_Application 

end; 

function TAPA_Grid.auffuellen(st:string; anzahl:longint):string; 

begin 

while (length(st)


end; 


end else //BFT 

begin; 

//Berechne die Tupels welche abgefragt werden 

anztupels:=0; 


anztupels:=anztupels+countdaten[counter,0]; 

end; 

Result:=anztupels; 

end; 

end; 

function TAPA_Grid.deltaBftW(aktspalte,aktzeile:longint;Query:boolean):Extended; 

var anztupels,storetupels:Extended; //Zähler 

var SummeBerechnungendeltaBFTW:Extended; 

begin; 

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 

//Berechne die Kosten für das Erzeugen des Würfels aus dem BFT table 

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 

anztupels:=gettupel(-1,-1); 

storetupels:=gettupel(aktspalte,aktzeile); 

try 

if Query= true then begin 

SummeBerechnungendeltaBFTW:= 

( 

( 

( 

((strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(anztupels+(2*storetupels)))) 

) 

/ 

strtofloat(APA_Parameter.APA_Thomas_timemax.text) 

)+ 

( 

(storetupels* 

log2(storetupels)*strtofloat(APA_Parameter.APA_Thomas_timecpu.Text)) 

/ 


) 

) 

* (APA_Parameter.APA_Thomas_Importance.Position/100); 


SummeBerechnungendeltaBFTW:= 

( 

(( 


+ 

(strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*storetupels) 

) 

/ 


)+ 

( 

(storetupels* 


/ 


- 315 -



) 

) 


SummeBerechnungendeltaBFTW:=SummeBerechnungendeltaBFTW 

+ 

(( 

(strtofloat(APA_Parameter.APA_Thomas_timestore.text)*storetupels) 

/ 

strtofloat(APA_Parameter.APA_Thomas_spacemax.text) 

) 

* (1-(APA_Parameter.APA_Thomas_Importance.Position/100)) 

); 

end; 

except 

showmessage('Error in Parameters'); 

SummeBerechnungendeltaBFTW:=0; 

end; 

Result:=SummeBerechnungendeltaBFTW; 

end; 

function 

TAPA_Grid.deltaVW(spalte,zeile,aktspalte,aktzeile:longint;query:boolean):Extended; 

var anztupels, storetupels:Extended; //Zähler 

var SummeBerechnungendeltaVW:Extended; 

begin; 

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 

//Berechne die Kosten für das Berechnen des Würfels aus dem BFT table 

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 

SummeBerechnungendeltaVW:=0; 

if (spalteaktspalte)or(zeileaktzeile) then begin 

if spalte-1 then begin 

anztupels:=gettupel(spalte,zeile); 

storetupels:=gettupel(aktspalte,aktzeile); 

try 

if Query=true then begin 

//ABfrage 

SummeBerechnungendeltaVW:= 

( 

(( 


) 

/ 


)+ 

( 

(storetupels* 


/ 


) 

) 



//Materialisieren 

SummeBerechnungendeltaVW:= 

( 

(( 


+ 

(strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*storetupels) 

- 316 -



) 

/ 


)+ 

( 

(storetupels* 


/ 


) 

) 


SummeBerechnungendeltaVW:=SummeBerechnungendeltaVW 

+ 

(( 

(strtofloat(APA_Parameter.APA_Thomas_timestore.text)*storetupels) 

/ 

strtofloat(APA_Parameter.APA_Thomas_spacemax.text) 

) 

* (1-(APA_Parameter.APA_Thomas_Importance.Position/100)) 

); 

end; 

except 

showmessage('Error in Parameters'); 

SummeBerechnungendeltaVW:=0; 

end; 

end //spalte -1 

else begin 

SummeBerechnungendeltaVW:=deltaBftW(aktspalte,aktzeile,Query); 

end; 

end; 

Result:=SummeBerechnungendeltaVW; 

end; 

function 

TAPA_Grid.GetMinDerivatOfSpalte(aktspalte,aktzeile:longint;Query:boolean):longint; 


New:string; 

derivat:longint; 

mincost:Extended; 

aus:boolean; 

begin 

try 

derivat:=0;mincost:=0; aus:=false; 

counter:=0; 

repeat; 

if counter



if (mincost=0)or 

(getbuild(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)


except 

Result:=0; 

end; 

end; 


if Query=false then begin 

if (mincost=0)or 

(getbuild(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)



spaceortime_limit_reached:=false; 

//Bestimmen des ersten Cube Anfang 

//******************************** 

//Schleife für alle Würfel, welche noch nicht ausgewählt wurden// 

for zeile:=0 to anzzeilen-1 do begin; 

for spalte:=0 to anzspalten-1 do begin; 

//zeile und spalte symbolisieren einen Würfel 

// v welcher zugestetz werden könnte 

BerechneE:=0; 

if (APA[spalte,zeile].farbe=clYellow) then 

begin; //Wenn redundanzfrei dann beginne// 

Listbox1.Items.Add('');listbox1.Items.Add('++++++++++++++++Kontrolliere 

Zelle '+inttostr(spalte)+':'+inttostr(zeile)); 

//Setzte den Wert für E(m) auf 0 



//aktzeile und aktspalte symbolisieren den würfel w 

//Feststellen ob der Würfel redundanzfrei und ausgewählt ist// 

if 

(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].gewicht0) 

then begin 

//if //aktuelle Würfel ist ein Derivat von aktellem v 

if 

(isderivat(spalte,zeile,aktspalte,aktzeile)=true)and(APA[aktspalte,aktzeile].inter 

essant=true) then begin 

listbox1.Items.Add('Schau mir das an: ist Derivat und nicht 

0 '+inttostr(aktspalte)+':'+inttostr(aktzeile)); 

//Berechne Summe aller Delta w 

if Userandomcosts1.Checked=false then begin 

BerechneE:=BerechneE+ 

((deltaBftW(aktspalte,aktzeile,false)deltaVW(spalte,zeile,aktspalte,aktzeile,false))*(APA[aktspalte,aktzeile].gewicht)) 

; 

listbox1.Items.Add('Berechne'+floattostr(deltaBftW(aktspalte,aktzeile,false))+'-' 

+floattostr(deltaVW(spalte,zeile,aktspalte,aktzeile,false))+'*'+floattostr((APA[ak 

tspalte,aktzeile].gewicht))); 



((getbuild(-1,-1,aktspalte,aktzeile)getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht)); 

listbox1.Items.Add('Berechne'+floattostr(getbuild(-1,- 

1,aktspalte,aktzeile))+'-' 

+floattostr(getbuild(spalte,zeile,aktspalte,aktzeile))+'*'+floattostr((APA[aktspal 

te,aktzeile].gewicht))); 

end; 

end; //Wenn Derivat 

end; //Wenn Würfel ist redundanzfrei 

end;{Ende von aktspalte} 

end;{Ende von aktzeile} 


listbox1.Items.add('Gesamtwert für BerechneE :'+floattostr(BerechneE)); 

APA[spalte,zeile].value:=(BerechneE-deltaBftW(spalte,zeile,false)); 

listbox1.Items.Add('Wert eintragen für Zelle 

'+inttostr(spalte)+':'+inttostr(zeile)+': Wert: 

'+floattostr(APA[spalte,zeile].value)+' Gewicht: 

'+floattostr((APA[spalte,zeile].gewicht))); 

- 320 -



if APA[spalte,zeile].gewicht0 then 

listbox1.Items.add('================================================='); 


listbox1.Items.add('Gesamtwert für BerechneE :'+floattostr(BerechneE)); 

APA[spalte,zeile].value:=(BerechneE-getbuild(-1,-1,spalte,zeile)); 

listbox1.Items.Add('Wert eintragen für Zelle 



'+floattostr((APA[spalte,zeile].gewicht))); 

if APA[spalte,zeile].gewicht0 then 

listbox1.Items.add('================================================='); 

end; 

end{von Redundanzfrei} 

else APA[spalte,zeile].value:=0; 

end;{For Schleife spalte} 

end;{For Schleife zeilen} 

//Materialisiere als ersten Würfel jenen mit dem besten Value 

//Finde den höchsten Wert 

merkvalue:=APA[0,0].value;aktzeile:=0;aktspalte:=0; 



if 

((APA[spalte,zeile].value>merkvalue)or((merkvalue=0)and(Minusnehmen1.Checked=true) 

)) 

and (APA[spalte,zeile].value0) then begin 

merkvalue:=APA[spalte,zeile].value;//Wert merken 

aktspalte:=spalte;aktzeile:=zeile;//Merken der Spalte und Zeile 

end; 

end; 

end; 

if merkvalue=0 then spaceortime_limit_reached:=true; 


timemax:=timemax-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,- 

1)+(2*gettupel(aktspalte,aktzeile)))+ 

+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo 

g2(gettupel(aktspalte,aktzeile))+ 

strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile)); 


timemax:=timemax-getbuild(-1,-1,aktspalte,aktzeile); 

end; 

spacemax:=spacemax- 

(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei 

le)); 

if (spacemax



if ProssernurersterLauf1.Checked=false then begin 

while (spaceortime_limit_reached=false) do begin; 

//Schleife für alle Würfel, welche noch nicht ausgewählt wurden// 



//zeile und spalte symbolisieren einen Würfel 

// v welcher zugestetz werden könnte 

//Setzte den Wert für E(m) auf 0 

BerechneE:=0; 

//Alle Wuerfel Value auf 0 setzen 

for aktzeile:=0 to anzzeilen-1 do begin; 

for aktspalte:=0 to anzspalten-1 do begin; 

APA[aktspalte,aktzeile].value:=0; 

end; 

end; 

if (APA[spalte,zeile].farbe=clYellow) then 

begin; //Wenn redundanzfrei dann beginne// 

Listbox1.items.add('+++++++++++'); 

listbox1.Items.Add('Kontrolliere zweite Schleife Zelle 



'+floattostr(APA[spalte,zeile].gewicht)); 

//Stelle fest, ob Würfel schon zugesetzt 

added:=false; 

for counter:=0 to Memorywuerfel.Count-1 do begin 

New:=Memorywuerfel[counter]; 

if 

(strtoint(copy(new,31,30))=zeile)and(strtoint(copy(new,1,30))=spalte) then 

added:=true; 

end; 

++++'); 

if added=true then listbox1.items.add('++++ Würfel schon zugesetzt 

if added=false then begin; 

//Würfel ist noch nicht in der Menge der bereits ausgewählten Würfel// 

isderivatof:=false; 



if 

isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),spalte,zeile) then 

begin; 

isderivatof:=true; 

Listbox1.Items.Add(copy(new,1,30)+':'+copy(new,31,30)+' kann erzeugen 

'+inttostr(spalte)+':'+inttostr(zeile)) 

end; 

end; 

if isderivatof=false then begin 

//ist kein Derivat Begin ++++++++++++++++++++++++ 

//wird also aus dem BFT berechnet 

//Berechne alle Zellen ein 




//Feststellen ob der Würfel redundanzfrei ist// 

if 

(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].gewicht0) 

then begin 


- 322 -



if isderivat(spalte,zeile,aktspalte,aktzeile)=true then 

begin 

listbox1.Items.add('Kontrolliere Würfel 

'+inttostr(aktspalte)+'.'+inttostr(aktzeile)); 

//Wenn u aus einem bereits materialisierten Würfel 

abgebildet werden kann 




if 


begin; 

Listbox1.Items.Add(copy(new,1,30)+':'+copy(new,31,30)+' ist auch ein derivat von 

'+inttostr(spalte)+':'+inttostr(zeile)); 


end; 

end; 

if isderivatof=false then begin; 


BerechneE:=BerechneE+((deltaBftW(aktspalte,aktzeile,false)- 

deltaVW(spalte,zeile,aktspalte,aktzeile,false))*(APA[aktspalte,aktzeile].gewicht)) 

; 

listbox1.Items.Add('Berechne'+floattostr(deltaBftW(aktspalte,aktzeile,false))+'-' 



1,aktspalte,aktzeile)- 

end//von Userkostenrandom 

else 

begin 

BerechneE:=BerechneE+((getbuild(-1,- 

getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht)); 

listbox1.Items.Add('Berechne'+floattostr(getbuild(- 

1,-1,aktspalte,aktzeile))+'-' 



end; 

end else 

begin 



max(0,((deltaVW(GetMinDerivatOfSpalte(aktspalte,aktzeile,false), 

GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false)- 


); 

listbox1.Items.Add('Berechne'+floattostr(deltaVW(GetMinDerivatOfSpalte(aktspalte,a 

ktzeile,false), 

GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false))+'-' 



end//von Userkosten 

else 

begin 


- 323 -



max(0,((getbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false), 

GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile)- 

getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht))); 

listbox1.Items.Add('Berechne'+floattostr(getbuild(GetMinDerivatOfSpalte(aktspalte, 

aktzeile,false), 

GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile))+'-' 



end; 

end; 



end;//Ende von aktspalte 

end;//Ende von aktzeile 


APA[spalte,zeile].value:=BerechneE-deltaBftW(spalte,zeile,false); 

listbox1.Items.add('BerechneE für 

'+inttostr(spalte)+':'+inttostr(Zeile)+' ist '+floattostr(BerechneEdeltaBftW(spalte,zeile,false))); 

end//von Userkosten 

else begin 

APA[spalte,zeile].value:=BerechneE-getbuild(-1,-1,spalte,zeile); 


'+inttostr(spalte)+':'+inttostr(Zeile)+' ist '+floattostr(BerechneE-getbuild(-1,- 

1,spalte,zeile))); 

end; 

end//von ist kein Derivat ++++++++++++++++++++++ 

else begin//von ist ein Derivat ++++++++++++++++++++++++ 

listbox1.Items.Add('is a derivat Cell 

'+inttostr(spalte)+':'+inttostr(zeile)); 




//Feststellen ob der Würfel redundanzfrei ist// 

if (APA[aktspalte,aktzeile].farbe=clYellow) 

and(APA[aktspalte,aktzeile].gewicht0) then begin 

begin 


if isderivat(spalte,zeile,aktspalte,aktzeile)=true then 



max(0,((deltaVW(GetMinDerivatOfSpalte(aktspalte,aktzeile,false), 

GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false)- 


); 

listbox1.items.add('Min Parent is 

'+inttostr(GetMinDerivatOfSpalte(aktspalte,aktzeile,false))+':'+ 

inttostr(GetMinDerivatOfZeile(aktspalte,aktzeile,false))); 

listbox1.Items.Add('Berechne 0 oder 

'+floattostr(deltaVW(GetMinDerivatOfSpalte(aktspalte,aktzeile,false), 

GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false))+'-' 

- 324 -





end//of Userkosten 

else begin 


max(0,((getbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false), 

GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile)- 

getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht))); 

listbox1.items.add('Min Parent is 

'+inttostr(GetMinDerivatOfSpalte(aktspalte,aktzeile,false))+':'+ 

inttostr(GetMinDerivatOfZeile(aktspalte,aktzeile,false))); 

listbox1.Items.Add('Berechne 0 oder 

'+floattostr(getbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false), 

GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile))+'-' 



end; 



end;//Ende von aktspalte 

end;//Ende von aktzeile 


APA[spalte,zeile].value:=BerechneE- 

deltaVW(GetMinDerivatOfSpalte(spalte,zeile,false),GetMinDerivatOfZeile(spalte,zeil 

e,false),spalte,zeile,false); 


'+inttostr(spalte)+':'+inttostr(Zeile)+' ist 

'+floattostr(APA[spalte,zeile].value)); 

end//Userkosten 

else begin 

APA[spalte,zeile].value:=BerechneE- 

getbuild(GetMinDerivatOfSpalte(spalte,zeile,false),GetMinDerivatOfZeile(spalte,zei 

le,false),spalte,zeile); 


'+inttostr(spalte)+':'+inttostr(Zeile)+' ist 

'+floattostr(APA[spalte,zeile].value)); 

end; 

end;//von ist ein Derivat ++++++++++++++++++++++++++++ 

end; //Würfel ist noch nicht in der Liste ENDE 

end;//von Redundanzfrei 

end;//For Schleife spalte 

end;//For Schleife zeilen 

//Materialisiere als nächsten Würfel jenen mit dem besten Value 

//Finde den höchsten Wert 

merkvalue:=0;aktzeile:=0;aktspalte:=0;isderivatof:=false; 



if 

((APA[spalte,zeile].value>merkvalue)or((merkvalue=0)and(Minusnehmen1.Checked=true) 

)) 

and (APA[spalte,zeile].value0) then begin 

merkvalue:=APA[spalte,zeile].value;//Wert merken 

- 325 -



aktspalte:=spalte;aktzeile:=zeile;//Merken der Spalte und Zeile 

//Festellen, ob aus dem BFT materialisiert wird oder aus einem bereits 

//materialisierten Würfel 



if 


begin; 


end; 

end; 

end; 

end; 

end; 

if merkvalue=0 then begin; 

spaceortime_limit_reached:=true; //Wenn kein Würfel einen Wert hat beenden 

showmessage('Alle Würfel 0'); 

end 

else 

begin; 

if isderivatof=false then begin 

//Wird aus dem BFT erzeugt 


timemax:=timemax- 

(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,- 






timemax:=timemax-getbuild(-1,-1,aktspalte,aktzeile); 

end; 



le)); 


//Wird aus bereits materialisiertem Würfel erzeugt 


timemax:=timemax-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)* 

(gettupel(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),GetMinDerivatOfZeile(akt 

spalte,aktzeile,false))+(2*gettupel(aktspalte,aktzeile)))+ 





timemax:=timemaxgetbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),GetMinDerivatOfZeile(akts 

palte,aktzeile,false), 

aktspalte,aktzeile); 

end; 



le)); 

end; 

end; 

- 326 -



if timemax



var merksecondcosts:Extended; 

begin 

Button_remove_materialized_cubes.Click; 


{$i-} 

reset(fKosten); 

{$i+} 


try 

APA_Grid.Enabled:=false; 

if (APA_Options.APA_ShowScreenheuristic.Checked) then begin 

APA_Show_Process.Show; 


end; 

listbox1.Items.Clear; 

{*********************************************************} 

{1. Vorbereitungen für die Iteration} 

{*********************************************************} 

APA_Show_Process.ausgabe('Start Thomas Achs heuristic ...'); 

{1.a Erzeuge die Liste der materialisierungswürdigen Würfel} 

PossibleCubes:=TStringList.Create(); 

SecondCubes:=TStringList.Create(); 

MerkMatCubes:=TList.Create(); 

MerkMatCubesfertig:=TList.Create(); 

MatCubes:=TStringList.Create(); 

SecondMatCubes:=TStringList.Create(); 

try 

APA_Show_Process.ausgabe('Search for required cubes...'); 

counter:=0; 



if (APA[aktspalte,aktzeile].interessant=true)and 

(APA[aktspalte,aktzeile].farbe=clYellow) then begin//Auswählen des Würfels 

listbox1.Items.Add('Required Cube: 

'+auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile),10)); 

PossibleCubes.Add(auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile) 

,10)); 


end;//of Auswählen des Würfels 

end;//of aktspalte 

end;//of aktzeile 

APA_Show_Process.ausgabe(' Found '+inttostr(counter)+' required Cubes'); 


if tomohnederivate1.Checked=false then begin 

APA_Show_Process.ausgabe('Search for parent cubes or required cubes...'); 

counter:=0; 



if 








if isderivat(aktspalte,aktzeile,derivspalte,derivzeile) then begin 






- 328 -






listbox1.Items.Add('Derivat Cube: 



,10)); 


end; 

end;//von Yellow 



APA_Show_Process.ausgabe('Found '+inttostr(counter)+' parent cubes of required 

cubes...'); 

end;//of tomohnederivate1 

Setcount:=1; 

NewSetsforEachIteration:=strtoint(trim(APA_Parameter.APA_Thomas_newsetsoneachiteration.t 

ext)); 

maxSets:=strtoint(trim(APA_Parameter.APA_Thomas_countofsets.text)); 

setlength(Sets,MaxSets); 

APA_Show_Process.ausgabe('Set of possible cubes of '+inttostr(counter)+' cubes is parent 

cubes union required cubes'); 

{1.c. Setze limits} 

spaceortimelimitreached:=false; 

timemax:=strtofloat(APA_Parameter.APA_Thomas_timemax.Text); 

spacemax:=strtofloat(APA_Parameter.APA_Thomas_spacemax.Text); 

{*********************************************************} 

{Ende 1. Vorbereitungen für die Iteration} 

{*********************************************************} 

{*********************************************************} 

{2. Iterationen der Sets} 

{*********************************************************} 

Setcounter:=-1; 

repeat; 

{*********************************************************} 

{2.1 Vorbereiten des Startsets für die Iteration} 

{*********************************************************} 

APA_Show_Process.ausgabe('Generate '+inttostr(Setcounter+2)+' Set'); 

APA_Show_Process.ausgabe('Add the best cube to the set as long as no limit reached '); 

if (Setcounter


end; 

end; 


for zahler2:=0 to zahler do begin 

if 

(isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2], 

11,10)), 

aktspalte,aktzeile)=true)and(zahlerzahler2) then 

begin; 

if (Userandomcosts1.Checked=false) then begin 

if (MinMatCosts> 

deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11, 

10)), 

aktspalte,aktzeile,false)) 

then 

begin; 

parentzeile:=strtoint(copy(MatCubes[zahler2],11,10)); 

parentspalte:=strtoint(copy(MatCubes[zahler2],1,10)); 

end; 

end//of keine Zufallskosten 

else 

begin//Wenn Zufallskosten 


getbuild(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11 

,10)), 

aktspalte,aktzeile)) 

then 

begin; 



end; 

end;//Ende Wenn Zufallskosten 

end; 

end; 

//Ende Feststellen des Würfels, welcher Materialisert werden soll und woher 










le)); 


timemax:=timemax-getbuild(parentspalte,parentzeile,aktspalte,aktzeile);; 



le)); 

end; 

{*********************************************************} 

- 330 -



{Ende 2.1 Vorbereiten des Startsets für die Iteration} 

{*********************************************************} 

{*********************************************************} 

{2.2. Beginn der Iteration des aktuellen Sets} 

{*********************************************************} 

spaceortimelimitreached:=false; 

while(spaceortimelimitreached=false)and(stop=false) do begin 

for zahler:=0 to PossibleCubes.Count-1 do begin 

aktspalte:=strtoint(copy(PossibleCubes[zahler],1,10)); 

aktzeile:=strtoint(copy(PossibleCubes[zahler],11,10)); 

SecondCubes.Clear; 

//Feststellen des Würfels, welcher Materialisert werden soll und woher 

bereitsmaterialisiert:=false; 

for zahler2:=0 to MatCubes.Count-1 do begin 

if PossibleCubes[zahler]=MatCubes[zahler2] then begin; 

bereitsmaterialisiert:=true; 

end; 

end; 

if bereitsmaterialisiert=false then begin 

//? gibt es ein x? 

kannabgeleitetwerden:=false; 

if (Userandomcosts1.Checked=false) then 

MinMatCosts:=deltaBftW(aktspalte,aktzeile,false) else 

MinMatCosts:=getbuild(-1,-1,aktspalte,aktzeile); 

parentzeile:=-1;parentspalte:=-1; 

{*********************************************************} 

{2.2.1. Feststellen des Cubes aus dem der Cube c (zahler) materialisiert wird: 

Dazu kontrolliere alle bereits materialisierten Cubes z (zahler2), 

ob c aus z abgeleitet werden kann} 

{*********************************************************} 


if 

isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],1 

1,10)), 

aktspalte,aktzeile)=true then 

begin; 




10)), 

aktspalte,aktzeile,false)) 

then 

begin; 

kannabgeleitetwerden:=true; 



MinMatCosts:=deltaVW(parentspalte,parentzeile,aktspalte,aktzeile,false); 

end; 


else 



getbuild(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11 

,10)), 

aktspalte,aktzeile)) 

then 

begin; 

kannabgeleitetwerden:=true; 


- 331 -




MinMatCosts:=getbuild(parentspalte,parentzeile,aktspalte,aktzeile); 

end; 


end;//isderivat 

end;//for zahler2 

//Ende Feststellen des Würfels, welcher Materialisert werden soll und woher 

{*********************************************************} 

{Ende 2.2.1. Feststellen des Cubes aus dem der Cube c (zahler) materialisiert wird: 

Dazu kontrolliere alle bereits materialisierten Cubes z (zahler2), 

ob c aus z abgeleitet werden kann} 

{*********************************************************} 

{*********************************************************} 

{2.2.2. Festellen der Derivate und der Abfragekosten 

der Summe der Derivate für den Cube c} 

{*********************************************************} 

Summederiv:=0;//Summe der Werte der Derivate 

for zahler3:=0 to PossibleCubes.Count-1 do begin 

derivspalte:=strtoint(copy(PossibleCubes[zahler3],1,10)); 

derivzeile:=strtoint(copy(PossibleCubes[zahler3],11,10)); 

faktor:=APA[derivspalte,derivzeile].gewicht; 

if APA[derivspalte,derivzeile].interessant=true then begin 

if isderivat(aktspalte,aktzeile,derivspalte,derivzeile)=true then 

//dies ist der Würfel u 

begin; 

//? kann derivat abgeleitet werden? 

kannderivatabgeleitetwerden:=false; 


if parentspalte-1 then 

MinQueryCosts:=deltaVW(parentspalte,parentzeile,aktspalte,aktzeile,false) 

else 

MinQueryCosts:=deltaBftW(aktspalte,aktzeile,false); 

end else 

MinQueryCosts:=getbuild(parentspalte,parentzeile,aktspalte,aktzeile); 

parentderivatspalte:=parentspalte;parentderivatzeile:=parentzeile; 


if 

isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],1 

1,10)), 

derivspalte,derivzeile)=true then 

begin; 


if (MinQueryCosts> 


10)), 

derivspalte,derivzeile,true)) 

then 

begin; 

kannderivatabgeleitetwerden:=true; 

parentderivatzeile:=strtoint(copy(MatCubes[zahler2],11,10)); 

parentderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10)); 

MinQueryCosts:=deltaVW(parentderivatspalte,parentderivatzeile,derivspalte,derivzei 

le,true); 

end; 


else 


- 332 -



if (MinQueryCosts> 

getquery(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11 

,10)), 

derivspalte,derivzeile)) 

then 

begin; 

kannderivatabgeleitetwerden:=true; 

parentderivatzeile:=strtoint(copy(MatCubes[zahler2],11,10)); 

parentderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10)); 

MinQueryCosts:=getquery(parentderivatspalte,parentderivatzeile,derivspalte,derivze 

ile); 

end; 


end; 

end; 

{*********************************************************} 

{2.2.2.1. Berechnen der Verbesserung der Abfragekosten 


{*********************************************************} 

if kannabgeleitetwerden=false then begin 

if kannderivatabgeleitetwerden=false then begin 


Summederiv:=Summederiv+ 

max(0,(deltaBFTw(derivspalte,derivzeile,true)- 

Deltavw(aktspalte,aktzeile,derivspalte,derivzeile,true))) 

*faktor; 


Summederiv:=Summederiv+ 

max(0,(getquery(-1,-1,derivspalte,derivzeile)- 

getquery(aktspalte,aktzeile,derivspalte,derivzeile))) 

*faktor; 

end; 



Summederiv:=Summederiv+max(0, 

(deltaVW(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile,true)- 

Deltavw(aktspalte,aktzeile,derivspalte,derivzeile,true)) 

*faktor); 



(getquery(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile)- 

getquery(aktspalte,aktzeile,derivspalte,derivzeile)) 

*faktor); 

end; 

end; 


//kannabgeleitet werden =true 



(deltaVW(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile,true)- 

Deltavw(aktspalte,aktzeile,derivspalte,derivzeile,true)) 

*faktor); 

end else 

begin 


(getquery(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile)- 

- 333 -



end; 

end; 

getquery(aktspalte,aktzeile,derivspalte,derivzeile)) 

*faktor); 

{*********************************************************} 

{Ende 2.2.2.1. Berechnen der Verbesserung der Abfragekosten 


{*********************************************************} 

end;//of isderivat 

end;//of ist interessant 

end;//of zahler3 

{*********************************************************} 

{Ende 2.2.2. Festellen der Derivate und der Abfragekosten 

der Summe der Derivate für den Cube c} 

{*********************************************************} 

{*********************************************************} 

{2.2.3. Berechnen der Verbesserung der 

Gesamtkosten durch das Materialisieren von c} 

{*********************************************************} 

if kannabgeleitetwerden=false then begin 


//Eintragen des Wertes 

APA[aktspalte,aktzeile].value:=Summederiv- 

DeltaBftw(aktspalte,aktzeile,false); 

APA[aktspalte,aktzeile].value2:=DeltaBftw(aktspalte,aktzeile,false); 

end else 

begin 

//Eintragen des Wertes 

APA[aktspalte,aktzeile].value:=Summederiv-getbuild(-1,- 

1,aktspalte,aktzeile); 

APA[aktspalte,aktzeile].value2:=getbuild(-1,-1,aktspalte,aktzeile); 

end; 



APA[aktspalte,aktzeile].value:=Summederiv- 

DeltaVW(parentspalte,parentzeile,aktspalte,aktzeile,false); 

APA[aktspalte,aktzeile].value2:=DeltaVW(parentspalte,parentzeile,aktspalte,aktzeil 

e,false); 

end else 

begin 

APA[aktspalte,aktzeile].value:=Summederivgetbuild(parentspalte,parentzeile,aktspalte,aktzeile); 

APA[aktspalte,aktzeile].value2:=getbuild(parentspalte,parentzeile,aktspalte,aktzei 

le); 

end; 

end; 

end;//of bereitsmateralisiert 

{*********************************************************} 

{Ende 2.2.3. Berechnen der Verbesserung der 

Gesamtkosten durch das Materialisieren von c} 

{*********************************************************} 

end;//of zahler 

{*********************************************************} 

{2.2.4 Gibt es einen Cube c mit Positivem dK(c) (Kostenersparnis) 

und innerhalb der Limits: True- dann setze den c mit Max(dK(c)) 

dem aktuellen Set zu; False - dann schließe das Set ab} 

{*********************************************************} 

maxvalue:=0; 

nocubefound:=true; 

for zahler:=0 to PossibleCubes.Count-1 do begin 

listbox1.items.Add('Würfel '+PossibleCubes[zahler]); 

- 334 -



listbox1.items.add(floattostr(APA[strtoint(copy(PossibleCubes[zahler],1,10)),strto 

int(copy(PossibleCubes[zahler],11,10))].value)); 

{if APA[strtoint(copy(PossibleCubes[zahler],1,10)), 

strtoint(copy(PossibleCubes[zahler],11,10))].value>maxvalue then begin} 

aktspalte:=strtoint(copy(PossibleCubes[zahler],1,10)); 

aktzeile:=strtoint(copy(PossibleCubes[zahler],11,10)); 

Application.ProcessMessages; 

//Feststellen, ob bereits materialisiert 

bereitsmaterialisiert:=false; 


if PossibleCubes[zahler]=MatCubes[zahler2] then begin; 

bereitsmaterialisiert:=true; 

listbox1.Items.Add('Schon materalisiert'); 

end; 

end; 

//Feststellen, ob in Limits überschritten 

alttimemax:=timemax;altspacemax:=spacemax; 

listbox1.items.Add('Try Cube 


listbox1.items.add('Value: '+floattostr(APA[aktspalte,aktzeile].value)); 










le)); 


timemax:=timemax-APA[aktspalte,aktzeile].value2; 



le)); 

end; 

listbox1.items.add('timemax('+floattostr(timemax)+')'); 

listbox1.items.add('spacemax('+floattostr(spacemax)+')'); 

if (timemaxmaxvalue) 

and(APA[strtoint(copy(PossibleCubes[zahler],1,10)), 

strtoint(copy(PossibleCubes[zahler],11,10))].value>0) then begin 

maxvalue:=APA[strtoint(copy(PossibleCubes[zahler],1,10)), 

- 335 -



strtoint(copy(PossibleCubes[zahler],11,10))].value; 

merkspalte:=strtoint(copy(PossibleCubes[zahler],1,10));//Merken der Spalte des 

neuen Cubes 

merkzeile:=strtoint(copy(PossibleCubes[zahler],11,10));//Merken der Zeile des 

neuen Cubes 

nocubefound:=false; 

listbox1.Items.Add('Maxvalue:'+floattostr(maxvalue)); 

end; 

end; 

{end;} 


if nocubefound=false then begin 

listbox1.items.Add('Materialize Cube 

'+auffuellen(inttostr(merkspalte),10)+auffuellen(inttostr(merkzeile),10)); 

listbox1.items.add('Value: '+floattostr(APA[merkspalte,merkzeile].value)); 

listbox1.items.add('================'); 

//Materialisiere den besten Cube 

MatCubes.Add(auffuellen(inttostr(merkspalte),10)+auffuellen(inttostr(merkzeile),10 

)); 

foundbestcube:=true; 

//Timemax und spacemax berechnen 




1)+(2*gettupel(merkspalte,merkzeile)))+ 

+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(merkspalte,merkzeile)* 

log2(gettupel(merkspalte,merkzeile))+ 

strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(merkspalte,merkzeile) 

); 


(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(merkspalte,merkz 

eile)); 


timemax:=timemax-APA[merkspalte,merkzeile].value2; 


(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(merkspalte,merkz 

eile)); 

end; 

//Entferne aktuell besten Würfel aus der Liste Secondcubes 

zahlersecond2:=0; 

repeat; 

if SecondCubes.count>0 then begin 

if 

(SecondCubes[zahlersecond2]=auffuellen(inttostr(merkspalte),10)+auffuellen(inttost 

r(merkzeile),10)) 

then begin; 

SecondCubes.Delete(zahlersecond2); 

zahlersecond2:=SecondCubes.count; 

end; 

end; 

zahlersecond2:=zahlersecond2+1; 

until (zahlersecond2>SecondCubes.count-1); 

{*********************************************************} 

{2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes, 

welche das Limit erfüllen dann wähle die NewSetsForEachIteration 

besten Cubes und eröffne neue Sets solange bis MaxSets erreicht.} 

{*********************************************************} 

//Erzeuge die neuen Wege, welche noch berechnet werden sollen 

- 336 -



listbox1.items.Add('Try adding '+inttostr(NewSetsforEachIteration)+' new 

Sets'); 

for zahlersecond2:=1 to NewSetsforEachIteration do begin 

merksecondcosts:=0; 

merkepossecond:=-1; 

merkzeilesecond:=-1;merkspaltesecond:=-1; 

for zahlersecond1:=0 to SecondCubes.count-1 do begin; 

//Finde zweitbesten Cube 

if (merkepossecond=- 

1)or(merksecondcosts0) then begin 

//Neuen Weg erzeugen 

if (Setcount0) then begin 

SecondMatCubes[SecondMatCubes.Count-1]:= 

auffuellen(inttostr(merkspaltesecond),10)+auffuellen(inttostr(merkzeilesecond),10) 

; 

listbox1.items.Add('Found '+inttostr(zahlersecond2+1)+' best Cube: 

'+SecondMatCubes[SecondMatCubes.Count-1]); 

if merkepossecond-1 then SecondCubes.Delete(merkepossecond); 

Cube'); 

NewStringList:=TStringList.Create; 

NewStringList.Clear; 

NewStringList.AddStrings(SecondMatCubes); 

MerkMatCubes.Add(NewStringList); 

end//Ende if (SecondMatCubes.Count>0 

else 

listbox1.items.Add('Did not found '+inttostr(zahlersecond2+2)+' best 

end;//Ende if (Setcount0) 

end;//zahlersecond2 

{*********************************************************} 

{Ende 2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes, 

welche das Limit erfüllen dann wähle die NewSetsForEachIteration 

besten Cubes und eröffne neue Sets solange bis MaxSets erreicht.} 

{*********************************************************} 

end else spaceortimelimitreached:=true; 

{*********************************************************} 

{Ende 2.2.4 Gibt es einen Cube c mit Positivem dK(c) (Kostenersparnis) 

und innerhalb der Limits: True- dann setze den c mit Max(dK(c)) 

dem aktuellen Set zu; False - dann schließe das Set ab} 

{*********************************************************} 

end;//of spaceortimelimitreached 

{*********************************************************} 

{Ende 2.2. Beginn der Iteration des aktuellen Sets} 

{*********************************************************} 

{Speichere die MatCubes in der Liste} 

if MatCubes.count>0 then begin 

- 337 -



NewStringLIst:=TStringList.Create; 

NewStringList.Clear; 

NewStringList.AddStrings(MatCubes); 

NewStringList:=getrightOrdertom(NewStringList); 

MerkMatCubesfertig.Add(NewStringList); 

APA_Show_Process.ausgabe(inttostr(Setcounter+2)+' Set found contain cubes '); 

for counter:=0 to MatCubes.Count-1 do begin 

APA_Show_Process.ausgabe('Cube No '+inttostr(counter)+' 

('+inttostr(strtoint(copy(MatCubes[counter],1,10)))+':'+ 

inttostr(strtoint(copy(MatCubes[counter],11,10)))+')'); 

end; 

end; 

end;//of MerkMatCubes 

Setcounter:=Setcounter+1; 

until (Setcounter>=maxSets-1)or(Setcounter>Setcount)or(stop=true);//of wayszahler 

{*********************************************************} 

{Ende 2. Iteration der Sets} 

{*********************************************************} 

APA_Show_Process.ausgabe(inttostr(Setcounter+1)+' Sets are build '); 

APA_Show_Process.ausgabe('Now select the set with lowest costs'); 

{*********************************************************} 

{3. Berechne die Gesamtkosten für jedes Set} 

{*********************************************************} 

{Feststellen des besten Weges} 

{*********************} 

MyReqCubes:=TStringList.Create; 

MyMatCubes:=TStringList.Create; 

try 

//Lege alle nicht redundaten Cubes an, und vergib eine Nummer 



if APA[spalte,zeile].farbe=clYellow then begin 

if APA[spalte,zeile].interessant=true then begin 

//Speichere Required Cubes 

//Merke dir die Required Cubes 

MyReqCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10)); 

end; 

end; 

end;//end of spalte 

end;//end of zeilen 

merkcosts:=-1;merkpos:=-1; 

for zahler:=0 to MerkmatCubesfertig.Count-1 do begin 

NewStringList:=MerkmatCubesfertig.items[zahler]; 

MyMatCubes.Clear; 

MyMatCubes.AddStrings(NewStringList); 

merkcosts2:=berechneKostenGesamt(MyMatCubes,MyReqCubes,true); 

Listbox1.Items.Add(inttostr(zahler)+' Kosten: '+floattostr(merkcosts2)); 

listbox1.Items.Add('******************'); 

APA_Show_Process.ausgabe('Set '+inttostr(zahler+1)+' has costs of 

'+floattostr(merkcosts2)); 

- 338 -



if (merkcosts=-1) or (merkcosts>merkcosts2) then begin 

Listbox1.items.add('Selected'); 

merkpos:=zahler; 

merkcosts:=merkcosts2; 

end; 

end;//Ende zahler 

if MerkmatCubesfertig.count=0 then 

showmessage('The limit is to low. It is not possible to materialize a cube.'); 

finally 

MyReqCubes.Free; 

MyMatCubes.Free; 

end; 

{*********************************************************} 

{Ende 3 Berechne die Gesamtkosten für jedes Set} 

{*********************************************************} 

{*********************************************************} 

{4. Materialisiere jenes Set mit den minimalen Kosten} 

{*********************************************************} 

if (merkpos-1)and(stop=false) then begin 

APA_Show_Process.ausgabe(inttostr(merkpos+1)+' sets minimizes the costs'); 

NewStringList:=MerkMatCubesfertig.items[merkpos]; 

for zahler:=0 to NewStringList.Count-1 do begin 

matcount:=matcount+1; 

end; 

end; 

APA[strtoint(copy(NewStringList[zahler],1,10)),strtoint(copy(NewStringList[zahler] 

,11,10))].materalisieren:=true; 

APA[strtoint(copy(NewStringList[zahler],1,10)),strtoint(copy(NewStringList[zahler] 

,11,10))].matcount:=matcount; 

{*********************************************************} 

{Ende 4 Materialisiere jenes Set mit den minimalen Kosten} 

{*********************************************************} 

finally 

Try 

//Freigeben der Daten 

for zahler:=0 to MerkMatCubes.Count-1 do begin 

NewStringList:=MerkMatCubes[zahler]; 

NewStringList.Free; 

end; 

for zahler:=0 to MerkMatCubesfertig.Count-1 do begin 

NewStringList:=MerkMatCubesfertig[zahler]; 

NewStringList.Free; 

end; 

MerkMatCubes.Free; 

MerkMatCubesfertig.Free; 

MatCubes.Free; 

PossibleCubes.Free; 

except 

end; 

end; 

finally 

APA_Grid.Enabled:=true; 

if APA_Show_Process.Visible=true then 



materialzeichnen; 


showmessage('Ready'); 

- 339 -


end; 

end; 


procedure TAPA_Grid.APAGridClick(Sender: TObject); 


var NewItem: TMenuItem; 

begin 

if (zellespalte-1) and(zellezeile-1) then begin 

klickspalte:=-1; 

klickzeile:=-1; 


((Remove_Redundancy.Checked=true)and(APA[zellespalte,zellezeile].farbe=clYellow)) then 

begin; 

langbezpopup.Items.Clear; 


NewItem:=TMenuItem.Create(self); 

NewItem.Caption:=APA[zellespalte,zellezeile].langbez[counter]; 

langbezpopup.Items.Add(NewItem); 

end; 

langbezpopup.Popup(Mouse.CursorPos.x,Mouse.CursorPos.Y); 

end; 

end; 

end; 

procedure TAPA_Grid.GridpopupPopup(Sender: TObject); 

var g:longint; 

begin 

if ((zellespalte-1)and(zellezeile-1)) 

then begin; 

For g:=0 to Gridpopup.Items.Count-1 do Gridpopup.Items[g].Visible:=true; 

if Showpossiblecubes2.Visible=false then begin 

Showpossiblecubes1.Visible:=false; 

Removepossiblecubes1.Visible:=true; 

end else 

begin 

Showpossiblecubes1.Visible:=true; 

Removepossiblecubes1.Visible:=false; 

end; 

if Showdeterministicsolution2.Visible=false then begin 

Showdeterministicsolution1.Visible:=false; 

Removedeterministicsolution1.Visible:=true; 




end; 

if ((APA[zellespalte,zellezeile].farbe=clYellow)) then 

begin; 

NoCubeselected1.Visible:=false; 

Redundantcube1.Visible:=false; 

Showderivatives1.Visible:=true; 

Showredundancyfreecube1.Visible:=false; 

n3.Visible:=false; 

if APA[zellespalte,zellezeile].interessant=true then begin 

Required1.Visible:=false;Notrequired1.Visible:=true; 

end 

else 

begin 

Required1.Visible:=true;Notrequired1.Visible:=false; 

//Festlegen der Required Spalten 

for g:=0 to Required1.Count-1 do begin 

if g



end; 

Required1.Items[g].Visible:=true; 

Required1.Items[g].Caption:=APA_Parameter.APA_Degrees.Items[g]; 


Required1.Items[g].Visible:=false; 

end; 

end; 

if APA[zellespalte,zellezeile].materalisieren=true then begin 

Materialize1.Visible:=false;Dematerialize1.Visible:=true; 

end 

else 

begin 

Materialize1.Visible:=true;Dematerialize1.Visible:=false; 

end; 


NoCubeselected1.Visible:=false; 

Redundantcube1.Visible:=true;n3.Visible:=true; 

Required1.Visible:=false;Notrequired1.Visible:=false; 

Materialize1.Visible:=false; Dematerialize1.Visible:=false; 

Showderivatives1.Visible:=false; 

Showredundancyfreecube1.Visible:=true; 

end; 


For g:=0 to Gridpopup.Items.Count-1 do Gridpopup.Items[g].Visible:=false; 

NoCubeselected1.Visible:=true; 

end; 

end; 

procedure TAPA_Grid.Removematerializedcubes1Click(Sender: TObject); 

begin 

Button_remove_materialized_cubes.Click; 

end; 

procedure TAPA_Grid.Removederivatives1Click(Sender: TObject); 

begin 

Button_remove_derivatives.Click; 

end; 

procedure TAPA_Grid.Removerequiredcubes1Click(Sender: TObject); 

begin 

Button_remove_required_cubes.Click; 

end; 

procedure TAPA_Grid.Removeredundancy1Click(Sender: TObject); 

begin 

if Remove_Redundancy.Checked=false then 

Remove_Redundancy.Checked:=true else 

Remove_Redundancy.checked:=false; 

Remove_RedundancyClick(self); 

end; 

procedure TAPA_Grid.Button3Click(Sender: TObject); 

var zeile,spalte, aktzeile,aktspalte:longint; 

var x,aktpos,maxpos,anzcube,reqcube, anzderivative,pos,cubepos:longint; 

var zahler, zahler2:longint; 

var istok:boolean; 

var ende:boolean; 

var kostenmerk,Kostenmerkmin:Extended; 

var neustarten, Alwaysspacemaxreached:boolean; 

var Countliste:array of Longint; 

var GeneriereListe,GeneriereReqListe:TStringList; 

begin 

assignfile(fMatCubes,'C:\APADIR\DATA\MatCubes.dat'); 

assignfile(fReqCubes,'C:\APADIR\DATA\ReqCubes.dat'); 


assignfile(fCounter,'C:\APADIR\DATA\Counter.dat'); 


- 341 -





{$i-} 


{$i+} 



Removedeterministicsolution1Click(self); 





GeneriereReqListe:=TStringList.Create(); 

try 

{Rechne alle möglichen Kombinationen durch, welche im Bereich des Maximum sind} 

// Mache das über eine Temporäre Datei auf der Festplatte 

// ist zwar langsamer, aber bei großen Rechnungen hängt sich der Rechner nicht auf. 


APA_Dialog.APA_Text.Caption:='Do you want to restart?'; 

if permutation=true then begin 

if APA_Dialog.showmodal=mryes then 

neustarten:=true else neustarten:=false; 

end else neustarten:=true; 

{1. Vorbereitungen für die Permutation} 

aktpos:=0;permutation:=true; 

if neustarten=true then begin; 

alwaysspacemaxreached:=false; 

{$i-} 

rewrite(fCubes); 

{$i+} 

if ioresult0 then begin; showmessage('Cubes database error ');exit;end; 

{$i-} 

rewrite(fReqCubes); 

{$i+} 

if ioresult0 then begin; showmessage('ReqCubes database error ');exit;end; 

{$i-} 

rewrite(fCounter); 

{$i+} 

if ioresult0 then begin; showmessage('Counter database error ');exit;end; 

{$i-} 

rewrite(fMerkkosten); 

{$i+} 


try 


vMerkkosten.Lfnr:=0; 

vMerkkosten.Kosten:=0; 

write(fMerkkosten,vMerkkosten); 

APA_Show_Process.ausgabe('Search for possible cubes...'); 

anzcube:=0; reqcube:=0; 





if APA[spalte,zeile].interessant=True then begin 

anzcube:=anzcube+1; 

seek(fCubes,anzcube-1); 

- 342 -



vCubes.Lfnr:=anzcube; 

vCubes.Spalte:=spalte; 

vCubes.Zeile:=zeile; 

vCubes.Required:=1; 

write(fCubes,vCubes); 

APA_Show_Process.ausgabe('Add Cube: 

('+inttostr(spalte)+':'+inttostr(zeile)+')'); 


anzderivative:=0; 



if (APA[aktspalte,aktzeile].farbe=clYellow)and 

(APA[aktspalte,aktzeile].interessant=true) then begin 

if isderivat(spalte,zeile,aktspalte,aktzeile) then begin 

anzderivative:=anzderivative+1; 

end; 

end; 

end; 

end; 

if anzderivative>0 then begin 










end; 

end; 




reqcube:=reqcube+1; 

seek(fReqCubes,reqcube-1); 

vReqCubes.Lfnr:=reqcube; 

vReqCubes.Spalte:=spalte; 

vReqCubes.Zeile:=zeile; 

write(fReqCubes,vReqCubes); 

end; 

end; 



finally 


CloseFile(fReqCubes); 

CloseFile(fCounter); 


end; 

end//von neustarten 

else begin 


end; 

try 

{$i-} 


{$i+} 


anzcube:=filesize(fCubes); 

Setlength(Countliste,anzcube); 

MemoryCubes:=nil; 

- 343 -



setlength(MemoryCubes,anzcube); 

pos:=0; 

repeat; 

if (filesize(fCubes)>0) then begin 

seek(fCubes,pos); 


x:=round(vCubes.lfnr)-1; 

Memorycubes[x].nr:=round(vCubes.lfnr); 

Memorycubes[x].spalte:=vCubes.Spalte; 

Memorycubes[x].zeile:=vCubes.Zeile; 

end; 

pos:=pos+1; 

until pos>=filesize(fCubes); 

{$i-} 

reset(fReqCubes); 

{$i+} 


try 

MemoryreqCubes:=nil; 

setlength(MemoryReqCubes,filesize(fReqCubes)); 

MemoryReqCubescount:=filesize(fReqCubes); 

pos:=0; 

repeat; 

if (filesize(fReqCubes)>0) then begin 

seek(fReqCubes,pos); 

read(fReqCubes,vReqCubes); 

x:=round(vReqCubes.Lfnr)-1; 

MemoryReqCubes[x].spalte:=vReqCubes.Spalte; 

MemoryReqCubes[x].zeile:=vReqCubes.Zeile; 

end; 

pos:=pos+1; 

until (pos>=filesize(fReqCubes)); 

for x:=0 to MemoryReqCubescount-1 do begin 

GeneriereReqListe.Add(auffuellen(inttostr(MemoryReqCubes[x].spalte),10)+auffuellen 

(inttostr(MemoryReqCubes[x].zeile),10)); 

end; 

APA_Show_Process.ausgabe(inttostr(anzcube)+' Cubes found'); 

finally 


end; 

finally 


end; 

Countliste:=nil; 

Setlength(Countliste,anzcube+1); 

MerkeListe:=nil; 

SetLength(Merkeliste,anzcube); 

if neustarten=true then begin 

//Zuerst alle 0 setzten 

for x:=0 to anzcube-1 do Countliste[x]:=0; 

maxpos:=0; 

Countliste[0]:=1; 

cubepos:=Countliste[0]; 

kostenmerkmin:=0; 

end// of neustarten 

else begin 


- 344 -


try 


//Laden der Cubes 

{$i-} 

reset(fCounter); 

{$i+} 


maxpos:=-1;pos:=0; 

repeat; 

if (filesize(fCounter)>0) then begin 

seek(fCounter,pos); 

read(fCounter,vCounter); 

if vcounter.Lfnr-1 then begin 

maxpos:=maxpos+1; 

x:=round(vCounter.Lfnr); 

Countliste[x]:=round(vCounter.nr); 

if countliste[x]=0 then countliste[x]:=1; 

end; 


//Feststellen von alwaysspacemaxreached 

if vcounter.nr=1 then 

alwaysspacemaxreached:=true else 


end; 

pos:=pos+1; 

until pos>=filesize(fCounter); 

cubepos:=Countliste[0] 

finally 


end; 

end; 

{$i-} 


{$i+} 

if ioresult0 then begin; showmessage('Merkkosten database error ');exit;end; 

try 

seek(fMerkkosten,0);read(fMerkkosten,vMerkkosten); 

kostenmerkmin:=vMerkkosten.Kosten; 

finally 


end; 

{Ende 1. Vorbereitungen für die Permutation} 

if anzcube>0 then begin 

//Kombinatorik 



aktpos:=0;maxpos:=0; 

end//neustarten 

else APA_Show_Process.ausgabe('*** Start Restart ***'); 

{2. Beginn der Permutationsschleife} 

ende:=false; 

while (ende=false)and (stop=false) do begin 

repeat; 

Application.processmessages; 

if APA_Show_Process.GroupBox1.tag=1 then begin 

APA_Show_Process.GroupBox1.tag:=0; 

//Geheimticker 

for x:=0 to maxpos do begin 

- 345 -



countliste[x]:=1; 

end; 

maxpos:=maxpos+1; 

countliste[maxpos]:=1; 

end; 

if APA_Show_Process.GroupBox1.tag=-1 then begin 



countliste[maxpos]:=0; 

maxpos:=maxpos-1; 


countliste[x]:=1; 

end; 

end; 

//Hüpfe nach links, wenn möglich 

// ausser bei Cube max dann nach rechts 

if cubepos>anzcube then begin 

//Hüpfe nach rechts 

//Speichere aktuelle Pos 

cubepos:=1; 

Countliste[aktpos]:=cubepos; 

aktpos:=aktpos+1; 

if aktpos>maxpos then maxpos:=aktpos; 

if aktposanzcube then begin 

cubepos:=1; 



if aktpos>maxpos then maxpos:=aktpos; 

end; 

if Countliste[aktpos]=0 then begin 

//Neue Zählung 

if (alwaysspacemaxreached=true)and(Alwaysspacemaxbeachten1.Checked=true) then 

ende:=true; 

cubepos:=1; 




//Springe auf gespeicherte Position 

Countliste[aktpos]:=Countliste[aktpos]+1; 

cubepos:=Countliste[aktpos]; 

end; 

until (cubepos50000 then 

APA_Show_Process.APA_Protocoll.Items.Clear; 

if stop=true then stop:=false; 

//Hier soll nicht abgebrochen werden 

end//von



//Es wird von der Position bis zum Ende kontrolliert 

//da die ersten Positionen schon verglichen wurden 

for zahler2:=zahler to maxpos do begin 

if ((zahler2zahler)and 

(Countliste[zahler2]=Countliste[zahler])) 

then 

istok:=false; 

end; 

end; 

if istok=true then begin 

//Speichern 

//Stelle fest ob spacemax erfüllt. 

//Wenn ja berechne Kosten 

spaceleftfirstcubes:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text); 

spaceleft:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text); 


APA_Show_Process.ausgabe(' '+inttostr(countliste[x])); 

if countliste[x]>0 then begin 

spaceleft:=spaceleft- 

(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(MemoryCubes[Coun 

tliste[x]-1].spalte,MemoryCubes[Countliste[x]-1].zeile)); 

if x0 then begin 

//Rechne den Speicherplatz ohne die letzte Ebene aus. 

//Wenn dieser überschritten kann der durchlauf der letzten Ebene gestoppt werden 

spaceleftfirstcubes:=spaceleftfirstcubes- 



end; 

end; 

end;//Ende von x 

//Wenn überschritten setzt den Zähler der ersten auf max 

if (spaceleftfirstcubes0 then begin 

GeneriereListe:=TStringList.create(); 

try 


if countliste[x]>0 then begin 

GeneriereListe.Add(auffuellen(inttostr(MemoryCubes[countliste[x]- 

1].spalte),10)+auffuellen(inttostr(MemoryCubes[countliste[x]-1].zeile),10)); 

end; 

end; 

kostenmerk:=berechneKostenGesamt(GeneriereListe,GeneriereReqListe,true); 

finally 

GeneriereListe.Free; 

end; 

if kostenmerk>0 then begin 

- 347 -



if(kostenmerkmin=0)or(kostenmerkmin>kostenmerk) 

then begin; 

Alwaysspacemaxreached:=false; 

{$i-} 


{$i+} 


try 

APA_Show_Process.ausgabe('*****************'); 

APA_Show_Process.ausgabe('Trage ein das Minimum '+floattostr(kostenmerk)); 

vMerkkosten.Kosten:=kostenmerk; 


seek(fMerkkosten,0);write(fMerkkosten,vMerkkosten); 

kostenmerkmin:=kostenmerk; 



vMerkkosten.Kosten:=spaceleft; 




vMerkkosten.Kosten:=timeleft; 


finally 


end; 

//Speichere Counttable 

assignfile(fCountermerk,'c:\APADIR\DATA\Countermerk.dat'); 

{$i-} 

rewrite(fCountermerk); 

{$i+} 


try 


seek(fCountermerk,filesize(fCountermerk)); 

vCountermerk.Lfnr:=x; 

vCountermerk.Nr:=Countliste[x]; 

write(fCountermerk,vCountermerk); 

APA_Show_Process.ausgabe('Save Cube Pos:'+floattostr(vCountermerk.Lfnr)+' 

Nr:'+floattostr(vCountermerk.Nr)); 

end; 

finally 

CloseFile(Fcountermerk); 

end; 

end; 

end else APA_Show_Process.ausgabe('Ist O '); 

end// spaceleft>0 

else APA_Show_Process.ausgabe('spacemax reached '); 

end;//of istok 

cubepos:=cubepos+1; 


end;//Ende von links 

repeat; Application.ProcessMessages; until break=false; 

if (stop=true) and (aktpos0) then stop:=false; 

//Nur in der aktpos stoppen 

until (cubepos>anzcube)or (stop=true); 

if (stop=true) and (aktpos0) then stop:=false; 

//Nur in der aktpos stoppen 

end;//ende=true; 

- 348 -



{Ende 2. Beginn der Permutationsschleife} 

//Speichern des aktuellen Cubeliste damit man wieder weiter machen kann. 

//speichere aktuelle Position 

assignfile(fCounter,'c:\APADIR\DATA\Counter.dat'); 

{$i-} 


{$i+} 

if ioresult0 then showmessage('Can not open File Counter.dat'); 

try 

seek(fCounter,0); 

vCounter.Lfnr:=-1; 


if alwaysspacemaxreached=true then vcounter.Nr:=1 

else vcounter.Nr:=0; 

write(fCounter,vCounter); 


seek(fCounter,x+1); 

vCounter.Lfnr:=x; 

vCounter.Nr:=Countliste[x]; 


end; 

finally 

CloseFile(fcounter); 

end; 

end;// Wenn es mindestens einen Cube gibt in der Cubeliste 

end;//with Apa_Application 

finally 


GeneriereReqListe.Free; 

Showmessage('Ready'); 


end; 

end; 

procedure TAPA_Grid.Algorithm1Click(Sender: TObject); 

begin 

if permutation=true then begin 

Button3.click; 


APA_Dialog.APA_Text.Caption:='Your last deterministic run was not a permutation. Do 

you want do continue? This will delete your last run!'; 

end; 

end; 


Button3.Click; 

end; 

procedure TAPA_Grid.SearchusingThomasAchsheuristic2Click(Sender: TObject); 

begin 


end; 

procedure TAPA_Grid.Alogrithm1Click(Sender: TObject); 

begin 


end; 

procedure TAPA_Grid.Parameter1Click(Sender: TObject); 

begin 

APA_Parameter.ShowModal; 

end; 

function TAPA_Grid.berechneKostenGesamt(MatCubes,ReqCubes:TStringList; 

Nullstellen:boolean):Extended; 

var x,aktspalte,aktzeile:longint; 

var SummeKosten:Extended; 

- 349 -



var zahler,counter:longint; 

var newcosts:Extended; 

var new:String; 

var isderivatof:boolean; 

var newminderivatspalte,newminderivatzeile:longint; 


begin 

// Berechne die Materialisierungskosten 


timeleft:=strtofloat(APA_Parameter.APA_Thomas_timemax.text); 

Memorywuerfel:= TStringList.Create; //Erzeuge die Liste der ausgewählten Würfel 

SummeKosten:=0; 

try 

for x:=0 to MatCubes.count-1 do begin 

aktspalte:=strtoint(copy(MatCubes[x],1,10)); 

aktzeile:=strtoint(copy(MatCubes[x],11,10)); 



le)); 


if (spaceleft>0) then begin 

//2. Kosten der Kombination berechnen 

SummeKosten:=0; 

//2A Ersten Würfel zusetzen 

aktspalte:=strtoint(copy(MatCubes[0],1,10)); 

aktzeile:=strtoint(copy(MatCubes[0],11,10)); 

if (Userandomcosts1.Checked=true) then begin 

newcosts:=getbuild(-1,-1,aktspalte,aktzeile); 


newcosts:=deltaBftW(aktspalte,aktzeile,false); 

end; 

SummeKosten:=SummeKosten+newcosts; 

new:=auffuellen(inttostr(aktspalte),30); 

new:=new+auffuellen(inttostr(aktzeile),30); 

Memorywuerfel.Add(new); 

listbox1.Items.Add('Add '+new+' build from BFT'); 

listbox1.Items.Add('that costs '+floattostr(newcosts)); 

timeleft:=timeleft-newcosts; 

//Erster Würfel zugesetzt Ende 

//2B Zusätzlich Würfel zusetzen 

for x:=1 to MatCubes.count-1 do begin 

aktspalte:=strtoint(copy(MatCubes[x],1,10)); 

aktzeile:=strtoint(copy(MatCubes[x],11,10)); 

//? Kann der neue Würfel aus einem bereits materialisierten Würfel abgeleitet 

werden? 


for counter:=0 to Memorywuerfel.count-1 do begin 


if 

isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)), 

aktspalte,aktzeile) then begin; 


end; 

end; 

if isderivatof=true then begin 

//Yes leite aus diesem Würfel ab 

newminderivatspalte:=GetMinDerivatOfSpalte(aktspalte,aktzeile,false); 

newminderivatzeile:=GetMinDerivatOfZeile(aktspalte,aktzeile,false); 

- 350 -




newcosts:=getbuild(newminderivatspalte,newminderivatzeile, 

aktspalte,aktzeile); 


newcosts:=deltaVW(newminderivatspalte,newminderivatzeile, 

aktspalte,aktzeile,false); 

end; 




listbox1.Items.Add('Add '+new+' build from ('+ 

inttostr(newminderivatspalte)+':'+ 

inttostr(newminderivatzeile)+')'); 

listbox1.Items.Add('that costs '+ 

floattostr(newcosts)); 


if Userandomcosts1.Checked=true then begin 


end else 

begin 

timeleft:=timeleft- 

(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(newminderivatspalte,ne 

wminderivatzeile)+(2*gettupel(aktspalte,aktzeile)))+ 




end; 


//No leite aus dem BFT ab 


newcosts:=getbuild(-1,-1,aktspalte,aktzeile); 


newcosts:=deltaBftW(aktspalte,aktzeile,false); 

end; 




listbox1.Items.Add('Add '+new+' build from BFT'); 



if Userandomcosts1.Checked=true then begin 



timeleft:=timeleft-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(- 

1,-1)+(2*gettupel(aktspalte,aktzeile)))+ 




end; 

end; 


Listbox1.Items.Add('Die Würfel sind'); 


Listbox1.Items.add(Memorywuerfel[counter]); 

end; 

{zahler:=0; EntferneausDiss 

repeat; 

If MatCubes.count>zahler then begin 

//Merke Ausgangscube 

merkcube:=zahler; 

merkspalte:=strtoint(copy(MatCubes[zahler],1,10)); 

merkzeile:=strtoint(copy(MatCubes[zahler],11,10)); 

- 351 -



//Kontrolliere alle Vorgänger des aktuellen Cube 

zahler2:=0; 

merkderivat:=-1;merkderivatspalte:=-1;merkderivatzeile:=-1; 

repeat; 

if (MatCubes.count>zahler2) then begin 

if 

((strtoint(copy(MatCubes[zahler2],1,10))merkspalte)or(strtoint(copy(MatCubes[zah 

ler2],11,10))merkzeile)) 

and(merkcube>zahler2)//Verhindert, dass nur Cubes, welche früher mat. wurden 

beachtet werden 

then begin 

if 

(isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2], 

11,10)), 

merkspalte,merkzeile)=true) 

then begin; 

//Wenn kosten kleiner als bereits gemerkter dann merken 


if (merkderivat=-1) or ( 

(getbuild(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],1 

1,10)), 

merkspalte,merkzeile)< 

getbuild(merkderivatspalte,merkderivatzeile,merkspalte,merkzeile))) 

then begin 

merkderivat:=zahler2; 

merkderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10)); 

merkderivatzeile:= strtoint(copy(MatCubes[zahler2],11,10)); 

end; 


if (merkderivat=-1) or ( 

(deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11 

,10)), 

merkspalte,merkzeile,false)< 

deltaVW(merkderivatspalte,merkderivatzeile,merkspalte,merkzeile,false))) 

then begin 




end; 

end; 

end; 

end;//spaltespalte oder zeilezeile 

end; //Lfnr 

zahler2:=zahler2+1; 

until (zahler2>MatCubes.count-1)or(zahler2=merkcube); 

//Wenn derivat vorhanden erzeuge aus dem Derivat sonst aus BFT 

if merkderivat-1 then begin 


merkcosts:=getbuild(merkderivatspalte,merkderivatzeile,strtoint(copy(MatCubes[zahl 

er],1,10)),strtoint(copy(MatCubes[zahler],11,10))); 


merkcosts:=deltaVW(merkderivatspalte,merkderivatzeile,strtoint(copy(MatCubes[zahle 

r],1,10)),strtoint(copy(MatCubes[zahler],11,10)),false); 

end; 

SummeKosten:=SummeKosten+merkcosts; 

listbox1.Items.Add('Add 

'+inttostr(strtoint(copy(MatCubes[zahler],1,10)))+':'+inttostr(strtoint(copy(MatCu 

bes[zahler],11,10)))+' erzeugt aus '+ 

inttostr(merkderivatspalte)+':'+inttostr(merkderivatzeile)); 

listbox1.Items.Add('costs are '+floattostr(merkcosts)); 

//Berechne spaceleft und timeleft 

- 352 -




timeleft:=timeleft-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)* 

(gettupel(-1,- 

1)+(2*gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler 

],11,10)))))+ 

+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)* 

gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1 

0))) 

*log2(gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler 

],11,10))))+ 

strtofloat(APA_Parameter.APA_Thomas_timestore.Text)* 


0)))); 


(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)* 


0)))); 



merkcosts; 




0)))); 

end; 



merkcosts:=getbuild(-1,- 

1,strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,10))); 


merkcosts:=deltaBftW(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[ 

zahler],11,10)),false); 

end; 

SummeKosten:=SummeKosten+merkcosts; 

listbox1.Items.Add('Add 

'+inttostr(strtoint(copy(MatCubes[zahler],1,10)))+':'+inttostr(strtoint(copy(MatCu 

bes[zahler],11,10)))+' erzeugt aus '+ 

inttostr(-1)+':'+inttostr(-1)); 

listbox1.Items.Add('costs are '+floattostr(merkcosts)); 


timeleft:=timeleft-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)* 

(gettupel(-1,- 

1)+(2*gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler 

],11,10)))))+ 

+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)* 


0))) 

*log2(gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler 

],11,10))))+ 

strtofloat(APA_Parameter.APA_Thomas_timestore.Text)* 

- 353 -




0)))); 




0)))); 



merkcosts; 




0)))); 

end; 

end; 

end; 

zahler:=zahler+1; 

until (zahler>MatCubes.count-1);} 

//3. Berechne die Abfragekosten 

{zahler:=0; //Zahler für ReqCubes 

repeat; 

if (zahler



deltaVW(merkderivatspalte,merkderivatzeile,strtoint(copy(ReqCubes[zahler],1,10)),s 

trtoint(copy(ReqCubes[zahler],11,10)),false))) 

then begin 

end; 

end; 

end; 




end; 


until (zahler2>MatCubes.count-1); 

aktspalte:=strtoint(copy(ReqCubes[zahler],1,10)); 

aktzeile:=strtoint(copy(ReqCubes[zahler],11,10)); 

if merkderivat=-1 then begin 

//Erzeuge aus BFT 


SummeKosten:=SummeKosten+ 

(getquery(-1,-1,aktspalte,aktzeile)* 

APA[aktspalte,aktzeile].gewicht); 

listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+' 

erzeugt aus '+ 


listbox1.Items.Add('costs are '+floattostr((getquery(-1,- 

1,aktspalte,aktzeile)* 

APA[aktspalte,aktzeile].gewicht))); 



(deltaBftW(aktspalte,aktzeile,true)* 


listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+' 

erzeugt aus '+ 


listbox1.Items.Add('costs are 

'+floattostr((deltaBftW(aktspalte,aktzeile,true)* 


end; 


//Erzeuge aus dem Derivat 



(getquery(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile)* 


end; 

end; 

listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+' erzeugt 

aus '+ 



'+floattostr((getquery(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile)* 




(deltaVW(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile,true)* 


listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+' erzeugt 

aus '+ 



'+floattostr((deltaVW(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile,true)* 


end; 

- 355 -




until (zahler>ReqCubes.count-1); } 

{3.Zusetzen der Querykosten} 

for zahler:=0 to ReqCubes.count-1 do begin; 

spalte:=strtoint(copy(ReqCubes[zahler],1,10)); 

zeile:=strtoint(copy(ReqCubes[zahler],11,10)); 




if 

isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)), 

spalte,zeile) then begin; 


end; 

end; 

if isderivatof=true then begin 

newminderivatspalte:=GetMinDerivatOfSpalte(spalte,zeile,true); 

newminderivatzeile:=GetMinDerivatOfZeile(spalte,zeile,true); 


newcosts:= ((getquery(newminderivatspalte,newminderivatzeile, 

spalte,zeile)) 

*APA[spalte,zeile].gewicht); 


newcosts:= ((deltaVW(newminderivatspalte,newminderivatzeile, 

spalte,zeile,true)) 


end; 


listbox1.Items.Add('Reqcosts ('+inttostr(spalte)+':'+inttostr(zeile)+')'); 

Listbox1.items.add('Query from ('+inttostr(newminderivatspalte)+':'+ 

inttostr(newminderivatzeile)+')'); 




newcosts:=((getquery(-1,-1,spalte,zeile)) 



newcosts:=((deltaBftW(spalte,zeile,true)) 


end; 

SummeKosten:=SummeKosten+ newcosts; 

listbox1.Items.Add('Reqcosts ('+inttostr(spalte)+':'+inttostr(zeile)+')'); 

Listbox1.Items.Add('Query from BFT'); 


end; 


if (timeleft0 

finally 

Result:=SummeKosten; 

Memorywuerfel.free; 

end; 

end; 

procedure TAPA_Grid.Showcosts1Click(Sender: TObject); 

- 356 -



var zeile,spalte, zahler:longint; 

var MatCubes,ReqCubes, MatCubesSorted:TStringList; 

var merkeRandom:boolean; 

begin 

if matcount>0 then begin 

//Berechne die Kosten der aktuellen Materialsierung 

//auf der Basis der Zufallskosten 

//Nur getbuild 


{$i-} 


{$i+} 


Listbox1.Items.Add(''); 

Listbox1.Items.Add('Berechne Kosten'); 

Listbox1.Items.Add(''); 

ReqCubes:=TStringList.Create; 

ReqCubes.Clear; 

MatCubes:=TStringList.Create; 

MatCubes.Clear; 

MatCubesSorted:=TStringList.Create; 

MatCubesSorted.Clear; 

merkerandom:=Userandomcosts1.Checked; 

Userandomcosts1.Checked:=true; 

try 








ReqCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10)); 

end; 


//Speichere Mat Cubes 

//Merke dir die MatCubes 

MatCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));; 

end; 

end; 



for zahler:=0 to MatCubes.count-1 do MatCubesSorted.Add('free'); 

for zahler:=0 to MatCubes.Count-1 do begin 

MatCubesSorted[APA[strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler], 

11,10))].matcount-1]:= 

MatCubes[zahler]; 

end; 

showmessage('Costs: '+floattostr(berechneKostenGesamt(MatCubesSorted,ReqCubes,false))+'; 

Time left: '+ 

floattostr(timeleft)+'; Space left: '+floattostr(spaceleft)); 

finally 


ReqCubes.Free; 

MatCubesSorted.Free; 

Userandomcosts1.Checked:=merkerandom; 

- 357 -




end; 

end //of matcount 

else showmessage('No materialized cubes selected'); 

end; 

function TAPA_Grid.GetRightOrdertom(Listecubes:TStringList):TStringList; 

type Knotendeklationszeiger= ^Knotendeklaration; 

Knotendeklaration = 

record 

Knoten:longint; 



MaxAbstand:Extended; 

Parent:longint; 

end; 

var Knoten, Knoten2, Knoten3 , Knotenmerk:Knotendeklationszeiger; 

var Innere_Knoten, Randknoten:TList; 

var zahler, zahler2, zahler3, zahlermerk:longint; 

var costmerk, Kostengewinn:Extended; 

var {Parent,} Parentvonderivat:longint; 

var {parentcostmerk,} Parentvonderivatcostmerk:Extended; 

begin 

//Erzeuge alle Randknoten und fülle sie mit den Kosten 

Randknoten:= TList.Create; 

Innere_Knoten:=TList.Create; 

try 

for zahler:=0 to Listecubes.Count-1 do begin 

//Berechne Maxabstand 

//Der Maxabstand ist die Kostenverbesserung der Materialisierung der Derivate von 

New(Knoten) 

//welche noch nicht materialisiert worden sind. 


for zahler2:=0 to Listecubes.count-1 do begin 

if 

(isderivat(strtoint(copy(Listecubes[zahler],1,10)),strtoint(copy(Listecubes[zahler 

],11,10)), 

strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler2],11,10)) 

)=true) then begin 


Kostengewinn:=Kostengewinn+max(0, 

(//Da noch kein Würfel materialisiert wurde werden alle vom BFT 

erzeugt 

getbuild(-1,- 

1,strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler2],11,10 

)) 

) 

- 

getbuild( 

strtoint(copy(Listecubes[zahler],1,10)),strtoint(copy(Listecubes[zahler],11,10)), 


) 

) 

); 


Kostengewinn:=Kostengewinn+max(0, 

(//Da noch kein Würfel materialisiert wurde werden alle vom BFT 

erzeugt 

deltaBftW(strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler 

2],11,10)),false 

) 

- 

deltaVW( 

- 358 -


end; 


strtoint(copy(Listecubes[zahler],1,10)),strtoint(copy(Listecubes[zahler],11,10)), 


,false 

) 

) 

); 

end; 

end; 

New(Knoten); 

Knoten^.Knoten:=zahler; 

Knoten^.MaxAbstand:=Kostengewinn; 

Knoten^.Parent:=-1; 

Knoten^.spalte:= strtoint(copy(Listecubes[zahler],1,10)); 

Knoten^.zeile:=strtoint(copy(Listecubes[zahler],11,10)); 

Randknoten.Add(Knoten); 

end; 

//Erzeuge Randknoten Ende 

repeat;//So lange durchlaufen, bis die Menge der Randknoten leer 

//Finde den Würfel mit dem Minimalen Abstand und setze diesen zu inneren Würfeln zu 

zahlermerk:=-1;costmerk:=0; 

for zahler:=0 to Randknoten.Count-1 do begin 

Knoten:= Randknoten.Items[zahler]; 

if (Knoten^.MaxAbstand>costmerk) or(zahlermerk=-1) then begin 

zahlermerk:=zahler; 

costmerk:=Knoten^.MaxAbstand; 

end; 

end; 

//Zusetzen des Würfels zu Inneren Knoten 

Knotenmerk:=Randknoten.Items[zahlermerk]; 

Innere_Knoten.Add(Knotenmerk); 

Randknoten.Delete(zahlermerk); 

if Randknoten.Count>0 then begin 

//Berechne die Kosten neu 

//Stelle fest, ob die Randknoten derivate von dem neuen Inneren Knoten sind. 

//Wenn ja und die Kosten sind geringer als die vom BFT dann ändere Kosten 

//Ist jedoch der neue Cube ein Derivat von dem Randknoten müssen die Kosten neu 

berechnet werden 


Knoten:=Randknoten.Items[zahler]; 

if 

(isderivat(Knotenmerk^.spalte,Knotenmerk^.zeile,Knoten^.spalte,Knoten^.zeile)=true 

) 

or 

(isderivat(Knoten^.spalte,Knoten^.zeile,Knotenmerk^.spalte,Knotenmerk^.zeile)=true 

) 

then begin 


//Berechne die Derivate 

//Durchlaufe alle Randknoten 

for zahler2:=0 to Randknoten.Count-1 do begin 

Knoten2:=Randknoten.Items[zahler2]; 

//Stelle fest, ob dieser Randknoten ein Derivat ist 

if 

(isderivat(Knoten^.spalte,Knoten^.zeile,Knoten2^.spalte,Knoten2.zeile)=true) 

and(Knoten^.KnotenKnoten2^.Knoten) 

then begin 

- 359 -



//Finde das Kostenminimale Parent von Knoten2 

Parentvonderivat:=-1; 


Parentvonderivatcostmerk:=getbuild(-1,-1,Knoten2.spalte,Knoten2^.zeile); 


Parentvonderivatcostmerk:=deltaBftW(Knoten2.spalte,Knoten2^.zeile,false); 

end; 

for zahler3:=0 to Innere_Knoten.count-1 do begin 

Knoten3:=Innere_Knoten.Items[zahler3]; 

if 

(isderivat(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile)=true) 

and(Knoten3^.KnotenKnotenmerk^.Knoten)and(Knoten3^.KnotenKnotenmerk^.Knoten) 

then begin 


costmerk:=getbuild(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile); 


costmerk:=deltaVW(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile,fa 

lse); 

end; 

if (costmerk



end;//Ende von Derivat oder Parent 

end; 

end;//Randknoten.count>0 

until Randknoten.Count=0;//So lange durchlaufen, bis die Menge der Randknoten leer ENDE 

finally 

Listecubes.Clear; 

for zahler:=0 to Innere_Knoten.Count-1 do begin 

Knoten:=Innere_Knoten.Items[zahler]; 

Listecubes.Add(auffuellen(inttostr(Knoten^.spalte),10)+auffuellen(inttostr(Knoten^ 

.zeile),10)); 

dispose(Knoten); 

end; 


Knoten:=Innere_Knoten.Items[zahler]; 

dispose(Knoten); 

end; 

Innere_Knoten.free; 

Randknoten.free; 

Result:=Listecubes; 

end; 

end; 


var zeile,spalte,aktzeile,aktspalte,anzderivative:longint; 

var x,aktpos,lang,anzcube,reqcube,pos:longint; 


var seqcounter:Extended; 

var istok:boolean; 

var ende:boolean; 

var kostenmerk,kostenmerkmin:Extended; 

var neustarten:boolean; 

var Countliste:array of Longint; 

var neuespalte:boolean; 

var alwaysspacemaxreached, geladen:boolean; 

var st:string; 

var GeneriereListe, GeneriereReqListe:TStringList; 

begin 

assignfile(fMatCubes,'C:\APADIR\DATA\MatCubes.dat'); 

assignfile(fReqCubes,'C:\APADIR\DATA\ReqCubes.dat'); 


assignfile(fCounter,'C:\APADIR\DATA\Counter.dat'); 






{$i-} 


{$i+} 



GeneriereReqListe:=TStringList.create(); 

try 

{Rechne alle möglichen Kombinationen durch, welche im Bereich des Maximum sind} 

// Mache das über eine Temporäre Datei auf der Festplatte 

// ist zwar langsamer, aber bei großen Rechnungen hängt sich der Rechner nicht auf. 

- 361 -




APA_Dialog.APA_Text.Caption:='Do you want to restart?'; 

if permutation=false then begin 


neustarten:=true else neustarten:=false; 

end else neustarten:=true; 

Permutation:=false; 

lang:=0;alwaysspacemaxreached:=false;seqcounter:=0; 




if neustarten=true then begin; 

APA_Show_Process.ausgabe('Clear Tables ...'); 

{$i-} 

rewrite(fCubes); 

{$i+} 


{$i-} 

rewrite(fReqCubes); 

{$i+} 


{$i-} 


{$i+} 

if ioresult0 then begin; showmessage('Counter database error ');exit;end; 

{$i-} 

rewrite(fMerkkosten); 

{$i+} 


try 



vMerkkosten.Kosten:=0; 


APA_Show_Process.ausgabe('Search for possible cubes...'); 

anzcube:=0; reqcube:=0; 





if APA[spalte,zeile].interessant=True then begin 











anzderivative:=0; 



if (APA[aktspalte,aktzeile].farbe=clYellow)and 

(APA[aktspalte,aktzeile].interessant=true) then begin 

if isderivat(spalte,zeile,aktspalte,aktzeile) then begin 

anzderivative:=anzderivative+1; 

end; 

end; 

end; 

- 362 -



end; 

if anzderivative>0 then begin 










end; 

end; 




reqcube:=reqcube+1; 

seek(fReqCubes,reqcube-1); 

vReqCubes.Lfnr:=reqcube; 

vReqCubes.Spalte:=spalte; 

vReqCubes.Zeile:=zeile; 

write(fReqCubes,vReqCubes); 

end; 

end; 



finally 





end; 

end;//von neustarten 

try 

{$i-} 


{$i+} 


anzcube:=filesize(fCubes); 

Setlength(Countliste,anzcube); 

MemoryCubes:=nil; 

setlength(MemoryCubes,anzcube); 

pos:=0; 

repeat; 

if (filesize(fCubes)>0) then begin 

seek(fCubes,pos); 


x:=round(vCubes.lfnr)-1; 

Memorycubes[x].nr:=round(vCubes.lfnr); 

Memorycubes[x].spalte:=vCubes.Spalte; 

Memorycubes[x].zeile:=vCubes.Zeile; 

end; 

pos:=pos+1; 

until pos>=filesize(fCubes); 

{$i-} 

reset(fReqCubes); 

{$i+} 


try 

MemoryreqCubes:=nil; 

setlength(MemoryReqCubes,filesize(fReqCubes)); 

- 363 -



MemoryReqCubescount:=filesize(fReqCubes); 

pos:=0; 

repeat; 

if (filesize(fReqCubes)>0) then begin 

seek(fReqCubes,pos); 

read(fReqCubes,vReqCubes); 

x:=round(vReqCubes.Lfnr)-1; 

MemoryReqCubes[x].spalte:=vReqCubes.Spalte; 

MemoryReqCubes[x].zeile:=vReqCubes.Zeile; 

end; 

pos:=pos+1; 

until (pos>=filesize(fReqCubes)); 

for x:=0 to MemoryReqCubescount-1 do begin 

GeneriereReqListe.Add(auffuellen(inttostr(MemoryReqCubes[x].spalte),10)+auffuellen 

(inttostr(MemoryReqCubes[x].zeile),10)); 

end; 

finally 


end; 

finally 


end; 

Countliste:=nil; 

Setlength(Countliste,anzcube+1); 

MerkeListe:=nil; 

SetLength(Merkeliste,anzcube); 

APA_Show_Process.ausgabe(inttostr(anzcube)+' Cubes found'); 


geladen:=false; 

//Zuerst alle 0 setzten 

for x:=0 to anzcube do Countliste[x]:=0; 


kostenmerkmin:=0; 

end// of neustarten 

else begin 

geladen:=true; 


//Laden der Cubes 

{$i-} 

reset(fCounter); 

{$i+} 


try 

lang:=-1;pos:=0; 

repeat; 

if (filesize(fCounter)>0) then begin 

seek(fCounter,pos); 

read(fCounter,vCounter); 

if vcounter.Lfnr-1 then begin 

lang:=lang+1; 

x:=round(vCounter.Lfnr); 

Countliste[x]:=round(vCounter.nr); 

end; 


//Feststellen von alwaysspacemaxreached 


alwaysspacemaxreached:=true else 


end; 

- 364 -



pos:=pos+1; 

until pos>=filesize(fCounter); 

finally 


end; 

end; 

{$i-} 


{$i+} 


try 

seek(fMerkkosten,0);read(fMerkkosten,vMerkkosten); 

kostenmerkmin:=vMerkkosten.Kosten; 

finally 


end; 

if anzcube0 then begin 

//Kombinatorik 



lang:=0; 

end//neustarten 

else APA_Show_Process.ausgabe('*** Restart ***'); 

ende:=false; 

repeat;//until (lang>=anzcube)or(ende=true) 

//von links nach rechts nummerieren 

if geladen=false then begin 

//Beim ersten Start nicht ausführen 

//wenn geladen wurde 


end// Ende geladen=false 

else geladen:=false; 

istok:=true;aktpos:=0; 

repeat;//until (neuespalte=true)or(ende=true) 

neuespalte:=false; 

if istok=true then begin; 

//Kontrolliere 

//Alle 50000 Einträge lösche die Anzeigeliste um Speicher zu schonen 

if APA_Show_Process.APA_Protocoll.Items.Count>50000 then 

APA_Show_Process.APA_Protocoll.Items.Clear; 

seqcounter:=seqcounter+1; 

if alwaysspacemaxreached=true then 

APA_Show_Process.ausgabe('>>Add Seq: '+floattostr(seqcounter)) 

else 

APA_Show_Process.ausgabe('>Add Seq: '+floattostr(seqcounter)); 

//Stelle fest ob spacemax erfüllt. 

//Wenn ja ordne die Würfel und berechne Kosten 

spaceleftfirstcubes:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text); 


for x:=0 to lang do begin 

APA_Show_Process.ausgabe(' '+inttostr(countliste[x])); 

- 365 -






if x0 then begin 

//Rechne den Speicherplatz ohne die letzte Ebene aus. 

//Wenn dieser überschritten kann der durchlauf der letzten Ebene gestoppt werden 

spaceleftfirstcubes:=spaceleftfirstcubes- 



end; 


//Wenn überschritten setzt den Zähler der ersten auf max 

if spaceleftfirstcubes0 then begin 

// Nur wenn die Spacemax Bedingung erfüllt weiterrechnen 


for zahler:=0 to lang do begin 

MerkeListe[zahler]:=countliste[zahler]; 

end; 

//Berechne Kosten 

GeneriereListe:=TStringList.create(); 

try 


GeneriereListe.Add(auffuellen(inttostr(MemoryCubes[countliste[x]- 

1].spalte),10)+auffuellen(inttostr(MemoryCubes[countliste[x]-1].zeile),10)); 

end; 


APA_Show_Process.ausgabe('Unsorted: '+inttostr(x)+': 

('+inttostr(strtoint(copy(GeneriereListe[x],1,10)))+':'+inttostr(strtoint(copy(Gen 

eriereListe[x],11,10)))+')'); 

end; 

APA_Show_Process.ausgabe('Sort Cubes ...'); 

GeneriereListe:=GetRightOrdertom(GeneriereListe); 


APA_Show_Process.ausgabe('Sorted: '+inttostr(x)+': 

('+inttostr(strtoint(copy(GeneriereListe[x],1,10)))+':'+inttostr(strtoint(copy(Gen 

eriereListe[x],11,10)))+')'); 

end; 

kostenmerk:=berechneKostenGesamt(GeneriereListe,GeneriereReqListe,true); 

finally 

GeneriereListe.free; 

end; 

if kostenmerk>0 then begin 

if(kostenmerkmin=0)or(kostenmerkmin>kostenmerk) 

then begin; 

{$i-} 


{$i+} 


try 

- 366 -



APA_Show_Process.ausgabe('*****************'); 

APA_Show_Process.ausgabe('Trage ein das Minimum '+floattostr(kostenmerk)); 

vMerkkosten.Kosten:=kostenmerk; 


seek(fMerkkosten,0);write(fMerkkosten,vMerkkosten); 

kostenmerkmin:=kostenmerk; 



vMerkkosten.Kosten:=spaceleft; 




vMerkkosten.Kosten:=timeleft; 


finally 


end; 

//Speichere Counttable 


{$i-} 

rewrite(fCountermerk); 

{$i+} 


try 


seek(fCountermerk,filesize(fCountermerk)); 

vCountermerk.Lfnr:=x; 

vCountermerk.Nr:=MerkeListe[x]; 

write(fCountermerk,vCountermerk); 

APA_Show_Process.ausgabe('Save Cube Pos:'+floattostr(vCountermerk.Lfnr)+' 

Nr:'+floattostr(vCountermerk.Nr)); 


finally 

CloseFile(fCountermerk); 

end; 

end;//Ende von if(Minkostcubetable['Kosten']=0) ... 

end;//Ende von if kostenmerk>0 then begin 

end//von if spacemax>0 

else 

APA_Show_Process.ausgabe('spacemax reached'); 

end;// von istok 

if countliste[aktpos]>=(anzcube-aktpos) then begin 

//Setze alle cubes vom aktpos und kleiner auf 1 

Countliste[aktpos]:=1; 

x:=aktpos; 

repeat; 

Countliste[x]:=1; 

x:=x-1; 

until x=-1; 


if countliste[aktpos]=0 then neuespalte:=true; 

Countliste[aktpos]:=countliste[aktpos]+1; 

//Finde den nächsten Cube, welcher nicht das Maximum hat 

repeat; 

if Countliste[aktpos]>(anzcube-aktpos) then begin 


if (aktpos>anzcube) then begin 

aktpos:=anzcube; 

- 367 -



ende:=true; 

end; 

if countliste[aktpos]=0 then neuespalte:=true; 


end; 

until (Countliste[aktpos]=0 then begin 

Countliste[x]:=Countliste[x+1]+1; 

end; 

x:=x-1; 

until x= ... 

else begin; 


aktpos:=0; 

end; 


while(break=true) do begin; 


end; 

if APA_Show_Process.Expertmode1.Checked=true then begin 

try 

repeat; 

st:=inputbox('Countnumber','Countnumber:',''); 

if st'' then begin 

x:=strtoint(st); 

st:=inputbox('New Countliste','New Countliste:',inttostr(Countliste[x])); 

Countliste[x]:=strtoint(st); 

end; 

until st=''; 

finally 

APA_Show_Process.Expertmode1.Checked:=false; 

end; 

end; 

if APA_Show_Process.GroupBox1.tag=1 then begin 


neuespalte:=true;//Geheimticker 

x:=lang+1;zahler:=0; 

repeat; 

if x>=0 then begin; 


countliste[x]:=zahler; 

end; 

x:=x-1; 

until x=-1; 

end; 

if APA_Show_Process.GroupBox1.tag=-1 then begin 



countliste[lang]:=0; 

lang:=lang-1; 

x:=lang;zahler:=0; 

repeat; 

if x>=0 then begin; 


countliste[x]:=zahler; 

end; 

x:=x-1; 

until x=-1; 

- 368 -


end; 


until (neuespalte=true)or(stop=true)or(ende=true); 

if (alwaysspacemaxreached=true) and(Alwaysspacemaxbeachten1.Checked=true) then 

stop:=true; 

//wenn die letzten z.B. 5 Cubes in allen Kombinationen zu wenig Speicherplatz 

//hatten, gehen sich 6 Cubes auch nicht aus. Also Ende 

lang:=lang+1; 

until (ende=true)or(lang>=anzcube)or(stop=true); 

//Speichern des aktuellen Cubeliste damit man wieder weiter machen kann. 

//Speichern der aktuellen Position 

assignfile(fCounter,'c:\APADIR\DATA\Counter.dat'); 

{$i-} 


{$i+} 

if ioresult0 then showmessage('Can not open File Counter.dat'); 

try 

seek(fCounter,0); 

vCounter.Lfnr:=-1; 


if alwaysspacemaxreached=true then vcounter.Nr:=1 

else vcounter.Nr:=0; 



seek(fCounter,x+1); 

vCounter.Lfnr:=x; 

vCounter.Nr:=Countliste[x]; 


end; 

finally 

CloseFile(fcounter); 

end; 

end;// Wenn es mindestens einen Cube gibt in der Cubeliste 

end;//with Apa_Application 

finally 

closeFile(fkosten); 

GeneriereReqListe.free; 

Showmessage('Ready'); 


end; 

end; 

procedure TAPA_Grid.Options1Click(Sender: TObject); 

begin 

APA_Options.showmodal; 

end; 

procedure TAPA_Grid.ShowData1Click(Sender: TObject); 


begin 

st:='Screenbez: '+APA[zellespalte,zellezeile].screenbez; 

st:=st+', Counthier:'+inttostr(APA[zellespalte,zellezeile].counthier)+', '; 

st:=st+'Countdim: '+inttostr(APA[zellespalte,zellezeile].countdimension)+', '; 

st:=st+'Weight: '+floattostr(APA[zellespalte,zellezeile].gewicht)+', '; 

st:=st+'Weightlevel: '+inttostr(APA[zellespalte,zellezeile].gewichtlevel)+', '; 

st:=st+'Matcount: '+inttostr(APA[zellespalte,zellezeile].matcount)+', '; 

showmessage(st); 

end; 


begin 

Panel3.Width:=1; 

end; 

procedure TAPA_Grid.AlgorithmKombination1Click(Sender: TObject); 

- 369 -


begin 


if permutation=false then begin 



APA_Dialog.APA_Text.Caption:='Your last deterministic run was a permutation. Do you 

want do continue? This will delete your last run!'; 

end; 

end; 



end; 

procedure TAPA_Grid.AlgorithmKombination2Click(Sender: TObject); 

begin 


end; 

procedure TAPA_Grid.GetbuildBFT2Click(Sender: TObject); 

begin 


{$i-} 


{$i+} 


try 


showmessage(floattostr(getbuild(-1,-1,zellespalte,zellezeile))); 

finally 


end; 

end; 

procedure TAPA_Grid.GetbuildParent2Click(Sender: TObject); 

var buildcosts, merkecosts:Extended; 

var parentzeile,parentspalte:longint; 


begin 


{$i-} 


{$i+} 


try 


merkecosts:=getbuild(-1,-1,zellespalte,zellezeile);;parentzeile:=-1;parentspalte:=-1; 




if isderivat(spalte,zeile,zellespalte,zellezeile)=true then begin 

buildcosts:=getbuild(spalte,zeile,zellespalte,zellezeile); 

if (buildcosts



{$i-} 


{$i+} 


try 

//Nur getquery 

showmessage(floattostr(getquery(-1,-1,zellespalte,zellezeile))); 

finally 


end; 

end; 

procedure TAPA_Grid.GetQueryParent2Click(Sender: TObject); 

var querycosts, merkecosts:Extended; 



begin 


{$i-} 


{$i+} 


try 

//Nur getquery 

merkecosts:=getquery(-1,-1,zellespalte,zellezeile);; 

parentzeile:=-1;parentspalte:=-1; 





querycosts:=getquery(spalte,zeile,zellespalte,zellezeile); 

if (querycosts



procedure TAPA_Grid.Showcosts2Click(Sender: TObject); 

begin 

Showcosts1Click(self); 

end; 

procedure TAPA_Grid.ShowAnalyseWindow1Click(Sender: TObject); 

begin 

Showlistbox1Click(self); 

end; 

procedure TAPA_Grid.AnalyseAPA1Click(Sender: TObject); 

begin 

APA_Application.AnalyseAPA1Click(self); 

end; 

procedure TAPA_Grid.ShowAnalysewindow2Click(Sender: TObject); 

begin 

APA_Application.AnalyseAPA1Click(self); 

end; 

procedure TAPA_Grid.Showpossiblecubes1Click(Sender: TObject); 

var PossibleCubes:TStringList; 

var counter,aktzeile,aktspalte,count_of_derivates:longint; 

var zahler,derivspalte,derivzeile:longint; 

begin 

PossibleCubes:=TStringList.Create(); 

counter:=0; 



if (APA[aktspalte,aktzeile].interessant=true)and 

(APA[aktspalte,aktzeile].farbe=clYellow) then begin//Auswählen des Würfels 


,10)); 


end;//of Auswählen des Würfels 

end;//of aktspalte 

end;//of aktzeile 


if tomohnederivate1.Checked=false then begin 



if 








if isderivat(aktspalte,aktzeile,derivspalte,derivzeile) then begin 










,10)); 


end; 

end;//von Yellow 

- 372 -





end; 

for zahler:=0 to PossibleCubes.count-1 do begin 

APA[strtoint(copy(PossibleCubes[zahler],1,10)),strtoint(copy(PossibleCubes[zahler],11,10 

))].flag:=1; 

end; 


showmessage('Found '+inttostr(counter)+' possible cubes. '); 

Showpossiblecubes2.Visible:=false; 

Removepossiblecubes2.Visible:=true; 

end; 

procedure TAPA_Grid.Removepossiblecubes1Click(Sender: TObject); 

var aktzeile,aktspalte:longint; 

begin 



APA[aktspalte,aktzeile].flag:=0; 

end; 

end; 


Showpossiblecubes2.Visible:=true; 

Removepossiblecubes2.Visible:=false; 

end; 

procedure TAPA_Grid.Showpossiblecubes2Click(Sender: TObject); 

begin 

Showpossiblecubes1Click(self); 

end; 

procedure TAPA_Grid.Removepossiblecubes2Click(Sender: TObject); 

begin 

Removepossiblecubes1Click(self); 

end; 

procedure TAPA_Grid.Getmaterialisationspaceofcube1Click(Sender: TObject); 

begin 

showmessage('Space required: 

'+floattostr((strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(zel 

lespalte,zellezeile)))); 

end; 

procedure TAPA_Grid.ShowButtons1Click(Sender: TObject); 

begin 

Button1.Visible:=true; 




end; 

procedure TAPA_Grid.GetbuildBFT1Click(Sender: TObject); 

begin 

//Nur delta 

showmessage('The Materialisation costs are 

'+floattostr(deltaBFTW(zellespalte,zellezeile,false))); 

end; 

procedure TAPA_Grid.GetqueryfromBFT1Click(Sender: TObject); 

begin 

//Nur delta 

showmessage('The Query costs are '+floattostr(deltaBFTW(zellespalte,zellezeile,true))); 

end; 

- 373 -



procedure TAPA_Grid.Getbuildfromparent1Click(Sender: TObject); 

var buildcosts, merkecosts:Extended; 



begin 

//Nur delta 

merkecosts:=deltaBFTW(zellespalte,zellezeile,false);parentzeile:=-1;parentspalte:=-1; 





buildcosts:=deltaVW(spalte,zeile,zellespalte,zellezeile,false); 

if (buildcosts



MatCubes:=TStringList.Create; 

MatCubes.Clear; 

MatCubesSorted:=TStringList.Create; 

MatCubesSorted.Clear; 

merkerandom:=Userandomcosts1.Checked; 

Userandomcosts1.Checked:=false; 

try 








ReqCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10)); 

end; 


//Speichere Mat Cubes 

//Merke dir die MatCubes 

MatCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));; 

end; 

end; 



for zahler:=0 to MatCubes.count-1 do MatCubesSorted.Add('free'); 

for zahler:=0 to MatCubes.Count-1 do begin 

MatCubesSorted[APA[strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler], 

11,10))].matcount-1]:= 

MatCubes[zahler]; 

end; 

showmessage('Costs: '+floattostr(berechneKostenGesamt(MatCubesSorted,ReqCubes,false))+'; 

Time left: '+ 

floattostr(timeleft)+'; Space left: '+floattostr(spaceleft)); 

finally 


ReqCubes.Free; 

MatCubesSorted.Free; 

Userandomcosts1.Checked:=merkerandom; 

end; 

end //of matcount 

else showmessage('No materialized cubes selected'); 

end; 

procedure TAPA_Grid.Restrictedcosts1Click(Sender: TObject); 

begin 

APA_Application.Restrictedcosts1.Checked:=APA_Grid.Restrictedcosts1.Checked; 

end; 

procedure TAPA_Grid.Showdeterministicsolution2Click(Sender: TObject); 

begin 

Showdeterministicsolution1Click(self); 

end; 

procedure TAPA_Grid.Showdeterministicsolution1Click(Sender: TObject); 

var countcube,pos:longint; 

var SolutionList:TStringList; 

begin 

- 375 -




{$i-} 

reset(fCountermerk); 

{$i+} 


try 

if filesize(fCountermerk)>0 then begin 

SolutionList:=TStringList.Create(); 

try 


{$i-} 


{$i+} 



{$i-} 


{$i+} 

if ioresult0 then showmessage('Can not open File Cubes.dat'); 

pos:=0; 

repeat; 

if filesize(fcountermerk)>0 then begin 

seek(fCountermerk,pos); 

read(fCountermerk,vCountermerk); 

seek(fCubes,round(vCountermerk.nr)-1); 


SolutionList.Add(auffuellen(inttostr(vCubes.Spalte),10)+auffuellen(inttostr(vCubes 

.Zeile),10)); 

end; 

pos:=pos+1; 

until pos=filesize(fCountermerk); 

SolutionList:=GetRightOrdertom(SolutionList); 

for countcube:=0 to SolutionList.Count-1 do begin 

end; 

APA[strtoint(copy(SolutionList[countcube],1,10)),strtoint(copy(SolutionList[countc 

ube],11,10))].flag:=(2+((countcube+1)/10000)) 

Showdeterministicsolution2.Visible:=false; 

Removedeterministicsolution2.Visible:=true; 


finally 



SolutionList.Free; 

end; 

end else showmessage('No solution found'); 

finally 

CloseFile(fCountermerk); 

end; 

end; 

procedure TAPA_Grid.Removedeterministicsolution1Click(Sender: TObject); 


begin 



if (APA[spalte,zeile].flag>=2)and(APA[spalte,zeile].flag


end; 

end; 





end; 

procedure TAPA_Grid.Removedeterministicsolution2Click(Sender: TObject); 

begin 


end; 

procedure TAPA_Grid.GenerateCREATESQLStatementsBFTanddimensiontables3Click( 


var counter, counter2:longint; 

var Fieldnamemerk ,Fieldtypemerk:string; 

begin 

//Generiere BFT Table und Dimension Tables 

APA_Sql.Sqltext.lines.Clear; 

//1. Generiere Dimension Tables 

for counter:=0 to anzd-1 do begin//Counter für Dimensionen 

APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id = 

object_id(N''[dbo].[FK_BFT_'+dimbez[counter]+'_table]'')'); 

APA_Sql.Sqltext.lines.add(' and OBJECTPROPERTY(id, N''IsForeignKey'') = 1)'); 

APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] DROP CONSTRAINT 

FK_BFT_'+dimbez[counter]+'_table'); 

APA_Sql.Sqltext.lines.add('GO'); 

APA_Sql.Sqltext.lines.add(''); 


object_id(N''[dbo].['+dimbez[counter]+'_table]'') and OBJECTPROPERTY(id, 

N''IsUserTable'') = 1)'); 

APA_Sql.Sqltext.lines.add('drop table [dbo].['+dimbez[counter]+'_table]'); 



APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].['+dimbez[counter]+'_table] ('); 

APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id] [varchar] (50) COLLATE 

Latin1_General_CI_AS NOT NULL ,'); 

for counter2:=0 to anzh[counter]-1 do begin//Counter für Hierarchiestufen 

APA_Sql.Sqltext.lines.add(' ['+dk[counter,counter2]+'] [varchar] (12) COLLATE 


APA_Sql.Sqltext.lines.add(' ['+dk[counter,counter2]+'_desc] [varchar] (40) COLLATE 


end;//Counter für Hierarchiestufen 

APA_Sql.Sqltext.lines.add(' [level] [bigint] NOT NULL'); 

APA_Sql.Sqltext.lines.add(') ON [PRIMARY]'); 



APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].['+dimbez[counter]+'_table] WITH NOCHECK 

ADD'); 

APA_Sql.Sqltext.lines.add(' CONSTRAINT [PK_'+dimbez[counter]+'_table] PRIMARY KEY 

CLUSTERED'); 

APA_Sql.Sqltext.lines.add(' ('); 

APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id]'); 

APA_Sql.Sqltext.lines.add(' ) ON [PRIMARY]'); 



end;//Counter für Dimensionen Ende 

//2. Generiere BFT Table 


object_id(N''[dbo].[BFT]'')'); 

APA_Sql.Sqltext.lines.add('and OBJECTPROPERTY(id, N''IsUserTable'') = 1)'); 

APA_Sql.Sqltext.lines.add('drop table [dbo].[BFT]'); 



APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].[BFT] ('); 


- 377 -





end; 

for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin 

Fieldnamemerk:= 

copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite 

ms[counter])-1); 

Fieldtypemerk:= 

APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.Items.IndexOf(co 

py(APA_Input_Screen.Keybox.items[counter],pos('//',APA_Input_Screen.Keybox.items[c 

ounter])+6, 

length(APA_Input_Screen.Keybox.items[counter])- 

(pos('//',APA_Input_Screen.Keybox.items[counter])+6)))]; 

APA_Sql.Sqltext.lines.add(' ['+Fieldnamemerk+'] ['+Fieldtypemerk+'] NOT NULL ,'); 

end; 

//Beistrich entfernen 

APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:= 

copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1, 

length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1); 




APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD'); 

APA_Sql.Sqltext.lines.add(' CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED'); 



APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id],'); 

end; 








//3. Zusetzen der FK Schlüssel 


APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] ADD'); 

APA_Sql.Sqltext.lines.add(' CONSTRAINT [FK_BFT_'+dimbez[counter]+'_table] FOREIGN 

KEY'); 



APA_Sql.Sqltext.lines.add(' ) REFERENCES [dbo].['+dimbez[counter]+'_table] ('); 


APA_Sql.Sqltext.lines.add(' ) ON UPDATE CASCADE '); 




end; //of counter 

APA_Sql.Show; 

end; 

procedure TAPA_Grid.GenerateCREATESQLStatementsformaterializedcubes2Click( 


var spalte,zeile,zahler:longint; 

var tablename:string; 



var foundcube:boolean; 

begin 

- 378 -



{1. Für alle materialisierten Würfel} 


foundcube:=false; 




tablename:='';foundcube:=true; 

for zahler:=0 to anzd-1 do begin 

tablename:=tablename+dk[zahler,APA[spalte,zeile].hierstufe[zahler]]; 

end; 


APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where '); 

APA_Sql.Sqltext.lines.add('id = object_id(N''[dbo].[FT '+tablename+']'') and 

OBJECTPROPERTY(id, N''IsUserTable'') = 1)'); 

APA_Sql.Sqltext.lines.add('drop table [dbo].[FT '+tablename+']'); 



APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].[FT '+tablename+'] ( '); 


if (anzh[zahler]-1APA[spalte,zeile].hierstufe[zahler]) then 

APA_Sql.Sqltext.lines.add(' ['+dk[zahler,APA[spalte,zeile].hierstufe[zahler]]+'] 

[varchar] (12) COLLATE Latin1_General_CI_AS NOT NULL ,'); 

end; 








ounter])+6, 




end; 








APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[FT '+tablename+'] WITH NOCHECK ADD'); 

APA_Sql.Sqltext.lines.add(' CONSTRAINT [PK_FT '+tablename+'] PRIMARY KEY CLUSTERED'); 

APA_Sql.Sqltext.lines.add(' ( '); 


if (anzh[zahler]-1APA[spalte,zeile].hierstufe[zahler]) then 

APA_Sql.Sqltext.lines.add(' ['+dk[zahler,APA[spalte,zeile].hierstufe[zahler]]+'] ,'); 

end; 








end; //End Materialisieren 

end;// End Zeile 

end;//End Spalte 

if foundcube=true then 

APA_Sql.Show 

- 379 -



else 

showmessage('No materialized cube found!'); 

end; 



var counter, counter2:longint; 


begin 

//Generiere BFT Table und Dimension Tables 


//1. Generiere Dimension Tables 

for counter:=0 to anzd-1 do begin//Counter für Dimensionen 


object_id(N''[dbo].[FK_BFT_'+dimbez[counter]+'_table]'')'); 

APA_Sql.Sqltext.lines.add(' and OBJECTPROPERTY(id, N''IsForeignKey'') = 1)'); 

APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] DROP CONSTRAINT 

FK_BFT_'+dimbez[counter]+'_table'); 




object_id(N''[dbo].['+dimbez[counter]+'_table]'') and OBJECTPROPERTY(id, 

N''IsUserTable'') = 1)'); 

APA_Sql.Sqltext.lines.add('drop table [dbo].['+dimbez[counter]+'_table]'); 



APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].['+dimbez[counter]+'_table] ('); 

//Primärschlüssel 



for counter2:=0 to anzh[counter]-1 do begin//Counter für Hierarchiestufen 

APA_Sql.Sqltext.lines.add(' ['+dk[counter,counter2]+'] [varchar] (12) COLLATE 


APA_Sql.Sqltext.lines.add(' ['+dk[counter,counter2]+'_desc] [varchar] (40) COLLATE 


end;//Counter für Hierarchiestufen 




APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].['+dimbez[counter]+'_table] WITH NOCHECK 

ADD'); 

APA_Sql.Sqltext.lines.add(' CONSTRAINT [PK_'+dimbez[counter]+'_table] PRIMARY KEY 

CLUSTERED'); 






for counter2:=0 to anzh[counter]-1 do begin 

APA_Sql.Sqltext.lines.add(' CREATE INDEX [IX_'+dk[counter,counter2]+'] ON 

[dbo].['+dimbez[counter]+'_table](['+dk[counter,counter2]+']) ON [PRIMARY]'); 



end; 

end;//Counter für Dimensionen Ende 

//2. Generiere BFT Table 


object_id(N''[dbo].[BFT]'')'); 

APA_Sql.Sqltext.lines.add('and OBJECTPROPERTY(id, N''IsUserTable'') = 1)'); 

APA_Sql.Sqltext.lines.add('drop table [dbo].[BFT]'); 

- 380 -





APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].[BFT] ('); 




end; 








ounter])+6, 




end; 








APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD'); 

APA_Sql.Sqltext.lines.add(' CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED'); 



APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id],'); 

end; 








//3. Zusetzen der FK Schlüssel 


APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] ADD'); 

APA_Sql.Sqltext.lines.add(' CONSTRAINT [FK_BFT_'+dimbez[counter]+'_table] FOREIGN 

KEY'); 



APA_Sql.Sqltext.lines.add(' ) REFERENCES [dbo].['+dimbez[counter]+'_table] ('); 


APA_Sql.Sqltext.lines.add(' ) ON UPDATE CASCADE '); 




end; //of counter 

APA_Sql.Show; 

end; 



begin 

GenerateCREATESQLStatementsBFTanddimensiontables2Click(self); 

- 381 -


end; 


procedure TAPA_Grid.GenerateCREATESQLStatementsformaterializedcubes1Click( 


begin 

GenerateCREATESQLStatementsformaterializedcubes2Click(self); 

end; 

procedure TAPA_Grid.APAGridMouseWheelUp(Sender: TObject; 

Shift: TShiftState; MousePos: TPoint; var Handled: Boolean); 

begin 

zellespalte:=-1; 

zellezeile:=-1; 

end; 

procedure TAPA_Grid.HelpforAPAGridScreen1Click(Sender: TObject); 

begin 


APA_Help.APABrowser.Navigate('C:\APADIR\Help\APA_Grid.htm'); 

end; 

procedure TAPA_Grid.HelpforAPAProgram1Click(Sender: TObject); 

begin 


APA_Help.APABrowser.Navigate('C:\APADIR\Help\index.htm'); 

end; 

procedure TAPA_Grid.factconstellationschema1Click(Sender: TObject); 

var aktspalte,aktzeile,parentzeile,parentspalte, counter:longint; 

var merkcosts, bestmerkcosts:Extended; 

var sumdimension:array of longint; 

var tablename:string; 

var nix, gleich:boolean; 

begin 


{$i-} 


{$i+} 


try 

{1. Finden den Cube oder den BFT aus welchem abgefragt wird} 

parentzeile:=-1;parentspalte:=-1;// Kann immer aus dem BFT abgeleitet werden 


bestmerkcosts:=getquery(-1,-1,zellespalte,zellezeile); 


bestmerkcosts:=deltaBftW(zellespalte,zellezeile,true); 

end; 



if APA[aktspalte,aktzeile].materalisieren=true then begin 

if isderivat(aktspalte,aktzeile,zellespalte,zellezeile)=true then begin 


merkcosts:=getquery(aktspalte,aktzeile,zellespalte,zellezeile); 


merkcosts:=deltaVW(aktspalte,aktzeile,zellespalte,zellezeile,true); 

end; 

if merkcosts



{2.1. Finde die Dimensionen welche aggregiert werden müssen} 

sumdimension:=nil; 

setlength(sumdimension,anzd); 

for counter:=0 to anzd-1 do sumdimension[counter]:=-1; 


if (APA[zellespalte,zellezeile].hierstufe[counter]anzh[counter]-1) then begin 

sumdimension[counter]:=APA[zellespalte,zellezeile].hierstufe[counter]; 

end; 

end; 


if parentspalte=-1 then begin 

APA_Sql.Sqltext.lines.add('SELECT '); 


if sumdimension[counter]-1 then begin 

//Feld aus dem Dimension table 

APA_Sql.Sqltext.lines.add(' 

dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf 

e[counter]]+'],'); 

end; 

end; 


APA_Sql.Sqltext.lines.add(copy(APA_Input_Screen.Keybox.items[counter],pos('//',APA 

_Input_Screen.Keybox.items[counter])+2,3)+'(['+ 


ms[counter])-1)+'])'+ 

' AS 

['+copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox. 

items[counter])-1)+'],'); 

end; 





APA_Sql.Sqltext.lines.add('FROM dbo.BFT'); 




APA_Sql.Sqltext.lines.add(' INNER JOIN dbo.['+dimbez[counter]+'_table] ON 

dbo.BFT.['+dimbez[counter]+'_id]='); 


dbo.['+dimbez[counter]+'_table].['+dimbez[counter]+'_id]'); 

end; 

end; 

APA_Sql.Sqltext.lines.add('GROUP BY '); 







end; 

end; 






//Abfrage aus dem aggregierten Cube 

- 383 -



tablename:='';nix:=true; 


tablename:=tablename+dk[counter,APA[parentspalte,parentzeile].hierstufe[counter]]; 

end; 

gleich:=true; 


if (APA[zellespalte,zellezeile].hierstufe[counter]> 

APA[parentspalte,parentzeile].hierstufe[counter]) 

and(APA[zellespalte,zellezeile].hierstufe[counter]anzh[counter]-1) then begin 

sumdimension[counter]:=APA[zellespalte,zellezeile].hierstufe[counter]; 

end; 

if 

(APA[zellespalte,zellezeile].hierstufe[counter]APA[parentspalte,parentzeile].hie 

rstufe[counter]) 

then gleich:=false; 

end; 


if gleich=false then begin 




if (anzh[counter]-1APA[zellespalte,zellezeile].hierstufe[counter]) then 

begin; 




nix:=false; 

end; 


//Feld aus dem Abfrage Table 


begin; 


dbo.['+tablename+'].['+dk[counter,APA[zellespalte,zellezeile].hierstufe[counter]]+ 

'],'); 

nix:=false; 

end; 

end; 

end; 






' AS 



end; 





end // von gleich 

else 

APA_Sql.Sqltext.lines.add('*'); 

APA_Sql.Sqltext.lines.add('FROM dbo.['+tablename+']'); 

if gleich=false then begin 





begin 


dbo.['+tablename+'].['+dk[counter,APA[parentspalte,parentzeile].hierstufe[counter] 

]+']='); 

- 384 -


end; 



dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[parentspalte,parentzeile].hierst 

ufe[counter]]+']'); 

end; 

end; 

end; 

if nix=false then 










//Feld aus dem BFT Table 



dbo.['+tablename+'].['+dk[counter,APA[zellespalte,zellezeile].hierstufe[counter]]+ 

'],'); 

end; 

end; 





end; // von gleich 

finally 


end; 

APA_Sql.Show; 

end; 

procedure TAPA_Grid.starschema1Click(Sender: TObject); 

var aktspalte,aktzeile,parentzeile,parentspalte, counter:longint; 

var merkcosts, bestmerkcosts:Extended; 

var sumdimension:array of longint; 

begin 


{$i-} 


{$i+} 


try 

{1. Finden den Cube oder den BFT aus welchem abgefragt wird} 

parentzeile:=-1;parentspalte:=-1;// Kann immer aus dem BFT abgeleitet werden 


bestmerkcosts:=getquery(-1,-1,zellespalte,zellezeile); 


bestmerkcosts:=deltaBftW(zellespalte,zellezeile,true); 

end; 



if APA[aktspalte,aktzeile].materalisieren=true then begin 

if isderivat(aktspalte,aktzeile,zellespalte,zellezeile)=true then begin 


merkcosts:=getquery(aktspalte,aktzeile,zellespalte,zellezeile); 


merkcosts:=deltaVW(aktspalte,aktzeile,zellespalte,zellezeile,true); 

end; 

- 385 -



if merkcosts








end; 

end; 






//Abfrage aus dem aggregierten Cube 








end; 

end; 






' AS 



end; 





APA_Sql.Sqltext.lines.add('FROM dbo.BFT'); 




dbo.BFT.['+dimbez[counter]+'_id]='); 


dbo.['+dimbez[counter]+'_table].['+dimbez[counter]+'_id]'); 

end; 

APA_Sql.Sqltext.lines.add('WHERE '); 



if counter0 then APA_Sql.Sqltext.lines.add(' AND '); 

APA_Sql.Sqltext.lines.add(' (dbo.['+dimbez[counter]+'_table].[level]=' 

+inttostr(APA[parentspalte,parentzeile].hierstufe[counter])+')'); 

end; 








end; 

end; 

- 387 -


end; 






finally 


end; 

APA_Sql.Show; 

end; 

end. 

12.1.10 UNIT APA_HELPUNIT.DFM 

object APA_Help: TAPA_Help 

Left = 220 

Top = 114 

Width = 696 

Height = 480 

Caption = 'APA Help' 









WindowState = wsMaximized 



object APABrowser: TWebBrowser 

Left = 0 

Top = 41 

Width = 688 

Height = 364 


TabOrder = 0 

ControlData = { 

4C0000001B4700009F2500000000000000000000000000000000000000000000 

000000004C000000000000000000000001000000E0D057007335CF11AE690800 

2B2E126208000000000000004C0000000114020000000000C000000000000046 

8000000000000000000000000000000000000000000000000000000000000000 

00000000000000000100000000000000000000000000000000000000} 

end 


Left = 0 

Top = 405 

Width = 688 

Height = 41 


TabOrder = 1 


Left = 16 

Top = 8 

Width = 75 

Height = 25 

Cancel = True 


TabOrder = 0 


end 

end 


Left = 0 

Top = 0 

- 388 -



Width = 688 

Height = 41 

Align = alTop 

TabOrder = 2 


Left = 16 

Top = 8 

Width = 75 

Height = 25 

Caption = 'Back' 

TabOrder = 0 


end 


Left = 104 

Top = 8 

Width = 75 

Height = 25 

Caption = 'Forward' 

TabOrder = 1 


end 

end 

end 

12.1.11 UNIT APA_HELPUNIT.PAS 

unit APA_Helpunit; 

interface 

uses 


Dialogs, StdCtrls, ExtCtrls, OleCtrls, SHDocVw; 

type 

TAPA_Help = class(TForm) 

APABrowser: TWebBrowser; 









private 


public 


end; 

var 

APA_Help: TAPA_Help; 


{$R *.dfm} 

procedure TAPA_Help.Button1Click(Sender: TObject); 

begin 

Close; 

end; 


begin 

try 

APABrowser.GoBack; 

except 

showmessage('Not Possible'); 

end; 

- 389 -


end; 



begin 

try 

APABrowser.GoForward; 

except 

showmessage('Not Possible'); 

end; 

end; 

end. 

12.1.12 UNIT APA_INPUT_DIMENSIONUNIT.DFM 

object APA_Insert_Dimension: TAPA_Insert_Dimension 

Left = 297 

Top = 234 

ActiveControl = Dimension 

BorderStyle = bsDialog 

Caption = 'APA_Insert_Dimension' 














object Bevel1: TBevel 

Left = 11 

Top = 10 

Width = 297 

Height = 65 

Shape = bsFrame 

end 

object Label1: TLabel 

Left = 27 

Top = 18 

Width = 103 

Height = 13 

Caption = 'Dimension description' 

end 

object OKBtn: TButton 

Left = 82 

Top = 90 

Width = 75 

Height = 25 

Caption = 'OK' 


Enabled = False 


TabOrder = 0 

OnClick = OKBtnClick 

end 

object CancelBtn: TButton 

Left = 162 

Top = 90 

Width = 75 

Height = 25 

Cancel = True 

Caption = 'Cancel' 


TabOrder = 1 

OnClick = CancelBtnClick 

end 

object Dimension: TEdit 

- 390 -



Left = 27 

Top = 34 

Width = 257 

Height = 21 

MaxLength = 40 

TabOrder = 2 

OnChange = DimensionChange 

end 

end 

12.1.13 UNIT APA_INPUT_DIMENSIONUNIT.PAS 

unit APA_Input_Dimensionunit; 

interface 

uses 



type 

TAPA_Insert_Dimension = class(TForm) 

Bevel1: TBevel; 

OKBtn: TButton; 

CancelBtn: TButton; 

Label1: TLabel; 

Dimension: TEdit; 

procedure DimensionChange(Sender: TObject); 

procedure CancelBtnClick(Sender: TObject); 


procedure OKBtnClick(Sender: TObject); 

private 


public 


end; 

var 

APA_Insert_Dimension: TAPA_Insert_Dimension; 


{$R *.dfm} 

procedure TAPA_Insert_Dimension.DimensionChange(Sender: TObject); 

begin 

OKBtn.Enabled:=true; 

end; 

procedure TAPA_Insert_Dimension.CancelBtnClick(Sender: TObject); 

begin 

Close; 

end; 

procedure TAPA_Insert_Dimension.FormShow(Sender: TObject); 

begin 

Dimension.SetFocus; 

end; 

procedure TAPA_Insert_Dimension.OKBtnClick(Sender: TObject); 


begin 

if (pos('//',Dimension.Text)0) then begin; 

showmessage('Sting "//" is not allowed in dimension'); 

st:=Dimension.Text; 

delete(st,pos('//',st),2); 

Dimension.Text:=st; 

end; 

end; 

end. 

- 391 -



12.1.14 UNIT APA_INPUT_HIERARCHYUNIT.DFM 

object APA_Insert_Hierarchy: TAPA_Insert_Hierarchy 

Left = 220 

Top = 114 

ActiveControl = short_hierarchy 


Caption = 'APA_Insert_Hierarchy' 















Left = 14 

Top = 14 

Width = 297 

Height = 150 


end 


Left = 30 

Top = 22 

Width = 125 

Height = 13 

Caption = 'Hierarchy short description' 

end 


Left = 30 

Top = 70 

Width = 122 

Height = 13 

Caption = 'Hierarchy long description' 

end 


Left = 30 

Top = 114 

Width = 99 

Height = 13 

Caption = 'Count of datarecords' 

end 


Left = 85 

Top = 170 

Width = 75 

Height = 25 





TabOrder = 3 


end 


Left = 165 

Top = 170 

Width = 75 

Height = 25 

Cancel = True 



TabOrder = 4 


end 

object short_hierarchy: TEdit 

- 392 -



Left = 30 

Top = 38 

Width = 131 

Height = 21 


TabOrder = 0 

OnChange = short_hierarchyChange 

end 

object long_hierarchy: TEdit 

Left = 30 

Top = 86 

Width = 257 

Height = 21 


TabOrder = 1 

OnChange = long_hierarchyChange 

end 

object datarecords: TMaskEdit 

Left = 30 

Top = 128 

Width = 257 

Height = 21 

EditMask = '0##############;0; ' 


TabOrder = 2 

Text = '1' 

end 

end 

12.1.15 UNIT APA_INPUT_HIERARCHYUNIT.PAS 

unit APA_Input_Hierarchyunit; 

interface 

uses 


Dialogs, StdCtrls, ExtCtrls, Mask; 

type 

TAPA_Insert_Hierarchy = class(TForm) 





short_hierarchy: TEdit; 


long_hierarchy: TEdit; 


datarecords: TMaskEdit; 

procedure short_hierarchyChange(Sender: TObject); 

procedure long_hierarchyChange(Sender: TObject); 


procedure CancelBtnClick(Sender: TObject); 


private 


public 


end; 

var 

APA_Insert_Hierarchy: TAPA_Insert_Hierarchy; 


{$R *.dfm} 

procedure TAPA_Insert_Hierarchy.short_hierarchyChange(Sender: TObject); 

begin 

if (length(short_hierarchy.Text)0)and 

(length(long_hierarchy.Text)0) then OKBtn.Enabled:=true; 

- 393 -


end; 


procedure TAPA_Insert_Hierarchy.long_hierarchyChange(Sender: TObject); 

begin 

if (length(short_hierarchy.Text)0)and 

(length(long_hierarchy.Text)0) then OKBtn.Enabled:=true; 

end; 

procedure TAPA_Insert_Hierarchy.OKBtnClick(Sender: TObject); 


begin 

{Überprüfe, ob // nicht im shortstring vorkommt} 

if (pos('//',short_hierarchy.Text)0) then begin; 

showmessage('Sting "//" is not allowed in short description'); 

st:=short_hierarchy.Text; 


short_hierarchy.Text:=st; 

end; 

if (pos('//',long_hierarchy.Text)0) then begin; 

showmessage('Sting "//" is not allowed in long description'); 

st:=long_hierarchy.Text; 


long_hierarchy.Text:=st; 

end; 

if (pos('//',datarecords.Text)0) then begin; 

showmessage('Sting "//" is not allowed in datarecords'); 

st:=datarecords.Text; 


datarecords.Text:=st; 

end; 

if (pos('::',short_hierarchy.Text)0) then begin; 

showmessage('Sting "::" is not allowed in short description'); 

st:=short_hierarchy.Text; 


short_hierarchy.Text:=st; 

end; 

if (pos('::',long_hierarchy.Text)0) then begin; 

showmessage('Sting "::" is not allowed in long description'); 

st:=long_hierarchy.Text; 

delete(st,pos('::',st),2); 

long_hierarchy.Text:=st; 

end; 

if (pos('::',datarecords.Text)0) then begin; 

showmessage('Sting "::" is not allowed in datarecords'); 

st:=datarecords.Text; 

delete(st,pos('::',st),2); 

datarecords.Text:=st; 

end; 

try 

if strtoint(datarecords.Text)


end; 


procedure TAPA_Insert_Hierarchy.FormShow(Sender: TObject); 

begin 

short_hierarchy.SetFocus; 

end; 

end. 

12.1.16 UNIT APA_INPUT_REQBLOCKUNIT.DFM 

object APA_Insert_Hierarchy: TAPA_Insert_Hierarchy 

Left = 220 

Top = 114 

ActiveControl = short_hierarchy 


Caption = 'APA_Insert_Hierarchy' 















Left = 14 

Top = 14 

Width = 297 

Height = 150 


end 


Left = 30 

Top = 22 

Width = 125 

Height = 13 

Caption = 'Hierarchy short description' 

end 


Left = 30 

Top = 70 

Width = 122 

Height = 13 

Caption = 'Hierarchy long description' 

end 


Left = 30 

Top = 114 

Width = 99 

Height = 13 

Caption = 'Count of datarecords' 

end 


Left = 85 

Top = 170 

Width = 75 

Height = 25 





TabOrder = 3 


end 


Left = 165 

- 395 -



Top = 170 

Width = 75 

Height = 25 

Cancel = True 



TabOrder = 4 


end 

object short_hierarchy: TEdit 

Left = 30 

Top = 38 

Width = 131 

Height = 21 


TabOrder = 0 

OnChange = short_hierarchyChange 

end 

object long_hierarchy: TEdit 

Left = 30 

Top = 86 

Width = 257 

Height = 21 


TabOrder = 1 

OnChange = long_hierarchyChange 

end 

object datarecords: TMaskEdit 

Left = 30 

Top = 128 

Width = 257 

Height = 21 

EditMask = '0##############;0; ' 


TabOrder = 2 

Text = '1' 

end 

end 

12.1.17 UNIT APA_INPUT_REQBLOCKUNIT.PAS 

unit APA_Input_Reqblockunit; 

interface 

uses 



type 

TAPA_Insert_Reqblock = class(TForm) 





Reqname: TEdit; 

Add_max_hier: TCheckBox; 

Importance_of_requirement: TListBox; 



procedure Importance_of_requirementClick(Sender: TObject); 

procedure ReqnameChange(Sender: TObject); 

private 


public 


end; 

var 

APA_Insert_Reqblock: TAPA_Insert_Reqblock; 


- 396 -



uses APA_Parameterunit; 

{$R *.dfm} 

procedure TAPA_Insert_Reqblock.FormShow(Sender: TObject); 

var merkindex,g:longint;//Zähler 

begin 

merkindex:=Importance_of_requirement.ItemIndex; 

Reqname.SetFocus; 

Importance_of_requirement.Items.Clear; 

//Festlegen der Required Spalten 

for g:=0 to APA_Parameter.APA_Degrees.Count-1 do begin 

Importance_of_requirement.Items.Add(APA_Parameter.APA_Degrees.Items[g]); 

end; 

Importance_of_requirement.ItemIndex:=merkindex; 

if Importance_of_requirement.ItemIndex=-1 then Importance_of_requirement.ItemIndex:=0; 

end; 

procedure TAPA_Insert_Reqblock.Importance_of_requirementClick( 


begin 


end; 

procedure TAPA_Insert_Reqblock.ReqnameChange(Sender: TObject); 

begin 


end; 

end. 

12.1.18 UNIT APA_INPUT_SCREENUNIT.DFM 

object APA_Input_Screen: TAPA_Input_Screen 

Left = 206 

Top = 119 

Width = 604 

Height = 568 

Caption = 'APA Input Screen' 









OnCloseQuery = FormCloseQuery 





Left = 0 

Top = 493 

Width = 596 

Height = 41 


TabOrder = 0 

object Saveandexit_button: TButton 

Left = 16 

Top = 8 

Width = 75 

Height = 25 

Caption = 'Save && Exit' 



TabOrder = 0 

OnClick = Saveandexit_buttonClick 

end 

- 397 -



object Abortandexit_button: TButton 

Left = 104 

Top = 8 

Width = 75 

Height = 25 

Caption = 'Abort && Exit' 


TabOrder = 1 

OnClick = Abortandexit_buttonClick 

end 

end 


Left = 0 

Top = 0 

Width = 596 

Height = 41 

Align = alTop 

TabOrder = 1 

object Button_insert_dimension: TButton 

Left = 8 

Top = 8 

Width = 90 

Height = 25 

Caption = 'Insert dimension' 

TabOrder = 0 

OnClick = Button_insert_dimensionClick 

end 

object Button_delete: TButton 

Left = 220 

Top = 8 

Width = 90 

Height = 25 

Caption = 'Delete' 

TabOrder = 2 

OnClick = Button_deleteClick 

end 

object Button_Edit: TButton 

Left = 327 

Top = 8 

Width = 90 

Height = 25 

Caption = 'Edit' 

TabOrder = 3 

OnClick = Button_EditClick 

end 

object Button_insert_hierarchy: TButton 

Left = 114 

Top = 8 

Width = 90 

Height = 25 

Caption = 'Insert hierarchy' 

TabOrder = 1 

OnClick = Button_insert_hierarchyClick 

end 

end 


Left = 0 

Top = 41 

Width = 65 

Height = 340 


TabOrder = 2 

object APA_dimbox: TGroupBox 

Left = 1 

Top = 1 

Width = 63 

Height = 72 

Align = alTop 

Caption = 'Dimension' 


TabOrder = 0 

object Button_dim_up: TButton 

Left = 8 

Top = 16 

- 398 -



Width = 50 

Height = 25 

Caption = 'Up' 

TabOrder = 0 

OnClick = Button_dim_upClick 

end 

object Button_dim_down: TButton 

Left = 8 

Top = 42 

Width = 50 

Height = 25 

Caption = 'Down' 

TabOrder = 1 

OnClick = Button_dim_downClick 

end 

end 

object APA_hierbox: TGroupBox 

Left = 1 

Top = 73 

Width = 63 

Height = 73 

Align = alTop 

Caption = 'Hierarchy' 


TabOrder = 1 

object button_hier_up: TButton 

Left = 8 

Top = 16 

Width = 50 

Height = 25 

Caption = 'Up' 

TabOrder = 0 

OnClick = button_hier_upClick 

end 

object Button_hier_down: TButton 

Left = 8 

Top = 42 

Width = 50 

Height = 25 

Caption = 'Down' 

TabOrder = 1 

OnClick = Button_hier_downClick 

end 

end 

end 

object GroupBox1: TGroupBox 

Left = 0 

Top = 381 

Width = 596 

Height = 112 


Caption = 'Key figures' 

TabOrder = 3 


Left = 2 

Top = 15 

Width = 95 

Height = 95 


TabOrder = 0 

object Button_key_insert: TButton 

Left = 5 

Top = 7 

Width = 75 

Height = 25 

Caption = 'Insert' 

TabOrder = 0 

OnClick = Button_key_insertClick 

end 

object Button_key_edit: TButton 

Left = 5 

Top = 35 

Width = 75 

Height = 25 

- 399 -




TabOrder = 1 

OnClick = Button_key_editClick 

end 

object Button_key_delete: TButton 

Left = 5 

Top = 62 

Width = 75 

Height = 25 


TabOrder = 2 

OnClick = Button_key_deleteClick 

end 

end 

object Keybox: TListBox 

Left = 97 

Top = 15 

Width = 497 

Height = 95 



Items.Strings = ( 

'Profit//SUM(MONEY)' 

'') 

TabOrder = 1 

OnDblClick = KeyboxDblClick 

end 

end 

object Eingabe: TTreeView 

Left = 65 

Top = 41 

Width = 531 

Height = 340 







HideSelection = False 

Images = APA_ImageList 

Indent = 19 

ParentFont = False 

ReadOnly = True 

TabOrder = 4 

OnClick = EingabeClick 

OnMouseUp = EingabeMouseUp 

Items.Data = { 

010000001D000000010000000100000001000000FFFFFFFF0000000004000000 

0454696D6527000000020000000200000002000000FFFFFFFF00000000000000 

000E5A5F642F2F5461673A3A3336353028000000020000000200000002000000 

FFFFFFFF00000000000000000F5A5F6D2F2F4D6F6E74683A3A31323026000000 

020000000200000002000000FFFFFFFF00000000000000000D5A5F792F2F5965 

61723A3A31302B000000020000000200000002000000FFFFFFFF000000000000 

0000125A5F2A2F2F54696D6520746F74616C3A3A31} 

end 

object Eingabemerk: TTreeView 

Left = 432 

Top = 272 

Width = 97 

Height = 57 

Indent = 19 

TabOrder = 5 


end 

object Keyboxmerk: TListBox 

Left = 448 

Top = 160 

Width = 81 

Height = 57 


TabOrder = 6 


end 

- 400 -



object APA_popup: TPopupMenu 

Left = 424 

Top = 64 

object Insertdimension1: TMenuItem 

Caption = 'Insert dimension' 

OnClick = Insertdimension1Click 

end 

object Inserthierarchy1: TMenuItem 

Caption = 'Insert hierarchy' 

OnClick = Inserthierarchy1Click 

end 

object Delete1: TMenuItem 


OnClick = Delete1Click 

end 

object Edit1: TMenuItem 


OnClick = Edit1Click 

end 


Caption = '-' 

end 

object Dimensionup1: TMenuItem 

Caption = 'Dimension up' 

OnClick = Dimensionup1Click 

end 

object Dimensiondown1: TMenuItem 

Caption = 'Dimension down' 

OnClick = Dimensiondown1Click 

end 


Caption = '-' 

end 

object Hierarchyup1: TMenuItem 

Caption = 'Hierarchy up' 

OnClick = Hierarchyup1Click 

end 

object Hierarchydown1: TMenuItem 

Caption = 'Hierarchy down' 

ImageIndex = 0 

OnClick = Hierarchydown1Click 

end 

end 

object APA_ImageList: TImageList 

Left = 504 

Top = 72 

Bitmap = { 

494C010103000400040010001000FFFFFFFFFF10FFFFFFFFFFFFFFFF424D3600 

0000000000003600000028000000400000001000000001002000000000000010 

000000000000000000000000000000000000344E4A006BB09B006BB09B006BB0 

. . . 

. . . 

0000800100010000000080010001000000008001000100000000800100010000 

0000800100010000000080010001000000008001000100000000800100010000 

00008001000100000000FFFFFFFF000000000000000000000000000000000000 

000000000000} 

end 

end 

12.1.19 UNIT APA_INPUT_SCREENUNIT.PAS 

unit APA_Input_Screenunit; 

interface 

uses 


Dialogs, ImgList, ComCtrls, Menus, StdCtrls, ExtCtrls; 

type 

TAPA_Input_Screen = class(TForm) 


- 401 -



Saveandexit_button: TButton; 

Abortandexit_button: TButton; 


Button_insert_dimension: TButton; 

Button_delete: TButton; 

Button_Edit: TButton; 

Button_insert_hierarchy: TButton; 


APA_dimbox: TGroupBox; 

Button_dim_up: TButton; 

Button_dim_down: TButton; 

APA_hierbox: TGroupBox; 

button_hier_up: TButton; 

Button_hier_down: TButton; 

GroupBox1: TGroupBox; 


Button_key_insert: TButton; 

Button_key_edit: TButton; 

Button_key_delete: TButton; 

Keybox: TListBox; 

APA_popup: TPopupMenu; 

Insertdimension1: TMenuItem; 

Inserthierarchy1: TMenuItem; 

Delete1: TMenuItem; 

Edit1: TMenuItem; 


Dimensionup1: TMenuItem; 

Dimensiondown1: TMenuItem; 


Hierarchyup1: TMenuItem; 

Hierarchydown1: TMenuItem; 

Eingabe: TTreeView; 

APA_ImageList: TImageList; 

Eingabemerk: TTreeView; 

Keyboxmerk: TListBox; 

procedure Button_insert_dimensionClick(Sender: TObject); 

procedure Button_EditClick(Sender: TObject); 

procedure Button_deleteClick(Sender: TObject); 

procedure Button_insert_hierarchyClick(Sender: TObject); 

procedure Delete1Click(Sender: TObject); 

procedure Insertdimension1Click(Sender: TObject); 

procedure Inserthierarchy1Click(Sender: TObject); 

procedure Edit1Click(Sender: TObject); 

procedure Dimensionup1Click(Sender: TObject); 

procedure Dimensiondown1Click(Sender: TObject); 

procedure Hierarchyup1Click(Sender: TObject); 

procedure Hierarchydown1Click(Sender: TObject); 

procedure Button_dim_upClick(Sender: TObject); 

procedure Button_dim_downClick(Sender: TObject); 

procedure button_hier_upClick(Sender: TObject); 

procedure Button_hier_downClick(Sender: TObject); 

procedure Saveandexit_buttonClick(Sender: TObject); 

procedure EingabeClick(Sender: TObject); 

procedure EingabeMouseUp(Sender: TObject; Button: TMouseButton; 


procedure Button_key_insertClick(Sender: TObject); 

procedure Button_key_deleteClick(Sender: TObject); 

procedure Button_key_editClick(Sender: TObject); 

procedure KeyboxDblClick(Sender: TObject); 

procedure Abortandexit_buttonClick(Sender: TObject); 


procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean); 

private 


public 


end; 

var 

APA_Input_Screen: TAPA_Input_Screen; 

generiereapaneu:boolean=true; 


uses APA_Input_Dimensionunit, APA_Input_Hierarchyunit, APA_Keyunit, APA_Gridunit, 

- 402 -



APA_Applicationunit, APA_Dialogunit; 

{$R *.dfm} 

var neuekosten:boolean; 

procedure TAPA_Input_Screen.Button_insert_dimensionClick(Sender: TObject); 

var merkex:longint; 

var ok:boolean; 

begin 


if (Eingabe.SelectedNil) then begin 

{Setze den Zeiger auf eine Dimension oder auf das erste Element} 

while (Eingabe.Selected.ImageIndex1)and(Eingabe.Selected.GetPrevnil) do 

Eingabe.Selected:=Eingabe.Selected.GetPrev; 

end; 

{Eine Dimension} 

APA_Insert_Dimension.Dimension.Text:=''; 

APA_Insert_Dimension.OKBtn.Enabled:=false; 

repeat; 

ok:=true; 

if APA_Insert_Dimension.showmodal=mrOK then begin 

for merkex:=0 to Eingabe.Items.Count-1 do begin 

if Eingabe.Items[merkex].ImageIndex=1 then begin 

if Eingabe.Items[merkex].Text=APA_Insert_Dimension.Dimension.Text then begin 

showmessage('The name '+APA_Insert_Dimension.Dimension.Text+' for a dimension is 

already used. Please change the name!'); 

ok:=false; 

end; 

end; 

end; 

if ok=true then begin 

merkex:=Eingabe.Items.Add(Eingabe.Selected,APA_Insert_Dimension.Dimension.Text).Ab 

soluteIndex; 

Eingabe.Items[merkex].ImageIndex:=1; 

Eingabe.Items[merkex].SelectedIndex:=1; 

Saveandexit_button.Enabled:=true; 


end; 

end else ok:=true; 

until ok=true; 

{Eine Dimension ENDE} 

Eingabeclick(self); 

if (Eingabe.SelectedNil) then Eingabe.Selected.Expanded:=true; 

end; 

procedure TAPA_Input_Screen.Button_EditClick(Sender: TObject); 



begin 


if (Eingabe.Selected.ImageIndex=1) then begin 

{Eine Dimension} 

APA_Insert_Dimension.Dimension.Text:=Eingabe.Selected.Text; 

APA_Insert_Dimension.OKBtn.Enabled:=false; 

repeat; 

ok:=true; 

if APA_Insert_Dimension.showmodal=mrOK then begin 



if (Eingabe.Items[merkex].Text=APA_Insert_Dimension.Dimension.Text)and 

(merkexEingabe.Selected.AbsoluteIndex) 

then begin 

showmessage('The name '+APA_Insert_Dimension.Dimension.Text+' for a dimension is 

already used. Please change the name!'); 

ok:=false; 

- 403 -



end; 

end; 

end; 


Eingabe.Selected.Text:=APA_Insert_Dimension.Dimension.Text; 



end; 



{Eine Dimension ENDE} 


{Eine Hierarchy} 

APA_Insert_Hierarchy.short_hierarchy.Text:= 

copy(Eingabe.Selected.Text,1,pos('//',Eingabe.Selected.Text)-1); 

APA_Insert_Hierarchy.long_hierarchy.Text:= 

copy(Eingabe.Selected.Text,pos('//',Eingabe.Selected.Text)+2,pos('::',Eingabe.Sele 

cted.Text)-(pos('//',Eingabe.Selected.Text)+2)); 

APA_Insert_Hierarchy.datarecords.Text:= 

copy(Eingabe.Selected.Text,pos('::',Eingabe.Selected.Text)+2,255); 

APA_Insert_Hierarchy.OKBtn.Enabled:=false; 

repeat; 

ok:=true; 

if APA_Insert_Hierarchy.showmodal=mrOK then begin 



if (copy(Eingabe.Items[merkex].Text,1,pos('//',Eingabe.Items[merkex].Text)- 

1)=APA_Insert_Hierarchy.short_hierarchy.Text)and 

(merkexEingabe.Selected.AbsoluteIndex) then begin 

showmessage('The name '+APA_Insert_Hierarchy.short_hierarchy.Text+' for a short 

hierarchy is already used. Please change the name!'); 

ok:=false; 

end; 

end; 

end; 


Eingabe.Selected.Text:= 

APA_Insert_Hierarchy.short_hierarchy.Text+'//'+APA_Insert_Hierarchy.long_hierarchy 

.Text+'::'+ 

APA_Insert_Hierarchy.datarecords.Text; 



end; 



{Eine Hierarchy ENDE} 

end; 


end; 

procedure TAPA_Input_Screen.Button_deleteClick(Sender: TObject); 

begin 


if Eingabe.Selectednil then begin 

if Eingabe.Selected.ImageIndex=2 then neuekosten:=true; 

Eingabe.Items.Delete(Eingabe.Selected); 



end else showmessage('No dimension or hierarchy selected.'); 


end; 

procedure TAPA_Input_Screen.Button_insert_hierarchyClick(Sender: TObject); 


- 404 -




var counter,merkdatacount,merkdatacount2:longint; 

var merketext1,merketext2:string; 

begin 



{Eine Hierarchy} 

APA_Insert_Hierarchy.short_hierarchy.Text:=''; 

APA_Insert_Hierarchy.long_hierarchy.Text:=''; 

APA_Insert_Hierarchy.OKBtn.Enabled:=false; 

repeat; 

ok:=true; 

if APA_Insert_Hierarchy.showmodal=mrOK then begin 



if copy(Eingabe.Items[merkex].Text,1,pos('//',Eingabe.Items[merkex].Text)- 

1)=APA_Insert_Hierarchy.short_hierarchy.Text then begin 

showmessage('The name '+APA_Insert_Hierarchy.short_hierarchy.Text+' for a short 

hierarchy is already used. Please change the name!'); 

ok:=false; 

end; 

end; 

end; 


if Eingabe.Selected.ImageIndex=1 then begin; 

{wenn Dimension markiert} 

merkex:=Eingabe.Items.AddChild(Eingabe.Selected, 


.Text 

+'::'+APA_Insert_Hierarchy.datarecords.Text).AbsoluteIndex; 



end 

else 

{wenn Hierarchy markiert} 

merkex:=Eingabe.Items.Add(Eingabe.Selected, 


.Text 

+'::'+APA_Insert_Hierarchy.datarecords.Text).AbsoluteIndex; 





neuekosten:=true; 

end;//von ok 



{Eine Hierarchy ENDE} 

end else showmessage('No Item selected!'); 


if (Eingabe.SelectedNil) then Eingabe.Selected.Expanded:=true; 

//Sortieren der Hierarchien 

counter:=0; 

repeat; 

if (counter


end; 


merkdatacount2:=strtoint(copy(Eingabe.Items[counter+1].Text,pos('::',Eingabe.Items 

[counter+1].Text)+2,255)); 

if merkdatacount






Eingabe.Repaint; 

end; 

procedure TAPA_Input_Screen.Button_dim_downClick(Sender: TObject); 

begin 


if Eingabe.Selectednil then 

if Eingabe.Selected.ImageIndex=1 then 

if Eingabe.Selected.getNextSiblingnil then 

if Eingabe.Selected.getNextSibling.ImageIndex=1 then 

Eingabe.Selected.getNextSibling.MoveTo(Eingabe.Selected,naInsert); 




end; 

procedure TAPA_Input_Screen.button_hier_upClick(Sender: TObject); 

var merke1,merke2:string; 

begin 




if Eingabe.Selected.GetPrevNil then 

if (Eingabe.Selected.GetPrev.ImageIndex=2) then begin; 

merke1:=Eingabe.Selected.Text; 

merke2:=Eingabe.Selected.getprev.Text; 

if strtoint(copy(merke2,pos('::',merke2)+2,255))> 

strtoint(copy(merke1,pos('::',merke1)+2,255)) then 

begin; 

Eingabe.Selected.Text:=copy(merke1,1,pos('::',merke1)+1)+ 

copy(merke2,pos('::',merke2)+2,255); 

Eingabe.Selected.Getprev.Text:=copy(merke2,1,pos('::',merke2)+1)+ 


end; 

Eingabe.Selected.MoveTo(Eingabe.Selected.GetPrev,naInsert); 

end; 




end; 

procedure TAPA_Input_Screen.Button_hier_downClick(Sender: TObject); 

var merke1,merke2:string; 

begin 




If Eingabe.Selected.GetNextnil then 

If Eingabe.Selected.GetNext.ImageIndex=2 then begin; 

merke1:=Eingabe.Selected.Text; 

merke2:=Eingabe.Selected.getnext.Text; 

if strtoint(copy(merke2,pos('::',merke2)+2,255))< 

strtoint(copy(merke1,pos('::',merke1)+2,255)) then 

begin; 

Eingabe.Selected.Text:=copy(merke1,1,pos('::',merke1)+1)+ 


Eingabe.Selected.GetNext.Text:=copy(merke2,1,pos('::',merke2)+1)+ 


- 407 -



end; 

Eingabe.Selected.GetNext.MoveTo(Eingabe.Selected,naInsert); 

end; 




end; 

procedure buttonchange; 

begin; 

with APA_Input_Screen do begin 


if Eingabe.Selected.ImageIndex=1 then begin 

{dimension} 

APA_dimbox.Enabled:=true; 

APA_hierbox.Enabled:=false; 

If Eingabe.Selected.getPrevSiblingnil then 

Button_dim_up.Enabled:=true else Button_dim_up.Enabled:=false; 

If Eingabe.Selected.getNextSiblingnil then 

Button_dim_down.Enabled:=true else Button_dim_down.Enabled:=false; 

button_hier_up.Enabled:=false; 

Button_hier_down.Enabled:=false; 

end else 

begin 

{Hierarchy} 

APA_dimbox.Enabled:=false; 

APA_hierbox.Enabled:=true; 

Button_dim_up.Enabled:=false; 

Button_dim_down.Enabled:=false; 

If Eingabe.Selected.getPrevSiblingnil then 

Button_hier_up.Enabled:=true else Button_hier_up.Enabled:=false; 

If Eingabe.Selected.getNextSiblingnil then 

Button_hier_down.Enabled:=true else Button_hier_down.Enabled:=false; 

end; 

end else 

begin 

APA_dimbox.Enabled:=false; 

APA_hierbox.Enabled:=false; 

Button_dim_up.Enabled:=false; 

Button_dim_down.Enabled:=false; 

button_hier_up.Enabled:=false; 

Button_hier_down.Enabled:=false; 

end; 

end; 

end; 

procedure TAPA_Input_Screen.Saveandexit_buttonClick(Sender: TObject); 

var counter,maxchilds,merkdatacount:longint; 

CurItem,lastdim,nrmaxchilds:TTreeNode; 

begin 

Saveandexit_button.Enabled:=false; 


//Überprüfe die richte Anordung der Hierarchien 

merkdatacount:=0; 

for counter:=0 to Eingabe.Items.Count-1 do begin 

If Eingabe.Items[counter].ImageIndex=1 then begin 

//Wert neu 

merkdatacount:=0; 


if ((merkdatacount=0)or 

(merkdatacount> 

strtoint(copy(Eingabe.Items[counter].Text,pos('::',Eingabe.Items[counter].Text)+2, 

255)))) 

then begin 

- 408 -


end; 

end; 


merkdatacount:=strtoint(copy(Eingabe.Items[counter].Text,pos('::',Eingabe.Items[co 

unter].Text)+2,255)); 


//Fehler 

showmessage('Hierarchies are not in right order. Please check '+ 

copy(Eingabe.Items[counter].Text,pos('//',Eingabe.Items[counter].Text)+2, 

pos('::',Eingabe.Items[counter].Text)-(pos('//',Eingabe.Items[counter].Text)+2))); 

exit; 

end; 


{Setze die Dimension mit den meisten Unterknoten nach unten} 

lastdim:=nil; 

CurItem:=Eingabe.Items.GetFirstNode;nrmaxchilds:=CurItem; 

while nrmaxchildslastdim do begin 

CurItem:=Eingabe.Items.GetFirstNode;nrmaxchilds:=CurItem; 

maxchilds:=0; 

while CurItemnil do begin 

if maxchilds






APA_Insert_Key.Key_Fieldname.Text:=''; 

APA_Insert_Key.APA_Function.ItemIndex:=0; 

APA_Insert_Key.APA_Field_type.ItemIndex:=4; 

APA_Insert_Key.OKBtn.enabled:=false; 

repeat; 

ok:=true; 

if APA_Insert_Key.showmodal=mrOK then begin 

for counter:=0 to Keybox.Items.Count-1 do begin 

if (APA_Insert_Key.Key_fieldname.Text= 

copy(Keybox.items[counter],1,pos('//',Keybox.items[counter])-1)) then begin 

ok:=false; 

showmessage('The name '+APA_Insert_Key.Key_fieldname.Text+' is already used. 

Please change the name!'); 

end; 

end; 


Keybox.Items.Add(APA_Insert_Key.Key_fieldname.Text+'//'+APA_Insert_Key.APA_Functio 

n.Items[APA_Insert_Key.APA_Function.itemindex] 

+'('+APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.itemindex]+ 

')'); 


end; 



end; 

procedure TAPA_Input_Screen.Button_key_deleteClick(Sender: TObject); 

begin 


if keybox.ItemIndex-1 then begin 


Keybox.Items.Delete(Keybox.ItemIndex); 


end 

else 

showmessage('No Key figure selected'); 

end; 

procedure TAPA_Input_Screen.Button_key_editClick(Sender: TObject); 


counter:longint; 

begin 


if Keybox.ItemIndex-1 then begin 

APA_Insert_Key.APA_Function.ItemIndex:= 

APA_Insert_Key.APA_Function.Items.IndexOf(copy(Keybox.items[Keybox.itemindex],pos( 

'//', 

Keybox.items[Keybox.itemindex])+2,3)); 

APA_Insert_Key.Key_fieldname.Text:= 

copy(Keybox.items[Keybox.itemindex],1,pos('//',Keybox.items[Keybox.itemindex])-1); 

APA_Insert_Key.APA_Field_type.ItemIndex:= 

APA_Insert_Key.APA_Field_type.Items.IndexOf( 

copy(Keybox.items[Keybox.itemindex],pos('//',Keybox.items[Keybox.itemindex])+6, 

length(Keybox.items[Keybox.itemindex])-(pos('//',Keybox.items[Keybox.itemindex])+6))); 

APA_Insert_Key.OKBtn.enabled:=false; 

repeat; 

ok:=true; 

if APA_Insert_Key.showmodal=mrOK then begin 

for counter:=0 to Keybox.Items.Count-1 do begin 

if (APA_Insert_Key.Key_fieldname.Text= 

copy(Keybox.items[counter],1,pos('//',Keybox.items[counter])-1)) 

- 410 -



and(counterKeybox.ItemIndex) 

then begin 

ok:=false; 

showmessage('The name '+APA_Insert_Key.Key_fieldname.Text+' is already used. 

Please change the name!'); 

end; 

end; 


Keybox.Items[Keybox.ItemIndex]:=APA_Insert_Key.Key_fieldname.Text+'//'+ 

APA_Insert_Key.APA_Function.Items[APA_Insert_Key.APA_Function.itemindex] 

+'('+APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.itemindex]+ 

')'; 

Saveandexit_button.Enabled:=true; mustsave:=true; 

end; 



end 

else showmessage('No Key figure selected'); 

end; 

procedure TAPA_Input_Screen.KeyboxDblClick(Sender: TObject); 

begin 

Button_key_edit.click; 

end; 

procedure TAPA_Input_Screen.Abortandexit_buttonClick(Sender: TObject); 

begin 

Saveandexit_button.Enabled:=false; 

keybox.Items.Clear; 

keybox.Items:=keyboxmerk.Items; 

Eingabe.Items.Clear; 

Eingabe.Items:=Eingabemerk.Items; 

end; 

procedure TAPA_Input_Screen.FormShow(Sender: TObject); 

begin 

//Speichere die aktuellen Eingabe 

keyboxmerk.Items.Clear; 

keyboxmerk.Items:=keybox.Items; 

Eingabemerk.Items.Clear; 

Eingabemerk.Items:=Eingabe.Items; 

neuekosten:=false; 

end; 

procedure TAPA_Input_Screen.FormCloseQuery(Sender: TObject; 

var CanClose: Boolean); 

var counter, merkcounter:longint; 

ok:boolean; 

begin 

{Kontrolliere, ob jede Dimension mindestens eine Hierarchie hat} 

ok:=true;merkcounter:=0; 

for counter:=0 to Eingabe.Items.Count-1 do begin 

if Eingabe.Items[counter].ImageIndex=1 then begin 

//wenn Dimension 

if ok=false //dann gibt es eine Hierarchie 

then begin 

showmessage('The dimension '+Eingabe.Items[merkcounter].Text+' do not have a 

hierarchy'); 

canClose:=false; 

end; 

ok:=false; merkcounter:=counter; 


//wenn Hierarchie 

ok:=true; 

- 411 -



end; 

end; 

if Saveandexit_button.Enabled=true then begin 

APA_Dialog.APA_Text.Caption:='Do you want to save your changes?'; 

if APA_Dialog.showmodal=mryes then Saveandexit_button.Click else 

Abortandexit_button.Click; 

end; 

end; 

end. 

12.1.20 UNIT APA_KEYUNIT.DFM 

object APA_Insert_Key: TAPA_Insert_Key 

Left = 234 

Top = 185 

ActiveControl = Key_fieldname 


Caption = 'APA Insert Key' 















Left = 12 

Top = 16 

Width = 297 

Height = 145 


end 


Left = 28 

Top = 25 

Width = 48 

Height = 13 

Caption = 'Fieldname' 

end 


Left = 28 

Top = 110 

Width = 42 

Height = 13 

Caption = 'Fieldtype' 

end 


Left = 28 

Top = 66 

Width = 41 

Height = 13 

Caption = 'Function' 

end 


Left = 83 

Top = 172 

Width = 75 

Height = 25 





- 412 -



TabOrder = 1 


end 


Left = 163 

Top = 172 

Width = 75 

Height = 25 

Cancel = True 



TabOrder = 2 

end 

object Key_fieldname: TEdit 

Left = 28 

Top = 41 

Width = 257 

Height = 21 


TabOrder = 0 

OnChange = Key_fieldnameChange 

end 

object APA_Field_type: TComboBox 

Left = 28 

Top = 126 

Width = 249 

Height = 21 

Style = csDropDownList 


ItemIndex = 0 

TabOrder = 3 

Text = 'BIGINT' 

OnChange = APA_Field_typeChange 


'BIGINT' 

'INT' 

'SMALLINT' 

'DECIMAL' 

'MONEY' 

'SMALLMONEY' 

'FLOAT' 

'REAL' 

'DATETIME' 

'SMALLDATETIME') 

end 

object APA_Function: TComboBox 

Left = 28 

Top = 82 

Width = 145 

Height = 21 



ItemIndex = 0 

TabOrder = 4 

Text = 'SUM' 

OnChange = APA_FunctionChange 


'SUM' 

'MAX' 

'MIN' 

'COUNT') 

end 

end 

12.1.21 UNIT APA_KEYUNIT.PAS 

unit APA_Keyunit; 

interface 

uses 


- 413 -



Dialogs, Spin, StdCtrls, ExtCtrls; 

type 

TAPA_Insert_Key = class(TForm) 





Key_fieldname: TEdit; 


APA_Field_type: TComboBox; 


APA_Function: TComboBox; 

procedure Key_fieldnameChange(Sender: TObject); 



procedure APA_FunctionChange(Sender: TObject); 

procedure APA_Field_typeChange(Sender: TObject); 

private 


public 


end; 

var 

APA_Insert_Key: TAPA_Insert_Key; 


{$R *.dfm} 

procedure TAPA_Insert_Key.Key_fieldnameChange(Sender: TObject); 

begin 


end; 

procedure TAPA_Insert_Key.OKBtnClick(Sender: TObject); 


begin 

if (pos('//',Key_Fieldname.Text)0) then begin; 

showmessage('Sting "//" is not allowed in Fieldname'); 

st:=Key_Fieldname.Text; 


Key_Fieldname.Text:=st; 

end; 

end; 

procedure TAPA_Insert_Key.FormShow(Sender: TObject); 

begin 

Key_Fieldname.SetFocus; 

end; 

procedure TAPA_Insert_Key.APA_FunctionChange(Sender: TObject); 

begin 


end; 

procedure TAPA_Insert_Key.APA_Field_typeChange(Sender: TObject); 

begin 


end; 

end. 

12.1.22 UNIT APA_OPTIONSUNIT.DFM 

object APA_Options: TAPA_Options 

Left = 223 

Top = 134 

Width = 454 

- 414 -



Height = 387 

Caption = 'APA Options' 












Left = 0 

Top = 312 

Width = 446 

Height = 41 


TabOrder = 0 


Left = 186 

Top = 8 

Width = 75 

Height = 25 

Cancel = True 



TabOrder = 0 


end 

end 

object PageControl1: TPageControl 

Left = 0 

Top = 0 

Width = 446 

Height = 312 

ActivePage = APA_On_Start 


TabOrder = 1 

object APA_On_Start: TTabSheet 

Caption = 'On Start' 

object APA_Load_Last_APA: TCheckBox 

Left = 16 

Top = 16 

Width = 177 

Height = 31 

Caption = 'Load last APA' 


State = cbChecked 

TabOrder = 0 

end 

object APA_Remove_redundancy: TCheckBox 

Left = 16 

Top = 87 

Width = 177 

Height = 31 

Caption = 'Remove Redundancy' 

TabOrder = 1 

end 

object APA_Add_max_hier: TCheckBox 

Left = 16 

Top = 122 

Width = 153 

Height = 31 

Caption = 'Add max hierarchy' 



TabOrder = 2 

end 

object APA_Save_on_termination: TCheckBox 

Left = 17 

Top = 51 

Width = 200 

Height = 31 

- 415 -



Caption = 'Save APA on termination of program' 



TabOrder = 3 

end 

object APA_ShowScreenheuristic: TCheckBox 

Left = 16 

Top = 158 

Width = 265 

Height = 31 

Caption = 'Show process screen during heuristic execution' 



TabOrder = 4 

end 

object APA_Show_Link_on_Desktop: TCheckBox 

Left = 16 

Top = 192 

Width = 249 

Height = 17 

Caption = 'Show link on desktop' 



TabOrder = 5 

OnExit = APA_Show_Link_on_DesktopExit 

end 

end 

object APA_Path_Settings: TTabSheet 

Caption = 'Path Settings' 



Left = 16 

Top = 16 

Width = 49 

Height = 13 

Caption = 'Savepath:' 

end 

object APA_Save_Path: TDirectoryListBox 

Left = 16 

Top = 48 

Width = 417 

Height = 129 


TabOrder = 0 

end 

end 

end 

end 

12.1.23 UNIT APA_OPTIONSUNIT.PAS 

unit APA_Optionsunit; 

interface 

uses 


Dialogs, StdCtrls, ExtCtrls, ComCtrls, DB, DBTables, FileCtrl; 

type 

TAPA_Options = class(TForm) 



PageControl1: TPageControl; 

APA_On_Start: TTabSheet; 

APA_Load_Last_APA: TCheckBox; 

APA_Remove_redundancy: TCheckBox; 

APA_Add_max_hier: TCheckBox; 

APA_Path_Settings: TTabSheet; 


APA_Save_Path: TDirectoryListBox; 

APA_Save_on_termination: TCheckBox; 

- 416 -



APA_ShowScreenheuristic: TCheckBox; 

APA_Show_Link_on_Desktop: TCheckBox; 


procedure APA_Show_Link_on_DesktopExit(Sender: TObject); 

private 


public 


end; 

var 

APA_Options: TAPA_Options; 


uses APA_Applicationunit; 

{$R *.dfm} 

procedure TAPA_Options.Button1Click(Sender: TObject); 

begin 

Close; 

end; 

procedure TAPA_Options.APA_Show_Link_on_DesktopExit(Sender: TObject); 

var fStreamladen,fStreamspeichern:TFileStream; 

begin 

if APA_Options.APA_Show_Link_on_Desktop.Checked=true then begin 

if fileexists(APA_Application.shelldir.Path+'\APAWin.lnk')=false then begin 

try 

fStreamLaden:=TFileStream.Create('c:\APADIR\PROGRAM\APAWin.lnk',fmOpenRead); 

try 

fStreamSpeichern:=TFileStream.Create(APA_Application.shelldir.Path+'\APAWin.lnk',f 

mCreate); 


finally 


end; 

finally 


end; 


//Löschen 

if fileexists(APA_Application.shelldir.Path+'\APAWin.lnk')=true then begin 

try 

deletefile(APA_Application.shelldir.Path+'\APAWin.lnk'); 

except 

showmessage('Can not remove link from Desktop'); 

end; 

end; 

end; 

end; 

end; 

end. 

12.1.24 UNIT APA_PARAMETERUNIT.DFM 

object APA_Parameter: TAPA_Parameter 

Left = 280 

Top = 188 


Caption = 'APA Parameter' 






- 417 -








OnClose = FormClose 

OnCreate = FormCreate 





Left = 0 

Top = 442 

Width = 399 

Height = 41 


TabOrder = 0 


Left = 134 

Top = 8 

Width = 75 

Height = 25 


TabOrder = 0 


end 

end 

object APA_Parameter_Control: TPageControl 

Left = 0 

Top = 0 

Width = 399 

Height = 442 

ActivePage = APA_Active_heuristicsheet 


TabOrder = 1 

object APA_Active_heuristicsheet: TTabSheet 

Caption = 'Heuristic && Algorithms parameters' 


Left = 0 

Top = 0 

Width = 391 

Height = 161 

Align = alTop 

Caption = 'Thomas Achs heuristic parameters' 

TabOrder = 0 


Left = 24 

Top = 24 

Width = 128 

Height = 13 

Caption = 'New Sets on each iteration' 

end 


Left = 24 

Top = 72 

Width = 116 

Height = 13 

Caption = 'Count of Sets calculated' 

end 

object APA_Thomas_newsetsoneachiteration: TMaskEdit 

Left = 24 

Top = 40 

Width = 33 

Height = 21 

EditMask = '0##;0; ' 

MaxLength = 3 

TabOrder = 0 

OnExit = APA_Thomas_newsetsoneachiterationExit 

end 

object APA_Thomas_countofsets: TMaskEdit 

Left = 24 

Top = 88 

Width = 39 

Height = 21 

- 418 -



EditMask = '0###;0; ' 

MaxLength = 4 

TabOrder = 1 

OnExit = APA_Thomas_countofsetsExit 

end 

end 

end 

object Thomas_Achs_heuristic: TTabSheet 

Caption = 'Cost function parameters' 

object tomstorelabel: TLabel 

Left = 38 

Top = 318 

Width = 139 

Height = 13 

Caption = 'Storage importantance: 25 % ' 

end 

object tomtimelabel: TLabel 

Left = 201 

Top = 318 

Width = 122 

Height = 13 

Alignment = taRightJustify 

Caption = 'Time importantance: 75 %' 

end 


Left = 144 

Top = 264 

Width = 81 

Height = 20 

Caption = 'Importance' 







end 

object tommatcosts: TLabel 

Left = 42 

Top = 396 

Width = 127 

Height = 13 

Caption = 'Materialisation costs: 25 % ' 

end 

object tomquerycosts: TLabel 

Left = 242 

Top = 396 

Width = 85 

Height = 13 


Caption = 'Query costs: 75 %' 

end 


Left = 159 

Top = 342 

Width = 50 

Height = 20 

Caption = 'Weight' 







end 

object APA_Thomas_Importance: TTrackBar 

Left = 41 

Top = 286 

Width = 281 

Height = 25 

Hint = 'Select the weight of ' 

Max = 100 

ParentShowHint = False 

Frequency = 5 

- 419 -



Position = 10 

ShowHint = True 

TabOrder = 0 

TickMarks = tmBoth 

OnChange = APA_Thomas_ImportanceChange 

end 

object APA_Thomas_Query_Importance: TTrackBar 

Left = 44 

Top = 366 

Width = 281 

Height = 25 

Hint = 'Select the weight of ' 

Max = 100 

ParentShowHint = False 

Frequency = 5 

Position = 10 

ShowHint = True 

TabOrder = 1 

TickMarks = tmBoth 

OnChange = APA_Thomas_Query_ImportanceChange 

end 


Left = 0 

Top = 161 

Width = 391 

Height = 88 

Align = alTop 

Caption = 'Sizeoriented Parameters' 

TabOrder = 2 


Left = 52 

Top = 19 

Width = 158 

Height = 26 


Caption = 'Average size in bytes per tupel in BFT in space units:' 

WordWrap = True 

end 


Left = 50 

Top = 47 

Width = 160 

Height = 26 


Caption = 

'Max available storage space for Materialized Cubes in space unit' + 

's:' 


end 

object APA_Thomas_avsizeoftupel: TMaskEdit 

Left = 219 

Top = 22 

Width = 144 

Height = 21 

EditMask = '0###########;0; ' 


TabOrder = 0 

OnChange = APA_Thomas_timemaxChange 

OnExit = APA_Thomas_avsizeoftupelExit 

end 

object APA_Thomas_spacemax: TMaskEdit 

Left = 219 

Top = 50 

Width = 144 

Height = 21 

EditMask = '0#####################;0; ' 


TabOrder = 1 


OnExit = APA_Thomas_spacemaxExit 

end 

end 


Left = 0 

- 420 -



Top = 0 

Width = 391 

Height = 161 

Align = alTop 

Caption = 'Timeoriented Parameters' 

TabOrder = 3 


Left = 14 

Top = 49 

Width = 196 

Height = 13 


Caption = 'Average time for IO per tupel in time units:' 

end 


Left = 50 

Top = 94 

Width = 160 

Height = 26 


Caption = 'Max available time in time units to Build Materialized Cubes :' 


end 


Left = 43 

Top = 14 

Width = 167 

Height = 26 


Caption = 

'Average time to store a tupel (Build materialized views) in time' + 

' units:' 


end 


Left = 57 

Top = 124 

Width = 157 

Height = 26 


Caption = 'Maximal average time to query in time units:' 


end 


Left = 7 

Top = 76 

Width = 204 

Height = 13 


Caption = 'Average time of CPU per tupel in time units:' 

end 

object APA_Thomas_timestore: TMaskEdit 

Left = 218 

Top = 17 

Width = 158 

Height = 21 

TabOrder = 0 

Text = '2' 


OnExit = APA_Thomas_timestoreExit 

end 

object APA_Thomas_timeio: TMaskEdit 

Left = 218 

Top = 45 

Width = 158 

Height = 21 

TabOrder = 1 

Text = '2' 


OnExit = APA_Thomas_timeioExit 

end 

object APA_Thomas_timemax: TMaskEdit 

Left = 218 

Top = 100 

- 421 -



Width = 155 

Height = 21 

EditMask = '0###########;0; ' 


TabOrder = 3 


OnExit = APA_Thomas_timemaxExit 

end 

object APA_Thomas_querytimemax: TMaskEdit 

Left = 218 

Top = 127 

Width = 157 

Height = 21 

TabOrder = 4 

Text = '20' 


OnExit = APA_Thomas_querytimemaxExit 

end 

object APA_Thomas_timecpu: TMaskEdit 

Left = 218 

Top = 73 

Width = 151 

Height = 21 

TabOrder = 2 


OnExit = APA_Thomas_timecpuExit 

end 

end 

end 

object Values_of_Cubes: TTabSheet 

Caption = 'Degrees of requirements' 


Left = 0 

Top = 0 

Width = 391 

Height = 137 

Align = alTop 

TabOrder = 0 


Left = 8 

Top = 8 

Width = 101 

Height = 13 

Caption = 'Description of degree' 

end 


Left = 8 

Top = 48 

Width = 77 

Height = 13 

Caption = 'Count of queries' 

end 

object APA_Description_of_degree: TEdit 

Left = 8 

Top = 24 

Width = 201 

Height = 21 


TabOrder = 0 

end 


Left = 1 

Top = 96 

Width = 389 

Height = 40 


TabOrder = 2 

object APA_Degree_Insert: TButton 

Left = 21 

Top = 8 

Width = 55 

Height = 25 


TabOrder = 0 

- 422 -



OnClick = APA_Degree_InsertClick 

end 

object APA_Degree_Edit: TButton 

Left = 85 

Top = 8 

Width = 55 

Height = 25 


TabOrder = 1 

OnClick = APA_Degree_EditClick 

end 

object APA_Degree_Save: TButton 

Left = 149 

Top = 8 

Width = 55 

Height = 25 

Caption = 'Save' 


TabOrder = 2 

OnClick = APA_Degree_SaveClick 

end 

object APA_Degree_Delete: TButton 

Left = 213 

Top = 8 

Width = 55 

Height = 25 


TabOrder = 3 

OnClick = APA_Degree_DeleteClick 

end 

object APA_Degree_Abort: TButton 

Left = 277 

Top = 7 

Width = 55 

Height = 25 

Caption = 'Abort' 


TabOrder = 4 

OnClick = APA_Degree_AbortClick 

end 

end 

object APA_Count_of_Queries: TMaskEdit 

Left = 9 

Top = 64 

Width = 136 

Height = 21 


EditMask = '0###############;0; ' 


TabOrder = 1 


OnExit = APA_Count_of_QueriesExit 

end 

end 


Left = 0 

Top = 137 

Width = 42 

Height = 277 


TabOrder = 1 

object APA_Degree_up: TBitBtn 

Left = 5 

Top = 4 

Width = 28 

Height = 25 

Caption = 'UP' 

TabOrder = 0 

OnClick = APA_Degree_upClick 

Layout = blGlyphTop 

end 

object APA_Degree_Down: TBitBtn 

Left = 0 

Top = 36 

- 423 -



Width = 39 

Height = 25 

Caption = 'DOWN' 

TabOrder = 1 

OnClick = APA_Degree_DownClick 

Layout = blGlyphTop 

end 

end 


Left = 258 

Top = 137 

Width = 133 

Height = 277 

Align = alRight 

Caption = 'Count of queries' 

TabOrder = 2 

object APA_Degreecounts: TListBox 

Left = 2 

Top = 15 

Width = 129 

Height = 260 




'10000' 

'1000' 

'1') 

TabOrder = 0 

OnClick = APA_DegreecountsClick 

end 

end 


Left = 42 

Top = 137 

Width = 216 

Height = 277 


Caption = 'Description of degree' 

TabOrder = 3 

object APA_Degrees: TListBox 

Left = 2 

Top = 15 

Width = 212 

Height = 260 




'High Importance' 

'Normal Importance' 

'Unimportant') 

TabOrder = 0 

OnClick = APA_DegreesClick 

end 

end 

end 

object APA_Colors_of_Degrees: TTabSheet 

Caption = 'Colors of Requirements' 



Left = 0 

Top = 0 

Width = 391 

Height = 41 

Align = alTop 

TabOrder = 0 

object APA_Changecolorbutton: TButton 

Left = 8 

Top = 8 

Width = 121 

Height = 25 

Caption = 'Change color' 

TabOrder = 0 

OnClick = APA_ChangecolorbuttonClick 

end 

- 424 -



end 

object Colorsgrid: TDrawGrid 

Left = 0 

Top = 41 

Width = 391 

Height = 373 


ColCount = 1 

DefaultColWidth = 300 

FixedCols = 0 

RowCount = 15 

FixedRows = 0 

Options = [goFixedVertLine, goFixedHorzLine, goVertLine, goHorzLine, 

goRangeSelect, goRowSelect] 

TabOrder = 1 

OnDrawCell = ColorsgridDrawCell 

RowHeights = ( 

24 

24 

24 

24 

24 

24 

24 

24 

24 

24 

24 

24 

24 

24 

24) 

end 

end 

end 

object ColorDialog: TColorDialog 

Left = 308 

Top = 280 

end 

end 

12.1.25 UNIT APA_PARAMETERUNIT.PAS 

unit APA_Parameterunit; 

interface 

uses 


Dialogs, ComCtrls, StdCtrls, ExtCtrls, Buttons, Grids, Mask; 

type 

TAPA_Parameter = class(TForm) 



APA_Parameter_Control: TPageControl; 

Values_of_Cubes: TTabSheet; 



APA_Description_of_degree: TEdit; 


APA_Degree_Insert: TButton; 

APA_Degree_Edit: TButton; 

APA_Degree_Save: TButton; 

APA_Degree_Delete: TButton; 



APA_Degree_up: TBitBtn; 

APA_Degree_Down: TBitBtn; 

APA_Active_heuristicsheet: TTabSheet; 

Thomas_Achs_heuristic: TTabSheet; 

- 425 -




APA_Degreecounts: TListBox; 


APA_Degrees: TListBox; 

APA_Degree_Abort: TButton; 

APA_Colors_of_Degrees: TTabSheet; 

ColorDialog: TColorDialog; 


APA_Changecolorbutton: TButton; 

Colorsgrid: TDrawGrid; 

tomstorelabel: TLabel; 

tomtimelabel: TLabel; 


APA_Thomas_Importance: TTrackBar; 

tommatcosts: TLabel; 

tomquerycosts: TLabel; 


APA_Thomas_Query_Importance: TTrackBar; 


APA_Thomas_newsetsoneachiteration: TMaskEdit; 


APA_Thomas_countofsets: TMaskEdit; 


APA_Count_of_Queries: TMaskEdit; 




APA_Thomas_avsizeoftupel: TMaskEdit; 

APA_Thomas_spacemax: TMaskEdit; 






APA_Thomas_timestore: TMaskEdit; 

APA_Thomas_timeio: TMaskEdit; 

APA_Thomas_timemax: TMaskEdit; 

APA_Thomas_querytimemax: TMaskEdit; 


APA_Thomas_timecpu: TMaskEdit; 




procedure APA_Degree_InsertClick(Sender: TObject); 

procedure APA_DegreesClick(Sender: TObject); 

procedure APA_DegreecountsClick(Sender: TObject); 

procedure APA_Degree_SaveClick(Sender: TObject); 

procedure APA_Degree_EditClick(Sender: TObject); 

procedure FormClose(Sender: TObject; var Action: TCloseAction); 

procedure APA_Degree_AbortClick(Sender: TObject); 

procedure APA_Degree_DeleteClick(Sender: TObject); 

procedure APA_Degree_upClick(Sender: TObject); 

procedure APA_Degree_DownClick(Sender: TObject); 

procedure ColorBox1Exit(Sender: TObject); 

procedure ColorsgridDrawCell(Sender: TObject; ACol, ARow: Integer; 


procedure APA_ChangecolorbuttonClick(Sender: TObject); 

procedure Colorsgrid2DrawCell(Sender: TObject; ACol, ARow: Integer; 


procedure APA_Thomas_ImportanceChange(Sender: TObject); 

procedure APA_Thomas_Query_ImportanceChange(Sender: TObject); 

procedure APA_Thomas_timemaxChange(Sender: TObject); 

procedure APA_Thomas_newsetsoneachiterationExit(Sender: TObject); 

procedure APA_Thomas_countofsetsExit(Sender: TObject); 

procedure APA_Thomas_timestoreExit(Sender: TObject); 

procedure APA_Thomas_timeioExit(Sender: TObject); 

procedure APA_Thomas_timecpuExit(Sender: TObject); 

procedure APA_Thomas_timemaxExit(Sender: TObject); 

procedure APA_Thomas_querytimemaxExit(Sender: TObject); 

procedure APA_Thomas_avsizeoftupelExit(Sender: TObject); 

procedure APA_Thomas_spacemaxExit(Sender: TObject); 

procedure APA_Count_of_QueriesExit(Sender: TObject); 

private 


- 426 -



public 


end; 

var 

APA_Parameter: TAPA_Parameter; 

DegreeColors:array[0..14] of TColor; 

Othercolors:array[0..14] of TColor; 


uses APA_Applicationunit, APA_Gridunit, APA_Selectionunit; 

{$R *.dfm} 

var degreeedit:longint=-2; 

procedure TAPA_Parameter.Button1Click(Sender: TObject); 

begin 

Close; 

end; 

procedure TAPA_Parameter.FormShow(Sender: TObject); 

begin 

APA_Thomas_ImportanceChange(self); 

APA_Thomas_Query_ImportanceChange(self); 

end; 

procedure TAPA_Parameter.FormCreate(Sender: TObject); 

begin 

APA_Parameter_Control.ActivePageIndex:=0; 

APA_Thomas_Importance.Position:=75; 

APA_Thomas_Query_Importance.Position:=75; 

//Standardfarben für Requirements festlegen 

DegreeColors[0]:=clBlue; 

DegreeColors[1]:=clMaroon; 

DegreeColors[2]:=clGreen; 

DegreeColors[3]:=clOlive; 

DegreeColors[4]:=clNavy; 

DegreeColors[5]:=clPurple; 

DegreeColors[6]:=clTeal; 

DegreeColors[7]:=clGray; 

DegreeColors[8]:=clRed; 

DegreeColors[9]:=clFuchsia; 

DegreeColors[10]:=clAqua; 

DegreeColors[11]:=clLtGray; 

DegreeColors[12]:=clCream; 

DegreeColors[13]:=clSkyBlue; 

DegreeColors[14]:=clMoneyGreen; 

OtherColors[0]:=clYellow; //Farbe für Rednundanzfrei 

OtherColors[1]:=clRed; //Farbe für materalisiert 

OtherColors[2]:=clBlack; //Farbe für Derivate 

end; 

procedure TAPA_Parameter.APA_Degree_InsertClick(Sender: TObject); 

begin 

if APA_Degrees.Items.Count




end else showmessage('Maxium Count of Entrys of 15 reached'); 

end; 

procedure TAPA_Parameter.APA_DegreesClick(Sender: TObject); 

begin 

APA_Degreecounts.ItemIndex:=APA_Degrees.ItemIndex; 

end; 

procedure TAPA_Parameter.APA_DegreecountsClick(Sender: TObject); 

begin 

APA_Degrees.ItemIndex:=APA_Degreecounts.ItemIndex; 

end; 

procedure TAPA_Parameter.APA_Degree_SaveClick(Sender: TObject); 

begin 


APA_Description_of_degree.Enabled:=false; 

APA_Count_of_Queries.Enabled:=false; 

APA_Degree_Insert.Enabled:=true; 

APA_Degree_Edit.Enabled:=true; 

APA_Degree_Save.Enabled:=false; 

APA_Degree_Delete.Enabled:=true; 

APA_Degree_Abort.Enabled:=false; 

if APA_Degree_Edit.tag=0 then begin 

APA_Degrees.Items.Add(APA_Description_of_degree.Text); 

APA_Degreecounts.Items.Add(APA_Count_of_Queries.Text); 


APA_Degrees.Items[APA_Degrees.itemindex]:=APA_Description_of_degree.Text; 

APA_Degreecounts.Items[APA_Degreecounts.ItemIndex]:=APA_Count_of_Queries.Text; 

end; 

APA_Degree_Edit.Tag:=0; 

end; 

procedure TAPA_Parameter.APA_Degree_EditClick(Sender: TObject); 

begin 

if APA_Degrees.ItemIndex-1 then begin 

APA_Description_of_degree.Enabled:=true; 

APA_Count_of_Queries.Enabled:=true; 

APA_Degree_Insert.Enabled:=false; 

APA_Degree_Edit.Enabled:=false; 

APA_Degree_Save.Enabled:=true; 

APA_Degree_Delete.Enabled:=false; 

APA_Degree_Abort.Enabled:=true; 

APA_Description_of_degree.Text:= APA_Degrees.Items[APA_Degrees.itemindex]; 

APA_Count_of_Queries.Text:= APA_Degreecounts.Items[APA_Degreecounts.itemindex]; 

APA_Description_of_degree.SetFocus; 

APA_Degree_Edit.Tag:=1;//Edit Mode setzen 


end else showmessage('No Entry selected'); 

end; 

procedure TAPA_Parameter.FormClose(Sender: TObject; 

var Action: TCloseAction); 

begin 

if APA_Degree_Edit.Tag=1 then begin 

if messagedlg('Do you want to save your changes?',mtconfirmation,[mbyes,mbno],0)=mryes 

then APA_Degree_Save.Click else APA_Degree_Abort.Click; 

end; 

end; 

procedure TAPA_Parameter.APA_Degree_AbortClick(Sender: TObject); 

begin 


APA_Description_of_degree.Enabled:=false; 

APA_Count_of_Queries.Enabled:=false; 

APA_Degree_Insert.Enabled:=true; 

- 428 -



APA_Degree_Edit.Enabled:=true; 

APA_Degree_Save.Enabled:=false; 

APA_Degree_Delete.Enabled:=true; 

APA_Degree_Abort.Enabled:=false; 

APA_Degree_Edit.Tag:=0; 

end; 

procedure TAPA_Parameter.APA_Degree_DeleteClick(Sender: TObject); 


var aktzeile,aktspalte:longint; 

begin 

if APA_Degrees.ItemIndex-1 then begin 

ok:=true; 



if APA[aktspalte,aktzeile].interessant=true then begin 

if APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex then begin 

ok:=false; 

end; 

end; 

end; 

end; 

if ok=false then showmessage('Degree is used in APA. Could not delete degree!'); 


for aktzeile:= 0 to APA_Selection_Screen.Listeint.items.count-1 do begin 

if copy(APA_Selection_Screen.Listeint.items[aktzeile],1,3)='Req' then begin 

if 

APA_Degrees.ItemIndex=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile], 

5,100)) then begin 

ok:=false; 

end; 

end; 

end; 

if ok=false then showmessage('Degree is used in Selection Screen. Could not delete 

degree!'); 

end; 


APA_Degreecounts.Items.Delete(APA_Degrees.ItemIndex); 

APA_Degrees.Items.Delete(APA_Degrees.ItemIndex); 


end; 


end; 

procedure TAPA_Parameter.APA_Degree_upClick(Sender: TObject); 


var aktspalte,aktzeile:longint; 

begin 

if (APA_Degrees.ItemIndex-1) then begin 

if (APA_Degrees.ItemIndex0) then begin 

ok:=true; 




if (APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex)or 

(APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex-1) then begin 

ok:=false; 

end; 

end; 

- 429 -


end; 

end; 


if ok=false then showmessage('Degree or upper degree is used in APA. Could not move 

degree!'); 




if 

(APA_Degrees.ItemIndex=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile] 

,5,100))) or 

(APA_Degrees.ItemIndex- 

1=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile],5,100)))then begin 

ok:=false; 

end; 

end; 

end; 

if ok=false then showmessage('Degree or upper degree is used in Selection Screen. Could 

not move degree!'); 

end; 


end; 

APA_Degrees.Items.Move(APA_Degrees.ItemIndex,APA_Degrees.ItemIndex-1); 


end else showmessage('Top Entry selected'); 


end; 

procedure TAPA_Parameter.APA_Degree_DownClick(Sender: TObject); 


var aktspalte,aktzeile:longint; 

begin 

if (APA_Degrees.ItemIndex-1) then begin 

if (APA_Degrees.ItemIndexAPA_Degrees.Items.Count-1) then begin 

ok:=true; 




if (APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex)or 

(APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex+1) then begin 

ok:=false; 

end; 

end; 

end; 

end; 

if ok=false then showmessage('Degree oder lower degree is used in APA. Could not move 

degree!'); 




if 

(APA_Degrees.ItemIndex=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile] 

,5,100)))or 

(APA_Degrees.ItemIndex+1=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeil 

e],5,100))) then begin 

ok:=false; 

end; 

end; 

end; 

if ok=false then showmessage('Degree or lower degree is used in Selection Screen. Could 

not move degree!'); 

end; 


- 430 -




APA_Degrees.Items.Move(APA_Degrees.ItemIndex,APA_Degrees.ItemIndex+1); 

end; 

end else showmessage('Last Entry selected'); 


end; 

procedure TAPA_Parameter.ColorBox1Exit(Sender: TObject); 

begin 

Colordialog.Execute; 

end; 

procedure TAPA_Parameter.ColorsgridDrawCell(Sender: TObject; ACol, 

ARow: Integer; Rect: TRect; State: TGridDrawState); 

begin 

Colorsgrid.Canvas.Brush.Color:=DegreeColors[Arow]; 

Colorsgrid.Canvas.FillRect(Rect); 

if Arow



procedure TAPA_Parameter.APA_Thomas_Query_ImportanceChange( 


begin 


tommatcosts.Caption:='Materialisation costs: '+ 

inttostr(100-APA_Thomas_Query_Importance.Position)+' %'; 

tomquerycosts.Caption:='Query costs: '+ 

inttostr(APA_Thomas_Query_Importance.Position)+' %'; 

end; 

procedure TAPA_Parameter.APA_Thomas_timemaxChange(Sender: TObject); 

begin 


end; 

procedure TAPA_Parameter.APA_Thomas_newsetsoneachiterationExit( 


begin 

APA_Thomas_newsetsoneachiteration.Text:= 

trim (APA_Thomas_newsetsoneachiteration.Text); 

try 

strtoint(APA_Thomas_newsetsoneachiteration.Text); 

except 

APA_Thomas_newsetsoneachiteration.Text:='2'; 

end; 

end; 

procedure TAPA_Parameter.APA_Thomas_countofsetsExit(Sender: TObject); 

begin 

APA_Thomas_countofsets.Text:= 

trim(APA_Thomas_countofsets.Text); 

try 

strtoint(APA_Thomas_countofsets.Text); 

except 

APA_Thomas_countofsets.Text:='10'; 

end; 

end; 

procedure TAPA_Parameter.APA_Thomas_timestoreExit(Sender: TObject); 

begin 

APA_Thomas_timestore.Text:= 

trim(APA_Thomas_timestore.Text); 

try 

strtofloat(APA_Thomas_timestore.Text); 

except 

APA_Thomas_timestore.Text:='2'; 

end; 

end; 

procedure TAPA_Parameter.APA_Thomas_timeioExit(Sender: TObject); 

begin 

APA_Thomas_timeio.Text:= 

trim(APA_Thomas_timeio.Text); 

try 

strtofloat(APA_Thomas_timeio.Text); 

except 

APA_Thomas_timeio.Text:='2'; 

end; 

end; 

procedure TAPA_Parameter.APA_Thomas_timecpuExit(Sender: TObject); 

begin 

APA_Thomas_timecpu.Text:= 

- 432 -



trim(APA_Thomas_timecpu.Text); 

try 

strtofloat(APA_Thomas_timecpu.Text); 

except 

APA_Thomas_timecpu.Text:='0,002'; 

end; 

end; 

procedure TAPA_Parameter.APA_Thomas_timemaxExit(Sender: TObject); 

begin 

APA_Thomas_timemax.Text:=trim(APA_Thomas_timemax.Text); 

try 

strtofloat(APA_Thomas_timemax.Text); 

except 

APA_Thomas_timemax.Text:='200000'; 

end; 

end; 

procedure TAPA_Parameter.APA_Thomas_querytimemaxExit(Sender: TObject); 

begin 

APA_Thomas_querytimemax.Text:=trim(APA_Thomas_querytimemax.Text); 

try 

strtofloat(APA_Thomas_querytimemax.Text); 

except 

APA_Thomas_querytimemax.Text:='20'; 

end; 

end; 

procedure TAPA_Parameter.APA_Thomas_avsizeoftupelExit(Sender: TObject); 

begin 

APA_Thomas_avsizeoftupel.Text:=trim(APA_Thomas_avsizeoftupel.Text); 

try 

strtofloat(APA_Thomas_avsizeoftupel.Text); 

except 

APA_Thomas_avsizeoftupel.Text:='32'; 

end; 

end; 

procedure TAPA_Parameter.APA_Thomas_spacemaxExit(Sender: TObject); 

begin 

APA_Thomas_spacemax.Text:=trim(APA_Thomas_spacemax.Text); 

try 

strtofloat(APA_Thomas_spacemax.Text); 

except 

APA_Thomas_spacemax.Text:='1000000'; 

end; 

end; 

procedure TAPA_Parameter.APA_Count_of_QueriesExit(Sender: TObject); 

begin 

APA_Count_of_Queries.Text:=trim(APA_Count_of_Queries.text); 

try 

strtoint(APA_Count_of_Queries.Text); 

except 

APA_Count_of_Queries.Text:='1'; 

end; 

end; 

end. 

- 433 -



12.1.26 UNIT APA_PROCESSUNIT.DFM 

object APA_Show_Process: TAPA_Show_Process 

Left = 266 

Top = 233 


Caption = 'Show Process' 









FormStyle = fsStayOnTop 








Left = 0 

Top = 237 

Width = 322 

Height = 41 


TabOrder = 0 

object ButtonCancel: TButton 

Left = 36 

Top = 8 

Width = 75 

Height = 25 


TabOrder = 0 

OnClick = ButtonCancelClick 

end 

object ButtonPause: TButton 

Left = 184 

Top = 8 

Width = 75 

Height = 25 

Caption = 'Pause' 

TabOrder = 1 

OnClick = ButtonPauseClick 

end 

end 


Left = 0 

Top = 0 

Width = 322 

Height = 237 


Caption = 'Protocoll' 

TabOrder = 1 

OnDblClick = GroupBox1DblClick 

object APA_Protocoll: TListBox 

Left = 2 

Top = 15 

Width = 318 

Height = 220 



TabOrder = 0 

end 

end 

object Ausschalten: TTimer 


Interval = 5000 

OnTimer = AusschaltenTimer 

Left = 128 

Top = 112 

- 434 -



end 

object secretMenu1: TPopupMenu 

Left = 176 

Top = 64 

object up1: TMenuItem 

Caption = 'up' 

OnClick = up1Click 

end 

object down1: TMenuItem 

Caption = 'down' 

OnClick = down1Click 

end 

object ShowProtokoll1: TMenuItem 

Caption = 'Show Protokoll' 

OnClick = ShowProtokoll1Click 

end 

object HideProtokoll1: TMenuItem 

Caption = 'Hide Protokoll' 

OnClick = HideProtokoll1Click 

end 

object Expertmode1: TMenuItem 


Caption = 'Expertmode' 

end 

end 

end 

12.1.27 UNIT APA_PROCESSUNIT.PAS 

unit APA_Processunit; 

interface 

uses 


Dialogs, StdCtrls, ExtCtrls, Menus; 

type 

TAPA_Show_Process = class(TForm) 


ButtonCancel: TButton; 


APA_Protocoll: TListBox; 

ButtonPause: TButton; 

Ausschalten: TTimer; 

secretMenu1: TPopupMenu; 

up1: TMenuItem; 

down1: TMenuItem; 

ShowProtokoll1: TMenuItem; 

HideProtokoll1: TMenuItem; 

Expertmode1: TMenuItem; 

procedure ausgabe(Ausgabe:string); 


procedure ButtonCancelClick(Sender: TObject); 

procedure ButtonPauseClick(Sender: TObject); 


procedure AusschaltenTimer(Sender: TObject); 

procedure GroupBox1DblClick(Sender: TObject); 

procedure up1Click(Sender: TObject); 

procedure down1Click(Sender: TObject); 

procedure ShowProtokoll1Click(Sender: TObject); 

procedure HideProtokoll1Click(Sender: TObject); 

private 


public 


end; 

var 

APA_Show_Process: TAPA_Show_Process; 

stop, break:boolean; 


- 435 -



uses APA_Dialogunit; 

{$R *.dfm} 

var showprotokoll:boolean=true; 

procedure TAPA_Show_Process.ausgabe(Ausgabe:string); 

begin; 

if showprotokoll=true then begin 

APA_Show_Process.APA_Protocoll.Items.Add(Ausgabe); 

end; 

end; 

APA_Show_Process.APA_Protocoll.ItemIndex:=APA_Show_Process.APA_Protocoll.Items.Cou 

nt-1; 


procedure TAPA_Show_Process.FormShow(Sender: TObject); 

begin 

stop:=false; 

end; 

procedure TAPA_Show_Process.ButtonCancelClick(Sender: TObject); 

begin 

stop:=true; 

break:=false; 

Ausschalten.Enabled:=false; 

APA_Show_Process.ButtonPause.Visible:=true; 

Close; 

end; 

procedure TAPA_Show_Process.ButtonPauseClick(Sender: TObject); 

begin 

if break=false then begin 

break:=true; 

ButtonPause.Caption:='Resume'; 


break:=false; 

ButtonPause.Caption:='Pause'; 

end; 

end; 

procedure TAPA_Show_Process.FormClose(Sender: TObject; 

var Action: TCloseAction); 

begin 

Stop:=true; 

break:=false; 

showprotokoll:=true; 

APA_Show_Process.ButtonCancel.Caption:='Abort'; 

end; 

procedure TAPA_Show_Process.AusschaltenTimer(Sender: TObject); 

begin 

Ausschalten.Enabled:=false; 

APA_Show_Process.ButtonPause.Visible:=true; 

Close; 

end; 

procedure TAPA_Show_Process.GroupBox1DblClick(Sender: TObject); 

begin 

Groupbox1.PopupMenu:=secretMenu1; 

end; 

procedure TAPA_Show_Process.up1Click(Sender: TObject); 

begin 

APA_Dialog.APA_Text.Caption:='Are you sure?'; 


Groupbox1.Tag:=1; 

end; 

procedure TAPA_Show_Process.down1Click(Sender: TObject); 

begin 

APA_Dialog.APA_Text.Caption:='Are you sure?'; 

- 436 -




Groupbox1.Tag:=-1; 

end; 

procedure TAPA_Show_Process.ShowProtokoll1Click(Sender: TObject); 

begin 

showprotokoll:=true; 

end; 

procedure TAPA_Show_Process.HideProtokoll1Click(Sender: TObject); 

begin 

showprotokoll:=false; 

end; 

end. 

12.1.28 UNIT APA_SCREENUNIT.DFM 

object APA_Screen: TAPA_Screen 

Left = 308 

Top = 209 

BorderStyle = bsNone 

Caption = 'APA_Screen' 



Color = clWhite 






FormStyle = fsStayOnTop 



OnClick = FormClick 

OnCreate = FormCreate 



object Shape1: TShape 

Left = 0 

Top = 0 

Width = 233 

Height = 182 


Pen.Color = clGreen 

Pen.Width = 2 

OnMouseDown = Shape2MouseDown 

end 

object Shape2: TShape 

Left = 4 

Top = 4 

Width = 225 

Height = 173 

Pen.Color = clGreen 

OnMouseDown = Shape2MouseDown 

end 

object Image1: TImage 

Left = 69 

Top = 32 

Width = 95 

Height = 90 

AutoSize = True 

Picture.Data = { 

07544269746D6170F6250000424DF62500000000000036040000280000005F00 

00005A0000000100080000000000C0210000120B0000120B0000000100000000 

000000000000330000006600000099000000CC000000FF000000003300003333 

. . . 

. . . 

D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7 

D700D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7 


- 437 -




D700} 

OnClick = Image1Click 

end 


Left = 19 

Top = 8 

Width = 195 

Height = 23 

Caption = 'APA Application' 


Font.Color = clGreen 


Font.Name = 'Courier New' 

Font.Style = [fsBold] 


end 


Left = 62 

Top = 120 

Width = 110 

Height = 18 

Caption = 'designed by' 







end 


Left = 62 

Top = 140 

Width = 110 

Height = 18 

Caption = 'Thomas ACHS' 







end 


Left = 69 

Top = 161 

Width = 100 

Height = 10 

Align = alCustom 

Alignment = taCenter 

Caption = ' Starting Program...' 




Font.Name = 'Lucida Sans Typewriter' 



end 

object Timer1: TTimer 

Interval = 100 

OnTimer = Timer1Timer 

Left = 32 

Top = 48 

end 

end 

12.1.29 UNIT APA_SCREENUNIT.PAS 

unit APA_Screenunit; 

interface 

- 438 -



uses 


Dialogs, ExtCtrls, StdCtrls, DB, DBTables; 

type 

TAPA_Screen = class(TForm) 

Image1: TImage; 

Shape1: TShape; 

Shape2: TShape; 




Timer1: TTimer; 


procedure FormClick(Sender: TObject); 

procedure Image1Click(Sender: TObject); 

procedure Shape2MouseDown(Sender: TObject; Button: TMouseButton; 


procedure Timer1Timer(Sender: TObject); 


private 


public 


end; 

var 

APA_Screen: TAPA_Screen; 



{$R *.dfm} 

var counter:longint=0; 

procedure TAPA_Screen.FormClick(Sender: TObject); 

begin 

Counter:=100; 

end; 

procedure TAPA_Screen.Image1Click(Sender: TObject); 

begin 

Counter:=100; 

end; 

procedure TAPA_Screen.Shape2MouseDown(Sender: TObject; 

Button: TMouseButton; Shift: TShiftState; X, Y: Integer); 

begin 

Counter:=100; 

end; 

procedure TAPA_Screen.Timer1Timer(Sender: TObject); 

begin 


if counter=10 then Label4.Caption:=' Loading Settings...'; 

if counter=25 then Label4.Caption:=' Ready to start...'; 

if counter>30 then begin; 

Timer1.Enabled:=false; 

APA_Screen.Hide; 

APA_Application.showmodal; 

Close; 

end; 

end; 

procedure TAPA_Screen.FormCreate(Sender: TObject); 

begin 

CurrencyString:=''; 

ShortDateFormat:='dd.mm.yyyy'; 

LongDateFormat:='dd.mm.yyyy'; 

DateSeparator := '.'; 

ThousandSeparator:='.'; 

- 439 -



DecimalSeparator:=','; 

CurrencyDecimals:=2; 

ShortTimeFormat:='hh:nn'; 

LongTimeFormat:='hh:nn'; 

end; 

end. 

12.1.30 UNIT APA_SELECTIONUNIT.DFM 

object APA_Selection_Screen: TAPA_Selection_Screen 

Left = 100 

Top = 115 

Width = 760 

Height = 551 













Left = 0 

Top = 476 

Width = 752 

Height = 41 


TabOrder = 0 

object Button_show_current_APA: TButton 

Left = 8 

Top = 8 

Width = 155 

Height = 25 

Caption = 'Show current APA' 


TabOrder = 0 

OnClick = Button_show_current_APAClick 

end 

object Button_delete_all: TButton 

Left = 330 

Top = 8 

Width = 155 

Height = 25 

Caption = 'Delete all req. blocks && cubes' 

TabOrder = 1 

OnClick = Button_delete_allClick 

end 

object Button_add_to_selection: TButton 

Left = 169 

Top = 8 

Width = 155 

Height = 25 

Caption = 'Add to selection' 



TabOrder = 2 

OnClick = Button_add_to_selectionClick 

end 

object Button_Main_Menu: TButton 

Left = 490 

Top = 8 

Width = 155 

Height = 25 

Caption = 'Back to Main Menu' 

TabOrder = 3 

OnClick = Button_Main_MenuClick 

- 440 -



end 

end 


Left = 0 

Top = 0 

Width = 752 

Height = 145 

Align = alTop 

Caption = 'Selection' 

TabOrder = 1 


Left = 120 

Top = 20 

Width = 52 

Height = 13 

Caption = 'Dimension:' 

end 


Left = 124 

Top = 44 

Width = 48 

Height = 13 

Caption = 'Hierarchy:' 

end 


Left = 133 

Top = 68 

Width = 39 

Height = 13 

Caption = 'Method:' 

end 


Left = 100 

Top = 92 

Width = 72 

Height = 13 

Caption = 'End of method:' 

end 

object Dimensionbox: TComboBox 

Left = 184 

Top = 16 

Width = 421 

Height = 21 



ItemIndex = 0 

TabOrder = 0 

Text = 'NONE' 

OnChange = DimensionboxChange 


'NONE') 

end 

object Hierarchybox: TComboBox 

Left = 184 

Top = 40 

Width = 421 

Height = 21 



ItemIndex = 0 

TabOrder = 2 

Text = 'NONE' 

OnChange = HierarchyboxChange 


'NONE') 

end 

object Methodbox: TComboBox 

Left = 184 

Top = 64 

Width = 421 

Height = 21 



ItemIndex = 0 

- 441 -



TabOrder = 4 

Text = 'NONE' 

OnChange = HierarchyboxChange 


'NONE' 

'DRILL DOWN' 

'ROLL UP') 

end 

object End_of_methodbox: TComboBox 

Left = 184 

Top = 88 

Width = 421 

Height = 21 



ItemIndex = 0 

TabOrder = 6 

Text = 'NONE' 


'NONE') 

end 

object Button_insert: TButton 

Left = 186 

Top = 111 

Width = 77 

Height = 25 


TabOrder = 8 

OnClick = Button_insertClick 

end 

object Button_delete: TButton 

Left = 265 

Top = 111 

Width = 77 

Height = 25 



TabOrder = 1 

OnClick = Button_deleteClick 

end 

object Button_Edit: TButton 

Left = 345 

Top = 111 

Width = 77 

Height = 25 



TabOrder = 3 

OnClick = Button_EditClick 

end 

object Button_Accept: TButton 

Left = 424 

Top = 111 

Width = 75 

Height = 25 

Caption = 'Accept' 

TabOrder = 5 

OnClick = Button_AcceptClick 

end 

object Button_Cancel: TButton 

Left = 504 

Top = 111 

Width = 75 

Height = 25 


TabOrder = 7 

OnClick = Button_CancelClick 

end 

end 

object Listeint: TListBox 

Left = 602 

Top = 145 

Width = 150 

Height = 331 

- 442 -



Align = alRight 


TabOrder = 2 


end 


Left = 0 

Top = 145 

Width = 193 

Height = 331 


TabOrder = 3 


Left = 1 

Top = 1 

Width = 191 

Height = 238 

Align = alTop 

TabOrder = 0 

object Button_new_requirement_block: TButton 

Left = 8 

Top = 8 

Width = 169 

Height = 25 

Caption = 'New req. block' 

TabOrder = 0 

OnClick = Button_new_requirement_blockClick 

end 

object Button_del_req_block: TButton 

Left = 8 

Top = 61 

Width = 169 

Height = 25 

Caption = 'Delete req. block' 


TabOrder = 1 

OnClick = Button_del_req_blockClick 

end 

object Button_select: TButton 

Left = 8 

Top = 88 

Width = 169 

Height = 25 

Caption = 'Select' 


TabOrder = 2 

OnClick = Button_selectClick 

end 

object Button_Deselect: TButton 

Left = 8 

Top = 115 

Width = 169 

Height = 25 

Caption = 'Deselect' 


TabOrder = 3 

OnClick = Button_DeselectClick 

end 

object Button_Select_all: TButton 

Left = 8 

Top = 142 

Width = 169 

Height = 25 

Caption = 'Select all' 

TabOrder = 4 

OnClick = Button_Select_allClick 

end 

object Button_Deselect_all: TButton 

Left = 8 

Top = 169 

Width = 169 

Height = 25 

Caption = 'Deselect all' 

TabOrder = 5 

- 443 -



OnClick = Button_Deselect_allClick 

end 

object Button_Edit_Requirement_block: TButton 

Left = 7 

Top = 34 

Width = 169 

Height = 25 

Caption = 'Edit req. block' 


TabOrder = 6 

OnClick = Button_Edit_Requirement_blockClick 

end 

end 

end 

object Req: TTreeView 

Left = 193 

Top = 145 

Width = 409 

Height = 331 







Images = ImageList2 

Indent = 19 


ReadOnly = True 

TabOrder = 4 

OnClick = ReqClick 

OnDblClick = ReqDblClick 

end 

object ImageList2: TImageList 

Left = 448 

Top = 288 

Bitmap = { 

494C010103000400040010001000FFFFFFFFFF10FFFFFFFFFFFFFFFF424D3600 

0000000000003600000028000000400000001000000001002000000000000010 

000000000000000000000000000000000000344E4A006BB09B006BB09B006BB0 

. . . 

. . . 

0000000000000000000000000000000000000000000000000000000000000000 

0000000000000000000000000000000000000000000000000000000000000000 

0000000000000000000000000000000000000000000000000000000000000000 

000000000000} 

end 

end 

12.1.31 UNIT APA_SELECTIONUNIT.PAS 

unit APA_Selectionunit; 

interface 

uses 


Dialogs, ImgList, ComCtrls, StdCtrls, ExtCtrls; 

type 

TAPA_Selection_Screen = class(TForm) 


Button_show_current_APA: TButton; 

Button_delete_all: TButton; 

Button_add_to_selection: TButton; 

Button_Main_Menu: TButton; 






Dimensionbox: TComboBox; 

- 444 -



Hierarchybox: TComboBox; 

Methodbox: TComboBox; 

End_of_methodbox: TComboBox; 

Button_insert: TButton; 

Button_delete: TButton; 

Button_Edit: TButton; 

Button_Accept: TButton; 

Button_Cancel: TButton; 

Listeint: TListBox; 



Button_new_requirement_block: TButton; 

Button_del_req_block: TButton; 

Button_select: TButton; 

Button_Deselect: TButton; 

Button_Select_all: TButton; 

Button_Deselect_all: TButton; 

Button_Edit_Requirement_block: TButton; 

Req: TTreeView; 

ImageList2: TImageList; 

procedure DimensionboxChange(Sender: TObject); 

procedure HierarchyboxChange(Sender: TObject); 

procedure Button_new_requirement_blockClick(Sender: TObject); 

procedure Button_Edit_Requirement_blockClick(Sender: TObject); 

procedure Button_selectClick(Sender: TObject); 

procedure Button_DeselectClick(Sender: TObject); 

procedure Button_del_req_blockClick(Sender: TObject); 

procedure Button_insertClick(Sender: TObject); 

procedure ReqClick(Sender: TObject); 

procedure Button_Select_allClick(Sender: TObject); 

procedure Button_Deselect_allClick(Sender: TObject); 

procedure Button_deleteClick(Sender: TObject); 

procedure Button_EditClick(Sender: TObject); 

procedure Button_AcceptClick(Sender: TObject); 

procedure Button_CancelClick(Sender: TObject); 

procedure ReqDblClick(Sender: TObject); 

procedure Button_show_current_APAClick(Sender: TObject); 

procedure Button_add_to_selectionClick(Sender: TObject); 

procedure Button_delete_allClick(Sender: TObject); 


procedure Button_Main_MenuClick(Sender: TObject); 

private 


public 


end; 

var 

APA_Selection_Screen: TAPA_Selection_Screen; 

gotoAPA:boolean=false; 


uses APA_Input_Reqblockunit, APA_Gridunit, APA_Parameterunit, 

APA_Optionsunit, APA_Dialogunit, APA_Applicationunit; 

{$R *.dfm} 

var editmode:boolean =false; 

editnode:TTreeNode; 

anzblocksselected:longint =0; 

function vergleichewuerfel(erster,zweiter:array of longint;Dimensionen:longint):longint; 


ergebnis0,ergebnisminus1:boolean; 

begin 

{Diese Funktion Vergleicht die beiden Würfel und gibt 1 zurück, wenn der Zweite kein 

Derivate des ersten ist. 0 wenn gleich und sonst -1} 

ergebnis0:=true;ergebnisminus1:=false; 

For zahler:=0 to Dimensionen-1 do begin 

if (erster[zahler]


end; 


if ergebnisminus1=true then Result:=-1 

else 

if ergebnis0=false then Result:=1 

else 

Result:=0; 

end; 

function getbezeichnung():string; 

var st2,st:string; 

begin; 

{Diese Funktion erzeugt die Bezeichnung für den Eintrag in der Anzeige} 

with APA_Selection_Screen do begin 

{Auflösen der Bezeichnung in der Spezialbox} 

st2:=inttostr(dimensionbox.itemindex);while length(st2)



then begin 

if 

strtoint(copy(Listeint.Items[zahler],1,4))=Dimensionbox.ItemIndex then 

zusetzen:=false; 

end; 

zahler:=zahler-1;if zahler0 then begin 

while(copy(Listeint.Items[aktindex],1,4)'Req:')and(aktindex>0) do begin 

aktindex:=aktindex-1; 

end; 

if Req.Items[aktindex].ImageIndex2 then aktiviert:=true; 

end; 

if Editmode=true then begin 

{Links alles deaktivieren} 

Button_Edit_Requirement_Block.Enabled:=false; 

Button_new_requirement_block.Enabled:=false; 

Button_del_req_block.Enabled:=false; 

Button_select.Enabled:=false; 

Button_Deselect.Enabled:=false; 

Button_Select_all.Enabled:=false; 

Button_Deselect_all.Enabled:=false; 

{Unten alles deaktivieren} 

Button_show_current_APA.Enabled:=false; 

Button_add_to_selection.Enabled:=false; 

Button_delete_all.Enabled:=false; 

{Oben nur Accept und Cancel aktivieren} 

Button_Insert.Enabled:=false; 

Button_Edit.Enabled:=false; 

Button_Delete.Enabled:=false; 

Button_Accept.Enabled:=true; 

Button_Cancel.Enabled:=true; 

Req.Enabled:=false; 

end 

else 

begin; 

{Unten alles aktivieren} 

{anzblocksselected gibt die Anzahl der Selektieren Blocks wieder} 

if anzblocksselected0 then begin; 

- 447 -



Button_show_current_APA.Enabled:=false; 

Button_add_to_selection.Enabled:=true; 


Button_show_current_APA.Enabled:=true; 

Button_add_to_selection.Enabled:=false; 

end; 

Button_delete_all.Enabled:=true; 

if req.selectednil then begin 

if aktiviert=true then begin 

Button_Edit_Requirement_Block.Enabled:=true; 

Button_new_requirement_block.Enabled:=true; 

Button_del_req_block.Enabled:=true; 





end; 

Button_Select_all.Enabled:=true; 

Button_Deselect_all.Enabled:=true; 

if req.Selected.Level=0 then begin 

if req.Selected.ImageIndex=0 then begin 

Button_select.Enabled:=true; 


end 

else 

begin 

if req.Selected.ImageIndex=1 then begin 


Button_Deselect.Enabled:=true; 


//Bereits zugesetzt 



end; 

end; 

{Ist eine Hierarchie ausgewählt dann alle deaktiveren außer insert} 

if aktiviert=true then 

Button_Insert.Enabled:=true 

else 




Button_Accept.Enabled:=false; 

Button_Cancel.Enabled:=false; 

Req.Enabled:=true; 

end {of level 0} 

else begin 

{begin von level 1} 



Button_new_requirement_block.Enabled:=true 

else 





if aktiviert=true then begin 

Button_Insert.Enabled:=true; 

Button_Edit.Enabled:=true; 

Button_Delete.Enabled:=true; 

end 

else 

begin 




- 448 -



Req.Enabled:=false; 

end; 




end; 


{Wenn nichts ausgewählt} 

{Buttons links} 




{Buttons oben} 


Button_Insert.Enabled:=true 

else 







end; 

end;{of editmode} 

end; 

end; 

procedure TAPA_Selection_Screen.DimensionboxChange(Sender: TObject); 


begin 

if Dimensionbox.Text'NONE' then begin 

hierarchybox.Items.Clear; 


for zahler:=0 to anzh[Dimensionbox.itemindex]-1 do begin 

Hierarchybox.Items.Add(dl[Dimensionbox.itemindex][zahler]) 

end; 

Hierarchybox.ItemIndex:=0; 


end; 

end; 

procedure TAPA_Selection_Screen.HierarchyboxChange(Sender: TObject); 


begin 

if Methodbox.itemindex0 then begin 

End_of_methodbox.Enabled:=true; 

if Methodbox.ItemIndex=2 then begin 

{Bei einem Roll up} 

End_of_Methodbox.Items.Clear; 


for zahler:=hierarchybox.itemindex+1 to anzh[Dimensionbox.itemindex]-1 do begin 

End_of_Methodbox.Items.Add(dl[Dimensionbox.itemindex][zahler]) 

end; 

end else 

begin 

{Bei einem DRILL DOWN} 

End_of_Methodbox.Items.Clear; 


for zahler:=0 to hierarchybox.itemindex-1 do begin 

End_of_Methodbox.Items.Add(dl[Dimensionbox.itemindex][zahler]) 

end; 

- 449 -


end; 


end else begin; 


End_of_methodbox.Items.Add('NONE'); 

end; 

if End_of_Methodbox.Items.Count=0 then begin; 



End_of_methodbox.Items.Add('NONE'); 

end; 

End_of_methodbox.ItemIndex:=0; 

end; 

procedure TAPA_Selection_Screen.Button_new_requirement_blockClick( 


var g:longint; 

importancestring:string; 

merkindex:longint; 

ok:boolean; 

begin 


{Ein Req} 

APA_Insert_Reqblock.Reqname.Text:=''; 

APA_Insert_Reqblock.OKBtn.Enabled:=false; 

APA_insert_Reqblock.Add_max_hier.Visible:=APA_Options.APA_Add_max_hier.checked; 

APA_Insert_Reqblock.Add_max_hier.Enabled:=true; 

repeat; 

ok:=true; 

if APA_Insert_Reqblock.showmodal=mrok then begin 

for merkindex:=0 to Req.Items.Count-1 do begin 

if copy(Listeint.Items[merkindex],1,3)='Req' then begin 

if (copy(Req.items[merkindex].text,1,pos('//',Req.items[merkindex].Text)-1)= 

APA_Insert_reqblock.reqname.Text) then begin 

ok:=false; 

showmessage('The name '+APA_Insert_reqblock.reqname.Text+' is already used. Please 

change the name!'); 

end; 

end; 

end; 


if Req.TopItemnil then Req.Selected:=Req.TopItem; 

importancestring:=APA_Parameter.APA_Degrees.Items[APA_Insert_Reqblock.Importance_o 

f_requirement.Itemindex]; 

merkindex:=Req.Items.Add(req.Selected,APA_Insert_reqblock.reqname.Text+'//'+import 

ancestring).AbsoluteIndex; 

Req.Items[merkindex].ImageIndex:=0; 

Req.Items[merkindex].SelectedIndex:=0; 

Req.Selected:=Req.Items[Req.Items.count-1]; 

Listeint.Items.Add('Req:'+inttostr(APA_Insert_Reqblock.Importance_of_requirement.I 

temindex)); 

if APA_insert_Reqblock.Add_max_hier.Checked=true then begin 

{Zusetzen aller Dimensionen mit max. Hierarchielevels} 

for g:=0 to Dimensionbox.Items.Count-1 do begin; 

{Dimension einstellen} 

Dimensionbox.ItemIndex:=g;DimensionboxChange(self); 

{max Hierarchie einstellen} 

- 450 -


end; 


Hierarchybox.ItemIndex:=Hierarchybox.items.count-1; 

{Methode ist Keine} 


{End of Methode ist auch keine} 

End_of_Methodbox.ItemIndex:=0; 

Button_insertClick(self); 

end; 

end;//von ok 



{Ein Req ENDE} 

buttonreqchange; 

Req.SetFocus; 

end; 

procedure TAPA_Selection_Screen.Button_Edit_Requirement_blockClick( 


var importancestring:string; 


var merkindex:longint; 

begin 

if Req.Selectednil then begin 

try 

{Ein Req} 

APA_Insert_Reqblock.Reqname.Text:=copy(Req.Selected.text,1,pos('//',Req.Selected.T 

ext)-1); 

APA_Insert_Reqblock.OKBtn.Enabled:=false; 

APA_insert_Reqblock.Add_max_hier.Visible:=false; 

APA_Insert_Reqblock.Importance_of_requirement.ItemIndex:= 

strtoint(copy(Listeint.Items[Req.Selected.Absoluteindex],5,255)); 

repeat; 

ok:=true; 

if APA_Insert_Reqblock.showmodal=mrok then begin 

for merkindex:=0 to Req.Items.Count-1 do begin 

if copy(Listeint.Items[merkindex],1,3)='Req' then begin 

if (copy(Req.items[merkindex].text,1,pos('//',Req.items[merkindex].Text)-1)= 

APA_Insert_reqblock.reqname.Text)and(Req.SelectedReq.Items[merkindex]) then 

begin 

ok:=false; 

showmessage('The name '+APA_Insert_reqblock.reqname.Text+' is already used. Please 

change the name!'); 

end; 

end; 

end; 


importancestring:=APA_Parameter.APA_Degrees.Items[APA_Insert_Reqblock.Importance_o 

f_requirement.Itemindex]; 

Req.Selected.Text:=APA_Insert_Reqblock.reqname.Text+'//'+importancestring; 

Listeint.Items[Req.Selected.Absoluteindex]:='Req:'+inttostr(APA_Insert_Reqblock.Im 

portance_of_requirement.Itemindex); 


end;//of ok 

- 451 -





{Ein Req ENDE} 


except 

showmessage('Fehler beim Auflösen der Daten'); 


exit; 

end; 

Req.SetFocus; 

end; 

end; 

procedure TAPA_Selection_Screen.Button_selectClick(Sender: TObject); 

begin 

Req.Selected.ImageIndex:=1; 

Req.Selected.SelectedIndex:=1; 

anzblocksselected:=anzblocksselected+1; 


end; 

procedure TAPA_Selection_Screen.Button_DeselectClick(Sender: TObject); 

begin 

if Req.Selected.ImageIndex=1 then begin 

Req.Selected.ImageIndex:=0; 

Req.Selected.SelectedIndex:=0; 

anzblocksselected:=anzblocksselected-1; 


end; 

end; 

procedure TAPA_Selection_Screen.Button_del_req_blockClick(Sender: TObject); 

var loschebis,zahler:longint; 

begin 

{Löschen der Einträge in Listeint} 

{1. Lösch so lange bis das nächste Req kommt} 

loschebis:=Req.Selected.AbsoluteIndex; 

repeat; 

loschebis:=loschebis+1; 

until(copy(Listeint.items[loschebis+1],1,4)='Req:') 

or(loschebis+1=Listeint.Items.Count-1); 

if loschebis+1=Listeint.Items.Count-1 then loschebis:=loschebis+1; 

for zahler:=0 to (loschebis-Req.Selected.AbsoluteIndex) 

do Listeint.Items.Delete(Req.Selected.AbsoluteIndex); 

Req.Selected.Delete; 



end; 

procedure TAPA_Selection_Screen.Button_insertClick(Sender: TObject); 

var st,st2:string; 

x:longint; 

begin 

if req.Selected=nil then begin; 

APA_Insert_Reqblock.Add_max_hier.Enabled:=true; 

APA_Insert_Reqblock.Add_max_hier.Checked:=false; 

Button_new_requirement_block.Click; 

Req.SetFocus; 

end; 

st2:=getbezeichnung(); {speichern der Spezialbezeichnung in st2} 

if kannzusetzen()=true then begin{Zusetzen der Bezeichnung} 

{Zusetzen der Anzeigebezeichnung in die Liste} 

st:='Choose from '+Dimensionbox.Text+' hierarchy '+hierarchybox.text; 

- 452 -



if Methodbox.ItemIndex0 then begin 

st:=st+' and a '+Methodbox.Text+' to '+End_of_Methodbox.Text; 

end; 

if req.Selected.Level=0 then 

{wenn Dimension markiert} 

x:=Req.Items.AddChild(Req.Selected, 

st).AbsoluteIndex 

else 

{wenn Hierarchy markiert} 

x:=Req.Items.Add(Req.Selected, 

st).AbsoluteIndex; 

{Zusetzen der Spezialbezeichnung in die Liste} 

Listeint.Items.insert(x, st2); 

Req.Items[x].ImageIndex:=6; 

Req.Items[x].SelectedIndex:=6; 

Req.selected.expand(true); 


end{End of Zusetzen} 

else 

showmessage('Diese Hierarchie wurde bereits zugesetzt'); 


end; 

procedure TAPA_Selection_Screen.ReqClick(Sender: TObject); 

begin 


end; 

procedure TAPA_Selection_Screen.Button_Select_allClick(Sender: TObject); 


begin 

anzblocksselected:=0; 

for zahler:=0 to Req.Items.Count-1 do begin 

if (req.items[zahler].Level=0)and(req.Items[zahler].ImageIndex2) then begin 

Req.items[zahler].ImageIndex:=1; 

Req.items[zahler].SelectedIndex:=1; 

anzblocksselected:=anzblocksselected+1; 

end; 

end; 

Req.Repaint; 


end; 

procedure TAPA_Selection_Screen.Button_Deselect_allClick(Sender: TObject); 


begin 

for zahler:=0 to req.Items.Count-1 do begin 

if (req.items[zahler].Level=0)and(Req.items[zahler].ImageIndex2) then begin 

Req.items[zahler].ImageIndex:=0; 

Req.items[zahler].SelectedIndex:=0; 

end; 

end; 

Req.Repaint; 




end; 

procedure TAPA_Selection_Screen.Button_deleteClick(Sender: TObject); 

begin 

Listeint.Items.Delete(Req.Selected.AbsoluteIndex); 

Req.Selected.Delete; 

- 453 -





end; 

procedure TAPA_Selection_Screen.Button_EditClick(Sender: TObject); 


begin 

if Req.Selectednil then begin 

editnode:=Req.Selected; 

editmode:=true; 

{Daten laden} 

st:=Listeint.Items[Req.Selected.Absoluteindex]; 

try 

Dimensionbox.ItemIndex:=strtoint(copy(st,1,4));DimensionboxChange(self); 

Hierarchybox.ItemIndex:=strtoint(copy(st,5,4)); 

Methodbox.ItemIndex:=strtoint(copy(st,9,4)); 

End_of_methodbox.ItemIndex:=strtoint(copy(st,13,4)); 


except 

showmessage('Fehler beim Auflösen der Daten'); 

editmode:=false;buttonreqchange; 

exit; 

end; 

end; 


end; 

procedure TAPA_Selection_Screen.Button_AcceptClick(Sender: TObject); 


begin 

editnode.Selected:=true; 

if kannzusetzen()=true then begin{Zusetzen der Bezeichnung} 

{Zusetzen der Anzeigebezeichnung in die Liste} 

st:='Choose from '+Dimensionbox.Text+' hierarchy '+hierarchybox.text; 

if Methodbox.ItemIndex0 then begin 

st:=st+' and a '+Methodbox.Text+' to '+End_of_Methodbox.Text; 

end; 

Req.Selected.Text:=st; 

{Zusetzen der Spezialbezeichnung in die Liste} 

Listeint.Items[Req.Selected.AbsoluteIndex]:=getbezeichnung(); 

Req.selected.expand(true); 


end{End of Zusetzen} 

else 

showmessage('Diese Hierarchie wurde bereits zugesetzt'); 

editmode:=false; 


end; 

procedure TAPA_Selection_Screen.Button_CancelClick(Sender: TObject); 

begin 

editmode:=false; 


end; 

procedure TAPA_Selection_Screen.ReqDblClick(Sender: TObject); 

begin 

if copy(Listeint.items[Req.Selected.AbsoluteIndex],1,4)'Req:' then begin 

if Button_Edit.Enabled=true then begin 

Button_Edit.Click; 

- 454 -



end 

else showmessage('Edit not allowed'); 

end; 

end; 

procedure TAPA_Selection_Screen.Button_show_current_APAClick( 


begin 

gotoAPA:=true; 

end; 

procedure TAPA_Selection_Screen.Button_add_to_selectionClick( 


var akth:array of longint; 

newbegin,newende,newakt:array of longint; 

zahler,zahler2:longint; 

begin 

spalte,zeile,aktdim:longint; 

ende,endifredundant,endedieserzeile,enderollup:boolean; 

copystring:string; 

gewicht:longint; 

{Zusetzen der Selektierten Cubes zum APA} 


{1. Feststellen des Cubes, welcher zugesetzt wird} 

for zahler:=0 to Listeint.Items.Count-1 do begin 

if(copy(Listeint.Items[zahler],1,4)='Req:')and(Req.Items[zahler].ImageIndex=1) then 

begin 

Req.Items[Zahler].ImageIndex:=2; 

Req.Items[Zahler].SelectedIndex:=2; 

gewicht:=strtoint(copy(Listeint.Items[zahler],5,255)); 

newbegin:=nil; 

setlength(newbegin,anzd); 

newende:=nil; 

setlength(newende,anzd); 

{Alle Hierarchiestufen der Dimensionen auf max setzen} 

for zahler2:=0 to anzd-1 do newbegin[zahler2]:=anzh[zahler2]-1; 

for zahler2:=0 to anzd-1 do newende[zahler2]:=anzh[zahler2]-1; 

zahler2:=zahler+1;copystring:=copy(Listeint.Items[zahler2],1,4); 

while (copystring'Req:')and(zahler2



newbegin[(strtoint(copy(Listeint.Items[zahler2],1,4)))]:=strtoint(copy(Listeint.It 

ems[zahler2],5,4)); 

newende[(strtoint(copy(Listeint.Items[zahler2],1,4)))]:=strtoint(copy(Listeint.Ite 

ms[zahler2],13,4)); 

end; 

end;//Ende von Dill Down and Roll UP 


if zahler2



if vergleichewuerfel(newakt,akth,anzd)=0 then begin; 

APA[spalte,zeile].interessant:=true; 

APA[spalte,zeile].gewicht:=strtoint(APA_Parameter.APA_Degreecounts.Items[gewicht]) 

;; 

APA[spalte,zeile].gewichtlevel:=gewicht; 

end; 

end;//of Endedieserzeile 

end;//Ende von clYellow Redundanzfrei 

spalte:=spalte+1; 

end;//Ende von Spalten und Ende=false 

zeile:=zeile+1; 

end;//Ende von Zeilen und Ende=false 

enderollup:=false; 

until (vergleichewuerfel(newakt,newende,anzd)=0); 

end;//Ende von es ist ein Reqirement 

end;//Ende von zahler 


gotoAPA:=true; 


end; 

procedure TAPA_Selection_Screen.Button_delete_allClick(Sender: TObject); 

begin 

APA_Dialog.APA_Text.Caption:='Are you sure to erase all cubes in the APA Selection 

Screen and in the APA itself?'; 

if APA_Dialog.showmodal=mryes then begin 

end; 

zellezeile:=0; 

while (zellezeile


end. 


12.1.32 UNIT APA_SHOW_COSTSUNIT.DFM 

object APA_Showcosts: TAPA_Showcosts 

Left = 220 

Top = 114 

Width = 696 

Height = 480 

Caption = 'Show Costs' 














Left = 0 

Top = 0 

Width = 688 

Height = 41 

Align = alTop 

TabOrder = 0 


Left = 16 

Top = 8 

Width = 89 

Height = 25 

Caption = 'Export to Excel' 

TabOrder = 0 


end 

end 


Left = 0 

Top = 405 

Width = 688 

Height = 41 


TabOrder = 1 


Left = 16 

Top = 8 

Width = 75 

Height = 25 

Cancel = True 

Caption = 'Close && Save' 

TabOrder = 0 


end 


Left = 104 

Top = 8 

Width = 75 

Height = 25 


TabOrder = 1 


end 

end 

object Kostengriddat: TStringGrid 

Left = 0 

Top = 41 

Width = 688 

Height = 364 


- 458 -



ColCount = 7 

DefaultColWidth = 60 

DefaultRowHeight = 20 

Options = [goFixedVertLine, goFixedHorzLine, goVertLine, goHorzLine, goRangeSelect, 

goColSizing, goEditing] 

TabOrder = 2 

OnGetEditMask = KostengriddatGetEditMask 

OnSetEditText = KostengriddatSetEditText 

end 

object OpenDialogcosts: TOpenDialog 

DefaultExt = 'xls' 

Filter = 'Excel Files|*.xls' 

Left = 376 

Top = 224 

end 

end 

12.1.33 UNIT APA_SHOW_COSTSUNIT.PAS 

unit APA_Show_costsunit; 

interface 

uses 


Dialogs, StdCtrls, Grids, ExtCtrls, ComObj; 

type 

TAPA_Showcosts = class(TForm) 




OpenDialogcosts: TOpenDialog; 

Kostengriddat: TStringGrid; 







procedure KostengriddatSetEditText(Sender: TObject; ACol, 

ARow: Integer; const Value: String); 

procedure KostengriddatGetEditMask(Sender: TObject; ACol, 

ARow: Integer; var Value: String); 


private 


public 


end; 

var 

APA_Showcosts: TAPA_Showcosts; 



{$R *.dfm} 

var wurdebearbeitet:boolean; 

procedure TAPA_Showcosts.Button1Click(Sender: TObject); 

begin 

Close; 

end; 

procedure TAPA_Showcosts.FormShow(Sender: TObject); 


var zeile:longint; 

begin 

wurdebearbeitet:=false; 

- 459 -





try 

Kostengriddat.Cells[1,0]:='FromColumn'; 

Kostengriddat.Cells[2,0]:='FromRow'; 

Kostengriddat.Cells[3,0]:='ToColumn'; 

Kostengriddat.Cells[4,0]:='ToRow'; 

Kostengriddat.Cells[5,0]:='Query'; 

Kostengriddat.Cells[6,0]:='Build'; 

counter:=filesize(fKosten); 

Kostengriddat.RowCount:=counter-1; 

Kostengriddat.ColWidths[0]:=25; 

zeile:=0; 

while zeile



vKosten.VonSpalte:=strtoint(trim(Kostengriddat.Cells[1,zeile])); 

vKosten.VonZeile:=strtoint(trim(Kostengriddat.Cells[2,zeile])); 

vKosten.ZuSpalte:=strtoint(trim(Kostengriddat.Cells[3,zeile])); 

vKosten.ZuZeile:=strtoint(trim(Kostengriddat.Cells[4,zeile])); 

vKosten.Query:=strtoint(trim(Kostengriddat.Cells[5,zeile])); 

vKosten.Build:=strtoint(trim(Kostengriddat.Cells[6,zeile])); 

write(fKosten,vKosten); 

end; 

end; 

finally 


end; 

end; 

end; 


var zeile : Integer; 

var Excel : variant; 


begin 

try 

assignfile(fKosten,'c:\APADIR\DATA\Kosten.dat'); 


try 

if opendialogcosts.Execute then begin 

try 

try 

Excel := GetactiveOleObject('Excel.Application'); 

except 

try 

Excel := CreateOleObject('Excel.Application'); 

try 

Excel.Workbooks.Open (Filename:=opendialogcosts.filename); 

except 

Excel.Workbooks.add; 

Excel.ActiveWorkbook.SaveAs (Filename:=Opendialogcosts.filename); 

end; 

except 

ShowMessage('Excel konnte nicht gestartet werden !'); 

Exit; 

end; 

end; 

counter:=0; 

Excel.Visible := false; { für die testphase sinnvoll } 

Excel.sheets[1].select; 

Excel.sheets.add; 

Excel.sheets[1].Name := 'Export'; 

zeile:=1; 

application.ProcessMessages; 

{Überschriften} 

Excel.Cells[zeile, 1].Value := 'FromColumn'; 

Excel.Cells[zeile, 2].Value := 'FromRow'; 

Excel.Cells[zeile, 3].Value := 'ToColumn'; 

Excel.Cells[zeile, 4].Value := 'ToRow'; 

Excel.Cells[zeile, 5].Value := 'Query'; 

Excel.Cells[zeile, 6].Value := 'Build'; 


repeat; 

zeile:=zeile+1; 


if counter



seek(fKosten,counter); 

read(fKosten,vKosten); 


Excel.Cells[zeile, 1].Value := vKosten.VonSpalte; 

Excel.Cells[zeile, 2].Value := vKosten.VonZeile; 

Excel.Cells[zeile, 3].Value := vKosten.ZuSpalte; 

Excel.Cells[zeile, 4].Value := vKosten.ZuZeile; 

Excel.Cells[zeile, 5].Value := vKosten.Query; 

Excel.Cells[zeile, 6].Value := vKosten.Build; 


end; 

until (counter>=filesize(fKosten)); 

Application.BringToFront; 

showmessage('Data saved'); 

finally 

Excel.visible:=true; 

Application.BringToFront; 

Excel.Visible := false; Excel.visible:=true; 

Excel.workbooks.Close; 

end; 

end;{opendialog1} 

finally 

end; 

finally 


end; 

end; 

procedure TAPA_Showcosts.KostengriddatSetEditText(Sender: TObject; ACol, 

ARow: Integer; const Value: String); 

begin 

wurdebearbeitet:=true; 

end; 

procedure TAPA_Showcosts.KostengriddatGetEditMask(Sender: TObject; ACol, 

ARow: Integer; var Value: String); 

begin 

Value := '!000000000;1'; 

end; 


begin 

wurdebearbeitet:=false; 

Close; 

end; 

end. 

12.1.34 UNIT APA_SQLUNIT.DFM 

object APA_Sql: TAPA_Sql 

Left = 220 

Top = 114 

Width = 696 

Height = 480 

Caption = 'APA Sql Scripts' 



- 462 -












Left = 0 

Top = 400 

Width = 688 

Height = 46 


TabOrder = 0 


Left = 306 

Top = 10 

Width = 75 

Height = 25 

Cancel = True 


TabOrder = 0 


end 

end 

object SQLtext: TRichEdit 

Left = 0 

Top = 41 

Width = 688 

Height = 359 


ScrollBars = ssBoth 

TabOrder = 1 

end 


Left = 0 

Top = 0 

Width = 688 

Height = 41 

Align = alTop 

TabOrder = 2 


Left = 16 

Top = 8 

Width = 121 

Height = 25 

Caption = 'Save SQL Script' 

TabOrder = 0 


end 

end 

object SaveDialogsql: TSaveDialog 

DefaultExt = 'SQL' 

Filter = 'SQL Script|*.sql' 

Left = 264 

Top = 144 

end 

end 

12.1.35 UNIT APA_SQLUNIT.PAS 

unit APA_Sqlunit; 

interface 

uses 


Dialogs, StdCtrls, ExtCtrls, ComCtrls; 

type 

TAPA_Sql = class(TForm) 

- 463 -





SQLtext: TRichEdit; 



SaveDialogsql: TSaveDialog; 



private 


public 


end; 

var 

APA_Sql: TAPA_Sql; 


uses APA_Optionsunit; 

{$R *.dfm} 

procedure TAPA_Sql.Button1Click(Sender: TObject); 

begin 

Close; 

end; 

procedure TAPA_Sql.Button2Click(Sender: TObject); 

var SaveFile:TextFile; 


begin 

Savedialogsql.InitialDir:=APA_Options.APA_Save_Path.Directory; 

if savedialogsql.Execute then begin 

AssignFile(SaveFile,Savedialogsql.FileName); 

{$I-} 

Rewrite(SaveFile); 

{$I+} 

if IOResult = 0 then 

begin 

end; 

end; 

end. 

for zahler:=0 to Sqltext.lines.count-1 do begin 

writeln(SaveFile,SQLtext.lines[zahler]); 

end; 

CloseFile(SaveFile); 

end 

else 

MessageDlg('File access error', mtWarning, [mbOk], 0); 

12.2 QUELLCODES DER HILFEDATEIEN 

12.2.1 INDEX.HTM 

 

 

 

 

Willkommen 

 

 

- 464 -



 

 

 

Welcome to the APA Helpfile Website. This site should help you working with 

the APA program developed by Thomas Achs 2004. Use the Links above to navigate 

to special help topics. 

The APA (Aggregation Path Array) is a semi-graphical data modelling method in a data 

warehouse. 

This programm helps you to 

 

paint the APA 

show the redundancy-free set 

get the required cubes marked in the set 

see the derivatives of one cube 

see the sum of the derivatives of many cubes 

compare the required cubes and the materialized cubes 

calculate the materialized cubes with Thomas Achs heuristic 

 

 

 

 

12.2.2 APA_GRID_SCREEN.HTM 

 

 

 

 

APA Help - APA Grid 

 

 

 

 

 

 

The APA Grid Screen shows the APA. This screen offers a lot of functions and 

useful operations. 

 

TOPICS 

Show descriptions of cubes 

Show short description 

Show long description 

Required cubes 

Add required cubes 

Remove required cube 

Remove all required cubes 

Materialized cubes 

Add materialized cube 

Remove materialized cube 

Remove all materialized cubes 

Derivates 

Show derivates 

Remove derivates 

Redundant cubes 

Show redundancy free cubes 

Heuristik 

Generate materialized cubes 

Permutation 

Find deterministic 

solution by permutation 

Combination 


solution by combination 

Deterministic solution 

Show deterministic solution 

- 465 -



Remove deterministic solution 

Possible cubes 

Show possible cubes 

Remove possible cubes 

Build SQL Statements 

Build SQL statements for star 

schema 

Build SQL 

statements for fact constellation schema 

Get Query of cube 

Save SQL Script 

Use Random Costs 

Set use random costs 

 

Show short description 

In order to get the detailed description of a cube move the mouse over the 

cell and see the short description in the status bar above. 

 

Show long description 

To get the right long description of a cube click the cell with the left 

mouse button. 

 

Add required cubes 

In order to add a required cube move to the cell and press the right mouse 

button. Choose required and the right importance. 

 

 

Remove required cube 

In order to remove a required cube select the cube an press the right mouse 

button and select "Not required". 

 

Remove all required cubes 

 

Add materialized cube 

 

 

Remove materialized cube 

 

Remove all materialized cubes 

In order to remove all materialized cubes press the button "Remove 

materialized cubes". 

 

Show derivatives 

In order to show a derivatives of a cube select the cube and press the right 

mouse button and select "Show derivatives". 

 

 

Remove derivatives 

In order to remove the derivatives press the button "Remove 

derivatives". 

 

Show redundancy free cubes 

If you want to remove the redundant cubes of the APA tick "Remove 

redundancy". 

 

Generate materialized cubes 

After you have selected all your required cubes the Thomas ACHS heuristc, 

will calculate the right cubes, which should be materialized. 

 

Select "Search using Thomas Achs heuristic" in the menu and the 

cubes will be selected. 

 

 

The Screen below shows the calculated set of materialized cubes. 

 


solution by permutation 

In oder to proof the heuristic the deterministic solution must be calculated. 

If you want to do that by permutation select "Alogirthm permutation" 

in the menu. 

 

 

 


- 466 -



solution by combination 

In oder to proof the heuristic the deterministic solution must be calculated. 

If you want to do that by combination select "Alogirthm combitation" 

in the menu. 

 

 

 

Show deterministic solution 

To have a look at the deterministic solution press "Show deterministic 

solution". 

 

 

Remove deterministic solution 

In order to remove the deterministic solution press "Remove 

deterministic solution". 

 

Show possible cubes 

If you want to see the set of possible cubes press "Show possible 

cubes". 

 

 

 

Remove possible cubes 

If you want to remove the set of possible cubes press "Remove possible 

cubes". 

 

Build SQL statements for star 

schema 

In order to create the SQL Statements for the star schema select "Generate 

CREATE SQL-statements for star schema- Generate CREATE SQL-statements BFT and 

dimension tables". 

 

 

Build SQL 

statements for fact constellation schema 

In order to create the SQL Statements for the star schema select "Generate 

CREATE SQL-statements for fact constellation schema- Generate CREATE 

SQL-statements BFT and dimension tables". If you want to create the 

SQL-statements for the aggregated fact tables select "Generate CREATE 

SQL-statements for fact constellation schema- Generate CREATE SQL-statements for 

materialized cubes". 

 

 

Get Query of cube 

If you want to know the query of a cube select the cube, press right mouse 

button and select "Get SQL statement to query this cube". 

 

 

Save SQL Script 

If you want to save a SQL script press the button "Save SQL Script" 

and choose the name. 

 

 

Set use random costs 

If you want to calculate with random costs or not chosse "Use random 

costs" in Settings menu. 

 

 

12.2.3 APA_INPUT_SCREEN.HTM 

 

 

 

 

APA Help - APA Input Screen 

 

 

 

- 467 -



 

 

The APA Input Screen helps you to insert all 

the dimensions, 

hierarchies and key figures. 

Insert a dimension 

Insert a hierarchy level 

Change a dimension 

Change a hierarchy level 

Delete a dimension or hierarchy level 

Insert key figure 

Edit key figure 

Delete key figure 

 

Go to Top 

 

Insert a dimension 

To add a dimension press the button "Insert dimension" and the 

Insert-dimension-screen will open. 

 

Type the description of the new dimension in the "Dimension description" 

textfield and press "OK". 

 

The new dimension will be added to your "Input Screen". 

 

Go to Top 

Insert hierarchy 

To add a new hierarchy select the dimension you want to add the new hierarchy 

and press the Button "Insert hierarchy". 

 

Type your data into the textfields and press "OK". 

 

The hierarchy will be added to your dimension in the "Input 

Screen". It´s possible to change the order of the hierarchies by using the 

"Up" and "Down" buttons on the left. 

 

Go to Top 

Change a dimension 

To change a dimension select the dimension in the "Input Screen" 

and press the button "Edit". 

 

Change the description of the dimension and press "OK". 

 

The new description of the dimension will be changed in the "Input 

Screen". 

 

Go to Top 

Change a hierarchy 

To change a hierarchy select the hierarchy in the "Input Screen" 

and press the button "Edit". 

 

Type in the changed data and press the button "OK". 

 

The hierarchy will be changed in the "Input Screen". 

 

Go to Top 

Delete a dimension or 

hierarchy level 

Select the dimension or hierarchy level and press the button "Delete". 

 

The dimension or hierarchy level will be erased from the "Input 

Screen". 

 

Go to Top 

Insert a key figure 

In order to insert a key figure press the Button "Insert". 

 

Enter data into the "APA Insert Key" form and press "OK". 

 

 

Go to Top 

 

Edit a key figure 

- 468 -



In order to edit a key figure select the figure and press the button 

"Edit". 

 

Change data in the "APA Insert Key" form and press "OK". 

 

 

Go to Top 

 

Delete a key figure 

In order to delete a key figure please select the figure and press the Button 

"Delete". 

 

 

Go to Top 

 

 

 

12.2.4 APA_INSTALL.HTM 

 

 

 

 

Installation 

 

 

 

 

 

 

 

 

How to install the APAWin 

program 

 

Valid for: APAWin Version 1 

Date: 

 

OVERWIEW 

This guide helps you install the APA program. There are two setup procedures 

nessesary to install the APA programm. First the database driver must be 

installed. You need administrator rights on your computer to run the setup. 

Second the APA program need to be installed. The setup programm installs all 

files required in the folder 'C:\APADIR'. Do not changed the name of the folder. 

This chause problems in running the software. 

 

HOW TO GO 

 

Download the SETUP.exe file to your computer and start the setup. 

 

 

The Setup program will start. The press "Weiter". 

 

 

Please wait a few seconds... 

 

 

- 469 -



 

The installation finished. 

 

 

 

 

 

 

12.2.5 APA_MAINMENU.HTM 

 

 

 

 

APA Help - APA Mainmenu 

 

 

 

 

 

 

The APA Main menu helps you to load and save your data, manipulate random 

costs, analyse the APA, edit the settings and show the help menu. 

Generate APA 

Selection Screen 

Mainmenu - File 

Load File 

Save File 

Save as.. File 

Mainmenu - Random costs 

Build random costs 

Show random costs 

Restricted costs 

Mainmenu-Analyse 

Analyse APA 

 

Go to Top 

 

Generate APA 

In order to generate the APA and show the APA Screen press button "APA 

Grid". 

Show Selection Screen 

In order to switch to "APA Selection Screen" press button "APA 

Selection Screen". 

Load File 

To Load a File press "File-Open" and select your file. 

 

 

Go to Top 

Save File 

To save the file press "File-Save". 

 

Go to Top 

Save as File 

Select "File-Save as ..." and choose a new file name. 

 

 

Go to Top 

Build random costs 

In order to generate random costs press "Random costs-Build random 

costs". 

 

 

 

Go to Top 

Show Random Costs 

- 470 -



In order to show the random costs select "Random costs-Show random 

costs". 

 

It´s possible to edit the data and to export the data to Excel. 

 

Go to Top 

Restricted costs 

To change the ticker Restricted costs select "Random costs-Restricted 

costs": 

 

Go to Top 

APA Analyse 

To show the "APA Analyse" window select "Analyse-Analyse 

APA". 

 

 

Go to Top 

 

 

12.2.6 APA_SELECTION_SCREEN.HTM 

 

 

 

 

APA Help - APA Selection Screen 

 

 

 

 

 

 

The APA Selection Screen helps you to do block operations or/and requirement 

operations. 

Block operations 

Add new requirement block 

Edit requirement block 

Delete requirement block 

Select block 

Deselect block 

Select all 

Deselect all 

Delete all requirement 

blocks and cubes 

Requirements operations 

Add new requirement 

Edit requirement 

Delete requirement 

 

 

Add new requirement block 

In order to add a new requirement block press the button "New req. 

block" and enter the data. If you select "Add max. hierarchy level" 

the maximum of all hierarchy levels is added. 

 

 

 

Edit requirement block 

If you want to edit a requirement block select the block and press the button 

"Edit req. block". 

 

 

 

Go to Top 

Delete requirement block 

If you want to delete a requirement block select the block and press the 

- 471 -



button "Delete req. block". 

 

 

Go to Top 

Select block 

In order to select a requirement block for adding the block to the APA select 

the block and press the button "Select". 

 

 

Go to Top 

Deselect block 

If you want to deselect a requirement block press the button 

"Deselect". 

 

 

Go to Top 

Select all 

Press the Button "Select all" if you want to select all required 

blocks. 

 

 

Go to Top 

Deselect all 

Press the Button "Deselect all" if you want to deselect all 

required blocks. 

 

 

Go to Top 

Delete all requirement 

blocks and cubes 

In order to delete all requirement blocks and all required cubes in the APA 

press "Delete all requirement blocks and cubes". 

 

 

 

 

Go to Top 

Add new requirement 

If you want to add a new requirement to an existing block press 

"Insert". 

 

 

 

Go to Top 

Edit requirement 

If you want to edit a new requirement select the requirement and press 

"Edit". 

Then change the requirement and press "Accept". 

 

 

 

 

Go to Top 

Delete requirement 

If you want to delete a single requirement select the requirement and press 

then button "Delete". 

 

 

Go to Top 

 

- 472 -

Download (3398Kb)

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?